Add for_stmt

Aaron1011 · Aaron1011 · commit d31dd804d74a · 2021-08-12T19:42:18.000-05:00
diff --git a/compiler/rustc_middle/src/ich/impls_hir.rs b/compiler/rustc_middle/src/ich/impls_hir.rs
@@ -123,6 +123,15 @@ impl<'a> ToStableHashKey<StableHashingContext<'a>> for hir::ItemLocalId {
     }
 }
 
+impl<'a> ToStableHashKey<StableHashingContext<'a>> for (hir::ItemLocalId, bool) {
+    type KeyType = (hir::ItemLocalId, bool);
+
+    #[inline]
+    fn to_stable_hash_key(&self, _: &StableHashingContext<'a>) -> (hir::ItemLocalId, bool) {
+        *self
+    }
+}
+
 impl<'a> HashStable<StableHashingContext<'a>> for hir::Body<'_> {
     fn hash_stable(&self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher) {
         let hir::Body { params, value, generator_kind } = self;
diff --git a/compiler/rustc_middle/src/middle/region.rs b/compiler/rustc_middle/src/middle/region.rs
@@ -84,21 +84,23 @@ use std::fmt;
 #[derive(HashStable)]
 pub struct Scope {
     pub id: hir::ItemLocalId,
+    pub for_stmt: bool,
     pub data: ScopeData,
 }
 
 impl fmt::Debug for Scope {
     fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self.data {
-            ScopeData::Node => write!(fmt, "Node({:?})", self.id),
-            ScopeData::CallSite => write!(fmt, "CallSite({:?})", self.id),
-            ScopeData::Arguments => write!(fmt, "Arguments({:?})", self.id),
-            ScopeData::Destruction => write!(fmt, "Destruction({:?})", self.id),
+            ScopeData::Node => write!(fmt, "Node({:?}, {:?})", self.id, self.for_stmt),
+            ScopeData::CallSite => write!(fmt, "CallSite({:?}. {:?})", self.id, self.for_stmt),
+            ScopeData::Arguments => write!(fmt, "Arguments({:?}, {:?})", self.id, self.for_stmt),
+            ScopeData::Destruction => write!(fmt, "Destruction({:?}, {:?})", self.id, self.for_stmt),
             ScopeData::Remainder(fsi) => write!(
                 fmt,
-                "Remainder {{ block: {:?}, first_statement_index: {}}}",
+                "Remainder {{ block: {:?}, first_statement_index: {}, for_stmt: {:?}}}",
                 self.id,
                 fsi.as_u32(),
+                self.for_stmt,
             ),
         }
     }
@@ -223,7 +225,7 @@ pub struct ScopeTree {
     var_map: FxHashMap<hir::ItemLocalId, Scope>,
 
     /// Maps from a `NodeId` to the associated destruction scope (if any).
-    destruction_scopes: FxHashMap<hir::ItemLocalId, Scope>,
+    destruction_scopes: FxHashMap<(hir::ItemLocalId, bool), Scope>,
 
     /// `rvalue_scopes` includes entries for those expressions whose
     /// cleanup scope is larger than the default. The map goes from the
@@ -331,17 +333,17 @@ impl ScopeTree {
 
         if let Some(p) = parent {
             let prev = self.parent_map.insert(child, p);
-            assert!(prev.is_none());
+            assert!(prev.is_none(), "Scope {:?} with parent {:?} has prev {:?}", child, p, prev);
         }
 
         // Record the destruction scopes for later so we can query them.
         if let ScopeData::Destruction = child.data {
-            self.destruction_scopes.insert(child.item_local_id(), child);
+            assert_eq!(self.destruction_scopes.insert((child.item_local_id(), child.for_stmt), child), None);
         }
     }
 
-    pub fn opt_destruction_scope(&self, n: hir::ItemLocalId) -> Option<Scope> {
-        self.destruction_scopes.get(&n).cloned()
+    pub fn opt_destruction_scope(&self, n: hir::ItemLocalId, for_stmt: bool) -> Option<Scope> {
+        self.destruction_scopes.get(&(n, for_stmt)).cloned()
     }
 
     pub fn record_var_scope(&mut self, var: hir::ItemLocalId, lifetime: Scope) {
@@ -372,7 +374,7 @@ impl ScopeTree {
     }
 
     /// Returns the scope when the temp created by `expr_id` will be cleaned up.
-    pub fn temporary_scope(&self, expr_id: hir::ItemLocalId) -> Option<Scope> {
+    pub fn temporary_scope(&self, expr_id: hir::ItemLocalId, for_stmt: bool) -> Option<Scope> {
         // Check for a designated rvalue scope.
         if let Some(&s) = self.rvalue_scopes.get(&expr_id) {
             debug!("temporary_scope({:?}) = {:?} [custom]", expr_id, s);
@@ -383,7 +385,7 @@ impl ScopeTree {
         // if there's one. Static items, for instance, won't
         // have an enclosing scope, hence no scope will be
         // returned.
-        let mut id = Scope { id: expr_id, data: ScopeData::Node };
+        let mut id = Scope { id: expr_id, data: ScopeData::Node, for_stmt };
 
         while let Some(&(p, _)) = self.parent_map.get(&id) {
             match p.data {
diff --git a/compiler/rustc_middle/src/thir.rs b/compiler/rustc_middle/src/thir.rs
@@ -189,7 +189,7 @@ pub enum StmtKind<'tcx> {
 
 // `Expr` is used a lot. Make sure it doesn't unintentionally get bigger.
 #[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))]
-rustc_data_structures::static_assert_size!(Expr<'_>, 104);
+rustc_data_structures::static_assert_size!(Expr<'_>, 112);
 
 /// A THIR expression.
 #[derive(Debug, HashStable)]
diff --git a/compiler/rustc_mir_build/src/build/mod.rs b/compiler/rustc_mir_build/src/build/mod.rs
@@ -625,9 +625,9 @@ where
     );
 
     let call_site_scope =
-        region::Scope { id: body.value.hir_id.local_id, data: region::ScopeData::CallSite };
+        region::Scope { id: body.value.hir_id.local_id, data: region::ScopeData::CallSite, for_stmt: false };
     let arg_scope =
-        region::Scope { id: body.value.hir_id.local_id, data: region::ScopeData::Arguments };
+        region::Scope { id: body.value.hir_id.local_id, data: region::ScopeData::Arguments, for_stmt: false };
     let source_info = builder.source_info(span);
     let call_site_s = (call_site_scope, source_info);
     unpack!(builder.in_scope(call_site_s, LintLevel::Inherited, |builder| {
diff --git a/compiler/rustc_mir_build/src/thir/cx/block.rs b/compiler/rustc_mir_build/src/thir/cx/block.rs
@@ -13,12 +13,13 @@ impl<'tcx> Cx<'tcx> {
         // in order to get the lexical scoping correctly.
         let stmts = self.mirror_stmts(block.hir_id.local_id, block.stmts);
         let opt_destruction_scope =
-            self.region_scope_tree.opt_destruction_scope(block.hir_id.local_id);
+            self.region_scope_tree.opt_destruction_scope(block.hir_id.local_id, false);
         Block {
             targeted_by_break: block.targeted_by_break,
             region_scope: region::Scope {
                 id: block.hir_id.local_id,
                 data: region::ScopeData::Node,
+                for_stmt: false,
             },
             opt_destruction_scope,
             span: block.span,
@@ -46,14 +47,15 @@ impl<'tcx> Cx<'tcx> {
             .enumerate()
             .filter_map(|(index, stmt)| {
                 let hir_id = stmt.kind.hir_id();
-                let opt_dxn_ext = self.region_scope_tree.opt_destruction_scope(hir_id.local_id);
+                let opt_dxn_ext = self.region_scope_tree.opt_destruction_scope(hir_id.local_id, true);
                 match stmt.kind {
                     hir::StmtKind::Expr(ref expr) | hir::StmtKind::Semi(ref expr) => {
                         let stmt = Stmt {
                             kind: StmtKind::Expr {
                                 scope: region::Scope {
                                     id: hir_id.local_id,
                                     data: region::ScopeData::Node,
+                                    for_stmt: true,
                                 },
                                 expr: self.mirror_expr(expr),
                             },
@@ -71,6 +73,7 @@ impl<'tcx> Cx<'tcx> {
                             data: region::ScopeData::Remainder(region::FirstStatementIndex::new(
                                 index,
                             )),
+                            for_stmt: false,
                         };
 
                         let mut pattern = self.pattern_from_hir(local.pat);
@@ -101,6 +104,7 @@ impl<'tcx> Cx<'tcx> {
                                 init_scope: region::Scope {
                                     id: hir_id.local_id,
                                     data: region::ScopeData::Node,
+                                    for_stmt: true,
                                 },
                                 pattern,
                                 initializer: local.init.map(|init| self.mirror_expr(init)),
diff --git a/compiler/rustc_mir_build/src/thir/cx/expr.rs b/compiler/rustc_mir_build/src/thir/cx/expr.rs
@@ -31,9 +31,9 @@ impl<'tcx> Cx<'tcx> {
     }
 
     pub(super) fn mirror_expr_inner(&mut self, hir_expr: &'tcx hir::Expr<'tcx>) -> ExprId {
-        let temp_lifetime = self.region_scope_tree.temporary_scope(hir_expr.hir_id.local_id);
+        let temp_lifetime = self.region_scope_tree.temporary_scope(hir_expr.hir_id.local_id, false);
         let expr_scope =
-            region::Scope { id: hir_expr.hir_id.local_id, data: region::ScopeData::Node };
+            region::Scope { id: hir_expr.hir_id.local_id, data: region::ScopeData::Node, for_stmt: false };
 
         debug!("Expr::make_mirror(): id={}, span={:?}", hir_expr.hir_id, hir_expr.span);
 
@@ -59,7 +59,7 @@ impl<'tcx> Cx<'tcx> {
 
         // Finally, create a destruction scope, if any.
         if let Some(region_scope) =
-            self.region_scope_tree.opt_destruction_scope(hir_expr.hir_id.local_id)
+            self.region_scope_tree.opt_destruction_scope(hir_expr.hir_id.local_id, false)
         {
             expr = Expr {
                 temp_lifetime,
@@ -150,7 +150,7 @@ impl<'tcx> Cx<'tcx> {
 
     fn make_mirror_unadjusted(&mut self, expr: &'tcx hir::Expr<'tcx>) -> Expr<'tcx> {
         let expr_ty = self.typeck_results().expr_ty(expr);
-        let temp_lifetime = self.region_scope_tree.temporary_scope(expr.hir_id.local_id);
+        let temp_lifetime = self.region_scope_tree.temporary_scope(expr.hir_id.local_id, false);
 
         let kind = match expr.kind {
             // Here comes the interesting stuff:
@@ -499,7 +499,7 @@ impl<'tcx> Cx<'tcx> {
                                     ),
                                 };
                                 let temp_lifetime =
-                                    self.region_scope_tree.temporary_scope(expr.hir_id.local_id);
+                                    self.region_scope_tree.temporary_scope(expr.hir_id.local_id, false);
                                 let res = self.typeck_results().qpath_res(qpath, expr.hir_id);
                                 let ty;
                                 match res {
@@ -579,14 +579,14 @@ impl<'tcx> Cx<'tcx> {
             }
             hir::ExprKind::Break(dest, ref value) => match dest.target_id {
                 Ok(target_id) => ExprKind::Break {
-                    label: region::Scope { id: target_id.local_id, data: region::ScopeData::Node },
+                    label: region::Scope { id: target_id.local_id, data: region::ScopeData::Node, for_stmt: false, },
                     value: value.as_ref().map(|value| self.mirror_expr(value)),
                 },
                 Err(err) => bug!("invalid loop id for break: {}", err),
             },
             hir::ExprKind::Continue(dest) => match dest.target_id {
                 Ok(loop_id) => ExprKind::Continue {
-                    label: region::Scope { id: loop_id.local_id, data: region::ScopeData::Node },
+                    label: region::Scope { id: loop_id.local_id, data: region::ScopeData::Node, for_stmt: false, },
                 },
                 Err(err) => bug!("invalid loop id for continue: {}", err),
             },
@@ -601,7 +601,7 @@ impl<'tcx> Cx<'tcx> {
             },
             hir::ExprKind::Loop(ref body, ..) => {
                 let block_ty = self.typeck_results().node_type(body.hir_id);
-                let temp_lifetime = self.region_scope_tree.temporary_scope(body.hir_id.local_id);
+                let temp_lifetime = self.region_scope_tree.temporary_scope(body.hir_id.local_id, false);
                 let block = self.mirror_block(body);
                 let body = self.thir.exprs.push(Expr {
                     ty: block_ty,
@@ -800,7 +800,7 @@ impl<'tcx> Cx<'tcx> {
         span: Span,
         overloaded_callee: Option<(DefId, SubstsRef<'tcx>)>,
     ) -> Expr<'tcx> {
-        let temp_lifetime = self.region_scope_tree.temporary_scope(expr.hir_id.local_id);
+        let temp_lifetime = self.region_scope_tree.temporary_scope(expr.hir_id.local_id, false);
         let (def_id, substs, user_ty) = match overloaded_callee {
             Some((def_id, substs)) => (def_id, substs, None),
             None => {
@@ -837,7 +837,7 @@ impl<'tcx> Cx<'tcx> {
             }),
             body: self.mirror_expr(arm.body),
             lint_level: LintLevel::Explicit(arm.hir_id),
-            scope: region::Scope { id: arm.hir_id.local_id, data: region::ScopeData::Node },
+            scope: region::Scope { id: arm.hir_id.local_id, data: region::ScopeData::Node, for_stmt: false },
             span: arm.span,
         };
         self.thir.arms.push(arm)
@@ -922,7 +922,7 @@ impl<'tcx> Cx<'tcx> {
             // a constant reference (or constant raw pointer for `static mut`) in MIR
             Res::Def(DefKind::Static, id) => {
                 let ty = self.tcx.static_ptr_ty(id);
-                let temp_lifetime = self.region_scope_tree.temporary_scope(expr.hir_id.local_id);
+                let temp_lifetime = self.region_scope_tree.temporary_scope(expr.hir_id.local_id, false);
                 let kind = if self.tcx.is_thread_local_static(id) {
                     ExprKind::ThreadLocalRef(id)
                 } else {
@@ -1006,7 +1006,7 @@ impl<'tcx> Cx<'tcx> {
 
         // construct the complete expression `foo()` for the overloaded call,
         // which will yield the &T type
-        let temp_lifetime = self.region_scope_tree.temporary_scope(expr.hir_id.local_id);
+        let temp_lifetime = self.region_scope_tree.temporary_scope(expr.hir_id.local_id, false);
         let fun = self.method_callee(expr, span, overloaded_callee);
         let fun = self.thir.exprs.push(fun);
         let fun_ty = self.thir[fun].ty;
@@ -1026,7 +1026,7 @@ impl<'tcx> Cx<'tcx> {
         closure_expr: &'tcx hir::Expr<'tcx>,
         place: HirPlace<'tcx>,
     ) -> Expr<'tcx> {
-        let temp_lifetime = self.region_scope_tree.temporary_scope(closure_expr.hir_id.local_id);
+        let temp_lifetime = self.region_scope_tree.temporary_scope(closure_expr.hir_id.local_id, false);
         let var_ty = place.base_ty;
 
         // The result of capture analysis in `rustc_typeck/check/upvar.rs`represents a captured path
@@ -1081,7 +1081,7 @@ impl<'tcx> Cx<'tcx> {
         let upvar_capture = captured_place.info.capture_kind;
         let captured_place_expr =
             self.convert_captured_hir_place(closure_expr, captured_place.place.clone());
-        let temp_lifetime = self.region_scope_tree.temporary_scope(closure_expr.hir_id.local_id);
+        let temp_lifetime = self.region_scope_tree.temporary_scope(closure_expr.hir_id.local_id, false);
 
         match upvar_capture {
             ty::UpvarCapture::ByValue(_) => captured_place_expr,
diff --git a/compiler/rustc_passes/src/region.rs b/compiler/rustc_passes/src/region.rs
diff --git a/compiler/rustc_typeck/src/check/generator_interior.rs b/compiler/rustc_typeck/src/check/generator_interior.rs
