Enum LexError 

#[non_exhaustive]
pub enum LexError {
    DanglingBlockComment,
    Unexpected(char),
    InvalidStringElement(char),
    InvalidStringEscape(char),
    InvalidHexDigit(char),
    InvalidDigit(char),
    Expected {
        wanted: char,
        found: char,
    },
    UnexpectedEof,
    NumberTooBig,
    InvalidUnicodeValue(u32),
    LoneUnderscore,
    ConfusingUnicode(char),
    InvalidUtf8Id(Utf8Error),
    EmptyId,
    EmptyAnnotation,
}

Errors that can be generated while lexing.

All lexing errors have line/colum/position information as well as a LexError indicating what kind of error happened while lexing.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

DanglingBlockComment

A dangling block comment was found with an unbalanced (; which was never terminated in the file.

Unexpected(char)

An unexpected character was encountered when generally parsing and looking for something else.

InvalidStringElement(char)

An invalid char in a string literal was found.

InvalidStringEscape(char)

An invalid string escape letter was found (the thing after the \ in string literals)

InvalidHexDigit(char)

An invalid hexadecimal digit was found.

InvalidDigit(char)

An invalid base-10 digit was found.

Expected

Parsing expected wanted but ended up finding found instead where the two characters aren’t the same.

Fields

wanted: char

The character that was expected to be found

found: char

The character that was actually found

UnexpectedEof

We needed to parse more but EOF (or end of the string) was encountered.

NumberTooBig

A number failed to parse because it was too big to fit within the target type.

InvalidUnicodeValue(u32)

An invalid unicode value was found in a \u{...} escape in a string, only valid unicode scalars can be escaped that way.

LoneUnderscore

A lone underscore was found when parsing a number, since underscores should always be preceded and succeeded with a digit of some form.

ConfusingUnicode(char)

A “confusing” unicode character is present in a comment or a string literal, such as a character that changes the direction text is typically displayed in editors. This could cause the human-read version to behave differently than the compiler-visible version, so these are simply rejected for now.

InvalidUtf8Id(Utf8Error)

An invalid utf-8 sequence was found in a quoted identifier, such as $"\ff".

EmptyId

An empty identifier was found, or a lone $.

EmptyAnnotation

An empty identifier was found, or a lone @.

Trait Implementations

impl Clone for LexError

fn clone(&self) -> LexError

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for LexError

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for LexError

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for LexError

fn eq(&self, other: &LexError) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for LexError

impl StructuralPartialEq for LexError