Account for let foo = expr; to suggest const foo: Ty = expr;

estebank · estebank · commit cbe75486f7eb · 2024-07-11T20:39:24.000Z
diff --git a/compiler/rustc_resolve/src/diagnostics.rs b/compiler/rustc_resolve/src/diagnostics.rs
@@ -819,7 +819,12 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
             ResolutionError::CannotCaptureDynamicEnvironmentInFnItem => {
                 self.dcx().create_err(errs::CannotCaptureDynamicEnvironmentInFnItem { span })
             }
-            ResolutionError::AttemptToUseNonConstantValueInConstant(ident, suggestion, current) => {
+            ResolutionError::AttemptToUseNonConstantValueInConstant {
+                ident,
+                suggestion,
+                current,
+                type_span,
+            } => {
                 // let foo =...
                 //     ^^^ given this Span
                 // ------- get this Span to have an applicable suggestion
@@ -844,6 +849,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
                                 span: sp,
                                 suggestion,
                                 current,
+                                type_span,
                             }), Some(errs::AttemptToUseNonConstantValueInConstantLabelWithSuggestion {span})),
                             None,
                         )
diff --git a/compiler/rustc_resolve/src/errors.rs b/compiler/rustc_resolve/src/errors.rs
@@ -240,16 +240,18 @@ pub(crate) struct AttemptToUseNonConstantValueInConstant<'a> {
 }
 
 #[derive(Subdiagnostic)]
-#[suggestion(
+#[multipart_suggestion(
     resolve_attempt_to_use_non_constant_value_in_constant_with_suggestion,
-    code = "{suggestion} ",
     style = "verbose",
-    applicability = "maybe-incorrect"
+    applicability = "has-placeholders"
 )]
 pub(crate) struct AttemptToUseNonConstantValueInConstantWithSuggestion<'a> {
-    #[primary_span]
+    // #[primary_span]
+    #[suggestion_part(code = "{suggestion} ")]
     pub(crate) span: Span,
     pub(crate) suggestion: &'a str,
+    #[suggestion_part(code = ": /* Type */")]
+    pub(crate) type_span: Option<Span>,
     pub(crate) current: &'a str,
 }
 
