unsafe_regexp : false,
unsafe_undefined: false,
unused : !false_by_default,
- warnings : false,
}, true);
var global_defs = this.options["global_defs"];
if (typeof global_defs == "object") for (var key in global_defs) {
};
var sequences = this.options["sequences"];
this.sequences_limit = sequences == 1 ? 800 : sequences | 0;
- this.warnings_produced = {};
}
Compressor.prototype = new TreeTransformer;
node.walk(new TreeWalker(function() {
count++;
}));
- this.info("pass " + pass + ": last_count: " + min_count + ", count: " + count);
+ AST_Node.info("pass " + pass + ": last_count: " + min_count + ", count: " + count);
if (count < min_count) {
min_count = count;
stopping = false;
}
return node;
},
- info: function() {
- if (this.options.warnings == "verbose") {
- AST_Node.warn.apply(AST_Node, arguments);
- }
- },
- warn: function(text, props) {
- if (this.options.warnings) {
- // only emit unique warnings
- var message = string_template(text, props);
- if (!(message in this.warnings_produced)) {
- this.warnings_produced[message] = true;
- AST_Node.warn.apply(AST_Node, arguments);
- }
- }
- },
- clear_warnings: function() {
- this.warnings_produced = {};
- },
before: function(node, descend, in_list) {
if (node._squeezed) return node;
var is_scope = node instanceof AST_Scope;
if (value_def && candidate instanceof AST_VarDef) return node;
}
CHANGED = abort = true;
- compressor.info("Collapsing {name} [{file}:{line},{col}]", {
+ AST_Node.info("Collapsing {name} [{file}:{line},{col}]", {
name: node.print_to_string(),
file: node.start.file,
line: node.start.line,
statements.length = n;
CHANGED = n != len;
if (has_quit) has_quit.forEach(function(stat) {
- extract_declarations_from_unreachable_code(compressor, stat, statements);
+ extract_declarations_from_unreachable_code(stat, statements);
});
}
}
}
- function extract_declarations_from_unreachable_code(compressor, stat, target) {
+ function extract_declarations_from_unreachable_code(stat, target) {
if (!(stat instanceof AST_Defun)) {
- compressor.warn("Dropping unreachable code [{file}:{line},{col}]", stat.start);
+ AST_Node.warn("Dropping unreachable code [{file}:{line},{col}]", stat.start);
}
stat.walk(new TreeWalker(function(node) {
if (node instanceof AST_Definitions) {
- compressor.warn("Declarations in unreachable code! [{file}:{line},{col}]", node.start);
+ AST_Node.warn("Declarations in unreachable code! [{file}:{line},{col}]", node.start);
node.remove_initializers();
target.push(node);
return true;
return make_node_from_constant(value, orig);
}
- function warn(compressor, node) {
- compressor.warn("global_defs " + node.print_to_string() + " redefined [{file}:{line},{col}]", node.start);
+ function warn(node) {
+ AST_Node.warn("global_defs " + node.print_to_string() + " redefined [{file}:{line},{col}]", node.start);
}
AST_Toplevel.DEFMETHOD("resolve_defines", function(compressor) {
child = parent;
}
if (is_lhs(child, parent)) {
- warn(compressor, node);
+ warn(node);
return;
}
return def;
});
def(AST_SymbolDeclaration, function(compressor) {
if (!this.global()) return;
- if (HOP(compressor.option("global_defs"), this.name)) warn(compressor, this);
+ if (HOP(compressor.option("global_defs"), this.name)) warn(this);
});
def(AST_SymbolRef, function(compressor, suffix) {
if (!this.global()) return;
try {
return val[key].apply(val, args);
} catch (ex) {
- compressor.warn("Error evaluating {code} [{file}:{line},{col}]", {
+ AST_Node.warn("Error evaluating {code} [{file}:{line},{col}]", {
code: this.print_to_string(),
file: this.start.file,
line: this.start.line,
sym.__unused = true;
if (trim) {
a.pop();
- compressor[sym.unreferenced() ? "warn" : "info"]("Dropping unused function argument {name} [{file}:{line},{col}]", template(sym));
+ AST_Node[sym.unreferenced() ? "warn" : "info"]("Dropping unused function argument {name} [{file}:{line},{col}]", template(sym));
}
} else {
trim = false;
if (drop_funcs && node instanceof AST_Defun && node !== self) {
var def = node.name.definition();
if (!(def.id in in_use_ids)) {
- compressor[node.name.unreferenced() ? "warn" : "info"]("Dropping unused function {name} [{file}:{line},{col}]", template(node.name));
+ AST_Node[node.name.unreferenced() ? "warn" : "info"]("Dropping unused function {name} [{file}:{line},{col}]", template(node.name));
def.eliminated++;
return make_node(AST_EmptyStatement, node);
}
}
var var_defs = var_defs_by_id.get(sym.id);
if (var_defs.length > 1 && (!def.value || sym.orig.indexOf(def.name) > sym.eliminated)) {
- compressor.warn("Dropping duplicated definition of variable {name} [{file}:{line},{col}]", template(def.name));
+ AST_Node.warn("Dropping duplicated definition of variable {name} [{file}:{line},{col}]", template(def.name));
if (def.value) {
var ref = make_node(AST_SymbolRef, def.name, def.name);
sym.references.push(ref);
&& def.value instanceof AST_Function
&& can_rename(def.value, def.name.name)
&& (!compressor.has_directive("use strict") || parent instanceof AST_Scope)) {
- compressor.warn("Declaring {name} as function [{file}:{line},{col}]", template(def.name));
+ AST_Node.warn("Declaring {name} as function [{file}:{line},{col}]", template(def.name));
var defun = make_node(AST_Defun, def, def.value);
defun.name = make_node(AST_SymbolDefun, def.name, def.name);
var name_def = def.name.scope.resolve().def_function(defun.name);
} else {
var value = def.value && def.value.drop_side_effect_free(compressor);
if (value) {
- compressor.warn("Side effects in initialization of unused variable {name} [{file}:{line},{col}]", template(def.name));
+ AST_Node.warn("Side effects in initialization of unused variable {name} [{file}:{line},{col}]", template(def.name));
side_effects.push(value);
} else {
- compressor[def.name.unreferenced() ? "warn" : "info"]("Dropping unused variable {name} [{file}:{line},{col}]", template(def.name));
+ AST_Node[def.name.unreferenced() ? "warn" : "info"]("Dropping unused variable {name} [{file}:{line},{col}]", template(def.name));
}
sym.eliminated++;
}
}
return this;
}
- if (this.pure) {
- compressor.warn("Dropping __PURE__ call [{file}:{line},{col}]", this.start);
- }
+ if (this.pure) AST_Node.warn("Dropping __PURE__ call [{file}:{line},{col}]", this.start);
var args = trim(this.args, compressor, first_in_statement);
return args && make_sequence(this, args);
});
var body = self.body;
var node = body.drop_side_effect_free(compressor, true);
if (!node) {
- compressor.warn("Dropping side-effect-free statement [{file}:{line},{col}]", self.start);
+ AST_Node.warn("Dropping side-effect-free statement [{file}:{line},{col}]", self.start);
return make_node(AST_EmptyStatement, self);
}
if (node !== body) {
body: self.condition
}));
}
- extract_declarations_from_unreachable_code(compressor, self.body, body);
+ extract_declarations_from_unreachable_code(self.body, body);
return make_node(AST_BlockStatement, self, {
body: body
});
if (!cond) {
if (compressor.option("dead_code")) {
var body = [];
- extract_declarations_from_unreachable_code(compressor, self.body, body);
+ extract_declarations_from_unreachable_code(self.body, body);
if (self.init instanceof AST_Statement) {
body.push(self.init);
} else if (self.init) {
cond = self.condition.is_truthy() || self.condition.tail_node().evaluate(compressor);
}
if (!cond) {
- compressor.warn("Condition always false [{file}:{line},{col}]", self.condition.start);
+ AST_Node.warn("Condition always false [{file}:{line},{col}]", self.condition.start);
var body = [];
- extract_declarations_from_unreachable_code(compressor, self.body, body);
+ extract_declarations_from_unreachable_code(self.body, body);
body.push(make_node(AST_SimpleStatement, self.condition, {
body: self.condition
}));
if (self.alternative) body.push(self.alternative);
return make_node(AST_BlockStatement, self, { body: body }).optimize(compressor);
} else if (!(cond instanceof AST_Node)) {
- compressor.warn("Condition always true [{file}:{line},{col}]", self.condition.start);
+ AST_Node.warn("Condition always true [{file}:{line},{col}]", self.condition.start);
var body = [];
- if (self.alternative) {
- extract_declarations_from_unreachable_code(compressor, self.alternative, body);
- }
+ if (self.alternative) extract_declarations_from_unreachable_code(self.alternative, body);
body.push(make_node(AST_SimpleStatement, self.condition, {
body: self.condition
}));
if (prev && !aborts(prev)) {
prev.body = prev.body.concat(branch.body);
} else {
- extract_declarations_from_unreachable_code(compressor, branch, decl);
+ extract_declarations_from_unreachable_code(branch, decl);
}
}
});
if (compressor.option("dead_code") && all(self.body, is_empty)) {
var body = [];
if (self.bcatch) {
- extract_declarations_from_unreachable_code(compressor, self.bcatch, body);
+ extract_declarations_from_unreachable_code(self.bcatch, body);
body.forEach(function(stat) {
if (!(stat instanceof AST_Definitions)) return;
stat.definitions.forEach(function(var_def) {
elements: elements
});
} catch (ex) {
- compressor.warn("Invalid array length: {length} [{file}:{line},{col}]", {
+ AST_Node.warn("Invalid array length: {length} [{file}:{line},{col}]", {
length: length,
file: self.start.file,
line: self.start.line,
value: RegExp.apply(RegExp, params),
}));
} catch (ex) {
- compressor.warn("Error converting {expr} [{file}:{line},{col}]", {
+ AST_Node.warn("Error converting {expr} [{file}:{line},{col}]", {
expr: self.print_to_string(),
file: self.start.file,
line: self.start.line,
return self;
} catch (ex) {
if (ex instanceof JS_Parse_Error) {
- compressor.warn("Error parsing code passed to new Function [{file}:{line},{col}]", self.args[self.args.length - 1].start);
- compressor.warn(ex.toString());
+ AST_Node.warn("Error parsing code passed to new Function [{file}:{line},{col}]", self.args[self.args.length - 1].start);
+ AST_Node.warn(ex.toString());
} else {
throw ex;
}
case "typeof":
// typeof always returns a non-empty string, thus it's
// always true in booleans
- compressor.warn("Boolean expression always true [{file}:{line},{col}]", self.start);
+ AST_Node.warn("Boolean expression always true [{file}:{line},{col}]", self.start);
return (e instanceof AST_SymbolRef ? make_node(AST_True, self) : make_sequence(self, [
e,
make_node(AST_True, self)
case "===":
case "!==":
if (is_undefined(self.left, compressor) && self.right.is_defined(compressor)) {
- compressor.warn("Expression always defined [{file}:{line},{col}]", self.start);
+ AST_Node.warn("Expression always defined [{file}:{line},{col}]", self.start);
return make_sequence(self, [
self.right,
make_node(self.operator == "===" ? AST_False : AST_True, self)
var ll = self.left.evaluate(compressor);
var rr = self.right.evaluate(compressor);
if (ll && typeof ll == "string") {
- compressor.warn("+ in boolean context always true [{file}:{line},{col}]", self.start);
+ AST_Node.warn("+ in boolean context always true [{file}:{line},{col}]", self.start);
return make_sequence(self, [
self.right,
make_node(AST_True, self)
]).optimize(compressor);
}
if (rr && typeof rr == "string") {
- compressor.warn("+ in boolean context always true [{file}:{line},{col}]", self.start);
+ AST_Node.warn("+ in boolean context always true [{file}:{line},{col}]", self.start);
return make_sequence(self, [
self.left,
make_node(AST_True, self)
case "&&":
var ll = fuzzy_eval(self.left);
if (!ll) {
- compressor.warn("Condition left of && always false [{file}:{line},{col}]", self.start);
+ AST_Node.warn("Condition left of && always false [{file}:{line},{col}]", self.start);
return maintain_this_binding(compressor, compressor.parent(), compressor.self(), self.left).optimize(compressor);
} else if (!(ll instanceof AST_Node)) {
- compressor.warn("Condition left of && always true [{file}:{line},{col}]", self.start);
+ AST_Node.warn("Condition left of && always true [{file}:{line},{col}]", self.start);
return make_sequence(self, [ self.left, self.right ]).optimize(compressor);
}
var rr = self.right.evaluate(compressor);
if (!rr) {
if (compressor.option("booleans") && compressor.in_boolean_context()) {
- compressor.warn("Boolean && always false [{file}:{line},{col}]", self.start);
+ AST_Node.warn("Boolean && always false [{file}:{line},{col}]", self.start);
return make_sequence(self, [
self.left,
make_node(AST_False, self)
var parent = compressor.parent();
if (parent.operator == "&&" && parent.left === compressor.self()
|| compressor.option("booleans") && compressor.in_boolean_context()) {
- compressor.warn("Dropping side-effect-free && [{file}:{line},{col}]", self.start);
+ AST_Node.warn("Dropping side-effect-free && [{file}:{line},{col}]", self.start);
return self.left.optimize(compressor);
}
}
case "||":
var ll = fuzzy_eval(self.left);
if (!ll) {
- compressor.warn("Condition left of || always false [{file}:{line},{col}]", self.start);
+ AST_Node.warn("Condition left of || always false [{file}:{line},{col}]", self.start);
return make_sequence(self, [ self.left, self.right ]).optimize(compressor);
} else if (!(ll instanceof AST_Node)) {
- compressor.warn("Condition left of || always true [{file}:{line},{col}]", self.start);
+ AST_Node.warn("Condition left of || always true [{file}:{line},{col}]", self.start);
return maintain_this_binding(compressor, compressor.parent(), compressor.self(), self.left).optimize(compressor);
}
var rr = self.right.evaluate(compressor);
var parent = compressor.parent();
if (parent.operator == "||" && parent.left === compressor.self()
|| compressor.option("booleans") && compressor.in_boolean_context()) {
- compressor.warn("Dropping side-effect-free || [{file}:{line},{col}]", self.start);
+ AST_Node.warn("Dropping side-effect-free || [{file}:{line},{col}]", self.start);
return self.left.optimize(compressor);
}
} else if (!(rr instanceof AST_Node)) {
if (compressor.option("booleans") && compressor.in_boolean_context()) {
- compressor.warn("Boolean || always true [{file}:{line},{col}]", self.start);
+ AST_Node.warn("Boolean || always true [{file}:{line},{col}]", self.start);
return make_sequence(self, [
self.left,
make_node(AST_True, self)
}
var cond = self.condition.is_truthy() || self.condition.tail_node().evaluate(compressor);
if (!cond) {
- compressor.warn("Condition always false [{file}:{line},{col}]", self.start);
+ AST_Node.warn("Condition always false [{file}:{line},{col}]", self.start);
return make_sequence(self, [ self.condition, self.alternative ]).optimize(compressor);
} else if (!(cond instanceof AST_Node)) {
- compressor.warn("Condition always true [{file}:{line},{col}]", self.start);
+ AST_Node.warn("Condition always true [{file}:{line},{col}]", self.start);
return make_sequence(self, [ self.condition, self.consequent ]).optimize(compressor);
}
var negated = cond.negate(compressor, first_in_statement(compressor));
});
var p = compressor.parent();
if (p instanceof AST_Binary && (p.operator == "==" || p.operator == "!=")) {
- compressor.warn("Non-strict equality against boolean: {operator} {value} [{file}:{line},{col}]", {
+ AST_Node.warn("Non-strict equality against boolean: {operator} {value} [{file}:{line},{col}]", {
operator : p.operator,
value : self.value,
file : p.start.file,
OPT(AST_Dot, function(self, compressor) {
if (self.property == "arguments" || self.property == "caller") {
- compressor.warn("Function.prototype.{prop} not supported [{file}:{line},{col}]", {
+ AST_Node.warn("Function.prototype.{prop} not supported [{file}:{line},{col}]", {
prop: self.property,
file: self.start.file,
line: self.start.line,