Replace illegal with invalid in most diagnostics

nagisa · nagisa · commit cca0ea718d36 · 2015-07-29T01:59:31.000+03:00
diff --git a/src/librustc/middle/resolve_lifetime.rs b/src/librustc/middle/resolve_lifetime.rs
@@ -674,8 +674,7 @@ impl<'a> LifetimeContext<'a> {
             for lifetime in lifetimes {
                 if special_idents.iter().any(|&i| i.name == lifetime.lifetime.name) {
                     span_err!(self.sess, lifetime.lifetime.span, E0262,
-                        "illegal lifetime parameter name: `{}`",
-                                lifetime.lifetime.name);
+                        "invalid lifetime parameter name: `{}`", lifetime.lifetime.name);
                 }
             }
 
diff --git a/src/librustc_trans/trans/expr.rs b/src/librustc_trans/trans/expr.rs
@@ -2325,7 +2325,7 @@ fn deref_once<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
         _ => {
             bcx.tcx().sess.span_bug(
                 expr.span,
-                &format!("deref invoked on expr of illegal type {:?}",
+                &format!("deref invoked on expr of invalid type {:?}",
                         datum.ty));
         }
     };
diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs
@@ -3468,7 +3468,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>,
         let tcx = fcx.tcx();
         if !tcx.expr_is_lval(&**lhs) {
             span_err!(tcx.sess, expr.span, E0070,
-                "illegal left-hand side expression");
+                "invalid left-hand side expression");
         }
 
         let lhs_ty = fcx.expr_ty(&**lhs);
