Merge branch 'master' into harmony-v3.1.6
This commit is contained in:
alexlamsl
@@ -649,6 +649,12 @@ If you're using the `X-SourceMap` header instead, you can just omit `sourceMap.u
|
||||
|
||||
- `hoist_funs` (default: `true`) -- hoist function declarations
|
||||
|
||||
- `hoist_props` (default: `false`) -- hoist properties from constant object and
|
||||
array literals into regular variables subject to a set of constraints. For example:
|
||||
`var o={p:1, q:2}; f(o.p, o.q);` is converted to `f(1, 2);`. Note: `hoist_props`
|
||||
works best with `mangle` enabled, the `compress` option `passes` set to `2` or higher,
|
||||
and the `compress` option `toplevel` enabled.
|
||||
|
||||
- `hoist_vars` (default: `false`) -- hoist `var` declarations (this is `false`
|
||||
by default because it seems to increase the size of the output in general)
|
||||
|
||||
|
||||
315
lib/compress.js
315
lib/compress.js
@@ -63,6 +63,7 @@ function Compressor(options, false_by_default) {
|
||||
expression : false,
|
||||
global_defs : {},
|
||||
hoist_funs : !false_by_default,
|
||||
hoist_props : false,
|
||||
hoist_vars : false,
|
||||
ie8 : false,
|
||||
if_return : !false_by_default,
|
||||
@@ -196,6 +197,7 @@ merge(Compressor.prototype, {
|
||||
if (node._squeezed) return node;
|
||||
var was_scope = false;
|
||||
if (node instanceof AST_Scope) {
|
||||
node = node.hoist_properties(this);
|
||||
node = node.hoist_declarations(this);
|
||||
was_scope = true;
|
||||
}
|
||||
@@ -318,7 +320,7 @@ merge(Compressor.prototype, {
|
||||
d.references.push(node);
|
||||
if (d.fixed === undefined || !safe_to_read(d) || d.single_use == "m") {
|
||||
d.fixed = false;
|
||||
} else {
|
||||
} else if (d.fixed) {
|
||||
var value = node.fixed_value();
|
||||
if (unused && !compressor.exposed(d)) {
|
||||
d.single_use = value
|
||||
@@ -327,20 +329,14 @@ merge(Compressor.prototype, {
|
||||
&& d.scope === node.scope
|
||||
&& value.is_constant_expression();
|
||||
}
|
||||
if (is_modified(node, 0, is_immutable(value))) {
|
||||
if (is_modified(node, value, 0, is_immutable(value))) {
|
||||
if (d.single_use) {
|
||||
d.single_use = "m";
|
||||
} else {
|
||||
d.fixed = false;
|
||||
}
|
||||
} else {
|
||||
var parent = tw.parent();
|
||||
if (parent instanceof AST_Assign && parent.operator == "=" && node === parent.right
|
||||
|| parent instanceof AST_Call && node !== parent.expression
|
||||
|| parent instanceof AST_Return && node === parent.value && node.scope !== d.scope
|
||||
|| parent instanceof AST_VarDef && node === parent.value) {
|
||||
d.escaped = true;
|
||||
}
|
||||
mark_escaped(d, node, value, 0);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -569,6 +565,7 @@ merge(Compressor.prototype, {
|
||||
}
|
||||
|
||||
function reset_def(def) {
|
||||
def.direct_access = false;
|
||||
def.escaped = false;
|
||||
if (def.scope.uses_eval) {
|
||||
def.fixed = false;
|
||||
@@ -586,18 +583,61 @@ merge(Compressor.prototype, {
|
||||
return value && (value.is_constant() || value instanceof AST_Lambda);
|
||||
}
|
||||
|
||||
function is_modified(node, level, immutable) {
|
||||
function read_property(obj, key) {
|
||||
if (key instanceof AST_Constant) key = key.getValue();
|
||||
if (key instanceof AST_Node) return null;
|
||||
var value;
|
||||
if (obj instanceof AST_Array) {
|
||||
var elements = obj.elements;
|
||||
if (key == "length") return make_node_from_constant(elements.length, obj);
|
||||
if (typeof key == "number" && key in elements) value = elements[key];
|
||||
} else if (obj instanceof AST_Object) {
|
||||
var props = obj.properties;
|
||||
for (var i = props.length; --i >= 0;) {
|
||||
var prop = props[i];
|
||||
if (!(prop instanceof AST_ObjectKeyVal)) return;
|
||||
if (!value && props[i].key === key) value = props[i].value;
|
||||
}
|
||||
}
|
||||
return value instanceof AST_SymbolRef && value.fixed_value() || value;
|
||||
}
|
||||
|
||||
function is_modified(node, value, level, immutable) {
|
||||
var parent = tw.parent(level);
|
||||
if (is_lhs(node, parent)
|
||||
|| !immutable && parent instanceof AST_Call && parent.expression === node) {
|
||||
|| !immutable
|
||||
&& parent instanceof AST_Call
|
||||
&& parent.expression === node
|
||||
&& (!(value instanceof AST_Function) || value.contains_this())) {
|
||||
return true;
|
||||
} else if (parent instanceof AST_Array || parent instanceof AST_Object) {
|
||||
return is_modified(parent, parent, level + 1);
|
||||
} else if (parent instanceof AST_PropAccess && parent.expression === node) {
|
||||
return !immutable && is_modified(parent, level + 1);
|
||||
return !immutable && is_modified(parent, read_property(value, parent.property), level + 1);
|
||||
}
|
||||
}
|
||||
|
||||
function mark_escaped(d, node, value, level) {
|
||||
var parent = tw.parent(level);
|
||||
if (value instanceof AST_Constant || value instanceof AST_Function) return;
|
||||
if (parent instanceof AST_Assign && parent.operator == "=" && node === parent.right
|
||||
|| parent instanceof AST_Call && node !== parent.expression
|
||||
|| parent instanceof AST_Return && node === parent.value && node.scope !== d.scope
|
||||
|| parent instanceof AST_VarDef && node === parent.value) {
|
||||
d.escaped = true;
|
||||
return;
|
||||
} else if (parent instanceof AST_Array || parent instanceof AST_Object) {
|
||||
mark_escaped(d, parent, parent, level + 1);
|
||||
} else if (parent instanceof AST_PropAccess && node === parent.expression) {
|
||||
value = read_property(value, parent.property);
|
||||
mark_escaped(d, parent, value, level + 1);
|
||||
if (value) return;
|
||||
}
|
||||
if (level == 0) d.direct_access = true;
|
||||
}
|
||||
});
|
||||
|
||||
AST_SymbolRef.DEFMETHOD("fixed_value", function() {
|
||||
AST_Symbol.DEFMETHOD("fixed_value", function() {
|
||||
var fixed = this.definition().fixed;
|
||||
if (!fixed || fixed instanceof AST_Node) return fixed;
|
||||
return fixed();
|
||||
@@ -1700,35 +1740,6 @@ merge(Compressor.prototype, {
|
||||
&& unaryPrefix(this.operator);
|
||||
}
|
||||
});
|
||||
// Obtain the constant value of an expression already known to be constant.
|
||||
// Result only valid iff this.is_constant() is true.
|
||||
AST_Node.DEFMETHOD("constant_value", function(compressor){
|
||||
// Accomodate when option evaluate=false.
|
||||
if (this instanceof AST_Constant && !(this instanceof AST_RegExp)) {
|
||||
return this.value;
|
||||
}
|
||||
// Accomodate the common constant expressions !0 and -1 when option evaluate=false.
|
||||
if (this instanceof AST_UnaryPrefix
|
||||
&& this.expression instanceof AST_Constant) switch (this.operator) {
|
||||
case "!":
|
||||
return !this.expression.value;
|
||||
case "~":
|
||||
return ~this.expression.value;
|
||||
case "-":
|
||||
return -this.expression.value;
|
||||
case "+":
|
||||
return +this.expression.value;
|
||||
default:
|
||||
throw new Error(string_template("Cannot evaluate unary expression {value}", {
|
||||
value: this.print_to_string()
|
||||
}));
|
||||
}
|
||||
var result = this.evaluate(compressor);
|
||||
if (result !== this) {
|
||||
return result;
|
||||
}
|
||||
throw new Error(string_template("Cannot evaluate constant [{file}:{line},{col}]", this.start));
|
||||
});
|
||||
def(AST_Statement, function(){
|
||||
throw new Error(string_template("Cannot evaluate a statement [{file}:{line},{col}]", this.start));
|
||||
});
|
||||
@@ -1752,6 +1763,7 @@ merge(Compressor.prototype, {
|
||||
var elements = [];
|
||||
for (var i = 0, len = this.elements.length; i < len; i++) {
|
||||
var element = this.elements[i];
|
||||
if (element instanceof AST_Function) continue;
|
||||
var value = ev(element, compressor);
|
||||
if (element === value) return this;
|
||||
elements.push(value);
|
||||
@@ -1776,6 +1788,7 @@ merge(Compressor.prototype, {
|
||||
if (typeof Object.prototype[key] === 'function') {
|
||||
return this;
|
||||
}
|
||||
if (prop.value instanceof AST_Function) continue;
|
||||
val[key] = ev(prop.value, compressor);
|
||||
if (val[key] === prop.value) return this;
|
||||
}
|
||||
@@ -2517,9 +2530,8 @@ merge(Compressor.prototype, {
|
||||
return node;
|
||||
}
|
||||
var parent = tt.parent();
|
||||
if (node instanceof AST_Definitions
|
||||
&& !(parent instanceof AST_ForIn && parent.init === node)
|
||||
&& (drop_vars || !(parent instanceof AST_Toplevel) && !(node instanceof AST_Var))) {
|
||||
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
|
||||
@@ -2530,8 +2542,8 @@ merge(Compressor.prototype, {
|
||||
if (def.value) def.value = def.value.transform(tt);
|
||||
if (def.name instanceof AST_Destructuring) return tail.push(def);
|
||||
var sym = def.name.definition();
|
||||
if (!drop_vars && sym.global) return tail.push(def);
|
||||
if (sym.id in in_use_ids) {
|
||||
if (drop_block && sym.global) return tail.push(def);
|
||||
if (!(drop_vars || drop_block) || sym.id in in_use_ids) {
|
||||
if (def.name instanceof AST_SymbolVar) {
|
||||
var var_defs = var_defs_by_id.get(sym.id);
|
||||
if (var_defs.length > 1 && !def.value) {
|
||||
@@ -2597,11 +2609,11 @@ merge(Compressor.prototype, {
|
||||
}));
|
||||
}
|
||||
switch (body.length) {
|
||||
case 0:
|
||||
case 0:
|
||||
return in_list ? MAP.skip : make_node(AST_EmptyStatement, node);
|
||||
case 1:
|
||||
case 1:
|
||||
return body[0];
|
||||
default:
|
||||
default:
|
||||
return in_list ? MAP.splice(body) : make_node(AST_BlockStatement, node, {
|
||||
body: body
|
||||
});
|
||||
@@ -2810,6 +2822,71 @@ merge(Compressor.prototype, {
|
||||
return self;
|
||||
});
|
||||
|
||||
AST_Scope.DEFMETHOD("hoist_properties", function(compressor){
|
||||
var self = this;
|
||||
if (!compressor.option("hoist_props") || compressor.has_directive("use asm")) return self;
|
||||
var defs_by_id = Object.create(null);
|
||||
var var_names = Object.create(null);
|
||||
self.enclosed.forEach(function(def) {
|
||||
var_names[def.name] = true;
|
||||
});
|
||||
self.variables.each(function(def, name) {
|
||||
var_names[name] = true;
|
||||
});
|
||||
return self.transform(new TreeTransformer(function(node) {
|
||||
if (node instanceof AST_VarDef) {
|
||||
var sym = node.name, def, value;
|
||||
if (sym.scope === self
|
||||
&& !(def = sym.definition()).escaped
|
||||
&& !def.single_use
|
||||
&& !def.direct_access
|
||||
&& (value = sym.fixed_value()) === node.value
|
||||
&& value instanceof AST_Object) {
|
||||
var defs = new Dictionary();
|
||||
var assignments = [];
|
||||
value.properties.forEach(function(prop) {
|
||||
assignments.push(make_node(AST_VarDef, node, {
|
||||
name: make_sym(prop.key),
|
||||
value: prop.value
|
||||
}));
|
||||
});
|
||||
defs_by_id[def.id] = defs;
|
||||
return MAP.splice(assignments);
|
||||
}
|
||||
}
|
||||
if (node instanceof AST_PropAccess && node.expression instanceof AST_SymbolRef) {
|
||||
var defs = defs_by_id[node.expression.definition().id];
|
||||
if (defs) {
|
||||
var key = node.property;
|
||||
if (key instanceof AST_Node) key = key.getValue();
|
||||
var def = defs.get(key);
|
||||
var sym = make_node(AST_SymbolRef, node, {
|
||||
name: def.name,
|
||||
scope: node.expression.scope,
|
||||
thedef: def
|
||||
});
|
||||
sym.reference({});
|
||||
return sym;
|
||||
}
|
||||
}
|
||||
|
||||
function make_sym(key) {
|
||||
var prefix = sym.name + "_" + key.toString().replace(/[^a-z_$]+/ig, "_");
|
||||
var name = prefix;
|
||||
for (var i = 0; var_names[name]; i++) name = prefix + "$" + i;
|
||||
var new_var = make_node(sym.CTOR, sym, {
|
||||
name: name,
|
||||
scope: self
|
||||
});
|
||||
var def = self.def_variable(new_var);
|
||||
defs.set(key, def);
|
||||
self.enclosed.push(def);
|
||||
var_names[name] = true;
|
||||
return new_var;
|
||||
}
|
||||
}));
|
||||
});
|
||||
|
||||
// drop_side_effect_free()
|
||||
// remove side-effect-free parts which only affects return value
|
||||
(function(def){
|
||||
@@ -3963,6 +4040,11 @@ merge(Compressor.prototype, {
|
||||
});
|
||||
|
||||
var commutativeOperators = makePredicate("== === != !== * & | ^");
|
||||
function is_object(node) {
|
||||
return node instanceof AST_Array
|
||||
|| node instanceof AST_Lambda
|
||||
|| node instanceof AST_Object;
|
||||
}
|
||||
|
||||
OPT(AST_Binary, function(self, compressor){
|
||||
function reversible() {
|
||||
@@ -3998,7 +4080,8 @@ merge(Compressor.prototype, {
|
||||
case "!==":
|
||||
if ((self.left.is_string(compressor) && self.right.is_string(compressor)) ||
|
||||
(self.left.is_number(compressor) && self.right.is_number(compressor)) ||
|
||||
(self.left.is_boolean() && self.right.is_boolean())) {
|
||||
(self.left.is_boolean() && self.right.is_boolean()) ||
|
||||
self.left.equivalent_to(self.right)) {
|
||||
self.operator = self.operator.substr(0, 2);
|
||||
}
|
||||
// XXX: intentionally falling down to the next case
|
||||
@@ -4018,6 +4101,13 @@ merge(Compressor.prototype, {
|
||||
if (self.operator.length == 2) self.operator += "=";
|
||||
}
|
||||
}
|
||||
// obj !== obj => false
|
||||
else if (self.left instanceof AST_SymbolRef
|
||||
&& self.right instanceof AST_SymbolRef
|
||||
&& self.left.definition() === self.right.definition()
|
||||
&& is_object(self.left.fixed_value())) {
|
||||
return make_node(self.operator[0] == "=" ? AST_True : AST_False, self);
|
||||
}
|
||||
break;
|
||||
}
|
||||
if (compressor.option("booleans") && self.operator == "+" && compressor.in_boolean_context()) {
|
||||
@@ -4713,19 +4803,69 @@ merge(Compressor.prototype, {
|
||||
});
|
||||
|
||||
OPT(AST_Sub, function(self, compressor){
|
||||
var expr = self.expression;
|
||||
var prop = self.property;
|
||||
if (prop instanceof AST_String && compressor.option("properties")) {
|
||||
prop = prop.getValue();
|
||||
if (is_identifier_string(prop)) {
|
||||
return make_node(AST_Dot, self, {
|
||||
expression : self.expression,
|
||||
property : prop
|
||||
}).optimize(compressor);
|
||||
if (compressor.option("properties")) {
|
||||
var key = prop.evaluate(compressor);
|
||||
if (key !== prop) {
|
||||
var property = "" + key;
|
||||
if (is_identifier_string(property)
|
||||
&& property.length <= prop.print_to_string().length + 1) {
|
||||
return make_node(AST_Dot, self, {
|
||||
expression: expr,
|
||||
property: property
|
||||
}).optimize(compressor);
|
||||
}
|
||||
if (!(prop instanceof AST_Number)) {
|
||||
var value = parseFloat(property);
|
||||
if (value.toString() == property) {
|
||||
prop = self.property = make_node(AST_Number, prop, {
|
||||
value: value
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
var v = parseFloat(prop);
|
||||
if (!isNaN(v) && v.toString() == prop) {
|
||||
self.property = make_node(AST_Number, self.property, {
|
||||
value: v
|
||||
}
|
||||
if (is_lhs(self, compressor.parent())) return self;
|
||||
if (compressor.option("properties") && key !== prop) {
|
||||
var node = self.flatten_object(property);
|
||||
if (node) {
|
||||
expr = self.expression = node.expression;
|
||||
prop = self.property = node.property;
|
||||
}
|
||||
}
|
||||
if (compressor.option("properties") && compressor.option("side_effects")
|
||||
&& prop instanceof AST_Number && expr instanceof AST_Array) {
|
||||
var index = prop.getValue();
|
||||
var elements = expr.elements;
|
||||
if (index in elements) {
|
||||
var flatten = true;
|
||||
var values = [];
|
||||
for (var i = elements.length; --i > index;) {
|
||||
var value = elements[i].drop_side_effect_free(compressor);
|
||||
if (value) {
|
||||
values.unshift(value);
|
||||
if (flatten && value.has_side_effects(compressor)) flatten = false;
|
||||
}
|
||||
}
|
||||
var retValue = elements[index];
|
||||
retValue = retValue instanceof AST_Hole ? make_node(AST_Undefined, retValue) : retValue;
|
||||
if (!flatten) values.unshift(retValue);
|
||||
while (--i >= 0) {
|
||||
var value = elements[i].drop_side_effect_free(compressor);
|
||||
if (value) values.unshift(value);
|
||||
else index--;
|
||||
}
|
||||
if (flatten) {
|
||||
values.push(retValue);
|
||||
return make_sequence(self, values).optimize(compressor);
|
||||
} else return make_node(AST_Sub, self, {
|
||||
expression: make_node(AST_Array, expr, {
|
||||
elements: values
|
||||
}),
|
||||
property: make_node(AST_Number, prop, {
|
||||
value: index
|
||||
})
|
||||
});
|
||||
}
|
||||
}
|
||||
@@ -4748,30 +4888,38 @@ merge(Compressor.prototype, {
|
||||
return result;
|
||||
});
|
||||
|
||||
AST_PropAccess.DEFMETHOD("flatten_object", function(key) {
|
||||
var expr = this.expression;
|
||||
if (expr instanceof AST_Object) {
|
||||
var props = expr.properties;
|
||||
for (var i = props.length; --i >= 0;) {
|
||||
var prop = props[i];
|
||||
if ("" + prop.key == key) {
|
||||
if (!all(props, function(prop) {
|
||||
return prop instanceof AST_ObjectKeyVal;
|
||||
})) break;
|
||||
var value = prop.value;
|
||||
if (value instanceof AST_Function && value.contains_this()) break;
|
||||
return make_node(AST_Sub, this, {
|
||||
expression: make_node(AST_Array, expr, {
|
||||
elements: props.map(function(prop) {
|
||||
return prop.value;
|
||||
})
|
||||
}),
|
||||
property: make_node(AST_Number, this, {
|
||||
value: i
|
||||
})
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
OPT(AST_Dot, function(self, compressor){
|
||||
var def = self.resolve_defines(compressor);
|
||||
if (def) {
|
||||
return def.optimize(compressor);
|
||||
}
|
||||
if (compressor.option("unsafe") && self.expression instanceof AST_Object) {
|
||||
var values = self.expression.properties;
|
||||
for (var i = values.length; --i >= 0;) {
|
||||
var key = values[i].key;
|
||||
if ((key instanceof AST_SymbolMethod ? key.name : key) === self.property) {
|
||||
var value = values[i].value;
|
||||
if (key instanceof AST_SymbolMethod) {
|
||||
if (values[i].is_generator) break;
|
||||
value = make_node(AST_Function, value, value);
|
||||
}
|
||||
if (value instanceof AST_Function ? !value.contains_this() : !value.has_side_effects(compressor)) {
|
||||
var obj = self.expression.clone();
|
||||
obj.properties = obj.properties.slice();
|
||||
obj.properties.splice(i, 1);
|
||||
return make_sequence(self, [ obj, value ]).optimize(compressor);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if (compressor.option("unsafe_proto")
|
||||
&& self.expression instanceof AST_Dot
|
||||
&& self.expression.property == "prototype") {
|
||||
@@ -4794,6 +4942,11 @@ merge(Compressor.prototype, {
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (is_lhs(self, compressor.parent())) return self;
|
||||
if (compressor.option("properties")) {
|
||||
var node = self.flatten_object(self.property);
|
||||
if (node) return node.optimize(compressor);
|
||||
}
|
||||
var ev = self.evaluate(compressor);
|
||||
if (ev !== self) {
|
||||
ev = make_node_from_constant(ev, self).optimize(compressor);
|
||||
|
||||
@@ -4,7 +4,7 @@
|
||||
"homepage": "https://github.com/mishoo/UglifyJS2/tree/harmony",
|
||||
"author": "Mihai Bazon <mihai.bazon@gmail.com> (http://lisperator.net/)",
|
||||
"license": "BSD-2-Clause",
|
||||
"version": "3.1.5",
|
||||
"version": "3.1.6",
|
||||
"engines": {
|
||||
"node": ">=0.8.0"
|
||||
},
|
||||
|
||||
@@ -203,50 +203,110 @@ constant_join_3: {
|
||||
|
||||
for_loop: {
|
||||
options = {
|
||||
unsafe : true,
|
||||
unused : true,
|
||||
evaluate : true,
|
||||
reduce_vars : true
|
||||
evaluate: true,
|
||||
reduce_vars: true,
|
||||
unsafe: true,
|
||||
unused: true,
|
||||
};
|
||||
input: {
|
||||
function f0() {
|
||||
var a = [1, 2, 3];
|
||||
for (var i = 0; i < a.length; i++) {
|
||||
console.log(a[i]);
|
||||
}
|
||||
var b = 0;
|
||||
for (var i = 0; i < a.length; i++)
|
||||
b += a[i];
|
||||
return b;
|
||||
}
|
||||
|
||||
function f1() {
|
||||
var a = [1, 2, 3];
|
||||
for (var i = 0, len = a.length; i < len; i++) {
|
||||
console.log(a[i]);
|
||||
}
|
||||
var b = 0;
|
||||
for (var i = 0, len = a.length; i < len; i++)
|
||||
b += a[i];
|
||||
return b;
|
||||
}
|
||||
|
||||
function f2() {
|
||||
var a = [1, 2, 3];
|
||||
for (var i = 0; i < a.length; i++) {
|
||||
a[i]++;
|
||||
}
|
||||
}
|
||||
}
|
||||
expect: {
|
||||
function f0() {
|
||||
var a = [1, 2, 3];
|
||||
for (var i = 0; i < 3; i++)
|
||||
console.log(a[i]);
|
||||
}
|
||||
|
||||
function f1() {
|
||||
var a = [1, 2, 3];
|
||||
for (var i = 0; i < 3; i++)
|
||||
console.log(a[i]);
|
||||
}
|
||||
|
||||
function f2() {
|
||||
var a = [1, 2, 3];
|
||||
for (var i = 0; i < a.length; i++)
|
||||
a[i]++;
|
||||
return a[2];
|
||||
}
|
||||
console.log(f0(), f1(), f2());
|
||||
}
|
||||
expect: {
|
||||
function f0() {
|
||||
var a = [1, 2, 3];
|
||||
var b = 0;
|
||||
for (var i = 0; i < 3; i++)
|
||||
b += a[i];
|
||||
return b;
|
||||
}
|
||||
function f1() {
|
||||
var a = [1, 2, 3];
|
||||
var b = 0;
|
||||
for (var i = 0; i < 3; i++)
|
||||
b += a[i];
|
||||
return b;
|
||||
}
|
||||
function f2() {
|
||||
var a = [1, 2, 3];
|
||||
for (var i = 0; i < a.length; i++)
|
||||
a[i]++;
|
||||
return a[2];
|
||||
}
|
||||
console.log(f0(), f1(), f2());
|
||||
}
|
||||
expect_stdout: "6 6 4"
|
||||
}
|
||||
|
||||
index: {
|
||||
options = {
|
||||
evaluate: true,
|
||||
reduce_vars: true,
|
||||
toplevel: true,
|
||||
unsafe: true,
|
||||
unused: true,
|
||||
}
|
||||
input: {
|
||||
var a = [ 1, 2 ];
|
||||
console.log(a[0], a[1]);
|
||||
}
|
||||
expect: {
|
||||
console.log(1, 2);
|
||||
}
|
||||
expect_stdout: "1 2"
|
||||
}
|
||||
|
||||
length: {
|
||||
options = {
|
||||
evaluate: true,
|
||||
reduce_vars: true,
|
||||
toplevel: true,
|
||||
unsafe: true,
|
||||
unused: true,
|
||||
}
|
||||
input: {
|
||||
var a = [ 1, 2 ];
|
||||
console.log(a.length);
|
||||
}
|
||||
expect: {
|
||||
console.log(2);
|
||||
}
|
||||
expect_stdout: "2"
|
||||
}
|
||||
|
||||
index_length: {
|
||||
options = {
|
||||
evaluate: true,
|
||||
reduce_vars: true,
|
||||
toplevel: true,
|
||||
unsafe: true,
|
||||
unused: true,
|
||||
}
|
||||
input: {
|
||||
var a = [ 1, 2 ];
|
||||
console.log(a[0], a.length);
|
||||
}
|
||||
expect: {
|
||||
console.log(1, 2);
|
||||
}
|
||||
expect_stdout: "1 2"
|
||||
}
|
||||
|
||||
@@ -2150,7 +2150,7 @@ inner_lvalues: {
|
||||
console.log(null, a, b);
|
||||
}
|
||||
expect: {
|
||||
var a, b = 10;
|
||||
var b = 10;
|
||||
var a = (--b || a || 3).toString(), c = --b + -a;
|
||||
console.log(null, a, b);
|
||||
}
|
||||
@@ -2808,73 +2808,6 @@ issue_2319_3: {
|
||||
expect_stdout: "true"
|
||||
}
|
||||
|
||||
prop_side_effects_1: {
|
||||
options = {
|
||||
collapse_vars: true,
|
||||
evaluate: true,
|
||||
pure_getters: "strict",
|
||||
reduce_vars: true,
|
||||
toplevel: true,
|
||||
unsafe: true,
|
||||
unused: true,
|
||||
}
|
||||
input: {
|
||||
var C = 1;
|
||||
console.log(C);
|
||||
var obj = {
|
||||
bar: function() {
|
||||
return C + C;
|
||||
}
|
||||
};
|
||||
console.log(obj.bar());
|
||||
}
|
||||
expect: {
|
||||
console.log(1);
|
||||
console.log({
|
||||
bar: function() {
|
||||
return 2;
|
||||
}
|
||||
}.bar());
|
||||
}
|
||||
expect_stdout: [
|
||||
"1",
|
||||
"2",
|
||||
]
|
||||
}
|
||||
|
||||
prop_side_effects_2: {
|
||||
options = {
|
||||
collapse_vars: true,
|
||||
evaluate: true,
|
||||
inline: true,
|
||||
passes: 2,
|
||||
pure_getters: "strict",
|
||||
reduce_vars: true,
|
||||
side_effects: true,
|
||||
toplevel: true,
|
||||
unsafe: true,
|
||||
unused: true,
|
||||
}
|
||||
input: {
|
||||
var C = 1;
|
||||
console.log(C);
|
||||
var obj = {
|
||||
bar: function() {
|
||||
return C + C;
|
||||
}
|
||||
};
|
||||
console.log(obj.bar());
|
||||
}
|
||||
expect: {
|
||||
console.log(1);
|
||||
console.log(2);
|
||||
}
|
||||
expect_stdout: [
|
||||
"1",
|
||||
"2",
|
||||
]
|
||||
}
|
||||
|
||||
issue_2365: {
|
||||
options = {
|
||||
collapse_vars: true,
|
||||
|
||||
@@ -74,3 +74,40 @@ dont_change_in_or_instanceof_expressions: {
|
||||
null instanceof null;
|
||||
}
|
||||
}
|
||||
|
||||
self_comparison_1: {
|
||||
options = {
|
||||
comparisons: true,
|
||||
}
|
||||
input: {
|
||||
a === a;
|
||||
a !== b;
|
||||
b.c === a.c;
|
||||
b.c !== b.c;
|
||||
}
|
||||
expect: {
|
||||
a == a;
|
||||
a !== b;
|
||||
b.c === a.c;
|
||||
b.c != b.c;
|
||||
}
|
||||
}
|
||||
|
||||
self_comparison_2: {
|
||||
options = {
|
||||
comparisons: true,
|
||||
reduce_vars: true,
|
||||
toplevel: true,
|
||||
}
|
||||
input: {
|
||||
function f() {}
|
||||
var o = {};
|
||||
console.log(f != f, o === o);
|
||||
}
|
||||
expect: {
|
||||
function f() {}
|
||||
var o = {};
|
||||
console.log(false, true);
|
||||
}
|
||||
expect_stdout: "false true"
|
||||
}
|
||||
|
||||
@@ -480,10 +480,11 @@ unsafe_object_accessor: {
|
||||
}
|
||||
}
|
||||
|
||||
unsafe_function: {
|
||||
prop_function: {
|
||||
options = {
|
||||
evaluate : true,
|
||||
unsafe : true
|
||||
evaluate: true,
|
||||
properties: true,
|
||||
side_effects: true,
|
||||
}
|
||||
input: {
|
||||
console.log(
|
||||
@@ -496,9 +497,9 @@ unsafe_function: {
|
||||
expect: {
|
||||
console.log(
|
||||
({a:{b:1},b:function(){}}) + 1,
|
||||
({b:function(){}}, {b:1}) + 1,
|
||||
({a:{b:1}}, function(){}) + 1,
|
||||
({b:function(){}}, {b:1}).b + 1
|
||||
({b:1}) + 1,
|
||||
function(){} + 1,
|
||||
2
|
||||
);
|
||||
}
|
||||
expect_stdout: true
|
||||
@@ -724,10 +725,11 @@ unsafe_string_bad_index: {
|
||||
expect_stdout: true
|
||||
}
|
||||
|
||||
unsafe_prototype_function: {
|
||||
prototype_function: {
|
||||
options = {
|
||||
evaluate : true,
|
||||
unsafe : true
|
||||
evaluate: true,
|
||||
properties: true,
|
||||
side_effects: true,
|
||||
}
|
||||
input: {
|
||||
var a = ({valueOf: 0}) < 1;
|
||||
@@ -746,8 +748,8 @@ unsafe_prototype_function: {
|
||||
var d = ({toString: 0}) + "";
|
||||
var e = (({valueOf: 0}) + "")[2];
|
||||
var f = (({toString: 0}) + "")[2];
|
||||
var g = ({}, 0)();
|
||||
var h = ({}, 0)();
|
||||
var g = 0();
|
||||
var h = 0();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1288,3 +1290,40 @@ issue_2231_2: {
|
||||
}
|
||||
expect_stdout: true
|
||||
}
|
||||
|
||||
self_comparison_1: {
|
||||
options = {
|
||||
evaluate: true,
|
||||
reduce_vars: true,
|
||||
toplevel: true,
|
||||
unsafe: true,
|
||||
unused: true,
|
||||
}
|
||||
input: {
|
||||
var o = { n: NaN };
|
||||
console.log(o.n == o.n, o.n === o.n, o.n != o.n, o.n !== o.n, typeof o.n);
|
||||
}
|
||||
expect: {
|
||||
console.log(false, false, true, true, "number");
|
||||
}
|
||||
expect_stdout: "false false true true 'number'"
|
||||
}
|
||||
|
||||
self_comparison_2: {
|
||||
options = {
|
||||
evaluate: true,
|
||||
hoist_props: true,
|
||||
passes: 2,
|
||||
reduce_vars: true,
|
||||
toplevel: true,
|
||||
unused: true,
|
||||
}
|
||||
input: {
|
||||
var o = { n: NaN };
|
||||
console.log(o.n == o.n, o.n === o.n, o.n != o.n, o.n !== o.n, typeof o.n);
|
||||
}
|
||||
expect: {
|
||||
console.log(false, false, true, true, "number");
|
||||
}
|
||||
expect_stdout: "false false true true 'number'"
|
||||
}
|
||||
|
||||
@@ -151,13 +151,13 @@ issue_1841_2: {
|
||||
|
||||
function_returning_constant_literal: {
|
||||
options = {
|
||||
reduce_vars: true,
|
||||
unsafe: true,
|
||||
toplevel: true,
|
||||
evaluate: true,
|
||||
cascade: true,
|
||||
unused: true,
|
||||
inline: true,
|
||||
passes: 2,
|
||||
properties: true,
|
||||
reduce_vars: true,
|
||||
side_effects: true,
|
||||
toplevel: true,
|
||||
unused: true,
|
||||
}
|
||||
input: {
|
||||
function greeter() {
|
||||
|
||||
371
test/compress/hoist_props.js
Normal file
371
test/compress/hoist_props.js
Normal file
@@ -0,0 +1,371 @@
|
||||
issue_2377_1: {
|
||||
options = {
|
||||
evaluate: true,
|
||||
inline: true,
|
||||
hoist_props: true,
|
||||
reduce_vars: true,
|
||||
toplevel: true,
|
||||
unused: true,
|
||||
}
|
||||
input: {
|
||||
var obj = {
|
||||
foo: 1,
|
||||
bar: 2,
|
||||
square: function(x) {
|
||||
return x * x;
|
||||
},
|
||||
cube: function(x) {
|
||||
return x * x * x;
|
||||
},
|
||||
};
|
||||
console.log(obj.foo, obj.cube(3));
|
||||
}
|
||||
expect: {
|
||||
var obj_foo = 1, obj_cube = function(x) {
|
||||
return x * x * x;
|
||||
};
|
||||
console.log(obj_foo, obj_cube(3));
|
||||
}
|
||||
expect_stdout: "1 27"
|
||||
}
|
||||
|
||||
issue_2377_2: {
|
||||
options = {
|
||||
evaluate: true,
|
||||
inline: true,
|
||||
hoist_props: true,
|
||||
passes: 2,
|
||||
reduce_vars: true,
|
||||
toplevel: true,
|
||||
unused: true,
|
||||
}
|
||||
input: {
|
||||
var obj = {
|
||||
foo: 1,
|
||||
bar: 2,
|
||||
square: function(x) {
|
||||
return x * x;
|
||||
},
|
||||
cube: function(x) {
|
||||
return x * x * x;
|
||||
},
|
||||
};
|
||||
console.log(obj.foo, obj.cube(3));
|
||||
}
|
||||
expect: {
|
||||
console.log(1, function(x) {
|
||||
return x * x * x;
|
||||
}(3));
|
||||
}
|
||||
expect_stdout: "1 27"
|
||||
}
|
||||
|
||||
issue_2377_3: {
|
||||
options = {
|
||||
evaluate: true,
|
||||
inline: true,
|
||||
hoist_props: true,
|
||||
passes: 3,
|
||||
reduce_vars: true,
|
||||
toplevel: true,
|
||||
unused: true,
|
||||
}
|
||||
input: {
|
||||
var obj = {
|
||||
foo: 1,
|
||||
bar: 2,
|
||||
square: function(x) {
|
||||
return x * x;
|
||||
},
|
||||
cube: function(x) {
|
||||
return x * x * x;
|
||||
},
|
||||
};
|
||||
console.log(obj.foo, obj.cube(3));
|
||||
}
|
||||
expect: {
|
||||
console.log(1, 27);
|
||||
}
|
||||
expect_stdout: "1 27"
|
||||
}
|
||||
|
||||
direct_access_1: {
|
||||
options = {
|
||||
hoist_props: true,
|
||||
reduce_vars: true,
|
||||
toplevel: true,
|
||||
unused: true,
|
||||
}
|
||||
input: {
|
||||
var a = 0;
|
||||
var obj = {
|
||||
a: 1,
|
||||
b: 2,
|
||||
};
|
||||
for (var k in obj) a++;
|
||||
console.log(a, obj.a);
|
||||
}
|
||||
expect: {
|
||||
var a = 0;
|
||||
var obj = {
|
||||
a: 1,
|
||||
b: 2,
|
||||
};
|
||||
for (var k in obj) a++;
|
||||
console.log(a, obj.a);
|
||||
}
|
||||
expect_stdout: "2 1"
|
||||
}
|
||||
|
||||
direct_access_2: {
|
||||
options = {
|
||||
hoist_props: true,
|
||||
reduce_vars: true,
|
||||
toplevel: true,
|
||||
unused: true,
|
||||
}
|
||||
input: {
|
||||
var o = { a: 1 };
|
||||
var f = function(k) {
|
||||
if (o[k]) return "PASS";
|
||||
};
|
||||
console.log(f("a"));
|
||||
}
|
||||
expect: {
|
||||
var o = { a: 1 };
|
||||
console.log(function(k) {
|
||||
if (o[k]) return "PASS";
|
||||
}("a"));
|
||||
}
|
||||
expect_stdout: "PASS"
|
||||
}
|
||||
|
||||
direct_access_3: {
|
||||
options = {
|
||||
hoist_props: true,
|
||||
reduce_vars: true,
|
||||
toplevel: true,
|
||||
unused: true,
|
||||
}
|
||||
input: {
|
||||
var o = { a: 1 };
|
||||
o.b;
|
||||
console.log(o.a);
|
||||
}
|
||||
expect: {
|
||||
var o = { a: 1 };
|
||||
o.b;
|
||||
console.log(o.a);
|
||||
}
|
||||
expect_stdout: "1"
|
||||
}
|
||||
|
||||
single_use: {
|
||||
options = {
|
||||
hoist_props: true,
|
||||
reduce_vars: true,
|
||||
toplevel: true,
|
||||
unused: true,
|
||||
}
|
||||
input: {
|
||||
var obj = {
|
||||
bar: function() {
|
||||
return 42;
|
||||
},
|
||||
};
|
||||
console.log(obj.bar());
|
||||
}
|
||||
expect: {
|
||||
console.log({
|
||||
bar: function() {
|
||||
return 42;
|
||||
},
|
||||
}.bar());
|
||||
}
|
||||
}
|
||||
|
||||
name_collision_1: {
|
||||
options = {
|
||||
hoist_props: true,
|
||||
reduce_vars: true,
|
||||
toplevel: true,
|
||||
}
|
||||
input: {
|
||||
var obj_foo = 1;
|
||||
var obj_bar = 2;
|
||||
function f() {
|
||||
var obj = {
|
||||
foo: 3,
|
||||
bar: 4,
|
||||
"b-r": 5,
|
||||
"b+r": 6,
|
||||
"b!r": 7,
|
||||
};
|
||||
console.log(obj_foo, obj.foo, obj.bar, obj["b-r"], obj["b+r"], obj["b!r"]);
|
||||
}
|
||||
f();
|
||||
}
|
||||
expect: {
|
||||
var obj_foo = 1;
|
||||
var obj_bar = 2;
|
||||
function f() {
|
||||
var obj_foo$0 = 3,
|
||||
obj_bar = 4,
|
||||
obj_b_r = 5,
|
||||
obj_b_r$0 = 6,
|
||||
obj_b_r$1 = 7;
|
||||
console.log(obj_foo, obj_foo$0, obj_bar, obj_b_r, obj_b_r$0, obj_b_r$1);
|
||||
}
|
||||
f();
|
||||
}
|
||||
expect_stdout: "1 3 4 5 6 7"
|
||||
}
|
||||
|
||||
name_collision_2: {
|
||||
options = {
|
||||
hoist_props: true,
|
||||
reduce_vars: true,
|
||||
toplevel: true,
|
||||
}
|
||||
input: {
|
||||
var o = {
|
||||
p: 1,
|
||||
0: function(x) {
|
||||
return x;
|
||||
},
|
||||
1: function(x) {
|
||||
return x + 1;
|
||||
}
|
||||
}, o__$0 = 2, o__$1 = 3;
|
||||
console.log(o.p === o.p, o[0](4), o[1](5), o__$0, o__$1);
|
||||
}
|
||||
expect: {
|
||||
var o_p = 1,
|
||||
o__ = function(x) {
|
||||
return x;
|
||||
},
|
||||
o__$2 = function(x) {
|
||||
return x + 1;
|
||||
},
|
||||
o__$0 = 2,
|
||||
o__$1 = 3;
|
||||
console.log(o_p === o_p, o__(4), o__$2(5), o__$0, o__$1);
|
||||
}
|
||||
expect_stdout: "true 4 6 2 3"
|
||||
}
|
||||
|
||||
name_collision_3: {
|
||||
options = {
|
||||
hoist_props: true,
|
||||
reduce_vars: true,
|
||||
toplevel: true,
|
||||
}
|
||||
input: {
|
||||
var o = {
|
||||
p: 1,
|
||||
0: function(x) {
|
||||
return x;
|
||||
},
|
||||
1: function(x) {
|
||||
return x + 1;
|
||||
}
|
||||
}, o__$0 = 2, o__$1 = 3;
|
||||
console.log(o.p === o.p, o[0](4), o[1](5));
|
||||
}
|
||||
expect: {
|
||||
var o_p = 1,
|
||||
o__ = function(x) {
|
||||
return x;
|
||||
},
|
||||
o__$2 = function(x) {
|
||||
return x + 1;
|
||||
},
|
||||
o__$0 = 2,
|
||||
o__$1 = 3;
|
||||
console.log(o_p === o_p, o__(4), o__$2(5));
|
||||
}
|
||||
expect_stdout: "true 4 6"
|
||||
}
|
||||
|
||||
contains_this_1: {
|
||||
options = {
|
||||
evaluate: true,
|
||||
hoist_props: true,
|
||||
inline: true,
|
||||
passes: 2,
|
||||
reduce_vars: true,
|
||||
toplevel: true,
|
||||
unused: true,
|
||||
}
|
||||
input: {
|
||||
var o = {
|
||||
u: function() {
|
||||
return this === this;
|
||||
},
|
||||
p: 1
|
||||
};
|
||||
console.log(o.p, o.p);
|
||||
}
|
||||
expect: {
|
||||
console.log(1, 1);
|
||||
}
|
||||
expect_stdout: "1 1"
|
||||
}
|
||||
|
||||
contains_this_2: {
|
||||
options = {
|
||||
evaluate: true,
|
||||
hoist_props: true,
|
||||
inline: true,
|
||||
passes: 2,
|
||||
reduce_vars: true,
|
||||
toplevel: true,
|
||||
unused: true,
|
||||
}
|
||||
input: {
|
||||
var o = {
|
||||
u: function() {
|
||||
return this === this;
|
||||
},
|
||||
p: 1
|
||||
};
|
||||
console.log(o.p, o.p, o.u);
|
||||
}
|
||||
expect: {
|
||||
console.log(1, 1, function() {
|
||||
return this === this;
|
||||
});
|
||||
}
|
||||
expect_stdout: true
|
||||
}
|
||||
|
||||
contains_this_3: {
|
||||
options = {
|
||||
evaluate: true,
|
||||
hoist_props: true,
|
||||
inline: true,
|
||||
passes: 2,
|
||||
reduce_vars: true,
|
||||
toplevel: true,
|
||||
unused: true,
|
||||
}
|
||||
input: {
|
||||
var o = {
|
||||
u: function() {
|
||||
return this === this;
|
||||
},
|
||||
p: 1
|
||||
};
|
||||
console.log(o.p, o.p, o.u());
|
||||
}
|
||||
expect: {
|
||||
var o = {
|
||||
u: function() {
|
||||
return this === this;
|
||||
},
|
||||
p: 1
|
||||
};
|
||||
console.log(o.p, o.p, o.u());
|
||||
}
|
||||
expect_stdout: "1 1 true"
|
||||
}
|
||||
@@ -1,7 +1,8 @@
|
||||
keep_properties: {
|
||||
options = {
|
||||
properties: false
|
||||
};
|
||||
evaluate: true,
|
||||
properties: false,
|
||||
}
|
||||
input: {
|
||||
a["foo"] = "bar";
|
||||
}
|
||||
@@ -12,6 +13,7 @@ keep_properties: {
|
||||
|
||||
dot_properties: {
|
||||
options = {
|
||||
evaluate: true,
|
||||
properties: true,
|
||||
}
|
||||
beautify = {
|
||||
@@ -37,6 +39,7 @@ dot_properties: {
|
||||
|
||||
dot_properties_es5: {
|
||||
options = {
|
||||
evaluate: true,
|
||||
properties: true,
|
||||
}
|
||||
beautify = {
|
||||
@@ -61,8 +64,8 @@ dot_properties_es5: {
|
||||
sub_properties: {
|
||||
options = {
|
||||
evaluate: true,
|
||||
properties: true
|
||||
};
|
||||
properties: true,
|
||||
}
|
||||
input: {
|
||||
a[0] = 0;
|
||||
a["0"] = 1;
|
||||
@@ -81,18 +84,18 @@ sub_properties: {
|
||||
a[3.14] = 3;
|
||||
a.if = 4;
|
||||
a["foo bar"] = 5;
|
||||
a[NaN] = 6;
|
||||
a[null] = 7;
|
||||
a.NaN = 6;
|
||||
a.null = 7;
|
||||
a[void 0] = 8;
|
||||
}
|
||||
}
|
||||
|
||||
evaluate_array_length: {
|
||||
options = {
|
||||
evaluate: true,
|
||||
properties: true,
|
||||
unsafe: true,
|
||||
evaluate: true
|
||||
};
|
||||
}
|
||||
input: {
|
||||
a = [1, 2, 3].length;
|
||||
a = [1, 2, 3].join()["len" + "gth"];
|
||||
@@ -109,10 +112,10 @@ evaluate_array_length: {
|
||||
|
||||
evaluate_string_length: {
|
||||
options = {
|
||||
evaluate: true,
|
||||
properties: true,
|
||||
unsafe: true,
|
||||
evaluate: true
|
||||
};
|
||||
}
|
||||
input: {
|
||||
a = "foo".length;
|
||||
a = ("foo" + "bar")["len" + "gth"];
|
||||
@@ -151,7 +154,8 @@ mangle_properties: {
|
||||
|
||||
mangle_unquoted_properties: {
|
||||
options = {
|
||||
properties: false
|
||||
evaluate: true,
|
||||
properties: false,
|
||||
}
|
||||
mangle = {
|
||||
properties: {
|
||||
@@ -250,7 +254,8 @@ mangle_debug_suffix: {
|
||||
|
||||
mangle_debug_suffix_keep_quoted: {
|
||||
options = {
|
||||
properties: false
|
||||
evaluate: true,
|
||||
properties: false,
|
||||
}
|
||||
mangle = {
|
||||
properties: {
|
||||
@@ -679,8 +684,8 @@ accessor_this: {
|
||||
issue_2208_1: {
|
||||
options = {
|
||||
inline: true,
|
||||
properties: true,
|
||||
side_effects: true,
|
||||
unsafe: true,
|
||||
}
|
||||
input: {
|
||||
console.log({
|
||||
@@ -698,8 +703,8 @@ issue_2208_1: {
|
||||
issue_2208_2: {
|
||||
options = {
|
||||
inline: true,
|
||||
properties: true,
|
||||
side_effects: true,
|
||||
unsafe: true,
|
||||
}
|
||||
input: {
|
||||
console.log({
|
||||
@@ -723,8 +728,8 @@ issue_2208_2: {
|
||||
issue_2208_3: {
|
||||
options = {
|
||||
inline: true,
|
||||
properties: true,
|
||||
side_effects: true,
|
||||
unsafe: true,
|
||||
}
|
||||
input: {
|
||||
a = 42;
|
||||
@@ -748,8 +753,8 @@ issue_2208_3: {
|
||||
issue_2208_4: {
|
||||
options = {
|
||||
inline: true,
|
||||
properties: true,
|
||||
side_effects: true,
|
||||
unsafe: true,
|
||||
}
|
||||
input: {
|
||||
function foo() {}
|
||||
@@ -772,8 +777,8 @@ issue_2208_4: {
|
||||
issue_2208_5: {
|
||||
options = {
|
||||
inline: true,
|
||||
properties: true,
|
||||
side_effects: true,
|
||||
unsafe: true,
|
||||
}
|
||||
input: {
|
||||
console.log({
|
||||
@@ -1052,3 +1057,200 @@ unsafe_methods_regex: {
|
||||
]
|
||||
node_version: ">=6"
|
||||
}
|
||||
|
||||
lhs_prop_1: {
|
||||
options = {
|
||||
evaluate: true,
|
||||
properties: true,
|
||||
}
|
||||
input: {
|
||||
console.log(++{
|
||||
a: 1
|
||||
}.a);
|
||||
}
|
||||
expect: {
|
||||
console.log(++{
|
||||
a: 1
|
||||
}.a);
|
||||
}
|
||||
expect_stdout: "2"
|
||||
}
|
||||
|
||||
lhs_prop_2: {
|
||||
options = {
|
||||
evaluate: true,
|
||||
inline: true,
|
||||
properties: true,
|
||||
reduce_vars: true,
|
||||
side_effects: true,
|
||||
unused: true,
|
||||
}
|
||||
input: {
|
||||
[1][0] = 42;
|
||||
(function(a) {
|
||||
a.b = "g";
|
||||
})("abc");
|
||||
(function(a) {
|
||||
a[2] = "g";
|
||||
})("def");
|
||||
(function(a) {
|
||||
a[""] = "g";
|
||||
})("ghi");
|
||||
}
|
||||
expect: {
|
||||
[1][0] = 42;
|
||||
"abc".b = "g";
|
||||
"def"[2] = "g";
|
||||
"ghi"[""] = "g";
|
||||
}
|
||||
}
|
||||
|
||||
literal_duplicate_key_side_effects: {
|
||||
options = {
|
||||
properties: true,
|
||||
side_effects: true,
|
||||
}
|
||||
input: {
|
||||
console.log({
|
||||
a: "FAIL",
|
||||
a: console.log ? "PASS" : "FAIL"
|
||||
}.a);
|
||||
}
|
||||
expect: {
|
||||
console.log(console.log ? "PASS" : "FAIL");
|
||||
}
|
||||
expect_stdout: "PASS"
|
||||
}
|
||||
|
||||
prop_side_effects_1: {
|
||||
options = {
|
||||
evaluate: true,
|
||||
inline: true,
|
||||
properties: true,
|
||||
reduce_vars: true,
|
||||
side_effects: true,
|
||||
toplevel: true,
|
||||
unused: true,
|
||||
}
|
||||
input: {
|
||||
var C = 1;
|
||||
console.log(C);
|
||||
var obj = {
|
||||
bar: function() {
|
||||
return C + C;
|
||||
}
|
||||
};
|
||||
console.log(obj.bar());
|
||||
}
|
||||
expect: {
|
||||
console.log(1);
|
||||
var obj = {
|
||||
bar: function() {
|
||||
return 2;
|
||||
}
|
||||
};
|
||||
console.log(obj.bar());
|
||||
}
|
||||
expect_stdout: [
|
||||
"1",
|
||||
"2",
|
||||
]
|
||||
}
|
||||
|
||||
prop_side_effects_2: {
|
||||
options = {
|
||||
evaluate: true,
|
||||
inline: true,
|
||||
passes: 2,
|
||||
properties: true,
|
||||
reduce_vars: true,
|
||||
side_effects: true,
|
||||
toplevel: true,
|
||||
unused: true,
|
||||
}
|
||||
input: {
|
||||
var C = 1;
|
||||
console.log(C);
|
||||
var obj = {
|
||||
"": function() {
|
||||
return C + C;
|
||||
}
|
||||
};
|
||||
console.log(obj[""]());
|
||||
}
|
||||
expect: {
|
||||
console.log(1);
|
||||
console.log(2);
|
||||
}
|
||||
expect_stdout: [
|
||||
"1",
|
||||
"2",
|
||||
]
|
||||
}
|
||||
|
||||
accessor_1: {
|
||||
options = {
|
||||
properties: true,
|
||||
}
|
||||
input: {
|
||||
console.log({
|
||||
a: "FAIL",
|
||||
get a() {
|
||||
return "PASS";
|
||||
}
|
||||
}.a);
|
||||
}
|
||||
expect: {
|
||||
console.log({
|
||||
a: "FAIL",
|
||||
get a() {
|
||||
return "PASS";
|
||||
}
|
||||
}.a);
|
||||
}
|
||||
expect_stdout: "PASS"
|
||||
node_version: ">=4"
|
||||
}
|
||||
|
||||
accessor_2: {
|
||||
options = {
|
||||
properties: true,
|
||||
}
|
||||
input: {
|
||||
console.log({
|
||||
get a() {
|
||||
return "PASS";
|
||||
},
|
||||
set a(v) {},
|
||||
a: "FAIL"
|
||||
}.a);
|
||||
}
|
||||
expect: {
|
||||
console.log({
|
||||
get a() {
|
||||
return "PASS";
|
||||
},
|
||||
set a(v) {},
|
||||
a: "FAIL"
|
||||
}.a);
|
||||
}
|
||||
expect_stdout: true
|
||||
}
|
||||
|
||||
array_hole: {
|
||||
options = {
|
||||
properties: true,
|
||||
side_effects: true,
|
||||
}
|
||||
input: {
|
||||
console.log(
|
||||
[ 1, 2, , 3][1],
|
||||
[ 1, 2, , 3][2],
|
||||
[ 1, 2, , 3][3]
|
||||
);
|
||||
}
|
||||
expect: {
|
||||
console.log(2, void 0, 3);
|
||||
}
|
||||
expect_stdout: "2 undefined 3"
|
||||
}
|
||||
|
||||
@@ -211,7 +211,116 @@ unsafe_evaluate: {
|
||||
}
|
||||
}
|
||||
|
||||
unsafe_evaluate_object: {
|
||||
unsafe_evaluate_side_effect_free_1: {
|
||||
options = {
|
||||
evaluate: true,
|
||||
reduce_vars: true,
|
||||
unsafe: true,
|
||||
unused: true,
|
||||
}
|
||||
input: {
|
||||
console.log(function(){ var o={p:1}; console.log(o.p); return o.p; }());
|
||||
console.log(function(){ var o={p:2}; console.log(o.p); return o; }());
|
||||
console.log(function(){ var o={p:3}; console.log([o][0].p); return o.p; }());
|
||||
}
|
||||
expect: {
|
||||
console.log(function(){ console.log(1); return 1; }());
|
||||
console.log(function(){ var o={p:2}; console.log(2); return o; }());
|
||||
console.log(function(){ console.log(3); return 3; }());
|
||||
}
|
||||
expect_stdout: true
|
||||
}
|
||||
|
||||
unsafe_evaluate_side_effect_free_2: {
|
||||
options = {
|
||||
collapse_vars: true,
|
||||
evaluate: true,
|
||||
passes: 2,
|
||||
pure_getters: "strict",
|
||||
reduce_vars: true,
|
||||
unsafe: true,
|
||||
unused: true,
|
||||
}
|
||||
input: {
|
||||
console.log(function(){ var o={p:1},a=[o]; console.log(a[0].p); return o.p; }());
|
||||
}
|
||||
expect: {
|
||||
console.log(function(){ console.log(1); return 1; }());
|
||||
}
|
||||
expect_stdout: true
|
||||
}
|
||||
|
||||
unsafe_evaluate_escaped: {
|
||||
options = {
|
||||
evaluate: true,
|
||||
reduce_vars: true,
|
||||
unsafe: true,
|
||||
unused: true,
|
||||
}
|
||||
input: {
|
||||
console.log(function(){ var o={p:1}; console.log(o, o.p); return o.p; }());
|
||||
console.log(function(){ var o={p:2}; console.log(o.p, o); return o.p; }());
|
||||
console.log(function(){ var o={p:3},a=[o]; console.log(a[0].p++); return o.p; }());
|
||||
}
|
||||
expect: {
|
||||
console.log(function(){ var o={p:1}; console.log(o, o.p); return o.p; }());
|
||||
console.log(function(){ var o={p:2}; console.log(o.p, o); return o.p; }());
|
||||
console.log(function(){ var o={p:3},a=[o]; console.log(a[0].p++); return o.p; }());
|
||||
}
|
||||
expect_stdout: true
|
||||
}
|
||||
|
||||
unsafe_evaluate_modified: {
|
||||
options = {
|
||||
evaluate: true,
|
||||
reduce_vars: true,
|
||||
unsafe: true,
|
||||
unused: true,
|
||||
}
|
||||
input: {
|
||||
console.log(function(){ var o={p:1}; o.p++; console.log(o.p); return o.p; }());
|
||||
console.log(function(){ var o={p:2}; --o.p; console.log(o.p); return o.p; }());
|
||||
console.log(function(){ var o={p:3}; o.p += ""; console.log(o.p); return o.p; }());
|
||||
console.log(function(){ var o={p:4}; o = {}; console.log(o.p); return o.p; }());
|
||||
console.log(function(){ var o={p:5}; o.p = -9; console.log(o.p); return o.p; }());
|
||||
function inc() { this.p++; }
|
||||
console.log(function(){ var o={p:6}; inc.call(o); console.log(o.p); return o.p; }());
|
||||
console.log(function(){ var o={p:7}; console.log([o][0].p++); return o.p; }());
|
||||
}
|
||||
expect: {
|
||||
console.log(function(){ var o={p:1}; o.p++; console.log(o.p); return o.p; }());
|
||||
console.log(function(){ var o={p:2}; --o.p; console.log(o.p); return o.p; }());
|
||||
console.log(function(){ var o={p:3}; o.p += ""; console.log(o.p); return o.p; }());
|
||||
console.log(function(){ var o={p:4}; o = {}; console.log(o.p); return o.p; }());
|
||||
console.log(function(){ var o={p:5}; o.p = -9; console.log(o.p); return o.p; }());
|
||||
function inc() { this.p++; }
|
||||
console.log(function(){ var o={p:6}; inc.call(o); console.log(o.p); return o.p; }());
|
||||
console.log(function(){ var o={p:7}; console.log([o][0].p++); return o.p; }());
|
||||
}
|
||||
expect_stdout: true
|
||||
}
|
||||
|
||||
unsafe_evaluate_unknown: {
|
||||
options = {
|
||||
evaluate: true,
|
||||
reduce_vars: true,
|
||||
unsafe: true,
|
||||
unused: true,
|
||||
}
|
||||
input: {
|
||||
console.log(function(){ var o={p:1}; console.log(o.not_present); return o.p; }());
|
||||
console.log(function(){ var o={p:2}; console.log(o.prototype); return o.p; }());
|
||||
console.log(function(){ var o={p:3}; console.log(o.hasOwnProperty); return o.p; }());
|
||||
}
|
||||
expect: {
|
||||
console.log(function(){ var o={p:1}; console.log(o.not_present); return o.p; }());
|
||||
console.log(function(){ var o={p:2}; console.log(o.prototype); return o.p; }());
|
||||
console.log(function(){ var o={p:3}; console.log(o.hasOwnProperty); return o.p; }());
|
||||
}
|
||||
expect_stdout: true
|
||||
}
|
||||
|
||||
unsafe_evaluate_object_1: {
|
||||
options = {
|
||||
evaluate : true,
|
||||
reduce_vars : true,
|
||||
@@ -251,7 +360,83 @@ unsafe_evaluate_object: {
|
||||
}
|
||||
}
|
||||
|
||||
unsafe_evaluate_array: {
|
||||
unsafe_evaluate_object_2: {
|
||||
options = {
|
||||
evaluate: true,
|
||||
reduce_vars: true,
|
||||
toplevel: true,
|
||||
unsafe: true,
|
||||
}
|
||||
input: {
|
||||
var obj = {
|
||||
foo: 1,
|
||||
bar: 2,
|
||||
square: function(x) {
|
||||
return x * x;
|
||||
},
|
||||
cube: function(x) {
|
||||
return x * x * x;
|
||||
},
|
||||
};
|
||||
console.log(obj.foo, obj.bar, obj.square(2), obj.cube);
|
||||
}
|
||||
expect: {
|
||||
var obj = {
|
||||
foo: 1,
|
||||
bar: 2,
|
||||
square: function(x) {
|
||||
return x * x;
|
||||
},
|
||||
cube: function(x) {
|
||||
return x * x * x;
|
||||
},
|
||||
};
|
||||
console.log(1, 2, obj.square(2), obj.cube);
|
||||
}
|
||||
expect_stdout: true
|
||||
}
|
||||
|
||||
unsafe_evaluate_object_3: {
|
||||
options = {
|
||||
evaluate: true,
|
||||
reduce_vars: true,
|
||||
toplevel: true,
|
||||
unsafe: true,
|
||||
}
|
||||
input: {
|
||||
var obj = {
|
||||
get foo() {
|
||||
return 1;
|
||||
},
|
||||
bar: 2,
|
||||
square: function(x) {
|
||||
return x * x;
|
||||
},
|
||||
cube: function(x) {
|
||||
return x * x * x;
|
||||
},
|
||||
};
|
||||
console.log(obj.foo, obj.bar, obj.square(2), obj.cube);
|
||||
}
|
||||
expect: {
|
||||
var obj = {
|
||||
get foo() {
|
||||
return 1;
|
||||
},
|
||||
bar: 2,
|
||||
square: function(x) {
|
||||
return x * x;
|
||||
},
|
||||
cube: function(x) {
|
||||
return x * x * x;
|
||||
},
|
||||
};
|
||||
console.log(obj.foo, obj.bar, obj.square(2), obj.cube);
|
||||
}
|
||||
expect_stdout: true
|
||||
}
|
||||
|
||||
unsafe_evaluate_array_1: {
|
||||
options = {
|
||||
evaluate : true,
|
||||
reduce_vars : true,
|
||||
@@ -299,6 +484,132 @@ unsafe_evaluate_array: {
|
||||
}
|
||||
}
|
||||
|
||||
unsafe_evaluate_array_2: {
|
||||
options = {
|
||||
evaluate: true,
|
||||
reduce_vars: true,
|
||||
toplevel: true,
|
||||
unsafe: true,
|
||||
}
|
||||
input: {
|
||||
var arr = [
|
||||
1,
|
||||
2,
|
||||
function(x) {
|
||||
return x * x;
|
||||
},
|
||||
function(x) {
|
||||
return x * x * x;
|
||||
},
|
||||
];
|
||||
console.log(arr[0], arr[1], arr[2](2), arr[3]);
|
||||
}
|
||||
expect: {
|
||||
var arr = [
|
||||
1,
|
||||
2,
|
||||
function(x) {
|
||||
return x * x;
|
||||
},
|
||||
function(x) {
|
||||
return x * x * x;
|
||||
},
|
||||
];
|
||||
console.log(1, 2, arr[2](2), arr[3]);
|
||||
}
|
||||
expect_stdout: true
|
||||
}
|
||||
|
||||
unsafe_evaluate_array_3: {
|
||||
options = {
|
||||
evaluate: true,
|
||||
reduce_vars: true,
|
||||
toplevel: true,
|
||||
unsafe: true,
|
||||
}
|
||||
input: {
|
||||
var arr = [
|
||||
1,
|
||||
2,
|
||||
function() {
|
||||
return ++arr[0];
|
||||
},
|
||||
];
|
||||
console.log(arr[0], arr[1], arr[2](), arr[0]);
|
||||
}
|
||||
expect: {
|
||||
var arr = [
|
||||
1,
|
||||
2,
|
||||
function() {
|
||||
return ++arr[0];
|
||||
},
|
||||
];
|
||||
console.log(arr[0], arr[1], arr[2](), arr[0]);
|
||||
}
|
||||
expect_stdout: "1 2 2 2"
|
||||
}
|
||||
|
||||
unsafe_evaluate_array_4: {
|
||||
options = {
|
||||
evaluate: true,
|
||||
reduce_vars: true,
|
||||
toplevel: true,
|
||||
unsafe: true,
|
||||
}
|
||||
input: {
|
||||
var arr = [
|
||||
1,
|
||||
2,
|
||||
function() {
|
||||
return ++this[0];
|
||||
},
|
||||
];
|
||||
console.log(arr[0], arr[1], arr[2], arr[0]);
|
||||
}
|
||||
expect: {
|
||||
var arr = [
|
||||
1,
|
||||
2,
|
||||
function() {
|
||||
return ++this[0];
|
||||
},
|
||||
];
|
||||
console.log(1, 2, arr[2], 1);
|
||||
}
|
||||
expect_stdout: true
|
||||
}
|
||||
|
||||
unsafe_evaluate_array_5: {
|
||||
options = {
|
||||
evaluate: true,
|
||||
reduce_vars: true,
|
||||
toplevel: true,
|
||||
unsafe: true,
|
||||
}
|
||||
input: {
|
||||
var arr = [
|
||||
1,
|
||||
2,
|
||||
function() {
|
||||
return ++this[0];
|
||||
},
|
||||
];
|
||||
console.log(arr[0], arr[1], arr[2](), arr[0]);
|
||||
}
|
||||
expect: {
|
||||
var arr = [
|
||||
1,
|
||||
2,
|
||||
function() {
|
||||
return ++this[0];
|
||||
},
|
||||
];
|
||||
console.log(arr[0], arr[1], arr[2](), arr[0]);
|
||||
}
|
||||
expect_stdout: "1 2 2 2"
|
||||
}
|
||||
|
||||
unsafe_evaluate_equality_1: {
|
||||
options = {
|
||||
evaluate : true,
|
||||
@@ -2766,6 +3077,7 @@ obj_var_2: {
|
||||
evaluate: true,
|
||||
inline: true,
|
||||
passes: 2,
|
||||
properties: true,
|
||||
reduce_vars: true,
|
||||
side_effects: true,
|
||||
toplevel: true,
|
||||
@@ -2822,10 +3134,10 @@ obj_arg_2: {
|
||||
evaluate: true,
|
||||
inline: true,
|
||||
passes: 2,
|
||||
properties: true,
|
||||
reduce_vars: true,
|
||||
side_effects: true,
|
||||
toplevel: true,
|
||||
unsafe: true,
|
||||
unused: true,
|
||||
}
|
||||
input: {
|
||||
@@ -3196,3 +3508,32 @@ issue_2406_2: {
|
||||
}.fn());
|
||||
}
|
||||
}
|
||||
|
||||
escaped_prop: {
|
||||
options = {
|
||||
collapse_vars: true,
|
||||
evaluate: true,
|
||||
inline: true,
|
||||
pure_getters: "strict",
|
||||
reduce_vars: true,
|
||||
side_effects: true,
|
||||
toplevel: true,
|
||||
unsafe: true,
|
||||
unused: true,
|
||||
}
|
||||
input: {
|
||||
var obj = { o: { a: 1 } };
|
||||
(function(o) {
|
||||
o.a++;
|
||||
})(obj.o);
|
||||
(function(o) {
|
||||
console.log(o.a);
|
||||
})(obj.o);
|
||||
}
|
||||
expect: {
|
||||
var obj = { o: { a: 1 } };
|
||||
obj.o.a++;
|
||||
console.log(obj.o.a);
|
||||
}
|
||||
expect_stdout: "2"
|
||||
}
|
||||
|
||||
@@ -16,11 +16,9 @@
|
||||
{},
|
||||
{
|
||||
"compress": {
|
||||
"toplevel": true
|
||||
"hoist_props": true
|
||||
},
|
||||
"mangle": {
|
||||
"toplevel": true
|
||||
}
|
||||
"toplevel": true
|
||||
},
|
||||
{
|
||||
"compress": {
|
||||
|
||||
Reference in New Issue
Block a user