Struct AdmittedProgram 

pub struct AdmittedProgram<'p, 'a> { /* private fields */ }

A short immutable borrow minted only by a clean original observation.

The owner borrow cannot be replaced with an arbitrary Program:

use oxc_parser::{AdmittedProgram, ProgramObservation};
fn forge<'p, 'a>(observation: &'p ProgramObservation<'a>) -> AdmittedProgram<'p, 'a> {
    AdmittedProgram { observation }
}

A live capability exposes only shared syntax:

use oxc_ast::ast::Program;
use oxc_parser::AdmittedProgram;
fn mutate<'p, 'a>(admitted: &'p AdmittedProgram<'p, 'a>) -> &'p mut Program<'a> {
    admitted.program()
}

Implementations

impl<'p, 'a> AdmittedProgram<'p, 'a>

pub fn sole_default_export(&self) -> Option<OriginalDefaultExport<'p, 'a>>

Project one existing original local Default entry in constant time. Syntax admission remains separate from the entry’s semantic consumers.

impl<'p, 'a> AdmittedProgram<'p, 'a>

pub fn program(&self) -> &'p Program<'a>

pub fn source(&self) -> &'a str

Actual original bytes, including comments and line endings.

pub fn has_legacy_literals(&self) -> bool

Whether the original lexer decoded a legacy numeric literal or string escape forbidden in a strict module. This does not certify semantics. Syntax diagnostics and ordinary parser output remain unchanged.

Examples found in repository

examples/failed_speculation_profile.rs (line 72)

fn packets(source: &str) {
    for source_type in [
        SourceType::ts(),
        SourceType::tsx(),
        SourceType::jsx(),
        SourceType::ts().with_script(true),
        SourceType::ts().with_unambiguous(true),
    ] {
        for tokens in [false, true] {
            for parse_regular_expression in [false, true] {
                let options = ParseOptions { parse_regular_expression, ..ParseOptions::default() };
                let allocator = Allocator::default();
                let result = Parser::new(&allocator, source, source_type)
                    .with_config(RuntimeParserConfig::new(tokens))
                    .with_options(options)
                    .parse();
                println!(
                    "program {source_type:?} tokens={tokens} regexp={parse_regular_expression}: {:?}\n{:?}\n{:?}\n{:?}\n{:?}\n{:?}",
                    result.program,
                    result.diagnostics,
                    result.tokens,
                    result.module_record,
                    result.irregular_whitespaces,
                    (result.panicked, result.is_flow_language),
                );
                let allocator = Allocator::default();
                let observation = Parser::new(&allocator, source, source_type)
                    .with_config(RuntimeParserConfig::new(tokens))
                    .with_options(options)
                    .parse_observed();
                let facts = observation.admitted().map(|admitted| {
                    (admitted.has_legacy_literals(), admitted.has_jsdoc_comments())
                });
                println!("original admitted source facts: {facts:?}");
                let allocator = Allocator::default();
                let result = Parser::new(&allocator, source, source_type)
                    .with_config(RuntimeParserConfig::new(tokens))
                    .with_options(options)
                    .parse_expression();
                println!(
                    "expression {source_type:?} tokens={tokens} regexp={parse_regular_expression}: {result:?}"
                );
            }
        }
    }
}

pub fn has_jsdoc_comments(&self) -> bool

Whether the original trivia classifier observed JSDoc or legal JSDoc. This is presence only; it grants no effective type or binding semantics. Checkpoints restore speculation, while committed reparses retain the fact.

Examples found in repository

examples/failed_speculation_profile.rs (line 72)

fn packets(source: &str) {
    for source_type in [
        SourceType::ts(),
        SourceType::tsx(),
        SourceType::jsx(),
        SourceType::ts().with_script(true),
        SourceType::ts().with_unambiguous(true),
    ] {
        for tokens in [false, true] {
            for parse_regular_expression in [false, true] {
                let options = ParseOptions { parse_regular_expression, ..ParseOptions::default() };
                let allocator = Allocator::default();
                let result = Parser::new(&allocator, source, source_type)
                    .with_config(RuntimeParserConfig::new(tokens))
                    .with_options(options)
                    .parse();
                println!(
                    "program {source_type:?} tokens={tokens} regexp={parse_regular_expression}: {:?}\n{:?}\n{:?}\n{:?}\n{:?}\n{:?}",
                    result.program,
                    result.diagnostics,
                    result.tokens,
                    result.module_record,
                    result.irregular_whitespaces,
                    (result.panicked, result.is_flow_language),
                );
                let allocator = Allocator::default();
                let observation = Parser::new(&allocator, source, source_type)
                    .with_config(RuntimeParserConfig::new(tokens))
                    .with_options(options)
                    .parse_observed();
                let facts = observation.admitted().map(|admitted| {
                    (admitted.has_legacy_literals(), admitted.has_jsdoc_comments())
                });
                println!("original admitted source facts: {facts:?}");
                let allocator = Allocator::default();
                let result = Parser::new(&allocator, source, source_type)
                    .with_config(RuntimeParserConfig::new(tokens))
                    .with_options(options)
                    .parse_expression();
                println!(
                    "expression {source_type:?} tokens={tokens} regexp={parse_regular_expression}: {result:?}"
                );
            }
        }
    }
}

pub fn source_type(&self) -> SourceType

Original requested profile, before any Unambiguous inference.

pub fn options(&self) -> ParseOptions

Actual parser options; admission does not imply default compiler options.