feat(es/parser): rewrite parser with OXC architecture

.changeset/rewrite-parser-api.md

@@ -0,0 +1,29 @@
+---
+dbg-swc: major
+jsdoc: patch
+swc: major
+swc_bundler: major
+swc_compiler_base: major
+swc_core: major
+swc_ecma_codegen: patch
+swc_ecma_lints: patch
+swc_ecma_minifier: major
+swc_ecma_parser: major
+swc_ecma_preset_env: patch
+swc_ecma_quote_macros: major
+swc_ecma_react_compiler: major
+swc_ecma_transforms_base: major
+swc_ecma_transforms_module: major
+swc_ecma_transforms_optimization: major
+swc_ecma_transforms_react: major
+swc_ecma_transforms_testing: major
+swc_ecma_transforms_typescript: patch
+swc_ecma_utils: patch
+swc_estree_compat: major
+swc_html_minifier: major
+swc_node_bundler: major
+swc_ts_fast_strip: major
+swc_typescript: patch
+---
+
+feat(es/parser): Replace the parser API with the OXC-style entry point and remove the abandoned lexer crate

Cargo.toml

@@ -98,7 +98,6 @@ rustc-hash                = "2"
 ryu-js                    = "1.0.0"
 scoped-tls                = "1.0.1"
 semver                    = "1.0.20"
-seq-macro                 = "0.3"
 serde                     = "1.0.225"
 serde-wasm-bindgen        = "0.6.5"
 serde_derive              = "1.0.225"

bindings/binding_core_wasm/__tests__/error.js

@@ -7,5 +7,5 @@ it("properly reports error", () => {
 
     expect(() => {
         swc.transformSync("Foo {}", {});
-    }).toThrow("Expected ';', '}' or <eof>");
+    }).toThrow();
 });

bindings/binding_es_ast_viewer/Cargo.toml

@@ -17,7 +17,7 @@ features = [
   "common",
   "ecma_visit",
   "ecma_transforms",
-  "ecma_parser_unstable",
+  "ecma_parser_typescript",
 ]
 path = "../../crates/swc_core"
 

bindings/binding_es_ast_viewer/__tests__/parse.js

