Add captures flag to capture or not while lowering

7 files changed, 211 insertions, 111 deletions

diff --git a/compiler/rustc_ast_lowering/src/asm.rs b/compiler/rustc_ast_lowering/src/asm.rs
index 4166b4fc2e5..7d74007d1cb 100644
--- a/compiler/rustc_ast_lowering/src/asm.rs
+++ b/compiler/rustc_ast_lowering/src/asm.rs
@@ -234,6 +234,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                                 &sym.path,
                                 ParamMode::Optional,
                                 ImplTraitContext::Disallowed(ImplTraitPosition::Path),
+                                true,
                             );
                             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 7cbfe143b4d..d51393d88c0 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, ImplTraitContext::Disallowed(ImplTraitPosition::Variable), true)
+        });
         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 983efa48a45..b4114007241 100644
--- a/compiler/rustc_ast_lowering/src/expr.rs
+++ b/compiler/rustc_ast_lowering/src/expr.rs
@@ -69,6 +69,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                         ParamMode::Optional,
                         ParenthesizedGenericArgs::Err,
                         ImplTraitContext::Disallowed(ImplTraitPosition::Path),
+                        true,
                     ));
                     let args = self.lower_exprs(args);
                     hir::ExprKind::MethodCall(hir_seg, args, self.lower_span(span))
@@ -89,14 +90,20 @@ 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,
+                        ImplTraitContext::Disallowed(ImplTraitPosition::Type),
+                        true,
+                    );
                     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,
+                        ImplTraitContext::Disallowed(ImplTraitPosition::Type),
+                        true,
+                    );
                     hir::ExprKind::Type(expr, ty)
                 }
                 ExprKind::AddrOf(k, m, ref ohs) => {
@@ -226,6 +233,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                         path,
                         ParamMode::Optional,
                         ImplTraitContext::Disallowed(ImplTraitPosition::Path),
+                        true,
                     );
                     hir::ExprKind::Path(qpath)
                 }
@@ -264,6 +272,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                             &se.path,
                             ParamMode::Optional,
                             ImplTraitContext::Disallowed(ImplTraitPosition::Path),
+                            true,
                         )),
                         self.arena
                             .alloc_from_iter(se.fields.iter().map(|x| self.lower_expr_field(x))),
@@ -561,9 +570,11 @@ impl<'hir> LoweringContext<'_, 'hir> {
         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)),
-            ),
+            Some(ty) => hir::FnRetTy::Return(self.lower_ty(
+                &ty,
+                ImplTraitContext::Disallowed(ImplTraitPosition::AsyncBlock),
+                true,
+            )),
             None => hir::FnRetTy::DefaultReturn(self.lower_span(span)),
         };
 
@@ -1167,6 +1178,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                         path,
                         ParamMode::Optional,
                         ImplTraitContext::Disallowed(ImplTraitPosition::Path),
+                        true,
                     );
                     // Destructure like a tuple struct.
                     let tuple_struct_pat =
@@ -1183,6 +1195,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                         path,
                         ParamMode::Optional,
                         ImplTraitContext::Disallowed(ImplTraitPosition::Path),
+                        true,
                     );
                     // Destructure like a unit struct.
                     let unit_struct_pat = hir::PatKind::Path(qpath);
@@ -1207,6 +1220,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     &se.path,
                     ParamMode::Optional,
                     ImplTraitContext::Disallowed(ImplTraitPosition::Path),
+                    true,
                 );
                 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 4cf0a8e0d2e..134876c2086 100644
--- a/compiler/rustc_ast_lowering/src/item.rs
+++ b/compiler/rustc_ast_lowering/src/item.rs
@@ -308,7 +308,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     &generics,
                     id,
                     ImplTraitContext::Disallowed(ImplTraitPosition::Generic),
-                    |this| this.lower_ty(ty, ImplTraitContext::TypeAliasesOpaqueTy),
+                    |this| this.lower_ty(ty, ImplTraitContext::TypeAliasesOpaqueTy, true),
                 );
                 hir::ItemKind::TyAlias(ty, generics)
             }
@@ -386,11 +386,15 @@ impl<'hir> LoweringContext<'_, 'hir> {
                             this.lower_trait_ref(
                                 trait_ref,
                                 ImplTraitContext::Disallowed(ImplTraitPosition::Trait),
+                                true,
                             )
                         });
 
