compiler/rustc_ast_lowering/src/block.rs

@@ -1,6 +1,7 @@
 use crate::{ImplTraitContext, ImplTraitPosition, LoweringContext};
 use rustc_ast::{Block, BlockCheckMode, Local, LocalKind, Stmt, StmtKind};
 use rustc_hir as hir;
+use rustc_span::symbol::sym;
 
 use smallvec::SmallVec;
 
@@ -96,8 +97,37 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         };
         let span = self.lower_span(l.span);
         let source = hir::LocalSource::Normal;
-        self.lower_attrs(hir_id, &l.attrs);
-        self.arena.alloc(hir::Local { hir_id, ty, pat, init, els, span, source })
+        let attrs = self.lower_attrs(hir_id, &l.attrs);
+        debug!("lower_local hir_id={hir_id:?} attrs={attrs:?}");
+        let reuse_slot = attrs
+            .map(|attrs| attrs.iter().any(|attr| attr.has_name(sym::rustc_reuse_upvar_slot)))
+            .unwrap_or(false);
+        let reuse_slot = if reuse_slot {
+            if let Some(hir::Expr {
+                kind: hir::ExprKind::Path(hir::QPath::Resolved(
+                    None, hir::Path { res: hir::def::Res::Local(hir_id), .. })), .. }) = init
+            {
+                Some(*hir_id)
+            } else {
+                if init.is_some() {
+                    panic!("init fed to let was not a simple upvar");
+                } else {
+                    panic!("with no init expression I cannot know what slot to use");
+                }
+            }
+        } else {
+            None
+        };
+        /*
+        Some(Expr { hir_id: HirId { owner: OwnerId { def_id: DefId(0:5 ~ example_89213_c[f670]::wait) }, local_id: 8 },
+                        kind: Path(Resolved(None, Path { span: example-89213-c.rs:9:53: 9:61 (#0), res: Local(HirId { owner: OwnerId { def_id: DefId(0:5 ~ example_89213_c[f670]::wait) }, local_id: 2 }), segments: [PathSegment { ident: an_upvar#0, hir_id: HirId { owner: OwnerId { def_id: DefId(0:5 ~ example_89213_c[f670]::wait) }, local_id: 7 }, res: Local(HirId { owner: OwnerId { def_id: DefId(0:5 ~ example_89213_c[f670]::wait) }, local_id: 2 }), args: None, infer_args: true }] })),
+                        span: example-89213-c.rs:9:53: 9:61 (#0) })
+
+         */
+        debug!("lower_local reuse_slot={reuse_slot:?} init={init:?}");
+        let local = self.arena.alloc(hir::Local { hir_id, ty, pat, init, els, reuse_slot, span, source });
+        debug!(?local);
+        local
     }
 
     fn lower_block_check_mode(&mut self, b: &BlockCheckMode) -> hir::BlockCheckMode {

compiler/rustc_ast_lowering/src/lib.rs

@@ -2362,6 +2362,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             init,
             pat,
             els: None,
+            reuse_slot: None,
             source,
             span: self.lower_span(span),
             ty: None,

compiler/rustc_feature/src/builtin_attrs.rs

@@ -741,6 +741,12 @@ pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
         "the `#[rustc_reservation_impl]` attribute is internally used \
          for reserving for `for<T> From<!> for T` impl"
     ),
