1517 lines
59 KiB
JavaScript
1517 lines
59 KiB
JavaScript
/***********************************************************************
|
|
|
|
A JavaScript tokenizer / parser / beautifier / compressor.
|
|
https://github.com/mishoo/UglifyJS2
|
|
|
|
-------------------------------- (C) ---------------------------------
|
|
|
|
Author: Mihai Bazon
|
|
<mihai.bazon@gmail.com>
|
|
http://mihai.bazon.net/blog
|
|
|
|
Distributed under the BSD license:
|
|
|
|
Copyright 2012 (c) Mihai Bazon <mihai.bazon@gmail.com>
|
|
|
|
Redistribution and use in source and binary forms, with or without
|
|
modification, are permitted provided that the following conditions
|
|
are met:
|
|
|
|
* Redistributions of source code must retain the above
|
|
copyright notice, this list of conditions and the following
|
|
disclaimer.
|
|
|
|
* Redistributions in binary form must reproduce the above
|
|
copyright notice, this list of conditions and the following
|
|
disclaimer in the documentation and/or other materials
|
|
provided with the distribution.
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER “AS IS” AND ANY
|
|
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
|
PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE
|
|
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
|
|
OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
|
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
|
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
|
|
TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
|
|
THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
SUCH DAMAGE.
|
|
|
|
***********************************************************************/
|
|
|
|
import {
|
|
AST_Array,
|
|
AST_Arrow,
|
|
AST_Assign,
|
|
AST_Await,
|
|
AST_Binary,
|
|
AST_Block,
|
|
AST_BlockStatement,
|
|
AST_Break,
|
|
AST_Call,
|
|
AST_Case,
|
|
AST_Chain,
|
|
AST_Class,
|
|
AST_Conditional,
|
|
AST_Const,
|
|
AST_Constant,
|
|
AST_Continue,
|
|
AST_Debugger,
|
|
AST_Default,
|
|
AST_Definitions,
|
|
AST_Defun,
|
|
AST_Destructuring,
|
|
AST_Directive,
|
|
AST_Dot,
|
|
AST_DWLoop,
|
|
AST_EmptyStatement,
|
|
AST_Exit,
|
|
AST_Expansion,
|
|
AST_Export,
|
|
AST_For,
|
|
AST_ForIn,
|
|
AST_If,
|
|
AST_Import,
|
|
AST_IterationStatement,
|
|
AST_Lambda,
|
|
AST_Let,
|
|
AST_LoopControl,
|
|
AST_Node,
|
|
AST_Number,
|
|
AST_Object,
|
|
AST_ObjectKeyVal,
|
|
AST_ObjectProperty,
|
|
AST_PropAccess,
|
|
AST_RegExp,
|
|
AST_Return,
|
|
AST_Scope,
|
|
AST_Sequence,
|
|
AST_SimpleStatement,
|
|
AST_Sub,
|
|
AST_Switch,
|
|
AST_Symbol,
|
|
AST_SymbolConst,
|
|
AST_SymbolDeclaration,
|
|
AST_SymbolDefun,
|
|
AST_SymbolFunarg,
|
|
AST_SymbolLambda,
|
|
AST_SymbolLet,
|
|
AST_SymbolRef,
|
|
AST_SymbolVar,
|
|
AST_This,
|
|
AST_Try,
|
|
AST_TryBlock,
|
|
AST_Unary,
|
|
AST_UnaryPostfix,
|
|
AST_UnaryPrefix,
|
|
AST_Undefined,
|
|
AST_Var,
|
|
AST_VarDef,
|
|
AST_With,
|
|
AST_Yield,
|
|
|
|
TreeTransformer,
|
|
TreeWalker,
|
|
walk,
|
|
walk_abort,
|
|
|
|
_NOINLINE,
|
|
} from "../ast.js";
|
|
import {
|
|
make_node,
|
|
MAP,
|
|
member,
|
|
remove,
|
|
has_annotation
|
|
} from "../utils/index.js";
|
|
|
|
import { pure_prop_access_globals } from "./native-objects.js";
|
|
import {
|
|
lazy_op,
|
|
unary_side_effects,
|
|
is_modified,
|
|
is_lhs,
|
|
aborts
|
|
} from "./inference.js";
|
|
import { WRITE_ONLY, clear_flag } from "./compressor-flags.js";
|
|
import {
|
|
make_sequence,
|
|
merge_sequence,
|
|
maintain_this_binding,
|
|
is_func_expr,
|
|
is_identifier_atom,
|
|
is_ref_of,
|
|
can_be_evicted_from_block,
|
|
as_statement_array,
|
|
} from "./common.js";
|
|
|
|
function loop_body(x) {
|
|
if (x instanceof AST_IterationStatement) {
|
|
return x.body instanceof AST_BlockStatement ? x.body : x;
|
|
}
|
|
return x;
|
|
}
|
|
|
|
function is_lhs_read_only(lhs) {
|
|
if (lhs instanceof AST_This) return true;
|
|
if (lhs instanceof AST_SymbolRef) return lhs.definition().orig[0] instanceof AST_SymbolLambda;
|
|
if (lhs instanceof AST_PropAccess) {
|
|
lhs = lhs.expression;
|
|
if (lhs instanceof AST_SymbolRef) {
|
|
if (lhs.is_immutable()) return false;
|
|
lhs = lhs.fixed_value();
|
|
}
|
|
if (!lhs) return true;
|
|
if (lhs instanceof AST_RegExp) return false;
|
|
if (lhs instanceof AST_Constant) return true;
|
|
return is_lhs_read_only(lhs);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/** var a = 1 --> var a*/
|
|
function remove_initializers(var_statement) {
|
|
var decls = [];
|
|
var_statement.definitions.forEach(function(def) {
|
|
if (def.name instanceof AST_SymbolDeclaration) {
|
|
def.value = null;
|
|
decls.push(def);
|
|
} else {
|
|
def.declarations_as_names().forEach(name => {
|
|
decls.push(make_node(AST_VarDef, def, {
|
|
name,
|
|
value: null
|
|
}));
|
|
});
|
|
}
|
|
});
|
|
return decls.length ? make_node(AST_Var, var_statement, { definitions: decls }) : null;
|
|
}
|
|
|
|
/** Called on code which we know is unreachable, to keep elements that affect outside of it. */
|
|
export function trim_unreachable_code(compressor, stat, target) {
|
|
walk(stat, node => {
|
|
if (node instanceof AST_Var) {
|
|
const no_initializers = remove_initializers(node);
|
|
if (no_initializers) target.push(no_initializers);
|
|
return true;
|
|
}
|
|
if (
|
|
node instanceof AST_Defun
|
|
&& (node === stat || !compressor.has_directive("use strict"))
|
|
) {
|
|
target.push(node === stat ? node : make_node(AST_Var, node, {
|
|
definitions: [
|
|
make_node(AST_VarDef, node, {
|
|
name: make_node(AST_SymbolVar, node.name, node.name),
|
|
value: null
|
|
})
|
|
]
|
|
}));
|
|
return true;
|
|
}
|
|
if (node instanceof AST_Export || node instanceof AST_Import) {
|
|
target.push(node);
|
|
return true;
|
|
}
|
|
if (node instanceof AST_Scope) {
|
|
return true;
|
|
}
|
|
});
|
|
}
|
|
|
|
/** Tighten a bunch of statements together, and perform statement-level optimization. */
|
|
export function tighten_body(statements, compressor) {
|
|
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;
|
|
eliminate_spurious_blocks(statements);
|
|
if (compressor.option("dead_code")) {
|
|
eliminate_dead_code(statements, compressor);
|
|
}
|
|
if (compressor.option("if_return")) {
|
|
handle_if_return(statements, compressor);
|
|
}
|
|
if (compressor.sequences_limit > 0) {
|
|
sequencesize(statements, compressor);
|
|
sequencesize_2(statements, compressor);
|
|
}
|
|
if (compressor.option("join_vars")) {
|
|
join_consecutive_vars(statements);
|
|
}
|
|
if (compressor.option("collapse_vars")) {
|
|
collapse(statements, compressor);
|
|
}
|
|
} while (CHANGED && max_iter-- > 0);
|
|
|
|
function find_loop_scope_try() {
|
|
var node = compressor.self(), level = 0, in_loop = false, in_try = false;
|
|
do {
|
|
if (node instanceof AST_IterationStatement) {
|
|
in_loop = true;
|
|
} else if (node instanceof AST_Scope) {
|
|
break;
|
|
} else if (node instanceof AST_TryBlock) {
|
|
in_try = true;
|
|
}
|
|
} while (node = compressor.parent(level++));
|
|
|
|
return { in_loop, in_try };
|
|
}
|
|
|
|
// Search from right to left for assignment-like expressions:
|
|
// - `var a = x;`
|
|
// - `a = x;`
|
|
// - `++a`
|
|
// For each candidate, scan from left to right for first usage, then try
|
|
// to fold assignment into the site for compression.
|
|
// 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 (nearest_scope.pinned() || defun_scope.pinned())
|
|
return statements;
|
|
var args;
|
|
var candidates = [];
|
|
var stat_index = statements.length;
|
|
var scanner = new TreeTransformer(function (node) {
|
|
if (abort)
|
|
return node;
|
|
// Skip nodes before `candidate` as quickly as possible
|
|
if (!hit) {
|
|
if (node !== hit_stack[hit_index])
|
|
return node;
|
|
hit_index++;
|
|
if (hit_index < hit_stack.length)
|
|
return handle_custom_scan_order(node);
|
|
hit = true;
|
|
stop_after = find_stop(node, 0);
|
|
if (stop_after === node)
|
|
abort = true;
|
|
return node;
|
|
}
|
|
// Stop immediately if these node types are encountered
|
|
var parent = scanner.parent();
|
|
if (node instanceof AST_Assign
|
|
&& (node.logical || node.operator != "=" && lhs.equivalent_to(node.left))
|
|
|| node instanceof AST_Await
|
|
|| node instanceof AST_Call && lhs instanceof AST_PropAccess && lhs.equivalent_to(node.expression)
|
|
||
|
|
(node instanceof AST_Call || node instanceof AST_PropAccess)
|
|
&& node.optional
|
|
|| node instanceof AST_Debugger
|
|
|| node instanceof AST_Destructuring
|
|
|| node instanceof AST_Expansion
|
|
&& node.expression instanceof AST_Symbol
|
|
&& (
|
|
node.expression instanceof AST_This
|
|
|| node.expression.definition().references.length > 1
|
|
)
|
|
|| node instanceof AST_IterationStatement && !(node instanceof AST_For)
|
|
|| node instanceof AST_LoopControl
|
|
|| node instanceof AST_Try
|
|
|| node instanceof AST_With
|
|
|| node instanceof AST_Yield
|
|
|| node instanceof AST_Export
|
|
|| node instanceof AST_Class
|
|
|| parent instanceof AST_For && node !== parent.init
|
|
|| !replace_all
|
|
&& (
|
|
node instanceof AST_SymbolRef
|
|
&& !node.is_declared(compressor)
|
|
&& !pure_prop_access_globals.has(node)
|
|
)
|
|
|| node instanceof AST_SymbolRef
|
|
&& parent instanceof AST_Call
|
|
&& has_annotation(parent, _NOINLINE)
|
|
|| node instanceof AST_ObjectProperty && node.key instanceof AST_Node
|
|
) {
|
|
abort = true;
|
|
return node;
|
|
}
|
|
// Stop only if candidate is found within conditional branches
|
|
if (!stop_if_hit && (!lhs_local || !replace_all)
|
|
&& (parent instanceof AST_Binary && lazy_op.has(parent.operator) && parent.left !== node
|
|
|| parent instanceof AST_Conditional && parent.condition !== node
|
|
|| parent instanceof AST_If && parent.condition !== node)) {
|
|
stop_if_hit = parent;
|
|
}
|
|
// Replace variable with assignment when found
|
|
if (
|
|
can_replace
|
|
&& !(node instanceof AST_SymbolDeclaration)
|
|
&& lhs.equivalent_to(node)
|
|
&& !shadows(scanner.find_scope() || nearest_scope, lvalues)
|
|
) {
|
|
if (stop_if_hit) {
|
|
abort = true;
|
|
return node;
|
|
}
|
|
if (is_lhs(node, parent)) {
|
|
if (value_def)
|
|
replaced++;
|
|
return node;
|
|
} else {
|
|
replaced++;
|
|
if (value_def && candidate instanceof AST_VarDef)
|
|
return node;
|
|
}
|
|
CHANGED = abort = true;
|
|
if (candidate instanceof AST_UnaryPostfix) {
|
|
return make_node(AST_UnaryPrefix, candidate, candidate);
|
|
}
|
|
if (candidate instanceof AST_VarDef) {
|
|
var def = candidate.name.definition();
|
|
var value = candidate.value;
|
|
if (def.references.length - def.replaced == 1 && !compressor.exposed(def)) {
|
|
def.replaced++;
|
|
if (funarg && is_identifier_atom(value)) {
|
|
return value.transform(compressor);
|
|
} else {
|
|
return maintain_this_binding(parent, node, value);
|
|
}
|
|
}
|
|
return make_node(AST_Assign, candidate, {
|
|
operator: "=",
|
|
logical: false,
|
|
left: make_node(AST_SymbolRef, candidate.name, candidate.name),
|
|
right: value
|
|
});
|
|
}
|
|
clear_flag(candidate, WRITE_ONLY);
|
|
return candidate;
|
|
}
|
|
// These node types have child nodes that execute sequentially,
|
|
// but are otherwise not safe to scan into or beyond them.
|
|
var sym;
|
|
if (node instanceof AST_Call
|
|
|| node instanceof AST_Exit
|
|
&& (side_effects || lhs instanceof AST_PropAccess || may_modify(lhs))
|
|
|| node instanceof AST_PropAccess
|
|
&& (side_effects || node.expression.may_throw_on_access(compressor))
|
|
|| node instanceof AST_SymbolRef
|
|
&& ((lvalues.has(node.name) && lvalues.get(node.name).modified) || side_effects && may_modify(node))
|
|
|| node instanceof AST_VarDef && node.value
|
|
&& (lvalues.has(node.name.name) || side_effects && may_modify(node.name))
|
|
|| (sym = is_lhs(node.left, node))
|
|
&& (sym instanceof AST_PropAccess || lvalues.has(sym.name))
|
|
|| may_throw
|
|
&& (in_try ? node.has_side_effects(compressor) : side_effects_external(node))) {
|
|
stop_after = node;
|
|
if (node instanceof AST_Scope)
|
|
abort = true;
|
|
}
|
|
return handle_custom_scan_order(node);
|
|
}, function (node) {
|
|
if (abort)
|
|
return;
|
|
if (stop_after === node)
|
|
abort = true;
|
|
if (stop_if_hit === node)
|
|
stop_if_hit = null;
|
|
});
|
|
|
|
var multi_replacer = new TreeTransformer(function (node) {
|
|
if (abort)
|
|
return node;
|
|
// Skip nodes before `candidate` as quickly as possible
|
|
if (!hit) {
|
|
if (node !== hit_stack[hit_index])
|
|
return node;
|
|
hit_index++;
|
|
if (hit_index < hit_stack.length)
|
|
return;
|
|
hit = true;
|
|
return node;
|
|
}
|
|
// Replace variable when found
|
|
if (node instanceof AST_SymbolRef
|
|
&& node.name == def.name) {
|
|
if (!--replaced)
|
|
abort = true;
|
|
if (is_lhs(node, multi_replacer.parent()))
|
|
return node;
|
|
def.replaced++;
|
|
value_def.replaced--;
|
|
return candidate.value;
|
|
}
|
|
// Skip (non-executed) functions and (leading) default case in switch statements
|
|
if (node instanceof AST_Default || node instanceof AST_Scope)
|
|
return node;
|
|
});
|
|
|
|
while (--stat_index >= 0) {
|
|
// Treat parameters as collapsible in IIFE, i.e.
|
|
// function(a, b){ ... }(x());
|
|
// would be translated into equivalent assignments:
|
|
// var a = x(), b = undefined;
|
|
if (stat_index == 0 && compressor.option("unused"))
|
|
extract_args();
|
|
// Find collapsible assignments
|
|
var hit_stack = [];
|
|
extract_candidates(statements[stat_index]);
|
|
while (candidates.length > 0) {
|
|
hit_stack = candidates.pop();
|
|
var hit_index = 0;
|
|
var candidate = hit_stack[hit_stack.length - 1];
|
|
var value_def = null;
|
|
var stop_after = null;
|
|
var stop_if_hit = null;
|
|
var lhs = get_lhs(candidate);
|
|
if (!lhs || is_lhs_read_only(lhs) || lhs.has_side_effects(compressor))
|
|
continue;
|
|
// Locate symbols which may execute code outside of scanning range
|
|
var lvalues = get_lvalues(candidate);
|
|
var lhs_local = is_lhs_local(lhs);
|
|
if (lhs instanceof AST_SymbolRef) {
|
|
lvalues.set(lhs.name, { def: lhs.definition(), modified: false });
|
|
}
|
|
var side_effects = value_has_side_effects(candidate);
|
|
var replace_all = replace_all_symbols();
|
|
var may_throw = candidate.may_throw(compressor);
|
|
var funarg = candidate.name instanceof AST_SymbolFunarg;
|
|
var hit = funarg;
|
|
var abort = false, replaced = 0, can_replace = !args || !hit;
|
|
if (!can_replace) {
|
|
for (
|
|
let j = compressor.self().argnames.lastIndexOf(candidate.name) + 1;
|
|
!abort && j < args.length;
|
|
j++
|
|
) {
|
|
args[j].transform(scanner);
|
|
}
|
|
can_replace = true;
|
|
}
|
|
for (var i = stat_index; !abort && i < statements.length; i++) {
|
|
statements[i].transform(scanner);
|
|
}
|
|
if (value_def) {
|
|
var def = candidate.name.definition();
|
|
if (abort && def.references.length - def.replaced > replaced)
|
|
replaced = false;
|
|
else {
|
|
abort = false;
|
|
hit_index = 0;
|
|
hit = funarg;
|
|
for (var i = stat_index; !abort && i < statements.length; i++) {
|
|
statements[i].transform(multi_replacer);
|
|
}
|
|
value_def.single_use = false;
|
|
}
|
|
}
|
|
if (replaced && !remove_candidate(candidate))
|
|
statements.splice(stat_index, 1);
|
|
}
|
|
}
|
|
|
|
function handle_custom_scan_order(node) {
|
|
// Skip (non-executed) functions
|
|
if (node instanceof AST_Scope)
|
|
return node;
|
|
|
|
// Scan case expressions first in a switch statement
|
|
if (node instanceof AST_Switch) {
|
|
node.expression = node.expression.transform(scanner);
|
|
for (var i = 0, len = node.body.length; !abort && i < len; i++) {
|
|
var branch = node.body[i];
|
|
if (branch instanceof AST_Case) {
|
|
if (!hit) {
|
|
if (branch !== hit_stack[hit_index])
|
|
continue;
|
|
hit_index++;
|
|
}
|
|
branch.expression = branch.expression.transform(scanner);
|
|
if (!replace_all)
|
|
break;
|
|
}
|
|
}
|
|
abort = true;
|
|
return node;
|
|
}
|
|
}
|
|
|
|
function redefined_within_scope(def, scope) {
|
|
if (def.global)
|
|
return false;
|
|
let cur_scope = def.scope;
|
|
while (cur_scope && cur_scope !== scope) {
|
|
if (cur_scope.variables.has(def.name)) {
|
|
return true;
|
|
}
|
|
cur_scope = cur_scope.parent_scope;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
function has_overlapping_symbol(fn, arg, fn_strict) {
|
|
var found = false, scan_this = !(fn instanceof AST_Arrow);
|
|
arg.walk(new TreeWalker(function (node, descend) {
|
|
if (found)
|
|
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 !== defun_scope)
|
|
while (s = s.parent_scope) {
|
|
if (s === defun_scope)
|
|
return true;
|
|
}
|
|
return found = true;
|
|
}
|
|
if ((fn_strict || scan_this) && node instanceof AST_This) {
|
|
return found = true;
|
|
}
|
|
if (node instanceof AST_Scope && !(node instanceof AST_Arrow)) {
|
|
var prev = scan_this;
|
|
scan_this = false;
|
|
descend();
|
|
scan_this = prev;
|
|
return true;
|
|
}
|
|
}));
|
|
return found;
|
|
}
|
|
|
|
function arg_is_injectable(arg) {
|
|
if (arg instanceof AST_Expansion) return false;
|
|
const contains_await = walk(arg, (node) => {
|
|
if (node instanceof AST_Await) return walk_abort;
|
|
});
|
|
if (contains_await) return false;
|
|
return true;
|
|
}
|
|
function extract_args() {
|
|
var iife, fn = compressor.self();
|
|
if (is_func_expr(fn)
|
|
&& !fn.name
|
|
&& !fn.uses_arguments
|
|
&& !fn.pinned()
|
|
&& (iife = compressor.parent()) instanceof AST_Call
|
|
&& iife.expression === fn
|
|
&& iife.args.every(arg_is_injectable)
|
|
) {
|
|
var fn_strict = compressor.has_directive("use strict");
|
|
if (fn_strict && !member(fn_strict, fn.body))
|
|
fn_strict = false;
|
|
var len = fn.argnames.length;
|
|
args = iife.args.slice(len);
|
|
var names = new Set();
|
|
for (var i = len; --i >= 0;) {
|
|
var sym = fn.argnames[i];
|
|
var arg = iife.args[i];
|
|
// The following two line fix is a duplicate of the fix at
|
|
// https://github.com/terser/terser/commit/011d3eb08cefe6922c7d1bdfa113fc4aeaca1b75
|
|
// This might mean that these two pieces of code (one here in collapse_vars and another in reduce_vars
|
|
// Might be doing the exact same thing.
|
|
const def = sym.definition && sym.definition();
|
|
const is_reassigned = def && def.orig.length > 1;
|
|
if (is_reassigned)
|
|
continue;
|
|
args.unshift(make_node(AST_VarDef, sym, {
|
|
name: sym,
|
|
value: arg
|
|
}));
|
|
if (names.has(sym.name))
|
|
continue;
|
|
names.add(sym.name);
|
|
if (sym instanceof AST_Expansion) {
|
|
var elements = iife.args.slice(i);
|
|
if (elements.every((arg) => !has_overlapping_symbol(fn, arg, fn_strict)
|
|
)) {
|
|
candidates.unshift([make_node(AST_VarDef, sym, {
|
|
name: sym.expression,
|
|
value: make_node(AST_Array, iife, {
|
|
elements: elements
|
|
})
|
|
})]);
|
|
}
|
|
} else {
|
|
if (!arg) {
|
|
arg = make_node(AST_Undefined, sym).transform(compressor);
|
|
} else if (arg instanceof AST_Lambda && arg.pinned()
|
|
|| has_overlapping_symbol(fn, arg, fn_strict)) {
|
|
arg = null;
|
|
}
|
|
if (arg)
|
|
candidates.unshift([make_node(AST_VarDef, sym, {
|
|
name: sym,
|
|
value: arg
|
|
})]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
function extract_candidates(expr) {
|
|
hit_stack.push(expr);
|
|
if (expr instanceof AST_Assign) {
|
|
if (!expr.left.has_side_effects(compressor)
|
|
&& !(expr.right instanceof AST_Chain)) {
|
|
candidates.push(hit_stack.slice());
|
|
}
|
|
extract_candidates(expr.right);
|
|
} else if (expr instanceof AST_Binary) {
|
|
extract_candidates(expr.left);
|
|
extract_candidates(expr.right);
|
|
} else if (expr instanceof AST_Call && !has_annotation(expr, _NOINLINE)) {
|
|
extract_candidates(expr.expression);
|
|
expr.args.forEach(extract_candidates);
|
|
} else if (expr instanceof AST_Case) {
|
|
extract_candidates(expr.expression);
|
|
} else if (expr instanceof AST_Conditional) {
|
|
extract_candidates(expr.condition);
|
|
extract_candidates(expr.consequent);
|
|
extract_candidates(expr.alternative);
|
|
} else if (expr instanceof AST_Definitions) {
|
|
var len = expr.definitions.length;
|
|
// limit number of trailing variable definitions for consideration
|
|
var i = len - 200;
|
|
if (i < 0)
|
|
i = 0;
|
|
for (; i < len; i++) {
|
|
extract_candidates(expr.definitions[i]);
|
|
}
|
|
} else if (expr instanceof AST_DWLoop) {
|
|
extract_candidates(expr.condition);
|
|
if (!(expr.body instanceof AST_Block)) {
|
|
extract_candidates(expr.body);
|
|
}
|
|
} else if (expr instanceof AST_Exit) {
|
|
if (expr.value)
|
|
extract_candidates(expr.value);
|
|
} else if (expr instanceof AST_For) {
|
|
if (expr.init)
|
|
extract_candidates(expr.init);
|
|
if (expr.condition)
|
|
extract_candidates(expr.condition);
|
|
if (expr.step)
|
|
extract_candidates(expr.step);
|
|
if (!(expr.body instanceof AST_Block)) {
|
|
extract_candidates(expr.body);
|
|
}
|
|
} else if (expr instanceof AST_ForIn) {
|
|
extract_candidates(expr.object);
|
|
if (!(expr.body instanceof AST_Block)) {
|
|
extract_candidates(expr.body);
|
|
}
|
|
} else if (expr instanceof AST_If) {
|
|
extract_candidates(expr.condition);
|
|
if (!(expr.body instanceof AST_Block)) {
|
|
extract_candidates(expr.body);
|
|
}
|
|
if (expr.alternative && !(expr.alternative instanceof AST_Block)) {
|
|
extract_candidates(expr.alternative);
|
|
}
|
|
} else if (expr instanceof AST_Sequence) {
|
|
expr.expressions.forEach(extract_candidates);
|
|
} else if (expr instanceof AST_SimpleStatement) {
|
|
extract_candidates(expr.body);
|
|
} else if (expr instanceof AST_Switch) {
|
|
extract_candidates(expr.expression);
|
|
expr.body.forEach(extract_candidates);
|
|
} else if (expr instanceof AST_Unary) {
|
|
if (expr.operator == "++" || expr.operator == "--") {
|
|
candidates.push(hit_stack.slice());
|
|
}
|
|
} else if (expr instanceof AST_VarDef) {
|
|
if (expr.value && !(expr.value instanceof AST_Chain)) {
|
|
candidates.push(hit_stack.slice());
|
|
extract_candidates(expr.value);
|
|
}
|
|
}
|
|
hit_stack.pop();
|
|
}
|
|
|
|
function find_stop(node, level, write_only) {
|
|
var parent = scanner.parent(level);
|
|
if (parent instanceof AST_Assign) {
|
|
if (write_only
|
|
&& !parent.logical
|
|
&& !(parent.left instanceof AST_PropAccess
|
|
|| lvalues.has(parent.left.name))) {
|
|
return find_stop(parent, level + 1, write_only);
|
|
}
|
|
return node;
|
|
}
|
|
if (parent instanceof AST_Binary) {
|
|
if (write_only && (!lazy_op.has(parent.operator) || parent.left === node)) {
|
|
return find_stop(parent, level + 1, write_only);
|
|
}
|
|
return node;
|
|
}
|
|
if (parent instanceof AST_Call)
|
|
return node;
|
|
if (parent instanceof AST_Case)
|
|
return node;
|
|
if (parent instanceof AST_Conditional) {
|
|
if (write_only && parent.condition === node) {
|
|
return find_stop(parent, level + 1, write_only);
|
|
}
|
|
return node;
|
|
}
|
|
if (parent instanceof AST_Definitions) {
|
|
return find_stop(parent, level + 1, true);
|
|
}
|
|
if (parent instanceof AST_Exit) {
|
|
return write_only ? find_stop(parent, level + 1, write_only) : node;
|
|
}
|
|
if (parent instanceof AST_If) {
|
|
if (write_only && parent.condition === node) {
|
|
return find_stop(parent, level + 1, write_only);
|
|
}
|
|
return node;
|
|
}
|
|
if (parent instanceof AST_IterationStatement)
|
|
return node;
|
|
if (parent instanceof AST_Sequence) {
|
|
return find_stop(parent, level + 1, parent.tail_node() !== node);
|
|
}
|
|
if (parent instanceof AST_SimpleStatement) {
|
|
return find_stop(parent, level + 1, true);
|
|
}
|
|
if (parent instanceof AST_Switch)
|
|
return node;
|
|
if (parent instanceof AST_VarDef)
|
|
return node;
|
|
return null;
|
|
}
|
|
|
|
function mangleable_var(var_def) {
|
|
var value = var_def.value;
|
|
if (!(value instanceof AST_SymbolRef))
|
|
return;
|
|
if (value.name == "arguments")
|
|
return;
|
|
var def = value.definition();
|
|
if (def.undeclared)
|
|
return;
|
|
return value_def = def;
|
|
}
|
|
|
|
function get_lhs(expr) {
|
|
if (expr instanceof AST_Assign && expr.logical) {
|
|
return false;
|
|
} else if (expr instanceof AST_VarDef && expr.name instanceof AST_SymbolDeclaration) {
|
|
var def = expr.name.definition();
|
|
if (!member(expr.name, def.orig))
|
|
return;
|
|
var referenced = def.references.length - def.replaced;
|
|
if (!referenced)
|
|
return;
|
|
var declared = def.orig.length - def.eliminated;
|
|
if (declared > 1 && !(expr.name instanceof AST_SymbolFunarg)
|
|
|| (referenced > 1 ? mangleable_var(expr) : !compressor.exposed(def))) {
|
|
return make_node(AST_SymbolRef, expr.name, expr.name);
|
|
}
|
|
} else {
|
|
const lhs = expr instanceof AST_Assign
|
|
? expr.left
|
|
: expr.expression;
|
|
return !is_ref_of(lhs, AST_SymbolConst)
|
|
&& !is_ref_of(lhs, AST_SymbolLet) && lhs;
|
|
}
|
|
}
|
|
|
|
function get_rvalue(expr) {
|
|
if (expr instanceof AST_Assign) {
|
|
return expr.right;
|
|
} else {
|
|
return expr.value;
|
|
}
|
|
}
|
|
|
|
function get_lvalues(expr) {
|
|
var lvalues = new Map();
|
|
if (expr instanceof AST_Unary)
|
|
return lvalues;
|
|
var tw = new TreeWalker(function (node) {
|
|
var sym = node;
|
|
while (sym instanceof AST_PropAccess)
|
|
sym = sym.expression;
|
|
if (sym instanceof AST_SymbolRef) {
|
|
const prev = lvalues.get(sym.name);
|
|
if (!prev || !prev.modified) {
|
|
lvalues.set(sym.name, {
|
|
def: sym.definition(),
|
|
modified: is_modified(compressor, tw, node, node, 0)
|
|
});
|
|
}
|
|
}
|
|
});
|
|
get_rvalue(expr).walk(tw);
|
|
return lvalues;
|
|
}
|
|
|
|
function remove_candidate(expr) {
|
|
if (expr.name instanceof AST_SymbolFunarg) {
|
|
var iife = compressor.parent(), argnames = compressor.self().argnames;
|
|
var index = argnames.indexOf(expr.name);
|
|
if (index < 0) {
|
|
iife.args.length = Math.min(iife.args.length, argnames.length - 1);
|
|
} else {
|
|
var args = iife.args;
|
|
if (args[index])
|
|
args[index] = make_node(AST_Number, args[index], {
|
|
value: 0
|
|
});
|
|
}
|
|
return true;
|
|
}
|
|
var found = false;
|
|
return statements[stat_index].transform(new TreeTransformer(function (node, descend, in_list) {
|
|
if (found)
|
|
return node;
|
|
if (node === expr || node.body === expr) {
|
|
found = true;
|
|
if (node instanceof AST_VarDef) {
|
|
node.value = node.name instanceof AST_SymbolConst
|
|
? make_node(AST_Undefined, node.value) // `const` always needs value.
|
|
: null;
|
|
return node;
|
|
}
|
|
return in_list ? MAP.skip : null;
|
|
}
|
|
}, function (node) {
|
|
if (node instanceof AST_Sequence)
|
|
switch (node.expressions.length) {
|
|
case 0: return null;
|
|
case 1: return node.expressions[0];
|
|
}
|
|
}));
|
|
}
|
|
|
|
function is_lhs_local(lhs) {
|
|
while (lhs instanceof AST_PropAccess)
|
|
lhs = lhs.expression;
|
|
return lhs instanceof AST_SymbolRef
|
|
&& lhs.definition().scope.get_defun_scope() === defun_scope
|
|
&& !(in_loop
|
|
&& (lvalues.has(lhs.name)
|
|
|| candidate instanceof AST_Unary
|
|
|| (candidate instanceof AST_Assign
|
|
&& !candidate.logical
|
|
&& candidate.operator != "=")));
|
|
}
|
|
|
|
function value_has_side_effects(expr) {
|
|
if (expr instanceof AST_Unary)
|
|
return unary_side_effects.has(expr.operator);
|
|
return get_rvalue(expr).has_side_effects(compressor);
|
|
}
|
|
|
|
function replace_all_symbols() {
|
|
if (side_effects)
|
|
return false;
|
|
if (value_def)
|
|
return true;
|
|
if (lhs instanceof AST_SymbolRef) {
|
|
var def = lhs.definition();
|
|
if (def.references.length - def.replaced == (candidate instanceof AST_VarDef ? 1 : 2)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
function may_modify(sym) {
|
|
if (!sym.definition)
|
|
return true; // AST_Destructuring
|
|
var def = sym.definition();
|
|
if (def.orig.length == 1 && def.orig[0] instanceof AST_SymbolDefun)
|
|
return false;
|
|
if (def.scope.get_defun_scope() !== defun_scope)
|
|
return true;
|
|
return def.references.some((ref) =>
|
|
ref.scope.get_defun_scope() !== defun_scope
|
|
);
|
|
}
|
|
|
|
function side_effects_external(node, lhs) {
|
|
if (node instanceof AST_Assign)
|
|
return side_effects_external(node.left, true);
|
|
if (node instanceof AST_Unary)
|
|
return side_effects_external(node.expression, true);
|
|
if (node instanceof AST_VarDef)
|
|
return node.value && side_effects_external(node.value);
|
|
if (lhs) {
|
|
if (node instanceof AST_Dot)
|
|
return side_effects_external(node.expression, true);
|
|
if (node instanceof AST_Sub)
|
|
return side_effects_external(node.expression, true);
|
|
if (node instanceof AST_SymbolRef)
|
|
return node.definition().scope.get_defun_scope() !== defun_scope;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* 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;
|
|
}
|
|
}
|
|
|
|
function eliminate_spurious_blocks(statements) {
|
|
var seen_dirs = [];
|
|
for (var i = 0; i < statements.length;) {
|
|
var stat = statements[i];
|
|
if (stat instanceof AST_BlockStatement && stat.body.every(can_be_evicted_from_block)) {
|
|
CHANGED = true;
|
|
eliminate_spurious_blocks(stat.body);
|
|
statements.splice(i, 1, ...stat.body);
|
|
i += stat.body.length;
|
|
} else if (stat instanceof AST_EmptyStatement) {
|
|
CHANGED = true;
|
|
statements.splice(i, 1);
|
|
} else if (stat instanceof AST_Directive) {
|
|
if (seen_dirs.indexOf(stat.value) < 0) {
|
|
i++;
|
|
seen_dirs.push(stat.value);
|
|
} else {
|
|
CHANGED = true;
|
|
statements.splice(i, 1);
|
|
}
|
|
} else
|
|
i++;
|
|
}
|
|
}
|
|
|
|
function handle_if_return(statements, compressor) {
|
|
var self = compressor.self();
|
|
var multiple_if_returns = has_multiple_if_returns(statements);
|
|
var in_lambda = self instanceof AST_Lambda;
|
|
// Prevent extremely deep nesting
|
|
// https://github.com/terser/terser/issues/1432
|
|
// https://github.com/webpack/webpack/issues/17548
|
|
const iteration_start = Math.min(statements.length, 500);
|
|
for (var i = iteration_start; --i >= 0;) {
|
|
var stat = statements[i];
|
|
var j = next_index(i);
|
|
var next = statements[j];
|
|
|
|
if (in_lambda && !next && stat instanceof AST_Return) {
|
|
if (!stat.value) {
|
|
CHANGED = true;
|
|
statements.splice(i, 1);
|
|
continue;
|
|
}
|
|
if (stat.value instanceof AST_UnaryPrefix && stat.value.operator == "void") {
|
|
CHANGED = true;
|
|
statements[i] = make_node(AST_SimpleStatement, stat, {
|
|
body: stat.value.expression
|
|
});
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if (stat instanceof AST_If) {
|
|
let ab, new_else;
|
|
|
|
ab = aborts(stat.body);
|
|
if (
|
|
can_merge_flow(ab)
|
|
&& (new_else = as_statement_array_with_return(stat.body, ab))
|
|
) {
|
|
if (ab.label) {
|
|
remove(ab.label.thedef.references, ab);
|
|
}
|
|
CHANGED = true;
|
|
stat = stat.clone();
|
|
stat.condition = stat.condition.negate(compressor);
|
|
stat.body = make_node(AST_BlockStatement, stat, {
|
|
body: as_statement_array(stat.alternative).concat(extract_functions())
|
|
});
|
|
stat.alternative = make_node(AST_BlockStatement, stat, {
|
|
body: new_else
|
|
});
|
|
statements[i] = stat.transform(compressor);
|
|
continue;
|
|
}
|
|
|
|
ab = aborts(stat.alternative);
|
|
if (
|
|
can_merge_flow(ab)
|
|
&& (new_else = as_statement_array_with_return(stat.alternative, ab))
|
|
) {
|
|
if (ab.label) {
|
|
remove(ab.label.thedef.references, ab);
|
|
}
|
|
CHANGED = true;
|
|
stat = stat.clone();
|
|
stat.body = make_node(AST_BlockStatement, stat.body, {
|
|
body: as_statement_array(stat.body).concat(extract_functions())
|
|
});
|
|
stat.alternative = make_node(AST_BlockStatement, stat.alternative, {
|
|
body: new_else
|
|
});
|
|
statements[i] = stat.transform(compressor);
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if (stat instanceof AST_If && stat.body instanceof AST_Return) {
|
|
var value = stat.body.value;
|
|
//---
|
|
// pretty silly case, but:
|
|
// if (foo()) return; return; ==> foo(); return;
|
|
if (!value && !stat.alternative
|
|
&& (in_lambda && !next || next instanceof AST_Return && !next.value)) {
|
|
CHANGED = true;
|
|
statements[i] = make_node(AST_SimpleStatement, stat.condition, {
|
|
body: stat.condition
|
|
});
|
|
continue;
|
|
}
|
|
//---
|
|
// if (foo()) return x; return y; ==> return foo() ? x : y;
|
|
if (value && !stat.alternative && next instanceof AST_Return && next.value) {
|
|
CHANGED = true;
|
|
stat = stat.clone();
|
|
stat.alternative = next;
|
|
statements[i] = stat.transform(compressor);
|
|
statements.splice(j, 1);
|
|
continue;
|
|
}
|
|
//---
|
|
// if (foo()) return x; [ return ; ] ==> return foo() ? x : undefined;
|
|
if (value && !stat.alternative
|
|
&& (!next && in_lambda && multiple_if_returns
|
|
|| next instanceof AST_Return)) {
|
|
CHANGED = true;
|
|
stat = stat.clone();
|
|
stat.alternative = next || make_node(AST_Return, stat, {
|
|
value: null
|
|
});
|
|
statements[i] = stat.transform(compressor);
|
|
if (next)
|
|
statements.splice(j, 1);
|
|
continue;
|
|
}
|
|
//---
|
|
// if (a) return b; if (c) return d; e; ==> return a ? b : c ? d : void e;
|
|
//
|
|
// if sequences is not enabled, this can lead to an endless loop (issue #866).
|
|
// however, with sequences on this helps producing slightly better output for
|
|
// the example code.
|
|
var prev = statements[prev_index(i)];
|
|
if (compressor.option("sequences") && in_lambda && !stat.alternative
|
|
&& prev instanceof AST_If && prev.body instanceof AST_Return
|
|
&& next_index(j) == statements.length && next instanceof AST_SimpleStatement) {
|
|
CHANGED = true;
|
|
stat = stat.clone();
|
|
stat.alternative = make_node(AST_BlockStatement, next, {
|
|
body: [
|
|
next,
|
|
make_node(AST_Return, next, {
|
|
value: null
|
|
})
|
|
]
|
|
});
|
|
statements[i] = stat.transform(compressor);
|
|
statements.splice(j, 1);
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
function has_multiple_if_returns(statements) {
|
|
var n = 0;
|
|
for (var i = statements.length; --i >= 0;) {
|
|
var stat = statements[i];
|
|
if (stat instanceof AST_If && stat.body instanceof AST_Return) {
|
|
if (++n > 1)
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
function is_return_void(value) {
|
|
return !value || value instanceof AST_UnaryPrefix && value.operator == "void";
|
|
}
|
|
|
|
function can_merge_flow(ab) {
|
|
if (!ab)
|
|
return false;
|
|
for (var j = i + 1, len = statements.length; j < len; j++) {
|
|
var stat = statements[j];
|
|
if (stat instanceof AST_Const || stat instanceof AST_Let)
|
|
return false;
|
|
}
|
|
var lct = ab instanceof AST_LoopControl ? compressor.loopcontrol_target(ab) : null;
|
|
return ab instanceof AST_Return && in_lambda && is_return_void(ab.value)
|
|
|| ab instanceof AST_Continue && self === loop_body(lct)
|
|
|| ab instanceof AST_Break && lct instanceof AST_BlockStatement && self === lct;
|
|
}
|
|
|
|
function extract_functions() {
|
|
var tail = statements.slice(i + 1);
|
|
statements.length = i + 1;
|
|
return tail.filter(function (stat) {
|
|
if (stat instanceof AST_Defun) {
|
|
statements.push(stat);
|
|
return false;
|
|
}
|
|
return true;
|
|
});
|
|
}
|
|
|
|
function as_statement_array_with_return(node, ab) {
|
|
var body = as_statement_array(node);
|
|
if (ab !== body[body.length - 1]) {
|
|
return undefined;
|
|
}
|
|
body = body.slice(0, -1);
|
|
if (ab.value) {
|
|
body.push(make_node(AST_SimpleStatement, ab.value, {
|
|
body: ab.value.expression
|
|
}));
|
|
}
|
|
return body;
|
|
}
|
|
|
|
function next_index(i) {
|
|
for (var j = i + 1, len = statements.length; j < len; j++) {
|
|
var stat = statements[j];
|
|
if (!(stat instanceof AST_Var && declarations_only(stat))) {
|
|
break;
|
|
}
|
|
}
|
|
return j;
|
|
}
|
|
|
|
function prev_index(i) {
|
|
for (var j = i; --j >= 0;) {
|
|
var stat = statements[j];
|
|
if (!(stat instanceof AST_Var && declarations_only(stat))) {
|
|
break;
|
|
}
|
|
}
|
|
return j;
|
|
}
|
|
}
|
|
|
|
function eliminate_dead_code(statements, compressor) {
|
|
var has_quit;
|
|
var self = compressor.self();
|
|
for (var i = 0, n = 0, len = statements.length; i < len; i++) {
|
|
var stat = statements[i];
|
|
if (stat instanceof AST_LoopControl) {
|
|
var lct = compressor.loopcontrol_target(stat);
|
|
if (stat instanceof AST_Break
|
|
&& !(lct instanceof AST_IterationStatement)
|
|
&& loop_body(lct) === self
|
|
|| stat instanceof AST_Continue
|
|
&& loop_body(lct) === self) {
|
|
if (stat.label) {
|
|
remove(stat.label.thedef.references, stat);
|
|
}
|
|
} else {
|
|
statements[n++] = stat;
|
|
}
|
|
} else {
|
|
statements[n++] = stat;
|
|
}
|
|
if (aborts(stat)) {
|
|
has_quit = statements.slice(i + 1);
|
|
break;
|
|
}
|
|
}
|
|
statements.length = n;
|
|
CHANGED = n != len;
|
|
if (has_quit)
|
|
has_quit.forEach(function (stat) {
|
|
trim_unreachable_code(compressor, stat, statements);
|
|
});
|
|
}
|
|
|
|
function declarations_only(node) {
|
|
return node.definitions.every((var_def) => !var_def.value);
|
|
}
|
|
|
|
function sequencesize(statements, compressor) {
|
|
if (statements.length < 2)
|
|
return;
|
|
var seq = [], n = 0;
|
|
function push_seq() {
|
|
if (!seq.length)
|
|
return;
|
|
var body = make_sequence(seq[0], seq);
|
|
statements[n++] = make_node(AST_SimpleStatement, body, { body: body });
|
|
seq = [];
|
|
}
|
|
for (var i = 0, len = statements.length; i < len; i++) {
|
|
var stat = statements[i];
|
|
if (stat instanceof AST_SimpleStatement) {
|
|
if (seq.length >= compressor.sequences_limit)
|
|
push_seq();
|
|
var body = stat.body;
|
|
if (seq.length > 0)
|
|
body = body.drop_side_effect_free(compressor);
|
|
if (body)
|
|
merge_sequence(seq, body);
|
|
} else if (stat instanceof AST_Definitions && declarations_only(stat)
|
|
|| stat instanceof AST_Defun) {
|
|
statements[n++] = stat;
|
|
} else {
|
|
push_seq();
|
|
statements[n++] = stat;
|
|
}
|
|
}
|
|
push_seq();
|
|
statements.length = n;
|
|
if (n != len)
|
|
CHANGED = true;
|
|
}
|
|
|
|
function to_simple_statement(block, decls) {
|
|
if (!(block instanceof AST_BlockStatement))
|
|
return block;
|
|
var stat = null;
|
|
for (var i = 0, len = block.body.length; i < len; i++) {
|
|
var line = block.body[i];
|
|
if (line instanceof AST_Var && declarations_only(line)) {
|
|
decls.push(line);
|
|
} else if (stat || line instanceof AST_Const || line instanceof AST_Let) {
|
|
return false;
|
|
} else {
|
|
stat = line;
|
|
}
|
|
}
|
|
return stat;
|
|
}
|
|
|
|
function sequencesize_2(statements, compressor) {
|
|
function cons_seq(right) {
|
|
n--;
|
|
CHANGED = true;
|
|
var left = prev.body;
|
|
return make_sequence(left, [left, right]).transform(compressor);
|
|
}
|
|
var n = 0, prev;
|
|
for (var i = 0; i < statements.length; i++) {
|
|
var stat = statements[i];
|
|
if (prev) {
|
|
if (stat instanceof AST_Exit) {
|
|
stat.value = cons_seq(stat.value || make_node(AST_Undefined, stat).transform(compressor));
|
|
} else if (stat instanceof AST_For) {
|
|
if (!(stat.init instanceof AST_Definitions)) {
|
|
const abort = walk(prev.body, node => {
|
|
if (node instanceof AST_Scope)
|
|
return true;
|
|
if (node instanceof AST_Binary
|
|
&& node.operator === "in") {
|
|
return walk_abort;
|
|
}
|
|
});
|
|
if (!abort) {
|
|
if (stat.init)
|
|
stat.init = cons_seq(stat.init);
|
|
else {
|
|
stat.init = prev.body;
|
|
n--;
|
|
CHANGED = true;
|
|
}
|
|
}
|
|
}
|
|
} else if (stat instanceof AST_ForIn) {
|
|
if (!(stat.init instanceof AST_Const) && !(stat.init instanceof AST_Let)) {
|
|
stat.object = cons_seq(stat.object);
|
|
}
|
|
} else if (stat instanceof AST_If) {
|
|
stat.condition = cons_seq(stat.condition);
|
|
} else if (stat instanceof AST_Switch) {
|
|
stat.expression = cons_seq(stat.expression);
|
|
} else if (stat instanceof AST_With) {
|
|
stat.expression = cons_seq(stat.expression);
|
|
}
|
|
}
|
|
if (compressor.option("conditionals") && stat instanceof AST_If) {
|
|
var decls = [];
|
|
var body = to_simple_statement(stat.body, decls);
|
|
var alt = to_simple_statement(stat.alternative, decls);
|
|
if (body !== false && alt !== false && decls.length > 0) {
|
|
var len = decls.length;
|
|
decls.push(make_node(AST_If, stat, {
|
|
condition: stat.condition,
|
|
body: body || make_node(AST_EmptyStatement, stat.body),
|
|
alternative: alt
|
|
}));
|
|
decls.unshift(n, 1);
|
|
[].splice.apply(statements, decls);
|
|
i += len;
|
|
n += len + 1;
|
|
prev = null;
|
|
CHANGED = true;
|
|
continue;
|
|
}
|
|
}
|
|
statements[n++] = stat;
|
|
prev = stat instanceof AST_SimpleStatement ? stat : null;
|
|
}
|
|
statements.length = n;
|
|
}
|
|
|
|
function join_object_assignments(defn, body) {
|
|
if (!(defn instanceof AST_Definitions))
|
|
return;
|
|
var def = defn.definitions[defn.definitions.length - 1];
|
|
if (!(def.value instanceof AST_Object))
|
|
return;
|
|
var exprs;
|
|
if (body instanceof AST_Assign && !body.logical) {
|
|
exprs = [body];
|
|
} else if (body instanceof AST_Sequence) {
|
|
exprs = body.expressions.slice();
|
|
}
|
|
if (!exprs)
|
|
return;
|
|
var trimmed = false;
|
|
do {
|
|
var node = exprs[0];
|
|
if (!(node instanceof AST_Assign))
|
|
break;
|
|
if (node.operator != "=")
|
|
break;
|
|
if (!(node.left instanceof AST_PropAccess))
|
|
break;
|
|
var sym = node.left.expression;
|
|
if (!(sym instanceof AST_SymbolRef))
|
|
break;
|
|
if (def.name.name != sym.name)
|
|
break;
|
|
if (!node.right.is_constant_expression(nearest_scope))
|
|
break;
|
|
var prop = node.left.property;
|
|
if (prop instanceof AST_Node) {
|
|
prop = prop.evaluate(compressor);
|
|
}
|
|
if (prop instanceof AST_Node)
|
|
break;
|
|
prop = "" + prop;
|
|
var diff = compressor.option("ecma") < 2015
|
|
&& compressor.has_directive("use strict") ? function (node) {
|
|
return node.key != prop && (node.key && node.key.name != prop);
|
|
} : function (node) {
|
|
return node.key && node.key.name != prop;
|
|
};
|
|
if (!def.value.properties.every(diff))
|
|
break;
|
|
var p = def.value.properties.filter(function (p) { return p.key === prop; })[0];
|
|
if (!p) {
|
|
def.value.properties.push(make_node(AST_ObjectKeyVal, node, {
|
|
key: prop,
|
|
value: node.right
|
|
}));
|
|
} else {
|
|
p.value = new AST_Sequence({
|
|
start: p.start,
|
|
expressions: [p.value.clone(), node.right.clone()],
|
|
end: p.end
|
|
});
|
|
}
|
|
exprs.shift();
|
|
trimmed = true;
|
|
} while (exprs.length);
|
|
return trimmed && exprs;
|
|
}
|
|
|
|
function join_consecutive_vars(statements) {
|
|
var defs;
|
|
for (var i = 0, j = -1, len = statements.length; i < len; i++) {
|
|
var stat = statements[i];
|
|
var prev = statements[j];
|
|
if (stat instanceof AST_Definitions) {
|
|
if (prev && prev.TYPE == stat.TYPE) {
|
|
prev.definitions = prev.definitions.concat(stat.definitions);
|
|
CHANGED = true;
|
|
} else if (defs && defs.TYPE == stat.TYPE && declarations_only(stat)) {
|
|
defs.definitions = defs.definitions.concat(stat.definitions);
|
|
CHANGED = true;
|
|
} else {
|
|
statements[++j] = stat;
|
|
defs = stat;
|
|
}
|
|
} else if (stat instanceof AST_Exit) {
|
|
stat.value = extract_object_assignments(stat.value);
|
|
} else if (stat instanceof AST_For) {
|
|
var exprs = join_object_assignments(prev, stat.init);
|
|
if (exprs) {
|
|
CHANGED = true;
|
|
stat.init = exprs.length ? make_sequence(stat.init, exprs) : null;
|
|
statements[++j] = stat;
|
|
} else if (
|
|
prev instanceof AST_Var
|
|
&& (!stat.init || stat.init.TYPE == prev.TYPE)
|
|
) {
|
|
if (stat.init) {
|
|
prev.definitions = prev.definitions.concat(stat.init.definitions);
|
|
}
|
|
stat.init = prev;
|
|
statements[j] = stat;
|
|
CHANGED = true;
|
|
} else if (
|
|
defs instanceof AST_Var
|
|
&& stat.init instanceof AST_Var
|
|
&& declarations_only(stat.init)
|
|
) {
|
|
defs.definitions = defs.definitions.concat(stat.init.definitions);
|
|
stat.init = null;
|
|
statements[++j] = stat;
|
|
CHANGED = true;
|
|
} else {
|
|
statements[++j] = stat;
|
|
}
|
|
} else if (stat instanceof AST_ForIn) {
|
|
stat.object = extract_object_assignments(stat.object);
|
|
} else if (stat instanceof AST_If) {
|
|
stat.condition = extract_object_assignments(stat.condition);
|
|
} else if (stat instanceof AST_SimpleStatement) {
|
|
var exprs = join_object_assignments(prev, stat.body);
|
|
if (exprs) {
|
|
CHANGED = true;
|
|
if (!exprs.length)
|
|
continue;
|
|
stat.body = make_sequence(stat.body, exprs);
|
|
}
|
|
statements[++j] = stat;
|
|
} else if (stat instanceof AST_Switch) {
|
|
stat.expression = extract_object_assignments(stat.expression);
|
|
} else if (stat instanceof AST_With) {
|
|
stat.expression = extract_object_assignments(stat.expression);
|
|
} else {
|
|
statements[++j] = stat;
|
|
}
|
|
}
|
|
statements.length = j + 1;
|
|
|
|
function extract_object_assignments(value) {
|
|
statements[++j] = stat;
|
|
var exprs = join_object_assignments(prev, value);
|
|
if (exprs) {
|
|
CHANGED = true;
|
|
if (exprs.length) {
|
|
return make_sequence(value, exprs);
|
|
} else if (value instanceof AST_Sequence) {
|
|
return value.tail_node().left;
|
|
} else {
|
|
return value.left;
|
|
}
|
|
}
|
|
return value;
|
|
}
|
|
}
|
|
}
|