Reject integer suffix when tuple indexing

src/libsyntax/parse/parser.rs

@@ -1119,9 +1119,8 @@ impl<'a> Parser<'a> {
                 if text.is_empty() {
                     self.span_bug(sp, "found empty literal suffix in Some")
                 }
-                let msg = format!("{} with a suffix is invalid", kind);
-                self.struct_span_err(sp, &msg)
-                    .span_label(sp, msg)
+                self.struct_span_err(sp, &format!("suffixes on {} are invalid", kind))
+                    .span_label(sp, format!("invalid suffix `{}`", text))
                     .emit();
             }
         }
@@ -2150,7 +2149,7 @@ impl<'a> Parser<'a> {
 
                 if suffix_illegal {
                     let sp = self.span;
-                    self.expect_no_suffix(sp, lit.literal_name(), suf)
+                    self.expect_no_suffix(sp, &format!("a {}", lit.literal_name()), suf)
                 }
 
                 result.unwrap()
@@ -2492,7 +2491,8 @@ impl<'a> Parser<'a> {
     }
 
     fn parse_field_name(&mut self) -> PResult<'a, Ident> {
-        if let token::Literal(token::Integer(name), None) = self.token {
+        if let token::Literal(token::Integer(name), suffix) = self.token {
+            self.expect_no_suffix(self.span, "a tuple index", suffix);
             self.bump();
             Ok(Ident::new(name, self.prev_span))
         } else {
@@ -3199,11 +3199,13 @@ impl<'a> Parser<'a> {
                     token::Ident(..) => {
                         e = self.parse_dot_suffix(e, lo)?;
                     }
-                  token::Literal(token::Integer(name), _) => {
+                    token::Literal(token::Integer(name), suffix) => {
                         let span = self.span;
                         self.bump();
                         let field = ExprKind::Field(e, Ident::new(name, span));
                         e = self.mk_expr(lo.to(span), field, ThinVec::new());
+
+                        self.expect_no_suffix(span, "a tuple index", suffix);
                     }
                     token::Literal(token::Float(n), _suf) => {
                       self.bump();
@@ -7789,7 +7791,7 @@ impl<'a> Parser<'a> {
         match self.token {
             token::Literal(token::Str_(s), suf) | token::Literal(token::StrRaw(s, _), suf) => {
                 let sp = self.span;
-                self.expect_no_suffix(sp, "ABI spec", suf);
+                self.expect_no_suffix(sp, "an ABI spec", suf);
                 self.bump();
                 match abi::lookup(&s.as_str()) {
                     Some(abi) => Ok(Some(abi)),
@@ -8610,7 +8612,7 @@ impl<'a> Parser<'a> {
         match self.parse_optional_str() {
             Some((s, style, suf)) => {
                 let sp = self.prev_span;
-                self.expect_no_suffix(sp, "string literal", suf);
+                self.expect_no_suffix(sp, "a string literal", suf);
                 Ok((s, style))
             }
             _ => {

src/test/ui/parser/bad-lit-suffixes.rs

@@ -2,20 +2,20 @@
 
 
 extern
-    "C"suffix //~ ERROR ABI spec with a suffix is invalid
+    "C"suffix //~ ERROR suffixes on an ABI spec are invalid
     fn foo() {}
 
 extern
-    "C"suffix //~ ERROR ABI spec with a suffix is invalid
+    "C"suffix //~ ERROR suffixes on an ABI spec are invalid
 {}
 
 fn main() {
-    ""suffix; //~ ERROR string literal with a suffix is invalid
-    b""suffix; //~ ERROR byte string literal with a suffix is invalid
-    r#""#suffix; //~ ERROR string literal with a suffix is invalid
-    br#""#suffix; //~ ERROR byte string literal with a suffix is invalid
-    'a'suffix; //~ ERROR char literal with a suffix is invalid
-    b'a'suffix; //~ ERROR byte literal with a suffix is invalid
+    ""suffix; //~ ERROR suffixes on a string literal are invalid
+    b""suffix; //~ ERROR suffixes on a byte string literal are invalid
+    r#""#suffix; //~ ERROR suffixes on a string literal are invalid
+    br#""#suffix; //~ ERROR suffixes on a byte string literal are invalid
+    'a'suffix; //~ ERROR suffixes on a char literal are invalid
+    b'a'suffix; //~ ERROR suffixes on a byte literal are invalid
 
     1234u1024; //~ ERROR invalid width `1024` for integer literal
     1234i1024; //~ ERROR invalid width `1024` for integer literal

src/test/ui/parser/bad-lit-suffixes.stderr

@@ -1,50 +1,50 @@
-error: ABI spec with a suffix is invalid
+error: suffixes on an ABI spec are invalid
   --> $DIR/bad-lit-suffixes.rs:5:5
    |
 LL |     "C"suffix
-   |     ^^^^^^^^^ ABI spec with a suffix is invalid
+   |     ^^^^^^^^^ invalid suffix `suffix`
 
-error: ABI spec with a suffix is invalid
+error: suffixes on an ABI spec are invalid
   --> $DIR/bad-lit-suffixes.rs:9:5
    |
 LL |     "C"suffix
-   |     ^^^^^^^^^ ABI spec with a suffix is invalid
+   |     ^^^^^^^^^ invalid suffix `suffix`
 
-error: string literal with a suffix is invalid
+error: suffixes on a string literal are invalid
   --> $DIR/bad-lit-suffixes.rs:13:5
    |
 LL |     ""suffix;
-   |     ^^^^^^^^ string literal with a suffix is invalid
+   |     ^^^^^^^^ invalid suffix `suffix`
 
-error: byte string literal with a suffix is invalid
+error: suffixes on a byte string literal are invalid
   --> $DIR/bad-lit-suffixes.rs:14:5
    |
 LL |     b""suffix;
-   |     ^^^^^^^^^ byte string literal with a suffix is invalid
+   |     ^^^^^^^^^ invalid suffix `suffix`
 
-error: string literal with a suffix is invalid
+error: suffixes on a string literal are invalid
   --> $DIR/bad-lit-suffixes.rs:15:5
    |
 LL |     r#""#suffix;
-   |     ^^^^^^^^^^^ string literal with a suffix is invalid
+   |     ^^^^^^^^^^^ invalid suffix `suffix`
 
-error: byte string literal with a suffix is invalid
+error: suffixes on a byte string literal are invalid
   --> $DIR/bad-lit-suffixes.rs:16:5
    |
 LL |     br#""#suffix;
-   |     ^^^^^^^^^^^^ byte string literal with a suffix is invalid
+   |     ^^^^^^^^^^^^ invalid suffix `suffix`
 
-error: char literal with a suffix is invalid
+error: suffixes on a char literal are invalid
   --> $DIR/bad-lit-suffixes.rs:17:5
    |
 LL |     'a'suffix;
-   |     ^^^^^^^^^ char literal with a suffix is invalid
+   |     ^^^^^^^^^ invalid suffix `suffix`
 
-error: byte literal with a suffix is invalid
+error: suffixes on a byte literal are invalid
   --> $DIR/bad-lit-suffixes.rs:18:5
    |
 LL |     b'a'suffix;
-   |     ^^^^^^^^^^ byte literal with a suffix is invalid
+   |     ^^^^^^^^^^ invalid suffix `suffix`
 
 error: invalid width `1024` for integer literal
   --> $DIR/bad-lit-suffixes.rs:20:5

src/test/ui/parser/issue-59418.rs

@@ -0,0 +1,18 @@
+struct X(i32,i32,i32);
+
+fn main() {
+    let a = X(1, 2, 3);
+    let b = a.1suffix;
+    //~^ ERROR suffixes on a tuple index are invalid
+    println!("{}", b);
+    let c = (1, 2, 3);
+    let d = c.1suffix;
+    //~^ ERROR suffixes on a tuple index are invalid
+    println!("{}", d);
+    let s = X { 0suffix: 0, 1: 1, 2: 2 };
+    //~^ ERROR suffixes on a tuple index are invalid
+    match s {
+        X { 0suffix: _, .. } => {}
+        //~^ ERROR suffixes on a tuple index are invalid
+    }
+}

src/test/ui/parser/issue-59418.stderr

@@ -0,0 +1,26 @@
+error: suffixes on a tuple index are invalid
+  --> $DIR/issue-59418.rs:5:15
+   |
+LL |     let b = a.1suffix;
+   |               ^^^^^^^ invalid suffix `suffix`
+
+error: suffixes on a tuple index are invalid
+  --> $DIR/issue-59418.rs:9:15
+   |
+LL |     let d = c.1suffix;
+   |               ^^^^^^^ invalid suffix `suffix`
+
+error: suffixes on a tuple index are invalid
+  --> $DIR/issue-59418.rs:12:17
+   |
+LL |     let s = X { 0suffix: 0, 1: 1, 2: 2 };
+   |                 ^^^^^^^ invalid suffix `suffix`
+
+error: suffixes on a tuple index are invalid
+  --> $DIR/issue-59418.rs:15:13
+   |
+LL |         X { 0suffix: _, .. } => {}
+   |             ^^^^^^^ invalid suffix `suffix`
+
+error: aborting due to 4 previous errors
+