pub struct ParserGuard<'p, 'a, 'ctx, 'int> { /* private fields */ }Expand description
RAII guard for speculative parsing with automatic rollback.
Created by Parser::guard(), this guard saves the parser state
on creation and automatically restores it if the guard is dropped
without being committed.
§Usage
let mut guard = parser.guard();
if let Ok(result) = try_parse(&mut *guard) {
guard.commit(); // Success - keep changes
return Ok(result);
}
// guard dropped here - parser state restoredImplementations§
Source§impl<'p, 'a, 'ctx, 'int> ParserGuard<'p, 'a, 'ctx, 'int>
impl<'p, 'a, 'ctx, 'int> ParserGuard<'p, 'a, 'ctx, 'int>
Methods from Deref<Target = Parser<'a, 'ctx, 'int>>§
Sourcepub fn stmt_spans(&self) -> &[Span]
pub fn stmt_spans(&self) -> &[Span]
The span of each top-level statement from the last parse_program
call, aligned 1:1 with the returned statement list.
Sourcepub fn nested_stmt_spans(&self) -> &NestedStmtSpans
pub fn nested_stmt_spans(&self) -> &NestedStmtSpans
The span of every statement read inside a block — a function’s body, a
loop’s, a branch’s — from the last parse_program call.
Sourcepub fn failure_sites(&self) -> &[FailureSite]
pub fn failure_sites(&self) -> &[FailureSite]
Every Stmt::Site marker’s own (component, action, span), indexed by the id a
Stmt::Site(id) in the returned program names — failure_sites()[id] answers what a
runtime failure at that site means. See crate::ast::stmt::FailureSite’s own doc comment
for why a single “current site” is enough, with no call stack, to answer “where did this
trap happen”.
pub fn set_discourse_event_var(&mut self, var: Symbol)
Sourcepub fn drs_mut(&mut self) -> &mut Drs
pub fn drs_mut(&mut self) -> &mut Drs
Get mutable reference to the active DRS (from WorldState).
Sourcepub fn swap_drs_with_world_state(&mut self)
pub fn swap_drs_with_world_state(&mut self)
Swap DRS between Parser and WorldState. Call at start of parsing to get the accumulated DRS from WorldState. Call at end of parsing to save the updated DRS back to WorldState.
Sourcepub fn has_world_state(&self) -> bool
pub fn has_world_state(&self) -> bool
WorldState is always present (no “single sentence mode”)
pub fn mode(&self) -> ParserMode
Sourcepub fn is_known_type(&self, sym: Symbol) -> bool
pub fn is_known_type(&self, sym: Symbol) -> bool
Check if a symbol is a known type in the registry. Used to disambiguate “Stack of Integers” (generic type) vs “Owner of House” (possessive).
Sourcepub fn is_generic_type(&self, sym: Symbol) -> bool
pub fn is_generic_type(&self, sym: Symbol) -> bool
Check if a symbol is a known generic type (takes type parameters). Used to parse “Stack of Integers” as generic instantiation.
pub fn process_block_headers(&mut self)
pub fn get_event_var(&mut self) -> Symbol
pub fn capture_event_template( &mut self, verb: Symbol, roles: &[(ThematicRole, Term<'a>)], modifiers: &[Symbol], )
pub fn set_pp_attachment_mode(&mut self, attach_to_noun: bool)
pub fn set_noun_priority_mode(&mut self, mode: bool)
pub fn set_collective_mode(&mut self, mode: bool)
Sourcepub fn set_distributive_marker(&mut self, on: bool)
pub fn set_distributive_marker(&mut self, on: bool)
Force the distributive (per-member) reading of mixed verbs with definite plurals — the readings enumerator’s counterpart to the default collective reading.
Sourcepub fn set_pragmatic_mode(&mut self, on: bool)
pub fn set_pragmatic_mode(&mut self, on: bool)
Enable pragmatic enrichment (scalar implicatures, degree standards) for whole-program parses — the defeasible theorem door needs the implicature channel that the literal parse omits.
pub fn set_event_reading_mode(&mut self, mode: bool)
pub fn set_negative_scope_mode(&mut self, mode: NegativeScopeMode)
pub fn set_modal_preference(&mut self, pref: ModalPreference)
pub fn guard(&mut self) -> ParserGuard<'_, 'a, 'ctx, 'int>
Sourcepub fn parse(&mut self) -> Result<&'a LogicExpr<'a>, ParseError>
pub fn parse(&mut self) -> Result<&'a LogicExpr<'a>, ParseError>
Parses the token stream into a logical expression.
This is the main entry point for declarative/FOL parsing. It handles multi-sentence inputs by conjoining them with logical AND, and processes various sentence types including declaratives, questions, and imperatives.
§Returns
An arena-allocated LogicExpr representing the parsed input, or
a ParseError with source location and Socratic explanation.
§Discourse State
The parser maintains discourse state across sentences, enabling anaphora resolution (“he”, “she”, “they” refer to prior entities) and temporal coherence (tense interpretation relative to reference time).
Sourcepub fn parse_pragmatic(&mut self) -> Result<&'a LogicExpr<'a>, ParseError>
pub fn parse_pragmatic(&mut self) -> Result<&'a LogicExpr<'a>, ParseError>
Parses with pragmatic enrichment: the truth-conditional parse PLUS scalar
implicature (§8.7). The literal parse() is unchanged; here a leading weak
scalar “some” is strengthened to ∃… +> ¬∀…. Used by the pragmatic compile
path so the implicature appears as a separate labeled component.
Sourcepub fn views(&self) -> &[ViewDef<'a>]
pub fn views(&self) -> &[ViewDef<'a>]
Parses a LOGOS program into a list of statements.
This is the main entry point for imperative/executable LOGOS code. It handles block structures (Definition, Policy, Procedure, Theorem), function definitions, type definitions, and executable statements.
§Returns
A vector of arena-allocated Stmt representing the program, or
a ParseError with source location and Socratic explanation.
§Block Types
- Definition: Type definitions (structs, enums, generics)
- Policy: Security predicates and capability rules
- Procedure: Executable code blocks
- Theorem: Logical propositions with proof strategies
The view IR trees this parse built, in source order (see
viewsfield).
Sourcepub fn take_views(&mut self) -> Vec<ViewDef<'a>>
pub fn take_views(&mut self) -> Vec<ViewDef<'a>>
Move the view IR trees out of the parser (they borrow only the AST arenas, never the parser), so a caller can release the parser’s interner borrow and keep them.
Sourcepub fn lgx_findings(&self) -> &[Finding]
pub fn lgx_findings(&self) -> &[Finding]
The template WARNINGS this parse collected, in source order — accessibility lint and anything else worth saying that must not stop a page from running. Errors never appear here: they stop the parse at the point they are found, which is what makes them errors.
Sourcepub fn value_copy_findings(&self) -> &[Finding]
pub fn value_copy_findings(&self) -> &[Finding]
The value-semantics copy lint’s own WARNINGS this parse collected, in source order — see
crate::lint.
pub fn parse_program(&mut self) -> Result<Vec<Stmt<'a>>, ParseError>
Sourcepub fn program_opt_flags(&self) -> OptimizationConfig
pub fn program_opt_flags(&self) -> OptimizationConfig
The program-wide optimization config from file-level ## No <X> decorators
(all-on minus the file-level disables). The compile entry combines this with
from_env and per-function flags.
Sourcepub fn program_tier_pins(&self) -> PinSet
pub fn program_tier_pins(&self) -> PinSet
The program-wide tiered-optimizer pins from file-level ## Tier <opt> <value>
decorators (HOTSWAP §8). The run-path engine overlays these onto the env
crate::optimization::HotswapConfig before optimizing.
Sourcepub fn required_optimizations(&self) -> Vec<Opt>
pub fn required_optimizations(&self) -> Vec<Opt>
Optimizations demanded via ## Require <opt> — each must have fired for
the compile, or it fails. Read after parse_program.