Enum ParseError 

pub enum ParseError {
    UnexpectedToken {
        found: TokenKind,
        expected: Vec<TokenKind>,
        span: Span,
    },
    UnexpectedEof {
        expected: Vec<TokenKind>,
        span: Span,
    },
    LexerError {
        message: String,
        span: Span,
    },
}

Domain-specific parser errors.

Consumed by the lexer (week 2), recognizer (later wiring), CST builder and AST builder. Each variant can be converted via ParseError::to_diagnostic into a Diagnostic.

Variants

UnexpectedToken

A specific set of tokens was expected, but a different token was found.

Fields

found: TokenKind

What was actually read.

expected: Vec<TokenKind>

Which tokens were expected (from the Earley expected-set).

span: Span

Position of the unexpected token.

UnexpectedEof

Input ended before the production was complete. At least one more token was expected.

Fields

expected: Vec<TokenKind>

What was expected at this position.

span: Span

End position of the input.

LexerError

Lexer-specific error (invalid character sequence, unterminated string, etc.). The detail text is lexer-specific.

Fields

message: String

Description of the lexer problem.

span: Span

Position of the faulty sequence.

Implementations

impl ParseError

pub fn to_diagnostic(&self) -> Diagnostic

Converts a parser error into a uniform Diagnostic.

pub const fn span(&self) -> Span

Position of the error in the source text.

Trait Implementations

impl Clone for ParseError

fn clone(&self) -> ParseError

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ParseError

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

Formats the value using the given formatter.

impl Eq for ParseError

impl From<ParseError> for Error

fn from(e: ParseError) -> Self

Converts to this type from the input type.

impl PartialEq for ParseError

fn eq(&self, other: &ParseError) -> 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 StructuralPartialEq for ParseError