Struct Parser

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

Implementations

impl<'a> Parser<'a>

pub fn parse_class_body( &mut self, ctx: ParseCtx, ) -> SyntaxResult<ParseClassBodyResult>

pub fn parse_class_or_object_member( &mut self, ctx: ParseCtx, value_delimiter: TokenType, statement_delimiter: TokenType, property_initialiser_asi: &mut Asi, ) -> SyntaxResult<ParseClassOrObjectMemberResult>

impl<'a> Parser<'a>

pub fn parse_decl_var( &mut self, ctx: ParseCtx, parse_mode: VarDeclParseMode, export: bool, ) -> SyntaxResult<Node>

pub fn parse_decl_function( &mut self, ctx: ParseCtx, export: bool, export_default: bool, ) -> SyntaxResult<Node>

pub fn parse_decl_class( &mut self, ctx: ParseCtx, export: bool, export_default: bool, ) -> SyntaxResult<Node>

impl<'a> Parser<'a>

pub fn parse_jsx_name(&mut self, ctx: ParseCtx) -> SyntaxResult<Node>

pub fn parse_jsx_tag_name( &mut self, ctx: ParseCtx, ) -> SyntaxResult<Option<Node>>

pub fn parse_jsx_element(&mut self, ctx: ParseCtx) -> SyntaxResult<Node>

pub fn parse_call_args(&mut self, ctx: ParseCtx) -> SyntaxResult<Vec<Node>>

pub fn parse_expr( &mut self, ctx: ParseCtx, terminator: TokenType, ) -> SyntaxResult<Node>

pub fn parse_expr_with_asi( &mut self, ctx: ParseCtx, terminator: TokenType, asi: &mut Asi, ) -> SyntaxResult<Node>

pub fn parse_expr_until_either( &mut self, ctx: ParseCtx, terminator_a: TokenType, terminator_b: TokenType, ) -> SyntaxResult<Node>

pub fn parse_expr_until_either_with_asi( &mut self, ctx: ParseCtx, terminator_a: TokenType, terminator_b: TokenType, asi: &mut Asi, ) -> SyntaxResult<Node>

pub fn parse_grouping( &mut self, ctx: ParseCtx, asi: &mut Asi, ) -> SyntaxResult<Node>

pub fn parse_expr_array(&mut self, ctx: ParseCtx) -> SyntaxResult<Node>

pub fn parse_expr_object(&mut self, ctx: ParseCtx) -> SyntaxResult<Node>

pub fn parse_expr_arrow_function( &mut self, ctx: ParseCtx, terminator_a: TokenType, terminator_b: TokenType, ) -> SyntaxResult<Node>

pub fn parse_expr_arrow_function_or_grouping( &mut self, ctx: ParseCtx, terminator_a: TokenType, terminator_b: TokenType, asi: &mut Asi, ) -> SyntaxResult<Node>

pub fn parse_expr_import(&mut self, ctx: ParseCtx) -> SyntaxResult<Node>

pub fn parse_expr_function(&mut self, ctx: ParseCtx) -> SyntaxResult<Node>

pub fn parse_expr_class(&mut self, ctx: ParseCtx) -> SyntaxResult<Node>

pub fn parse_expr_with_min_prec( &mut self, ctx: ParseCtx, min_prec: u8, terminator_a: TokenType, terminator_b: TokenType, parenthesised: bool, asi: &mut Asi, ) -> SyntaxResult<Node>

impl<'a> Parser<'a>

pub fn parse_function_parameters( &mut self, ctx: ParseCtx, ) -> SyntaxResult<Vec<Node>>

pub fn parse_function_body(&mut self, ctx: ParseCtx) -> SyntaxResult<Node>

impl<'a> Parser<'a>

pub fn parse_and_normalise_literal_string( &mut self, ctx: ParseCtx, ) -> SyntaxResult<String>

impl<'a> Parser<'a>

pub fn parse_pattern(&mut self, ctx: ParseCtx) -> SyntaxResult<Node>