+    rustc_attr!(
+        rustc_reuse_upvar_slot, Normal,
+        template!(Word), WarnFollowing,
+        "the `#[rustc_reuse_upvar_slot]` attribute is used to experiment with \
+         generator layout strategies"
+    ),
     rustc_attr!(
         rustc_test_marker, Normal, template!(NameValueStr: "name"), WarnFollowing,
         "the `#[rustc_test_marker]` attribute is used internally to track tests",

compiler/rustc_hir/src/hir.rs

@@ -1355,6 +1355,7 @@ pub struct Local<'hir> {
     pub init: Option<&'hir Expr<'hir>>,
     /// Else block for a `let...else` binding.
     pub els: Option<&'hir Block<'hir>>,
+    pub reuse_slot: Option<HirId>,
     pub hir_id: HirId,
     pub span: Span,
     /// Can be `ForLoopDesugar` if the `let` statement is part of a `for` loop
@@ -3598,7 +3599,7 @@ mod size_asserts {
     static_assert_size!(ImplItemKind<'_>, 32);
     static_assert_size!(Item<'_>, 80);
     static_assert_size!(ItemKind<'_>, 48);
-    static_assert_size!(Local<'_>, 64);
+    static_assert_size!(Local<'_>, 72); // FIXME: add separate side-table and bring this back to 64
     static_assert_size!(Param<'_>, 32);
     static_assert_size!(Pat<'_>, 72);
     static_assert_size!(Path<'_>, 40);

compiler/rustc_hir_typeck/src/gather_locals.rs

@@ -22,7 +22,7 @@ pub(super) struct Declaration<'a> {
 
 impl<'a> From<&'a hir::Local<'a>> for Declaration<'a> {
     fn from(local: &'a hir::Local<'a>) -> Self {
-        let hir::Local { hir_id, pat, ty, span, init, els, source: _ } = *local;
+        let hir::Local { hir_id, pat, ty, span, init, els, reuse_slot: _, source: _ } = *local;
         Declaration { hir_id, pat, ty, span, init, els }
     }
 }

compiler/rustc_middle/src/mir/mod.rs

@@ -812,6 +812,8 @@ pub struct LocalDecl<'tcx> {
     /// generator.
     pub internal: bool,
 
+    pub reuse_upvar: Option<Place<'tcx>>,
+
     /// If this local is a temporary and `is_block_tail` is `Some`,
     /// then it is a temporary created for evaluation of some
     /// subexpression of some block's tail expression (with no
@@ -1025,16 +1027,23 @@ impl<'tcx> LocalDecl<'tcx> {
     /// Creates a new `LocalDecl` for a temporary: mutable, non-internal.
     #[inline]
     pub fn new(ty: Ty<'tcx>, span: Span) -> Self {
-        Self::with_source_info(ty, SourceInfo::outermost(span))
+        Self::with_source_info_core(ty, SourceInfo::outermost(span))
     }
 
     /// Like `LocalDecl::new`, but takes a `SourceInfo` instead of a `Span`.
     #[inline]
     pub fn with_source_info(ty: Ty<'tcx>, source_info: SourceInfo) -> Self {
+        Self::with_source_info_core(ty, source_info)
+    }
+
+    /// Like `LocalDecl::new`, but takes a `SourceInfo` instead of a `Span`.
+    #[inline]
+    fn with_source_info_core(ty: Ty<'tcx>, source_info: SourceInfo) -> Self {
         LocalDecl {
             mutability: Mutability::Mut,
             local_info: None,
             internal: false,
+            reuse_upvar: None,
             is_block_tail: None,
             ty,
             user_ty: None,
@@ -3092,7 +3101,7 @@ mod size_asserts {
     use rustc_data_structures::static_assert_size;
     // tidy-alphabetical-start
     static_assert_size!(BasicBlockData<'_>, 144);
-    static_assert_size!(LocalDecl<'_>, 56);
+    static_assert_size!(LocalDecl<'_>, 72); // FIXME: add separate side-table and bring this back to 56
     static_assert_size!(Statement<'_>, 32);
     static_assert_size!(StatementKind<'_>, 16);
     static_assert_size!(Terminator<'_>, 112);

compiler/rustc_middle/src/mir/visit.rs

@@ -811,6 +811,7 @@ macro_rules! make_mir_visitor {
                     user_ty,
                     source_info,
                     internal: _,
+                    reuse_upvar: _,
                     local_info: _,
                     is_block_tail: _,
                 } = local_decl;

compiler/rustc_middle/src/thir.rs

@@ -205,11 +205,22 @@ pub enum StmtKind<'tcx> {
         /// `let pat: ty = <INIT> else { <ELSE> }`
         else_block: Option<BlockId>,
 
+        reuse_upvar_slot: Option<UpvarRef>,
+
         /// The lint level for this `let` statement.
         lint_level: LintLevel,
     },
 }
 
+#[derive(Copy, Clone, Debug, HashStable)]
+pub struct UpvarRef {
+    /// DefId of the closure/generator
+    pub closure_def_id: DefId,
+
+    /// HirId of the root variable
+    pub var_hir_id: LocalVarId,
+}
+
 #[derive(Clone, Debug, Copy, PartialEq, Eq, Hash, HashStable, TyEncodable, TyDecodable)]
 #[derive(TypeFoldable, TypeVisitable)]
 pub struct LocalVarId(pub hir::HirId);
@@ -853,7 +864,7 @@ mod size_asserts {
     static_assert_size!(ExprKind<'_>, 40);
     static_assert_size!(Pat<'_>, 72);
     static_assert_size!(PatKind<'_>, 56);
-    static_assert_size!(Stmt<'_>, 48);
-    static_assert_size!(StmtKind<'_>, 40);
+    static_assert_size!(Stmt<'_>, 64); // FIXME: add separate side-table and bring this back to 48
+    static_assert_size!(StmtKind<'_>, 56); // FIXME: add separate side table and bring this back to 40.
     // tidy-alphabetical-end
 }

compiler/rustc_middle/src/thir/visit.rs

@@ -173,6 +173,7 @@ pub fn walk_stmt<'a, 'tcx: 'a, V: Visitor<'a, 'tcx>>(visitor: &mut V, stmt: &Stm
             remainder_scope: _,
             init_scope: _,
             ref pattern,
+            reuse_upvar_slot: _,
             lint_level: _,
             else_block,
         } => {

compiler/rustc_mir_build/src/build/block.rs

@@ -6,6 +6,7 @@ use rustc_middle::{mir::*, ty};
 use rustc_span::Span;
 
 impl<'a, 'tcx> Builder<'a, 'tcx> {
+    #[instrument(skip(self), level = "debug")]
     pub(crate) fn ast_block(
         &mut self,
         destination: Place<'tcx>,
@@ -115,6 +116,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                     initializer: Some(initializer),
                     lint_level,
                     else_block: Some(else_block),
+                    reuse_upvar_slot: _,
                 } => {
                     // When lowering the statement `let <pat> = <expr> else { <else> };`,
                     // the `<else>` block is nested in the parent scope enclosing this statement.
@@ -232,6 +234,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                                         pattern,
                                         None,
                                         Some((None, initializer_span)),
+                                        None,
                                     );
                                     this.visit_primary_bindings(
                                         pattern,
@@ -278,7 +281,9 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                     initializer,
                     lint_level,
                     else_block: None,
+                    reuse_upvar_slot,
                 } => {
+                    debug!("ast_block_stmts StmtKind::Let pattern: {pattern:?} reuse_upvar_slot: {reuse_upvar_slot:?}");
                     let ignores_expr_result = matches!(pattern.kind, PatKind::Wild);
                     this.block_context.push(BlockFrame::Statement { ignores_expr_result });
 
@@ -309,6 +314,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                                             pattern,
                                             None,
                                             Some((None, initializer_span)),
+                                            *reuse_upvar_slot,
                                         );
                                         this.expr_into_pattern(block, &pattern, init)
                                         // irrefutable pattern
@@ -317,6 +323,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                             )
                         )
                     } else {
+                        assert!(reuse_upvar_slot.is_none());
                         let scope = (*init_scope, source_info);
                         unpack!(this.in_scope(scope, *lint_level, |this| {
                             this.declare_bindings(
@@ -325,6 +332,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                                 pattern,
                                 None,
                                 None,
+                                None,
                             );
                             block.unit()
                         }));

compiler/rustc_mir_build/src/build/expr/into.rs

@@ -108,7 +108,8 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             ExprKind::Let { expr, ref pat } => {
                 let scope = this.local_scope();
                 let (true_block, false_block) = this.in_if_then_scope(scope, expr_span, |this| {
-                    this.lower_let_expr(block, &this.thir[expr], pat, scope, None, expr_span, true)
+                    this.lower_let_expr(
+                        block, &this.thir[expr], pat, scope, None, expr_span, true, None)
                 });
 
                 this.cfg.push_assign_constant(

compiler/rustc_mir_build/src/build/matches/mod.rs

@@ -5,7 +5,7 @@
 //! This also includes code for pattern bindings in `let` statements and
 //! function parameters.
 
-use crate::build::expr::as_place::PlaceBuilder;
+use crate::build::expr::as_place::{PlaceBase, PlaceBuilder};
 use crate::build::scope::DropKind;
 use crate::build::ForGuard::{self, OutsideGuard, RefWithinGuard};
 use crate::build::{BlockAnd, BlockAndExtension, Builder};
@@ -85,6 +85,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 Some(variable_source_info.scope),
                 variable_source_info.span,
                 true,
+                None,
             ),
             _ => {
                 let temp_scope = temp_scope_override.unwrap_or_else(|| this.local_scope());
@@ -354,6 +355,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                         &arm.pattern,
                         arm.guard.as_ref(),
                         opt_scrutinee_place,
+                        None,
                     );
 
                     let arm_block = this.bind_pattern(
@@ -640,6 +642,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         pattern: &Pat<'tcx>,
         guard: Option<&Guard<'tcx>>,
         opt_match_place: Option<(Option<&Place<'tcx>>, Span)>,
+        opt_reuse_upvar_slot: Option<UpvarRef>,
     ) -> Option<SourceScope> {
         self.visit_primary_bindings(
             &pattern,
@@ -663,12 +666,13 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                     ArmHasGuard(guard.is_some()),
                     opt_match_place.map(|(x, y)| (x.cloned(), y)),
                     pattern.span,
+                    opt_reuse_upvar_slot,
                 );
             },
         );
         if let Some(Guard::IfLet(guard_pat, _)) = guard {
             // FIXME: pass a proper `opt_match_place`
-            self.declare_bindings(visibility_scope, scope_span, guard_pat, None, None);
+            self.declare_bindings(visibility_scope, scope_span, guard_pat, None, None, None);
         }
         visibility_scope
     }
@@ -1772,7 +1776,10 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         source_scope: Option<SourceScope>,
         span: Span,
         declare_bindings: bool,
+        // FIXME does this need a potential reuse_var_slot parameter? When is this lowering path used?
+        reuse_upvar_slot: Option<UpvarRef>,
     ) -> BlockAnd<()> {
+        debug!("lower_let_expr expr: {expr:?} pat: {pat:?} reuse_upvar_slot: {reuse_upvar_slot:?}");
         let expr_span = expr.span;
         let expr_place_builder = unpack!(block = self.lower_scrutinee(block, expr, expr_span));
         let wildcard = Pat::wildcard_from_ty(pat.ty);
@@ -1792,7 +1799,14 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         self.break_for_else(otherwise_post_guard_block, else_target, self.source_info(expr_span));
 
         if declare_bindings {
-            self.declare_bindings(source_scope, pat.span.to(span), pat, None, opt_expr_place);
+            self.declare_bindings(
+                source_scope,
+                pat.span.to(span),
+                pat,
+                None,
+                opt_expr_place,
+                reuse_upvar_slot
+            );
         }
 
         let post_guard_block = self.bind_pattern(
@@ -1974,7 +1988,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                     Guard::IfLet(ref pat, scrutinee) => {
                         let s = &this.thir[scrutinee];
                         guard_span = s.span;
-                        this.lower_let_expr(block, s, pat, match_scope, None, arm.span, false)
+                        this.lower_let_expr(block, s, pat, match_scope, None, arm.span, false, None)
                     }
                 });
 
@@ -2204,7 +2218,9 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         has_guard: ArmHasGuard,
         opt_match_place: Option<(Option<Place<'tcx>>, Span)>,
         pat_span: Span,
+        reuse_upvar: Option<UpvarRef>,
     ) {
+        debug!("declare_binding var_id: {var_id:?} var_ty: {var_ty:?} reuse_upvar: {reuse_upvar:?}");
         let tcx = self.tcx;
         let debug_source_info = SourceInfo { span: source_info.span, scope: visibility_scope };
         let binding_mode = match mode {
@@ -2217,6 +2233,10 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             user_ty: if user_ty.is_empty() { None } else { Some(Box::new(user_ty)) },
             source_info,
             internal: false,
+            reuse_upvar: reuse_upvar.map(|thir::UpvarRef { closure_def_id, var_hir_id }| {
+                let closure_def_id = closure_def_id.expect_local();
+                PlaceBuilder::from(PlaceBase::Upvar { var_hir_id, closure_def_id }).to_place(self)
+            }),
             is_block_tail: None,
             local_info: Some(Box::new(LocalInfo::User(ClearCrossCrate::Set(BindingForm::Var(
                 VarBindingForm {
@@ -2246,6 +2266,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 user_ty: None,
                 source_info,
                 internal: false,
+                reuse_upvar: None,
                 is_block_tail: None,
                 local_info: Some(Box::new(LocalInfo::User(ClearCrossCrate::Set(
                     BindingForm::RefForGuard,

compiler/rustc_mir_build/src/build/mod.rs

@@ -926,6 +926,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                         &pat,
                         None,
                         Some((Some(&place), span)),
+                        None,
                     );
                     let place_builder = PlaceBuilder::from(local);
                     unpack!(block = self.place_into_pattern(block, &pat, place_builder, false));

compiler/rustc_mir_build/src/thir/cx/block.rs

@@ -116,6 +116,21 @@ impl<'tcx> Cx<'tcx> {
                                 initializer: local.init.map(|init| self.mirror_expr(init)),
                                 else_block,
                                 lint_level: LintLevel::Explicit(local.hir_id),
+                                reuse_upvar_slot: {
+                                    let tcx = self.tcx;
+                                    let body_owner = self.body_owner;
+                                    local.reuse_slot.map(|hir_id| {
+                                        tcx.upvars_mentioned(body_owner)
+                                            .iter()
+                                            .for_each(|upvars| {
+                                                assert!(upvars.contains_key(&hir_id));
+                                            });
+                                        UpvarRef {
+                                            closure_def_id: self.body_owner,
+                                            var_hir_id: LocalVarId(hir_id),
+                                        }
+                                    })
+                                },
                             },
                             opt_destruction_scope: opt_dxn_ext,
                         };