refactor: use a single transform option

Author: Boshen

benches/transformer.rs

@@ -8,26 +8,34 @@ static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;
 
 trait TheBencher {
     type RunOutput;
+    type Options: Send + Sync;
 
     const ID: &'static str;
 
-    fn run(path: &Path, source: &str) -> Self::RunOutput;
+    fn run(path: &Path, source: &str, options: &Self::Options) -> Self::RunOutput;
 
-    fn bench(g: &mut BenchmarkGroup<'_, WallTime>, path: &Path, source: &str) {
+    fn bench(
+        g: &mut BenchmarkGroup<'_, WallTime>,
+        path: &Path,
+        source: &str,
+        options: &Self::Options,
+    ) {
         let cpus = num_cpus::get_physical();
         let id = BenchmarkId::new(Self::ID, "single-thread");
-        g.bench_with_input(id, &source, |b, source| b.iter(|| Self::run(path, source)));
+        g.bench_with_input(id, &source, |b, source| {
+            b.iter(|| Self::run(path, source, options))
+        });
 
         let id = BenchmarkId::new(Self::ID, "no-drop");
         g.bench_with_input(id, &source, |b, source| {
-            b.iter_with_large_drop(|| Self::run(path, source))
+            b.iter_with_large_drop(|| Self::run(path, source, options))
         });
 
         let id = BenchmarkId::new(Self::ID, "parallel");
         g.bench_with_input(id, &source, |b, source| {
             b.iter(|| {
                 (0..cpus).into_par_iter().for_each(|_| {
-                    Self::run(path, source);
+                    Self::run(path, source, options);
                 });
             })
         });
@@ -38,22 +46,24 @@ struct OxcBencher;
 
 impl TheBencher for OxcBencher {
     type RunOutput = (oxc::allocator::Allocator, String);
+    type Options = oxc::transformer::TransformOptions;
 
     const ID: &'static str = "oxc";
 
-    fn run(path: &Path, source_text: &str) -> Self::RunOutput {
-        bench_transformer::oxc::transform(path, source_text)
+    fn run(path: &Path, source_text: &str, options: &Self::Options) -> Self::RunOutput {
+        bench_transformer::oxc::transform(path, source_text, options)
     }
 }
 
 struct SwcBencher;
 
 impl TheBencher for SwcBencher {
     type RunOutput = String;
+    type Options = ();
 
     const ID: &'static str = "swc";
 
-    fn run(path: &Path, source_text: &str) -> Self::RunOutput {
+    fn run(path: &Path, source_text: &str, _option: &Self::Options) -> Self::RunOutput {
         bench_transformer::swc::transform(path, source_text)
     }
 }
@@ -64,8 +74,11 @@ fn transformer_benchmark(c: &mut Criterion) {
         let path = Path::new("files").join(filename);
         let source = std::fs::read_to_string(&path).unwrap();
         let mut g = c.benchmark_group(filename);
-        OxcBencher::bench(&mut g, &path, &source);
-        SwcBencher::bench(&mut g, &path, &source);
+
+        let options = oxc::transformer::TransformOptions::from_target("es2015").unwrap();
+        OxcBencher::bench(&mut g, &path, &source, &options);
+
+        SwcBencher::bench(&mut g, &path, &source, &());
         g.finish();
     }
 }

src/lib.rs

@@ -10,22 +10,30 @@ pub mod oxc {
         transformer::{TransformOptions, Transformer},
     };
 
-    pub fn transform(path: &Path, source_text: &str) -> (Allocator, String) {
+    pub fn transform_options() -> TransformOptions {
+        TransformOptions::from_target("es2015").unwrap()
+    }
+
+    pub fn transform(
+        path: &Path,
+        source_text: &str,
+        options: &TransformOptions,
+    ) -> (Allocator, String) {
         let allocator = Allocator::default();
         let source_type = SourceType::from_path(path).unwrap();
-        let printed = {
-            let ret = Parser::new(&allocator, source_text, source_type).parse();
-            let mut program = ret.program;
-            let transform_options = TransformOptions::from_target("es2015").unwrap();
-            let (symbols, scopes) = SemanticBuilder::new()
-                .build(&program)
-                .semantic
-                .into_symbol_table_and_scope_tree();
-            let ret = Transformer::new(&allocator, path, &transform_options)
-                .build_with_symbols_and_scopes(symbols, scopes, &mut program);
-            assert!(ret.errors.is_empty());
-            CodeGenerator::new().build(&program).code
-        };
+        let ret = Parser::new(&allocator, source_text, source_type).parse();
+        let mut program = ret.program;
+        let (symbols, scopes) = SemanticBuilder::new()
+            .build(&program)
+            .semantic
+            .into_symbol_table_and_scope_tree();
+        let ret = Transformer::new(&allocator, path, options).build_with_symbols_and_scopes(
+            symbols,
+            scopes,
+            &mut program,
+        );
+        assert!(ret.errors.is_empty());
+        let printed = CodeGenerator::new().build(&program).code;
 
         (allocator, printed)
     }

src/oxc.rs

@@ -9,6 +9,7 @@ pub fn main() {
     let path = env::args().nth(1).unwrap();
     let path = Path::new(&path);
     let source_text = fs::read_to_string(path).unwrap();
-    let _output = oxc::transform(path, &source_text);
+    let options = oxc::transform_options();
+    let _output = oxc::transform(path, &source_text, &options);
     // println!("{}", output.1);
 }