Struct Parser

pub struct Parser<'a, 'e> {
    pub check_double_underscore: bool,
    /* private fields */
}

Fields

check_double_underscore: bool

Implementations

impl<'a, 'e> Parser<'a, 'e>

pub fn new( handler: &'e Handler, token_stream: &'a TokenStream, ) -> Parser<'a, 'e>

pub fn emit_error(&mut self, kind: ParseErrorKind) -> ErrorEmitted

pub fn emit_error_with_span( &mut self, kind: ParseErrorKind, span: Span, ) -> ErrorEmitted

pub fn take<P: Peek>(&mut self) -> Option<P>

Eats a P in its canonical way by peeking.

Unlike Parser::peek, this method advances the parser on success, but not on failure.

pub fn peek<P: Peek>(&self) -> Option<P>

Tries to peek a P in its canonical way.

Either way, on success or failure, the parser is not advanced.

pub fn call_parsing_function_with_recovery<'original, T, F: FnOnce(&mut Parser<'a, '_>) -> Result<T, ErrorEmitted>>( &'original mut self, parsing_function: F, ) -> Result<T, ParseRecoveryStrategies<'original, 'a, 'e>>

This function will fork the current parse, and call the parsing function. If it succeeds it will sync the original parser with the forked one;

If it fails it will return a Recoverer together with the ErrorEmitted.

This recoverer can be used to put the forked parsed back in track and then sync the original parser to allow the parsing to continue.

pub fn parse_with_recovery<'original, T: Parse>( &'original mut self, ) -> Result<T, ParseRecoveryStrategies<'original, 'a, 'e>>

This function will fork the current parse, and try to parse T using the fork. If it succeeds it will sync the original parser with the forked one;

If it fails it will return a Recoverer together with the ErrorEmitted.

This recoverer can be used to put the forked parsed back in track and then sync the original parser to allow the parsing to continue.

pub fn guarded_parse_with_recovery<'original, P: Peek, T: Parse>( &'original mut self, ) -> Result<Option<T>, ParseRecoveryStrategies<'original, 'a, 'e>>

This function does three things 1 - it peeks P; 2 - it forks the current parser and tries to parse T using this fork. If it succeeds it syncs the original parser with the forked one; 3 - if it fails it will return a Recoverer together with the ErrorEmitted.

This recoverer can be used to put the forked parsed back in track and then sync the original parser to allow the parsing to continue.

pub fn try_parse<T: Parse>( &mut self, append_diagnostics: bool, ) -> Result<T, ErrorEmitted>

Parses a T in its canonical way. Do not advance the parser on failure

pub fn try_parse_and_check_empty<T: Parse>( self, append_diagnostics: bool, ) -> Result<Option<(T, ParserConsumed<'a>)>, ErrorEmitted>

This method is useful if T does not impl ParseToEnd

pub fn parse<T: Parse>(&mut self) -> Result<T, ErrorEmitted>

Parses a T in its canonical way.

pub fn guarded_parse<G: Peek, T: Parse>( &mut self, ) -> Result<Option<T>, ErrorEmitted>

Parses T given that the guard G was successfully peeked.

Useful to parse e.g., $keyword $stuff as a unit where $keyword is your guard.

pub fn parse_to_end<T: ParseToEnd>( self, ) -> Result<(T, ParserConsumed<'a>), ErrorEmitted>

pub fn try_parse_to_end<T: ParseToEnd>( &mut self, append_diagnostics: bool, ) -> Result<(T, ParserConsumed<'a>), ErrorEmitted>

Do not advance the parser on failure

pub fn enter_delimited( &mut self, expected_delimiter: Delimiter, ) -> Option<(Parser<'_, '_>, Span)>

pub fn is_empty(&self) -> bool

pub fn check_empty(&self) -> Option<ParserConsumed<'a>>

pub fn debug_tokens(&self) -> &[TokenTree]

pub fn ban_visibility_qualifier( &mut self, vis: &Option<PubToken>, ) -> Result<(), ErrorEmitted>

Errors given Some(PubToken).

pub fn full_span(&self) -> &Span

pub fn consume_while_line_equals(&mut self, line: usize)

Consume tokens while its line equals to line.

Warning

To calculate lines the original source code needs to be transversed.

pub fn has_errors(&self) -> bool

pub fn has_warnings(&self) -> bool