-                        let lowered_ty = this
-                            .lower_ty(ty, ImplTraitContext::Disallowed(ImplTraitPosition::Type));
+                        let lowered_ty = this.lower_ty(
+                            ty,
+                            ImplTraitContext::Disallowed(ImplTraitPosition::Type),
+                            true,
+                        );
 
                         (trait_ref, lowered_ty)
                     });
@@ -434,6 +438,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                         let bounds = this.lower_param_bounds(
                             bounds,
                             ImplTraitContext::Disallowed(ImplTraitPosition::Bound),
+                            true,
                         );
                         let items = this.arena.alloc_from_iter(
                             items.iter().map(|item| this.lower_trait_item_ref(item)),
@@ -453,6 +458,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                         this.lower_param_bounds(
                             bounds,
                             ImplTraitContext::Disallowed(ImplTraitPosition::Bound),
+                            true,
                         )
                     },
                 );
@@ -475,7 +481,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, ImplTraitContext::Disallowed(ImplTraitPosition::Type), true);
         (ty, self.lower_const_body(span, body))
     }
 
@@ -661,8 +667,11 @@ 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,
+                        ImplTraitContext::Disallowed(ImplTraitPosition::Type),
+                        true,
+                    );
                     hir::ForeignItemKind::Static(ty, m)
                 }
                 ForeignItemKind::TyAlias(..) => hir::ForeignItemKind::Type,
@@ -731,10 +740,11 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 path,
                 ParamMode::ExplicitNamed, // no `'_` in declarations (Issue #61124)
                 ImplTraitContext::Disallowed(ImplTraitPosition::Path),
+                true,
             );
             self.arena.alloc(t)
         } else {
-            self.lower_ty(&f.ty, ImplTraitContext::Disallowed(ImplTraitPosition::Type))
+            self.lower_ty(&f.ty, ImplTraitContext::Disallowed(ImplTraitPosition::Type), true)
         };
         let hir_id = self.lower_node_id(f.id);
         self.lower_attrs(hir_id, &f.attrs);
@@ -757,7 +767,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
         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, ImplTraitContext::Disallowed(ImplTraitPosition::Type), true);
                 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())
             }
@@ -795,12 +806,17 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     ImplTraitContext::Disallowed(ImplTraitPosition::Generic),
                     |this| {
                         let ty = ty.as_ref().map(|x| {
-                            this.lower_ty(x, ImplTraitContext::Disallowed(ImplTraitPosition::Type))
+                            this.lower_ty(
+                                x,
+                                ImplTraitContext::Disallowed(ImplTraitPosition::Type),
+                                true,
+                            )
                         });
                         hir::TraitItemKind::Type(
                             this.lower_param_bounds(
                                 bounds,
                                 ImplTraitContext::Disallowed(ImplTraitPosition::Generic),
+                                true,
                             ),
                             ty,
                         )
@@ -853,7 +869,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
         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, ImplTraitContext::Disallowed(ImplTraitPosition::Type), true);
                 (
                     hir::Generics::empty(),
                     hir::ImplItemKind::Const(ty, self.lower_const_body(i.span, expr.as_deref())),
@@ -887,7 +904,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                             hir::ImplItemKind::TyAlias(ty)
                         }
                         Some(ty) => {
-                            let ty = this.lower_ty(ty, ImplTraitContext::TypeAliasesOpaqueTy);
+                            let ty = this.lower_ty(ty, ImplTraitContext::TypeAliasesOpaqueTy, true);
                             hir::ImplItemKind::TyAlias(ty)
                         }
                     },
@@ -1412,7 +1429,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             return None;
         }
 
-        let bounds = self.lower_param_bounds(bounds, itctx);
+        let bounds = self.lower_param_bounds(bounds, itctx, true);
 
         let ident = self.lower_ident(ident);
         let param_span = ident.span;
@@ -1458,7 +1475,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     panic!("Missing resolution for lifetime {:?} at {:?}", id, ident.span)
                 });
                 let lt_id = self.next_node_id();
