refactor(es/minifier): Remove CompileUnit to simplify (#10055)

**Description:**

This type disturbs the transition to the core visitor.

Author: kdy1

.changeset/silver-spoons-joke.md

@@ -0,0 +1,6 @@
+---
+swc_ecma_minifier: minor
+swc_core: minor
+---
+
+refactor(es/minifier): Remove `CompileUnit` to simplify

crates/swc_ecma_minifier/src/compress/mod.rs

@@ -11,8 +11,8 @@ use swc_ecma_ast::*;
 use swc_ecma_transforms_optimization::simplify::{
     dead_branch_remover, expr_simplifier, ExprSimplifierConfig,
 };
-use swc_ecma_usage_analyzer::{analyzer::UsageAnalyzer, marks::Marks};
-use swc_ecma_visit::{noop_visit_mut_type, visit_mut_pass, VisitMut, VisitMutWith, VisitWith};
+use swc_ecma_usage_analyzer::marks::Marks;
+use swc_ecma_visit::{visit_mut_pass, VisitMutWith, VisitWith};
 use swc_timer::timer;
 use tracing::{debug, error};
 
@@ -23,8 +23,8 @@ use crate::{
     debug::{dump, AssertValid},
     mode::Mode,
     option::{CompressOptions, MangleOptions},
-    program_data::{analyze, ProgramData},
-    util::{now, unit::CompileUnit},
+    program_data::analyze,
+    util::{force_dump_program, now},
 };
 
 mod hoist_decls;
@@ -37,7 +37,7 @@ pub(crate) fn compressor<'a, M>(
     options: &'a CompressOptions,
     mangle_options: Option<&'a MangleOptions>,
     mode: &'a M,
-) -> impl 'a + VisitMut
+) -> impl 'a + Pass
 where
     M: Mode,
 {
@@ -52,7 +52,7 @@ where
     };
 
     (
-        visit_mut_pass(compressor),
+        compressor,
         Optional {
             enabled: options.evaluate || options.side_effects,
             visitor: visit_mut_pass(expr_simplifier(
@@ -81,14 +81,14 @@ impl CompilerPass for Compressor<'_> {
     }
 }
 
+impl Pass for Compressor<'_> {
+    fn process(&mut self, program: &mut Program) {
+        self.optimize_unit_repeatedly(program);
+    }
+}
+
 impl Compressor<'_> {
-    fn optimize_unit_repeatedly<N>(&mut self, n: &mut N)
-    where
-        N: CompileUnit
-            + VisitWith<UsageAnalyzer<ProgramData>>
-            + for<'aa> VisitMutWith<Compressor<'aa>>
-            + VisitWith<AssertValid>,
-    {
+    fn optimize_unit_repeatedly(&mut self, n: &mut Program) {
         trace_op!(
             "Optimizing a compile unit within `{:?}`",
             thread::current().name()
@@ -105,7 +105,7 @@ impl Compressor<'_> {
                 },
                 &data,
             );
-            n.apply(&mut v);
+            n.visit_mut_with(&mut v);
             self.changed |= v.changed();
         }
 
@@ -129,13 +129,7 @@ impl Compressor<'_> {
     }
 
     /// Optimize a module. `N` can be [Module] or [FnExpr].
