diff options
Diffstat (limited to 'lib')
| -rw-r--r-- | lib/ast.js | 137 | ||||
| -rw-r--r-- | lib/compress.js | 597 | ||||
| -rw-r--r-- | lib/mozilla-ast.js | 35 | ||||
| -rw-r--r-- | lib/output.js | 230 | ||||
| -rw-r--r-- | lib/parse.js | 209 | ||||
| -rw-r--r-- | lib/propmangle.js | 8 | ||||
| -rw-r--r-- | lib/scope.js | 24 | ||||
| -rw-r--r-- | lib/sourcemap.js | 73 | ||||
| -rw-r--r-- | lib/transform.js | 132 | ||||
| -rw-r--r-- | lib/utils.js | 14 |
10 files changed, 694 insertions, 765 deletions
@@ -44,21 +44,21 @@ "use strict"; function DEFNODE(type, props, methods, base) { - if (arguments.length < 4) base = AST_Node; - if (!props) props = []; - else props = props.split(/\s+/); + if (typeof base === "undefined") base = AST_Node; + props = props ? props.split(/\s+/) : []; var self_props = props; - if (base && base.PROPS) - props = props.concat(base.PROPS); - var code = "return function AST_" + type + "(props){ if (props) { "; - for (var i = props.length; --i >= 0;) { - code += "this." + props[i] + " = props." + props[i] + ";"; - } + if (base && base.PROPS) props = props.concat(base.PROPS); + var code = [ + "return function AST_", type, "(props){", + "if(props){", + ]; + props.forEach(function(prop) { + code.push("this.", prop, "=props.", prop, ";"); + }); var proto = base && new base; - if (proto && proto.initialize || (methods && methods.initialize)) - code += "this.initialize();"; - code += "}}"; - var ctor = new Function(code)(); + if (proto && proto.initialize || methods && methods.initialize) code.push("this.initialize();"); + code.push("}}"); + var ctor = new Function(code.join(""))(); if (proto) { ctor.prototype = proto; ctor.BASE = base; @@ -71,11 +71,11 @@ function DEFNODE(type, props, methods, base) { if (type) { ctor.prototype.TYPE = ctor.TYPE = type; } - if (methods) for (i in methods) if (HOP(methods, i)) { - if (/^\$/.test(i)) { - ctor[i.substr(1)] = methods[i]; + if (methods) for (var name in methods) if (HOP(methods, name)) { + if (/^\$/.test(name)) { + ctor[name.substr(1)] = methods[name]; } else { - ctor.prototype[i] = methods[i]; + ctor.prototype[name] = methods[name]; } } ctor.DEFMETHOD = function(name, method) { @@ -85,7 +85,7 @@ function DEFNODE(type, props, methods, base) { exports["AST_" + type] = ctor; } return ctor; -}; +} var AST_Token = DEFNODE("Token", "type value line col pos endline endcol endpos nlb comments_before comments_after file raw", { }, null); @@ -148,7 +148,7 @@ var AST_SimpleStatement = DEFNODE("SimpleStatement", "body", { body: "[AST_Node] an expression node (should not be instanceof AST_Statement)" }, _walk: function(visitor) { - return visitor._visit(this, function(){ + return visitor._visit(this, function() { this.body._walk(visitor); }); } @@ -158,11 +158,10 @@ function walk_body(node, visitor) { var body = node.body; if (body instanceof AST_Statement) { body._walk(visitor); - } - else for (var i = 0, len = body.length; i < len; i++) { - body[i]._walk(visitor); - } -}; + } else body.forEach(function(node) { + node._walk(visitor); + }); +} var AST_Block = DEFNODE("Block", "body", { $documentation: "A body of statements (usually braced)", @@ -170,7 +169,7 @@ var AST_Block = DEFNODE("Block", "body", { body: "[AST_Statement*] an array of statements" }, _walk: function(visitor) { - return visitor._visit(this, function(){ + return visitor._visit(this, function() { walk_body(this, visitor); }); } @@ -197,7 +196,7 @@ var AST_LabeledStatement = DEFNODE("LabeledStatement", "label", { label: "[AST_Label] a label definition" }, _walk: function(visitor) { - return visitor._visit(this, function(){ + return visitor._visit(this, function() { this.label._walk(visitor); this.body._walk(visitor); }); @@ -233,7 +232,7 @@ var AST_DWLoop = DEFNODE("DWLoop", "condition", { var AST_Do = DEFNODE("Do", null, { $documentation: "A `do` statement", _walk: function(visitor) { - return visitor._visit(this, function(){ + return visitor._visit(this, function() { this.body._walk(visitor); this.condition._walk(visitor); }); @@ -243,7 +242,7 @@ var AST_Do = DEFNODE("Do", null, { var AST_While = DEFNODE("While", null, { $documentation: "A `while` statement", _walk: function(visitor) { - return visitor._visit(this, function(){ + return visitor._visit(this, function() { this.condition._walk(visitor); this.body._walk(visitor); }); @@ -258,7 +257,7 @@ var AST_For = DEFNODE("For", "init condition step", { step: "[AST_Node?] the `for` update clause, or null if empty" }, _walk: function(visitor) { - return visitor._visit(this, function(){ + return visitor._visit(this, function() { if (this.init) this.init._walk(visitor); if (this.condition) this.condition._walk(visitor); if (this.step) this.step._walk(visitor); @@ -274,7 +273,7 @@ var AST_ForIn = DEFNODE("ForIn", "init object", { object: "[AST_Node] the object that we're looping through" }, _walk: function(visitor) { - return visitor._visit(this, function(){ + return visitor._visit(this, function() { this.init._walk(visitor); this.object._walk(visitor); this.body._walk(visitor); @@ -288,7 +287,7 @@ var AST_With = DEFNODE("With", "expression", { expression: "[AST_Node] the `with` expression" }, _walk: function(visitor) { - return visitor._visit(this, function(){ + return visitor._visit(this, function() { this.expression._walk(visitor); this.body._walk(visitor); }); @@ -329,7 +328,7 @@ var AST_Toplevel = DEFNODE("Toplevel", "globals", { var body = this.body; var wrapped_tl = "(function(exports){'$ORIG';})(typeof " + name + "=='undefined'?(" + name + "={}):" + name + ");"; wrapped_tl = parse(wrapped_tl); - wrapped_tl = wrapped_tl.transform(new TreeTransformer(function before(node){ + wrapped_tl = wrapped_tl.transform(new TreeTransformer(function before(node) { if (node instanceof AST_Directive && node.value == "$ORIG") { return MAP.splice(body); } @@ -363,12 +362,11 @@ var AST_Lambda = DEFNODE("Lambda", "name argnames uses_arguments", { uses_arguments: "[boolean/S] tells whether this function accesses the arguments array" }, _walk: function(visitor) { - return visitor._visit(this, function(){ + return visitor._visit(this, function() { if (this.name) this.name._walk(visitor); - var argnames = this.argnames; - for (var i = 0, len = argnames.length; i < len; i++) { - argnames[i]._walk(visitor); - } + this.argnames.forEach(function(argname) { + argname._walk(visitor); + }); walk_body(this, visitor); }); } @@ -398,7 +396,7 @@ var AST_Exit = DEFNODE("Exit", "value", { value: "[AST_Node?] the value returned or thrown by this statement; could be null for AST_Return" }, _walk: function(visitor) { - return visitor._visit(this, this.value && function(){ + return visitor._visit(this, this.value && function() { this.value._walk(visitor); }); } @@ -418,7 +416,7 @@ var AST_LoopControl = DEFNODE("LoopControl", "label", { label: "[AST_LabelRef?] the label, or null if none", }, _walk: function(visitor) { - return visitor._visit(this, this.label && function(){ + return visitor._visit(this, this.label && function() { this.label._walk(visitor); }); } @@ -441,7 +439,7 @@ var AST_If = DEFNODE("If", "condition alternative", { alternative: "[AST_Statement?] the `else` part, or null if not present" }, _walk: function(visitor) { - return visitor._visit(this, function(){ + return visitor._visit(this, function() { this.condition._walk(visitor); this.body._walk(visitor); if (this.alternative) this.alternative._walk(visitor); @@ -457,7 +455,7 @@ var AST_Switch = DEFNODE("Switch", "expression", { expression: "[AST_Node] the `switch` “discriminant”" }, _walk: function(visitor) { - return visitor._visit(this, function(){ + return visitor._visit(this, function() { this.expression._walk(visitor); walk_body(this, visitor); }); @@ -478,7 +476,7 @@ var AST_Case = DEFNODE("Case", "expression", { expression: "[AST_Node] the `case` expression" }, _walk: function(visitor) { - return visitor._visit(this, function(){ + return visitor._visit(this, function() { this.expression._walk(visitor); walk_body(this, visitor); }); @@ -494,7 +492,7 @@ var AST_Try = DEFNODE("Try", "bcatch bfinally", { bfinally: "[AST_Finally?] the finally block, or null if not present" }, _walk: function(visitor) { - return visitor._visit(this, function(){ + return visitor._visit(this, function() { walk_body(this, visitor); if (this.bcatch) this.bcatch._walk(visitor); if (this.bfinally) this.bfinally._walk(visitor); @@ -508,7 +506,7 @@ var AST_Catch = DEFNODE("Catch", "argname", { argname: "[AST_SymbolCatch] symbol for the exception" }, _walk: function(visitor) { - return visitor._visit(this, function(){ + return visitor._visit(this, function() { this.argname._walk(visitor); walk_body(this, visitor); }); @@ -527,11 +525,10 @@ var AST_Definitions = DEFNODE("Definitions", "definitions", { definitions: "[AST_VarDef*] array of variable definitions" }, _walk: function(visitor) { - return visitor._visit(this, function(){ - var definitions = this.definitions; - for (var i = 0, len = definitions.length; i < len; i++) { - definitions[i]._walk(visitor); - } + return visitor._visit(this, function() { + this.definitions.forEach(function(defn) { + defn._walk(visitor); + }); }); } }, AST_Statement); @@ -547,7 +544,7 @@ var AST_VarDef = DEFNODE("VarDef", "name value", { value: "[AST_Node?] initializer, or null of there's no initializer" }, _walk: function(visitor) { - return visitor._visit(this, function(){ + return visitor._visit(this, function() { this.name._walk(visitor); if (this.value) this.value._walk(visitor); }); @@ -582,7 +579,7 @@ var AST_Sequence = DEFNODE("Sequence", "expressions", { expressions: "[AST_Node*] array of expressions (at least two)" }, _walk: function(visitor) { - return visitor._visit(this, function(){ + return visitor._visit(this, function() { this.expressions.forEach(function(node) { node._walk(visitor); }); @@ -601,7 +598,7 @@ var AST_PropAccess = DEFNODE("PropAccess", "expression property", { var AST_Dot = DEFNODE("Dot", null, { $documentation: "A dotted property access expression", _walk: function(visitor) { - return visitor._visit(this, function(){ + return visitor._visit(this, function() { this.expression._walk(visitor); }); } @@ -610,7 +607,7 @@ var AST_Dot = DEFNODE("Dot", null, { var AST_Sub = DEFNODE("Sub", null, { $documentation: "Index-style property access, i.e. `a[\"foo\"]`", _walk: function(visitor) { - return visitor._visit(this, function(){ + return visitor._visit(this, function() { this.expression._walk(visitor); this.property._walk(visitor); }); @@ -624,7 +621,7 @@ var AST_Unary = DEFNODE("Unary", "operator expression", { expression: "[AST_Node] expression that this unary operator applies to" }, _walk: function(visitor) { - return visitor._visit(this, function(){ + return visitor._visit(this, function() { this.expression._walk(visitor); }); } @@ -646,7 +643,7 @@ var AST_Binary = DEFNODE("Binary", "operator left right", { right: "[AST_Node] right-hand side expression" }, _walk: function(visitor) { - return visitor._visit(this, function(){ + return visitor._visit(this, function() { this.left._walk(visitor); this.right._walk(visitor); }); @@ -661,7 +658,7 @@ var AST_Conditional = DEFNODE("Conditional", "condition consequent alternative", alternative: "[AST_Node]" }, _walk: function(visitor) { - return visitor._visit(this, function(){ + return visitor._visit(this, function() { this.condition._walk(visitor); this.consequent._walk(visitor); this.alternative._walk(visitor); @@ -681,11 +678,10 @@ var AST_Array = DEFNODE("Array", "elements", { elements: "[AST_Node*] array of elements" }, _walk: function(visitor) { - return visitor._visit(this, function(){ - var elements = this.elements; - for (var i = 0, len = elements.length; i < len; i++) { - elements[i]._walk(visitor); - } + return visitor._visit(this, function() { + this.elements.forEach(function(element) { + element._walk(visitor); + }); }); } }); @@ -696,11 +692,10 @@ var AST_Object = DEFNODE("Object", "properties", { properties: "[AST_ObjectProperty*] array of properties" }, _walk: function(visitor) { - return visitor._visit(this, function(){ - var properties = this.properties; - for (var i = 0, len = properties.length; i < len; i++) { - properties[i]._walk(visitor); - } + return visitor._visit(this, function() { + this.properties.forEach(function(prop) { + prop._walk(visitor); + }); }); } }); @@ -712,7 +707,7 @@ var AST_ObjectProperty = DEFNODE("ObjectProperty", "key value", { value: "[AST_Node] property value. For getters and setters this is an AST_Accessor." }, _walk: function(visitor) { - return visitor._visit(this, function(){ + return visitor._visit(this, function() { this.value._walk(visitor); }); } @@ -839,12 +834,12 @@ var AST_NaN = DEFNODE("NaN", null, { var AST_Undefined = DEFNODE("Undefined", null, { $documentation: "The `undefined` value", - value: (function(){}()) + value: function(){}() }, AST_Atom); var AST_Hole = DEFNODE("Hole", null, { $documentation: "A hole in an array", - value: (function(){}()) + value: function(){}() }, AST_Atom); var AST_Infinity = DEFNODE("Infinity", null, { @@ -872,11 +867,11 @@ function TreeWalker(callback) { this.visit = callback; this.stack = []; this.directives = Object.create(null); -}; +} TreeWalker.prototype = { _visit: function(node, descend) { this.push(node); - var ret = this.visit(node, descend ? function(){ + var ret = this.visit(node, descend ? function() { descend.call(node); } : noop); if (!ret && descend) { diff --git a/lib/compress.js b/lib/compress.js index 1832f7a8..ad01e48c 100644 --- a/lib/compress.js +++ b/lib/compress.js @@ -136,7 +136,7 @@ function Compressor(options, false_by_default) { var sequences = this.options["sequences"]; this.sequences_limit = sequences == 1 ? 800 : sequences | 0; this.warnings_produced = {}; -}; +} Compressor.prototype = new TreeTransformer; merge(Compressor.prototype, { @@ -201,11 +201,10 @@ merge(Compressor.prototype, { }, before: function(node, descend, in_list) { 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; + var is_scope = node instanceof AST_Scope; + if (is_scope) { + node.hoist_properties(this); + node.hoist_declarations(this); } // Before https://github.com/mishoo/UglifyJS2/pull/1602 AST_Node.optimize() // would call AST_Node.transform() if a different instance of AST_Node is @@ -220,7 +219,7 @@ merge(Compressor.prototype, { // output and performance. descend(node, this); var opt = node.optimize(this); - if (was_scope && opt instanceof AST_Scope) { + if (is_scope) { opt.drop_unused(this); descend(opt, this); } @@ -229,24 +228,12 @@ merge(Compressor.prototype, { } }); -(function(){ - - function OPT(node, optimizer) { - node.DEFMETHOD("optimize", function(compressor){ - var self = this; - if (self._optimized) return self; - if (compressor.has_directive("use asm")) return self; - var opt = optimizer(self, compressor); - opt._optimized = true; - return opt; - }); - }; - - OPT(AST_Node, function(self, compressor){ +(function(OPT) { + OPT(AST_Node, function(self, compressor) { return self; }); - AST_Node.DEFMETHOD("equivalent_to", function(node){ + AST_Node.DEFMETHOD("equivalent_to", function(node) { return this.TYPE == node.TYPE && this.print_to_string() == node.print_to_string(); }); @@ -821,7 +808,7 @@ merge(Compressor.prototype, { tw.in_loop = saved_loop; return true; }); - })(function(node, func){ + })(function(node, func) { node.DEFMETHOD("reduce_vars", func); }); @@ -894,7 +881,7 @@ merge(Compressor.prototype, { if (!props.end) props.end = orig.end; } return new ctor(props); - }; + } function make_sequence(orig, expressions) { if (expressions.length == 1) return expressions[0]; @@ -971,21 +958,21 @@ merge(Compressor.prototype, { if (thing instanceof AST_EmptyStatement) return []; if (thing instanceof AST_Statement) return [ thing ]; throw new Error("Can't convert thing to statement array"); - }; + } function is_empty(thing) { if (thing === null) return true; if (thing instanceof AST_EmptyStatement) return true; if (thing instanceof AST_BlockStatement) return thing.body.length == 0; return false; - }; + } function loop_body(x) { if (x instanceof AST_IterationStatement) { return x.body instanceof AST_BlockStatement ? x.body : x; } return x; - }; + } function root_expr(prop) { while (prop instanceof AST_PropAccess) prop = prop.expression; @@ -1406,7 +1393,10 @@ merge(Compressor.prototype, { } } else if (expr instanceof AST_VarDef) { if (expr.value) { - candidates.push(hit_stack.slice()); + var def = expr.name.definition(); + if (def.references.length > def.replaced) { + candidates.push(hit_stack.slice()); + } extract_candidates(expr.value); } } @@ -1476,7 +1466,6 @@ merge(Compressor.prototype, { 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))) { @@ -1947,7 +1936,7 @@ merge(Compressor.prototype, { 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]; @@ -2149,7 +2138,7 @@ merge(Compressor.prototype, { if (!(stat instanceof AST_Defun)) { compressor.warn("Dropping unreachable code [{file}:{line},{col}]", stat.start); } - stat.walk(new TreeWalker(function(node){ + stat.walk(new TreeWalker(function(node) { if (node instanceof AST_Definitions) { compressor.warn("Declarations in unreachable code! [{file}:{line},{col}]", node.start); node.remove_initializers(); @@ -2164,7 +2153,7 @@ merge(Compressor.prototype, { return true; } })); - }; + } function get_value(key) { if (key instanceof AST_Constant) { @@ -2272,83 +2261,83 @@ merge(Compressor.prototype, { /* -----[ boolean/negation helpers ]----- */ // methods to determine whether an expression has a boolean result type - (function(def){ + (function(def) { var unary_bool = makePredicate("! delete"); var binary_bool = makePredicate("in instanceof == != === !== < <= >= >"); def(AST_Node, return_false); - def(AST_UnaryPrefix, function(){ + def(AST_UnaryPrefix, function() { return unary_bool[this.operator]; }); - def(AST_Binary, function(){ + def(AST_Binary, function() { return binary_bool[this.operator] || lazy_op[this.operator] && this.left.is_boolean() && this.right.is_boolean(); }); - def(AST_Conditional, function(){ + def(AST_Conditional, function() { return this.consequent.is_boolean() && this.alternative.is_boolean(); }); - def(AST_Assign, function(){ + def(AST_Assign, function() { return this.operator == "=" && this.right.is_boolean(); }); - def(AST_Sequence, function(){ + def(AST_Sequence, function() { return this.tail_node().is_boolean(); }); def(AST_True, return_true); def(AST_False, return_true); - })(function(node, func){ + })(function(node, func) { node.DEFMETHOD("is_boolean", func); }); // methods to determine if an expression has a numeric result type - (function(def){ + (function(def) { def(AST_Node, return_false); def(AST_Number, return_true); var unary = makePredicate("+ - ~ ++ --"); - def(AST_Unary, function(){ + def(AST_Unary, function() { return unary[this.operator]; }); var binary = makePredicate("- * / % & | ^ << >> >>>"); - def(AST_Binary, function(compressor){ + def(AST_Binary, function(compressor) { return binary[this.operator] || this.operator == "+" && this.left.is_number(compressor) && this.right.is_number(compressor); }); - def(AST_Assign, function(compressor){ + def(AST_Assign, function(compressor) { return binary[this.operator.slice(0, -1)] || this.operator == "=" && this.right.is_number(compressor); }); - def(AST_Sequence, function(compressor){ + def(AST_Sequence, function(compressor) { return this.tail_node().is_number(compressor); }); - def(AST_Conditional, function(compressor){ + def(AST_Conditional, function(compressor) { return this.consequent.is_number(compressor) && this.alternative.is_number(compressor); }); - })(function(node, func){ + })(function(node, func) { node.DEFMETHOD("is_number", func); }); // methods to determine if an expression has a string result type - (function(def){ + (function(def) { def(AST_Node, return_false); def(AST_String, return_true); - def(AST_UnaryPrefix, function(){ + def(AST_UnaryPrefix, function() { return this.operator == "typeof"; }); - def(AST_Binary, function(compressor){ + def(AST_Binary, function(compressor) { return this.operator == "+" && (this.left.is_string(compressor) || this.right.is_string(compressor)); }); - def(AST_Assign, function(compressor){ + def(AST_Assign, function(compressor) { return (this.operator == "=" || this.operator == "+=") && this.right.is_string(compressor); }); - def(AST_Sequence, function(compressor){ + def(AST_Sequence, function(compressor) { return this.tail_node().is_string(compressor); }); - def(AST_Conditional, function(compressor){ + def(AST_Conditional, function(compressor) { return this.consequent.is_string(compressor) && this.alternative.is_string(compressor); }); - })(function(node, func){ + })(function(node, func) { node.DEFMETHOD("is_string", func); }); @@ -2360,7 +2349,7 @@ merge(Compressor.prototype, { if (parent instanceof AST_Assign && parent.left === node) return node; } - (function(def){ + (function(def) { AST_Node.DEFMETHOD("resolve_defines", function(compressor) { if (!compressor.option("global_defs")) return; var def = this._find_defs(compressor, ""); @@ -2399,10 +2388,10 @@ merge(Compressor.prototype, { return make_node_from_constant(value, orig); } def(AST_Node, noop); - def(AST_Dot, function(compressor, suffix){ + def(AST_Dot, function(compressor, suffix) { return this.expression._find_defs(compressor, "." + this.property + suffix); }); - def(AST_SymbolRef, function(compressor, suffix){ + def(AST_SymbolRef, function(compressor, suffix) { if (!this.global()) return; var name; var defines = compressor.option("global_defs"); @@ -2418,7 +2407,7 @@ merge(Compressor.prototype, { return node; } }); - })(function(node, func){ + })(function(node, func) { node.DEFMETHOD("_find_defs", func); }); @@ -2533,13 +2522,13 @@ merge(Compressor.prototype, { convert_to_predicate(static_fns); // methods to evaluate a constant expression - (function(def){ + (function(def) { // If the node has been successfully reduced to a constant, // then its value is returned; otherwise the element itself // is returned. // They can be distinguished as constant value is never a // descendant of AST_Node. - AST_Node.DEFMETHOD("evaluate", function(compressor){ + AST_Node.DEFMETHOD("evaluate", function(compressor) { if (!compressor.option("evaluate")) return this; var cached = []; var val = this._eval(compressor, cached, 1); @@ -2551,7 +2540,7 @@ merge(Compressor.prototype, { return val; }); var unaryPrefix = makePredicate("! ~ - + void"); - AST_Node.DEFMETHOD("is_constant", function(){ + AST_Node.DEFMETHOD("is_constant", function() { // Accomodate when compress option evaluate=false // as well as the common constant expressions !0 and -1 if (this instanceof AST_Constant) { @@ -2562,12 +2551,12 @@ merge(Compressor.prototype, { && unaryPrefix[this.operator]; } }); - def(AST_Statement, function(){ + def(AST_Statement, function() { throw new Error(string_template("Cannot evaluate a statement [{file}:{line},{col}]", this.start)); }); def(AST_Lambda, return_this); def(AST_Node, return_this); - def(AST_Constant, function(){ + def(AST_Constant, function() { return this.getValue(); }); def(AST_Function, function(compressor) { @@ -2811,12 +2800,12 @@ merge(Compressor.prototype, { return this; }); def(AST_New, return_this); - })(function(node, func){ + })(function(node, func) { node.DEFMETHOD("_eval", func); }); // method to negate an expression - (function(def){ + (function(def) { function basic_negation(exp) { return make_node(AST_UnaryPrefix, exp, { operator: "!", @@ -2833,32 +2822,32 @@ merge(Compressor.prototype, { } return best_of_expression(negated, alt); } - def(AST_Node, function(){ + def(AST_Node, function() { return basic_negation(this); }); - def(AST_Statement, function(){ + def(AST_Statement, function() { throw new Error("Cannot negate a statement"); }); - def(AST_Function, function(){ + def(AST_Function, function() { return basic_negation(this); }); - def(AST_UnaryPrefix, function(){ + def(AST_UnaryPrefix, function() { if (this.operator == "!") return this.expression; return basic_negation(this); }); - def(AST_Sequence, function(compressor){ + def(AST_Sequence, function(compressor) { var expressions = this.expressions.slice(); expressions.push(expressions.pop().negate(compressor)); return make_sequence(this, expressions); }); - def(AST_Conditional, function(compressor, first_in_statement){ + def(AST_Conditional, function(compressor, first_in_statement) { var self = this.clone(); self.consequent = self.consequent.negate(compressor); self.alternative = self.alternative.negate(compressor); return best(this, self, first_in_statement); }); - def(AST_Binary, function(compressor, first_in_statement){ + def(AST_Binary, function(compressor, first_in_statement) { var self = this.clone(), op = this.operator; if (compressor.option("unsafe_comps")) { switch (op) { @@ -2886,8 +2875,8 @@ merge(Compressor.prototype, { } return basic_negation(this); }); - })(function(node, func){ - node.DEFMETHOD("negate", function(compressor, first_in_statement){ + })(function(node, func) { + node.DEFMETHOD("negate", function(compressor, first_in_statement) { return func.call(this, compressor, first_in_statement); }); }); @@ -2926,7 +2915,7 @@ merge(Compressor.prototype, { }); // determine if expression has side effects - (function(def){ + (function(def) { def(AST_Node, return_true); def(AST_EmptyStatement, return_false); @@ -2940,10 +2929,10 @@ merge(Compressor.prototype, { return false; } - def(AST_Block, function(compressor){ + def(AST_Block, function(compressor) { return any(this.body, compressor); }); - def(AST_Call, function(compressor){ + def(AST_Call, function(compressor) { if (!this.is_expr_pure(compressor) && (!this.expression.is_call_pure(compressor) || this.expression.has_side_effects(compressor))) { @@ -2951,82 +2940,82 @@ merge(Compressor.prototype, { } return any(this.args, compressor); }); - def(AST_Switch, function(compressor){ + def(AST_Switch, function(compressor) { return this.expression.has_side_effects(compressor) || any(this.body, compressor); }); - def(AST_Case, function(compressor){ + def(AST_Case, function(compressor) { return this.expression.has_side_effects(compressor) || any(this.body, compressor); }); - def(AST_Try, function(compressor){ + def(AST_Try, function(compressor) { return any(this.body, compressor) || this.bcatch && this.bcatch.has_side_effects(compressor) || this.bfinally && this.bfinally.has_side_effects(compressor); }); - def(AST_If, function(compressor){ + def(AST_If, function(compressor) { return this.condition.has_side_effects(compressor) || this.body && this.body.has_side_effects(compressor) || this.alternative && this.alternative.has_side_effects(compressor); }); - def(AST_LabeledStatement, function(compressor){ + def(AST_LabeledStatement, function(compressor) { return this.body.has_side_effects(compressor); }); - def(AST_SimpleStatement, function(compressor){ + def(AST_SimpleStatement, function(compressor) { return this.body.has_side_effects(compressor); }); def(AST_Lambda, return_false); - def(AST_Binary, function(compressor){ + def(AST_Binary, function(compressor) { return this.left.has_side_effects(compressor) || this.right.has_side_effects(compressor); }); def(AST_Assign, return_true); - def(AST_Conditional, function(compressor){ + def(AST_Conditional, function(compressor) { return this.condition.has_side_effects(compressor) || this.consequent.has_side_effects(compressor) || this.alternative.has_side_effects(compressor); }); - def(AST_Unary, function(compressor){ + def(AST_Unary, function(compressor) { return unary_side_effects[this.operator] || this.expression.has_side_effects(compressor); }); - def(AST_SymbolRef, function(compressor){ + def(AST_SymbolRef, function(compressor) { return !this.is_declared(compressor); }); def(AST_SymbolDeclaration, return_false); - def(AST_Object, function(compressor){ + def(AST_Object, function(compressor) { return any(this.properties, compressor); }); - def(AST_ObjectProperty, function(compressor){ + def(AST_ObjectProperty, function(compressor) { return this.value.has_side_effects(compressor); }); - def(AST_Array, function(compressor){ + def(AST_Array, function(compressor) { return any(this.elements, compressor); }); - def(AST_Dot, function(compressor){ + def(AST_Dot, function(compressor) { return this.expression.may_throw_on_access(compressor) || this.expression.has_side_effects(compressor); }); - def(AST_Sub, function(compressor){ + def(AST_Sub, function(compressor) { return this.expression.may_throw_on_access(compressor) || this.expression.has_side_effects(compressor) || this.property.has_side_effects(compressor); }); - def(AST_Sequence, function(compressor){ + def(AST_Sequence, function(compressor) { return any(this.expressions, compressor); }); - def(AST_Definitions, function(compressor){ + def(AST_Definitions, function(compressor) { return any(this.definitions, compressor); }); - def(AST_VarDef, function(compressor){ + def(AST_VarDef, function(compressor) { return this.value; }); - })(function(node, func){ + })(function(node, func) { node.DEFMETHOD("has_side_effects", func); }); // determine if expression may throw - (function(def){ + (function(def) { def(AST_Node, return_true); def(AST_Constant, return_false); @@ -3042,10 +3031,10 @@ merge(Compressor.prototype, { return false; } - def(AST_Array, function(compressor){ + def(AST_Array, function(compressor) { return any(this.elements, compressor); }); - def(AST_Assign, function(compressor){ + def(AST_Assign, function(compressor) { if (this.right.may_throw(compressor)) return true; if (!compressor.has_directive("use strict") && this.operator == "=" @@ -3054,90 +3043,90 @@ merge(Compressor.prototype, { } return this.left.may_throw(compressor); }); - def(AST_Binary, function(compressor){ + def(AST_Binary, function(compressor) { return this.left.may_throw(compressor) || this.right.may_throw(compressor); }); - def(AST_Block, function(compressor){ + def(AST_Block, function(compressor) { return any(this.body, compressor); }); - def(AST_Call, function(compressor){ + def(AST_Call, function(compressor) { if (any(this.args, compressor)) return true; if (this.is_expr_pure(compressor)) return false; if (this.expression.may_throw(compressor)) return true; return !(this.expression instanceof AST_Lambda) || any(this.expression.body, compressor); }); - def(AST_Case, function(compressor){ + def(AST_Case, function(compressor) { return this.expression.may_throw(compressor) || any(this.body, compressor); }); - def(AST_Conditional, function(compressor){ + def(AST_Conditional, function(compressor) { return this.condition.may_throw(compressor) || this.consequent.may_throw(compressor) || this.alternative.may_throw(compressor); }); - def(AST_Definitions, function(compressor){ + def(AST_Definitions, function(compressor) { return any(this.definitions, compressor); }); - def(AST_Dot, function(compressor){ + def(AST_Dot, function(compressor) { return this.expression.may_throw_on_access(compressor) || this.expression.may_throw(compressor); }); - def(AST_If, function(compressor){ + def(AST_If, function(compressor) { return this.condition.may_throw(compressor) || this.body && this.body.may_throw(compressor) || this.alternative && this.alternative.may_throw(compressor); }); - def(AST_LabeledStatement, function(compressor){ + def(AST_LabeledStatement, function(compressor) { return this.body.may_throw(compressor); }); - def(AST_Object, function(compressor){ + def(AST_Object, function(compressor) { return any(this.properties, compressor); }); - def(AST_ObjectProperty, function(compressor){ + def(AST_ObjectProperty, function(compressor) { return this.value.may_throw(compressor); }); - def(AST_Return, function(compressor){ + def(AST_Return, function(compressor) { return this.value && this.value.may_throw(compressor); }); - def(AST_Sequence, function(compressor){ + def(AST_Sequence, function(compressor) { return any(this.expressions, compressor); }); - def(AST_SimpleStatement, function(compressor){ + def(AST_SimpleStatement, function(compressor) { return this.body.may_throw(compressor); }); - def(AST_Sub, function(compressor){ + def(AST_Sub, function(compressor) { return this.expression.may_throw_on_access(compressor) || this.expression.may_throw(compressor) || this.property.may_throw(compressor); }); - def(AST_Switch, function(compressor){ + def(AST_Switch, function(compressor) { return this.expression.may_throw(compressor) || any(this.body, compressor); }); - def(AST_SymbolRef, function(compressor){ + def(AST_SymbolRef, function(compressor) { return !this.is_declared(compressor); }); - def(AST_Try, function(compressor){ + def(AST_Try, function(compressor) { return this.bcatch ? this.bcatch.may_throw(compressor) : any(this.body, compressor) || this.bfinally && this.bfinally.may_throw(compressor); }); - def(AST_Unary, function(compressor){ + def(AST_Unary, function(compressor) { if (this.operator == "typeof" && this.expression instanceof AST_SymbolRef) return false; return this.expression.may_throw(compressor); }); - def(AST_VarDef, function(compressor){ + def(AST_VarDef, function(compressor) { if (!this.value) return false; return this.value.may_throw(compressor); }); - })(function(node, func){ + })(function(node, func) { node.DEFMETHOD("may_throw", func); }); // determine if expression is constant - (function(def){ + (function(def) { function all(list) { for (var i = list.length; --i >= 0;) if (!list[i].is_constant_expression()) @@ -3146,7 +3135,7 @@ merge(Compressor.prototype, { } def(AST_Node, return_false); def(AST_Constant, return_true); - def(AST_Lambda, function(scope){ + def(AST_Lambda, function(scope) { var self = this; var result = true; self.walk(new TreeWalker(function(node) { @@ -3173,61 +3162,61 @@ merge(Compressor.prototype, { })); return result; }); - def(AST_Unary, function(){ + def(AST_Unary, function() { return this.expression.is_constant_expression(); }); - def(AST_Binary, function(){ + def(AST_Binary, function() { return this.left.is_constant_expression() && this.right.is_constant_expression(); }); - def(AST_Array, function(){ + def(AST_Array, function() { return all(this.elements); }); - def(AST_Object, function(){ + def(AST_Object, function() { return all(this.properties); }); - def(AST_ObjectProperty, function(){ + def(AST_ObjectProperty, function() { return this.value.is_constant_expression(); }); - })(function(node, func){ + })(function(node, func) { node.DEFMETHOD("is_constant_expression", func); }); // tell me if a statement aborts function aborts(thing) { return thing && thing.aborts(); - }; - (function(def){ + } + (function(def) { def(AST_Statement, return_null); def(AST_Jump, return_this); - function block_aborts(){ + function block_aborts() { var n = this.body.length; return n > 0 && aborts(this.body[n - 1]); - }; + } def(AST_BlockStatement, block_aborts); def(AST_SwitchBranch, block_aborts); - def(AST_If, function(){ + def(AST_If, function() { return this.alternative && aborts(this.body) && aborts(this.alternative) && this; }); - })(function(node, func){ + })(function(node, func) { node.DEFMETHOD("aborts", func); }); /* -----[ optimizers ]----- */ - OPT(AST_Directive, function(self, compressor){ + OPT(AST_Directive, function(self, compressor) { if (compressor.has_directive(self.value) !== self) { return make_node(AST_EmptyStatement, self); } return self; }); - OPT(AST_Debugger, function(self, compressor){ + OPT(AST_Debugger, function(self, compressor) { if (compressor.option("drop_debugger")) return make_node(AST_EmptyStatement, self); return self; }); - OPT(AST_LabeledStatement, function(self, compressor){ + OPT(AST_LabeledStatement, function(self, compressor) { if (self.body instanceof AST_Break && compressor.loopcontrol_target(self.body) === self.body) { return make_node(AST_EmptyStatement, self); @@ -3235,12 +3224,12 @@ merge(Compressor.prototype, { return self.label.references.length == 0 ? self.body : self; }); - OPT(AST_Block, function(self, compressor){ + OPT(AST_Block, function(self, compressor) { tighten_body(self.body, compressor); return self; }); - OPT(AST_BlockStatement, function(self, compressor){ + OPT(AST_BlockStatement, function(self, compressor) { tighten_body(self.body, compressor); switch (self.body.length) { case 1: return self.body[0]; @@ -3249,7 +3238,7 @@ merge(Compressor.prototype, { return self; }); - OPT(AST_Lambda, function(self, compressor){ + OPT(AST_Lambda, function(self, compressor) { tighten_body(self.body, compressor); if (compressor.option("side_effects") && self.body.length == 1 @@ -3259,7 +3248,7 @@ merge(Compressor.prototype, { return self; }); - AST_Scope.DEFMETHOD("drop_unused", function(compressor){ + AST_Scope.DEFMETHOD("drop_unused", function(compressor) { if (!compressor.option("unused")) return; if (compressor.has_directive("use asm")) return; var self = this; @@ -3299,7 +3288,7 @@ merge(Compressor.prototype, { // pass 1: find out which symbols are directly used in // this scope (not in nested scopes). var scope = this; - var tw = new TreeWalker(function(node, descend){ + var tw = new TreeWalker(function(node, descend) { if (node === self) return; if (node instanceof AST_Defun) { var node_def = node.name.definition(); @@ -3316,7 +3305,7 @@ merge(Compressor.prototype, { var_defs_by_id.add(node.definition().id, node); } if (node instanceof AST_Definitions && scope === self) { - node.definitions.forEach(function(def){ + node.definitions.forEach(function(def) { var node_def = def.name.definition(); if (def.name instanceof AST_SymbolVar) { var_defs_by_id.add(node_def.id, def); @@ -3607,135 +3596,128 @@ merge(Compressor.prototype, { } }); - AST_Scope.DEFMETHOD("hoist_declarations", function(compressor){ - var self = this; - if (compressor.has_directive("use asm")) return self; + AST_Scope.DEFMETHOD("hoist_declarations", function(compressor) { + if (compressor.has_directive("use asm")) return; var hoist_funs = compressor.option("hoist_funs"); var hoist_vars = compressor.option("hoist_vars"); - if (hoist_funs || hoist_vars) { - var dirs = []; - var hoisted = []; - var vars = new Dictionary(), vars_found = 0, var_decl = 0; + var self = this; + if (hoist_vars) { // let's count var_decl first, we seem to waste a lot of // space if we hoist `var` when there's only one. - self.walk(new TreeWalker(function(node){ - if (node instanceof AST_Scope && node !== self) - return true; + var var_decl = 0; + self.walk(new TreeWalker(function(node) { + if (var_decl > 1) return true; + if (node instanceof AST_Scope && node !== self) return true; if (node instanceof AST_Var) { - ++var_decl; + var_decl++; return true; } })); - hoist_vars = hoist_vars && var_decl > 1; - var tt = new TreeTransformer( - function before(node) { - if (node !== self) { - if (node instanceof AST_Directive) { - dirs.push(node); - return make_node(AST_EmptyStatement, node); - } - if (hoist_funs && node instanceof AST_Defun - && (tt.parent() === self || !compressor.has_directive("use strict"))) { - hoisted.push(node); - return make_node(AST_EmptyStatement, node); - } - if (hoist_vars && node instanceof AST_Var) { - node.definitions.forEach(function(def){ - vars.set(def.name.name, def); - ++vars_found; - }); - var seq = node.to_assignments(compressor); - var p = tt.parent(); - if (p instanceof AST_ForIn && p.init === node) { - if (seq == null) { - var def = node.definitions[0].name; - return make_node(AST_SymbolRef, def, def); - } - return seq; - } - if (p instanceof AST_For && p.init === node) { - return seq; - } - if (!seq) return make_node(AST_EmptyStatement, node); - return make_node(AST_SimpleStatement, node, { - body: seq - }); - } - if (node instanceof AST_Scope) - return node; // to avoid descending in nested scopes - } - } - ); - self = self.transform(tt); - if (vars_found > 0) { - // collect only vars which don't show up in self's arguments list - var defs = []; - vars.each(function(def, name){ - if (self instanceof AST_Lambda - && !all(self.argnames, function(argname) { - return argname.name != name; - })) { - vars.del(name); - } else { - def = def.clone(); - def.value = null; - defs.push(def); - vars.set(name, def); - } + if (var_decl <= 1) hoist_vars = false; + } + if (!hoist_funs && !hoist_vars) return; + var dirs = []; + var hoisted = []; + var vars = new Dictionary(), vars_found = 0; + var tt = new TreeTransformer(function(node) { + if (node === self) return; + if (node instanceof AST_Directive) { + dirs.push(node); + return make_node(AST_EmptyStatement, node); + } + if (hoist_funs && node instanceof AST_Defun + && (tt.parent() === self || !compressor.has_directive("use strict"))) { + hoisted.push(node); + return make_node(AST_EmptyStatement, node); + } + if (hoist_vars && node instanceof AST_Var) { + node.definitions.forEach(function(def) { + vars.set(def.name.name, def); + ++vars_found; }); - if (defs.length > 0) { - // try to merge in assignments - for (var i = 0; i < self.body.length;) { - if (self.body[i] instanceof AST_SimpleStatement) { - var expr = self.body[i].body, sym, assign; - if (expr instanceof AST_Assign - && expr.operator == "=" - && (sym = expr.left) instanceof AST_Symbol - && vars.has(sym.name)) - { - var def = vars.get(sym.name); - if (def.value) break; - def.value = expr.right; - remove(defs, def); - defs.push(def); - self.body.splice(i, 1); - continue; - } - if (expr instanceof AST_Sequence - && (assign = expr.expressions[0]) instanceof AST_Assign - && assign.operator == "=" - && (sym = assign.left) instanceof AST_Symbol - && vars.has(sym.name)) - { - var def = vars.get(sym.name); - if (def.value) break; - def.value = assign.right; - remove(defs, def); - defs.push(def); - self.body[i].body = make_sequence(expr, expr.expressions.slice(1)); - continue; - } - } - if (self.body[i] instanceof AST_EmptyStatement) { + var seq = node.to_assignments(compressor); + var p = tt.parent(); + if (p instanceof AST_ForIn && p.init === node) { + if (seq) return seq; + var def = node.definitions[0].name; + return make_node(AST_SymbolRef, def, def); + } + if (p instanceof AST_For && p.init === node) return seq; + if (!seq) return make_node(AST_EmptyStatement, node); + return make_node(AST_SimpleStatement, node, { + body: seq + }); + } + if (node instanceof AST_Scope) return node; + }); + self.transform(tt); + if (vars_found > 0) { + // collect only vars which don't show up in self's arguments list + var defs = []; + vars.each(function(def, name) { + if (self instanceof AST_Lambda + && !all(self.argnames, function(argname) { + return argname.name != name; + })) { + vars.del(name); + } else { + def = def.clone(); + def.value = null; + defs.push(def); + vars.set(name, def); + } + }); + if (defs.length > 0) { + // try to merge in assignments + for (var i = 0; i < self.body.length;) { + if (self.body[i] instanceof AST_SimpleStatement) { + var expr = self.body[i].body, sym, assign; + if (expr instanceof AST_Assign + && expr.operator == "=" + && (sym = expr.left) instanceof AST_Symbol + && vars.has(sym.name)) + { + var def = vars.get(sym.name); + if (def.value) break; + def.value = expr.right; + remove(defs, def); + defs.push(def); self.body.splice(i, 1); continue; } - if (self.body[i] instanceof AST_BlockStatement) { - var tmp = [ i, 1 ].concat(self.body[i].body); - self.body.splice.apply(self.body, tmp); + if (expr instanceof AST_Sequence + && (assign = expr.expressions[0]) instanceof AST_Assign + && assign.operator == "=" + && (sym = assign.left) instanceof AST_Symbol + && vars.has(sym.name)) + { + var def = vars.get(sym.name); + if (def.value) break; + def.value = assign.right; + remove(defs, def); + defs.push(def); + self.body[i].body = make_sequence(expr, expr.expressions.slice(1)); continue; } - break; } - defs = make_node(AST_Var, self, { - definitions: defs - }); - hoisted.push(defs); - }; + if (self.body[i] instanceof AST_EmptyStatement) { + self.body.splice(i, 1); + continue; + } + if (self.body[i] instanceof AST_BlockStatement) { + var tmp = [ i, 1 ].concat(self.body[i].body); + self.body.splice.apply(self.body, tmp); + continue; + } + break; + } + defs = make_node(AST_Var, self, { + definitions: defs + }); + hoisted.push(defs); } - self.body = dirs.concat(hoisted, self.body); } - return self; + self.body = dirs.concat(hoisted, self.body); }); AST_Scope.DEFMETHOD("var_names", function() { @@ -3761,12 +3743,12 @@ merge(Compressor.prototype, { return name; }); - AST_Scope.DEFMETHOD("hoist_properties", function(compressor){ + AST_Scope.DEFMETHOD("hoist_properties", function(compressor) { + if (!compressor.option("hoist_props") || compressor.has_directive("use asm")) return; var self = this; - if (!compressor.option("hoist_props") || compressor.has_directive("use asm")) return self; var top_retain = self instanceof AST_Toplevel && compressor.top_retain || return_false; var defs_by_id = Object.create(null); - return self.transform(new TreeTransformer(function(node, descend) { + self.transform(new TreeTransformer(function(node, descend) { if (node instanceof AST_Assign && node.operator == "=" && node.write_only @@ -3832,6 +3814,7 @@ merge(Compressor.prototype, { if (def.assignments != count) return; if (def.direct_access) return; if (def.escaped == 1) return; + if (def.references.length == count) return; if (def.single_use) return; if (top_retain(def)) return; if (sym.fixed_value() !== right) return; @@ -3853,7 +3836,7 @@ merge(Compressor.prototype, { // drop_side_effect_free() // remove side-effect-free parts which only affects return value - (function(def){ + (function(def) { // 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 @@ -3876,7 +3859,7 @@ merge(Compressor.prototype, { def(AST_Node, return_this); def(AST_Constant, return_null); def(AST_This, return_null); - def(AST_Call, function(compressor, first_in_statement){ + def(AST_Call, function(compressor, first_in_statement) { if (!this.is_expr_pure(compressor)) { if (this.expression.is_call_pure(compressor)) { var exprs = this.args.slice(); @@ -3908,7 +3891,7 @@ merge(Compressor.prototype, { }); def(AST_Accessor, return_null); def(AST_Function, return_null); - def(AST_Binary, function(compressor, first_in_statement){ + def(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[this.operator]) { @@ -3922,7 +3905,7 @@ merge(Compressor.prototype, { return make_sequence(this, [ left, right ]); } }); - def(AST_Assign, function(compressor){ + def(AST_Assign, function(compressor) { var left = this.left; if (left.has_side_effects(compressor) || compressor.has_directive("use strict") @@ -3936,7 +3919,7 @@ merge(Compressor.prototype, { } return this; }); - def(AST_Conditional, function(compressor){ + def(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; @@ -3955,7 +3938,7 @@ merge(Compressor.prototype, { node.alternative = alternative; return node; }); - def(AST_Unary, function(compressor, first_in_statement){ + def(AST_Unary, function(compressor, first_in_statement) { if (unary_side_effects[this.operator]) { this.write_only = !this.expression.has_side_effects(compressor); return this; @@ -3971,22 +3954,22 @@ merge(Compressor.prototype, { def(AST_SymbolRef, function(compressor) { return this.is_declared(compressor) ? null : this; }); - def(AST_Object, function(compressor, first_in_statement){ + def(AST_Object, function(compressor, first_in_statement) { var values = trim(this.properties, compressor, first_in_statement); return values && make_sequence(this, values); }); - def(AST_ObjectProperty, function(compressor, first_in_statement){ + def(AST_ObjectProperty, function(compressor, first_in_statement) { return this.value.drop_side_effect_free(compressor, first_in_statement); }); - def(AST_Array, function(compressor, first_in_statement){ + def(AST_Array, function(compressor, first_in_statement) { var values = trim(this.elements, compressor, first_in_statement); return values && make_sequence(this, values); }); - def(AST_Dot, function(compressor, first_in_statement){ + def(AST_Dot, function(compressor, first_in_statement) { if (this.expression.may_throw_on_access(compressor)) return this; return this.expression.drop_side_effect_free(compressor, first_in_statement); }); - def(AST_Sub, function(compressor, first_in_statement){ + def(AST_Sub, function(compressor, first_in_statement) { if (this.expression.may_throw_on_access(compressor)) return this; var expression = this.expression.drop_side_effect_free(compressor, first_in_statement); if (!expression) return this.property.drop_side_effect_free(compressor, first_in_statement); @@ -3994,7 +3977,7 @@ merge(Compressor.prototype, { if (!property) return expression; return make_sequence(this, [ expression, property ]); }); - def(AST_Sequence, function(compressor){ + def(AST_Sequence, function(compressor) { var last = this.tail_node(); var expr = last.drop_side_effect_free(compressor); if (expr === last) return this; @@ -4002,11 +3985,11 @@ merge(Compressor.prototype, { if (expr) expressions.push(expr); return make_sequence(this, expressions); }); - })(function(node, func){ + })(function(node, func) { node.DEFMETHOD("drop_side_effect_free", func); }); - OPT(AST_SimpleStatement, function(self, compressor){ + OPT(AST_SimpleStatement, function(self, compressor) { if (compressor.option("side_effects")) { var body = self.body; var node = body.drop_side_effect_free(compressor, true); @@ -4021,7 +4004,7 @@ merge(Compressor.prototype, { return self; }); - OPT(AST_While, function(self, compressor){ + OPT(AST_While, function(self, compressor) { return compressor.option("loops") ? make_node(AST_For, self, self).optimize(compressor) : self; }); @@ -4039,7 +4022,7 @@ merge(Compressor.prototype, { return found; } - OPT(AST_Do, function(self, compressor){ + OPT(AST_Do, function(self, compressor) { if (!compressor.option("loops")) return self; var cond = self.condition.is_truthy() || self.condition.tail_node().evaluate(compressor); if (!(cond instanceof AST_Node)) { @@ -4142,7 +4125,7 @@ merge(Compressor.prototype, { } } - OPT(AST_For, function(self, compressor){ + OPT(AST_For, function(self, compressor) { if (!compressor.option("loops")) return self; if (compressor.option("side_effects") && self.init) { self.init = self.init.drop_side_effect_free(compressor); @@ -4191,7 +4174,7 @@ merge(Compressor.prototype, { return if_break_in_loop(self, compressor); }); - OPT(AST_If, function(self, compressor){ + OPT(AST_If, function(self, compressor) { if (is_empty(self.alternative)) self.alternative = null; if (!compressor.option("conditionals")) return self; @@ -4337,7 +4320,7 @@ merge(Compressor.prototype, { return self; }); - OPT(AST_Switch, function(self, compressor){ + OPT(AST_Switch, function(self, compressor) { if (!compressor.option("switches")) return self; var branch; var value = self.expression.evaluate(compressor); @@ -4443,7 +4426,7 @@ merge(Compressor.prototype, { } }); - OPT(AST_Try, function(self, compressor){ + OPT(AST_Try, function(self, compressor) { tighten_body(self.body, compressor); if (self.bcatch && self.bfinally && all(self.bfinally.body, is_empty)) self.bfinally = null; if (compressor.option("dead_code") && all(self.body, is_empty)) { @@ -4468,13 +4451,15 @@ merge(Compressor.prototype, { return self; }); - AST_Definitions.DEFMETHOD("remove_initializers", function(){ - this.definitions.forEach(function(def){ def.value = null }); + AST_Definitions.DEFMETHOD("remove_initializers", function() { + this.definitions.forEach(function(def) { + def.value = null; + }); }); - AST_Definitions.DEFMETHOD("to_assignments", function(compressor){ + AST_Definitions.DEFMETHOD("to_assignments", function(compressor) { var reduce_vars = compressor.option("reduce_vars"); - var assignments = this.definitions.reduce(function(a, def){ + var assignments = this.definitions.reduce(function(a, def) { if (def.value) { var name = make_node(AST_SymbolRef, def.name, def.name); a.push(make_node(AST_Assign, def, { @@ -4493,7 +4478,7 @@ merge(Compressor.prototype, { return make_sequence(this, assignments); }); - OPT(AST_Definitions, function(self, compressor){ + OPT(AST_Definitions, function(self, compressor) { if (self.definitions.length == 0) return make_node(AST_EmptyStatement, self); return self; @@ -4669,7 +4654,7 @@ merge(Compressor.prototype, { } else { first = make_node(AST_String, self, { value: "" }); } - return elements.reduce(function(prev, el){ + return elements.reduce(function(prev, el) { return make_node(AST_Binary, el, { operator : "+", left : prev, @@ -5048,7 +5033,7 @@ merge(Compressor.prototype, { return self; }); - OPT(AST_Sequence, function(self, compressor){ + OPT(AST_Sequence, function(self, compressor) { if (!compressor.option("side_effects")) return self; var expressions = []; filter_for_side_effects(); @@ -5086,7 +5071,7 @@ merge(Compressor.prototype, { } }); - AST_Unary.DEFMETHOD("lift_sequences", function(compressor){ + AST_Unary.DEFMETHOD("lift_sequences", function(compressor) { if (compressor.option("sequences") && this.expression instanceof AST_Sequence) { var x = this.expression.expressions.slice(); var e = this.clone(); @@ -5097,11 +5082,11 @@ merge(Compressor.prototype, { return this; }); - OPT(AST_UnaryPostfix, function(self, compressor){ + OPT(AST_UnaryPostfix, function(self, compressor) { return self.lift_sequences(compressor); }); - OPT(AST_UnaryPrefix, function(self, compressor){ + OPT(AST_UnaryPrefix, function(self, compressor) { var e = self.expression; if (self.operator == "delete" && !(e instanceof AST_SymbolRef @@ -5177,7 +5162,7 @@ merge(Compressor.prototype, { return self; }); - AST_Binary.DEFMETHOD("lift_sequences", function(compressor){ + AST_Binary.DEFMETHOD("lift_sequences", function(compressor) { if (compressor.option("sequences")) { if (this.left instanceof AST_Sequence) { var x = this.left.expressions.slice(); @@ -5218,7 +5203,7 @@ merge(Compressor.prototype, { || node instanceof AST_Object; } - OPT(AST_Binary, function(self, compressor){ + OPT(AST_Binary, function(self, compressor) { function reversible() { return self.left.is_constant() || self.right.is_constant() @@ -5666,7 +5651,7 @@ merge(Compressor.prototype, { return node; } - OPT(AST_SymbolRef, function(self, compressor){ + OPT(AST_SymbolRef, function(self, compressor) { var def = self.resolve_defines(compressor); if (def) { return def.optimize(compressor); @@ -5799,7 +5784,7 @@ merge(Compressor.prototype, { return lhs instanceof AST_SymbolRef || lhs.TYPE === self.TYPE; } - OPT(AST_Undefined, function(self, compressor){ + OPT(AST_Undefined, function(self, compressor) { if (compressor.option("unsafe_undefined")) { var undef = find_variable(compressor, "undefined"); if (undef) { @@ -5822,7 +5807,7 @@ merge(Compressor.prototype, { }); }); - OPT(AST_Infinity, function(self, compressor){ + OPT(AST_Infinity, function(self, compressor) { var lhs = is_lhs(compressor.self(), compressor.parent()); if (lhs && is_atomic(lhs, self)) return self; if (compressor.option("keep_infinity") @@ -5840,7 +5825,7 @@ merge(Compressor.prototype, { }); }); - OPT(AST_NaN, function(self, compressor){ + OPT(AST_NaN, function(self, compressor) { var lhs = is_lhs(compressor.self(), compressor.parent()); if (lhs && !is_atomic(lhs, self) || find_variable(compressor, "NaN")) { @@ -5880,7 +5865,7 @@ merge(Compressor.prototype, { var ASSIGN_OPS = makePredicate("+ - / * % >> << >>> | ^ &"); var ASSIGN_OPS_COMMUTATIVE = makePredicate("* | ^ &"); - OPT(AST_Assign, function(self, compressor){ + OPT(AST_Assign, function(self, compressor) { var def; if (compressor.option("dead_code") && self.left instanceof AST_SymbolRef @@ -5940,7 +5925,7 @@ merge(Compressor.prototype, { } }); - OPT(AST_Conditional, function(self, compressor){ + OPT(AST_Conditional, function(self, compressor) { if (!compressor.option("conditionals")) return self; // This looks like lift_sequences(), should probably be under "sequences" if (self.condition instanceof AST_Sequence) { @@ -6160,7 +6145,7 @@ merge(Compressor.prototype, { } }); - OPT(AST_Boolean, function(self, compressor){ + OPT(AST_Boolean, function(self, compressor) { if (!compressor.option("booleans")) return self; if (compressor.in_boolean_context()) return make_node(AST_Number, self, { value: +self.value @@ -6186,7 +6171,7 @@ merge(Compressor.prototype, { }); }); - OPT(AST_Sub, function(self, compressor){ + OPT(AST_Sub, function(self, compressor) { var expr = self.expression; var prop = self.property; if (compressor.option("properties")) { @@ -6330,7 +6315,7 @@ merge(Compressor.prototype, { } }); - OPT(AST_Dot, function(self, compressor){ + OPT(AST_Dot, function(self, compressor) { if (self.property == "arguments" || self.property == "caller") { compressor.warn("Function.protoype.{prop} not supported [{file}:{line},{col}]", { prop: self.property, @@ -6392,19 +6377,27 @@ merge(Compressor.prototype, { return self; }); - OPT(AST_Return, function(self, compressor){ + OPT(AST_Return, function(self, compressor) { if (self.value && is_undefined(self.value, compressor)) { self.value = null; } return self; }); - OPT(AST_VarDef, function(self, compressor){ + OPT(AST_VarDef, function(self, compressor) { var defines = compressor.option("global_defs"); if (defines && HOP(defines, self.name.name)) { compressor.warn('global_defs ' + self.name.name + ' redefined [{file}:{line},{col}]', self.start); } return self; }); - -})(); +})(function(node, optimizer) { + node.DEFMETHOD("optimize", function(compressor) { + var self = this; + if (self._optimized) return self; + if (compressor.has_directive("use asm")) return self; + var opt = optimizer(self, compressor); + opt._optimized = true; + return opt; + }); +}); diff --git a/lib/mozilla-ast.js b/lib/mozilla-ast.js index 8e66c916..dace808a 100644 --- a/lib/mozilla-ast.js +++ b/lib/mozilla-ast.js @@ -43,11 +43,9 @@ "use strict"; -(function(){ - - var normalize_directives = function(body) { +(function() { + function normalize_directives(body) { var in_directive = true; - for (var i = 0; i < body.length; i++) { if (in_directive && body[i] instanceof AST_Statement && body[i].body instanceof AST_String) { body[i] = new AST_Directive({ @@ -59,9 +57,8 @@ in_directive = false; } } - return body; - }; + } var MOZ_TO_ME = { Program: function(M) { @@ -129,7 +126,7 @@ return new AST_Array({ start : my_start_token(M), end : my_end_token(M), - elements : M.elements.map(function(elem){ + elements : M.elements.map(function(elem) { return elem === null ? new AST_Hole() : from_moz(elem); }) }); @@ -138,7 +135,7 @@ return new AST_Object({ start : my_start_token(M), end : my_end_token(M), - properties : M.properties.map(function(prop){ + properties : M.properties.map(function(prop) { prop.type = "Property"; return from_moz(prop) }) @@ -480,7 +477,7 @@ endpos : range ? range[0] : moznode.start, raw : raw_token(moznode), }); - }; + } function my_end_token(moznode) { var loc = moznode.loc, end = loc && loc.end; @@ -495,7 +492,7 @@ endpos : range ? range[1] : moznode.end, raw : raw_token(moznode), }); - }; + } function map(moztype, mytype, propmap) { var moz_to_me = "function From_Moz_" + moztype + "(M){\n"; @@ -507,7 +504,7 @@ me_to_moz += "return {\n" + "type: " + JSON.stringify(moztype); - if (propmap) propmap.split(/\s*,\s*/).forEach(function(prop){ + if (propmap) propmap.split(/\s*,\s*/).forEach(function(prop) { var m = /([a-z0-9$_]+)(=|@|>|%)([a-z0-9$_]+)/i.exec(prop); if (!m) throw new Error("Can't understand property map: " + prop); var moz = m[1], how = m[2], my = m[3]; @@ -550,7 +547,7 @@ ); MOZ_TO_ME[moztype] = moz_to_me; def_to_moz(mytype, me_to_moz); - }; + } var FROM_MOZ_STACK = null; @@ -559,9 +556,9 @@ var ret = node != null ? MOZ_TO_ME[node.type](node) : null; FROM_MOZ_STACK.pop(); return ret; - }; + } - AST_Node.from_mozilla_ast = function(node){ + AST_Node.from_mozilla_ast = function(node) { var save_stack = FROM_MOZ_STACK; FROM_MOZ_STACK = []; var ast = from_moz(node); @@ -600,24 +597,24 @@ } } return moznode; - }; + } function def_to_moz(mytype, handler) { mytype.DEFMETHOD("to_mozilla_ast", function() { return set_moz_loc(this, handler(this)); }); - }; + } function to_moz(node) { return node != null ? node.to_mozilla_ast() : null; - }; + } function to_moz_block(node) { return { type: "BlockStatement", body: node.body.map(to_moz) }; - }; + } function to_moz_scope(type, node) { var body = node.body.map(to_moz); @@ -628,5 +625,5 @@ type: type, body: body }; - }; + } })(); diff --git a/lib/output.js b/lib/output.js index 6d7b0723..1dbc1f6e 100644 --- a/lib/output.js +++ b/lib/output.js @@ -137,7 +137,7 @@ function OutputStream(options) { function make_string(str, quote) { var dq = 0, sq = 0; str = str.replace(/[\\\b\f\n\r\v\t\x22\x27\u2028\u2029\0\ufeff]/g, - function(s, i){ + function(s, i) { switch (s) { case '"': ++dq; return '"'; case "'": ++sq; return "'"; @@ -408,7 +408,7 @@ function OutputStream(options) { var ret; print("{"); newline(); - with_indent(next_indent(), function(){ + with_indent(next_indent(), function() { ret = cont(); }); indent(); @@ -631,7 +631,7 @@ function OutputStream(options) { /* -----[ code generators ]----- */ -(function(){ +(function() { /* -----[ utils ]----- */ @@ -643,7 +643,7 @@ function OutputStream(options) { var active_scope = null; var use_asm = null; - AST_Node.DEFMETHOD("print", function(stream, force_parens){ + AST_Node.DEFMETHOD("print", function(stream, force_parens) { var self = this, generator = self._codegen; if (self instanceof AST_Scope) { active_scope = self; @@ -670,7 +670,7 @@ function OutputStream(options) { }); AST_Node.DEFMETHOD("_print", AST_Node.prototype.print); - AST_Node.DEFMETHOD("print_to_string", function(options){ + AST_Node.DEFMETHOD("print_to_string", function(options) { var s = OutputStream(options); this.print(s); return s.get(); @@ -680,7 +680,7 @@ function OutputStream(options) { function PARENS(nodetype, func) { if (Array.isArray(nodetype)) { - nodetype.forEach(function(nodetype){ + nodetype.forEach(function(nodetype) { PARENS(nodetype, func); }); } else { @@ -692,7 +692,7 @@ function OutputStream(options) { // a function expression needs parens around it when it's provably // the first token to appear in a statement. - PARENS(AST_Function, function(output){ + PARENS(AST_Function, function(output) { if (!output.has_parens() && first_in_statement(output)) { return true; } @@ -714,17 +714,17 @@ function OutputStream(options) { // same goes for an object literal, because otherwise it would be // interpreted as a block of code. - PARENS(AST_Object, function(output){ + PARENS(AST_Object, function(output) { return !output.has_parens() && first_in_statement(output); }); - PARENS(AST_Unary, function(output){ + PARENS(AST_Unary, function(output) { var p = output.parent(); return p instanceof AST_PropAccess && p.expression === this || p instanceof AST_Call && p.expression === this; }); - PARENS(AST_Sequence, function(output){ + PARENS(AST_Sequence, function(output) { var p = output.parent(); return p instanceof AST_Call // (foo, bar)() or foo(1, (2, 3), 4) || p instanceof AST_Unary // !(foo, bar, baz) @@ -738,7 +738,7 @@ function OutputStream(options) { ; }); - PARENS(AST_Binary, function(output){ + PARENS(AST_Binary, function(output) { var p = output.parent(); // (foo && bar)() if (p instanceof AST_Call && p.expression === this) @@ -761,7 +761,7 @@ function OutputStream(options) { } }); - PARENS(AST_PropAccess, function(output){ + PARENS(AST_PropAccess, function(output) { var p = output.parent(); if (p instanceof AST_New && p.expression === this) { // i.e. new (foo.bar().baz) @@ -782,7 +782,7 @@ function OutputStream(options) { } }); - PARENS(AST_Call, function(output){ + PARENS(AST_Call, function(output) { var p = output.parent(), p1; if (p instanceof AST_New && p.expression === this) return true; @@ -796,7 +796,7 @@ function OutputStream(options) { && p1.left === p; }); - PARENS(AST_New, function(output){ + PARENS(AST_New, function(output) { var p = output.parent(); if (!need_constructor_parens(this, output) && (p instanceof AST_PropAccess // (new Date).getTime(), (new Date)["getTime"]() @@ -804,7 +804,7 @@ function OutputStream(options) { return true; }); - PARENS(AST_Number, function(output){ + PARENS(AST_Number, function(output) { var p = output.parent(); if (p instanceof AST_PropAccess && p.expression === this) { var value = this.getValue(); @@ -814,7 +814,7 @@ function OutputStream(options) { } }); - PARENS([ AST_Assign, AST_Conditional ], function(output){ + PARENS([ AST_Assign, AST_Conditional ], function(output) { var p = output.parent(); // !(a = false) → true if (p instanceof AST_Unary) @@ -835,11 +835,11 @@ function OutputStream(options) { /* -----[ PRINTERS ]----- */ - DEFPRINT(AST_Directive, function(self, output){ + DEFPRINT(AST_Directive, function(self, output) { output.print_string(self.value, self.quote); output.semicolon(); }); - DEFPRINT(AST_Debugger, function(self, output){ + DEFPRINT(AST_Debugger, function(self, output) { output.print("debugger"); output.semicolon(); }); @@ -849,7 +849,7 @@ function OutputStream(options) { function display_body(body, is_toplevel, output, allow_directives) { var last = body.length - 1; in_directive = allow_directives; - body.forEach(function(stmt, i){ + body.forEach(function(stmt, i) { if (in_directive === true && !(stmt instanceof AST_Directive || stmt instanceof AST_EmptyStatement || (stmt instanceof AST_SimpleStatement && stmt.body instanceof AST_String) @@ -874,24 +874,24 @@ function OutputStream(options) { in_directive = false; } - AST_StatementWithBody.DEFMETHOD("_do_print_body", function(output){ + AST_StatementWithBody.DEFMETHOD("_do_print_body", function(output) { force_statement(this.body, output); }); - DEFPRINT(AST_Statement, function(self, output){ + DEFPRINT(AST_Statement, function(self, output) { self.body.print(output); output.semicolon(); }); - DEFPRINT(AST_Toplevel, function(self, output){ + DEFPRINT(AST_Toplevel, function(self, output) { display_body(self.body, true, output, true); output.print(""); }); - DEFPRINT(AST_LabeledStatement, function(self, output){ + DEFPRINT(AST_LabeledStatement, function(self, output) { self.label.print(output); output.colon(); self.body.print(output); }); - DEFPRINT(AST_SimpleStatement, function(self, output){ + DEFPRINT(AST_SimpleStatement, function(self, output) { self.body.print(output); output.semicolon(); }); @@ -909,37 +909,37 @@ function OutputStream(options) { }); } else print_braced_empty(self, output); } - DEFPRINT(AST_BlockStatement, function(self, output){ + DEFPRINT(AST_BlockStatement, function(self, output) { print_braced(self, output); }); - DEFPRINT(AST_EmptyStatement, function(self, output){ + DEFPRINT(AST_EmptyStatement, function(self, output) { output.semicolon(); }); - DEFPRINT(AST_Do, function(self, output){ + DEFPRINT(AST_Do, function(self, output) { output.print("do"); output.space(); make_block(self.body, output); output.space(); output.print("while"); output.space(); - output.with_parens(function(){ + output.with_parens(function() { self.condition.print(output); }); output.semicolon(); }); - DEFPRINT(AST_While, function(self, output){ + DEFPRINT(AST_While, function(self, output) { output.print("while"); output.space(); - output.with_parens(function(){ + output.with_parens(function() { self.condition.print(output); }); output.space(); self._do_print_body(output); }); - DEFPRINT(AST_For, function(self, output){ + DEFPRINT(AST_For, function(self, output) { output.print("for"); output.space(); - output.with_parens(function(){ + output.with_parens(function() { if (self.init) { if (self.init instanceof AST_Definitions) { self.init.print(output); @@ -965,10 +965,10 @@ function OutputStream(options) { output.space(); self._do_print_body(output); }); - DEFPRINT(AST_ForIn, function(self, output){ + DEFPRINT(AST_ForIn, function(self, output) { output.print("for"); output.space(); - output.with_parens(function(){ + output.with_parens(function() { self.init.print(output); output.space(); output.print("in"); @@ -978,10 +978,10 @@ function OutputStream(options) { output.space(); self._do_print_body(output); }); - DEFPRINT(AST_With, function(self, output){ + DEFPRINT(AST_With, function(self, output) { output.print("with"); output.space(); - output.with_parens(function(){ + output.with_parens(function() { self.expression.print(output); }); output.space(); @@ -989,7 +989,7 @@ function OutputStream(options) { }); /* -----[ functions ]----- */ - AST_Lambda.DEFMETHOD("_do_print", function(output, nokeyword){ + AST_Lambda.DEFMETHOD("_do_print", function(output, nokeyword) { var self = this; if (!nokeyword) { output.print("function"); @@ -998,8 +998,8 @@ function OutputStream(options) { output.space(); self.name.print(output); } - output.with_parens(function(){ - self.argnames.forEach(function(arg, i){ + output.with_parens(function() { + self.argnames.forEach(function(arg, i) { if (i) output.comma(); arg.print(output); }); @@ -1007,40 +1007,31 @@ function OutputStream(options) { output.space(); print_braced(self, output, true); }); - DEFPRINT(AST_Lambda, function(self, output){ + DEFPRINT(AST_Lambda, function(self, output) { self._do_print(output); }); - /* -----[ exits ]----- */ - AST_Exit.DEFMETHOD("_do_print", function(output, kind){ + /* -----[ jumps ]----- */ + function print_jump(output, kind, target) { output.print(kind); - if (this.value) { + if (target) { output.space(); - this.value.print(output); + target.print(output); } output.semicolon(); - }); - DEFPRINT(AST_Return, function(self, output){ - self._do_print(output, "return"); - }); - DEFPRINT(AST_Throw, function(self, output){ - self._do_print(output, "throw"); - }); + } - /* -----[ loop control ]----- */ - AST_LoopControl.DEFMETHOD("_do_print", function(output, kind){ - output.print(kind); - if (this.label) { - output.space(); - this.label.print(output); - } - output.semicolon(); + DEFPRINT(AST_Return, function(self, output) { + print_jump(output, "return", self.value); + }); + DEFPRINT(AST_Throw, function(self, output) { + print_jump(output, "throw", self.value); }); - DEFPRINT(AST_Break, function(self, output){ - self._do_print(output, "break"); + DEFPRINT(AST_Break, function(self, output) { + print_jump(output, "break", self.label); }); - DEFPRINT(AST_Continue, function(self, output){ - self._do_print(output, "continue"); + DEFPRINT(AST_Continue, function(self, output) { + print_jump(output, "continue", self.label); }); /* -----[ if ]----- */ @@ -1072,10 +1063,10 @@ function OutputStream(options) { } force_statement(self.body, output); } - DEFPRINT(AST_If, function(self, output){ + DEFPRINT(AST_If, function(self, output) { output.print("if"); output.space(); - output.with_parens(function(){ + output.with_parens(function() { self.condition.print(output); }); output.space(); @@ -1094,17 +1085,17 @@ function OutputStream(options) { }); /* -----[ switch ]----- */ - DEFPRINT(AST_Switch, function(self, output){ + DEFPRINT(AST_Switch, function(self, output) { output.print("switch"); output.space(); - output.with_parens(function(){ + output.with_parens(function() { self.expression.print(output); }); output.space(); var last = self.body.length - 1; if (last < 0) print_braced_empty(self, output); - else output.with_block(function(){ - self.body.forEach(function(branch, i){ + else output.with_block(function() { + self.body.forEach(function(branch, i) { output.indent(true); branch.print(output); if (i < last && branch.body.length > 0) @@ -1112,19 +1103,19 @@ function OutputStream(options) { }); }); }); - AST_SwitchBranch.DEFMETHOD("_do_print_body", function(output){ + AST_SwitchBranch.DEFMETHOD("_do_print_body", function(output) { output.newline(); - this.body.forEach(function(stmt){ + this.body.forEach(function(stmt) { output.indent(); stmt.print(output); output.newline(); }); }); - DEFPRINT(AST_Default, function(self, output){ + DEFPRINT(AST_Default, function(self, output) { output.print("default:"); self._do_print_body(output); }); - DEFPRINT(AST_Case, function(self, output){ + DEFPRINT(AST_Case, function(self, output) { output.print("case"); output.space(); self.expression.print(output); @@ -1133,7 +1124,7 @@ function OutputStream(options) { }); /* -----[ exceptions ]----- */ - DEFPRINT(AST_Try, function(self, output){ + DEFPRINT(AST_Try, function(self, output) { output.print("try"); output.space(); print_braced(self, output); @@ -1146,37 +1137,30 @@ function OutputStream(options) { self.bfinally.print(output); } }); - DEFPRINT(AST_Catch, function(self, output){ + DEFPRINT(AST_Catch, function(self, output) { output.print("catch"); output.space(); - output.with_parens(function(){ + output.with_parens(function() { self.argname.print(output); }); output.space(); print_braced(self, output); }); - DEFPRINT(AST_Finally, function(self, output){ + DEFPRINT(AST_Finally, function(self, output) { output.print("finally"); output.space(); print_braced(self, output); }); - /* -----[ var/const ]----- */ - AST_Definitions.DEFMETHOD("_do_print", function(output, kind){ - output.print(kind); + DEFPRINT(AST_Var, function(self, output) { + output.print("var"); output.space(); - this.definitions.forEach(function(def, i){ + self.definitions.forEach(function(def, i) { if (i) output.comma(); def.print(output); }); var p = output.parent(); - var in_for = p instanceof AST_For || p instanceof AST_ForIn; - var avoid_semicolon = in_for && p.init === this; - if (!avoid_semicolon) - output.semicolon(); - }); - DEFPRINT(AST_Var, function(self, output){ - self._do_print(output, "var"); + if (p.init !== self || !(p instanceof AST_For || p instanceof AST_ForIn)) output.semicolon(); }); function parenthesize_for_noin(node, output, noin) { @@ -1193,7 +1177,7 @@ function OutputStream(options) { node.print(output, parens); } - DEFPRINT(AST_VarDef, function(self, output){ + DEFPRINT(AST_VarDef, function(self, output) { self.name.print(output); if (self.value) { output.space(); @@ -1206,28 +1190,27 @@ function OutputStream(options) { }); /* -----[ other expressions ]----- */ - DEFPRINT(AST_Call, function(self, output){ + DEFPRINT(AST_Call, function(self, output) { self.expression.print(output); if (self instanceof AST_New && !need_constructor_parens(self, output)) return; if (self.expression instanceof AST_Call || self.expression instanceof AST_Lambda) { output.add_mapping(self.start); } - output.with_parens(function(){ - self.args.forEach(function(expr, i){ + output.with_parens(function() { + self.args.forEach(function(expr, i) { if (i) output.comma(); expr.print(output); }); }); }); - DEFPRINT(AST_New, function(self, output){ + DEFPRINT(AST_New, function(self, output) { output.print("new"); output.space(); AST_Call.prototype._codegen(self, output); }); - - AST_Sequence.DEFMETHOD("_do_print", function(output){ - this.expressions.forEach(function(node, index) { + DEFPRINT(AST_Sequence, function(self, output) { + self.expressions.forEach(function(node, index) { if (index > 0) { output.comma(); if (output.should_break()) { @@ -1238,18 +1221,7 @@ function OutputStream(options) { node.print(output); }); }); - DEFPRINT(AST_Sequence, function(self, output){ - self._do_print(output); - // var p = output.parent(); - // if (p instanceof AST_Statement) { - // output.with_indent(output.next_indent(), function(){ - // self._do_print(output); - // }); - // } else { - // self._do_print(output); - // } - }); - DEFPRINT(AST_Dot, function(self, output){ + DEFPRINT(AST_Dot, function(self, output) { var expr = self.expression; expr.print(output); var prop = self.property; @@ -1270,13 +1242,13 @@ function OutputStream(options) { output.print_name(prop); } }); - DEFPRINT(AST_Sub, function(self, output){ + DEFPRINT(AST_Sub, function(self, output) { self.expression.print(output); output.print("["); self.property.print(output); output.print("]"); }); - DEFPRINT(AST_UnaryPrefix, function(self, output){ + DEFPRINT(AST_UnaryPrefix, function(self, output) { var op = self.operator; output.print(op); if (/^[a-z]/i.test(op) @@ -1287,11 +1259,11 @@ function OutputStream(options) { } self.expression.print(output); }); - DEFPRINT(AST_UnaryPostfix, function(self, output){ + DEFPRINT(AST_UnaryPostfix, function(self, output) { self.expression.print(output); output.print(self.operator); }); - DEFPRINT(AST_Binary, function(self, output){ + DEFPRINT(AST_Binary, function(self, output) { var op = self.operator; self.left.print(output); if (op[0] == ">" /* ">>" ">>>" ">" ">=" */ @@ -1317,7 +1289,7 @@ function OutputStream(options) { } self.right.print(output); }); - DEFPRINT(AST_Conditional, function(self, output){ + DEFPRINT(AST_Conditional, function(self, output) { self.condition.print(output); output.space(); output.print("?"); @@ -1329,11 +1301,11 @@ function OutputStream(options) { }); /* -----[ literals ]----- */ - DEFPRINT(AST_Array, function(self, output){ - output.with_square(function(){ + DEFPRINT(AST_Array, function(self, output) { + output.with_square(function() { var a = self.elements, len = a.length; if (len > 0) output.space(); - a.forEach(function(exp, i){ + a.forEach(function(exp, i) { if (i) output.comma(); exp.print(output); // If the final element is a hole, we need to make sure it @@ -1345,9 +1317,9 @@ function OutputStream(options) { if (len > 0) output.space(); }); }); - DEFPRINT(AST_Object, function(self, output){ - if (self.properties.length > 0) output.with_block(function(){ - self.properties.forEach(function(prop, i){ + DEFPRINT(AST_Object, function(self, output) { + if (self.properties.length > 0) output.with_block(function() { + self.properties.forEach(function(prop, i) { if (i) { output.print(","); output.newline(); @@ -1376,7 +1348,7 @@ function OutputStream(options) { } } - DEFPRINT(AST_ObjectKeyVal, function(self, output){ + DEFPRINT(AST_ObjectKeyVal, function(self, output) { print_property_name(self.key, self.quote, output); output.colon(); self.value.print(output); @@ -1387,27 +1359,27 @@ function OutputStream(options) { print_property_name(this.key.name, this.quote, output); this.value._do_print(output, true); }); - DEFPRINT(AST_ObjectSetter, function(self, output){ + DEFPRINT(AST_ObjectSetter, function(self, output) { self._print_getter_setter("set", output); }); - DEFPRINT(AST_ObjectGetter, function(self, output){ + DEFPRINT(AST_ObjectGetter, function(self, output) { self._print_getter_setter("get", output); }); - DEFPRINT(AST_Symbol, function(self, output){ + DEFPRINT(AST_Symbol, function(self, output) { var def = self.definition(); output.print_name(def ? def.mangled_name || def.name : self.name); }); DEFPRINT(AST_Hole, noop); - DEFPRINT(AST_This, function(self, output){ + DEFPRINT(AST_This, function(self, output) { output.print("this"); }); - DEFPRINT(AST_Constant, function(self, output){ + DEFPRINT(AST_Constant, function(self, output) { output.print(self.getValue()); }); - DEFPRINT(AST_String, function(self, output){ + DEFPRINT(AST_String, function(self, output) { output.print_string(self.getValue(), self.quote, in_directive); }); - DEFPRINT(AST_Number, function(self, output){ + DEFPRINT(AST_Number, function(self, output) { if (use_asm && self.start && self.start.raw != null) { output.print(self.start.raw); } else { @@ -1415,7 +1387,7 @@ function OutputStream(options) { } }); - DEFPRINT(AST_RegExp, function(self, output){ + DEFPRINT(AST_RegExp, function(self, output) { var regexp = self.getValue(); var str = regexp.toString(); if (regexp.raw_source) { @@ -1487,7 +1459,7 @@ function OutputStream(options) { output.print("{}"); else if (stmt instanceof AST_BlockStatement) stmt.print(output); - else output.with_block(function(){ + else output.with_block(function() { output.indent(); stmt.print(output); output.newline(); diff --git a/lib/parse.js b/lib/parse.js index 21c89676..29df370c 100644 --- a/lib/parse.js +++ b/lib/parse.js @@ -130,7 +130,7 @@ function is_letter(code) { return (code >= 97 && code <= 122) || (code >= 65 && code <= 90) || (code >= 0xaa && UNICODE.letter.test(String.fromCharCode(code))); -}; +} function is_surrogate_pair_head(code) { if (typeof code == "string") @@ -146,11 +146,11 @@ function is_surrogate_pair_tail(code) { function is_digit(code) { return code >= 48 && code <= 57; -}; +} function is_alphanumeric_char(code) { return is_digit(code) || is_letter(code); -}; +} function is_unicode_digit(code) { return UNICODE.digit.test(String.fromCharCode(code)); @@ -158,19 +158,19 @@ function is_unicode_digit(code) { function is_unicode_combining_mark(ch) { return UNICODE.non_spacing_mark.test(ch) || UNICODE.space_combining_mark.test(ch); -}; +} function is_unicode_connector_punctuation(ch) { return UNICODE.connector_punctuation.test(ch); -}; +} function is_identifier(name) { return !RESERVED_WORDS[name] && /^[a-z_$][a-z0-9_$]*$/i.test(name); -}; +} function is_identifier_start(code) { return code == 36 || code == 95 || is_letter(code); -}; +} function is_identifier_char(ch) { var code = ch.charCodeAt(0); @@ -182,11 +182,11 @@ function is_identifier_char(ch) { || is_unicode_connector_punctuation(ch) || is_unicode_digit(code) ; -}; +} -function is_identifier_string(str){ +function is_identifier_string(str) { return /^[a-z_$][a-z0-9_$]*$/i.test(str); -}; +} function parse_js_number(num) { if (RE_HEX_NUMBER.test(num)) { @@ -197,7 +197,7 @@ function parse_js_number(num) { var val = parseFloat(num); if (val == num) return val; } -}; +} function JS_Parse_Error(message, filename, line, col, pos) { this.message = message; @@ -205,7 +205,7 @@ function JS_Parse_Error(message, filename, line, col, pos) { this.line = line; this.col = col; this.pos = pos; -}; +} JS_Parse_Error.prototype = Object.create(Error.prototype); JS_Parse_Error.prototype.constructor = JS_Parse_Error; JS_Parse_Error.prototype.name = "SyntaxError"; @@ -213,11 +213,11 @@ configure_error_stack(JS_Parse_Error); function js_error(message, filename, line, col, pos) { throw new JS_Parse_Error(message, filename, line, col, pos); -}; +} function is_token(token, type, val) { return token.type == type && (val == null || token.value == val); -}; +} var EX_EOF = {}; @@ -239,7 +239,9 @@ function tokenizer($TEXT, filename, html5_comments, shebang) { directive_stack : [] }; - function peek() { return S.text.charAt(S.pos); }; + function peek() { + return S.text.charAt(S.pos); + } function next(signal_eof, in_string) { var ch = S.text.charAt(S.pos++); @@ -258,15 +260,15 @@ function tokenizer($TEXT, filename, html5_comments, shebang) { ++S.col; } return ch; - }; + } function forward(i) { while (i-- > 0) next(); - }; + } function looking_at(str) { return S.text.substr(S.pos, str.length) == str; - }; + } function find_eol() { var text = S.text; @@ -276,19 +278,19 @@ function tokenizer($TEXT, filename, html5_comments, shebang) { return i; } return -1; - }; + } function find(what, signal_eof) { var pos = S.text.indexOf(what, S.pos); if (signal_eof && pos == -1) throw EX_EOF; return pos; - }; + } function start_token() { S.tokline = S.line; S.tokcol = S.col; S.tokpos = S.pos; - }; + } var prev_was_dot = false; function token(type, value, is_comment) { @@ -321,27 +323,27 @@ function tokenizer($TEXT, filename, html5_comments, shebang) { } S.newline_before = false; return new AST_Token(ret); - }; + } function skip_whitespace() { while (WHITESPACE_CHARS[peek()]) next(); - }; + } function read_while(pred) { var ret = "", ch, i = 0; while ((ch = peek()) && pred(ch, i++)) ret += next(); return ret; - }; + } function parse_error(err) { js_error(err, filename, S.tokline, S.tokcol, S.tokpos); - }; + } function read_num(prefix) { var has_e = false, after_e = false, has_x = false, has_dot = prefix == "."; - var num = read_while(function(ch, i){ + var num = read_while(function(ch, i) { var code = ch.charCodeAt(0); switch (code) { case 120: case 88: // xX @@ -367,7 +369,7 @@ function tokenizer($TEXT, filename, html5_comments, shebang) { } else { parse_error("Invalid syntax: " + num); } - }; + } function read_escaped_char(in_string) { var ch = next(true, in_string); @@ -390,7 +392,7 @@ function tokenizer($TEXT, filename, html5_comments, shebang) { if (ch >= "0" && ch <= "7") return read_octal_escape_sequence(ch); return ch; - }; + } function read_octal_escape_sequence(ch) { // Read @@ -417,9 +419,9 @@ function tokenizer($TEXT, filename, html5_comments, shebang) { num = (num << 4) | digit; } return num; - }; + } - var read_string = with_eof_error("Unterminated string constant", function(quote_char){ + var read_string = with_eof_error("Unterminated string constant", function(quote_char) { var quote = next(), ret = ""; for (;;) { var ch = next(true, true); @@ -447,9 +449,9 @@ function tokenizer($TEXT, filename, html5_comments, shebang) { S.comments_before.push(token(type, ret, true)); S.regex_allowed = regex_allowed; return next_token; - }; + } - var skip_multiline_comment = with_eof_error("Unterminated multiline comment", function(){ + var skip_multiline_comment = with_eof_error("Unterminated multiline comment", function() { var regex_allowed = S.regex_allowed; var i = find("*/", true); var text = S.text.substring(S.pos, i).replace(/\r\n|\r|\u2028|\u2029/g, '\n'); @@ -481,7 +483,7 @@ function tokenizer($TEXT, filename, html5_comments, shebang) { name = "\\u" + "0000".substr(hex.length) + hex + name.slice(1); } return name; - }; + } var read_regexp = with_eof_error("Unterminated regular expression", function(source) { var prev_backslash = false, ch, in_class = false; @@ -523,9 +525,9 @@ function tokenizer($TEXT, filename, html5_comments, shebang) { } else { return op; } - }; + } return token("operator", grow(prefix || next())); - }; + } function handle_slash() { next(); @@ -538,14 +540,14 @@ function tokenizer($TEXT, filename, html5_comments, shebang) { return skip_multiline_comment(); } return S.regex_allowed ? read_regexp("") : read_operator("/"); - }; + } function handle_dot() { next(); return is_digit(peek().charCodeAt(0)) ? read_num(".") : token("punc", "."); - }; + } function read_word() { var word = read_name(); @@ -554,7 +556,7 @@ function tokenizer($TEXT, filename, html5_comments, shebang) { : !KEYWORDS[word] ? token("name", word) : OPERATORS[word] ? token("operator", word) : token("keyword", word); - }; + } function with_eof_error(eof_error, cont) { return function(x) { @@ -565,7 +567,7 @@ function tokenizer($TEXT, filename, html5_comments, shebang) { else throw ex; } }; - }; + } function next_token(force_regexp) { if (force_regexp != null) @@ -609,7 +611,7 @@ function tokenizer($TEXT, filename, html5_comments, shebang) { break; } parse_error("Unexpected character '" + ch + "'"); - }; + } next_token.context = function(nc) { if (nc) S = nc; @@ -645,8 +647,7 @@ function tokenizer($TEXT, filename, html5_comments, shebang) { } return next_token; - -}; +} /* -----[ Parser (constants) ]----- */ @@ -666,7 +667,7 @@ var UNARY_POSTFIX = makePredicate([ "--", "++" ]); var ASSIGNMENT = makePredicate([ "=", "+=", "-=", "/=", "*=", "%=", ">>=", "<<=", ">>>=", "|=", "^=", "&=" ]); -var PRECEDENCE = (function(a, ret){ +var PRECEDENCE = function(a, ret) { for (var i = 0; i < a.length; ++i) { var b = a[i]; for (var j = 0; j < b.length; ++j) { @@ -674,28 +675,24 @@ var PRECEDENCE = (function(a, ret){ } } return ret; -})( - [ - ["||"], - ["&&"], - ["|"], - ["^"], - ["&"], - ["==", "===", "!=", "!=="], - ["<", ">", "<=", ">=", "in", "instanceof"], - [">>", "<<", ">>>"], - ["+", "-"], - ["*", "/", "%"] - ], - {} -); +}([ + ["||"], + ["&&"], + ["|"], + ["^"], + ["&"], + ["==", "===", "!=", "!=="], + ["<", ">", "<=", ">=", "in", "instanceof"], + [">>", "<<", ">>>"], + ["+", "-"], + ["*", "/", "%"] +], {}); var ATOMIC_START_TOKEN = makePredicate([ "atom", "num", "string", "regexp", "name" ]); /* -----[ Parser ]----- */ function parse($TEXT, options) { - options = defaults(options, { bare_returns : false, expression : false, @@ -724,9 +721,11 @@ function parse($TEXT, options) { function is(type, value) { return is_token(S.token, type, value); - }; + } - function peek() { return S.peeked || (S.peeked = S.input()); }; + function peek() { + return S.peeked || (S.peeked = S.input()); + } function next() { S.prev = S.token; @@ -740,11 +739,11 @@ function parse($TEXT, options) { S.token.type == "string" || is("punc", ";") ); return S.token; - }; + } function prev() { return S.prev; - }; + } function croak(msg, line, col, pos) { var ctx = S.input.context(); @@ -753,26 +752,28 @@ function parse($TEXT, options) { line != null ? line : ctx.tokline, col != null ? col : ctx.tokcol, pos != null ? pos : ctx.tokpos); - }; + } function token_error(token, msg) { croak(msg, token.line, token.col); - }; + } function unexpected(token) { if (token == null) token = S.token; token_error(token, "Unexpected token: " + token.type + " (" + token.value + ")"); - }; + } function expect_token(type, val) { if (is(type, val)) { return next(); } token_error(S.token, "Unexpected token " + S.token.type + " «" + S.token.value + "»" + ", expected " + type + " «" + val + "»"); - }; + } - function expect(punc) { return expect_token("punc", punc); }; + function expect(punc) { + return expect_token("punc", punc); + } function has_newline_before(token) { return token.nlb || !all(token.comments_before, function(comment) { @@ -783,19 +784,19 @@ function parse($TEXT, options) { function can_insert_semicolon() { return !options.strict && (is("eof") || is("punc", "}") || has_newline_before(S.token)); - }; + } function semicolon(optional) { if (is("punc", ";")) next(); else if (!optional && !can_insert_semicolon()) unexpected(); - }; + } function parenthesised() { expect("("); var exp = expression(true); expect(")"); return exp; - }; + } function embed_tokens(parser) { return function() { @@ -806,14 +807,14 @@ function parse($TEXT, options) { expr.end = end; return expr; }; - }; + } function handle_regexp() { if (is("operator", "/") || is("operator", "/=")) { S.peeked = null; S.token = S.input(S.token.value.substr(1)); // force regexp } - }; + } var statement = embed_tokens(function(strict_defun) { handle_regexp(); @@ -986,7 +987,7 @@ function parse($TEXT, options) { // check for `continue` that refers to this label. // those should be reported as syntax errors. // https://github.com/mishoo/UglifyJS2/issues/287 - label.references.forEach(function(ref){ + label.references.forEach(function(ref) { if (ref instanceof AST_Continue) { ref = ref.label.start; croak("Continue label `" + label.name + "` refers to non-IterationStatement.", @@ -995,11 +996,11 @@ function parse($TEXT, options) { }); } return new AST_LabeledStatement({ body: stat, label: label }); - }; + } function simple_statement(tmp) { return new AST_SimpleStatement({ body: (tmp = expression(true), semicolon(), tmp) }); - }; + } function break_cont(type) { var label = null, ldef; @@ -1007,18 +1008,17 @@ function parse($TEXT, options) { label = as_symbol(AST_LabelRef, true); } if (label != null) { - ldef = find_if(function(l){ return l.name == label.name }, S.labels); - if (!ldef) - croak("Undefined label " + label.name); + ldef = find_if(function(l) { + return l.name == label.name; + }, S.labels); + if (!ldef) croak("Undefined label " + label.name); label.thedef = ldef; - } - else if (S.in_loop == 0) - croak(type.TYPE + " not inside a loop or switch"); + } else if (S.in_loop == 0) croak(type.TYPE + " not inside a loop or switch"); semicolon(); var stat = new type({ label: label }); if (ldef) ldef.references.push(stat); return stat; - }; + } function for_() { expect("("); @@ -1039,7 +1039,7 @@ function parse($TEXT, options) { } } return regular_for(init); - }; + } function regular_for(init) { expect(";"); @@ -1053,7 +1053,7 @@ function parse($TEXT, options) { step : step, body : in_loop(statement) }); - }; + } function for_in(init) { var obj = expression(true); @@ -1063,7 +1063,7 @@ function parse($TEXT, options) { object : obj, body : in_loop(statement) }); - }; + } var function_ = function(ctor) { var in_statement = ctor === AST_Defun; @@ -1113,7 +1113,7 @@ function parse($TEXT, options) { body : body, alternative : belse }); - }; + } function block_(strict_defun) { expect("{"); @@ -1124,7 +1124,7 @@ function parse($TEXT, options) { } next(); return a; - }; + } function switch_body_() { expect("{"); @@ -1159,7 +1159,7 @@ function parse($TEXT, options) { if (branch) branch.end = prev(); next(); return a; - }; + } function try_() { var body = block_(), bcatch = null, bfinally = null; @@ -1192,7 +1192,7 @@ function parse($TEXT, options) { bcatch : bcatch, bfinally : bfinally }); - }; + } function vardefs(no_in) { var a = []; @@ -1208,7 +1208,7 @@ function parse($TEXT, options) { next(); } return a; - }; + } var var_ = function(no_in) { return new AST_Var({ @@ -1274,7 +1274,7 @@ function parse($TEXT, options) { } next(); return ret; - }; + } var expr_atom = function(allow_calls) { if (is("operator", "new")) { @@ -1340,7 +1340,7 @@ function parse($TEXT, options) { } next(); return a; - }; + } var array_ = embed_tokens(function() { expect("["); @@ -1417,14 +1417,14 @@ function parse($TEXT, options) { default: unexpected(); } - }; + } function as_name() { var tmp = S.token; if (tmp.type != "name") unexpected(); next(); return tmp.value; - }; + } function _make_symbol(type) { var name = S.token.value; @@ -1433,7 +1433,7 @@ function parse($TEXT, options) { start : S.token, end : S.token }); - }; + } function strict_verify_symbol(sym) { if (sym.name == "arguments" || sym.name == "eval") @@ -1451,7 +1451,7 @@ function parse($TEXT, options) { } next(); return sym; - }; + } function mark_pure(call) { var start = call.start; @@ -1536,7 +1536,7 @@ function parse($TEXT, options) { break; } return new ctor({ operator: op, expression: expr }); - }; + } var expr_op = function(left, min_prec, no_in) { var op = is("operator") ? S.token.value : null; @@ -1558,7 +1558,7 @@ function parse($TEXT, options) { function expr_ops(no_in) { return expr_op(maybe_unary(true), 0, no_in); - }; + } var maybe_conditional = function(no_in) { var start = S.token; @@ -1580,7 +1580,7 @@ function parse($TEXT, options) { function is_assignable(expr) { return expr instanceof AST_PropAccess || expr instanceof AST_SymbolRef; - }; + } var maybe_assign = function(no_in) { var start = S.token; @@ -1622,13 +1622,13 @@ function parse($TEXT, options) { var ret = cont(); --S.in_loop; return ret; - }; + } if (options.expression) { return expression(true); } - return (function(){ + return function() { var start = S.token; var body = []; S.input.push_directives_stack(); @@ -1644,6 +1644,5 @@ function parse($TEXT, options) { toplevel = new AST_Toplevel({ start: start, body: body, end: end }); } return toplevel; - })(); - -}; + }(); +} diff --git a/lib/propmangle.js b/lib/propmangle.js index 1bca1ad4..7ad4804d 100644 --- a/lib/propmangle.js +++ b/lib/propmangle.js @@ -56,7 +56,7 @@ function find_builtins(reserved) { [ Object, Array, Function, Number, String, Boolean, Error, Math, Date, RegExp - ].forEach(function(ctor){ + ].forEach(function(ctor) { Object.getOwnPropertyNames(ctor).map(add); if (ctor.prototype) { Object.getOwnPropertyNames(ctor.prototype).map(add); @@ -136,7 +136,7 @@ function mangle_properties(ast, options) { var unmangleable = []; // step 1: find candidates to mangle - ast.walk(new TreeWalker(function(node){ + ast.walk(new TreeWalker(function(node) { if (node instanceof AST_ObjectKeyVal) { add(node.key); } @@ -157,7 +157,7 @@ function mangle_properties(ast, options) { })); // step 2: transform the tree, renaming properties - return ast.transform(new TreeTransformer(function(node){ + return ast.transform(new TreeTransformer(function(node) { if (node instanceof AST_ObjectKeyVal) { node.key = mangle(node.key); } @@ -234,7 +234,7 @@ function mangle_properties(ast, options) { } function mangleStrings(node) { - return node.transform(new TreeTransformer(function(node){ + return node.transform(new TreeTransformer(function(node) { if (node instanceof AST_Sequence) { var last = node.expressions.length - 1; node.expressions[last] = mangleStrings(node.expressions[last]); diff --git a/lib/scope.js b/lib/scope.js index fb14480f..d4b13d12 100644 --- a/lib/scope.js +++ b/lib/scope.js @@ -91,7 +91,7 @@ SymbolDef.prototype = { } }; -AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){ +AST_Toplevel.DEFMETHOD("figure_out_scope", function(options) { options = defaults(options, { cache: null, ie8: false, @@ -101,7 +101,7 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){ var self = this; var scope = self.parent_scope = null; var defun = null; - var tw = new TreeWalker(function(node, descend){ + var tw = new TreeWalker(function(node, descend) { if (node instanceof AST_Catch) { var save_scope = scope; scope = new AST_Scope(node); @@ -162,7 +162,7 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){ // pass 2: find back references and eval self.globals = new Dictionary(); - var tw = new TreeWalker(function(node, descend){ + var tw = new TreeWalker(function(node, descend) { if (node instanceof AST_LoopControl && node.label) { node.label.thedef.references.push(node); return true; @@ -217,7 +217,7 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){ } }); -AST_Toplevel.DEFMETHOD("def_global", function(node){ +AST_Toplevel.DEFMETHOD("def_global", function(node) { var globals = this.globals, name = node.name; if (globals.has(name)) { return globals.get(name); @@ -230,7 +230,7 @@ AST_Toplevel.DEFMETHOD("def_global", function(node){ } }); -AST_Scope.DEFMETHOD("init_scope_vars", function(parent_scope){ +AST_Scope.DEFMETHOD("init_scope_vars", function(parent_scope) { this.variables = new Dictionary(); // map name to AST_SymbolVar (variables defined in this scope; includes functions) this.functions = new Dictionary(); // map name to AST_SymbolDefun (functions defined in this scope) this.uses_with = false; // will be set to true if this or some nested scope uses the `with` statement @@ -240,7 +240,7 @@ AST_Scope.DEFMETHOD("init_scope_vars", function(parent_scope){ this.cname = -1; // the current index for mangling functions/variables }); -AST_Lambda.DEFMETHOD("init_scope_vars", function(){ +AST_Lambda.DEFMETHOD("init_scope_vars", function() { AST_Scope.prototype.init_scope_vars.apply(this, arguments); this.uses_arguments = false; this.def_variable(new AST_SymbolFunarg({ @@ -270,20 +270,20 @@ AST_Symbol.DEFMETHOD("reference", function(options) { this.mark_enclosed(options); }); -AST_Scope.DEFMETHOD("find_variable", function(name){ +AST_Scope.DEFMETHOD("find_variable", function(name) { if (name instanceof AST_Symbol) name = name.name; return this.variables.get(name) || (this.parent_scope && this.parent_scope.find_variable(name)); }); -AST_Scope.DEFMETHOD("def_function", function(symbol, init){ +AST_Scope.DEFMETHOD("def_function", function(symbol, init) { var def = this.def_variable(symbol, init); if (!def.init || def.init instanceof AST_Defun) def.init = init; this.functions.set(symbol.name, def); return def; }); -AST_Scope.DEFMETHOD("def_variable", function(symbol, init){ +AST_Scope.DEFMETHOD("def_variable", function(symbol, init) { var def = this.variables.get(symbol.name); if (def) { def.orig.push(symbol); @@ -390,7 +390,7 @@ function _default_mangler_options(options) { return options; } -AST_Toplevel.DEFMETHOD("mangle_names", function(options){ +AST_Toplevel.DEFMETHOD("mangle_names", function(options) { options = _default_mangler_options(options); // We only need to mangle declaration nodes. Special logic wired @@ -407,7 +407,7 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options){ } var redefined = []; - var tw = new TreeWalker(function(node, descend){ + var tw = new TreeWalker(function(node, descend) { if (node instanceof AST_LabeledStatement) { // lname is incremented when we get to the AST_Label var save_nesting = lname; @@ -520,7 +520,7 @@ AST_Sequence.DEFMETHOD("tail_node", function() { return this.expressions[this.expressions.length - 1]; }); -AST_Toplevel.DEFMETHOD("compute_char_frequency", function(options){ +AST_Toplevel.DEFMETHOD("compute_char_frequency", function(options) { options = _default_mangler_options(options); base54.reset(); try { diff --git a/lib/sourcemap.js b/lib/sourcemap.js index dcb8e476..2feec45d 100644 --- a/lib/sourcemap.js +++ b/lib/sourcemap.js @@ -46,16 +46,15 @@ // a small wrapper around fitzgen's source-map library function SourceMap(options) { options = defaults(options, { - file : null, - root : null, - orig : null, - - orig_line_diff : 0, - dest_line_diff : 0, - }); + file: null, + root: null, + orig: null, + orig_line_diff: 0, + dest_line_diff: 0, + }, true); var generator = new MOZ_SourceMap.SourceMapGenerator({ - file : options.file, - sourceRoot : options.root + file: options.file, + sourceRoot: options.root }); var maps = options.orig && Object.create(null); if (maps) for (var source in options.orig) { @@ -68,30 +67,38 @@ function SourceMap(options) { } maps[source] = map; } - - function add(source, gen_line, gen_col, orig_line, orig_col, name) { - var map = maps && maps[source]; - if (map) { - var info = map.originalPositionFor({ - line: orig_line, - column: orig_col + return { + add: function(source, gen_line, gen_col, orig_line, orig_col, name) { + var map = maps && maps[source]; + if (map) { + var info = map.originalPositionFor({ + line: orig_line, + column: orig_col + }); + if (info.source === null) return; + source = info.source; + orig_line = info.line; + orig_col = info.column; + name = info.name || name; + } + generator.addMapping({ + name: name, + source: source, + generated: { + line: gen_line + options.dest_line_diff, + column: gen_col + }, + original: { + line: orig_line + options.orig_line_diff, + column: orig_col + } }); - if (info.source === null) return; - source = info.source; - orig_line = info.line; - orig_col = info.column; - name = info.name || name; + }, + get: function() { + return generator; + }, + toString: function() { + return JSON.stringify(generator.toJSON()); } - generator.addMapping({ - generated : { line: gen_line + options.dest_line_diff, column: gen_col }, - original : { line: orig_line + options.orig_line_diff, column: orig_col }, - source : source, - name : name - }); - }; - return { - add : add, - get : function() { return generator }, - toString : function() { return JSON.stringify(generator.toJSON()); } }; -}; +} diff --git a/lib/transform.js b/lib/transform.js index 41b24c54..5897aa77 100644 --- a/lib/transform.js +++ b/lib/transform.js @@ -43,8 +43,6 @@ "use strict"; -// Tree transformer helpers. - function TreeTransformer(before, after) { TreeWalker.call(this); this.before = before; @@ -52,168 +50,136 @@ function TreeTransformer(before, after) { } TreeTransformer.prototype = new TreeWalker; -(function(undefined){ - - function _(node, descend) { - node.DEFMETHOD("transform", function(tw, in_list){ - var x, y; - tw.push(this); - if (tw.before) x = tw.before(this, descend, in_list); - if (x === undefined) { - x = this; - descend(x, tw); - if (tw.after) { - y = tw.after(x, in_list); - if (y !== undefined) x = y; - } - } - tw.pop(); - return x; - }); - }; - +(function(DEF) { function do_list(list, tw) { - return MAP(list, function(node){ + return MAP(list, function(node) { return node.transform(tw, true); }); - }; + } - _(AST_Node, noop); - - _(AST_LabeledStatement, function(self, tw){ + DEF(AST_Node, noop); + DEF(AST_LabeledStatement, function(self, tw) { self.label = self.label.transform(tw); self.body = self.body.transform(tw); }); - - _(AST_SimpleStatement, function(self, tw){ + DEF(AST_SimpleStatement, function(self, tw) { self.body = self.body.transform(tw); }); - - _(AST_Block, function(self, tw){ + DEF(AST_Block, function(self, tw) { self.body = do_list(self.body, tw); }); - - _(AST_Do, function(self, tw){ + DEF(AST_Do, function(self, tw) { self.body = self.body.transform(tw); self.condition = self.condition.transform(tw); }); - - _(AST_While, function(self, tw){ + DEF(AST_While, function(self, tw) { self.condition = self.condition.transform(tw); self.body = self.body.transform(tw); }); - - _(AST_For, function(self, tw){ + DEF(AST_For, function(self, tw) { if (self.init) self.init = self.init.transform(tw); if (self.condition) self.condition = self.condition.transform(tw); if (self.step) self.step = self.step.transform(tw); self.body = self.body.transform(tw); }); - - _(AST_ForIn, function(self, tw){ + DEF(AST_ForIn, function(self, tw) { self.init = self.init.transform(tw); self.object = self.object.transform(tw); self.body = self.body.transform(tw); }); - - _(AST_With, function(self, tw){ + DEF(AST_With, function(self, tw) { self.expression = self.expression.transform(tw); self.body = self.body.transform(tw); }); - - _(AST_Exit, function(self, tw){ + DEF(AST_Exit, function(self, tw) { if (self.value) self.value = self.value.transform(tw); }); - - _(AST_LoopControl, function(self, tw){ + DEF(AST_LoopControl, function(self, tw) { if (self.label) self.label = self.label.transform(tw); }); - - _(AST_If, function(self, tw){ + DEF(AST_If, function(self, tw) { self.condition = self.condition.transform(tw); self.body = self.body.transform(tw); if (self.alternative) self.alternative = self.alternative.transform(tw); }); - - _(AST_Switch, function(self, tw){ + DEF(AST_Switch, function(self, tw) { self.expression = self.expression.transform(tw); self.body = do_list(self.body, tw); }); - - _(AST_Case, function(self, tw){ + DEF(AST_Case, function(self, tw) { self.expression = self.expression.transform(tw); self.body = do_list(self.body, tw); }); - - _(AST_Try, function(self, tw){ + DEF(AST_Try, function(self, tw) { self.body = do_list(self.body, tw); if (self.bcatch) self.bcatch = self.bcatch.transform(tw); if (self.bfinally) self.bfinally = self.bfinally.transform(tw); }); - - _(AST_Catch, function(self, tw){ + DEF(AST_Catch, function(self, tw) { self.argname = self.argname.transform(tw); self.body = do_list(self.body, tw); }); - - _(AST_Definitions, function(self, tw){ + DEF(AST_Definitions, function(self, tw) { self.definitions = do_list(self.definitions, tw); }); - - _(AST_VarDef, function(self, tw){ + DEF(AST_VarDef, function(self, tw) { self.name = self.name.transform(tw); if (self.value) self.value = self.value.transform(tw); }); - - _(AST_Lambda, function(self, tw){ + DEF(AST_Lambda, function(self, tw) { if (self.name) self.name = self.name.transform(tw); self.argnames = do_list(self.argnames, tw); self.body = do_list(self.body, tw); }); - - _(AST_Call, function(self, tw){ + DEF(AST_Call, function(self, tw) { self.expression = self.expression.transform(tw); self.args = do_list(self.args, tw); }); - - _(AST_Sequence, function(self, tw){ + DEF(AST_Sequence, function(self, tw) { self.expressions = do_list(self.expressions, tw); }); - - _(AST_Dot, function(self, tw){ + DEF(AST_Dot, function(self, tw) { self.expression = self.expression.transform(tw); }); - - _(AST_Sub, function(self, tw){ + DEF(AST_Sub, function(self, tw) { self.expression = self.expression.transform(tw); self.property = self.property.transform(tw); }); - - _(AST_Unary, function(self, tw){ + DEF(AST_Unary, function(self, tw) { self.expression = self.expression.transform(tw); }); - - _(AST_Binary, function(self, tw){ + DEF(AST_Binary, function(self, tw) { self.left = self.left.transform(tw); self.right = self.right.transform(tw); }); - - _(AST_Conditional, function(self, tw){ + DEF(AST_Conditional, function(self, tw) { self.condition = self.condition.transform(tw); self.consequent = self.consequent.transform(tw); self.alternative = self.alternative.transform(tw); }); - - _(AST_Array, function(self, tw){ + DEF(AST_Array, function(self, tw) { self.elements = do_list(self.elements, tw); }); - - _(AST_Object, function(self, tw){ + DEF(AST_Object, function(self, tw) { self.properties = do_list(self.properties, tw); }); - - _(AST_ObjectProperty, function(self, tw){ + DEF(AST_ObjectProperty, function(self, tw) { self.value = self.value.transform(tw); }); - -})(); +})(function(node, descend) { + node.DEFMETHOD("transform", function(tw, in_list) { + var x, y; + tw.push(this); + if (tw.before) x = tw.before(this, descend, in_list); + if (typeof x === "undefined") { + x = this; + descend(x, tw); + if (tw.after) { + y = tw.after(x, in_list); + if (typeof y !== "undefined") x = y; + } + } + tw.pop(); + return x; + }); +}); diff --git a/lib/utils.js b/lib/utils.js index d4d28348..ca4b2d4b 100644 --- a/lib/utils.js +++ b/lib/utils.js @@ -115,7 +115,7 @@ function return_true() { return true; } function return_this() { return this; } function return_null() { return null; } -var MAP = (function(){ +var MAP = (function() { function MAP(a, f, backwards) { var ret = [], top = [], i; function doit() { @@ -138,7 +138,7 @@ var MAP = (function(){ } } return is_last; - }; + } if (Array.isArray(a)) { if (backwards) { for (i = a.length; --i >= 0;) if (doit()) break; @@ -152,14 +152,14 @@ var MAP = (function(){ for (i in a) if (HOP(a, i)) if (doit()) break; } return top.concat(ret); - }; + } MAP.at_top = function(val) { return new AtTop(val) }; MAP.splice = function(val) { return new Splice(val) }; MAP.last = function(val) { return new Last(val) }; var skip = MAP.skip = {}; - function AtTop(val) { this.v = val }; - function Splice(val) { this.v = val }; - function Last(val) { this.v = val }; + function AtTop(val) { this.v = val } + function Splice(val) { this.v = val } + function Last(val) { this.v = val } return MAP; })(); @@ -169,7 +169,7 @@ function push_uniq(array, el) { } function string_template(text, props) { - return text.replace(/\{(.+?)\}/g, function(str, p){ + return text.replace(/\{(.+?)\}/g, function(str, p) { return props && props[p]; }); } |