diff options
Diffstat (limited to 'node_modules/uglify-js/lib/scope.js')
| -rw-r--r-- | node_modules/uglify-js/lib/scope.js | 421 |
1 files changed, 214 insertions, 207 deletions
diff --git a/node_modules/uglify-js/lib/scope.js b/node_modules/uglify-js/lib/scope.js index bbfa037cd..c88ce8fce 100644 --- a/node_modules/uglify-js/lib/scope.js +++ b/node_modules/uglify-js/lib/scope.js @@ -43,9 +43,10 @@ "use strict"; -function SymbolDef(scope, orig) { +function SymbolDef(scope, orig, init) { this.name = orig.name; this.orig = [ orig ]; + this.init = init; this.eliminated = 0; this.scope = scope; this.references = []; @@ -54,7 +55,7 @@ function SymbolDef(scope, orig) { this.mangled_name = null; this.undeclared = false; this.id = SymbolDef.next_id++; -}; +} SymbolDef.next_id = 1; @@ -62,28 +63,24 @@ SymbolDef.prototype = { unmangleable: function(options) { if (!options) options = {}; - return (this.global && !options.toplevel) + return this.global && !options.toplevel || this.undeclared - || (!options.eval && (this.scope.uses_eval || this.scope.uses_with)) - || (options.keep_fnames + || !options.eval && this.scope.pinned() + || options.keep_fnames && (this.orig[0] instanceof AST_SymbolLambda - || this.orig[0] instanceof AST_SymbolDefun)); + || this.orig[0] instanceof AST_SymbolDefun); }, mangle: function(options) { var cache = options.cache && options.cache.props; if (this.global && cache && cache.has(this.name)) { this.mangled_name = cache.get(this.name); - } - else if (!this.mangled_name && !this.unmangleable(options)) { - var s = this.scope; - var sym = this.orig[0]; - if (options.ie8 && sym instanceof AST_SymbolLambda) - s = s.parent_scope; + } else if (!this.mangled_name && !this.unmangleable(options)) { var def; if (def = this.redefined()) { this.mangled_name = def.mangled_name || def.name; - } else - this.mangled_name = s.next_mangled(options, this); + } else { + this.mangled_name = next_mangled_name(this.scope, options, this); + } if (this.global && cache) { cache.set(this.name, this.mangled_name); } @@ -94,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, @@ -103,9 +100,8 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){ // pass 1: setup scope chaining and handle definitions var self = this; var scope = self.parent_scope = null; - var labels = new Dictionary(); 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); @@ -118,28 +114,14 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){ node.init_scope_vars(scope); var save_scope = scope; var save_defun = defun; - var save_labels = labels; defun = scope = node; - labels = new Dictionary(); descend(); scope = save_scope; defun = save_defun; - labels = save_labels; - return true; // don't descend again in TreeWalker - } - if (node instanceof AST_LabeledStatement) { - var l = node.label; - if (labels.has(l.name)) { - throw new Error(string_template("Label {name} defined twice", l)); - } - labels.set(l.name, l); - descend(); - labels.del(l.name); - return true; // no descend again + return true; } if (node instanceof AST_With) { - for (var s = scope; s; s = s.parent_scope) - s.uses_with = true; + for (var s = scope; s; s = s.parent_scope) s.uses_with = true; return; } if (node instanceof AST_Symbol) { @@ -149,48 +131,34 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){ node.thedef = node; node.references = []; } - if (node instanceof AST_SymbolLambda) { - defun.def_function(node); - } - else if (node instanceof AST_SymbolDefun) { - // Careful here, the scope where this should be defined is - // the parent scope. The reason is that we enter a new - // scope when we encounter the AST_Defun node (which is - // instanceof AST_Scope) but we get to the symbol a bit - // later. - (node.scope = defun.parent_scope).def_function(node); - } - else if (node instanceof AST_SymbolVar) { - defun.def_variable(node); + if (node instanceof AST_SymbolDefun) { + // This should be defined in the parent scope, as we encounter the + // AST_Defun node before getting to its AST_Symbol. + (node.scope = defun.parent_scope.resolve()).def_function(node, defun); + } else if (node instanceof AST_SymbolLambda) { + var def = defun.def_function(node, node.name == "arguments" ? undefined : defun); + if (options.ie8) def.defun = defun.parent_scope.resolve(); + } else if (node instanceof AST_SymbolVar) { + defun.def_variable(node, node.TYPE == "SymbolVar" ? null : undefined); if (defun !== scope) { node.mark_enclosed(options); var def = scope.find_variable(node); if (node.thedef !== def) { node.thedef = def; - node.reference(options); } + node.reference(options); } - } - else if (node instanceof AST_SymbolCatch) { + } else if (node instanceof AST_SymbolCatch) { scope.def_variable(node).defun = defun; } - else if (node instanceof AST_LabelRef) { - var sym = labels.get(node.name); - if (!sym) throw new Error(string_template("Undefined label {name} [{line},{col}]", { - name: node.name, - line: node.start.line, - col: node.start.col - })); - node.thedef = sym; - } }); self.walk(tw); // pass 2: find back references and eval self.globals = new Dictionary(); - var tw = new TreeWalker(function(node, descend){ - if (node instanceof AST_LoopControl && node.label) { - node.label.thedef.references.push(node); + var tw = new TreeWalker(function(node) { + if (node instanceof AST_LoopControl) { + if (node.label) node.label.thedef.references.push(node); return true; } if (node instanceof AST_SymbolRef) { @@ -211,43 +179,47 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){ return true; } // ensure mangling works if catch reuses a scope variable - var def; - if (node instanceof AST_SymbolCatch && (def = node.definition().redefined())) { - var s = node.scope; - while (s) { + if (node instanceof AST_SymbolCatch) { + var def = node.definition().redefined(); + if (def) for (var s = node.scope; s; s = s.parent_scope) { push_uniq(s.enclosed, def); if (s === def.scope) break; - s = s.parent_scope; } + return true; } }); self.walk(tw); // pass 3: fix up any scoping issue with IE8 - if (options.ie8) { - self.walk(new TreeWalker(function(node, descend) { - if (node instanceof AST_SymbolCatch) { - var name = node.name; - var refs = node.thedef.references; - var scope = node.thedef.defun; - var def = scope.find_variable(name) || self.globals.get(name) || scope.def_variable(node); - refs.forEach(function(ref) { - ref.thedef = def; - ref.reference(options); - }); - node.thedef = def; - node.reference(options); - return true; + if (options.ie8) self.walk(new TreeWalker(function(node) { + if (node instanceof AST_SymbolCatch) { + redefine(node, node.thedef.defun); + return true; + } + if (node instanceof AST_SymbolLambda) { + var def = node.thedef; + if (def.orig.length == 1) { + redefine(node, node.scope.parent_scope); + node.thedef.init = def.init; } - })); - } + return true; + } + })); - if (options.cache) { - this.cname = options.cache.cname; + function redefine(node, scope) { + var name = node.name; + var refs = node.thedef.references; + var def = scope.find_variable(name) || self.globals.get(name) || scope.def_variable(node); + refs.forEach(function(ref) { + ref.thedef = def; + ref.reference(options); + }); + node.thedef = def; + node.reference(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); @@ -260,7 +232,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 @@ -270,7 +242,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({ @@ -282,8 +254,7 @@ AST_Lambda.DEFMETHOD("init_scope_vars", function(){ AST_Symbol.DEFMETHOD("mark_enclosed", function(options) { var def = this.definition(); - var s = this.scope; - while (s) { + for (var s = this.scope; s; s = s.parent_scope) { push_uniq(s.enclosed, def); if (options.keep_fnames) { s.functions.each(function(d) { @@ -291,7 +262,6 @@ AST_Symbol.DEFMETHOD("mark_enclosed", function(options) { }); } if (s === def.scope) break; - s = s.parent_scope; } }); @@ -300,69 +270,87 @@ 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){ - this.functions.set(symbol.name, this.def_variable(symbol)); +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){ - var def; - if (!this.variables.has(symbol.name)) { - def = new SymbolDef(this, symbol); +AST_Scope.DEFMETHOD("def_variable", function(symbol, init) { + var def = this.variables.get(symbol.name); + if (def) { + def.orig.push(symbol); + if (def.init && (def.scope !== symbol.scope || def.init instanceof AST_Function)) { + def.init = init; + } + } else { + def = new SymbolDef(this, symbol, init); this.variables.set(symbol.name, def); def.global = !this.parent_scope; - } else { - def = this.variables.get(symbol.name); - def.orig.push(symbol); } return symbol.thedef = def; }); -AST_Scope.DEFMETHOD("next_mangled", function(options){ - var ext = this.enclosed; - out: while (true) { - var m = base54(++this.cname); - if (!is_identifier(m)) continue; // skip over "do" - - // https://github.com/mishoo/UglifyJS2/issues/242 -- do not - // shadow a name reserved from mangling. - if (member(m, options.reserved)) continue; - - // we must ensure that the mangled name does not shadow a name - // from some parent scope that is referenced in this or in - // inner scopes. - for (var i = ext.length; --i >= 0;) { - var sym = ext[i]; - var name = sym.mangled_name || (sym.unmangleable(options) && sym.name); - if (m == name) continue out; - } - return m; - } +AST_Lambda.DEFMETHOD("resolve", return_this); +AST_Scope.DEFMETHOD("resolve", function() { + return this.parent_scope; }); - -AST_Function.DEFMETHOD("next_mangled", function(options, def){ - // #179, #326 - // in Safari strict mode, something like (function x(x){...}) is a syntax error; - // a function expression's argument cannot shadow the function expression's name - - var tricky_def = def.orig[0] instanceof AST_SymbolFunarg && this.name && this.name.definition(); - - // the function's mangled_name is null when keep_fnames is true - var tricky_name = tricky_def ? tricky_def.mangled_name || tricky_def.name : null; - +AST_Toplevel.DEFMETHOD("resolve", return_this); + +function names_in_use(scope, options) { + var names = scope.names_in_use; + if (!names) { + scope.names_in_use = names = Object.create(scope.mangled_names || null); + scope.cname_holes = []; + scope.enclosed.forEach(function(def) { + if (def.unmangleable(options)) names[def.name] = true; + }); + } + return names; +} + +function next_mangled_name(scope, options, def) { + var in_use = names_in_use(scope, options); + var holes = scope.cname_holes; + var names = Object.create(null); + var scopes = [ scope ]; + def.references.forEach(function(sym) { + var scope = sym.scope; + do { + if (scopes.indexOf(scope) < 0) { + for (var name in names_in_use(scope, options)) { + names[name] = true; + } + scopes.push(scope); + } else break; + } while (scope = scope.parent_scope); + }); + var name; + for (var i = 0, len = holes.length; i < len; i++) { + name = base54(holes[i]); + if (names[name]) continue; + holes.splice(i, 1); + scope.names_in_use[name] = true; + return name; + } while (true) { - var name = AST_Lambda.prototype.next_mangled.call(this, options, def); - if (!tricky_name || tricky_name != name) - return name; + name = base54(++scope.cname); + if (in_use[name] || !is_identifier(name) || options.reserved.has[name]) continue; + if (!names[name]) break; + holes.push(scope.cname); } -}); + scope.names_in_use[name] = true; + return name; +} -AST_Symbol.DEFMETHOD("unmangleable", function(options){ +AST_Symbol.DEFMETHOD("unmangleable", function(options) { var def = this.definition(); return !def || def.unmangleable(options); }); @@ -370,20 +358,19 @@ AST_Symbol.DEFMETHOD("unmangleable", function(options){ // labels are always mangleable AST_Label.DEFMETHOD("unmangleable", return_false); -AST_Symbol.DEFMETHOD("unreferenced", function(){ - return this.definition().references.length == 0 - && !(this.scope.uses_eval || this.scope.uses_with); +AST_Symbol.DEFMETHOD("unreferenced", function() { + return !this.definition().references.length && !this.scope.pinned(); }); -AST_Symbol.DEFMETHOD("definition", function(){ +AST_Symbol.DEFMETHOD("definition", function() { return this.thedef; }); -AST_Symbol.DEFMETHOD("global", function(){ +AST_Symbol.DEFMETHOD("global", function() { return this.definition().global; }); -AST_Toplevel.DEFMETHOD("_default_mangler_options", function(options) { +function _default_mangler_options(options) { options = defaults(options, { eval : false, ie8 : false, @@ -394,113 +381,128 @@ AST_Toplevel.DEFMETHOD("_default_mangler_options", function(options) { if (!Array.isArray(options.reserved)) options.reserved = []; // Never mangle arguments push_uniq(options.reserved, "arguments"); + options.reserved.has = makePredicate(options.reserved); return options; -}); +} -AST_Toplevel.DEFMETHOD("mangle_names", function(options){ - options = this._default_mangler_options(options); +AST_Toplevel.DEFMETHOD("mangle_names", function(options) { + options = _default_mangler_options(options); // We only need to mangle declaration nodes. Special logic wired // into the code generator will display the mangled name if it's // present (and for AST_SymbolRef-s it'll use the mangled name of // the AST_SymbolDeclaration that it points to). var lname = -1; - var to_mangle = []; - if (options.cache) { - this.globals.each(collect); + if (options.cache && options.cache.props) { + var mangled_names = this.mangled_names = Object.create(null); + options.cache.props.each(function(mangled_name) { + mangled_names[mangled_name] = true; + }); } - var tw = new TreeWalker(function(node, descend){ + var redefined = []; + 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; descend(); lname = save_nesting; - return true; // don't descend again in TreeWalker + return true; } if (node instanceof AST_Scope) { - node.variables.each(collect); - return; + descend(); + if (options.cache && node instanceof AST_Toplevel) { + node.globals.each(mangle); + } + node.variables.each(mangle); + return true; } if (node instanceof AST_Label) { var name; - do name = base54(++lname); while (!is_identifier(name)); + do { + name = base54(++lname); + } while (!is_identifier(name)); node.mangled_name = name; return true; } - if (!options.ie8 && node instanceof AST_SymbolCatch) { - to_mangle.push(node.definition()); - return; + if (!options.ie8 && node instanceof AST_Catch) { + var def = node.argname.definition(); + var redef = def.redefined(); + if (redef) { + redefined.push(def); + reference(node.argname); + def.references.forEach(reference); + } + descend(); + if (!redef) mangle(def); + return true; + } + + function reference(sym) { + sym.thedef = redef; + sym.reference(options); + sym.thedef = def; } }); this.walk(tw); - to_mangle.forEach(function(def){ def.mangle(options) }); - - if (options.cache) { - options.cache.cname = this.cname; - } + redefined.forEach(mangle); - function collect(symbol) { - if (!member(symbol.name, options.reserved)) { - to_mangle.push(symbol); - } + function mangle(def) { + if (options.reserved.has[def.name]) return; + def.mangle(options); } }); -AST_Toplevel.DEFMETHOD("find_unique_prefix", function(options) { - var letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_"; +AST_Toplevel.DEFMETHOD("find_colliding_names", function(options) { var cache = options.cache && options.cache.props; - var prefixes = Object.create(null); - options.reserved.forEach(add_prefix); + var avoid = Object.create(null); + options.reserved.forEach(to_avoid); this.globals.each(add_def); this.walk(new TreeWalker(function(node) { if (node instanceof AST_Scope) node.variables.each(add_def); if (node instanceof AST_SymbolCatch) add_def(node.definition()); })); - var prefix, i = 0; - do { - prefix = create_name(i++); - } while (prefixes[prefix]); - return prefix; - - function add_prefix(name) { - if (/[0-9]$/.test(name)) { - prefixes[name.replace(/[0-9]+$/, "")] = true; - } + return avoid; + + function to_avoid(name) { + avoid[name] = true; } function add_def(def) { var name = def.name; if (def.global && cache && cache.has(name)) name = cache.get(name); else if (!def.unmangleable(options)) return; - add_prefix(name); - } - - function create_name(num) { - var name = ""; - do { - name += letters[num % letters.length]; - num = Math.floor(num / letters.length); - } while (num); - return name; + to_avoid(name); } }); AST_Toplevel.DEFMETHOD("expand_names", function(options) { - options = this._default_mangler_options(options); - var prefix = this.find_unique_prefix(options); + base54.reset(); + base54.sort(); + options = _default_mangler_options(options); + var avoid = this.find_colliding_names(options); + var cname = 0; this.globals.each(rename); this.walk(new TreeWalker(function(node) { if (node instanceof AST_Scope) node.variables.each(rename); if (node instanceof AST_SymbolCatch) rename(node.definition()); })); + function next_name() { + var name; + do { + name = base54(cname++); + } while (avoid[name] || !is_identifier(name)); + return name; + } + function rename(def) { - if (def.global || def.unmangleable(options)) return; - if (member(def.name, options.reserved)) return; + if (def.global && options.cache) return; + if (def.unmangleable(options)) return; + if (options.reserved.has[def.name]) return; var d = def.redefined(); - def.name = d ? d.name : prefix + def.id; + def.name = d ? d.name : next_name(); def.orig.forEach(function(sym) { sym.name = def.name; }); @@ -515,8 +517,9 @@ AST_Sequence.DEFMETHOD("tail_node", function() { return this.expressions[this.expressions.length - 1]; }); -AST_Toplevel.DEFMETHOD("compute_char_frequency", function(options){ - options = this._default_mangler_options(options); +AST_Toplevel.DEFMETHOD("compute_char_frequency", function(options) { + options = _default_mangler_options(options); + base54.reset(); try { AST_Node.prototype.print = function(stream, force_parens) { this._print(stream, force_parens); @@ -549,17 +552,21 @@ AST_Toplevel.DEFMETHOD("compute_char_frequency", function(options){ }); var base54 = (function() { - var leading = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_".split(""); - var digits = "0123456789".split(""); + var freq = Object.create(null); + function init(chars) { + var array = []; + for (var i = 0, len = chars.length; i < len; i++) { + var ch = chars[i]; + array.push(ch); + freq[ch] = -1e-2 * i; + } + return array; + } + var digits = init("0123456789"); + var leading = init("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_"); var chars, frequency; function reset() { - frequency = Object.create(null); - leading.forEach(function(ch) { - frequency[ch] = 0; - }); - digits.forEach(function(ch) { - frequency[ch] = 0; - }); + frequency = Object.create(freq); } base54.consider = function(str, delta) { for (var i = str.length; --i >= 0;) { @@ -570,7 +577,7 @@ var base54 = (function() { return frequency[b] - frequency[a]; } base54.sort = function() { - chars = mergeSort(leading, compare).concat(mergeSort(digits, compare)); + chars = leading.sort(compare).concat(digits.sort(compare)); }; base54.reset = reset; reset(); @@ -584,6 +591,6 @@ var base54 = (function() { base = 64; } while (num > 0); return ret; - }; + } return base54; })(); |