-    fn optimize_unit<N>(&mut self, n: &mut N)
-    where
-        N: CompileUnit
-            + VisitWith<UsageAnalyzer<ProgramData>>
-            + for<'aa> VisitMutWith<Compressor<'aa>>
-            + VisitWith<AssertValid>,
-    {
+    fn optimize_unit(&mut self, n: &mut Program) {
         let _timer = timer!("optimize", pass = self.pass);
 
         if self.options.passes != 0 && self.options.passes < self.pass {
@@ -150,7 +144,7 @@ impl Compressor<'_> {
                 error!("Seems like there's an infinite loop");
             }
 
-            let code = n.force_dump();
+            let code = force_dump_program(n);
 
             if self.dump_for_infinite_loop.contains(&code) {
                 let mut msg = String::new();
@@ -189,7 +183,7 @@ impl Compressor<'_> {
             let start = n.dump();
 
             let mut visitor = expr_simplifier(self.marks.unresolved_mark, ExprSimplifierConfig {});
-            n.apply(&mut visitor);
+            n.visit_mut_with(&mut visitor);
 
             self.changed |= visitor.changed();
             if visitor.changed() {
@@ -240,7 +234,7 @@ impl Compressor<'_> {
                     debug_infinite_loop: self.pass >= 20,
                 },
             );
-            n.apply(&mut visitor);
+            n.visit_mut_with(&mut visitor);
 
             self.changed |= visitor.changed();
 
@@ -276,7 +270,7 @@ impl Compressor<'_> {
                 self.mode,
                 !self.dump_for_infinite_loop.is_empty(),
             );
-            n.apply(&mut visitor);
+            n.visit_mut_with(&mut visitor);
 
             self.changed |= visitor.changed();
 
@@ -291,7 +285,7 @@ impl Compressor<'_> {
             let start_time = now();
 
             let mut v = dead_branch_remover(self.marks.unresolved_mark);
-            n.apply(&mut v);
+            n.visit_mut_with(&mut v);
 
             if let Some(start_time) = start_time {
                 let end_time = Instant::now();
@@ -320,42 +314,6 @@ impl Compressor<'_> {
     }
 }
 
-impl VisitMut for Compressor<'_> {
-    noop_visit_mut_type!();
-
-    fn visit_mut_script(&mut self, n: &mut Script) {
-        self.optimize_unit_repeatedly(n);
-    }
-
-    fn visit_mut_module(&mut self, n: &mut Module) {
-        self.optimize_unit_repeatedly(n);
-    }
-
-    fn visit_mut_module_items(&mut self, stmts: &mut Vec<ModuleItem>) {
-        stmts.retain(|stmt| match stmt {
-            ModuleItem::Stmt(Stmt::Empty(..)) => false,
-            ModuleItem::ModuleDecl(ModuleDecl::ExportDecl(ExportDecl {
-                decl: Decl::Var(v),
-                ..
-            }))
-            | ModuleItem::Stmt(Stmt::Decl(Decl::Var(v)))
-                if v.decls.is_empty() =>
-            {
-                false
-            }
-            _ => true,
-        });
-    }
-
-    fn visit_mut_stmts(&mut self, stmts: &mut Vec<Stmt>) {
-        stmts.retain(|stmt| match stmt {
-            Stmt::Empty(..) => false,
-            Stmt::Decl(Decl::Var(v)) if v.decls.is_empty() => false,
-            _ => true,
-        });
-    }
-}
-
 #[cfg(feature = "debug")]
 #[derive(PartialEq, Eq)]
 struct DebugUsingDisplay<'a>(pub &'a str);

crates/swc_ecma_minifier/src/debug.rs

@@ -1,16 +1,9 @@
-use std::{
-    io::Write,
-    process::{Command, Stdio},
-};
-
 use swc_common::{sync::Lrc, SourceMap, SyntaxContext};
 use swc_ecma_ast::*;
 use swc_ecma_codegen::{text_writer::JsWriter, Emitter};
-use swc_ecma_transforms_base::{fixer::fixer, hygiene::hygiene};
-pub use swc_ecma_transforms_optimization::{debug_assert_valid, AssertValid};
+pub use swc_ecma_transforms_optimization::AssertValid;
 use swc_ecma_utils::{drop_span, DropSpan};
 use swc_ecma_visit::{noop_visit_mut_type, VisitMut, VisitMutWith};
-use tracing::debug;
 
 pub(crate) struct Debugger {}
 
@@ -61,184 +54,3 @@ where
 
     String::from_utf8(buf).unwrap()
 }
-
-/// Invokes code using node.js.
-///
-/// If the cargo feature `debug` is disabled or the environment variable
-/// `SWC_RUN` is not `1`, this function is noop.
-pub(crate) fn invoke_module(module: &Module) {
-    debug_assert_valid(module);
-
-    let _noop_sub = tracing::subscriber::set_default(tracing::subscriber::NoSubscriber::default());
-
-    let should_run =
-        cfg!(debug_assertions) && cfg!(feature = "debug") && option_env!("SWC_RUN") == Some("1");
-    let should_check = cfg!(debug_assertions) && option_env!("SWC_CHECK") == Some("1");
-
-    if !should_run && !should_check {
-        return;
-    }
-
-    let module = Program::Module(module.clone())
-        .apply(hygiene())
-        .apply(fixer(None));
-    let module = drop_span(module);
-
-    let mut buf = Vec::new();
-    let cm = Lrc::new(SourceMap::default());
-
-    {
-        let mut emitter = Emitter {
-            cfg: Default::default(),
-            cm: cm.clone(),
-            comments: None,
-            wr: Box::new(JsWriter::new(cm, "\n", &mut buf, None)),
-        };
-
-        emitter.emit_program(&module).unwrap();
-    }
-
-    let code = String::from_utf8(buf).unwrap();
-
-    debug!("Validating with node.js:\n{}", code);
-
-    if should_check {
-        let mut child = Command::new("node")
-            .arg("-")
-            .arg("--check")
-            .stdin(Stdio::piped())
-            .stdout(Stdio::piped())
-            .stderr(Stdio::piped())
-            .spawn()
-            .expect("failed to spawn node");
-
-        {
-            let child_stdin = child.stdin.as_mut().unwrap();
-            child_stdin
-                .write_all(code.as_bytes())
-                .expect("failed to write");
-        }
-
-        let output = child.wait_with_output().expect("failed to check syntax");
-
-        if !output.status.success() {
-            panic!(
-                "[SWC_CHECK] Failed to validate code:\n{}\n===== ===== ===== ===== =====\n{}\n{}",
-                code,
-                String::from_utf8_lossy(&output.stdout),
-                String::from_utf8_lossy(&output.stderr),
-            );
-        }
-    } else {
-        let output = Command::new("node")
-            .arg("--input-type=module")
-            .arg("-e")
-            .arg(&code)
-            .output()
-            .expect("[SWC_RUN] failed to validate code using `node`");
-        if !output.status.success() {
-            panic!(
-                "[SWC_RUN] Failed to validate code:\n{}\n===== ===== ===== ===== =====\n{}\n{}",
-                code,
-                String::from_utf8_lossy(&output.stdout),
-                String::from_utf8_lossy(&output.stderr),
-            );
-        }
-
-        tracing::info!(
-            "[SWC_RUN]\n{}\n{}",
-            code,
-            String::from_utf8_lossy(&output.stdout)
-        )
-    }
-}
-
-/// Invokes code using node.js.
-///
-/// If the cargo feature `debug` is disabled or the environment variable
-/// `SWC_RUN` is not `1`, this function is noop.
-pub(crate) fn invoke_script(script: &Script) {
-    debug_assert_valid(script);
-
-    let _noop_sub = tracing::subscriber::set_default(tracing::subscriber::NoSubscriber::default());
-
-    let should_run =
-        cfg!(debug_assertions) && cfg!(feature = "debug") && option_env!("SWC_RUN") == Some("1");
-    let should_check = cfg!(debug_assertions) && option_env!("SWC_CHECK") == Some("1");
-
-    if !should_run && !should_check {
-        return;
-    }
-
-    let script = Program::Script(script.clone())
-        .apply(hygiene())
-        .apply(fixer(None));
-    let script = drop_span(script);
-
-    let mut buf = Vec::new();
-    let cm = Lrc::new(SourceMap::default());
-
-    {
-        let mut emitter = Emitter {
-            cfg: Default::default(),
-            cm: cm.clone(),
-            comments: None,
-            wr: Box::new(JsWriter::new(cm, "\n", &mut buf, None)),
-        };
-
-        emitter.emit_program(&script).unwrap();
-    }
-
-    let code = String::from_utf8(buf).unwrap();
-
-    debug!("Validating with node.js:\n{}", code);
-
-    if should_check {
-        let mut child = Command::new("node")
-            .arg("-")
-            .arg("--check")
-            .stdin(Stdio::piped())
-            .stdout(Stdio::piped())
-            .stderr(Stdio::piped())
-            .spawn()
-            .expect("failed to spawn node");
-
-        {
-            let child_stdin = child.stdin.as_mut().unwrap();
-            child_stdin
-                .write_all(code.as_bytes())
-                .expect("failed to write");
-        }
-
-        let output = child.wait_with_output().expect("failed to check syntax");
-
-        if !output.status.success() {
-            panic!(
-                "[SWC_CHECK] Failed to validate code:\n{}\n===== ===== ===== ===== =====\n{}\n{}",
-                code,
-                String::from_utf8_lossy(&output.stdout),
-                String::from_utf8_lossy(&output.stderr),
-            );
-        }
-    } else {
-        let output = Command::new("node")
-            .arg("-e")
-            .arg(&code)
-            .output()
-            .expect("[SWC_RUN] failed to validate code using `node`");
-        if !output.status.success() {
-            panic!(
-                "[SWC_RUN] Failed to validate code:\n{}\n===== ===== ===== ===== =====\n{}\n{}",
-                code,
-                String::from_utf8_lossy(&output.stdout),
-                String::from_utf8_lossy(&output.stderr),
-            );
-        }
-
-        tracing::info!(
-            "[SWC_RUN]\n{}\n{}",
-            code,
-            String::from_utf8_lossy(&output.stdout)
-        )
-    }
-}

