Struct parse_js::parse::Parser

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

Implementations§

source§

impl<'a> Parser<'a>

source

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

source

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>>

source§

impl<'a> Parser<'a>

source

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

source

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

source

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

source§

impl<'a> Parser<'a>

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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>>

source

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

source

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

source

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

source

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

source

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>>

source

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

source

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

source

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

source

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>>

source§

impl<'a> Parser<'a>

source

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

source§

impl<'a> Parser<'a>

source

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

source§

impl<'a> Parser<'a>

source

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

source§

impl<'a> Parser<'a>

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source§

impl<'a> Parser<'a>

source

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

source§

impl<'a> Parser<'a>

source

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

source

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

source

pub fn source_range(&self) -> SourceRange<'a>

source

pub fn checkpoint(&self) -> ParserCheckpoint

source

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

source

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

source

pub fn clear_buffered(&mut self)

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

Auto Trait Implementations§

§

impl<'a> RefUnwindSafe for Parser<'a>

§

impl<'a> !Send for Parser<'a>

§

impl<'a> !Sync for Parser<'a>

§

impl<'a> Unpin for Parser<'a>

§

impl<'a> UnwindSafe for Parser<'a>

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.