Rebased work from rust-lang#68577

Author: voidc

compiler/rustc_ast_lowering/src/expr.rs

@@ -85,7 +85,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     hir::ExprKind::AddrOf(k, m, ohs)
                 }
                 ExprKind::Let(ref pat, ref scrutinee) => {
-                    self.lower_expr_let(e.span, pat, scrutinee)
+                    hir::ExprKind::Let(self.lower_pat(pat), self.lower_expr(scrutinee))
                 }
                 ExprKind::If(ref cond, ref then, ref else_opt) => {
                     self.lower_expr_if(e.span, cond, then, else_opt.as_deref())
@@ -268,51 +268,36 @@ impl<'hir> LoweringContext<'_, 'hir> {
         }
     }
 
-    /// Emit an error and lower `ast::ExprKind::Let(pat, scrutinee)` into:
-    /// ```rust
-    /// match scrutinee { pats => true, _ => false }
-    /// ```
-    fn lower_expr_let(&mut self, span: Span, pat: &Pat, scrutinee: &Expr) -> hir::ExprKind<'hir> {
-        // If we got here, the `let` expression is not allowed.
-
-        if self.sess.opts.unstable_features.is_nightly_build() {
-            self.sess
-                .struct_span_err(span, "`let` expressions are not supported here")
-                .note("only supported directly in conditions of `if`- and `while`-expressions")
-                .note("as well as when nested within `&&` and parenthesis in those conditions")
-                .emit();
-        } else {
-            self.sess
-                .struct_span_err(span, "expected expression, found statement (`let`)")
-                .note("variable declaration using `let` is a statement")
-                .emit();
+    /// Lower the condition of an `if` or `while` expression.
+    /// This entails some special handling of immediate `let` expressions as conditions.
+    /// Namely, if the given `cond` is not a `let` expression then it is wrapped in `drop-temps`.
+    fn lower_expr_cond(&mut self, cond: &Expr) -> &'hir hir::Expr<'hir> {
+        // Lower the `cond` expression.
+        let cond = self.lower_expr(cond);
+        // Normally, the `cond` of `if cond` will drop temporaries before evaluating the blocks.
+        // This is achieved by using `drop-temps { cond }`, equivalent to `{ let _t = $cond; _t }`.
+        // However, for backwards compatibility reasons, `if let pat = scrutinee`, like `match`
+        // does not drop the temporaries of `scrutinee` before evaluating the blocks.
+        match cond.kind {
+            hir::ExprKind::Let(..) => cond,
+            _ => {
+                let reason = DesugaringKind::CondTemporary;
+                let span = self.mark_span_with_reason(reason, cond.span, None);
+                self.expr_drop_temps(span, cond, ThinVec::new())
+            }
         }
+    }
 
-        // For better recovery, we emit:
-        // ```
-        // match scrutinee { pat => true, _ => false }
-        // ```
-        // While this doesn't fully match the user's intent, it has key advantages:
-        // 1. We can avoid using `abort_if_errors`.
-        // 2. We can typeck both `pat` and `scrutinee`.
-        // 3. `pat` is allowed to be refutable.
-        // 4. The return type of the block is `bool` which seems like what the user wanted.
-        let scrutinee = self.lower_expr(scrutinee);
-        let then_arm = {
-            let pat = self.lower_pat(pat);
-            let expr = self.expr_bool(span, true);
-            self.arm(pat, expr)
-        };
-        let else_arm = {
-            let pat = self.pat_wild(span);
-            let expr = self.expr_bool(span, false);
-            self.arm(pat, expr)
-        };
-        hir::ExprKind::Match(
-            scrutinee,
-            arena_vec![self; then_arm, else_arm],
-            hir::MatchSource::Normal,
-        )
+    /// Lower `then` into `true => then`.
+    fn lower_then_arm(&mut self, span: Span, then: &Block) -> hir::Arm<'hir> {
+        let then_expr = self.lower_block_expr(then);
+        let then_pat = self.pat_bool(span, true);
+        self.arm(then_pat, self.arena.alloc(then_expr))
+    }
+
+    fn lower_else_arm(&mut self, span: Span, else_expr: &'hir hir::Expr<'hir>) -> hir::Arm<'hir> {
+        let else_pat = self.pat_wild(span);
+        self.arm(else_pat, else_expr)
     }
 
     fn lower_expr_if(
@@ -322,112 +307,53 @@ impl<'hir> LoweringContext<'_, 'hir> {
         then: &Block,
         else_opt: Option<&Expr>,
     ) -> hir::ExprKind<'hir> {
