Trait Parser

pub trait Parser: Sized {
    type Kind: SyntaxKind;
    type Source: TokenSource<Kind = Self::Kind>;

    // Required methods
    fn context(&self) -> &ParserContext<Self::Kind>;
    fn context_mut(&mut self) -> &mut ParserContext<Self::Kind>;
    fn source(&self) -> &Self::Source;
    fn source_mut(&mut self) -> &mut Self::Source;

    // Provided methods
    fn is_speculative_parsing(&self) -> bool { ... }
    fn text(&self, span: TextRange) -> &str { ... }
    fn cur(&self) -> Self::Kind { ... }
    fn cur_range(&self) -> TextRange { ... }
    fn has_preceding_line_break(&self) -> bool { ... }
    fn cur_text(&self) -> &str { ... }
    fn at(&self, kind: Self::Kind) -> bool { ... }
    fn at_ts(&self, kinds: TokenSet<Self::Kind>) -> bool { ... }
    fn nth(&mut self, n: usize) -> Self::Kind
       where Self::Source: NthToken { ... }
    fn nth_at(&mut self, n: usize, kind: Self::Kind) -> bool
       where Self::Source: NthToken { ... }
    fn has_nth_preceding_line_break(&mut self, n: usize) -> bool
       where Self::Source: NthToken { ... }
    fn bump(&mut self, kind: Self::Kind) { ... }
    fn bump_remap(&mut self, kind: Self::Kind) { ... }
    fn bump_any(&mut self) { ... }
    fn bump_with_context(
        &mut self,
        kind: Self::Kind,
        context: <Self::Source as BumpWithContext>::Context,
    )
       where Self::Source: BumpWithContext { ... }
    fn eat(&mut self, kind: Self::Kind) -> bool { ... }
    fn expect(&mut self, kind: Self::Kind) -> bool { ... }
    fn parse_as_skipped_trivia_tokens<P>(&mut self, parse: P)
       where P: FnOnce(&mut Self) { ... }
    fn error(&mut self, err: impl ToDiagnostic<Self>) { ... }
    fn err_builder(
        &self,
        message: impl Display,
        span: impl AsSpan,
    ) -> ParseDiagnostic { ... }
    fn err_and_bump(
        &mut self,
        err: impl ToDiagnostic<Self>,
        unknown_syntax_kind: Self::Kind,
    ) { ... }
    fn last(&self) -> Option<Self::Kind> { ... }
    fn last_end(&self) -> Option<TextSize> { ... }
    fn start(&mut self) -> Marker { ... }
}

Required Associated Types

type Kind: SyntaxKind

type Source: TokenSource<Kind = Self::Kind>

Required Methods

fn context(&self) -> &ParserContext<Self::Kind>

Returns a reference to the ParserContext

fn context_mut(&mut self) -> &mut ParserContext<Self::Kind>

Returns a mutable reference to the ParserContext.

fn source(&self) -> &Self::Source

Returns a reference to the `TokenSource``(TokenSource]

fn source_mut(&mut self) -> &mut Self::Source

Returns a mutable reference to the TokenSource

Provided Methods

fn is_speculative_parsing(&self) -> bool

Returns true if the parser is trying to parse some syntax but only if it has no errors.

Returning true disables more involved error recovery.

fn text(&self, span: TextRange) -> &str

Gets the source text of a range

Panics

If the range is out of bounds

fn cur(&self) -> Self::Kind

Gets the current token kind of the parser

fn cur_range(&self) -> TextRange

Gets the range of the current token

fn has_preceding_line_break(&self) -> bool

Tests if there’s a line break before the current token (between the last and current)

fn cur_text(&self) -> &str

Get the source code of the parser’s current token.

fn at(&self, kind: Self::Kind) -> bool

Checks if the parser is currently at a specific token

fn at_ts(&self, kinds: TokenSet<Self::Kind>) -> bool

Check if the parser’s current token is contained in a token set

fn nth(&mut self, n: usize) -> Self::Kind

where Self::Source: NthToken,

Look ahead at a token and get its kind.

fn nth_at(&mut self, n: usize, kind: Self::Kind) -> bool

where Self::Source: NthToken,

Checks if a token lookahead is something

fn has_nth_preceding_line_break(&mut self, n: usize) -> bool

where Self::Source: NthToken,

Tests if there’s a line break before the nth token.

fn bump(&mut self, kind: Self::Kind)

Consume the current token if kind matches.

fn bump_remap(&mut self, kind: Self::Kind)

Consume any token but cast it as a different kind

fn bump_any(&mut self)

Bumps the current token regardless of its kind and advances to the next token.

fn bump_with_context( &mut self, kind: Self::Kind, context: <Self::Source as BumpWithContext>::Context, )

where Self::Source: BumpWithContext,

Consumes the current token if kind matches and lexes the next token using the specified `context.

fn eat(&mut self, kind: Self::Kind) -> bool

Consume the next token if kind matches.

fn expect(&mut self, kind: Self::Kind) -> bool

Try to eat a specific token kind, if the kind is not there then adds an error to the events stack.

fn parse_as_skipped_trivia_tokens<P>(&mut self, parse: P)

where P: FnOnce(&mut Self),

Allows parsing an unsupported syntax as skipped trivia tokens.

fn error(&mut self, err: impl ToDiagnostic<Self>)

Add a diagnostic

fn err_builder( &self, message: impl Display, span: impl AsSpan, ) -> ParseDiagnostic

Creates a new diagnostic. Pass the message and the range where the error occurred

fn err_and_bump( &mut self, err: impl ToDiagnostic<Self>, unknown_syntax_kind: Self::Kind, )

Bump and add an error event

fn last(&self) -> Option<Self::Kind>

Returns the kind of the last bumped token.

fn last_end(&self) -> Option<TextSize>

Returns the end offset of the last bumped token.

fn start(&mut self) -> Marker

Starts a new node in the syntax tree. All nodes and tokens consumed between the start and the corresponding Marker::complete belong to the same node.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors