| /*********************************************************************** |
| |
| A JavaScript tokenizer / parser / beautifier / compressor. |
| https://github.com/mishoo/UglifyJS2 |
| |
| -------------------------------- (C) --------------------------------- |
| |
| Author: Mihai Bazon |
| <mihai.bazon@gmail.com> |
| http://mihai.bazon.net/blog |
| |
| Distributed under the BSD license: |
| |
| Copyright 2012 (c) Mihai Bazon <mihai.bazon@gmail.com> |
| |
| Redistribution and use in source and binary forms, with or without |
| modification, are permitted provided that the following conditions |
| are met: |
| |
| * Redistributions of source code must retain the above |
| copyright notice, this list of conditions and the following |
| disclaimer. |
| |
| * Redistributions in binary form must reproduce the above |
| copyright notice, this list of conditions and the following |
| disclaimer in the documentation and/or other materials |
| provided with the distribution. |
| |
| THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER “AS IS” AND ANY |
| EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
| PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE |
| LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, |
| OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, |
| PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR |
| PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR |
| TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF |
| THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
| SUCH DAMAGE. |
| |
| ***********************************************************************/ |
| |
| import { |
| AST_Array, |
| AST_Arrow, |
| AST_Assign, |
| AST_Binary, |
| AST_Block, |
| AST_BlockStatement, |
| AST_Call, |
| AST_Case, |
| AST_Chain, |
| AST_Class, |
| AST_ClassProperty, |
| AST_ConciseMethod, |
| AST_Conditional, |
| AST_Constant, |
| AST_Definitions, |
| AST_Dot, |
| AST_EmptyStatement, |
| AST_Expansion, |
| AST_False, |
| AST_Function, |
| AST_If, |
| AST_Import, |
| AST_Jump, |
| AST_LabeledStatement, |
| AST_Lambda, |
| AST_New, |
| AST_Node, |
| AST_Null, |
| AST_Number, |
| AST_Object, |
| AST_ObjectGetter, |
| AST_ObjectKeyVal, |
| AST_ObjectProperty, |
| AST_ObjectSetter, |
| AST_PropAccess, |
| AST_RegExp, |
| AST_Return, |
| AST_Sequence, |
| AST_SimpleStatement, |
| AST_Statement, |
| AST_String, |
| AST_Sub, |
| AST_Switch, |
| AST_SwitchBranch, |
| AST_SymbolClassProperty, |
| AST_SymbolDeclaration, |
| AST_SymbolRef, |
| AST_TemplateSegment, |
| AST_TemplateString, |
| AST_This, |
| AST_Toplevel, |
| AST_True, |
| AST_Try, |
| AST_Unary, |
| AST_UnaryPostfix, |
| AST_UnaryPrefix, |
| AST_Undefined, |
| AST_VarDef, |
| |
| TreeTransformer, |
| walk, |
| walk_abort, |
| |
| _PURE |
| } from "../ast.js"; |
| import { |
| makePredicate, |
| return_true, |
| return_false, |
| return_null, |
| return_this, |
| make_node, |
| member, |
| noop, |
| has_annotation, |
| HOP |
| } from "../utils/index.js"; |
| import { make_node_from_constant, make_sequence, best_of_expression, read_property } from "./common.js"; |
| |
| import { INLINED, UNDEFINED, has_flag } from "./compressor-flags.js"; |
| import { pure_prop_access_globals, is_pure_native_fn, is_pure_native_method } from "./native-objects.js"; |
| |
| // Functions and methods to infer certain facts about expressions |
| // It's not always possible to be 100% sure about something just by static analysis, |
| // so `true` means yes, and `false` means maybe |
| |
| export const is_undeclared_ref = (node) => |
| node instanceof AST_SymbolRef && node.definition().undeclared; |
| |
| export const lazy_op = makePredicate("&& || ??"); |
| export const unary_side_effects = makePredicate("delete ++ --"); |
| |
| // methods to determine whether an expression has a boolean result type |
| (function(def_is_boolean) { |
| const unary_bool = makePredicate("! delete"); |
| const binary_bool = makePredicate("in instanceof == != === !== < <= >= >"); |
| def_is_boolean(AST_Node, return_false); |
| def_is_boolean(AST_UnaryPrefix, function() { |
| return unary_bool.has(this.operator); |
| }); |
| def_is_boolean(AST_Binary, function() { |
| return binary_bool.has(this.operator) |
| || lazy_op.has(this.operator) |
| && this.left.is_boolean() |
| && this.right.is_boolean(); |
| }); |
| def_is_boolean(AST_Conditional, function() { |
| return this.consequent.is_boolean() && this.alternative.is_boolean(); |
| }); |
| def_is_boolean(AST_Assign, function() { |
| return this.operator == "=" && this.right.is_boolean(); |
| }); |
| def_is_boolean(AST_Sequence, function() { |
| return this.tail_node().is_boolean(); |
| }); |
| def_is_boolean(AST_True, return_true); |
| def_is_boolean(AST_False, return_true); |
| })(function(node, func) { |
| node.DEFMETHOD("is_boolean", func); |
| }); |
| |
| // methods to determine if an expression has a numeric result type |
| (function(def_is_number) { |
| def_is_number(AST_Node, return_false); |
| def_is_number(AST_Number, return_true); |
| const unary = makePredicate("+ - ~ ++ --"); |
| def_is_number(AST_Unary, function() { |
| return unary.has(this.operator); |
| }); |
| const numeric_ops = makePredicate("- * / % & | ^ << >> >>>"); |
| def_is_number(AST_Binary, function(compressor) { |
| return numeric_ops.has(this.operator) || this.operator == "+" |
| && this.left.is_number(compressor) |
| && this.right.is_number(compressor); |
| }); |
| def_is_number(AST_Assign, function(compressor) { |
| return numeric_ops.has(this.operator.slice(0, -1)) |
| || this.operator == "=" && this.right.is_number(compressor); |
| }); |
| def_is_number(AST_Sequence, function(compressor) { |
| return this.tail_node().is_number(compressor); |
| }); |
| def_is_number(AST_Conditional, function(compressor) { |
| return this.consequent.is_number(compressor) && this.alternative.is_number(compressor); |
| }); |
| })(function(node, func) { |
| node.DEFMETHOD("is_number", func); |
| }); |
| |
| // methods to determine if an expression has a string result type |
| (function(def_is_string) { |
| def_is_string(AST_Node, return_false); |
| def_is_string(AST_String, return_true); |
| def_is_string(AST_TemplateString, return_true); |
| def_is_string(AST_UnaryPrefix, function() { |
| return this.operator == "typeof"; |
| }); |
| def_is_string(AST_Binary, function(compressor) { |
| return this.operator == "+" && |
| (this.left.is_string(compressor) || this.right.is_string(compressor)); |
| }); |
| def_is_string(AST_Assign, function(compressor) { |
| return (this.operator == "=" || this.operator == "+=") && this.right.is_string(compressor); |
| }); |
| def_is_string(AST_Sequence, function(compressor) { |
| return this.tail_node().is_string(compressor); |
| }); |
| def_is_string(AST_Conditional, function(compressor) { |
| return this.consequent.is_string(compressor) && this.alternative.is_string(compressor); |
| }); |
| })(function(node, func) { |
| node.DEFMETHOD("is_string", func); |
| }); |
| |
| export function is_undefined(node, compressor) { |
| return ( |
| has_flag(node, UNDEFINED) |
| || node instanceof AST_Undefined |
| || node instanceof AST_UnaryPrefix |
| && node.operator == "void" |
| && !node.expression.has_side_effects(compressor) |
| ); |
| } |
| |
| // Is the node explicitly null or undefined. |
| function is_null_or_undefined(node, compressor) { |
| let fixed; |
| return ( |
| node instanceof AST_Null |
| || is_undefined(node, compressor) |
| || ( |
| node instanceof AST_SymbolRef |
| && (fixed = node.definition().fixed) instanceof AST_Node |
| && is_nullish(fixed, compressor) |
| ) |
| ); |
| } |
| |
| // Find out if this expression is optionally chained from a base-point that we |
| // can statically analyze as null or undefined. |
| export function is_nullish_shortcircuited(node, compressor) { |
| if (node instanceof AST_PropAccess || node instanceof AST_Call) { |
| return ( |
| (node.optional && is_null_or_undefined(node.expression, compressor)) |
| || is_nullish_shortcircuited(node.expression, compressor) |
| ); |
| } |
| if (node instanceof AST_Chain) return is_nullish_shortcircuited(node.expression, compressor); |
| return false; |
| } |
| |
| // Find out if something is == null, or can short circuit into nullish. |
| // Used to optimize ?. and ?? |
| export function is_nullish(node, compressor) { |
| if (is_null_or_undefined(node, compressor)) return true; |
| return is_nullish_shortcircuited(node, compressor); |
| } |
| |
| // Determine if expression might cause side effects |
| // If there's a possibility that a node may change something when it's executed, this returns true |
| (function(def_has_side_effects) { |
| def_has_side_effects(AST_Node, return_true); |
| |
| def_has_side_effects(AST_EmptyStatement, return_false); |
| def_has_side_effects(AST_Constant, return_false); |
| def_has_side_effects(AST_This, return_false); |
| |
| function any(list, compressor) { |
| for (var i = list.length; --i >= 0;) |
| if (list[i].has_side_effects(compressor)) |
| return true; |
| return false; |
| } |
| |
| def_has_side_effects(AST_Block, function(compressor) { |
| return any(this.body, compressor); |
| }); |
| def_has_side_effects(AST_Call, function(compressor) { |
| if ( |
| !this.is_callee_pure(compressor) |
| && (!this.expression.is_call_pure(compressor) |
| || this.expression.has_side_effects(compressor)) |
| ) { |
| return true; |
| } |
| return any(this.args, compressor); |
| }); |
| def_has_side_effects(AST_Switch, function(compressor) { |
| return this.expression.has_side_effects(compressor) |
| || any(this.body, compressor); |
| }); |
| def_has_side_effects(AST_Case, function(compressor) { |
| return this.expression.has_side_effects(compressor) |
| || any(this.body, compressor); |
| }); |
| def_has_side_effects(AST_Try, function(compressor) { |
| return any(this.body, compressor) |
| || this.bcatch && this.bcatch.has_side_effects(compressor) |
| || this.bfinally && this.bfinally.has_side_effects(compressor); |
| }); |
| def_has_side_effects(AST_If, function(compressor) { |
| return this.condition.has_side_effects(compressor) |
| || this.body && this.body.has_side_effects(compressor) |
| || this.alternative && this.alternative.has_side_effects(compressor); |
| }); |
| def_has_side_effects(AST_LabeledStatement, function(compressor) { |
| return this.body.has_side_effects(compressor); |
| }); |
| def_has_side_effects(AST_SimpleStatement, function(compressor) { |
| return this.body.has_side_effects(compressor); |
| }); |
| def_has_side_effects(AST_Lambda, return_false); |
| def_has_side_effects(AST_Class, function (compressor) { |
| if (this.extends && this.extends.has_side_effects(compressor)) { |
| return true; |
| } |
| return any(this.properties, compressor); |
| }); |
| def_has_side_effects(AST_Binary, function(compressor) { |
| return this.left.has_side_effects(compressor) |
| || this.right.has_side_effects(compressor); |
| }); |
| def_has_side_effects(AST_Assign, return_true); |
| def_has_side_effects(AST_Conditional, function(compressor) { |
| return this.condition.has_side_effects(compressor) |
| || this.consequent.has_side_effects(compressor) |
| || this.alternative.has_side_effects(compressor); |
| }); |
| def_has_side_effects(AST_Unary, function(compressor) { |
| return unary_side_effects.has(this.operator) |
| || this.expression.has_side_effects(compressor); |
| }); |
| def_has_side_effects(AST_SymbolRef, function(compressor) { |
| return !this.is_declared(compressor) && !pure_prop_access_globals.has(this.name); |
| }); |
| def_has_side_effects(AST_SymbolClassProperty, return_false); |
| def_has_side_effects(AST_SymbolDeclaration, return_false); |
| def_has_side_effects(AST_Object, function(compressor) { |
| return any(this.properties, compressor); |
| }); |
| def_has_side_effects(AST_ObjectProperty, function(compressor) { |
| return ( |
| this.computed_key() && this.key.has_side_effects(compressor) |
| || this.value && this.value.has_side_effects(compressor) |
| ); |
| }); |
| def_has_side_effects(AST_ClassProperty, function(compressor) { |
| return ( |
| this.computed_key() && this.key.has_side_effects(compressor) |
| || this.static && this.value && this.value.has_side_effects(compressor) |
| ); |
| }); |
| def_has_side_effects(AST_ConciseMethod, function(compressor) { |
| return this.computed_key() && this.key.has_side_effects(compressor); |
| }); |
| def_has_side_effects(AST_ObjectGetter, function(compressor) { |
| return this.computed_key() && this.key.has_side_effects(compressor); |
| }); |
| def_has_side_effects(AST_ObjectSetter, function(compressor) { |
| return this.computed_key() && this.key.has_side_effects(compressor); |
| }); |
| def_has_side_effects(AST_Array, function(compressor) { |
| return any(this.elements, compressor); |
| }); |
| def_has_side_effects(AST_Dot, function(compressor) { |
| if (is_nullish(this, compressor)) return false; |
| return !this.optional && this.expression.may_throw_on_access(compressor) |
| || this.expression.has_side_effects(compressor); |
| }); |
| def_has_side_effects(AST_Sub, function(compressor) { |
| if (is_nullish(this, compressor)) return false; |
| |
| return !this.optional && this.expression.may_throw_on_access(compressor) |
| || this.expression.has_side_effects(compressor) |
| || this.property.has_side_effects(compressor); |
| }); |
| def_has_side_effects(AST_Chain, function (compressor) { |
| return this.expression.has_side_effects(compressor); |
| }); |
| def_has_side_effects(AST_Sequence, function(compressor) { |
| return any(this.expressions, compressor); |
| }); |
| def_has_side_effects(AST_Definitions, function(compressor) { |
| return any(this.definitions, compressor); |
| }); |
| def_has_side_effects(AST_VarDef, function() { |
| return this.value; |
| }); |
| def_has_side_effects(AST_TemplateSegment, return_false); |
| def_has_side_effects(AST_TemplateString, function(compressor) { |
| return any(this.segments, compressor); |
| }); |
| })(function(node, func) { |
| node.DEFMETHOD("has_side_effects", func); |
| }); |
| |
| // determine if expression may throw |
| (function(def_may_throw) { |
| def_may_throw(AST_Node, return_true); |
| |
| def_may_throw(AST_Constant, return_false); |
| def_may_throw(AST_EmptyStatement, return_false); |
| def_may_throw(AST_Lambda, return_false); |
| def_may_throw(AST_SymbolDeclaration, return_false); |
| def_may_throw(AST_This, return_false); |
| |
| function any(list, compressor) { |
| for (var i = list.length; --i >= 0;) |
| if (list[i].may_throw(compressor)) |
| return true; |
| return false; |
| } |
| |
| def_may_throw(AST_Class, function(compressor) { |
| if (this.extends && this.extends.may_throw(compressor)) return true; |
| return any(this.properties, compressor); |
| }); |
| |
| def_may_throw(AST_Array, function(compressor) { |
| return any(this.elements, compressor); |
| }); |
| def_may_throw(AST_Assign, function(compressor) { |
| if (this.right.may_throw(compressor)) return true; |
| if (!compressor.has_directive("use strict") |
| && this.operator == "=" |
| && this.left instanceof AST_SymbolRef) { |
| return false; |
| } |
| return this.left.may_throw(compressor); |
| }); |
| def_may_throw(AST_Binary, function(compressor) { |
| return this.left.may_throw(compressor) |
| || this.right.may_throw(compressor); |
| }); |
| def_may_throw(AST_Block, function(compressor) { |
| return any(this.body, compressor); |
| }); |
| def_may_throw(AST_Call, function(compressor) { |
| if (is_nullish(this, compressor)) return false; |
| if (any(this.args, compressor)) return true; |
| if (this.is_callee_pure(compressor)) return false; |
| if (this.expression.may_throw(compressor)) return true; |
| return !(this.expression instanceof AST_Lambda) |
| || any(this.expression.body, compressor); |
| }); |
| def_may_throw(AST_Case, function(compressor) { |
| return this.expression.may_throw(compressor) |
| || any(this.body, compressor); |
| }); |
| def_may_throw(AST_Conditional, function(compressor) { |
| return this.condition.may_throw(compressor) |
| || this.consequent.may_throw(compressor) |
| || this.alternative.may_throw(compressor); |
| }); |
| def_may_throw(AST_Definitions, function(compressor) { |
| return any(this.definitions, compressor); |
| }); |
| def_may_throw(AST_If, function(compressor) { |
| return this.condition.may_throw(compressor) |
| || this.body && this.body.may_throw(compressor) |
| || this.alternative && this.alternative.may_throw(compressor); |
| }); |
| def_may_throw(AST_LabeledStatement, function(compressor) { |
| return this.body.may_throw(compressor); |
| }); |
| def_may_throw(AST_Object, function(compressor) { |
| return any(this.properties, compressor); |
| }); |
| def_may_throw(AST_ObjectProperty, function(compressor) { |
| // TODO key may throw too |
| return this.value ? this.value.may_throw(compressor) : false; |
| }); |
| def_may_throw(AST_ClassProperty, function(compressor) { |
| return ( |
| this.computed_key() && this.key.may_throw(compressor) |
| || this.static && this.value && this.value.may_throw(compressor) |
| ); |
| }); |
| def_may_throw(AST_ConciseMethod, function(compressor) { |
| return this.computed_key() && this.key.may_throw(compressor); |
| }); |
| def_may_throw(AST_ObjectGetter, function(compressor) { |
| return this.computed_key() && this.key.may_throw(compressor); |
| }); |
| def_may_throw(AST_ObjectSetter, function(compressor) { |
| return this.computed_key() && this.key.may_throw(compressor); |
| }); |
| def_may_throw(AST_Return, function(compressor) { |
| return this.value && this.value.may_throw(compressor); |
| }); |
| def_may_throw(AST_Sequence, function(compressor) { |
| return any(this.expressions, compressor); |
| }); |
| def_may_throw(AST_SimpleStatement, function(compressor) { |
| return this.body.may_throw(compressor); |
| }); |
| def_may_throw(AST_Dot, function(compressor) { |
| if (is_nullish(this, compressor)) return false; |
| return !this.optional && this.expression.may_throw_on_access(compressor) |
| || this.expression.may_throw(compressor); |
| }); |
| def_may_throw(AST_Sub, function(compressor) { |
| if (is_nullish(this, compressor)) return false; |
| return !this.optional && this.expression.may_throw_on_access(compressor) |
| || this.expression.may_throw(compressor) |
| || this.property.may_throw(compressor); |
| }); |
| def_may_throw(AST_Chain, function(compressor) { |
| return this.expression.may_throw(compressor); |
| }); |
| def_may_throw(AST_Switch, function(compressor) { |
| return this.expression.may_throw(compressor) |
| || any(this.body, compressor); |
| }); |
| def_may_throw(AST_SymbolRef, function(compressor) { |
| return !this.is_declared(compressor) && !pure_prop_access_globals.has(this.name); |
| }); |
| def_may_throw(AST_SymbolClassProperty, return_false); |
| def_may_throw(AST_Try, function(compressor) { |
| return this.bcatch ? this.bcatch.may_throw(compressor) : any(this.body, compressor) |
| || this.bfinally && this.bfinally.may_throw(compressor); |
| }); |
| def_may_throw(AST_Unary, function(compressor) { |
| if (this.operator == "typeof" && this.expression instanceof AST_SymbolRef) |
| return false; |
| return this.expression.may_throw(compressor); |
| }); |
| def_may_throw(AST_VarDef, function(compressor) { |
| if (!this.value) return false; |
| return this.value.may_throw(compressor); |
| }); |
| })(function(node, func) { |
| node.DEFMETHOD("may_throw", func); |
| }); |
| |
| // determine if expression is constant |
| (function(def_is_constant_expression) { |
| function all_refs_local(scope) { |
| let result = true; |
| walk(this, node => { |
| if (node instanceof AST_SymbolRef) { |
| if (has_flag(this, INLINED)) { |
| result = false; |
| return walk_abort; |
| } |
| var def = node.definition(); |
| if ( |
| member(def, this.enclosed) |
| && !this.variables.has(def.name) |
| ) { |
| if (scope) { |
| var scope_def = scope.find_variable(node); |
| if (def.undeclared ? !scope_def : scope_def === def) { |
| result = "f"; |
| return true; |
| } |
| } |
| result = false; |
| return walk_abort; |
| } |
| return true; |
| } |
| if (node instanceof AST_This && this instanceof AST_Arrow) { |
| // TODO check arguments too! |
| result = false; |
| return walk_abort; |
| } |
| }); |
| return result; |
| } |
| |
| def_is_constant_expression(AST_Node, return_false); |
| def_is_constant_expression(AST_Constant, return_true); |
| def_is_constant_expression(AST_Class, function(scope) { |
| if (this.extends && !this.extends.is_constant_expression(scope)) { |
| return false; |
| } |
| |
| for (const prop of this.properties) { |
| if (prop.computed_key() && !prop.key.is_constant_expression(scope)) { |
| return false; |
| } |
| if (prop.static && prop.value && !prop.value.is_constant_expression(scope)) { |
| return false; |
| } |
| } |
| |
| return all_refs_local.call(this, scope); |
| }); |
| def_is_constant_expression(AST_Lambda, all_refs_local); |
| def_is_constant_expression(AST_Unary, function() { |
| return this.expression.is_constant_expression(); |
| }); |
| def_is_constant_expression(AST_Binary, function() { |
| return this.left.is_constant_expression() |
| && this.right.is_constant_expression(); |
| }); |
| def_is_constant_expression(AST_Array, function() { |
| return this.elements.every((l) => l.is_constant_expression()); |
| }); |
| def_is_constant_expression(AST_Object, function() { |
| return this.properties.every((l) => l.is_constant_expression()); |
| }); |
| def_is_constant_expression(AST_ObjectProperty, function() { |
| return !!(!(this.key instanceof AST_Node) && this.value && this.value.is_constant_expression()); |
| }); |
| })(function(node, func) { |
| node.DEFMETHOD("is_constant_expression", func); |
| }); |
| |
| |
| // may_throw_on_access() |
| // returns true if this node may be null, undefined or contain `AST_Accessor` |
| (function(def_may_throw_on_access) { |
| AST_Node.DEFMETHOD("may_throw_on_access", function(compressor) { |
| return !compressor.option("pure_getters") |
| || this._dot_throw(compressor); |
| }); |
| |
| function is_strict(compressor) { |
| return /strict/.test(compressor.option("pure_getters")); |
| } |
| |
| def_may_throw_on_access(AST_Node, is_strict); |
| def_may_throw_on_access(AST_Null, return_true); |
| def_may_throw_on_access(AST_Undefined, return_true); |
| def_may_throw_on_access(AST_Constant, return_false); |
| def_may_throw_on_access(AST_Array, return_false); |
| def_may_throw_on_access(AST_Object, function(compressor) { |
| if (!is_strict(compressor)) return false; |
| for (var i = this.properties.length; --i >=0;) |
| if (this.properties[i]._dot_throw(compressor)) return true; |
| return false; |
| }); |
| // Do not be as strict with classes as we are with objects. |
| // Hopefully the community is not going to abuse static getters and setters. |
| // https://github.com/terser/terser/issues/724#issuecomment-643655656 |
| def_may_throw_on_access(AST_Class, return_false); |
| def_may_throw_on_access(AST_ObjectProperty, return_false); |
| def_may_throw_on_access(AST_ObjectGetter, return_true); |
| def_may_throw_on_access(AST_Expansion, function(compressor) { |
| return this.expression._dot_throw(compressor); |
| }); |
| def_may_throw_on_access(AST_Function, return_false); |
| def_may_throw_on_access(AST_Arrow, return_false); |
| def_may_throw_on_access(AST_UnaryPostfix, return_false); |
| def_may_throw_on_access(AST_UnaryPrefix, function() { |
| return this.operator == "void"; |
| }); |
| def_may_throw_on_access(AST_Binary, function(compressor) { |
| return (this.operator == "&&" || this.operator == "||" || this.operator == "??") |
| && (this.left._dot_throw(compressor) || this.right._dot_throw(compressor)); |
| }); |
| def_may_throw_on_access(AST_Assign, function(compressor) { |
| if (this.logical) return true; |
| |
| return this.operator == "=" |
| && this.right._dot_throw(compressor); |
| }); |
| def_may_throw_on_access(AST_Conditional, function(compressor) { |
| return this.consequent._dot_throw(compressor) |
| || this.alternative._dot_throw(compressor); |
| }); |
| def_may_throw_on_access(AST_Dot, function(compressor) { |
| if (!is_strict(compressor)) return false; |
| |
| if (this.property == "prototype") { |
| return !( |
| this.expression instanceof AST_Function |
| || this.expression instanceof AST_Class |
| ); |
| } |
| return true; |
| }); |
| def_may_throw_on_access(AST_Chain, function(compressor) { |
| return this.expression._dot_throw(compressor); |
| }); |
| def_may_throw_on_access(AST_Sequence, function(compressor) { |
| return this.tail_node()._dot_throw(compressor); |
| }); |
| def_may_throw_on_access(AST_SymbolRef, function(compressor) { |
| if (this.name === "arguments") return false; |
| if (has_flag(this, UNDEFINED)) return true; |
| if (!is_strict(compressor)) return false; |
| if (is_undeclared_ref(this) && this.is_declared(compressor)) return false; |
| if (this.is_immutable()) return false; |
| var fixed = this.fixed_value(); |
| return !fixed || fixed._dot_throw(compressor); |
| }); |
| })(function(node, func) { |
| node.DEFMETHOD("_dot_throw", func); |
| }); |
| |
| export function is_lhs(node, parent) { |
| if (parent instanceof AST_Unary && unary_side_effects.has(parent.operator)) return parent.expression; |
| if (parent instanceof AST_Assign && parent.left === node) return node; |
| } |
| |
| (function(def_find_defs) { |
| function to_node(value, orig) { |
| if (value instanceof AST_Node) { |
| if (!(value instanceof AST_Constant)) { |
| // Value may be a function, an array including functions and even a complex assign / block expression, |
| // so it should never be shared in different places. |
| // Otherwise wrong information may be used in the compression phase |
| value = value.clone(true); |
| } |
| return make_node(value.CTOR, orig, value); |
| } |
| if (Array.isArray(value)) return make_node(AST_Array, orig, { |
| elements: value.map(function(value) { |
| return to_node(value, orig); |
| }) |
| }); |
| if (value && typeof value == "object") { |
| var props = []; |
| for (var key in value) if (HOP(value, key)) { |
| props.push(make_node(AST_ObjectKeyVal, orig, { |
| key: key, |
| value: to_node(value[key], orig) |
| })); |
| } |
| return make_node(AST_Object, orig, { |
| properties: props |
| }); |
| } |
| return make_node_from_constant(value, orig); |
| } |
| |
| AST_Toplevel.DEFMETHOD("resolve_defines", function(compressor) { |
| if (!compressor.option("global_defs")) return this; |
| this.figure_out_scope({ ie8: compressor.option("ie8") }); |
| return this.transform(new TreeTransformer(function(node) { |
| var def = node._find_defs(compressor, ""); |
| if (!def) return; |
| var level = 0, child = node, parent; |
| while (parent = this.parent(level++)) { |
| if (!(parent instanceof AST_PropAccess)) break; |
| if (parent.expression !== child) break; |
| child = parent; |
| } |
| if (is_lhs(child, parent)) { |
| return; |
| } |
| return def; |
| })); |
| }); |
| def_find_defs(AST_Node, noop); |
| def_find_defs(AST_Chain, function(compressor, suffix) { |
| return this.expression._find_defs(compressor, suffix); |
| }); |
| def_find_defs(AST_Dot, function(compressor, suffix) { |
| return this.expression._find_defs(compressor, "." + this.property + suffix); |
| }); |
| def_find_defs(AST_SymbolDeclaration, function() { |
| if (!this.global()) return; |
| }); |
| def_find_defs(AST_SymbolRef, function(compressor, suffix) { |
| if (!this.global()) return; |
| var defines = compressor.option("global_defs"); |
| var name = this.name + suffix; |
| if (HOP(defines, name)) return to_node(defines[name], this); |
| }); |
| })(function(node, func) { |
| node.DEFMETHOD("_find_defs", func); |
| }); |
| |
| // method to negate an expression |
| (function(def_negate) { |
| function basic_negation(exp) { |
| return make_node(AST_UnaryPrefix, exp, { |
| operator: "!", |
| expression: exp |
| }); |
| } |
| function best(orig, alt, first_in_statement) { |
| var negated = basic_negation(orig); |
| if (first_in_statement) { |
| var stat = make_node(AST_SimpleStatement, alt, { |
| body: alt |
| }); |
| return best_of_expression(negated, stat) === stat ? alt : negated; |
| } |
| return best_of_expression(negated, alt); |
| } |
| def_negate(AST_Node, function() { |
| return basic_negation(this); |
| }); |
| def_negate(AST_Statement, function() { |
| throw new Error("Cannot negate a statement"); |
| }); |
| def_negate(AST_Function, function() { |
| return basic_negation(this); |
| }); |
| def_negate(AST_Arrow, function() { |
| return basic_negation(this); |
| }); |
| def_negate(AST_UnaryPrefix, function() { |
| if (this.operator == "!") |
| return this.expression; |
| return basic_negation(this); |
| }); |
| def_negate(AST_Sequence, function(compressor) { |
| var expressions = this.expressions.slice(); |
| expressions.push(expressions.pop().negate(compressor)); |
| return make_sequence(this, expressions); |
| }); |
| def_negate(AST_Conditional, function(compressor, first_in_statement) { |
| var self = this.clone(); |
| self.consequent = self.consequent.negate(compressor); |
| self.alternative = self.alternative.negate(compressor); |
| return best(this, self, first_in_statement); |
| }); |
| def_negate(AST_Binary, function(compressor, first_in_statement) { |
| var self = this.clone(), op = this.operator; |
| if (compressor.option("unsafe_comps")) { |
| switch (op) { |
| case "<=" : self.operator = ">" ; return self; |
| case "<" : self.operator = ">=" ; return self; |
| case ">=" : self.operator = "<" ; return self; |
| case ">" : self.operator = "<=" ; return self; |
| } |
| } |
| switch (op) { |
| case "==" : self.operator = "!="; return self; |
| case "!=" : self.operator = "=="; return self; |
| case "===": self.operator = "!=="; return self; |
| case "!==": self.operator = "==="; return self; |
| case "&&": |
| self.operator = "||"; |
| self.left = self.left.negate(compressor, first_in_statement); |
| self.right = self.right.negate(compressor); |
| return best(this, self, first_in_statement); |
| case "||": |
| self.operator = "&&"; |
| self.left = self.left.negate(compressor, first_in_statement); |
| self.right = self.right.negate(compressor); |
| return best(this, self, first_in_statement); |
| } |
| return basic_negation(this); |
| }); |
| })(function(node, func) { |
| node.DEFMETHOD("negate", function(compressor, first_in_statement) { |
| return func.call(this, compressor, first_in_statement); |
| }); |
| }); |
| |
| // Is the callee of this function pure? |
| var global_pure_fns = makePredicate("Boolean decodeURI decodeURIComponent Date encodeURI encodeURIComponent Error escape EvalError isFinite isNaN Number Object parseFloat parseInt RangeError ReferenceError String SyntaxError TypeError unescape URIError"); |
| AST_Call.DEFMETHOD("is_callee_pure", function(compressor) { |
| if (compressor.option("unsafe")) { |
| var expr = this.expression; |
| var first_arg = (this.args && this.args[0] && this.args[0].evaluate(compressor)); |
| if ( |
| expr.expression && expr.expression.name === "hasOwnProperty" && |
| (first_arg == null || first_arg.thedef && first_arg.thedef.undeclared) |
| ) { |
| return false; |
| } |
| if (is_undeclared_ref(expr) && global_pure_fns.has(expr.name)) return true; |
| if ( |
| expr instanceof AST_Dot |
| && is_undeclared_ref(expr.expression) |
| && is_pure_native_fn(expr.expression.name, expr.property) |
| ) { |
| return true; |
| } |
| } |
| return !!has_annotation(this, _PURE) || !compressor.pure_funcs(this); |
| }); |
| |
| // If I call this, is it a pure function? |
| AST_Node.DEFMETHOD("is_call_pure", return_false); |
| AST_Dot.DEFMETHOD("is_call_pure", function(compressor) { |
| if (!compressor.option("unsafe")) return; |
| const expr = this.expression; |
| |
| let native_obj; |
| if (expr instanceof AST_Array) { |
| native_obj = "Array"; |
| } else if (expr.is_boolean()) { |
| native_obj = "Boolean"; |
| } else if (expr.is_number(compressor)) { |
| native_obj = "Number"; |
| } else if (expr instanceof AST_RegExp) { |
| native_obj = "RegExp"; |
| } else if (expr.is_string(compressor)) { |
| native_obj = "String"; |
| } else if (!this.may_throw_on_access(compressor)) { |
| native_obj = "Object"; |
| } |
| return native_obj != null && is_pure_native_method(native_obj, this.property); |
| }); |
| |
| // tell me if a statement aborts |
| export const aborts = (thing) => thing && thing.aborts(); |
| |
| (function(def_aborts) { |
| def_aborts(AST_Statement, return_null); |
| def_aborts(AST_Jump, return_this); |
| function block_aborts() { |
| for (var i = 0; i < this.body.length; i++) { |
| if (aborts(this.body[i])) { |
| return this.body[i]; |
| } |
| } |
| return null; |
| } |
| def_aborts(AST_Import, function() { return null; }); |
| def_aborts(AST_BlockStatement, block_aborts); |
| def_aborts(AST_SwitchBranch, block_aborts); |
| def_aborts(AST_If, function() { |
| return this.alternative && aborts(this.body) && aborts(this.alternative) && this; |
| }); |
| })(function(node, func) { |
| node.DEFMETHOD("aborts", func); |
| }); |
| |
| export function is_modified(compressor, tw, node, value, level, immutable) { |
| var parent = tw.parent(level); |
| var lhs = is_lhs(node, parent); |
| if (lhs) return lhs; |
| if (!immutable |
| && parent instanceof AST_Call |
| && parent.expression === node |
| && !(value instanceof AST_Arrow) |
| && !(value instanceof AST_Class) |
| && !parent.is_callee_pure(compressor) |
| && (!(value instanceof AST_Function) |
| || !(parent instanceof AST_New) && value.contains_this())) { |
| return true; |
| } |
| if (parent instanceof AST_Array) { |
| return is_modified(compressor, tw, parent, parent, level + 1); |
| } |
| if (parent instanceof AST_ObjectKeyVal && node === parent.value) { |
| var obj = tw.parent(level + 1); |
| return is_modified(compressor, tw, obj, obj, level + 2); |
| } |
| if (parent instanceof AST_PropAccess && parent.expression === node) { |
| var prop = read_property(value, parent.property); |
| return !immutable && is_modified(compressor, tw, parent, prop, level + 1); |
| } |
| } |
