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);
}
}
_ => {
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));
}
};
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);
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);
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
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
}
}
"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
}
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;
}
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();
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();
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)
// 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)");
}
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));
}
}
}
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));
// 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
}
fn main() {
A::C = 1;
- //~^ ERROR: illegal left-hand side expression
+ //~^ ERROR: invalid left-hand side expression
//~| ERROR: mismatched types
}
// 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
}
// 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
}
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
}
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
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
}
//~^ 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
}
// compile-flags: -Z parse-only
pub extern
- "invalid-ab_isize" //~ ERROR illegal ABI
+ "invalid-ab_isize" //~ ERROR invalid ABI
fn foo() {}
fn main() {}
// 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
}
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
}
// 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
;