impl<'a> Parser<'a>

pub fn parse_stmts( &mut self, ctx: ParseCtx, end: TokenType, ) -> SyntaxResult<Vec<Node>>

pub fn parse_stmt(&mut self, ctx: ParseCtx) -> SyntaxResult<Node>

pub fn parse_stmt_empty(&mut self, ctx: ParseCtx) -> SyntaxResult<Node>

pub fn parse_stmt_block(&mut self, ctx: ParseCtx) -> SyntaxResult<Node>

pub fn parse_stmt_break(&mut self, ctx: ParseCtx) -> SyntaxResult<Node>

pub fn parse_stmt_continue(&mut self, ctx: ParseCtx) -> SyntaxResult<Node>

pub fn parse_stmt_debugger(&mut self, ctx: ParseCtx) -> SyntaxResult<Node>

pub fn parse_stmt_export(&mut self, ctx: ParseCtx) -> SyntaxResult<Node>

pub fn parse_stmt_expression(&mut self, ctx: ParseCtx) -> SyntaxResult<Node>

pub fn parse_stmt_for(&mut self, ctx: ParseCtx) -> SyntaxResult<Node>

pub fn parse_stmt_if(&mut self, ctx: ParseCtx) -> SyntaxResult<Node>

pub fn parse_stmt_import_or_expr_import( &mut self, ctx: ParseCtx, ) -> SyntaxResult<Node>

pub fn parse_stmt_return(&mut self, ctx: ParseCtx) -> SyntaxResult<Node>

pub fn parse_stmt_throw(&mut self, ctx: ParseCtx) -> SyntaxResult<Node>

pub fn parse_stmt_try(&mut self, ctx: ParseCtx) -> SyntaxResult<Node>

pub fn parse_stmt_while(&mut self, ctx: ParseCtx) -> SyntaxResult<Node>

pub fn parse_stmt_do_while(&mut self, ctx: ParseCtx) -> SyntaxResult<Node>

pub fn parse_stmt_switch(&mut self, ctx: ParseCtx) -> SyntaxResult<Node>

impl<'a> Parser<'a>

pub fn parse_top_level(&mut self) -> SyntaxResult<Node>

impl<'a> Parser<'a>

pub fn new(lexer: Lexer<'a>) -> Parser<'a>

pub fn lexer_mut(&mut self) -> &mut Lexer<'a>

pub fn source_range(&self) -> Loc

pub fn bytes(&self, loc: Loc) -> &[u8]

pub fn str(&self, loc: Loc) -> &str

pub fn string(&self, loc: Loc) -> String

pub fn checkpoint(&self) -> ParserCheckpoint

pub fn since_checkpoint(&self, checkpoint: ParserCheckpoint) -> Loc

pub fn restore_checkpoint(&mut self, checkpoint: ParserCheckpoint)

pub fn clear_buffered(&mut self)

pub fn next_with_mode(&mut self, mode: LexMode) -> SyntaxResult<Token>

pub fn next(&mut self) -> SyntaxResult<Token>

pub fn peek_with_mode(&mut self, mode: LexMode) -> SyntaxResult<Token>

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

pub fn consume_peeked(&mut self) -> Token

pub fn maybe_with_mode( &mut self, typ: TokenType, mode: LexMode, ) -> SyntaxResult<MaybeToken>

pub fn consume_if(&mut self, typ: TokenType) -> SyntaxResult<MaybeToken>

pub fn consume_if_pred<F: FnOnce(&Token) -> bool>( &mut self, pred: F, ) -> SyntaxResult<MaybeToken>

pub fn require_with_mode( &mut self, typ: TokenType, mode: LexMode, ) -> SyntaxResult<Token>

pub fn require_predicate<P: FnOnce(TokenType) -> bool>( &mut self, pred: P, expected: &'static str, ) -> SyntaxResult<Token>

pub fn require(&mut self, typ: TokenType) -> SyntaxResult<Token>