terser 5.16.0 → 5.16.1

package/lib/compress/index.js

@@ -56,7 +56,6 @@ import {
     AST_Catch,
     AST_Chain,
     AST_Class,
-    AST_ClassExpression,
     AST_ClassProperty,
     AST_ClassStaticBlock,
     AST_ConciseMethod,
@@ -66,7 +65,6 @@ import {
     AST_Debugger,
     AST_Default,
     AST_DefaultAssign,
-    AST_DefClass,
     AST_Definitions,
     AST_Defun,
     AST_Destructuring,
@@ -110,8 +108,6 @@ import {
     AST_Switch,
     AST_SwitchBranch,
     AST_Symbol,
-    AST_SymbolBlockDeclaration,
-    AST_SymbolCatch,
     AST_SymbolClassProperty,
     AST_SymbolDeclaration,
     AST_SymbolDefun,
@@ -121,7 +117,6 @@ import {
     AST_SymbolLet,
     AST_SymbolMethod,
     AST_SymbolRef,
-    AST_SymbolVar,
     AST_TemplateString,
     AST_This,
     AST_Toplevel,
@@ -149,10 +144,8 @@ import {
 import {
     defaults,
     HOP,
-    keep_name,
     make_node,
     makePredicate,
-    map_add,
     MAP,
     remove,
     return_false,
@@ -170,14 +163,12 @@ import {
     PRECEDENCE,
 } from "../parse.js";
 import { OutputStream } from "../output.js";
-import {
-    base54,
-    SymbolDef,
-} from "../scope.js";
+import { base54, format_mangler_options } from "../scope.js";
 import "../size.js";
 
 import "./evaluate.js";
 import "./drop-side-effect-free.js";
+import "./drop-unused.js";
 import "./reduce-vars.js";
 import {
     is_undeclared_ref,
@@ -192,7 +183,6 @@ import {
     OPTIMIZED,
     CLEAR_BETWEEN_PASSES,
     TOP,
-    WRITE_ONLY,
     UNDEFINED,
     UNUSED,
     TRUTHY,
@@ -214,7 +204,6 @@ import {
     is_empty,
     is_identifier_atom,
     is_reachable,
-    is_ref_of,
     can_be_evicted_from_block,
     as_statement_array,
     retain_top_func,
@@ -332,7 +321,9 @@ class Compressor extends TreeWalker {
         this.sequences_limit = sequences == 1 ? 800 : sequences | 0;
         this.evaluated_regexps = new Map();
         this._toplevel = undefined;
-        this.mangle_options = mangle_options;
+        this.mangle_options = mangle_options
+            ? format_mangler_options(mangle_options)
+            : mangle_options;
     }
 
     option(key) {
@@ -653,382 +644,6 @@ function opt_AST_Lambda(self, compressor) {
 }
 def_optimize(AST_Lambda, opt_AST_Lambda);
 
-const r_keep_assign = /keep_assign/;
-AST_Scope.DEFMETHOD("drop_unused", function(compressor) {
-    if (!compressor.option("unused")) return;
-    if (compressor.has_directive("use asm")) return;
-    var self = this;
-    if (self.pinned()) return;
-    var drop_funcs = !(self instanceof AST_Toplevel) || compressor.toplevel.funcs;
-    var drop_vars = !(self instanceof AST_Toplevel) || compressor.toplevel.vars;
-    const assign_as_unused = r_keep_assign.test(compressor.option("unused")) ? return_false : function(node) {
-        if (node instanceof AST_Assign
-            && !node.logical
-            && (has_flag(node, WRITE_ONLY) || node.operator == "=")
-        ) {
-            return node.left;
-        }
-        if (node instanceof AST_Unary && has_flag(node, WRITE_ONLY)) {
-            return node.expression;
-        }
-    };
-    var in_use_ids = new Map();
-    var fixed_ids = new Map();
-    if (self instanceof AST_Toplevel && compressor.top_retain) {
-        self.variables.forEach(function(def) {
-            if (compressor.top_retain(def) && !in_use_ids.has(def.id)) {
-                in_use_ids.set(def.id, def);
-            }
-        });
-    }
-    var var_defs_by_id = new Map();
-    var initializations = new Map();
-    // pass 1: find out which symbols are directly used in
-    // this scope (not in nested scopes).
-    var scope = this;
-    var tw = new TreeWalker(function(node, descend) {
-        if (node instanceof AST_Lambda && node.uses_arguments && !tw.has_directive("use strict")) {
-            node.argnames.forEach(function(argname) {
-                if (!(argname instanceof AST_SymbolDeclaration)) return;
-                var def = argname.definition();
-                if (!in_use_ids.has(def.id)) {
-                    in_use_ids.set(def.id, def);
-                }
-            });
-        }
-        if (node === self) return;
-        if (node instanceof AST_Defun || node instanceof AST_DefClass) {
-            var node_def = node.name.definition();
-            const in_export = tw.parent() instanceof AST_Export;
-            if (in_export || !drop_funcs && scope === self) {
-                if (node_def.global && !in_use_ids.has(node_def.id)) {
-                    in_use_ids.set(node_def.id, node_def);
-                }
-            }
-            if (node instanceof AST_DefClass) {
-                if (
-                    node.extends
-                    && (node.extends.has_side_effects(compressor)
-                    || node.extends.may_throw(compressor))
-                ) {
-                    node.extends.walk(tw);
-                }
-                for (const prop of node.properties) {
-                    if (
-                        prop.has_side_effects(compressor) ||
-                        prop.may_throw(compressor)
-                    ) {
-                        prop.walk(tw);
-                    }
-                }
-            }
-            map_add(initializations, node_def.id, node);
-            return true; // don't go in nested scopes
-        }
-        if (node instanceof AST_SymbolFunarg && scope === self) {
-            map_add(var_defs_by_id, node.definition().id, node);
-        }
-        if (node instanceof AST_Definitions && scope === self) {
-            const in_export = tw.parent() instanceof AST_Export;
-            node.definitions.forEach(function(def) {
-                if (def.name instanceof AST_SymbolVar) {
-                    map_add(var_defs_by_id, def.name.definition().id, def);
-                }
-                if (in_export || !drop_vars) {
-                    walk(def.name, node => {
-                        if (node instanceof AST_SymbolDeclaration) {
-                            const def = node.definition();
-                            if (
-                                (in_export || def.global)
-                                && !in_use_ids.has(def.id)
-                            ) {
-                                in_use_ids.set(def.id, def);
-                            }
-                        }
-                    });
-                }
-                if (def.value) {
-                    if (def.name instanceof AST_Destructuring) {
-                        def.walk(tw);
-                    } else {
-                        var node_def = def.name.definition();
-                        map_add(initializations, node_def.id, def.value);
-                        if (!node_def.chained && def.name.fixed_value() === def.value) {
-                            fixed_ids.set(node_def.id, def);
-                        }
-                    }
-                    if (def.value.has_side_effects(compressor)) {
-                        def.value.walk(tw);
-                    }
-                }
-            });
-            return true;
-        }
-        return scan_ref_scoped(node, descend);
-    });
-    self.walk(tw);
-    // pass 2: for every used symbol we need to walk its
-    // initialization code to figure out if it uses other
-    // symbols (that may not be in_use).
-    tw = new TreeWalker(scan_ref_scoped);
-    in_use_ids.forEach(function (def) {
-        var init = initializations.get(def.id);
-        if (init) init.forEach(function(init) {
-            init.walk(tw);
-        });
-    });
-    // pass 3: we should drop declarations not in_use
-    var tt = new TreeTransformer(
-        function before(node, descend, in_list) {
-            var parent = tt.parent();
-            if (drop_vars) {
-                const sym = assign_as_unused(node);
-                if (sym instanceof AST_SymbolRef) {
-                    var def = sym.definition();
-                    var in_use = in_use_ids.has(def.id);
-                    if (node instanceof AST_Assign) {
-                        if (!in_use || fixed_ids.has(def.id) && fixed_ids.get(def.id) !== node) {
-                            return maintain_this_binding(parent, node, node.right.transform(tt));
-                        }
-                    } else if (!in_use) return in_list ? MAP.skip : make_node(AST_Number, node, {
-                        value: 0
-                    });
-                }
-            }
-            if (scope !== self) return;
-            var def;
-            if (node.name
-                && (node instanceof AST_ClassExpression
-                    && !keep_name(compressor.option("keep_classnames"), (def = node.name.definition()).name)
-                || node instanceof AST_Function
-                    && !keep_name(compressor.option("keep_fnames"), (def = node.name.definition()).name))) {
-                // any declarations with same name will overshadow
-                // name of this anonymous function and can therefore
-                // never be used anywhere
-                if (!in_use_ids.has(def.id) || def.orig.length > 1) node.name = null;
-            }
-            if (node instanceof AST_Lambda && !(node instanceof AST_Accessor)) {
-                var trim = !compressor.option("keep_fargs");
-                for (var a = node.argnames, i = a.length; --i >= 0;) {
-                    var sym = a[i];
-                    if (sym instanceof AST_Expansion) {
-                        sym = sym.expression;
-                    }
-                    if (sym instanceof AST_DefaultAssign) {
-                        sym = sym.left;
-                    }
-                    // Do not drop destructuring arguments.
-                    // They constitute a type assertion, so dropping
-                    // them would stop that TypeError which would happen
-                    // if someone called it with an incorrectly formatted
-                    // parameter.
-                    if (!(sym instanceof AST_Destructuring) && !in_use_ids.has(sym.definition().id)) {
-                        set_flag(sym, UNUSED);
-                        if (trim) {
-                            a.pop();
-                        }
-                    } else {
-                        trim = false;
-                    }
-                }
-            }
-            if ((node instanceof AST_Defun || node instanceof AST_DefClass) && node !== self) {
-                const def = node.name.definition();
-                const keep = def.global && !drop_funcs || in_use_ids.has(def.id);
-                // Class "extends" and static blocks may have side effects
-                const has_side_effects = !keep
-                    && node instanceof AST_Class
-                    && node.has_side_effects(compressor);
-                if (!keep && !has_side_effects) {
-                    def.eliminated++;
-                    return in_list ? MAP.skip : make_node(AST_EmptyStatement, node);
-                }
-            }
-            if (node instanceof AST_Definitions && !(parent instanceof AST_ForIn && parent.init === node)) {
-                var drop_block = !(parent instanceof AST_Toplevel) && !(node instanceof AST_Var);
-                // place uninitialized names at the start
-                var body = [], head = [], tail = [];
-                // for unused names whose initialization has
-                // side effects, we can cascade the init. code
-                // into the next one, or next statement.
-                var side_effects = [];
-                node.definitions.forEach(function(def) {
-                    if (def.value) def.value = def.value.transform(tt);
-                    var is_destructure = def.name instanceof AST_Destructuring;
-                    var sym = is_destructure
-                        ? new SymbolDef(null, { name: "<destructure>" }) /* fake SymbolDef */
-                        : def.name.definition();
-                    if (drop_block && sym.global) return tail.push(def);
-                    if (!(drop_vars || drop_block)
-                        || is_destructure
-                            && (def.name.names.length
-                                || def.name.is_array
-                                || compressor.option("pure_getters") != true)
-                        || in_use_ids.has(sym.id)
-                    ) {
-                        if (def.value && fixed_ids.has(sym.id) && fixed_ids.get(sym.id) !== def) {
-                            def.value = def.value.drop_side_effect_free(compressor);
-                        }
-                        if (def.name instanceof AST_SymbolVar) {
-                            var var_defs = var_defs_by_id.get(sym.id);
-                            if (var_defs.length > 1 && (!def.value || sym.orig.indexOf(def.name) > sym.eliminated)) {
-                                if (def.value) {
-                                    var ref = make_node(AST_SymbolRef, def.name, def.name);
-                                    sym.references.push(ref);
-                                    var assign = make_node(AST_Assign, def, {
-                                        operator: "=",
-                                        logical: false,
-                                        left: ref,
-                                        right: def.value
-                                    });
-                                    if (fixed_ids.get(sym.id) === def) {
-                                        fixed_ids.set(sym.id, assign);
-                                    }
-                                    side_effects.push(assign.transform(tt));
-                                }
-                                remove(var_defs, def);
-                                sym.eliminated++;
-                                return;
-                            }
-                        }
-                        if (def.value) {
-                            if (side_effects.length > 0) {
-                                if (tail.length > 0) {
-                                    side_effects.push(def.value);
-                                    def.value = make_sequence(def.value, side_effects);
-                                } else {
-                                    body.push(make_node(AST_SimpleStatement, node, {
-                                        body: make_sequence(node, side_effects)
-                                    }));
-                                }
-                                side_effects = [];
-                            }
-                            tail.push(def);
-                        } else {
-                            head.push(def);
-                        }
-                    } else if (sym.orig[0] instanceof AST_SymbolCatch) {
-                        var value = def.value && def.value.drop_side_effect_free(compressor);
-                        if (value) side_effects.push(value);
-                        def.value = null;
-                        head.push(def);
-                    } else {
-                        var value = def.value && def.value.drop_side_effect_free(compressor);
-                        if (value) {
-                            side_effects.push(value);
-                        }
-                        sym.eliminated++;
-                    }
-                });
-                if (head.length > 0 || tail.length > 0) {
-                    node.definitions = head.concat(tail);
-                    body.push(node);
-                }
-                if (side_effects.length > 0) {
-                    body.push(make_node(AST_SimpleStatement, node, {
-                        body: make_sequence(node, side_effects)
-                    }));
-                }
-                switch (body.length) {
-                  case 0:
-                    return in_list ? MAP.skip : make_node(AST_EmptyStatement, node);
-                  case 1:
-                    return body[0];
-                  default:
-                    return in_list ? MAP.splice(body) : make_node(AST_BlockStatement, node, {
-                        body: body
-                    });
-                }
-            }
-            // certain combination of unused name + side effect leads to:
-            //    https://github.com/mishoo/UglifyJS2/issues/44
-            //    https://github.com/mishoo/UglifyJS2/issues/1830
-            //    https://github.com/mishoo/UglifyJS2/issues/1838
-            // that's an invalid AST.
-            // We fix it at this stage by moving the `var` outside the `for`.
-            if (node instanceof AST_For) {
-                descend(node, this);
-                var block;
-                if (node.init instanceof AST_BlockStatement) {
-                    block = node.init;
-                    node.init = block.body.pop();
-                    block.body.push(node);
-                }
-                if (node.init instanceof AST_SimpleStatement) {
-                    node.init = node.init.body;
-                } else if (is_empty(node.init)) {
-                    node.init = null;
-                }
-                return !block ? node : in_list ? MAP.splice(block.body) : block;
-            }
-            if (node instanceof AST_LabeledStatement
-                && node.body instanceof AST_For
-            ) {
-                descend(node, this);
-                if (node.body instanceof AST_BlockStatement) {
-                    var block = node.body;
-                    node.body = block.body.pop();
-                    block.body.push(node);
-                    return in_list ? MAP.splice(block.body) : block;
-                }
-                return node;
-            }
-            if (node instanceof AST_BlockStatement) {
-                descend(node, this);
-                if (in_list && node.body.every(can_be_evicted_from_block)) {
-                    return MAP.splice(node.body);
-                }
-                return node;
-            }
-            if (node instanceof AST_Scope) {
-                const save_scope = scope;
-                scope = node;
-                descend(node, this);
-                scope = save_scope;
-                return node;
-            }
-        }
-    );
-
-    self.transform(tt);
-
-    function scan_ref_scoped(node, descend) {
-        var node_def;
-        const sym = assign_as_unused(node);
-        if (sym instanceof AST_SymbolRef
-            && !is_ref_of(node.left, AST_SymbolBlockDeclaration)
-            && self.variables.get(sym.name) === (node_def = sym.definition())
-        ) {
-            if (node instanceof AST_Assign) {
-                node.right.walk(tw);
-                if (!node_def.chained && node.left.fixed_value() === node.right) {
-                    fixed_ids.set(node_def.id, node);
-                }
-            }
-            return true;
-        }
-        if (node instanceof AST_SymbolRef) {
-            node_def = node.definition();
-            if (!in_use_ids.has(node_def.id)) {
-                in_use_ids.set(node_def.id, node_def);
-                if (node_def.orig[0] instanceof AST_SymbolCatch) {
-                    const redef = node_def.scope.is_block_scope()
-                        && node_def.scope.get_defun_scope().variables.get(node_def.name);
-                    if (redef) in_use_ids.set(redef.id, redef);
-                }
-            }
-            return true;
-        }
-        if (node instanceof AST_Scope) {
-            var save_scope = scope;
-            scope = node;
-            descend();
-            scope = save_scope;
-            return true;
-        }
-    }
-});
-
 AST_Scope.DEFMETHOD("hoist_declarations", function(compressor) {
     var self = this;
     if (compressor.has_directive("use asm")) return self;
@@ -1173,8 +788,6 @@ AST_Scope.DEFMETHOD("hoist_properties", function(compressor) {
     var top_retain = self instanceof AST_Toplevel && compressor.top_retain || return_false;
     var defs_by_id = new Map();
     var hoister = new TreeTransformer(function(node, descend) {
-        if (node instanceof AST_Definitions
-            && hoister.parent() instanceof AST_Export) return node;
         if (node instanceof AST_VarDef) {
             const sym = node.name;
             let def;

package/lib/compress/inference.js

@@ -573,7 +573,6 @@ export function is_nullish(node, compressor) {
                 return true;
             }
             if (node instanceof AST_This && this instanceof AST_Arrow) {
-                // TODO check arguments too!
                 result = false;
                 return walk_abort;
             }
@@ -694,7 +693,7 @@ export function is_nullish(node, compressor) {
         return this.tail_node()._dot_throw(compressor);
     });
     def_may_throw_on_access(AST_SymbolRef, function(compressor) {
-        if (this.name === "arguments") return false;
+        if (this.name === "arguments" && this.scope instanceof AST_Lambda) return false;
         if (has_flag(this, UNDEFINED)) return true;
         if (!is_strict(compressor)) return false;
         if (is_undeclared_ref(this) && this.is_declared(compressor)) return false;

package/lib/compress/inline.js

@@ -57,10 +57,8 @@ import {
     AST_Expansion,
     AST_Export,
     AST_Function,
-    AST_Infinity,
     AST_IterationStatement,
     AST_Lambda,
-    AST_NaN,
     AST_Node,
     AST_Number,
     AST_Object,
@@ -81,7 +79,6 @@ import {
     AST_Undefined,
     AST_Var,
     AST_VarDef,
-    AST_With,
 
     walk,
 
@@ -95,7 +92,7 @@ import "../size.js";
 import "./evaluate.js";
 import "./drop-side-effect-free.js";
 import "./reduce-vars.js";
-import { is_undeclared_ref, is_lhs } from "./inference.js";
+import { is_lhs } from "./inference.js";
 import {
     SQUEEZED,
     INLINED,
@@ -146,21 +143,6 @@ function scope_encloses_variables_in_this_scope(scope, pulled_scope) {
 }
 
 export function inline_into_symbolref(self, compressor) {
-    if (
-        !compressor.option("ie8")
-        && is_undeclared_ref(self)
-        && !compressor.find_parent(AST_With)
-    ) {
-        switch (self.name) {
-          case "undefined":
-            return make_node(AST_Undefined, self).optimize(compressor);
-          case "NaN":
-            return make_node(AST_NaN, self).optimize(compressor);
-          case "Infinity":
-            return make_node(AST_Infinity, self).optimize(compressor);
-        }
-    }
-
     const parent = compressor.parent();
     if (compressor.option("reduce_vars") && is_lhs(self, parent) !== self) {
         const def = self.definition();

package/lib/compress/tighten-body.js

@@ -205,9 +205,10 @@ export function trim_unreachable_code(compressor, stat, target) {
 
 /** Tighten a bunch of statements together, and perform statement-level optimization. */
 export function tighten_body(statements, compressor) {
-    var in_loop, in_try;
-    var scope = compressor.find_parent(AST_Scope).get_defun_scope();
-    find_loop_scope_try();
+    const nearest_scope = compressor.find_scope();
+    const defun_scope = nearest_scope.get_defun_scope();
+    const { in_loop, in_try } = find_loop_scope_try();
+
     var CHANGED, max_iter = 10;
     do {
         CHANGED = false;
@@ -231,19 +232,20 @@ export function tighten_body(statements, compressor) {
     } while (CHANGED && max_iter-- > 0);
 
     function find_loop_scope_try() {
-        var node = compressor.self(), level = 0;
+        var node = compressor.self(), level = 0, in_loop = false, in_try = false;
         do {
             if (node instanceof AST_Catch || node instanceof AST_Finally) {
                 level++;
             } else if (node instanceof AST_IterationStatement) {
                 in_loop = true;
             } else if (node instanceof AST_Scope) {
-                scope = node;
                 break;
             } else if (node instanceof AST_Try) {
                 in_try = true;
             }
         } while (node = compressor.parent(level++));
+
+        return { in_loop, in_try };
     }
 
     // Search from right to left for assignment-like expressions:
@@ -255,7 +257,7 @@ export function tighten_body(statements, compressor) {
     // Will not attempt to collapse assignments into or past code blocks
     // which are not sequentially executed, e.g. loops and conditionals.
     function collapse(statements, compressor) {
-        if (scope.pinned())
+        if (nearest_scope.pinned() || defun_scope.pinned())
             return statements;
         var args;
         var candidates = [];
@@ -319,10 +321,11 @@ export function tighten_body(statements, compressor) {
                 stop_if_hit = parent;
             }
             // Replace variable with assignment when found
-            if (can_replace
+            if (
+                can_replace
                 && !(node instanceof AST_SymbolDeclaration)
                 && lhs.equivalent_to(node)
-                && !shadows(node.scope, lvalues)
+                && !shadows(scanner.find_scope() || nearest_scope, lvalues)
             ) {
                 if (stop_if_hit) {
                     abort = true;
@@ -527,9 +530,9 @@ export function tighten_body(statements, compressor) {
                     return true;
                 if (node instanceof AST_SymbolRef && (fn.variables.has(node.name) || redefined_within_scope(node.definition(), fn))) {
                     var s = node.definition().scope;
-                    if (s !== scope)
+                    if (s !== defun_scope)
                         while (s = s.parent_scope) {
-                            if (s === scope)
+                            if (s === defun_scope)
                                 return true;
                         }
                     return found = true;
@@ -851,7 +854,7 @@ export function tighten_body(statements, compressor) {
             while (lhs instanceof AST_PropAccess)
                 lhs = lhs.expression;
             return lhs instanceof AST_SymbolRef
-                && lhs.definition().scope === scope
+                && lhs.definition().scope.get_defun_scope() === defun_scope
                 && !(in_loop
                     && (lvalues.has(lhs.name)
                         || candidate instanceof AST_Unary
@@ -886,15 +889,11 @@ export function tighten_body(statements, compressor) {
             var def = sym.definition();
             if (def.orig.length == 1 && def.orig[0] instanceof AST_SymbolDefun)
                 return false;
-            if (def.scope.get_defun_scope() !== scope)
+            if (def.scope.get_defun_scope() !== defun_scope)
                 return true;
-            return !def.references.every((ref) => {
-                var s = ref.scope.get_defun_scope();
-                // "block" scope within AST_Catch
-                if (s.TYPE == "Scope")
-                    s = s.parent_scope;
-                return s === scope;
-            });
+            return def.references.some((ref) =>
+                ref.scope.get_defun_scope() !== defun_scope
+            );
         }
 
         function side_effects_external(node, lhs) {
@@ -910,18 +909,20 @@ export function tighten_body(statements, compressor) {
                 if (node instanceof AST_Sub)
                     return side_effects_external(node.expression, true);
                 if (node instanceof AST_SymbolRef)
-                    return node.definition().scope !== scope;
+                    return node.definition().scope.get_defun_scope() !== defun_scope;
             }
             return false;
         }
 
-        function shadows(newScope, lvalues) {
-            for (const {def} of lvalues.values()) {
-                let current = newScope;
-                while (current && current !== def.scope) {
-                    let nested_def = current.variables.get(def.name);
-                    if (nested_def && nested_def !== def) return true;
-                    current = current.parent_scope;
+        /**
+         * Will any of the pulled-in lvalues shadow a variable in newScope or parents?
+         * similar to scope_encloses_variables_in_this_scope */
+        function shadows(my_scope, lvalues) {
+            for (const { def } of lvalues.values()) {
+                const looked_up = my_scope.find_variable(def.name);
+                if (looked_up) {
+                    if (looked_up === def) continue;
+                    return true;
                 }
             }
             return false;
@@ -1343,7 +1344,7 @@ export function tighten_body(statements, compressor) {
                 break;
             if (def.name.name != sym.name)
                 break;
-            if (!node.right.is_constant_expression(scope))
+            if (!node.right.is_constant_expression(nearest_scope))
                 break;
             var prop = node.left.property;
             if (prop instanceof AST_Node) {