Enum ParseErrorKind 

pub enum ParseErrorKind {
    UnexpectedToken {
        found: TokenInfo,
        expected: Vec<ExpectedToken>,
    },
    UnexpectedEof {
        expected: Vec<ExpectedToken>,
    },
    UnterminatedString {
        start_location: SourceLocation,
        delimiter: StringDelimiter,
    },
    UnterminatedComment {
        start_location: SourceLocation,
    },
    InvalidNumber {
        text: String,
        reason: NumberError,
    },
    UnbalancedDelimiter {
        opener: char,
        open_location: SourceLocation,
        found: Option<char>,
    },
    ReservedKeyword {
        keyword: String,
        context: IdentifierContext,
    },
    InvalidEscape {
        sequence: String,
        valid_escapes: Vec<String>,
    },
    InvalidCharacter {
        char: char,
        codepoint: u32,
    },
    MissingComponent {
        component: MissingComponentKind,
        after: Option<String>,
    },
    Custom {
        message: String,
    },
}

Specific parse error variants with structured context

Variants

UnexpectedToken

Parser expected specific tokens but found something else

Fields

found: TokenInfo

What was found at this position

expected: Vec<ExpectedToken>

What tokens/rules were expected

UnexpectedEof

End of input reached unexpectedly

Fields

expected: Vec<ExpectedToken>

What tokens/rules were expected

UnterminatedString

Unterminated string literal

Fields

start_location: SourceLocation

Where the string started

delimiter: StringDelimiter

The delimiter used

UnterminatedComment

Unterminated block comment

Fields

start_location: SourceLocation

Where the comment started

InvalidNumber

Invalid number literal

Fields

text: String

The invalid number text

reason: NumberError

Why it’s invalid

UnbalancedDelimiter

Unbalanced delimiter (brackets, braces, parentheses)

Fields

opener: char

The opening delimiter

open_location: SourceLocation

Where it was opened

found: Option<char>

What was found instead of closing (if any)

ReservedKeyword

Reserved keyword used as identifier

Fields

keyword: String

The keyword that was used

context: IdentifierContext

Context where it was used

InvalidEscape

Invalid escape sequence in string

Fields

sequence: String

The escape sequence text

valid_escapes: Vec<String>

Valid escapes for reference

InvalidCharacter

Invalid character in source

Fields

char: char

The invalid character

codepoint: u32

Unicode codepoint for non-printable chars

MissingComponent

Missing required component

Fields

component: MissingComponentKind

What’s missing

after: Option<String>

Where it should appear

Custom

Custom parse error from semantic validation during parsing

Fields

message: String

Error message

Trait Implementations

impl Clone for ParseErrorKind

fn clone(&self) -> ParseErrorKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ParseErrorKind

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

Formats the value using the given formatter.

impl PartialEq for ParseErrorKind

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