-                let lifetime = self.new_named_lifetime_with_res(lt_id, ident_span, ident, res);
+                let lifetime =
+                    self.new_named_lifetime_with_res(lt_id, ident_span, ident, res, true);
                 Some(hir::WherePredicate::RegionPredicate(hir::WhereRegionPredicate {
                     lifetime,
                     span,
@@ -1478,12 +1496,16 @@ 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,
+                    ImplTraitContext::Disallowed(ImplTraitPosition::Type),
+                    true,
+                ),
                 bounds: self.arena.alloc_from_iter(bounds.iter().map(|bound| {
                     self.lower_param_bound(
                         bound,
                         ImplTraitContext::Disallowed(ImplTraitPosition::Bound),
+                        true,
                     )
                 })),
                 span: self.lower_span(span),
@@ -1495,20 +1517,27 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 span,
             }) => hir::WherePredicate::RegionPredicate(hir::WhereRegionPredicate {
                 span: self.lower_span(span),
-                lifetime: self.lower_lifetime(lifetime),
+                lifetime: self.lower_lifetime(lifetime, true),
                 bounds: self.lower_param_bounds(
                     bounds,
                     ImplTraitContext::Disallowed(ImplTraitPosition::Bound),
+                    true,
                 ),
                 in_where_clause: true,
             }),
             WherePredicate::EqPredicate(WhereEqPredicate { id, ref lhs_ty, ref rhs_ty, span }) => {
                 hir::WherePredicate::EqPredicate(hir::WhereEqPredicate {
                     hir_id: self.lower_node_id(id),
-                    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,
+                        ImplTraitContext::Disallowed(ImplTraitPosition::Type),
+                        true,
+                    ),
+                    rhs_ty: self.lower_ty(
+                        rhs_ty,
+                        ImplTraitContext::Disallowed(ImplTraitPosition::Type),
+                        true,
+                    ),
                     span: self.lower_span(span),
                 })
             }
diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs
index 8fb29dcb675..2749af72b68 100644
--- a/compiler/rustc_ast_lowering/src/lib.rs
+++ b/compiler/rustc_ast_lowering/src/lib.rs
@@ -957,7 +957,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         let kind = match constraint.kind {
             AssocConstraintKind::Equality { ref term } => {
                 let term = match term {
-                    Term::Ty(ref ty) => self.lower_ty(ty, itctx).into(),
+                    Term::Ty(ref ty) => self.lower_ty(ty, itctx, true).into(),
                     Term::Const(ref c) => self.lower_anon_const(c).into(),
                 };
                 hir::TypeBindingKind::Equality { term }
@@ -1022,6 +1022,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                                 tokens: None,
                             },
                             itctx,
+                            true,
                         );
 
                         hir::TypeBindingKind::Equality { term: ty.into() }
@@ -1029,7 +1030,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 } else {
                     // Desugar `AssocTy: Bounds` into a type binding where the
                     // later desugars into a trait predicate.
-                    let bounds = self.lower_param_bounds(bounds, itctx);
+                    let bounds = self.lower_param_bounds(bounds, itctx, true);
 
                     hir::TypeBindingKind::Constraint { bounds }
                 }
@@ -1088,7 +1089,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         itctx: ImplTraitContext,
     ) -> hir::GenericArg<'hir> {
         match arg {
-            ast::GenericArg::Lifetime(lt) => GenericArg::Lifetime(self.lower_lifetime(&lt)),
+            ast::GenericArg::Lifetime(lt) => GenericArg::Lifetime(self.lower_lifetime(&lt, true)),
             ast::GenericArg::Type(ty) => {
                 match ty.kind {
                     TyKind::Infer if self.tcx.features().generic_arg_infer => {
@@ -1137,7 +1138,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                     }
                     _ => {}
                 }
-                GenericArg::Type(self.lower_ty_direct(&ty, itctx))
+                GenericArg::Type(self.lower_ty_direct(&ty, itctx, true))
             }
             ast::GenericArg::Const(ct) => GenericArg::Const(ConstArg {
                 value: self.lower_anon_const(&ct),
@@ -1147,8 +1148,8 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
     }
 
     #[instrument(level = "debug", skip(self))]
-    fn lower_ty(&mut self, t: &Ty, itctx: ImplTraitContext) -> &'hir hir::Ty<'hir> {
-        self.arena.alloc(self.lower_ty_direct(t, itctx))
+    fn lower_ty(&mut self, t: &Ty, itctx: ImplTraitContext, captures: bool) -> &'hir hir::Ty<'hir> {
+        self.arena.alloc(self.lower_ty_direct(t, itctx, captures))
     }
 
     fn lower_path_ty(
@@ -1158,6 +1159,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         path: &Path,
         param_mode: ParamMode,
         itctx: ImplTraitContext,
+        captures: bool,
     ) -> hir::Ty<'hir> {
         // 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
@@ -1177,6 +1179,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                         span: t.span
                     },
                     itctx,
+                    captures,
                 );
                 let bounds = this.arena.alloc_from_iter([bound]);
                 let lifetime_bound = this.elided_dyn_bound(t.span);
@@ -1187,7 +1190,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         }
 
         let id = self.lower_node_id(t.id);
