diff --git a/compiler/rustc_ast/src/ast.rs b/compiler/rustc_ast/src/ast.rs
index 3af6dee9e43f7..4dfdb8d7552c3 100644
--- a/compiler/rustc_ast/src/ast.rs
+++ b/compiler/rustc_ast/src/ast.rs
@@ -434,6 +434,27 @@ impl Default for Generics {
     }
 }
 
+impl Generics {
+    pub fn merge(&self, other: &Generics) -> Generics {
+        let mut params = Vec::with_capacity(self.params.len() + other.params.len());
+        params.extend(self.params.iter().cloned());
+        params.extend(other.params.iter().cloned());
+
+        let has_where_token =
+            self.where_clause.has_where_token || other.where_clause.has_where_token;
+        let mut predicates = Vec::with_capacity(
+            self.where_clause.predicates.len() + other.where_clause.predicates.len(),
+        );
+        predicates.extend(self.where_clause.predicates.iter().cloned());
+        predicates.extend(other.where_clause.predicates.iter().cloned());
+
+        let where_clause =
+            WhereClause { has_where_token, predicates, span: self.where_clause.span };
+
+        Generics { params, where_clause, span: self.span }
+    }
+}
+
 /// A where-clause in a definition.
 #[derive(Clone, Encodable, Decodable, Debug)]
 pub struct WhereClause {
diff --git a/compiler/rustc_ast_lowering/src/asm.rs b/compiler/rustc_ast_lowering/src/asm.rs
index 0dba9da63da2a..e5d2a45868ebb 100644
--- a/compiler/rustc_ast_lowering/src/asm.rs
+++ b/compiler/rustc_ast_lowering/src/asm.rs
@@ -220,7 +220,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                                 &sym.qself,
                                 &sym.path,
                                 ParamMode::Optional,
-                                ImplTraitContext::Disallowed(ImplTraitPosition::Path),
+                                &mut ImplTraitContext::Disallowed(ImplTraitPosition::Path),
                             );
                             hir::InlineAsmOperand::SymStatic { path, def_id }
                         } else {
diff --git a/compiler/rustc_ast_lowering/src/block.rs b/compiler/rustc_ast_lowering/src/block.rs
index 7cbfe143b4d83..7465706d1a9bb 100644
--- a/compiler/rustc_ast_lowering/src/block.rs
+++ b/compiler/rustc_ast_lowering/src/block.rs
@@ -84,10 +84,9 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
     }
 
     fn lower_local(&mut self, l: &Local) -> &'hir hir::Local<'hir> {
-        let ty = l
-            .ty
-            .as_ref()
-            .map(|t| self.lower_ty(t, ImplTraitContext::Disallowed(ImplTraitPosition::Variable)));
+        let ty = l.ty.as_ref().map(|t| {
+            self.lower_ty(t, &mut ImplTraitContext::Disallowed(ImplTraitPosition::Variable))
+        });
         let init = l.kind.init().map(|init| self.lower_expr(init));
         let hir_id = self.lower_node_id(l.id);
         let pat = self.lower_pat(&l.pat);
diff --git a/compiler/rustc_ast_lowering/src/expr.rs b/compiler/rustc_ast_lowering/src/expr.rs
index 7df3520422c18..3e8ffccb2b6e1 100644
--- a/compiler/rustc_ast_lowering/src/expr.rs
+++ b/compiler/rustc_ast_lowering/src/expr.rs
@@ -66,7 +66,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                         seg,
                         ParamMode::Optional,
                         ParenthesizedGenericArgs::Err,
-                        ImplTraitContext::Disallowed(ImplTraitPosition::Path),
+                        &mut ImplTraitContext::Disallowed(ImplTraitPosition::Path),
                     ));
                     let args = self.arena.alloc_from_iter(
                         [&*receiver].into_iter().chain(args.iter()).map(|x| self.lower_expr_mut(x)),
@@ -89,14 +89,14 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 }
                 ExprKind::Cast(ref expr, ref ty) => {
                     let expr = self.lower_expr(expr);
-                    let ty =
-                        self.lower_ty(ty, ImplTraitContext::Disallowed(ImplTraitPosition::Type));
+                    let ty = self
+                        .lower_ty(ty, &mut ImplTraitContext::Disallowed(ImplTraitPosition::Type));
                     hir::ExprKind::Cast(expr, ty)
                 }
                 ExprKind::Type(ref expr, ref ty) => {
                     let expr = self.lower_expr(expr);
-                    let ty =
-                        self.lower_ty(ty, ImplTraitContext::Disallowed(ImplTraitPosition::Type));
+                    let ty = self
+                        .lower_ty(ty, &mut ImplTraitContext::Disallowed(ImplTraitPosition::Type));
                     hir::ExprKind::Type(expr, ty)
                 }
                 ExprKind::AddrOf(k, m, ref ohs) => {
@@ -219,7 +219,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                         qself,
                         path,
                         ParamMode::Optional,
-                        ImplTraitContext::Disallowed(ImplTraitPosition::Path),
+                        &mut ImplTraitContext::Disallowed(ImplTraitPosition::Path),
                     );
                     hir::ExprKind::Path(qpath)
                 }
@@ -253,7 +253,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                             &se.qself,
                             &se.path,
                             ParamMode::Optional,
-                            ImplTraitContext::Disallowed(ImplTraitPosition::Path),
+                            &mut ImplTraitContext::Disallowed(ImplTraitPosition::Path),
                         )),
                         self.arena
                             .alloc_from_iter(se.fields.iter().map(|x| self.lower_expr_field(x))),
@@ -550,12 +550,14 @@ impl<'hir> LoweringContext<'_, 'hir> {
         async_gen_kind: hir::AsyncGeneratorKind,
         body: impl FnOnce(&mut Self) -> hir::Expr<'hir>,
     ) -> hir::ExprKind<'hir> {
-        let output = match ret_ty {
-            Some(ty) => hir::FnRetTy::Return(
-                self.lower_ty(&ty, ImplTraitContext::Disallowed(ImplTraitPosition::AsyncBlock)),
-            ),
-            None => hir::FnRetTy::DefaultReturn(self.lower_span(span)),
-        };
+        let output =
+            match ret_ty {
+                Some(ty) => hir::FnRetTy::Return(self.lower_ty(
+                    &ty,
+                    &mut ImplTraitContext::Disallowed(ImplTraitPosition::AsyncBlock),
+                )),
+                None => hir::FnRetTy::DefaultReturn(self.lower_span(span)),
+            };
 
         // Resume argument type. We let the compiler infer this to simplify the lowering. It is
         // fully constrained by `future::from_generator`.
@@ -847,21 +849,34 @@ impl<'hir> LoweringContext<'_, 'hir> {
             (body_id, generator_option)
         });
 
-        let bound_generic_params = self.lower_lifetime_binder(closure_id, generic_params);
-        // Lower outside new scope to preserve `is_in_loop_condition`.
-        let fn_decl = self.lower_fn_decl(decl, None, FnDeclKind::Closure, None);
-
-        let c = self.arena.alloc(hir::Closure {
-            binder: binder_clause,
-            capture_clause,
-            bound_generic_params,
-            fn_decl,
-            body: body_id,
-            fn_decl_span: self.lower_span(fn_decl_span),
-            movability: generator_option,
-        });
+        self.lower_lifetime_binder(
+            closure_id,
+            generic_params,
+            false,
+            |lctx, bound_generic_params| {
+                // Lower outside new scope to preserve `is_in_loop_condition`.
+                let fn_decl = lctx.lower_fn_decl(
+                    decl,
+                    None,
+                    FnDeclKind::Closure,
+                    &Generics::default(),
+                    None,
+                    None,
+                );
 
-        hir::ExprKind::Closure(c)
+                let c = lctx.arena.alloc(hir::Closure {
+                    binder: binder_clause,
+                    capture_clause,
+                    bound_generic_params,
+                    fn_decl,
+                    body: body_id,
+                    fn_decl_span: lctx.lower_span(fn_decl_span),
+                    movability: generator_option,
+                });
+
+                hir::ExprKind::Closure(c)
+            },
+        )
     }
 
     fn generator_movability_for_fn(
@@ -948,23 +963,35 @@ impl<'hir> LoweringContext<'_, 'hir> {
             body_id
         });
 
-        let bound_generic_params = self.lower_lifetime_binder(closure_id, generic_params);
-
-        // We need to lower the declaration outside the new scope, because we
-        // have to conserve the state of being inside a loop condition for the
-        // closure argument types.
-        let fn_decl = self.lower_fn_decl(&outer_decl, None, FnDeclKind::Closure, None);
-
-        let c = self.arena.alloc(hir::Closure {
-            binder: binder_clause,
-            capture_clause,
-            bound_generic_params,
-            fn_decl,
-            body,
-            fn_decl_span: self.lower_span(fn_decl_span),
-            movability: None,
-        });
-        hir::ExprKind::Closure(c)
+        self.lower_lifetime_binder(
+            closure_id,
+            generic_params,
+            false,
+            |lctx, bound_generic_params| {
+                // We need to lower the declaration outside the new scope, because we
+                // have to conserve the state of being inside a loop condition for the
+                // closure argument types.
+                let fn_decl = lctx.lower_fn_decl(
+                    &outer_decl,
+                    None,
+                    FnDeclKind::Closure,
+                    &Generics::default(),
+                    None,
+                    None,
+                );
+
+                let c = lctx.arena.alloc(hir::Closure {
+                    binder: binder_clause,
+                    capture_clause,
+                    bound_generic_params,
+                    fn_decl,
+                    body,
+                    fn_decl_span: lctx.lower_span(fn_decl_span),
+                    movability: None,
+                });
+                hir::ExprKind::Closure(c)
+            },
+        )
     }
 
     /// Destructure the LHS of complex assignments.
@@ -1123,7 +1150,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                         qself,
                         path,
                         ParamMode::Optional,
-                        ImplTraitContext::Disallowed(ImplTraitPosition::Path),
+                        &mut ImplTraitContext::Disallowed(ImplTraitPosition::Path),
                     );
                     // Destructure like a tuple struct.
                     let tuple_struct_pat =
@@ -1139,7 +1166,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                         qself,
                         path,
                         ParamMode::Optional,
-                        ImplTraitContext::Disallowed(ImplTraitPosition::Path),
+                        &mut ImplTraitContext::Disallowed(ImplTraitPosition::Path),
                     );
                     // Destructure like a unit struct.
                     let unit_struct_pat = hir::PatKind::Path(qpath);
@@ -1163,7 +1190,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     &se.qself,
                     &se.path,
                     ParamMode::Optional,