diff --git a/compiler/rustc_resolve/src/ident.rs b/compiler/rustc_resolve/src/ident.rs
@@ -1178,21 +1178,41 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
                             if let Some(span) = finalize {
                                 let (span, resolution_error) = match item {
                                     None if rib_ident.as_str() == "self" => (span, LowercaseSelf),
-                                    None => (
-                                        rib_ident.span,
-                                        AttemptToUseNonConstantValueInConstant(
-                                            original_rib_ident_def,
-                                            "const",
-                                            "let",
-                                        ),
-                                    ),
+                                    None => {
+                                        // If we have a `let name = expr;`, we have the span for
+                                        // `name` and use that to see if it is followed by a type
+                                        // specifier. If not, then we know we need to suggest
+                                        // `const name: Ty = expr;`. This is a heuristic, it will
+                                        // break down in the presence of macros.
+                                        let sm = self.tcx.sess.source_map();
+                                        let type_span = match sm.span_look_ahead(
+                                            original_rib_ident_def.span,
+                                            ":",
+                                            None,
+                                        ) {
+                                            None => {
+                                                Some(original_rib_ident_def.span.shrink_to_hi())
+                                            }
+                                            Some(_) => None,
+                                        };
+                                        (
+                                            rib_ident.span,
+                                            AttemptToUseNonConstantValueInConstant {
+                                                ident: original_rib_ident_def,
+                                                suggestion: "const",
+                                                current: "let",
+                                                type_span,
+                                            },
+                                        )
+                                    }
                                     Some((ident, kind)) => (
                                         span,
-                                        AttemptToUseNonConstantValueInConstant(
+                                        AttemptToUseNonConstantValueInConstant {
                                             ident,
-                                            "let",
-                                            kind.as_str(),
-                                        ),
+                                            suggestion: "let",
+                                            current: kind.as_str(),
+                                            type_span: None,
+                                        },
                                     ),
                                 };
                                 self.report_error(span, resolution_error);
diff --git a/compiler/rustc_resolve/src/lib.rs b/compiler/rustc_resolve/src/lib.rs
@@ -236,11 +236,12 @@ enum ResolutionError<'a> {
     /// Error E0434: can't capture dynamic environment in a fn item.
     CannotCaptureDynamicEnvironmentInFnItem,
     /// Error E0435: attempt to use a non-constant value in a constant.
-    AttemptToUseNonConstantValueInConstant(
-        Ident,
-        /* suggestion */ &'static str,
-        /* current */ &'static str,
-    ),
+    AttemptToUseNonConstantValueInConstant {
+        ident: Ident,
+        suggestion: &'static str,
+        current: &'static str,
+        type_span: Option<Span>,
+    },
     /// Error E0530: `X` bindings cannot shadow `Y`s.
     BindingShadowsSomethingUnacceptable {
         shadowing_binding: PatternSource,
diff --git a/tests/ui/asm/parse-error.stderr b/tests/ui/asm/parse-error.stderr
@@ -376,8 +376,8 @@ LL |         asm!("{}", options(), const foo);
    |
 help: consider using `const` instead of `let`
    |
-LL |     const foo = 0;
-   |     ~~~~~
+LL |     const foo: /* Type */ = 0;
+   |     ~~~~~    ++++++++++++
 
 error[E0435]: attempt to use a non-constant value in a constant
   --> $DIR/parse-error.rs:71:44
@@ -387,8 +387,8 @@ LL |         asm!("{}", clobber_abi("C"), const foo);
    |
 help: consider using `const` instead of `let`
    |
-LL |     const foo = 0;
-   |     ~~~~~
+LL |     const foo: /* Type */ = 0;
+   |     ~~~~~    ++++++++++++
 
 error[E0435]: attempt to use a non-constant value in a constant
   --> $DIR/parse-error.rs:74:55
@@ -398,8 +398,8 @@ LL |         asm!("{}", options(), clobber_abi("C"), const foo);
    |
 help: consider using `const` instead of `let`
    |
-LL |     const foo = 0;
-   |     ~~~~~
+LL |     const foo: /* Type */ = 0;
+   |     ~~~~~    ++++++++++++
 
 error[E0435]: attempt to use a non-constant value in a constant
   --> $DIR/parse-error.rs:76:31
@@ -409,8 +409,8 @@ LL |         asm!("{a}", a = const foo, a = const bar);
    |
 help: consider using `const` instead of `let`
    |
-LL |     const foo = 0;
-   |     ~~~~~
+LL |     const foo: /* Type */ = 0;
+   |     ~~~~~    ++++++++++++
 
 error[E0435]: attempt to use a non-constant value in a constant
   --> $DIR/parse-error.rs:76:46
@@ -420,8 +420,8 @@ LL |         asm!("{a}", a = const foo, a = const bar);
    |
 help: consider using `const` instead of `let`
    |
-LL |     const bar = 0;
-   |     ~~~~~
+LL |     const bar: /* Type */ = 0;
+   |     ~~~~~    ++++++++++++
 
 error: aborting due to 64 previous errors
 
diff --git a/tests/ui/asm/type-check-1.stderr b/tests/ui/asm/type-check-1.stderr
@@ -6,8 +6,8 @@ LL |         asm!("{}", const x);
    |
 help: consider using `const` instead of `let`
    |
-LL |         const x = 0;
-   |         ~~~~~
+LL |         const x: /* Type */ = 0;
+   |         ~~~~~  ++++++++++++
 
 error[E0435]: attempt to use a non-constant value in a constant
   --> $DIR/type-check-1.rs:44:36
@@ -17,8 +17,8 @@ LL |         asm!("{}", const const_foo(x));
    |
 help: consider using `const` instead of `let`
    |
-LL |         const x = 0;
-   |         ~~~~~
+LL |         const x: /* Type */ = 0;
+   |         ~~~~~  ++++++++++++
 
 error[E0435]: attempt to use a non-constant value in a constant
   --> $DIR/type-check-1.rs:47:36
@@ -28,8 +28,8 @@ LL |         asm!("{}", const const_bar(x));
    |
 help: consider using `const` instead of `let`
    |
-LL |         const x = 0;
-   |         ~~~~~
+LL |         const x: /* Type */ = 0;
+   |         ~~~~~  ++++++++++++
 
 error: invalid `sym` operand
   --> $DIR/type-check-1.rs:49:24
diff --git a/tests/ui/asm/x86_64/x86_64_parse_error.stderr b/tests/ui/asm/x86_64/x86_64_parse_error.stderr
@@ -20,8 +20,8 @@ LL |         asm!("{a}", in("eax") foo, a = const bar);
    |
 help: consider using `const` instead of `let`
    |
-LL |     const bar = 0;
-   |     ~~~~~
+LL |     const bar: /* Type */ = 0;
+   |     ~~~~~    ++++++++++++
 
 error[E0435]: attempt to use a non-constant value in a constant
   --> $DIR/x86_64_parse_error.rs:15:46
@@ -31,8 +31,8 @@ LL |         asm!("{a}", in("eax") foo, a = const bar);
    |
 help: consider using `const` instead of `let`
    |
-LL |     const bar = 0;
-   |     ~~~~~
+LL |     const bar: /* Type */ = 0;
+   |     ~~~~~    ++++++++++++
 
 error[E0435]: attempt to use a non-constant value in a constant
   --> $DIR/x86_64_parse_error.rs:17:42
@@ -42,8 +42,8 @@ LL |         asm!("{1}", in("eax") foo, const bar);
    |
 help: consider using `const` instead of `let`
    |
-LL |     const bar = 0;
-   |     ~~~~~
+LL |     const bar: /* Type */ = 0;
+   |     ~~~~~    ++++++++++++
 
 error: aborting due to 5 previous errors
 
diff --git a/tests/ui/const-generics/legacy-const-generics-bad.stderr b/tests/ui/const-generics/legacy-const-generics-bad.stderr
@@ -6,8 +6,8 @@ LL |     legacy_const_generics::foo(0, a, 2);
    |
 help: consider using `const` instead of `let`
    |
-LL |     const a = 1;
-   |     ~~~~~
+LL |     const a: /* Type */ = 1;
+   |     ~~~~~  ++++++++++++
 
 error: generic parameters may not be used in const operations
   --> $DIR/legacy-const-generics-bad.rs:12:35
diff --git a/tests/ui/consts/non-const-value-in-const.stderr b/tests/ui/consts/non-const-value-in-const.stderr
@@ -17,8 +17,8 @@ LL |     let _ = [0; x];
    |
 help: consider using `const` instead of `let`
    |
-LL |     const x = 5;
-   |     ~~~~~
+LL |     const x: /* Type */ = 5;
+   |     ~~~~~  ++++++++++++
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/issues/issue-27433.fixed b/tests/ui/issues/issue-27433.fixed
@@ -3,5 +3,5 @@ fn main() {
     let foo = 42u32;
     #[allow(unused_variables, non_snake_case)]
     let FOO : u32 = foo;
-                   //~^ ERROR attempt to use a non-constant value in a constant
+    //~^ ERROR attempt to use a non-constant value in a constant
 }
diff --git a/tests/ui/issues/issue-27433.rs b/tests/ui/issues/issue-27433.rs
@@ -3,5 +3,5 @@ fn main() {
     let foo = 42u32;
     #[allow(unused_variables, non_snake_case)]
     const FOO : u32 = foo;
-                   //~^ ERROR attempt to use a non-constant value in a constant
+    //~^ ERROR attempt to use a non-constant value in a constant
 }
diff --git a/tests/ui/repeat-expr/repeat_count.stderr b/tests/ui/repeat-expr/repeat_count.stderr
@@ -6,8 +6,8 @@ LL |     let a = [0; n];
    |
 help: consider using `const` instead of `let`
    |
-LL |     const n = 1;
-   |     ~~~~~
+LL |     const n: /* Type */ = 1;
+   |     ~~~~~  ++++++++++++
 
 error[E0308]: mismatched types
   --> $DIR/repeat_count.rs:7:17
diff --git a/tests/ui/typeof/issue-42060.stderr b/tests/ui/typeof/issue-42060.stderr
@@ -6,8 +6,8 @@ LL |     let other: typeof(thing) = thing;
    |
 help: consider using `const` instead of `let`
    |
-LL |     const thing = ();
-   |     ~~~~~
+LL |     const thing: /* Type */ = ();
+   |     ~~~~~      ++++++++++++
 
 error[E0435]: attempt to use a non-constant value in a constant
   --> $DIR/issue-42060.rs:9:13
@@ -17,8 +17,8 @@ LL |     <typeof(q)>::N
    |
 help: consider using `const` instead of `let`
    |
-LL |     const q = 1;
-   |     ~~~~~
+LL |     const q: /* Type */ = 1;
+   |     ~~~~~  ++++++++++++
 
 error[E0516]: `typeof` is a reserved keyword but unimplemented
   --> $DIR/issue-42060.rs:3:16

Original file line number	Diff line number	Diff line change
`@@ -376,8 +376,8 @@ LL \| asm!("{}", options(), const foo);`
`376`	`376`	`\|`
`377`	`377`	help: consider using `const` instead of `let`
`378`	`378`	`\|`
`379`		`-LL \| const foo = 0;`
`380`		`- \| ~~~~~`
	`379`	`+LL \| const foo: /* Type */ = 0;`
	`380`	`+ \| ~~~~~ ++++++++++++`
`381`	`381`
`382`	`382`	`error[E0435]: attempt to use a non-constant value in a constant`
`383`	`383`	`--> $DIR/parse-error.rs:71:44`
`@@ -387,8 +387,8 @@ LL \| asm!("{}", clobber_abi("C"), const foo);`
`387`	`387`	`\|`
`388`	`388`	help: consider using `const` instead of `let`
`389`	`389`	`\|`
`390`		`-LL \| const foo = 0;`
`391`		`- \| ~~~~~`
	`390`	`+LL \| const foo: /* Type */ = 0;`
	`391`	`+ \| ~~~~~ ++++++++++++`
`392`	`392`
`393`	`393`	`error[E0435]: attempt to use a non-constant value in a constant`
`394`	`394`	`--> $DIR/parse-error.rs:74:55`
`@@ -398,8 +398,8 @@ LL \| asm!("{}", options(), clobber_abi("C"), const foo);`
`398`	`398`	`\|`
`399`	`399`	help: consider using `const` instead of `let`
`400`	`400`	`\|`
`401`		`-LL \| const foo = 0;`
`402`		`- \| ~~~~~`
	`401`	`+LL \| const foo: /* Type */ = 0;`
	`402`	`+ \| ~~~~~ ++++++++++++`
`403`	`403`
`404`	`404`	`error[E0435]: attempt to use a non-constant value in a constant`
`405`	`405`	`--> $DIR/parse-error.rs:76:31`
`@@ -409,8 +409,8 @@ LL \| asm!("{a}", a = const foo, a = const bar);`
`409`	`409`	`\|`
`410`	`410`	help: consider using `const` instead of `let`
`411`	`411`	`\|`
`412`		`-LL \| const foo = 0;`
`413`		`- \| ~~~~~`
	`412`	`+LL \| const foo: /* Type */ = 0;`
	`413`	`+ \| ~~~~~ ++++++++++++`
`414`	`414`
`415`	`415`	`error[E0435]: attempt to use a non-constant value in a constant`
`416`	`416`	`--> $DIR/parse-error.rs:76:46`
`@@ -420,8 +420,8 @@ LL \| asm!("{a}", a = const foo, a = const bar);`
`420`	`420`	`\|`
`421`	`421`	help: consider using `const` instead of `let`
`422`	`422`	`\|`
`423`		`-LL \| const bar = 0;`
`424`		`- \| ~~~~~`
	`423`	`+LL \| const bar: /* Type */ = 0;`
	`424`	`+ \| ~~~~~ ++++++++++++`
`425`	`425`
`426`	`426`	`error: aborting due to 64 previous errors`
`427`	`427`
Original file line number	Diff line number	Diff line change
`@@ -6,8 +6,8 @@ LL \| asm!("{}", const x);`
`6`	`6`	`\|`
`7`	`7`	help: consider using `const` instead of `let`
`8`	`8`	`\|`
`9`		`-LL \| const x = 0;`
`10`		`- \| ~~~~~`
	`9`	`+LL \| const x: /* Type */ = 0;`
	`10`	`+ \| ~~~~~ ++++++++++++`
`11`	`11`
`12`	`12`	`error[E0435]: attempt to use a non-constant value in a constant`
`13`	`13`	`--> $DIR/type-check-1.rs:44:36`
`@@ -17,8 +17,8 @@ LL \| asm!("{}", const const_foo(x));`
`17`	`17`	`\|`
`18`	`18`	help: consider using `const` instead of `let`
`19`	`19`	`\|`
`20`		`-LL \| const x = 0;`
`21`		`- \| ~~~~~`
	`20`	`+LL \| const x: /* Type */ = 0;`
	`21`	`+ \| ~~~~~ ++++++++++++`
`22`	`22`
`23`	`23`	`error[E0435]: attempt to use a non-constant value in a constant`
`24`	`24`	`--> $DIR/type-check-1.rs:47:36`
`@@ -28,8 +28,8 @@ LL \| asm!("{}", const const_bar(x));`
`28`	`28`	`\|`
`29`	`29`	help: consider using `const` instead of `let`
`30`	`30`	`\|`
`31`		`-LL \| const x = 0;`
`32`		`- \| ~~~~~`
	`31`	`+LL \| const x: /* Type */ = 0;`
	`32`	`+ \| ~~~~~ ++++++++++++`
`33`	`33`
`34`	`34`	error: invalid `sym` operand
`35`	`35`	`--> $DIR/type-check-1.rs:49:24`
Original file line number	Diff line number	Diff line change
`@@ -20,8 +20,8 @@ LL \| asm!("{a}", in("eax") foo, a = const bar);`
`20`	`20`	`\|`
`21`	`21`	help: consider using `const` instead of `let`
`22`	`22`	`\|`
`23`		`-LL \| const bar = 0;`
`24`		`- \| ~~~~~`
	`23`	`+LL \| const bar: /* Type */ = 0;`
	`24`	`+ \| ~~~~~ ++++++++++++`
`25`	`25`
`26`	`26`	`error[E0435]: attempt to use a non-constant value in a constant`
`27`	`27`	`--> $DIR/x86_64_parse_error.rs:15:46`
`@@ -31,8 +31,8 @@ LL \| asm!("{a}", in("eax") foo, a = const bar);`
`31`	`31`	`\|`
`32`	`32`	help: consider using `const` instead of `let`
`33`	`33`	`\|`
`34`		`-LL \| const bar = 0;`
`35`		`- \| ~~~~~`
	`34`	`+LL \| const bar: /* Type */ = 0;`
	`35`	`+ \| ~~~~~ ++++++++++++`
`36`	`36`
`37`	`37`	`error[E0435]: attempt to use a non-constant value in a constant`
`38`	`38`	`--> $DIR/x86_64_parse_error.rs:17:42`
`@@ -42,8 +42,8 @@ LL \| asm!("{1}", in("eax") foo, const bar);`
`42`	`42`	`\|`
`43`	`43`	help: consider using `const` instead of `let`
`44`	`44`	`\|`
`45`		`-LL \| const bar = 0;`
`46`		`- \| ~~~~~`
	`45`	`+LL \| const bar: /* Type */ = 0;`
	`46`	`+ \| ~~~~~ ++++++++++++`
`47`	`47`
`48`	`48`	`error: aborting due to 5 previous errors`
`49`	`49`
Original file line number	Diff line number	Diff line change
`@@ -6,8 +6,8 @@ LL \| legacy_const_generics::foo(0, a, 2);`
`6`	`6`	`\|`
`7`	`7`	help: consider using `const` instead of `let`
`8`	`8`	`\|`
`9`		`-LL \| const a = 1;`
`10`		`- \| ~~~~~`
	`9`	`+LL \| const a: /* Type */ = 1;`
	`10`	`+ \| ~~~~~ ++++++++++++`
`11`	`11`
`12`	`12`	`error: generic parameters may not be used in const operations`
`13`	`13`	`--> $DIR/legacy-const-generics-bad.rs:12:35`
Original file line number	Diff line number	Diff line change
`@@ -17,8 +17,8 @@ LL \| let _ = [0; x];`
`17`	`17`	`\|`
`18`	`18`	help: consider using `const` instead of `let`
`19`	`19`	`\|`
`20`		`-LL \| const x = 5;`
`21`		`- \| ~~~~~`
	`20`	`+LL \| const x: /* Type */ = 5;`
	`21`	`+ \| ~~~~~ ++++++++++++`
`22`	`22`
`23`	`23`	`error: aborting due to 2 previous errors`
`24`	`24`
Original file line number	Diff line number	Diff line change
`@@ -3,5 +3,5 @@ fn main() {`
`3`	`3`	`let foo = 42u32;`
`4`	`4`	`#[allow(unused_variables, non_snake_case)]`
`5`	`5`	`let FOO : u32 = foo;`
`6`		`- //~^ ERROR attempt to use a non-constant value in a constant`
	`6`	`+ //~^ ERROR attempt to use a non-constant value in a constant`
`7`	`7`	`}`