Struct pomelo_parse::Parser

pub struct Parser<'a> {
    current_pos: usize,
    tokens: Vec<Token<'a>>,
    errors: Vec<Error>,
    builder: NodeBuilder,
}

The main interface for manipulating the lexed source.

This handles iterating over the lex tokens as well as building the syntax tree (see rowan::GreenNodeBuilder for details).

Fields

current_pos: usize

tokens: Vec<Token<'a>>

Tokens are stored in reverse order

errors: Vec<Error>

builder: NodeBuilder

Implementations

impl<'a> Parser<'a>

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

pub fn parse(self) -> SyntaxTree

Parse an entire source file.

pub fn parse_expr(self) -> SyntaxTree

Parse a single expression.

pub fn parse_pat(self) -> SyntaxTree

Parse a single pattern.

pub fn parse_type(self) -> SyntaxTree

Parse a single type.

pub fn parse_dec(self) -> SyntaxTree

Parse a single declaration.

impl<'a> Parser<'a>

pub(crate) fn parse_inner<F>(self, f: F) -> SyntaxTreewhere
    F: FnMut(&mut Parser<'_>),

Parse according to a specified parsing function f.

This is here for testing purposes.

pub(crate) fn peek(&self) -> SyntaxKind

Peek at the kind of the next token.

pub(crate) fn peek_nth(&self, n: usize) -> SyntaxKind

Peek ahead n tokens.

pub(crate) fn peek_next_nontrivia(&self, skip: usize) -> SyntaxKind

Skips past skip nontrivia tokens, then peeks at the kind of the next one.

pub(crate) fn peek_token(&self) -> Option<&Token<'_>>

Peek at the next token.

pub(crate) fn peek_text(&self) -> &str

Peek at the text of the next token.

pub(crate) fn peek_token_next_nontrivia(&self, skip: usize) -> Option<&Token<'_>>

Peeks past skip nontrivia tokens, then peeks at the next token.

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

If kind matches the next token kind, consumes the token and returns true. Else, returns false.

pub(crate) fn eat_any(&mut self) -> SyntaxKind

Consume the next token, regardless of its kind.

pub(crate) fn eat_trivia(&mut self) -> bool

While the next token is trivia, consume it.

pub(crate) fn eat_through_trivia(&mut self, kind: SyntaxKind) -> bool

If the next nontrivia token matches kind, consume it (and any leading trivia) and return true. Else returns false.

pub(crate) fn expect(&mut self, kind: SyntaxKind)

Consume the next token if it matches kind, else generate an error.

pub(crate) fn error(&mut self, msg: impl Into<String> + Clone)

Append a new error to the stored list of errors.

pub(crate) fn eat_mapped(&mut self, kind: SyntaxKind) -> SyntaxKind

Consume the next token but remap its SyntaxKind to be kind.

pub(crate) fn is_eof(&self) -> bool

pub(crate) fn is_vid(&self) -> bool

Check if the current token is a valid VId.

With the current lexing strategy, correct symbolic identifiers are caught at lexing stage. Thus, the only special one we need to check for is EQ.

However, not sure if this is a good strategy for being error-resilient. The lexer obviously has less context than the parser for determining what to do if there is an error. This may be generally an issue with gluing together tokens at lex-time (like “=>” as THICK_ARROW, “…” as ELLIPSIS, etc.)

pub(crate) fn next_nontrivia_is_vid(&self) -> bool

Check if the current token is a valid VId.

With the current lexing strategy, correct symbolic identifiers are caught at lexing stage. Thus, the only special one we need to check for is EQ.

However, not sure if this is a good strategy for being error-resilient. The lexer obviously has less context than the parser for determining what to do if there is an error. This may be generally an issue with gluing together tokens at lex-time (like “=>” as THICK_ARROW, “…” as ELLIPSIS, etc.)

pub(crate) fn is_strid(&self) -> bool

Check if the current token is a valid StrId.

fn pop(&mut self) -> Token<'a>

impl<'a> Parser<'a>

pub(crate) fn start_node(&mut self, kind: SyntaxKind) -> NodeGuard

Start a new node in the syntax tree.

Note that the returned NodeGuard will be dropped immediately if not bound to a variable.

pub(crate) fn checkpoint(&self) -> Checkpoint

Set a checkpoint that can be used later to create a node earlier in the tree.

This is essentially just lookahead. Make an example?

pub(crate) fn start_node_at(
    &mut self,
    checkpoint: Checkpoint,
    kind: SyntaxKind
) -> NodeGuard

Use a previously set checkpoint to create a new node at its position (higher up in the tree).

Note that the returned NodeGuard will be dropped immediately if not bound to a variable.

pub fn push_token(&mut self, token: Token<'_>)

Add a token to the current node.

Trait Implementations

impl<'a> Clone for Parser<'a>

fn clone(&self) -> Parser<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Parser<'a>

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

Formats the value using the given formatter.