-        let qpath = self.lower_qpath(t.id, qself, path, param_mode, itctx);
+        let qpath = self.lower_qpath(t.id, qself, path, param_mode, itctx, true);
         self.ty_path(id, t.span, qpath)
     }
 
@@ -1199,11 +1202,16 @@ 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(
+        &mut self,
+        t: &Ty,
+        itctx: ImplTraitContext,
+        captures: bool,
+    ) -> hir::Ty<'hir> {
         let kind = match t.kind {
             TyKind::Infer => hir::TyKind::Infer,
             TyKind::Err => hir::TyKind::Err,
-            TyKind::Slice(ref ty) => hir::TyKind::Slice(self.lower_ty(ty, itctx)),
+            TyKind::Slice(ref ty) => hir::TyKind::Slice(self.lower_ty(ty, itctx, captures)),
             TyKind::Ptr(ref mt) => hir::TyKind::Ptr(self.lower_mt(mt, itctx)),
             TyKind::Rptr(ref region, ref mt) => {
                 let region = region.unwrap_or_else(|| {
@@ -1218,7 +1226,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                     let span = self.tcx.sess.source_map().next_point(t.span.shrink_to_lo());
                     Lifetime { ident: Ident::new(kw::UnderscoreLifetime, span), id }
                 });
-                let lifetime = self.lower_lifetime(&region);
+                let lifetime = self.lower_lifetime(&region, captures);
                 hir::TyKind::Rptr(lifetime, self.lower_mt(mt, itctx))
             }
             TyKind::BareFn(ref f) => {
@@ -1233,14 +1241,16 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 })
             }
             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))),
-            ),
+            TyKind::Tup(ref tys) => {
+                hir::TyKind::Tup(self.arena.alloc_from_iter(
+                    tys.iter().map(|ty| self.lower_ty_direct(ty, itctx, captures)),
+                ))
+            }
             TyKind::Paren(ref ty) => {
-                return self.lower_ty_direct(ty, itctx);
+                return self.lower_ty_direct(ty, itctx, captures);
             }
             TyKind::Path(ref qself, ref path) => {
-                return self.lower_path_ty(t, qself, path, ParamMode::Explicit, itctx);
+                return self.lower_path_ty(t, qself, path, ParamMode::Explicit, itctx, captures);
             }
             TyKind::ImplicitSelf => {
                 let res = self.expect_full_res(t.id);
@@ -1256,9 +1266,10 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                     }),
                 ))
             }
-            TyKind::Array(ref ty, ref length) => {
-                hir::TyKind::Array(self.lower_ty(ty, itctx), self.lower_array_length(length))
-            }
+            TyKind::Array(ref ty, ref length) => hir::TyKind::Array(
+                self.lower_ty(ty, itctx, captures),
+                self.lower_array_length(length),
+            ),
             TyKind::Typeof(ref expr) => hir::TyKind::Typeof(self.lower_anon_const(expr)),
             TyKind::TraitObject(ref bounds, kind) => {
                 let mut lifetime_bound = None;
@@ -1269,7 +1280,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                                 GenericBound::Trait(
                                     ref ty,
                                     TraitBoundModifier::None | TraitBoundModifier::MaybeConst,
-                                ) => Some(this.lower_poly_trait_ref(ty, itctx)),
+                                ) => Some(this.lower_poly_trait_ref(ty, itctx, captures)),
                                 // `~const ?Bound` will cause an error during AST validation
                                 // anyways, so treat it like `?Bound` as compilation proceeds.
                                 GenericBound::Trait(
@@ -1278,7 +1289,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                                 ) => None,
                                 GenericBound::Outlives(ref lifetime) => {
                                     if lifetime_bound.is_none() {
-                                        lifetime_bound = Some(this.lower_lifetime(lifetime));
+                                        lifetime_bound = Some(this.lower_lifetime(lifetime, true));
                                     }
                                     None
                                 }
