feat(es/compiler): Port single-pass compiler from oxc

crates/swc_ecma_compat_common/Cargo.toml

@@ -14,5 +14,6 @@ version       = "24.0.0"
 [dependencies]
 swc_common     = { version = "17.0.1", path = "../swc_common" }
 swc_ecma_ast   = { version = "18.0.0", path = "../swc_ecma_ast" }
+swc_ecma_compiler = { version = "8.0.0", path = "../swc_ecma_compiler" }
 swc_ecma_utils = { version = "24.0.0", path = "../swc_ecma_utils" }
 swc_ecma_visit = { version = "18.0.1", path = "../swc_ecma_visit" }

crates/swc_ecma_compat_common/src/regexp.rs

@@ -1,10 +1,19 @@
-use swc_common::util::take::Take;
-use swc_ecma_ast::{CallExpr, Expr, Lit, Pass, Regex};
-use swc_ecma_utils::{quote_ident, ExprFactory};
-use swc_ecma_visit::{noop_visit_mut_type, visit_mut_pass, VisitMut, VisitMutWith};
+use swc_ecma_ast::Pass;
+use swc_ecma_compiler::{TransformOptions, Transformer};
 
 pub fn regexp(config: Config) -> impl Pass {
-    visit_mut_pass(RegExp { config })
+    let mut transform_options = TransformOptions::default();
+
+    transform_options.env.regexp.dot_all_flag = config.dot_all_regex;
+    transform_options.env.regexp.match_indices = config.has_indices;
+    transform_options.env.regexp.look_behind_assertions = config.lookbehind_assertion;
+    transform_options.env.regexp.named_capture_groups = config.named_capturing_groups_regex;
+    transform_options.env.regexp.sticky_flag = config.sticky_regex;
+    transform_options.env.regexp.unicode_property_escapes = config.unicode_property_regex;
+    transform_options.env.regexp.unicode_flag = config.unicode_regex;
+    transform_options.env.regexp.set_notation = config.unicode_sets_regex;
+
+    Transformer::new("".as_ref(), &transform_options)
 }
 
 #[derive(Default, Clone, Copy)]
@@ -26,47 +35,3 @@ pub struct Config {
     // [RegExp.prototype.unicodeSets](https://github.com/tc39/proposal-regexp-v-flag)
     pub unicode_sets_regex: bool,
 }
-
-struct RegExp {
-    config: Config,
-}
-
-impl VisitMut for RegExp {
-    noop_visit_mut_type!(fail);
-
-    fn visit_mut_expr(&mut self, expr: &mut Expr) {
-        expr.visit_mut_children_with(self);
-
-        if let Expr::Lit(Lit::Regex(regex)) = expr {
-            if (self.config.dot_all_regex && regex.flags.contains('s'))
-                || (self.config.sticky_regex && regex.flags.contains('y'))
-                || (self.config.unicode_regex && regex.flags.contains('u'))
-                || (self.config.unicode_sets_regex && regex.flags.contains('v'))
-                || (self.config.has_indices && regex.flags.contains('d'))
-                || (self.config.named_capturing_groups_regex && regex.exp.contains("(?<"))
-                || (self.config.lookbehind_assertion && regex.exp.contains("(?<=")
-                    || regex.exp.contains("(?<!"))
-                || (self.config.unicode_property_regex
-                    && (regex.exp.contains("\\p{") || regex.exp.contains("\\P{")))
-            {
-                let Regex { exp, flags, span } = regex.take();
-
-                let exp: Expr = exp.into();
-                let mut args = vec![exp.into()];
-
-                if !flags.is_empty() {
-                    let flags: Expr = flags.into();
-                    args.push(flags.into());
-                }
-
-                *expr = CallExpr {
-                    span,
-                    callee: quote_ident!("RegExp").as_callee(),
-                    args,
-                    ..Default::default()
-                }
-                .into()
-            }
-        }
-    }
-}

crates/swc_ecma_compat_es2020/src/export_namespace_from.rs

@@ -1,9 +1,18 @@
 use swc_ecma_ast::Pass;
