Struct Parser 

pub struct Parser<'a, C: ParserConfig = NoTokensParserConfig> { /* private fields */ }

Recursive Descent Parser for ECMAScript and TypeScript

See Parser::parse for entry function.

Implementations

impl<'a> Parser<'a, NoTokensParserConfig>

pub fn parse_observed(self) -> ProgramObservation<'a>

Retain the actual source/profile/options and complete result of one parse.

Only the parser’s built-in configurations can establish this authority. A custom configuration still supports ordinary parse, but cannot substitute lexer handlers and mint native compiler admission:

use oxc_allocator::Allocator;
use oxc_parser::{Parser, config::{NoTokensLexerConfig, ParserConfig}};
use oxc_span::SourceType;
#[derive(Default)]
struct Custom;
impl ParserConfig for Custom {
    type LexerConfig = NoTokensLexerConfig;
    fn lexer_config(&self) -> NoTokensLexerConfig { NoTokensLexerConfig }
}
let allocator = Allocator::default();
Parser::new(&allocator, "const value = 1;", SourceType::mjs())
    .with_config(Custom).parse_observed();

impl<'a> Parser<'a, TokensParserConfig>

pub fn parse_observed(self) -> ProgramObservation<'a>

Retain one complete observation using the built-in token configuration.

impl<'a> Parser<'a, RuntimeParserConfig>

pub fn parse_observed(self) -> ProgramObservation<'a>

Retain one complete observation using the built-in runtime configuration.

impl<'a, C: ParserConfig> Parser<'a, C>

pub fn parse(self) -> ParserReturn<'a>

Main entry point

Returns an empty Program on unrecoverable error, Recoverable errors are stored inside errors.

See the module-level documentation for examples and more information.

Examples found in repository

examples/visitor.rs (line 35)

fn main() -> std::io::Result<()> {
    let name = env::args().nth(1).unwrap_or_else(|| "test.js".to_string());
    let path = Path::new(&name);
    let source_text = std::fs::read_to_string(path)?;
    let allocator = Allocator::default();
    let source_type = SourceType::from_path(path).unwrap();
    let ret = Parser::new(&allocator, &source_text, source_type).parse();

    // Report any parsing errors
    for error in ret.diagnostics {
        let error = error.with_source_code(source_text.clone());
        println!("{error:?}");
    }

    let program = ret.program;

    // Use visitor to count different AST node types
    let mut ast_pass = CountASTNodes::default();
    ast_pass.visit_program(&program);
    println!("{ast_pass:?}");

    Ok(())
}

examples/regular_expression.rs (line 25)

fn main() {
    // 1. Get the file content and parse
    let name = env::args().nth(1).unwrap_or_else(|| "test.js".to_string());
    let path = Path::new(&name);

    let source_text: Arc<str> = Arc::from(fs::read_to_string(path).unwrap());
    let source_type = SourceType::from_path(path).unwrap();

    let allocator = Allocator::default();
    let options = ParseOptions { parse_regular_expression: true, ..ParseOptions::default() };

    let parser_ret =
        Parser::new(&allocator, source_text.as_ref(), source_type).with_options(options).parse();
    if !parser_ret.diagnostics.is_empty() {
        println!("Parsing failed:");
        for error in parser_ret.diagnostics {
            let error = error.with_source_code(Arc::clone(&source_text));
            println!("{error:?}");
        }
        return;
    }

    // Parse regular expressions
    // - RegExpLiteral
    // - new RegExp() with string or template literal if static
    RegularExpressionVisitor { source_text: Arc::clone(&source_text) }
        .visit_program(&parser_ret.program);
}

examples/parser_tsx.rs (line 46)

fn main() -> Result<(), String> {
    let source_text = r"
import React from 'react';

/**
 * A simple counter component
 */
export const Counter: React.FC = () => {
    const [count, setCount] = React.useState(0);

    return (
        <div>
            <p>Count: {count}</p>
            <button onClick={() => setCount(count + 1)}>Increment</button>
            <button onClick={() => setCount(count - 1)}>Decrement</button>
        </div>
    )
}";

    // Memory arena where AST nodes get stored
    let allocator = Allocator::default();
    // Infers TypeScript + JSX + ESM modules
    let source_type = SourceType::from_path("Counter.tsx").unwrap();

    let ParserReturn {
        program,     // AST
        diagnostics, // Syntax errors
        panicked,    // Parser encountered an error it couldn't recover from
        ..
    } = Parser::new(&allocator, source_text, source_type).parse();

    if panicked {
        return Err("Parser panicked".to_string());
    }

    if !diagnostics.is_empty() {
        return Err(format!("Parsing errors: {}", diagnostics.len()));
    }

    assert!(!program.body.is_empty());
    assert_eq!(program.comments.len(), 1);

    Ok(())
}

pub fn parse_expression(self) -> Result<Expression<'a>, Diagnostics>

Parse a single Expression.

Example

use oxc_allocator::Allocator;
use oxc_ast::ast::Expression;
use oxc_parser::Parser;
use oxc_span::SourceType;