@@ -1295,7 +1306,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 match itctx {
                     ImplTraitContext::ReturnPositionOpaqueTy { origin } => self
                         .lower_opaque_impl_trait(span, origin, def_node_id, |this| {
-                            this.lower_param_bounds(bounds, itctx)
+                            this.lower_param_bounds(bounds, itctx, true)
                         }),
                     ImplTraitContext::TypeAliasesOpaqueTy => {
                         let nested_itctx = ImplTraitContext::TypeAliasesOpaqueTy;
@@ -1303,7 +1314,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                             span,
                             hir::OpaqueTyOrigin::TyAlias,
                             def_node_id,
-                            |this| this.lower_param_bounds(bounds, nested_itctx),
+                            |this| this.lower_param_bounds(bounds, nested_itctx, true),
                         )
                     }
                     ImplTraitContext::Universal => {
@@ -1417,7 +1428,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             |(_, (span, _, p_name, res))| {
                 let id = self.next_node_id();
                 let ident = Ident::new(p_name.ident().name, span);
-                let l = self.new_named_lifetime_with_res(id, span, ident, res);
+                let l = self.new_named_lifetime_with_res(id, span, ident, res, true);
                 hir::GenericArg::Lifetime(l)
             },
         ));
@@ -1495,7 +1506,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         }
         let inputs = self.arena.alloc_from_iter(inputs.iter().map(|param| {
             if fn_node_id.is_some() {
-                self.lower_ty_direct(&param.ty, ImplTraitContext::Universal)
+                self.lower_ty_direct(&param.ty, ImplTraitContext::Universal, true)
             } else {
                 self.lower_ty_direct(
                     &param.ty,
@@ -1509,6 +1520,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                         FnDeclKind::Trait => ImplTraitPosition::TraitParam,
                         FnDeclKind::Impl => ImplTraitPosition::ImplParam,
                     }),
+                    true,
                 )
             }
         }));
@@ -1540,7 +1552,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, context, true))
                 }
                 FnRetTy::Default(span) => hir::FnRetTy::DefaultReturn(self.lower_span(span)),
             }
@@ -1746,7 +1758,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             self.arena.alloc_from_iter(captures.into_iter().map(|(_, (span, _, p_name, res))| {
                 let id = self.next_node_id();
                 let ident = Ident::new(p_name.ident().name, span);
-                let l = self.new_named_lifetime_with_res(id, span, ident, res);
+                let l = self.new_named_lifetime_with_res(id, span, ident, res, true);
                 hir::GenericArg::Lifetime(l)
             }));
 
@@ -1776,7 +1788,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 let context = ImplTraitContext::ReturnPositionOpaqueTy {
                     origin: hir::OpaqueTyOrigin::FnReturn(fn_def_id),
                 };
-                self.lower_ty(ty, context)
+                self.lower_ty(ty, context, true)
             }
             FnRetTy::Default(ret_ty_span) => self.arena.alloc(self.ty_tup(*ret_ty_span, &[])),
         };
@@ -1803,23 +1815,24 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         &mut self,
         tpb: &GenericBound,
         itctx: ImplTraitContext,
+        captures: bool,
     ) -> hir::GenericBound<'hir> {
         match tpb {
             GenericBound::Trait(p, modifier) => hir::GenericBound::Trait(
-                self.lower_poly_trait_ref(p, itctx),
+                self.lower_poly_trait_ref(p, itctx, captures),
                 self.lower_trait_bound_modifier(*modifier),
             ),
             GenericBound::Outlives(lifetime) => {
-                hir::GenericBound::Outlives(self.lower_lifetime(lifetime))
+                hir::GenericBound::Outlives(self.lower_lifetime(lifetime, captures))
             }
         }
     }
 
