Lines Matching +defs:a +defs:name
126 var name = lambda.name;
127 if (!name) return parent && parent.TYPE == "Call" && parent.expression === lambda;
128 if (name.fixed_value() !== lambda) return false;
129 var def = name.definition();
166 return top_retain.test(def.name);
175 return member(def.name, top_retain);
201 // would call AST_Node.transform() if a different instance of AST_Node is
206 // thus gives a consistent AST snapshot.
286 defn.name.match_symbol(export_symbol, true);
289 export_symbol(stat.name);
301 node.alias = make_node(AST_String, node, { value: node.name });
404 function is_read_only_fn(value, name) {
405 if (value instanceof AST_Boolean) return native_fns.Boolean[name];
406 if (value instanceof AST_Number) return native_fns.Number[name];
407 if (value instanceof AST_String) return native_fns.String[name];
408 if (name == "valueOf") return false;
409 if (value instanceof AST_Array) return native_fns.Array[name];
410 if (value instanceof AST_Lambda) return native_fns.Function[name];
411 if (value instanceof AST_Object) return native_fns.Object[name];
412 if (value instanceof AST_RegExp) return native_fns.RegExp[name] && !value.value.global;
474 return def.name == "arguments" && def.scope.uses_arguments;
592 if (fn.variables.get(d.name) === d) return;
679 if (def.global && def.name == "arguments") return false;
832 node.name.walk(scanner);
927 // (function(a,b) {...})(c,d) ---> (function() {var a=c,b=d; ...})()
1177 if (node.name) {
1178 var d = node.name.definition();
1228 this.name.walk(tw);
1274 init.definitions[0].name.mark_symbol(function(node) {
1325 if (fn.name) mark_escaped(tw, fn.name.definition(), fn, fn.name, fn, 0, 1);
1330 var def = fn.name.definition();
1548 if (value instanceof AST_LambdaExpression && node.name instanceof AST_SymbolDeclaration) {
1552 var ld = node.name.definition();
1563 scan_declaration(tw, compressor, node.name, function() {
1565 }, function(name, fixed) {
1566 var d = name.definition();
1572 if (name instanceof AST_SymbolConst && d.redefined()
1573 || !(can_drop_symbol(name) || is_safe_lexical(d))) {
1613 // Stack of look-up tables to keep track of whether a `SymbolDef` has been
1649 node.name = node.name.transform(this);
1684 node.name.walk(marker);
1713 node.name.walk(tw);
1744 if (parent.name || is_async(parent) || is_generator(parent)) return true;
1771 return compressor.exposed(def) && identifier_atom[def.name];
1824 || is_undeclared_ref(val) && val.name == "eval";
1880 var def = stat.name.definition();
1881 var scope = stat.name.scope;
1932 if (exp.name) return false;
1951 || compressor.option("unsafe") && global_names[this.name];
1984 // Certain combination of unused name + side effect leads to invalid AST:
2114 // - `var a = x;`
2115 // - `a = x;`
2116 // - `++a`
2236 var def = candidate.name.definition();
2281 node.name = node.name.transform(scanner);
2292 return !enclosed.has(def.name) && !lvalues.has(def.name);
2359 // function(a, b){ ... }(x());
2361 // var a = x(), b = undefined;
2384 var funarg = candidate.name instanceof AST_SymbolFunarg;
2462 if (node.name) node.name = node.name.transform(tt);
2484 // Scan object only in a for-in/of statement
2490 // Scan first case expression only in a switch statement
2512 if (parent instanceof AST_DefaultValue) return parent.name === node;
2532 if (node instanceof AST_Defun) return funarg && lhs.name === node.name.name;
2626 return compressor.option("ie") && node.name && lvalues.has(node.name.name);
2634 if (is_undeclared_ref(exp) && global_names[exp.name]) return false;
2652 if (check_destructured(node.name)) return true;
2653 return (node.value || parent instanceof AST_Let) && node.name.match_symbol(function(node) {
2655 && (lvalues.has(node.name) || side_effects && may_modify(node));
2665 && (lvalues.has(node.name) || read_toplevel && compressor.exposed(node.definition()));
2677 || arg_may_throw(reject, node.name, node.value)
2678 || !is_undefined(value) && arg_may_throw(reject, node.name, value);
2726 return node instanceof AST_Symbol && node.name == "await";
2749 || (def = fn.variables.get(node.name)) && def !== node.definition()) {
2771 sym = sym.name;
2784 if (names.has(sym.name)) continue;
2785 names.set(sym.name, true);
2796 name: sym,
2818 assignments.set(lhs.name, (assignments.get(lhs.name) || 0) + 1);
2903 if (expr.name instanceof AST_SymbolVar) {
2905 var def = expr.name.definition();
2910 declare_only.set(expr.name.name, (declare_only.get(expr.name.name) || 0) + 1);
2982 return ref instanceof AST_SymbolRef && (lhs.name == ref.name || value_def.name == ref.name);
3045 if (parent instanceof AST_VarDef) return parent.name.match_symbol(function(sym) {
3046 return sym instanceof AST_SymbolDeclaration && (lhs.name == sym.name || value_def.name == sym.name);
3087 if (parent instanceof AST_VarDef) return check_assignment(parent.name);
3128 return def.references.length - def.replaced - (assignments.get(def.name) || 0);
3155 var lhs = expr.name;
3160 var declared = def.orig.length - def.eliminated - (declare_only.get(def.name) || 0);
3280 if (!expr.name.definition().fixed) well_defined = false;
3281 lvalues.add(expr.name.name, lhs);
3303 lvalues.add(node.name, is_modified(compressor, tw, node, value, 0));
3328 if (def.scope !== node) enclosed.set(def.name, true);
3335 lvalues.add(argname.name, true);
3383 declare_only.set(last.name.name, (declare_only.get(last.name.name) || 0) + 1);
3431 var lvalue = lvalues.get(sym.name);
3475 var lvalue = lvalues.get(sym.name);
3605 // proceed further only if `TreeWalker.stack` is in a consistent state
3672 // if (a) return b; if (c) return d; e; ---> return a ? b : c ? d : void e;
3777 if (stat.name.definition().preinit) return false;
3780 return !defn.name.match_symbol(function(node) {
4133 if (trim_assigns(def.name, def.value, exprs)) trimmed = true;
4159 if (var_def.name instanceof AST_Destructured) return;
4161 var def = var_def.name.definition();
4186 var name = make_node(AST_SymbolVar, lhs);
4188 name: name,
4191 def.orig.push(name);
4199 function trim_assigns(name, value, exprs) {
4201 names.set(name.name, true);
4203 if (value.left instanceof AST_SymbolRef) names.set(value.left.name, true);
4221 if (!names.has(sym.name)) return;
4312 stat.init = stat.init.definitions[0].name.convert_symbol(AST_SymbolRef, function(ref, name) {
4313 defns.push(make_node(AST_VarDef, name, {
4314 name: name,
4317 name.definition().references.push(ref);
4560 if (rhs instanceof AST_Binary && rhs.operator == "||" && sym.name == rhs.left.name) {
4682 // methods to determine whether an expression has a boolean result type
4725 // methods to determine if an expression has a numeric result type
4786 || is_undeclared_ref(exp.expression) && exp.expression.name == "Math");
4818 // methods to determine if an expression has a string result type
4927 if (HOP(compressor.option("global_defs"), this.name)) warn(this);
4932 var name = this.name + suffix;
4933 if (HOP(defines, name)) return to_node(defines[name], this);
5086 var static_fn = static_fns[expr.name];
5087 return static_fn && (static_fn[node.property] || expr.name == "Math" && node.property == "random");
5104 // methods to evaluate a constant expression
5106 // If the node has been successfully reduced to a constant,
5110 // They can be distinguished as constant value is never a
5149 throw new Error(string_template("Cannot evaluate a statement [{start}]", this));
5255 // incorrectly return "object". Hence making is a special case.
5461 var static_value = static_values[exp.name];
5463 val = global_objs[exp.name];
5469 case "name":
5470 return val.node.name ? val.node.name.name : "";
5495 if (fn.name && fn.name.definition().recursive_refs > 0) return this;
5506 sym = sym.name;
5559 var static_fn = static_fns[e.name];
5561 val = global_objs[e.name];
5565 var native_fn = native_fns[val.constructor.name];
5583 if (sym instanceof AST_DefaultValue) sym = sym.name;
5645 throw new Error("Cannot negate a statement");
5709 if (global_pure_fns[expr.name]) return true;
5710 if (this instanceof AST_New && global_pure_constructors[expr.name]) return true;
5720 if (is_undeclared_ref(tag) && global_pure_fns[tag.name]) return true;
5722 var static_fn = static_fns[tag.expression.name];
5724 || tag.expression.name == "Math" && tag.property == "random");
6000 return this.name.may_throw(compressor)
6072 return this.name.may_throw(compressor)
6123 if (self.variables.has(node.name)) return true;
6127 var scope_def = scope.find_variable(node.name);
6158 // tell me if a statement aborts
6304 } else if (self.name && self.name.definition() === exp.definition()) {
6318 if ((fn !== exp || fn.name)
6411 if (node.name) node.name.walk(tw);
6487 if (node.name) references[node.name.definition().id] = false;
6600 }, node.name);
6680 return scope.find_variable(def.name) === def;
6687 sym.name = def.name;
6720 node.name.walk(marker);
6747 ldef = fn.variables.get(sym.name);
6752 && fn.parent_scope.find_variable(sym.name) !== def;
6771 } else if ((ldef = self.variables.get(def.name)) !== def) {
6774 } else if (compressor.exposed(def) || NO_MERGE[sym.name]) {
6843 if (cl.name) cl.name = drop_name ? null : make_node(AST_SymbolClass, cl.name);
6864 fn.name = drop_name ? null : make_node(AST_SymbolLambda, defun.name);
6907 var find_variable = function(name) {
6909 return find_variable(name);
6915 return compose(parent, level + 1, in_arg ? function(name) {
6916 var def = find(name);
6918 def = parent.variables.get(name);
6923 } : parent.variables ? function(name) {
6924 return find(name) || parent.variables.get(name);
6938 AST_Node.info("Retaining variable {name}", def);
6962 var def = node.name.definition();
6993 var def = node.name.definition();
7011 && (defn.name instanceof AST_Destructured || value.has_side_effects(compressor));
7013 defn.name.mark_symbol(function(name) {
7014 if (!(name instanceof AST_SymbolDeclaration)) return;
7015 var def = name.definition();
7031 verify_safe_usage(def, name, value_modified[def.id]);
7073 // function argument will always overshadow its name
7084 if (node instanceof AST_Function && node.name && !drop_fn_name(node.name.definition())) {
7245 var def = node.name.definition();
7247 log(node.name, "Dropping unused class {name}");
7257 if (node instanceof AST_ClassExpression && node.name && drop_fn_name(node.name.definition())) {
7258 node.name = null;
7262 var def = node.name.definition();
7264 log(node.name, "Dropping unused function {name}");
7274 if (node instanceof AST_LambdaExpression && node.name && drop_fn_name(node.name.definition())) {
7275 node.name = null;
7296 rest = trimmed.name;
7323 log(sym, "Dropping unused function argument {name}");
7337 funarg = trimmed.name;
7345 log_default(sym, "Dropping unused default argument {name}");
7348 log_default(sym, "Dropping unused default argument assignment {name}");
7349 if (sym.name instanceof AST_SymbolFunarg) {
7350 sym.name.unused = true;
7354 argnames[i] = sym.name;
7356 log_default(sym, "Dropping unused default argument value {name}");
7385 if (def.name instanceof AST_Destructured) {
7386 var trimmed = trim_destructured(def.name, value, function(node) {
7393 if (trimmed.name) {
7395 name: trimmed.name,
7404 var sym = def.name.definition();
7405 var drop_sym = is_var ? can_drop_symbol(def.name) : is_safe_lexical(sym);
7411 if (value) AST_Node.warn("Side effects in definition of variable {name} [{start}]", def.name);
7426 AST_Node.info("Dropping declaration of variable {name} [{start}]", def.name);
7443 && (old_def = rename_def(fn, def.name.name)) !== false) {
7444 AST_Node.warn("Declaring {name} as function [{start}]", def.name);
7461 defun.name = make_node(AST_SymbolDefun, def.name);
7462 var name_def = def.name.scope.resolve().def_function(defun.name);
7464 node.name = name_def.name;
7474 && sym.orig.indexOf(def.name) > sym.eliminated) {
7480 } else if (is_catch(def.name)) {
7484 AST_Node.warn("Dropping duplicated declaration of variable {name} [{start}]", def.name);
7494 AST_Node.warn("Side effects in initialization of unused variable {name} [{start}]", def.name);
7497 log(def.name, "Dropping unused variable {name}");
7507 if (refs.length == 0) return fn === def.name.fixed_value();
7522 function rename_def(fn, name) {
7523 if (!fn.name) return null;
7524 var def = fn.name.definition();
7527 if (def.name == name) return def;
7530 switch (name) {
7540 if (scope.find_variable(name) !== sym) return false;
7579 AST_Node.info("Dropping duplicated definition of variable {name} [{start}]", def.name);
7580 var sym = def.name.definition();
7581 var ref = make_node(AST_SymbolRef, def.name);
7598 var id = head[0].name.definition().id;
7627 if (trimmed.name) return make_node(AST_Assign, node, {
7629 left: trimmed.name,
7637 // Certain combination of unused name + side effect leads to invalid AST:
7681 log(sym, "Dropping unused loop variable {name}");
7721 if (node.name instanceof AST_SymbolFunarg) {
7722 log(node.name, text);
7802 init = init.definitions[0].name;
7822 if (node_def.scope.resolve() !== self && self.variables.get(sym.name) !== node_def) return;
7885 var d = find_variable(sym.name);
7917 return (node instanceof AST_DefaultValue ? node.name : node) instanceof AST_SymbolDeclaration;
7928 var name = node.name.transform(trimmer);
7929 if (!name) {
7930 if (node.name instanceof AST_Destructured) return null;
7933 log(node.name, "Side effects in default value of unused variable {name}");
7935 node.name.unused = null;
7952 root = node = node.name;
7954 node = node.name;
8194 name: node.transform(trimmer),
8221 if (node instanceof AST_DefaultValue) return retain_lhs(node.name);
8248 // let's count var_decl first, we seem to waste a lot of
8287 var sym = defn.name;
8289 && !consts.has(sym.name)
8290 && self.find_variable(sym.name) === sym.definition();
8293 vars.set(defn.name.name, defn);
8298 var sym = node.definitions[0].name;
8307 consts.set(node.name, true);
8318 })) vars.del(argname.name);
8320 vars.each(function(defn, name) {
8322 defn.name = defn.name.clone();
8325 vars.set(name, defn);
8326 defn.name.definition().orig.unshift(defn.name);
8393 switch (can_trim_returns(this.name.definition(), map_self_returns(this), compressor)) {
8406 if (this.name && !can_trim(this.name.definition())) return;
8428 if (sym instanceof AST_DefaultValue) sym = sym.name;
8464 var_names.set(def.name, true);
8466 this.variables.each(function(def, name) {
8467 var_names.set(name, true);
8482 prefix = prefix.replace(/^[^a-z_$]|[^a-z0-9_$]/gi, "_");
8483 var name = prefix;
8485 return !scope.var_names().has(name);
8486 }); i++) name = prefix + "$" + i;
8488 name: name,
8494 scope.var_names().set(name, true);
8517 name: decl,
8521 name: decl.name,
8546 if (!can_hoist(node.name, node.value, 0)) return;
8551 decl.value = node.name instanceof AST_SymbolConst ? make_node(AST_Number, node, { value: 0 }) : null;
8555 name: make_sym(node.name.CTOR, node.name, prop.key),
8560 defs_by_id[node.name.definition().id] = defs;
8565 var new_var = self.make_var(type, sym, sym.name + "_" + key);
8579 name: def.name,
8600 if (self.find_variable(sym.name) !== def) return;
8616 if (!fn.name || !compressor.option("ie")) return true;
8617 var def = fn.name.definition();
8641 if (!ignore_name && exp.name) {
8642 var def = exp.name.definition();
8707 var abort = !drop_body && exp.name || arrow && exp.value && !needs_enqueuing(compressor, exp.value);
8933 if (!base && !values && !self.name) return null;
8936 if (base || self.name || !compressor.has_directive("use strict")) {
9351 var name = self.init.definitions[0].name;
9352 if ((name instanceof AST_Destructured || name instanceof AST_SymbolLet)
9353 && !name.match_symbol(function(node) {
9870 left: var_def.name.convert_symbol(AST_SymbolRef, function(ref) {
10071 var def = var_def.name.definition().redefined();
10073 var_def.name = var_def.name.clone();
10074 var_def.name.thedef = def;
10100 defn.name.match_symbol(function(node) {
10102 name: node,
10118 var assignments = this.definitions.reduce(function(a, defn) {
10119 var def = defn.name.definition();
10123 var name = make_node(AST_SymbolRef, defn.name);
10126 left: name,
10129 a.push(assign);
10136 name.fixed = fixed;
10149 def.references.push(name);
10154 return a;
10161 return def.name != "arguments" && def.orig.length < (def.orig[0] instanceof AST_SymbolLambda ? 3 : 2);
10169 if (s.var_names().has(def.name)) return true;
10177 name: defn.name.convert_symbol(AST_SymbolVar, function(name, node) {
10178 var def = name.definition();
10179 def.orig[def.orig.indexOf(node)] = name;
10182 scope.variables.set(def.name, def);
10184 scope.var_names().set(def.name, true);
10202 return !defn.name.match_symbol(function(node) {
10249 var is_iife = fn === exp && !fn.name;
10278 argnames[i] = argname = argname.name;
10348 } else if (node instanceof AST_LambdaDefinition && avoid[node.name.name]) {
10353 if (node instanceof AST_Symbol && avoid[node.name] && node !== fn.name) safe = false;
10383 if (is_undeclared_ref(exp)) switch (exp.name) {
10484 if (separator instanceof AST_Node) break EXIT; // not a constant
10518 // [ 1, 2, a, 3 ].join("") ---> "12" + a + "3"
10598 && exp.expression.name == "Object") {
10606 && exp.name == "Function") {
10615 // quite a corner-case, but we can handle it:
10617 // if the code argument is a constant, then we can minify it.
10678 argname = argname.name;
10693 && !fn.name
10704 && !(fn.name && fn instanceof AST_LambdaExpression)
10715 if (fn.variables.get(node.name) !== def) {
10779 var name = exp.expression;
10780 while (name.expression) {
10781 name = name.expression;
10783 if (is_undeclared_ref(name) && name.name == "console") {
10807 name: node.name.transform(tt) || make_void_lhs(node),
10944 if (avoid && node instanceof AST_Symbol && avoid[node.name]) return abort = true;
10947 if (fn.variables.get(node.name) !== def) {
10992 function var_exists(defined, name) {
10993 return defined.has(name) || identifier_atom[name] || scope.var_names().has(name);
11001 if (!safe_to_inject || var_exists(defined, arg.name)) return abort = true;
11002 arg_used.set(arg.name, true);
11012 var name = stat.name;
11014 if (arg_used.has(name.name)) return false;
11015 if (var_exists(defined, name.name)) return false;
11017 return def.scope === scope || def.scope === stat || !defined.has(def.name);
11019 if (in_loop) in_loop.push(name.definition());
11025 var name = stat.definitions[j].name;
11026 if (var_exists(defined, name.name)) return false;
11027 if (in_loop) in_loop.push(name.definition());
11039 defined.set(def.name, true);
11074 function append_var(decls, expressions, name, value) {
11075 var def = name.definition();
11076 if (!scope.var_names().has(name.name)) {
11077 scope.var_names().set(name.name, true);
11078 decls.push(make_node(AST_VarDef, name, {
11079 name: name,
11083 scope.variables.set(name.name, def);
11086 var sym = make_node(AST_SymbolRef, name);
11104 var name;
11107 name = argname.name;
11109 name = argname;
11112 if (name.unused || scope.var_names().has(name.name)) {
11115 var symbol = make_node(AST_SymbolVar, name);
11116 var def = name.definition();
11119 if (name.unused !== undefined) {
11123 if (!value && argname === name && (in_loop
11124 || name.name == "arguments" && !is_arrow(fn) && is_arrow(scope))) {
11135 if (node.name.unused !== undefined) {
11138 var sym = make_node(AST_SymbolRef, node.name);
11139 node.name.definition().references.push(sym);
11162 function process(ref, name) {
11163 if (name.unused) return make_void_lhs(name);
11164 var def = name.definition();
11167 var symbol = make_node(AST_SymbolVar, name);
11179 var name = make_node(AST_SymbolVar, flatten_var(stat.name));
11180 var def = name.definition();
11182 def.orig.push(name);
11184 append_var(decls, expr_fn, name, to_func_expr(stat, true));
11188 var def = stat.name.definition();
11189 scope.functions.set(def.name, def);
11190 scope.variables.set(def.name, def);
11192 scope.var_names().set(def.name, true);
11202 var name = flatten_var(var_def.name);
11209 append_var(decl_var, expr_var, name, value);
11211 if (arg_used.has(name.name)) continue;
11212 if (name.definition().orig.length == 1 && fn.functions.has(name.name)) continue;
11213 expr_loop.push(init_ref(compressor, name));
11236 if (scope.var_names().has(def.name)) return;
11238 scope.var_names().set(def.name, true);
11247 if (is_undeclared_ref(exp)) switch (exp.name) {
11264 // (a = b, x && a = c) ---> a = x ? c : b
11265 // (a = b, x || a = c) ---> a = x ? b : c
11417 // typeof always returns a non-empty string, thus always truthy
11649 // if right is a constant, whatever side effects the
11661 // a || (a = x) ---> a = a || x
11662 // (a = x) && (a = y) ---> a = (a = x) && y
11761 // a || a ---> a
11762 // (a = x) && a --> a = x
11969 // a + -b ---> a - b
11980 // -a + b ---> b - a
11992 // (a + b) + 3 ---> 3 + (a + b)
12013 // a - -b ---> a + b
12028 // +a - b ---> a - b
12029 // a - +b ---> a - b
12042 // a + +b ---> +b + a
12058 // a + (b + c) ---> (a + b) + c
12315 if (is_lambda(node) && node.name && node.name.definition() === def) return node;
12331 switch (self.name) {
12354 } else if (fixed.name && fixed.name.definition() !== def) {
12367 } else if (fixed.name && (fixed.name.name == "await" && is_async(fixed)
12368 || fixed.name.name == "yield" && is_generator(fixed))) {
12397 if (fixed.variables.has(def.name)) return;
12401 scope.var_names().set(def.name, true);
12408 var defun_def = value.name.definition();
12409 var lambda_def = value.variables.get(value.name.name);
12410 var name = lambda_def && lambda_def.orig[0];
12419 if (!(name instanceof symbol_type)) {
12420 name = make_node(symbol_type, value.name);
12421 name.scope = value;
12422 value.name = name;
12423 lambda_def = value[def_fn_name](name);
12428 if (node !== name) {
12443 && fn.name
12444 && fn.name.definition() === def
12445 && def.scope === fn.name.scope
12446 && fixed.variables.get(fn.name.name) === def) {
12447 fn.name = fn.name.clone();
12448 node.thedef = def = value.variables.get(fn.name.name) || value[def_fn_name](fn.name);
12490 var name_length = def.name.length;
12540 && tag.expression.name == "String";
12644 name: "undefined",
12693 if (!(node.name || is_async(node) || is_generator(node))) {
12774 if (!(parent.name instanceof AST_SymbolDeclaration)) continue;
12775 if (parent.name.definition() !== def) continue;
12790 && self.right.left.name == self.left.name
12796 && self.right.right.name == self.left.name
12963 // x ? (a, c) : (b, c) ---> x ? a : b, c
12976 // x ? y(a) : z(a) ---> (x ? y : z)(a)
12977 // x ? y.f(a) : z.f(a) ---> (x ? y : z).f(a)
12980 // x ? y(a) : y(b) ---> y(x ? a : b)
13003 // x ? (y ? a : b) : b ---> x && y ? a : b
13016 // x ? (y ? a : b) : a ---> !x || y ? a : b
13029 // x ? a : (y ? a : b) ---> x || y ? a : b
13042 // x ? b : (y ? a : b) ---> !x && y ? a : b
13055 // x ? y && a : a ---> (!x || y) && a
13069 // x ? y || a : a ---> x && y || a
13083 // x ? a : y && a ---> (x || y) && a
13097 // x ? a : y || a ---> !x && y || a
13183 var a = consequent.args;
13185 var len = a.length;
13188 if (!a[i].equals(b[i])) {
13189 if (a[i] instanceof AST_Spread !== b[i] instanceof AST_Spread) return -3;
13191 if (!a[j].equals(b[j])) return -2;
13353 || argname.name == "await"
13354 || expr.scope.find_variable(argname.name) !== (arg_def = argname.definition())) {
13357 || fn.name
13379 return node.name === argname.name;
13522 if (avoid[argname.name]) arrow = false;
13563 if (is_undeclared_ref(exp)) switch (exp.name) {
13713 function flatten_var(name) {
13714 var redef = name.definition().redefined();
13716 name = name.clone();
13717 name.thedef = redef;
13719 return name;
13726 if (node instanceof AST_SymbolRef && fn.variables.get(node.name) === node.definition()) {
13746 function init_ref(compressor, name) {
13747 var sym = make_node(AST_SymbolRef, name);
13748 var assign = make_node(AST_Assign, name, {
13751 right: make_node(AST_Undefined, name).transform(compressor),
13753 var def = name.definition();
13835 if (fn.name) return;
13848 defined.set(def.name, true);
13869 if (!fn.variables.all(function(def, name) {
13871 if (!defined.has(name) && !names.has(name)) return true;
13872 return !arrow && name == "arguments" && def.orig.length == 1;
13882 node.name.walk(tw);
13941 fn.functions.each(function(def, name) {
13942 scope.functions.set(name, def);
13945 fn.variables.each(function(def, name) {
13946 if (!arrow && name == "arguments" && def.orig.length == 1) return;
13947 names.set(name, true);
13949 scope.variables.set(name, def);
13954 if (def.orig.length == 1 && fn.functions.has(name)) return;
13977 name: argname.convert_symbol(AST_SymbolVar, process),
13989 name: make_node(AST_DestructuredArray, call, {
14007 var name = make_node(AST_SymbolVar, flatten_var(stat.name));
14008 var def = name.definition();
14010 def.orig.push(name);
14014 name: name,