refactor(es/minifier): Use chili for minify-all example (#9885)

Author: kdy1

crates/swc_ecma_minifier/examples/minify-all.rs

@@ -6,7 +6,7 @@ use std::{env, fs, path::PathBuf, time::Instant};
 
 use anyhow::Result;
 use rayon::prelude::*;
-use swc_common::{errors::HANDLER, sync::Lrc, Mark, SourceMap, GLOBALS};
+use swc_common::{sync::Lrc, Mark, SourceMap, GLOBALS};
 use swc_ecma_ast::Program;
 use swc_ecma_codegen::text_writer::JsWriter;
 use swc_ecma_minifier::{
@@ -18,6 +18,7 @@ use swc_ecma_transforms_base::{
     fixer::{fixer, paren_remover},
     resolver,
 };
+use swc_ecma_utils::parallel::{Parallel, ParallelExt};
 use walkdir::WalkDir;
 
 fn main() {
@@ -53,74 +54,72 @@ fn expand_dirs(dirs: Vec<String>) -> Vec<PathBuf> {
         .collect()
 }
 
+struct Worker;
+
+impl Parallel for Worker {
+    fn create(&self) -> Self {
+        Worker
+    }
+
+    fn merge(&mut self, _: Self) {}
+}
+
 #[inline(never)] // For profiling
 fn minify_all(files: Vec<PathBuf>) {
-    testing::run_test2(false, |cm, handler| {
-        GLOBALS.with(|globals| {
-            HANDLER.set(&handler, || {
-                let _ = files
-                    .into_iter()
-                    .map(|path| -> Result<_> {
-                        GLOBALS.set(globals, || {
-                            let fm = cm.load_file(&path).expect("failed to load file");
-
-                            let unresolved_mark = Mark::new();
-                            let top_level_mark = Mark::new();
-
-                            let program = parse_file_as_module(
-                                &fm,
-                                Default::default(),
-                                Default::default(),
-                                None,
-                                &mut Vec::new(),
-                            )
-                            .map_err(|err| {
-                                err.into_diagnostic(&handler).emit();
-                            })
-                            .map(Program::Module)
-                            .map(|module| {
-                                module.apply(&mut resolver(unresolved_mark, top_level_mark, false))
-                            })
-                            .map(|module| module.apply(&mut paren_remover(None)))
-                            .unwrap();
-
-                            let output = optimize(
-                                program,
-                                cm.clone(),
-                                None,
-                                None,
-                                &MinifyOptions {
-                                    compress: Some(Default::default()),
-                                    mangle: Some(MangleOptions {
-                                        top_level: Some(true),
-                                        ..Default::default()
-                                    }),
-                                    ..Default::default()
-                                },
-                                &ExtraOptions {
-                                    unresolved_mark,
-                                    top_level_mark,
-                                    mangle_name_cache: None,
-                                },
-                            );
-
-                            let output = output.apply(&mut fixer(None));
-
-                            let code = print(cm.clone(), &[output], true);
-
-                            fs::write("output.js", code.as_bytes())
-                                .expect("failed to write output");
-
-                            Ok(())
-                        })
-                    })
-                    .collect::<Vec<_>>();
+    GLOBALS.set(&Default::default(), || {
+        Worker.maybe_par(2, files, |_, path| {
+            testing::run_test(false, |cm, handler| {
+                let fm = cm.load_file(&path).expect("failed to load file");
+
+                let unresolved_mark = Mark::new();
+                let top_level_mark = Mark::new();
+
+                let program = parse_file_as_module(
+                    &fm,
+                    Default::default(),
+                    Default::default(),
+                    None,
+                    &mut Vec::new(),
+                )
+                .map_err(|err| {
+                    err.into_diagnostic(handler).emit();
+                })
+                .map(Program::Module)
+                .map(|module| module.apply(&mut resolver(unresolved_mark, top_level_mark, false)))
+                .map(|module| module.apply(&mut paren_remover(None)))
+                .unwrap();
+
+                let output = optimize(
+                    program,
+                    cm.clone(),
+                    None,
+                    None,
+                    &MinifyOptions {
+                        compress: Some(Default::default()),
+                        mangle: Some(MangleOptions {
+                            top_level: Some(true),
+                            ..Default::default()
+                        }),
+                        ..Default::default()
+                    },
+                    &ExtraOptions {
+                        unresolved_mark,
+                        top_level_mark,
+                        mangle_name_cache: None,
+                    },
+                );
+
+                let output = output.apply(&mut fixer(None));
+
+                let code = print(cm.clone(), &[output], true);
+
+                fs::write("output.js", code.as_bytes()).expect("failed to write output");
 
                 Ok(())
             })
-        })
-    })
-    .unwrap()
+            .unwrap()
+        });
+    });
 }
 
 fn print<N: swc_ecma_codegen::Node>(cm: Lrc<SourceMap>, nodes: &[N], minify: bool) -> String {