-use swc_ecma_compiler::{Compiler, Features};
+use swc_ecma_compiler::{ES2020Options, EnvOptions, TransformOptions, Transformer};
 
 pub fn export_namespace_from() -> impl Pass {
-    Compiler::new(swc_ecma_compiler::Config {
-        includes: Features::EXPORT_NAMESPACE_FROM,
-        ..Default::default()
-    })
+    Transformer::new(
+        "".as_ref(),
+        &TransformOptions {
+            env: EnvOptions {
+                es2020: ES2020Options {
+                    export_namespace_from: true,
+                    ..Default::default()
+                },
+                ..Default::default()
+            },
+            ..Default::default()
+        },
+    )
 }

crates/swc_ecma_compat_es2020/src/lib.rs

@@ -1,7 +1,7 @@
 use serde::Deserialize;
 use swc_common::Mark;
 use swc_ecma_ast::Pass;
-use swc_ecma_compiler::{Compiler, Features};
+use swc_ecma_compiler::{ES2020Options, EnvOptions, TransformOptions, Transformer};
 use swc_ecma_transforms_base::assumptions::Assumptions;
 
 pub use self::{
@@ -19,11 +19,20 @@ pub fn es2020(config: Config, unresolved_mark: Mark) -> impl Pass {
 
     (
         optional_chaining(config.optional_chaining, unresolved_mark),
-        Compiler::new(swc_ecma_compiler::Config {
-            includes: Features::EXPORT_NAMESPACE_FROM | Features::NULLISH_COALESCING,
-            assumptions,
-            ..Default::default()
-        }),
+        Transformer::new(
+            "".as_ref(),
+            &TransformOptions {
+                env: EnvOptions {
+                    es2020: ES2020Options {
+                        export_namespace_from: true,
+                        nullish_coalescing_operator: true,
+                        ..Default::default()
+                    },
+                    ..Default::default()
+                },
+                ..Default::default()
+            },
+        ),
     )
 }
 

crates/swc_ecma_compat_es2020/src/nullish_coalescing.rs

@@ -1,6 +1,6 @@
 use serde::Deserialize;
 use swc_ecma_ast::Pass;
-use swc_ecma_compiler::{Compiler, Features};
+use swc_ecma_compiler::{ES2020Options, EnvOptions, TransformOptions, Transformer};
 use swc_ecma_transforms_base::assumptions::Assumptions;
 
 /// Configuration for nullish coalescing transformation
@@ -18,9 +18,17 @@ pub fn nullish_coalescing(c: Config) -> impl Pass + 'static {
     let mut assumptions = Assumptions::default();
     assumptions.no_document_all = c.no_document_all;
 
-    Compiler::new(swc_ecma_compiler::Config {
-        includes: Features::NULLISH_COALESCING,
-        assumptions,
-        ..Default::default()
-    })
+    Transformer::new(
+        "".as_ref(),
+        &TransformOptions {
+            env: EnvOptions {
+                es2020: ES2020Options {
+                    nullish_coalescing_operator: true,
+                    ..Default::default()
+                },
+                ..Default::default()
+            },
+            ..Default::default()
+        },
+    )
 }

crates/swc_ecma_compat_es2021/src/logical_assignments.rs

@@ -1,9 +1,17 @@
 use swc_ecma_ast::Pass;
-use swc_ecma_compiler::{Compiler, Features};
+use swc_ecma_compiler::{ES2021Options, EnvOptions, TransformOptions, Transformer};
 
 pub fn logical_assignments() -> impl Pass {
-    Compiler::new(swc_ecma_compiler::Config {
-        includes: Features::LOGICAL_ASSIGNMENTS,
-        ..Default::default()
-    })
+    Transformer::new(
+        "".as_ref(),
+        &TransformOptions {
+            env: EnvOptions {
+                es2021: ES2021Options {
+                    logical_assignment_operators: true,
+                },
+                ..Default::default()
+            },
+            ..Default::default()
+        },
+    )
 }

crates/swc_ecma_compat_es2022/src/lib.rs

@@ -3,7 +3,7 @@
 use swc_common::Mark;
 use swc_ecma_ast::Pass;
 use swc_ecma_compat_common::regexp::{self, regexp};
-use swc_ecma_compiler::{Compiler, Features};
+use swc_ecma_compiler::{ES2022Options, EnvOptions, TransformOptions, Transformer};
 
 pub use self::{
     class_properties::class_properties, private_in_object::private_in_object,
@@ -27,10 +27,20 @@ pub fn es2022(config: Config, unresolved_mark: Mark) -> impl Pass {
             unicode_regex: false,
             unicode_sets_regex: false,
         }),
