Auto merge of rust-lang#127382 - estebank:const-let, r=compiler-errors

Use verbose style when suggesting changing `const` with `let`
rust-lang-ci · Jul 12, 2024 · 4a31a6c · 4a31a6c
2 parents 5e311f9 + 4df7514
commit 4a31a6c
Show file tree

Hide file tree

Showing 25 changed files with 245 additions and 129 deletions.
diff --git a/compiler/rustc_parse/src/parser/item.rs b/compiler/rustc_parse/src/parser/item.rs
@@ -810,7 +810,7 @@ impl<'a> Parser<'a> {
                         self.dcx().struct_span_err(non_item_span, "non-item in item list");
                     self.consume_block(Delimiter::Brace, ConsumeClosingDelim::Yes);
                     if is_let {
-                        err.span_suggestion(
+                        err.span_suggestion_verbose(
                             non_item_span,
                             "consider using `const` instead of `let` for associated const",
                             "const",

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
@@ -836,13 +841,15 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
 
                 let ((with, with_label), without) = match sp {
                     Some(sp) if !self.tcx.sess.source_map().is_multiline(sp) => {
-                        let sp = sp.with_lo(BytePos(sp.lo().0 - (current.len() as u32)));
+                        let sp = sp
+                            .with_lo(BytePos(sp.lo().0 - (current.len() as u32)))
+                            .until(ident.span);
                         (
                         (Some(errs::AttemptToUseNonConstantValueInConstantWithSuggestion {
                                 span: sp,
-                                ident,
                                 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} {ident}",
-    applicability = "maybe-incorrect"
+    style = "verbose",
+    applicability = "has-placeholders"
 )]
 pub(crate) struct AttemptToUseNonConstantValueInConstantWithSuggestion<'a> {
-    #[primary_span]
+    // #[primary_span]
+    #[suggestion_part(code = "{suggestion} ")]
     pub(crate) span: Span,
-    pub(crate) ident: Ident,
     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/aarch64/parse-error.stderr b/tests/ui/asm/aarch64/parse-error.stderr
@@ -313,74 +313,90 @@ LL | global_asm!("{1}", format!("{{{}}}", 0), const FOO, const BAR);
 error[E0435]: attempt to use a non-constant value in a constant
   --> $DIR/parse-error.rs:39:37
    |
-LL |     let mut foo = 0;
-   |     ----------- help: consider using `const` instead of `let`: `const foo`
-...
 LL |         asm!("{}", options(), const foo);
    |                                     ^^^ non-constant value
+   |
+help: consider using `const` instead of `let`
+   |
+LL |     const foo: /* Type */ = 0;
+   |     ~~~~~    ++++++++++++
 
 error[E0435]: attempt to use a non-constant value in a constant
   --> $DIR/parse-error.rs:47:44
    |
-LL |     let mut foo = 0;
-   |     ----------- help: consider using `const` instead of `let`: `const foo`
-...
 LL |         asm!("{}", clobber_abi("C"), const foo);
    |                                            ^^^ non-constant value
+   |
+help: consider using `const` instead of `let`
+   |
+LL |     const foo: /* Type */ = 0;
+   |     ~~~~~    ++++++++++++
 
 error[E0435]: attempt to use a non-constant value in a constant
   --> $DIR/parse-error.rs:50:55
    |
-LL |     let mut foo = 0;
-   |     ----------- help: consider using `const` instead of `let`: `const foo`
-...
 LL |         asm!("{}", options(), clobber_abi("C"), const foo);
    |                                                       ^^^ non-constant value
+   |
+help: consider using `const` instead of `let`
+   |
+LL |     const foo: /* Type */ = 0;
+   |     ~~~~~    ++++++++++++
 
 error[E0435]: attempt to use a non-constant value in a constant
   --> $DIR/parse-error.rs:52:31
    |
-LL |     let mut foo = 0;
-   |     ----------- help: consider using `const` instead of `let`: `const foo`
-...
 LL |         asm!("{a}", a = const foo, a = const bar);
    |                               ^^^ non-constant value
+   |
+help: consider using `const` instead of `let`
+   |
+LL |     const foo: /* Type */ = 0;
+   |     ~~~~~    ++++++++++++
 
 error[E0435]: attempt to use a non-constant value in a constant
   --> $DIR/parse-error.rs:52:46
    |
-LL |     let mut bar = 0;
-   |     ----------- help: consider using `const` instead of `let`: `const bar`
-...
 LL |         asm!("{a}", a = const foo, a = const bar);
    |                                              ^^^ non-constant value
+   |
+help: consider using `const` instead of `let`
+   |
+LL |     const bar: /* Type */ = 0;
+   |     ~~~~~    ++++++++++++
 
 error[E0435]: attempt to use a non-constant value in a constant
   --> $DIR/parse-error.rs:59:45
    |
-LL |     let mut bar = 0;
-   |     ----------- help: consider using `const` instead of `let`: `const bar`
-...
 LL |         asm!("{a}", in("x0") foo, a = const bar);
    |                                             ^^^ non-constant value
+   |
+help: consider using `const` instead of `let`
+   |
+LL |     const bar: /* Type */ = 0;
+   |     ~~~~~    ++++++++++++
 
 error[E0435]: attempt to use a non-constant value in a constant
   --> $DIR/parse-error.rs:61:45
    |
-LL |     let mut bar = 0;
-   |     ----------- help: consider using `const` instead of `let`: `const bar`
-...
 LL |         asm!("{a}", in("x0") foo, a = const bar);
    |                                             ^^^ non-constant value
+   |
+help: consider using `const` instead of `let`
+   |
+LL |     const bar: /* Type */ = 0;
+   |     ~~~~~    ++++++++++++
 
 error[E0435]: attempt to use a non-constant value in a constant
   --> $DIR/parse-error.rs:63:41
    |
-LL |     let mut bar = 0;
-   |     ----------- help: consider using `const` instead of `let`: `const bar`
-...
 LL |         asm!("{1}", in("x0") foo, const bar);
    |                                         ^^^ non-constant value
+   |
+help: consider using `const` instead of `let`
+   |
+LL |     const bar: /* Type */ = 0;
+   |     ~~~~~    ++++++++++++
 
 error: aborting due to 57 previous errors
 

diff --git a/tests/ui/asm/parse-error.stderr b/tests/ui/asm/parse-error.stderr
@@ -371,47 +371,57 @@ LL | global_asm!("{}", label {});
 error[E0435]: attempt to use a non-constant value in a constant
   --> $DIR/parse-error.rs:39:37
    |
-LL |     let mut foo = 0;
-   |     ----------- help: consider using `const` instead of `let`: `const foo`
-...
 LL |         asm!("{}", options(), const foo);
    |                                     ^^^ non-constant value
+   |
+help: consider using `const` instead of `let`
+   |
+LL |     const foo: /* Type */ = 0;
+   |     ~~~~~    ++++++++++++
 
 error[E0435]: attempt to use a non-constant value in a constant
   --> $DIR/parse-error.rs:71:44
    |
-LL |     let mut foo = 0;
-   |     ----------- help: consider using `const` instead of `let`: `const foo`
-...
 LL |         asm!("{}", clobber_abi("C"), const foo);
    |                                            ^^^ non-constant value
+   |
+help: consider using `const` instead of `let`
+   |
+LL |     const foo: /* Type */ = 0;
+   |     ~~~~~    ++++++++++++
 
 error[E0435]: attempt to use a non-constant value in a constant
   --> $DIR/parse-error.rs:74:55
    |
-LL |     let mut foo = 0;
-   |     ----------- help: consider using `const` instead of `let`: `const foo`
-...
 LL |         asm!("{}", options(), clobber_abi("C"), const foo);
    |                                                       ^^^ non-constant value
+   |
+help: consider using `const` instead of `let`
+   |
+LL |     const foo: /* Type */ = 0;
+   |     ~~~~~    ++++++++++++
 
 error[E0435]: attempt to use a non-constant value in a constant
   --> $DIR/parse-error.rs:76:31
    |
-LL |     let mut foo = 0;
-   |     ----------- help: consider using `const` instead of `let`: `const foo`
-...
 LL |         asm!("{a}", a = const foo, a = const bar);
    |                               ^^^ non-constant value
+   |
+help: consider using `const` instead of `let`
+   |
+LL |     const foo: /* Type */ = 0;
+   |     ~~~~~    ++++++++++++
 
 error[E0435]: attempt to use a non-constant value in a constant
   --> $DIR/parse-error.rs:76:46
    |
-LL |     let mut bar = 0;
-   |     ----------- help: consider using `const` instead of `let`: `const bar`
-...
 LL |         asm!("{a}", a = const foo, a = const bar);
    |                                              ^^^ non-constant value
+   |
+help: consider using `const` instead of `let`
+   |
+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
@@ -1,29 +1,35 @@
 error[E0435]: attempt to use a non-constant value in a constant
   --> $DIR/type-check-1.rs:41:26
    |
-LL |         let x = 0;
-   |         ----- help: consider using `const` instead of `let`: `const x`
-...
 LL |         asm!("{}", const x);
    |                          ^ non-constant value
+   |
+help: consider using `const` instead of `let`
+   |
+LL |         const x: /* Type */ = 0;
+   |         ~~~~~  ++++++++++++
 
 error[E0435]: attempt to use a non-constant value in a constant
   --> $DIR/type-check-1.rs:44:36
    |
-LL |         let x = 0;
-   |         ----- help: consider using `const` instead of `let`: `const x`
-...
 LL |         asm!("{}", const const_foo(x));
    |                                    ^ non-constant value
+   |
+help: consider using `const` instead of `let`
+   |
+LL |         const x: /* Type */ = 0;
+   |         ~~~~~  ++++++++++++
 
 error[E0435]: attempt to use a non-constant value in a constant
   --> $DIR/type-check-1.rs:47:36
    |
-LL |         let x = 0;
-   |         ----- help: consider using `const` instead of `let`: `const x`
-...
 LL |         asm!("{}", const const_bar(x));
    |                                    ^ non-constant value
+   |
+help: consider using `const` instead of `let`
+   |
+LL |         const x: /* Type */ = 0;
+   |         ~~~~~  ++++++++++++
 
 error: invalid `sym` operand
   --> $DIR/type-check-1.rs:49:24