v3.16.0

fixes #5485

.github/workflows/ufuzz.yml

@@ -17,13 +17,13 @@ jobs:
       fail-fast: false
       matrix:
         include:
-          - node: latest
+          - node: '16'
             os: macos-latest
-          - node: '8'
+          - node: '12'
             os: ubuntu-latest
           - node: '8'
             os: ubuntu-latest
-          - node: '8'
+          - node: '12'
             os: windows-latest
           - node: '8'
             os: windows-latest

README.md

@@ -118,6 +118,7 @@ a double dash to prevent input files being used as option arguments:
     --keep-fargs                Do not mangle/drop function arguments.
     --keep-fnames               Do not mangle/drop function names.  Useful for
                                 code relying on Function.prototype.name.
+    --module                    Process input as ES module (implies --toplevel)
     --name-cache <file>         File to hold mangled name mappings.
     --self                      Build UglifyJS as a library (implies --wrap UglifyJS)
     --source-map [options]      Enable source map/specify source map options:
@@ -146,7 +147,7 @@ a double dash to prevent input files being used as option arguments:
     --warn                      Print warning messages.
     --webkit                    Support non-standard Safari/Webkit.
                                 Equivalent to setting `webkit: true` in `minify()`
-                                for `mangle` and `output` options.
+                                for `compress`, `mangle` and `output` options.
                                 By default UglifyJS will not try to be Safari-proof.
     --wrap <name>               Embed everything in a big function, making the
                                 “exports” and “global” variables available. You
