fix(es/minifier): Fix performance issues & bugs

ecmascript/minifier/Cargo.toml

@@ -13,11 +13,13 @@ version = "0.16.1"
 debug = []
 
 [dependencies]
+ahash = "0.7.4"
 fxhash = "0.2.1"
 indexmap = "1.7.0"
 log = "0.4"
 once_cell = "1.5.2"
 pretty_assertions = {version = "0.6.1", optional = true}
+rayon = "1.5.1"
 regex = "1.5.3"
 retain_mut = "0.1.2"
 serde = {version = "1.0.118", features = ["derive"]}

ecmascript/minifier/scripts/project-ref.sh

@@ -9,14 +9,20 @@ run() {
 mkdir -p ./tests/projects/refs
 
 run angular-1.2.5.js
+run antd-4.16.9.js
 run backbone-1.1.0.js
+run echarts-5.1.2.js
 run jquery-1.9.1.js
 run jquery.mobile-1.4.2.js
+run lodash-4.17.71.js
+run moment-2.29.1.js
 run mootools-1.4.5.js
-run underscore-1.5.2.js
-run yui-3.12.0.js
 run react-17.0.2.js
 run react-dom-17.0.2.js
+run three-0.124.0.js
+run underscore-1.5.2.js
+run vue-2.6.12.js
+run yui-3.12.0.js
 
 prettier --write tests/projects/refs/
 yarn run eslint --fix ./tests/projects/refs/

ecmascript/minifier/src/analyzer/mod.rs

@@ -1,16 +1,14 @@
 use self::ctx::Ctx;
 use crate::util::can_end_conditionally;
-use crate::util::idents_used_by;
 use crate::util::now;
-use fxhash::FxHashMap;
-use fxhash::FxHashSet;
+use crate::util::FastHashMap;
+use crate::util::FastHashSet;
 use std::collections::hash_map::Entry;
 use std::time::Instant;
 use swc_atoms::JsWord;
 use swc_common::SyntaxContext;
 use swc_common::DUMMY_SP;
 use swc_ecma_ast::*;
-use swc_ecma_utils::find_ids;
 use swc_ecma_utils::ident::IdentLike;
 use swc_ecma_utils::Id;
 use swc_ecma_visit::noop_visit_type;
@@ -75,7 +73,7 @@ pub(crate) struct VarUsageInfo {
     pub mutated: bool,
 
     pub has_property_access: bool,
-    pub accessed_props: FxHashSet<JsWord>,
+    pub accessed_props: FastHashSet<JsWord>,
 
     pub exported: bool,
     /// True if used **above** the declaration. (Not eval order).
@@ -102,7 +100,7 @@ pub(crate) struct VarUsageInfo {
     pub no_side_effect_for_member_access: bool,
 
     /// In `c = b`, `b` inffects `c`.
-    infects: Vec<Id>,
+    infects: FastHashSet<Id>,
 }
 
 impl VarUsageInfo {
@@ -123,7 +121,7 @@ pub(crate) struct ScopeData {
     pub has_eval_call: bool,
 
     /// Variables declared in the scope.
-    pub declared_symbols: FxHashMap<JsWord, FxHashSet<SyntaxContext>>,
+    pub declared_symbols: FastHashMap<JsWord, FastHashSet<SyntaxContext>>,
 }
 
 impl ScopeData {
@@ -142,14 +140,11 @@ impl ScopeData {
 /// Analyzed info of a whole program we are working on.
 #[derive(Debug, Default)]
 pub(crate) struct ProgramData {
-    pub vars: FxHashMap<Id, VarUsageInfo>,
+    pub vars: FastHashMap<Id, VarUsageInfo>,
 
     pub top: ScopeData,
 
-    pub scopes: FxHashMap<SyntaxContext, ScopeData>,
-
-    /// { dependant: [dependendcies] }
-    var_deps: FxHashMap<Id, FxHashSet<Id>>,
+    pub scopes: FastHashMap<SyntaxContext, ScopeData>,
 }
 
 impl ProgramData {
@@ -223,12 +218,6 @@ impl ProgramData {
             }
         }
     }
-
-    /// TODO: Make this recursive
-    #[allow(unused)]
-    pub fn deps(&self, id: &Id) -> FxHashSet<Id> {
-        self.var_deps.get(id).cloned().unwrap_or_default()
-    }
 }
 
 /// This assumes there are no two variable with same name and same span hygiene.
@@ -262,7 +251,7 @@ impl UsageAnalyzer {
         ret
     }
 
-    fn report(&mut self, i: Id, is_modify: bool, dejavu: &mut FxHashSet<Id>) {
+    fn report(&mut self, i: Id, is_modify: bool, dejavu: &mut FastHashSet<Id>) {
         // log::trace!("report({}{:?})", i.0, i.1);
 
         let is_first = dejavu.is_empty();
@@ -805,22 +794,22 @@ impl Visit for UsageAnalyzer {
         for decl in &n.decls {
             match (&decl.name, decl.init.as_deref()) {
                 (Pat::Ident(var), Some(init)) => {
-                    let used_idents = idents_used_by(init);
+                    let used_idents = get_deps(init);
 
                     for id in used_idents {
                         self.data
                             .vars
                             .entry(id.clone())
                             .or_default()
                             .infects
-                            .push(var.to_id());
+                            .insert(var.to_id());
 
                         self.data
                             .vars
                             .entry(var.to_id())
                             .or_default()
                             .infects
-                            .push(id);
+                            .insert(id);
                     }
                 }
                 _ => {}
@@ -840,17 +829,6 @@ impl Visit for UsageAnalyzer {
         };
         e.name.visit_with(e, &mut *self.with_ctx(ctx));
 
-        let declared_names: Vec<Id> = find_ids(&e.name);
-        let used_names = idents_used_by(&e.init);
-
-        for name in declared_names {
-            self.data
-                .var_deps
-                .entry(name)
-                .or_default()
-                .extend(used_names.clone());
-        }
-
         e.init.visit_with(e, self);
     }
 
@@ -868,3 +846,46 @@ impl Visit for UsageAnalyzer {
         n.visit_children_with(self);
     }
 }
+
+fn get_deps<N>(n: &N) -> Vec<Id>
+where
+    N: VisitWith<DepCalculator>,
+{
+    let mut v = DepCalculator::default();
+    n.visit_with(&Invalid { span: DUMMY_SP }, &mut v);
+    v.deps
+}
+
+#[derive(Default)]
+struct DepCalculator {
+    deps: Vec<Id>,
+}
+
+impl DepCalculator {}
+
+impl Visit for DepCalculator {
+    noop_visit_type!();
+
+    fn visit_block_stmt_or_expr(&mut self, _: &BlockStmtOrExpr, _: &dyn Node) {}
+
+    fn visit_constructor(&mut self, _s: &Constructor, _: &dyn Node) {}
+
+    fn visit_function(&mut self, _: &Function, _: &dyn Node) {}
+
+    fn visit_ident(&mut self, n: &Ident, _: &dyn Node) {
+        self.deps.push(n.to_id());
+    }
+
+    fn visit_member_expr(&mut self, n: &MemberExpr, _: &dyn Node) {
+        n.obj.visit_with(n, self);
+    }
+
+    fn visit_prop_name(&mut self, n: &PropName, _: &dyn Node) {
+        match n {
+            PropName::Computed(..) => {
+                n.visit_children_with(self);
+            }
+            _ => {}
+        }
+    }
+}

ecmascript/minifier/src/compress/mod.rs

@@ -4,6 +4,7 @@ use self::optimize::optimizer;
 use crate::analyzer::analyze;
 use crate::analyzer::ProgramData;
 use crate::compress::hoist_decls::decl_hoister;
+use crate::compress::pure::pure_optimizer;
 use crate::debug::dump;
 use crate::debug::invoke;
 use crate::marks::Marks;
@@ -23,11 +24,13 @@ use swc_common::pass::CompilerPass;
 use swc_common::pass::Repeat;
 use swc_common::pass::Repeated;
 use swc_common::sync::Lrc;
+use swc_common::Globals;
 use swc_common::{chain, SourceMap};
 use swc_ecma_ast::*;
 use swc_ecma_transforms::fixer;
 use swc_ecma_transforms::optimization::simplify::dead_branch_remover;
 use swc_ecma_transforms::optimization::simplify::expr_simplifier;
+use swc_ecma_transforms::optimization::simplify::expr_simplifier_with_config;
 use swc_ecma_transforms::pass::JsPass;
 use swc_ecma_transforms_base::ext::MapWithMut;
 use swc_ecma_utils::StmtLike;
@@ -40,9 +43,12 @@ use swc_ecma_visit::VisitMutWith;
 mod drop_console;
 mod hoist_decls;
 mod optimize;
+mod pure;
+mod util;
 
 pub(crate) fn compressor<'a>(
     cm: Lrc<SourceMap>,
+    swc_globals: &'a Globals,
     marks: Marks,
     options: &'a CompressOptions,
     comments: Option<&'a dyn Comments>,
@@ -53,6 +59,7 @@ pub(crate) fn compressor<'a>(
     };
     let compressor = Compressor {
         cm,
+        swc_globals,
         marks,
         options,
         comments,
@@ -70,6 +77,7 @@ pub(crate) fn compressor<'a>(
 
 struct Compressor<'a> {
     cm: Lrc<SourceMap>,
+    swc_globals: &'a Globals,
     marks: Marks,
     options: &'a CompressOptions,
     comments: Option<&'a dyn Comments>,
@@ -134,8 +142,10 @@ impl VisitMut for Compressor<'_> {
         self.data = Some(analyze(&*n));
 
         if self.options.passes != 0 && self.options.passes + 1 <= self.pass {
-            let done = dump(&*n);
-            log::debug!("===== Done =====\n{}", done);
+            if cfg!(feature = "debug") {
+                let done = dump(&*n);
+                log::debug!("===== Done =====\n{}", done);
+            }
             return;
         }
 
@@ -144,6 +154,31 @@ impl VisitMut for Compressor<'_> {
             panic!("Infinite loop detected (current pass = {})", self.pass)
         }
 
+        {
+            // Pure optimizer uses all cpu cores, so we don't have to branch this.
+            log::info!("compress: Running pure optimizer (pass = {})", self.pass);
+
+            let start_time = now();
+            // TODO: reset_opt_flags
+            //
+            // This is swc version of `node.optimize(this);`.
+            let mut visitor = pure_optimizer(&self.swc_globals, self.marks, self.options);
+            n.visit_mut_with(&mut visitor);
+            self.changed |= visitor.changed();
+
+            if let Some(start_time) = start_time {
+                let end_time = Instant::now();
+
+                log::info!(
+                    "compress: Pure optimizer took {:?} (pass = {})",
+                    end_time - start_time,
+                    self.pass
+                );
+            }
+            // let done = dump(&*n);
+            // log::debug!("===== Result =====\n{}", done);
+        }
+
         let start = if cfg!(feature = "debug") {
             let start = dump(&n.clone().fold_with(&mut fixer(None)));
             log::debug!("===== Start =====\n{}", start);
@@ -160,7 +195,7 @@ impl VisitMut for Compressor<'_> {
 
             let start_time = now();
 
-            let mut visitor = expr_simplifier();
+            let mut visitor = expr_simplifier_with_config(false);
             n.visit_mut_with(&mut visitor);
             self.changed |= visitor.changed();
             if visitor.changed() {

ecmascript/minifier/src/compress/optimize/arguments.rs

@@ -16,6 +16,7 @@ use swc_ecma_visit::VisitMutWith;
 impl Optimizer<'_> {
     ///
     /// - `arguments['foo']` => `arguments.foo`
+
     pub(super) fn optimize_str_access_to_arguments(&mut self, e: &mut Expr) {
         if !self.options.arguments {
             return;