-    fn lower_lifetime(&mut self, l: &Lifetime) -> hir::Lifetime {
+    fn lower_lifetime(&mut self, l: &Lifetime, captures: bool) -> hir::Lifetime {
         let span = self.lower_span(l.ident.span);
         let ident = self.lower_ident(l.ident);
         let res = self.resolver.get_lifetime_res(l.id).unwrap_or(LifetimeRes::Error);
-        self.new_named_lifetime_with_res(l.id, span, ident, res)
+        self.new_named_lifetime_with_res(l.id, span, ident, res, captures)
     }
 
     #[tracing::instrument(level = "debug", skip(self))]
@@ -1829,55 +1842,60 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         span: Span,
         ident: Ident,
         res: LifetimeRes,
+        captures: bool,
     ) -> hir::Lifetime {
         debug!(?self.captured_lifetimes);
         let name = match res {
             LifetimeRes::Param { mut param, binder } => {
                 let p_name = ParamName::Plain(ident);
-                if let Some(mut captured_lifetimes) = self.captured_lifetimes.take() {
-                    if !captured_lifetimes.binders_to_ignore.contains(&binder) {
-                        match captured_lifetimes.captures.entry(param) {
-                            Entry::Occupied(o) => param = self.local_def_id(o.get().1),
-                            Entry::Vacant(v) => {
-                                let p_id = self.next_node_id();
-                                let p_def_id = self.create_def(
-                                    captured_lifetimes.parent_def_id,
-                                    p_id,
-                                    DefPathData::LifetimeNs(p_name.ident().name),
-                                );
-
-                                v.insert((span, p_id, p_name, res));
-                                param = p_def_id;
+                if captures {
+                    if let Some(mut captured_lifetimes) = self.captured_lifetimes.take() {
+                        if !captured_lifetimes.binders_to_ignore.contains(&binder) {
+                            match captured_lifetimes.captures.entry(param) {
+                                Entry::Occupied(o) => param = self.local_def_id(o.get().1),
+                                Entry::Vacant(v) => {
+                                    let p_id = self.next_node_id();
+                                    let p_def_id = self.create_def(
+                                        captured_lifetimes.parent_def_id,
+                                        p_id,
+                                        DefPathData::LifetimeNs(p_name.ident().name),
+                                    );
+
+                                    v.insert((span, p_id, p_name, res));
+                                    param = p_def_id;
+                                }
                             }
                         }
-                    }
 
-                    self.captured_lifetimes = Some(captured_lifetimes);
+                        self.captured_lifetimes = Some(captured_lifetimes);
+                    }
                 }
                 hir::LifetimeName::Param(param, p_name)
             }
             LifetimeRes::Fresh { param, binder } => {
                 debug_assert_eq!(ident.name, kw::UnderscoreLifetime);
                 let mut param = self.local_def_id(param);
-                if let Some(mut captured_lifetimes) = self.captured_lifetimes.take() {
-                    if !captured_lifetimes.binders_to_ignore.contains(&binder) {
-                        match captured_lifetimes.captures.entry(param) {
-                            Entry::Occupied(o) => param = self.local_def_id(o.get().1),
-                            Entry::Vacant(v) => {
-                                let p_id = self.next_node_id();
-                                let p_def_id = self.create_def(
-                                    captured_lifetimes.parent_def_id,
-                                    p_id,
-                                    DefPathData::LifetimeNs(kw::UnderscoreLifetime),
-                                );
-
-                                v.insert((span, p_id, ParamName::Fresh, res));
-                                param = p_def_id;
+                if captures {
+                    if let Some(mut captured_lifetimes) = self.captured_lifetimes.take() {
+                        if !captured_lifetimes.binders_to_ignore.contains(&binder) {
+                            match captured_lifetimes.captures.entry(param) {
+                                Entry::Occupied(o) => param = self.local_def_id(o.get().1),
+                                Entry::Vacant(v) => {
+                                    let p_id = self.next_node_id();
+                                    let p_def_id = self.create_def(
+                                        captured_lifetimes.parent_def_id,
+                                        p_id,
+                                        DefPathData::LifetimeNs(kw::UnderscoreLifetime),
+                                    );
+
+                                    v.insert((span, p_id, ParamName::Fresh, res));
+                                    param = p_def_id;
+                                }
                             }
                         }
-                    }
 
-                    self.captured_lifetimes = Some(captured_lifetimes);
+                        self.captured_lifetimes = Some(captured_lifetimes);
+                    }
                 }
                 hir::LifetimeName::Param(param, ParamName::Fresh)
             }
@@ -1941,7 +1959,11 @@ 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,
+                            ImplTraitContext::Disallowed(ImplTraitPosition::Type),
+                            true,
+                        )
                     }),
                     synthetic: false,
                 };
@@ -1949,7 +1971,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, ImplTraitContext::Disallowed(ImplTraitPosition::Type), true);
                 let default = default.as_ref().map(|def| self.lower_anon_const(def));
                 (
                     hir::ParamName::Plain(self.lower_ident(param.ident)),
@@ -1959,8 +1982,20 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         }
     }
 
-    fn lower_trait_ref(&mut self, p: &TraitRef, itctx: ImplTraitContext) -> hir::TraitRef<'hir> {
-        let path = match self.lower_qpath(p.ref_id, &None, &p.path, ParamMode::Explicit, itctx) {
+    fn lower_trait_ref(
+        &mut self,
+        p: &TraitRef,
+        itctx: ImplTraitContext,
+        captures: bool,
+    ) -> hir::TraitRef<'hir> {
+        let path = match self.lower_qpath(
+            p.ref_id,
+            &None,
+            &p.path,
+            ParamMode::Explicit,
+            itctx,
+            captures,
+        ) {
             hir::QPath::Resolved(None, path) => path,
             qpath => panic!("lower_trait_ref: unexpected QPath `{:?}`", qpath),
         };
@@ -1972,35 +2007,38 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         &mut self,
         p: &PolyTraitRef,
         itctx: ImplTraitContext,
+        captures: bool,
     ) -> hir::PolyTraitRef<'hir> {
         self.with_lifetime_binder(
             p.trait_ref.ref_id,
             &p.bound_generic_params,
             |this, bound_generic_params| {
-                let trait_ref = this.lower_trait_ref(&p.trait_ref, itctx);
+                let trait_ref = this.lower_trait_ref(&p.trait_ref, itctx, captures);
                 hir::PolyTraitRef { bound_generic_params, trait_ref, span: this.lower_span(p.span) }
             },
         )
     }
 
     fn lower_mt(&mut self, mt: &MutTy, itctx: ImplTraitContext) -> hir::MutTy<'hir> {
-        hir::MutTy { ty: self.lower_ty(&mt.ty, itctx), mutbl: mt.mutbl }
+        hir::MutTy { ty: self.lower_ty(&mt.ty, itctx, true), mutbl: mt.mutbl }
     }
 
     fn lower_param_bounds(
         &mut self,
         bounds: &[GenericBound],
         itctx: ImplTraitContext,
+        captures: bool,
     ) -> hir::GenericBounds<'hir> {
