376 lines
13 KiB
JavaScript
376 lines
13 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_Accessor,
|
|
AST_Array,
|
|
AST_Arrow,
|
|
AST_Assign,
|
|
AST_Binary,
|
|
AST_Call,
|
|
AST_Chain,
|
|
AST_Class,
|
|
AST_ClassStaticBlock,
|
|
AST_ClassProperty,
|
|
AST_ConciseMethod,
|
|
AST_Conditional,
|
|
AST_Constant,
|
|
AST_DefClass,
|
|
AST_Dot,
|
|
AST_Expansion,
|
|
AST_Function,
|
|
AST_Node,
|
|
AST_Number,
|
|
AST_Object,
|
|
AST_ObjectGetter,
|
|
AST_ObjectKeyVal,
|
|
AST_ObjectProperty,
|
|
AST_ObjectSetter,
|
|
AST_PropAccess,
|
|
AST_Scope,
|
|
AST_Sequence,
|
|
AST_SimpleStatement,
|
|
AST_Sub,
|
|
AST_SymbolRef,
|
|
AST_TemplateSegment,
|
|
AST_TemplateString,
|
|
AST_This,
|
|
AST_Unary,
|
|
} from "../ast.js";
|
|
import { make_node, return_null, return_this } from "../utils/index.js";
|
|
import { first_in_statement } from "../utils/first_in_statement.js";
|
|
|
|
import { pure_prop_access_globals } from "./native-objects.js";
|
|
import { lazy_op, unary_side_effects, is_nullish_shortcircuited } from "./inference.js";
|
|
import { WRITE_ONLY, set_flag, clear_flag } from "./compressor-flags.js";
|
|
import { make_sequence, is_func_expr, is_iife_call } from "./common.js";
|
|
|
|
// AST_Node#drop_side_effect_free() gets called when we don't care about the value,
|
|
// only about side effects. We'll be defining this method for each node type in this module
|
|
//
|
|
// Examples:
|
|
// foo++ -> foo++
|
|
// 1 + func() -> func()
|
|
// 10 -> (nothing)
|
|
// knownPureFunc(foo++) -> foo++
|
|
|
|
function def_drop_side_effect_free(node, func) {
|
|
node.DEFMETHOD("drop_side_effect_free", func);
|
|
}
|
|
|
|
// Drop side-effect-free elements from an array of expressions.
|
|
// Returns an array of expressions with side-effects or null
|
|
// if all elements were dropped. Note: original array may be
|
|
// returned if nothing changed.
|
|
function trim(nodes, compressor, first_in_statement) {
|
|
var len = nodes.length;
|
|
if (!len) return null;
|
|
|
|
var ret = [], changed = false;
|
|
for (var i = 0; i < len; i++) {
|
|
var node = nodes[i].drop_side_effect_free(compressor, first_in_statement);
|
|
changed |= node !== nodes[i];
|
|
if (node) {
|
|
ret.push(node);
|
|
first_in_statement = false;
|
|
}
|
|
}
|
|
return changed ? ret.length ? ret : null : nodes;
|
|
}
|
|
|
|
def_drop_side_effect_free(AST_Node, return_this);
|
|
def_drop_side_effect_free(AST_Constant, return_null);
|
|
def_drop_side_effect_free(AST_This, return_null);
|
|
|
|
def_drop_side_effect_free(AST_Call, function (compressor, first_in_statement) {
|
|
if (is_nullish_shortcircuited(this, compressor)) {
|
|
return this.expression.drop_side_effect_free(compressor, first_in_statement);
|
|
}
|
|
|
|
if (!this.is_callee_pure(compressor)) {
|
|
if (this.expression.is_call_pure(compressor)) {
|
|
var exprs = this.args.slice();
|
|
exprs.unshift(this.expression.expression);
|
|
exprs = trim(exprs, compressor, first_in_statement);
|
|
return exprs && make_sequence(this, exprs);
|
|
}
|
|
if (is_func_expr(this.expression)
|
|
&& (!this.expression.name || !this.expression.name.definition().references.length)) {
|
|
var node = this.clone();
|
|
node.expression.process_expression(false, compressor);
|
|
return node;
|
|
}
|
|
return this;
|
|
}
|
|
|
|
var args = trim(this.args, compressor, first_in_statement);
|
|
return args && make_sequence(this, args);
|
|
});
|
|
|
|
def_drop_side_effect_free(AST_Accessor, return_null);
|
|
|
|
def_drop_side_effect_free(AST_Function, return_null);
|
|
|
|
def_drop_side_effect_free(AST_Arrow, return_null);
|
|
|
|
def_drop_side_effect_free(AST_Class, function (compressor) {
|
|
const with_effects = [];
|
|
|
|
if (this.is_self_referential() && this.has_side_effects(compressor)) {
|
|
return this;
|
|
}
|
|
|
|
const trimmed_extends = this.extends && this.extends.drop_side_effect_free(compressor);
|
|
if (trimmed_extends) with_effects.push(trimmed_extends);
|
|
|
|
for (const prop of this.properties) {
|
|
if (prop instanceof AST_ClassStaticBlock) {
|
|
if (prop.has_side_effects(compressor)) {
|
|
return this; // Be cautious about these
|
|
}
|
|
} else {
|
|
const trimmed_prop = prop.drop_side_effect_free(compressor);
|
|
if (trimmed_prop) with_effects.push(trimmed_prop);
|
|
}
|
|
}
|
|
|
|
if (!with_effects.length)
|
|
return null;
|
|
|
|
const exprs = make_sequence(this, with_effects);
|
|
if (this instanceof AST_DefClass) {
|
|
// We want a statement
|
|
return make_node(AST_SimpleStatement, this, { body: exprs });
|
|
} else {
|
|
return exprs;
|
|
}
|
|
});
|
|
|
|
def_drop_side_effect_free(AST_ClassProperty, function (compressor) {
|
|
const key = this.computed_key() && this.key.drop_side_effect_free(compressor);
|
|
|
|
const value = this.static && this.value
|
|
&& this.value.drop_side_effect_free(compressor);
|
|
|
|
if (key && value)
|
|
return make_sequence(this, [key, value]);
|
|
return key || value || null;
|
|
});
|
|
|
|
def_drop_side_effect_free(AST_Binary, function (compressor, first_in_statement) {
|
|
var right = this.right.drop_side_effect_free(compressor);
|
|
if (!right)
|
|
return this.left.drop_side_effect_free(compressor, first_in_statement);
|
|
if (lazy_op.has(this.operator)) {
|
|
if (right === this.right)
|
|
return this;
|
|
var node = this.clone();
|
|
node.right = right;
|
|
return node;
|
|
} else {
|
|
var left = this.left.drop_side_effect_free(compressor, first_in_statement);
|
|
if (!left)
|
|
return this.right.drop_side_effect_free(compressor, first_in_statement);
|
|
return make_sequence(this, [left, right]);
|
|
}
|
|
});
|
|
|
|
def_drop_side_effect_free(AST_Assign, function (compressor) {
|
|
if (this.logical)
|
|
return this;
|
|
|
|
var left = this.left;
|
|
if (left.has_side_effects(compressor)
|
|
|| compressor.has_directive("use strict")
|
|
&& left instanceof AST_PropAccess
|
|
&& left.expression.is_constant()) {
|
|
return this;
|
|
}
|
|
set_flag(this, WRITE_ONLY);
|
|
while (left instanceof AST_PropAccess) {
|
|
left = left.expression;
|
|
}
|
|
if (left.is_constant_expression(compressor.find_parent(AST_Scope))) {
|
|
return this.right.drop_side_effect_free(compressor);
|
|
}
|
|
return this;
|
|
});
|
|
|
|
def_drop_side_effect_free(AST_Conditional, function (compressor) {
|
|
var consequent = this.consequent.drop_side_effect_free(compressor);
|
|
var alternative = this.alternative.drop_side_effect_free(compressor);
|
|
if (consequent === this.consequent && alternative === this.alternative)
|
|
return this;
|
|
if (!consequent)
|
|
return alternative ? make_node(AST_Binary, this, {
|
|
operator: "||",
|
|
left: this.condition,
|
|
right: alternative
|
|
}) : this.condition.drop_side_effect_free(compressor);
|
|
if (!alternative)
|
|
return make_node(AST_Binary, this, {
|
|
operator: "&&",
|
|
left: this.condition,
|
|
right: consequent
|
|
});
|
|
var node = this.clone();
|
|
node.consequent = consequent;
|
|
node.alternative = alternative;
|
|
return node;
|
|
});
|
|
|
|
def_drop_side_effect_free(AST_Unary, function (compressor, first_in_statement) {
|
|
if (unary_side_effects.has(this.operator)) {
|
|
if (!this.expression.has_side_effects(compressor)) {
|
|
set_flag(this, WRITE_ONLY);
|
|
} else {
|
|
clear_flag(this, WRITE_ONLY);
|
|
}
|
|
return this;
|
|
}
|
|
if (this.operator == "typeof" && this.expression instanceof AST_SymbolRef)
|
|
return null;
|
|
var expression = this.expression.drop_side_effect_free(compressor, first_in_statement);
|
|
if (first_in_statement && expression && is_iife_call(expression)) {
|
|
if (expression === this.expression && this.operator == "!")
|
|
return this;
|
|
return expression.negate(compressor, first_in_statement);
|
|
}
|
|
return expression;
|
|
});
|
|
|
|
def_drop_side_effect_free(AST_SymbolRef, function (compressor) {
|
|
const safe_access = this.is_declared(compressor)
|
|
|| pure_prop_access_globals.has(this.name);
|
|
return safe_access ? null : this;
|
|
});
|
|
|
|
def_drop_side_effect_free(AST_Object, function (compressor, first_in_statement) {
|
|
var values = trim(this.properties, compressor, first_in_statement);
|
|
return values && make_sequence(this, values);
|
|
});
|
|
|
|
def_drop_side_effect_free(AST_ObjectProperty, function (compressor, first_in_statement) {
|
|
const computed_key = this instanceof AST_ObjectKeyVal && this.key instanceof AST_Node;
|
|
const key = computed_key && this.key.drop_side_effect_free(compressor, first_in_statement);
|
|
const value = this.value && this.value.drop_side_effect_free(compressor, first_in_statement);
|
|
if (key && value) {
|
|
return make_sequence(this, [key, value]);
|
|
}
|
|
return key || value;
|
|
});
|
|
|
|
def_drop_side_effect_free(AST_ConciseMethod, function () {
|
|
return this.computed_key() ? this.key : null;
|
|
});
|
|
|
|
def_drop_side_effect_free(AST_ObjectGetter, function () {
|
|
return this.computed_key() ? this.key : null;
|
|
});
|
|
|
|
def_drop_side_effect_free(AST_ObjectSetter, function () {
|
|
return this.computed_key() ? this.key : null;
|
|
});
|
|
|
|
def_drop_side_effect_free(AST_Array, function (compressor, first_in_statement) {
|
|
var values = trim(this.elements, compressor, first_in_statement);
|
|
return values && make_sequence(this, values);
|
|
});
|
|
|
|
def_drop_side_effect_free(AST_Dot, function (compressor, first_in_statement) {
|
|
if (is_nullish_shortcircuited(this, compressor)) {
|
|
return this.expression.drop_side_effect_free(compressor, first_in_statement);
|
|
}
|
|
if (!this.optional && this.expression.may_throw_on_access(compressor)) {
|
|
return this;
|
|
}
|
|
|
|
return this.expression.drop_side_effect_free(compressor, first_in_statement);
|
|
});
|
|
|
|
def_drop_side_effect_free(AST_Sub, function (compressor, first_in_statement) {
|
|
if (is_nullish_shortcircuited(this, compressor)) {
|
|
return this.expression.drop_side_effect_free(compressor, first_in_statement);
|
|
}
|
|
if (!this.optional && this.expression.may_throw_on_access(compressor)) {
|
|
return this;
|
|
}
|
|
|
|
var property = this.property.drop_side_effect_free(compressor);
|
|
if (property && this.optional) return this;
|
|
|
|
var expression = this.expression.drop_side_effect_free(compressor, first_in_statement);
|
|
|
|
if (expression && property) return make_sequence(this, [expression, property]);
|
|
return expression || property;
|
|
});
|
|
|
|
def_drop_side_effect_free(AST_Chain, function (compressor, first_in_statement) {
|
|
return this.expression.drop_side_effect_free(compressor, first_in_statement);
|
|
});
|
|
|
|
def_drop_side_effect_free(AST_Sequence, function (compressor) {
|
|
var last = this.tail_node();
|
|
var expr = last.drop_side_effect_free(compressor);
|
|
if (expr === last)
|
|
return this;
|
|
var expressions = this.expressions.slice(0, -1);
|
|
if (expr)
|
|
expressions.push(expr);
|
|
if (!expressions.length) {
|
|
return make_node(AST_Number, this, { value: 0 });
|
|
}
|
|
return make_sequence(this, expressions);
|
|
});
|
|
|
|
def_drop_side_effect_free(AST_Expansion, function (compressor, first_in_statement) {
|
|
return this.expression.drop_side_effect_free(compressor, first_in_statement);
|
|
});
|
|
|
|
def_drop_side_effect_free(AST_TemplateSegment, return_null);
|
|
|
|
def_drop_side_effect_free(AST_TemplateString, function (compressor) {
|
|
var values = trim(this.segments, compressor, first_in_statement);
|
|
return values && make_sequence(this, values);
|
|
});
|