OpenE2K
/
rust
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Handle `Span`s for byte and raw strings and add more detail

This commit is contained in:
Esteban Küber 2021-01-23 12:48:31 -08:00
parent b81f5811f9
commit 3b5d018ebb
35 changed files with 279 additions and 184 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
compiler/rustc_parse/src/lexer/mod.rs
View File

@ -14,7 +14,7 @@ mod tokentrees;
mod unescape_error_reporting;
mod unicode_chars;
use unescape_error_reporting::{emit_unescape_error, push_escaped_char};
use unescape_error_reporting::{emit_unescape_error, escaped_char};
#[derive(Clone, Debug)]
pub struct UnmatchedBrace {
@ -122,11 +122,9 @@ impl<'a> StringReader<'a> {
m: &str,
c: char,
) -> DiagnosticBuilder<'a> {
let mut m = m.to_string();
m.push_str(": ");
push_escaped_char(&mut m, c);
self.sess.span_diagnostic.struct_span_fatal(self.mk_sp(from_pos, to_pos), &m[..])
self.sess
.span_diagnostic
.struct_span_fatal(self.mk_sp(from_pos, to_pos), &format!("{}: {}", m, escaped_char(c)))
}
/// Turns simple `rustc_lexer::TokenKind` enum into a rich
@ -421,7 +419,7 @@ impl<'a> StringReader<'a> {
let content_start = start + BytePos(prefix_len);
let content_end = suffix_start - BytePos(postfix_len);
let id = self.symbol_from_to(content_start, content_end);
self.validate_literal_escape(mode, content_start, content_end);
self.validate_literal_escape(mode, content_start, content_end, prefix_len, postfix_len);
(lit_kind, id)
}
@ -525,17 +523,29 @@ impl<'a> StringReader<'a> {
.raise();
}
fn validate_literal_escape(&self, mode: Mode, content_start: BytePos, content_end: BytePos) {
fn validate_literal_escape(
&self,
mode: Mode,
content_start: BytePos,
content_end: BytePos,
prefix_len: u32,
postfix_len: u32,
) {
let lit_content = self.str_from_to(content_start, content_end);
unescape::unescape_literal(lit_content, mode, &mut |range, result| {
// Here we only check for errors. The actual unescaping is done later.
if let Err(err) = result {
let span_with_quotes =
self.mk_sp(content_start - BytePos(1), content_end + BytePos(1));
let span_with_quotes = self
.mk_sp(content_start - BytePos(prefix_len), content_end + BytePos(postfix_len));
let (start, end) = (range.start as u32, range.end as u32);
let lo = content_start + BytePos(start);
let hi = lo + BytePos(end - start);
let span = self.mk_sp(lo, hi);
emit_unescape_error(
&self.sess.span_diagnostic,
lit_content,
span_with_quotes,
span,
mode,
range,
err,

188
compiler/rustc_parse/src/lexer/unescape_error_reporting.rs
View File

@ -13,6 +13,8 @@ pub(crate) fn emit_unescape_error(
lit: &str,
// full span of the literal, including quotes
span_with_quotes: Span,
// interior span of the literal, without quotes
span: Span,
mode: Mode,
// range of the error inside `lit`
range: Range<usize>,
@ -26,13 +28,6 @@ pub(crate) fn emit_unescape_error(
range,
error
);
let span = {
let Range { start, end } = range;
let (start, end) = (start as u32, end as u32);
let lo = span_with_quotes.lo() + BytePos(start + 1);
let hi = lo + BytePos(end - start);
span_with_quotes.with_lo(lo).with_hi(hi)
};
let last_char = || {
let c = lit[range.clone()].chars().rev().next().unwrap();
let span = span.with_lo(span.hi() - BytePos(c.len_utf8() as u32));
@ -42,20 +37,22 @@ pub(crate) fn emit_unescape_error(
EscapeError::LoneSurrogateUnicodeEscape => {
handler
.struct_span_err(span, "invalid unicode character escape")
.span_label(span, "invalid escape")
.help("unicode escape must not be a surrogate")
.emit();
}
EscapeError::OutOfRangeUnicodeEscape => {
handler
.struct_span_err(span, "invalid unicode character escape")
.span_label(span, "invalid escape")
.help("unicode escape must be at most 10FFFF")
.emit();
}
EscapeError::MoreThanOneChar => {
let msg = if mode.is_bytes() {
"if you meant to write a byte string literal, use double quotes"
let (prefix, msg) = if mode.is_bytes() {
("b", "if you meant to write a byte string literal, use double quotes")
} else {
"if you meant to write a `str` literal, use double quotes"
("", "if you meant to write a `str` literal, use double quotes")
};
handler
@ -66,31 +63,44 @@ pub(crate) fn emit_unescape_error(
.span_suggestion(
span_with_quotes,
msg,
format!("\"{}\"", lit),
format!("{}\"{}\"", prefix, lit),
Applicability::MachineApplicable,
)
.emit();
}
EscapeError::EscapeOnlyChar => {
let (c, _span) = last_char();
let (c, char_span) = last_char();
let mut msg = if mode.is_bytes() {
"byte constant must be escaped: "
let msg = if mode.is_bytes() {
"byte constant must be escaped"
} else {
"character constant must be escaped: "
}
.to_string();
push_escaped_char(&mut msg, c);
handler.span_err(span, msg.as_str())
"character constant must be escaped"
};
handler
.struct_span_err(span, &format!("{}: `{}`", msg, escaped_char(c)))
.span_suggestion(
char_span,
"escape the character",
c.escape_default().to_string(),
Applicability::MachineApplicable,
)
.emit()
}
EscapeError::BareCarriageReturn => {
let msg = if mode.in_double_quotes() {
"bare CR not allowed in string, use \\r instead"
"bare CR not allowed in string, use `\\r` instead"
} else {
"character constant must be escaped: \\r"
"character constant must be escaped: `\\r`"
};
handler.span_err(span, msg);
handler
.struct_span_err(span, msg)
.span_suggestion(
span,
"escape the character",
"\\r".to_string(),
Applicability::MachineApplicable,
)
.emit();
}
EscapeError::BareCarriageReturnInRawString => {
assert!(mode.in_double_quotes());
@ -102,21 +112,22 @@ pub(crate) fn emit_unescape_error(
let label =
if mode.is_bytes() { "unknown byte escape" } else { "unknown character escape" };
let mut msg = label.to_string();
msg.push_str(": ");
push_escaped_char(&mut msg, c);
let mut diag = handler.struct_span_err(span, msg.as_str());
let ec = escaped_char(c);
let mut diag = handler.struct_span_err(span, &format!("{}: `{}`", label, ec));
diag.span_label(span, label);
if c == '{' || c == '}' && !mode.is_bytes() {
diag.help(
"if used in a formatting string, \
curly braces are escaped with `{{` and `}}`",
"if used in a formatting string, curly braces are escaped with `{{` and `}}`",
);
} else if c == '\r' {
diag.help(
"this is an isolated carriage return; \
consider checking your editor and version control settings",
"this is an isolated carriage return; consider checking your editor and \
version control settings",
);
} else {
diag.help(
"for more information, visit \
<https://static.rust-lang.org/doc/master/reference.html#literals>",
);
}
diag.emit();
@ -127,45 +138,70 @@ pub(crate) fn emit_unescape_error(
EscapeError::InvalidCharInHexEscape | EscapeError::InvalidCharInUnicodeEscape => {
let (c, span) = last_char();
let mut msg = if error == EscapeError::InvalidCharInHexEscape {
"invalid character in numeric character escape: "
let msg = if error == EscapeError::InvalidCharInHexEscape {
"invalid character in numeric character escape"
} else {
"invalid character in unicode escape: "
}
.to_string();
push_escaped_char(&mut msg, c);
"invalid character in unicode escape"
};
let c = escaped_char(c);
handler.span_err(span, msg.as_str())
handler
.struct_span_err(span, &format!("{}: `{}`", msg, c))
.span_label(span, msg)
.emit();
}
EscapeError::NonAsciiCharInByte => {
assert!(mode.is_bytes());
let (_c, span) = last_char();
handler.span_err(
span,
"byte constant must be ASCII. \
Use a \\xHH escape for a non-ASCII byte",
)
let (c, span) = last_char();
handler
.struct_span_err(span, "non-ASCII character in byte constant")
.span_label(span, "byte constant must be ASCII")
.span_suggestion(
span,
"use a \\xHH escape for a non-ASCII byte",
format!("\\x{:X}", c as u32),
Applicability::MachineApplicable,
)
.emit();
}
EscapeError::NonAsciiCharInByteString => {
assert!(mode.is_bytes());
let (_c, span) = last_char();
handler.span_err(span, "raw byte string must be ASCII")
handler
.struct_span_err(span, "raw byte string must be ASCII")
.span_label(span, "must be ASCII")
.emit();
}
EscapeError::OutOfRangeHexEscape => {
handler
.struct_span_err(span, "out of range hex escape")
.span_label(span, "must be a character in the range [\\x00-\\x7f]")
.emit();
}
EscapeError::OutOfRangeHexEscape => handler.span_err(
span,
"this form of character escape may only be used \
with characters in the range [\\x00-\\x7f]",
),
EscapeError::LeadingUnderscoreUnicodeEscape => {
let (_c, span) = last_char();
handler.span_err(span, "invalid start of unicode escape")
let (c, span) = last_char();
let msg = "invalid start of unicode escape";
handler
.struct_span_err(span, &format!("{}: `{}`", msg, c))
.span_label(span, msg)
.emit();
}
EscapeError::OverlongUnicodeEscape => {
handler.span_err(span, "overlong unicode escape (must have at most 6 hex digits)")
}
EscapeError::UnclosedUnicodeEscape => {
handler.span_err(span, "unterminated unicode escape (needed a `}`)")
handler
.struct_span_err(span, "overlong unicode escape")
.span_label(span, "must have at most 6 hex digits")
.emit();
}
EscapeError::UnclosedUnicodeEscape => handler
.struct_span_err(span, "unterminated unicode escape")
.span_label(span, "missing a closing `}`")
.span_suggestion_verbose(
span.shrink_to_hi(),
"terminate the unicode escape",
"}".to_string(),
Applicability::MaybeIncorrect,
)
.emit(),
EscapeError::NoBraceInUnicodeEscape => {
let msg = "incorrect unicode escape sequence";
let mut diag = handler.struct_span_err(span, msg);
@ -195,28 +231,38 @@ pub(crate) fn emit_unescape_error(
diag.emit();
}
EscapeError::UnicodeEscapeInByte => handler.span_err(
span,
"unicode escape sequences cannot be used \
as a byte or in a byte string",
),
EscapeError::EmptyUnicodeEscape => {
handler.span_err(span, "empty unicode escape (must have at least 1 hex digit)")
EscapeError::UnicodeEscapeInByte => {
let msg = "unicode escape in byte string";
handler
.struct_span_err(span, msg)
.span_label(span, msg)
.help("unicode escape sequences cannot be used as a byte or in a byte string")
.emit();
}
EscapeError::EmptyUnicodeEscape => {
handler
.struct_span_err(span, "empty unicode escape")
.span_label(span, "this escape must have at least 1 hex digit")
.emit();
}
EscapeError::ZeroChars => {
let msg = "empty character literal";
handler.struct_span_err(span, msg).span_label(span, msg).emit()
}
EscapeError::LoneSlash => {
let msg = "invalid trailing slash in literal";
handler.struct_span_err(span, msg).span_label(span, msg).emit();
}
EscapeError::ZeroChars => handler.span_err(span, "empty character literal"),
EscapeError::LoneSlash => handler.span_err(span, "invalid trailing slash in literal"),
}
}
/// Pushes a character to a message string for error reporting
pub(crate) fn push_escaped_char(msg: &mut String, c: char) {
pub(crate) fn escaped_char(c: char) -> String {
match c {
'\u{20}'..='\u{7e}' => {
// Don't escape \, ' or " for user-facing messages
msg.push(c);
}
_ => {
msg.extend(c.escape_default());
c.to_string()
}
_ => c.escape_default().to_string(),
}
}

2
src/test/ui/attributes/key-value-non-ascii.rs
View File

@ -1,4 +1,4 @@
#![feature(rustc_attrs)]
#[rustc_dummy = b"ffi.rs"] //~ ERROR byte constant must be ASCII
#[rustc_dummy = b"ffi.rs"] //~ ERROR non-ASCII character in byte constant
fn main() {}

5
src/test/ui/attributes/key-value-non-ascii.stderr
View File

@ -1,8 +1,11 @@
error: byte constant must be ASCII. Use a \xHH escape for a non-ASCII byte
error: non-ASCII character in byte constant
--> $DIR/key-value-non-ascii.rs:3:19
|
LL | #[rustc_dummy = b"ffi.rs"]
| ^
| |
| byte constant must be ASCII
| help: use a \xHH escape for a non-ASCII byte: `\xFB03`
error: aborting due to previous error

6
src/test/ui/parser/ascii-only-character-escape.rs
View File

@ -1,6 +1,6 @@
fn main() {
let x = "\x80"; //~ ERROR may only be used
let y = "\xff"; //~ ERROR may only be used
let z = "\xe2"; //~ ERROR may only be used
let x = "\x80"; //~ ERROR out of range hex escape
let y = "\xff"; //~ ERROR out of range hex escape
let z = "\xe2"; //~ ERROR out of range hex escape
let a = b"\x00e2"; // ok because byte literal
}

12
src/test/ui/parser/ascii-only-character-escape.stderr
View File

@ -1,20 +1,20 @@
error: this form of character escape may only be used with characters in the range [\x00-\x7f]
error: out of range hex escape
--> $DIR/ascii-only-character-escape.rs:2:14
|
LL | let x = "\x80";
| ^^^^
| ^^^^ must be a character in the range [\x00-\x7f]
error: this form of character escape may only be used with characters in the range [\x00-\x7f]
error: out of range hex escape
--> $DIR/ascii-only-character-escape.rs:3:14
|
LL | let y = "\xff";
| ^^^^
| ^^^^ must be a character in the range [\x00-\x7f]
error: this form of character escape may only be used with characters in the range [\x00-\x7f]
error: out of range hex escape
--> $DIR/ascii-only-character-escape.rs:4:14
|
LL | let z = "\xe2";
| ^^^^
| ^^^^ must be a character in the range [\x00-\x7f]
error: aborting due to 3 previous errors

8
src/test/ui/parser/bad-char-literals.rs
View File

@ -4,17 +4,17 @@
fn main() {
// these literals are just silly.
''';
//~^ ERROR: character constant must be escaped: '
//~^ ERROR: character constant must be escaped: `'`
// note that this is a literal "\n" byte
'
';
//~^^ ERROR: character constant must be escaped: \n
//~^^ ERROR: character constant must be escaped: `\n`
// note that this is a literal "\r" byte
' '; //~ ERROR: character constant must be escaped: \r
' '; //~ ERROR: character constant must be escaped: `\r`
// note that this is a literal tab character here
' ';
//~^ ERROR: character constant must be escaped: \t
//~^ ERROR: character constant must be escaped: `\t`
}

16
src/test/ui/parser/bad-char-literals.stderr
View File

@ -1,28 +1,28 @@
error: character constant must be escaped: '
error: character constant must be escaped: `'`
--> $DIR/bad-char-literals.rs:6:6
|
LL | ''';
| ^
| ^ help: escape the character: `\'`
error: character constant must be escaped: \n
error: character constant must be escaped: `\n`
--> $DIR/bad-char-literals.rs:10:6
|
LL | '
| ______^
LL | | ';
| |_
| |_ help: escape the character: `\n`
error: character constant must be escaped: \r
error: character constant must be escaped: `\r`
--> $DIR/bad-char-literals.rs:15:6
|
LL | ' ';
| ^
| ^ help: escape the character: `\r`
error: character constant must be escaped: \t
error: character constant must be escaped: `\t`
--> $DIR/bad-char-literals.rs:18:6
|
LL | ' ';
| ^^^^
| ^^^^ help: escape the character: `\t`
error: aborting due to 4 previous errors

4
src/test/ui/parser/byte-literals.rs
View File

@ -4,9 +4,9 @@ static FOO: u8 = b'\f'; //~ ERROR unknown byte escape
pub fn main() {
b'\f'; //~ ERROR unknown byte escape
b'\x0Z'; //~ ERROR invalid 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
b'é'; //~ ERROR non-ASCII character in byte constant
b'a //~ ERROR unterminated byte constant [E0763]
}

25
src/test/ui/parser/byte-literals.stderr
View File

@ -1,38 +1,45 @@
error: unknown byte escape: f
error: unknown byte escape: `f`
--> $DIR/byte-literals.rs:3:21
|
LL | static FOO: u8 = b'\f';
| ^ unknown byte escape
|
= help: for more information, visit <https://static.rust-lang.org/doc/master/reference.html#literals>
error: unknown byte escape: f
error: unknown byte escape: `f`
--> $DIR/byte-literals.rs:6:8
|
LL | b'\f';
| ^ unknown byte escape
|
= help: for more information, visit <https://static.rust-lang.org/doc/master/reference.html#literals>
error: invalid character in numeric character escape: Z
error: invalid character in numeric character escape: `Z`
--> $DIR/byte-literals.rs:7:10
|
LL | b'\x0Z';
| ^
| ^ invalid character in numeric character escape
error: byte constant must be escaped: \t
error: byte constant must be escaped: `\t`
--> $DIR/byte-literals.rs:8:7
|
LL | b' ';
| ^^^^
| ^^^^ help: escape the character: `\t`
error: byte constant must be escaped: '
error: byte constant must be escaped: `'`
--> $DIR/byte-literals.rs:9:7
|
LL | b''';
| ^
| ^ help: escape the character: `\'`
error: byte constant must be ASCII. Use a \xHH escape for a non-ASCII byte
error: non-ASCII character in byte constant
--> $DIR/byte-literals.rs:10:7
|
LL | b'é';
| ^
| |
| byte constant must be ASCII
| help: use a \xHH escape for a non-ASCII byte: `\xE9`
error[E0763]: unterminated byte constant
--> $DIR/byte-literals.rs:11:6

5
src/test/ui/parser/byte-string-literals.rs
View File

@ -2,7 +2,8 @@ static FOO: &'static [u8] = b"\f"; //~ ERROR unknown byte escape
pub fn main() {
b"\f"; //~ ERROR unknown byte escape
b"\x0Z"; //~ ERROR invalid character in numeric character escape: Z
b"é"; //~ ERROR byte constant must be ASCII
b"\x0Z"; //~ ERROR invalid character in numeric character escape: `Z`
b"é"; //~ ERROR non-ASCII character in byte constant
br##"é"##; //~ ERROR raw byte string must be ASCII
b"a //~ ERROR unterminated double quote byte string
}

27
src/test/ui/parser/byte-string-literals.stderr
View File

@ -1,35 +1,48 @@
error: unknown byte escape: f
error: unknown byte escape: `f`
--> $DIR/byte-string-literals.rs:1:32
|
LL | static FOO: &'static [u8] = b"\f";
| ^ unknown byte escape
|
= help: for more information, visit <https://static.rust-lang.org/doc/master/reference.html#literals>
error: unknown byte escape: f
error: unknown byte escape: `f`
--> $DIR/byte-string-literals.rs:4:8
|
LL | b"\f";
| ^ unknown byte escape
|
= help: for more information, visit <https://static.rust-lang.org/doc/master/reference.html#literals>
error: invalid character in numeric character escape: Z
error: invalid character in numeric character escape: `Z`
--> $DIR/byte-string-literals.rs:5:10
|
LL | b"\x0Z";
| ^
| ^ invalid character in numeric character escape
error: byte constant must be ASCII. Use a \xHH escape for a non-ASCII byte
error: non-ASCII character in byte constant
--> $DIR/byte-string-literals.rs:6:7
|
LL | b"é";
| ^
| |
| byte constant must be ASCII
| help: use a \xHH escape for a non-ASCII byte: `\xE9`
error: raw byte string must be ASCII
--> $DIR/byte-string-literals.rs:7:10
|
LL | br##"é"##;
| ^ must be ASCII
error[E0766]: unterminated double quote byte string
--> $DIR/byte-string-literals.rs:7:6
--> $DIR/byte-string-literals.rs:8:6
|
LL | b"a
| ______^
LL | | }
| |__^
error: aborting due to 5 previous errors
error: aborting due to 6 previous errors
For more information about this error, try `rustc --explain E0766`.

14
src/test/ui/parser/issue-23620-invalid-escapes.rs
View File

@ -1,9 +1,9 @@
fn main() {
let _ = b"\u{a66e}";
//~^ ERROR unicode escape sequences cannot be used as a byte or in a byte string
//~^ ERROR unicode escape in byte string
let _ = b'\u{a66e}';
//~^ ERROR unicode escape sequences cannot be used as a byte or in a byte string
//~^ ERROR unicode escape in byte string
let _ = b'\u';
//~^ ERROR incorrect unicode escape sequence
@ -12,21 +12,21 @@ fn main() {
//~^ ERROR numeric character escape is too short
let _ = b'\xxy';
//~^ ERROR invalid character in numeric character escape: x
//~^ ERROR invalid character in numeric character escape: `x`
let _ = '\x5';
//~^ ERROR numeric character escape is too short
let _ = '\xxy';
//~^ ERROR invalid character in numeric character escape: x
//~^ ERROR invalid character in numeric character escape: `x`
let _ = b"\u{a4a4} \xf \u";
//~^ ERROR unicode escape sequences cannot be used as a byte or in a byte string
//~^^ ERROR invalid character in numeric character escape:
//~^ ERROR unicode escape in byte string
//~^^ ERROR invalid character in numeric character escape: ` `
//~^^^ ERROR incorrect unicode escape sequence
let _ = "\xf \u";
//~^ ERROR invalid character in numeric character escape:
//~^ ERROR invalid character in numeric character escape: ` `
//~^^ ERROR incorrect unicode escape sequence
let _ = "\u8f";

34
src/test/ui/parser/issue-23620-invalid-escapes.stderr
View File

@ -1,14 +1,18 @@
error: unicode escape sequences cannot be used as a byte or in a byte string
error: unicode escape in byte string
--> $DIR/issue-23620-invalid-escapes.rs:2:15
|
LL | let _ = b"\u{a66e}";
| ^^^^^^^^
| ^^^^^^^^ unicode escape in byte string
|
= help: unicode escape sequences cannot be used as a byte or in a byte string
error: unicode escape sequences cannot be used as a byte or in a byte string
error: unicode escape in byte string
--> $DIR/issue-23620-invalid-escapes.rs:5:15
|
LL | let _ = b'\u{a66e}';
| ^^^^^^^^
| ^^^^^^^^ unicode escape in byte string
|
= help: unicode escape sequences cannot be used as a byte or in a byte string
error: incorrect unicode escape sequence
--> $DIR/issue-23620-invalid-escapes.rs:8:15
@ -24,11 +28,11 @@ error: numeric character escape is too short
LL | let _ = b'\x5';
| ^^^
error: invalid character in numeric character escape: x
error: invalid character in numeric character escape: `x`
--> $DIR/issue-23620-invalid-escapes.rs:14:17
|
LL | let _ = b'\xxy';
| ^
| ^ invalid character in numeric character escape
error: numeric character escape is too short
--> $DIR/issue-23620-invalid-escapes.rs:17:14
@ -36,23 +40,25 @@ error: numeric character escape is too short
LL | let _ = '\x5';
| ^^^
error: invalid character in numeric character escape: x
error: invalid character in numeric character escape: `x`
--> $DIR/issue-23620-invalid-escapes.rs:20:16
|
LL | let _ = '\xxy';
| ^
| ^ invalid character in numeric character escape
error: unicode escape sequences cannot be used as a byte or in a byte string
error: unicode escape in byte string
--> $DIR/issue-23620-invalid-escapes.rs:23:15
|
LL | let _ = b"\u{a4a4} \xf \u";
| ^^^^^^^^
| ^^^^^^^^ unicode escape in byte string
|
= help: unicode escape sequences cannot be used as a byte or in a byte string
error: invalid character in numeric character escape:
error: invalid character in numeric character escape: ` `
--> $DIR/issue-23620-invalid-escapes.rs:23:27
|
LL | let _ = b"\u{a4a4} \xf \u";
| ^
| ^ invalid character in numeric character escape
error: incorrect unicode escape sequence
--> $DIR/issue-23620-invalid-escapes.rs:23:28
@ -62,11 +68,11 @@ LL | let _ = b"\u{a4a4} \xf \u";
|
= help: format of unicode escape sequences is `\u{...}`
error: invalid character in numeric character escape:
error: invalid character in numeric character escape: ` `
--> $DIR/issue-23620-invalid-escapes.rs:28:17
|
LL | let _ = "\xf \u";
| ^
| ^ invalid character in numeric character escape
error: incorrect unicode escape sequence
--> $DIR/issue-23620-invalid-escapes.rs:28:18

4
src/test/ui/parser/issue-43692.stderr
View File

@ -1,8 +1,8 @@
error: invalid start of unicode escape
error: invalid start of unicode escape: `_`
--> $DIR/issue-43692.rs:2:9
|
LL | '\u{_10FFFF}';
| ^
| ^ invalid start of unicode escape
error: aborting due to previous error

2
src/test/ui/parser/issue-62913.stderr
View File

@ -10,7 +10,7 @@ error: invalid trailing slash in literal
--> $DIR/issue-62913.rs:1:5
|
LL | "\u\"
| ^
| ^ invalid trailing slash in literal
error: expected item, found `"\u\"`
--> $DIR/issue-62913.rs:1:1

6
src/test/ui/parser/issue-64732.stderr
View File

@ -1,13 +1,13 @@
error: character literal may only contain one codepoint
--> $DIR/issue-64732.rs:3:17
--> $DIR/issue-64732.rs:3:16
|
LL | let _foo = b'hello\0';
| ^^^^^^^^^
| ^^^^^^^^^^
|
help: if you meant to write a byte string literal, use double quotes
|
LL | let _foo = b"hello\0";
| ^^^^^^^^^
| ^^^^^^^^^^
error: character literal may only contain one codepoint
--> $DIR/issue-64732.rs:6:16

8
src/test/ui/parser/lex-bad-char-literals-1.stderr
View File

@ -10,17 +10,21 @@ error: numeric character escape is too short
LL | "\x1"
| ^^^
error: unknown character escape: \u{25cf}
error: unknown character escape: `\u{25cf}`
--> $DIR/lex-bad-char-literals-1.rs:10:7
|
LL | '\●'
| ^ unknown character escape
|
= help: for more information, visit <https://static.rust-lang.org/doc/master/reference.html#literals>
error: unknown character escape: \u{25cf}
error: unknown character escape: `\u{25cf}`
--> $DIR/lex-bad-char-literals-1.rs:14:7
|
LL | "\●"
| ^ unknown character escape
|
= help: for more information, visit <https://static.rust-lang.org/doc/master/reference.html#literals>
error: aborting due to 4 previous errors

2
src/test/ui/parser/lex-bad-char-literals-7.rs
View File

@ -2,7 +2,7 @@ fn main() {
let _: char = '';
//~^ ERROR: empty character literal
let _: char = '\u{}';
//~^ ERROR: empty unicode escape (must have at least 1 hex digit)
//~^ ERROR: empty unicode escape
// Next two are OK, but may befool error recovery
let _ = '/';

6
src/test/ui/parser/lex-bad-char-literals-7.stderr
View File

@ -2,13 +2,13 @@ error: empty character literal
--> $DIR/lex-bad-char-literals-7.rs:2:20
|
LL | let _: char = '';
| ^
| ^ empty character literal
error: empty unicode escape (must have at least 1 hex digit)
error: empty unicode escape
--> $DIR/lex-bad-char-literals-7.rs:4:20
|
LL | let _: char = '\u{}';
| ^^^^
| ^^^^ this escape must have at least 1 hex digit
error[E0762]: unterminated character literal
--> $DIR/lex-bad-char-literals-7.rs:11:13

2
src/test/ui/parser/lex-bare-cr-string-literal-doc-comment.rs
View File

@ -22,5 +22,5 @@ fn main() {
let _s = r"bar foo"; //~ ERROR: bare CR not allowed in raw string
// the following string literal has a bare CR in it
let _s = "foo\ bar"; //~ ERROR: unknown character escape: \r
let _s = "foo\ bar"; //~ ERROR: unknown character escape: `\r`
}

6
src/test/ui/parser/lex-bare-cr-string-literal-doc-comment.stderr
View File

@ -22,11 +22,11 @@ error: bare CR not allowed in block doc-comment
LL | /*! block doc comment with bare CR: ' ' */
| ^
error: bare CR not allowed in string, use \r instead
error: bare CR not allowed in string, use `\r` instead
--> $DIR/lex-bare-cr-string-literal-doc-comment.rs:19:18
|
LL | let _s = "foo bar";
| ^
| ^ help: escape the character: `\r`
error: bare CR not allowed in raw string
--> $DIR/lex-bare-cr-string-literal-doc-comment.rs:22:19
@ -34,7 +34,7 @@ error: bare CR not allowed in raw string
LL | let _s = r"bar foo";
| ^
error: unknown character escape: \r
error: unknown character escape: `\r`
--> $DIR/lex-bare-cr-string-literal-doc-comment.rs:25:19
|
LL | let _s = "foo\ bar";

4
src/test/ui/parser/macro/literals-are-validated-before-expansion.stderr
View File

@ -2,7 +2,7 @@ error: invalid unicode character escape
--> $DIR/literals-are-validated-before-expansion.rs:6:20
|
LL | black_hole! { '\u{FFFFFF}' }
| ^^^^^^^^^^
| ^^^^^^^^^^ invalid escape
|
= help: unicode escape must be at most 10FFFF
@ -10,7 +10,7 @@ error: invalid unicode character escape
--> $DIR/literals-are-validated-before-expansion.rs:8:39
|
LL | black_hole! { "this is surrogate: \u{DAAA}" }
| ^^^^^^^^
| ^^^^^^^^ invalid escape
|
= help: unicode escape must not be a surrogate

2
src/test/ui/parser/new-unicode-escapes-1.rs
View File

@ -1,3 +1,3 @@
pub fn main() {
let s = "\u{2603"; //~ ERROR unterminated unicode escape (needed a `}`)
let s = "\u{2603"; //~ ERROR unterminated unicode escape
}

9
src/test/ui/parser/new-unicode-escapes-1.stderr
View File

@ -1,8 +1,13 @@
error: unterminated unicode escape (needed a `}`)
error: unterminated unicode escape
--> $DIR/new-unicode-escapes-1.rs:2:14
|
LL | let s = "\u{2603";
| ^^^^^^^
| ^^^^^^^ missing a closing `}`
|
help: terminate the unicode escape
|
LL | let s = "\u{2603}";
| ^
error: aborting due to previous error

2
src/test/ui/parser/new-unicode-escapes-2.rs
View File

@ -1,3 +1,3 @@
pub fn main() {
let s = "\u{260311111111}"; //~ ERROR overlong unicode escape (must have at most 6 hex digits)
let s = "\u{260311111111}"; //~ ERROR overlong unicode escape
}

4
src/test/ui/parser/new-unicode-escapes-2.stderr
View File

@ -1,8 +1,8 @@
error: overlong unicode escape (must have at most 6 hex digits)
error: overlong unicode escape
--> $DIR/new-unicode-escapes-2.rs:2:14
|
LL | let s = "\u{260311111111}";
| ^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^^^^ must have at most 6 hex digits
error: aborting due to previous error

4
src/test/ui/parser/new-unicode-escapes-3.stderr
View File

@ -2,7 +2,7 @@ error: invalid unicode character escape
--> $DIR/new-unicode-escapes-3.rs:2:15
|
LL | let s1 = "\u{d805}";
| ^^^^^^^^
| ^^^^^^^^ invalid escape
|
= help: unicode escape must not be a surrogate
@ -10,7 +10,7 @@ error: invalid unicode character escape
--> $DIR/new-unicode-escapes-3.rs:3:15
|
LL | let s2 = "\u{ffffff}";
| ^^^^^^^^^^
| ^^^^^^^^^^ invalid escape
|
= help: unicode escape must be at most 10FFFF

2
src/test/ui/parser/new-unicode-escapes-4.rs
View File

@ -1,4 +1,4 @@
pub fn main() {
let s = "\u{lol}";
//~^ ERROR invalid character in unicode escape: l
//~^ ERROR invalid character in unicode escape: `l`
}

4
src/test/ui/parser/new-unicode-escapes-4.stderr
View File

@ -1,8 +1,8 @@
error: invalid character in unicode escape: l
error: invalid character in unicode escape: `l`
--> $DIR/new-unicode-escapes-4.rs:2:17
|
LL | let s = "\u{lol}";
| ^
| ^ invalid character in unicode escape
error: aborting due to previous error

2
src/test/ui/parser/raw/raw-byte-string-literals.stderr
View File

@ -8,7 +8,7 @@ error: raw byte string must be ASCII
--> $DIR/raw-byte-string-literals.rs:5:8
|
LL | br"é";
| ^
| ^ must be ASCII
error: found invalid character; only `#` is allowed in raw string delimitation: ~
--> $DIR/raw-byte-string-literals.rs:6:5

4
src/test/ui/parser/trailing-carriage-return-in-string.rs
View File

@ -8,7 +8,7 @@ fn main() {
a test";
// \r only
let bad = "This is \ a test";
//~^ ERROR unknown character escape: \r
//~^^ HELP this is an isolated carriage return
//~^ ERROR unknown character escape: `\r`
//~| HELP this is an isolated carriage return
}

2
src/test/ui/parser/trailing-carriage-return-in-string.stderr
View File

@ -1,4 +1,4 @@
error: unknown character escape: \r
error: unknown character escape: `\r`
--> $DIR/trailing-carriage-return-in-string.rs:10:25
|
LL | let bad = "This is \ a test";

8
src/test/ui/parser/wrong-escape-of-curly-braces.rs
View File

@ -1,8 +1,8 @@
fn main() {
let ok = "{{everything fine}}";
let bad = "\{it is wrong\}";
//~^ ERROR unknown character escape: {
//~^^ HELP if used in a formatting string, curly braces are escaped with `{{` and `}}`
//~^^^ ERROR unknown character escape: }
//~^^^^ HELP if used in a formatting string, curly braces are escaped with `{{` and `}}`
//~^ ERROR unknown character escape: `{`
//~| HELP if used in a formatting string, curly braces are escaped with `{{` and `}}`
//~| ERROR unknown character escape: `}`
//~| HELP if used in a formatting string, curly braces are escaped with `{{` and `}}`
}

4
src/test/ui/parser/wrong-escape-of-curly-braces.stderr
View File

@ -1,4 +1,4 @@
error: unknown character escape: {
error: unknown character escape: `{`
--> $DIR/wrong-escape-of-curly-braces.rs:3:17
|
LL | let bad = "\{it is wrong\}";
@ -6,7 +6,7 @@ LL | let bad = "\{it is wrong\}";
|
= help: if used in a formatting string, curly braces are escaped with `{{` and `}}`
error: unknown character escape: }
error: unknown character escape: `}`
--> $DIR/wrong-escape-of-curly-braces.rs:3:30
|
LL | let bad = "\{it is wrong\}";