Turn invalid index suffixes into hard errors

Author: jieyouxu

compiler/rustc_parse/messages.ftl

@@ -473,9 +473,6 @@ parse_invalid_label =
 
 parse_invalid_literal_suffix_on_tuple_index = suffixes on a tuple index are invalid
     .label = invalid suffix `{$suffix}`
-    .tuple_exception_line_1 = `{$suffix}` is *temporarily* accepted on tuple index fields as it was incorrectly accepted on stable for a few releases
-    .tuple_exception_line_2 = on proc macros, you'll want to use `syn::Index::from` or `proc_macro::Literal::*_unsuffixed` for code that will desugar to tuple field access
-    .tuple_exception_line_3 = see issue #60210 <https://github.com/rust-lang/rust/issues/60210> for more information
 
 parse_invalid_logical_operator = `{$incorrect}` is not a logical operator
     .note = unlike in e.g., Python and PHP, `&&` and `||` are used for logical operators

compiler/rustc_parse/src/errors.rs

@@ -1016,10 +1016,6 @@ pub(crate) struct InvalidLiteralSuffixOnTupleIndex {
     #[label]
     pub span: Span,
     pub suffix: Symbol,
-    #[help(parse_tuple_exception_line_1)]
-    #[help(parse_tuple_exception_line_2)]
-    #[help(parse_tuple_exception_line_3)]
-    pub exception: bool,
 }
 
 #[derive(Diagnostic)]

compiler/rustc_parse/src/parser/expr.rs

@@ -2226,21 +2226,7 @@ impl<'a> Parser<'a> {
     }
 
     pub(super) fn expect_no_tuple_index_suffix(&self, span: Span, suffix: Symbol) {
-        if [sym::i32, sym::u32, sym::isize, sym::usize].contains(&suffix) {
-            // #59553: warn instead of reject out of hand to allow the fix to percolate
-            // through the ecosystem when people fix their macros
-            self.dcx().emit_warn(errors::InvalidLiteralSuffixOnTupleIndex {
-                span,
-                suffix,
-                exception: true,
-            });
-        } else {
-            self.dcx().emit_err(errors::InvalidLiteralSuffixOnTupleIndex {
-                span,
-                suffix,
-                exception: false,
-            });
-        }
+        self.dcx().emit_err(errors::InvalidLiteralSuffixOnTupleIndex { span, suffix });
     }
 
     /// Matches `'-' lit | lit` (cf. `ast_validation::AstValidator::check_expr_within_pat`).

tests/ui/parser/tuple-index-suffix-proc-macro.rs

