Struct ParserContext 

pub struct ParserContext {
    pub id_generator: NodeIdGenerator,
    /* private fields */
}

Parser context with error tracking and recovery

Fields

id_generator: NodeIdGenerator

Node ID generator

Implementations

impl ParserContext

pub fn new(source: String) -> ParserContext

Create a new parser context

pub fn with_budget(source: String, budget: ParseBudget) -> ParserContext

Create a new parser context with a custom budget.

pub fn budget(&self) -> &ParseBudget

Get the current budget.

pub fn budget_tracker(&self) -> &BudgetTracker

Get the budget tracker.

pub fn budget_tracker_mut(&mut self) -> &mut BudgetTracker

Get mutable access to the budget tracker.

pub fn errors_exhausted(&self) -> bool

Check if error budget is exhausted.

pub fn depth_would_exceed(&self) -> bool

Check if depth budget would be exceeded.

pub fn enter_depth(&mut self) -> bool

Enter a nesting level, tracking depth.

pub fn exit_depth(&mut self)

Exit a nesting level.

pub fn current_token(&self) -> Option<&TokenWithPosition>

Get current token

pub fn peek_token(&self, offset: usize) -> Option<&TokenWithPosition>

Peek at next token

pub fn advance(&mut self) -> Option<&TokenWithPosition>

Advance to next token

pub fn is_eof(&self) -> bool

Check if at end of tokens

pub fn current_position(&self) -> Position

Get current position

pub fn current_position_range(&self) -> Range

Get current position range

pub fn add_error(&mut self, error: ParseError) -> bool

Add a parse error, tracking budget consumption.

Returns true if the error was added, false if error budget exhausted.

pub fn add_error_unchecked(&mut self, error: ParseError)

Add a parse error without checking budget (for critical errors).

pub fn take_errors(&mut self) -> Vec<ParseError>

Get all accumulated errors

pub fn current_index(&self) -> usize

Get current token index (for saving/restoring)

pub fn set_index(&mut self, index: usize)

Set current token index (for restoring)

pub fn expect( &mut self, expected: TokenType, ) -> Result<&TokenWithPosition, ParseError>

Match and consume a specific token type

pub fn check(&self, token_type: &TokenType) -> bool

Check if current token matches

pub fn consume(&mut self, token_type: &TokenType) -> bool

Consume token if it matches

pub fn source_slice(&self, range: &Range) -> &str

Get source slice for a range

Trait Implementations

impl ErrorRecovery for ParserContext

fn create_error_node( &mut self, message: String, expected: Vec<String>, partial: Option<Node>, ) -> Node

Create an error node and recover

fn synchronize(&mut self, sync_points: &[SyncPoint]) -> bool

Synchronize to a recovery point

fn recover_with_node(&mut self, error: ParseError) -> Node

Try to recover from an error

fn skip_until(&mut self, sync_points: &[SyncPoint]) -> usize

Skip tokens until a sync point.

fn skip_until_with_budget( &mut self, sync_points: &[SyncPoint], budget: &ParseBudget, tracker: &mut BudgetTracker, ) -> RecoveryResult

Budget-aware skip that respects limits.

fn is_sync_point(&self, sync_point: SyncPoint) -> bool

Check if current token is a sync point