1 //! Utilities for rendering escape sequence errors as diagnostics.
6 use rustc_errors::{pluralize, Applicability, Handler};
7 use rustc_lexer::unescape::{EscapeError, Mode};
8 use rustc_span::{BytePos, Span};
10 pub(crate) fn emit_unescape_error(
12 // interior part of the literal, without quotes
14 // full span of the literal, including quotes
15 span_with_quotes: Span,
16 // interior span of the literal, without quotes
19 // range of the error inside `lit`
24 "emit_unescape_error: {:?}, {:?}, {:?}, {:?}, {:?}",
25 lit, span_with_quotes, mode, range, error
28 let c = lit[range.clone()].chars().rev().next().unwrap();
29 let span = span.with_lo(span.hi() - BytePos(c.len_utf8() as u32));
33 EscapeError::LoneSurrogateUnicodeEscape => {
35 .struct_span_err(span, "invalid unicode character escape")
36 .span_label(span, "invalid escape")
37 .help("unicode escape must not be a surrogate")
40 EscapeError::OutOfRangeUnicodeEscape => {
42 .struct_span_err(span, "invalid unicode character escape")
43 .span_label(span, "invalid escape")
44 .help("unicode escape must be at most 10FFFF")
47 EscapeError::MoreThanOneChar => {
48 use unicode_normalization::{char::is_combining_mark, UnicodeNormalization};
50 let mut has_help = false;
51 let mut handler = handler.struct_span_err(
53 "character literal may only contain one codepoint",
56 if lit.chars().skip(1).all(|c| is_combining_mark(c)) {
58 lit.chars().skip(1).map(|c| c.escape_default().to_string()).collect::<Vec<_>>();
62 "this `{}` is followed by the combining mark{} `{}`",
63 lit.chars().next().unwrap(),
64 pluralize!(escaped_marks.len()),
65 escaped_marks.join(""),
68 let normalized = lit.nfc().to_string();
69 if normalized.chars().count() == 1 {
71 handler.span_suggestion(
74 "consider using the normalized form `{}` of this character",
75 normalized.chars().next().unwrap().escape_default()
78 Applicability::MachineApplicable,
82 let printable: Vec<char> = lit
85 unicode_width::UnicodeWidthChar::width(x).unwrap_or(0) != 0
90 if let [ch] = printable.as_slice() {
96 "there are non-printing characters, the full sequence is `{}`",
101 handler.span_suggestion(
103 "consider removing the non-printing characters",
105 Applicability::MaybeIncorrect,
111 let (prefix, msg) = if mode.is_byte() {
112 ("b", "if you meant to write a byte string literal, use double quotes")
114 ("", "if you meant to write a `str` literal, use double quotes")
116 let mut escaped = String::with_capacity(lit.len());
117 let mut chrs = lit.chars().peekable();
118 while let Some(first) = chrs.next() {
119 match (first, chrs.peek()) {
120 ('\\', Some('"')) => {
129 (c, _) => escaped.push(c),
132 handler.span_suggestion(
135 format!("{prefix}\"{escaped}\""),
136 Applicability::MachineApplicable,
142 EscapeError::EscapeOnlyChar => {
143 let (c, char_span) = last_char();
145 let msg = if mode.is_byte() {
146 "byte constant must be escaped"
148 "character constant must be escaped"
151 .struct_span_err(span, &format!("{}: `{}`", msg, escaped_char(c)))
154 "escape the character",
156 Applicability::MachineApplicable,
160 EscapeError::BareCarriageReturn => {
161 let msg = if mode.in_double_quotes() {
162 "bare CR not allowed in string, use `\\r` instead"
164 "character constant must be escaped: `\\r`"
167 .struct_span_err(span, msg)
170 "escape the character",
172 Applicability::MachineApplicable,
176 EscapeError::BareCarriageReturnInRawString => {
177 assert!(mode.in_double_quotes());
178 let msg = "bare CR not allowed in raw string";
179 handler.span_err(span, msg);
181 EscapeError::InvalidEscape => {
182 let (c, span) = last_char();
185 if mode.is_byte() { "unknown byte escape" } else { "unknown character escape" };
186 let ec = escaped_char(c);
187 let mut diag = handler.struct_span_err(span, &format!("{}: `{}`", label, ec));
188 diag.span_label(span, label);
189 if c == '{' || c == '}' && !mode.is_byte() {
191 "if used in a formatting string, curly braces are escaped with `{{` and `}}`",
193 } else if c == '\r' {
195 "this is an isolated carriage return; consider checking your editor and \
196 version control settings",
200 diag.span_suggestion(
202 "if you meant to write a literal backslash (perhaps escaping in a regular expression), consider a raw string literal",
203 format!("r\"{}\"", lit),
204 Applicability::MaybeIncorrect,
209 "for more information, visit \
210 <https://static.rust-lang.org/doc/master/reference.html#literals>",
215 EscapeError::TooShortHexEscape => {
216 handler.span_err(span, "numeric character escape is too short");
218 EscapeError::InvalidCharInHexEscape | EscapeError::InvalidCharInUnicodeEscape => {
219 let (c, span) = last_char();
221 let msg = if error == EscapeError::InvalidCharInHexEscape {
222 "invalid character in numeric character escape"
224 "invalid character in unicode escape"
226 let c = escaped_char(c);
229 .struct_span_err(span, &format!("{}: `{}`", msg, c))
230 .span_label(span, msg)
233 EscapeError::NonAsciiCharInByte => {
234 let (c, span) = last_char();
235 let desc = match mode {
236 Mode::Byte => "byte literal",
237 Mode::ByteStr => "byte string literal",
238 Mode::RawByteStr => "raw byte string literal",
239 _ => panic!("non-is_byte literal paired with NonAsciiCharInByte"),
241 let mut err = handler.struct_span_err(span, format!("non-ASCII character in {}", desc));
242 let postfix = if unicode_width::UnicodeWidthChar::width(c).unwrap_or(1) == 0 {
243 format!(" but is {:?}", c)
247 err.span_label(span, &format!("must be ASCII{}", postfix));
248 // Note: the \\xHH suggestions are not given for raw byte string
249 // literals, because they are araw and so cannot use any escapes.
250 if (c as u32) <= 0xFF && mode != Mode::RawByteStr {
254 "if you meant to use the unicode code point for {:?}, use a \\xHH escape",
257 format!("\\x{:X}", c as u32),
258 Applicability::MaybeIncorrect,
260 } else if mode == Mode::Byte {
261 err.span_label(span, "this multibyte character does not fit into a single byte");
262 } else if mode != Mode::RawByteStr {
263 let mut utf8 = String::new();
268 "if you meant to use the UTF-8 encoding of {:?}, use \\xHH escapes",
273 .map(|b: &u8| format!("\\x{:X}", *b))
274 .fold("".to_string(), |a, c| a + &c),
275 Applicability::MaybeIncorrect,
280 EscapeError::OutOfRangeHexEscape => {
282 .struct_span_err(span, "out of range hex escape")
283 .span_label(span, "must be a character in the range [\\x00-\\x7f]")
286 EscapeError::LeadingUnderscoreUnicodeEscape => {
287 let (c, span) = last_char();
288 let msg = "invalid start of unicode escape";
290 .struct_span_err(span, &format!("{}: `{}`", msg, c))
291 .span_label(span, msg)
294 EscapeError::OverlongUnicodeEscape => {
296 .struct_span_err(span, "overlong unicode escape")
297 .span_label(span, "must have at most 6 hex digits")
300 EscapeError::UnclosedUnicodeEscape => {
302 .struct_span_err(span, "unterminated unicode escape")
303 .span_label(span, "missing a closing `}`")
304 .span_suggestion_verbose(
306 "terminate the unicode escape",
308 Applicability::MaybeIncorrect,
312 EscapeError::NoBraceInUnicodeEscape => {
313 let msg = "incorrect unicode escape sequence";
314 let mut diag = handler.struct_span_err(span, msg);
316 let mut suggestion = "\\u{".to_owned();
317 let mut suggestion_len = 0;
318 let (c, char_span) = last_char();
319 let chars = once(c).chain(lit[range.end..].chars());
320 for c in chars.take(6).take_while(|c| c.is_digit(16)) {
322 suggestion_len += c.len_utf8();
325 if suggestion_len > 0 {
326 suggestion.push('}');
327 let hi = char_span.lo() + BytePos(suggestion_len as u32);
328 diag.span_suggestion(
330 "format of unicode escape sequences uses braces",
332 Applicability::MaybeIncorrect,
335 diag.span_label(span, msg);
336 diag.help("format of unicode escape sequences is `\\u{...}`");
341 EscapeError::UnicodeEscapeInByte => {
342 let msg = "unicode escape in byte string";
344 .struct_span_err(span, msg)
345 .span_label(span, msg)
346 .help("unicode escape sequences cannot be used as a byte or in a byte string")
349 EscapeError::EmptyUnicodeEscape => {
351 .struct_span_err(span, "empty unicode escape")
352 .span_label(span, "this escape must have at least 1 hex digit")
355 EscapeError::ZeroChars => {
356 let msg = "empty character literal";
357 handler.struct_span_err(span, msg).span_label(span, msg).emit();
359 EscapeError::LoneSlash => {
360 let msg = "invalid trailing slash in literal";
361 handler.struct_span_err(span, msg).span_label(span, msg).emit();
363 EscapeError::UnskippedWhitespaceWarning => {
364 let (c, char_span) = last_char();
366 format!("non-ASCII whitespace symbol '{}' is not skipped", c.escape_unicode());
367 handler.struct_span_warn(span, &msg).span_label(char_span, &msg).emit();
369 EscapeError::MultipleSkippedLinesWarning => {
370 let msg = "multiple lines skipped by escaped newline";
371 let bottom_msg = "skipping everything up to and including this point";
372 handler.struct_span_warn(span, msg).span_label(span, bottom_msg).emit();
377 /// Pushes a character to a message string for error reporting
378 pub(crate) fn escaped_char(c: char) -> String {
380 '\u{20}'..='\u{7e}' => {
381 // Don't escape \, ' or " for user-facing messages
384 _ => c.escape_default().to_string(),