-                    ImplTraitContext::Disallowed(ImplTraitPosition::Path),
+                    &mut ImplTraitContext::Disallowed(ImplTraitPosition::Path),
                 );
                 let fields_omitted = match &se.rest {
                     StructRest::Base(e) => {
diff --git a/compiler/rustc_ast_lowering/src/item.rs b/compiler/rustc_ast_lowering/src/item.rs
index fd338ffc0c5e8..14a7c26715bcc 100644
--- a/compiler/rustc_ast_lowering/src/item.rs
+++ b/compiler/rustc_ast_lowering/src/item.rs
@@ -1,7 +1,7 @@
 use super::errors::{InvalidAbi, MisplacedRelaxTraitBound};
 use super::ResolverAstLoweringExt;
 use super::{AstOwner, ImplTraitContext, ImplTraitPosition};
-use super::{FnDeclKind, LoweringContext, ParamMode};
+use super::{FnDeclKind, LoweringArena, LoweringContext, ParamMode};
 
 use rustc_ast::ptr::P;
 use rustc_ast::visit::AssocCtxt;
@@ -25,6 +25,7 @@ use std::iter;
 pub(super) struct ItemLowerer<'a, 'hir> {
     pub(super) tcx: TyCtxt<'hir>,
     pub(super) resolver: &'a mut ResolverAstLowering,
+    pub(super) lowering_arena: &'a LoweringArena,
     pub(super) ast_index: &'a IndexVec<LocalDefId, AstOwner<'a>>,
     pub(super) owners: &'a mut IndexVec<LocalDefId, hir::MaybeOwner<&'hir hir::OwnerInfo<'hir>>>,
 }
@@ -60,6 +61,7 @@ impl<'a, 'hir> ItemLowerer<'a, 'hir> {
             tcx: self.tcx,
             resolver: self.resolver,
             arena: self.tcx.hir_arena,
+            lowering_arena: self.lowering_arena,
 
             // HirId handling.
             bodies: Vec::new(),
@@ -82,6 +84,7 @@ impl<'a, 'hir> ItemLowerer<'a, 'hir> {
             current_item: None,
             impl_trait_defs: Vec::new(),
             impl_trait_bounds: Vec::new(),
+            in_scope_generics: Vec::new(),
             allow_try_trait: Some([sym::try_trait_v2, sym::yeet_desugar_details][..].into()),
             allow_gen_future: Some([sym::gen_future][..].into()),
             allow_into_future: Some([sym::into_future][..].into()),
@@ -133,6 +136,10 @@ impl<'a, 'hir> ItemLowerer<'a, 'hir> {
         let def_id = self.resolver.node_id_to_def_id[&item.id];
 
         let parent_id = self.tcx.local_parent(def_id);
+
+        let parent_ast_owner = self.ast_index[parent_id];
+        let parent_generics = parent_ast_owner.item_generics();
+
         let parent_hir = self.lower_node(parent_id).unwrap();
         self.with_lctx(item.id, |lctx| {
             // Evaluate with the lifetimes in `params` in-scope.
@@ -146,8 +153,12 @@ impl<'a, 'hir> ItemLowerer<'a, 'hir> {
             };
 
             match ctxt {
-                AssocCtxt::Trait => hir::OwnerNode::TraitItem(lctx.lower_trait_item(item)),
-                AssocCtxt::Impl => hir::OwnerNode::ImplItem(lctx.lower_impl_item(item)),
+                AssocCtxt::Trait => {
+                    hir::OwnerNode::TraitItem(lctx.lower_trait_item(item, &parent_generics))
+                }
+                AssocCtxt::Impl => {
+                    hir::OwnerNode::ImplItem(lctx.lower_impl_item(item, &parent_generics))
+                }
             }
         })
     }
@@ -157,7 +168,7 @@ impl<'a, 'hir> ItemLowerer<'a, 'hir> {
     }
 }
 
-impl<'hir> LoweringContext<'_, 'hir> {
+impl<'a, 'hir> LoweringContext<'a, 'hir> {
     pub(super) fn lower_mod(&mut self, items: &[P<Item>], spans: &ModSpans) -> hir::Mod<'hir> {
         hir::Mod {
             spans: hir::ModSpans {
@@ -259,10 +270,10 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     let body_id =
                         this.lower_maybe_async_body(span, &decl, asyncness, body.as_deref());
 
-                    let itctx = ImplTraitContext::Universal;
-                    let (generics, decl) = this.lower_generics(generics, id, itctx, |this| {
+                    let mut itctx = ImplTraitContext::Universal { apit_nodes: &mut Vec::new() };
+                    let (generics, decl) = this.lower_generics(generics, id, &mut itctx, |this| {
                         let ret_id = asyncness.opt_return_id();
-                        this.lower_fn_decl(&decl, Some(id), FnDeclKind::Fn, ret_id)
+                        this.lower_fn_decl(&decl, Some(id), FnDeclKind::Fn, generics, None, ret_id)
                     });
                     let sig = hir::FnSig {
                         decl,
@@ -306,8 +317,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 let (generics, ty) = self.lower_generics(
                     &generics,
                     id,
-                    ImplTraitContext::Disallowed(ImplTraitPosition::Generic),
-                    |this| this.lower_ty(ty, ImplTraitContext::TypeAliasesOpaqueTy),
+                    &mut ImplTraitContext::Disallowed(ImplTraitPosition::Generic),
+                    |this| this.lower_ty(ty, &mut ImplTraitContext::TypeAliasesOpaqueTy),
                 );
                 hir::ItemKind::TyAlias(ty, generics)
             }
@@ -319,7 +330,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 let (generics, ty) = self.lower_generics(
                     &generics,
                     id,
-                    ImplTraitContext::Disallowed(ImplTraitPosition::Generic),
+                    &mut ImplTraitContext::Disallowed(ImplTraitPosition::Generic),
                     |this| this.arena.alloc(this.ty(span, hir::TyKind::Err)),
                 );
                 hir::ItemKind::TyAlias(ty, generics)
@@ -328,7 +339,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 let (generics, variants) = self.lower_generics(
                     generics,
                     id,
-                    ImplTraitContext::Disallowed(ImplTraitPosition::Generic),
+                    &mut ImplTraitContext::Disallowed(ImplTraitPosition::Generic),
                     |this| {
                         this.arena.alloc_from_iter(
                             enum_definition.variants.iter().map(|x| this.lower_variant(x)),
@@ -341,7 +352,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 let (generics, struct_def) = self.lower_generics(
                     generics,
                     id,
-                    ImplTraitContext::Disallowed(ImplTraitPosition::Generic),
+                    &mut ImplTraitContext::Disallowed(ImplTraitPosition::Generic),
                     |this| this.lower_variant_data(hir_id, struct_def),
                 );
                 hir::ItemKind::Struct(struct_def, generics)
@@ -350,7 +361,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 let (generics, vdata) = self.lower_generics(
                     generics,
                     id,
-                    ImplTraitContext::Disallowed(ImplTraitPosition::Generic),
+                    &mut ImplTraitContext::Disallowed(ImplTraitPosition::Generic),
                     |this| this.lower_variant_data(hir_id, vdata),
                 );
                 hir::ItemKind::Union(vdata, generics)
@@ -378,18 +389,20 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 // method, it will not be considered an in-band
                 // lifetime to be added, but rather a reference to a
                 // parent lifetime.
-                let itctx = ImplTraitContext::Universal;
+                let mut itctx = ImplTraitContext::Universal { apit_nodes: &mut Vec::new() };
                 let (generics, (trait_ref, lowered_ty)) =
-                    self.lower_generics(ast_generics, id, itctx, |this| {
+                    self.lower_generics(ast_generics, id, &mut itctx, |this| {
                         let trait_ref = trait_ref.as_ref().map(|trait_ref| {
                             this.lower_trait_ref(
                                 trait_ref,
-                                ImplTraitContext::Disallowed(ImplTraitPosition::Trait),
+                                &mut ImplTraitContext::Disallowed(ImplTraitPosition::Trait),
                             )
                         });
 
-                        let lowered_ty = this
-                            .lower_ty(ty, ImplTraitContext::Disallowed(ImplTraitPosition::Type));
+                        let lowered_ty = this.lower_ty(
+                            ty,
+                            &mut ImplTraitContext::Disallowed(ImplTraitPosition::Type),
+                        );
 
                         (trait_ref, lowered_ty)
                     });
@@ -428,11 +441,11 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 let (generics, (unsafety, items, bounds)) = self.lower_generics(
                     generics,
                     id,
-                    ImplTraitContext::Disallowed(ImplTraitPosition::Generic),
+                    &mut ImplTraitContext::Disallowed(ImplTraitPosition::Generic),
                     |this| {
                         let bounds = this.lower_param_bounds(
                             bounds,
-                            ImplTraitContext::Disallowed(ImplTraitPosition::Bound),
+                            &mut ImplTraitContext::Disallowed(ImplTraitPosition::Bound),
                         );
                         let items = this.arena.alloc_from_iter(
                             items.iter().map(|item| this.lower_trait_item_ref(item)),
@@ -447,11 +460,11 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 let (generics, bounds) = self.lower_generics(
                     generics,
                     id,
-                    ImplTraitContext::Disallowed(ImplTraitPosition::Generic),
+                    &mut ImplTraitContext::Disallowed(ImplTraitPosition::Generic),
                     |this| {
                         this.lower_param_bounds(
                             bounds,
-                            ImplTraitContext::Disallowed(ImplTraitPosition::Bound),
+                            &mut ImplTraitContext::Disallowed(ImplTraitPosition::Bound),
                         )
                     },
                 );
@@ -474,7 +487,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         span: Span,
         body: Option<&Expr>,
     ) -> (&'hir hir::Ty<'hir>, hir::BodyId) {
-        let ty = self.lower_ty(ty, ImplTraitContext::Disallowed(ImplTraitPosition::Type));
+        let ty = self.lower_ty(ty, &mut ImplTraitContext::Disallowed(ImplTraitPosition::Type));
         (ty, self.lower_const_body(span, body))
     }
 
@@ -647,12 +660,19 @@ impl<'hir> LoweringContext<'_, 'hir> {
             kind: match i.kind {
                 ForeignItemKind::Fn(box Fn { ref sig, ref generics, .. }) => {
                     let fdec = &sig.decl;
-                    let itctx = ImplTraitContext::Universal;
+                    let mut itctx = ImplTraitContext::Universal { apit_nodes: &mut Vec::new() };
                     let (generics, (fn_dec, fn_args)) =
-                        self.lower_generics(generics, i.id, itctx, |this| {
+                        self.lower_generics(generics, i.id, &mut itctx, |this| {
                             (
                                 // Disallow `impl Trait` in foreign items.
-                                this.lower_fn_decl(fdec, None, FnDeclKind::ExternFn, None),
+                                this.lower_fn_decl(
+                                    fdec,
+                                    None,
+                                    FnDeclKind::ExternFn,
+                                    generics,
+                                    None,
+                                    None,
+                                ),
                                 this.lower_fn_params_to_names(fdec),
                             )
                         });
@@ -660,8 +680,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     hir::ForeignItemKind::Fn(fn_dec, fn_args, generics)
                 }
                 ForeignItemKind::Static(ref t, m, _) => {
-                    let ty =
-                        self.lower_ty(t, ImplTraitContext::Disallowed(ImplTraitPosition::Type));
+                    let ty = self
+                        .lower_ty(t, &mut ImplTraitContext::Disallowed(ImplTraitPosition::Type));
                     hir::ForeignItemKind::Static(ty, m)
                 }
                 ForeignItemKind::TyAlias(..) => hir::ForeignItemKind::Type,
@@ -729,11 +749,11 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 qself,
                 path,
                 ParamMode::ExplicitNamed, // no `'_` in declarations (Issue #61124)
-                ImplTraitContext::Disallowed(ImplTraitPosition::Path),
+                &mut ImplTraitContext::Disallowed(ImplTraitPosition::Path),
             );
             self.arena.alloc(t)
         } else {
-            self.lower_ty(&f.ty, ImplTraitContext::Disallowed(ImplTraitPosition::Type))
+            self.lower_ty(&f.ty, &mut ImplTraitContext::Disallowed(ImplTraitPosition::Type))
         };
         let hir_id = self.lower_node_id(f.id);
         self.lower_attrs(hir_id, &f.attrs);
@@ -750,20 +770,31 @@ impl<'hir> LoweringContext<'_, 'hir> {
         }
     }
 
-    fn lower_trait_item(&mut self, i: &AssocItem) -> &'hir hir::TraitItem<'hir> {
+    fn lower_trait_item(
+        &mut self,
+        i: &AssocItem,
+        parent_generics: &ast::Generics,
+    ) -> &'hir hir::TraitItem<'hir> {
         let hir_id = self.lower_node_id(i.id);
         let trait_item_def_id = hir_id.expect_owner();
 
         let (generics, kind, has_default) = match i.kind {
             AssocItemKind::Const(_, ref ty, ref default) => {
-                let ty = self.lower_ty(ty, ImplTraitContext::Disallowed(ImplTraitPosition::Type));
+                let ty =
+                    self.lower_ty(ty, &mut ImplTraitContext::Disallowed(ImplTraitPosition::Type));
                 let body = default.as_ref().map(|x| self.lower_const_body(i.span, Some(x)));
                 (hir::Generics::empty(), hir::TraitItemKind::Const(ty, body), body.is_some())
             }
             AssocItemKind::Fn(box Fn { ref sig, ref generics, body: None, .. }) => {
                 let names = self.lower_fn_params_to_names(&sig.decl);
-                let (generics, sig) =
-                    self.lower_method_sig(generics, sig, i.id, FnDeclKind::Trait, None);
+                let (generics, sig) = self.lower_method_sig(
+                    generics,
+                    parent_generics,
+                    sig,
+                    i.id,
+                    FnDeclKind::Trait,
+                    None,
+                );
                 (generics, hir::TraitItemKind::Fn(sig, hir::TraitFn::Required(names)), false)
             }
             AssocItemKind::Fn(box Fn { ref sig, ref generics, body: Some(ref body), .. }) => {
@@ -772,6 +803,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     self.lower_maybe_async_body(i.span, &sig.decl, asyncness, Some(&body));
                 let (generics, sig) = self.lower_method_sig(
                     generics,
+                    parent_generics,
                     sig,
                     i.id,
                     FnDeclKind::Trait,
@@ -791,15 +823,18 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 let (generics, kind) = self.lower_generics(
                     &generics,
                     i.id,
-                    ImplTraitContext::Disallowed(ImplTraitPosition::Generic),
+                    &mut ImplTraitContext::Disallowed(ImplTraitPosition::Generic),
                     |this| {
                         let ty = ty.as_ref().map(|x| {
-                            this.lower_ty(x, ImplTraitContext::Disallowed(ImplTraitPosition::Type))
+                            this.lower_ty(
+                                x,
+                                &mut ImplTraitContext::Disallowed(ImplTraitPosition::Type),
+                            )
                         });
                         hir::TraitItemKind::Type(
                             this.lower_param_bounds(
                                 bounds,
-                                ImplTraitContext::Disallowed(ImplTraitPosition::Generic),
+                                &mut ImplTraitContext::Disallowed(ImplTraitPosition::Generic),
                             ),
                             ty,
                         )
@@ -845,14 +880,19 @@ impl<'hir> LoweringContext<'_, 'hir> {
         self.expr(span, hir::ExprKind::Err, AttrVec::new())
     }
 
-    fn lower_impl_item(&mut self, i: &AssocItem) -> &'hir hir::ImplItem<'hir> {
+    fn lower_impl_item(
+        &mut self,
+        i: &AssocItem,
+        parent_generics: &ast::Generics,
+    ) -> &'hir hir::ImplItem<'hir> {
         // Since `default impl` is not yet implemented, this is always true in impls.
         let has_value = true;
         let (defaultness, _) = self.lower_defaultness(i.kind.defaultness(), has_value);
 
         let (generics, kind) = match &i.kind {
             AssocItemKind::Const(_, ty, expr) => {
-                let ty = self.lower_ty(ty, ImplTraitContext::Disallowed(ImplTraitPosition::Type));
+                let ty =
+                    self.lower_ty(ty, &mut ImplTraitContext::Disallowed(ImplTraitPosition::Type));
                 (
                     hir::Generics::empty(),
                     hir::ImplItemKind::Const(ty, self.lower_const_body(i.span, expr.as_deref())),
@@ -865,6 +905,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     self.lower_maybe_async_body(i.span, &sig.decl, asyncness, body.as_deref());
                 let (generics, sig) = self.lower_method_sig(
                     generics,
+                    parent_generics,
                     sig,
                     i.id,
                     if self.is_in_trait_impl { FnDeclKind::Impl } else { FnDeclKind::Inherent },
@@ -879,14 +920,14 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 self.lower_generics(
                     &generics,
                     i.id,
-                    ImplTraitContext::Disallowed(ImplTraitPosition::Generic),
+                    &mut ImplTraitContext::Disallowed(ImplTraitPosition::Generic),
                     |this| match ty {
                         None => {
                             let ty = this.arena.alloc(this.ty(i.span, hir::TyKind::Err));
                             hir::ImplItemKind::TyAlias(ty)
                         }
                         Some(ty) => {
-                            let ty = this.lower_ty(ty, ImplTraitContext::TypeAliasesOpaqueTy);
+                            let ty = this.lower_ty(ty, &mut ImplTraitContext::TypeAliasesOpaqueTy);
                             hir::ImplItemKind::TyAlias(ty)
                         }
                     },
@@ -1222,15 +1263,23 @@ impl<'hir> LoweringContext<'_, 'hir> {
     fn lower_method_sig(
         &mut self,
         generics: &Generics,
+        parent_generics: &Generics,
         sig: &FnSig,
         id: NodeId,
         kind: FnDeclKind,
         is_async: Option<NodeId>,
     ) -> (&'hir hir::Generics<'hir>, hir::FnSig<'hir>) {
         let header = self.lower_fn_header(sig.header);
-        let itctx = ImplTraitContext::Universal;
-        let (generics, decl) = self.lower_generics(generics, id, itctx, |this| {
-            this.lower_fn_decl(&sig.decl, Some(id), kind, is_async)
+        let mut itctx = ImplTraitContext::Universal { apit_nodes: &mut Vec::new() };
+        let (generics, decl) = self.lower_generics(&generics, id, &mut itctx, |this| {
+            this.lower_fn_decl(
+                &sig.decl,
+                Some(id),
+                kind,
+                &generics,
+                Some(parent_generics),
+                is_async,
+            )
         });
         (generics, hir::FnSig { header, decl, span: self.lower_span(sig.span) })
     }
@@ -1291,13 +1340,16 @@ impl<'hir> LoweringContext<'_, 'hir> {
     /// Return the pair of the lowered `generics` as `hir::Generics` and the evaluation of `f` with
     /// the carried impl trait definitions and bounds.
     #[instrument(level = "debug", skip(self, f))]
-    fn lower_generics<T>(
+    fn lower_generics<'itctx, T>(
         &mut self,
-        generics: &Generics,
+        generics: &'itctx Generics,
         parent_node_id: NodeId,
-        itctx: ImplTraitContext,
+        itctx: &mut ImplTraitContext<'_, 'itctx>,
         f: impl FnOnce(&mut Self) -> T,
-    ) -> (&'hir hir::Generics<'hir>, T) {
+    ) -> (&'hir hir::Generics<'hir>, T)
+    where
+        'a: 'itctx,
+    {
         debug_assert!(self.impl_trait_defs.is_empty());
         debug_assert!(self.impl_trait_bounds.is_empty());
 
@@ -1394,15 +1446,18 @@ impl<'hir> LoweringContext<'_, 'hir> {
         (lowered_generics, res)
     }
 
-    pub(super) fn lower_generic_bound_predicate(
+    pub(super) fn lower_generic_bound_predicate<'itctx>(
         &mut self,
         ident: Ident,
         id: NodeId,
         kind: &GenericParamKind,
-        bounds: &[GenericBound],
-        itctx: ImplTraitContext,
+        bounds: &'itctx [GenericBound],
+        itctx: &mut ImplTraitContext<'_, 'itctx>,
         origin: PredicateOrigin,
-    ) -> Option<hir::WherePredicate<'hir>> {
+    ) -> Option<hir::WherePredicate<'hir>>
+    where
+        'a: 'itctx,
+    {
         // Do not create a clause if we do not have anything inside it.
         if bounds.is_empty() {
             return None;
@@ -1462,7 +1517,10 @@ impl<'hir> LoweringContext<'_, 'hir> {
         }
     }
 
-    fn lower_where_predicate(&mut self, pred: &WherePredicate) -> hir::WherePredicate<'hir> {
+    pub(super) fn lower_where_predicate(
+        &mut self,
+        pred: &WherePredicate,
+    ) -> hir::WherePredicate<'hir> {
         match *pred {
             WherePredicate::BoundPredicate(WhereBoundPredicate {
                 ref bound_generic_params,
@@ -1471,12 +1529,14 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 span,
             }) => hir::WherePredicate::BoundPredicate(hir::WhereBoundPredicate {
                 bound_generic_params: self.lower_generic_params(bound_generic_params),
-                bounded_ty: self
-                    .lower_ty(bounded_ty, ImplTraitContext::Disallowed(ImplTraitPosition::Type)),
+                bounded_ty: self.lower_ty(
+                    bounded_ty,
+                    &mut ImplTraitContext::Disallowed(ImplTraitPosition::Type),
+                ),
                 bounds: self.arena.alloc_from_iter(bounds.iter().map(|bound| {
                     self.lower_param_bound(
                         bound,
-                        ImplTraitContext::Disallowed(ImplTraitPosition::Bound),
+                        &mut ImplTraitContext::Disallowed(ImplTraitPosition::Bound),
                     )
                 })),
                 span: self.lower_span(span),
@@ -1491,16 +1551,20 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 lifetime: self.lower_lifetime(lifetime),
                 bounds: self.lower_param_bounds(
                     bounds,
-                    ImplTraitContext::Disallowed(ImplTraitPosition::Bound),
+                    &mut ImplTraitContext::Disallowed(ImplTraitPosition::Bound),
                 ),
                 in_where_clause: true,
             }),
             WherePredicate::EqPredicate(WhereEqPredicate { ref lhs_ty, ref rhs_ty, span }) => {
                 hir::WherePredicate::EqPredicate(hir::WhereEqPredicate {
-                    lhs_ty: self
-                        .lower_ty(lhs_ty, ImplTraitContext::Disallowed(ImplTraitPosition::Type)),
-                    rhs_ty: self
-                        .lower_ty(rhs_ty, ImplTraitContext::Disallowed(ImplTraitPosition::Type)),
+                    lhs_ty: self.lower_ty(
+                        lhs_ty,
+                        &mut ImplTraitContext::Disallowed(ImplTraitPosition::Type),
+                    ),
+                    rhs_ty: self.lower_ty(
+                        rhs_ty,
+                        &mut ImplTraitContext::Disallowed(ImplTraitPosition::Type),
+                    ),
                     span: self.lower_span(span),
                 })
             }
diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs
index 9a960356a85f4..8cba0b9f8623a 100644
--- a/compiler/rustc_ast_lowering/src/lib.rs
+++ b/compiler/rustc_ast_lowering/src/lib.rs
@@ -44,6 +44,7 @@ extern crate tracing;
 
 use crate::errors::{AssocTyParentheses, AssocTyParenthesesSub, MisplacedImplTrait};
 
+use rustc_arena::TypedArena;
 use rustc_ast::ptr::P;
 use rustc_ast::visit;
 use rustc_ast::{self as ast, *};
@@ -95,6 +96,13 @@ struct LoweringContext<'a, 'hir> {
     /// Used to allocate HIR nodes.
     arena: &'hir hir::Arena<'hir>,
 
+    /// Used to allocate temporary AST nodes for use during lowering.
+    /// This allows us to create "fake" AST -- these nodes can sometimes
+    /// be allocated on the stack, but other times we need them to live longer
+    /// than the current stack frame, so they can be collected into vectors
+    /// and things like that.
+    lowering_arena: &'a LoweringArena,
+
     /// Bodies inside the owner being lowered.
     bodies: Vec<(hir::ItemLocalId, &'hir hir::Body<'hir>)>,
     /// Attributes inside the owner being lowered.
@@ -126,6 +134,8 @@ struct LoweringContext<'a, 'hir> {
     impl_trait_defs: Vec<hir::GenericParam<'hir>>,
     impl_trait_bounds: Vec<hir::WherePredicate<'hir>>,
 
+    in_scope_generics: Vec<LocalDefId>,
+
     /// NodeIds that are lowered inside the current HIR owner.
     node_id_to_local_id: FxHashMap<NodeId, hir::ItemLocalId>,
 
@@ -134,6 +144,13 @@ struct LoweringContext<'a, 'hir> {
     allow_into_future: Option<Lrc<[Symbol]>>,
 }
 
+struct LoweringArena {
+    tys: TypedArena<Ty>,
+    aba: TypedArena<AngleBracketedArgs>,
+    ptr: TypedArena<PolyTraitRef>,
+    gs: TypedArena<Generics>,
+}
+
 trait ResolverAstLoweringExt {
     fn legacy_const_generic_args(&self, expr: &Expr) -> Option<Vec<usize>>;
     fn get_partial_res(&self, id: NodeId) -> Option<PartialRes>;
@@ -209,7 +226,7 @@ impl ResolverAstLoweringExt for ResolverAstLowering {
     /// The extra lifetimes that appear from the parenthesized `Fn`-trait desugaring
     /// should appear at the enclosing `PolyTraitRef`.
     fn take_extra_lifetime_params(&mut self, id: NodeId) -> Vec<(Ident, NodeId, LifetimeRes)> {
-        self.extra_lifetime_params_map.remove(&id).unwrap_or_default()
+        self.extra_lifetime_params_map.get(&id).map_or_else(|| Vec::new(), |map| map.clone())
     }
 
     fn decl_macro_kind(&self, def_id: LocalDefId) -> MacroKind {
@@ -254,14 +271,18 @@ impl ResolverAstLoweringExt for ResolverAstLowering {
 
 /// Context of `impl Trait` in code, which determines whether it is allowed in an HIR subtree,
 /// and if so, what meaning it has.
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-enum ImplTraitContext {
+#[derive(Debug)]
+enum ImplTraitContext<'b, 'itctx> {
     /// Treat `impl Trait` as shorthand for a new universal generic parameter.
     /// Example: `fn foo(x: impl Debug)`, where `impl Debug` is conceptually
     /// equivalent to a fresh universal parameter like `fn foo<T: Debug>(x: T)`.
     ///
     /// Newly generated parameters should be inserted into the given `Vec`.
-    Universal,
+    Universal {
+        apit_nodes: &'b mut Vec<&'itctx Ty>,
+    },
+
+    UniversalInRPIT,
 
     /// Treat `impl Trait` as shorthand for a new opaque type.
     /// Example: `fn foo() -> impl Debug`, where `impl Debug` is conceptually
@@ -270,6 +291,10 @@ enum ImplTraitContext {
     ReturnPositionOpaqueTy {
         /// Origin: Either OpaqueTyOrigin::FnReturn or OpaqueTyOrigin::AsyncFn,
         origin: hir::OpaqueTyOrigin,
+        impl_trait_inputs: &'b Vec<&'itctx Ty>,
+        /// In scope generics
+        generics: &'itctx Generics,
+        parent_generics: Option<&'itctx Generics>,
     },
     /// Impl trait in type aliases.
     TypeAliasesOpaqueTy,
@@ -358,6 +383,21 @@ enum AstOwner<'a> {
     ForeignItem(&'a ast::ForeignItem),
 }
 
+impl<'a> AstOwner<'a> {
+    fn item_generics(&self) -> ast::Generics {
+        match self {
+            Self::Item(Item {
+                kind:
+                    ItemKind::Trait(box Trait { generics, .. })
+                    | ItemKind::Impl(box Impl { generics, .. }),
+                ..
+            }) => generics.clone(),
+
+            _ => Generics::default(),
+        }
+    }
+}
+
 fn index_crate<'a>(
     node_id_to_def_id: &FxHashMap<NodeId, LocalDefId>,
     krate: &'a Crate,
@@ -436,10 +476,18 @@ pub fn lower_to_hir<'hir>(tcx: TyCtxt<'hir>, (): ()) -> hir::Crate<'hir> {
         tcx.definitions_untracked().def_index_count(),
     );
 
+    let lowering_arena = LoweringArena {
+        tys: TypedArena::default(),
+        aba: TypedArena::default(),
+        ptr: TypedArena::default(),
+        gs: TypedArena::default(),
+    };
+
     for def_id in ast_index.indices() {
         item::ItemLowerer {
             tcx,
             resolver: &mut resolver,
+            lowering_arena: &lowering_arena,
             ast_index: &ast_index,
             owners: &mut owners,
         }
@@ -483,7 +531,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
     ) -> LocalDefId {
         debug_assert_ne!(node_id, ast::DUMMY_NODE_ID);
         assert!(
-            self.opt_local_def_id(node_id).is_none(),
+            self.resolver.node_id_to_def_id.get(&node_id).is_none(),
             "adding a def'n for node-id {:?} and data {:?} but a previous def'n exists: {:?}",
             node_id,
             data,
@@ -595,11 +643,16 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
     fn with_remapping<R>(
         &mut self,
         remap: FxHashMap<LocalDefId, LocalDefId>,
+        in_scope_generics: &[LocalDefId],
         f: impl FnOnce(&mut Self) -> R,
     ) -> R {
+        let original_len = self.in_scope_generics.len();
+        self.in_scope_generics
+            .extend(in_scope_generics.iter().filter(|in_scope| !remap.contains_key(in_scope)));
         self.resolver.generics_def_id_map.push(remap);
         let res = f(self);
         self.resolver.generics_def_id_map.pop();
+        self.in_scope_generics.truncate(original_len);
         res
     }
 
@@ -680,6 +733,8 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 let local_id = self.item_local_id_counter;
                 let hir_id = hir::HirId { owner, local_id };
 
+                debug!("hir_id created: {:?} from {:?} via `lower_node_id`", hir_id, ast_node_id);
+
                 v.insert(local_id);
                 self.item_local_id_counter.increment_by(1);
 
@@ -704,12 +759,23 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         let owner = self.current_hir_id_owner;
         let local_id = self.item_local_id_counter;
         assert_ne!(local_id, hir::ItemLocalId::new(0));
+        debug!("hir_id created: {:?} via `next_id`", hir::HirId { owner, local_id });
+
         self.item_local_id_counter.increment_by(1);
         hir::HirId { owner, local_id }
     }
 
     #[instrument(level = "trace", skip(self))]
     fn lower_res(&mut self, res: Res<NodeId>) -> Res {
+        let res = res.map_def_id(|def_id| {
+            if let Some(local_def_id) = def_id.as_local() {
+                self.resolver.get_remapped_def_id(local_def_id).to_def_id()
+            } else {
+                def_id
+            }
+        });
+        trace!(?res, "from remapping");
+
         let res: Result<Res, ()> = res.apply_id(|id| {
             let owner = self.current_hir_id_owner;
             let local_id = self.node_id_to_local_id.get(&id).copied().ok_or(())?;
@@ -810,28 +876,163 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         })
     }
 
+    /// Collect a "to be lowered" copy of each type and const generic parameter, skipping
+    /// lifetimes.
+    #[instrument(level = "debug", skip(self))]
+    fn create_generic_defs(
+        &mut self,
+        parent_def_id: LocalDefId,
+        generics: &[GenericParam],
+        remapping: &mut FxHashMap<LocalDefId, LocalDefId>,
+    ) {
+        for param in generics {
+            if matches!(param.kind, GenericParamKind::Const { .. } | GenericParamKind::Type { .. })
+            {
+                let old_def_id = self.local_def_id(param.id);
+                let node_id = self.next_node_id();
+
+                // Add a definition for the generic param def.
+                let new_def_id = self.create_def(parent_def_id, node_id, DefPathData::ImplTrait);
+
+                remapping.insert(old_def_id, new_def_id);
+            }
+        }
+    }
+
+    /// Collect a "to be lowered" copy of each type and const argument, skipping lifetimes.
+    #[instrument(level = "debug", skip(self))]
+    fn collect_type_const_args(&mut self, params: &[GenericParam]) -> Vec<hir::GenericArg<'hir>> {
+        params
+            .iter()
+            .filter(|param| {
+                matches!(param.kind, GenericParamKind::Const { .. } | GenericParamKind::Type { .. })
+            })
+            .map(|param| {
+                let span = param.span();
+                let local_def_id = self.local_def_id(param.id);
+                let def_id = local_def_id.to_def_id();
+
+                match param.kind {
+                    GenericParamKind::Lifetime => {
+                        unreachable!("Lifetimes should have been filtered at this point.")
+                    }
+                    GenericParamKind::Type { .. } => hir::GenericArg::Type(hir::Ty {
+                        hir_id: self.next_id(),
+                        span,
+                        kind: hir::TyKind::Path(hir::QPath::Resolved(
+                            None,
+                            self.arena.alloc(hir::Path {
+                                res: Res::Def(
+                                    DefKind::TyParam,
+                                    def_id,
+                                ),
+                                span,
+                                segments: arena_vec![self; hir::PathSegment::from_ident(self.lower_ident(param.ident))],
+                            }),
+                        )),
+                    }),
+                    GenericParamKind::Const { .. } => {
+                        let parent_def_id = self.current_hir_id_owner;
+                        let node_id = self.next_node_id();
+
+                        self.create_def(
+                            parent_def_id,
+                            node_id,
+                            DefPathData::AnonConst,
+                        );
+                        let hir_id = self.lower_node_id(node_id);
+
+                        let span = self.lower_span(span);
+                        let ct = hir::AnonConst {
+                            hir_id,
+                            body: self.lower_body(|this| {
+                                (
+                                    &[],
+                                    hir::Expr {
+                                        hir_id: this.next_id(),
+                                        kind: hir::ExprKind::Path(hir::QPath::Resolved(
+                                            None,
+                                            this.arena.alloc(hir::Path {
+                                                res: Res::Def(
+                                                    DefKind::ConstParam,
+                                                    def_id,
+                                                ),
+                                                span,
+                                                segments: arena_vec![this; hir::PathSegment::from_ident(this.lower_ident(param.ident))],
+                                            }),
+                                        )),
+                                        span,
+                                    },
+                                )
+                            }),
+                        };
+
+                        hir::GenericArg::Const(hir::ConstArg { value: ct, span })
+                    }
+                }
+            })
+            .collect()
+    }
+
     /// Lowers a lifetime binder that defines `generic_params`, returning the corresponding HIR
     /// nodes. The returned list includes any "extra" lifetime parameters that were added by the
     /// name resolver owing to lifetime elision; this also populates the resolver's node-id->def-id
     /// map, so that later calls to `opt_node_id_to_def_id` that refer to these extra lifetime
     /// parameters will be successful.
-    #[instrument(level = "debug", skip(self))]
+    /// Creating new definitions and remapping for `generic_params` if `copy_generics` is set to
+    /// `true`. This is used for RPITs.
+    #[instrument(level = "debug", skip(self, in_binder))]
     #[inline]
-    fn lower_lifetime_binder(
+    fn lower_lifetime_binder<R>(
         &mut self,
         binder: NodeId,
         generic_params: &[GenericParam],
-    ) -> &'hir [hir::GenericParam<'hir>] {
-        let mut generic_params: Vec<_> = self.lower_generic_params_mut(generic_params).collect();
+        copy_generics: bool,
+        in_binder: impl FnOnce(&mut Self, &'hir [hir::GenericParam<'hir>]) -> R,
+    ) -> R {
+        let mut new_remapping = FxHashMap::default();
+
         let extra_lifetimes = self.resolver.take_extra_lifetime_params(binder);
         debug!(?extra_lifetimes);
-        generic_params.extend(extra_lifetimes.into_iter().filter_map(|(ident, node_id, res)| {
-            self.lifetime_res_to_generic_param(ident, node_id, res)
-        }));
-        let generic_params = self.arena.alloc_from_iter(generic_params);
-        debug!(?generic_params);
 
-        generic_params
+        let mut hir_extra_lifetimes = Vec::new();
+
+        let current_node_id_to_def_id = self.resolver.node_id_to_def_id.clone();
+
+        for (ident, node_id, res) in &extra_lifetimes {
+            if let Some(lifetime) = self.lifetime_res_to_generic_param(*ident, *node_id, *res) {
+                hir_extra_lifetimes.push(lifetime)
+            }
+        }
+
+        if copy_generics {
+            for old_node_id in generic_params.iter().map(|param| param.id) {
+                let old_def_id = self.local_def_id(old_node_id);
+                let node_id = self.next_node_id();
+
+                // Add a definition for the generic param def.
+                let new_def_id =
+                    self.create_def(self.current_hir_id_owner, node_id, DefPathData::ImplTrait);
+
+                new_remapping.insert(old_def_id, new_def_id);
+                debug!("old_def_id={:?} new_def_id={:?}", old_def_id, new_def_id);
+            }
+        }
+
+        // Install the remapping from old to new (if any):
+        let result = self.with_remapping(new_remapping, &[], |lctx| {
+            let mut generic_params: Vec<_> =
+                lctx.lower_generic_params_mut(generic_params).collect();
+            generic_params.extend(hir_extra_lifetimes);
+            let generic_params = lctx.arena.alloc_from_iter(generic_params);
+            debug!(?generic_params);
+
+            in_binder(lctx, generic_params)
+        });
+
+        self.resolver.node_id_to_def_id = current_node_id_to_def_id;
+
+        result
     }
 
     fn with_dyn_type_scope<T>(&mut self, in_scope: bool, f: impl FnOnce(&mut Self) -> T) -> T {
@@ -957,11 +1158,14 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
     ///
     /// returns a `hir::TypeBinding` representing `Item`.
     #[instrument(level = "debug", skip(self))]
-    fn lower_assoc_ty_constraint(
+    fn lower_assoc_ty_constraint<'itctx>(
         &mut self,
-        constraint: &AssocConstraint,
-        itctx: ImplTraitContext,
-    ) -> hir::TypeBinding<'hir> {
+        constraint: &'itctx AssocConstraint,
+        itctx: &mut ImplTraitContext<'_, 'itctx>,
+    ) -> hir::TypeBinding<'hir>
+    where
+        'a: 'itctx,
+    {
         debug!("lower_assoc_ty_constraint(constraint={:?}, itctx={:?})", constraint, itctx);
         // lower generic arguments of identifier in constraint
         let gen_args = if let Some(ref gen_args) = constraint.gen_args {
@@ -971,18 +1175,15 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 }
                 GenericArgs::Parenthesized(ref data) => {
                     self.emit_bad_parenthesized_trait_in_assoc_ty(data);
-                    self.lower_angle_bracketed_parameter_data(
-                        &data.as_angle_bracketed_args(),
-                        ParamMode::Explicit,
-                        itctx,
-                    )
-                    .0
+                    let aba = self.lowering_arena.aba.alloc(data.as_angle_bracketed_args());
+                    self.lower_angle_bracketed_parameter_data(aba, ParamMode::Explicit, itctx).0
                 }
             };
             gen_args_ctor.into_generic_args(self)
         } else {
             self.arena.alloc(hir::GenericArgs::none())
         };
+        let mut itctx_tait = ImplTraitContext::TypeAliasesOpaqueTy;
 
         let kind = match constraint.kind {
             AssocConstraintKind::Equality { ref term } => {
@@ -1012,7 +1213,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                     // so desugar to
                     //
                     //     fn foo(x: dyn Iterator<Item = impl Debug>)
-                    ImplTraitContext::Universal if self.is_in_dyn_type => (true, itctx),
+                    ImplTraitContext::Universal { .. } if self.is_in_dyn_type => (true, itctx),
 
                     // In `type Foo = dyn Iterator<Item: Debug>` we desugar to
                     // `type Foo = dyn Iterator<Item = impl Debug>` but we have to override the
@@ -1021,7 +1222,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                     //
                     // FIXME: this is only needed until `impl Trait` is allowed in type aliases.
                     ImplTraitContext::Disallowed(_) if self.is_in_dyn_type => {
-                        (true, ImplTraitContext::TypeAliasesOpaqueTy)
+                        (true, &mut itctx_tait)
                     }
 
                     // We are in the parameter position, but not within a dyn type:
@@ -1044,15 +1245,13 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
 
                     self.with_dyn_type_scope(false, |this| {
                         let node_id = this.next_node_id();
-                        let ty = this.lower_ty(
-                            &Ty {
-                                id: node_id,
-                                kind: TyKind::ImplTrait(impl_trait_node_id, bounds.clone()),
-                                span: this.lower_span(constraint.span),
-                                tokens: None,
-                            },
-                            itctx,
-                        );
+                        let ty = this.lowering_arena.tys.alloc(Ty {
+                            id: node_id,
+                            kind: TyKind::ImplTrait(impl_trait_node_id, bounds.clone()),
+                            span: this.lower_span(constraint.span),
+                            tokens: None,
+                        });
+                        let ty = this.lower_ty(ty, itctx);
 
                         hir::TypeBindingKind::Equality { term: ty.into() }
                     })
@@ -1100,11 +1299,14 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
     }
 
     #[instrument(level = "debug", skip(self))]
-    fn lower_generic_arg(
+    fn lower_generic_arg<'itctx>(
         &mut self,
-        arg: &ast::GenericArg,
-        itctx: ImplTraitContext,
-    ) -> hir::GenericArg<'hir> {
+        arg: &'itctx ast::GenericArg,
+        itctx: &mut ImplTraitContext<'_, 'itctx>,
+    ) -> hir::GenericArg<'hir>
+    where
+        'a: 'itctx,
+    {
         match arg {
             ast::GenericArg::Lifetime(lt) => GenericArg::Lifetime(self.lower_lifetime(&lt)),
             ast::GenericArg::Type(ty) => {
@@ -1155,7 +1357,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                     }
                     _ => {}
                 }
-                GenericArg::Type(self.lower_ty_direct(&ty, itctx))
+                GenericArg::Type(self.lower_ty_direct(ty, itctx))
             }
             ast::GenericArg::Const(ct) => GenericArg::Const(ConstArg {
                 value: self.lower_anon_const(&ct),
@@ -1165,18 +1367,28 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
     }
 
     #[instrument(level = "debug", skip(self))]
-    fn lower_ty(&mut self, t: &Ty, itctx: ImplTraitContext) -> &'hir hir::Ty<'hir> {
+    fn lower_ty<'itctx>(
+        &mut self,
+        t: &'itctx Ty,
+        itctx: &mut ImplTraitContext<'_, 'itctx>,
+    ) -> &'hir hir::Ty<'hir>
+    where
+        'a: 'itctx,
+    {
         self.arena.alloc(self.lower_ty_direct(t, itctx))
     }
 
-    fn lower_path_ty(
+    fn lower_path_ty<'itctx>(
         &mut self,
-        t: &Ty,
-        qself: &Option<QSelf>,
-        path: &Path,
+        t: &'itctx Ty,
+        qself: &'itctx Option<QSelf>,
+        path: &'itctx Path,
         param_mode: ParamMode,
-        itctx: ImplTraitContext,
-    ) -> hir::Ty<'hir> {
+        itctx: &mut ImplTraitContext<'_, 'itctx>,
+    ) -> hir::Ty<'hir>
+    where
+        'a: 'itctx,
+    {
         // Check whether we should interpret this as a bare trait object.
         // This check mirrors the one in late resolution.  We only introduce this special case in
         // the rare occurrence we need to lower `Fresh` anonymous lifetimes.
@@ -1188,12 +1400,13 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             && let Res::Def(DefKind::Trait | DefKind::TraitAlias, _) = partial_res.base_res()
         {
             let (bounds, lifetime_bound) = self.with_dyn_type_scope(true, |this| {
+                let poly_trait_ref = this.lowering_arena.ptr.alloc(PolyTraitRef {
+                    bound_generic_params: vec![],
+                    trait_ref: TraitRef { path: path.clone(), ref_id: t.id },
+                    span: t.span
+                });
                 let bound = this.lower_poly_trait_ref(
-                    &PolyTraitRef {
-                        bound_generic_params: vec![],
-                        trait_ref: TraitRef { path: path.clone(), ref_id: t.id },
-                        span: t.span
-                    },
+                    poly_trait_ref,
                     itctx,
                 );
                 let bounds = this.arena.alloc_from_iter([bound]);
@@ -1217,7 +1430,14 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         self.ty(span, hir::TyKind::Tup(tys))
     }
 
-    fn lower_ty_direct(&mut self, t: &Ty, itctx: ImplTraitContext) -> hir::Ty<'hir> {
+    fn lower_ty_direct<'itctx>(
+        &mut self,
+        t: &'itctx Ty,
+        itctx: &mut ImplTraitContext<'_, 'itctx>,
+    ) -> hir::Ty<'hir>
+    where
+        'a: 'itctx,
+    {
         let kind = match t.kind {
             TyKind::Infer => hir::TyKind::Infer,
             TyKind::Err => hir::TyKind::Err,
@@ -1239,16 +1459,35 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 let lifetime = self.lower_lifetime(&region);
                 hir::TyKind::Rptr(lifetime, self.lower_mt(mt, itctx))
             }
-            TyKind::BareFn(ref f) => {
-                let generic_params = self.lower_lifetime_binder(t.id, &f.generic_params);
-                hir::TyKind::BareFn(self.arena.alloc(hir::BareFnTy {
-                    generic_params,
-                    unsafety: self.lower_unsafety(f.unsafety),
-                    abi: self.lower_extern(f.ext),
-                    decl: self.lower_fn_decl(&f.decl, None, FnDeclKind::Pointer, None),
-                    param_names: self.lower_fn_params_to_names(&f.decl),
-                }))
-            }
+            TyKind::BareFn(ref f) => self.lower_lifetime_binder(
+                t.id,
+                &f.generic_params,
+                matches!(itctx, ImplTraitContext::ReturnPositionOpaqueTy { .. }),
+                |lctx, generic_params| {
+                    hir::TyKind::BareFn(lctx.arena.alloc(hir::BareFnTy {
+                        generic_params,
+                        unsafety: lctx.lower_unsafety(f.unsafety),
+                        abi: lctx.lower_extern(f.ext),
+                        decl: lctx.lower_fn_decl(
+                            &f.decl,
+                            None,
+                            FnDeclKind::Pointer,
+                            &Generics {
+                                params: f.generic_params.clone(),
+                                where_clause: WhereClause {
+                                    has_where_token: false,
+                                    predicates: Vec::new(),
+                                    span: DUMMY_SP,
+                                },
+                                span: DUMMY_SP,
+                            },
+                            None,
+                            None,
+                        ),
+                        param_names: lctx.lower_fn_params_to_names(&f.decl),
+                    }))
+                },
+            ),
             TyKind::Never => hir::TyKind::Never,
             TyKind::Tup(ref tys) => hir::TyKind::Tup(
                 self.arena.alloc_from_iter(tys.iter().map(|ty| self.lower_ty_direct(ty, itctx))),
@@ -1310,30 +1549,66 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             TyKind::ImplTrait(def_node_id, ref bounds) => {
                 let span = t.span;
                 match itctx {
-                    ImplTraitContext::ReturnPositionOpaqueTy { origin } => {
-                        self.lower_opaque_impl_trait(span, origin, def_node_id, bounds, itctx)
+                    ImplTraitContext::ReturnPositionOpaqueTy {
+                        origin,
+                        impl_trait_inputs,
+                        generics,
+                        parent_generics,
+                    } => {
+                        let generics = if let Some(parent_generics) = parent_generics {
+                            &*self.lowering_arena.gs.alloc(parent_generics.merge(generics))
+                        } else {
+                            generics
+                        };
+
+                        self.lower_opaque_impl_trait(
+                            span,
+                            *origin,
+                            def_node_id,
+                            generics,
+                            impl_trait_inputs,
+                            bounds,
+                            itctx,
+                        )
                     }
                     ImplTraitContext::TypeAliasesOpaqueTy => {
-                        let nested_itctx = ImplTraitContext::TypeAliasesOpaqueTy;
+                        let mut nested_itctx = ImplTraitContext::TypeAliasesOpaqueTy;
                         self.lower_opaque_impl_trait(
                             span,
                             hir::OpaqueTyOrigin::TyAlias,
                             def_node_id,
+                            &Generics::default(),
+                            &Vec::new(),
                             bounds,
-                            nested_itctx,
+                            &mut nested_itctx,
                         )
                     }
-                    ImplTraitContext::Universal => {
+                    ImplTraitContext::Universal { apit_nodes } => {
                         let span = t.span;
                         let ident = Ident::from_str_and_span(&pprust::ty_to_string(t), span);
+                        apit_nodes.push(t);
                         let (param, bounds, path) =
-                            self.lower_generic_and_bounds(def_node_id, span, ident, bounds);
+                            self.lower_generic_and_bounds(def_node_id, span, ident, bounds, itctx);
                         self.impl_trait_defs.push(param);
                         if let Some(bounds) = bounds {
                             self.impl_trait_bounds.push(bounds);
                         }
                         path
                     }
+                    ImplTraitContext::UniversalInRPIT => {
+                        let span = t.span;
+                        let ident = Ident::from_str_and_span(&pprust::ty_to_string(t), span);
+                        let def_id = self.local_def_id(def_node_id);
+
+                        hir::TyKind::Path(hir::QPath::Resolved(
+                            None,
+                            self.arena.alloc(hir::Path {
+                                span: self.lower_span(span),
+                                res: Res::Def(DefKind::TyParam, def_id.to_def_id()),
+                                segments: arena_vec![self; hir::PathSegment::from_ident(self.lower_ident(ident))],
+                            }),
+                        ))
+                    }
                     ImplTraitContext::Disallowed(position) => {
                         self.tcx.sess.emit_err(MisplacedImplTrait {
                             span: t.span,
@@ -1386,14 +1661,19 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
     /// capture the lifetimes that are referenced in the bounds. Therefore, we add *extra* lifetime parameters
     /// for the lifetimes that get captured (`'x`, in our example above) and reference those.
     #[instrument(level = "debug", skip(self))]
-    fn lower_opaque_impl_trait(
+    fn lower_opaque_impl_trait<'itctx>(
         &mut self,
         span: Span,
         origin: hir::OpaqueTyOrigin,
         opaque_ty_node_id: NodeId,
-        bounds: &GenericBounds,
-        itctx: ImplTraitContext,
-    ) -> hir::TyKind<'hir> {
+        ast_generics: &'itctx Generics,
+        impl_trait_inputs: &Vec<&Ty>,
+        bounds: &'itctx GenericBounds,
+        itctx: &mut ImplTraitContext<'_, 'itctx>,
+    ) -> hir::TyKind<'hir>
+    where
+        'a: 'itctx,
+    {
         // Make sure we know that some funky desugaring has been going on here.
         // This is a first: there is code in other places like for loop
         // desugaring that explicitly states that we don't want to track that.
@@ -1434,13 +1714,53 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             debug!(?collected_lifetimes);
             debug!(?new_remapping);
 
+            lctx.create_generic_defs(opaque_ty_def_id, &ast_generics.params, &mut new_remapping);
+            debug!(?new_remapping);
+
+            debug!("impl_trait_inputs = {:#?}", impl_trait_inputs);
+            for ty in impl_trait_inputs {
+                if let TyKind::ImplTrait(node_id, _) = &ty.kind {
+                    let old_def_id = lctx.local_def_id(*node_id);
+
+                    let node_id = lctx.next_node_id();
+                    // Add a definition for the generic param def.
+                    let new_def_id =
+                        lctx.create_def(opaque_ty_def_id, node_id, DefPathData::ImplTrait);
+
+                    new_remapping.insert(old_def_id, new_def_id);
+                } else {
+                    unreachable!(
+                        "impl_trait_inputs contains {:?} which is not TyKind::ImplTrait(..)",
+                        ty.kind
+                    );
+                }
+            }
+
+            let in_scope_generics: Vec<_> = ast_generics
+                .params
+                .iter()
+                .map(|param| param.id)
+                .chain(impl_trait_inputs.iter().map(|ty| {
+                    if let TyKind::ImplTrait(node_id, _) = ty.kind {
+                        node_id
+                    } else {
+                        unreachable!(
+                            "impl_trait_inputs contains {:?} which is not TyKind::ImplTrait(..)",
+                            ty.kind
+                        );
+                    }
+                }))
+                .map(|node_id| lctx.local_def_id(node_id))
+                .collect();
+
             // Install the remapping from old to new (if any):
-            lctx.with_remapping(new_remapping, |lctx| {
+            lctx.with_remapping(new_remapping, &in_scope_generics, |lctx| {
                 // This creates HIR lifetime definitions as `hir::GenericParam`, in the given
                 // example `type TestReturn<'a, T, 'x> = impl Debug + 'x`, it creates a collection
                 // containing `&['x]`.
-                let lifetime_defs = lctx.arena.alloc_from_iter(collected_lifetimes.iter().map(
-                    |&(new_node_id, lifetime)| {
+                let lifetime_defs: Vec<_> = collected_lifetimes
+                    .iter()
+                    .map(|&(new_node_id, lifetime)| {
                         let hir_id = lctx.lower_node_id(new_node_id);
                         debug_assert_ne!(lctx.opt_local_def_id(new_node_id), None);
 
@@ -1461,20 +1781,93 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                             kind: hir::GenericParamKind::Lifetime { kind },
                             colon_span: None,
                         }
-                    },
-                ));
+                    })
+                    .collect();
                 debug!(?lifetime_defs);
 
+                let type_const_defs: Vec<_> = ast_generics
+                    .params
+                    .iter()
+                    .filter(|param| {
+                        matches!(
+                            param.kind,
+                            GenericParamKind::Const { .. } | GenericParamKind::Type { .. }
+                        )
+                    })
+                    .map(|param| lctx.lower_generic_param(&param))
+                    .collect();
+                debug!(?type_const_defs);
+
+                let (universal_params, universal_predicates): (
+                    Vec<_>,
+                    Vec<_>,
+                ) = impl_trait_inputs.iter().map(|ty| {
+                    debug!("lowering impl trait input {:?}", ty);
+                    // FIXME
+                    if let TyKind::ImplTrait(node_id, ref bounds) = ty.kind {
+                        let span = ty.span;
+                        let ident = Ident::from_str_and_span(&pprust::ty_to_string(ty), span);
+
+                        let (universal_params, universal_predicates, _) = lctx.lower_generic_and_bounds(node_id, span, ident, bounds, &mut ImplTraitContext::UniversalInRPIT);
+                        (universal_params, universal_predicates)
+                    } else {
+                        unreachable!(
+                            "impl_trait_inputs contains {:?} which is not TyKind::ImplTrait(..)",
+                            ty.kind
+                        );
+                    }
+                }).unzip();
+
+                debug!(?universal_params);
+                debug!(?universal_predicates);
+
                 // Then when we lower the param bounds, references to 'a are remapped to 'a1, so we
                 // get back Debug + 'a1, which is suitable for use on the TAIT.
                 let hir_bounds = lctx.lower_param_bounds(bounds, itctx);
                 debug!(?hir_bounds);
 
+                let generic_defs = lifetime_defs
+                    .into_iter()
+                    .chain(type_const_defs.into_iter())
+                    .chain(universal_params);
+
+                let mut predicates: Vec<_> = ast_generics
+                    .params
+                    .iter()
+                    .filter(|param| {
+                        matches!(
+                            param.kind,
+                            GenericParamKind::Const { .. } | GenericParamKind::Type { .. }
+                        )
+                    })
+                    .filter_map(|param| {
+                        lctx.lower_generic_bound_predicate(
+                            param.ident,
+                            param.id,
+                            &param.kind,
+                            &param.bounds,
+                            itctx,
+                            hir::PredicateOrigin::GenericParam,
+                        )
+                    })
+                    .collect();
+
+                predicates.extend(
+                    ast_generics
+                        .where_clause
+                        .predicates
+                        .iter()
+                        .map(|predicate| lctx.lower_where_predicate(predicate)),
+                );
+                predicates.extend(universal_predicates.into_iter().flatten());
+
+                let has_where_clause_predicates = !predicates.is_empty();
+
                 let opaque_ty_item = hir::OpaqueTy {
                     generics: self.arena.alloc(hir::Generics {
-                        params: lifetime_defs,
-                        predicates: &[],
-                        has_where_clause_predicates: false,
+                        params: self.arena.alloc_from_iter(generic_defs),
+                        predicates: self.arena.alloc_from_iter(predicates),
+                        has_where_clause_predicates,
                         where_clause_span: lctx.lower_span(span),
                         span: lctx.lower_span(span),
                     }),
@@ -1489,8 +1882,9 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
 
         // This creates HIR lifetime arguments as `hir::GenericArg`, in the given example `type
         // TestReturn<'a, T, 'x> = impl Debug + 'x`, it creates a collection containing `&['x]`.
-        let lifetimes =
-            self.arena.alloc_from_iter(collected_lifetimes.into_iter().map(|(_, lifetime)| {
+        let lifetimes: Vec<_> = collected_lifetimes
+            .into_iter()
+            .map(|(_, lifetime)| {
                 let id = self.next_node_id();
                 let span = lifetime.ident.span;
 
@@ -1502,11 +1896,46 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
 
                 let l = self.new_named_lifetime(lifetime.id, id, span, ident);
                 hir::GenericArg::Lifetime(l)
-            }));
+            })
+            .collect();
         debug!(?lifetimes);
 
+        let type_const_args = self.collect_type_const_args(&ast_generics.params);
+
+        let universal_args: Vec<_> = impl_trait_inputs.iter().map(|ty| match ty.kind {
+            TyKind::ImplTrait(node_id, _) => {
+                let def_id = self.local_def_id(node_id);
+                let span = self.lower_span(ty.span);
+                let ident = Ident::from_str_and_span(&pprust::ty_to_string(ty), span);
+                hir::GenericArg::Type(hir::Ty {
+                    hir_id: self.next_id(),
+                    span,
+                    kind: hir::TyKind::Path(hir::QPath::Resolved(None, self.arena.alloc(hir::Path {
+                        span,
+                        res: Res::Def(DefKind::TyParam, def_id.to_def_id()),
+                        segments: arena_vec![self; hir::PathSegment::from_ident(self.lower_ident(ident))],
+                    })))
+                })
+            }
+            _ => {
+                unreachable!(
+                    "impl_trait_inputs contains {:?} which is not TyKind::ImplTrait(..)",
+                    ty.kind
+                );
+            }
+        }).collect();
+
+        let generic_args = self.arena.alloc_from_iter(
+            lifetimes
+                .into_iter()
+                .chain(type_const_args.into_iter())
+                .chain(universal_args.into_iter()),
+        );
+
         // `impl Trait` now just becomes `Foo<'a, 'b, ..>`.
-        hir::TyKind::OpaqueDef(hir::ItemId { def_id: opaque_ty_def_id }, lifetimes)
+        let result = hir::TyKind::OpaqueDef(hir::ItemId { def_id: opaque_ty_def_id }, generic_args);
+        debug!("lower_opaque_impl_trait = {:?}", result);
+        result
     }
 
     /// Registers a new opaque type with the proper `NodeId`s and
@@ -1627,6 +2056,8 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         decl: &FnDecl,
         fn_node_id: Option<NodeId>,
         kind: FnDeclKind,
+        generics: &Generics,
+        parent_generics: Option<&Generics>,
         make_ret_async: Option<NodeId>,
     ) -> &'hir hir::FnDecl<'hir> {
         let c_variadic = decl.c_variadic();
@@ -1634,17 +2065,19 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         // Skip the `...` (`CVarArgs`) trailing arguments from the AST,
         // as they are not explicit in HIR/Ty function signatures.
         // (instead, the `c_variadic` flag is set to `true`)
-        let mut inputs = &decl.inputs[..];
+        let mut ast_inputs = &decl.inputs[..];
         if c_variadic {
-            inputs = &inputs[..inputs.len() - 1];
+            ast_inputs = &ast_inputs[..ast_inputs.len() - 1];
         }
-        let inputs = self.arena.alloc_from_iter(inputs.iter().map(|param| {
+        let mut impl_trait_inputs = vec![];
+        let mut itctx = ImplTraitContext::Universal { apit_nodes: &mut impl_trait_inputs };
+        let inputs = self.arena.alloc_from_iter(ast_inputs.iter().map(|param| {
             if fn_node_id.is_some() {
-                self.lower_ty_direct(&param.ty, ImplTraitContext::Universal)
+                self.lower_ty_direct(&param.ty, &mut itctx)
             } else {
                 self.lower_ty_direct(
                     &param.ty,
-                    ImplTraitContext::Disallowed(match kind {
+                    &mut ImplTraitContext::Disallowed(match kind {
                         FnDeclKind::Fn | FnDeclKind::Inherent => {
                             unreachable!("fn should allow in-band lifetimes")
                         }
@@ -1659,19 +2092,31 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         }));
 
         let output = if let Some(ret_id) = make_ret_async {
-            self.lower_async_fn_ret_ty(
-                &decl.output,
-                fn_node_id.expect("`make_ret_async` but no `fn_def_id`"),
-                ret_id,
-            )
+            let fn_node_id = fn_node_id.expect("`make_ret_async` but no `fn_def_id`");
+            let fn_def_id = self.local_def_id(fn_node_id);
+
+            // Not `OpaqueTyOrigin::AsyncFn`: that's only used for the
+            // `impl Future` opaque type that `async fn` implicitly
+            // generates.
+            let mut output_itctx = ImplTraitContext::ReturnPositionOpaqueTy {
+                origin: hir::OpaqueTyOrigin::FnReturn(fn_def_id),
+                impl_trait_inputs: &impl_trait_inputs,
+                generics,
+                parent_generics,
+            };
+
+            self.lower_async_fn_ret_ty(&decl.output, fn_node_id, ret_id, &mut output_itctx)
         } else {
             match decl.output {
                 FnRetTy::Ty(ref ty) => {
-                    let context = match fn_node_id {
+                    let mut context = match fn_node_id {
                         Some(fn_node_id) if kind.impl_trait_return_allowed() => {
                             let fn_def_id = self.local_def_id(fn_node_id);
                             ImplTraitContext::ReturnPositionOpaqueTy {
                                 origin: hir::OpaqueTyOrigin::FnReturn(fn_def_id),
+                                impl_trait_inputs: &impl_trait_inputs,
+                                generics,
+                                parent_generics: parent_generics,
                             }
                         }
                         _ => ImplTraitContext::Disallowed(match kind {
@@ -1685,7 +2130,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                             FnDeclKind::Impl => ImplTraitPosition::ImplReturn,
                         }),
                     };
-                    hir::FnRetTy::Return(self.lower_ty(ty, context))
+                    hir::FnRetTy::Return(self.lower_ty(ty, &mut context))
                 }
                 FnRetTy::Default(span) => hir::FnRetTy::DefaultReturn(self.lower_span(span)),
             }
@@ -1731,12 +2176,16 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
     // `fn_def_id`: `DefId` of the parent function (used to create child impl trait definition)
     // `opaque_ty_node_id`: `NodeId` of the opaque `impl Trait` type that should be created
     #[instrument(level = "debug", skip(self))]
-    fn lower_async_fn_ret_ty(
+    fn lower_async_fn_ret_ty<'itctx>(
         &mut self,
-        output: &FnRetTy,
+        output: &'itctx FnRetTy,
         fn_node_id: NodeId,
         opaque_ty_node_id: NodeId,
-    ) -> hir::FnRetTy<'hir> {
+        output_itctx: &mut ImplTraitContext<'_, 'itctx>,
+    ) -> hir::FnRetTy<'hir>
+    where
+        'a: 'itctx,
+    {
         let span = output.span();
 
         let opaque_ty_span = self.mark_span_with_reason(DesugaringKind::Async, span, None);
@@ -1853,7 +2302,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             debug!(?new_remapping);
 
             // Install the remapping from old to new (if any):
-            this.with_remapping(new_remapping, |this| {
+            this.with_remapping(new_remapping, &[], |this| {
                 // We have to be careful to get elision right here. The
                 // idea is that we create a lifetime parameter for each
                 // lifetime in the return type.  So, given a return type
@@ -1863,7 +2312,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 // Then, we will create `fn foo(..) -> Foo<'_, '_>`, and
                 // hence the elision takes place at the fn site.
                 let future_bound =
-                    this.lower_async_fn_output_type_to_future_bound(output, fn_def_id, span);
+                    this.lower_async_fn_output_type_to_future_bound(output, span, output_itctx);
 
                 let generic_params = this.arena.alloc_from_iter(collected_lifetimes.iter().map(
                     |&(new_node_id, lifetime, _)| {
@@ -1953,23 +2402,18 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
     }
 
     /// Transforms `-> T` into `Future<Output = T>`.
-    fn lower_async_fn_output_type_to_future_bound(
+    fn lower_async_fn_output_type_to_future_bound<'itctx>(
         &mut self,
-        output: &FnRetTy,
-        fn_def_id: LocalDefId,
+        output: &'itctx FnRetTy,
         span: Span,
-    ) -> hir::GenericBound<'hir> {
+        output_itctx: &mut ImplTraitContext<'_, 'itctx>,
+    ) -> hir::GenericBound<'hir>
+    where
+        'a: 'itctx,
+    {
         // Compute the `T` in `Future<Output = T>` from the return type.
         let output_ty = match output {
-            FnRetTy::Ty(ty) => {
-                // Not `OpaqueTyOrigin::AsyncFn`: that's only used for the
-                // `impl Future` opaque type that `async fn` implicitly
-                // generates.
-                let context = ImplTraitContext::ReturnPositionOpaqueTy {
-                    origin: hir::OpaqueTyOrigin::FnReturn(fn_def_id),
-                };
-                self.lower_ty(ty, context)
-            }
+            FnRetTy::Ty(ty) => self.lower_ty(ty, output_itctx),
             FnRetTy::Default(ret_ty_span) => self.arena.alloc(self.ty_tup(*ret_ty_span, &[])),
         };
 
@@ -1991,11 +2435,14 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
     }
 
     #[instrument(level = "trace", skip(self))]
-    fn lower_param_bound(
+    fn lower_param_bound<'itctx>(
         &mut self,
-        tpb: &GenericBound,
-        itctx: ImplTraitContext,
-    ) -> hir::GenericBound<'hir> {
+        tpb: &'itctx GenericBound,
+        itctx: &mut ImplTraitContext<'_, 'itctx>,
+    ) -> hir::GenericBound<'hir>
+    where
+        'a: 'itctx,
+    {
         match tpb {
             GenericBound::Trait(p, modifier) => hir::GenericBound::Trait(
                 self.lower_poly_trait_ref(p, itctx),
@@ -2024,9 +2471,12 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         let name = match res {
             LifetimeRes::Param { param, .. } => {
                 let p_name = ParamName::Plain(ident);
-                let param = self.resolver.get_remapped_def_id(param);
-
-                hir::LifetimeName::Param(param, p_name)
+                if self.in_scope_generics.contains(&param) {
+                    hir::LifetimeName::Static
+                } else {
+                    let param = self.resolver.get_remapped_def_id(param);
+                    hir::LifetimeName::Param(param, p_name)
+                }
             }
             LifetimeRes::Fresh { param, .. } => {
                 debug_assert_eq!(ident.name, kw::UnderscoreLifetime);
@@ -2106,7 +2556,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             GenericParamKind::Type { ref default, .. } => {
                 let kind = hir::GenericParamKind::Type {
                     default: default.as_ref().map(|x| {
-                        self.lower_ty(x, ImplTraitContext::Disallowed(ImplTraitPosition::Type))
+                        self.lower_ty(x, &mut ImplTraitContext::Disallowed(ImplTraitPosition::Type))
                     }),
                     synthetic: false,
                 };
@@ -2114,7 +2564,8 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 (hir::ParamName::Plain(self.lower_ident(param.ident)), kind)
             }
             GenericParamKind::Const { ref ty, kw_span: _, ref default } => {
-                let ty = self.lower_ty(&ty, ImplTraitContext::Disallowed(ImplTraitPosition::Type));
+                let ty =
+                    self.lower_ty(&ty, &mut ImplTraitContext::Disallowed(ImplTraitPosition::Type));
                 let default = default.as_ref().map(|def| self.lower_anon_const(def));
                 (
                     hir::ParamName::Plain(self.lower_ident(param.ident)),
@@ -2124,7 +2575,14 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         }
     }
 
-    fn lower_trait_ref(&mut self, p: &TraitRef, itctx: ImplTraitContext) -> hir::TraitRef<'hir> {
+    fn lower_trait_ref<'itctx>(
+        &mut self,
+        p: &'itctx TraitRef,
+        itctx: &mut ImplTraitContext<'_, 'itctx>,
+    ) -> hir::TraitRef<'hir>
+    where
+        'a: 'itctx,
+    {
         let path = match self.lower_qpath(p.ref_id, &None, &p.path, ParamMode::Explicit, itctx) {
             hir::QPath::Resolved(None, path) => path,
             qpath => panic!("lower_trait_ref: unexpected QPath `{:?}`", qpath),
@@ -2133,44 +2591,76 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
     }
 
     #[instrument(level = "debug", skip(self))]
-    fn lower_poly_trait_ref(
+    fn lower_poly_trait_ref<'itctx>(
         &mut self,
-        p: &PolyTraitRef,
-        itctx: ImplTraitContext,
-    ) -> hir::PolyTraitRef<'hir> {
-        let bound_generic_params =
-            self.lower_lifetime_binder(p.trait_ref.ref_id, &p.bound_generic_params);
-        let trait_ref = self.lower_trait_ref(&p.trait_ref, itctx);
-        hir::PolyTraitRef { bound_generic_params, trait_ref, span: self.lower_span(p.span) }
+        p: &'itctx PolyTraitRef,
+        itctx: &mut ImplTraitContext<'_, 'itctx>,
+    ) -> hir::PolyTraitRef<'hir>
+    where
+        'a: 'itctx,
+    {
+        self.lower_lifetime_binder(
+            p.trait_ref.ref_id,
+            &p.bound_generic_params,
+            matches!(itctx, ImplTraitContext::ReturnPositionOpaqueTy { .. }),
+            |lctx, bound_generic_params| {
+                let trait_ref = lctx.lower_trait_ref(&p.trait_ref, itctx);
+                hir::PolyTraitRef { bound_generic_params, trait_ref, span: lctx.lower_span(p.span) }
+            },
+        )
     }
 
-    fn lower_mt(&mut self, mt: &MutTy, itctx: ImplTraitContext) -> hir::MutTy<'hir> {
+    fn lower_mt<'itctx>(
+        &mut self,
+        mt: &'itctx MutTy,
+        itctx: &mut ImplTraitContext<'_, 'itctx>,
+    ) -> hir::MutTy<'hir>
+    where
+        'a: 'itctx,
+    {
         hir::MutTy { ty: self.lower_ty(&mt.ty, itctx), mutbl: mt.mutbl }
     }
 
-    fn lower_param_bounds(
+    #[tracing::instrument(level = "debug", skip(self))]
+    fn lower_param_bounds<'b, 'itctx>(
         &mut self,
-        bounds: &[GenericBound],
-        itctx: ImplTraitContext,
-    ) -> hir::GenericBounds<'hir> {
+        bounds: &'itctx [GenericBound],
+        itctx: &'b mut ImplTraitContext<'_, 'itctx>,
+    ) -> hir::GenericBounds<'hir>
+    where
+        'a: 'itctx,
+    {
         self.arena.alloc_from_iter(self.lower_param_bounds_mut(bounds, itctx))
     }
 
-    fn lower_param_bounds_mut<'s>(
+    fn lower_param_bounds_mut<'s, 'b, 'c, 'itctx>(
         &'s mut self,
-        bounds: &'s [GenericBound],
-        itctx: ImplTraitContext,
-    ) -> impl Iterator<Item = hir::GenericBound<'hir>> + Captures<'s> + Captures<'a> {
+        bounds: &'itctx [GenericBound],
+        itctx: &'b mut ImplTraitContext<'c, 'itctx>,
+    ) -> impl Iterator<Item = hir::GenericBound<'hir>>
+    + Captures<'s>
+    + Captures<'b>
+    + Captures<'c>
+    + Captures<'a>
+    + Captures<'itctx>
+    where
+        'a: 'itctx,
+    {
         bounds.iter().map(move |bound| self.lower_param_bound(bound, itctx))
     }
 
-    fn lower_generic_and_bounds(
+    #[tracing::instrument(level = "debug", skip(self))]
+    fn lower_generic_and_bounds<'itctx>(
         &mut self,
         node_id: NodeId,
         span: Span,
         ident: Ident,
-        bounds: &[GenericBound],
-    ) -> (hir::GenericParam<'hir>, Option<hir::WherePredicate<'hir>>, hir::TyKind<'hir>) {
+        bounds: &'itctx [GenericBound],
+        itctx: &mut ImplTraitContext<'_, 'itctx>,
+    ) -> (hir::GenericParam<'hir>, Option<hir::WherePredicate<'hir>>, hir::TyKind<'hir>)
+    where
+        'a: 'itctx,
+    {
         // Add a definition for the in-band `Param`.
         let def_id = self.local_def_id(node_id);
 
@@ -2189,7 +2679,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             node_id,
             &GenericParamKind::Type { default: None },
             bounds,
-            ImplTraitContext::Universal,
+            itctx,
             hir::PredicateOrigin::ImplTrait,
         );
 
@@ -2202,6 +2692,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             }),
         ));
 
+        debug!("lower_generic_and_bounds=(param={:?}, preds={:?}, ty={:?})", param, preds, ty);
         (param, preds, ty)
     }
 
diff --git a/compiler/rustc_ast_lowering/src/pat.rs b/compiler/rustc_ast_lowering/src/pat.rs
index 1efa19a3a8286..eeb1f66b41148 100644
--- a/compiler/rustc_ast_lowering/src/pat.rs
+++ b/compiler/rustc_ast_lowering/src/pat.rs
@@ -37,7 +37,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                             qself,
                             path,
                             ParamMode::Optional,
-                            ImplTraitContext::Disallowed(ImplTraitPosition::Path),
+                            &mut ImplTraitContext::Disallowed(ImplTraitPosition::Path),
                         );
                         let (pats, ddpos) = self.lower_pat_tuple(pats, "tuple struct");
                         break hir::PatKind::TupleStruct(qpath, pats, ddpos);
@@ -53,7 +53,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                             qself,
                             path,
                             ParamMode::Optional,
-                            ImplTraitContext::Disallowed(ImplTraitPosition::Path),
+                            &mut ImplTraitContext::Disallowed(ImplTraitPosition::Path),
                         );
                         break hir::PatKind::Path(qpath);
                     }
@@ -63,7 +63,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                             qself,
                             path,
                             ParamMode::Optional,
-                            ImplTraitContext::Disallowed(ImplTraitPosition::Path),
+                            &mut ImplTraitContext::Disallowed(ImplTraitPosition::Path),
                         );
 
                         let fs = self.arena.alloc_from_iter(fields.iter().map(|f| {
diff --git a/compiler/rustc_ast_lowering/src/path.rs b/compiler/rustc_ast_lowering/src/path.rs
index 897c7215805e0..9e5103748e346 100644
--- a/compiler/rustc_ast_lowering/src/path.rs
+++ b/compiler/rustc_ast_lowering/src/path.rs
@@ -16,14 +16,17 @@ use smallvec::smallvec;
 
 impl<'a, 'hir> LoweringContext<'a, 'hir> {
     #[instrument(level = "trace", skip(self))]
-    pub(crate) fn lower_qpath(
+    pub(crate) fn lower_qpath<'itctx>(
         &mut self,
         id: NodeId,
-        qself: &Option<QSelf>,
-        p: &Path,
+        qself: &'itctx Option<QSelf>,
+        p: &'itctx Path,
         param_mode: ParamMode,
-        itctx: ImplTraitContext,
-    ) -> hir::QPath<'hir> {
+        itctx: &mut ImplTraitContext<'_, 'itctx>,
+    ) -> hir::QPath<'hir>
+    where
+        'a: 'itctx,
+    {
         let qself_position = qself.as_ref().map(|q| q.position);
         let qself = qself.as_ref().map(|q| self.lower_ty(&q.ty, itctx));
 
@@ -156,7 +159,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                     segment,
                     param_mode,
                     ParenthesizedGenericArgs::Err,
-                    ImplTraitContext::Disallowed(ImplTraitPosition::Path),
+                    &mut ImplTraitContext::Disallowed(ImplTraitPosition::Path),
                 )
             })),
             span: self.lower_span(p.span),
@@ -174,14 +177,17 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         self.lower_path_extra(res, p, param_mode)
     }
 
-    pub(crate) fn lower_path_segment(
+    pub(crate) fn lower_path_segment<'itctx>(
         &mut self,
         path_span: Span,
-        segment: &PathSegment,
+        segment: &'itctx PathSegment,
         param_mode: ParamMode,
         parenthesized_generic_args: ParenthesizedGenericArgs,
-        itctx: ImplTraitContext,
-    ) -> hir::PathSegment<'hir> {
+        itctx: &mut ImplTraitContext<'_, 'itctx>,
+    ) -> hir::PathSegment<'hir>
+    where
+        'a: 'itctx,
+    {
         debug!("path_span: {:?}, lower_path_segment(segment: {:?})", path_span, segment,);
         let (mut generic_args, infer_args) = if let Some(ref generic_args) = segment.args {
             match **generic_args {
@@ -214,15 +220,8 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                             None
                         };
                         self.tcx.sess.emit_err(GenericTypeWithParentheses { span: data.span, sub });
-                        (
-                            self.lower_angle_bracketed_parameter_data(
-                                &data.as_angle_bracketed_args(),
-                                param_mode,
-                                itctx,
-                            )
-                            .0,
-                            false,
-                        )
+                        let aba = self.lowering_arena.aba.alloc(data.as_angle_bracketed_args());
+                        (self.lower_angle_bracketed_parameter_data(aba, param_mode, itctx).0, false)
                     }
                 },
             }
@@ -312,12 +311,15 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         );
     }
 
-    pub(crate) fn lower_angle_bracketed_parameter_data(
+    pub(crate) fn lower_angle_bracketed_parameter_data<'itctx>(
         &mut self,
-        data: &AngleBracketedArgs,
+        data: &'itctx AngleBracketedArgs,
         param_mode: ParamMode,
-        itctx: ImplTraitContext,
-    ) -> (GenericArgsCtor<'hir>, bool) {
+        itctx: &mut ImplTraitContext<'_, 'itctx>,
+    ) -> (GenericArgsCtor<'hir>, bool)
+    where
+        'a: 'itctx,
+    {
         let has_non_lt_args = data.args.iter().any(|arg| match arg {
             AngleBracketedArg::Arg(ast::GenericArg::Lifetime(_))
             | AngleBracketedArg::Constraint(_) => false,
@@ -350,12 +352,14 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         // we generally don't permit such things (see #51008).
         let ParenthesizedArgs { span, inputs, inputs_span, output } = data;
         let inputs = self.arena.alloc_from_iter(inputs.iter().map(|ty| {
-            self.lower_ty_direct(ty, ImplTraitContext::Disallowed(ImplTraitPosition::FnTraitParam))
+            self.lower_ty_direct(
+                ty,
+                &mut ImplTraitContext::Disallowed(ImplTraitPosition::FnTraitParam),
+            )
         }));
         let output_ty = match output {
-            FnRetTy::Ty(ty) => {
-                self.lower_ty(&ty, ImplTraitContext::Disallowed(ImplTraitPosition::FnTraitReturn))
-            }
+            FnRetTy::Ty(ty) => self
+                .lower_ty(&ty, &mut ImplTraitContext::Disallowed(ImplTraitPosition::FnTraitReturn)),
             FnRetTy::Default(_) => self.arena.alloc(self.ty_tup(*span, &[])),
         };
         let args = smallvec![GenericArg::Type(self.ty_tup(*inputs_span, inputs))];
diff --git a/compiler/rustc_hir/src/def.rs b/compiler/rustc_hir/src/def.rs
index 2d2648a8f35af..1412d09d34674 100644
--- a/compiler/rustc_hir/src/def.rs
+++ b/compiler/rustc_hir/src/def.rs
@@ -650,6 +650,19 @@ impl<Id> Res<Id> {
         }
     }
 
+    pub fn map_def_id(self, mut map: impl FnMut(DefId) -> DefId) -> Res<Id> {
+        match self {
+            Res::Def(kind, id) => Res::Def(kind, map(id)),
+            Res::SelfCtor(id) => Res::SelfCtor(id),
+            Res::PrimTy(id) => Res::PrimTy(id),
+            Res::Local(id) => Res::Local(id),
+            Res::SelfTy { trait_, alias_to } => Res::SelfTy { trait_, alias_to },
+            Res::ToolMod => Res::ToolMod,
+            Res::NonMacroAttr(attr_kind) => Res::NonMacroAttr(attr_kind),
+            Res::Err => Res::Err,
+        }
+    }
+
     pub fn apply_id<R, E>(self, mut map: impl FnMut(Id) -> Result<R, E>) -> Result<Res<R>, E> {
         Ok(match self {
             Res::Def(kind, id) => Res::Def(kind, id),
diff --git a/compiler/rustc_infer/src/infer/opaque_types.rs b/compiler/rustc_infer/src/infer/opaque_types.rs
index d45adf43abfcc..32e52b4f001ca 100644
--- a/compiler/rustc_infer/src/infer/opaque_types.rs
+++ b/compiler/rustc_infer/src/infer/opaque_types.rs
@@ -346,7 +346,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
         debug!(?concrete_ty);
 
         let first_own_region = match self.opaque_ty_origin_unchecked(def_id, span) {
-            hir::OpaqueTyOrigin::FnReturn(..) | hir::OpaqueTyOrigin::AsyncFn(..) => {
+            hir::OpaqueTyOrigin::AsyncFn(..) => {
                 // We lower
                 //
                 // fn foo<'l0..'ln>() -> impl Trait<'l0..'lm>
@@ -361,7 +361,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
             }
             // These opaque type inherit all lifetime parameters from their
             // parent, so we have to check them all.
-            hir::OpaqueTyOrigin::TyAlias => 0,
+            hir::OpaqueTyOrigin::TyAlias | hir::OpaqueTyOrigin::FnReturn(..) => 0,
         };
 
         // For a case like `impl Foo<'a, 'b>`, we would generate a constraint
diff --git a/compiler/rustc_infer/src/infer/outlives/verify.rs b/compiler/rustc_infer/src/infer/outlives/verify.rs
index c7d7ef40d9d41..9187ca39c7fbd 100644
--- a/compiler/rustc_infer/src/infer/outlives/verify.rs
+++ b/compiler/rustc_infer/src/infer/outlives/verify.rs
@@ -57,6 +57,7 @@ impl<'cx, 'tcx> VerifyBoundCx<'cx, 'tcx> {
         // environment. If the environment contains something like
         // `for<'a> T: 'a`, then we know that `T` outlives everything.
         let declared_bounds_from_env = self.declared_generic_bounds_from_env(param_ty);
+        debug!(?declared_bounds_from_env);
         let mut param_bounds = vec![];
         for declared_bound in declared_bounds_from_env {
             let bound_region = declared_bound.map_bound(|outlives| outlives.1);
@@ -65,6 +66,7 @@ impl<'cx, 'tcx> VerifyBoundCx<'cx, 'tcx> {
                 param_bounds.push(VerifyBound::OutlivedBy(region));
             } else {
                 // This is `for<'a> T: 'a`. This means that `T` outlives everything! All done here.
+                debug!("found that {param_ty:?} outlives any lifetime, returning empty vector");
                 return VerifyBound::AllBounds(vec![]);
             }
         }
@@ -72,6 +74,7 @@ impl<'cx, 'tcx> VerifyBoundCx<'cx, 'tcx> {
         // Add in the default bound of fn body that applies to all in
         // scope type parameters:
         if let Some(r) = self.implicit_region_bound {
+            debug!("adding implicit region bound of {r:?}");
             param_bounds.push(VerifyBound::OutlivedBy(r));
         }
 
diff --git a/compiler/rustc_middle/src/ty/generics.rs b/compiler/rustc_middle/src/ty/generics.rs
index a1d980af921af..b398076d223aa 100644
--- a/compiler/rustc_middle/src/ty/generics.rs
+++ b/compiler/rustc_middle/src/ty/generics.rs
@@ -337,6 +337,9 @@ impl<'tcx> GenericPredicates<'tcx> {
         if let Some(def_id) = self.parent {
             tcx.predicates_of(def_id).instantiate_into(tcx, instantiated, substs);
         }
+
+        debug!("instantiate_into: predicates={:#?} substs={:#?}", instantiated.predicates, substs);
+
         instantiated
             .predicates
             .extend(self.predicates.iter().map(|(p, _)| EarlyBinder(*p).subst(tcx, substs)));
diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
index ed04e7660339e..7634b4e26dff0 100644
--- a/compiler/rustc_middle/src/ty/mod.rs
+++ b/compiler/rustc_middle/src/ty/mod.rs
@@ -2393,16 +2393,11 @@ impl<'tcx> TyCtxt<'tcx> {
 }
 
 /// Yields the parent function's `LocalDefId` if `def_id` is an `impl Trait` definition.
-pub fn is_impl_trait_defn(tcx: TyCtxt<'_>, def_id: DefId) -> Option<LocalDefId> {
+pub fn impl_trait_origin(tcx: TyCtxt<'_>, def_id: DefId) -> Option<hir::OpaqueTyOrigin> {
     let def_id = def_id.as_local()?;
     if let Node::Item(item) = tcx.hir().get_by_def_id(def_id) {
         if let hir::ItemKind::OpaqueTy(ref opaque_ty) = item.kind {
-            return match opaque_ty.origin {
-                hir::OpaqueTyOrigin::FnReturn(parent) | hir::OpaqueTyOrigin::AsyncFn(parent) => {
-                    Some(parent)
-                }
-                hir::OpaqueTyOrigin::TyAlias => None,
-            };
+            return Some(opaque_ty.origin);
         }
     }
     None
diff --git a/compiler/rustc_passes/src/hir_id_validator.rs b/compiler/rustc_passes/src/hir_id_validator.rs
index 212ea9e57a37b..3bb8c0bb48c5f 100644
--- a/compiler/rustc_passes/src/hir_id_validator.rs
+++ b/compiler/rustc_passes/src/hir_id_validator.rs
@@ -103,7 +103,7 @@ impl<'a, 'hir> HirIdValidator<'a, 'hir> {
             self.error(|| {
                 format!(
                     "ItemLocalIds not assigned densely in {}. \
-                Max ItemLocalId = {}, missing IDs = {:?}; seens IDs = {:?}",
+                Max ItemLocalId = {}, missing IDs = {:#?}; seens IDs = {:#?}",
                     self.hir_map.def_path(owner).to_string_no_crate_verbose(),
                     max,
                     missing_items,
diff --git a/compiler/rustc_resolve/src/late/lifetimes.rs b/compiler/rustc_resolve/src/late/lifetimes.rs
index c16eab222f625..8382b4f70aa6b 100644
--- a/compiler/rustc_resolve/src/late/lifetimes.rs
+++ b/compiler/rustc_resolve/src/late/lifetimes.rs
@@ -525,6 +525,7 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> {
         }
     }
 
+    #[tracing::instrument(level = "debug", skip(self))]
     fn visit_item(&mut self, item: &'tcx hir::Item<'tcx>) {
         match &item.kind {
             hir::ItemKind::Impl(hir::Impl { of_trait, .. }) => {
@@ -839,6 +840,7 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> {
         }
     }
 
+    #[tracing::instrument(level = "debug", skip(self))]
     fn visit_trait_item(&mut self, trait_item: &'tcx hir::TraitItem<'tcx>) {
         use self::hir::TraitItemKind::*;
         match trait_item.kind {
@@ -888,6 +890,7 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> {
         }
     }
 
+    #[tracing::instrument(level = "debug", skip(self))]
     fn visit_impl_item(&mut self, impl_item: &'tcx hir::ImplItem<'tcx>) {
         use self::hir::ImplItemKind::*;
         match impl_item.kind {
@@ -1046,20 +1049,31 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> {
                                     continue;
                                 }
                                 this.insert_lifetime(lt, Region::Static);
-                                this.tcx
-                                    .sess
-                                    .struct_span_warn(
-                                        lifetime.span,
-                                        &format!(
-                                            "unnecessary lifetime parameter `{}`",
-                                            lifetime.name.ident(),
-                                        ),
-                                    )
-                                    .help(&format!(
-                                        "you can use the `'static` lifetime directly, in place of `{}`",
-                                        lifetime.name.ident(),
-                                    ))
-                                    .emit();
+
+                                let hir_map = this.tcx.hir();
+                                let parent = hir_map.get_parent_node(lt.hir_id);
+
+                                match hir_map.get(parent) {
+                                    hir::Node::Item(&hir::Item { kind: hir::ItemKind::OpaqueTy(..), .. }) => {
+                                        // do not warn
+                                    }
+                                    _ => {
+                                        this.tcx
+                                            .sess
+                                            .struct_span_warn(
+                                                lifetime.span,
+                                                &format!(
+                                                    "unnecessary lifetime parameter `{}`",
+                                                    lifetime.name.ident(),
+                                                ),
+                                            )
+                                            .help(&format!(
+                                                "you can use the `'static` lifetime directly, in place of `{}`",
+                                                lifetime.name.ident(),
+                                            ))
+                                            .emit();
+                                    }
+                                }
                             }
                         }
                     }
diff --git a/compiler/rustc_trait_selection/src/traits/wf.rs b/compiler/rustc_trait_selection/src/traits/wf.rs
index bb6009cb22a37..5c88339bfaf19 100644
--- a/compiler/rustc_trait_selection/src/traits/wf.rs
+++ b/compiler/rustc_trait_selection/src/traits/wf.rs
@@ -434,6 +434,7 @@ impl<'tcx> WfPredicates<'tcx> {
     }
 
     /// Pushes all the predicates needed to validate that `ty` is WF into `out`.
+    #[tracing::instrument(level = "debug", skip(self))]
     fn compute(&mut self, arg: GenericArg<'tcx>) {
         let mut walker = arg.walk();
         let param_env = self.param_env;
@@ -488,6 +489,8 @@ impl<'tcx> WfPredicates<'tcx> {
                 }
             };
 
+            debug!("wf bounds for ty={:?} ty.kind={:#?}", ty, ty.kind());
+
             match *ty.kind() {
                 ty::Bool
                 | ty::Char
@@ -628,9 +631,29 @@ impl<'tcx> WfPredicates<'tcx> {
                     // All of the requirements on type parameters
                     // have already been checked for `impl Trait` in
                     // return position. We do need to check type-alias-impl-trait though.
-                    if ty::is_impl_trait_defn(self.tcx, did).is_none() {
-                        let obligations = self.nominal_obligations(did, substs);
-                        self.out.extend(obligations);
+                    debug!(
+                        "ty::Opaque(did={did:?}, substs={substs:?}, impl_trait_origin={:?}",
+                        ty::impl_trait_origin(self.tcx, did)
+                    );
+                    match ty::impl_trait_origin(self.tcx, did) {
+                        Some(hir::OpaqueTyOrigin::TyAlias) => {
+                            let obligations = self.nominal_obligations(did, substs);
+                            debug!("opaque obligations = {:#?}", obligations);
+                            self.out.extend(obligations);
+                        }
+                        Some(hir::OpaqueTyOrigin::AsyncFn(_))
+                        | Some(hir::OpaqueTyOrigin::FnReturn(_))
+                        | None => {
+                            // for opaque types introduced via `-> impl Trait` or async fn desugaring,
+                            // the where-clauses are currently kinda bogus so we skip them.
+                            //
+                            // These opaque type references only appear in 1 place (the fn return type)
+                            // and we know they are well-formed in that location if the fn's where-clauses are met.
+                            //
+                            // The only other place this type will propagate to is the return type of a fn call,
+                            // and it of course must satisfy the fn where clauses, so we know the type will be well-formed
+                            // in that context as well.\
+                        }
                     }
                 }
 
diff --git a/compiler/rustc_ty_utils/src/ty.rs b/compiler/rustc_ty_utils/src/ty.rs
index 9d640672cf92c..3cc957ed2fd55 100644
--- a/compiler/rustc_ty_utils/src/ty.rs
+++ b/compiler/rustc_ty_utils/src/ty.rs
@@ -106,7 +106,7 @@ fn adt_sized_constraint(tcx: TyCtxt<'_>, def_id: DefId) -> ty::AdtSizedConstrain
 /// See `ParamEnv` struct definition for details.
 fn param_env(tcx: TyCtxt<'_>, def_id: DefId) -> ty::ParamEnv<'_> {
     // The param_env of an impl Trait type is its defining function's param_env
-    if let Some(parent) = ty::is_impl_trait_defn(tcx, def_id) {
+    if let Some(hir::OpaqueTyOrigin::AsyncFn(parent)) = ty::impl_trait_origin(tcx, def_id) {
         return param_env(tcx, parent.to_def_id());
     }
     // Compute the bounds on Self and the type parameters.
@@ -235,7 +235,7 @@ fn well_formed_types_in_env<'tcx>(
     debug!("environment(def_id = {:?})", def_id);
 
     // The environment of an impl Trait type is its defining function's environment.
-    if let Some(parent) = ty::is_impl_trait_defn(tcx, def_id) {
+    if let Some(hir::OpaqueTyOrigin::AsyncFn(parent)) = ty::impl_trait_origin(tcx, def_id) {
         return well_formed_types_in_env(tcx, parent.to_def_id());
     }
 
diff --git a/compiler/rustc_typeck/src/astconv/mod.rs b/compiler/rustc_typeck/src/astconv/mod.rs
index ef927058df4ee..5f30e3dc1013f 100644
--- a/compiler/rustc_typeck/src/astconv/mod.rs
+++ b/compiler/rustc_typeck/src/astconv/mod.rs
@@ -2362,7 +2362,11 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
         match path.res {
             Res::Def(DefKind::OpaqueTy, did) => {
                 // Check for desugared `impl Trait`.
-                assert!(ty::is_impl_trait_defn(tcx, did).is_none());
+                assert!(matches!(
+                    ty::impl_trait_origin(tcx, did),
+                    None | Some(hir::OpaqueTyOrigin::FnReturn(_))
+                        | Some(hir::OpaqueTyOrigin::TyAlias)
+                ));
                 let item_segment = path.segments.split_last().unwrap();
                 self.prohibit_generics(item_segment.1.iter(), |err| {
                     err.note("`impl Trait` types can't have type parameters");
@@ -2697,15 +2701,48 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
         result_ty
     }
 
+    #[tracing::instrument(level = "debug", skip(self))]
     fn impl_trait_ty_to_ty(
         &self,
         def_id: DefId,
-        lifetimes: &[hir::GenericArg<'_>],
+        generic_args: &[hir::GenericArg<'_>],
         origin: OpaqueTyOrigin,
     ) -> Ty<'tcx> {
-        debug!("impl_trait_ty_to_ty(def_id={:?}, lifetimes={:?})", def_id, lifetimes);
         let tcx = self.tcx();
 
+        match origin {
+            hir::OpaqueTyOrigin::FnReturn(..) => {
+                let params = &self.tcx().generics_of(def_id).params;
+                assert_eq!(params.len(), generic_args.len());
+                let substs: Vec<_> = generic_args
+                    .iter()
+                    .zip(params)
+                    .map(|(generic_arg, param)| match generic_arg {
+                        GenericArg::Lifetime(lt) => self.ast_region_to_region(lt, None).into(),
+                        GenericArg::Type(ty) => self.ast_ty_to_ty(ty).into(),
+                        GenericArg::Const(ct) => ty::Const::from_opt_const_arg_anon_const(
+                            tcx,
+                            ty::WithOptConstParam {
+                                did: tcx.hir().local_def_id(ct.value.hir_id),
+                                const_param_did: Some(param.def_id),
+                            },
+                        )
+                        .into(),
+                        _ => {
+                            bug!(
+                                "Generic argument {:?} should have been inferred already",
+                                generic_arg
+                            )
+                        }
+                    })
+                    .collect();
+                let ty = tcx.mk_opaque(def_id, tcx.intern_substs(&substs));
+                debug!(?ty);
+                return ty;
+            }
+            _ => {}
+        }
+
         let generics = tcx.generics_of(def_id);
 
         debug!("impl_trait_ty_to_ty: generics={:?}", generics);
@@ -2713,7 +2750,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
             if let Some(i) = (param.index as usize).checked_sub(generics.parent_count) {
                 // Our own parameters are the resolved lifetimes.
                 if let GenericParamDefKind::Lifetime = param.kind {
-                    if let hir::GenericArg::Lifetime(lifetime) = &lifetimes[i] {
+                    if let hir::GenericArg::Lifetime(lifetime) = &generic_args[i] {
                         self.ast_region_to_region(lifetime, None).into()
                     } else {
                         bug!()
diff --git a/compiler/rustc_typeck/src/check/check.rs b/compiler/rustc_typeck/src/check/check.rs
index 29a128f27b840..367421206dd5f 100644
--- a/compiler/rustc_typeck/src/check/check.rs
+++ b/compiler/rustc_typeck/src/check/check.rs
@@ -725,11 +725,12 @@ fn check_opaque_meets_bounds<'tcx>(
     let hidden_type = tcx.bound_type_of(def_id.to_def_id()).subst(tcx, substs);
 
     let hir_id = tcx.hir().local_def_id_to_hir_id(def_id);
-    let defining_use_anchor = match *origin {
-        hir::OpaqueTyOrigin::FnReturn(did) | hir::OpaqueTyOrigin::AsyncFn(did) => did,
-        hir::OpaqueTyOrigin::TyAlias => def_id,
+    let (param_env_did, defining_use_anchor) = match *origin {
+        hir::OpaqueTyOrigin::FnReturn(did) => (def_id, did),
+        hir::OpaqueTyOrigin::AsyncFn(did) => (did, did),
+        hir::OpaqueTyOrigin::TyAlias => (def_id, def_id),
     };
-    let param_env = tcx.param_env(defining_use_anchor);
+    let param_env = tcx.param_env(param_env_did);
 
     tcx.infer_ctxt().with_opaque_type_inference(DefiningAnchor::Bind(defining_use_anchor)).enter(
         move |infcx| {
diff --git a/compiler/rustc_typeck/src/collect.rs b/compiler/rustc_typeck/src/collect.rs
index 6236ad370df60..81c1afd8d2ffc 100644
--- a/compiler/rustc_typeck/src/collect.rs
+++ b/compiler/rustc_typeck/src/collect.rs
@@ -573,6 +573,7 @@ fn get_new_lifetime_name<'tcx>(
 
 /// Returns the predicates defined on `item_def_id` of the form
 /// `X: Foo` where `X` is the type parameter `def_id`.
+#[instrument(level = "trace", skip(tcx))]
 fn type_param_predicates(
     tcx: TyCtxt<'_>,
     (item_def_id, def_id, assoc_name): (DefId, LocalDefId, Ident),
@@ -617,7 +618,7 @@ fn type_param_predicates(
                 | ItemKind::TyAlias(_, ref generics)
                 | ItemKind::OpaqueTy(OpaqueTy {
                     ref generics,
-                    origin: hir::OpaqueTyOrigin::TyAlias,
+                    origin: hir::OpaqueTyOrigin::TyAlias | hir::OpaqueTyOrigin::FnReturn(..),
                     ..
                 })
                 | ItemKind::Enum(_, ref generics)
@@ -669,7 +670,7 @@ impl<'tcx> ItemCtxt<'tcx> {
     /// AST. We do this to avoid having to convert *all* the bounds, which
     /// would create artificial cycles. Instead, we can only convert the
     /// bounds for a type parameter `X` if `X::Foo` is used.
-    #[instrument(level = "trace", skip(self, ast_generics))]
+    #[instrument(level = "trace", skip(self))]
     fn type_parameter_bounds_in_generics(
         &self,
         ast_generics: &'tcx hir::Generics<'tcx>,
@@ -1583,8 +1584,7 @@ fn generics_of(tcx: TyCtxt<'_>, def_id: DefId) -> ty::Generics {
         }
         Node::Item(item) => match item.kind {
             ItemKind::OpaqueTy(hir::OpaqueTy {
-                origin:
-                    hir::OpaqueTyOrigin::FnReturn(fn_def_id) | hir::OpaqueTyOrigin::AsyncFn(fn_def_id),
+                origin: hir::OpaqueTyOrigin::AsyncFn(fn_def_id),
                 ..
             }) => Some(fn_def_id.to_def_id()),
             ItemKind::OpaqueTy(hir::OpaqueTy { origin: hir::OpaqueTyOrigin::TyAlias, .. }) => {
@@ -2105,11 +2105,10 @@ fn predicates_of(tcx: TyCtxt<'_>, def_id: DefId) -> ty::GenericPredicates<'_> {
 
 /// Returns a list of user-specified type predicates for the definition with ID `def_id`.
 /// N.B., this does not include any implied/inferred constraints.
+#[instrument(level = "trace", skip(tcx))]
 fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: DefId) -> ty::GenericPredicates<'_> {
     use rustc_hir::*;
 
-    debug!("explicit_predicates_of(def_id={:?})", def_id);
-
     let hir_id = tcx.hir().local_def_id_to_hir_id(def_id.expect_local());
     let node = tcx.hir().get(hir_id);
 
@@ -2152,8 +2151,7 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: DefId) -> ty::GenericP
                     *generics
                 }
                 ItemKind::OpaqueTy(OpaqueTy {
-                    origin: hir::OpaqueTyOrigin::AsyncFn(..) | hir::OpaqueTyOrigin::FnReturn(..),
-                    ..
+                    origin: hir::OpaqueTyOrigin::AsyncFn(..), ..
                 }) => {
                     // return-position impl trait
                     //
@@ -2173,12 +2171,9 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: DefId) -> ty::GenericP
                 }
                 ItemKind::OpaqueTy(OpaqueTy {
                     ref generics,
-                    origin: hir::OpaqueTyOrigin::TyAlias,
+                    origin: hir::OpaqueTyOrigin::TyAlias | hir::OpaqueTyOrigin::FnReturn(..),
                     ..
-                }) => {
-                    // type-alias impl trait
-                    generics
-                }
+                }) => generics,
 
                 _ => NO_GENERICS,
             }
@@ -2224,6 +2219,8 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: DefId) -> ty::GenericP
         + has_own_self as u32
         + early_bound_lifetimes_from_generics(tcx, ast_generics).count() as u32;
 
+    debug!("gather_explicit_predicates_of(predicates={:?})", predicates);
+    debug!("gather_explicit_predicates_of(ast_generics={:?})", ast_generics);
     // Collect the predicates that were written inline by the user on each
     // type parameter (e.g., `<T: Foo>`).
     for param in ast_generics.params {
@@ -2244,7 +2241,9 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: DefId) -> ty::GenericP
                     Some((param.hir_id, ast_generics.predicates)),
                     param.span,
                 );
+                debug!("gather_explicit_predicates_of(bounds={:?})", bounds);
                 predicates.extend(bounds.predicates(tcx, param_ty));
+                debug!("gather_explicit_predicates_of(predicates={:?})", predicates);
             }
             GenericParamKind::Const { .. } => {
                 // Bounds on const parameters are currently not possible.
@@ -2253,6 +2252,7 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: DefId) -> ty::GenericP
         }
     }
 
+    debug!("gather_explicit_predicates_of(predicates={:?})", predicates);
     // Add in the bounds that appear in the where-clause.
     for predicate in ast_generics.predicates {
         match predicate {
diff --git a/compiler/rustc_typeck/src/collect/item_bounds.rs b/compiler/rustc_typeck/src/collect/item_bounds.rs
index 0d2b75d3328fc..2d9b5aaf09878 100644
--- a/compiler/rustc_typeck/src/collect/item_bounds.rs
+++ b/compiler/rustc_typeck/src/collect/item_bounds.rs
@@ -53,6 +53,7 @@ fn associated_type_bounds<'tcx>(
 /// impl trait it isn't possible to write a suitable predicate on the
 /// containing function and for type-alias impl trait we don't have a backwards
 /// compatibility issue.
+#[instrument(level = "trace", skip(tcx))]
 fn opaque_type_bounds<'tcx>(
     tcx: TyCtxt<'tcx>,
     opaque_def_id: DefId,
@@ -65,9 +66,14 @@ fn opaque_type_bounds<'tcx>(
 
         let icx = ItemCtxt::new(tcx, opaque_def_id);
         let mut bounds = <dyn AstConv<'_>>::compute_bounds(&icx, item_ty, ast_bounds);
+
+        debug!("opaque_type_bounds(bounds={:?})", bounds);
         // Opaque types are implicitly sized unless a `?Sized` bound is found
         <dyn AstConv<'_>>::add_implicitly_sized(&icx, &mut bounds, ast_bounds, None, span);
-        tcx.arena.alloc_from_iter(bounds.predicates(tcx, item_ty))
+        debug!("opaque_type_bounds(bounds={:?})", bounds);
+        let result = tcx.arena.alloc_from_iter(bounds.predicates(tcx, item_ty));
+        debug!("opaque_type_bounds(predicates={:?})", result);
+        result
     })
 }
 
diff --git a/compiler/rustc_typeck/src/collect/type_of.rs b/compiler/rustc_typeck/src/collect/type_of.rs
index 9f931de6fdedb..3f95361e3e8a3 100644
--- a/compiler/rustc_typeck/src/collect/type_of.rs
+++ b/compiler/rustc_typeck/src/collect/type_of.rs
@@ -195,6 +195,29 @@ pub(super) fn opt_const_param_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Option<
 
             (generics, arg_index)
         }
+
+        Node::Ty(&Ty { kind: TyKind::OpaqueDef(id, generics), .. }) => {
+            let parent_generics = tcx.generics_of(id.def_id.to_def_id());
+
+            generics
+                .iter()
+                .enumerate()
+                .filter_map(|(idx, arg)| match arg {
+                    hir::GenericArg::Const(ConstArg {
+                        value: hir::AnonConst { hir_id: inner_hir_id, .. },
+                        ..
+                    }) => {
+                        if *inner_hir_id == hir_id {
+                            Some((parent_generics, idx))
+                        } else {
+                            None
+                        }
+                    }
+                    _ => None,
+                })
+                .next()?
+        }
+
         _ => return None,
     };
 
diff --git a/src/test/ui/chalkify/bugs/async.stderr b/src/test/ui/chalkify/bugs/async.stderr
index f53ed53f73c49..2a8aa94deae02 100644
--- a/src/test/ui/chalkify/bugs/async.stderr
+++ b/src/test/ui/chalkify/bugs/async.stderr
@@ -28,12 +28,21 @@ note: required by a bound in `std::future::from_generator`
 LL |     T: Generator<ResumeTy, Yield = ()>,
    |                            ^^^^^^^^^^ required by this bound in `std::future::from_generator`
 
+error: the type `impl Future<Output = u32>` is not well-formed (chalk)
+  --> $DIR/async.rs:7:29
+   |
+LL |   async fn foo(x: u32) -> u32 {
+   |  _____________________________^
+LL | |     x
+LL | | }
+   | |_^
+
 error[E0280]: the requirement `<impl Future<Output = u32> as Future>::Output == u32` is not satisfied
   --> $DIR/async.rs:7:25
    |
 LL | async fn foo(x: u32) -> u32 {
    |                         ^^^
 
-error: aborting due to 3 previous errors
+error: aborting due to 4 previous errors
 
 For more information about this error, try `rustc --explain E0277`.
diff --git a/src/test/ui/impl-trait/bound-normalization-fail.rs b/src/test/ui/impl-trait/bound-normalization-fail.rs
index 3329592478d6f..88eea4551777d 100644
--- a/src/test/ui/impl-trait/bound-normalization-fail.rs
+++ b/src/test/ui/impl-trait/bound-normalization-fail.rs
@@ -23,7 +23,7 @@ mod impl_trait {
 
     /// `T::Assoc` can't be normalized any further here.
     fn foo_fail<T: Trait>() -> impl FooLike<Output = T::Assoc> {
-        //~^ ERROR: type mismatch
+        //~^ ERROR: type mismatch resolving `<Foo<()> as FooLike>::Output == <T as impl_trait::Trait>::Assoc` [E0271]
         Foo(())
     }
 }
@@ -39,8 +39,7 @@ mod lifetimes {
 
     /// Missing bound constraining `Assoc`, `T::Assoc` can't be normalized further.
     fn foo2_fail<'a, T: Trait<'a>>() -> impl FooLike<Output = T::Assoc> {
-        //~^ ERROR `impl Trait` return type cannot contain a projection or `Self` that references lifetimes from a parent scope
-        //~| ERROR: type mismatch
+        //~^ ERROR: type mismatch resolving `<Foo<()> as FooLike>::Output == <T as lifetimes::Trait<'static>>::Assoc` [E0271]
         Foo(())
     }
 }
diff --git a/src/test/ui/impl-trait/bound-normalization-fail.stderr b/src/test/ui/impl-trait/bound-normalization-fail.stderr
index bd8d3d3d24ece..fdaebf383df43 100644
--- a/src/test/ui/impl-trait/bound-normalization-fail.stderr
+++ b/src/test/ui/impl-trait/bound-normalization-fail.stderr
@@ -19,18 +19,12 @@ help: consider constraining the associated type `<T as impl_trait::Trait>::Assoc
 LL |     fn foo_fail<T: Trait<Assoc = ()>>() -> impl FooLike<Output = T::Assoc> {
    |                         ++++++++++++
 
-error[E0760]: `impl Trait` return type cannot contain a projection or `Self` that references lifetimes from a parent scope
-  --> $DIR/bound-normalization-fail.rs:41:41
-   |
-LL |     fn foo2_fail<'a, T: Trait<'a>>() -> impl FooLike<Output = T::Assoc> {
-   |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
 error[E0271]: type mismatch resolving `<Foo<()> as FooLike>::Output == <T as lifetimes::Trait<'static>>::Assoc`
   --> $DIR/bound-normalization-fail.rs:41:41
    |
 LL |     fn foo2_fail<'a, T: Trait<'a>>() -> impl FooLike<Output = T::Assoc> {
    |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type mismatch resolving `<Foo<()> as FooLike>::Output == <T as lifetimes::Trait<'static>>::Assoc`
-...
+LL |
 LL |         Foo(())
    |         ------- return type was inferred to be `Foo<()>` here
    |
@@ -46,7 +40,6 @@ help: consider constraining the associated type `<T as lifetimes::Trait<'static>
 LL |     fn foo2_fail<'a, T: Trait<'a, Assoc = ()>>() -> impl FooLike<Output = T::Assoc> {
    |                                 ++++++++++++
 
-error: aborting due to 3 previous errors
+error: aborting due to 2 previous errors
 
-Some errors have detailed explanations: E0271, E0760.
-For more information about an error, try `rustc --explain E0271`.
+For more information about this error, try `rustc --explain E0271`.
diff --git a/src/test/ui/nll/ty-outlives/impl-trait-captures.stderr b/src/test/ui/nll/ty-outlives/impl-trait-captures.stderr
index 330c6fafa2d61..1a699edcf5899 100644
--- a/src/test/ui/nll/ty-outlives/impl-trait-captures.stderr
+++ b/src/test/ui/nll/ty-outlives/impl-trait-captures.stderr
@@ -1,4 +1,4 @@
-error[E0700]: hidden type for `Opaque(DefId(0:11 ~ impl_trait_captures[1afc]::foo::{opaque#0}), [ReStatic, T, ReEarlyBound(0, 'a)])` captures lifetime that does not appear in bounds
+error[E0700]: hidden type for `Opaque(DefId(0:11 ~ impl_trait_captures[1afc]::foo::{opaque#0}), [ReEarlyBound(0, 'a), T])` captures lifetime that does not appear in bounds
   --> $DIR/impl-trait-captures.rs:11:5
    |
 LL | fn foo<'a, T>(x: &T) -> impl Foo<'a> {