-        Compiler::new(swc_ecma_compiler::Config {
-            includes: Features::STATIC_BLOCKS | Features::PRIVATE_IN_OBJECT,
-            ..Default::default()
-        }),
+        Transformer::new(
+            "".as_ref(),
+            &TransformOptions {
+                env: EnvOptions {
+                    es2022: ES2022Options {
+                        class_static_block: true,
+                        top_level_await: true,
+                        ..Default::default()
+                    },
+                    ..Default::default()
+                },
+                ..Default::default()
+            },
+        ),
         class_properties(config.class_properties, unresolved_mark),
     )
 }

crates/swc_ecma_compat_es2022/src/private_in_object.rs

@@ -1,10 +1,23 @@
 use swc_ecma_ast::Pass;
-use swc_ecma_compiler::{Compiler, Features};
+use swc_ecma_compiler::{
+    ClassPropertiesOptions, ES2022Options, EnvOptions, TransformOptions, Transformer,
+};
 
 /// https://github.com/tc39/proposal-private-fields-in-in
 pub fn private_in_object() -> impl Pass {
-    Compiler::new(swc_ecma_compiler::Config {
-        includes: Features::PRIVATE_IN_OBJECT,
-        ..Default::default()
-    })
+    Transformer::new(
+        "".as_ref(),
+        &TransformOptions {
+            env: EnvOptions {
+                es2022: ES2022Options {
+                    class_properties: Some(ClassPropertiesOptions {
+                        ..Default::default()
+                    }),
+                    ..Default::default()
+                },
+                ..Default::default()
+            },
+            ..Default::default()
+        },
+    )
 }

crates/swc_ecma_compat_es2022/src/static_blocks.rs

@@ -1,9 +1,18 @@
 use swc_ecma_ast::*;
-use swc_ecma_compiler::{Compiler, Features};
+use swc_ecma_compiler::{ES2022Options, EnvOptions, TransformOptions, Transformer};
 
 pub fn static_blocks() -> impl Pass {
-    Compiler::new(swc_ecma_compiler::Config {
-        includes: Features::STATIC_BLOCKS,
-        ..Default::default()
-    })
+    Transformer::new(
+        "".as_ref(),
+        &TransformOptions {
+            env: EnvOptions {
+                es2022: ES2022Options {
+                    class_static_block: true,
+                    ..Default::default()
+                },
+                ..Default::default()
+            },
+            ..Default::default()
+        },
+    )
 }

crates/swc_ecma_compiler/Cargo.toml

@@ -13,13 +13,25 @@ version       = "8.0.0"
 unexpected_cfgs = { level = "warn", check-cfg = ['cfg(swc_ast_unknown)'] }
 
 [dependencies]
-bitflags   = { workspace = true }
-rustc-hash = { workspace = true }
-tracing    = { workspace = true }
+base64      = { workspace = true }
+bitflags    = { workspace = true }
+indexmap    = { workspace = true }
+itoa        = "1"
+memchr      = { workspace = true }
+once_cell   = { workspace = true }
+rustc-hash  = { workspace = true }
+serde       = { workspace = true }
+serde_json  = { workspace = true }
+sha1        = { workspace = true }
+tracing     = { workspace = true }
 
 swc_atoms                = { version = "9.0.0", path = "../swc_atoms" }
 swc_common               = { version = "17.0.1", path = "../swc_common" }
 swc_ecma_ast             = { version = "18.0.0", path = "../swc_ecma_ast" }
+swc_ecma_hooks           = { version = "0.1.0", path = "../swc_ecma_hooks" }
+swc_ecma_regexp          = { version = "0.6.0", path = "../swc_ecma_regexp" }
+swc_ecma_regexp_ast      = { version = "0.6.0", path = "../swc_ecma_regexp_ast" }
+swc_ecma_regexp_visit    = { version = "0.6.0", path = "../swc_ecma_regexp_visit" }
 swc_ecma_transforms_base = { version = "30.0.0", path = "../swc_ecma_transforms_base" }
 swc_ecma_utils           = { version = "24.0.0", path = "../swc_ecma_utils" }
 swc_ecma_visit           = { version = "18.0.1", path = "../swc_ecma_visit" }