Struct ParserState 

pub struct ParserState {
    pub arena: NodeArena,
    pub context_flags: u32,
    /* private fields */
}

This parser produces the same AST semantically as ParserState, but uses the cache-optimized NodeArena for storage.

Fields

arena: NodeArena

Arena for allocating Nodes

context_flags: u32

Parser context flags

Implementations

impl ParserState

pub fn new(file_name: String, source_text: String) -> Self

Create a new Parser for the given source text.

pub fn reset(&mut self, file_name: String, source_text: String)

pub fn parse_optional(&mut self, kind: SyntaxKind) -> bool

Parse optional token, returns true if found

pub fn parse_expected(&mut self, kind: SyntaxKind) -> bool

Parse expected token, report error if not found Suppresses error if we already emitted an error at the current position (to prevent cascading errors from sequential parse_expected calls)

pub fn parse_error_at_current_token(&mut self, message: &str, code: u32)

Report parse error at current token with specific error code

impl ParserState

pub fn parse_expression(&mut self) -> NodeIndex

impl ParserState

pub fn parse_source_file(&mut self) -> NodeIndex

Parse a source file

pub fn parse_source_file_statements_from_offset( &mut self, file_name: String, source_text: String, start: u32, ) -> IncrementalParseResult

pub fn parse_statement(&mut self) -> NodeIndex

Parse a statement

impl ParserState

pub fn get_diagnostics(&self) -> &[ParseDiagnostic]

Get parse diagnostics

pub const fn get_arena(&self) -> &NodeArena

Get the arena

pub fn into_arena(self) -> NodeArena

Consume the parser and return the arena. This is used for lib files where we need to store the arena in an Arc.

pub const fn get_node_count(&self) -> usize

Get node count

pub fn get_source_text(&self) -> &str

Get the source text. Delegates to the scanner which owns the source text.

pub fn get_file_name(&self) -> &str

Get the file name

pub fn into_parts(self) -> (NodeArena, Vec<ParseDiagnostic>)

Consume the parser and return its parts. This is useful for taking ownership of the arena after parsing.