Struct Parser 

pub struct Parser<'a> { /* private fields */ }

The parser state.

Implementations

impl<'a> Parser<'a>

pub fn new(source: &'a str) -> Self

A parser over source.

pub fn over(source: &'a str, tokens: Vec<Token>) -> Self

A parser over an already-lexed stream.

The preprocessor produces one: its tokens index into text it assembled from every file that contributed, so the parser lexes nothing and reads spans into that text instead.

pub fn parse_file(self) -> Parse

Parse the whole file.

pub fn current(&self) -> TokenKind

What the current token is.

pub fn peek(&self, ahead: usize) -> TokenKind

What the token ahead positions on is.

pub fn at_eof(&self) -> bool

Whether the cursor is at the end.

pub fn current_span(&self) -> Span

Where the current token is.

pub fn current_text(&self) -> &str

The text of the current token.

pub fn bump(&mut self)

Consume the current token into the tree, trivia first.

Trivia reaches the tree through Parser::emit_leading_trivia and nowhere else, which is what keeps the round trip exact without every rule having to think about it.

pub fn eat(&mut self, kind: TokenKind) -> bool

Consume the current token if it is kind.

pub fn expect(&mut self, kind: TokenKind, what: &str) -> bool

Consume kind, or diagnose that it was missing.

Does not consume anything on failure: the caller’s recovery decides what to skip.

pub fn start(&mut self, kind: CstKind)

Begin a node.

pub fn finish(&mut self)

End the node in progress.

pub fn checkpoint(&self) -> Checkpoint

Mark the current position, for wrapping already-emitted children.

pub fn start_at(&mut self, checkpoint: Checkpoint, kind: CstKind)

Wrap everything since checkpoint in a node.

pub fn tokens_left(&self) -> usize

How many tokens are left.

pub fn split_shift_right(&mut self)

Consume the first half of a >> token, leaving the second.

sequence<sequence<long>> ends in one token that closes two argument lists. The tree records two > covering one source token, so text() still reproduces the input. Spec §2.3.

pub fn diagnose( &mut self, code: DiagnosticCode, message: &str, spec_reference: &'static str, )

Record a diagnostic without consuming anything.

pub fn error_token(&mut self, message: &str)

Wrap the current token in an error node and move past it.

pub fn recover_to_declaration(&mut self)

Skip to the next place a declaration can begin.

Recovery points are ;, } and the top-level keywords. The skipped range becomes an error node so the round trip holds. Spec §3.2.

pub fn at_recovery_point(&self) -> bool

Whether the current token can begin a declaration.

pub fn diagnostics(&self) -> &[Diagnostic]

The diagnostics gathered so far.