rustc_parse: improve the error diagnostic for "missing let in let chain"

Author: Unique-Usman

compiler/rustc_parse/messages.ftl

@@ -1030,3 +1030,15 @@ parse_where_generics = generic parameters on `where` clauses are reserved for fu
 
 parse_zero_chars = empty character literal
     .label = {parse_zero_chars}
+
+parse_let_chain_missing_let =
+    let-chain with missing `let`
+
+parse_let_chain_start =
+    let-chain starting here
+
+parse_expected_let_found_assign =
+    expected `let` expression, found assignment
+
+parse_add_let =
+    add `let` before the expression

compiler/rustc_parse/src/errors.rs

@@ -3684,3 +3684,21 @@ pub(crate) struct ImplReuseInherentImpl {
     #[primary_span]
     pub span: Span,
 }
+
+#[derive(Diagnostic)]
+#[diag(parse_let_chain_missing_let)]
+pub(crate) struct LetChainWithMissingLet {
+    #[label(parse_let_chain_start)]
+    pub left_span: Span,
+
+    #[label(parse_expected_let_found_assign)]
+    pub right_span: Span,
+
+    #[suggestion(
+        parse_add_let,
+        style = "verbose",
+        applicability = "machine-applicable",
+        code = "let "
+    )]
+    pub let_span: Span,
+}

compiler/rustc_parse/src/parser/expr.rs

@@ -4211,7 +4211,26 @@ impl MutVisitor for CondChecker<'_> {
                     }
                 }
             }
-            ExprKind::Binary(Spanned { node: BinOpKind::And, .. }, _, _) => {
+
+            ExprKind::Binary(Spanned { node: BinOpKind::And, .. }, ref lhs, ref mut rhs) => {
+                if let ExprKind::Assign(assign_lhs, _, _) = &rhs.kind {
+                    if let ExprKind::Call(callee, _) = &assign_lhs.kind
+                        && let ExprKind::Path(None, path) = &callee.kind
+                        && path.segments.len() == 1
+                        && path.segments[0].ident.name == sym::Some
+                    {
+                        let guar = self
+                            .parser
+                            .dcx()
+                            .create_err(errors::LetChainWithMissingLet {
+                                right_span: rhs.span,
+                                left_span: lhs.span,
+                                let_span: rhs.span.shrink_to_hi(),
+                            })
+                            .emit();
+                        *rhs = self.parser.mk_expr_err(rhs.span, guar);
+                    }
+                }
                 mut_visit::walk_expr(self, e);
             }
             ExprKind::Binary(Spanned { node: BinOpKind::Or, span: or_span }, _, _)