@@ -11,12 +11,13 @@ fn main() {
     struct TupStruct(i32);
     let tup_struct = TupStruct(42);
 
-    // #60186 carve outs `{i,u}{32,usize}` as non-lint pseudo-FCW warnings.
+    // Previously, #60186 had carve outs for `{i,u}{32,usize}` as non-lint pseudo-FCW warnings. Now,
+    // they all hard error.
 
     aux::bad_tup_indexing!(0usize);
-    //~^ WARN suffixes on a tuple index are invalid
+    //~^ ERROR suffixes on a tuple index are invalid
     aux::bad_tup_struct_indexing!(tup_struct, 0isize);
-    //~^ WARN suffixes on a tuple index are invalid
+    //~^ ERROR suffixes on a tuple index are invalid
 
     // Not part of the #60186 carve outs.
 

tests/ui/parser/tuple-index-suffix-proc-macro.stderr

@@ -1,34 +1,26 @@
-warning: suffixes on a tuple index are invalid
-  --> $DIR/tuple-index-suffix-proc-macro.rs:16:28
+error: suffixes on a tuple index are invalid
+  --> $DIR/tuple-index-suffix-proc-macro.rs:17:28
    |
 LL |     aux::bad_tup_indexing!(0usize);
    |                            ^^^^^^ invalid suffix `usize`
-   |
-   = help: `usize` is *temporarily* accepted on tuple index fields as it was incorrectly accepted on stable for a few releases
-   = help: on proc macros, you'll want to use `syn::Index::from` or `proc_macro::Literal::*_unsuffixed` for code that will desugar to tuple field access
-   = help: see issue #60210 <https://github.com/rust-lang/rust/issues/60210> for more information
 
-warning: suffixes on a tuple index are invalid
-  --> $DIR/tuple-index-suffix-proc-macro.rs:18:47
+error: suffixes on a tuple index are invalid
+  --> $DIR/tuple-index-suffix-proc-macro.rs:19:47
    |
 LL |     aux::bad_tup_struct_indexing!(tup_struct, 0isize);
    |                                               ^^^^^^ invalid suffix `isize`
-   |
-   = help: `isize` is *temporarily* accepted on tuple index fields as it was incorrectly accepted on stable for a few releases
-   = help: on proc macros, you'll want to use `syn::Index::from` or `proc_macro::Literal::*_unsuffixed` for code that will desugar to tuple field access
-   = help: see issue #60210 <https://github.com/rust-lang/rust/issues/60210> for more information
 
 error: suffixes on a tuple index are invalid
-  --> $DIR/tuple-index-suffix-proc-macro.rs:23:28
+  --> $DIR/tuple-index-suffix-proc-macro.rs:24:28
    |
 LL |     aux::bad_tup_indexing!(0u8);
    |                            ^^^ invalid suffix `u8`
 
 error: suffixes on a tuple index are invalid
-  --> $DIR/tuple-index-suffix-proc-macro.rs:25:47
+  --> $DIR/tuple-index-suffix-proc-macro.rs:26:47
    |
 LL |     aux::bad_tup_struct_indexing!(tup_struct, 0u64);
    |                                               ^^^^ invalid suffix `u64`
 
-error: aborting due to 2 previous errors; 2 warnings emitted
+error: aborting due to 4 previous errors
 

tests/ui/parser/tuple-index-suffix.rs

@@ -15,35 +15,36 @@
 //! - This is a *pseudo* FCW, because it's implemented as a non-lint warning whose message tries to
 //!   emulate the wording of proper FCW lints. This is due to not being able to distinguish the span
 //!   of the valid numeral part vs invalid suffix part when it comes from a proc macro.
+//! - Now, they all hard error.
 
 struct X(i32,i32,i32);
 
 fn main() {
     let tup_struct = X(1, 2, 3);
     let invalid_tup_struct_suffix = tup_struct.0suffix;
     //~^ ERROR suffixes on a tuple index are invalid
-    let carve_out_tup_struct_suffix = tup_struct.0i32;
-    //~^ WARN suffixes on a tuple index are invalid
+    let previous_carve_out_tup_struct_suffix = tup_struct.0i32;
+    //~^ ERROR suffixes on a tuple index are invalid
 
     let tup = (1, 2, 3);
     let invalid_tup_suffix = tup.0suffix;
     //~^ ERROR suffixes on a tuple index are invalid
-    let carve_out_tup_suffix = tup.0u32;
-    //~^ WARN suffixes on a tuple index are invalid
+    let previous_carve_out_tup_suffix = tup.0u32;
+    //~^ ERROR suffixes on a tuple index are invalid
 
     numeral_struct_field_name_suffix_invalid();
-    numeral_struct_field_name_suffix_carve_out();
+    numeral_struct_field_name_suffix_previous_carve_out();
 }
 
-// Very limited carve outs as a ecosystem impact mitigation implemented in #60186. *Only*
-// `{i,u}{32,usize}` suffixes are temporarily accepted.
-fn carve_outs() {
-    // Ok, only pseudo-FCW warnings.
+// Previously, there were very limited carve outs as a ecosystem impact mitigation implemented in
+// #60186. *Only* `{i,u}{32,usize}` suffixes were temporarily accepted. Now, they all hard error.
+fn previous_carve_outs() {
+    // Previously temporarily accepted by a pseudo-FCW, now hard error.
 
-    let carve_out_i32 = (42,).0i32;     //~ WARN suffixes on a tuple index are invalid
-    let carve_out_i32 = (42,).0u32;     //~ WARN suffixes on a tuple index are invalid
-    let carve_out_isize = (42,).0isize; //~ WARN suffixes on a tuple index are invalid
-    let carve_out_usize = (42,).0usize; //~ WARN suffixes on a tuple index are invalid
+    let previous_carve_out_i32 = (42,).0i32;     //~ ERROR suffixes on a tuple index are invalid
+    let previous_carve_out_i32 = (42,).0u32;     //~ ERROR suffixes on a tuple index are invalid
+    let previous_carve_out_isize = (42,).0isize; //~ ERROR suffixes on a tuple index are invalid
+    let previous_carve_out_usize = (42,).0usize; //~ ERROR suffixes on a tuple index are invalid
 
     // Not part of the carve outs!
     let error_i8 = (42,).0i8;      //~ ERROR suffixes on a tuple index are invalid
@@ -65,12 +66,12 @@ fn numeral_struct_field_name_suffix_invalid() {
     }
 }
 
-fn numeral_struct_field_name_suffix_carve_out() {
+fn numeral_struct_field_name_suffix_previous_carve_out() {
     let carve_out_struct_name = X { 0u32: 0, 1: 1, 2: 2 };
-    //~^ WARN suffixes on a tuple index are invalid
+    //~^ ERROR suffixes on a tuple index are invalid
     match carve_out_struct_name {
         X { 0u32: _, .. } => {}
-        //~^ WARN suffixes on a tuple index are invalid
+        //~^ ERROR suffixes on a tuple index are invalid
     }
 }
 
@@ -79,9 +80,9 @@ fn offset_of_suffix() {
     #[repr(C)]
     pub struct Struct<T>(u8, T);
 
-    // Carve outs
+    // Previous pseudo-FCW carve outs
     assert_eq!(std::mem::offset_of!(Struct<u32>, 0usize), 0);
-    //~^ WARN suffixes on a tuple index are invalid
+    //~^ ERROR suffixes on a tuple index are invalid
 
     // Not part of carve outs
     assert_eq!(std::mem::offset_of!(Struct<u32>, 0u8), 0);

tests/ui/parser/tuple-index-suffix.stderr

@@ -1,170 +1,134 @@
 error: suffixes on a tuple index are invalid
-  --> $DIR/tuple-index-suffix.rs:23:48
+  --> $DIR/tuple-index-suffix.rs:24:48
    |
 LL |     let invalid_tup_struct_suffix = tup_struct.0suffix;
    |                                                ^^^^^^^ invalid suffix `suffix`
 
-warning: suffixes on a tuple index are invalid
-  --> $DIR/tuple-index-suffix.rs:25:50
-   |
-LL |     let carve_out_tup_struct_suffix = tup_struct.0i32;
-   |                                                  ^^^^ invalid suffix `i32`
+error: suffixes on a tuple index are invalid
+  --> $DIR/tuple-index-suffix.rs:26:59
    |
-   = help: `i32` is *temporarily* accepted on tuple index fields as it was incorrectly accepted on stable for a few releases
-   = help: on proc macros, you'll want to use `syn::Index::from` or `proc_macro::Literal::*_unsuffixed` for code that will desugar to tuple field access
-   = help: see issue #60210 <https://github.com/rust-lang/rust/issues/60210> for more information
+LL |     let previous_carve_out_tup_struct_suffix = tup_struct.0i32;
+   |                                                           ^^^^ invalid suffix `i32`
 
 error: suffixes on a tuple index are invalid
-  --> $DIR/tuple-index-suffix.rs:29:34
+  --> $DIR/tuple-index-suffix.rs:30:34
    |
 LL |     let invalid_tup_suffix = tup.0suffix;
    |                                  ^^^^^^^ invalid suffix `suffix`
 
-warning: suffixes on a tuple index are invalid
-  --> $DIR/tuple-index-suffix.rs:31:36
-   |
-LL |     let carve_out_tup_suffix = tup.0u32;
-   |                                    ^^^^ invalid suffix `u32`
+error: suffixes on a tuple index are invalid
+  --> $DIR/tuple-index-suffix.rs:32:45
    |
-   = help: `u32` is *temporarily* accepted on tuple index fields as it was incorrectly accepted on stable for a few releases
-   = help: on proc macros, you'll want to use `syn::Index::from` or `proc_macro::Literal::*_unsuffixed` for code that will desugar to tuple field access
-   = help: see issue #60210 <https://github.com/rust-lang/rust/issues/60210> for more information
+LL |     let previous_carve_out_tup_suffix = tup.0u32;
+   |                                             ^^^^ invalid suffix `u32`
 
-warning: suffixes on a tuple index are invalid
-  --> $DIR/tuple-index-suffix.rs:43:31
-   |
-LL |     let carve_out_i32 = (42,).0i32;
-   |                               ^^^^ invalid suffix `i32`
+error: suffixes on a tuple index are invalid
+  --> $DIR/tuple-index-suffix.rs:44:40
    |
-   = help: `i32` is *temporarily* accepted on tuple index fields as it was incorrectly accepted on stable for a few releases
-   = help: on proc macros, you'll want to use `syn::Index::from` or `proc_macro::Literal::*_unsuffixed` for code that will desugar to tuple field access
-   = help: see issue #60210 <https://github.com/rust-lang/rust/issues/60210> for more information
+LL |     let previous_carve_out_i32 = (42,).0i32;
+   |                                        ^^^^ invalid suffix `i32`
 
-warning: suffixes on a tuple index are invalid
-  --> $DIR/tuple-index-suffix.rs:44:31
-   |
-LL |     let carve_out_i32 = (42,).0u32;
-   |                               ^^^^ invalid suffix `u32`
+error: suffixes on a tuple index are invalid
+  --> $DIR/tuple-index-suffix.rs:45:40
    |
-   = help: `u32` is *temporarily* accepted on tuple index fields as it was incorrectly accepted on stable for a few releases
-   = help: on proc macros, you'll want to use `syn::Index::from` or `proc_macro::Literal::*_unsuffixed` for code that will desugar to tuple field access
-   = help: see issue #60210 <https://github.com/rust-lang/rust/issues/60210> for more information
+LL |     let previous_carve_out_i32 = (42,).0u32;
+   |                                        ^^^^ invalid suffix `u32`
 
-warning: suffixes on a tuple index are invalid
-  --> $DIR/tuple-index-suffix.rs:45:33
-   |
-LL |     let carve_out_isize = (42,).0isize;
-   |                                 ^^^^^^ invalid suffix `isize`
+error: suffixes on a tuple index are invalid
+  --> $DIR/tuple-index-suffix.rs:46:42
    |
-   = help: `isize` is *temporarily* accepted on tuple index fields as it was incorrectly accepted on stable for a few releases
-   = help: on proc macros, you'll want to use `syn::Index::from` or `proc_macro::Literal::*_unsuffixed` for code that will desugar to tuple field access
-   = help: see issue #60210 <https://github.com/rust-lang/rust/issues/60210> for more information
+LL |     let previous_carve_out_isize = (42,).0isize;
+   |                                          ^^^^^^ invalid suffix `isize`
 
-warning: suffixes on a tuple index are invalid
-  --> $DIR/tuple-index-suffix.rs:46:33
-   |
-LL |     let carve_out_usize = (42,).0usize;
-   |                                 ^^^^^^ invalid suffix `usize`
+error: suffixes on a tuple index are invalid
+  --> $DIR/tuple-index-suffix.rs:47:42
    |
-   = help: `usize` is *temporarily* accepted on tuple index fields as it was incorrectly accepted on stable for a few releases
-   = help: on proc macros, you'll want to use `syn::Index::from` or `proc_macro::Literal::*_unsuffixed` for code that will desugar to tuple field access
-   = help: see issue #60210 <https://github.com/rust-lang/rust/issues/60210> for more information
+LL |     let previous_carve_out_usize = (42,).0usize;
+   |                                          ^^^^^^ invalid suffix `usize`
 
 error: suffixes on a tuple index are invalid
-  --> $DIR/tuple-index-suffix.rs:49:26
+  --> $DIR/tuple-index-suffix.rs:50:26
    |
 LL |     let error_i8 = (42,).0i8;
    |                          ^^^ invalid suffix `i8`
 
 error: suffixes on a tuple index are invalid
-  --> $DIR/tuple-index-suffix.rs:50:26
+  --> $DIR/tuple-index-suffix.rs:51:26
    |
 LL |     let error_u8 = (42,).0u8;
    |                          ^^^ invalid suffix `u8`
 
 error: suffixes on a tuple index are invalid
-  --> $DIR/tuple-index-suffix.rs:51:27
+  --> $DIR/tuple-index-suffix.rs:52:27
    |
 LL |     let error_i16 = (42,).0i16;
    |                           ^^^^ invalid suffix `i16`
 
 error: suffixes on a tuple index are invalid
-  --> $DIR/tuple-index-suffix.rs:52:27
+  --> $DIR/tuple-index-suffix.rs:53:27
    |
 LL |     let error_u16 = (42,).0u16;
    |                           ^^^^ invalid suffix `u16`
 
 error: suffixes on a tuple index are invalid
-  --> $DIR/tuple-index-suffix.rs:53:27
+  --> $DIR/tuple-index-suffix.rs:54:27
    |
 LL |     let error_i64 = (42,).0i64;
    |                           ^^^^ invalid suffix `i64`
 
 error: suffixes on a tuple index are invalid
-  --> $DIR/tuple-index-suffix.rs:54:27
+  --> $DIR/tuple-index-suffix.rs:55:27
    |
 LL |     let error_u64 = (42,).0u64;
    |                           ^^^^ invalid suffix `u64`
 
 error: suffixes on a tuple index are invalid
-  --> $DIR/tuple-index-suffix.rs:55:28
+  --> $DIR/tuple-index-suffix.rs:56:28
    |
 LL |     let error_i128 = (42,).0i128;
    |                            ^^^^^ invalid suffix `i128`
 
 error: suffixes on a tuple index are invalid
-  --> $DIR/tuple-index-suffix.rs:56:28
+  --> $DIR/tuple-index-suffix.rs:57:28
    |
 LL |     let error_u128 = (42,).0u128;
    |                            ^^^^^ invalid suffix `u128`
 
 error: suffixes on a tuple index are invalid
-  --> $DIR/tuple-index-suffix.rs:60:35
+  --> $DIR/tuple-index-suffix.rs:61:35
    |
 LL |     let invalid_struct_name = X { 0suffix: 0, 1: 1, 2: 2 };
    |                                   ^^^^^^^ invalid suffix `suffix`
 
 error: suffixes on a tuple index are invalid
-  --> $DIR/tuple-index-suffix.rs:63:13
+  --> $DIR/tuple-index-suffix.rs:64:13
    |
 LL |         X { 0suffix: _, .. } => {}
    |             ^^^^^^^ invalid suffix `suffix`
 
-warning: suffixes on a tuple index are invalid
-  --> $DIR/tuple-index-suffix.rs:69:37
+error: suffixes on a tuple index are invalid
+  --> $DIR/tuple-index-suffix.rs:70:37
    |
 LL |     let carve_out_struct_name = X { 0u32: 0, 1: 1, 2: 2 };
    |                                     ^^^^ invalid suffix `u32`
-   |
-   = help: `u32` is *temporarily* accepted on tuple index fields as it was incorrectly accepted on stable for a few releases
-   = help: on proc macros, you'll want to use `syn::Index::from` or `proc_macro::Literal::*_unsuffixed` for code that will desugar to tuple field access
-   = help: see issue #60210 <https://github.com/rust-lang/rust/issues/60210> for more information
 
-warning: suffixes on a tuple index are invalid
-  --> $DIR/tuple-index-suffix.rs:72:13
+error: suffixes on a tuple index are invalid
+  --> $DIR/tuple-index-suffix.rs:73:13
    |
 LL |         X { 0u32: _, .. } => {}
    |             ^^^^ invalid suffix `u32`
-   |
-   = help: `u32` is *temporarily* accepted on tuple index fields as it was incorrectly accepted on stable for a few releases
-   = help: on proc macros, you'll want to use `syn::Index::from` or `proc_macro::Literal::*_unsuffixed` for code that will desugar to tuple field access
-   = help: see issue #60210 <https://github.com/rust-lang/rust/issues/60210> for more information
 
-warning: suffixes on a tuple index are invalid
-  --> $DIR/tuple-index-suffix.rs:83:50
+error: suffixes on a tuple index are invalid
+  --> $DIR/tuple-index-suffix.rs:84:50
    |
 LL |     assert_eq!(std::mem::offset_of!(Struct<u32>, 0usize), 0);
    |                                                  ^^^^^^ invalid suffix `usize`
-   |
-   = help: `usize` is *temporarily* accepted on tuple index fields as it was incorrectly accepted on stable for a few releases
-   = help: on proc macros, you'll want to use `syn::Index::from` or `proc_macro::Literal::*_unsuffixed` for code that will desugar to tuple field access
-   = help: see issue #60210 <https://github.com/rust-lang/rust/issues/60210> for more information
 
 error: suffixes on a tuple index are invalid
-  --> $DIR/tuple-index-suffix.rs:87:50
+  --> $DIR/tuple-index-suffix.rs:88:50
    |
 LL |     assert_eq!(std::mem::offset_of!(Struct<u32>, 0u8), 0);
    |                                                  ^^^ invalid suffix `u8`
 
-error: aborting due to 13 previous errors; 9 warnings emitted
+error: aborting due to 22 previous errors