Lines Matching refs:make_node
296 if (props.length) body.push(make_node(AST_ExportReferences, this, { properties: props }));
300 var node = make_node(AST_SymbolExport, sym);
301 node.alias = make_node(AST_String, node, { value: node.name });
310 if (node instanceof AST_Directive) node = make_node(AST_SimpleStatement, node, {
311 body: make_node(AST_String, node),
314 … return transform ? transform(node) : make_node(AST_Return, node, { value: node.body });
319 if (value instanceof AST_String) return make_node(AST_Directive, value);
320 return make_node(AST_SimpleStatement, node, {
321 body: value || make_node(AST_UnaryPrefix, node, {
323 expression: make_node(AST_Number, node, { value: 0 }),
354 return make_node(AST_UnaryPrefix, self, {
356 expression: make_node(AST_Number, self, { value: 0 }),
360 if (stat instanceof AST_Directive) return make_node(AST_String, stat);
363 return make_node(AST_Call, self, {
364 expression: make_node(AST_Function, self, {
374 if (!is_statement(self)) self = make_node(AST_SimpleStatement, self, { body: self });
375 … if (!(self instanceof AST_Toplevel)) self = make_node(AST_Toplevel, self, { body: [ self ] });
505 var node = make_node(AST_SymbolRef, ref);
506 node.fixed = fixed || make_node(AST_Undefined, ref);
681 def.fixed = make_node(AST_Undefined, def.orig[0]);
842 return make_node(AST_Sub, node, {
844 property: make_node(AST_Number, node, { value: index }),
856 if (!fixed_node) fixed_node = make_node(AST_Array, node, {});
885 return make_node(type, node, {
936 return arg || make_node(AST_Undefined, iife);
942 if (!fixed_node) fixed_node = make_node(AST_Array, fn, {});
1017 return make_node(AST_Binary, node, {
1514 return make_node(AST_Binary, node, {
1516 left: make_node(AST_UnaryPrefix, node, {
1520 right: make_node(AST_Number, node, { value: 1 }),
1529 return make_node(AST_UnaryPrefix, node, {
1564 return node.value || make_node(AST_Undefined, node);
1668 var node = make_node(type, this);
1776 function make_node(ctor, orig, props) { function
1788 … return make_node(AST_Sequence, orig, { expressions: expressions.reduce(merge_sequence, []) });
1794 return make_node(AST_String, orig, { value: val });
1796 if (isNaN(val)) return make_node(AST_NaN, orig);
1798 return 1 / val < 0 ? make_node(AST_UnaryPrefix, orig, {
1800 expression: make_node(AST_Number, orig, { value: -val }),
1801 }) : make_node(AST_Number, orig, { value: val });
1803 return val < 0 ? make_node(AST_UnaryPrefix, orig, {
1805 expression: make_node(AST_Infinity, orig),
1806 }) : make_node(AST_Infinity, orig);
1808 return make_node(val ? AST_True : AST_False, orig);
1810 return make_node(AST_Undefined, orig);
1813 return make_node(AST_Null, orig);
1816 return make_node(AST_RegExp, orig, { value: val });
1840 return wrap ? make_sequence(orig, [ make_node(AST_Number, orig, { value: 0 }), val ]) : val;
1997 if (!block) block = make_node(AST_BlockStatement, node, { body: [ node ] });
2162 folded = make_node(AST_Binary, candidate, {
2168 return make_node(AST_Assign, node, {
2171 right: make_node(AST_Binary, node, {
2212 return make_node(AST_Assign, candidate, {
2215 … right: candidate.operator == "&&" ? make_node(AST_Conditional, candidate, {
2219 }) : make_node(AST_Conditional, candidate, {
2226 … if (candidate instanceof AST_UnaryPostfix) return make_node(AST_UnaryPrefix, candidate, {
2241 return make_node(AST_Assign, candidate, {
2343 return make_node(AST_Assign, candidate, {
2588 if (fn.rest && arg_may_throw(reject, fn.rest, make_node(AST_Array, node, {
2788 arg = make_node(AST_Undefined, sym).transform(compressor);
2795 var candidate = make_node(AST_VarDef, sym, {
3170 return make_node(AST_SymbolRef, lhs);
3173 return make_node(AST_SymbolRef, lhs);
3366 argname.value = value || make_node(AST_Number, argname, { value: 0 });
3369 args[index] = value || make_node(AST_Number, args[index], { value: 0 });
3393 var body = [ make_node(AST_SimpleStatement, value, { body: value }) ];
3403 … return in_list ? List.splice(body) : make_node(AST_BlockStatement, node, { body: body });
3406 … return is_statement(node) ? make_node(AST_SimpleStatement, value, { body: value }) : value;
3568 statements[i] = make_node(AST_SimpleStatement, stat, { body: body });
3580 stat.body = make_node(AST_BlockStatement, stat, {
3583 stat.alternative = make_node(AST_BlockStatement, stat, {
3601 stat.body = make_node(AST_BlockStatement, next, {
3620 stat.body = make_node(AST_BlockStatement, stat.body, {
3623 stat.alternative = make_node(AST_BlockStatement, stat.alternative, {
3633 … var stats = make_node(AST_BlockStatement, self, { body: statements.slice(i + 1) });
3637 … var stats = make_node(AST_BlockStatement, self, { body: statements.slice(i + 1) });
3651 stat.alternative = make_node(AST_BlockStatement, next, {
3667 stat.alternative = make_node(AST_Return, stat, { value: null });
3688 stat.alternative = make_node(AST_BlockStatement, self, {
3689 … body: extract_functions().concat(make_node(AST_Return, self, { value: null })),
3811 tail.push(make_node(AST_SimpleStatement, stop.value, {
3840 if (value) block.push(make_node(AST_SimpleStatement, value, { body: value }));
3887 if (value) return make_node(AST_SimpleStatement, value, { body: value });
3888 return in_block ? null : make_node(AST_EmptyStatement, stat);
3990 statements[n++] = make_node(AST_SimpleStatement, body, { body: body });
4033 … stat.value = cons_seq(stat.value || make_node(AST_Undefined, stat)).optimize(compressor);
4070 decls.push(make_node(AST_If, stat, {
4072 body: body || make_node(AST_EmptyStatement, stat.body),
4186 var name = make_node(AST_SymbolVar, lhs);
4187 definitions.push(make_node(AST_VarDef, expr, {
4241 value.properties.push(make_node(AST_ObjectKeyVal, node, {
4313 defns.push(make_node(AST_VarDef, name, {
4369 return in_list ? List.skip : make_node(AST_EmptyStatement, node);
4410 target.push(make_node(AST_BlockStatement, stat, { body: block }));
4880 if (Array.isArray(value)) return make_node(AST_Array, orig, {
4888 props.push(make_node(AST_ObjectKeyVal, orig, {
4893 return make_node(AST_Object, orig, { properties: props });
4945 return best_of_expression(make_node(AST_SimpleStatement, ast1, {
4947 }), make_node(AST_SimpleStatement, ast2, {
4972 if (this.value) return make_node(AST_Return, this.value, { value: this.value });
5179 node = make_node(AST_Binary, this, {
5629 return make_node(AST_UnaryPrefix, exp, {
5636 … if (first_in_statement) return best_of_expression(negated, make_node(AST_SimpleStatement, alt, {
6184 return make_node(AST_EmptyStatement, self);
6191 return make_node(AST_EmptyStatement, self);
6200 self.body = make_node(AST_EmptyStatement, self);
6206 self.body = make_node(AST_BlockStatement, self, { body: body });
6236 return in_list ? List.skip : make_node(AST_EmptyStatement, node);
6837 if (!elements[i]) elements[i] = make_node(AST_Hole, orig);
6842 var cl = make_node(AST_ClassExpression, defcl);
6843 if (cl.name) cl.name = drop_name ? null : make_node(AST_SymbolClass, cl.name);
6863 var fn = make_node(ctor, defun);
6864 fn.name = drop_name ? null : make_node(AST_SymbolLambda, defun.name);
7145 node.elements[i] = make_node(AST_Hole, node.elements[i]);
7165 … value = make_node(AST_DestructuredArray, prop.value, { elements: [] });
7167 … value = make_node(AST_DestructuredObject, prop.value, { properties: [] });
7192 if (!value) value = make_node(AST_Number, node, { value: 0 });
7221 return make_node(AST_UnaryPrefix, node, {
7232 var value = make_node(AST_False, node).optimize(compressor);
7253 if (trimmed) return make_node(AST_SimpleStatement, node, { body: trimmed });
7254 return in_list ? List.skip : make_node(AST_EmptyStatement, node);
7270 return in_list ? List.skip : make_node(AST_EmptyStatement, node);
7293 var trimmed = trim_destructured(rest, make_node(AST_Array, parent, {
7358 sym.value = make_node(AST_Number, sym, { value: 0 });
7364 node.rest = make_node(AST_DestructuredArray, node, { elements: [] });
7394 def = make_node(AST_VarDef, def, {
7413 def.value = value || make_node(AST_Number, def, { value: 0 });
7460 var defun = make_node(ctor, fn);
7461 defun.name = make_node(AST_SymbolDefun, def.name);
7557 body.push(make_node(AST_SimpleStatement, node, {
7564 def.value = make_node(AST_UnaryPrefix, def, {
7581 var ref = make_node(AST_SymbolRef, def.name);
7583 var assign = make_node(AST_Assign, def, {
7609 body.push(make_node(AST_SimpleStatement, node, {
7617 … body.push(make_node(AST_SimpleStatement, node, { body: make_sequence(node, side_effects) }));
7627 if (trimmed.name) return make_node(AST_Assign, node, {
7634 return make_node(AST_Number, node, { value: 0 });
7687 body.push(make_node(AST_SimpleStatement, node, { body: value }));
7735 return in_list ? List.skip : make_node(AST_EmptyStatement, orig);
7739 … return in_list ? List.splice(body) : make_node(AST_BlockStatement, orig, { body: body });
7991 value = values && make_node(AST_Array, save_value, {
8037 value = make_node(AST_Sub, node, {
8039 property: make_node(AST_Number, node, { value: 0 }),
8116 … prop_map.set(key, retain_key(mapped) && make_node(AST_ObjectKeyVal, mapped, {
8118 value: make_node(AST_Number, mapped, { value: 0 }),
8155 return retain_key(prop) ? make_node(AST_ObjectKeyVal, prop, {
8157 value: make_node(AST_Number, prop, { value: 0 }),
8176 value = make_node(AST_Sub, node, {
8224 value = make_node(AST_Number, node, { value: 0 });
8227 value = make_node(AST_Array, node, {
8234 return make_node(AST_DestructuredObject, node, { properties: [] });
8271 return in_list ? List.skip : make_node(AST_EmptyStatement, node);
8280 return in_list ? List.skip : make_node(AST_EmptyStatement, node);
8299 return make_node(AST_SymbolRef, sym);
8302 if (!seq) return in_list ? List.skip : make_node(AST_EmptyStatement, node);
8303 return make_node(AST_SimpleStatement, node, { body: seq });
8328 if (defns.length > 0) hoisted.push(make_node(AST_Var, self, { definitions: defns }));
8376 make_node(AST_Number, node.value, { value: 0 }),
8382 make_node(AST_Number, node.value, { value: 1 }),
8383 ]) : make_node(AST_Number, node.value, { value: 1 });
8487 var sym = make_node(type, orig, {
8516 decls.push(make_node(AST_VarDef, node, {
8520 var sym = make_node(AST_SymbolRef, node, {
8526 assignments.push(make_node(AST_Assign, node, {
8534 self.body.splice(self.body.indexOf(tt.stack[1]) + 1, 0, make_node(AST_Var, node, {
8551 …decl.value = node.name instanceof AST_SymbolConst ? make_node(AST_Number, node, { value: 0 }) : nu…
8554 var_defs.push(make_node(AST_VarDef, node, {
8578 var sym = make_node(AST_SymbolRef, node, {
8590 return make_node(AST_Object, node, { properties: [] });
8656 if (!value) return make_node(AST_EmptyStatement, node);
8657 return make_node(AST_SimpleStatement, node, { body: value });
8681 if (!body) return make_node(AST_EmptyStatement, node);
8696 return make_node(AST_EmptyStatement, node);
8733 return make_node(ctor, exp);
8771 … return node instanceof AST_Spread ? make_node(AST_Array, node, { elements: [ node ] }) : node;
8804 dropped = make_node(AST_Number, exp, { value: 0 });
8820 node.left = lhs || make_node(AST_Number, left, { value: 0 });
8872 call.expression = make_node(AST_Function, exp);
8896 self = make_node(AST_Call, self);
8942 if (exprs.length) values.unshift(make_node(AST_ClassField, self, {
8947 } else node.properties.push(make_node(AST_ClassField, self, {
8952 } else if (exprs.length) node.properties.push(make_node(AST_ClassMethod, self, {
8954 value: make_node(AST_Function, self, {
8961 if (values) exprs.push(make_node(AST_Call, self, {
8962 expression: make_node(AST_Arrow, self, {
8974 var fn = make_node(AST_Arrow, node.value);
8976 return make_node(AST_Call, node, {
9001 node = alternative ? make_node(AST_Binary, this, {
9007 node = make_node(AST_Binary, this, {
9050 … return node instanceof AST_Spread ? make_node(AST_Object, node, { properties: [ node ] }) : node;
9137 return make_node(AST_EmptyStatement, self);
9140 return make_node(AST_SimpleStatement, self, { body: node });
9147 return compressor.option("loops") ? make_node(AST_For, self).optimize(compressor) : self;
9169 …nd && !has_loop_control(self, compressor.parent(), AST_Continue)) return make_node(AST_For, self, {
9170 body: make_node(AST_BlockStatement, self.body, {
9173 make_node(AST_SimpleStatement, self.condition, { body: self.condition }),
9177 …if (!has_loop_control(self, compressor.parent())) return make_node(AST_BlockStatement, self.body, {
9180 make_node(AST_SimpleStatement, self.condition, { body: self.condition }),
9193 self.condition = make_node(AST_Binary, self, {
9212 … if (self.body instanceof AST_EmptyStatement) return make_node(AST_For, self).optimize(compressor);
9213 if (self.body instanceof AST_SimpleStatement) return make_node(AST_For, self, {
9218 body: make_node(AST_EmptyStatement, self),
9245 body.push(make_node(AST_SimpleStatement, self.init, { body: self.init }));
9249 body.push(make_node(AST_If, self, {
9255 body.push(make_node(AST_SimpleStatement, self.condition, { body: self.condition }));
9260 return make_node(AST_BlockStatement, self, { body: body });
9266 self.condition = make_node(AST_Binary, self.condition, {
9281 self.condition = make_node(AST_Binary, self.condition, {
9310 … self.body = make_node(AST_BlockStatement, self.body, { body: rest }).transform(compressor);
9330 body.push(make_node(AST_SimpleStatement, self.init, { body: self.init }));
9332 … body.push(make_node(AST_SimpleStatement, self.condition, { body: self.condition }));
9334 return make_node(AST_BlockStatement, self, { body: body }).optimize(compressor);
9337 self.body = make_node(AST_BlockStatement, self.body, {
9339 make_node(AST_SimpleStatement, self.condition, { body: self.condition }),
9583 … make_node(AST_SimpleStatement, self.condition, { body: self.condition }).transform(compressor),
9587 return make_node(AST_BlockStatement, self, { body: body }).optimize(compressor);
9591 … make_node(AST_SimpleStatement, self.condition, { body: self.condition }).transform(compressor),
9595 return make_node(AST_BlockStatement, self, { body: body }).optimize(compressor);
9627 self.body = make_node(AST_EmptyStatement, self.body);
9629 self.body = make_node(AST_SimpleStatement, self.body, {
9643 self.alternative = make_node(AST_SimpleStatement, self.alternative, {
9649 if (var_defs.length > 0) body.push(make_node(AST_Var, self, { definitions: var_defs }));
9652 return make_node(AST_BlockStatement, self, { body: body }).optimize(compressor);
9656 … if (body_var_defs.length > 0 || alt_var_defs.length > 0) body.push(make_node(AST_Var, self, {
9660 body.push(make_node(AST_SimpleStatement, self.condition, {
9661 body: alt_exprs.length > 0 ? make_node(AST_Binary, self, {
9675 body.push(make_node(AST_SimpleStatement, self, {
9676 body: make_node(AST_Binary, self, {
9683 body.push(make_node(AST_SimpleStatement, self, {
9684 body: make_node(AST_Conditional, self, {
9693 return make_node(AST_BlockStatement, self, { body: body }).optimize(compressor);
9695 if (is_empty(self.body)) self = make_node(AST_If, self, {
9703 if (!cons_value && !alt_value) return make_node(AST_BlockStatement, self, {
9705 make_node(AST_SimpleStatement, self, { body: self.condition }),
9710 var exit = make_node(self.body.CTOR, self, {
9711 value: make_node(AST_Conditional, self, {
9713 … consequent: cons_value || make_node(AST_Undefined, self.body).transform(compressor),
9714 … alternative: alt_value || make_node(AST_Undefined, self.alternative).transform(compressor),
9722 self = make_node(AST_If, self, {
9723 condition: make_node(AST_Binary, self.condition, {
9735 … return make_node(AST_BlockStatement, self, { body: [ self, alt ] }).optimize(compressor);
9742 … return make_node(AST_BlockStatement, self, { body: [ self, body ] }).optimize(compressor);
9764 … stats.unshift(make_node(AST_SimpleStatement, expr1, { body: merge_expression(expr1, expr2) }));
9768 self.body = body_stats.length > 0 ? make_node(AST_BlockStatement, self, {
9770 }) : make_node(AST_EmptyStatement, self);
9771 self.alternative = alt_stats.length > 0 ? make_node(AST_BlockStatement, self, {
9775 return make_node(AST_BlockStatement, self, { body: stats }).optimize(compressor);
9810 stats[index] = make_node(AST_SimpleStatement, body, {
9830 … exprs.push(line.value || make_node(AST_Undefined, line).transform(compressor));
9868 exprs.push(make_node(AST_Assign, var_def, {
9900 var equals = make_node(AST_Binary, self, {
9920 default_branch = branch = make_node(AST_Default, branch);
9934 var prev_block = make_node(AST_BlockStatement, prev);
9935 var next_block = make_node(AST_BlockStatement, branch, { body: statements });
9941 … body.push(make_node(AST_Case, self, { expression: make_sequence(self, side_effects), body: [] }));
9951 … body.push(make_node(AST_Case, self, { expression: make_sequence(self, side_effects), body: [] }));
9970 decl.push(make_node(AST_SimpleStatement, self.expression, { body: self.expression }));
9971 if (side_effects.length) decl.push(make_node(AST_SimpleStatement, self, {
9974 return make_node(AST_BlockStatement, self, { body: decl }).optimize(compressor);
9983 default_branch.body.unshift(make_node(AST_SimpleStatement, self, { body: exp }));
9995 … if (body[0] !== default_branch && body[0] !== exact_match) return make_node(AST_If, self, {
9996 condition: make_node(AST_Binary, self, {
10001 body: make_node(AST_BlockStatement, self, { body: statements }),
10004 if (exp) statements.unshift(make_node(AST_SimpleStatement, exp, { body: exp }));
10005 … statements.unshift(make_node(AST_SimpleStatement, self.expression, { body: self.expression }));
10006 return make_node(AST_BlockStatement, self, { body: statements }).optimize(compressor);
10013 var alternative = body[1].body.length && make_node(AST_BlockStatement, body[1]);
10014 var node = make_node(AST_If, self, {
10015 condition: make_node(AST_Binary, self, body[0] === default_branch ? {
10024 body: make_node(AST_BlockStatement, body[0], { body: statements }),
10027 …if (!exclusive && alternative) node = make_node(AST_BlockStatement, self, { body: [ node, alternat…
10078 body.unshift(make_node(AST_BlockStatement, self).optimize(compressor));
10080 body.push(make_node(AST_BlockStatement, self.bfinally).optimize(compressor));
10082 return make_node(AST_BlockStatement, self, { body: body }).optimize(compressor);
10085 var body = make_node(AST_BlockStatement, self.bfinally).optimize(compressor);
10087 … if (!self.bcatch) return make_node(AST_BlockStatement, self, { body: body }).optimize(compressor);
10101 … if (node instanceof AST_SymbolDeclaration) defns.push(make_node(AST_VarDef, node, {
10112 return make_node(AST_Undefined, node).optimize(compressor);
10123 var name = make_node(AST_SymbolRef, defn.name);
10124 var assign = make_node(AST_Assign, defn, {
10174 return make_node(AST_Var, stat, {
10176 return make_node(AST_VarDef, defn, {
10217 if (ev == null) return make_node(AST_UnaryPrefix, node, {
10254 … while (args.length < insert) args.push(make_node(AST_Undefined, call).optimize(compressor));
10255 args.push(make_node(AST_Array, call, { elements: call.args.slice(insert) }));
10297 args[pos++] = make_node(AST_Number, args[i], { value: 0 });
10323 args.push(args.length < argnames.length ? make_node(AST_UnaryPrefix, call, {
10392 for (var i = 0; i < length; i++) elements[i] = make_node(AST_Hole, self);
10393 return make_node(AST_Array, self, { elements: elements });
10404 return make_node(AST_Array, self, { elements: self.args });
10407 if (self.args.length == 0) return make_node(AST_Object, self, { properties: [] });
10411 if (self.args.length == 0) return make_node(AST_String, self, { value: "" });
10413 if (self.args.length == 1) return make_node(AST_Binary, self, {
10415 left: make_node(AST_String, self, { value: "" }),
10421 if (self.args.length == 0) return make_node(AST_Number, self, { value: 0 });
10423 if (self.args.length == 1) return make_node(AST_UnaryPrefix, self, {
10425 expression: make_node(AST_Binary, self, {
10427 left: make_node(AST_String, self, { value: "" }),
10434 if (self.args.length == 0) return make_node(AST_False, self).optimize(compressor);
10436 if (self.args.length == 1) return make_node(AST_UnaryPrefix, self, {
10438 expression: make_node(AST_UnaryPrefix, self, {
10452 return best_of(compressor, self, make_node(AST_RegExp, self, {
10464 return make_node(AST_Binary, self, {
10466 left: make_node(AST_String, self, { value: "" }),
10479 make_node(AST_String, self, { value: "" }),
10480 ]).optimize(compressor) : make_node(AST_String, self, { value: "" });
10497 … elements.push(make_node(AST_String, self, { value: consts.join(separator) }));
10503 if (consts.length > 0) elements.push(make_node(AST_String, self, {
10512 return make_node(AST_Binary, elements[0], {
10514 left: make_node(AST_String, self, { value: "" }),
10524 first = make_node(AST_String, self, { value: "" });
10527 return make_node(AST_Binary, el, {
10547 var node = make_node(AST_Binary, self, {
10549 left: make_node(AST_Sub, self, {
10551 property: self.args.length ? make_node(AST_Binary, self.args[0], {
10553 left: make_node(AST_Number, self, { value: 0 }),
10555 }) : make_node(AST_Number, self, { value: 0 }),
10557 right: make_node(AST_String, self, { value: "" }),
10567 return make_node(AST_Call, self, {
10568 expression: make_node(AST_Dot, exp, {
10584 make_node(AST_Call, self, {
10588 ]) : make_node(AST_Call, self, {
10608 if (self.args.length == 0) return make_node(AST_Function, self, {
10641 make_node(AST_String, self, {
10646 make_node(AST_String, self.args[self.args.length - 1], {
10721 if (!arg) return make_node(AST_Undefined, self);
10784 return make_node(AST_Undefined, self).optimize(compressor);
10794 return make_node(AST_Sub, orig, {
10795 expression: make_node(AST_Array, orig, { elements: [] }),
10796 property: make_node(AST_Number, orig, { value: 0 }),
10803 … if (destructured || has_spread) args = [ make_node(AST_Array, self, { elements: args }) ];
10806 if (node instanceof AST_DefaultValue) return make_node(AST_DefaultValue, node, {
10817 return make_node(AST_DestructuredArray, node, { elements: elements });
10831 properties.push(make_node(AST_DestructuredKeyVal, prop, {
10839 … if (side_effects.length) properties.push(make_node(AST_DestructuredKeyVal, node, {
10843 return make_node(AST_DestructuredObject, node, { properties: properties });
10855 args[0] = make_node(AST_Assign, self, {
10857 left: make_node(AST_DestructuredArray, fn, {
10866 args.push(value || make_node(AST_Undefined, self));
10871 …return self.call_only ? make_node(AST_Number, self, { value: 0 }) : make_node(AST_Undefined, self);
10878 return self.call_only ? stat.body : make_node(AST_UnaryPrefix, stat, {
11078 decls.push(make_node(AST_VarDef, name, {
11086 var sym = make_node(AST_SymbolRef, name);
11089 expressions.push(make_node(AST_Assign, self, {
11115 var symbol = make_node(AST_SymbolVar, name);
11125 value = make_node(AST_Undefined, self);
11138 var sym = make_node(AST_SymbolRef, node.name);
11140 expressions.push(make_node(AST_Assign, node, {
11150 expressions.push(make_node(AST_Assign, self, {
11152 left: make_node(AST_DestructuredArray, self, {
11154 if (argname.unused) return make_node(AST_Hole, argname);
11159 right: make_node(AST_Array, self, { elements: self.args.slice() }),
11167 var symbol = make_node(AST_SymbolVar, name);
11179 var name = make_node(AST_SymbolVar, flatten_var(stat.name));
11233 if (decls.length) args.push(make_node(AST_Var, fn, { definitions: decls }));
11253 return make_node(AST_Call, self).transform(compressor);
11277 return node.operator == "&&" ? make_node(AST_Conditional, node, {
11281 }) : make_node(AST_Conditional, node, {
11330 expressions[end] = make_node(AST_UnaryPrefix, self, {
11400 …if (exp.is_truthy()) return make_sequence(self, [ exp, make_node(AST_False, self) ]).optimize(comp…
11413 return make_sequence(self, [ exp, make_node(AST_True, self) ]).optimize(compressor);
11419 var exprs = [ make_node(AST_True, self) ];
11425 if (!exp) return make_node(AST_Undefined, self).optimize(compressor);
11434 return make_node(AST_Binary, self, {
11436 left: make_node(AST_UnaryPrefix, exp.left, {
11628 self.left = make_node(AST_Binary, self, {
11668 var assign = make_node(AST_Assign, self, {
11671 right: make_node(AST_Binary, self, {
11696 make_node(self.operator == "===" ? AST_False : AST_True, self),
11711 self.left = make_node(AST_Null, self.left);
11723 self.left = make_node(AST_Undefined, self.left).optimize(compressor);
11732 … return make_node(self.operator[0] == "=" ? AST_True : AST_False, self).optimize(compressor);
11751 left.left = make_node(AST_Null, self);
11779 exprs.push(make_node(AST_True, self));
11787 return make_node(AST_UnaryPrefix, self, {
11801 var negated = make_node(AST_UnaryPrefix, self, {
11814 var before = make_node(AST_Binary, self, {
11879 … return make_sequence(self, [ self.left, make_node(AST_False, self) ]).optimize(compressor);
11889 if (!lr) return make_node(AST_Conditional, self, {
11919 … return make_sequence(self, [ self.left, make_node(AST_True, self) ]).optimize(compressor);
11929 if (lr && !(lr instanceof AST_Node)) return make_node(AST_Conditional, self, {
11943 self = make_node(AST_Binary, self, {
11945 left: make_node(AST_String, self.left, {
11959 self = make_node(AST_Binary, self, {
11962 right: make_node(AST_String, self.right, {
11973 self = make_node(AST_Binary, self, {
11985 self = make_node(AST_Binary, self, {
12001 self = make_node(AST_Binary, self, {
12003 left: make_node(AST_Binary, self, {
12018 self = make_node(AST_Binary, self, {
12051 self = best_of(compressor, self, make_node(AST_Binary, self, {
12070 self = make_node(AST_Binary, self, {
12072 left: make_node(AST_Binary, self.left, {
12084 self.right = make_node(AST_UnaryPrefix, self.right, {
12119 make_node(AST_False, self),
12128 … if (self.right.is_boolean(compressor)) return make_node(AST_UnaryPrefix, self, {
12137 if (self.left.value == 1) return make_node(AST_UnaryPrefix, self, {
12147 … if (self.left.is_boolean(compressor)) return make_node(AST_UnaryPrefix, self, {
12156 if (self.right.value == 0) return make_node(AST_UnaryPrefix, self, {
12163 if (self.right.value == 1) return make_node(AST_UnaryPrefix, self, {
12186 return (self.operator == "==" ? make_node(AST_UnaryPrefix, self, {
12193 var node = make_node(AST_UnaryPrefix, self, {
12195 expression: make_node(AST_UnaryPrefix, self, {
12205 node = make_node(AST_UnaryPrefix, self, {
12245 left = make_node(AST_UnaryPrefix, left, {
12251 right = make_node(AST_UnaryPrefix, right, {
12257 return make_node(AST_Binary, orig, {
12333 return make_node(AST_Undefined, self).optimize(compressor);
12335 return make_node(AST_NaN, self).optimize(compressor);
12337 return make_node(AST_Infinity, self).optimize(compressor);
12420 name = make_node(symbol_type, value.name);
12583 if (strs[strs.length - 1] == "") return make_node(AST_Binary, self, {
12585 left: make_node(AST_Template, self, {
12592 var left = make_node(AST_Binary, self, {
12594 left: make_node(AST_String, self, { value: "" }),
12598 left = make_node(AST_Binary, self, {
12604 return best_of(compressor, self, make_node(AST_Binary, self, {
12607 right: make_node(AST_Template, self, {