crates/swc_ecma_minifier/src/eval.rs

@@ -19,7 +19,7 @@ use crate::{
 pub struct Evaluator {
     expr_ctx: ExprCtx,
 
-    module: Module,
+    program: Program,
     marks: Marks,
     data: Eval,
     /// We run minification only once.
@@ -36,7 +36,7 @@ impl Evaluator {
                 remaining_depth: 3,
             },
 
-            module,
+            program: Program::Module(module),
             marks,
             data: Default::default(),
             done: Default::default(),
@@ -88,7 +88,7 @@ impl Evaluator {
             let marks = self.marks;
             let data = self.data.clone();
             //
-            self.module.visit_mut_with(&mut compressor(
+            self.program.mutate(&mut compressor(
                 marks,
                 &CompressOptions {
                     // We should not drop unused variables.

crates/swc_ecma_minifier/src/lib.rs

@@ -186,7 +186,7 @@ pub fn optimize(
         {
             let _timer = timer!("compress ast");
 
-            n.visit_mut_with(&mut compressor(
+            n.mutate(&mut compressor(
                 marks,
                 c,
                 options.mangle.as_ref(),

crates/swc_ecma_minifier/src/util/mod.rs

@@ -6,13 +6,13 @@ use rustc_hash::FxHashSet;
 use swc_atoms::Atom;
 use swc_common::{util::take::Take, Span, Spanned, DUMMY_SP};
 use swc_ecma_ast::*;
-use swc_ecma_utils::{stack_size::maybe_grow_default, ModuleItemLike, StmtLike, Value};
-use swc_ecma_visit::{noop_visit_type, visit_obj_and_computed, Visit, VisitWith};
+use swc_ecma_transforms_base::{fixer::fixer, hygiene::hygiene};
+use swc_ecma_utils::{stack_size::maybe_grow_default, DropSpan, ModuleItemLike, StmtLike, Value};
+use swc_ecma_visit::{noop_visit_type, visit_mut_pass, visit_obj_and_computed, Visit, VisitWith};
 
 pub(crate) mod base54;
 pub(crate) mod size;
 pub(crate) mod sort;
-pub(crate) mod unit;
 
 pub(crate) fn make_number(span: Span, value: f64) -> Expr {
     trace_op!("Creating a numeric literal");
@@ -520,6 +520,30 @@ impl Visit for EvalFinder {
     }
 }
 
+#[allow(unused)]
+pub(crate) fn dump_program(p: &Program) -> String {
+    #[cfg(feature = "debug")]
+    {
+        force_dump_program(p)
+    }
+    #[cfg(not(feature = "debug"))]
+    {
+        String::new()
+    }
+}
+
+pub(crate) fn force_dump_program(p: &Program) -> String {
+    let _noop_sub = tracing::subscriber::set_default(tracing::subscriber::NoSubscriber::default());
+
+    crate::debug::dump(
+        &p.clone()
+            .apply(fixer(None))
+            .apply(hygiene())
+            .apply(visit_mut_pass(DropSpan {})),
+        true,
+    )
+}
+
 #[cfg(feature = "concurrent")]
 #[macro_export(local_inner_macros)]
 #[allow(clippy::crate_in_macro_def)]