Context Navigation

source: imaps-frontend/node_modules/terser/lib/compress/tighten-body.js@ 79a0317

main

Last change on this file since 79a0317 was 79a0317, checked in by stefan toskovski <stefantoska84@…>, 3 days ago
F4 Finalna Verzija
Property mode set to `100644`
File size: 58.7 KB

Line
1	/***********************************************************************
2
3	A JavaScript tokenizer / parser / beautifier / compressor.
4	https://github.com/mishoo/UglifyJS2
5
6	-------------------------------- (C) ---------------------------------
7
8	Author: Mihai Bazon
9	<mihai.bazon@gmail.com>
10	http://mihai.bazon.net/blog
11
12	Distributed under the BSD license:
13
14	Copyright 2012 (c) Mihai Bazon <mihai.bazon@gmail.com>
15
16	Redistribution and use in source and binary forms, with or without
17	modification, are permitted provided that the following conditions
18	are met:
19
20	* Redistributions of source code must retain the above
21	copyright notice, this list of conditions and the following
22	disclaimer.
23
24	* Redistributions in binary form must reproduce the above
25	copyright notice, this list of conditions and the following
26	disclaimer in the documentation and/or other materials
27	provided with the distribution.
28
29	THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER “AS IS” AND ANY
30	EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
31	IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
32	PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE
33	LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
34	OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
35	PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
36	PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
37	THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
38	TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
39	THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
40	SUCH DAMAGE.
41
42	***********************************************************************/
43
44	import {
45	AST_Array,
46	AST_Arrow,
47	AST_Assign,
48	AST_Await,
49	AST_Binary,
50	AST_Block,
51	AST_BlockStatement,
52	AST_Break,
53	AST_Call,
54	AST_Case,
55	AST_Chain,
56	AST_Class,
57	AST_Conditional,
58	AST_Const,
59	AST_Constant,
60	AST_Continue,
61	AST_Debugger,
62	AST_Default,
63	AST_Definitions,
64	AST_Defun,
65	AST_Destructuring,
66	AST_Directive,
67	AST_Dot,
68	AST_DWLoop,
69	AST_EmptyStatement,
70	AST_Exit,
71	AST_Expansion,
72	AST_Export,
73	AST_For,
74	AST_ForIn,
75	AST_If,
76	AST_Import,
77	AST_IterationStatement,
78	AST_Lambda,
79	AST_Let,
80	AST_LoopControl,
81	AST_Node,
82	AST_Number,
83	AST_Object,
84	AST_ObjectKeyVal,
85	AST_ObjectProperty,
86	AST_PropAccess,
87	AST_RegExp,
88	AST_Return,
89	AST_Scope,
90	AST_Sequence,
91	AST_SimpleStatement,
92	AST_Sub,
93	AST_Switch,
94	AST_Symbol,
95	AST_SymbolConst,
96	AST_SymbolDeclaration,
97	AST_SymbolDefun,
98	AST_SymbolFunarg,
99	AST_SymbolLambda,
100	AST_SymbolLet,
101	AST_SymbolRef,
102	AST_SymbolVar,
103	AST_This,
104	AST_Try,
105	AST_TryBlock,
106	AST_Unary,
107	AST_UnaryPostfix,
108	AST_UnaryPrefix,
109	AST_Undefined,
110	AST_Var,
111	AST_VarDef,
112	AST_With,
113	AST_Yield,
114
115	TreeTransformer,
116	TreeWalker,
117	walk,
118	walk_abort,
119
120	_NOINLINE,
121	} from "../ast.js";
122	import {
123	make_node,
124	MAP,
125	member,
126	remove,
127	has_annotation
128	} from "../utils/index.js";
129
130	import { pure_prop_access_globals } from "./native-objects.js";
131	import {
132	lazy_op,
133	unary_side_effects,
134	is_modified,
135	is_lhs,
136	aborts
137	} from "./inference.js";
138	import { WRITE_ONLY, clear_flag } from "./compressor-flags.js";
139	import {
140	make_sequence,
141	merge_sequence,
142	maintain_this_binding,
143	is_func_expr,
144	is_identifier_atom,
145	is_ref_of,
146	can_be_evicted_from_block,
147	as_statement_array,
148	} from "./common.js";
149
150	function loop_body(x) {
151	if (x instanceof AST_IterationStatement) {
152	return x.body instanceof AST_BlockStatement ? x.body : x;
153	}
154	return x;
155	}
156
157	function is_lhs_read_only(lhs) {
158	if (lhs instanceof AST_This) return true;
159	if (lhs instanceof AST_SymbolRef) return lhs.definition().orig[0] instanceof AST_SymbolLambda;
160	if (lhs instanceof AST_PropAccess) {
161	lhs = lhs.expression;
162	if (lhs instanceof AST_SymbolRef) {
163	if (lhs.is_immutable()) return false;
164	lhs = lhs.fixed_value();
165	}
166	if (!lhs) return true;
167	if (lhs instanceof AST_RegExp) return false;
168	if (lhs instanceof AST_Constant) return true;
169	return is_lhs_read_only(lhs);
170	}
171	return false;
172	}
173
174	/** var a = 1 --> var a*/
175	function remove_initializers(var_statement) {
176	var decls = [];
177	var_statement.definitions.forEach(function(def) {
178	if (def.name instanceof AST_SymbolDeclaration) {
179	def.value = null;
180	decls.push(def);
181	} else {
182	def.declarations_as_names().forEach(name => {
183	decls.push(make_node(AST_VarDef, def, {
184	name,
185	value: null
186	}));
187	});
188	}
189	});
190	return decls.length ? make_node(AST_Var, var_statement, { definitions: decls }) : null;
191	}
192
193	/** Called on code which we know is unreachable, to keep elements that affect outside of it. */
194	export function trim_unreachable_code(compressor, stat, target) {
195	walk(stat, node => {
196	if (node instanceof AST_Var) {
197	const no_initializers = remove_initializers(node);
198	if (no_initializers) target.push(no_initializers);
199	return true;
200	}
201	if (
202	node instanceof AST_Defun
203	&& (node === stat \|\| !compressor.has_directive("use strict"))
204	) {
205	target.push(node === stat ? node : make_node(AST_Var, node, {
206	definitions: [
207	make_node(AST_VarDef, node, {
208	name: make_node(AST_SymbolVar, node.name, node.name),
209	value: null
210	})
211	]
212	}));
213	return true;
214	}
215	if (node instanceof AST_Export \|\| node instanceof AST_Import) {
216	target.push(node);
217	return true;
218	}
219	if (node instanceof AST_Scope) {
220	return true;
221	}
222	});
223	}
224
225	/** Tighten a bunch of statements together, and perform statement-level optimization. */
226	export function tighten_body(statements, compressor) {
227	const nearest_scope = compressor.find_scope();
228	const defun_scope = nearest_scope.get_defun_scope();
229	const { in_loop, in_try } = find_loop_scope_try();
230
231	var CHANGED, max_iter = 10;
232	do {
233	CHANGED = false;
234	eliminate_spurious_blocks(statements);
235	if (compressor.option("dead_code")) {
236	eliminate_dead_code(statements, compressor);
237	}
238	if (compressor.option("if_return")) {
239	handle_if_return(statements, compressor);
240	}
241	if (compressor.sequences_limit > 0) {
242	sequencesize(statements, compressor);
243	sequencesize_2(statements, compressor);
244	}
245	if (compressor.option("join_vars")) {
246	join_consecutive_vars(statements);
247	}
248	if (compressor.option("collapse_vars")) {
249	collapse(statements, compressor);
250	}
251	} while (CHANGED && max_iter-- > 0);
252
253	function find_loop_scope_try() {
254	var node = compressor.self(), level = 0, in_loop = false, in_try = false;
255	do {
256	if (node instanceof AST_IterationStatement) {
257	in_loop = true;
258	} else if (node instanceof AST_Scope) {
259	break;
260	} else if (node instanceof AST_TryBlock) {
261	in_try = true;
262	}
263	} while (node = compressor.parent(level++));
264
265	return { in_loop, in_try };
266	}
267
268	// Search from right to left for assignment-like expressions:
269	// - `var a = x;`
270	// - `a = x;`
271	// - `++a`
272	// For each candidate, scan from left to right for first usage, then try
273	// to fold assignment into the site for compression.
274	// Will not attempt to collapse assignments into or past code blocks
275	// which are not sequentially executed, e.g. loops and conditionals.
276	function collapse(statements, compressor) {
277	if (nearest_scope.pinned() \|\| defun_scope.pinned())
278	return statements;
279	var args;
280	var candidates = [];
281	var stat_index = statements.length;
282	var scanner = new TreeTransformer(function (node) {
283	if (abort)
284	return node;
285	// Skip nodes before `candidate` as quickly as possible
286	if (!hit) {
287	if (node !== hit_stack[hit_index])
288	return node;
289	hit_index++;
290	if (hit_index < hit_stack.length)
291	return handle_custom_scan_order(node);
292	hit = true;
293	stop_after = find_stop(node, 0);
294	if (stop_after === node)
295	abort = true;
296	return node;
297	}
298	// Stop immediately if these node types are encountered
299	var parent = scanner.parent();
300	if (node instanceof AST_Assign
301	&& (node.logical \|\| node.operator != "=" && lhs.equivalent_to(node.left))
302	\|\| node instanceof AST_Await
303	\|\| node instanceof AST_Call && lhs instanceof AST_PropAccess && lhs.equivalent_to(node.expression)
304	\|\|
305	(node instanceof AST_Call \|\| node instanceof AST_PropAccess)
306	&& node.optional
307	\|\| node instanceof AST_Debugger
308	\|\| node instanceof AST_Destructuring
309	\|\| node instanceof AST_Expansion
310	&& node.expression instanceof AST_Symbol
311	&& (
312	node.expression instanceof AST_This
313	\|\| node.expression.definition().references.length > 1
314	)
315	\|\| node instanceof AST_IterationStatement && !(node instanceof AST_For)
316	\|\| node instanceof AST_LoopControl
317	\|\| node instanceof AST_Try
318	\|\| node instanceof AST_With
319	\|\| node instanceof AST_Yield
320	\|\| node instanceof AST_Export
321	\|\| node instanceof AST_Class
322	\|\| parent instanceof AST_For && node !== parent.init
323	\|\| !replace_all
324	&& (
325	node instanceof AST_SymbolRef
326	&& !node.is_declared(compressor)
327	&& !pure_prop_access_globals.has(node)
328	)
329	\|\| node instanceof AST_SymbolRef
330	&& parent instanceof AST_Call
331	&& has_annotation(parent, _NOINLINE)
332	\|\| node instanceof AST_ObjectProperty && node.key instanceof AST_Node
333	) {
334	abort = true;
335	return node;
336	}
337	// Stop only if candidate is found within conditional branches
338	if (!stop_if_hit && (!lhs_local \|\| !replace_all)
339	&& (parent instanceof AST_Binary && lazy_op.has(parent.operator) && parent.left !== node
340	\|\| parent instanceof AST_Conditional && parent.condition !== node
341	\|\| parent instanceof AST_If && parent.condition !== node)) {
342	stop_if_hit = parent;
343	}
344	// Replace variable with assignment when found
345	if (
346	can_replace
347	&& !(node instanceof AST_SymbolDeclaration)
348	&& lhs.equivalent_to(node)
349	&& !shadows(scanner.find_scope() \|\| nearest_scope, lvalues)
350	) {
351	if (stop_if_hit) {
352	abort = true;
353	return node;
354	}
355	if (is_lhs(node, parent)) {
356	if (value_def)
357	replaced++;
358	return node;
359	} else {
360	replaced++;
361	if (value_def && candidate instanceof AST_VarDef)
362	return node;
363	}
364	CHANGED = abort = true;
365	if (candidate instanceof AST_UnaryPostfix) {
366	return make_node(AST_UnaryPrefix, candidate, candidate);
367	}
368	if (candidate instanceof AST_VarDef) {
369	var def = candidate.name.definition();
370	var value = candidate.value;
371	if (def.references.length - def.replaced == 1 && !compressor.exposed(def)) {
372	def.replaced++;
373	if (funarg && is_identifier_atom(value)) {
374	return value.transform(compressor);
375	} else {
376	return maintain_this_binding(parent, node, value);
377	}
378	}
379	return make_node(AST_Assign, candidate, {
380	operator: "=",
381	logical: false,
382	left: make_node(AST_SymbolRef, candidate.name, candidate.name),
383	right: value
384	});
385	}
386	clear_flag(candidate, WRITE_ONLY);
387	return candidate;
388	}
389	// These node types have child nodes that execute sequentially,
390	// but are otherwise not safe to scan into or beyond them.
391	var sym;
392	if (node instanceof AST_Call
393	\|\| node instanceof AST_Exit
394	&& (side_effects \|\| lhs instanceof AST_PropAccess \|\| may_modify(lhs))
395	\|\| node instanceof AST_PropAccess
396	&& (side_effects \|\| node.expression.may_throw_on_access(compressor))
397	\|\| node instanceof AST_SymbolRef
398	&& ((lvalues.has(node.name) && lvalues.get(node.name).modified) \|\| side_effects && may_modify(node))
399	\|\| node instanceof AST_VarDef && node.value
400	&& (lvalues.has(node.name.name) \|\| side_effects && may_modify(node.name))
401	\|\| (sym = is_lhs(node.left, node))
402	&& (sym instanceof AST_PropAccess \|\| lvalues.has(sym.name))
403	\|\| may_throw
404	&& (in_try ? node.has_side_effects(compressor) : side_effects_external(node))) {
405	stop_after = node;
406	if (node instanceof AST_Scope)
407	abort = true;
408	}
409	return handle_custom_scan_order(node);
410	}, function (node) {
411	if (abort)
412	return;
413	if (stop_after === node)
414	abort = true;
415	if (stop_if_hit === node)
416	stop_if_hit = null;
417	});
418
419	var multi_replacer = new TreeTransformer(function (node) {
420	if (abort)
421	return node;
422	// Skip nodes before `candidate` as quickly as possible
423	if (!hit) {
424	if (node !== hit_stack[hit_index])
425	return node;
426	hit_index++;
427	if (hit_index < hit_stack.length)
428	return;
429	hit = true;
430	return node;
431	}
432	// Replace variable when found
433	if (node instanceof AST_SymbolRef
434	&& node.name == def.name) {
435	if (!--replaced)
436	abort = true;
437	if (is_lhs(node, multi_replacer.parent()))
438	return node;
439	def.replaced++;
440	value_def.replaced--;
441	return candidate.value;
442	}
443	// Skip (non-executed) functions and (leading) default case in switch statements
444	if (node instanceof AST_Default \|\| node instanceof AST_Scope)
445	return node;
446	});
447
448	while (--stat_index >= 0) {
449	// Treat parameters as collapsible in IIFE, i.e.
450	// function(a, b){ ... }(x());
451	// would be translated into equivalent assignments:
452	// var a = x(), b = undefined;
453	if (stat_index == 0 && compressor.option("unused"))
454	extract_args();
455	// Find collapsible assignments
456	var hit_stack = [];
457	extract_candidates(statements[stat_index]);
458	while (candidates.length > 0) {
459	hit_stack = candidates.pop();
460	var hit_index = 0;
461	var candidate = hit_stack[hit_stack.length - 1];
462	var value_def = null;
463	var stop_after = null;
464	var stop_if_hit = null;
465	var lhs = get_lhs(candidate);
466	if (!lhs \|\| is_lhs_read_only(lhs) \|\| lhs.has_side_effects(compressor))
467	continue;
468	// Locate symbols which may execute code outside of scanning range
469	var lvalues = get_lvalues(candidate);
470	var lhs_local = is_lhs_local(lhs);
471	if (lhs instanceof AST_SymbolRef) {
472	lvalues.set(lhs.name, { def: lhs.definition(), modified: false });
473	}
474	var side_effects = value_has_side_effects(candidate);
475	var replace_all = replace_all_symbols();
476	var may_throw = candidate.may_throw(compressor);
477	var funarg = candidate.name instanceof AST_SymbolFunarg;
478	var hit = funarg;
479	var abort = false, replaced = 0, can_replace = !args \|\| !hit;
480	if (!can_replace) {
481	for (
482	let j = compressor.self().argnames.lastIndexOf(candidate.name) + 1;
483	!abort && j < args.length;
484	j++
485	) {
486	args[j].transform(scanner);
487	}
488	can_replace = true;
489	}
490	for (var i = stat_index; !abort && i < statements.length; i++) {
491	statements[i].transform(scanner);
492	}
493	if (value_def) {
494	var def = candidate.name.definition();
495	if (abort && def.references.length - def.replaced > replaced)
496	replaced = false;
497	else {
498	abort = false;
499	hit_index = 0;
500	hit = funarg;
501	for (var i = stat_index; !abort && i < statements.length; i++) {
502	statements[i].transform(multi_replacer);
503	}
504	value_def.single_use = false;
505	}
506	}
507	if (replaced && !remove_candidate(candidate))
508	statements.splice(stat_index, 1);
509	}
510	}
511
512	function handle_custom_scan_order(node) {
513	// Skip (non-executed) functions
514	if (node instanceof AST_Scope)
515	return node;
516
517	// Scan case expressions first in a switch statement
518	if (node instanceof AST_Switch) {
519	node.expression = node.expression.transform(scanner);
520	for (var i = 0, len = node.body.length; !abort && i < len; i++) {
521	var branch = node.body[i];
522	if (branch instanceof AST_Case) {
523	if (!hit) {
524	if (branch !== hit_stack[hit_index])
525	continue;
526	hit_index++;
527	}
528	branch.expression = branch.expression.transform(scanner);
529	if (!replace_all)
530	break;
531	}
532	}
533	abort = true;
534	return node;
535	}
536	}
537
538	function redefined_within_scope(def, scope) {
539	if (def.global)
540	return false;
541	let cur_scope = def.scope;
542	while (cur_scope && cur_scope !== scope) {
543	if (cur_scope.variables.has(def.name)) {
544	return true;
545	}
546	cur_scope = cur_scope.parent_scope;
547	}
548	return false;
549	}
550
551	function has_overlapping_symbol(fn, arg, fn_strict) {
552	var found = false, scan_this = !(fn instanceof AST_Arrow);
553	arg.walk(new TreeWalker(function (node, descend) {
554	if (found)
555	return true;
556	if (node instanceof AST_SymbolRef && (fn.variables.has(node.name) \|\| redefined_within_scope(node.definition(), fn))) {
557	var s = node.definition().scope;
558	if (s !== defun_scope)
559	while (s = s.parent_scope) {
560	if (s === defun_scope)
561	return true;
562	}
563	return found = true;
564	}
565	if ((fn_strict \|\| scan_this) && node instanceof AST_This) {
566	return found = true;
567	}
568	if (node instanceof AST_Scope && !(node instanceof AST_Arrow)) {
569	var prev = scan_this;
570	scan_this = false;
571	descend();
572	scan_this = prev;
573	return true;
574	}
575	}));
576	return found;
577	}
578
579	function arg_is_injectable(arg) {
580	if (arg instanceof AST_Expansion) return false;
581	const contains_await = walk(arg, (node) => {
582	if (node instanceof AST_Await) return walk_abort;
583	});
584	if (contains_await) return false;
585	return true;
586	}
587	function extract_args() {
588	var iife, fn = compressor.self();
589	if (is_func_expr(fn)
590	&& !fn.name
591	&& !fn.uses_arguments
592	&& !fn.pinned()
593	&& (iife = compressor.parent()) instanceof AST_Call
594	&& iife.expression === fn
595	&& iife.args.every(arg_is_injectable)
596	) {
597	var fn_strict = compressor.has_directive("use strict");
598	if (fn_strict && !member(fn_strict, fn.body))
599	fn_strict = false;
600	var len = fn.argnames.length;
601	args = iife.args.slice(len);
602	var names = new Set();
603	for (var i = len; --i >= 0;) {
604	var sym = fn.argnames[i];
605	var arg = iife.args[i];
606	// The following two line fix is a duplicate of the fix at
607	// https://github.com/terser/terser/commit/011d3eb08cefe6922c7d1bdfa113fc4aeaca1b75
608	// This might mean that these two pieces of code (one here in collapse_vars and another in reduce_vars
609	// Might be doing the exact same thing.
610	const def = sym.definition && sym.definition();
611	const is_reassigned = def && def.orig.length > 1;
612	if (is_reassigned)
613	continue;
614	args.unshift(make_node(AST_VarDef, sym, {
615	name: sym,
616	value: arg
617	}));
618	if (names.has(sym.name))
619	continue;
620	names.add(sym.name);
621	if (sym instanceof AST_Expansion) {
622	var elements = iife.args.slice(i);
623	if (elements.every((arg) => !has_overlapping_symbol(fn, arg, fn_strict)
624	)) {
625	candidates.unshift([make_node(AST_VarDef, sym, {
626	name: sym.expression,
627	value: make_node(AST_Array, iife, {
628	elements: elements
629	})
630	})]);
631	}
632	} else {
633	if (!arg) {
634	arg = make_node(AST_Undefined, sym).transform(compressor);
635	} else if (arg instanceof AST_Lambda && arg.pinned()
636	\|\| has_overlapping_symbol(fn, arg, fn_strict)) {
637	arg = null;
638	}
639	if (arg)
640	candidates.unshift([make_node(AST_VarDef, sym, {
641	name: sym,
642	value: arg
643	})]);
644	}
645	}
646	}
647	}
648
649	function extract_candidates(expr) {
650	hit_stack.push(expr);
651	if (expr instanceof AST_Assign) {
652	if (!expr.left.has_side_effects(compressor)
653	&& !(expr.right instanceof AST_Chain)) {
654	candidates.push(hit_stack.slice());
655	}
656	extract_candidates(expr.right);
657	} else if (expr instanceof AST_Binary) {
658	extract_candidates(expr.left);
659	extract_candidates(expr.right);
660	} else if (expr instanceof AST_Call && !has_annotation(expr, _NOINLINE)) {
661	extract_candidates(expr.expression);
662	expr.args.forEach(extract_candidates);
663	} else if (expr instanceof AST_Case) {
664	extract_candidates(expr.expression);
665	} else if (expr instanceof AST_Conditional) {
666	extract_candidates(expr.condition);
667	extract_candidates(expr.consequent);
668	extract_candidates(expr.alternative);
669	} else if (expr instanceof AST_Definitions) {
670	var len = expr.definitions.length;
671	// limit number of trailing variable definitions for consideration
672	var i = len - 200;
673	if (i < 0)
674	i = 0;
675	for (; i < len; i++) {
676	extract_candidates(expr.definitions[i]);
677	}
678	} else if (expr instanceof AST_DWLoop) {
679	extract_candidates(expr.condition);
680	if (!(expr.body instanceof AST_Block)) {
681	extract_candidates(expr.body);
682	}
683	} else if (expr instanceof AST_Exit) {
684	if (expr.value)
685	extract_candidates(expr.value);
686	} else if (expr instanceof AST_For) {
687	if (expr.init)
688	extract_candidates(expr.init);
689	if (expr.condition)
690	extract_candidates(expr.condition);
691	if (expr.step)
692	extract_candidates(expr.step);
693	if (!(expr.body instanceof AST_Block)) {
694	extract_candidates(expr.body);
695	}
696	} else if (expr instanceof AST_ForIn) {
697	extract_candidates(expr.object);
698	if (!(expr.body instanceof AST_Block)) {
699	extract_candidates(expr.body);
700	}
701	} else if (expr instanceof AST_If) {
702	extract_candidates(expr.condition);
703	if (!(expr.body instanceof AST_Block)) {
704	extract_candidates(expr.body);
705	}
706	if (expr.alternative && !(expr.alternative instanceof AST_Block)) {
707	extract_candidates(expr.alternative);
708	}
709	} else if (expr instanceof AST_Sequence) {
710	expr.expressions.forEach(extract_candidates);
711	} else if (expr instanceof AST_SimpleStatement) {
712	extract_candidates(expr.body);
713	} else if (expr instanceof AST_Switch) {
714	extract_candidates(expr.expression);
715	expr.body.forEach(extract_candidates);
716	} else if (expr instanceof AST_Unary) {
717	if (expr.operator == "++" \|\| expr.operator == "--") {
718	candidates.push(hit_stack.slice());
719	}
720	} else if (expr instanceof AST_VarDef) {
721	if (expr.value && !(expr.value instanceof AST_Chain)) {
722	candidates.push(hit_stack.slice());
723	extract_candidates(expr.value);
724	}
725	}
726	hit_stack.pop();
727	}
728
729	function find_stop(node, level, write_only) {
730	var parent = scanner.parent(level);
731	if (parent instanceof AST_Assign) {
732	if (write_only
733	&& !parent.logical
734	&& !(parent.left instanceof AST_PropAccess
735	\|\| lvalues.has(parent.left.name))) {
736	return find_stop(parent, level + 1, write_only);
737	}
738	return node;
739	}
740	if (parent instanceof AST_Binary) {
741	if (write_only && (!lazy_op.has(parent.operator) \|\| parent.left === node)) {
742	return find_stop(parent, level + 1, write_only);
743	}
744	return node;
745	}
746	if (parent instanceof AST_Call)
747	return node;
748	if (parent instanceof AST_Case)
749	return node;
750	if (parent instanceof AST_Conditional) {
751	if (write_only && parent.condition === node) {
752	return find_stop(parent, level + 1, write_only);
753	}
754	return node;
755	}
756	if (parent instanceof AST_Definitions) {
757	return find_stop(parent, level + 1, true);
758	}
759	if (parent instanceof AST_Exit) {
760	return write_only ? find_stop(parent, level + 1, write_only) : node;
761	}
762	if (parent instanceof AST_If) {
763	if (write_only && parent.condition === node) {
764	return find_stop(parent, level + 1, write_only);
765	}
766	return node;
767	}
768	if (parent instanceof AST_IterationStatement)
769	return node;
770	if (parent instanceof AST_Sequence) {
771	return find_stop(parent, level + 1, parent.tail_node() !== node);
772	}
773	if (parent instanceof AST_SimpleStatement) {
774	return find_stop(parent, level + 1, true);
775	}
776	if (parent instanceof AST_Switch)
777	return node;
778	if (parent instanceof AST_VarDef)
779	return node;
780	return null;
781	}
782
783	function mangleable_var(var_def) {
784	var value = var_def.value;
785	if (!(value instanceof AST_SymbolRef))
786	return;
787	if (value.name == "arguments")
788	return;
789	var def = value.definition();
790	if (def.undeclared)
791	return;
792	return value_def = def;
793	}
794
795	function get_lhs(expr) {
796	if (expr instanceof AST_Assign && expr.logical) {
797	return false;
798	} else if (expr instanceof AST_VarDef && expr.name instanceof AST_SymbolDeclaration) {
799	var def = expr.name.definition();
800	if (!member(expr.name, def.orig))
801	return;
802	var referenced = def.references.length - def.replaced;
803	if (!referenced)
804	return;
805	var declared = def.orig.length - def.eliminated;
806	if (declared > 1 && !(expr.name instanceof AST_SymbolFunarg)
807	\|\| (referenced > 1 ? mangleable_var(expr) : !compressor.exposed(def))) {
808	return make_node(AST_SymbolRef, expr.name, expr.name);
809	}
810	} else {
811	const lhs = expr instanceof AST_Assign
812	? expr.left
813	: expr.expression;
814	return !is_ref_of(lhs, AST_SymbolConst)
815	&& !is_ref_of(lhs, AST_SymbolLet) && lhs;
816	}
817	}
818
819	function get_rvalue(expr) {
820	if (expr instanceof AST_Assign) {
821	return expr.right;
822	} else {
823	return expr.value;
824	}
825	}
826
827	function get_lvalues(expr) {
828	var lvalues = new Map();
829	if (expr instanceof AST_Unary)
830	return lvalues;
831	var tw = new TreeWalker(function (node) {
832	var sym = node;
833	while (sym instanceof AST_PropAccess)
834	sym = sym.expression;
835	if (sym instanceof AST_SymbolRef) {
836	const prev = lvalues.get(sym.name);
837	if (!prev \|\| !prev.modified) {
838	lvalues.set(sym.name, {
839	def: sym.definition(),
840	modified: is_modified(compressor, tw, node, node, 0)
841	});
842	}
843	}
844	});
845	get_rvalue(expr).walk(tw);
846	return lvalues;
847	}
848
849	function remove_candidate(expr) {
850	if (expr.name instanceof AST_SymbolFunarg) {
851	var iife = compressor.parent(), argnames = compressor.self().argnames;
852	var index = argnames.indexOf(expr.name);
853	if (index < 0) {
854	iife.args.length = Math.min(iife.args.length, argnames.length - 1);
855	} else {
856	var args = iife.args;
857	if (args[index])
858	args[index] = make_node(AST_Number, args[index], {
859	value: 0
860	});
861	}
862	return true;
863	}
864	var found = false;
865	return statements[stat_index].transform(new TreeTransformer(function (node, descend, in_list) {
866	if (found)
867	return node;
868	if (node === expr \|\| node.body === expr) {
869	found = true;
870	if (node instanceof AST_VarDef) {
871	node.value = node.name instanceof AST_SymbolConst
872	? make_node(AST_Undefined, node.value) // `const` always needs value.
873	: null;
874	return node;
875	}
876	return in_list ? MAP.skip : null;
877	}
878	}, function (node) {
879	if (node instanceof AST_Sequence)
880	switch (node.expressions.length) {
881	case 0: return null;
882	case 1: return node.expressions[0];
883	}
884	}));
885	}
886
887	function is_lhs_local(lhs) {
888	while (lhs instanceof AST_PropAccess)
889	lhs = lhs.expression;
890	return lhs instanceof AST_SymbolRef
891	&& lhs.definition().scope.get_defun_scope() === defun_scope
892	&& !(in_loop
893	&& (lvalues.has(lhs.name)
894	\|\| candidate instanceof AST_Unary
895	\|\| (candidate instanceof AST_Assign
896	&& !candidate.logical
897	&& candidate.operator != "=")));
898	}
899
900	function value_has_side_effects(expr) {
901	if (expr instanceof AST_Unary)
902	return unary_side_effects.has(expr.operator);
903	return get_rvalue(expr).has_side_effects(compressor);
904	}
905
906	function replace_all_symbols() {
907	if (side_effects)
908	return false;
909	if (value_def)
910	return true;
911	if (lhs instanceof AST_SymbolRef) {
912	var def = lhs.definition();
913	if (def.references.length - def.replaced == (candidate instanceof AST_VarDef ? 1 : 2)) {
914	return true;
915	}
916	}
917	return false;
918	}
919
920	function may_modify(sym) {
921	if (!sym.definition)
922	return true; // AST_Destructuring
923	var def = sym.definition();
924	if (def.orig.length == 1 && def.orig[0] instanceof AST_SymbolDefun)
925	return false;
926	if (def.scope.get_defun_scope() !== defun_scope)
927	return true;
928	return def.references.some((ref) =>
929	ref.scope.get_defun_scope() !== defun_scope
930	);
931	}
932
933	function side_effects_external(node, lhs) {
934	if (node instanceof AST_Assign)
935	return side_effects_external(node.left, true);
936	if (node instanceof AST_Unary)
937	return side_effects_external(node.expression, true);
938	if (node instanceof AST_VarDef)
939	return node.value && side_effects_external(node.value);
940	if (lhs) {
941	if (node instanceof AST_Dot)
942	return side_effects_external(node.expression, true);
943	if (node instanceof AST_Sub)
944	return side_effects_external(node.expression, true);
945	if (node instanceof AST_SymbolRef)
946	return node.definition().scope.get_defun_scope() !== defun_scope;
947	}
948	return false;
949	}
950
951	/**
952	* Will any of the pulled-in lvalues shadow a variable in newScope or parents?
953	* similar to scope_encloses_variables_in_this_scope */
954	function shadows(my_scope, lvalues) {
955	for (const { def } of lvalues.values()) {
956	const looked_up = my_scope.find_variable(def.name);
957	if (looked_up) {
958	if (looked_up === def) continue;
959	return true;
960	}
961	}
962	return false;
963	}
964	}
965
966	function eliminate_spurious_blocks(statements) {
967	var seen_dirs = [];
968	for (var i = 0; i < statements.length;) {
969	var stat = statements[i];
970	if (stat instanceof AST_BlockStatement && stat.body.every(can_be_evicted_from_block)) {
971	CHANGED = true;
972	eliminate_spurious_blocks(stat.body);
973	statements.splice(i, 1, ...stat.body);
974	i += stat.body.length;
975	} else if (stat instanceof AST_EmptyStatement) {
976	CHANGED = true;
977	statements.splice(i, 1);
978	} else if (stat instanceof AST_Directive) {
979	if (seen_dirs.indexOf(stat.value) < 0) {
980	i++;
981	seen_dirs.push(stat.value);
982	} else {
983	CHANGED = true;
984	statements.splice(i, 1);
985	}
986	} else
987	i++;
988	}
989	}
990
991	function handle_if_return(statements, compressor) {
992	var self = compressor.self();
993	var multiple_if_returns = has_multiple_if_returns(statements);
994	var in_lambda = self instanceof AST_Lambda;
995	// Prevent extremely deep nesting
996	// https://github.com/terser/terser/issues/1432
997	// https://github.com/webpack/webpack/issues/17548
998	const iteration_start = Math.min(statements.length, 500);
999	for (var i = iteration_start; --i >= 0;) {
1000	var stat = statements[i];
1001	var j = next_index(i);
1002	var next = statements[j];
1003
1004	if (in_lambda && !next && stat instanceof AST_Return) {
1005	if (!stat.value) {
1006	CHANGED = true;
1007	statements.splice(i, 1);
1008	continue;
1009	}
1010	if (stat.value instanceof AST_UnaryPrefix && stat.value.operator == "void") {
1011	CHANGED = true;
1012	statements[i] = make_node(AST_SimpleStatement, stat, {
1013	body: stat.value.expression
1014	});
1015	continue;
1016	}
1017	}
1018
1019	if (stat instanceof AST_If) {
1020	let ab, new_else;
1021
1022	ab = aborts(stat.body);
1023	if (
1024	can_merge_flow(ab)
1025	&& (new_else = as_statement_array_with_return(stat.body, ab))
1026	) {
1027	if (ab.label) {
1028	remove(ab.label.thedef.references, ab);
1029	}
1030	CHANGED = true;
1031	stat = stat.clone();
1032	stat.condition = stat.condition.negate(compressor);
1033	stat.body = make_node(AST_BlockStatement, stat, {
1034	body: as_statement_array(stat.alternative).concat(extract_functions())
1035	});
1036	stat.alternative = make_node(AST_BlockStatement, stat, {
1037	body: new_else
1038	});
1039	statements[i] = stat.transform(compressor);
1040	continue;
1041	}
1042
1043	ab = aborts(stat.alternative);
1044	if (
1045	can_merge_flow(ab)
1046	&& (new_else = as_statement_array_with_return(stat.alternative, ab))
1047	) {
1048	if (ab.label) {
1049	remove(ab.label.thedef.references, ab);
1050	}
1051	CHANGED = true;
1052	stat = stat.clone();
1053	stat.body = make_node(AST_BlockStatement, stat.body, {
1054	body: as_statement_array(stat.body).concat(extract_functions())
1055	});
1056	stat.alternative = make_node(AST_BlockStatement, stat.alternative, {
1057	body: new_else
1058	});
1059	statements[i] = stat.transform(compressor);
1060	continue;
1061	}
1062	}
1063
1064	if (stat instanceof AST_If && stat.body instanceof AST_Return) {
1065	var value = stat.body.value;
1066	//---
1067	// pretty silly case, but:
1068	// if (foo()) return; return; ==> foo(); return;
1069	if (!value && !stat.alternative
1070	&& (in_lambda && !next \|\| next instanceof AST_Return && !next.value)) {
1071	CHANGED = true;
1072	statements[i] = make_node(AST_SimpleStatement, stat.condition, {
1073	body: stat.condition
1074	});
1075	continue;
1076	}
1077	//---
1078	// if (foo()) return x; return y; ==> return foo() ? x : y;
1079	if (value && !stat.alternative && next instanceof AST_Return && next.value) {
1080	CHANGED = true;
1081	stat = stat.clone();
1082	stat.alternative = next;
1083	statements[i] = stat.transform(compressor);
1084	statements.splice(j, 1);
1085	continue;
1086	}
1087	//---
1088	// if (foo()) return x; [ return ; ] ==> return foo() ? x : undefined;
1089	if (value && !stat.alternative
1090	&& (!next && in_lambda && multiple_if_returns
1091	\|\| next instanceof AST_Return)) {
1092	CHANGED = true;
1093	stat = stat.clone();
1094	stat.alternative = next \|\| make_node(AST_Return, stat, {
1095	value: null
1096	});
1097	statements[i] = stat.transform(compressor);
1098	if (next)
1099	statements.splice(j, 1);
1100	continue;
1101	}
1102	//---
1103	// if (a) return b; if (c) return d; e; ==> return a ? b : c ? d : void e;
1104	//
1105	// if sequences is not enabled, this can lead to an endless loop (issue #866).
1106	// however, with sequences on this helps producing slightly better output for
1107	// the example code.
1108	var prev = statements[prev_index(i)];
1109	if (compressor.option("sequences") && in_lambda && !stat.alternative
1110	&& prev instanceof AST_If && prev.body instanceof AST_Return
1111	&& next_index(j) == statements.length && next instanceof AST_SimpleStatement) {
1112	CHANGED = true;
1113	stat = stat.clone();
1114	stat.alternative = make_node(AST_BlockStatement, next, {
1115	body: [
1116	next,
1117	make_node(AST_Return, next, {
1118	value: null
1119	})
1120	]
1121	});
1122	statements[i] = stat.transform(compressor);
1123	statements.splice(j, 1);
1124	continue;
1125	}
1126	}
1127	}
1128
1129	function has_multiple_if_returns(statements) {
1130	var n = 0;
1131	for (var i = statements.length; --i >= 0;) {
1132	var stat = statements[i];
1133	if (stat instanceof AST_If && stat.body instanceof AST_Return) {
1134	if (++n > 1)
1135	return true;
1136	}
1137	}
1138	return false;
1139	}
1140
1141	function is_return_void(value) {
1142	return !value \|\| value instanceof AST_UnaryPrefix && value.operator == "void";
1143	}
1144
1145	function can_merge_flow(ab) {
1146	if (!ab)
1147	return false;
1148	for (var j = i + 1, len = statements.length; j < len; j++) {
1149	var stat = statements[j];
1150	if (stat instanceof AST_Const \|\| stat instanceof AST_Let)
1151	return false;
1152	}
1153	var lct = ab instanceof AST_LoopControl ? compressor.loopcontrol_target(ab) : null;
1154	return ab instanceof AST_Return && in_lambda && is_return_void(ab.value)
1155	\|\| ab instanceof AST_Continue && self === loop_body(lct)
1156	\|\| ab instanceof AST_Break && lct instanceof AST_BlockStatement && self === lct;
1157	}
1158
1159	function extract_functions() {
1160	var tail = statements.slice(i + 1);
1161	statements.length = i + 1;
1162	return tail.filter(function (stat) {
1163	if (stat instanceof AST_Defun) {
1164	statements.push(stat);
1165	return false;
1166	}
1167	return true;
1168	});
1169	}
1170
1171	function as_statement_array_with_return(node, ab) {
1172	var body = as_statement_array(node);
1173	if (ab !== body[body.length - 1]) {
1174	return undefined;
1175	}
1176	body = body.slice(0, -1);
1177	if (ab.value) {
1178	body.push(make_node(AST_SimpleStatement, ab.value, {
1179	body: ab.value.expression
1180	}));
1181	}
1182	return body;
1183	}
1184
1185	function next_index(i) {
1186	for (var j = i + 1, len = statements.length; j < len; j++) {
1187	var stat = statements[j];
1188	if (!(stat instanceof AST_Var && declarations_only(stat))) {
1189	break;
1190	}
1191	}
1192	return j;
1193	}
1194
1195	function prev_index(i) {
1196	for (var j = i; --j >= 0;) {
1197	var stat = statements[j];
1198	if (!(stat instanceof AST_Var && declarations_only(stat))) {
1199	break;
1200	}
1201	}
1202	return j;
1203	}
1204	}
1205
1206	function eliminate_dead_code(statements, compressor) {
1207	var has_quit;
1208	var self = compressor.self();
1209	for (var i = 0, n = 0, len = statements.length; i < len; i++) {
1210	var stat = statements[i];
1211	if (stat instanceof AST_LoopControl) {
1212	var lct = compressor.loopcontrol_target(stat);
1213	if (stat instanceof AST_Break
1214	&& !(lct instanceof AST_IterationStatement)
1215	&& loop_body(lct) === self
1216	\|\| stat instanceof AST_Continue
1217	&& loop_body(lct) === self) {
1218	if (stat.label) {
1219	remove(stat.label.thedef.references, stat);
1220	}
1221	} else {
1222	statements[n++] = stat;
1223	}
1224	} else {
1225	statements[n++] = stat;
1226	}
1227	if (aborts(stat)) {
1228	has_quit = statements.slice(i + 1);
1229	break;
1230	}
1231	}
1232	statements.length = n;
1233	CHANGED = n != len;
1234	if (has_quit)
1235	has_quit.forEach(function (stat) {
1236	trim_unreachable_code(compressor, stat, statements);
1237	});
1238	}
1239
1240	function declarations_only(node) {
1241	return node.definitions.every((var_def) => !var_def.value);
1242	}
1243
1244	function sequencesize(statements, compressor) {
1245	if (statements.length < 2)
1246	return;
1247	var seq = [], n = 0;
1248	function push_seq() {
1249	if (!seq.length)
1250	return;
1251	var body = make_sequence(seq[0], seq);
1252	statements[n++] = make_node(AST_SimpleStatement, body, { body: body });
1253	seq = [];
1254	}
1255	for (var i = 0, len = statements.length; i < len; i++) {
1256	var stat = statements[i];
1257	if (stat instanceof AST_SimpleStatement) {
1258	if (seq.length >= compressor.sequences_limit)
1259	push_seq();
1260	var body = stat.body;
1261	if (seq.length > 0)
1262	body = body.drop_side_effect_free(compressor);
1263	if (body)
1264	merge_sequence(seq, body);
1265	} else if (stat instanceof AST_Definitions && declarations_only(stat)
1266	\|\| stat instanceof AST_Defun) {
1267	statements[n++] = stat;
1268	} else {
1269	push_seq();
1270	statements[n++] = stat;
1271	}
1272	}
1273	push_seq();
1274	statements.length = n;
1275	if (n != len)
1276	CHANGED = true;
1277	}
1278
1279	function to_simple_statement(block, decls) {
1280	if (!(block instanceof AST_BlockStatement))
1281	return block;
1282	var stat = null;
1283	for (var i = 0, len = block.body.length; i < len; i++) {
1284	var line = block.body[i];
1285	if (line instanceof AST_Var && declarations_only(line)) {
1286	decls.push(line);
1287	} else if (stat \|\| line instanceof AST_Const \|\| line instanceof AST_Let) {
1288	return false;
1289	} else {
1290	stat = line;
1291	}
1292	}
1293	return stat;
1294	}
1295
1296	function sequencesize_2(statements, compressor) {
1297	function cons_seq(right) {
1298	n--;
1299	CHANGED = true;
1300	var left = prev.body;
1301	return make_sequence(left, [left, right]).transform(compressor);
1302	}
1303	var n = 0, prev;
1304	for (var i = 0; i < statements.length; i++) {
1305	var stat = statements[i];
1306	if (prev) {
1307	if (stat instanceof AST_Exit) {
1308	stat.value = cons_seq(stat.value \|\| make_node(AST_Undefined, stat).transform(compressor));
1309	} else if (stat instanceof AST_For) {
1310	if (!(stat.init instanceof AST_Definitions)) {
1311	const abort = walk(prev.body, node => {
1312	if (node instanceof AST_Scope)
1313	return true;
1314	if (node instanceof AST_Binary
1315	&& node.operator === "in") {
1316	return walk_abort;
1317	}
1318	});
1319	if (!abort) {
1320	if (stat.init)
1321	stat.init = cons_seq(stat.init);
1322	else {
1323	stat.init = prev.body;
1324	n--;
1325	CHANGED = true;
1326	}
1327	}
1328	}
1329	} else if (stat instanceof AST_ForIn) {
1330	if (!(stat.init instanceof AST_Const) && !(stat.init instanceof AST_Let)) {
1331	stat.object = cons_seq(stat.object);
1332	}
1333	} else if (stat instanceof AST_If) {
1334	stat.condition = cons_seq(stat.condition);
1335	} else if (stat instanceof AST_Switch) {
1336	stat.expression = cons_seq(stat.expression);
1337	} else if (stat instanceof AST_With) {
1338	stat.expression = cons_seq(stat.expression);
1339	}
1340	}
1341	if (compressor.option("conditionals") && stat instanceof AST_If) {
1342	var decls = [];
1343	var body = to_simple_statement(stat.body, decls);
1344	var alt = to_simple_statement(stat.alternative, decls);
1345	if (body !== false && alt !== false && decls.length > 0) {
1346	var len = decls.length;
1347	decls.push(make_node(AST_If, stat, {
1348	condition: stat.condition,
1349	body: body \|\| make_node(AST_EmptyStatement, stat.body),
1350	alternative: alt
1351	}));
1352	decls.unshift(n, 1);
1353	[].splice.apply(statements, decls);
1354	i += len;
1355	n += len + 1;
1356	prev = null;
1357	CHANGED = true;
1358	continue;
1359	}
1360	}
1361	statements[n++] = stat;
1362	prev = stat instanceof AST_SimpleStatement ? stat : null;
1363	}
1364	statements.length = n;
1365	}
1366
1367	function join_object_assignments(defn, body) {
1368	if (!(defn instanceof AST_Definitions))
1369	return;
1370	var def = defn.definitions[defn.definitions.length - 1];
1371	if (!(def.value instanceof AST_Object))
1372	return;
1373	var exprs;
1374	if (body instanceof AST_Assign && !body.logical) {
1375	exprs = [body];
1376	} else if (body instanceof AST_Sequence) {
1377	exprs = body.expressions.slice();
1378	}
1379	if (!exprs)
1380	return;
1381	var trimmed = false;
1382	do {
1383	var node = exprs[0];
1384	if (!(node instanceof AST_Assign))
1385	break;
1386	if (node.operator != "=")
1387	break;
1388	if (!(node.left instanceof AST_PropAccess))
1389	break;
1390	var sym = node.left.expression;
1391	if (!(sym instanceof AST_SymbolRef))
1392	break;
1393	if (def.name.name != sym.name)
1394	break;
1395	if (!node.right.is_constant_expression(nearest_scope))
1396	break;
1397	var prop = node.left.property;
1398	if (prop instanceof AST_Node) {
1399	prop = prop.evaluate(compressor);
1400	}
1401	if (prop instanceof AST_Node)
1402	break;
1403	prop = "" + prop;
1404	var diff = compressor.option("ecma") < 2015
1405	&& compressor.has_directive("use strict") ? function (node) {
1406	return node.key != prop && (node.key && node.key.name != prop);
1407	} : function (node) {
1408	return node.key && node.key.name != prop;
1409	};
1410	if (!def.value.properties.every(diff))
1411	break;
1412	var p = def.value.properties.filter(function (p) { return p.key === prop; })[0];
1413	if (!p) {
1414	def.value.properties.push(make_node(AST_ObjectKeyVal, node, {
1415	key: prop,
1416	value: node.right
1417	}));
1418	} else {
1419	p.value = new AST_Sequence({
1420	start: p.start,
1421	expressions: [p.value.clone(), node.right.clone()],
1422	end: p.end
1423	});
1424	}
1425	exprs.shift();
1426	trimmed = true;
1427	} while (exprs.length);
1428	return trimmed && exprs;
1429	}
1430
1431	function join_consecutive_vars(statements) {
1432	var defs;
1433	for (var i = 0, j = -1, len = statements.length; i < len; i++) {
1434	var stat = statements[i];
1435	var prev = statements[j];
1436	if (stat instanceof AST_Definitions) {
1437	if (prev && prev.TYPE == stat.TYPE) {
1438	prev.definitions = prev.definitions.concat(stat.definitions);
1439	CHANGED = true;
1440	} else if (defs && defs.TYPE == stat.TYPE && declarations_only(stat)) {
1441	defs.definitions = defs.definitions.concat(stat.definitions);
1442	CHANGED = true;
1443	} else {
1444	statements[++j] = stat;
1445	defs = stat;
1446	}
1447	} else if (stat instanceof AST_Exit) {
1448	stat.value = extract_object_assignments(stat.value);
1449	} else if (stat instanceof AST_For) {
1450	var exprs = join_object_assignments(prev, stat.init);
1451	if (exprs) {
1452	CHANGED = true;
1453	stat.init = exprs.length ? make_sequence(stat.init, exprs) : null;
1454	statements[++j] = stat;
1455	} else if (
1456	prev instanceof AST_Var
1457	&& (!stat.init \|\| stat.init.TYPE == prev.TYPE)
1458	) {
1459	if (stat.init) {
1460	prev.definitions = prev.definitions.concat(stat.init.definitions);
1461	}
1462	stat.init = prev;
1463	statements[j] = stat;
1464	CHANGED = true;
1465	} else if (
1466	defs instanceof AST_Var
1467	&& stat.init instanceof AST_Var
1468	&& declarations_only(stat.init)
1469	) {
1470	defs.definitions = defs.definitions.concat(stat.init.definitions);
1471	stat.init = null;
1472	statements[++j] = stat;
1473	CHANGED = true;
1474	} else {
1475	statements[++j] = stat;
1476	}
1477	} else if (stat instanceof AST_ForIn) {
1478	stat.object = extract_object_assignments(stat.object);
1479	} else if (stat instanceof AST_If) {
1480	stat.condition = extract_object_assignments(stat.condition);
1481	} else if (stat instanceof AST_SimpleStatement) {
1482	var exprs = join_object_assignments(prev, stat.body);
1483	if (exprs) {
1484	CHANGED = true;
1485	if (!exprs.length)
1486	continue;
1487	stat.body = make_sequence(stat.body, exprs);
1488	}
1489	statements[++j] = stat;
1490	} else if (stat instanceof AST_Switch) {
1491	stat.expression = extract_object_assignments(stat.expression);
1492	} else if (stat instanceof AST_With) {
1493	stat.expression = extract_object_assignments(stat.expression);
1494	} else {
1495	statements[++j] = stat;
1496	}
1497	}
1498	statements.length = j + 1;
1499
1500	function extract_object_assignments(value) {
1501	statements[++j] = stat;
1502	var exprs = join_object_assignments(prev, value);
1503	if (exprs) {
1504	CHANGED = true;
1505	if (exprs.length) {
1506	return make_sequence(value, exprs);
1507	} else if (value instanceof AST_Sequence) {
1508	return value.tail_node().left;
1509	} else {
1510	return value.left;
1511	}
1512	}
1513	return value;
1514	}
1515	}
1516	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: