Supress suggest let else when no let in refutable bindings

Signed-off-by: xizheyin <[email protected]>

Author: xizheyin

compiler/rustc_mir_build/src/thir/pattern/check_match.rs

@@ -6,7 +6,7 @@ use rustc_errors::codes::*;
 use rustc_errors::{Applicability, ErrorGuaranteed, MultiSpan, struct_span_code_err};
 use rustc_hir::def::*;
 use rustc_hir::def_id::LocalDefId;
-use rustc_hir::{self as hir, BindingMode, ByRef, HirId, MatchSource};
+use rustc_hir::{self as hir, BindingMode, ByRef, HirId, LocalSource, MatchSource, Node};
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::Level;
 use rustc_middle::bug;
@@ -715,6 +715,8 @@ impl<'p, 'tcx> MatchVisitor<'p, 'tcx> {
             && self.tcx.sess.source_map().is_span_accessible(span)
             && interpreted_as_const.is_none()
             && scrut.is_some()
+            // we only suggest `let else` when the pattern is not desugared from an assignment
+            && !self.is_pat_from_assign_desugar(pat)
         {
             let mut bindings = vec![];
             pat.each_binding(|name, _, _, _| bindings.push(name));
@@ -768,6 +770,32 @@ impl<'p, 'tcx> MatchVisitor<'p, 'tcx> {
             adt_defined_here,
         }));
     }
+
+    /// Check if `pat` is desugared into a `let`, i.e., `LocalSource::AssignDesugar`
+    /// rather than a real `let` the user wrote.
+    /// This helps suppress suggestions for `let` statements when
+    /// we're dealing with an assignment like `Some(x) = rhs`.
+    fn is_pat_from_assign_desugar(&self, pat: &Pat<'tcx>) -> bool {
+        // Find a binding in the pattern
+        let mut binding: Option<LocalVarId> = None;
+        pat.walk(|p| {
+            if let PatKind::Binding { var, .. } = p.kind {
+                binding = Some(var);
+                return false;
+            }
+            true
+        });
+
+        // Walk up the HIR parents to the enclosing `LetStmt`, then check its `source`.
+        if let Some(var) = binding {
+            for (_, node) in self.tcx.hir_parent_iter(var.0) {
+                if let Node::LetStmt(let_stmt) = node {
+                    return matches!(let_stmt.source, LocalSource::AssignDesugar(_));
+                }
+            }
+        }
+        false
+    }
 }
 
 /// Check if a by-value binding is by-value. That is, check if the binding's type is not `Copy`.

tests/ui/let-else/suggest-with-let-issue-145548.rs

@@ -1,5 +1,5 @@
 // `Some(x) = Some(1)` is treated as a let statement,
-// so we should suggest to add`let ... else{...}`
+// so we should not suggest to add `let ... else{...}`
 
 fn foo1(){
     let x = 2;

tests/ui/let-else/suggest-with-let-issue-145548.stderr

@@ -7,10 +7,6 @@ LL |     Some(x) = Some(1);
    = note: `let` bindings require an "irrefutable pattern", like a `struct` or an `enum` with only one variant
    = note: for more information, visit https://doc.rust-lang.org/book/ch19-02-refutability.html
    = note: the matched value is of type `Option<i32>`
-help: you might want to use `let else` to handle the variant that isn't matched
-   |
-LL |     Some(x) = Some(1) else { todo!() };
-   |                       ++++++++++++++++
 
 error[E0005]: refutable pattern in local binding
   --> $DIR/suggest-with-let-issue-145548.rs:11:9