@@ -517,6 +518,9 @@ if (result.error) throw result.error;
   - `mangle.properties` (default: `false`) — a subcategory of the mangle option.
     Pass an object to specify custom [mangle property options](#mangle-properties-options).
 
+- `module` (default: `false`) — set to `true` if you wish to process input as
+  ES module, i.e. implicit `"use strict";` alongside with `toplevel` enabled.
+
 - `nameCache` (default: `null`) — pass an empty object `{}` or a previously
   used `nameCache` object if you wish to cache mangled variable and
   property names across multiple invocations of `minify()`. Note: this is
@@ -728,6 +732,9 @@ to be `false` and all symbol names will be omitted.
 
 - `merge_vars` (default: `true`) — combine and reuse variables.
 
+- `module` (default: `false`) — set to `true` if you wish to process input as
+  ES module, i.e. implicit `"use strict";` alongside with `toplevel` enabled.
+
 - `negate_iife` (default: `true`) — negate "Immediately-Called Function Expressions"
   where the return value is discarded, to avoid the parens that the
   code generator would insert.
@@ -1331,11 +1338,9 @@ To allow for better optimizations, the compiler makes various assumptions:
 - Later versions of JavaScript will throw `SyntaxError` with the following:
   ```javascript
   var await;
-  async function f() {
   class A {
       static p = await;
   }
-  }
   // SyntaxError: Unexpected reserved word
   ```
   UglifyJS may modify the input which in turn may suppress those errors.
@@ -1373,3 +1378,46 @@ To allow for better optimizations, the compiler makes various assumptions:
   // TypeError: const 'a' has already been declared
   ```
   UglifyJS may modify the input which in turn may suppress those errors.
+- Later versions of Chrome and Node.js will give incorrect results with the
+  following:
+  ```javascript
+  try {
+      class A {
+          static 42;
+          static get 42() {}
+      }
+      console.log("PASS");
+  } catch (e) {
+      console.log("FAIL");
+  }
+  // Expected: "PASS"
+  // Actual:   "FAIL"
+  ```
+  UglifyJS may modify the input which in turn may suppress those errors.
+- Some versions of Chrome and Node.js will give incorrect results with the
+  following:
+  ```javascript
+  (async function(a) {
+      (function() {
+          var b = await => console.log("PASS");
+          b();
+      })();
+  })().catch(console.error);
+  // Expected: "PASS"
+  // Actual:   SyntaxError: Unexpected reserved word
+  ```
+  UglifyJS may modify the input which in turn may suppress those errors.
+- Later versions of Chrome and Node.js will give incorrect results with the
+  following:
+  ```javascript
+  try {
+      f();
+      function f() {
+          throw 42;
+      }
+  } catch (e) {}
+  console.log(typeof f);
+  // Expected: "function"
+  // Actual:   "undefined"
+  ```
+  UglifyJS may modify the input which in turn may suppress those errors.

bin/uglifyjs

@@ -107,6 +107,7 @@ function process_option(name, no_value) {
                 "  --ie                                     Support non-standard Internet Explorer.",
                 "  --keep-fargs                             Do not mangle/drop function arguments.",
                 "  --keep-fnames                            Do not mangle/drop function names. Useful for code relying on Function.prototype.name.",
+                "  --module                                 Process input as ES module (implies --toplevel)",
                 "  --name-cache <file>                      File to hold mangled name mappings.",
                 "  --rename                                 Force symbol expansion.",
                 "  --no-rename                              Disable symbol expansion.",
@@ -152,6 +153,7 @@ function process_option(name, no_value) {
       case "annotations":
       case "ie":
       case "ie8":
+      case "module":
       case "timings":
       case "toplevel":
       case "v8":

lib/ast.js

@@ -827,6 +827,9 @@ var AST_Class = DEFNODE("Class", "extends name properties", {
         extends: "[AST_Node?] the super class, or null if not specified",
         properties: "[AST_ClassProperty*] array of class properties",
     },
+    resolve: function(def_class) {
+        return def_class ? this : this.parent_scope.resolve();
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -1834,7 +1837,7 @@ var AST_Label = DEFNODE("Label", "references", {
     initialize: function() {
         this.references = [];
         this.thedef = this;
-    }
+    },
 }, AST_Symbol);
 
 var AST_SymbolRef = DEFNODE("SymbolRef", "fixed in_arg redef", {
@@ -2036,16 +2039,21 @@ TreeWalker.prototype = {
         return this.stack[this.stack.length - 2 - (n || 0)];
     },
     push: function(node) {
-        if (node instanceof AST_Lambda) {
+        var value;
+        if (node instanceof AST_Class) {
+            this.directives = Object.create(this.directives);
+            value = "use strict";
+        } else if (node instanceof AST_Directive) {
+            value = node.value;
+        } else if (node instanceof AST_Lambda) {
             this.directives = Object.create(this.directives);
-        } else if (node instanceof AST_Directive && !this.directives[node.value]) {
-            this.directives[node.value] = node;
         }
+        if (value && !this.directives[value]) this.directives[value] = node;
         this.stack.push(node);
     },
     pop: function() {
         var node = this.stack.pop();
-        if (node instanceof AST_Lambda) {
+        if (node instanceof AST_Class || node instanceof AST_Lambda) {
             this.directives = Object.getPrototypeOf(this.directives);
         }
     },

lib/minify.js

@@ -81,13 +81,14 @@ function minify(files, options) {
             keep_fargs: false,
             keep_fnames: false,
             mangle: {},
+            module: false,
             nameCache: null,
             output: {},
             parse: {},
             rename: undefined,
             sourceMap: false,
             timings: false,
-            toplevel: false,
+            toplevel: !!(options && options["module"]),
             v8: false,
             validate: false,
             warnings: false,
@@ -96,15 +97,15 @@ function minify(files, options) {
         }, true);
         if (options.validate) AST_Node.enable_validation();
         var timings = options.timings && { start: Date.now() };
-        if (options.rename === undefined) options.rename = options.compress && options.mangle;
         if (options.annotations !== undefined) set_shorthand("annotations", options, [ "compress", "output" ]);
         if (options.ie8) options.ie = options.ie || options.ie8;
-        if (options.ie) set_shorthand("ie", options, [ "compress", "mangle", "output" ]);
+        if (options.ie) set_shorthand("ie", options, [ "compress", "mangle", "output", "rename" ]);
-        if (options.keep_fargs) set_shorthand("keep_fargs", options, [ "compress", "mangle" ]);
+        if (options.keep_fargs) set_shorthand("keep_fargs", options, [ "compress", "mangle", "rename" ]);
-        if (options.keep_fnames) set_shorthand("keep_fnames", options, [ "compress", "mangle" ]);
+        if (options.keep_fnames) set_shorthand("keep_fnames", options, [ "compress", "mangle", "rename" ]);
-        if (options.toplevel) set_shorthand("toplevel", options, [ "compress", "mangle" ]);
+        if (options.module) set_shorthand("module", options, [ "compress", "parse" ]);
-        if (options.v8) set_shorthand("v8", options, [ "mangle", "output" ]);
+        if (options.toplevel) set_shorthand("toplevel", options, [ "compress", "mangle", "rename" ]);
-        if (options.webkit) set_shorthand("webkit", options, [ "compress", "mangle", "output" ]);
+        if (options.v8) set_shorthand("v8", options, [ "mangle", "output", "rename" ]);
+        if (options.webkit) set_shorthand("webkit", options, [ "compress", "mangle", "output", "rename" ]);
         var quoted_props;
         if (options.mangle) {
             options.mangle = defaults(options.mangle, {
@@ -135,6 +136,7 @@ function minify(files, options) {
             init_cache(options.mangle.cache);
             init_cache(options.mangle.properties.cache);
         }
+        if (options.rename === undefined) options.rename = options.compress && options.mangle;
         if (options.sourceMap) {
             options.sourceMap = defaults(options.sourceMap, {
                 content: null,
@@ -190,8 +192,8 @@ function minify(files, options) {
         if (options.validate) toplevel.validate_ast();
         if (timings) timings.rename = Date.now();
         if (options.rename) {
-            toplevel.figure_out_scope(options.mangle);
+            toplevel.figure_out_scope(options.rename);
-            toplevel.expand_names(options.mangle);
+            toplevel.expand_names(options.rename);
         }
         if (timings) timings.compress = Date.now();
         if (options.compress) {

lib/parse.js

@@ -237,8 +237,7 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
         newline_before  : false,
         regex_allowed   : false,
         comments_before : [],
-        directives      : {},
+        directives      : Object.create(null),
-        directive_stack : [],
         read_template   : with_eof_error("Unterminated template literal", function(strings) {
             var s = "";
             for (;;) {
@@ -635,24 +634,19 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
     };
 
     next_token.add_directive = function(directive) {
-        S.directive_stack[S.directive_stack.length - 1].push(directive);
+        S.directives[directive] = true;
-        if (S.directives[directive]) S.directives[directive]++;
-        else S.directives[directive] = 1;
     }
 
     next_token.push_directives_stack = function() {
-        S.directive_stack.push([]);
+        S.directives = Object.create(S.directives);
     }
 
     next_token.pop_directives_stack = function() {
-        var directives = S.directive_stack.pop();
+        S.directives = Object.getPrototypeOf(S.directives);
-        for (var i = directives.length; --i >= 0;) {
-            S.directives[directives[i]]--;
-        }
     }
 
     next_token.has_directive = function(directive) {
-        return S.directives[directive] > 0;
+        return !!S.directives[directive];
     }
 
     return next_token;
@@ -699,6 +693,7 @@ function parse($TEXT, options) {
         expression     : false,
         filename       : null,
         html5_comments : true,
+        module         : false,
         shebang        : true,
         strict         : false,
         toplevel       : null,
@@ -1194,10 +1189,10 @@ function parse($TEXT, options) {
     }
 
     function for_() {
-        var await = is("name", "await") && next();
+        var await_token = is("name", "await") && next();
         expect("(");
         var init = null;
-        if (await || !is("punc", ";")) {
+        if (await_token || !is("punc", ";")) {
             init = is("keyword", "const")
                 ? (next(), const_(true))
                 : is("name", "let") && is_vardefs()
@@ -1206,7 +1201,7 @@ function parse($TEXT, options) {
                 ? (next(), var_(true))
                 : expression(true);
             var ctor;
-            if (await) {
+            if (await_token) {
                 expect_token("name", "of");
                 ctor = AST_ForAwaitOf;
             } else if (is("operator", "in")) {
@@ -1340,8 +1335,6 @@ function parse($TEXT, options) {
         var loop = S.in_loop;
         var labels = S.labels;
         ++S.in_function;
-        S.in_directives = true;
-        S.input.push_directives_stack();
         S.in_loop = 0;
         S.labels = [];
         if (is("punc", "{")) {
@@ -1352,8 +1345,6 @@ function parse($TEXT, options) {
             handle_regexp();
             value = maybe_assign();
         }
-        var is_strict = S.input.has_directive("use strict");
-        S.input.pop_directives_stack();
         --S.in_function;
         S.in_loop = loop;
         S.labels = labels;
@@ -1367,7 +1358,7 @@ function parse($TEXT, options) {
             value: value,
             end: prev(),
         });
-        if (is_strict) node.each_argname(strict_verify_symbol);
+        if (S.input.has_directive("use strict")) node.each_argname(strict_verify_symbol);
         return node;
     }
 
@@ -1412,7 +1403,7 @@ function parse($TEXT, options) {
             name: name,
             argnames: argnames,
             rest: argnames.rest || null,
-            body: body
+            body: body,
         });
         if (is_strict) {
             if (name) strict_verify_symbol(name);
@@ -2550,6 +2541,7 @@ function parse($TEXT, options) {
     return function() {
         var start = S.token;
         var body = [];
+        if (options.module) S.input.add_directive("use strict");
         S.input.push_directives_stack();
         while (!is("eof"))
             body.push(statement());

lib/scope.js

@@ -64,19 +64,20 @@ SymbolDef.prototype = {
         this.references.forEach(fn);
     },
     mangle: function(options) {
-        var cache = options.cache && options.cache.props;
+        if (this.mangled_name) return;
-        if (this.global && cache && cache.has(this.name)) {
+        var cache = this.global && options.cache && options.cache.props;
+        if (cache && cache.has(this.name)) {
             this.mangled_name = cache.get(this.name);
-        } else if (!this.mangled_name && !this.unmangleable(options)) {
+        } else if (this.unmangleable(options)) {
+            names_in_use(this.scope, options).set(this.name, true);
+        } else {
             var def = this.redefined();
             if (def) {
                 this.mangled_name = def.mangled_name || def.name;
             } else {
                 this.mangled_name = next_mangled_name(this, options);
             }
-            if (this.global && cache) {
+            if (cache) cache.set(this.name, this.mangled_name);
-                cache.set(this.name, this.mangled_name);
-            }
         }
     },
     redefined: function() {
@@ -469,6 +470,7 @@ AST_Lambda.DEFMETHOD("init_vars", function(parent_scope) {
     this.uses_arguments = false;
     this.def_variable(new AST_SymbolFunarg({
         name: "arguments",
+        scope: this,
         start: this.start,
         end: this.end,
     }));
@@ -620,14 +622,10 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options) {
     var lname = -1;
     var redefined = [];
     var tw = new TreeWalker(function(node, descend) {
-        if (node instanceof AST_LabeledStatement) {
+        var save_nesting;
-            // `lname` is incremented when we get to the `AST_Label`
-            var save_nesting = lname;
-            descend();
-            if (!options.v8 || !in_label(tw)) lname = save_nesting;
-            return true;
-        }
         if (node instanceof AST_BlockScope) {
+            // `lname` is incremented when we get to the `AST_Label`
+            if (node instanceof AST_LabeledStatement) save_nesting = lname;
             if (options.webkit && node instanceof AST_IterationStatement && node.init instanceof AST_Let) {
                 node.init.definitions.forEach(function(defn) {
                     defn.name.match_symbol(function(sym) {
@@ -673,6 +671,7 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options) {
                 }));
             }
             to_mangle.forEach(mangle);
+            if (node instanceof AST_LabeledStatement && !(options.v8 && in_label(tw))) lname = save_nesting;
             return true;
         }
         if (node instanceof AST_Label) {

package.json

@@ -3,7 +3,7 @@
   "description": "JavaScript parser, mangler/compressor and beautifier toolkit",
   "author": "Mihai Bazon <mihai.bazon@gmail.com> (http://lisperator.net/)",
   "license": "BSD-2-Clause",
-  "version": "3.15.3",
+  "version": "3.16.0",
   "engines": {
     "node": ">=0.8.0"
   },

test/compress.js

@@ -69,9 +69,7 @@ function make_code(ast, options) {
 function parse_test(file) {
     var script = fs.readFileSync(file, "utf8");
     try {
-        var ast = U.parse(script, {
+        var ast = U.parse(script, { filename: file });
-            filename: file
-        });
     } catch (e) {
         console.error("Caught error while parsing tests in " + file);
         console.error(e);
@@ -98,14 +96,14 @@ function parse_test(file) {
             file: file,
             line: node.start.line,
             col: node.start.col,
-            code: make_code(node, { beautify: false })
+            code: make_code(node, { beautify: false }),
         }));
     }
 
     function read_string(stat) {
         if (stat.TYPE == "SimpleStatement") {
             var body = stat.body;
-            switch(body.TYPE) {
+            switch (body.TYPE) {
               case "String":
                 return body.value;
               case "Array":
@@ -142,7 +140,7 @@ function parse_test(file) {
                 ].indexOf(label.name) >= 0, tmpl("Unsupported label {name} [{line},{col}]", {
                     name: label.name,
                     line: label.start.line,
-                    col: label.start.col
+                    col: label.start.col,
                 }));
                 var stat = node.body;
                 if (label.name == "expect_exact" || label.name == "node_version") {
@@ -155,12 +153,12 @@ function parse_test(file) {
                         var ctor = global[body.expression.name];
                         assert.ok(ctor === Error || ctor.prototype instanceof Error, tmpl("Unsupported expect_stdout format [{line},{col}]", {
                             line: label.start.line,
-                            col: label.start.col
+                            col: label.start.col,
                         }));
                         test[label.name] = ctor.apply(null, body.args.map(function(node) {
                             assert.ok(node instanceof U.AST_Constant, tmpl("Unsupported expect_stdout format [{line},{col}]", {
                                 line: label.start.line,
-                                col: label.start.col
+                                col: label.start.col,
                             }));
                             return node.value;
                         }));
@@ -183,13 +181,11 @@ function parse_test(file) {
 function reminify(orig_options, input_code, input_formatted, stdout) {
     for (var i = 0; i < minify_options.length; i++) {
         var options = JSON.parse(minify_options[i]);
-        if (options.compress) [
+        [
             "keep_fargs",
             "keep_fnames",
         ].forEach(function(name) {
-            if (name in orig_options) {
+            if (name in orig_options) options[name] = orig_options[name];
-                options.compress[name] = orig_options[name];
-            }
         });
         var options_formatted = JSON.stringify(options, null, 4);
         options.validate = true;

test/compress/arrows.js

@@ -1018,3 +1018,91 @@ issue_5356: {
     expect_stdout: "NaN"
     node_version: ">=4"
 }
+
+issue_5414_1: {
+    options = {
+        arrows: true,
+        if_return: true,
+        inline: true,
+        toplevel: true,
+    }
+    input: {
+        (() => {
+            (() => {
+                if (!console)
+                    var arguments = 42;
+                while (console.log(arguments));
+            })();
+        })();
+    }
+    expect: {
+        (() => {
+            if (!console)
+                var arguments = 42;
+            while (console.log(arguments));
+        })();
+    }
+    expect_stdout: true
+    node_version: ">=4"
+}
+
+issue_5414_2: {
+    options = {
+        arrows: true,
+        inline: true,
+        side_effects: true,
+        toplevel: true,
+    }
+    input: {
+        (() => {
+            (() => {
+                if (!console)
+                    var arguments = 42;
+                while (console.log(arguments));
+            })();
+        })();
+    }
+    expect: {
+        (() => {
+            if (!console)
+                var arguments = 42;
+            while (console.log(arguments));
+        })();
+    }
+    expect_stdout: true
+    node_version: ">=4"
+}
+
+issue_5416: {
+    options = {
+        dead_code: true,
+        evaluate: true,
+        inline: true,
+        loops: true,
+        unused: true,
+    }
+    input: {
+        var f = () => {
+            while ((() => {
+                console;
+                var a = function g(arguments) {
+                    console.log(arguments);
+                }();
+            })());
+        };
+        f();
+    }
+    expect: {
+        var f = () => {
+            {
+                arguments = void 0;
+                console;
+                console.log(arguments);
+                var arguments;
+            }
+        };
+        f();
+    }
+    expect_stdout: "undefined"
+    node_version: ">=4"
+}

test/compress/awaits.js

@@ -1748,8 +1748,8 @@ issue_4454_2: {
     expect: {
         function f(a) {
             (async function(c = console.log(a)) {})();
-            var a = 42..toString();
+            var b = 42..toString();
-            console.log(a);
+            console.log(b);
         }
         f("PASS");
     }
@@ -2427,80 +2427,6 @@ issue_5023_2: {
     node_version: ">=8"
 }
 
-issue_5032_normal: {
-    options = {
-        merge_vars: true,
-        webkit: false,
-    }
-    input: {
-        function log(value) {
-            console.log(value);
-            return value;
-        }
-        async function f(a) {
-            var b = log(a), c = b;
-            log(b);
-            log(c);
-        }
-        f("PASS");
-    }
-    expect: {
-        function log(value) {
-            console.log(value);
-            return value;
-        }
-        async function f(a) {
-            var a = log(a), c = a;
-            log(a);
-            log(c);
-        }
-        f("PASS");
-    }
-    expect_stdout: [
-        "PASS",
-        "PASS",
-        "PASS",
-    ]
-    node_version: ">=8"
-}
-
-issue_5032_webkit: {
-    options = {
-        merge_vars: true,
-        webkit: true,
-    }
-    input: {
-        function log(value) {
-            console.log(value);
-            return value;
-        }
-        async function f(a) {
-            var b = log(a), c = b;
-            log(b);
-            log(c);
-        }
-        f("PASS");
-    }
-    expect: {
-        function log(value) {
-            console.log(value);
-            return value;
-        }
-        async function f(a) {
-            var b = log(a), c = b;
-            log(b);
-            log(c);
-        }
-        f("PASS");
-    }
-    expect_stdout: [
-        "PASS",
-        "PASS",
-        "PASS",
-    ]
-    node_version: ">=8"
-}
-
 issue_5034: {
     options = {
         functions: true,
@@ -2959,3 +2885,79 @@ issue_5305_3: {
     expect_stdout: "PASS"
     node_version: ">=8"
 }
+
+issue_5456: {
+    options = {
+        inline: true,
+        merge_vars: true,
+    }
+    input: {
+        var a = true;
+        (function() {
+            (function(b, c) {
+                var d = async function() {
+                    c = await null;
+                }();
+                var e = function() {
+                    if (c)
+                        console.log(typeof d);
+                    while (b);
+                }();
+            })(function(i) {
+                return console.log("foo") && i;
+            }(a));
+        })();
+    }
+    expect: {
+        var a = true;
+        (function() {
+            b = (i = a, console.log("foo") && i),
+            d = async function() {
+                c = await null;
+            }(),
+            e = function() {
+                if (c) console.log(typeof d);
+                while (b);
+            }(),
+            void 0;
+            var b, c, d, e;
+            var i;
+        })();
+    }
+    expect_stdout: "foo"
+    node_version: ">=8"
+}
+
+issue_5478: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        A = {
+            get then() {
+                a = "FAIL";
+            },
+        };
+        var a = "PASS";
+        (async function() {
+            for (var b in "foo")
+                return void A;
+        })();
+        console.log(a);
+    }
+    expect: {
+        A = {
+            get then() {
+                a = "FAIL";
+            },
+        };
+        var a = "PASS";
+        (async function() {
+            for (var b in "foo")
+                return !A;
+        })();
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=8"
+}

test/compress/booleans.js

@@ -762,3 +762,27 @@ issue_5228: {
     }
     expect_stdout: "true"
 }
+
+issue_5469: {
+    options = {
+        assignments: true,
+        booleans: true,
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        pure_getters: "strict",
+        side_effects: true,
+    }
+    input: {
+        console.log(function f(a) {
+            a && 42[a = A && null];
+        }());
+    }
+    expect: {
+        console.log(function f(a) {
+            a && A,
+            0;
+        }());
+    }
+    expect_stdout: "undefined"
+}

test/compress/classes.js

@@ -341,7 +341,7 @@ drop_extends: {
     node_version: ">=4"
 }
 
-keep_extends: {
+keep_extends_1: {
     options = {
         toplevel: true,
         unused: true,
@@ -366,6 +366,43 @@ keep_extends: {
     node_version: ">=4"
 }
 
+keep_extends_2: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        "use strict";
+        (class extends Function {});
+        console.log("PASS");
+    }
+    expect: {
+        "use strict";
+        (class extends Function {});
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+keep_extends_3: {
+    options = {
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        class A extends Function {}
+        console.log("PASS");
+    }
+    expect: {
+        "use strict";
+        (class extends Function {});
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
 drop_name: {
     options = {
         unused: true,
@@ -670,6 +707,58 @@ single_use_7: {
     node_version: ">=4"
 }
 
+single_use_extends: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        class A extends class B {
+            f() {
+                return "PASS";
+            }
+        } {}
+        console.log(new A().f());
+    }
+    expect: {
+        "use strict";
+        console.log(new class extends class {
+            f() {
+                return "PASS";
+            }
+        } {}().f());
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+single_use_extends_non_strict: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        class A extends class B {
+            f() {
+                return "PASS";
+            }
+        } {}
+        console.log(new A().f());
+    }
+    expect: {
+        console.log(new class extends class {
+            f() {
+                return "PASS";
+            }
+        } {}().f());
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
 collapse_non_strict: {
     options = {
         collapse_vars: true,
@@ -742,6 +831,38 @@ collapse_rhs_static: {
     node_version: ">=12"
 }
 
+inline_non_strict: {
+    options = {
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f(a) {
+            return a.p = "PASS";
+        }
+        class A {
+            g() {
+                return f(42);
+            }
+        }
+        console.log(new A().g());
+    }
+    expect: {
+        function f(a) {
+            return a.p = "PASS";
+        }
+        console.log(new class {
+            g() {
+                return f(42);
+            }
+        }().g());
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
 self_comparison: {
     options = {
         booleans: true,
@@ -939,6 +1060,8 @@ keep_fnames: {
         class Foo {}
         console.log(Foo.name, class Bar {}.name);
     }
+    expect_stdout: "Foo Bar"
+    node_version: ">=4"
 }
 
 issue_805_1: {
@@ -1756,12 +1879,14 @@ issue_4962_1: {
         })(function g() {});
     }
     expect: {
-        (function g() {}),
+        (function() {
-        void class {
+            function f() {
-            static c = function() {
                 while (console.log(typeof g));
-            }();
+            }
-        };
+            (class {
+                static c = f();
+            });
+        })(function g() {});
     }
     expect_stdout: "undefined"
     node_version: ">=12"
@@ -1794,6 +1919,37 @@ issue_4962_1_strict: {
     node_version: ">=12"
 }
 
+issue_4962_1_strict_direct: {
+    options = {
+        ie: true,
+        inline: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        (function() {
+            function f() {
+                "use strict";
+                while (console.log(typeof g));
+            }
+            class A {
+                static p = f();
+            }
+        })(function g() {});
+    }
+    expect: {
+        (function g() {}),
+        void class {
+            static c = function() {
+                "use strict";
+                while (console.log(typeof g));
+            }();
+        };
+    }
+    expect_stdout: "undefined"
+    node_version: ">=12"
+}
+
 issue_4962_2: {
     options = {
         ie: true,
@@ -1813,8 +1969,11 @@ issue_4962_2: {
     }
     expect: {
         console.log(function f() {}(function g() {
+            function h() {
+                f;
+            }
             (class {
-                static c = f;
+                static c = h();
             });
         }));
     }
@@ -1850,6 +2009,69 @@ issue_4962_2_strict: {
     node_version: ">=12"
 }
 
+issue_4962_2_strict_direct: {
+    options = {
+        ie: true,
+        inline: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        console.log(function f() {}(function g() {
+            function h() {
+                "use strict";
+                f;
+            }
+            class A {
+                static p = h();
+            }
+        }, typeof g));
+    }
+    expect: {
+        console.log(function f() {}(function g() {
+            (class {
+                static c = function() {
+                    "use strict";
+                    f;
+                }();
+            });
+        }));
+    }
+    expect_stdout: "undefined"
+    node_version: ">=12"
+}
+
+issue_4962_2_strict_direct_inline: {
+    options = {
+        directives: true,
+        ie: true,
+        inline: true,
+        passes: 2,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        console.log(function f() {}(function g() {
+            function h() {
+                "use strict";
+                f;
+            }
+            class A {
+                static p = h();
+            }
+        }, typeof g));
+    }
+    expect: {
+        console.log(function f() {}(function g() {
+            (class {
+                static c = f;
+            });
+        }));
+    }
+    expect_stdout: "undefined"
+    node_version: ">=12"
+}
+
 issue_4982_1: {
     options = {
         dead_code: true,
@@ -2502,3 +2724,161 @@ issue_5352: {
     expect_stdout: "PASS"
     node_version: ">=12"
 }
+
+issue_5387: {
+    options = {
+        properties: true,
+    }
+    input: {
+        "use strict";
+        (function(a) {
+            try {
+                class A extends a {}
+            } catch (e) {
+                console.log("PASS");
+            }
+        })({
+            f() {
+                return this;
+            }
+        }.f);
+    }
+    expect: {
+        "use strict";
+        (function(a) {
+            try {
+                class A extends a {}
+            } catch (e) {
+                console.log("PASS");
+            }
+        })({
+            f() {
+                return this;
+            }
+        }.f);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_5389_1: {
+    options = {
+        collapse_vars: true,
+        toplevel: true,
+    }
+    input: {
+        function log(m, n) {
+            console.log(m, n);
+        }
+        var a = log;
+        class A {
+            [a = "FAIL"] = a = "PASS";
+        }
+        var b = new A();
+        log(a, b.FAIL);
+    }
+    expect: {
+        function log(m, n) {
+            console.log(m, n);
+        }
+        var a = log;
+        class A {
+            [a = "FAIL"] = a = "PASS";
+        }
+        var b = new A();
+        log(a, b.FAIL);
+    }
+    expect_stdout: "PASS PASS"
+    node_version: ">=12"
+}
+
+issue_5389_2: {
+    options = {
+        collapse_vars: true,
+        toplevel: true,
+    }
+    input: {
+        function log(m, n) {
+            console.log(m, n);
+        }
+        var a = log;
+        var A = class {
+            [a = "FAIL"] = a = "PASS";
+        };
+        var b = new A();
+        log(a, b.FAIL);
+    }
+    expect: {
+        function log(m, n) {
+            console.log(m, n);
+        }
+        var a = log;
+        var A;
+        var b = new class {
+            [a = "FAIL"] = a = "PASS";
+        }();
+        log(a, b.FAIL);
+    }
+    expect_stdout: "PASS PASS"
+    node_version: ">=12"
+}
+
+issue_5436: {
+    options = {
+        merge_vars: true,
+    }
+    input: {
+        function f(a) {
+            class A {
+                p = a;
+            }
+            var b = "FAIL";
+            A == b && b();
+            return new A();
+        }
+        console.log(f("PASS").p);
+    }
+    expect: {
+        function f(a) {
+            class A {
+                p = a;
+            }
+            var b = "FAIL";
+            A == b && b();
+            return new A();
+        }
+        console.log(f("PASS").p);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=12"
+}
+
+issue_5481: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        "use strict";
+        var a = "FAIL 1", log = console.log;
+        try {
+            a = "PASS";
+            (class extends 42 {});
+            log("FAIL 2", a);
+        } catch (e) {
+            log(a);
+        }
+    }
+    expect: {
+        "use strict";
+        var a = "FAIL 1", log = console.log;
+        try {
+            a = "PASS";
+            (class extends 42 {});
+            log("FAIL 2", a);
+        } catch (e) {
+            log(a);
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}

test/compress/collapse_vars.js

@@ -9925,3 +9925,57 @@ issue_5309_2: {
     }
     expect_stdout: "PASS"
 }
+
+issue_5394: {
+    options = {
+        collapse_vars: true,
+        evaluate: true,
+    }
+    input: {
+        try {
+            throw A.p = (console.log("FAIL"), []), !1;
+        } catch (e) {
+            console.log(typeof e);
+        }
+    }
+    expect: {
+        try {
+            throw !(A.p = (console.log("FAIL"), []));
+        } catch (e) {
+            console.log(typeof e);
+        }
+    }
+    expect_stdout: "object"
+}
+
+issue_5396: {
+    options = {
+        collapse_vars: true,
+        merge_vars: true,
+        reduce_vars: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        var a, b;
+        function f() {}
+        b = 0;
+        new function g(c) {
+            var d = a && g(e), e = ++d, i = [ 42 ];
+            for (var j in i)
+                console.log("PASS"),
+                i;
+        }();
+    }
+    expect: {
+        var a, b;
+        function f() {}
+        b = 0;
+        (function g(c) {
+            a && g();
+            for (var j in [ 42 ])
+                console.log("PASS");
+        })();
+    }
+    expect_stdout: "PASS"
+}

test/compress/const.js

@@ -1855,3 +1855,20 @@ issue_5338: {
     }
     expect_stdout: true
 }
+
+issue_5476: {
+    mangle = {
+        keep_fargs: true,
+    }
+    input: {
+        console.log(function(n) {
+            const a = 42;
+        }());
+    }
+    expect: {
+        console.log(function(n) {
+            const o = 42;
+        }());
+    }
+    expect_stdout: "undefined"
+}

test/compress/default-values.js

@@ -2209,3 +2209,256 @@ issue_5340_3: {
     expect_stdout: "undefined"
     node_version: ">=6"
 }
+
+issue_5407: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+    }
+    input: {
+        (function(a) {
+            for (var i = 0; i < 2; i++)
+                (function(b = 4) {
+                    console.log(b);
+                    a = 2;
+                })(a);
+        })();
+    }
+    expect: {
+        (function(a) {
+            for (var i = 0; i < 2; i++)
+                (function(b = 4) {
+                    console.log(b);
+                    a = 2;
+                })(a);
+        })();
+    }
+    expect_stdout: [
+        "4",
+        "2",
+    ]
+    node_version: ">=6"
+}
+
+issue_5444_1: {
+    options = {
+        merge_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var a = 42;
+        var b = function({} = setImmediate(function() {
+            console.log(a++);
+        })) {
+            return this;
+        }();
+        console.log(typeof b);
+    }
+    expect: {
+        var a = 42;
+        var b = function({} = setImmediate(function() {
+            console.log(a++);
+        })) {
+            return this;
+        }();
+        console.log(typeof b);
+    }
+    expect_stdout: [
+        "object",
+        "42",
+    ]
+    node_version: ">=6"
+}
+
+issue_5444_2: {
+    options = {
+        merge_vars: true,
+    }
+    input: {
+        function f(a, b = a++) {
+            return b;
+        }
+        console.log(f("FAIL") || "PASS");
+    }
+    expect: {
+        function f(a, b = a++) {
+            return b;
+        }
+        console.log(f("FAIL") || "PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_5444_3: {
+    options = {
+        merge_vars: true,
+    }
+    input: {
+        function f(a, b = function(c = a *= this) {
+            return c;
+        }()) {
+            return b;
+        }
+        console.log(f("FAIL") || "PASS");
+    }
+    expect: {
+        function f(a, b = function(c = a *= this) {
+            return c;
+        }()) {
+            return b;
+        }
+        console.log(f("FAIL") || "PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_5448_1: {
+    options = {
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        (function(a = typeof console.log) {
+            do {
+                var b = [ ...a ];
+            } while (console.log("PASS"));
+        })();
+    }
+    expect: {
+        (function(a = console.log) {
+            do {} while (console.log("PASS"));
+        })();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_5448_2: {
+    options = {
+        keep_fargs: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        (function(a = typeof console) {
+            do {
+                var b = [ ...a ];
+            } while (console.log("PASS"));
+        })();
+    }
+    expect: {
+        (function(a = 0) {
+            do {} while (console.log("PASS"));
+        })();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_5448_3: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unsafe: true,
+        unused: true,
+    }
+    input: {
+        var [ a = typeof console ] = [ void console.log("PASS") ];
+        var b = [ ...a ];
+    }
+    expect: {
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_5448_4: {
+    options = {
+        evaluate: true,
+        pure_getters: "strict",
+        reduce_vars: true,
+        toplevel: true,
+        unsafe: true,
+        unused: true,
+    }
+    input: {
+        var { p: a = typeof console } = { p: void console.log("PASS") };
+        var b = [ ...a ];
+    }
+    expect: {
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_5463: {
+    options = {
+        collapse_vars: true,
+        conditionals: true,
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unsafe: true,
+    }
+    input: {
+        if (console.log("PASS"))
+            var a = void 0,
+                b = void 0,
+                b = ([ a = FAIL ] = b && b);
+    }
+    expect: {
+        var a, b, b;
+        console.log("PASS") && (
+            b = a = void 0,
+            b = [a = FAIL] = a && a
+        );
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_5465: {
+    options = {
+        inline: true,
+        merge_vars: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f(a, b) {
+            (function(c = b = "FAIL 2") {
+                this && console.log(b || "PASS");
+            })(42 - a && a);
+        }
+        f("FAIL 1");
+    }
+    expect: {
+        a = "FAIL 1",
+        void function(c = b = "FAIL 2") {
+            this && console.log(b || "PASS");
+        }(42 - a && a);
+        var a, b;
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_5485: {
+    options = {
+        comparisons: true,
+    }
+    input: {
+        (function f(f, a = console.log(void 0 === f ? "PASS" : "FAIL")) {})();
+    }
+    expect: {
+        (function f(f, a = console.log(void 0 === f ? "PASS" : "FAIL")) {})();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}

test/compress/destructured.js

@@ -1848,8 +1848,8 @@ issue_4294: {
             }) {}({
                 [a]: 0,
             });
-            var a = A;
+            var b = A;
-            console.log(a);
+            console.log(b);
         })();
     }
     expect_stdout: "PASS"
@@ -3020,6 +3020,7 @@ issue_5074_method_pure_getters: {
 issue_5085_1: {
     options = {
         evaluate: true,
+        passes: 2,
         reduce_vars: true,
         toplevel: true,
         unsafe: true,
@@ -3032,8 +3033,7 @@ issue_5085_1: {
     }
     expect: {
         var a = "PASS";
-        var b = [ 42 ][0];
+        42;
-        b;
         console.log(a);
     }
     expect_stdout: "PASS"
@@ -3043,6 +3043,7 @@ issue_5085_1: {
 issue_5085_2: {
     options = {
         evaluate: true,
+        passes: 2,
         reduce_vars: true,
         side_effects: true,
         unsafe: true,
@@ -3059,7 +3060,7 @@ issue_5085_2: {
     expect: {
         var a = "PASS";
         (function(b) {
-            b = [ 42 ][0];
+            0;
         })();
         console.log(a);
     }
@@ -3400,7 +3401,7 @@ issue_5222: {
     node_version: ">=6"
 }
 
-issue_5288: {
+issue_5288_1: {
     options = {
         conditionals: true,
         inline: true,
@@ -3420,7 +3421,37 @@ issue_5288: {
         }() ]));
     }
     expect: {
-        while (console ? console.log("PASS") : 0, void 0);
+        while (function() {
+            if (console)
+                console.log("PASS");
+        }(), void 0);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_5288_2: {
+    options = {
+        conditionals: true,
+        inline: true,
+        keep_fargs: false,
+        passes: 2,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+        varify: true,
+    }
+    input: {
+        while (function([]) {}([ function f() {
+            if (console)
+                return console.log("PASS");
+            else {
+                let a = 0;
+            }
+        }() ]));
+    }
+    expect: {
+        while (console && console.log("PASS"), void 0);
     }
     expect_stdout: "PASS"
     node_version: ">=6"
@@ -3497,3 +3528,121 @@ issue_5370: {
     expect_stdout: true
     node_version: ">=6"
 }
+
+issue_5405_1: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unsafe: true,
+    }
+    input: {
+        var [ a ] = [ {} ];
+        console.log(a === a ? "PASS" : "FAIL");
+    }
+    expect: {
+        var [ a ] = [ {} ];
+        console.log(true ? "PASS" : "FAIL");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_5405_2: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unsafe: true,
+    }
+    input: {
+        var { p: a } = { p: [] };
+        console.log(a === a ? "PASS" : "FAIL");
+    }
+    expect: {
+        var { p: a } = { p: [] };
+        console.log(true ? "PASS" : "FAIL");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_5423: {
+    options = {
+        merge_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var a, b;
+        function f({
+            [function() {
+                if (++a)
+                    return 42;
+            }()]: c
+        }) {}
+        f(b = f);
+        console.log(typeof b);
+    }
+    expect: {
+        var a, b;
+        function f({
+            [function() {
+                if (++a)
+                    return 42;
+            }()]: c
+        }) {}
+        f(b = f);
+        console.log(typeof b);
+    }
+    expect_stdout: "function"
+    node_version: ">=6"
+}
+
+issue_5454: {
+    options = {
+        hoist_props: true,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f(a) {
+            var a = 42, a = {
+                p: [ a ] = [],
+            };
+            return "PASS";
+        }
+        console.log(f());
+    }
+    expect: {
+        console.log(function(a) {
+            a = 42, a = {
+                p: [ a ] = [],
+            };
+            return "PASS";
+        }());
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_5485: {
+    options = {
+        comparisons: true,
+    }
+    input: {
+        (function f({
+            p: f,
+            [console.log(void 0 === f ? "PASS" : "FAIL")]: a,
+        }) {})(42);
+    }
+    expect: {
+        (function f({
+            p: f,
+            [console.log(void 0 === f ? "PASS" : "FAIL")]: a,
+        }) {})(42);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}

test/compress/evaluate.js

@@ -3349,3 +3349,30 @@ issue_5362_2: {
     }
     expect_stdout: "true"
 }
+
+issue_5380: {
+    options = {
+        evaluate: true,
+        keep_fnames: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = function f(b) {
+            return function g() {
+                for (b in { PASS: 42 });
+            }(), b;
+        }("FAIL");
+        console.log(a);
+    }
+    expect: {
+        var a = function f(b) {
+            return function g() {
+                for (b in { PASS: 42 });
+            }(), b;
+        }("FAIL");
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+}

test/compress/exports.js

@@ -496,3 +496,16 @@ issue_4766: {
         export var a = "bar";
     }
 }
+
+issue_5444: {
+    options = {
+        unused: true,
+    }
+    input: {
+        export var a = (console, console);
+    }
+    expect: {
+        console;
+        export var a = console;
+    }
+}

test/compress/functions.js

@@ -3557,6 +3557,27 @@ functions_inner_var: {
     expect_stdout: "undefined undefined"
 }
 
+functions_keep_fnames: {
+    options = {
+        functions: true,
+        keep_fnames: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var FAIL = function PASS() {};
+        FAIL.p = 42;
+        console.log(FAIL.name, FAIL.p);
+    }
+    expect: {
+        var FAIL = function PASS() {};
+        FAIL.p = 42;
+        console.log(FAIL.name, FAIL.p);
+    }
+    expect_stdout: "PASS 42"
+}
+
 issue_2437: {
     options = {
         collapse_vars: true,
@@ -8329,3 +8350,299 @@ issue_5376_2: {
     }
     expect_stdout: Error("PASS")
 }
+
+issue_5401: {
+    options = {
+        inline: true,
+    }
+    input: {
+        L: for (var a in function() {
+            while (console.log("PASS"));
+        }(), a) do {
+            continue L;
+        } while (console.log("FAIL"));
+    }
+    expect: {
+        while (console.log("PASS"));
+        L: for (var a in a) do {
+            continue L;
+        } while (console.log("FAIL"));
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5409: {
+    options = {
+        inline: true,
+        merge_vars: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        (function(a) {
+            (a = console) || FAIL(a);
+            (function(b) {
+                console.log(b && b);
+                while (!console);
+            })();
+        })();
+    }
+    expect: {
+        (function(a) {
+            (a = console) || FAIL(a);
+            a = void 0;
+            console.log(a && a);
+            while (!console);
+            return;
+        })();
+    }
+    expect_stdout: "undefined"
+}
+
+mixed_mode_inline_1: {
+    options = {
+        directives: true,
+        inline: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            return this;
+        }
+        console.log(function() {
+            return f();
+        }() ? "PASS" : "FAIL");
+    }
+    expect: {
+        console.log(function() {
+            return this;
+        }() ? "PASS" : "FAIL");
+    }
+    expect_stdout: "PASS"
+}
+
+mixed_mode_inline_1_strict: {
+    options = {
+        directives: true,
+        inline: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        function f() {
+            return this;
+        }
+        console.log(function() {
+            return f();
+        }() ? "FAIL" : "PASS");
+    }
+    expect: {
+        "use strict";
+        console.log(function() {
+            return this;
+        }() ? "FAIL" : "PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+mixed_mode_inline_2: {
+    options = {
+        directives: true,
+        inline: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            "use strict";
+            return this;
+        }
+        console.log(function() {
+            return f();
+        }() ? "FAIL" : "PASS");
+    }
+    expect: {
+        console.log(function() {
+            "use strict";
+            return this;
+        }() ? "FAIL" : "PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+mixed_mode_inline_2_strict: {
+    options = {
+        directives: true,
+        inline: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        function f() {
+            "use strict";
+            return this;
+        }
+        console.log(function() {
+            return f();
+        }() ? "FAIL" : "PASS");
+    }
+    expect: {
+        "use strict";
+        console.log(function() {
+            return this;
+        }() ? "FAIL" : "PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+mixed_mode_inline_3: {
+    options = {
+        directives: true,
+        inline: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            return this;
+        }
+        console.log(function() {
+            "use strict";
+            return f();
+        }() ? "PASS" : "FAIL");
+    }
+    expect: {
+        function f() {
+            return this;
+        }
+        console.log(function() {
+            "use strict";
+            return f();
+        }() ? "PASS" : "FAIL");
+    }
+    expect_stdout: "PASS"
+}
+
+mixed_mode_inline_3_strict: {
+    options = {
+        directives: true,
+        inline: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        function f() {
+            return this;
+        }
+        console.log(function() {
+            "use strict";
+            return f();
+        }() ? "FAIL" : "PASS");
+    }
+    expect: {
+        "use strict";
+        console.log(function() {
+            return this;
+        }() ? "FAIL" : "PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+mixed_mode_inline_4: {
+    options = {
+        directives: true,
+        inline: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            "use strict";
+            return this;
+        }
+        console.log(function() {
+            "use strict";
+            return f();
+        }() ? "FAIL" : "PASS");
+    }
+    expect: {
+        console.log(function() {
+            "use strict";
+            return function() {
+                "use strict";
+                return this;
+            }();
+        }() ? "FAIL" : "PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+mixed_mode_inline_4_strict: {
+    options = {
+        directives: true,
+        inline: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        function f() {
+            "use strict";
+            return this;
+        }
+        console.log(function() {
+            "use strict";
+            return f();
+        }() ? "FAIL" : "PASS");
+    }
+    expect: {
+        "use strict";
+        console.log(function() {
+            return this;
+        }() ? "FAIL" : "PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+module_inline: {
+    options = {
+        inline: true,
+        module: true,
+        reduce_vars: true,
+    }
+    input: {
+        var a = f;
+        function f() {
+            return a;
+        }
+        console.log(f() === a);
+    }
+    expect: {
+        var a = f;
+        function f() {
+            return a;
+        }
+        console.log(a === a);
+    }
+    expect_stdout: "true"
+}

test/compress/hoist_props.js

@@ -1176,3 +1176,30 @@ issue_5182: {
         "42",
     ]
 }
+
+issue_5441: {
+    options = {
+        hoist_props: true,
+        passes: 2,
+        reduce_vars: true,
+        side_effects: true,
+    }
+    input: {
+        console.log(function(a) {
+            (function() {
+                a = { p: this };
+            })();
+            return typeof a;
+        }());
+    }
+    expect: {
+        console.log(function(a) {
+            (function() {
+                a_p = this;
+            })();
+            var a_p;
+            return typeof {};
+        }());
+    }
+    expect_stdout: "object"
+}

test/compress/hoist_vars.js

@@ -224,8 +224,7 @@ issue_4489: {
         console.log(k);
     }
     expect: {
-        !(A = 0);
+        for (var k in !(A = 0));
-        for (var k in true);
         console.log(k);
     }
     expect_stdout: "undefined"
@@ -407,9 +406,9 @@ issue_4893_2: {
     expect: {
         try{
             (function() {
-                var b;
+                var a;
-                b = null;
+                a = null;
-                b.p += 42;
+                a.p += 42;
             })();
         } catch (e) {
             console.log("PASS");
@@ -530,3 +529,77 @@ issue_5378: {
         "undefined",
     ]
 }
+
+issue_5411_1: {
+    options = {
+        collapse_vars: true,
+        dead_code: true,
+        hoist_vars: true,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+    }
+    input: {
+        var a = "PASS";
+        b++;
+        b = a;
+        var b = b, c = c && c[b];
+        console.log(b);
+    }
+    expect: {
+        var b, c, a = "PASS";
+        b++;
+        b = a;
+        c = c && c[b];
+        console.log(b);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5411_2: {
+    options = {
+        collapse_vars: true,
+        dead_code: true,
+        evaluate: true,
+        hoist_vars: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = "PASS";
+        b++;
+        b = a;
+        var b = b, c = c && c[b];
+        console.log(b);
+    }
+    expect: {
+        var b, c;
+        b++;
+        b = "PASS",
+        c = c && c[b];
+        console.log(b);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5411_3: {
+    options = {
+        collapse_vars: true,
+        hoist_vars: true,
+        reduce_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var a = console;
+        a++;
+        var a = A = a;
+        console.log(A);
+    }
+    expect: {
+        var a = console;
+        a = A = ++a;
+        console.log(A);
+    }
+    expect_stdout: "NaN"
+}

test/compress/keep_fargs.js

@@ -1258,8 +1258,7 @@ issues_3267_1: {
     }
     expect: {
         !function() {
-            var i = Object();
+            if (Object())
-            if (i)
                 return console.log("PASS");
             throw "FAIL";
         }();

test/compress/let.js

@@ -1604,48 +1604,6 @@ issue_4305_2: {
     node_version: ">=4"
 }
 
-issue_1753: {
-    mangle = {
-        toplevel: false,
-        webkit: true,
-    }
-    input: {
-        "use strict";
-        let l = null;
-        for (let i = 0; i < 1; i++)
-            console.log(i);
-    }
-    expect: {
-        "use strict";
-        let l = null;
-        for (let i = 0; i < 1; i++)
-            console.log(i);
-    }
-    expect_stdout: "0"
-    node_version: ">=4"
-}
-
-issue_1753_toplevel: {
-    mangle = {
-        toplevel: true,
-        webkit: true,
-    }
-    input: {
-        "use strict";
-        let l = null;
-        for (let i = 0; i < 1; i++)
-            console.log(i);
-    }
-    expect: {
-        "use strict";
-        let l = null;
-        for (let e = 0; e < 1; e++)
-            console.log(e);
-    }
-    expect_stdout: "0"
-    node_version: ">=4"
-}
-
 issue_4438: {
     options = {
         if_return: true,
@@ -2020,3 +1978,23 @@ issue_5338: {
     expect_stdout: ReferenceError("a is not defined")
     node_version: ">=4"
 }
+
+issue_5476: {
+    mangle = {
+        keep_fargs: true,
+    }
+    input: {
+        "use strict";
+        console.log(function(n) {
+            let a;
+        }());
+    }
+    expect: {
+        "use strict";
+        console.log(function(n) {
+            let o;
+        }());
+    }
+    expect_stdout: "undefined"
+    node_version: ">=4"
+}

test/compress/merge_vars.js

@@ -3702,3 +3702,146 @@ issue_5182: {
     ]
     node_version: ">=4"
 }
+
+issue_5420: {
+    options = {
+        merge_vars: true,
+        toplevel: true,
+    }
+    input: {
+        do {
+            var a = "FAIL 1";
+            a && a.p;
+            a = "FAIL 2";
+            try {
+                continue;
+            } catch (e) {}
+            var b = "FAIL 3";
+        } while (console.log(b || "PASS"));
+    }
+    expect: {
+        do {
+            var a = "FAIL 1";
+            a && a.p;
+            a = "FAIL 2";
+            try {
+                continue;
+            } catch (e) {}
+            var b = "FAIL 3";
+        } while (console.log(b || "PASS"));
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5451: {
+    options = {
+        merge_vars: true,
+        toplevel: true,
+    }
+    input: {
+        A = 1;
+        var a = 1, b;
+        console.log(function f() {
+            return a-- && f(b = A, b);
+        }());
+    }
+    expect: {
+        A = 1;
+        var a = 1, b;
+        console.log(function f() {
+            return a-- && f(b = A, b);
+        }());
+    }
+    expect_stdout: "0"
+}
+
+issue_5471_1: {
+    options = {
+        conditionals: true,
+        inline: true,
+        merge_vars: true,
+        reduce_vars: true,
+        sequences: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = "FAIL 1";
+        function f(b, c) {
+            function g() {
+                if (console)
+                    return 42;
+                else
+                    c = "FAIL 2";
+            }
+            var d = g();
+            console.log(c || "PASS");
+            var e = function h() {
+                while (b && e);
+            }();
+        }
+        f(a++) && a;
+    }
+    expect: {
+        var a = "FAIL 1";
+        var b, c, e;
+        b = +a,
+        function() {
+            if (console)
+                return;
+            c = "FAIL 2";
+        }(),
+        console.log(c || "PASS"),
+        e = function() {
+            while (b && e);
+        }();
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5471_2: {
+    options = {
+        conditionals: true,
+        evaluate: true,
+        inline: true,
+        merge_vars: true,
+        reduce_vars: true,
+        sequences: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = "FAIL 1";
+        function f(b, c) {
+            function g() {
+                if (console)
+                    return 42;
+                else
+                    c = "FAIL 2";
+            }
+            var d = g();
+            console.log(c || "PASS");
+            var e = function h() {
+                while (b && e);
+            }();
+        }
+        f(a++) && a;
+    }
+    expect: {
+        var a = "FAIL 1";
+        var b, c, e;
+        b = +a,
+        function() {
+            if (console)
+                return;
+            c = "FAIL 2";
+        }(),
+        console.log(c || "PASS"),
+        e = function() {
+            while (b && e);
+        }(),
+        void 0;
+    }
+    expect_stdout: "PASS"
+}

test/compress/reduce_vars.js

@@ -6689,8 +6689,7 @@ issues_3267_1: {
     }
     expect: {
         !function(x) {
-            var i = Object();
+            if (Object())
-            if (i)
                 return console.log("PASS");
             throw "FAIL";
         }();
@@ -7862,3 +7861,38 @@ issue_5324: {
     }
     expect_stdout: "NaN"
 }
+
+issue_5434: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        console.log(function(a) {
+            for (var i = 0; i < 2; i++) {
+                var b = "FAIL";
+                f && f();
+                a = b;
+                var f = function() {
+                    b = "PASS";
+                };
+            }
+            return a;
+        }());
+    }
+    expect: {
+        console.log(function(a) {
+            for (var i = 0; i < 2; i++) {
+                var b = "FAIL";
+                f && f();
+                a = b;
+                var f = function() {
+                    b = "PASS";
+                };
+            }
+            return a;
+        }());
+    }
+    expect_stdout: "PASS"
+}

test/compress/rests.js

@@ -1323,3 +1323,43 @@ issue_5370: {
     expect_stdout: true
     node_version: ">=6"
 }
+
+issue_5391: {
+    options = {
+        evaluate: true,
+        keep_fargs: false,
+        objects: true,
+        pure_getters: "strict",
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a, b = function f({
+            p: {},
+            ...c
+        }) {
+            while (c.q);
+        }({
+            p: {
+                r: a++,
+                r: 0,
+            }
+        });
+        console.log(a);
+    }
+    expect: {
+        (function({
+            p: {},
+            ...c
+        }) {
+            while (c.q);
+        })({
+            p: 0,
+        });
+        console.log(NaN);
+    }
+    expect_stdout: "NaN"
+    node_version: ">=8.3.0"
+}

test/compress/spreads.js

@@ -1166,3 +1166,31 @@ issue_5006: {
     expect_stdout: "PASS"
     node_version: ">=6"
 }
+
+issue_5382: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        ({
+            f() {
+                ({ ...this });
+            },
+            get p() {
+                console.log("PASS");
+            },
+        }).f();
+    }
+    expect: {
+        ({
+            f() {
+                ({ ...this });
+            },
+            get p() {
+                console.log("PASS");
+            },
+        }).f();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=8.3.0"
+}

test/compress/varify.js

@@ -111,7 +111,7 @@ hoist_props_const: {
         }
     }
     expect: {
-        var o = 0, o_p = "PASS";
+        var o, o_p = "PASS";
         console.log(o_p);
     }
     expect_stdout: "PASS"

test/compress/webkit.js

@@ -107,3 +107,209 @@ function_name_mangle_ie8: {
     expect_exact: "(function(){console.log(typeof function n(o){})})();"
     expect_stdout: "function"
 }
+
+issue_1753: {
+    mangle = {
+        toplevel: false,
+        webkit: true,
+    }
+    input: {
+        "use strict";
+        let l = null;
+        for (let i = 0; i < 1; i++)
+            console.log(i);
+    }
+    expect: {
+        "use strict";
+        let l = null;
+        for (let i = 0; i < 1; i++)
+            console.log(i);
+    }
+    expect_stdout: "0"
+    node_version: ">=4"
+}
+
+issue_1753_toplevel: {
+    mangle = {
+        toplevel: true,
+        webkit: true,
+    }
+    input: {
+        "use strict";
+        let l = null;
+        for (let i = 0; i < 1; i++)
+            console.log(i);
+    }
+    expect: {
+        "use strict";
+        let l = null;
+        for (let e = 0; e < 1; e++)
+            console.log(e);
+    }
+    expect_stdout: "0"
+    node_version: ">=4"
+}
+
+issue_5032_await: {
+    options = {
+        merge_vars: true,
+        webkit: false,
+    }
+    input: {
+        function log(value) {
+            console.log(value);
+            return value;
+        }
+        async function f(a) {
+            var b = log(a), c = b;
+            log(b);
+            log(c);
+        }
+        f("PASS");
+    }
+    expect: {
+        function log(value) {
+            console.log(value);
+            return value;
+        }
+        async function f(a) {
+            var a = log(a), c = a;
+            log(a);
+            log(c);
+        }
+        f("PASS");
+    }
+    expect_stdout: [
+        "PASS",
+        "PASS",
+        "PASS",
+    ]
+    node_version: ">=8"
+}
+
+issue_5032_await_webkit: {
+    options = {
+        merge_vars: true,
+        webkit: true,
+    }
+    input: {
+        function log(value) {
+            console.log(value);
+            return value;
+        }
+        async function f(a) {
+            var b = log(a), c = b;
+            log(b);
+            log(c);
+        }
+        f("PASS");
+    }
+    expect: {
+        function log(value) {
+            console.log(value);
+            return value;
+        }
+        async function f(a) {
+            var b = log(a), c = b;
+            log(b);
+            log(c);
+        }
+        f("PASS");
+    }
+    expect_stdout: [
+        "PASS",
+        "PASS",
+        "PASS",
+    ]
+    node_version: ">=8"
+}
+
+issue_5032_yield: {
+    options = {
+        merge_vars: true,
+        webkit: false,
+    }
+    input: {
+        function log(value) {
+            console.log(value);
+            return value;
+        }
+        function *f(a) {
+            var b = log(a), c = b;
+            log(b);
+            log(c);
+        }
+        f("PASS").next();
+    }
+    expect: {
+        function log(value) {
+            console.log(value);
+            return value;
+        }
+        function *f(a) {
+            var a = log(a), c = a;
+            log(a);
+            log(c);
+        }
+        f("PASS").next();
+    }
+    expect_stdout: [
+        "PASS",
+        "PASS",
+        "PASS",
+    ]
+    node_version: ">=4"
+}
+
+issue_5032_yield_webkit: {
+    options = {
+        merge_vars: true,
+        webkit: true,
+    }
+    input: {
+        function log(value) {
+            console.log(value);
+            return value;
+        }
+        function *f(a) {
+            var b = log(a), c = b;
+            log(b);
+            log(c);
+        }
+        f("PASS").next();
+    }
+    expect: {
+        function log(value) {
+            console.log(value);
+            return value;
+        }
+        function *f(a) {
+            var b = log(a), c = b;
+            log(b);
+            log(c);
+        }
+        f("PASS").next();
+    }
+    expect_stdout: [
+        "PASS",
+        "PASS",
+        "PASS",
+    ]
+    node_version: ">=4"
+}
+
+issue_5480: {
+    mangle = {
+        webkit: true,
+    }
+    input: {
+        "use strict";
+        L: for (let a in console.log("PASS"));
+    }
+    expect: {
+        "use strict";
+        o: for (let o in console.log("PASS"));
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}

test/compress/yields.js

@@ -978,8 +978,8 @@ issue_4454_2: {
     expect: {
         function f(a) {
             (function*(c = console.log(a)) {})();
-            var a = 42..toString();
+            var b = 42..toString();
-            console.log(a);
+            console.log(b);
         }
         f("PASS");
     }
@@ -1267,80 +1267,6 @@ issue_5019_2: {
     node_version: ">=4"
 }
 
-issue_5032_normal: {
-    options = {
-        merge_vars: true,
-        webkit: false,
-    }
-    input: {
-        function log(value) {
-            console.log(value);
-            return value;
-        }
-        function *f(a) {
-            var b = log(a), c = b;
-            log(b);
-            log(c);
-        }
-        f("PASS").next();
-    }
-    expect: {
-        function log(value) {
-            console.log(value);
-            return value;
-        }
-        function *f(a) {
-            var a = log(a), c = a;
-            log(a);
-            log(c);
-        }
-        f("PASS").next();
-    }
-    expect_stdout: [
-        "PASS",
-        "PASS",
-        "PASS",
-    ]
-    node_version: ">=4"
-}
-
-issue_5032_webkit: {
-    options = {
-        merge_vars: true,
-        webkit: true,
-    }
-    input: {
-        function log(value) {
-            console.log(value);
-            return value;
-        }
-        function *f(a) {
-            var b = log(a), c = b;
-            log(b);
-            log(c);
-        }
-        f("PASS").next();
-    }
-    expect: {
-        function log(value) {
-            console.log(value);
-            return value;
-        }
-        function *f(a) {
-            var b = log(a), c = b;
-            log(b);
-            log(c);
-        }
-        f("PASS").next();
-    }
-    expect_stdout: [
-        "PASS",
-        "PASS",
-        "PASS",
-    ]
-    node_version: ">=4"
-}
-
 issue_5034: {
     options = {
         functions: true,
@@ -1451,3 +1377,141 @@ issue_5177: {
     expect_stdout: "function"
     node_version: ">=4"
 }
+
+issue_5385_1: {
+    options = {
+        inline: true,
+    }
+    input: {
+        (async function*() {
+            (function() {
+                try {
+                    return console.log("foo");
+                } finally {
+                    return console.log("bar");
+                }
+                console.log("baz");
+            })();
+        })().next();
+        console.log("moo");
+    }
+    expect: {
+        (async function*() {
+            (function() {
+                try {
+                    return console.log("foo");
+                } finally {
+                    return console.log("bar");
+                }
+                console.log("baz");
+            })();
+        })().next();
+        console.log("moo");
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+        "moo",
+    ]
+    node_version: ">=10"
+}
+
+issue_5385_2: {
+    options = {
+        inline: true,
+    }
+    input: {
+        (async function*() {
+            return function() {
+                try {
+                    return console.log("foo");
+                } finally {
+                    return console.log("bar");
+                }
+            }();
+        })().next();
+        console.log("moo");
+    }
+    expect: {
+        (async function*() {
+            return function() {
+                try {
+                    return console.log("foo");
+                } finally {
+                    return console.log("bar");
+                }
+            }();
+        })().next();
+        console.log("moo");
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+        "moo",
+    ]
+    node_version: ">=10"
+}
+
+issue_5425: {
+    options = {
+        assignments: true,
+        ie: true,
+        toplevel: true,
+        unused: true,
+        yields: true,
+    }
+    input: {
+        var a = "FAIL";
+        var b = function* f() {}(a ? a = "PASS" : 42);
+        console.log(a, typeof f);
+    }
+    expect: {
+        var a = "FAIL";
+        (function* f() {})(a && (a = "PASS"));
+        console.log(a, typeof f);
+    }
+    expect_stdout: "PASS undefined"
+    node_version: ">=4"
+}
+
+issue_5456: {
+    options = {
+        inline: true,
+        merge_vars: true,
+    }
+    input: {
+        var a = true;
+        (function() {
+            (function(b, c) {
+                var d = function*() {
+                    c = null;
+                }();
+                var e = function() {
+                    if (c)
+                        console.log(typeof d);
+                    while (b);
+                }();
+            })(function(i) {
+                return console.log("foo") && i;
+            }(a));
+        })();
+    }
+    expect: {
+        var a = true;
+        (function() {
+            b = (i = a, console.log("foo") && i),
+            d = function*() {
+                c = null;
+            }(),
+            e = function() {
+                if (c) console.log(typeof d);
+                while (b);
+            }(),
+            void 0;
+            var b, c, d, e;
+            var i;
+        })();
+    }
+    expect_stdout: "foo"
+    node_version: ">=4"
+}

test/input/module/expect.js

@@ -0,0 +1 @@
+function n(){return this||arguments[0]+arguments[1]}function o(){return this||arguments[0]+arguments[1]}console.log(n(n(1,3),5)),console.log(o(o(2,4),6));

test/input/module/input.js

@@ -0,0 +1,13 @@
+console.log(function() {
+    function sum(...params) {
+        return this || arguments[0] + arguments[1];
+    }
+    return sum(sum(1, 3), 5);
+}());
+console.log(function() {
+    "use strict";
+    function sum(...params) {
+        return this || arguments[0] + arguments[1];
+    }
+    return sum(sum(2, 4), 6);
+}());

test/mocha/cli.js

@@ -928,6 +928,14 @@ describe("bin/uglifyjs", function() {
             done();
         });
     });
+    it("Should work with --module", function(done) {
+        var command = uglifyjscmd + " test/input/module/input.js --module -mc";
+        exec(command, function(err, stdout, stderr) {
+            if (err) throw err;
+            assert.strictEqual(stdout, read("test/input/module/expect.js"));
+            done();
+        });
+    });
     it("Should compress swarm of unused variables with reasonable performance", function(done) {
         var code = [
             "console.log(function() {",

test/mocha/reduce.js

@@ -434,7 +434,7 @@ describe("test/reduce.js", function() {
             "// }",
         ].join("\n"));
     });
-    it("Should transform `export default` correctly", function() {
+    it("Should transform `export default class` correctly", function() {
         var result = reduce_test(read("test/input/reduce/export_default.js"), {
             compress: false,
             toplevel: true,
@@ -448,4 +448,41 @@ describe("test/reduce.js", function() {
             "// }",
         ].join("\n"));
     });
+    it("Should transform `export default function` correctly", function() {
+        var code = [
+            "for (var k in this)",
+            "    console.log(k);",
+            "export default (function f() {});",
+            "console.log(k);",
+        ].join("\n");
+        var result = reduce_test(code, {
+            mangle: false,
+        });
+        if (result.error) throw result.error;
+        assert.strictEqual(result.code, [
+            "// Can't reproduce test failure",
+            "// minify options: {",
+            '//   "mangle": false',
+            "// }",
+        ].join("\n"));
+    });
+    it("Should transform `export default (42)` correctly", function() {
+        var code = [
+            "export default (42);",
+            "for (var k in this)",
+            "    console.log(k);",
+        ].join("\n");
+        var result = reduce_test(code, {
+            compress: false,
+            mangle: false,
+        });
+        if (result.error) throw result.error;
+        assert.strictEqual(result.code, [
+            "// Can't reproduce test failure",
+            "// minify options: {",
+            '//   "compress": false,',
+            '//   "mangle": false',
+            "// }",
+        ].join("\n"));
+    });
 });

test/reduce.js

@@ -210,10 +210,10 @@ module.exports = function reduce_test(testcase, minify_options, reduce_options)
             }
             if (node.expression instanceof U.AST_Function) {
                 // hoist and return expressions from the IIFE function expression
-                var seq = [];
+                var scope = tt.find_parent(U.AST_Scope), seq = [];
                 node.expression.body.forEach(function(node) {
                     var expr = node instanceof U.AST_Exit ? node.value : node.body;
-                    if (expr instanceof U.AST_Node && !U.is_statement(expr) && can_hoist(expr)) {
+                    if (expr instanceof U.AST_Node && !U.is_statement(expr) && can_hoist(expr, scope)) {
                         // collect expressions from each statement's body
                         seq.push(expr);
                     }
@@ -264,11 +264,12 @@ module.exports = function reduce_test(testcase, minify_options, reduce_options)
                 CHANGED = true;
                 return List.skip;
               default:
-                if (!has_exit(node) && can_hoist(node)) {
+                if (can_hoist(node, tt.find_parent(U.AST_Scope))) {
                     // hoist function declaration body
                     var body = node.body;
                     node.body = [];
-                    body.push(node); // retain function with empty body to be dropped later
+                    // retain function with empty body to be dropped later
+                    body.push(node);
                     CHANGED = true;
                     return List.splice(body);
                 }
@@ -382,7 +383,7 @@ module.exports = function reduce_test(testcase, minify_options, reduce_options)
             if (node.body instanceof U.AST_Call && node.body.expression instanceof U.AST_Function) {
                 // hoist simple statement IIFE function expression body
                 node.start._permute++;
-                if (!has_exit(node.body.expression) && can_hoist(node.body.expression)) {
+                if (can_hoist(node.body.expression, tt.find_parent(U.AST_Scope))) {
                     CHANGED = true;
                     return List.splice(node.body.expression.body);
                 }
@@ -647,21 +648,6 @@ function trim_trailing_whitespace(value) {
     return ("" + value).replace(/\s+$/, "");
 }
 
-function has_exit(fn) {
-    var found = false;
-    var tw = new U.TreeWalker(function(node) {
-        if (found) return found;
-        if (node instanceof U.AST_Exit) {
-            return found = true;
-        }
-        if (node instanceof U.AST_Scope && node !== fn) {
-            return true; // don't descend into nested functions
-        }
-    });
-    fn.walk(tw);
-    return found;
-}
-
 function has_loopcontrol(body, loop, label) {
     var found = false;
     var tw = new U.TreeWalker(function(node) {
@@ -676,17 +662,31 @@ function has_loopcontrol(body, loop, label) {
     return found;
 }
 
-function can_hoist(body) {
+function can_hoist(body, scope) {
     var found = false;
-    body.walk(new U.TreeWalker(function(node) {
+    var tw = new U.TreeWalker(function(node) {
         if (found) return true;
+        if (node instanceof U.AST_Exit) return found = true;
         if (node instanceof U.AST_NewTarget) return found = true;
         if (node instanceof U.AST_Scope) {
             if (node === body) return;
+            if (node instanceof U.AST_Arrow || node instanceof U.AST_AsyncArrow) node.argnames.forEach(function(sym) {
+                sym.walk(tw);
+            });
+            // don't descend into nested functions
             return true;
         }
         if (node instanceof U.AST_Super) return found = true;
-    }));
+        if (node instanceof U.AST_SymbolDeclaration || node instanceof U.AST_SymbolRef) switch (node.name) {
+          case "await":
+            if (/^Async/.test(scope.TYPE)) return found = true;
+            return;
+          case "yield":
+            if (/Generator/.test(scope.TYPE)) return found = true;
+            return;
+        }
+    });
+    body.walk(tw);
     return !found;
 }
 

test/release/web-tooling-benchmark.sh

@@ -54,7 +54,7 @@ ERR=$?; if [ "$ERR" != "0" ]; then echo "Error: $ERR"; exit $ERR; fi
 minify_in_situ "src" \
 && minify_in_situ "third_party" \
 && rm -rf node_modules \
-&& npm_install \
+&& npm_install --package-lock \
 && rm -rf build/* \
 && npm run build:terser-bundled \
 && npm run build:uglify-js-bundled \

test/sandbox.js

@@ -52,12 +52,17 @@ exports.same_stdout = semver.satisfies(process.version, "0.12") ? function(expec
     return typeof expected == typeof actual && strip_func_ids(expected) == strip_func_ids(actual);
 };
 exports.patch_module_statements = function(code) {
-    var count = 0, imports = [];
+    var count = 0, has_default = "", imports = [], strict_mode = "";
-    code = code.replace(/\bexport(?:\s*\{[^{}]*}\s*?(?:$|\n|;)|\s+default\b(?:\s*(\(|\{|class\s*\{|class\s+(?=extends\b)|(?:async\s+)?function\s*(?:\*\s*)?\())?|\b)/g, function(match, header) {
+    code = code.replace(/^\s*("|')use strict\1\s*;?/, function(match) {
+        strict_mode = match;
+        return "";
+    }).replace(/\bexport(?:\s*\{[^{}]*}\s*?(?:$|\n|;)|\s+default\b(?:\s*(\(|\{|class\s*\{|class\s+(?=extends\b)|(?:async\s+)?function\s*(?:\*\s*)?\())?|\b)/g, function(match, header) {
+        if (/^export\s+default/.test(match)) has_default = "var _uglify_export_default_;";
         if (!header) return "";
         if (header.length == 1) return "0, " + header;
-        do {
+        var name = "_uglify_export_default_";
-            var name = "_export_default_" + ++count;
+        if (/^class\b/.test(header)) do {
+            name = "_uglify_export_default_" + ++count;
         } while (code.indexOf(name) >= 0);
         return header.slice(0, -1) + " " + name + header.slice(-1);
     }).replace(/\bimport\.meta\b/g, function() {
@@ -76,7 +81,7 @@ exports.patch_module_statements = function(code) {
         return "";
     });
     imports.push("");
-    return imports.join("\n") + code;
+    return strict_mode + has_default + imports.join("\n") + code;
 };
 
 function is_error(result) {

test/ufuzz/index.js

@@ -128,7 +128,7 @@ for (var i = 2; i < process.argv.length; ++i) {
 
 var SUPPORT = function(matrix) {
     for (var name in matrix) {
-        matrix[name] = typeof sandbox.run_code(matrix[name]) == "string";
+        matrix[name] = !sandbox.is_error(sandbox.run_code(matrix[name]));
     }
     return matrix;
 }({
@@ -1805,7 +1805,7 @@ function createClassLiteral(recurmax, stmtDepth, canThrow, name) {
         if (canThrow && rng(20) == 0) {
             s += p;
         } else {
-            s += "(" + p + " && " + p + ".constructor === Function ? " + p + " : function() {})";
+            s += "(typeof " + p + ' == "function" && typeof ' + p + '.prototype == "object" && ' + p + ".constructor === Function ? " + p + " : function() {})";
         }
     }
     s += " {\n";
@@ -1824,9 +1824,15 @@ function createClassLiteral(recurmax, stmtDepth, canThrow, name) {
             declared.push(internal);
         }
         if (SUPPORT.class_field && rng(2)) {
-            s += internal || createObjectKey(recurmax, stmtDepth, canThrow);
+            if (internal) {
+                s += internal;
+            } else if (fixed && bug_class_static_nontrivial) {
+                s += getDotKey();
+            } else {
+                s += createObjectKey(recurmax, stmtDepth, canThrow);
+            }
             if (rng(5)) {
-                async = bug_async_class_await && fixed && 0;
+                async = false;
                 generator = false;
                 s += " = " + createExpression(recurmax, NO_COMMA, stmtDepth, fixed ? canThrow : CANNOT_THROW);
                 generator = save_generator;
@@ -2031,7 +2037,7 @@ function isBannedKeyword(name) {
       case "let":
         return in_class;
       case "await":
-        return async !== false;
+        return async || in_class && bug_class_static_await;
       case "yield":
         return generator || in_class;
     }
@@ -2110,7 +2116,7 @@ function try_beautify(code, toplevel, result, printfn, options) {
     } else if (options) {
         var uglified = UglifyJS.minify(beautified.code, JSON.parse(options));
         var expected, actual;
-        if (typeof uglify_code != "string" || uglified.error) {
+        if (sandbox.is_error(uglify_code) || uglified.error) {
             expected = uglify_code;
             actual = uglified.error;
         } else {
@@ -2147,7 +2153,7 @@ function log_suspects(minify_options, component) {
             m[component] = o;
             m.validate = true;
             var result = UglifyJS.minify(original_code, m);
-            if (typeof uglify_code != "string") {
+            if (sandbox.is_error(uglify_code)) {
                 return !sandbox.same_stdout(uglify_code, result.error);
             } else if (result.error) {
                 errorln("Error testing options." + component + "." + name);
@@ -2175,7 +2181,7 @@ function log_suspects_global(options, toplevel) {
         m[component] = false;
         m.validate = true;
         var result = UglifyJS.minify(original_code, m);
-        if (typeof uglify_code != "string") {
+        if (sandbox.is_error(uglify_code)) {
             return !sandbox.same_stdout(uglify_code, result.error);
         } else if (result.error) {
             errorln("Error testing options." + component);
@@ -2204,7 +2210,16 @@ function log(options) {
     errorln();
     errorln();
     errorln("//-------------------------------------------------------------");
-    if (typeof uglify_code == "string") {
+    if (sandbox.is_error(uglify_code)) {
+        errorln("// !!! uglify failed !!!");
+        errorln(uglify_code);
+        if (original_erred) {
+            errorln();
+            errorln();
+            errorln("original stacktrace:");
+            errorln(original_result);
+        }
+    } else {
         errorln("// uglified code");
         try_beautify(uglify_code, toplevel, uglify_result, errorln);
         errorln();
@@ -2213,15 +2228,6 @@ function log(options) {
         errorln(original_result);
         errorln("uglified result:");
         errorln(uglify_result);
-    } else {
-        errorln("// !!! uglify failed !!!");
-        errorln(uglify_code);
-        if (errored) {
-            errorln();
-            errorln();
-            errorln("original stacktrace:");
-            errorln(original_result);
-        }
     }
     errorln("//-------------------------------------------------------------");
     if (!ok) {
@@ -2318,20 +2324,28 @@ function is_error_in(ex) {
     return ex.name == "TypeError" && /'in'/.test(ex.message);
 }
 
+function is_error_tdz(ex) {
+    return ex.name == "ReferenceError";
+}
+
 function is_error_spread(ex) {
-    return ex.name == "TypeError" && /Found non-callable @@iterator| is not iterable| not a function/.test(ex.message);
+    return ex.name == "TypeError" && /Found non-callable @@iterator| is not iterable| not a function|Symbol\(Symbol\.iterator\)/.test(ex.message);
 }
 
 function is_error_recursion(ex) {
     return ex.name == "RangeError" && /Invalid string length|Maximum call stack size exceeded/.test(ex.message);
 }
 
+function is_error_set_property(ex) {
+    return ex.name == "TypeError" && /^Cannot set propert[\s\S]+? of (null|undefined)/.test(ex.message);
+}
+
 function is_error_redeclaration(ex) {
     return ex.name == "SyntaxError" && /already been declared|redeclaration/.test(ex.message);
 }
 
 function is_error_destructuring(ex) {
-    return ex.name == "TypeError" && /^Cannot destructure /.test(ex.message);
+    return ex.name == "TypeError" && /^Cannot (destructure|read propert)/.test(ex.message);
 }
 
 function is_error_class_constructor(ex) {
@@ -2345,6 +2359,8 @@ function is_error_getter_only_property(ex) {
 }
 
 function patch_try_catch(orig, toplevel) {
+    var patched = Object.create(null);
+    var patches = [];
     var stack = [ {
         code: orig,
         index: 0,
@@ -2382,7 +2398,7 @@ function patch_try_catch(orig, toplevel) {
                     "throw " + match[1] + ";",
                 ].join("\n");
             }
-            var new_code = code.slice(0, index) + insert + code.slice(index) + tail_throw;
+            var new_code = code.slice(0, index) + insert + code.slice(index) + tail_throw + "var UFUZZ_ERROR;";
             var result = run_code(new_code, toplevel);
             if (!sandbox.is_error(result)) {
                 if (!stack.filled && match[1]) stack.push({
@@ -2394,27 +2410,35 @@ function patch_try_catch(orig, toplevel) {
                 offset += insert.length;
                 code = new_code;
             } else if (is_error_in(result)) {
-                index = result.ufuzz_catch;
+                patch(result.ufuzz_catch, result.ufuzz_var + ' = new Error("invalid `in`");');
-                return orig.slice(0, index) + result.ufuzz_var + ' = new Error("invalid `in`");' + orig.slice(index);
+            } else if (is_error_tdz(result)) {
+                patch(result.ufuzz_catch, result.ufuzz_var + ' = new Error("TDZ");');
             } else if (is_error_spread(result)) {
-                index = result.ufuzz_catch;
+                patch(result.ufuzz_catch, result.ufuzz_var + ' = new Error("spread not iterable");');
-                return orig.slice(0, index) + result.ufuzz_var + ' = new Error("spread not iterable");' + orig.slice(index);
             } else if (is_error_recursion(result)) {
-                index = result.ufuzz_try;
+                patch(result.ufuzz_try, 'throw new Error("skipping infinite recursion");');
-                return orig.slice(0, index) + 'throw new Error("skipping infinite recursion");' + orig.slice(index);
+            } else if (is_error_set_property(result)) {
+                patch(result.ufuzz_catch, result.ufuzz_var + ' = new Error("cannot set property");');
             } else if (is_error_destructuring(result)) {
-                index = result.ufuzz_catch;
+                patch(result.ufuzz_catch, result.ufuzz_var + ' = new Error("cannot destructure");');
-                return orig.slice(0, index) + result.ufuzz_var + ' = new Error("cannot destructure");' + orig.slice(index);
             } else if (is_error_class_constructor(result)) {
-                index = result.ufuzz_catch;
+                patch(result.ufuzz_catch, result.ufuzz_var + ' = new Error("missing new for class");');
-                return orig.slice(0, index) + result.ufuzz_var + ' = new Error("missing new for class");' + orig.slice(index);
             } else if (is_error_getter_only_property(result)) {
-                index = result.ufuzz_catch;
+                patch(result.ufuzz_catch, result.ufuzz_var + ' = new Error("setting getter-only property");');
-                return orig.slice(0, index) + result.ufuzz_var + ' = new Error("setting getter-only property");' + orig.slice(index);
             }
         }
         stack.filled = true;
     }
+    if (patches.length) return patches.reduce(function(code, patch) {
+        var index = patch[0];
+        return code.slice(0, index) + patch[1] + code.slice(index);
+    }, orig);
+
+    function patch(index, code) {
+        if (patched[index]) return;
+        patched[index] = true;
+        patches.unshift([ index, code ]);
+    }
 }
 
 var beautify_options = {
@@ -2426,22 +2450,23 @@ var beautify_options = {
     },
 };
 var minify_options = require("./options.json");
-if (typeof sandbox.run_code("A:if (0) B:; else B:;") != "string") {
+if (sandbox.is_error(sandbox.run_code("A:if (0) B:; else B:;"))) {
     minify_options.forEach(function(o) {
         if (!("mangle" in o)) o.mangle = {};
         if (o.mangle) o.mangle.v8 = true;
     });
 }
 var bug_async_arrow_rest = function() {};
-if (SUPPORT.arrow && SUPPORT.async && SUPPORT.rest && typeof sandbox.run_code("async (a = f(...[], b)) => 0;") != "string") {
+if (SUPPORT.arrow && SUPPORT.async && SUPPORT.rest && sandbox.is_error(sandbox.run_code("async (a = f(...[], b)) => 0;"))) {
     bug_async_arrow_rest = function(ex) {
         return ex.name == "SyntaxError" && ex.message == "Rest parameter must be last formal parameter";
     };
 }
-var bug_async_class_await = SUPPORT.async && SUPPORT.class_field && typeof sandbox.run_code("var await; async function f() { class A { static p = await; } }") != "string";
+var bug_class_static_await = SUPPORT.async && SUPPORT.class_field && sandbox.is_error(sandbox.run_code("var await; class A { static p = await; }"));
-var bug_for_of_async = SUPPORT.for_await_of && typeof sandbox.run_code("var async; for (async of []);") != "string";
+var bug_class_static_nontrivial = SUPPORT.class_field && sandbox.is_error(sandbox.run_code("class A { static 42; static get 42() {} }"));
-var bug_for_of_var = SUPPORT.for_of && SUPPORT.let && typeof sandbox.run_code("try {} catch (e) { for (var e of []); }") != "string";
+var bug_for_of_async = SUPPORT.for_await_of && sandbox.is_error(sandbox.run_code("var async; for (async of []);"));
-if (SUPPORT.destructuring && typeof sandbox.run_code("console.log([ 1 ], {} = 2);") != "string") {
+var bug_for_of_var = SUPPORT.for_of && SUPPORT.let && sandbox.is_error(sandbox.run_code("try {} catch (e) { for (var e of []); }"));
+if (SUPPORT.destructuring && sandbox.is_error(sandbox.run_code("console.log([ 1 ], {} = 2);"))) {
     beautify_options.output.v8 = true;
     minify_options.forEach(function(o) {
         if (!("output" in o)) o.output = {};
@@ -2450,7 +2475,7 @@ if (SUPPORT.destructuring && typeof sandbox.run_code("console.log([ 1 ], {} = 2)
 }
 beautify_options = JSON.stringify(beautify_options);
 minify_options = minify_options.map(JSON.stringify);
-var original_code, original_result, errored;
+var original_code, original_result, original_erred;
 var uglify_code, uglify_result, ok;
 for (var round = 1; round <= num_iterations; round++) {
     process.stdout.write(round + " of " + num_iterations + "\r");
@@ -2458,7 +2483,7 @@ for (var round = 1; round <= num_iterations; round++) {
     original_code = createTopLevelCode();
     var orig_result = [ run_code(original_code), run_code(original_code, true) ];
     if (orig_result.some(function(result, toplevel) {
-        if (typeof result == "string") return;
+        if (!sandbox.is_error(result)) return;
         println();
         println();
         println("//=============================================================");
@@ -2480,19 +2505,20 @@ for (var round = 1; round <= num_iterations; round++) {
         o.validate = true;
         uglify_code = UglifyJS.minify(original_code, o);
         original_result = orig_result[toplevel ? 1 : 0];
-        errored = typeof original_result != "string";
+        original_erred = sandbox.is_error(original_result);
         if (!uglify_code.error) {
             uglify_code = uglify_code.code;
             uglify_result = run_code(uglify_code, toplevel);
             ok = sandbox.same_stdout(original_result, uglify_result);
+            var uglify_erred = sandbox.is_error(uglify_result);
             // ignore v8 parser bug
-            if (!ok && bug_async_arrow_rest(uglify_result)) ok = true;
+            if (!ok && uglify_erred && bug_async_arrow_rest(uglify_result)) ok = true;
             // ignore runtime platform bugs
-            if (!ok && uglify_result.message == "Script execution aborted.") ok = true;
+            if (!ok && uglify_erred && uglify_result.message == "Script execution aborted.") ok = true;
             // handle difference caused by time-outs
             if (!ok) {
-                if (errored && is_error_timeout(original_result)) {
+                if (original_erred && is_error_timeout(original_result)) {
-                    if (is_error_timeout(uglify_result)) {
+                    if (uglify_erred && is_error_timeout(uglify_result)) {
                         // ignore difference in error message
                         ok = true;
                     } else {
@@ -2500,21 +2526,23 @@ for (var round = 1; round <= num_iterations; round++) {
                         if (!orig_result[toplevel ? 3 : 2]) orig_result[toplevel ? 3 : 2] = run_code(original_code, toplevel, 10000);
                         ok = sandbox.same_stdout(orig_result[toplevel ? 3 : 2], uglify_result);
                     }
-                } else if (is_error_timeout(uglify_result)) {
+                } else if (uglify_erred && is_error_timeout(uglify_result)) {
                     // ignore spurious time-outs
                     var waited_result = run_code(uglify_code, toplevel, 10000);
                     ok = sandbox.same_stdout(original_result, waited_result);
                 }
             }
             // ignore declaration order of global variables
-            if (!ok && !toplevel && uglify_result.name != "SyntaxError" && original_result.name != "SyntaxError") {
+            if (!ok && !toplevel) {
+                if (!(original_erred && original_result.name == "SyntaxError") && !(uglify_erred && uglify_result.name == "SyntaxError")) {
                     ok = sandbox.same_stdout(run_code(sort_globals(original_code)), run_code(sort_globals(uglify_code)));
                 }
+            }
             // ignore numerical imprecision caused by `unsafe_math`
-            if (!ok && o.compress && o.compress.unsafe_math && typeof original_result == typeof uglify_result) {
+            if (!ok && o.compress && o.compress.unsafe_math) {
-                if (typeof original_result == "string") {
+                if (typeof original_result == "string" && typeof uglify_result == "string") {
                     ok = fuzzy_match(original_result, uglify_result);
-                } else if (sandbox.is_error(original_result)) {
+                } else if (original_erred && uglify_erred) {
                     ok = original_result.name == uglify_result.name && fuzzy_match(original_result.message, uglify_result.message);
                 }
                 if (!ok) {
@@ -2522,46 +2550,33 @@ for (var round = 1; round <= num_iterations; round++) {
                     ok = sandbox.same_stdout(fuzzy_result, uglify_result);
                 }
             }
+            if (!ok && original_erred && uglify_erred && (
+                // ignore difference in error message caused by `in`
+                is_error_in(original_result) && is_error_in(uglify_result)
                 // ignore difference in error message caused by Temporal Dead Zone
-            if (!ok && errored && uglify_result.name == "ReferenceError" && original_result.name == "ReferenceError") ok = true;
+                || is_error_tdz(original_result) && is_error_tdz(uglify_result)
-            // ignore difference due to implicit strict-mode in `class`
+                // ignore difference in error message caused by spread syntax
-            if (!ok && /\bclass\b/.test(original_code)) {
+                || is_error_spread(original_result) && is_error_spread(uglify_result)
-                var original_strict = run_code('"use strict";\n' + original_code, toplevel);
+                // ignore difference in error message caused by destructuring assignment
-                if (/^(Syntax|Type)Error$/.test(uglify_result.name)) {
+                || is_error_set_property(original_result) && is_error_set_property(uglify_result)
-                    ok = typeof original_strict != "string";
-                } else {
-                    ok = sandbox.same_stdout(original_strict, uglify_result);
-                }
-            }
                 // ignore difference in error message caused by `import` symbol redeclaration
-            if (!ok && errored && /\bimport\b/.test(original_code)) {
+                || /\bimport\b/.test(original_code) && is_error_redeclaration(original_result) && is_error_redeclaration(uglify_result)
-                if (is_error_redeclaration(uglify_result) && is_error_redeclaration(original_result)) ok = true;
+                // ignore difference in error message caused by destructuring
-            }
+                || is_error_destructuring(original_result) && is_error_destructuring(uglify_result)
+                // ignore difference in error message caused by call on class
+                || is_error_class_constructor(original_result) && is_error_class_constructor(uglify_result)
+                // ignore difference in error message caused by setting getter-only property
+                || is_error_getter_only_property(original_result) && is_error_getter_only_property(uglify_result)
+            )) ok = true;
             // ignore difference due to `__proto__` assignment
             if (!ok && /\b__proto__\b/.test(original_code)) {
                 var original_proto = run_code("(" + patch_proto + ")();\n" + original_code, toplevel);
                 var uglify_proto = run_code("(" + patch_proto + ")();\n" + uglify_code, toplevel);
                 ok = sandbox.same_stdout(original_proto, uglify_proto);
             }
-            // ignore difference in error message caused by `in`
-            if (!ok && errored && is_error_in(uglify_result) && is_error_in(original_result)) ok = true;
-            // ignore difference in error message caused by spread syntax
-            if (!ok && errored && is_error_spread(uglify_result) && is_error_spread(original_result)) ok = true;
             // ignore difference in depth of termination caused by infinite recursion
-            if (!ok && errored && is_error_recursion(original_result)) {
+            if (!ok && original_erred && is_error_recursion(original_result)) {
-                if (is_error_recursion(uglify_result) || typeof uglify_result == "string") ok = true;
+                if (!uglify_erred || is_error_recursion(uglify_result)) ok = true;
-            }
-            // ignore difference in error message caused by destructuring
-            if (!ok && errored && is_error_destructuring(uglify_result) && is_error_destructuring(original_result)) {
-                ok = true;
-            }
-            // ignore difference in error message caused by call on class
-            if (!ok && errored && is_error_class_constructor(uglify_result) && is_error_class_constructor(original_result)) {
-                ok = true;
-            }
-            // ignore difference in error message caused by setting getter-only property
-            if (!ok && errored && is_error_getter_only_property(uglify_result) && is_error_getter_only_property(original_result)) {
-                ok = true;
             }
             // ignore errors above when caught by try-catch
             if (!ok) {
@@ -2573,7 +2588,7 @@ for (var round = 1; round <= num_iterations; round++) {
             }
         } else {
             uglify_code = uglify_code.error;
-            ok = errored && uglify_code.name == original_result.name;
+            ok = original_erred && uglify_code.name == original_result.name;
         }
         if (verbose || (verbose_interval && !(round % INTERVAL_COUNT)) || !ok) log(options);
         if (!ok && isFinite(num_iterations)) {