src/err.rs - platform/external/rust/crates/litrs - Git at Google

 use std::{fmt, ops::Range};


 /// An error signaling that a different kind of token was expected. Returned by
 /// the various `TryFrom` impls.
 #[derive(Debug, Clone, Copy)]
 pub struct InvalidToken {
     pub(crate) expected: TokenKind,
     pub(crate) actual: TokenKind,
     pub(crate) span: Span,
 }

 impl InvalidToken {
     /// Returns a token stream representing `compile_error!("msg");` where
     /// `"msg"` is the output of `self.to_string()`. **Panics if called outside
     /// of a proc-macro context!**
     pub fn to_compile_error(&self) -> proc_macro::TokenStream {
         use proc_macro::{Delimiter, Ident, Group, Punct, Spacing, TokenTree};

         let span = match self.span {
             Span::One(s) => s,
             #[cfg(feature = "proc-macro2")]
             Span::Two(s) => s.unwrap(),
         };
         let msg = self.to_string();
         let tokens = vec![
             TokenTree::from(Ident::new("compile_error", span)),
             TokenTree::from(Punct::new('!', Spacing::Alone)),
             TokenTree::from(Group::new(
                 Delimiter::Parenthesis,
                 TokenTree::from(proc_macro::Literal::string(&msg)).into(),
             )),
         ];


         tokens.into_iter().map(|mut t| { t.set_span(span); t }).collect()
     }

     /// Like [`to_compile_error`][Self::to_compile_error], but returns a token
     /// stream from `proc_macro2` and does not panic outside of a proc-macro
     /// context.
     #[cfg(feature = "proc-macro2")]
     pub fn to_compile_error2(&self) -> proc_macro2::TokenStream {
         use proc_macro2::{Delimiter, Ident, Group, Punct, Spacing, TokenTree};

         let span = match self.span {
             Span::One(s) => proc_macro2::Span::from(s),
             Span::Two(s) => s,
         };
         let msg = self.to_string();
         let tokens = vec![
             TokenTree::from(Ident::new("compile_error", span)),
             TokenTree::from(Punct::new('!', Spacing::Alone)),
             TokenTree::from(Group::new(
                 Delimiter::Parenthesis,
                 TokenTree::from(proc_macro2::Literal::string(&msg)).into(),
             )),
         ];


         tokens.into_iter().map(|mut t| { t.set_span(span); t }).collect()
     }
 }

 impl std::error::Error for InvalidToken {}

 impl fmt::Display for InvalidToken {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         fn kind_desc(kind: TokenKind) -> &'static str {
             match kind {
                 TokenKind::Punct => "a punctuation character",
                 TokenKind::Ident => "an identifier",
                 TokenKind::Group => "a group",
                 TokenKind::Literal => "a literal",
                 TokenKind::BoolLit => "a bool literal (`true` or `false`)",
                 TokenKind::ByteLit => "a byte literal (e.g. `b'r')",
                 TokenKind::ByteStringLit => r#"a byte string literal (e.g. `b"fox"`)"#,
                 TokenKind::CharLit => "a character literal (e.g. `'P'`)",
                 TokenKind::FloatLit => "a float literal (e.g. `3.14`)",
                 TokenKind::IntegerLit => "an integer literal (e.g. `27`)",
                 TokenKind::StringLit => r#"a string literal (e.g. "Ferris")"#,
             }
         }

         write!(f, "expected {}, but found {}", kind_desc(self.expected), kind_desc(self.actual))
     }
 }

 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub(crate) enum TokenKind {
     Punct,
     Ident,
     Group,
     Literal,
     BoolLit,
     ByteLit,
     ByteStringLit,
     CharLit,
     FloatLit,
     IntegerLit,
     StringLit,
 }

 /// Unfortunately, we have to deal with both cases.
 #[derive(Debug, Clone, Copy)]
 pub(crate) enum Span {
     One(proc_macro::Span),
     #[cfg(feature = "proc-macro2")]
     Two(proc_macro2::Span),
 }

 impl From<proc_macro::Span> for Span {
     fn from(src: proc_macro::Span) -> Self {
         Self::One(src)
     }
 }

 #[cfg(feature = "proc-macro2")]
 impl From<proc_macro2::Span> for Span {
     fn from(src: proc_macro2::Span) -> Self {
         Self::Two(src)
     }
 }

 /// Errors during parsing.
 ///
 /// This type should be seen primarily for error reporting and not for catching
 /// specific cases. The span and error kind are not guaranteed to be stable
 /// over different versions of this library, meaning that a returned error can
 /// change from one version to the next. There are simply too many fringe cases
 /// that are not easy to classify as a specific error kind. It depends entirely
 /// on the specific parser code how an invalid input is categorized.
 ///
 /// Consider these examples:
 /// - `'\` can be seen as
 ///     - invalid escape in character literal, or
 ///     - unterminated character literal.
 /// - `'''` can be seen as
 ///     - empty character literal, or
 ///     - unescaped quote character in character literal.
 /// - `0b64` can be seen as
 ///     - binary integer literal with invalid digit 6, or
 ///     - binary integer literal with invalid digit 4, or
 ///     - decimal integer literal with invalid digit b, or
 ///     - decimal integer literal 0 with unknown type suffix `b64`.
 ///
 /// If you want to see more if these examples, feel free to check out the unit
 /// tests of this library.
 ///
 /// While this library does its best to emit sensible and precise errors, and to
 /// keep the returned errors as stable as possible, full stability cannot be
 /// guaranteed.
 #[derive(Debug, Clone)]
 pub struct ParseError {
     pub(crate) span: Option<Range<usize>>,
     pub(crate) kind: ParseErrorKind,
 }

 impl ParseError {
     /// Returns a span of this error, if available. **Note**: the returned span
     /// might change in future versions of this library. See [the documentation
     /// of this type][ParseError] for more information.
     pub fn span(&self) -> Option<Range<usize>> {
         self.span.clone()
     }
 }

 /// This is a free standing function instead of an associated one to reduce
 /// noise around parsing code. There are lots of places that create errors, we
 /// I wanna keep them as short as possible.
 pub(crate) fn perr(span: impl SpanLike, kind: ParseErrorKind) -> ParseError {
     ParseError {
         span: span.into_span(),
         kind,
     }
 }

 pub(crate) trait SpanLike {
     fn into_span(self) -> Option<Range<usize>>;
 }

 impl SpanLike for Option<Range<usize>> {
     #[inline(always)]
     fn into_span(self) -> Option<Range<usize>> {
         self
     }
 }
 impl SpanLike for Range<usize> {
     #[inline(always)]
     fn into_span(self) -> Option<Range<usize>> {
         Some(self)
     }
 }
 impl SpanLike for usize {
     #[inline(always)]
     fn into_span(self) -> Option<Range<usize>> {
         Some(self..self + 1)
     }
 }


 /// Kinds of errors.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 #[non_exhaustive]
 pub(crate) enum ParseErrorKind {
     /// The input was an empty string
     Empty,

     /// An unexpected char was encountered.
     UnexpectedChar,

     /// Literal was not recognized.
     InvalidLiteral,

     /// Input does not start with decimal digit when trying to parse an integer.
     DoesNotStartWithDigit,

     /// A digit invalid for the specified integer base was found.
     InvalidDigit,

     /// Integer literal does not contain any valid digits.
     NoDigits,

     /// Found a integer type suffix that is invalid.
     InvalidIntegerTypeSuffix,

     /// Found a float type suffix that is invalid. Only `f32` and `f64` are
     /// valid.
     InvalidFloatTypeSuffix,

     /// Exponent of a float literal does not contain any digits.
     NoExponentDigits,

     /// An unknown escape code, e.g. `\b`.
     UnknownEscape,

     /// A started escape sequence where the input ended before the escape was
     /// finished.
     UnterminatedEscape,

     /// An `\x` escape where the two digits are not valid hex digits.
     InvalidXEscape,

     /// A string or character literal using the `\xNN` escape where `NN > 0x7F`.
     NonAsciiXEscape,

     /// A `\u{...}` escape in a byte or byte string literal.
     UnicodeEscapeInByteLiteral,

     /// A Unicode escape that does not start with a hex digit.
     InvalidStartOfUnicodeEscape,

     /// A `\u{...}` escape that lacks the opening brace.
     UnicodeEscapeWithoutBrace,

     /// In a `\u{...}` escape, a non-hex digit and non-underscore character was
     /// found.
     NonHexDigitInUnicodeEscape,

     /// More than 6 digits found in unicode escape.
     TooManyDigitInUnicodeEscape,

     /// The value from a unicode escape does not represent a valid character.
     InvalidUnicodeEscapeChar,

     /// A `\u{..` escape that is not terminated (lacks the closing brace).
     UnterminatedUnicodeEscape,

     /// A character literal that's not terminated.
     UnterminatedCharLiteral,

     /// A character literal that contains more than one character.
     OverlongCharLiteral,

     /// An empty character literal, i.e. `''`.
     EmptyCharLiteral,

     UnterminatedByteLiteral,
     OverlongByteLiteral,
     EmptyByteLiteral,
     NonAsciiInByteLiteral,

     /// A `'` character was not escaped in a character or byte literal, or a `"`
     /// character was not escaped in a string or byte string literal.
     UnescapedSingleQuote,

     /// A \n, \t or \r raw character in a char or byte literal.
     UnescapedSpecialWhitespace,

     /// When parsing a character, byte, string or byte string literal directly
     /// and the input does not start with the corresponding quote character
     /// (plus optional raw string prefix).
     DoesNotStartWithQuote,

     /// Unterminated raw string literal.
     UnterminatedRawString,

     /// String literal without a `"` at the end.
     UnterminatedString,

     /// Invalid start for a string literal.
     InvalidStringLiteralStart,

     /// Invalid start for a byte literal.
     InvalidByteLiteralStart,

     InvalidByteStringLiteralStart,

     /// An literal `\r` character not followed by a `\n` character in a
     /// (raw) string or byte string literal.
     IsolatedCr,
 }

 impl std::error::Error for ParseError {}

 impl fmt::Display for ParseError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         use ParseErrorKind::*;

         let description = match self.kind {
             Empty => "input is empty",
             UnexpectedChar => "unexpected character",
             InvalidLiteral => "invalid literal",
             DoesNotStartWithDigit => "number literal does not start with decimal digit",
             InvalidDigit => "integer literal contains a digit invalid for its base",
             NoDigits => "integer literal does not contain any digits",
             InvalidIntegerTypeSuffix => "invalid integer type suffix",
             InvalidFloatTypeSuffix => "invalid floating point type suffix",
             NoExponentDigits => "exponent of floating point literal does not contain any digits",
             UnknownEscape => "unknown escape",
             UnterminatedEscape => "unterminated escape: input ended too soon",
             InvalidXEscape => r"invalid `\x` escape: not followed by two hex digits",
             NonAsciiXEscape => r"`\x` escape in char/string literal exceed ASCII range",
             UnicodeEscapeInByteLiteral => r"`\u{...}` escape in byte (string) literal not allowed",
             InvalidStartOfUnicodeEscape => r"invalid start of `\u{...}` escape",
             UnicodeEscapeWithoutBrace => r"`Unicode \u{...}` escape without opening brace",
             NonHexDigitInUnicodeEscape => r"non-hex digit found in `\u{...}` escape",
             TooManyDigitInUnicodeEscape => r"more than six digits in `\u{...}` escape",
             InvalidUnicodeEscapeChar => r"value specified in `\u{...}` escape is not a valid char",
             UnterminatedUnicodeEscape => r"unterminated `\u{...}` escape",
             UnterminatedCharLiteral => "character literal is not terminated",
             OverlongCharLiteral => "character literal contains more than one character",
             EmptyCharLiteral => "empty character literal",
             UnterminatedByteLiteral => "byte literal is not terminated",
             OverlongByteLiteral => "byte literal contains more than one byte",
             EmptyByteLiteral => "empty byte literal",
             NonAsciiInByteLiteral => "non ASCII character in byte (string) literal",
             UnescapedSingleQuote => "character literal contains unescaped ' character",
             UnescapedSpecialWhitespace => r"unescaped newline (\n), tab (\t) or cr (\r) character",
             DoesNotStartWithQuote => "invalid start for char/byte/string literal",
             UnterminatedRawString => "unterminated raw (byte) string literal",
             UnterminatedString => "unterminated (byte) string literal",
             InvalidStringLiteralStart => "invalid start for string literal",
             InvalidByteLiteralStart => "invalid start for byte literal",
             InvalidByteStringLiteralStart => "invalid start for byte string literal",
             IsolatedCr => r"`\r` not immediately followed by `\n` in string",
         };

         description.fmt(f)?;
         if let Some(span) = &self.span {
             write!(f, " (at {}..{})", span.start, span.end)?;
         }

         Ok(())
     }
 }
	use std::{fmt, ops::Range};


	/// An error signaling that a different kind of token was expected. Returned by
	/// the various `TryFrom` impls.
	#[derive(Debug, Clone, Copy)]
	pub struct InvalidToken {
	pub(crate) expected: TokenKind,
	pub(crate) actual: TokenKind,
	pub(crate) span: Span,
	}

	impl InvalidToken {
	/// Returns a token stream representing `compile_error!("msg");` where
	/// `"msg"` is the output of `self.to_string()`. **Panics if called outside
	/// of a proc-macro context!**
	pub fn to_compile_error(&self) -> proc_macro::TokenStream {
	use proc_macro::{Delimiter, Ident, Group, Punct, Spacing, TokenTree};

	let span = match self.span {
	Span::One(s) => s,
	#[cfg(feature = "proc-macro2")]
	Span::Two(s) => s.unwrap(),
	};
	let msg = self.to_string();
	let tokens = vec![
	TokenTree::from(Ident::new("compile_error", span)),
	TokenTree::from(Punct::new('!', Spacing::Alone)),
	TokenTree::from(Group::new(
	Delimiter::Parenthesis,
	TokenTree::from(proc_macro::Literal::string(&msg)).into(),
	)),
	];


	tokens.into_iter().map(\|mut t\| { t.set_span(span); t }).collect()
	}

	/// Like [`to_compile_error`][Self::to_compile_error], but returns a token
	/// stream from `proc_macro2` and does not panic outside of a proc-macro
	/// context.
	#[cfg(feature = "proc-macro2")]
	pub fn to_compile_error2(&self) -> proc_macro2::TokenStream {
	use proc_macro2::{Delimiter, Ident, Group, Punct, Spacing, TokenTree};

	let span = match self.span {
	Span::One(s) => proc_macro2::Span::from(s),
	Span::Two(s) => s,
	};
	let msg = self.to_string();
	let tokens = vec![
	TokenTree::from(Ident::new("compile_error", span)),
	TokenTree::from(Punct::new('!', Spacing::Alone)),
	TokenTree::from(Group::new(
	Delimiter::Parenthesis,
	TokenTree::from(proc_macro2::Literal::string(&msg)).into(),
	)),
	];


	tokens.into_iter().map(\|mut t\| { t.set_span(span); t }).collect()
	}
	}

	impl std::error::Error for InvalidToken {}

	impl fmt::Display for InvalidToken {
	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
	fn kind_desc(kind: TokenKind) -> &'static str {
	match kind {
	TokenKind::Punct => "a punctuation character",
	TokenKind::Ident => "an identifier",
	TokenKind::Group => "a group",
	TokenKind::Literal => "a literal",
	TokenKind::BoolLit => "a bool literal (`true` or `false`)",
	TokenKind::ByteLit => "a byte literal (e.g. `b'r')",
	TokenKind::ByteStringLit => r#"a byte string literal (e.g. `b"fox"`)"#,
	TokenKind::CharLit => "a character literal (e.g. `'P'`)",
	TokenKind::FloatLit => "a float literal (e.g. `3.14`)",
	TokenKind::IntegerLit => "an integer literal (e.g. `27`)",
	TokenKind::StringLit => r#"a string literal (e.g. "Ferris")"#,
	}
	}

	write!(f, "expected {}, but found {}", kind_desc(self.expected), kind_desc(self.actual))
	}
	}

	#[derive(Debug, Clone, Copy, PartialEq, Eq)]
	pub(crate) enum TokenKind {
	Punct,
	Ident,
	Group,
	Literal,
	BoolLit,
	ByteLit,
	ByteStringLit,
	CharLit,
	FloatLit,
	IntegerLit,
	StringLit,
	}

	/// Unfortunately, we have to deal with both cases.
	#[derive(Debug, Clone, Copy)]
	pub(crate) enum Span {
	One(proc_macro::Span),
	#[cfg(feature = "proc-macro2")]
	Two(proc_macro2::Span),
	}

	impl From<proc_macro::Span> for Span {
	fn from(src: proc_macro::Span) -> Self {
	Self::One(src)
	}
	}

	#[cfg(feature = "proc-macro2")]
	impl From<proc_macro2::Span> for Span {
	fn from(src: proc_macro2::Span) -> Self {
	Self::Two(src)
	}
	}

	/// Errors during parsing.
	///
	/// This type should be seen primarily for error reporting and not for catching
	/// specific cases. The span and error kind are not guaranteed to be stable
	/// over different versions of this library, meaning that a returned error can
	/// change from one version to the next. There are simply too many fringe cases
	/// that are not easy to classify as a specific error kind. It depends entirely
	/// on the specific parser code how an invalid input is categorized.
	///
	/// Consider these examples:
	/// - `'\` can be seen as
	/// - invalid escape in character literal, or
	/// - unterminated character literal.
	/// - `'''` can be seen as
	/// - empty character literal, or
	/// - unescaped quote character in character literal.
	/// - `0b64` can be seen as
	/// - binary integer literal with invalid digit 6, or
	/// - binary integer literal with invalid digit 4, or
	/// - decimal integer literal with invalid digit b, or
	/// - decimal integer literal 0 with unknown type suffix `b64`.
	///
	/// If you want to see more if these examples, feel free to check out the unit
	/// tests of this library.
	///
	/// While this library does its best to emit sensible and precise errors, and to
	/// keep the returned errors as stable as possible, full stability cannot be
	/// guaranteed.
	#[derive(Debug, Clone)]
	pub struct ParseError {
	pub(crate) span: Option<Range<usize>>,
	pub(crate) kind: ParseErrorKind,
	}

	impl ParseError {
	/// Returns a span of this error, if available. Note: the returned span
	/// might change in future versions of this library. See [the documentation
	/// of this type][ParseError] for more information.
	pub fn span(&self) -> Option<Range<usize>> {
	self.span.clone()
	}
	}

	/// This is a free standing function instead of an associated one to reduce
	/// noise around parsing code. There are lots of places that create errors, we
	/// I wanna keep them as short as possible.
	pub(crate) fn perr(span: impl SpanLike, kind: ParseErrorKind) -> ParseError {
	ParseError {
	span: span.into_span(),
	kind,
	}
	}

	pub(crate) trait SpanLike {
	fn into_span(self) -> Option<Range<usize>>;
	}

	impl SpanLike for Option<Range<usize>> {
	#[inline(always)]
	fn into_span(self) -> Option<Range<usize>> {
	self
	}
	}
	impl SpanLike for Range<usize> {
	#[inline(always)]
	fn into_span(self) -> Option<Range<usize>> {
	Some(self)
	}
	}
	impl SpanLike for usize {
	#[inline(always)]
	fn into_span(self) -> Option<Range<usize>> {
	Some(self..self + 1)
	}
	}


	/// Kinds of errors.
	#[derive(Debug, Clone, Copy, PartialEq, Eq)]
	#[non_exhaustive]
	pub(crate) enum ParseErrorKind {
	/// The input was an empty string
	Empty,

	/// An unexpected char was encountered.
	UnexpectedChar,

	/// Literal was not recognized.
	InvalidLiteral,

	/// Input does not start with decimal digit when trying to parse an integer.
	DoesNotStartWithDigit,

	/// A digit invalid for the specified integer base was found.
	InvalidDigit,

	/// Integer literal does not contain any valid digits.
	NoDigits,

	/// Found a integer type suffix that is invalid.
	InvalidIntegerTypeSuffix,

	/// Found a float type suffix that is invalid. Only `f32` and `f64` are
	/// valid.
	InvalidFloatTypeSuffix,

	/// Exponent of a float literal does not contain any digits.
	NoExponentDigits,

	/// An unknown escape code, e.g. `\b`.
	UnknownEscape,

	/// A started escape sequence where the input ended before the escape was
	/// finished.
	UnterminatedEscape,

	/// An `\x` escape where the two digits are not valid hex digits.
	InvalidXEscape,

	/// A string or character literal using the `\xNN` escape where `NN > 0x7F`.
	NonAsciiXEscape,

	/// A `\u{...}` escape in a byte or byte string literal.
	UnicodeEscapeInByteLiteral,

	/// A Unicode escape that does not start with a hex digit.
	InvalidStartOfUnicodeEscape,

	/// A `\u{...}` escape that lacks the opening brace.
	UnicodeEscapeWithoutBrace,

	/// In a `\u{...}` escape, a non-hex digit and non-underscore character was
	/// found.
	NonHexDigitInUnicodeEscape,

	/// More than 6 digits found in unicode escape.
	TooManyDigitInUnicodeEscape,

	/// The value from a unicode escape does not represent a valid character.
	InvalidUnicodeEscapeChar,

	/// A `\u{..` escape that is not terminated (lacks the closing brace).
	UnterminatedUnicodeEscape,

	/// A character literal that's not terminated.
	UnterminatedCharLiteral,

	/// A character literal that contains more than one character.
	OverlongCharLiteral,

	/// An empty character literal, i.e. `''`.
	EmptyCharLiteral,

	UnterminatedByteLiteral,
	OverlongByteLiteral,
	EmptyByteLiteral,
	NonAsciiInByteLiteral,

	/// A `'` character was not escaped in a character or byte literal, or a `"`
	/// character was not escaped in a string or byte string literal.
	UnescapedSingleQuote,

	/// A \n, \t or \r raw character in a char or byte literal.
	UnescapedSpecialWhitespace,

	/// When parsing a character, byte, string or byte string literal directly
	/// and the input does not start with the corresponding quote character
	/// (plus optional raw string prefix).
	DoesNotStartWithQuote,

	/// Unterminated raw string literal.
	UnterminatedRawString,

	/// String literal without a `"` at the end.
	UnterminatedString,

	/// Invalid start for a string literal.
	InvalidStringLiteralStart,

	/// Invalid start for a byte literal.
	InvalidByteLiteralStart,

	InvalidByteStringLiteralStart,

	/// An literal `\r` character not followed by a `\n` character in a
	/// (raw) string or byte string literal.
	IsolatedCr,
	}

	impl std::error::Error for ParseError {}

	impl fmt::Display for ParseError {
	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
	use ParseErrorKind::*;

	let description = match self.kind {
	Empty => "input is empty",
	UnexpectedChar => "unexpected character",
	InvalidLiteral => "invalid literal",
	DoesNotStartWithDigit => "number literal does not start with decimal digit",
	InvalidDigit => "integer literal contains a digit invalid for its base",
	NoDigits => "integer literal does not contain any digits",
	InvalidIntegerTypeSuffix => "invalid integer type suffix",
	InvalidFloatTypeSuffix => "invalid floating point type suffix",
	NoExponentDigits => "exponent of floating point literal does not contain any digits",
	UnknownEscape => "unknown escape",
	UnterminatedEscape => "unterminated escape: input ended too soon",
	InvalidXEscape => r"invalid `\x` escape: not followed by two hex digits",
	NonAsciiXEscape => r"`\x` escape in char/string literal exceed ASCII range",
	UnicodeEscapeInByteLiteral => r"`\u{...}` escape in byte (string) literal not allowed",
	InvalidStartOfUnicodeEscape => r"invalid start of `\u{...}` escape",
	UnicodeEscapeWithoutBrace => r"`Unicode \u{...}` escape without opening brace",
	NonHexDigitInUnicodeEscape => r"non-hex digit found in `\u{...}` escape",
	TooManyDigitInUnicodeEscape => r"more than six digits in `\u{...}` escape",
	InvalidUnicodeEscapeChar => r"value specified in `\u{...}` escape is not a valid char",
	UnterminatedUnicodeEscape => r"unterminated `\u{...}` escape",
	UnterminatedCharLiteral => "character literal is not terminated",
	OverlongCharLiteral => "character literal contains more than one character",
	EmptyCharLiteral => "empty character literal",
	UnterminatedByteLiteral => "byte literal is not terminated",
	OverlongByteLiteral => "byte literal contains more than one byte",
	EmptyByteLiteral => "empty byte literal",
	NonAsciiInByteLiteral => "non ASCII character in byte (string) literal",
	UnescapedSingleQuote => "character literal contains unescaped ' character",
	UnescapedSpecialWhitespace => r"unescaped newline (\n), tab (\t) or cr (\r) character",
	DoesNotStartWithQuote => "invalid start for char/byte/string literal",
	UnterminatedRawString => "unterminated raw (byte) string literal",
	UnterminatedString => "unterminated (byte) string literal",
	InvalidStringLiteralStart => "invalid start for string literal",
	InvalidByteLiteralStart => "invalid start for byte literal",
	InvalidByteStringLiteralStart => "invalid start for byte string literal",
	IsolatedCr => r"`\r` not immediately followed by `\n` in string",
	};

	description.fmt(f)?;
	if let Some(span) = &self.span {
	write!(f, " (at {}..{})", span.start, span.end)?;
	}

	Ok(())
	}
	}