rustc_parse: improve the error diagnostic for "missing let"

Signed-off-by: Usman Akinyemi <usmanakinyemi202@gmail.com>

Author: Unique-Usman

compiler/rustc_parse/messages.ftl

@@ -535,6 +535,11 @@ parse_leading_underscore_unicode_escape_label = invalid start of unicode escape
 parse_left_arrow_operator = unexpected token: `<-`
     .suggestion = if you meant to write a comparison against a negative value, add a space in between `<` and `-`
 
+parse_let_chain_missing_let = let-chain with missing `let`
+    .label = expected `let` expression, found assignment
+    .rhs_label = let expression later in the condition
+    .suggestion = add `let` before the expression
+
 parse_let_chain_pre_2024 = let chains are only allowed in Rust 2024 or later
 
 parse_lifetime_after_mut = lifetime must precede `mut`

compiler/rustc_parse/src/errors.rs

@@ -512,6 +512,19 @@ pub(crate) struct ExpectedExpressionFoundLet {
     pub comparison: Option<MaybeComparison>,
 }
 
+#[derive(Diagnostic)]
+#[diag(parse_let_chain_missing_let)]
+pub(crate) struct LetChainMissingLet {
+    #[primary_span]
+    pub span: Span,
+    #[label]
+    pub label_span: Span,
+    #[label(parse_rhs_label)]
+    pub rhs_span: Span,
+    #[suggestion(applicability = "maybe-incorrect", code = "let ", style = "verbose")]
+    pub sug_span: Span,
+}
+
 #[derive(Diagnostic)]
 #[diag(parse_or_in_let_chain)]
 pub(crate) struct OrInLetChain {

compiler/rustc_parse/src/parser/expr.rs

@@ -4304,7 +4304,52 @@ impl MutVisitor for CondChecker<'_> {
                 mut_visit::walk_expr(self, e);
                 self.forbid_let_reason = forbid_let_reason;
             }
-            ExprKind::Assign(ref lhs, _, span) => {
+            ExprKind::Assign(ref lhs, ref rhs, span) => {
+                if let ExprKind::Call(_, _) = &lhs.kind {
+                    fn get_path_from_rhs(e: &Expr) -> Option<(u32, &Path)> {
+                        fn inner(e: &Expr, depth: u32) -> Option<(u32, &Path)> {
+                            match &e.kind {
+                                ExprKind::Binary(_, lhs, _) => inner(lhs, depth + 1),
+                                ExprKind::Path(_, path) => Some((depth, path)),
+                                _ => None,
+                            }
+                        }
+
+                        inner(e, 0)
+                    }
+
+                    if let Some((depth, path)) = get_path_from_rhs(rhs) {
+                        // For cases like if Some(_) = x && let Some(_) = y && let Some(_) = z
+                        // This return let Some(_) = y expression
+                        fn find_let_some(expr: &Expr) -> Option<&Expr> {
+                            match &expr.kind {
+                                ExprKind::Let(..) => Some(expr),
+
+                                ExprKind::Binary(op, lhs, rhs) if op.node == BinOpKind::And => {
+                                    find_let_some(lhs).or_else(|| find_let_some(rhs))
+                                }
+
+                                _ => None,
+                            }
+                        }
+
+                        let expr_span = lhs.span.to(path.span);
+
+                        if let Some(later_rhs) = find_let_some(rhs)
+                            && depth > 0
+                        {
+                            let guar = self.parser.dcx().emit_err(errors::LetChainMissingLet {
+                                span: lhs.span,
+                                label_span: expr_span,
+                                rhs_span: later_rhs.span,
+                                sug_span: lhs.span.shrink_to_lo(),
+                            });
+
+                            self.found_incorrect_let_chain = Some(guar);
+                        }
+                    }
+                }
+
                 let forbid_let_reason = self.forbid_let_reason;
                 self.forbid_let_reason = Some(OtherForbidden);
                 let missing_let = self.missing_let;

tests/ui/missing/missing-let.rs

@@ -1,6 +1,18 @@
 fn main() {
     let x = Some(42);
+    let y = Some(42);
+    let z = Some(42);
     if let Some(_) = x
         && Some(x) = x //~^ ERROR expected expression, found `let` statement
+        //~| NOTE: only supported directly in conditions of `if` and `while` expressions
+    {}
+
+    if Some(_) = y &&
+    //~^ NOTE expected `let` expression, found assignment
+    //~| ERROR let-chain with missing `let`
+        let Some(_) = z
+        //~^ ERROR: expected expression, found `let` statement
+        //~| NOTE: let expression later in the condition
+        //~| NOTE: only supported directly in conditions of `if` and `while` expressions
     {}
 }

tests/ui/missing/missing-let.stderr

@@ -1,5 +1,5 @@
 error: expected expression, found `let` statement
-  --> $DIR/missing-let.rs:3:8
+  --> $DIR/missing-let.rs:5:8
    |
 LL |     if let Some(_) = x
    |        ^^^^^^^^^^^^^^^
@@ -14,5 +14,29 @@ help: you might have meant to compare for equality
 LL |         && Some(x) == x
    |                     +
 
-error: aborting due to 1 previous error
+error: expected expression, found `let` statement
+  --> $DIR/missing-let.rs:13:9
+   |
+LL |         let Some(_) = z
+   |         ^^^
+   |
+   = note: only supported directly in conditions of `if` and `while` expressions
+
+error: let-chain with missing `let`
+  --> $DIR/missing-let.rs:10:8
+   |
+LL |     if Some(_) = y &&
+   |        ^^^^^^^----
+   |        |
+   |        expected `let` expression, found assignment
+...
+LL |         let Some(_) = z
+   |         --------------- let expression later in the condition
+   |
+help: add `let` before the expression
+   |
+LL |     if let Some(_) = y &&
+   |        +++
+
+error: aborting due to 3 previous errors