-        // FIXME(#53667): handle lowering of && and parens.
-
-        // `_ => else_block` where `else_block` is `{}` if there's `None`:
-        let else_pat = self.pat_wild(span);
-        let (else_expr, contains_else_clause) = match else_opt {
-            None => (self.expr_block_empty(span), false),
-            Some(els) => (self.lower_expr(els), true),
+        let scrutinee = self.lower_expr_cond(cond);
+        let then_arm = self.lower_then_arm(span, then);
+        let else_expr = match else_opt {
+            None => self.expr_block_empty(span), // Use `{}` if there's no `else` block.
+            Some(els) => self.lower_expr(els),
         };
-        let else_arm = self.arm(else_pat, else_expr);
-
-        // Handle then + scrutinee:
-        let then_expr = self.lower_block_expr(then);
-        let (then_pat, scrutinee, desugar) = match cond.kind {
-            // `<pat> => <then>`:
-            ExprKind::Let(ref pat, ref scrutinee) => {
-                let scrutinee = self.lower_expr(scrutinee);
-                let pat = self.lower_pat(pat);
-                (pat, scrutinee, hir::MatchSource::IfLetDesugar { contains_else_clause })
-            }
-            // `true => <then>`:
-            _ => {
-                // Lower condition:
-                let cond = self.lower_expr(cond);
-                let span_block =
-                    self.mark_span_with_reason(DesugaringKind::CondTemporary, cond.span, None);
-                // Wrap in a construct equivalent to `{ let _t = $cond; _t }`
-                // to preserve drop semantics since `if cond { ... }` does not
-                // let temporaries live outside of `cond`.
-                let cond = self.expr_drop_temps(span_block, cond, ThinVec::new());
-                let pat = self.pat_bool(span, true);
-                (pat, cond, hir::MatchSource::IfDesugar { contains_else_clause })
-            }
-        };
-        let then_arm = self.arm(then_pat, self.arena.alloc(then_expr));
-
+        let else_arm = self.lower_else_arm(span, else_expr);
+        let desugar = hir::MatchSource::IfDesugar { contains_else_clause: else_opt.is_some() };
         hir::ExprKind::Match(scrutinee, arena_vec![self; then_arm, else_arm], desugar)
     }
 
+    /// We desugar: `'label: while $cond $body` into:
+    ///
+    /// ```
+    /// 'label: loop {
+    ///     match $cond {
+    ///         true => $body,
+    ///         _ => break,
+    ///     }
+    /// }
+    /// ```
+    ///
+    /// where `$cond` is wrapped in `drop-temps { $cond }` if it isn't a `Let` expression.
     fn lower_expr_while_in_loop_scope(
         &mut self,
         span: Span,
         cond: &Expr,
         body: &Block,
         opt_label: Option<Label>,
     ) -> hir::ExprKind<'hir> {
-        // FIXME(#53667): handle lowering of && and parens.
-
         // Note that the block AND the condition are evaluated in the loop scope.
         // This is done to allow `break` from inside the condition of the loop.
 
+        // Lower the condition:
+        let scrutinee = self.with_loop_condition_scope(|t| t.lower_expr_cond(cond));
+        // `true => body`:
+        let then_arm = self.lower_then_arm(span, body);
         // `_ => break`:
-        let else_arm = {
-            let else_pat = self.pat_wild(span);
-            let else_expr = self.expr_break(span, ThinVec::new());
-            self.arm(else_pat, else_expr)
-        };
-
-        // Handle then + scrutinee:
-        let then_expr = self.lower_block_expr(body);
-        let (then_pat, scrutinee, desugar, source) = match cond.kind {
-            ExprKind::Let(ref pat, ref scrutinee) => {
-                // to:
-                //
-                //   [opt_ident]: loop {
-                //     match <sub_expr> {
-                //       <pat> => <body>,
-                //       _ => break
-                //     }
-                //   }
-                let scrutinee = self.with_loop_condition_scope(|t| t.lower_expr(scrutinee));
-                let pat = self.lower_pat(pat);
-                (pat, scrutinee, hir::MatchSource::WhileLetDesugar, hir::LoopSource::WhileLet)
-            }
-            _ => {
-                // We desugar: `'label: while $cond $body` into:
-                //
-                // ```
-                // 'label: loop {
-                //     match drop-temps { $cond } {
-                //         true => $body,
-                //         _ => break,
-                //     }
-                // }
-                // ```
-
-                // Lower condition:
-                let cond = self.with_loop_condition_scope(|this| this.lower_expr(cond));
-                let span_block =
-                    self.mark_span_with_reason(DesugaringKind::CondTemporary, cond.span, None);
-                // Wrap in a construct equivalent to `{ let _t = $cond; _t }`
-                // to preserve drop semantics since `while cond { ... }` does not
-                // let temporaries live outside of `cond`.
-                let cond = self.expr_drop_temps(span_block, cond, ThinVec::new());
-                // `true => <then>`:
-                let pat = self.pat_bool(span, true);
-                (pat, cond, hir::MatchSource::WhileDesugar, hir::LoopSource::While)
-            }
-        };
-        let then_arm = self.arm(then_pat, self.arena.alloc(then_expr));
-
+        let else_expr = self.expr_break(span, ThinVec::new());
+        let else_arm = self.lower_else_arm(span, else_expr);
         // `match <scrutinee> { ... }`
