Turn invalid index suffixes into hard errors

9 files changed, 92 insertions, 151 deletions

diff --git a/compiler/rustc_parse/messages.ftl b/compiler/rustc_parse/messages.ftl
index 9e0075c21b9..0d1a3c78389 100644
--- a/compiler/rustc_parse/messages.ftl
+++ b/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
diff --git a/compiler/rustc_parse/src/errors.rs b/compiler/rustc_parse/src/errors.rs
index a105dd1909e..8a10e7d05eb 100644
--- a/compiler/rustc_parse/src/errors.rs
+++ b/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)]
diff --git a/compiler/rustc_parse/src/parser/expr.rs b/compiler/rustc_parse/src/parser/expr.rs
index d0604f76317..7d33f3de15c 100644
--- a/compiler/rustc_parse/src/parser/expr.rs
+++ b/compiler/rustc_parse/src/parser/expr.rs
@@ -1163,7 +1163,10 @@ impl<'a> Parser<'a> {
                         suffix,
                     }) => {
                         if let Some(suffix) = suffix {
-                            self.expect_no_tuple_index_suffix(current.span, suffix);
+                            self.dcx().emit_err(errors::InvalidLiteralSuffixOnTupleIndex {
+                                span: current.span,
+                                suffix,
+                            });
                         }
                         match self.break_up_float(symbol, current.span) {
                             // 1e2
@@ -1239,7 +1242,8 @@ impl<'a> Parser<'a> {
         suffix: Option<Symbol>,
     ) -> Box<Expr> {
         if let Some(suffix) = suffix {
-            self.expect_no_tuple_index_suffix(ident_span, suffix);
+            self.dcx()
+                .emit_err(errors::InvalidLiteralSuffixOnTupleIndex { span: ident_span, suffix });
         }
         self.mk_expr(lo.to(ident_span), ExprKind::Field(base, Ident::new(field, ident_span)))
     }
@@ -2225,24 +2229,6 @@ 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,
-            });
-        }
-    }
-
     /// Matches `'-' lit | lit` (cf. `ast_validation::AstValidator::check_expr_within_pat`).
     /// Keep this in sync with `Token::can_begin_literal_maybe_minus`.
     pub fn parse_literal_maybe_minus(&mut self) -> PResult<'a, Box<Expr>> {
