Struct Parser 

pub struct Parser { /* private fields */ }

Implementations

impl Parser

pub fn push_error(&mut self, err: SpannedItem<ParseErrorKind>)

pub fn slice(&self) -> &str

pub fn intern(&mut self, internee: Rc<str>) -> SymbolId

pub fn span(&self) -> Span

pub fn peek(&mut self) -> SpannedItem<Token>

pub fn new_with_existing_interner_and_source_map( sources: impl IntoIterator<Item = (impl Into<String>, impl Into<String>)>, interner: SymbolInterner, source_map: IndexMap<SourceId, (&'static str, &'static str)>, ) -> Parser

pub fn new_expr_id(&mut self) -> ExprId

pub fn new( sources: impl IntoIterator<Item = (impl Into<String>, impl Into<String>)>, ) -> Parser

pub fn drain_comments(&mut self) -> Vec<Comment>

pub fn into_result( self, ) -> (Ast, Vec<SpannedItem<ParseError>>, SymbolInterner, IndexMap<SourceId, (&'static str, &'static str)>)

consume tokens until a node is produced

pub fn interner(&self) -> &SymbolInterner

pub fn many<P>(&mut self) -> Vec<P>

where P: Parse,

pub fn sequence_zero_or_more<P>(&mut self, separator: Token) -> Option<Vec<P>>

where P: Parse,

parses a sequence separated by separator e.g. if separator is Token::Comma, can parse a, b, c, d NOTE: this parses zero or more items. Will not reject zero items.

pub fn sequence_one_or_more<P>(&mut self, separator: Token) -> Option<Vec<P>>

where P: Parse,

parses a sequence separated by separator e.g. if separator is Token::Comma, can parse a, b, c, d NOTE: this parses one or more items. Will reject zero items. alias for sequence

pub fn sequence<P>(&mut self, separator: Token) -> Option<Vec<P>>

where P: Parse,

parses a sequence separated by separator e.g. if separator is Token::Comma, can parse a, b, c, d NOTE: this parses one or more items. Will reject zero items.

pub fn advance(&mut self) -> SpannedItem<Token>

pub fn try_token(&mut self, tok: Token) -> Option<SpannedItem<Token>>

doesn’t push the error to the error list and doesn’t advance if the token is not found

pub fn token(&mut self, tok: Token) -> Option<SpannedItem<Token>>

pub fn parse<P>(&mut self) -> Option<P>

where P: Parse,

pub fn one_of<const N: usize>( &mut self, toks: [Token; N], ) -> Option<SpannedItem<Token>>

pub fn errors(&self) -> &[SpannedItem<ParseError>]

pub fn with_help<F, T>(&mut self, help_text: impl Into<String>, f: F) -> T

where F: Fn(&mut Parser) -> T,

pub fn with_backtrack<F, T>( &mut self, f: F, ) -> Result<T, Vec<SpannedItem<ParseError>>>

where F: Fn(&mut Parser) -> Option<T>,

Performs a backtracking parse, which means that if the inner function returns None, the parser will backtrack to the state before the function was called and revert any errors that were encountered, returning them as Err but crucially not appending them to self.errors`. Note that this is NOT a performant method, and it should be used sparingly.

pub fn source_map(&self) -> &IndexMap<SourceId, (&'static str, &'static str)>