let src = "let x = 1 + 2;";
let allocator = Allocator::new();
let source_type = SourceType::default();

let expr: Expression<'_> = Parser::new(&allocator, src, source_type).parse_expression().unwrap();

Errors

If the source code being parsed has syntax errors.

impl<'a> Parser<'a>

pub fn new( allocator: &'a Allocator, source_text: &'a str, source_type: SourceType, ) -> Self

Create a new Parser

Parameters

• allocator: Memory arena for allocating AST nodes
• source_text: Source code to parse
• source_type: Source type (e.g. JavaScript, TypeScript, JSX, ESM Module, Script)

Examples found in repository

examples/visitor.rs (line 35)

fn main() -> std::io::Result<()> {
    let name = env::args().nth(1).unwrap_or_else(|| "test.js".to_string());
    let path = Path::new(&name);
    let source_text = std::fs::read_to_string(path)?;
    let allocator = Allocator::default();
    let source_type = SourceType::from_path(path).unwrap();
    let ret = Parser::new(&allocator, &source_text, source_type).parse();

    // Report any parsing errors
    for error in ret.diagnostics {
        let error = error.with_source_code(source_text.clone());
        println!("{error:?}");
    }

    let program = ret.program;

    // Use visitor to count different AST node types
    let mut ast_pass = CountASTNodes::default();
    ast_pass.visit_program(&program);
    println!("{ast_pass:?}");

    Ok(())
}

examples/regular_expression.rs (line 25)

fn main() {
    // 1. Get the file content and parse
    let name = env::args().nth(1).unwrap_or_else(|| "test.js".to_string());
    let path = Path::new(&name);

    let source_text: Arc<str> = Arc::from(fs::read_to_string(path).unwrap());
    let source_type = SourceType::from_path(path).unwrap();

    let allocator = Allocator::default();
    let options = ParseOptions { parse_regular_expression: true, ..ParseOptions::default() };

    let parser_ret =
        Parser::new(&allocator, source_text.as_ref(), source_type).with_options(options).parse();
    if !parser_ret.diagnostics.is_empty() {
        println!("Parsing failed:");
        for error in parser_ret.diagnostics {
            let error = error.with_source_code(Arc::clone(&source_text));
            println!("{error:?}");
        }
        return;
    }

    // Parse regular expressions
    // - RegExpLiteral
    // - new RegExp() with string or template literal if static
    RegularExpressionVisitor { source_text: Arc::clone(&source_text) }
        .visit_program(&parser_ret.program);
}

examples/parser_tsx.rs (line 46)

fn main() -> Result<(), String> {
    let source_text = r"
import React from 'react';

/**
 * A simple counter component
 */
export const Counter: React.FC = () => {
    const [count, setCount] = React.useState(0);

    return (
        <div>
            <p>Count: {count}</p>
            <button onClick={() => setCount(count + 1)}>Increment</button>
            <button onClick={() => setCount(count - 1)}>Decrement</button>
        </div>
    )
}";

    // Memory arena where AST nodes get stored
    let allocator = Allocator::default();
    // Infers TypeScript + JSX + ESM modules
    let source_type = SourceType::from_path("Counter.tsx").unwrap();

    let ParserReturn {
        program,     // AST
        diagnostics, // Syntax errors
        panicked,    // Parser encountered an error it couldn't recover from
        ..
    } = Parser::new(&allocator, source_text, source_type).parse();

    if panicked {
        return Err("Parser panicked".to_string());
    }

    if !diagnostics.is_empty() {
        return Err(format!("Parsing errors: {}", diagnostics.len()));
    }

    assert!(!program.body.is_empty());
    assert_eq!(program.comments.len(), 1);

    Ok(())
}

impl<'a, C: ParserConfig> Parser<'a, C>

pub fn with_options(self, options: ParseOptions) -> Self

Set parse options

Examples found in repository

examples/regular_expression.rs (line 25)

fn main() {
    // 1. Get the file content and parse
    let name = env::args().nth(1).unwrap_or_else(|| "test.js".to_string());
    let path = Path::new(&name);

    let source_text: Arc<str> = Arc::from(fs::read_to_string(path).unwrap());
    let source_type = SourceType::from_path(path).unwrap();

    let allocator = Allocator::default();
    let options = ParseOptions { parse_regular_expression: true, ..ParseOptions::default() };

    let parser_ret =
        Parser::new(&allocator, source_text.as_ref(), source_type).with_options(options).parse();
    if !parser_ret.diagnostics.is_empty() {
        println!("Parsing failed:");
        for error in parser_ret.diagnostics {
            let error = error.with_source_code(Arc::clone(&source_text));
            println!("{error:?}");
        }
        return;
    }

    // Parse regular expressions
    // - RegExpLiteral
    // - new RegExp() with string or template literal if static
    RegularExpressionVisitor { source_text: Arc::clone(&source_text) }
        .visit_program(&parser_ret.program);
}

pub fn with_config<Config: ParserConfig>( self, config: Config, ) -> Parser<'a, Config>

Set parser config.

See ParserConfig for more details.