terser 5.42.0 → 5.43.0

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## v5.43.0
+
+ - Do not wrap callbacks in parentheses (`wrap_func_args` format option is now false by default)
+ - Do not inline functions into for loops (for performance reasons)
+
 ## v5.42.0
 
  - Improved performance in the parse step by adding a fast path for simple identifiers.

package/README.md

@@ -1070,7 +1070,7 @@ as "output options".
   function expressions. See
   [#640](https://github.com/mishoo/UglifyJS2/issues/640) for more details.
 
-- `wrap_func_args` (default `true`) -- pass `false` if you do not want to wrap
+- `wrap_func_args` (default `false`) -- pass `true` in order to wrap
   function expressions that are passed as arguments, in parenthesis. See
   [OptimizeJS](https://github.com/nolanlawson/optimize-js) for more details.
 

package/dist/bundle.min.js

@@ -1711,10 +1711,10 @@ function parse($TEXT, options) {
         });
     };
 
-    var function_ = function(ctor, is_generator_property, is_async, is_export_default) {
+    var function_ = function(ctor, is_generator, is_async, is_export_default) {
         var in_statement = ctor === AST_Defun;
-        var is_generator = is("operator", "*");
-        if (is_generator) {
+        if (is("operator", "*")) {
+            is_generator = true;
             next();
         }
 
@@ -1731,11 +1731,11 @@ function parse($TEXT, options) {
             unexpected(prev());
 
         var args = [];
-        var body = _function_body(true, is_generator || is_generator_property, is_async, name, args);
+        var body = _function_body(true, is_generator, is_async, name, args);
         return new ctor({
             start : args.start,
             end   : body.end,
-            is_generator: is_generator || is_generator_property,
+            is_generator: is_generator,
             async : is_async,
             name  : name,
             argnames: args,
@@ -2811,8 +2811,6 @@ function parse($TEXT, options) {
             var node = new AST_MethodVariant({
                 start       : start,
                 static      : is_static,
-                is_generator: is_generator,
-                async       : is_async,
                 key         : name,
                 quote       : name instanceof AST_SymbolMethod ?
                               property_token.quote : undefined,
@@ -5792,12 +5790,10 @@ var AST_ObjectGetter = DEFNODE("ObjectGetter", "quote static", function AST_Obje
     }
 }, AST_ObjectProperty);
 
-var AST_ConciseMethod = DEFNODE("ConciseMethod", "quote static is_generator async", function AST_ConciseMethod(props) {
+var AST_ConciseMethod = DEFNODE("ConciseMethod", "quote static", function AST_ConciseMethod(props) {
     if (props) {
         this.quote = props.quote;
         this.static = props.static;
-        this.is_generator = props.is_generator;
-        this.async = props.async;
         this.key = props.key;
         this.value = props.value;
         this.start = props.start;
@@ -5810,8 +5806,6 @@ var AST_ConciseMethod = DEFNODE("ConciseMethod", "quote static is_generator asyn
     $propdoc: {
         quote: "[string|undefined] the original quote character, if any",
         static: "[boolean] is this method static (classes only)",
-        is_generator: "[boolean] is this a generator method",
-        async: "[boolean] is this method async",
     },
     $documentation: "An ES6 concise method inside an object or class",
     computed_key() {
@@ -5819,11 +5813,9 @@ var AST_ConciseMethod = DEFNODE("ConciseMethod", "quote static is_generator asyn
     }
 }, AST_ObjectProperty);
 
-var AST_PrivateMethod = DEFNODE("PrivateMethod", "", function AST_PrivateMethod(props) {
+var AST_PrivateMethod = DEFNODE("PrivateMethod", "static", function AST_PrivateMethod(props) {
     if (props) {
         this.static = props.static;
-        this.is_generator = props.is_generator;
-        this.async = props.async;
         this.key = props.key;
         this.value = props.value;
         this.start = props.start;
@@ -5833,6 +5825,9 @@ var AST_PrivateMethod = DEFNODE("PrivateMethod", "", function AST_PrivateMethod(
     this.flags = 0;
 }, {
     $documentation: "A private class method inside a class",
+    $propdoc: {
+        static: "[boolean] is this a static private method",
+    },
     computed_key() {
         return false;
     },
@@ -6823,6 +6818,28 @@ class TreeWalker {
         }
     }
 
+    is_within_loop() {
+        let i = this.stack.length - 1;
+        let child = this.stack[i];
+        while (i--) {
+            const node = this.stack[i];
+
+            if (node instanceof AST_Lambda) return false;
+            if (
+                node instanceof AST_IterationStatement
+                // exclude for-loop bits that only run once
+                && !((node instanceof AST_For) && child === node.init)
+                && !((node instanceof AST_ForIn || node instanceof AST_ForOf) && child === node.object)
+            ) {
+                return true;
+            }
+
+            child = node;
+        }
+
+        return false;
+    }
+
     find_scope() {
         var stack = this.stack;
         for (var i = stack.length; --i >= 0;) {
@@ -7392,8 +7409,6 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
                                 ? from_moz(M.key)
                                 : from_moz_symbol(AST_SymbolMethod, M.key),
                     quote    : from_moz_quote(M.key, M.computed),
-                    is_generator: value.is_generator,
-                    async    : value.async,
                     static   : false, // always an object
                     value,
                 };
@@ -7422,8 +7437,6 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
             if (M.kind == "set") {
                 return new (is_private ? AST_PrivateSetter : AST_ObjectSetter)(args);
             }
-            args.is_generator = M.value.generator;
-            args.async = M.value.async;
             return new (is_private ? AST_PrivateMethod : AST_ConciseMethod)(args);
         },
 
@@ -8284,15 +8297,12 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
         };
     });
 
-    def_to_moz(AST_Function, function To_Moz_FunctionExpression(M, parent) {
-        var is_generator = parent.is_generator !== undefined
-            ? parent.is_generator
-            : M.is_generator;
+    def_to_moz(AST_Function, function To_Moz_FunctionExpression(M) {
         return {
             type: "FunctionExpression",
             id: to_moz(M.name),
             params: M.argnames.map(to_moz_pattern),
-            generator: is_generator || false,
+            generator: M.is_generator || false,
             async: M.async || false,
             body: to_moz_scope("BlockStatement", M)
         };
@@ -9316,7 +9326,7 @@ function OutputStream(options) {
         webkit               : false,
         width                : 80,
         wrap_iife            : false,
-        wrap_func_args       : true,
+        wrap_func_args       : false,
 
         _destroy_ast         : false
     }, true);
@@ -11327,22 +11337,22 @@ function OutputStream(options) {
     });
     DEFPRINT(AST_ConciseMethod, function(self, output) {
         var type;
-        if (self.is_generator && self.async) {
+        if (self.value.is_generator && self.value.async) {
             type = "async*";
-        } else if (self.is_generator) {
+        } else if (self.value.is_generator) {
             type = "*";
-        } else if (self.async) {
+        } else if (self.value.async) {
             type = "async";
         }
         self._print_getter_setter(type, false, output);
     });
     DEFPRINT(AST_PrivateMethod, function(self, output) {
         var type;
-        if (self.is_generator && self.async) {
+        if (self.value.is_generator && self.value.async) {
             type = "async*";
-        } else if (self.is_generator) {
+        } else if (self.value.is_generator) {
             type = "*";
-        } else if (self.async) {
+        } else if (self.value.async) {
             type = "async";
         }
         self._print_getter_setter(type, true, output);
@@ -11738,11 +11748,11 @@ AST_ObjectGetter.prototype.shallow_cmp = function(other) {
 };
 
 AST_ConciseMethod.prototype.shallow_cmp = function(other) {
-    return this.static === other.static && this.is_generator === other.is_generator && this.async === other.async;
+    return this.static === other.static;
 };
 
 AST_PrivateMethod.prototype.shallow_cmp = function(other) {
-    return this.static === other.static && this.is_generator === other.is_generator && this.async === other.async;
+    return this.static === other.static;
 };
 
 AST_Class.prototype.shallow_cmp = function(other) {
@@ -13078,7 +13088,7 @@ AST_ObjectSetter.prototype._size = function () {
 };
 
 AST_ConciseMethod.prototype._size = function () {
-    return static_size(this.static) + key_size(this.key) + lambda_modifiers(this);
+    return static_size(this.static) + key_size(this.key);
 };
 
 AST_PrivateMethod.prototype._size = function () {
@@ -18421,6 +18431,8 @@ function inline_into_symbolref(self, compressor) {
         return self;
     }
 
+    if (dont_inline_lambda_in_loop(compressor, fixed)) return self;
+
     let single_use = def.single_use
         && !(parent instanceof AST_Call
             && (parent.is_callee_pure(compressor))
@@ -18574,6 +18586,11 @@ function inline_into_call(self, compressor) {
         fn = fixed;
     }
 
+    if (
+        dont_inline_lambda_in_loop(compressor, fn)
+        && !has_annotation(self, _INLINE)
+    ) return self;
+
     var is_func = fn instanceof AST_Lambda;
 
     var stat = is_func && fn.body[0];
@@ -18902,6 +18919,14 @@ function inline_into_call(self, compressor) {
     }
 }
 
+/** prevent inlining functions into loops, for performance reasons */
+function dont_inline_lambda_in_loop(compressor, maybe_lambda) {
+    return (
+        (maybe_lambda instanceof AST_Lambda || maybe_lambda instanceof AST_Class)
+        && !!compressor.is_within_loop()
+    );
+}
+
 (function(def_find_defs) {
     function to_node(value, orig) {
         if (value instanceof AST_Node) {
@@ -22328,7 +22353,7 @@ AST_PropAccess.DEFMETHOD("flatten_object", function(key, compressor) {
             if ("" + (prop instanceof AST_ConciseMethod ? prop.key.name : prop.key) == key) {
                 const all_props_flattenable = props.every((p) =>
                     (p instanceof AST_ObjectKeyVal
-                        || arrows && p instanceof AST_ConciseMethod && !p.is_generator
+                        || arrows && p instanceof AST_ConciseMethod && !p.value.is_generator
                     )
                     && !p.computed_key()
                 );
@@ -22814,7 +22839,7 @@ def_optimize(AST_ConciseMethod, function(self, compressor) {
     // p(){return x;} ---> p:()=>x
     if (compressor.option("arrows")
         && compressor.parent() instanceof AST_Object
-        && !self.is_generator
+        && !self.value.is_generator
         && !self.value.uses_arguments
         && !self.value.pinned()
         && self.value.body.length == 1
@@ -22822,8 +22847,8 @@ def_optimize(AST_ConciseMethod, function(self, compressor) {
         && self.value.body[0].value
         && !self.value.contains_this()) {
         var arrow = make_node(AST_Arrow, self.value, self.value);
-        arrow.async = self.async;
-        arrow.is_generator = self.is_generator;
+        arrow.async = self.value.async;
+        arrow.is_generator = self.value.is_generator;
         return make_node(AST_ObjectKeyVal, self, {
             key: self.key instanceof AST_SymbolMethod ? self.key.name : self.key,
             value: arrow,
@@ -22851,8 +22876,6 @@ def_optimize(AST_ObjectKeyVal, function(self, compressor) {
             && !value.contains_this();
         if ((is_arrow_with_block || value instanceof AST_Function) && !value.name) {
             return make_node(AST_ConciseMethod, self, {
-                async: value.async,
-                is_generator: value.is_generator,
                 key: key instanceof AST_Node ? key : make_node(AST_SymbolMethod, self, {
                     name: key,
                 }),

package/lib/ast.js

@@ -2150,12 +2150,10 @@ var AST_ObjectGetter = DEFNODE("ObjectGetter", "quote static", function AST_Obje
     }
 }, AST_ObjectProperty);
 
-var AST_ConciseMethod = DEFNODE("ConciseMethod", "quote static is_generator async", function AST_ConciseMethod(props) {
+var AST_ConciseMethod = DEFNODE("ConciseMethod", "quote static", function AST_ConciseMethod(props) {
     if (props) {
         this.quote = props.quote;
         this.static = props.static;
-        this.is_generator = props.is_generator;
-        this.async = props.async;
         this.key = props.key;
         this.value = props.value;
         this.start = props.start;
@@ -2168,8 +2166,6 @@ var AST_ConciseMethod = DEFNODE("ConciseMethod", "quote static is_generator asyn
     $propdoc: {
         quote: "[string|undefined] the original quote character, if any",
         static: "[boolean] is this method static (classes only)",
-        is_generator: "[boolean] is this a generator method",
-        async: "[boolean] is this method async",
     },
     $documentation: "An ES6 concise method inside an object or class",
     computed_key() {
@@ -2177,11 +2173,9 @@ var AST_ConciseMethod = DEFNODE("ConciseMethod", "quote static is_generator asyn
     }
 }, AST_ObjectProperty);
 
-var AST_PrivateMethod = DEFNODE("PrivateMethod", "", function AST_PrivateMethod(props) {
+var AST_PrivateMethod = DEFNODE("PrivateMethod", "static", function AST_PrivateMethod(props) {
     if (props) {
         this.static = props.static;
-        this.is_generator = props.is_generator;
-        this.async = props.async;
         this.key = props.key;
         this.value = props.value;
         this.start = props.start;
@@ -2191,6 +2185,9 @@ var AST_PrivateMethod = DEFNODE("PrivateMethod", "", function AST_PrivateMethod(
     this.flags = 0;
 }, {
     $documentation: "A private class method inside a class",
+    $propdoc: {
+        static: "[boolean] is this a static private method",
+    },
     computed_key() {
         return false;
     },
@@ -3181,6 +3178,28 @@ class TreeWalker {
         }
     }
 
+    is_within_loop() {
+        let i = this.stack.length - 1;
+        let child = this.stack[i];
+        while (i--) {
+            const node = this.stack[i];
+
+            if (node instanceof AST_Lambda) return false;
+            if (
+                node instanceof AST_IterationStatement
+                // exclude for-loop bits that only run once
+                && !((node instanceof AST_For) && child === node.init)
+                && !((node instanceof AST_ForIn || node instanceof AST_ForOf) && child === node.object)
+            ) {
+                return true;
+            }
+
+            child = node;
+        }
+
+        return false;
+    }
+
     find_scope() {
         var stack = this.stack;
         for (var i = stack.length; --i >= 0;) {

package/lib/compress/index.js

@@ -3522,7 +3522,7 @@ AST_PropAccess.DEFMETHOD("flatten_object", function(key, compressor) {
             if ("" + (prop instanceof AST_ConciseMethod ? prop.key.name : prop.key) == key) {
                 const all_props_flattenable = props.every((p) =>
                     (p instanceof AST_ObjectKeyVal
-                        || arrows && p instanceof AST_ConciseMethod && !p.is_generator
+                        || arrows && p instanceof AST_ConciseMethod && !p.value.is_generator
                     )
                     && !p.computed_key()
                 );
@@ -4008,7 +4008,7 @@ def_optimize(AST_ConciseMethod, function(self, compressor) {
     // p(){return x;} ---> p:()=>x
     if (compressor.option("arrows")
         && compressor.parent() instanceof AST_Object
-        && !self.is_generator
+        && !self.value.is_generator
         && !self.value.uses_arguments
         && !self.value.pinned()
         && self.value.body.length == 1
@@ -4016,8 +4016,8 @@ def_optimize(AST_ConciseMethod, function(self, compressor) {
         && self.value.body[0].value
         && !self.value.contains_this()) {
         var arrow = make_node(AST_Arrow, self.value, self.value);
-        arrow.async = self.async;
-        arrow.is_generator = self.is_generator;
+        arrow.async = self.value.async;
+        arrow.is_generator = self.value.is_generator;
         return make_node(AST_ObjectKeyVal, self, {
             key: self.key instanceof AST_SymbolMethod ? self.key.name : self.key,
             value: arrow,
@@ -4045,8 +4045,6 @@ def_optimize(AST_ObjectKeyVal, function(self, compressor) {
             && !value.contains_this();
         if ((is_arrow_with_block || value instanceof AST_Function) && !value.name) {
             return make_node(AST_ConciseMethod, self, {
-                async: value.async,
-                is_generator: value.is_generator,
                 key: key instanceof AST_Node ? key : make_node(AST_SymbolMethod, self, {
                     name: key,
                 }),

package/lib/compress/inline.js

@@ -187,6 +187,8 @@ export function inline_into_symbolref(self, compressor) {
         return self;
     }
 
+    if (dont_inline_lambda_in_loop(compressor, fixed)) return self;
+
     let single_use = def.single_use
         && !(parent instanceof AST_Call
             && (parent.is_callee_pure(compressor))
@@ -340,6 +342,11 @@ export function inline_into_call(self, compressor) {
         fn = fixed;
     }
 
+    if (
+        dont_inline_lambda_in_loop(compressor, fn)
+        && !has_annotation(self, _INLINE)
+    ) return self;
+
     var is_func = fn instanceof AST_Lambda;
 
     var stat = is_func && fn.body[0];
@@ -667,3 +674,11 @@ export function inline_into_call(self, compressor) {
         return expressions.map(exp => exp.clone(true));
     }
 }
+
+/** prevent inlining functions into loops, for performance reasons */
+function dont_inline_lambda_in_loop(compressor, maybe_lambda) {
+    return (
+        (maybe_lambda instanceof AST_Lambda || maybe_lambda instanceof AST_Class)
+        && !!compressor.is_within_loop()
+    );
+}

package/lib/equivalent-to.js

@@ -249,11 +249,11 @@ AST_ObjectGetter.prototype.shallow_cmp = function(other) {
 };
 
 AST_ConciseMethod.prototype.shallow_cmp = function(other) {
-    return this.static === other.static && this.is_generator === other.is_generator && this.async === other.async;
+    return this.static === other.static;
 };
 
 AST_PrivateMethod.prototype.shallow_cmp = function(other) {
-    return this.static === other.static && this.is_generator === other.is_generator && this.async === other.async;
+    return this.static === other.static;
 };
 
 AST_Class.prototype.shallow_cmp = function(other) {

package/lib/mozilla-ast.js

@@ -365,8 +365,6 @@ import { is_basic_identifier_string } from "./parse.js";
                                 ? from_moz(M.key)
                                 : from_moz_symbol(AST_SymbolMethod, M.key),
                     quote    : from_moz_quote(M.key, M.computed),
-                    is_generator: value.is_generator,
-                    async    : value.async,
                     static   : false, // always an object
                     value,
                 };
@@ -395,8 +393,6 @@ import { is_basic_identifier_string } from "./parse.js";
             if (M.kind == "set") {
                 return new (is_private ? AST_PrivateSetter : AST_ObjectSetter)(args);
             }
-            args.is_generator = M.value.generator;
-            args.async = M.value.async;
             return new (is_private ? AST_PrivateMethod : AST_ConciseMethod)(args);
         },
 
@@ -1257,15 +1253,12 @@ import { is_basic_identifier_string } from "./parse.js";
         };
     });
 
-    def_to_moz(AST_Function, function To_Moz_FunctionExpression(M, parent) {
-        var is_generator = parent.is_generator !== undefined
-            ? parent.is_generator
-            : M.is_generator;
+    def_to_moz(AST_Function, function To_Moz_FunctionExpression(M) {
         return {
             type: "FunctionExpression",
             id: to_moz(M.name),
             params: M.argnames.map(to_moz_pattern),
-            generator: is_generator || false,
+            generator: M.is_generator || false,
             async: M.async || false,
             body: to_moz_scope("BlockStatement", M)
         };

package/lib/output.js

@@ -287,7 +287,7 @@ function OutputStream(options) {
         webkit               : false,
         width                : 80,
         wrap_iife            : false,
-        wrap_func_args       : true,
+        wrap_func_args       : false,
 
         _destroy_ast         : false
     }, true);
@@ -2298,22 +2298,22 @@ function OutputStream(options) {
     });
     DEFPRINT(AST_ConciseMethod, function(self, output) {
         var type;
-        if (self.is_generator && self.async) {
+        if (self.value.is_generator && self.value.async) {
             type = "async*";
-        } else if (self.is_generator) {
+        } else if (self.value.is_generator) {
             type = "*";
-        } else if (self.async) {
+        } else if (self.value.async) {
             type = "async";
         }
         self._print_getter_setter(type, false, output);
     });
     DEFPRINT(AST_PrivateMethod, function(self, output) {
         var type;
-        if (self.is_generator && self.async) {
+        if (self.value.is_generator && self.value.async) {
             type = "async*";
-        } else if (self.is_generator) {
+        } else if (self.value.is_generator) {
             type = "*";
-        } else if (self.async) {
+        } else if (self.value.async) {
             type = "async";
         }
         self._print_getter_setter(type, true, output);

package/lib/parse.js

@@ -1565,10 +1565,10 @@ function parse($TEXT, options) {
         });
     };
 
-    var function_ = function(ctor, is_generator_property, is_async, is_export_default) {
+    var function_ = function(ctor, is_generator, is_async, is_export_default) {
         var in_statement = ctor === AST_Defun;
-        var is_generator = is("operator", "*");
-        if (is_generator) {
+        if (is("operator", "*")) {
+            is_generator = true;
             next();
         }
 
@@ -1585,11 +1585,11 @@ function parse($TEXT, options) {
             unexpected(prev());
 
         var args = [];
-        var body = _function_body(true, is_generator || is_generator_property, is_async, name, args);
+        var body = _function_body(true, is_generator, is_async, name, args);
         return new ctor({
             start : args.start,
             end   : body.end,
-            is_generator: is_generator || is_generator_property,
+            is_generator: is_generator,
             async : is_async,
             name  : name,
             argnames: args,
@@ -2665,8 +2665,6 @@ function parse($TEXT, options) {
             var node = new AST_MethodVariant({
                 start       : start,
                 static      : is_static,
-                is_generator: is_generator,
-                async       : is_async,
                 key         : name,
                 quote       : name instanceof AST_SymbolMethod ?
                               property_token.quote : undefined,

package/lib/size.js

@@ -383,7 +383,7 @@ AST_ObjectSetter.prototype._size = function () {
 };
 
 AST_ConciseMethod.prototype._size = function () {
-    return static_size(this.static) + key_size(this.key) + lambda_modifiers(this);
+    return static_size(this.static) + key_size(this.key);
 };
 
 AST_PrivateMethod.prototype._size = function () {

package/package.json

@@ -4,7 +4,7 @@
   "homepage": "https://terser.org",
   "author": "Mihai Bazon <mihai.bazon@gmail.com> (http://lisperator.net/)",
   "license": "BSD-2-Clause",
-  "version": "5.42.0",
+  "version": "5.43.0",
   "engines": {
     "node": ">=10"
   },