diff --git a/src/librustc_typeck/check/op.rs b/src/librustc_typeck/check/op.rs
@@ -57,7 +57,7 @@ pub fn check_binop_assign<'a,'tcx>(fcx: &FnCtxt<'a,'tcx>,
 
     let tcx = fcx.tcx();
     if !tcx.expr_is_lval(lhs_expr) {
-        span_err!(tcx.sess, lhs_expr.span, E0067, "illegal left-hand side expression");
+        span_err!(tcx.sess, lhs_expr.span, E0067, "invalid left-hand side expression");
     }
 
     fcx.require_expr_have_sized_type(lhs_expr, traits::AssignmentLhsSized);
diff --git a/src/libsyntax/parse/lexer/mod.rs b/src/libsyntax/parse/lexer/mod.rs
@@ -694,7 +694,7 @@ impl<'a> StringReader<'a> {
             accum_int *= 16;
             accum_int += c.to_digit(16).unwrap_or_else(|| {
                 self.err_span_char(self.last_pos, self.pos,
-                              "illegal character in numeric character escape", c);
+                              "invalid character in numeric character escape", c);
 
                 valid = false;
                 0
@@ -714,7 +714,7 @@ impl<'a> StringReader<'a> {
             Some(_) => valid,
             None => {
                 let last_bpos = self.last_pos;
-                self.err_span_(start_bpos, last_bpos, "illegal numeric character escape");
+                self.err_span_(start_bpos, last_bpos, "invalid numeric character escape");
                 false
             }
         }
@@ -846,7 +846,7 @@ impl<'a> StringReader<'a> {
                                      "unterminated unicode escape (needed a `}`)");
                 } else {
                     self.err_span_char(self.last_pos, self.pos,
-                                   "illegal character in unicode escape", c);
+                                   "invalid character in unicode escape", c);
                 }
                 valid = false;
                 0
@@ -862,7 +862,7 @@ impl<'a> StringReader<'a> {
         }
 
         if valid && (char::from_u32(accum_int).is_none() || count == 0) {
-            self.err_span_(start_bpos, self.last_pos, "illegal unicode character escape");
+            self.err_span_(start_bpos, self.last_pos, "invalid unicode character escape");
             valid = false;
         }
 
@@ -1138,8 +1138,8 @@ impl<'a> StringReader<'a> {
                 let last_bpos = self.last_pos;
                 let curr_char = self.curr.unwrap();
                 self.fatal_span_char(start_bpos, last_bpos,
-                                "only `#` is allowed in raw string delimitation; \
-                                 found illegal character",
+                                "found invalid character; \
+                                 only `#` is allowed in raw string delimitation",
                                 curr_char);
             }
             self.bump();
@@ -1323,8 +1323,8 @@ impl<'a> StringReader<'a> {
             let last_pos = self.last_pos;
             let ch = self.curr.unwrap();
             self.fatal_span_char(start_bpos, last_pos,
-                            "only `#` is allowed in raw string delimitation; \
-                             found illegal character",
+                            "found invalid character; \
+                             only `#` is allowed in raw string delimitation",
                             ch);
         }
         self.bump();
diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs
@@ -446,11 +446,11 @@ fn filtered_float_lit(data: token::InternedString, suffix: Option<&str>,
         Some(suf) => {
             if suf.len() >= 2 && looks_like_width_suffix(&['f'], suf) {
                 // if it looks like a width, lets try to be helpful.
-                sd.span_err(sp, &*format!("illegal width `{}` for float literal, \
-                                          valid widths are 32 and 64", &suf[1..]));
+                sd.span_err(sp, &*format!("invalid width `{}` for float literal", &suf[1..]));
+                sd.fileline_help(sp, "valid widths are 32 and 64");
             } else {
-                sd.span_err(sp, &*format!("illegal suffix `{}` for float literal, \
-                                          valid suffixes are `f32` and `f64`", suf));
+                sd.span_err(sp, &*format!("invalid suffix `{}` for float literal", suf));
+                sd.fileline_help(sp, "valid suffixes are `f32` and `f64`");
             }
 
             ast::LitFloatUnsuffixed(data)
@@ -619,11 +619,11 @@ pub fn integer_lit(s: &str,
                 // i<digits> and u<digits> look like widths, so lets
                 // give an error message along those lines
                 if looks_like_width_suffix(&['i', 'u'], suf) {
-                    sd.span_err(sp, &*format!("illegal width `{}` for integer literal; \
-                                              valid widths are 8, 16, 32 and 64",
+                    sd.span_err(sp, &*format!("invalid width `{}` for integer literal",
                                               &suf[1..]));
+                    sd.fileline_help(sp, "valid widths are 8, 16, 32 and 64");
                 } else {
-                    sd.span_err(sp, &*format!("illegal suffix `{}` for numeric literal", suf));
+                    sd.span_err(sp, &*format!("invalid suffix `{}` for numeric literal", suf));
                     sd.fileline_help(sp, "the suffix must be one of the integral types \
                                       (`u32`, `isize`, etc)");
                 }
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
@@ -681,7 +681,7 @@ impl<'a> Parser<'a> {
                 if text.is_empty() {
                     self.span_bug(sp, "found empty literal suffix in Some")
                 }
-                self.span_err(sp, &*format!("{} with a suffix is illegal", kind));
+                self.span_err(sp, &*format!("{} with a suffix is invalid", kind));
             }
         }
     }
@@ -5286,7 +5286,7 @@ impl<'a> Parser<'a> {
                         let last_span = self.last_span;
                         self.span_err(
                             last_span,
-                            &format!("illegal ABI: expected one of [{}], \
+                            &format!("invalid ABI: expected one of [{}], \
                                      found `{}`",
                                     abi::all_names().join(", "),
                                     s));
diff --git a/src/test/compile-fail/bad-expr-lhs.rs b/src/test/compile-fail/bad-expr-lhs.rs
@@ -9,12 +9,12 @@
 // except according to those terms.
 
 fn main() {
-    1 = 2; //~ ERROR illegal left-hand side expression
-    1 += 2; //~ ERROR illegal left-hand side expression
-    (1, 2) = (3, 4); //~ ERROR illegal left-hand side expression
+    1 = 2; //~ ERROR invalid left-hand side expression
+    1 += 2; //~ ERROR invalid left-hand side expression
+    (1, 2) = (3, 4); //~ ERROR invalid left-hand side expression
 
     let (a, b) = (1, 2);
-    (a, b) = (3, 4); //~ ERROR illegal left-hand side expression
+    (a, b) = (3, 4); //~ ERROR invalid left-hand side expression
 
-    None = Some(3); //~ ERROR illegal left-hand side expression
+    None = Some(3); //~ ERROR invalid left-hand side expression
 }
diff --git a/src/test/compile-fail/issue-13407.rs b/src/test/compile-fail/issue-13407.rs
@@ -14,6 +14,6 @@ mod A {
 
 fn main() {
     A::C = 1;
-    //~^ ERROR: illegal left-hand side expression
+    //~^ ERROR: invalid left-hand side expression
     //~| ERROR: mismatched types
 }
diff --git a/src/test/compile-fail/old-suffixes-are-really-forbidden.rs b/src/test/compile-fail/old-suffixes-are-really-forbidden.rs
@@ -9,6 +9,6 @@
 // except according to those terms.
 
 fn main() {
-    let a = 1_is; //~ ERROR illegal suffix
-    let b = 2_us; //~ ERROR illegal suffix
+    let a = 1_is; //~ ERROR invalid suffix
+    let b = 2_us; //~ ERROR invalid suffix
 }
diff --git a/src/test/compile-fail/regions-name-static.rs b/src/test/compile-fail/regions-name-static.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-struct Foo<'static> { //~ ERROR illegal lifetime parameter name: `'static`
+struct Foo<'static> { //~ ERROR invalid lifetime parameter name: `'static`
     x: &'static isize
 }
 
diff --git a/src/test/parse-fail/bad-lit-suffixes.rs b/src/test/parse-fail/bad-lit-suffixes.rs
@@ -12,28 +12,28 @@
 
 
 extern
-    "C"suffix //~ ERROR ABI spec with a suffix is illegal
+    "C"suffix //~ ERROR ABI spec with a suffix is invalid
     fn foo() {}
 
 extern
-    "C"suffix //~ ERROR ABI spec with a suffix is illegal
+    "C"suffix //~ ERROR ABI spec with a suffix is invalid
 {}
 
 fn main() {
-    ""suffix; //~ ERROR str literal with a suffix is illegal
-    b""suffix; //~ ERROR binary str literal with a suffix is illegal
-    r#""#suffix; //~ ERROR str literal with a suffix is illegal
-    br#""#suffix; //~ ERROR binary str literal with a suffix is illegal
-    'a'suffix; //~ ERROR char literal with a suffix is illegal
-    b'a'suffix; //~ ERROR byte literal with a suffix is illegal
+    ""suffix; //~ ERROR str literal with a suffix is invalid
+    b""suffix; //~ ERROR binary str literal with a suffix is invalid
+    r#""#suffix; //~ ERROR str literal with a suffix is invalid
+    br#""#suffix; //~ ERROR binary str 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
 
-    1234u1024; //~ ERROR illegal width `1024` for integer literal
-    1234i1024; //~ ERROR illegal width `1024` for integer literal
-    1234f1024; //~ ERROR illegal width `1024` for float literal
-    1234.5f1024; //~ ERROR illegal width `1024` for float literal
+    1234u1024; //~ ERROR invalid width `1024` for integer literal
+    1234i1024; //~ ERROR invalid width `1024` for integer literal
+    1234f1024; //~ ERROR invalid width `1024` for float literal
+    1234.5f1024; //~ ERROR invalid width `1024` for float literal
 
-    1234suffix; //~ ERROR illegal suffix `suffix` for numeric literal
-    0b101suffix; //~ ERROR illegal suffix `suffix` for numeric literal
-    1.0suffix; //~ ERROR illegal suffix `suffix` for float literal
-    1.0e10suffix; //~ ERROR illegal suffix `suffix` for float literal
+    1234suffix; //~ ERROR invalid suffix `suffix` for numeric literal
+    0b101suffix; //~ ERROR invalid suffix `suffix` for numeric literal
+    1.0suffix; //~ ERROR invalid suffix `suffix` for float literal
+    1.0e10suffix; //~ ERROR invalid suffix `suffix` for float literal
 }
diff --git a/src/test/parse-fail/byte-literals.rs b/src/test/parse-fail/byte-literals.rs
@@ -17,7 +17,7 @@ static FOO: u8 = b'\f';  //~ ERROR unknown byte escape
 
 pub fn main() {
     b'\f';  //~ ERROR unknown byte escape
-    b'\x0Z';  //~ ERROR illegal character in numeric character escape: Z
+    b'\x0Z';  //~ ERROR invalid character in numeric character escape: Z
     b'	';  //~ ERROR byte constant must be escaped
     b''';  //~ ERROR byte constant must be escaped
     b'é';  //~ ERROR byte constant must be ASCII
diff --git a/src/test/parse-fail/byte-string-literals.rs b/src/test/parse-fail/byte-string-literals.rs
@@ -17,7 +17,7 @@ static FOO: &'static [u8] = b"\f";  //~ ERROR unknown byte escape
 
 pub fn main() {
     b"\f";  //~ ERROR unknown byte escape
-    b"\x0Z";  //~ ERROR illegal character in numeric character escape: Z
+    b"\x0Z";  //~ ERROR invalid character in numeric character escape: Z
     b"é";  //~ ERROR byte constant must be ASCII
     b"a  //~ ERROR unterminated double quote byte string
 }
diff --git a/src/test/parse-fail/issue-23620-invalid-escapes.rs b/src/test/parse-fail/issue-23620-invalid-escapes.rs
@@ -23,25 +23,25 @@ fn main() {
     //~^ ERROR numeric character escape is too short
 
     let _ = b'\xxy';
-    //~^ ERROR illegal character in numeric character escape: x
-    //~^^ ERROR illegal character in numeric character escape: y
+    //~^ ERROR invalid character in numeric character escape: x
+    //~^^ ERROR invalid character in numeric character escape: y
 
     let _ = '\x5';
     //~^ ERROR numeric character escape is too short
 
     let _ = '\xxy';
-    //~^ ERROR illegal character in numeric character escape: x
-    //~^^ ERROR illegal character in numeric character escape: y
+    //~^ ERROR invalid character in numeric character escape: x
+    //~^^ ERROR invalid character in numeric character escape: y
 
     let _ = b"\u{a4a4} \xf \u";
     //~^ ERROR unicode escape sequences cannot be used as a byte or in a byte string
-    //~^^ ERROR illegal character in numeric character escape:
+    //~^^ ERROR invalid character in numeric character escape:
     //~^^^ ERROR incorrect unicode escape sequence
     //~^^^^ ERROR unicode escape sequences cannot be used as a byte or in a byte string
 
     let _ = "\u{ffffff} \xf \u";
-    //~^ ERROR illegal unicode character escape
-    //~^^ ERROR illegal character in numeric character escape:
+    //~^ ERROR invalid unicode character escape
+    //~^^ ERROR invalid character in numeric character escape:
     //~^^^ ERROR form of character escape may only be used with characters in the range [\x00-\x7f]
     //~^^^^ ERROR incorrect unicode escape sequence
 }
diff --git a/src/test/parse-fail/issue-8537.rs b/src/test/parse-fail/issue-8537.rs
@@ -11,7 +11,7 @@
 // compile-flags: -Z parse-only
 
 pub extern
-  "invalid-ab_isize" //~ ERROR illegal ABI
+  "invalid-ab_isize" //~ ERROR invalid ABI
 fn foo() {}
 
 fn main() {}
diff --git a/src/test/parse-fail/new-unicode-escapes-3.rs b/src/test/parse-fail/new-unicode-escapes-3.rs
@@ -11,5 +11,5 @@
 // compile-flags: -Z parse-only
 
 pub fn main() {
-    let s = "\u{d805}"; //~ ERROR illegal unicode character escape
+    let s = "\u{d805}"; //~ ERROR invalid unicode character escape
 }
diff --git a/src/test/parse-fail/new-unicode-escapes-4.rs b/src/test/parse-fail/new-unicode-escapes-4.rs
@@ -12,7 +12,7 @@
 
 pub fn main() {
     let s = "\u{lol}";
-     //~^ ERROR illegal character in unicode escape: l
-     //~^^ ERROR illegal character in unicode escape: o
-     //~^^^ ERROR illegal character in unicode escape: l
+     //~^ ERROR invalid character in unicode escape: l
+     //~^^ ERROR invalid character in unicode escape: o
+     //~^^^ ERROR invalid character in unicode escape: l
 }
diff --git a/src/test/parse-fail/raw-str-delim.rs b/src/test/parse-fail/raw-str-delim.rs
@@ -11,5 +11,5 @@
 // compile-flags: -Z parse-only
 
 static s: &'static str =
-    r#x"#"x# //~ ERROR only `#` is allowed in raw string delimitation; found illegal character
+    r#x"#"x# //~ ERROR found invalid character; only `#` is allowed in raw string delimitation
 ;

Original file line number	Diff line number	Diff line change
`@@ -674,8 +674,7 @@ impl<'a> LifetimeContext<'a> {`
`674`	`674`	`for lifetime in lifetimes {`
`675`	`675`	`if special_idents.iter().any(\|&i\| i.name == lifetime.lifetime.name) {`
`676`	`676`	`span_err!(self.sess, lifetime.lifetime.span, E0262,`
`677`		- "illegal lifetime parameter name: `{}`",
`678`		`- lifetime.lifetime.name);`
	`677`	+ "invalid lifetime parameter name: `{}`", lifetime.lifetime.name);
`679`	`678`	`}`
`680`	`679`	`}`
`681`	`680`
Original file line number	Diff line number	Diff line change
`@@ -2325,7 +2325,7 @@ fn deref_once<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,`
`2325`	`2325`	`_ => {`
`2326`	`2326`	`bcx.tcx().sess.span_bug(`
`2327`	`2327`	`expr.span,`
`2328`		`- &format!("deref invoked on expr of illegal type {:?}",`
	`2328`	`+ &format!("deref invoked on expr of invalid type {:?}",`
`2329`	`2329`	`datum.ty));`
`2330`	`2330`	`}`
`2331`	`2331`	`};`
Original file line number	Diff line number	Diff line change
`@@ -3468,7 +3468,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>,`
`3468`	`3468`	`let tcx = fcx.tcx();`
`3469`	`3469`	`if !tcx.expr_is_lval(&**lhs) {`
`3470`	`3470`	`span_err!(tcx.sess, expr.span, E0070,`
`3471`		`- "illegal left-hand side expression");`
	`3471`	`+ "invalid left-hand side expression");`
`3472`	`3472`	`}`
`3473`	`3473`
`3474`	`3474`	`let lhs_ty = fcx.expr_ty(&**lhs);`
Original file line number	Diff line number	Diff line change
`@@ -57,7 +57,7 @@ pub fn check_binop_assign<'a,'tcx>(fcx: &FnCtxt<'a,'tcx>,`
`57`	`57`
`58`	`58`	`let tcx = fcx.tcx();`
`59`	`59`	`if !tcx.expr_is_lval(lhs_expr) {`
`60`		`- span_err!(tcx.sess, lhs_expr.span, E0067, "illegal left-hand side expression");`
	`60`	`+ span_err!(tcx.sess, lhs_expr.span, E0067, "invalid left-hand side expression");`
`61`	`61`	`}`
`62`	`62`
`63`	`63`	`fcx.require_expr_have_sized_type(lhs_expr, traits::AssignmentLhsSized);`
Original file line number	Diff line number	Diff line change
`@@ -694,7 +694,7 @@ impl<'a> StringReader<'a> {`
`694`	`694`	`accum_int *= 16;`
`695`	`695`	`accum_int += c.to_digit(16).unwrap_or_else(\|\| {`
`696`	`696`	`self.err_span_char(self.last_pos, self.pos,`
`697`		`- "illegal character in numeric character escape", c);`
	`697`	`+ "invalid character in numeric character escape", c);`
`698`	`698`
`699`	`699`	`valid = false;`
`700`	`700`	`0`
`@@ -714,7 +714,7 @@ impl<'a> StringReader<'a> {`
`714`	`714`	`Some(_) => valid,`
`715`	`715`	`None => {`
`716`	`716`	`let last_bpos = self.last_pos;`
`717`		`- self.err_span_(start_bpos, last_bpos, "illegal numeric character escape");`
	`717`	`+ self.err_span_(start_bpos, last_bpos, "invalid numeric character escape");`
`718`	`718`	`false`
`719`	`719`	`}`
`720`	`720`	`}`
`@@ -846,7 +846,7 @@ impl<'a> StringReader<'a> {`
`846`	`846`	"unterminated unicode escape (needed a `}`)");
`847`	`847`	`} else {`
`848`	`848`	`self.err_span_char(self.last_pos, self.pos,`
`849`		`- "illegal character in unicode escape", c);`
	`849`	`+ "invalid character in unicode escape", c);`
`850`	`850`	`}`
`851`	`851`	`valid = false;`
`852`	`852`	`0`
`@@ -862,7 +862,7 @@ impl<'a> StringReader<'a> {`
`862`	`862`	`}`
`863`	`863`
`864`	`864`	`if valid && (char::from_u32(accum_int).is_none() \|\| count == 0) {`
`865`		`- self.err_span_(start_bpos, self.last_pos, "illegal unicode character escape");`
	`865`	`+ self.err_span_(start_bpos, self.last_pos, "invalid unicode character escape");`
`866`	`866`	`valid = false;`
`867`	`867`	`}`
`868`	`868`
`@@ -1138,8 +1138,8 @@ impl<'a> StringReader<'a> {`
`1138`	`1138`	`let last_bpos = self.last_pos;`
`1139`	`1139`	`let curr_char = self.curr.unwrap();`
`1140`	`1140`	`self.fatal_span_char(start_bpos, last_bpos,`
`1141`		- "only `#` is allowed in raw string delimitation; \
`1142`		`- found illegal character",`
	`1141`	`+ "found invalid character; \`
	`1142`	+ only `#` is allowed in raw string delimitation",
`1143`	`1143`	`curr_char);`
`1144`	`1144`	`}`
`1145`	`1145`	`self.bump();`
`@@ -1323,8 +1323,8 @@ impl<'a> StringReader<'a> {`
`1323`	`1323`	`let last_pos = self.last_pos;`
`1324`	`1324`	`let ch = self.curr.unwrap();`
`1325`	`1325`	`self.fatal_span_char(start_bpos, last_pos,`
`1326`		- "only `#` is allowed in raw string delimitation; \
`1327`		`- found illegal character",`
	`1326`	`+ "found invalid character; \`
	`1327`	+ only `#` is allowed in raw string delimitation",
`1328`	`1328`	`ch);`
`1329`	`1329`	`}`
`1330`	`1330`	`self.bump();`
Original file line number	Diff line number	Diff line change
`@@ -681,7 +681,7 @@ impl<'a> Parser<'a> {`
`681`	`681`	`if text.is_empty() {`
`682`	`682`	`self.span_bug(sp, "found empty literal suffix in Some")`
`683`	`683`	`}`
`684`		`- self.span_err(sp, &*format!("{} with a suffix is illegal", kind));`
	`684`	`+ self.span_err(sp, &*format!("{} with a suffix is invalid", kind));`
`685`	`685`	`}`
`686`	`686`	`}`
`687`	`687`	`}`
`@@ -5286,7 +5286,7 @@ impl<'a> Parser<'a> {`
`5286`	`5286`	`let last_span = self.last_span;`
`5287`	`5287`	`self.span_err(`
`5288`	`5288`	`last_span,`
`5289`		`- &format!("illegal ABI: expected one of [{}], \`
	`5289`	`+ &format!("invalid ABI: expected one of [{}], \`
`5290`	`5290`	found `{}`",
`5291`	`5291`	`abi::all_names().join(", "),`
`5292`	`5292`	`s));`
Original file line number	Diff line number	Diff line change
`@@ -14,6 +14,6 @@ mod A {`
`14`	`14`
`15`	`15`	`fn main() {`
`16`	`16`	`A::C = 1;`
`17`		`- //~^ ERROR: illegal left-hand side expression`
	`17`	`+ //~^ ERROR: invalid left-hand side expression`
`18`	`18`	`//~\| ERROR: mismatched types`
`19`	`19`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,6 +9,6 @@`
`9`	`9`	`// except according to those terms.`
`10`	`10`
`11`	`11`	`fn main() {`
`12`		`- let a = 1_is; //~ ERROR illegal suffix`
`13`		`- let b = 2_us; //~ ERROR illegal suffix`
	`12`	`+ let a = 1_is; //~ ERROR invalid suffix`
	`13`	`+ let b = 2_us; //~ ERROR invalid suffix`
`14`	`14`	`}`