Fix diagnostic when using = instead of : in let bindings

Author: chenyukang

compiler/rustc_resolve/src/late/diagnostics.rs

@@ -2347,26 +2347,47 @@ impl<'ast, 'ra: 'ast, 'tcx> LateResolutionVisitor<'_, 'ast, 'ra, 'tcx> {
     // try to give a suggestion for this pattern: `name = blah`, which is common in other languages
     // suggest `let name = blah` to introduce a new binding
     fn let_binding_suggestion(&mut self, err: &mut Diag<'_>, ident_span: Span) -> bool {
-        if let Some(Expr { kind: ExprKind::Assign(lhs, ..), .. }) = self.diag_metadata.in_assignment
-            && let ast::ExprKind::Path(None, ref path) = lhs.kind
-            && !ident_span.from_expansion()
-        {
-            let (span, text) = match path.segments.first() {
-                Some(seg) if let Some(name) = seg.ident.as_str().strip_prefix("let") => {
-                    // a special case for #117894
-                    let name = name.strip_prefix('_').unwrap_or(name);
-                    (ident_span, format!("let {name}"))
-                }
-                _ => (ident_span.shrink_to_lo(), "let ".to_string()),
-            };
+        if !ident_span.from_expansion() {
+            // only suggest when the code is a assignment without prefix code
+            if let Some(Expr { kind: ExprKind::Assign(lhs, ..), .. }) =
+                self.diag_metadata.in_assignment
+                && let ast::ExprKind::Path(None, ref path) = lhs.kind
+                && self.r.tcx.sess.source_map().is_line_before_span_empty(ident_span)
+            {
+                let (span, text) = match path.segments.first() {
+                    Some(seg) if let Some(name) = seg.ident.as_str().strip_prefix("let") => {
+                        // a special case for #117894
+                        let name = name.strip_prefix('_').unwrap_or(name);
+                        (ident_span, format!("let {name}"))
+                    }
+                    _ => (ident_span.shrink_to_lo(), "let ".to_string()),
+                };
 
-            err.span_suggestion_verbose(
-                span,
-                "you might have meant to introduce a new binding",
-                text,
-                Applicability::MaybeIncorrect,
-            );
-            return true;
+                err.span_suggestion_verbose(
+                    span,
+                    "you might have meant to introduce a new binding",
+                    text,
+                    Applicability::MaybeIncorrect,
+                );
+                return true;
+            } else {
+                // a special case for #133713
+                // '=' maybe a typo of `:`, which is a type annotation instead of assignment
+                if err.code == Some(E0423)
+                    && let Some((let_span, _, _)) = self.diag_metadata.current_let_binding
+                    && let span = let_span.shrink_to_hi().to(ident_span.shrink_to_lo())
+                    && let Ok(code) = self.r.tcx.sess.source_map().span_to_snippet(span)
+                    && code.trim() == "="
+                {
+                    err.span_suggestion_verbose(
+                        span,
+                        "you might have meant to use `:` for type annotation",
+                        ": ",
+                        Applicability::MaybeIncorrect,
+                    );
+                    return true;
+                }
+            }
         }
         false
     }

tests/ui/suggestions/let-binding-suggest-issue-133713.fixed

@@ -0,0 +1,12 @@
+//@ run-rustfix
+#![allow(dead_code)]
+
+fn demo1() {
+    let _last: u64 = 0; //~ ERROR expected value, found builtin type `u64`
+}
+
+fn demo2() {
+    let _val: u64; //~ ERROR expected value, found builtin type `u64`
+}
+
+fn main() {}

tests/ui/suggestions/let-binding-suggest-issue-133713.rs

@@ -0,0 +1,12 @@
+//@ run-rustfix
+#![allow(dead_code)]
+
+fn demo1() {
+    let _last = u64 = 0; //~ ERROR expected value, found builtin type `u64`
+}
+
+fn demo2() {
+    let _val = u64; //~ ERROR expected value, found builtin type `u64`
+}
+
+fn main() {}

tests/ui/suggestions/let-binding-suggest-issue-133713.stderr

@@ -0,0 +1,27 @@
+error[E0423]: expected value, found builtin type `u64`
+  --> $DIR/let-binding-suggest-issue-133713.rs:5:17
+   |
+LL |     let _last = u64 = 0;
+   |                 ^^^
+   |
+help: you might have meant to use `:` for type annotation
+   |
+LL -     let _last = u64 = 0;
+LL +     let _last: u64 = 0;
+   |
+
+error[E0423]: expected value, found builtin type `u64`
+  --> $DIR/let-binding-suggest-issue-133713.rs:9:16
+   |
+LL |     let _val = u64;
+   |                ^^^
+   |
+help: you might have meant to use `:` for type annotation
+   |
+LL -     let _val = u64;
+LL +     let _val: u64;
+   |
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0423`.