Crate swc_ecma_parser[][src]

EcmaScript/TypeScript parser for the rust programming language.

Features

Heavily tested

Passes almost all tests from tc39/test262.

Error reporting

error: 'implements', 'interface', 'let', 'package', 'private', 'protected',  'public', 'static', or 'yield' cannot be used as an identifier in strict mode
 --> invalid.js:3:10
  |
3 | function yield() {
  |          ^^^^^

Error recovery

The parser can recover from some parsing errors. For example, parser returns Ok(Module) for the code below, while emitting error to handler.

const CONST = 9000 % 2;
const enum D {
    // Comma is required, but parser can recover because of the newline.
    d = 10
    g = CONST
}

Example (lexer)

See lexer.rs in examples directory.

Example (parser)

#[macro_use]
extern crate swc_common;
extern crate swc_ecma_parser;
use swc_common::sync::Lrc;
use swc_common::{
    errors::{ColorConfig, Handler},
    FileName, FilePathMapping, SourceMap,
};
use swc_ecma_parser::{lexer::Lexer, Parser, StringInput, Syntax};

fn main() {
    let cm: Lrc<SourceMap> = Default::default();
    let handler =
        Handler::with_tty_emitter(ColorConfig::Auto, true, false,
        Some(cm.clone()));

    // Real usage
    // let fm = cm
    //     .load_file(Path::new("test.js"))
    //     .expect("failed to load test.js");
    let fm = cm.new_source_file(
        FileName::Custom("test.js".into()),
        "function foo() {}".into(),
    );
    let lexer = Lexer::new(
        // We want to parse ecmascript
        Syntax::Es(Default::default()),
        // JscTarget defaults to es5
        Default::default(),
        StringInput::from(&*fm),
        None,
    );

    let mut parser = Parser::new_from(lexer);

    for e in parser.take_errors() {
        e.into_diagnostic(&handler).emit();
    }

    let _module = parser
        .parse_module()
        .map_err(|mut e| {
            // Unrecoverable fatal error occurred
            e.into_diagnostic(&handler).emit()
        })
        .expect("failed to parser module");
}

Known issues

Null character after \

Becuase String of rust should only contain valid utf-8 characters while javascript allows non-utf8 chraceters, the parser stores invalid utf8 chracters in escpaed form.

As a result, swc needs a way to distinguish invalid-utf8 code points and input specified by the user. The parser stores a null chracter right after \\ for non-utf8 code points. Note that other parts of swc is aware of this fact.

Note that this can be changed at anytime with a breaking change.

Modules

error
input
lexer

ECMAScript lexer.

token

Ported from babel/babylon

Structs

Capturing

Note: Lexer need access to parser’s context to lex correctly.

Context

Syntactic context.

EsConfig
Parser

EcmaScript parser.

StringInput

Implementation of Input.

TokensInput
TsConfig

Enums

JscTarget
Syntax

Traits

Input
Tokens

Clone should be cheap if you are parsing typescript because typescript syntax requires backtracking.

Type Definitions

PResult

When error occurs, error is emitted and parser returns Err(()).