Change:
<!-- Thank you for finding an Internal Compiler Error! If possible, try to provide a minimal verifiable example. You can read "Rust Bug Minimization Patterns" for how to create smaller examples. --<!-- If you're using the stable version of the compiler, you should also check if the bug also exists in the beta or nightly versions. --: <!-- Include a backtrace in the code block by setting in your environment. E.g. . --<details<summary<strongBacktrace</strong</summary<p</p</details

Discussion:
for (region_a, region_a_idx) in &regions { // Ignore `'static` lifetimes for the purpose of this lint: it's // because we know it outlives everything and so doesn't give meaningful <del> // clues if let ty::ReStatic = **region_a { </del> <ins> // clues. Also ignore `ReError`, to avoid knock-down errors. if let ty::ReStatic | ty::ReError(_) = **region_a { </ins> continue; } // For each region argument (e.g., `'a` in our example), check for a

// on the GAT itself. for (region_b, region_b_idx) in &regions { // Again, skip `'static` because it outlives everything. Also, we trivially <del> // know that a region outlives itself. if ty::ReStatic == **region_b || region_a == region_b { </del> <ins> // know that a region outlives itself. Also ignore `ReError`, to avoid // knock-down errors. if matches!(**region_b, ty::ReStatic | ty::ReError(_)) || region_a == region_b { </ins> continue; } if region_known_to_outlive(

None, ); if let Some(infer::RelateParamBound(_, t, _)) = origin { <del> let return_impl_trait = self.tcx.return_type_impl_trait(generic_param_scope).is_some(); </del> let t = self.resolve_vars_if_possible(t); match t.kind() { // We've got: // fn get_later<G, T>(g: G, dest: &mut T) -> impl FnOnce() + '_ // suggest: // fn get_later<'a, G: 'a, T>(g: G, dest: &mut T) -> impl FnOnce() + '_ + 'a <del> ty::Closure(..) | ty::Alias(ty::Opaque, ..) if return_impl_trait => { </del> <ins> ty::Closure(..) | ty::Alias(ty::Opaque, ..) => { </ins> new_binding_suggestion(&mut err, type_param_span); } _ => {

generic_ty: Ty<'tcx>, min: ty::Region<'tcx>, ) -> bool { <ins> if let ty::ReError(_) = *min { return true; } </ins> match bound { VerifyBound::IfEq(verify_if_eq_b) => { let verify_if_eq_b = var_values.normalize(self.region_rels.tcx, *verify_if_eq_b);

use rustc_hir::definitions::Definitions; use rustc_hir::intravisit::Visitor; use rustc_hir::lang_items::LangItem; <del> use rustc_hir::{ Constness, ExprKind, HirId, ImplItemKind, ItemKind, Node, TraitCandidate, TraitItemKind, }; </del> <ins> use rustc_hir::{Constness, HirId, Node, TraitCandidate}; </ins> use rustc_index::IndexVec; use rustc_macros::HashStable; use rustc_query_system::dep_graph::DepNodeIndex;

return None; } <del> pub fn return_type_impl_trait(self, scope_def_id: LocalDefId) -> Option<(Ty<'tcx>, Span)> { // `type_of()` will fail on these (#55796, #86483), so only allow `fn`s or closures. match self.hir().get_by_def_id(scope_def_id) { Node::Item(&hir::Item { kind: ItemKind::Fn(..), .. }) => {} Node::TraitItem(&hir::TraitItem { kind: TraitItemKind::Fn(..), .. }) => {} Node::ImplItem(&hir::ImplItem { kind: ImplItemKind::Fn(..), .. }) => {} Node::Expr(&hir::Expr { kind: ExprKind::Closure { .. }, .. }) => {} _ => return None, } let ret_ty = self.type_of(scope_def_id).instantiate_identity(); match ret_ty.kind() { ty::FnDef(_, _) => { let sig = ret_ty.fn_sig(self); let output = self.erase_late_bound_regions(sig.output()); output.is_impl_trait().then(|| { let hir_id = self.hir().local_def_id_to_hir_id(scope_def_id); let fn_decl = self.hir().fn_decl_by_hir_id(hir_id).unwrap(); (output, fn_decl.output.span()) }) } _ => None, } } </del> /// Checks if the bound region is in Impl Item. pub fn is_bound_region_in_impl_item(self, suitable_region_binding_scope: LocalDefId) -> bool { let container_id = self.parent(suitable_region_binding_scope.to_def_id());

<ins> #![feature(return_position_impl_trait_in_trait)] trait Iterable { type Item<'a> where Self: 'a; fn iter(&self) -> impl Iterator<Item = Self::Item<'missing>>; //~^ ERROR use of undeclared lifetime name `'missing` } fn main() {} </ins>

<ins> error[E0261]: use of undeclared lifetime name `'missing` --> $DIR/missing-lt-outlives-in-rpitit-114274.rs:8:55 | LL |     fn iter(&self) -> impl Iterator<Item = Self::Item<'missing>>; |                                                       ^^^^^^^^ undeclared lifetime | = note: for more information on higher-ranked polymorphism, visit https://doc.rust-lang.org/nomicon/hrtb.html help: consider making the bound lifetime-generic with a new `'missing` lifetime | LL |     fn iter(&self) -> impl for<'missing> Iterator<Item = Self::Item<'missing>>; |                            +++++++++++++ help: consider introducing lifetime `'missing` here | LL |     fn iter<'missing>(&self) -> impl Iterator<Item = Self::Item<'missing>>; |            ++++++++++ help: consider introducing lifetime `'missing` here | LL | trait Iterable<'missing> { |               ++++++++++ error: aborting due to previous error For more information about this error, try `rustc --explain E0261`. </ins>