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);