diff --git a/compiler/rustc_parse/src/parser/mod.rs b/compiler/rustc_parse/src/parser/mod.rs
index 41ed1f95a01..db72faf4ec7 100644
--- a/compiler/rustc_parse/src/parser/mod.rs
+++ b/compiler/rustc_parse/src/parser/mod.rs
@@ -1333,7 +1333,10 @@ impl<'a> Parser<'a> {
         if let token::Literal(token::Lit { kind: token::Integer, symbol, suffix }) = self.token.kind
         {
             if let Some(suffix) = suffix {
-                self.expect_no_tuple_index_suffix(self.token.span, suffix);
+                self.dcx().emit_err(errors::InvalidLiteralSuffixOnTupleIndex {
+                    span: self.token.span,
+                    suffix,
+                });
             }
             self.bump();
             Ok(Ident::new(symbol, self.prev_token.span))
diff --git a/tests/ui/parser/auxiliary/tuple-index-suffix-proc-macro-aux.rs b/tests/ui/parser/auxiliary/tuple-index-suffix-proc-macro-aux.rs
index fa40ed948a6..a5084b55aac 100644
--- a/tests/ui/parser/auxiliary/tuple-index-suffix-proc-macro-aux.rs
+++ b/tests/ui/parser/auxiliary/tuple-index-suffix-proc-macro-aux.rs
@@ -18,14 +18,14 @@ pub fn bad_tup_indexing(input: TokenStream) -> TokenStream {
 pub fn bad_tup_struct_indexing(input: TokenStream) -> TokenStream {
     let mut input = input.into_iter();
 
-    let id_tt = input.next().unwrap();
+    let ident = input.next().unwrap();
     let _comma = input.next().unwrap();
-    let tt = input.next().unwrap();
+    let lit = input.next().unwrap();
 
-    let TokenTree::Ident(ident) = id_tt else {
+    let TokenTree::Ident(ident) = ident else {
         unreachable!("id");
     };
-    let TokenTree::Literal(indexing_expr) = tt else {
+    let TokenTree::Literal(indexing_expr) = lit else {
         unreachable!("lit");
     };
 
diff --git a/tests/ui/parser/tuple-index-suffix-proc-macro.rs b/tests/ui/parser/tuple-index-suffix-proc-macro.rs
index feca6f9cdfb..557c67738d3 100644
--- a/tests/ui/parser/tuple-index-suffix-proc-macro.rs
+++ b/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.
 
diff --git a/tests/ui/parser/tuple-index-suffix-proc-macro.stderr b/tests/ui/parser/tuple-index-suffix-proc-macro.stderr
index c8bc3a4576b..47d179d3555 100644
--- a/tests/ui/parser/tuple-index-suffix-proc-macro.stderr
+++ b/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
 
diff --git a/tests/ui/parser/tuple-index-suffix.rs b/tests/ui/parser/tuple-index-suffix.rs
index 31c5bc25063..c4769500005 100644
--- a/tests/ui/parser/tuple-index-suffix.rs
+++ b/tests/ui/parser/tuple-index-suffix.rs
@@ -1,8 +1,10 @@
-//! See #60210.
+//! Regression test for both the original regression in #59418 where invalid suffixes in indexing
+//! positions were accidentally accepted, and also for the removal of the temporary carve out that
+//! mitigated ecosystem impact following trying to reject #59418 (this was implemented as a FCW
+//! tracked in #60210).
 //!
 //! Check that we hard error on invalid suffixes in tuple indexing subexpressions and struct numeral
-//! field names, modulo carve-outs for `{i,u}{32,usize}` at warning level to mitigate ecosystem
-//! impact.
+//! field names.
 
 struct X(i32,i32,i32);
 
@@ -10,28 +12,28 @@ 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 (#60210), 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
@@ -53,12 +55,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
     }
 }
 
@@ -67,9 +69,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);
diff --git a/tests/ui/parser/tuple-index-suffix.stderr b/tests/ui/parser/tuple-index-suffix.stderr
index 3a499dd6a8d..6d96c6d3cbf 100644
--- a/tests/ui/parser/tuple-index-suffix.stderr
+++ b/tests/ui/parser/tuple-index-suffix.stderr
@@ -1,170 +1,134 @@
 error: suffixes on a tuple index are invalid
-  --> $DIR/tuple-index-suffix.rs:11:48
+  --> $DIR/tuple-index-suffix.rs:13: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:13: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:15: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:17:34
+  --> $DIR/tuple-index-suffix.rs:19:34
    |
 LL |     let invalid_tup_suffix = tup.0suffix;
    |                                  ^^^^^^^ invalid suffix `suffix`
 
-warning: suffixes on a tuple index are invalid
-  --> $DIR/tuple-index-suffix.rs:19: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:21: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:31:31
-   |
-LL |     let carve_out_i32 = (42,).0i32;
-   |                               ^^^^ invalid suffix `i32`
+error: suffixes on a tuple index are invalid
+  --> $DIR/tuple-index-suffix.rs:33: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:32:31
-   |
-LL |     let carve_out_i32 = (42,).0u32;
-   |                               ^^^^ invalid suffix `u32`
+error: suffixes on a tuple index are invalid
+  --> $DIR/tuple-index-suffix.rs:34: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:33:33
-   |
-LL |     let carve_out_isize = (42,).0isize;
-   |                                 ^^^^^^ invalid suffix `isize`
+error: suffixes on a tuple index are invalid
+  --> $DIR/tuple-index-suffix.rs:35: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:34:33
-   |
-LL |     let carve_out_usize = (42,).0usize;
-   |                                 ^^^^^^ invalid suffix `usize`
+error: suffixes on a tuple index are invalid
+  --> $DIR/tuple-index-suffix.rs:36: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:37:26
+  --> $DIR/tuple-index-suffix.rs:39:26
    |
 LL |     let error_i8 = (42,).0i8;
    |                          ^^^ invalid suffix `i8`
 
 error: suffixes on a tuple index are invalid
-  --> $DIR/tuple-index-suffix.rs:38:26
+  --> $DIR/tuple-index-suffix.rs:40:26
    |
 LL |     let error_u8 = (42,).0u8;
    |                          ^^^ invalid suffix `u8`
 
 error: suffixes on a tuple index are invalid
-  --> $DIR/tuple-index-suffix.rs:39:27
+  --> $DIR/tuple-index-suffix.rs:41:27
    |
 LL |     let error_i16 = (42,).0i16;
    |                           ^^^^ invalid suffix `i16`
 
 error: suffixes on a tuple index are invalid
-  --> $DIR/tuple-index-suffix.rs:40:27
+  --> $DIR/tuple-index-suffix.rs:42:27
    |
 LL |     let error_u16 = (42,).0u16;
    |                           ^^^^ invalid suffix `u16`
 
 error: suffixes on a tuple index are invalid
-  --> $DIR/tuple-index-suffix.rs:41:27
+  --> $DIR/tuple-index-suffix.rs:43:27
    |
 LL |     let error_i64 = (42,).0i64;
    |                           ^^^^ invalid suffix `i64`
 
 error: suffixes on a tuple index are invalid
-  --> $DIR/tuple-index-suffix.rs:42:27
+  --> $DIR/tuple-index-suffix.rs:44:27
    |
 LL |     let error_u64 = (42,).0u64;
    |                           ^^^^ invalid suffix `u64`
 
 error: suffixes on a tuple index are invalid
-  --> $DIR/tuple-index-suffix.rs:43:28
+  --> $DIR/tuple-index-suffix.rs:45:28
    |
 LL |     let error_i128 = (42,).0i128;
    |                            ^^^^^ invalid suffix `i128`
 
 error: suffixes on a tuple index are invalid
-  --> $DIR/tuple-index-suffix.rs:44:28
+  --> $DIR/tuple-index-suffix.rs:46:28
    |
 LL |     let error_u128 = (42,).0u128;
    |                            ^^^^^ invalid suffix `u128`
 
 error: suffixes on a tuple index are invalid
-  --> $DIR/tuple-index-suffix.rs:48:35
+  --> $DIR/tuple-index-suffix.rs:50: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:51:13
+  --> $DIR/tuple-index-suffix.rs:53:13
    |
 LL |         X { 0suffix: _, .. } => {}
    |             ^^^^^^^ invalid suffix `suffix`
 
-warning: suffixes on a tuple index are invalid
-  --> $DIR/tuple-index-suffix.rs:57:37
+error: suffixes on a tuple index are invalid
+  --> $DIR/tuple-index-suffix.rs:59: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:60:13
+error: suffixes on a tuple index are invalid
+  --> $DIR/tuple-index-suffix.rs:62: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:71:50
+error: suffixes on a tuple index are invalid
+  --> $DIR/tuple-index-suffix.rs:73: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:75:50
+  --> $DIR/tuple-index-suffix.rs:77: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