de-duplicate condition scoping logic

Author: dianne

compiler/rustc_ast_lowering/src/expr.rs

@@ -547,15 +547,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
     // Lowers a condition (i.e. `cond` in `if cond` or `while cond`), wrapping it in a terminating scope
     // so that temporaries created in the condition don't live beyond it.
-    fn lower_cond(&mut self, cond: &Expr) -> &'hir hir::Expr<'hir> {
-        fn has_let_expr(expr: &Expr) -> bool {
-            match &expr.kind {
-                ExprKind::Binary(_, lhs, rhs) => has_let_expr(lhs) || has_let_expr(rhs),
-                ExprKind::Let(..) => true,
-                _ => false,
-            }
-        }
-
+    pub(super) fn lower_cond(&mut self, cond: &Expr) -> &'hir hir::Expr<'hir> {
         // We have to take special care for `let` exprs in the condition, e.g. in
         // `if let pat = val` or `if foo && let pat = val`, as we _do_ want `val` to live beyond the
         // condition in this case.
@@ -564,14 +556,10 @@ impl<'hir> LoweringContext<'_, 'hir> {
         // we still wrap them in terminating scopes, e.g. `if foo && let pat = val` essentially
         // gets transformed into `if { let _t = foo; _t } && let pat = val`
         match &cond.kind {
-            ExprKind::Binary(op @ Spanned { node: ast::BinOpKind::And, .. }, lhs, rhs)
-                if has_let_expr(cond) =>
-            {
-                let op = self.lower_binop(*op);
-                let lhs = self.lower_cond(lhs);
-                let rhs = self.lower_cond(rhs);
-
-                self.arena.alloc(self.expr(cond.span, hir::ExprKind::Binary(op, lhs, rhs)))
+            ExprKind::Binary(BinOp { node: BinOpKind::And | BinOpKind::Or, .. }, _, _) => {
+                // Terminating scopes for logical `&&` and `||` are handled in
+                // `rustc_hir_analysis::check::region::resolve_expr`; see the comment there.
+                self.lower_expr(cond)
             }
             ExprKind::Let(..) => self.lower_expr(cond),
             _ => {
@@ -675,7 +663,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
     fn lower_arm(&mut self, arm: &Arm) -> hir::Arm<'hir> {
         let pat = self.lower_pat(&arm.pat);
-        let guard = arm.guard.as_ref().map(|cond| self.lower_expr(cond));
+        let guard = arm.guard.as_ref().map(|cond| self.lower_cond(cond));
         let hir_id = self.next_id();
         let span = self.lower_span(arm.span);
         self.lower_attrs(hir_id, &arm.attrs, arm.span);

compiler/rustc_ast_lowering/src/pat.rs

@@ -134,7 +134,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                         );
                     }
                     PatKind::Guard(inner, cond) => {
-                        break hir::PatKind::Guard(self.lower_pat(inner), self.lower_expr(cond));
+                        break hir::PatKind::Guard(self.lower_pat(inner), self.lower_cond(cond));
                     }
                     PatKind::Slice(pats) => break self.lower_pat_slice(pats),
                     PatKind::Rest => {

compiler/rustc_hir_analysis/src/check/region.rs

@@ -177,22 +177,16 @@ fn resolve_block<'tcx>(
 }
 
 fn resolve_arm<'tcx>(visitor: &mut ScopeResolutionVisitor<'tcx>, arm: &'tcx hir::Arm<'tcx>) {
-    fn has_let_expr(expr: &Expr<'_>) -> bool {
-        match &expr.kind {
-            hir::ExprKind::Binary(_, lhs, rhs) => has_let_expr(lhs) || has_let_expr(rhs),
-            hir::ExprKind::Let(..) => true,
-            _ => false,
-        }
-    }
-
     let prev_cx = visitor.cx;
 
     visitor.enter_node_scope_with_dtor(arm.hir_id.local_id, true);
     visitor.cx.var_parent = visitor.cx.parent;
 
     resolve_pat(visitor, arm.pat);
     if let Some(guard) = arm.guard {
-        resolve_expr(visitor, guard, !has_let_expr(guard));
+        // If the guard should be a terminating scope (i.e. it has no `let` expressions), it will
+        // have been wrapped in a `DropTemps` expression during AST -> HIR lowering.
+        resolve_expr(visitor, guard, false);
     }
     resolve_expr(visitor, arm.body, false);
 

tests/coverage/branch/guard.cov-map

@@ -1,5 +1,5 @@
 Function name: guard::branch_match_guard
-Raw bytes (104): 0x[01, 01, 08, 05, 0d, 09, 05, 05, 0f, 0d, 11, 17, 1b, 01, 05, 1f, 11, 09, 0d, 10, 01, 0c, 01, 00, 26, 01, 01, 05, 00, 0e, 02, 02, 0b, 00, 0c, 06, 01, 14, 02, 0a, 0d, 03, 0e, 00, 0f, 05, 00, 14, 00, 19, 20, 0d, 02, 00, 14, 00, 1e, 0d, 00, 1d, 00, 1e, 0d, 00, 22, 02, 0a, 11, 03, 0e, 00, 0f, 02, 00, 14, 00, 19, 20, 11, 0a, 00, 14, 00, 1e, 11, 00, 1d, 00, 1e, 11, 00, 22, 02, 0a, 12, 03, 0e, 02, 0a, 01, 04, 01, 00, 02]
+Raw bytes (94): 0x[01, 01, 08, 05, 0d, 09, 05, 05, 0f, 0d, 11, 17, 1b, 01, 05, 1f, 11, 09, 0d, 0e, 01, 0c, 01, 00, 26, 01, 01, 05, 00, 0e, 02, 02, 0b, 00, 0c, 06, 01, 14, 02, 0a, 0d, 03, 0e, 00, 0f, 05, 00, 14, 00, 19, 20, 0d, 02, 00, 14, 00, 1e, 0d, 00, 22, 02, 0a, 11, 03, 0e, 00, 0f, 02, 00, 14, 00, 19, 20, 11, 0a, 00, 14, 00, 1e, 11, 00, 22, 02, 0a, 12, 03, 0e, 02, 0a, 01, 04, 01, 00, 02]
 Number of files: 1
 - file 0 => $DIR/guard.rs
 Number of expressions: 8
@@ -11,7 +11,7 @@ Number of expressions: 8
 - expression 5 operands: lhs = Counter(0), rhs = Counter(1)
 - expression 6 operands: lhs = Expression(7, Add), rhs = Counter(4)
 - expression 7 operands: lhs = Counter(2), rhs = Counter(3)
-Number of file 0 mappings: 16
+Number of file 0 mappings: 14
 - Code(Counter(0)) at (prev + 12, 1) to (start + 0, 38)
 - Code(Counter(0)) at (prev + 1, 5) to (start + 0, 14)
 - Code(Expression(0, Sub)) at (prev + 2, 11) to (start + 0, 12)
@@ -23,15 +23,13 @@ Number of file 0 mappings: 16
 - Branch { true: Counter(3), false: Expression(0, Sub) } at (prev + 0, 20) to (start + 0, 30)
     true  = c3
     false = (c1 - c3)
-- Code(Counter(3)) at (prev + 0, 29) to (start + 0, 30)
 - Code(Counter(3)) at (prev + 0, 34) to (start + 2, 10)
 - Code(Counter(4)) at (prev + 3, 14) to (start + 0, 15)
 - Code(Expression(0, Sub)) at (prev + 0, 20) to (start + 0, 25)
     = (c1 - c3)
 - Branch { true: Counter(4), false: Expression(2, Sub) } at (prev + 0, 20) to (start + 0, 30)
     true  = c4
     false = (c1 - (c3 + c4))
-- Code(Counter(4)) at (prev + 0, 29) to (start + 0, 30)
 - Code(Counter(4)) at (prev + 0, 34) to (start + 2, 10)
 - Code(Expression(4, Sub)) at (prev + 3, 14) to (start + 2, 10)
     = ((c0 + c1) - ((c2 + c3) + c4))

tests/coverage/branch/match-arms.cov-map

@@ -1,5 +1,5 @@
 Function name: match_arms::guards
-Raw bytes (158): 0x[01, 01, 08, 15, 05, 19, 09, 1d, 0d, 21, 11, 01, 17, 1b, 11, 1f, 0d, 05, 09, 1a, 01, 30, 01, 00, 23, 01, 01, 05, 00, 0e, 21, 02, 0b, 00, 10, 05, 01, 11, 00, 12, 20, 05, 02, 00, 17, 00, 1b, 05, 00, 1a, 00, 1b, 05, 00, 1f, 00, 26, 05, 00, 27, 00, 28, 09, 01, 11, 00, 12, 20, 09, 06, 00, 17, 00, 1b, 09, 00, 1a, 00, 1b, 09, 00, 1f, 00, 26, 09, 00, 27, 00, 28, 0d, 01, 11, 00, 12, 20, 0d, 0a, 00, 17, 00, 1b, 0d, 00, 1a, 00, 1b, 0d, 00, 1f, 00, 26, 0d, 00, 27, 00, 28, 11, 01, 11, 00, 12, 20, 11, 0e, 00, 17, 00, 1b, 11, 00, 1a, 00, 1b, 11, 00, 1f, 00, 26, 11, 00, 27, 00, 28, 12, 01, 0e, 00, 15, 01, 03, 05, 00, 0c, 01, 01, 01, 00, 02]
+Raw bytes (158): 0x[01, 01, 08, 15, 05, 19, 09, 1d, 0d, 21, 11, 01, 17, 1b, 11, 1f, 0d, 05, 09, 1a, 01, 30, 01, 00, 23, 01, 01, 05, 00, 0e, 21, 02, 0b, 00, 10, 05, 01, 11, 00, 12, 05, 00, 17, 00, 1b, 20, 05, 02, 00, 17, 00, 1b, 05, 00, 1f, 00, 26, 05, 00, 27, 00, 28, 09, 01, 11, 00, 12, 09, 00, 17, 00, 1b, 20, 09, 06, 00, 17, 00, 1b, 09, 00, 1f, 00, 26, 09, 00, 27, 00, 28, 0d, 01, 11, 00, 12, 0d, 00, 17, 00, 1b, 20, 0d, 0a, 00, 17, 00, 1b, 0d, 00, 1f, 00, 26, 0d, 00, 27, 00, 28, 11, 01, 11, 00, 12, 11, 00, 17, 00, 1b, 20, 11, 0e, 00, 17, 00, 1b, 11, 00, 1f, 00, 26, 11, 00, 27, 00, 28, 12, 01, 0e, 00, 15, 01, 03, 05, 00, 0c, 01, 01, 01, 00, 02]
 Number of files: 1
 - file 0 => $DIR/match-arms.rs
 Number of expressions: 8
@@ -16,31 +16,31 @@ Number of file 0 mappings: 26
 - Code(Counter(0)) at (prev + 1, 5) to (start + 0, 14)
 - Code(Counter(8)) at (prev + 2, 11) to (start + 0, 16)
 - Code(Counter(1)) at (prev + 1, 17) to (start + 0, 18)
+- Code(Counter(1)) at (prev + 0, 23) to (start + 0, 27)
 - Branch { true: Counter(1), false: Expression(0, Sub) } at (prev + 0, 23) to (start + 0, 27)
     true  = c1
     false = (c5 - c1)
-- Code(Counter(1)) at (prev + 0, 26) to (start + 0, 27)
 - Code(Counter(1)) at (prev + 0, 31) to (start + 0, 38)
 - Code(Counter(1)) at (prev + 0, 39) to (start + 0, 40)
 - Code(Counter(2)) at (prev + 1, 17) to (start + 0, 18)
+- Code(Counter(2)) at (prev + 0, 23) to (start + 0, 27)
 - Branch { true: Counter(2), false: Expression(1, Sub) } at (prev + 0, 23) to (start + 0, 27)
     true  = c2
     false = (c6 - c2)
-- Code(Counter(2)) at (prev + 0, 26) to (start + 0, 27)
 - Code(Counter(2)) at (prev + 0, 31) to (start + 0, 38)
 - Code(Counter(2)) at (prev + 0, 39) to (start + 0, 40)
 - Code(Counter(3)) at (prev + 1, 17) to (start + 0, 18)
+- Code(Counter(3)) at (prev + 0, 23) to (start + 0, 27)
 - Branch { true: Counter(3), false: Expression(2, Sub) } at (prev + 0, 23) to (start + 0, 27)
     true  = c3
     false = (c7 - c3)
-- Code(Counter(3)) at (prev + 0, 26) to (start + 0, 27)
 - Code(Counter(3)) at (prev + 0, 31) to (start + 0, 38)
 - Code(Counter(3)) at (prev + 0, 39) to (start + 0, 40)
 - Code(Counter(4)) at (prev + 1, 17) to (start + 0, 18)
+- Code(Counter(4)) at (prev + 0, 23) to (start + 0, 27)
 - Branch { true: Counter(4), false: Expression(3, Sub) } at (prev + 0, 23) to (start + 0, 27)
     true  = c4
     false = (c8 - c4)
-- Code(Counter(4)) at (prev + 0, 26) to (start + 0, 27)
 - Code(Counter(4)) at (prev + 0, 31) to (start + 0, 38)
 - Code(Counter(4)) at (prev + 0, 39) to (start + 0, 40)
 - Code(Expression(4, Sub)) at (prev + 1, 14) to (start + 0, 21)