@@ -14,7 +14,7 @@ describe("parse", () => {
         expect(result[0]).toMatch(/Module|Script/);
         expect(result[0]).toContain("Stmt");
         // Second element should be the tokens
-        expect(result[1]).toContain("TokenAndSpan");
+        expect(result[1]).toContain("PackedToken");
     });
 
     it("should parse TypeScript code with type annotations", () => {
@@ -25,7 +25,7 @@ describe("parse", () => {
         expect(result[0]).toMatch(/Module|Script/);
         expect(result[0]).toContain("TsTypeAnn");
         // Should have tokens
-        expect(result[1]).toContain("TokenAndSpan");
+        expect(result[1]).toContain("PackedToken");
     });
 
     it("should parse JSX code", () => {
@@ -70,7 +70,7 @@ describe("parse", () => {
         expect(result).toHaveLength(2);
         expect(result[0]).toContain("ArrowExpr");
         // Check for arrow token
-        expect(result[1]).toContain("=>");
+        expect(result[1]).toContain("kind: Arrow");
     });
 
     it("should parse async/await", () => {
@@ -80,7 +80,7 @@ describe("parse", () => {
         expect(result[0]).toContain("AwaitExpr");
         expect(result[0]).toContain("FnDecl");
         // Tokens should be present
-        expect(result[1]).toContain("TokenAndSpan");
+        expect(result[1]).toContain("PackedToken");
     });
 
     it("should parse class declarations", () => {
@@ -90,7 +90,7 @@ describe("parse", () => {
         expect(result[0]).toContain("ClassDecl");
         expect(result[0]).toContain("Constructor");
         // Check for class keyword in tokens
-        expect(result[1]).toContain("class");
+        expect(result[1]).toContain("kind: Class");
     });
 
     it("should parse template literals", () => {
@@ -99,7 +99,7 @@ describe("parse", () => {
         expect(result).toHaveLength(2);
         expect(result[0]).toContain("Tpl");
         // Check for template tokens
-        expect(result[1]).toContain("`");
+        expect(result[1]).toContain("kind: TemplateHead");
     });
 
     it("should handle syntax errors gracefully", () => {
@@ -169,7 +169,7 @@ describe("parse", () => {
         expect(result).toHaveLength(2);
         expect(result[0]).toContain("SpreadElement");
         // Check for spread token
-        expect(result[1]).toContain("...");
+        expect(result[1]).toContain("kind: DotDotDot");
     });
 
     it("should parse optional chaining", () => {
@@ -187,7 +187,7 @@ describe("parse", () => {
         expect(result[0]).toContain("BinExpr");
         expect(result[0]).toContain('op: "??"');
         // Check for nullish coalescing token
-        expect(result[1]).toContain("??");
+        expect(result[1]).toContain("kind: NullishCoalescing");
     });
 
     it("should parse BigInt literals", () => {
@@ -196,7 +196,7 @@ describe("parse", () => {
         expect(result).toHaveLength(2);
         expect(result[0]).toContain("BigInt");
         // Check for BigInt token
-        expect(result[1]).toContain("<bigint literal>");
+        expect(result[1]).toContain("kind: BigInt");
     });
 
     it("should parse private class fields", () => {

bindings/binding_es_ast_viewer/src/lib.rs

@@ -6,7 +6,7 @@ use swc_core::{
     common::{errors::ColorConfig, FileName, Globals, Mark, SourceMap, GLOBALS},
     ecma::{
         ast::*,
-        parser::{unstable::Capturing, EsSyntax, Lexer, Parser, StringInput, Syntax, TsSyntax},
+        parser::{ModuleKind, ParseOptions, Parser, ParserReturn, SourceType},
         transforms::base::resolver,
         visit::VisitMutWith,
     },
@@ -46,40 +46,53 @@ pub fn parse(input: &str, file_name: Option<String>) -> Result<Vec<String>, Stri
         .map(|e| e == "ts" || e == "tsx" || e == "mts" || e == "cts" || e == "mtsx" || e == "ctsx")
         .unwrap_or_default();
 
-    let is_d_ts =
-        is_ts && matches!(iter.next(), Some("d" | "D")) || matches!(iter.next(), Some("d" | "D"));
+    let lower_file_name = file_name.to_ascii_lowercase();
+    let is_d_ts = is_ts
+        && [".d.ts", ".d.mts", ".d.cts"]
+            .iter()
+            .any(|suffix| lower_file_name.ends_with(suffix));
 
     let cm: Arc<SourceMap> = Default::default();
     let fm = cm.new_source_file(
         Arc::new(FileName::Real(file_name.into())),
         input.to_string(),
     );
 
-    let syntax = if is_ts {
-        Syntax::Typescript(TsSyntax {
-            tsx: is_jsx,
-            dts: is_d_ts,
-            ..Default::default()
-        })
+    let source_type = if is_d_ts {
+        SourceType::type_definition()
+    } else if is_ts && is_jsx {
+        SourceType::tsx()
+    } else if is_ts {
+        SourceType::typescript()
+    } else if is_jsx {
+        SourceType::jsx()
     } else {
-        Syntax::Es(EsSyntax {
-            jsx: is_jsx,
-            ..Default::default()
-        })
+        SourceType::unambiguous()
     };
-    let target = EsVersion::latest();
-
-    let lexer = Capturing::new(Lexer::new(syntax, target, StringInput::from(&*fm), None));
 
-    let mut parser = Parser::new_from(lexer);
-
-    let program = if is_esm {
-        parser.parse_module().map(Program::Module)
+    let module_kind = if is_esm {
+        ModuleKind::Module
     } else if is_cjs {
-        parser.parse_commonjs().map(Program::Script)
+        ModuleKind::CommonJs
     } else {
-        parser.parse_program()
+        ModuleKind::Unambiguous
+    };
+    let source_type = source_type.with_module_kind(module_kind);
+    let options = ParseOptions {
+        target: EsVersion::latest(),
+        ..Default::default()
     };
+    let ParserReturn {
+        program,
+        diagnostics,
+        tokens,
+        panicked,
+        ..
+    } = Parser::new(input, source_type)
+        .with_options(options)
+        .with_start_pos(fm.start_pos)
+        .with_tokens()
+        .parse();
 
     let mut ast = try_with_handler(
         cm,
@@ -88,20 +101,19 @@ pub fn parse(input: &str, file_name: Option<String>) -> Result<Vec<String>, Stri
             ..Default::default()
         },
         |handler| {
-            for err in parser.take_errors() {
+            for err in diagnostics {
                 err.into_diagnostic(handler).emit();
             }
 
-            program.map_err(|err| {
-                err.into_diagnostic(handler).emit();
-                anyhow::anyhow!("Failed to parse the input")
-            })
+            if panicked || handler.has_errors() {
+                Err(anyhow::anyhow!("Failed to parse the input"))
+            } else {
+                Ok(program)
+            }
         },
     )
     .map_err(|err| err.to_pretty_string())?;
 
-    let tokens = parser.input_mut().iter_mut().take();
-
     GLOBALS.set(&Globals::default(), || {
         let unresolved_mark = Mark::new();
         let top_level_mark = Mark::new();

bindings/binding_react_compiler_node/src/support.rs

@@ -1,8 +1,5 @@
 use napi::bindgen_prelude::*;
-use swc_core::{
-    common::{sync::Lrc, FileName, SourceMap},
-    ecma::{ast::EsVersion, parser::Syntax},
-};
+use swc_core::ecma::parser::{ParseOptions, Parser, SourceType};
 
 struct IsReactCompilerRequiredTask {
     code: String,
@@ -23,26 +20,17 @@ impl Task for IsReactCompilerRequiredTask {
 }
 
 fn is_react_compiler_required_inner(code: &str) -> bool {
-    let cm = Lrc::new(SourceMap::default());
-    let fm = cm.new_source_file(FileName::Anon.into(), code.to_string());
-
-    let program = swc_core::ecma::parser::parse_file_as_program(
-        &fm,
-        Syntax::Typescript(swc_core::ecma::parser::TsSyntax {
+    let result = Parser::new(code, SourceType::tsx())
+        .with_options(ParseOptions {
             decorators: true,
-            tsx: true,
-            ..Default::default()
-        }),
-        EsVersion::latest(),
-        None,
-        &mut vec![],
-    );
-
-    let Ok(program) = program else {
+            ..ParseOptions::default()
+        })
+        .parse();
+    if result.panicked || !result.diagnostics.is_empty() {
         return false;
-    };
+    }
 
-    swc_ecma_react_compiler::fast_check::is_required(&program)
+    swc_ecma_react_compiler::fast_check::is_required(&result.program)
 }
 
 #[napi]

bindings/binding_typescript_wasm/__tests__/__snapshots__/transform.js.snap

@@ -6,7 +6,7 @@ exports[`transform > in strip-only mode > should not emit 'Caused by: failed to
   "endColumn": 22,
   "endLine": 1,
   "filename": "test.ts",
-  "message": "await isn't allowed in non-async function",
+  "message": "Expected 'Ident', got 'Await'",
   "snippet": "function foo() { await Promise.resolve(1); }
                  ^^^^^
 ",
@@ -47,7 +47,7 @@ exports[`transform > in strip-only mode > should report correct error for syntax
   "endColumn": 31,
   "endLine": 1,
   "filename": "test.ts",
-  "message": "Expected ';', '}' or <eof>",
+  "message": "Expected 'Semi', got 'Ident'",
   "snippet": "function foo() { invalid syntax }
                          ^^^^^^
 ",

bindings/binding_typescript_wasm/__tests__/transform.js

@@ -31,7 +31,7 @@ describe("transform", () => {
                     {},
                 ),
             ).resolves.toMatchSnapshot();
-            expect(
+            await expect(
                 swc.transform(
                     `declare enum Foo {
                     a = 2,