perf(es/minifier): Move logic to the pure minifier (#10264)

**Description:**

```
Benchmarking es/minifier/real/es/minifier/real/sequential: Warming up for 3.0000 s
Warning: Unable to complete 10 samples in 5.0s. You may wish to increase target time to 99.0s.
es/minifier/real/es/minifier/real/sequential
                        time:   [10.086 s 10.173 s 10.274 s]
                        change: [-7.5770% -6.7384% -5.7020%] (p = 0.00 < 0.05)
                        Performance has improved.
```

Author: kdy1

crates/swc/tests/libs-size.snapshot.md

@@ -1,14 +1,14 @@
 | File | Original Size | Compressed Size | Gzipped Size |
 | --- | --- | --- | --- |
-| antd.js | 6.38 MiB | 2.05 MiB | 444.48 KiB |
+| antd.js | 6.38 MiB | 2.05 MiB | 444.47 KiB |
 | d3.js | 542.74 KiB | 259.00 KiB | 85.06 KiB |
-| echarts.js | 3.41 MiB | 971.04 KiB | 313.32 KiB |
+| echarts.js | 3.41 MiB | 971.11 KiB | 313.35 KiB |
 | jquery.js | 280.89 KiB | 87.11 KiB | 30.15 KiB |
 | lodash.js | 531.35 KiB | 68.18 KiB | 24.52 KiB |
-| moment.js | 169.83 KiB | 57.03 KiB | 18.21 KiB |
+| moment.js | 169.83 KiB | 57.04 KiB | 18.22 KiB |
 | react.js | 70.45 KiB | 22.28 KiB | 8.00 KiB |
-| terser.js | 1.08 MiB | 444.88 KiB | 120.45 KiB |
+| terser.js | 1.08 MiB | 444.91 KiB | 120.44 KiB |
 | three.js | 1.19 MiB | 627.90 KiB | 154.58 KiB |
-| typescript.js | 10.45 MiB | 3.17 MiB | 846.03 KiB |
+| typescript.js | 10.45 MiB | 3.17 MiB | 846.04 KiB |
 | victory.js | 2.30 MiB | 689.65 KiB | 153.64 KiB |
-| vue.js | 334.13 KiB | 112.95 KiB | 41.69 KiB |
+| vue.js | 334.13 KiB | 112.96 KiB | 41.69 KiB |

crates/swc/tests/tsc-references/parserModule1.2.minified.js

@@ -6,7 +6,7 @@ function Alert(output) {
 CompilerDiagnostics.debug = !1, CompilerDiagnostics.diagnosticWriter = null, CompilerDiagnostics.analysisPass = 0, CompilerDiagnostics.Alert = Alert, CompilerDiagnostics.debugPrint = function(s) {
     CompilerDiagnostics.debug && Alert(s);
 }, CompilerDiagnostics.assert = function(condition, s) {
-    CompilerDiagnostics.debug && (condition || Alert(s));
+    CompilerDiagnostics.debug && !condition && Alert(s);
 };
 var CompilerDiagnostics1;
 export { CompilerDiagnostics1 as CompilerDiagnostics };

crates/swc/tests/tsc-references/parserRealSource1.2.minified.js

@@ -7,7 +7,7 @@ function Alert(output) {
 CompilerDiagnostics.debug = !1, CompilerDiagnostics.diagnosticWriter = null, CompilerDiagnostics.analysisPass = 0, CompilerDiagnostics.Alert = Alert, CompilerDiagnostics.debugPrint = function(s) {
     CompilerDiagnostics.debug && Alert(s);
 }, CompilerDiagnostics.assert = function(condition, s) {
-    CompilerDiagnostics.debug && (condition || Alert(s));
+    CompilerDiagnostics.debug && !condition && Alert(s);
 }, TypeScript1.NullLogger = /*#__PURE__*/ function() {
     function NullLogger() {
         _class_call_check(this, NullLogger);

crates/swc_ecma_minifier/src/compress/optimize/bools.rs

@@ -6,35 +6,6 @@ use super::Optimizer;
 
 /// Methods related to the options `bools` and `bool_as_ints`.
 impl Optimizer<'_> {
-    pub(super) fn compress_if_stmt_as_expr(&mut self, s: &mut Stmt) {
-        if !self.options.conditionals && !self.options.bools {
-            return;
-        }
-
-        let stmt = match s {
-            Stmt::If(v) => v,
-            _ => return,
-        };
-
-        if stmt.alt.is_none() {
-            if let Stmt::Expr(cons) = &mut *stmt.cons {
-                self.changed = true;
-                report_change!("conditionals: `if (foo) bar;` => `foo && bar`");
-                *s = ExprStmt {
-                    span: stmt.span,
-                    expr: BinExpr {
-                        span: stmt.test.span(),
-                        op: op!("&&"),
-                        left: stmt.test.take(),
-                        right: cons.expr.take(),
-                    }
-                    .into(),
-                }
-                .into();
-            }
-        }
-    }
-
     ///
     /// - `"undefined" == typeof value;` => `void 0 === value`
     pub(super) fn compress_typeof_undefined(&mut self, e: &mut BinExpr) {

crates/swc_ecma_minifier/src/compress/optimize/collapse_vars.rs

@@ -1,4 +1,4 @@
-use swc_common::{util::take::Take, Spanned, DUMMY_SP};
+use swc_common::{util::take::Take, DUMMY_SP};
 use swc_ecma_ast::*;
 use swc_ecma_transforms_optimization::debug_assert_valid;
 use swc_ecma_utils::StmtLike;
@@ -12,36 +12,6 @@ use crate::{compress::util::is_pure_undefined, util::ExprOptExt};
 /// Methods related to the option `if_return`. All methods are noop if
 /// `if_return` is false.
 impl Optimizer<'_> {
-    pub(super) fn merge_nested_if(&mut self, s: &mut IfStmt) {
-        if !self.options.conditionals && !self.options.bools {
-            return;
-        }
-
-        if s.alt.is_some() {
-            return;
-        }
-
-        if let Stmt::If(IfStmt {
-            test,
-            cons,
-            alt: None,
-            ..
-        }) = &mut *s.cons
-        {
-            self.changed = true;
-            report_change!("if_return: Merging nested if statements");
-
-            s.test = BinExpr {
-                span: s.test.span(),
-                op: op!("&&"),
-                left: s.test.take(),
-                right: test.take(),
-            }
-            .into();
-            s.cons = cons.take();
-        }
-    }
-
     pub(super) fn merge_if_returns(
         &mut self,
         stmts: &mut Vec<Stmt>,

crates/swc_ecma_minifier/src/compress/optimize/if_return.rs

@@ -119,30 +119,4 @@ impl Optimizer<'_> {
             _ => {}
         }
     }
-
-    ///
-    /// - `for (a(), 5; b(); c())` => `for (a(); b(); c())`
-    pub(super) fn optimize_init_of_for_stmt(&mut self, s: &mut ForStmt) {
-        if !self.options.side_effects {
-            return;
-        }
-
-        if let Some(init) = &mut s.init {
-            match init {
-                VarDeclOrExpr::VarDecl(_) => {}
-                VarDeclOrExpr::Expr(init) => {
-                    let new = self.ignore_return_value(init);
-                    if let Some(new) = new {
-                        *init = Box::new(new);
-                    } else {
-                        s.init = None;
-                        self.changed = true;
-                        report_change!(
-                            "loops: Removed side-effect-free expressions in `init` of a for stmt"
-                        );
-                    }
-                }
-            }
-        }
-    }
 }

crates/swc_ecma_minifier/src/compress/optimize/loops.rs

@@ -37,7 +37,6 @@ use crate::{
 
 mod arguments;
 mod bools;
-mod collapse_vars;
 mod conditionals;
 mod dead_code;
 mod evaluate;
@@ -526,13 +525,6 @@ impl Optimizer<'_> {
             stmts.visit_with(&mut AssertValid);
         }
 
-        self.break_assignments_in_seqs(stmts);
-
-        #[cfg(debug_assertions)]
-        {
-            stmts.visit_with(&mut AssertValid);
-        }
-
         // stmts.extend(self.append_stmts.drain(..).map(T::from));
 
         drop_invalid_stmts(stmts);
@@ -542,99 +534,6 @@ impl Optimizer<'_> {
         self.append_stmts = append_stmts;
     }
 
-    /// `a = a + 1` => `a += 1`.
-    fn compress_bin_assignment_to_left(&mut self, e: &mut AssignExpr) {
-        if e.op != op!("=") {
-            return;
-        }
-
-        // TODO: Handle pure properties.
-        let lhs = match &e.left {
-            AssignTarget::Simple(SimpleAssignTarget::Ident(i)) => i,
-            _ => return,
-        };
-
-        // If left operand of a binary expression is not same as lhs, this method has
-        // nothing to do.
-        let (op, right) = match &mut *e.right {
-            Expr::Bin(BinExpr {
-                left, op, right, ..
-            }) => match &**left {
-                Expr::Ident(r) if lhs.sym == r.sym && lhs.ctxt == r.ctxt => (op, right),
-                _ => return,
-            },
-            _ => return,
-        };
-
-        // Don't break code for old browsers.
-        match op {
-            BinaryOp::LogicalOr => return,
-            BinaryOp::LogicalAnd => return,
-            BinaryOp::Exp => return,
-            BinaryOp::NullishCoalescing => return,
-            _ => {}
-        }
-
-        let op = match op {
-            BinaryOp::In | BinaryOp::InstanceOf => return,
-
-            BinaryOp::EqEq | BinaryOp::NotEq | BinaryOp::EqEqEq | BinaryOp::NotEqEq => {
-                // TODO(kdy1): Check if this is optimizable.
-                return;
-            }
-
-            BinaryOp::Lt | BinaryOp::LtEq | BinaryOp::Gt | BinaryOp::GtEq => return,
-
-            BinaryOp::LShift => op!("<<="),
-            BinaryOp::RShift => {
-                op!(">>=")
-            }
-            BinaryOp::ZeroFillRShift => {
-                op!(">>>=")
-            }
-            BinaryOp::Add => {
-                op!("+=")
-            }
-            BinaryOp::Sub => {
-                op!("-=")
-            }
-            BinaryOp::Mul => {
-                op!("*=")
-            }
-            BinaryOp::Div => {
-                op!("/=")
-            }
-            BinaryOp::Mod => {
-                op!("%=")
-            }
-            BinaryOp::BitOr => {
-                op!("|=")
-            }
-            BinaryOp::BitXor => {
-                op!("^=")
-            }
-            BinaryOp::BitAnd => {
-                op!("&=")
-            }
-            BinaryOp::LogicalOr => {
-                op!("||=")
-            }
-            BinaryOp::LogicalAnd => {
-                op!("&&=")
-            }
-            BinaryOp::Exp => {
-                op!("**=")
-            }
-            BinaryOp::NullishCoalescing => {
-                op!("??=")
-            }
-        };
-
-        e.op = op;
-        e.right = right.take();
-        // Now we can compress it to an assignment
-    }
-
     ///
     /// - `undefined` => `void 0`
     fn compress_undefined(&mut self, e: &mut Expr) {
@@ -1578,15 +1477,8 @@ impl VisitMut for Optimizer<'_> {
                 ..self.ctx.clone()
             };
             e.left.visit_mut_with(&mut *self.with_ctx(ctx));
-
-            if is_left_access_to_arguments(&e.left) {
-                // self.ctx.can_inline_arguments = false;
-            }
         }
         e.right.visit_mut_with(self);
-
-        self.compress_bin_assignment_to_left(e);
-        self.compress_bin_assignment_to_right(e);
     }
 
     #[cfg_attr(feature = "debug", tracing::instrument(skip_all))]
@@ -1937,19 +1829,6 @@ impl VisitMut for Optimizer<'_> {
             debug_assert_valid(e);
         }
 
