Lines Matching +defs:node +defs:body
139 this.pure_funcs = function(node) { argument
149 this.pure_funcs = function(node) { argument
188 Compressor.prototype = new TreeTransformer(function(node, descend, in_list) { argument
233 Compressor.prototype.compress = function(node) { argument
308 var tt = new TreeTransformer(function(node) { argument
311 body: make_node(AST_String, node), property
321 body: value || make_node(AST_UnaryPrefix, node, { property
374 if (!is_statement(self)) self = make_node(AST_SimpleStatement, self, { body: self }); property
375 … if (!(self instanceof AST_Toplevel)) self = make_node(AST_Toplevel, self, { body: [ self ] }); property
379 function read_property(obj, node) { argument
415 function is_modified(compressor, tw, node, value, level, immutable, recursive) { argument
465 function is_lambda(node) { argument
469 function safe_for_extends(node) { argument
496 function has_escaped(d, scope, node, parent) { argument
511 return function(node) { argument
569 if (scope.uses_arguments) scope.each_argname(function(node) { argument
743 function value_in_use(node, parent) { argument
751 function mark_escaped(tw, d, scope, node, value, level, depth) { argument
780 function mark_assignment_to_arguments(node) { argument
807 function make_fixed_default(compressor, node, save) { argument
824 var scanner = new TreeWalker(function(node) { argument
839 node.elements.forEach(function(node, index) { argument
868 node.properties.forEach(function(node) { argument
919 fn.walk(new TreeWalker(function(node) { argument
952 function visit(node, fixed) { argument
1025 left.fixed.to_binary = replace_ref(function(node) { argument
1145 function mark_refs(node, drop) { argument
1274 init.definitions[0].name.mark_symbol(function(node) { argument
1282 init.mark_symbol(function(node) { argument
1535 exp.fixed.to_prefix = replace_ref(function(node) { argument
1591 })(function(node, func) { argument
1595 function reset_flags(node) { argument
1603 var tw = new TreeWalker(compressor.option("reduce_vars") ? function(node, descend) { argument
1646 return this.transform(new TreeTransformer(function(node, descend) { argument
1681 var marker = new TreeWalker(function(node) { argument
1709 var tw = new TreeWalker(function(node) { argument
1740 function find_try(compressor, level, node, scope, may_throw, sync) { argument
1845 base.walk(new TreeWalker(function(node) { argument
1855 if (fixed_by_id.size() > 0) target.walk(new TreeWalker(function(node) { argument
1865 function merge_sequence(array, node) { argument
1922 function is_iife_call(node) { argument
1935 exp.walk(new TreeWalker(function(node) { argument
1943 function is_undeclared_ref(node) { argument
1958 function declarations_only(node) { argument
1975 function is_last_statement(body, stat) { argument
1989 function patch_for_init(node, in_list) { argument
1997 if (!block) block = make_node(AST_BlockStatement, node, { body: [ node ] }); property
2010 var in_lambda = last_of(compressor, function(node) { argument
2130 var scanner = new TreeTransformer(function(node, descend) { argument
2302 var multi_replacer = new TreeTransformer(function(node) { argument
2354 }, function(node) { argument
2449 function signal_abort(node) { argument
2456 function handle_custom_scan_order(node, tt) { argument
2510 function is_direct_assignment(node, parent) { argument
2517 function should_stop(node, parent) { argument
2541 function should_stop_ref(node, parent) { argument
2557 function in_conditional(node, parent) { argument
2567 function is_last_node(node, parent) { argument
2653 … return (node.value || parent instanceof AST_Let) && node.name.match_symbol(function(node) { argument
2663 return sym.match_symbol(function(node) { argument
2668 function reject(node) { argument
2674 function arg_may_throw(reject, node, value) { argument
2725 has_await = function(node) { argument
2736 var tw = new TreeWalker(function(node, descend) { argument
2775 if (iife_in_try && arg_may_throw(function(node) { argument
2809 expr.elements.forEach(function(node) { argument
2883 expr.expressions.forEach(function(node, index) { argument
2920 function find_stop(node, level) { argument
2957 function find_stop_expr(expr, cont, node, parent, level) { argument
2976 function find_stop_value(node, level) { argument
3056 function find_stop_unused(node, level) { argument
3205 var marker = new TreeWalker(function(node) { argument
3226 expr.walk(new TreeWalker(function(node) { argument
3232 function rhs_exact_match(node) { argument
3238 return function(node, tw) { argument
3260 function update_symbols(value, node) { argument
3262 value.walk(new TreeWalker(function(node) { argument
3268 function may_be_global(node) { argument
3285 var tw = new TreeWalker(function(node) { argument
3376 var tt = new TreeTransformer(function(node, descend, in_list) { argument
3393 var body = [ make_node(AST_SimpleStatement, value, { body: value }) ]; property
3403 … return in_list ? List.splice(body) : make_node(AST_BlockStatement, node, { body: body }); property
3406 … return is_statement(node) ? make_node(AST_SimpleStatement, value, { body: value }) : value; property
3407 }, function(node, in_list) { argument
3417 function patch_sequence(node, tt) { argument
3493 function side_effects_external(node, lhs) { argument
3568 statements[i] = make_node(AST_SimpleStatement, stat, { body: body }); property
3581 body: as_statement_array_with_return(stat.body, ab), property
3584 … body: as_statement_array(stat.alternative).concat(extract_functions(merge_jump, jump)), property
3602 body: extract_functions(true, null, j + 1), property
3621 … body: as_statement_array(stat.body).concat(extract_functions(merge_jump, jump)), property
3624 body: as_statement_array_with_return(stat.alternative, alt), property
3633 … var stats = make_node(AST_BlockStatement, self, { body: statements.slice(i + 1) }); property
3637 … var stats = make_node(AST_BlockStatement, self, { body: statements.slice(i + 1) }); property
3652 body: extract_functions(true, null, j + 1), property
3689 … body: extract_functions().concat(make_node(AST_Return, self, { value: null })), property
3718 return last_of(compressor, function(node) { argument
3780 return !defn.name.match_symbol(function(node) { argument
3812 body: make_sequence(stop.value, stop.value.expressions.slice(0, -1)), property
3831 function as_statement_array_with_return(node, ab) { argument
3840 if (value) block.push(make_node(AST_SimpleStatement, value, { body: value })); property
3887 if (value) return make_node(AST_SimpleStatement, value, { body: value }); property
3990 statements[n++] = make_node(AST_SimpleStatement, body, { body: body }); property
4038 prev.body.walk(new TreeWalker(function(node) { argument
4066 var body = to_simple_statement(stat.body, decls); variable
4072 body: body || make_node(AST_EmptyStatement, stat.body), property
4098 function extract_exprs(body) { argument
4103 function join_assigns(defn, body, keep) { argument
4141 function can_trim(node) { argument
4215 function try_join(node) { argument
4359 return stat.transform(new TreeTransformer(function(node, descend, in_list) { argument
4382 stat.walk(new TreeWalker(function(node, descend) { argument
4410 target.push(make_node(AST_BlockStatement, stat, { body: block })); property
4421 function push(node) { argument
4431 function is_undefined(node, compressor) { argument
4455 })(function(node, func) { argument
4481 })(function(node, func) { argument
4536 })(function(node, func) { argument
4623 })(function(node, func) { argument
4630 function is_binary_defined(compressor, op, node) { argument
4676 })(function(node, func) { argument
4721 })(function(node, func) { argument
4814 })(function(node, func) { argument
4871 })(function(node, func) { argument
4898 function warn(node) { argument
4905 return this.transform(new TreeTransformer(function(node) { argument
4935 })(function(node, func) { argument
4946 body: ast1, property
4948 body: ast2, property
4964 function skip_directives(body) { argument
4989 function try_evaluate(compressor, node) { argument
5082 function is_static_fn(node) { argument
5100 })(function(node, func) { argument
5120 cached.forEach(function(node) { argument
5128 var scan_modified = new TreeWalker(function(node) { argument
5133 function modified(node) { argument
5392 escaped[0].walk(new TreeWalker(function(node) { argument
5518 walk_body(fn, new TreeWalker(function(node) { argument
5546 cached_args.forEach(function(node) { argument
5587 def.references.forEach(function(node) { argument
5622 })(function(node, func) { argument
5637 body: alt, property
5697 })(function(node, func) { argument
5790 })(function(node, func) { argument
5797 return !all(list, spread ? function(node) { argument
5799 } : function(node) { argument
5803 function array_spread(node, compressor) { argument
5885 return any(this.properties, compressor, function(node, compressor) { argument
5929 })(function(node, func) { argument
6075 })(function(node, func) { argument
6109 self.walk(new TreeWalker(function(node, descend) { argument
6154 })(function(node, func) { argument
6174 })(function(node, func) { argument
6206 self.body = make_node(AST_BlockStatement, self, { body: body }); property
6233 function trim_block(node, parent, in_list) { argument
6362 var tw = new TreeWalker(function(node, descend) { argument
6549 if (node.bcatch.argname) node.bcatch.argname.mark_symbol(function(node) { argument
6582 walk_destructured(AST_SymbolDeclaration, assigned ? function(node) { argument
6588 } : function(node) { argument
6714 var marker = new TreeWalker(function(node) { argument
6887 function extract_reference(node, props) { argument
6949 var tw = new TreeWalker(function(node, descend) { argument
7083 init.walk(new TreeWalker(function(node) { argument
7114 var in_use = (assignments.get(id) || []).filter(function(node) { argument
7132 var trimmer = new TreeTransformer(function(node) { argument
7181 var tt = new TreeTransformer(function(node, descend, in_list) { argument
7253 if (trimmed) return make_node(AST_SimpleStatement, node, { body: trimmed }); property
7386 var trimmed = trim_destructured(def.name, value, function(node) { argument
7463 if (old_def) old_def.forEach(function(node) { argument
7549 function is_catch(node) { argument
7558 body: make_sequence(node, side_effects), property
7610 body: make_sequence(seq, seq.expressions.slice(0, -1)), property
7617 … body.push(make_node(AST_SimpleStatement, node, { body: make_sequence(node, side_effects) })); property
7624 var trimmed = trim_destructured(node.left, node.right, function(node) { argument
7664 }, function(node, in_list) { argument
7687 body.push(make_node(AST_SimpleStatement, node, { body: value })); property
7720 function log_default(node, text) { argument
7732 function insert_statements(body, orig, in_list) { argument
7739 … return in_list ? List.splice(body) : make_node(AST_BlockStatement, orig, { body: body }); property
7743 function track_assigns(def, node) { argument
7749 function add_assigns(def, node) { argument
7754 function indexOf_assign(def, node) { argument
7778 function can_drop_lhs(sym, node) { argument
7809 function scan_ref_scoped(node, descend, init) { argument
7824 return !argname.match_symbol(function(node) { argument
7916 function is_decl(node) { argument
7920 function trim_decl(node) { argument
7926 function trim_default(trimmer, node) { argument
7941 function trim_destructured(node, value, process, drop, root) { argument
7942 var trimmer = new TreeTransformer(function(node) { argument
8034 if (value.has_side_effects(compressor) && sym.match_symbol(function(node) { argument
8173 … if (value.has_side_effects(compressor) && prop.value.match_symbol(function(node) { argument
8202 function clear_write_only(node) { argument
8220 function retain_lhs(node) { argument
8251 self.walk(new TreeWalker(function(node) { argument
8267 var tt = new TreeTransformer(function(node, descend, in_list) { argument
8303 return make_node(AST_SimpleStatement, node, { body: seq }); property
8334 fn.walk(new TreeWalker(function(node) { argument
8345 scan_local_returns(fn, function(node) { argument
8367 scan_local_returns(fn, function(node) { argument
8505 var tt = new TreeTransformer(function(node, descend) { argument
8571 self.transform(new TreeTransformer(function(node, descend) { argument
8649 exp.process_expression(false, function(node) { argument
8657 return make_node(AST_SimpleStatement, node, { body: value }); property
8659 scan_local_returns(exp, function(node) { argument
8675 if (drop_body) exp.process_expression("awaits", function(node) { argument
8708 var tw = new TreeWalker(function(node) { argument
8765 function array_spread(node, compressor, first_in_statement) { argument
8770 function convert_spread(node) { argument
8778 if (values === this.elements && all(values, function(node) { argument
8972 return make_sequence(self, values.map(function(node) { argument
9041 …var values = trim(exprs, compressor, first_in_statement, function(node, compressor, first_in_state… argument
9046 if (values === exprs && !all(values, function(node) { argument
9049 return make_sequence(this, values.map(function(node) { argument
9127 })(function(node, func) { argument
9140 return make_node(AST_SimpleStatement, self, { body: node }); property
9153 var tw = new TreeWalker(function(node) { argument
9170 body: make_node(AST_BlockStatement, self.body, { property
9178 body: [ property
9180 make_node(AST_SimpleStatement, self.condition, { body: self.condition }), property
9218 body: make_node(AST_EmptyStatement, self), property
9222 function has_block_scope_refs(node) { argument
9224 node.walk(new TreeWalker(function(node) { argument
9245 body.push(make_node(AST_SimpleStatement, self.init, { body: self.init })); property
9251 body: first, property
9255 body.push(make_node(AST_SimpleStatement, self.condition, { body: self.condition })); property
9260 return make_node(AST_BlockStatement, self, { body: body }); property
9296 function first_statement(body) { argument
9300 function external_target(node) { argument
9310 … self.body = make_node(AST_BlockStatement, self.body, { body: rest }).transform(compressor); property
9330 body.push(make_node(AST_SimpleStatement, self.init, { body: self.init })); property
9332 … body.push(make_node(AST_SimpleStatement, self.condition, { body: self.condition })); property
9334 return make_node(AST_BlockStatement, self, { body: body }).optimize(compressor); property
9338 body: [ property
9339 make_node(AST_SimpleStatement, self.condition, { body: self.condition }), property
9353 && !name.match_symbol(function(node) { argument
9403 var tw = new TreeWalker(function(node, descend) { argument
9469 function negate(node) { argument
9484 function fuzzy_eval(compressor, node, nullish) { argument
9492 function mark_duplicate_condition(compressor, node) { argument
9583 … make_node(AST_SimpleStatement, self.condition, { body: self.condition }).transform(compressor), property
9587 return make_node(AST_BlockStatement, self, { body: body }).optimize(compressor); property
9591 … make_node(AST_SimpleStatement, self.condition, { body: self.condition }).transform(compressor), property
9595 return make_node(AST_BlockStatement, self, { body: body }).optimize(compressor); property
9630 body: make_sequence(self.body, body_exprs), property
9644 body: make_sequence(self.alternative, alt_exprs), property
9652 return make_node(AST_BlockStatement, self, { body: body }).optimize(compressor); property
9661 body: alt_exprs.length > 0 ? make_node(AST_Binary, self, { property
9676 body: make_node(AST_Binary, self, { property
9684 body: make_node(AST_Conditional, self, { property
9693 return make_node(AST_BlockStatement, self, { body: body }).optimize(compressor); property
9697 body: self.alternative, property
9704 body: [ property
9705 make_node(AST_SimpleStatement, self, { body: self.condition }), property
9728 body: self.body.body, property
9735 … return make_node(AST_BlockStatement, self, { body: [ self, alt ] }).optimize(compressor); property
9742 … return make_node(AST_BlockStatement, self, { body: [ self, body ] }).optimize(compressor); property
9764 … stats.unshift(make_node(AST_SimpleStatement, expr1, { body: merge_expression(expr1, expr2) })); property
9769 body: body_stats, property
9772 body: alt_stats, property
9775 return make_node(AST_BlockStatement, self, { body: stats }).optimize(compressor); property
9781 function as_array(node) { argument
9808 function pop_expr(stats, body, index) { argument
9811 body: make_sequence(body, body.expressions.slice(0, -1)), property
9935 var next_block = make_node(AST_BlockStatement, branch, { body: statements }); property
9941 … body.push(make_node(AST_Case, self, { expression: make_sequence(self, side_effects), body: [] })); property
9951 … body.push(make_node(AST_Case, self, { expression: make_sequence(self, side_effects), body: [] })); property
9970 decl.push(make_node(AST_SimpleStatement, self.expression, { body: self.expression })); property
9972 body: make_sequence(self, side_effects), property
9974 return make_node(AST_BlockStatement, self, { body: decl }).optimize(compressor); property
9983 default_branch.body.unshift(make_node(AST_SimpleStatement, self, { body: exp })); property
10001 body: make_node(AST_BlockStatement, self, { body: statements }), property
10004 if (exp) statements.unshift(make_node(AST_SimpleStatement, exp, { body: exp })); property
10005 … statements.unshift(make_node(AST_SimpleStatement, self.expression, { body: self.expression })); property
10006 return make_node(AST_BlockStatement, self, { body: statements }).optimize(compressor); property
10024 body: make_node(AST_BlockStatement, body[0], { body: statements }), property
10027 …if (!exclusive && alternative) node = make_node(AST_BlockStatement, self, { body: [ node, alternat… property
10032 function is_break(node, tw) { argument
10036 function no_break(node) { argument
10038 var tw = new TreeWalker(function(node) { argument
10062 … && !(self.bcatch && self.bcatch.argname && self.bcatch.argname.match_symbol(function(node) { argument
10082 return make_node(AST_BlockStatement, self, { body: body }).optimize(compressor); property
10087 … if (!self.bcatch) return make_node(AST_BlockStatement, self, { body: body }).optimize(compressor); property
10100 defn.name.match_symbol(function(node) { argument
10111 AST_Const.DEFMETHOD("remove_initializers", remove_initializers(function(compressor, node) { argument
10202 return !defn.name.match_symbol(function(node) { argument
10211 function trim_optional_chain(node, compressor) { argument
10227 function lift_sequence_in_expression(node, compressor) { argument
10342 var tw = new TreeWalker(function(node) { argument
10610 body: [], property
10631 ast.walk(new TreeWalker(function(node) { argument
10712 var retValue = value.clone(true).transform(new TreeTransformer(function(node) { argument
10733 arg.walk(new TreeWalker(function(node) { argument
10805 var tt = new TreeTransformer(function(node, descend) { argument
10812 node.elements.forEach(function(node, index) { argument
10936 var tw = new TreeWalker(function(node, descend) { argument
11266 function to_conditional_assignment(compressor, def, value, node) { argument
11287 function safe_from_assignment(node) { argument
11290 node.walk(new TreeWalker(function(node) { argument
11338 function is_simple_assign(node) { argument
11445 function may_not_delete(node) { argument
11558 function is_object(node, plain) { argument
11581 function needs_enqueuing(compressor, node) { argument
11601 function extract_lhs(node, compressor) { argument
11610 function repeatable(compressor, node) { argument
12216 function is_modify_array(node) { argument
12218 node.walk(new TreeWalker(function(node) { argument
12264 function is_indexFn(node) { argument
12426 value.walk(new TreeWalker(function(node) { argument
12461 value = value.transform(new TreeTransformer(function(node, descend) { argument
12527 value.walk(new TreeWalker(function(node) { argument
12625 function should_join(node) { argument
12686 var find_ref = new TreeWalker(function(node) { argument
12690 var scan_scope = new TreeWalker(function(node) { argument
12751 if (parent.left.match_symbol(function(node) { argument
12816 function is_tail(node, parent) { argument
12855 function in_try(level, node, sync) { argument
12865 if (fixed) fixed.to_binary = replace_ref(function(node) { argument
13147 function booleanize(node) { argument
13157 function is_true(node) { argument
13168 function is_false(node) { argument
13199 function fuse(node, tail, prop) { argument
13242 function can_shift_lhs_of_tail(node) { argument
13248 function pop_lhs(node) { argument
13255 function pop_seq(node) { argument
13282 return List.splice(exp.elements.map(function(node) { argument
13378 if (argname && find_if(function(node) { argument
13466 self.walk(new TreeWalker(function(node) { argument
13484 self.walk(new TreeWalker(function(node) { argument
13491 })(function(node, func) { argument
13570 body: [], property
13722 function has_arg_refs(fn, node) { argument
13724 node.walk(new TreeWalker(function(node) { argument
13774 if (!no_return) scan_local_returns(inlined, function(node) { argument
13783 body: [ inlined, make_node(AST_SimpleStatement, self, { property
13784 … body: make_node(AST_Await, self, { expression: make_node(AST_Number, self, { value: 0 })}), property
13797 body: inlined, property
13878 var tw = new TreeWalker(function(node) { argument
13907 stat.walk(new TreeWalker(function(node) { argument
13920 var find_return = new TreeWalker(function(node) { argument
13925 stat.walk(new TreeWalker(function(node) { argument
13963 … body.push(make_node(AST_SimpleStatement, sym, { body: init_ref(compressor, flatten_var(sym)) })); property
13973 if (value) body.push(make_node(AST_SimpleStatement, call, { body: value })); property
13984 body: make_sequence(call, values), property
14020 var inlined = make_node(AST_BlockStatement, call, { body: body }); property
14022 if (async) scan_local_returns(inlined, function(node) { argument
14046 body: body || make_body(self.consequent), property
14051 if (no_return) return make_node(AST_SimpleStatement, value, { body: value }); property
14067 return make_node(AST_BlockStatement, inlined, { body: [ inlined, this ] }); property
14128 function inline_sequence(compressor, scope, no_return, in_loop, in_await, node, skip) { argument
14141 return make_node(AST_BlockStatement, node, { body: body.reverse() }); property
14145 body: make_sequence(node, exprs.slice(i + 1, j)), property
14174 if (!no_return) scan_local_returns(inlined, function(node) { argument
14219 })(function(node, func) { argument
14232 })(function(node, optimizer) { argument