-        self.arena.alloc_from_iter(self.lower_param_bounds_mut(bounds, itctx))
+        self.arena.alloc_from_iter(self.lower_param_bounds_mut(bounds, itctx, captures))
     }
 
     fn lower_param_bounds_mut<'s>(
         &'s mut self,
         bounds: &'s [GenericBound],
         itctx: ImplTraitContext,
+        captures: bool,
     ) -> impl Iterator<Item = hir::GenericBound<'hir>> + Captures<'s> + Captures<'a> {
-        bounds.iter().map(move |bound| self.lower_param_bound(bound, itctx))
+        bounds.iter().map(move |bound| self.lower_param_bound(bound, itctx, captures))
     }
 
     fn lower_generic_and_bounds(
diff --git a/compiler/rustc_ast_lowering/src/pat.rs b/compiler/rustc_ast_lowering/src/pat.rs
index bd2e76e5528..b995b1b649d 100644
--- a/compiler/rustc_ast_lowering/src/pat.rs
+++ b/compiler/rustc_ast_lowering/src/pat.rs
@@ -36,6 +36,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                             path,
                             ParamMode::Optional,
                             ImplTraitContext::Disallowed(ImplTraitPosition::Path),
+                            true,
                         );
                         let (pats, ddpos) = self.lower_pat_tuple(pats, "tuple struct");
                         break hir::PatKind::TupleStruct(qpath, pats, ddpos);
@@ -52,6 +53,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                             path,
                             ParamMode::Optional,
                             ImplTraitContext::Disallowed(ImplTraitPosition::Path),