-        if let Expr::Bin(bin) = e {
-            let expr = self.optimize_lit_cmp(bin);
-            if let Some(expr) = expr {
-                report_change!("Optimizing: Literal comparison");
-                self.changed = true;
-                *e = expr;
-            }
-        }
-
-        if e.is_seq() {
-            debug_assert_valid(e);
-        }
-
         self.compress_cond_expr_if_similar(e);
 
         if e.is_seq() {
@@ -2194,8 +2073,6 @@ impl VisitMut for Optimizer<'_> {
         };
 
         s.body.visit_mut_with(&mut *self.with_ctx(ctx.clone()));
-
-        self.with_ctx(ctx.clone()).optimize_init_of_for_stmt(s);
     }
 
     #[cfg_attr(feature = "debug", tracing::instrument(skip_all))]
@@ -2275,8 +2152,6 @@ impl VisitMut for Optimizer<'_> {
 
         n.alt.visit_mut_with(&mut *self.with_ctx(ctx.clone()));
 
-        self.merge_nested_if(n);
-
         self.negate_if_stmt(n);
     }
 
@@ -2472,10 +2347,6 @@ impl VisitMut for Optimizer<'_> {
     fn visit_mut_seq_expr(&mut self, n: &mut SeqExpr) {
         n.visit_mut_children_with(self);
 
-        self.shift_void(n);
-
-        self.shift_assignment(n);
-
         self.merge_sequences_in_seq_expr(n);
     }
 
@@ -2707,12 +2578,6 @@ impl VisitMut for Optimizer<'_> {
         debug_assert_eq!(self.prepend_stmts.len(), prepend_len);
         debug_assert_eq!(self.append_stmts.len(), append_len);
         debug_assert_valid(s);
-
-        self.compress_if_stmt_as_expr(s);
-
-        debug_assert_eq!(self.prepend_stmts.len(), prepend_len);
-        debug_assert_eq!(self.append_stmts.len(), append_len);
-        debug_assert_valid(s);
     }
 
     #[cfg_attr(feature = "debug", tracing::instrument(skip_all))]