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

@@ -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>> {

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))

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");
     };
 

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

@@ -1,37 +1,39 @@
-//! 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);
 
 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);