+                            true,
                         );
                         break hir::PatKind::Path(qpath);
                     }
@@ -62,6 +64,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                             path,
                             ParamMode::Optional,
                             ImplTraitContext::Disallowed(ImplTraitPosition::Path),
+                            true,
                         );
 
                         let fs = self.arena.alloc_from_iter(fields.iter().map(|f| hir::PatField {
diff --git a/compiler/rustc_ast_lowering/src/path.rs b/compiler/rustc_ast_lowering/src/path.rs
index 393be3b454c..02e5816593c 100644
--- a/compiler/rustc_ast_lowering/src/path.rs
+++ b/compiler/rustc_ast_lowering/src/path.rs
@@ -24,9 +24,10 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         p: &Path,
         param_mode: ParamMode,
         itctx: ImplTraitContext,
+        captures: bool,
     ) -> hir::QPath<'hir> {
         let qself_position = qself.as_ref().map(|q| q.position);
-        let qself = qself.as_ref().map(|q| self.lower_ty(&q.ty, itctx));
+        let qself = qself.as_ref().map(|q| self.lower_ty(&q.ty, itctx, captures));
 
         let partial_res =
             self.resolver.get_partial_res(id).unwrap_or_else(|| PartialRes::new(Res::Err));
@@ -72,6 +73,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                         param_mode,
                         parenthesized_generic_args,
                         itctx,
+                        captures,
                     )
                 },
             )),
@@ -118,6 +120,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 param_mode,
                 ParenthesizedGenericArgs::Err,
                 itctx,
+                captures,
             ));
             let qpath = hir::QPath::TypeRelative(ty, hir_segment);
 
@@ -158,6 +161,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                     param_mode,
                     ParenthesizedGenericArgs::Err,
                     ImplTraitContext::Disallowed(ImplTraitPosition::Path),
+                    true,
                 )
             })),
             span: self.lower_span(p.span),
@@ -182,6 +186,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         param_mode: ParamMode,
         parenthesized_generic_args: ParenthesizedGenericArgs,
         itctx: ImplTraitContext,
+        captures: bool,
     ) -> hir::PathSegment<'hir> {
         debug!("path_span: {:?}, lower_path_segment(segment: {:?})", path_span, segment,);
         let (mut generic_args, infer_args) = if let Some(ref generic_args) = segment.args {
@@ -254,6 +259,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 segment.id,
                 segment.ident.span,
                 &mut generic_args,
+                captures,
             );
         }
 
@@ -283,6 +289,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         segment_id: NodeId,
         segment_ident_span: Span,
         generic_args: &mut GenericArgsCtor<'hir>,
+        captures: bool,
     ) {
         let (start, end) = match self.resolver.get_lifetime_res(segment_id) {
             Some(LifetimeRes::ElidedAnchor { start, end }) => (start, end),
@@ -311,10 +318,13 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             0,
             (start.as_u32()..end.as_u32()).map(|i| {
                 let id = NodeId::from_u32(i);
-                let l = self.lower_lifetime(&Lifetime {
-                    id,
-                    ident: Ident::new(kw::UnderscoreLifetime, elided_lifetime_span),
-                });
+                let l = self.lower_lifetime(
+                    &Lifetime {
+                        id,
+                        ident: Ident::new(kw::UnderscoreLifetime, elided_lifetime_span),
+                    },
+                    captures,
+                );
                 GenericArg::Lifetime(l)
             }),
         );
@@ -358,12 +368,18 @@ 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,
+                ImplTraitContext::Disallowed(ImplTraitPosition::FnTraitParam),
+                true,
+            )
         }));
         let output_ty = match output {
-            FnRetTy::Ty(ty) => {
-                self.lower_ty(&ty, ImplTraitContext::Disallowed(ImplTraitPosition::FnTraitReturn))
-            }
+            FnRetTy::Ty(ty) => self.lower_ty(
+                &ty,
+                ImplTraitContext::Disallowed(ImplTraitPosition::FnTraitReturn),
+                true,
+            ),
             FnRetTy::Default(_) => self.arena.alloc(self.ty_tup(*span, &[])),
         };
         let args = smallvec![GenericArg::Type(self.ty_tup(*inputs_span, inputs))];