-        let match_expr =
-            self.expr_match(span, scrutinee, arena_vec![self; then_arm, else_arm], desugar);
-
+        let match_arms = arena_vec![self; then_arm, else_arm];
+        let match_desugar = hir::MatchSource::WhileDesugar;
+        let match_expr = self.expr_match(span, scrutinee, match_arms, match_desugar);
         // `[opt_ident]: loop { ... }`
-        hir::ExprKind::Loop(self.block_expr(self.arena.alloc(match_expr)), opt_label, source)
+        let loop_block = self.block_expr(self.arena.alloc(match_expr));
+        hir::ExprKind::Loop(loop_block, opt_label, hir::LoopSource::While)
     }
 
     /// Desugar `try { <stmts>; <expr> }` into `{ <stmts>; ::std::ops::Try::from_ok(<expr>) }`,

compiler/rustc_ast_passes/src/ast_validation.rs

@@ -80,6 +80,9 @@ struct AstValidator<'a> {
     /// certain positions.
     is_assoc_ty_bound_banned: bool,
 
+    /// Used to allow `let` expressions in certain syntactic locations.
+    is_let_allowed: bool,
+
     lint_buffer: &'a mut LintBuffer,
 }
 
@@ -118,6 +121,27 @@ impl<'a> AstValidator<'a> {
         self.bound_context = old;
     }
 
+    fn with_let_allowed(&mut self, allowed: bool, f: impl FnOnce(&mut Self, bool)) {
+        let old = mem::replace(&mut self.is_let_allowed, allowed);
+        f(self, old);
+        self.is_let_allowed = old;
+    }
+
+    /// Emits an error banning the `let` expression provided in the given location.
+    fn ban_let_expr(&self, expr: &'a Expr) {
+        let sess = &self.session;
+        if sess.opts.unstable_features.is_nightly_build() {
+            sess.struct_span_err(expr.span, "`let` expressions are not supported here")
+                .note("only supported directly in conditions of `if`- and `while`-expressions")
+                .note("as well as when nested within `&&` and parenthesis in those conditions")
+                .emit();
+        } else {
+            sess.struct_span_err(expr.span, "expected expression, found statement (`let`)")
+                .note("variable declaration using `let` is a statement")
+                .emit();
+        }
+    }
+
     fn visit_assoc_ty_constraint_from_generic_args(&mut self, constraint: &'a AssocTyConstraint) {
         match constraint.kind {
             AssocTyConstraintKind::Equality { .. } => {}
@@ -795,20 +819,43 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
     }
 
     fn visit_expr(&mut self, expr: &'a Expr) {
-        match &expr.kind {
-            ExprKind::LlvmInlineAsm(..) if !self.session.target.allow_asm => {
-                struct_span_err!(
-                    self.session,
-                    expr.span,
-                    E0472,
-                    "llvm_asm! is unsupported on this target"
-                )
-                .emit();
+        self.with_let_allowed(false, |this, let_allowed| {
+            match &expr.kind {
+                ExprKind::LlvmInlineAsm(..) if !this.session.target.allow_asm => {
+                    struct_span_err!(
+                        this.session,
+                        expr.span,
+                        E0472,
+                        "llvm_asm! is unsupported on this target"
+                    )
+                    .emit();
+                }
+                ExprKind::Let(..) if !let_allowed => this.ban_let_expr(expr),
+                // `(e)` or `e && e` does not impose additional constraints on `e`.
+                ExprKind::Paren(_) | ExprKind::Binary(BinOp { node: BinOpKind::And, .. }, ..) => {
+                    this.with_let_allowed(let_allowed, |this, _| visit::walk_expr(this, expr));
+                    return; // We've already walked into `expr`.
+                }
+                // However, we do allow it in the condition of the `if` expression.
+                // We do not allow `let` in `then` and `opt_else` directly.
+                ExprKind::If(cond, then, opt_else) => {
+                    this.visit_block(then);
+                    walk_list!(this, visit_expr, opt_else);
+                    this.with_let_allowed(true, |this, _| this.visit_expr(cond));
+                    return; // We've already walked into `expr`.
+                }
+                // The same logic applies to `While`.
+                ExprKind::While(cond, then, opt_label) => {
+                    walk_list!(this, visit_label, opt_label);
+                    this.visit_block(then);
+                    this.with_let_allowed(true, |this, _| this.visit_expr(cond));
+                    return; // We've already walked into `expr`.
+                }
+                _ => {}
             }
-            _ => {}
-        }
 
-        visit::walk_expr(self, expr);
+            visit::walk_expr(this, expr);
+        });
     }
 
     fn visit_ty(&mut self, ty: &'a Ty) {
@@ -1443,6 +1490,7 @@ pub fn check_crate(session: &Session, krate: &Crate, lints: &mut LintBuffer) ->
         bound_context: None,
         is_impl_trait_banned: false,
         is_assoc_ty_bound_banned: false,
+        is_let_allowed: false,
         lint_buffer: lints,
     };
     visit::walk_crate(&mut validator, krate);