Struct parse_js::parse::Parser

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

Implementations

impl<'a> Parser<'a>

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

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

impl<'a> Parser<'a>

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

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

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

impl<'a> Parser<'a>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<'a> Parser<'a>

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

impl<'a> Parser<'a>

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

impl<'a> Parser<'a>

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

impl<'a> Parser<'a>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<'a> Parser<'a>

pub fn parse_top_level( &mut self, session: &'a Session, symbol_generator: SymbolGenerator, top_level_mode: TopLevelMode ) -> SyntaxResult<'a, Node<'a>>

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) -> SourceRange<'a>

pub fn checkpoint(&self) -> ParserCheckpoint

pub fn since_checkpoint(&self, checkpoint: ParserCheckpoint) -> SourceRange<'a>

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

pub fn clear_buffered(&mut self)

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

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

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

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

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

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

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

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

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

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

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