comments about the workings

Author: dingxiangfei2009

compiler/rustc_middle/src/middle/region.rs

@@ -234,6 +234,13 @@ pub struct ScopeTree {
     /// escape into 'static and should have no local cleanup scope.
     rvalue_scopes: FxHashMap<hir::ItemLocalId, Option<Scope>>,
 
+    /// Sometimes destruction scopes are too overarching in the sense that
+    /// all temporaries are dropped while it may be the case that
+    /// only a subset of temporaries is requested to be dropped.
+    /// For instance, `x[y.z()]` indexing operation can discard the temporaries
+    /// generated in evaluating `y.z()`.
+    /// `eager_scopes` is a map from items to a region smaller than a destruction scope
+    /// so that the temporaries do not need to linger unnecessarily.
     eager_scopes: FxHashMap<hir::ItemLocalId, Scope>,
 
     /// If there are any `yield` nested within a scope, this map
@@ -380,6 +387,8 @@ impl ScopeTree {
     pub fn record_eager_scope(&mut self, var: hir::ItemLocalId, proposed_lifetime: Scope) {
         if let Some(destruction) = self.temporary_scope(var) {
             if self.is_subscope_of(destruction, proposed_lifetime) {
+                // If the current temporary scope is already a subset of the proposed region,
+                // it is safe to keep this scope and discard the proposal.
                 return;
             }
         }

compiler/rustc_passes/src/region.rs

@@ -221,6 +221,12 @@ fn mark_local_terminating_scopes<'tcx>(expr: &'tcx hir::Expr<'tcx>) -> FxHashSet
                 Project,
                 Local,
             }
+            // Here we are looking for a chain of access to extract a place reference for
+            // a local variable.
+            // For instance, given `&*(&*x[y]).z().u`, `probe` will pick out
+            // the sub-expressions `&*x[y]` and `y` as expressions making accesses to locals.
+            // The place references generated can be discarded earlier as MIR allows,
+            // and, thus, can be assigned a smaller region.
             loop {
                 match nested_expr.kind {
                     hir::ExprKind::Path(hir::QPath::Resolved(
@@ -268,6 +274,9 @@ fn mark_local_terminating_scopes<'tcx>(expr: &'tcx hir::Expr<'tcx>) -> FxHashSet
                         }
                     }
                     OpTy::Project => {
+                        // The generated MIR produces temporaries for the each of the nested references,
+                        // such as `&x`, `&&x` in `(&&&x).y` for the field access of `y`.
+                        // These temporaries must stay alive even after the field access.
                         ref_level.clear();
                     }
                     OpTy::Local => {
@@ -290,6 +299,8 @@ fn mark_local_terminating_scopes<'tcx>(expr: &'tcx hir::Expr<'tcx>) -> FxHashSet
                 | hir::ExprKind::Field(..)
                 | hir::ExprKind::Index(..)
                 | hir::ExprKind::Path(..) => self.probe(expr),
+
+                // We do not probe into other function bodies or blocks.
                 hir::ExprKind::Block(..)
                 | hir::ExprKind::Closure(..)
                 | hir::ExprKind::ConstBlock(..) => {}
@@ -300,7 +311,6 @@ fn mark_local_terminating_scopes<'tcx>(expr: &'tcx hir::Expr<'tcx>) -> FxHashSet
     let mut locals = Default::default();
     let mut resolution_visitor = LocalAccessResolutionVisitor { locals: &mut locals };
     resolution_visitor.visit_expr(expr);
-    // visitor.terminating_scopes.extend(locals.iter().copied());
     locals
 }