v3.16.3

fixes #5573

README.md

@@ -1359,7 +1359,7 @@ To allow for better optimizations, the compiler makes various assumptions:
   // SyntaxError: The left-hand side of a for-of loop may not be 'async'.
   ```
   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
+- Some versions of Chrome and Node.js will give incorrect results with the
   following:
   ```javascript
   console.log({
@@ -1368,9 +1368,15 @@ To allow for better optimizations, the compiler makes various assumptions:
           return "FAIL";
       },
       [42]: "PASS",
+  }[42], {
+      ...console,
+      get 42() {
+          return "FAIL";
+      },
+      42: "PASS",
   }[42]);
-  // Expected: "PASS"
-  // Actual:   "FAIL"
+  // Expected: "PASS PASS"
+  // Actual:   "PASS FAIL"
   ```
   UglifyJS may modify the input which in turn may suppress those errors.
 - Earlier versions of JavaScript will throw `TypeError` with the following:

lib/ast.js

@@ -109,6 +109,9 @@ var AST_Node = DEFNODE("Node", "start end", {
         start: "[AST_Token] The first token of this node",
         end: "[AST_Token] The last token of this node"
     },
+    equals: function(node) {
+        return this.TYPE == node.TYPE && this._equals(node);
+    },
     walk: function(visitor) {
         visitor.visit(this);
     },
@@ -138,6 +141,7 @@ var AST_Node = DEFNODE("Node", "start end", {
 }, null);
 
 DEF_BITPROPS(AST_Node, [
+    // AST_Node
     "_optimized",
     "_squeezed",
     // AST_Call
@@ -172,6 +176,8 @@ DEF_BITPROPS(AST_Node, [
     "pure",
     // AST_Assign
     "redundant",
+    // AST_Node
+    "single_use",
     // AST_ClassProperty
     "static",
     // AST_Call
@@ -231,6 +237,24 @@ AST_Node.disable_validation = function() {
     while (restore = restore_transforms.pop()) restore();
 };
 
+function all_equals(k, l) {
+    return k.length == l.length && all(k, function(m, i) {
+        return m.equals(l[i]);
+    });
+}
+
+function list_equals(s, t) {
+    return s.length == t.length && all(s, function(u, i) {
+        return u == t[i];
+    });
+}
+
+function prop_equals(u, v) {
+    if (u === v) return true;
+    if (u == null) return v == null;
+    return u instanceof AST_Node && v instanceof AST_Node && u.equals(v);
+}
+
 /* -----[ statements ]----- */
 
 var AST_Statement = DEFNODE("Statement", null, {
@@ -242,6 +266,7 @@ var AST_Statement = DEFNODE("Statement", null, {
 
 var AST_Debugger = DEFNODE("Debugger", null, {
     $documentation: "Represents a debugger statement",
+    _equals: return_true,
 }, AST_Statement);
 
 var AST_Directive = DEFNODE("Directive", "quote value", {
@@ -250,6 +275,9 @@ var AST_Directive = DEFNODE("Directive", "quote value", {
         quote: "[string?] the original quote character",
         value: "[string] The value of this directive as a plain string (it's not an AST_String!)",
     },
+    _equals: function(node) {
+        return this.value == node.value;
+    },
     _validate: function() {
         if (this.quote != null) {
             if (typeof this.quote != "string") throw new Error("quote must be string");
@@ -260,7 +288,8 @@ var AST_Directive = DEFNODE("Directive", "quote value", {
 }, AST_Statement);
 
 var AST_EmptyStatement = DEFNODE("EmptyStatement", null, {
-    $documentation: "The empty statement (empty block or simply a semicolon)"
+    $documentation: "The empty statement (empty block or simply a semicolon)",
+    _equals: return_true,
 }, AST_Statement);
 
 function is_statement(node) {
@@ -291,6 +320,9 @@ var AST_SimpleStatement = DEFNODE("SimpleStatement", "body", {
     $propdoc: {
         body: "[AST_Node] an expression node (should not be instanceof AST_Statement)",
     },
+    _equals: function(node) {
+        return this.body.equals(node.body);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -342,6 +374,9 @@ var AST_Block = DEFNODE("Block", "body", {
     $propdoc: {
         body: "[AST_Statement*] an array of statements"
     },
+    _equals: function(node) {
+        return all_equals(this.body, node.body);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -376,6 +411,10 @@ var AST_LabeledStatement = DEFNODE("LabeledStatement", "label", {
     $propdoc: {
         label: "[AST_Label] a label definition"
     },
+    _equals: function(node) {
+        return this.label.equals(node.label)
+            && this.body.equals(node.body);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -417,6 +456,10 @@ var AST_DWLoop = DEFNODE("DWLoop", "condition", {
     $propdoc: {
         condition: "[AST_Node] the loop condition.  Should not be instanceof AST_Statement"
     },
+    _equals: function(node) {
+        return this.body.equals(node.body)
+            && this.condition.equals(node.condition);
+    },
     _validate: function() {
         if (this.TYPE == "DWLoop") throw new Error("should not instantiate AST_DWLoop");
         must_be_expression(this, "condition");
@@ -431,7 +474,7 @@ var AST_Do = DEFNODE("Do", null, {
             node.body.walk(visitor);
             node.condition.walk(visitor);
         });
-    }
+    },
 }, AST_DWLoop);
 
 var AST_While = DEFNODE("While", null, {
@@ -442,7 +485,7 @@ var AST_While = DEFNODE("While", null, {
             node.condition.walk(visitor);
             node.body.walk(visitor);
         });
-    }
+    },
 }, AST_DWLoop);
 
 var AST_For = DEFNODE("For", "init condition step", {
@@ -452,6 +495,12 @@ var AST_For = DEFNODE("For", "init condition step", {
         condition: "[AST_Node?] the `for` termination clause, or null if empty",
         step: "[AST_Node?] the `for` update clause, or null if empty"
     },
+    _equals: function(node) {
+        return prop_equals(this.init, node.init)
+            && prop_equals(this.condition, node.condition)
+            && prop_equals(this.step, node.step)
+            && this.body.equals(node.body);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -479,6 +528,11 @@ var AST_ForEnumeration = DEFNODE("ForEnumeration", "init object", {
         init: "[AST_Node] the assignment target during iteration",
         object: "[AST_Node] the object to iterate over"
     },
+    _equals: function(node) {
+        return this.init.equals(node.init)
+            && this.object.equals(node.object)
+            && this.body.equals(node.body);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -519,6 +573,10 @@ var AST_With = DEFNODE("With", "expression", {
     $propdoc: {
         expression: "[AST_Node] the `with` expression"
     },
+    _equals: function(node) {
+        return this.expression.equals(node.expression)
+            && this.body.equals(node.body);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -621,6 +679,13 @@ var AST_Lambda = DEFNODE("Lambda", "argnames length_read rest safe_ids uses_argu
         });
         if (this.rest) this.rest.walk(tw);
     },
+    _equals: function(node) {
+        return prop_equals(this.rest, node.rest)
+            && prop_equals(this.name, node.name)
+            && prop_equals(this.value, node.value)
+            && all_equals(this.argnames, node.argnames)
+            && all_equals(this.body, node.body);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -831,6 +896,11 @@ 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",
     },
+    _equals: function(node) {
+        return prop_equals(this.name, node.name)
+            && prop_equals(this.extends, node.extends)
+            && all_equals(this.properties, node.properties);
+    },
     resolve: function(def_class) {
         return def_class ? this : this.parent_scope.resolve();
     },
@@ -883,6 +953,12 @@ var AST_ClassProperty = DEFNODE("ClassProperty", "key private static value", {
         static: "[boolean] whether this is a static property",
         value: "[AST_Node?] property value (AST_Accessor for getters/setters, AST_LambdaExpression for methods, null if not specified for fields)",
     },
+    _equals: function(node) {
+        return !this.private == !node.private
+            && !this.static == !node.static
+            && prop_equals(this.key, node.key)
+            && prop_equals(this.value, node.value);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -959,6 +1035,9 @@ var AST_Exit = DEFNODE("Exit", "value", {
     $propdoc: {
         value: "[AST_Node?] the value returned or thrown by this statement; could be null for AST_Return"
     },
+    _equals: function(node) {
+        return prop_equals(this.value, node.value);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -989,6 +1068,9 @@ var AST_LoopControl = DEFNODE("LoopControl", "label", {
     $propdoc: {
         label: "[AST_LabelRef?] the label, or null if none",
     },
+    _equals: function(node) {
+        return prop_equals(this.label, node.label);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -1019,6 +1101,11 @@ var AST_If = DEFNODE("If", "condition alternative", {
         condition: "[AST_Node] the `if` condition",
         alternative: "[AST_Statement?] the `else` part, or null if not present"
     },
+    _equals: function(node) {
+        return this.body.equals(node.body)
+            && this.condition.equals(node.condition)
+            && prop_equals(this.alternative, node.alternative);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -1042,6 +1129,10 @@ var AST_Switch = DEFNODE("Switch", "expression", {
     $propdoc: {
         expression: "[AST_Node] the `switch` “discriminant”"
     },
+    _equals: function(node) {
+        return this.expression.equals(node.expression)
+            && all_equals(this.body, node.body);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -1073,6 +1164,10 @@ var AST_Case = DEFNODE("Case", "expression", {
     $propdoc: {
         expression: "[AST_Node] the `case` expression"
     },
+    _equals: function(node) {
+        return this.expression.equals(node.expression)
+            && all_equals(this.body, node.body);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -1093,6 +1188,11 @@ var AST_Try = DEFNODE("Try", "bcatch bfinally", {
         bcatch: "[AST_Catch?] the catch block, or null if not present",
         bfinally: "[AST_Finally?] the finally block, or null if not present"
     },
+    _equals: function(node) {
+        return all_equals(this.body, node.body)
+            && prop_equals(this.bcatch, node.bcatch)
+            && prop_equals(this.bfinally, node.bfinally);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -1116,6 +1216,10 @@ var AST_Catch = DEFNODE("Catch", "argname", {
     $propdoc: {
         argname: "[(AST_Destructured|AST_SymbolCatch)?] symbol for the exception, or null if not present",
     },
+    _equals: function(node) {
+        return prop_equals(this.argname, node.argname)
+            && all_equals(this.body, node.body);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -1141,6 +1245,9 @@ var AST_Definitions = DEFNODE("Definitions", "definitions", {
     $propdoc: {
         definitions: "[AST_VarDef*] array of variable definitions"
     },
+    _equals: function(node) {
+        return all_equals(this.definitions, node.definitions);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -1197,6 +1304,10 @@ var AST_VarDef = DEFNODE("VarDef", "name value", {
         name: "[AST_Destructured|AST_SymbolVar] name of the variable",
         value: "[AST_Node?] initializer, or null of there's no initializer",
     },
+    _equals: function(node) {
+        return this.name.equals(node.name)
+            && prop_equals(this.value, node.value);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -1216,6 +1327,9 @@ var AST_ExportDeclaration = DEFNODE("ExportDeclaration", "body", {
     $propdoc: {
         body: "[AST_DefClass|AST_Definitions|AST_LambdaDefinition] the statement to export",
     },
+    _equals: function(node) {
+        return this.body.equals(node.body);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -1236,6 +1350,9 @@ var AST_ExportDefault = DEFNODE("ExportDefault", "body", {
     $propdoc: {
         body: "[AST_Node] the default export",
     },
+    _equals: function(node) {
+        return this.body.equals(node.body);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -1249,29 +1366,29 @@ var AST_ExportDefault = DEFNODE("ExportDefault", "body", {
     },
 }, AST_Statement);
 
-var AST_ExportForeign = DEFNODE("ExportForeign", "aliases keys path quote", {
+var AST_ExportForeign = DEFNODE("ExportForeign", "aliases keys path", {
     $documentation: "An `export ... from '...'` statement",
     $propdoc: {
-        aliases: "[string*] array of aliases to export",
-        keys: "[string*] array of keys to import",
-        path: "[string] the path to import module",
-        quote: "[string?] the original quote character",
+        aliases: "[AST_String*] array of aliases to export",
+        keys: "[AST_String*] array of keys to import",
+        path: "[AST_String] the path to import module",
+    },
+    _equals: function(node) {
+        return this.path.equals(node.path)
+            && all_equals(this.aliases, node.aliases)
+            && all_equals(this.keys, node.keys);
     },
     _validate: function() {
         if (this.aliases.length != this.keys.length) {
             throw new Error("aliases:key length mismatch: " + this.aliases.length + " != " + this.keys.length);
         }
         this.aliases.forEach(function(name) {
-            if (typeof name != "string") throw new Error("aliases must contain string");
+            if (!(name instanceof AST_String)) throw new Error("aliases must contain AST_String");
         });
         this.keys.forEach(function(name) {
-            if (typeof name != "string") throw new Error("keys must contain string");
+            if (!(name instanceof AST_String)) throw new Error("keys must contain AST_String");
         });
-        if (typeof this.path != "string") throw new Error("path must be string");
-        if (this.quote != null) {
-            if (typeof this.quote != "string") throw new Error("quote must be string");
-            if (!/^["']$/.test(this.quote)) throw new Error("invalid quote: " + this.quote);
-        }
+        if (!(this.path instanceof AST_String)) throw new Error("path must be AST_String");
     },
 }, AST_Statement);
 
@@ -1280,6 +1397,9 @@ var AST_ExportReferences = DEFNODE("ExportReferences", "properties", {
     $propdoc: {
         properties: "[AST_SymbolExport*] array of aliases to export",
     },
+    _equals: function(node) {
+        return all_equals(this.properties, node.properties);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -1295,14 +1415,20 @@ var AST_ExportReferences = DEFNODE("ExportReferences", "properties", {
     },
 }, AST_Statement);
 
-var AST_Import = DEFNODE("Import", "all default path properties quote", {
+var AST_Import = DEFNODE("Import", "all default path properties", {
     $documentation: "An `import` statement",
     $propdoc: {
         all: "[AST_SymbolImport?] the imported namespace, or null if not specified",
         default: "[AST_SymbolImport?] the alias for default `export`, or null if not specified",
-        path: "[string] the path to import module",
+        path: "[AST_String] the path to import module",
         properties: "[(AST_SymbolImport*)?] array of aliases, or null if not specified",
-        quote: "[string?] the original quote character",
+    },
+    _equals: function(node) {
+        return this.path.equals(node.path)
+            && prop_equals(this.all, node.all)
+            && prop_equals(this.default, node.default)
+            && !this.properties == !node.properties
+            && (!this.properties || all_equals(this.properties, node.properties));
     },
     walk: function(visitor) {
         var node = this;
@@ -1321,16 +1447,12 @@ var AST_Import = DEFNODE("Import", "all default path properties quote", {
         }
         if (this.default != null) {
             if (!(this.default instanceof AST_SymbolImport)) throw new Error("default must be AST_SymbolImport");
-            if (this.default.key !== "") throw new Error("invalid default key: " + this.default.key);
+            if (this.default.key.value !== "") throw new Error("invalid default key: " + this.default.key.value);
         }
-        if (typeof this.path != "string") throw new Error("path must be string");
+        if (!(this.path instanceof AST_String)) throw new Error("path must be AST_String");
         if (this.properties != null) this.properties.forEach(function(node) {
             if (!(node instanceof AST_SymbolImport)) throw new Error("properties must contain AST_SymbolImport");
         });
-        if (this.quote != null) {
-            if (typeof this.quote != "string") throw new Error("quote must be string");
-            if (!/^["']$/.test(this.quote)) throw new Error("invalid quote: " + this.quote);
-        }
     },
 }, AST_Statement);
 
@@ -1340,6 +1462,10 @@ var AST_DefaultValue = DEFNODE("DefaultValue", "name value", {
         name: "[AST_Destructured|AST_SymbolDeclaration] name of the variable",
         value: "[AST_Node] value to assign if variable is `undefined`",
     },
+    _equals: function(node) {
+        return this.name.equals(node.name)
+            && this.value.equals(node.value);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -1367,6 +1493,11 @@ var AST_Call = DEFNODE("Call", "args expression optional pure terminal", {
         pure: "[boolean/S] marker for side-effect-free call expression",
         terminal: "[boolean] whether the chain has ended",
     },
+    _equals: function(node) {
+        return !this.optional == !node.optional
+            && this.expression.equals(node.expression)
+            && all_equals(this.args, node.args);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -1395,6 +1526,9 @@ var AST_Sequence = DEFNODE("Sequence", "expressions", {
     $propdoc: {
         expressions: "[AST_Node*] array of expressions (at least two)"
     },
+    _equals: function(node) {
+        return all_equals(this.expressions, node.expressions);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -1422,6 +1556,11 @@ var AST_PropAccess = DEFNODE("PropAccess", "expression optional property termina
         property: "[AST_Node|string] the property to access.  For AST_Dot this is always a plain string, while for AST_Sub it's an arbitrary AST_Node",
         terminal: "[boolean] whether the chain has ended",
     },
+    _equals: function(node) {
+        return !this.optional == !node.optional
+            && prop_equals(this.property, node.property)
+            && this.expression.equals(node.expression);
+    },
     get_property: function() {
         var p = this.property;
         if (p instanceof AST_Constant) return p.value;
@@ -1466,6 +1605,9 @@ var AST_Spread = DEFNODE("Spread", "expression", {
     $propdoc: {
         expression: "[AST_Node] expression to be expanded",
     },
+    _equals: function(node) {
+        return this.expression.equals(node.expression);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -1483,6 +1625,10 @@ var AST_Unary = DEFNODE("Unary", "operator expression", {
         operator: "[string] the operator",
         expression: "[AST_Node] expression that this unary operator applies to"
     },
+    _equals: function(node) {
+        return this.operator == node.operator
+            && this.expression.equals(node.expression);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -1511,6 +1657,11 @@ var AST_Binary = DEFNODE("Binary", "operator left right", {
         operator: "[string] the operator",
         right: "[AST_Node] right-hand side expression"
     },
+    _equals: function(node) {
+        return this.operator == node.operator
+            && this.left.equals(node.left)
+            && this.right.equals(node.right);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -1532,6 +1683,11 @@ var AST_Conditional = DEFNODE("Conditional", "condition consequent alternative",
         consequent: "[AST_Node]",
         alternative: "[AST_Node]"
     },
+    _equals: function(node) {
+        return this.condition.equals(node.condition)
+            && this.consequent.equals(node.consequent)
+            && this.alternative.equals(node.alternative);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -1573,6 +1729,9 @@ var AST_Await = DEFNODE("Await", "expression", {
     $propdoc: {
         expression: "[AST_Node] expression with Promise to resolve on",
     },
+    _equals: function(node) {
+        return this.expression.equals(node.expression);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -1590,6 +1749,10 @@ var AST_Yield = DEFNODE("Yield", "expression nested", {
         expression: "[AST_Node?] return value for iterator, or null if undefined",
         nested: "[boolean] whether to iterate over expression as generator",
     },
+    _equals: function(node) {
+        return !this.nested == !node.nested
+            && prop_equals(this.expression, node.expression);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -1612,6 +1775,9 @@ var AST_Array = DEFNODE("Array", "elements", {
     $propdoc: {
         elements: "[AST_Node*] array of elements"
     },
+    _equals: function(node) {
+        return all_equals(this.elements, node.elements);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -1654,6 +1820,10 @@ var AST_DestructuredArray = DEFNODE("DestructuredArray", "elements", {
     $propdoc: {
         elements: "[(AST_DefaultValue|AST_Destructured|AST_SymbolDeclaration|AST_SymbolRef)*] array of elements",
     },
+    _equals: function(node) {
+        return prop_equals(this.rest, node.rest)
+            && all_equals(this.elements, node.elements);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -1671,6 +1841,10 @@ var AST_DestructuredKeyVal = DEFNODE("DestructuredKeyVal", "key value", {
         key: "[string|AST_Node] property name.  For computed property this is an AST_Node.",
         value: "[AST_DefaultValue|AST_Destructured|AST_SymbolDeclaration|AST_SymbolRef] property value",
     },
+    _equals: function(node) {
+        return prop_equals(this.key, node.key)
+            && this.value.equals(node.value);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -1692,6 +1866,10 @@ var AST_DestructuredObject = DEFNODE("DestructuredObject", "properties", {
     $propdoc: {
         properties: "[AST_DestructuredKeyVal*] array of properties",
     },
+    _equals: function(node) {
+        return prop_equals(this.rest, node.rest)
+            && all_equals(this.properties, node.properties);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -1713,6 +1891,9 @@ var AST_Object = DEFNODE("Object", "properties", {
     $propdoc: {
         properties: "[(AST_ObjectProperty|AST_Spread)*] array of properties"
     },
+    _equals: function(node) {
+        return all_equals(this.properties, node.properties);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -1736,6 +1917,10 @@ var AST_ObjectProperty = DEFNODE("ObjectProperty", "key value", {
         key: "[string|AST_Node] property name.  For computed property this is an AST_Node.",
         value: "[AST_Node] property value.  For getters and setters this is an AST_Accessor.",
     },
+    _equals: function(node) {
+        return prop_equals(this.key, node.key)
+            && this.value.equals(node.value);
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -1790,6 +1975,9 @@ var AST_Symbol = DEFNODE("Symbol", "scope name thedef", {
         scope: "[AST_Scope/S] the current scope (not necessarily the definition scope)",
         thedef: "[SymbolDef/S] the definition of this symbol"
     },
+    _equals: function(node) {
+        return this.thedef ? this.thedef === node.thedef : this.name == node.name;
+    },
     _validate: function() {
         if (this.TYPE == "Symbol") throw new Error("should not instantiate AST_Symbol");
         if (typeof this.name != "string") throw new Error("name must be string");
@@ -1807,10 +1995,14 @@ var AST_SymbolConst = DEFNODE("SymbolConst", null, {
 var AST_SymbolImport = DEFNODE("SymbolImport", "key", {
     $documentation: "Symbol defined by an `import` statement",
     $propdoc: {
-        key: "[string] the original `export` name",
+        key: "[AST_String] the original `export` name",
+    },
+    _equals: function(node) {
+        return this.name == node.name
+            && this.key.equals(node.key);
     },
     _validate: function() {
-        if (typeof this.key != "string") throw new Error("key must be string");
+        if (!(this.key instanceof AST_String)) throw new Error("key must be AST_String");
     },
 }, AST_SymbolConst);
 
@@ -1864,10 +2056,14 @@ var AST_SymbolRef = DEFNODE("SymbolRef", "fixed in_arg redef", {
 var AST_SymbolExport = DEFNODE("SymbolExport", "alias", {
     $documentation: "Reference in an `export` statement",
     $propdoc: {
-        alias: "[string] the `export` alias",
+        alias: "[AST_String] the `export` alias",
+    },
+    _equals: function(node) {
+        return this.name == node.name
+            && this.alias.equals(node.alias);
     },
     _validate: function() {
-        if (typeof this.alias != "string") throw new Error("alias must be string");
+        if (!(this.alias instanceof AST_String)) throw new Error("alias must be AST_String");
     },
 }, AST_SymbolRef);
 
@@ -1877,6 +2073,7 @@ var AST_LabelRef = DEFNODE("LabelRef", null, {
 
 var AST_ObjectIdentity = DEFNODE("ObjectIdentity", null, {
     $documentation: "Base class for `super` & `this`",
+    _equals: return_true,
     _validate: function() {
         if (this.TYPE == "ObjectIdentity") throw new Error("should not instantiate AST_ObjectIdentity");
     },
@@ -1911,7 +2108,12 @@ var AST_Template = DEFNODE("Template", "expressions strings tag", {
     $propdoc: {
         expressions: "[AST_Node*] the placeholder expressions",
         strings: "[string*] the raw text segments",
-        tag: "[AST_Node] tag function, or null if absent",
+        tag: "[AST_Node?] tag function, or null if absent",
+    },
+    _equals: function(node) {
+        return prop_equals(this.tag, node.tag)
+            && list_equals(this.strings, node.strings)
+            && all_equals(this.expressions, node.expressions);
     },
     walk: function(visitor) {
         var node = this;
@@ -1936,6 +2138,9 @@ var AST_Template = DEFNODE("Template", "expressions strings tag", {
 
 var AST_Constant = DEFNODE("Constant", null, {
     $documentation: "Base class for all constants",
+    _equals: function(node) {
+        return this.value === node.value;
+    },
     _validate: function() {
         if (this.TYPE == "Constant") throw new Error("should not instantiate AST_Constant");
     },
@@ -1984,6 +2189,9 @@ var AST_RegExp = DEFNODE("RegExp", "value", {
     $propdoc: {
         value: "[RegExp] the actual regexp"
     },
+    _equals: function(node) {
+        return "" + this.value == "" + node.value;
+    },
     _validate: function() {
         if (!(this.value instanceof RegExp)) throw new Error("value must be RegExp");
     },
@@ -1991,6 +2199,7 @@ var AST_RegExp = DEFNODE("RegExp", "value", {
 
 var AST_Atom = DEFNODE("Atom", null, {
     $documentation: "Base class for atoms",
+    _equals: return_true,
     _validate: function() {
         if (this.TYPE == "Atom") throw new Error("should not instantiate AST_Atom");
     },

lib/mozilla-ast.js

@@ -192,6 +192,19 @@
                 value: from_moz(M.value),
             });
         },
+        StaticBlock: function(M) {
+            var start = my_start_token(M);
+            var end = my_end_token(M);
+            return new AST_ClassInit({
+                start: start,
+                end: end,
+                value: new AST_ClassInitBlock({
+                    start: start,
+                    end: end,
+                    body: normalize_directives(M.body.map(from_moz)),
+                }),
+            });
+        },
         ForOfStatement: function(M) {
             return new (M.await ? AST_ForAwaitOf : AST_ForOf)({
                 start: my_start_token(M),
@@ -303,13 +316,22 @@
             });
         },
         ExportAllDeclaration: function(M) {
-            var alias = M.exported ? read_name(M.exported) : "*";
+            var start = my_start_token(M);
+            var end = my_end_token(M);
             return new AST_ExportForeign({
-                start: my_start_token(M),
-                end: my_end_token(M),
-                aliases: [ alias ],
-                keys: [ "*" ],
-                path: M.source.value,
+                start: start,
+                end: end,
+                aliases: [ M.exported ? from_moz_alias(M.exported) : new AST_String({
+                    start: start,
+                    value: "*",
+                    end: end,
+                }) ],
+                keys: [ new AST_String({
+                    start: start,
+                    value: "*",
+                    end: end,
+                }) ],
+                path: from_moz(M.source),
             });
         },
         ExportDefaultDeclaration: function(M) {
@@ -346,15 +368,15 @@
             if (M.source) {
                 var aliases = [], keys = [];
                 M.specifiers.forEach(function(prop) {
-                    aliases.push(read_name(prop.exported));
-                    keys.push(read_name(prop.local));
+                    aliases.push(from_moz_alias(prop.exported));
+                    keys.push(from_moz_alias(prop.local));
                 });
                 return new AST_ExportForeign({
                     start: my_start_token(M),
                     end: my_end_token(M),
                     aliases: aliases,
                     keys: keys,
-                    path: M.source.value,
+                    path: from_moz(M.source),
                 });
             }
             return new AST_ExportReferences({
@@ -362,38 +384,48 @@
                 end: my_end_token(M),
                 properties: M.specifiers.map(function(prop) {
                     var sym = new AST_SymbolExport(from_moz(prop.local));
-                    sym.alias = read_name(prop.exported);
+                    sym.alias = from_moz_alias(prop.exported);
                     return sym;
                 }),
             });
         },
         ImportDeclaration: function(M) {
+            var start = my_start_token(M);
+            var end = my_end_token(M);
             var all = null, def = null, props = null;
             M.specifiers.forEach(function(prop) {
                 var sym = new AST_SymbolImport(from_moz(prop.local));
                 switch (prop.type) {
                   case "ImportDefaultSpecifier":
                     def = sym;
-                    def.key = "";
+                    def.key = new AST_String({
+                        start: start,
+                        value: "",
+                        end: end,
+                    });
                     break;
                   case "ImportNamespaceSpecifier":
                     all = sym;
-                    all.key = "*";
+                    all.key = new AST_String({
+                        start: start,
+                        value: "*",
+                        end: end,
+                    });
                     break;
                   default:
-                    sym.key = prop.imported.name || syn.name;
+                    sym.key = from_moz_alias(prop.imported);
                     if (!props) props = [];
                     props.push(sym);
                     break;
                 }
             });
             return new AST_Import({
-                start: my_start_token(M),
-                end: my_end_token(M),
+                start: start,
+                end: end,
                 all: all,
                 default: def,
                 properties: props,
-                path: M.source.value,
+                path: from_moz(M.source),
             });
         },
         ImportExpression: function(M) {
@@ -714,6 +746,10 @@
         };
     });
 
+    def_to_moz(AST_ClassInit, function To_Moz_StaticBlock(M) {
+        return to_moz_scope("StaticBlock", M.value);
+    });
+
     function To_Moz_ForOfStatement(is_await) {
         return function(M) {
             return {
@@ -780,38 +816,26 @@
     });
 
     def_to_moz(AST_ExportForeign, function To_Moz_ExportAllDeclaration_ExportNamedDeclaration(M) {
-        if (M.keys[0] == "*") return {
+        if (M.keys[0].value == "*") return {
             type: "ExportAllDeclaration",
-            exported: M.aliases[0] == "*" ? null : {
-                type: "Identifier",
-                name: M.aliases[0],
-            },
-            source: {
-                type: "Literal",
-                value: M.path,
-            },
+            exported: M.aliases[0].value == "*" ? null : to_moz_alias(M.aliases[0]),
+            source: to_moz(M.path),
         };
         var specifiers = [];
         for (var i = 0; i < M.aliases.length; i++) {
-            specifiers.push({
+            specifiers.push(set_moz_loc({
+                start: M.keys[i].start,
+                end: M.aliases[i].end,
+            }, {
                 type: "ExportSpecifier",
-                exported: {
-                    type: "Identifier",
-                    name: M.aliases[i],
-                },
-                local: {
-                    type: "Identifier",
-                    name: M.keys[i],
-                },
-            });
+                local: to_moz_alias(M.keys[i]),
+                exported: to_moz_alias(M.aliases[i]),
+            }));
         }
         return {
             type: "ExportNamedDeclaration",
             specifiers: specifiers,
-            source: {
-                type: "Literal",
-                value: M.path,
-            },
+            source: to_moz(M.path),
         };
     });
 
@@ -819,44 +843,41 @@
         return {
             type: "ExportNamedDeclaration",
             specifiers: M.properties.map(function(prop) {
-                return {
+                return set_moz_loc({
+                    start: prop.start,
+                    end: prop.alias.end,
+                }, {
                     type: "ExportSpecifier",
                     local: to_moz(prop),
-                    exported: {
-                        type: "Identifier",
-                        name: prop.alias,
-                    },
-                };
+                    exported: to_moz_alias(prop.alias),
+                });
             }),
         };
     });
 
     def_to_moz(AST_Import, function To_Moz_ImportDeclaration(M) {
         var specifiers = M.properties ? M.properties.map(function(prop) {
-            return {
+            return set_moz_loc({
+                start: prop.key.start,
+                end: prop.end,
+            }, {
                 type: "ImportSpecifier",
                 local: to_moz(prop),
-                imported: {
-                    type: "Identifier",
-                    name: prop.key,
-                },
-            };
+                imported: to_moz_alias(prop.key),
+            });
         }) : [];
-        if (M.all) specifiers.unshift({
+        if (M.all) specifiers.unshift(set_moz_loc(M.all, {
             type: "ImportNamespaceSpecifier",
             local: to_moz(M.all),
-        });
-        if (M.default) specifiers.unshift({
+        }));
+        if (M.default) specifiers.unshift(set_moz_loc(M.default, {
             type: "ImportDefaultSpecifier",
             local: to_moz(M.default),
-        });
+        }));
         return {
             type: "ImportDeclaration",
             specifiers: specifiers,
-            source: {
-                type: "Literal",
-                value: M.path,
-            },
+            source: to_moz(M.path),
         };
     });
 
@@ -1203,6 +1224,14 @@
         return node;
     }
 
+    function from_moz_alias(moz) {
+        return new AST_String({
+            start: my_start_token(moz),
+            value: read_name(moz),
+            end: my_end_token(moz),
+        });
+    }
+
     AST_Node.from_mozilla_ast = function(node) {
         var save_stack = FROM_MOZ_STACK;
         FROM_MOZ_STACK = [];
@@ -1254,6 +1283,13 @@
         return node != null ? node.to_mozilla_ast() : null;
     }
 
+    function to_moz_alias(alias) {
+        return is_identifier_string(alias.value) ? set_moz_loc(alias, {
+            type: "Identifier",
+            name: alias.value,
+        }) : to_moz(alias);
+    }
+
     function to_moz_block(node) {
         return {
             type: "BlockStatement",

lib/output.js

@@ -1061,6 +1061,14 @@ function OutputStream(options) {
         }
         output.semicolon();
     });
+    function print_alias(alias, output) {
+        var value = alias.value;
+        if (value == "*" || is_identifier_string(value)) {
+            output.print_name(value);
+        } else {
+            output.print_string(value, alias.quote);
+        }
+    }
     DEFPRINT(AST_ExportForeign, function(output) {
         var self = this;
         output.print("export");
@@ -1068,7 +1076,7 @@ function OutputStream(options) {
         var len = self.keys.length;
         if (len == 0) {
             print_braced_empty(self, output);
-        } else if (self.keys[0] == "*") {
+        } else if (self.keys[0].value == "*") {
             print_entry(0);
         } else output.with_block(function() {
             output.indent();
@@ -1084,18 +1092,18 @@ function OutputStream(options) {
         output.space();
         output.print("from");
         output.space();
-        output.print_string(self.path, self.quote);
+        self.path.print(output);
         output.semicolon();
 
         function print_entry(index) {
             var alias = self.aliases[index];
             var key = self.keys[index];
-            output.print_name(key);
-            if (alias != key) {
+            print_alias(key, output);
+            if (alias.value != key.value) {
                 output.space();
                 output.print("as");
                 output.space();
-                output.print_name(alias);
+                print_alias(alias, output);
             }
         }
     });
@@ -1124,7 +1132,7 @@ function OutputStream(options) {
             output.print("from");
             output.space();
         }
-        output.print_string(self.path, self.quote);
+        self.path.print(output);
         output.semicolon();
     });
 
@@ -1734,19 +1742,19 @@ function OutputStream(options) {
         var name = get_symbol_name(self);
         output.print_name(name);
         var alias = self.alias;
-        if (alias != name) {
+        if (alias.value != name) {
             output.space();
             output.print("as");
             output.space();
-            output.print_name(alias);
+            print_alias(alias, output);
         }
     });
     DEFPRINT(AST_SymbolImport, function(output) {
         var self = this;
         var name = get_symbol_name(self);
         var key = self.key;
-        if (key && key != name) {
-            output.print_name(key);
+        if (key.value && key.value != name) {
+            print_alias(key, output);
             output.space();
             output.print("as");
             output.space();

lib/parse.js

@@ -552,16 +552,8 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
 
     function handle_dot() {
         next();
-        var ch = peek();
-        if (ch == ".") {
-            var op = ".";
-            do {
-                op += ".";
-                next();
-            } while (peek() == ".");
-            return token("operator", op);
-        }
-        return is_digit(ch.charCodeAt(0)) ? read_num(".") : token("punc", ".");
+        if (looking_at("..")) return token("operator", "." + next() + next());
+        return is_digit(peek().charCodeAt(0)) ? read_num(".") : token("punc", ".");
     }
 
     function read_word() {
@@ -815,7 +807,7 @@ function parse($TEXT, options) {
         }
     }
 
-    var statement = embed_tokens(function() {
+    var statement = embed_tokens(function(toplevel) {
         handle_regexp();
         switch (S.token.type) {
           case "string":
@@ -854,15 +846,15 @@ function parse($TEXT, options) {
                 if (S.in_async) return simple_statement();
                 break;
               case "export":
+                if (!toplevel && options.module !== "") unexpected();
                 next();
                 return export_();
               case "import":
                 var token = peek();
-                if (!(token.type == "punc" && /^[(.]$/.test(token.value))) {
-                    next();
-                    return import_();
-                }
-                break;
+                if (token.type == "punc" && /^[(.]$/.test(token.value)) break;
+                if (!toplevel && options.module !== "") unexpected();
+                next();
+                return import_();
               case "let":
                 if (is_vardefs()) {
                     next();
@@ -1442,28 +1434,41 @@ function parse($TEXT, options) {
     }
 
     function is_alias() {
-        return is("name") || is_identifier_string(S.token.value);
+        return is("name") || is("string") || is_identifier_string(S.token.value);
+    }
+
+    function make_string(token) {
+        return new AST_String({
+            start: token,
+            quote: token.quote,
+            value: token.value,
+            end: token,
+        });
+    }
+
+    function as_path() {
+        var path = S.token;
+        expect_token("string");
+        semicolon();
+        return make_string(path);
     }
 
     function export_() {
         if (is("operator", "*")) {
+            var key = S.token;
+            var alias = key;
             next();
-            var alias = "*";
             if (is("name", "as")) {
                 next();
                 if (!is_alias()) expect_token("name");
-                alias = S.token.value;
+                alias = S.token;
                 next();
             }
             expect_token("name", "from");
-            var path = S.token;
-            expect_token("string");
-            semicolon();
             return new AST_ExportForeign({
-                aliases: [ alias ],
-                keys: [ "*" ],
-                path: path.value,
-                quote: path.quote,
+                aliases: [ make_string(alias) ],
+                keys: [ make_string(key) ],
+                path: as_path(),
             });
         }
         if (is("punc", "{")) {
@@ -1477,26 +1482,20 @@ function parse($TEXT, options) {
                 if (is("name", "as")) {
                     next();
                     if (!is_alias()) expect_token("name");
-                    aliases.push(S.token.value);
+                    aliases.push(S.token);
                     next();
                 } else {
-                    aliases.push(key.value);
+                    aliases.push(key);
                 }
                 if (!is("punc", "}")) expect(",");
             }
             expect("}");
             if (is("name", "from")) {
                 next();
-                var path = S.token;
-                expect_token("string");
-                semicolon();
                 return new AST_ExportForeign({
-                    aliases: aliases,
-                    keys: keys.map(function(token) {
-                        return token.value;
-                    }),
-                    path: path.value,
-                    quote: path.quote,
+                    aliases: aliases.map(make_string),
+                    keys: keys.map(make_string),
+                    path: as_path(),
                 });
             }
             semicolon();
@@ -1504,7 +1503,7 @@ function parse($TEXT, options) {
                 properties: keys.map(function(token, index) {
                     if (!is_token(token, "name")) token_error(token, "Name expected");
                     var sym = _make_symbol(AST_SymbolExport, token);
-                    sym.alias = aliases[index];
+                    sym.alias = make_string(aliases[index]);
                     return sym;
                 }),
             });
@@ -1594,26 +1593,42 @@ function parse($TEXT, options) {
         var all = null;
         var def = as_symbol(AST_SymbolImport, true);
         var props = null;
-        if (def ? (def.key = "", is("punc", ",") && next()) : !is("string")) {
+        var cont;
+        if (def) {
+            def.key = new AST_String({
+                start: def.start,
+                value: "",
+                end: def.end,
+            });
+            if (cont = is("punc", ",")) next();
+        } else {
+            cont = !is("string");
+        }
+        if (cont) {
             if (is("operator", "*")) {
+                var key = S.token;
                 next();
                 expect_token("name", "as");
                 all = as_symbol(AST_SymbolImport);
-                all.key = "*";
+                all.key = make_string(key);
             } else {
                 expect("{");
                 props = [];
                 while (is_alias()) {
                     var alias;
                     if (is_token(peek(), "name", "as")) {
-                        var key = S.token.value;
+                        var key = S.token;
                         next();
                         next();
                         alias = as_symbol(AST_SymbolImport);
-                        alias.key = key;
+                        alias.key = make_string(key);
                     } else {
                         alias = as_symbol(AST_SymbolImport);
-                        alias.key = alias.name;
+                        alias.key = new AST_String({
+                            start: alias.start,
+                            value: alias.name,
+                            end: alias.end,
+                        });
                     }
                     props.push(alias);
                     if (!is("punc", "}")) expect(",");
@@ -1622,15 +1637,11 @@ function parse($TEXT, options) {
             }
         }
         if (all || def || props) expect_token("name", "from");
-        var path = S.token;
-        expect_token("string");
-        semicolon();
         return new AST_Import({
             all: all,
             default: def,
-            path: path.value,
+            path: as_path(),
             properties: props,
-            quote: path.quote,
         });
     }
 
@@ -1808,7 +1819,7 @@ function parse($TEXT, options) {
             ret = new AST_BigInt({ value: value });
             break;
           case "string":
-            ret = new AST_String({ value : value, quote : tok.quote });
+            ret = new AST_String({ value: value, quote: tok.quote });
             break;
           case "regexp":
             ret = new AST_RegExp({ value: value });
@@ -2563,7 +2574,7 @@ function parse($TEXT, options) {
         }
         S.input.push_directives_stack();
         while (!is("eof"))
-            body.push(statement());
+            body.push(statement(true));
         S.input.pop_directives_stack();
         var end = prev() || start;
         var toplevel = options.toplevel;

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.16.1",
+  "version": "3.16.3",
   "engines": {
     "node": ">=0.8.0"
   },
@@ -23,7 +23,7 @@
     "LICENSE"
   ],
   "devDependencies": {
-    "acorn": "~8.2.1",
+    "acorn": "~8.7.1",
     "semver": "~6.3.0"
   },
   "scripts": {

test/compress.js

@@ -69,7 +69,7 @@ function make_code(ast, options) {
 function parse_test(file) {
     var script = fs.readFileSync(file, "utf8");
     try {
-        var ast = U.parse(script, { filename: file });
+        var ast = U.parse(script, { filename: file, module: "" });
     } catch (e) {
         console.error("Caught error while parsing tests in " + file);
         console.error(e);

test/compress/arrows.js

@@ -1073,7 +1073,7 @@ issue_5414_2: {
     node_version: ">=4"
 }
 
-issue_5416: {
+issue_5416_1: {
     options = {
         dead_code: true,
         evaluate: true,
@@ -1095,10 +1095,11 @@ issue_5416: {
     expect: {
         var f = () => {
             {
-                arguments = void 0;
                 console;
+                arguments = void 0,
                 console.log(arguments);
                 var arguments;
+                return;
             }
         };
         f();
@@ -1107,6 +1108,97 @@ issue_5416: {
     node_version: ">=4"
 }
 
+issue_5416_2: {
+    options = {
+        dead_code: true,
+        evaluate: true,
+        inline: true,
+        loops: true,
+        unused: true,
+    }
+    input: {
+        var f = () => {
+            while ((() => {
+                console;
+                var a = function g(arguments) {
+                    while (console.log(arguments));
+                }();
+            })());
+        };
+        f();
+    }
+    expect: {
+        var f = () => {
+            {
+                console;
+                var arguments = void 0;
+                for (; console.log(arguments););
+                return;
+            }
+        };
+        f();
+    }
+    expect_stdout: "undefined"
+    node_version: ">=4"
+}
+
+issue_5416_3: {
+    options = {
+        inline: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        var f = () => {
+            (() => {
+                var a = function g(arguments) {
+                    console.log(arguments);
+                }();
+            })();
+        };
+        f();
+    }
+    expect: {
+        var f = () => {
+            arguments = void 0,
+            console.log(arguments);
+            var arguments;
+        };
+        f();
+    }
+    expect_stdout: "undefined"
+    node_version: ">=4"
+}
+
+issue_5416_4: {
+    options = {
+        arrows: true,
+        inline: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        var f = () => {
+            (() => {
+                var a = function g(arguments) {
+                    while (console.log(arguments));
+                }();
+            })();
+        };
+        f();
+    }
+    expect: {
+        var f = () => {
+            var arguments = void 0;
+            while (console.log(arguments));
+            return;
+        };
+        f();
+    }
+    expect_stdout: "undefined"
+    node_version: ">=4"
+}
+
 issue_5495: {
     input: {
         console.log((() => {

test/compress/awaits.js

@@ -1046,6 +1046,60 @@ collapse_vars_3: {
     node_version: ">=8"
 }
 
+collapse_funarg_1: {
+    options = {
+        collapse_vars: true,
+        unused: true,
+    }
+    input: {
+        A = "FAIL";
+        var a = "PASS";
+        (async function({}, b) {
+            return b;
+        })(null, A = a);
+        console.log(A);
+    }
+    expect: {
+        A = "FAIL";
+        var a = "PASS";
+        (async function({}, b) {
+            return b;
+        })(null, A = a);
+        console.log(A);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=8"
+}
+
+collapse_funarg_2: {
+    options = {
+        collapse_vars: true,
+        unused: true,
+    }
+    input: {
+        A = "FAIL";
+        B = "PASS";
+        (async function() {
+            console.log(function({}, a) {
+                return a;
+            }(null, A = B));
+        })();
+        console.log(A);
+    }
+    expect: {
+        A = "FAIL";
+        B = "PASS";
+        (async function() {
+            console.log(function({}, a) {
+                return a;
+            }(null, A = B));
+        })();
+        console.log(A);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=8"
+}
+
 collapse_property_lambda: {
     options = {
         collapse_vars: true,
@@ -3021,3 +3075,157 @@ issue_5506: {
     expect_stdout: "PASS"
     node_version: ">=8"
 }
+
+issue_5528_1: {
+    options = {
+        inline: true,
+    }
+    input: {
+        (async function() {
+            await function() {
+                try {
+                    return;
+                } finally {
+                    console.log("foo");
+                }
+            }();
+        })();
+        console.log("bar");
+    }
+    expect: {
+        (async function() {
+            await function() {
+                try {
+                    return;
+                } finally {
+                    console.log("foo");
+                }
+            }();
+        })();
+        console.log("bar");
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+    ]
+    node_version: ">=8"
+}
+
+issue_5528_2: {
+    options = {
+        inline: true,
+    }
+    input: {
+        (async function() {
+            await function() {
+                try {
+                    return 42;
+                } finally {
+                    console.log("foo");
+                }
+            }();
+        })();
+        console.log("bar");
+    }
+    expect: {
+        (async function() {
+            await function() {
+                try {
+                    return 42;
+                } finally {
+                    console.log("foo");
+                }
+            }();
+        })();
+        console.log("bar");
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+    ]
+    node_version: ">=8"
+}
+
+issue_5528_3: {
+    options = {
+        inline: true,
+    }
+    input: {
+        (async function() {
+            await function() {
+                try {
+                    FAIL;
+                } catch (e) {
+                    return console.log("foo");
+                } finally {
+                    console.log("bar");
+                }
+            }();
+        })();
+        console.log("baz");
+    }
+    expect: {
+        (async function() {
+            await function() {
+                try {
+                    FAIL;
+                } catch (e) {
+                    return console.log("foo");
+                } finally {
+                    console.log("bar");
+                }
+            }();
+        })();
+        console.log("baz");
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+        "baz",
+    ]
+    node_version: ">=8"
+}
+
+issue_5528_4: {
+    options = {
+        inline: true,
+    }
+    input: {
+        (async function() {
+            await function() {
+                try {
+                    return {
+                        then() {
+                            console.log("foo");
+                        },
+                    };
+                } finally {
+                    console.log("bar");
+                }
+            }();
+        })();
+        console.log("baz");
+    }
+    expect: {
+        (async function() {
+            await function() {
+                try {
+                    return {
+                        then() {
+                            console.log("foo");
+                        },
+                    };
+                } finally {
+                    console.log("bar");
+                }
+            }();
+        })();
+        console.log("baz");
+    }
+    expect_stdout: [
+        "bar",
+        "baz",
+        "foo",
+    ]
+    node_version: ">=8"
+}

test/compress/classes.js

@@ -3330,3 +3330,113 @@ issue_5512: {
     expect_stdout: "PASS"
     node_version: ">=16"
 }
+
+issue_5531_1: {
+    options = {
+        inline: true,
+        toplevel: true,
+    }
+    input: {
+        class A {
+            p = function() {
+                var a = function f() {
+                    if (!a)
+                        console.log("foo");
+                    return 42;
+                }(a++);
+            }();
+        }
+        new A();
+        new A();
+    }
+    expect: {
+        class A {
+            p = function() {
+                var a = function f() {
+                    if (!a)
+                        console.log("foo");
+                    return 42;
+                }(a++);
+            }();
+        }
+        new A();
+        new A();
+    }
+    expect_stdout: [
+        "foo",
+        "foo",
+    ]
+    node_version: ">=12"
+}
+
+issue_5531_2: {
+    options = {
+        inline: true,
+        toplevel: true,
+    }
+    input: {
+        class A {
+            static p = function() {
+                var a = function f() {
+                    if (!a)
+                        console.log("foo");
+                    return 42;
+                }(a++);
+            }();
+        }
+        new A();
+        new A();
+    }
+    expect: {
+        class A {
+            static p = (a = function f() {
+                if (!a)
+                    console.log("foo");
+                return 42;
+            }(a++), void 0);
+        }
+        var a;
+        new A();
+        new A();
+    }
+    expect_stdout: "foo"
+    node_version: ">=12"
+}
+
+issue_5531_3: {
+    options = {
+        inline: true,
+    }
+    input: {
+        class A {
+            static {
+                (function() {
+                    var a = function f() {
+                        if (!a)
+                            console.log("foo");
+                        return 42;
+                    }(a++);
+                })();
+            }
+        }
+        new A();
+        new A();
+    }
+    expect: {
+        class A {
+            static {
+                a = function f() {
+                    if (!a)
+                        console.log("foo");
+                    return 42;
+                }(a++),
+                void 0;
+                var a;
+            }
+        }
+        new A();
+        new A();
+    }
+    expect_stdout: "foo"
+    node_version: ">=16"
+}

test/compress/collapse_vars.js

@@ -9979,3 +9979,25 @@ issue_5396: {
     }
     expect_stdout: "PASS"
 }
+
+issue_5568: {
+    options = {
+        collapse_vars: true,
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        A = "FAIL";
+        var a = (A = "PASS", !1);
+        for (var b in a);
+        console.log(A);
+    }
+    expect: {
+        A = "FAIL";
+        for (var b in !(A = "PASS"));
+        console.log(A);
+    }
+    expect_stdout: "PASS"
+}

test/compress/conditionals.js

@@ -196,6 +196,88 @@ ifs_7: {
     }
 }
 
+merge_tail_1: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        function f(a) {
+            var b = "foo";
+            if (a) {
+                while (console.log("bar"));
+                console.log(b);
+            } else {
+                while (console.log("baz"));
+                console.log(b);
+            }
+        }
+        f();
+        f(42);
+    }
+    expect: {
+        function f(a) {
+            var b = "foo";
+            if (a)
+                while (console.log("bar"));
+            else
+                while (console.log("baz"));
+            console.log(b);
+        }
+        f();
+        f(42);
+    }
+    expect_stdout: [
+        "baz",
+        "foo",
+        "bar",
+        "foo",
+    ]
+}
+
+merge_tail_2: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        function f(a) {
+            var b = "foo";
+            if (a) {
+                while (console.log("bar"));
+                console.log(b);
+            } else {
+                c = "baz";
+                while (console.log(c));
+                while (console.log("bar"));
+                console.log(b);
+                var c;
+            }
+        }
+        f();
+        f(42);
+    }
+    expect: {
+        function f(a) {
+            var b = "foo";
+            if (!a) {
+                c = "baz";
+                while (console.log(c));
+                var c;
+            }
+            while (console.log("bar"));
+            console.log(b);
+        }
+        f();
+        f(42);
+    }
+    expect_stdout: [
+        "baz",
+        "bar",
+        "foo",
+        "bar",
+        "foo",
+    ]
+}
+
 cond_1: {
     options = {
         conditionals: true,
@@ -1731,7 +1813,7 @@ issue_3576: {
     expect_stdout: "PASS"
 }
 
-issue_3668: {
+issue_3668_1: {
     options = {
         conditionals: true,
         if_return: true,
@@ -1748,6 +1830,38 @@ issue_3668: {
         }
         console.log(f());
     }
+    expect: {
+        function f() {
+            try {
+                var undefined = typeof f;
+                if (!f) return undefined;
+            } catch (e) {
+                return "FAIL";
+            }
+        }
+        console.log(f());
+    }
+    expect_stdout: "undefined"
+}
+
+issue_3668_2: {
+    options = {
+        conditionals: true,
+        if_return: true,
+    }
+    input: {
+        function f() {
+            try {
+                var undefined = typeof f;
+                if (!f) return undefined;
+                return;
+            } catch (e) {
+                return "FAIL";
+            }
+            FAIL;
+        }
+        console.log(f());
+    }
     expect: {
         function f() {
             try {
@@ -1756,6 +1870,7 @@ issue_3668: {
             } catch (e) {
                 return "FAIL";
             }
+            FAIL;
         }
         console.log(f());
     }
@@ -2062,3 +2177,176 @@ issue_5334_2: {
     }
     expect_stdout: "PASS"
 }
+
+issue_5544_1: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        var a;
+        if (a)
+            switch (42) {
+              case console.log("FAIL"):
+              case console:
+            }
+        else
+            switch (false) {
+              case console.log("PASS"):
+              case console:
+            }
+    }
+    expect: {
+        var a;
+        if (a)
+            switch (42) {
+              case console.log("FAIL"):
+              case console:
+            }
+        else
+            switch (false) {
+              case console.log("PASS"):
+              case console:
+            }
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5544_2: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        var a;
+        if (a)
+            switch (42) {
+              case console.log("FAIL"):
+              case console:
+            }
+        else
+            switch (42) {
+              case console.log("PASS"):
+              case console:
+            }
+    }
+    expect: {
+        var a;
+        if (a)
+            switch (42) {
+              case console.log("FAIL"):
+              case console:
+            }
+        else
+            switch (42) {
+              case console.log("PASS"):
+              case console:
+            }
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5546_1: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        var a;
+        if (a)
+            try {
+                console;
+            } finally {
+                console.log("FAIL");
+            }
+        else
+            try {
+                console;
+            } finally {
+                console.log("PASS");
+            }
+    }
+    expect: {
+        var a;
+        if (a)
+            try {
+                console;
+            } finally {
+                console.log("FAIL");
+            }
+        else
+            try {
+                console;
+            } finally {
+                console.log("PASS");
+            }
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5546_2: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        var a;
+        if (a)
+            try {
+                console;
+            } catch (e) {}
+        else
+            try {
+                console;
+            } finally {
+                console.log("PASS");
+            }
+    }
+    expect: {
+        var a;
+        if (a)
+            try {
+                console;
+            } catch (e) {}
+        else
+            try {
+                console;
+            } finally {
+                console.log("PASS");
+            }
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5546_3: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        var a;
+        if (a)
+            try {
+                FAIL;
+            } catch (e) {
+                console.log("FAIL");
+            }
+        else
+            try {
+                FAIL;
+            } catch (e) {
+                console.log("PASS");
+            }
+    }
+    expect: {
+        var a;
+        if (a)
+            try {
+                FAIL;
+            } catch (e) {
+                console.log("FAIL");
+            }
+        else
+            try {
+                FAIL;
+            } catch (e) {
+                console.log("PASS");
+            }
+    }
+    expect_stdout: "PASS"
+}

test/compress/const.js

@@ -142,6 +142,80 @@ if_dead_branch: {
     expect_stdout: "undefined"
 }
 
+retain_tail_1: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        function f(a) {
+            var b = "foo";
+            if (a) {
+                const b = "bar";
+                while (console.log("baz"));
+                console.log(b);
+            } else {
+                while (console.log("moo"));
+                console.log(b);
+            }
+        }
+        f();
+        f(42);
+    }
+    expect: {
+        function f(a) {
+            var b = "foo";
+            if (a) {
+                const b = "bar";
+                while (console.log("baz"));
+                console.log(b);
+            } else {
+                while (console.log("moo"));
+                console.log(b);
+            }
+        }
+        f();
+        f(42);
+    }
+    expect_stdout: true
+}
+
+retain_tail_2: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        function f(a) {
+            var b = "foo";
+            if (a) {
+                while (console.log("bar"));
+                console.log(b);
+            } else {
+                const b = "baz";
+                while (console.log("moo"));
+                console.log(b);
+            }
+        }
+        f();
+        f(42);
+    }
+    expect: {
+        function f(a) {
+            var b = "foo";
+            if (a) {
+                while (console.log("bar"));
+                console.log(b);
+            } else {
+                const b = "baz";
+                while (console.log("moo"));
+                console.log(b);
+            }
+        }
+        f();
+        f(42);
+    }
+    expect_stdout: true
+}
+
 merge_vars_1: {
     options = {
         merge_vars: true,
@@ -579,6 +653,37 @@ dead_block_after_return: {
     expect_stdout: true
 }
 
+if_return_3: {
+    options = {
+        if_return: true,
+    }
+    input: {
+        var a = "PASS";
+        function f(b) {
+            if (console) {
+                const b = a;
+                return b;
+            } else
+                while (console.log("FAIL 1"));
+            return b;
+        }
+        console.log(f("FAIL 2"));
+    }
+    expect: {
+        var a = "PASS";
+        function f(b) {
+            if (console) {
+                const b = a;
+                return b;
+            } else
+                while (console.log("FAIL 1"));
+            return b;
+        }
+        console.log(f("FAIL 2"));
+    }
+    expect_stdout: true
+}
+
 do_if_continue_1: {
     options = {
         if_return: true,
@@ -1872,3 +1977,37 @@ issue_5476: {
     }
     expect_stdout: "undefined"
 }
+
+issue_5516: {
+    options = {
+        inline: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        console.log(typeof function() {
+            try {} catch (a) {
+                (function f() {
+                    a;
+                })();
+            }
+            {
+                const a = function() {};
+                return a;
+            }
+        }());
+    }
+    expect: {
+        console.log(typeof function() {
+            try {} catch (a) {
+                void a;
+            }
+            {
+                const a = function() {};
+                return a;
+            }
+        }());
+    }
+    expect_stdout: "function"
+}

test/compress/default-values.js

@@ -180,6 +180,26 @@ collapse_arg_sequence: {
     node_version: ">=6"
 }
 
+collapse_in_arg: {
+    options = {
+        collapse_vars: true,
+        keep_fargs: false,
+        unused: true,
+    }
+    input: {
+        (function(a, b = a) {
+            b("PASS");
+        })(console.log);
+    }
+    expect: {
+        (function(a) {
+            a("PASS");
+        })(console.log);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
 collapse_value_1: {
     options = {
         collapse_vars: true,
@@ -541,7 +561,7 @@ inline_side_effects_2: {
     }
     expect: {
         var a = 42;
-        [ [].e = --a ] = [ console ];
+        [ [][0] = --a ] = [ console ];
         console.log(a);
     }
     expect_stdout: "42"
@@ -1170,6 +1190,49 @@ mangle_arrow_2_toplevel: {
     node_version: ">=6.9.3"
 }
 
+collapse_preceding_simple_arg: {
+    options = {
+        collapse_vars: true,
+        unused: true,
+    }
+    input: {
+        var a = "foo";
+        console.log(function(b, c = "bar") {
+            return b + c;
+        }(a, a));
+    }
+    expect: {
+        var a = "foo";
+        console.log(function(b, c = "bar") {
+            return a + c;
+        }(0, a));
+    }
+    expect_stdout: "foofoo"
+    node_version: ">=6"
+}
+
+drop_preceding_simple_arg: {
+    options = {
+        collapse_vars: true,
+        keep_fargs: false,
+        unused: true,
+    }
+    input: {
+        var a = "foo";
+        console.log(function(b, c = "bar") {
+            return b + c;
+        }(a, a));
+    }
+    expect: {
+        var a = "foo";
+        console.log(function(c = "bar") {
+            return a + c;
+        }(a));
+    }
+    expect_stdout: "foofoo"
+    node_version: ">=6"
+}
+
 issue_4444: {
     options = {
         collapse_vars: true,
@@ -1558,7 +1621,7 @@ issue_4502_4: {
         (function(a, b = console.log("FAIL")) {})(..."" + console.log(42));
     }
     expect: {
-        [ , [].e = console.log("FAIL") ] = [ ..."" + console.log(42) ];
+        [ , [][0] = console.log("FAIL") ] = [ ..."" + console.log(42) ];
     }
     expect_stdout: "42"
     node_version: ">=6"
@@ -2183,7 +2246,7 @@ issue_5340_2: {
     }
     expect: {
         var a;
-        [ [].e = 0 ] = [ ({ p: a } = true).q ];
+        [ [][0] = 0 ] = [ ({ p: a } = true).q ];
         console.log(a);
     }
     expect_stdout: "undefined"
@@ -2462,3 +2525,494 @@ issue_5485: {
     expect_stdout: "PASS"
     node_version: ">=6"
 }
+
+issue_5533_1_keep_fargs: {
+    options = {
+        evaluate: true,
+        inline: true,
+        join_vars: true,
+        keep_fargs: true,
+        loops: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        try {
+            (function() {
+                var a;
+                for (; 1;)
+                    a = function() {
+                        (function f(b = 42) {
+                            b;
+                            throw "PASS";
+                        })();
+                    }();
+            })();
+        } catch (e) {
+            console.log(e);
+        }
+    }
+    expect: {
+        "use strict";
+        try {
+            (function() {
+                for (;;)
+                    throw "PASS";
+            })();
+        } catch (e) {
+            console.log(e);
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_5533_1_drop_fargs: {
+    options = {
+        evaluate: true,
+        inline: true,
+        join_vars: true,
+        keep_fargs: false,
+        loops: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        try {
+            (function() {
+                var a;
+                for (; 1;)
+                    a = function() {
+                        (function f(b = 42) {
+                            b;
+                            throw "PASS";
+                        })();
+                    }();
+            })();
+        } catch (e) {
+            console.log(e);
+        }
+    }
+    expect: {
+        "use strict";
+        try {
+            (function() {
+                for (;;)
+                    throw "PASS";
+            })();
+        } catch (e) {
+            console.log(e);
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_5533_2_keep_fargs: {
+    options = {
+        evaluate: true,
+        inline: true,
+        join_vars: true,
+        keep_fargs: true,
+        loops: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        try {
+            (function() {
+                var a;
+                for (; 1;)
+                    a = function() {
+                        (function f([ b ] = []) {
+                            b;
+                            throw "PASS";
+                        })();
+                    }();
+            })();
+        } catch (e) {
+            console.log(e);
+        }
+    }
+    expect: {
+        "use strict";
+        try {
+            (function() {
+                for (;;) {
+                    var [ [] = [] ] = [];
+                    throw "PASS";
+                }
+            })();
+        } catch (e) {
+            console.log(e);
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_5533_2_drop_fargs: {
+    options = {
+        evaluate: true,
+        inline: true,
+        join_vars: true,
+        keep_fargs: false,
+        loops: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        try {
+            (function() {
+                var a;
+                for (; 1;)
+                    a = function() {
+                        (function f([ b ] = []) {
+                            b;
+                            throw "PASS";
+                        })();
+                    }();
+            })();
+        } catch (e) {
+            console.log(e);
+        }
+    }
+    expect: {
+        "use strict";
+        try {
+            (function() {
+                for (;;) {
+                    var [ [] = [] ] = [];
+                    throw "PASS";
+                }
+            })();
+        } catch (e) {
+            console.log(e);
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_5533_3_keep_fargs: {
+    options = {
+        evaluate: true,
+        inline: true,
+        join_vars: true,
+        keep_fargs: true,
+        loops: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        try {
+            (function() {
+                var a;
+                for (; 1;)
+                    a = function() {
+                        (function f(b = 42, c = null) {
+                            c;
+                            throw "PASS";
+                        })();
+                    }();
+            })();
+        } catch (e) {
+            console.log(e);
+        }
+    }
+    expect: {
+        "use strict";
+        try {
+            (function() {
+                for (;;)
+                    throw "PASS";
+            })();
+        } catch (e) {
+            console.log(e);
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_5533_3_drop_fargs: {
+    options = {
+        evaluate: true,
+        inline: true,
+        join_vars: true,
+        keep_fargs: false,
+        loops: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        try {
+            (function() {
+                var a;
+                for (; 1;)
+                    a = function() {
+                        (function f(b = 42, c = null) {
+                            c;
+                            throw "PASS";
+                        })();
+                    }();
+            })();
+        } catch (e) {
+            console.log(e);
+        }
+    }
+    expect: {
+        "use strict";
+        try {
+            (function() {
+                for (;;)
+                    throw "PASS";
+            })();
+        } catch (e) {
+            console.log(e);
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_5533_4_keep_fargs: {
+    options = {
+        evaluate: true,
+        inline: true,
+        join_vars: true,
+        keep_fargs: true,
+        loops: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        try {
+            (function() {
+                var a;
+                for (; 1;)
+                    a = function() {
+                        (function f(b = 42, [ c ] = []) {
+                            c;
+                            throw "PASS";
+                        })();
+                    }();
+            })();
+        } catch (e) {
+            console.log(e);
+        }
+    }
+    expect: {
+        "use strict";
+        try {
+            (function() {
+                for (;;) {
+                    var [ [] = [] ] = [];
+                    throw "PASS";
+                }
+            })();
+        } catch (e) {
+            console.log(e);
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_5533_4_drop_fargs: {
+    options = {
+        evaluate: true,
+        inline: true,
+        join_vars: true,
+        keep_fargs: false,
+        loops: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        try {
+            (function() {
+                var a;
+                for (; 1;)
+                    a = function() {
+                        (function f(b = 42, [ c ] = []) {
+                            c;
+                            throw "PASS";
+                        })();
+                    }();
+            })();
+        } catch (e) {
+            console.log(e);
+        }
+    }
+    expect: {
+        "use strict";
+        try {
+            (function() {
+                for (;;) {
+                    var [ [] = [] ] = [];
+                    throw "PASS";
+                }
+            })();
+        } catch (e) {
+            console.log(e);
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_5536: {
+    options = {
+        inline: true,
+        keep_fargs: true,
+        unused: true,
+    }
+    input: {
+        (function*() {
+            (([], a = 42) => {})([]);
+            console.log(typeof a);
+        })().next();
+    }
+    expect: {
+        (function*() {
+            [ , [][0] = 0 ] = [ [] ],
+            void 0;
+            console.log(typeof a);
+        })().next();
+    }
+    expect_stdout: "undefined"
+    node_version: ">=6"
+}
+
+issue_5566_1: {
+    options = {
+        unused: true,
+    }
+    input: {
+        (function(a, f = function() {
+            return a;
+        }) {
+            var a = "foo";
+            console.log(a, f());
+        })("bar");
+    }
+    expect: {
+        (function(a, f = function() {
+            return a;
+        }) {
+            var a = "foo";
+            console.log(a, f());
+        })("bar");
+    }
+    expect_stdout: "foo bar"
+    node_version: ">=6"
+}
+
+issue_5566_2: {
+    options = {
+        inline: true,
+        reduce_vars: true,
+    }
+    input: {
+        (function(a, f = function() {
+            return a;
+        }) {
+            function a() {}
+            console.log(typeof a, typeof f());
+        })(42);
+    }
+    expect: {
+        (function(a, f = function() {
+            return a;
+        }) {
+            function a() {}
+            console.log(typeof a, typeof f());
+        })(42);
+    }
+    expect_stdout: "function number"
+    node_version: ">=6"
+}
+
+issue_5566_3: {
+    options = {
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        (function(a, f = function() {
+            return a;
+        }) {
+            function a() {}
+            console.log(typeof a, typeof f());
+        })(42);
+    }
+    expect: {
+        (function(a, f = function() {
+            return a;
+        }) {
+            function a() {}
+            console.log(typeof a, typeof f());
+        })(42);
+    }
+    expect_stdout: "function number"
+    node_version: ">=6"
+}
+
+issue_5566_4: {
+    options = {
+        collapse_vars: true,
+        unused: true,
+    }
+    input: {
+        (function(a, b = function() {
+            return a;
+        }) {
+            var a = 0;
+            b()("PASS");
+        })(console.log);
+    }
+    expect: {
+        (function(a, b = function() {
+            return a;
+        }) {
+            var a = 0;
+            b()("PASS");
+        })(console.log);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_5566_5: {
+    options = {
+        hoist_vars: true,
+    }
+    input: {
+        (function(a, f = function() {
+            return a;
+        }) {
+            var a = "foo";
+            var b;
+            console.log(a, f());
+        })("bar");
+    }
+    expect: {
+        (function(a, f = function() {
+            return a;
+        }) {
+            var b, a = "foo";
+            console.log(a, f());
+        })("bar");
+    }
+    expect_stdout: "foo bar"
+    node_version: ">=6"
+}

test/compress/destructured.js

@@ -472,6 +472,93 @@ funarg_collapse_vars_3: {
     node_version: ">=6"
 }
 
+funarg_collapse_vars_4: {
+    options = {
+        collapse_vars: true,
+        unused: true,
+    }
+    input: {
+        var a = "PASS";
+        (function(b, { log: c }) {
+            c(b);
+        })(a, console);
+    }
+    expect: {
+        var a = "PASS";
+        (function(b, { log: c }) {
+            c(a);
+        })(0, console);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+funarg_collapse_vars_5: {
+    options = {
+        collapse_vars: true,
+        unused: true,
+    }
+    input: {
+        A = "FAIL";
+        B = "PASS";
+        try {
+            console.log(function({}, a) {
+                return a;
+            }(null, A = B));
+        } catch (e) {}
+        console.log(A);
+    }
+    expect: {
+        A = "FAIL";
+        B = "PASS";
+        try {
+            console.log(function({}, a) {
+                return a;
+            }(null, A = B));
+        } catch (e) {}
+        console.log(A);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+funarg_collapse_vars_6: {
+    options = {
+        collapse_vars: true,
+        unused: true,
+    }
+    input: {
+        A = "FAIL";
+        B = "PASS";
+        function f() {
+            console.log(function({}, a) {
+                return a;
+            }(null, A = B));
+        }
+        try {
+            f();
+        } catch (e) {
+            console.log(A);
+        }
+    }
+    expect: {
+        A = "FAIL";
+        B = "PASS";
+        function f() {
+            console.log(function({}, a) {
+                return a;
+            }(null, A = B));
+        }
+        try {
+            f();
+        } catch (e) {
+            console.log(A);
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
 funarg_reduce_vars_1: {
     options = {
         reduce_vars: true,
@@ -3497,7 +3584,7 @@ issue_5314_2: {
         A = this;
         new function() {
             [ {
-                [console.log(this === A ? "FAIL" : "PASS")]: [].e,
+                [console.log(this === A ? "FAIL" : "PASS")]: [][0],
             } ] = [ 42 ];
         }();
     }
@@ -3646,3 +3733,114 @@ issue_5485: {
     expect_stdout: "PASS"
     node_version: ">=6"
 }
+
+issue_5533_keep_fargs: {
+    options = {
+        evaluate: true,
+        inline: true,
+        join_vars: true,
+        keep_fargs: true,
+        loops: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        try {
+            (function() {
+                var a;
+                for (; 1;)
+                    a = function() {
+                        (function f([ b ]) {
+                            b;
+                            throw "PASS";
+                        })([]);
+                    }();
+            })();
+        } catch (e) {
+            console.log(e);
+        }
+    }
+    expect: {
+        "use strict";
+        try {
+            (function() {
+                for (;;)
+                    throw "PASS";
+            })();
+        } catch (e) {
+            console.log(e);
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_5533_drop_fargs: {
+    options = {
+        evaluate: true,
+        inline: true,
+        join_vars: true,
+        keep_fargs: false,
+        loops: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        try {
+            (function() {
+                var a;
+                for (; 1;)
+                    a = function() {
+                        (function f([ b ]) {
+                            b;
+                            throw "PASS";
+                        })([]);
+                    }();
+            })();
+        } catch (e) {
+            console.log(e);
+        }
+    }
+    expect: {
+        "use strict";
+        try {
+            (function() {
+                for (;;)
+                    throw "PASS";
+            })();
+        } catch (e) {
+            console.log(e);
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_5573: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var log = console.log;
+        var a = "FAIL";
+        (function([ { [log(a)]: b } ]) {
+            A = 42;
+        })((a = "PASS", [ {} ]));
+        log(a, A);
+    }
+    expect: {
+        var log = console.log;
+        var a = "FAIL";
+        (function([ { [log(a)]: b } ]) {
+            A = 42;
+        })((a = "PASS", [ {} ]));
+        log(a, A);
+    }
+    expect_stdout: [
+        "PASS",
+        "PASS 42",
+    ]
+    node_version: ">=6"
+}

test/compress/drop-unused.js

@@ -3685,3 +3685,85 @@ issue_5271: {
     }
     expect_stdout: "42"
 }
+
+issue_5533_keep_fargs: {
+    options = {
+        evaluate: true,
+        inline: true,
+        join_vars: true,
+        keep_fargs: true,
+        loops: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        try {
+            (function() {
+                var a;
+                for (; 1;)
+                    a = function() {
+                        (function f(b) {
+                            b;
+                            throw "PASS";
+                        })();
+                    }();
+            })();
+        } catch (e) {
+            console.log(e);
+        }
+    }
+    expect: {
+        "use strict";
+        try {
+            (function() {
+                for (;;)
+                    throw "PASS";
+            })();
+        } catch (e) {
+            console.log(e);
+        }
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5533_drop_fargs: {
+    options = {
+        evaluate: true,
+        inline: true,
+        join_vars: true,
+        keep_fargs: false,
+        loops: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        try {
+            (function() {
+                var a;
+                for (; 1;)
+                    a = function() {
+                        (function f(b) {
+                            b;
+                            throw "PASS";
+                        })();
+                    }();
+            })();
+        } catch (e) {
+            console.log(e);
+        }
+    }
+    expect: {
+        "use strict";
+        try {
+            (function() {
+                for (;;)
+                    throw "PASS";
+            })();
+        } catch (e) {
+            console.log(e);
+        }
+    }
+    expect_stdout: "PASS"
+}

test/compress/evaluate.js

@@ -3390,3 +3390,29 @@ issue_5380: {
     }
     expect_stdout: "PASS"
 }
+
+issue_5558: {
+    options = {
+        collapse_vars: true,
+        evaluate: true,
+        reduce_vars: true,
+        sequences: true,
+        toplevel: true,
+    }
+    input: {
+        var a = 99, b = 0;
+        a++;
+        b++;
+        b += a;
+        b *= a;
+        b += a;
+        console.log(a);
+    }
+    expect: {
+        var a = 99, b = 0;
+        b++,
+        b = (b += ++a) * a + a,
+        console.log(a);
+    }
+    expect_stdout: "100"
+}

test/compress/exports.js

@@ -109,6 +109,17 @@ foreign: {
     expect_exact: 'export*from"foo";export{}from"bar";export*as a from"baz";export{default}from"moo";export{b,c as case,default as delete,d}from"moz";'
 }
 
+non_identifiers: {
+    beautify = {
+        quote_style: 3,
+    }
+    input: {
+        export * as "42" from 'foo';
+        export { '42', "delete" as 'foo' } from "bar";
+    }
+    expect_exact: "export*as\"42\"from'foo';export{'42',delete as foo}from\"bar\";"
+}
+
 same_quotes: {
     beautify = {
         beautify: true,

test/compress/functions.js

@@ -629,7 +629,7 @@ inline_binary_and: {
                 return void "moo";
                 return;
             } else
-                return;
+                return void 0;
         }());
     }
     expect_stdout: [
@@ -5582,7 +5582,7 @@ issue_3835: {
             return f();
         })();
     }
-    expect_stdout: true
+    expect_stdout: RangeError("Maximum call stack size exceeded")
 }
 
 issue_3836_1: {
@@ -7835,7 +7835,7 @@ issue_5249_1: {
                 while (console.log("FAIL 2"));
                 return;
             } else
-                return;
+                return void 0;
             throw "FAIL 3";
         }());
     }

test/compress/if_return.js

@@ -850,3 +850,546 @@ issue_866_2: {
         })();
     }
 }
+
+identical_returns_1: {
+    options = {
+        conditionals: true,
+        if_return: true,
+    }
+    input: {
+        console.log(function() {
+            if (console.log("foo"))
+                return 42;
+            else
+                while (console.log("bar"));
+            return 42;
+        }());
+    }
+    expect: {
+        console.log(function() {
+            if (!console.log("foo"))
+                while (console.log("bar"));
+            return 42;
+        }());
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+        "42",
+    ]
+}
+
+identical_returns_2: {
+    options = {
+        conditionals: true,
+        if_return: true,
+    }
+    input: {
+        console.log(function() {
+            if (console.log("foo"))
+                while (console.log("FAIL"));
+            else
+                return "bar";
+            return "bar";
+        }());
+    }
+    expect: {
+        console.log(function() {
+            if (console.log("foo"))
+                while (console.log("FAIL"));
+            return "bar";
+        }());
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+    ]
+}
+
+identical_returns_3: {
+    options = {
+        if_return: true,
+    }
+    input: {
+        function f(a) {
+            if (a)
+                return 42;
+            if (a)
+                return;
+            return 42;
+        }
+        if (f(console))
+            console.log("PASS");
+    }
+    expect: {
+        function f(a) {
+            if (a)
+                return 42;
+            if (a)
+                ;
+            else
+                return 42;
+        }
+        if (f(console))
+            console.log("PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4374: {
+    options = {
+        booleans: true,
+        conditionals: true,
+        if_return: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        (function() {
+            console.log(f(console));
+            function f(a) {
+                if (console) return 0;
+                if (a) return 1;
+                return 0;
+            }
+        })();
+    }
+    expect: {
+        (function() {
+            console.log(function(a) {
+                return !console && a ? 1 : 0;
+            }(console));
+        })();
+    }
+    expect_stdout: "0"
+}
+
+issue_5521: {
+    options = {
+        if_return: true,
+    }
+    input: {
+        console.log(function() {
+            if (console)
+                try {
+                    return "FAIL";
+                } finally {
+                    return;
+                }
+        }());
+    }
+    expect: {
+        console.log(function() {
+            if (console)
+                try {
+                    return "FAIL";
+                } finally {
+                    return;
+                }
+        }());
+    }
+    expect_stdout: "undefined"
+}
+
+issue_5523: {
+    options = {
+        if_return: true,
+    }
+    input: {
+        console.log(function() {
+            if (console)
+                try {
+                    FAIL;
+                } finally {
+                    return;
+                }
+        }());
+    }
+    expect: {
+        console.log(function() {
+            if (console)
+                try {
+                    FAIL;
+                } finally {
+                    return;
+                }
+        }());
+    }
+    expect_stdout: "undefined"
+}
+
+drop_catch: {
+    options = {
+        if_return: true,
+    }
+    input: {
+        function f() {
+            try {
+                throw 42;
+            } catch (e) {
+                return console.log("foo"), "bar";
+            } finally {
+                console.log("baz");
+            }
+            return "bar";
+        }
+        console.log(f());
+    }
+    expect: {
+        function f() {
+            try {
+                throw 42;
+            } catch (e) {
+                console.log("foo");
+            } finally {
+                console.log("baz");
+            }
+            return "bar";
+        }
+        console.log(f());
+    }
+    expect_stdout: [
+        "foo",
+        "baz",
+        "bar",
+    ]
+}
+
+retain_catch: {
+    options = {
+        if_return: true,
+    }
+    input: {
+        function f() {
+            try {
+                throw 42;
+            } catch (e) {
+                return console.log("foo");
+            } finally {
+                console.log("bar");
+            }
+            return console.log("foo");
+        }
+        f();
+    }
+    expect: {
+        function f() {
+            try {
+                throw 42;
+            } catch (e) {
+                return console.log("foo");
+            } finally {
+                console.log("bar");
+            }
+            return console.log("foo");
+        }
+        f();
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+    ]
+}
+
+retain_finally: {
+    options = {
+        if_return: true,
+    }
+    input: {
+        function f() {
+            try {
+                return console.log("foo"), FAIL;
+            } catch (e) {
+                return console.log("bar"), "FAIL";
+            } finally {
+                return console.log("baz"), console.log("moo");
+            }
+            return console.log("moo");
+        }
+        console.log(f());
+    }
+    expect: {
+        function f() {
+            try {
+                return console.log("foo"), FAIL;
+            } catch (e) {
+                return console.log("bar"), "FAIL";
+            } finally {
+                return console.log("baz"), console.log("moo");
+            }
+            return console.log("moo");
+        }
+        console.log(f());
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+        "baz",
+        "moo",
+        "undefined",
+    ]
+}
+
+drop_try: {
+    options = {
+        if_return: true,
+    }
+    input: {
+        function f() {
+            try {
+                return console.log("foo"), "bar";
+            } finally {
+                console.log("baz");
+            }
+            return "bar";
+        }
+        console.log(f());
+    }
+    expect: {
+        function f() {
+            try {
+                console.log("foo");
+            } finally {
+                console.log("baz");
+            }
+            return "bar";
+        }
+        console.log(f());
+    }
+    expect_stdout: [
+        "foo",
+        "baz",
+        "bar",
+    ]
+}
+
+retain_try: {
+    options = {
+        if_return: true,
+    }
+    input: {
+        function f() {
+            try {
+                return console.log("foo");
+            } finally {
+                console.log("bar");
+            }
+            return console.log("foo");
+        }
+        f();
+    }
+    expect: {
+        function f() {
+            try {
+                return console.log("foo");
+            } finally {
+                console.log("bar");
+            }
+            return console.log("foo");
+        }
+        f();
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+    ]
+}
+
+drop_try_catch: {
+    options = {
+        if_return: true,
+    }
+    input: {
+        function f(a) {
+            try {
+                if (a())
+                    return console.log("foo"), console.log("baz");
+            } catch (e) {
+                return console.log("bar"), console.log("baz");
+            }
+            return console.log("baz");
+        }
+        f(function() {
+            return 42;
+        });
+        f(function() {});
+        f();
+    }
+    expect: {
+        function f(a) {
+            try {
+                if (a())
+                    console.log("foo");
+            } catch (e) {
+                console.log("bar");
+            }
+            return console.log("baz");
+        }
+        f(function() {
+            return 42;
+        });
+        f(function() {});
+        f();
+    }
+    expect_stdout: [
+        "foo",
+        "baz",
+        "baz",
+        "bar",
+        "baz",
+    ]
+}
+
+empty_try: {
+    options = {
+        if_return: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        console.log(function() {
+            return f;
+            function f() {
+                try {} finally {}
+                return "PASS";
+            }
+        }()());
+    }
+    expect: {
+        console.log(function() {
+            return function() {
+                try {} finally {}
+                return "PASS";
+            };
+        }()());
+    }
+    expect_stdout: "PASS"
+}
+
+sequence_void_1: {
+    options = {
+        if_return: true,
+    }
+    input: {
+        function f() {
+            {
+                if (console)
+                    return console, void console.log("PASS");
+                return;
+            }
+        }
+        f();
+    }
+    expect: {
+        function f() {
+            if (console)
+                console, void console.log("PASS");
+        }
+        f();
+    }
+    expect_stdout: "PASS"
+}
+
+sequence_void_2: {
+    options = {
+        if_return: true,
+    }
+    input: {
+        function f() {
+            {
+                if (console)
+                    return console, void console.log("PASS");
+                return;
+            }
+            FAIL;
+        }
+        f();
+    }
+    expect: {
+        function f() {
+            if (console)
+                console, void console.log("PASS");
+            else {
+                return;
+                FAIL;
+            }
+        }
+        f();
+    }
+    expect_stdout: "PASS"
+}
+
+tail_match: {
+    options = {
+        if_return: true,
+    }
+    input: {
+        function f(a) {
+            if (a) {
+                console.log("foo");
+                return console.log("bar");
+            }
+            while (console.log("baz"));
+            return console.log("moo"), console.log("bar");
+        }
+        f();
+        f(42);
+    }
+    expect: {
+        function f(a) {
+            if (a)
+                console.log("foo");
+            else {
+                while (console.log("baz"));
+                console.log("moo");
+            }
+            return console.log("bar");
+        }
+        f();
+        f(42);
+    }
+    expect_stdout: [
+        "baz",
+        "moo",
+        "bar",
+        "foo",
+        "bar",
+    ]
+}
+
+void_match: {
+    options = {
+        if_return: true,
+    }
+    input: {
+        function f(a) {
+            if (a) {
+                console.log("foo");
+                return;
+            }
+            while (console.log("bar"));
+            return console.log("baz"), void console.log("moo");
+        }
+        f();
+        f(42);
+    }
+    expect: {
+        function f(a) {
+            if (a)
+                console.log("foo");
+            else {
+                while (console.log("bar"));
+                console.log("baz"),
+                console.log("moo");
+            }
+        }
+        f();
+        f(42);
+    }
+    expect_stdout: [
+        "bar",
+        "baz",
+        "moo",
+        "foo",
+    ]
+}

test/compress/imports.js

@@ -40,6 +40,17 @@ default_keys: {
     expect_exact: 'import foo,{bar}from"baz";'
 }
 
+non_identifiers: {
+    beautify = {
+        quote_style: 3,
+    }
+    input: {
+        import { '42' as foo } from "bar";
+        import { "foo" as bar } from 'baz';
+    }
+    expect_exact: "import{'42'as foo}from\"bar\";import{foo as bar}from'baz';"
+}
+
 dynamic: {
     input: {
         (async a => await import(a))("foo").then(bar);
@@ -227,3 +238,33 @@ issue_4708_2: {
         import a from "foo";
     }
 }
+
+pr_5550_1: {
+    input: {
+        if (console)
+            import("foo");
+        else
+            import.meta.url.replace(/bar/g, console.log);
+    }
+    expect: {
+        if (console)
+            import("foo");
+        else
+            import.meta.url.replace(/bar/g, console.log);
+    }
+}
+
+pr_5550_2: {
+    input: {
+        L: {
+            import("foo");
+            import.meta.url.replace(/bar/g, console.log);
+        }
+    }
+    expect: {
+        L: {
+            import("foo");
+            import.meta.url.replace(/bar/g, console.log);
+        }
+    }
+}

test/compress/labels.js

@@ -111,6 +111,7 @@ labels_5: {
 labels_6: {
     options = {
         dead_code: true,
+        unused: true,
     }
     input: {
         out: break out;
@@ -208,6 +209,59 @@ labels_10: {
     expect_stdout: "PASS"
 }
 
+labels_11: {
+    options = {
+        conditionals: true,
+        if_return: true,
+        unused: true,
+    }
+    input: {
+        L: if (console.log("PASS"))
+            break L;
+    }
+    expect: {
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+labels_12: {
+    options = {
+        conditionals: true,
+        dead_code: true,
+        if_return: true,
+    }
+    input: {
+        L: try {
+            if (console.log("foo"))
+                break L;
+            throw "bar";
+        } catch (e) {
+            console.log(e);
+            break L;
+        } finally {
+            if (console.log("baz"))
+                break L;
+        }
+    }
+    expect: {
+        L: try {
+            if (!console.log("foo"))
+                throw "bar";
+        } catch (e) {
+            console.log(e);
+        } finally {
+            if (console.log("baz"))
+                break L;
+        }
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+        "baz",
+    ]
+}
+
 issue_4466_1: {
     mangle = {
         v8: false,
@@ -327,3 +381,53 @@ issue_4466_2_toplevel_v8: {
     }
     expect_stdout: "PASS"
 }
+
+issue_5522: {
+    options = {
+        dead_code: true,
+    }
+    input: {
+        console.log(function() {
+            L: try {
+                return "FAIL";
+            } finally {
+                break L;
+            }
+            return "PASS";
+        }());
+    }
+    expect: {
+        console.log(function() {
+            L: try {
+                return "FAIL";
+            } finally {
+                break L;
+            }
+            return "PASS";
+        }());
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5524: {
+    options = {
+        dead_code: true,
+    }
+    input: {
+        L: try {
+            FAIL;
+        } finally {
+            break L;
+        }
+        console.log("PASS");
+    }
+    expect: {
+        L: try {
+            FAIL;
+        } finally {
+            break L;
+        }
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+}

test/compress/let.js

@@ -190,6 +190,96 @@ if_dead_branch: {
     node_version: ">=4"
 }
 
+retain_tail_1: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        "use strict";
+        function f(a) {
+            var b = "foo";
+            if (a) {
+                let b = "bar";
+                while (console.log("baz"));
+                console.log(b);
+            } else {
+                while (console.log("moo"));
+                console.log(b);
+            }
+        }
+        f();
+        f(42);
+    }
+    expect: {
+        "use strict";
+        function f(a) {
+            var b = "foo";
+            if (a) {
+                let b = "bar";
+                while (console.log("baz"));
+                console.log(b);
+            } else {
+                while (console.log("moo"));
+                console.log(b);
+            }
+        }
+        f();
+        f(42);
+    }
+    expect_stdout: [
+        "moo",
+        "foo",
+        "baz",
+        "bar",
+    ]
+    node_version: ">=4"
+}
+
+retain_tail_2: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        "use strict";
+        function f(a) {
+            var b = "foo";
+            if (a) {
+                while (console.log("bar"));
+                console.log(b);
+            } else {
+                let b = "baz";
+                while (console.log("moo"));
+                console.log(b);
+            }
+        }
+        f();
+        f(42);
+    }
+    expect: {
+        "use strict";
+        function f(a) {
+            var b = "foo";
+            if (a) {
+                while (console.log("bar"));
+                console.log(b);
+            } else {
+                let b = "baz";
+                while (console.log("moo"));
+                console.log(b);
+            }
+        }
+        f();
+        f(42);
+    }
+    expect_stdout: [
+        "moo",
+        "baz",
+        "bar",
+        "foo",
+    ]
+    node_version: ">=4"
+}
+
 merge_vars_1: {
     options = {
         merge_vars: true,
@@ -892,6 +982,40 @@ if_return_2: {
     node_version: ">=4"
 }
 
+if_return_3: {
+    options = {
+        if_return: true,
+    }
+    input: {
+        "use strict";
+        var a = "PASS";
+        function f(b) {
+            if (console) {
+                let b = a;
+                return b;
+            } else
+                while (console.log("FAIL 1"));
+            return b;
+        }
+        console.log(f("FAIL 2"));
+    }
+    expect: {
+        "use strict";
+        var a = "PASS";
+        function f(b) {
+            if (console) {
+                let b = a;
+                return b;
+            } else
+                while (console.log("FAIL 1"));
+            return b;
+        }
+        console.log(f("FAIL 2"));
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
 do_if_continue_1: {
     options = {
         if_return: true,
@@ -1625,7 +1749,7 @@ issue_4438: {
         function f() {
             if (console) {
                 let a = console.log;
-                void a("PASS");
+                a("PASS");
             }
         }
         f();

test/compress/nullish.js

@@ -308,6 +308,7 @@ issue_4679: {
 issue_5266: {
     options = {
         inline: true,
+        side_effects: true,
     }
     input: {
         [

test/compress/rests.js

@@ -648,7 +648,7 @@ drop_new_function: {
     }
     expect: {
         void ([ ... {
-            [console.log("PASS")]: [].e,
+            [console.log("PASS")]: [][0],
         }] = []);
     }
     expect_stdout: "PASS"
@@ -1363,3 +1363,264 @@ issue_5391: {
     expect_stdout: "NaN"
     node_version: ">=8.3.0"
 }
+
+issue_5533_1_keep_fargs: {
+    options = {
+        evaluate: true,
+        inline: true,
+        join_vars: true,
+        keep_fargs: true,
+        loops: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        try {
+            (function() {
+                var a;
+                for (; 1;)
+                    a = function() {
+                        (function f(...b) {
+                            b;
+                            throw "PASS";
+                        })();
+                    }();
+            })();
+        } catch (e) {
+            console.log(e);
+        }
+    }
+    expect: {
+        "use strict";
+        try {
+            (function() {
+                for (;;)
+                    throw "PASS";
+            })();
+        } catch (e) {
+            console.log(e);
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_5533_1_drop_fargs: {
+    options = {
+        evaluate: true,
+        inline: true,
+        join_vars: true,
+        keep_fargs: false,
+        loops: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        try {
+            (function() {
+                var a;
+                for (; 1;)
+                    a = function() {
+                        (function f(...b) {
+                            b;
+                            throw "PASS";
+                        })();
+                    }();
+            })();
+        } catch (e) {
+            console.log(e);
+        }
+    }
+    expect: {
+        "use strict";
+        try {
+            (function() {
+                for (;;)
+                    throw "PASS";
+            })();
+        } catch (e) {
+            console.log(e);
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_5533_2_keep_fargs: {
+    options = {
+        evaluate: true,
+        inline: true,
+        join_vars: true,
+        keep_fargs: true,
+        loops: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        try {
+            (function() {
+                var a;
+                for (; 1;)
+                    a = function() {
+                        (function f(...[ b ]) {
+                            b;
+                            throw "PASS";
+                        })();
+                    }();
+            })();
+        } catch (e) {
+            console.log(e);
+        }
+    }
+    expect: {
+        "use strict";
+        try {
+            (function() {
+                for (;;)
+                    throw "PASS";
+            })();
+        } catch (e) {
+            console.log(e);
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_5533_2_drop_fargs: {
+    options = {
+        evaluate: true,
+        inline: true,
+        join_vars: true,
+        keep_fargs: false,
+        loops: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        try {
+            (function() {
+                var a;
+                for (; 1;)
+                    a = function() {
+                        (function f(...[ b ]) {
+                            b;
+                            throw "PASS";
+                        })();
+                    }();
+            })();
+        } catch (e) {
+            console.log(e);
+        }
+    }
+    expect: {
+        "use strict";
+        try {
+            (function() {
+                for (;;)
+                    throw "PASS";
+            })();
+        } catch (e) {
+            console.log(e);
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_5552_1: {
+    options = {
+        collapse_vars: true,
+        reduce_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var log = console.log;
+        var a = f, b = log();
+        function f(...[ c = a = "PASS" ]) {}
+        f((a = "FAIL", b));
+        log(a);
+    }
+    expect: {
+        var log = console.log;
+        var a = f, b = log();
+        function f(...[ c = a = "PASS" ]) {}
+        f((a = "FAIL", b));
+        log(a);
+    }
+    expect_stdout: [
+        "",
+        "PASS",
+    ]
+    node_version: ">=6"
+}
+
+issue_5552_2: {
+    options = {
+        collapse_vars: true,
+        reduce_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var log = console.log;
+        var a = f;
+        function f(...{ [a = "PASS"]: b }) {}
+        f((a = "FAIL", 42));
+        log(a);
+    }
+    expect: {
+        var log = console.log;
+        var a = f;
+        function f(...{ [a = "PASS"]: b }) {}
+        f((a = "FAIL", 42));
+        log(a);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_5552_3: {
+    options = {
+        collapse_vars: true,
+        unused: true,
+    }
+    input: {
+        var a = [ "FAIL", "PASS" ];
+        console.log(function(b, ...[ c = a.pop() ]) {
+            return b;
+        }(a.pop()));
+    }
+    expect: {
+        var a = [ "FAIL", "PASS" ];
+        console.log(function(b, ...[ c = a.pop() ]) {
+            return b;
+        }(a.pop()));
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_5552_4: {
+    options = {
+        collapse_vars: true,
+        unused: true,
+    }
+    input: {
+        var a = [ "FAIL", "PASS" ];
+        console.log(function(b, ...{ [a.pop()]: c }) {
+            return b;
+        }(a.pop()));
+    }
+    expect: {
+        var a = [ "FAIL", "PASS" ];
+        console.log(function(b, ...{ [a.pop()]: c }) {
+            return b;
+        }(a.pop()));
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}

test/compress/spreads.js

@@ -1,3 +1,12 @@
+decimal: {
+    input: {
+        console.log({... 0.42});
+    }
+    expect_exact: "console.log({....42});"
+    expect_stdout: "{}"
+    node_version: ">=8.3.0"
+}
+
 collapse_vars_1: {
     options = {
         collapse_vars: true,

test/compress/switches.js

@@ -1608,3 +1608,83 @@ issue_5012: {
     }
     expect_stdout: "PASS"
 }
+
+issue_5543_1: {
+    options = {
+        dead_code: true,
+        switches: true,
+    }
+    input: {
+        var a;
+        switch (a) {
+          default:
+            switch (42) {
+              case a:
+              case console.log("PASS"):
+            }
+            break;
+          case null:
+            switch (false) {
+              case a:
+              case console.log("FAIL"):
+            }
+        }
+    }
+    expect: {
+        var a;
+        switch (a) {
+          default:
+            switch (42) {
+              case a:
+              case console.log("PASS"):
+            }
+            break;
+          case null:
+            switch (false) {
+              case a:
+              case console.log("FAIL"):
+            }
+        }
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5543_2: {
+    options = {
+        dead_code: true,
+        switches: true,
+    }
+    input: {
+        var a;
+        switch (a) {
+          default:
+            switch (42) {
+              case a:
+              case console.log("PASS"):
+            }
+            break;
+          case null:
+            switch (42) {
+              case a:
+              case console.log("FAIL"):
+            }
+        }
+    }
+    expect: {
+        var a;
+        switch (a) {
+          default:
+            switch (42) {
+              case a:
+              case console.log("PASS"):
+            }
+            break;
+          case null:
+            switch (42) {
+              case a:
+              case console.log("FAIL"):
+            }
+        }
+    }
+    expect_stdout: "PASS"
+}

test/compress/transform.js

@@ -127,7 +127,7 @@ if_return: {
                 if (w) {
                     if (y) return;
                 } else if (z) return;
-                return x == y || (x && w(), y && z()), !0;
+                return x != y && (x && w(), y && z()), !0;
             }
         }
     }

test/compress/varify.js

@@ -613,3 +613,35 @@ issue_4954: {
     ]
     node_version: ">=4"
 }
+
+issue_5516: {
+    options = {
+        reduce_funcs: true,
+        reduce_vars: true,
+        unused: true,
+        varify: true,
+    }
+    input: {
+        "use strict";
+        console.log(typeof function() {
+            {
+                let a;
+            }
+            {
+                const a = function() {};
+                return a;
+            }
+        }());
+    }
+    expect: {
+        "use strict";
+        console.log(typeof function() {
+            {
+                const a = function() {};
+                return a;
+            }
+        }());
+    }
+    expect_stdout: "function"
+    node_version: ">=4"
+}

test/compress/yields.js

@@ -907,7 +907,7 @@ drop_body: {
         })([ console.log("baz") ]);
     }
     expect: {
-        [ [ , [].e = console.log("foo") ] ] = [ [ console.log("baz") ] ];
+        [ [ , [][0] = console.log("foo") ] ] = [ [ console.log("baz") ] ];
     }
     expect_stdout: [
         "baz",
@@ -1183,6 +1183,35 @@ issue_4641_2: {
     node_version: ">=10"
 }
 
+issue_4641_3: {
+    options = {
+        if_return: true,
+    }
+    input: {
+        console.log(typeof async function*() {
+            try {
+                return void "FAIL";
+            } finally {
+                console.log("PASS");
+            }
+        }().next().then);
+    }
+    expect: {
+        console.log(typeof async function*() {
+            try {
+                return void "FAIL";
+            } finally {
+                console.log("PASS");
+            }
+        }().next().then);
+    }
+    expect_stdout: [
+        "function",
+        "PASS",
+    ]
+    node_version: ">=10"
+}
+
 issue_4769_1: {
     options = {
         side_effects: true,
@@ -1467,6 +1496,80 @@ issue_5385_2: {
     node_version: ">=10"
 }
 
+issue_5385_3: {
+    options = {
+        inline: true,
+    }
+    input: {
+        (async function*() {
+            return function() {
+                try {
+                    throw console.log("foo");
+                } catch (e) {
+                    return console.log("bar");
+                }
+            }();
+        })().next();
+        console.log("moo");
+    }
+    expect: {
+        (async function*() {
+            try {
+                throw console.log("foo");
+            } catch (e) {
+                return console.log("bar");
+            }
+            return void 0;
+        })().next();
+        console.log("moo");
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+        "moo",
+    ]
+    node_version: ">=10"
+}
+
+issue_5385_4: {
+    options = {
+        awaits: true,
+        inline: true,
+    }
+    input: {
+        (async function*() {
+            return async function() {
+                try {
+                    return {
+                        then(resolve) {
+                            resolve(console.log("FAIL"));
+                        },
+                    };
+                } finally {
+                    return "PASS";
+                }
+            }();
+        })().next().then(o => console.log(o.value, o.done));
+    }
+    expect: {
+        (async function*() {
+            return async function() {
+                try {
+                    return {
+                        then(resolve) {
+                            resolve(console.log("FAIL"));
+                        },
+                    };
+                } finally {
+                    return "PASS";
+                }
+            }();
+        })().next().then(o => console.log(o.value, o.done));
+    }
+    expect_stdout: "PASS true"
+    node_version: ">=10"
+}
+
 issue_5425: {
     options = {
         assignments: true,
@@ -1562,3 +1665,39 @@ issue_5506: {
     expect_stdout: "PASS"
     node_version: ">=4"
 }
+
+issue_5526: {
+    options = {
+        inline: true,
+        side_effects: true,
+    }
+    input: {
+        (async function*() {
+            try {
+                return function() {
+                    while (console.log("foo"));
+                }();
+            } finally {
+                console.log("bar");
+            }
+        })().next();
+        console.log("baz");
+    }
+    expect: {
+        (async function*() {
+            try {
+                while (console.log("foo"));
+                return void 0;
+            } finally {
+                console.log("bar");
+            }
+        })().next();
+        console.log("baz");
+    }
+    expect_stdout: [
+        "foo",
+        "baz",
+        "bar",
+    ]
+    node_version: ">=10"
+}

test/mocha/exports.js

@@ -1,3 +1,4 @@
+var acorn = require("acorn");
 var assert = require("assert");
 var UglifyJS = require("../node");
 
@@ -25,6 +26,7 @@ describe("export", function() {
             "export { * };",
             "export { * as A };",
             "export { 42 as A };",
+            "export { 'A' as B };",
             "export { A as B-C };",
             "export { default as A };",
         ].forEach(function(code) {
@@ -51,8 +53,11 @@ describe("export", function() {
     it("Should reject invalid `export ... from ...` statement syntax", function() {
         [
             "export from 'path';",
+            "export A from 'path';",
             "export * from `path`;",
+            "export 'A' from 'path';",
             "export A as B from 'path';",
+            "export 'A' as B from 'path';",
             "export default from 'path';",
             "export { A }, B from 'path';",
             "export * as A, B from 'path';",
@@ -68,4 +73,109 @@ describe("export", function() {
             }, code);
         });
     });
+    it("Should reject `export` statement not under top-level scope", function() {
+        [
+            "{ export {}; }",
+            "if (0) export var A;",
+            "function f() { export default 42; }",
+        ].forEach(function(code) {
+            assert.throws(function() {
+                UglifyJS.parse(code);
+            }, function(e) {
+                return e instanceof UglifyJS.JS_Parse_Error;
+            }, code);
+        });
+    });
+    it("Should compare `export` statements correctly", function() {
+        var stats = {
+            Declaration: [
+                "export let A;",
+                "export const A = 42;",
+                "export var { A, B: [] } = C;",
+                "export function A() { return B(A); }",
+                "export async function* A({}, ...[]) { return B(A); }",
+            ],
+            Default: [
+                "export default 42;",
+                "export default A => A(B);",
+                "export default class A extends B {}",
+                "export default (class A extends B {});",
+                "export default class A { static C = 42; }",
+                "export default class A extends B { static C = 42; }",
+            ],
+            Foreign: [
+                "export * from 'path';",
+                "export {} from 'path';",
+                "export * as A from 'path';",
+                "export { default } from 'path';",
+                "export { A, B as C } from 'path';",
+                "export { A, default as C } from 'path';",
+            ],
+            References: [
+                "export {};",
+                "export { A };",
+                "export { A as B };",
+                "export { A, B as C };",
+                "export { A as default };",
+            ],
+        };
+        for (var k in stats) stats[k].forEach(function(c, i) {
+            var s = UglifyJS.parse(c);
+            assert.ok(s instanceof UglifyJS.AST_Toplevel, c);
+            assert.strictEqual(s.body.length, 1, c);
+            assert.strictEqual(s.body[0].TYPE, "Export" + k, c);
+            for (var l in stats) stats[l].forEach(function(d, j) {
+                var t = UglifyJS.parse(d);
+                assert.ok(t instanceof UglifyJS.AST_Toplevel, d);
+                assert.strictEqual(t.body.length, 1, d);
+                assert.strictEqual(t.body[0].TYPE, "Export" + l, d);
+                assert.strictEqual(s.equals(t), k === l && i === j, c + "\n" + d);
+            });
+        });
+    });
+    it("Should interoperate with ESTree correctly", function() {
+        [
+            "export var A = 42;",
+            "export default (class A {});",
+            "var A; export { A as '42' };",
+            "export { '42' } from 'path';",
+            "export * as '42' from 'path';",
+        ].forEach(function(code) {
+            var ast = UglifyJS.parse(code);
+            try {
+                var spidermonkey = ast.to_mozilla_ast();
+            } catch (ex) {
+                assert.fail("[to_mozilla_ast] " + ex.stack);
+            }
+            try {
+                var ast2 = UglifyJS.AST_Node.from_mozilla_ast(spidermonkey);
+            } catch (ex) {
+                assert.fail("[from_mozilla_ast] " + ex.stack);
+            }
+            assert.strictEqual(ast2.print_to_string(), ast.print_to_string(), [
+                "spidermonkey:",
+                ast.print_to_string(),
+                ast2.print_to_string(),
+            ].join("\n"));
+            try {
+                var acorn_est = acorn.parse(code, {
+                    ecmaVersion: "latest",
+                    locations: true,
+                    sourceType: "module",
+                });
+            } catch (ex) {
+                assert.fail("[acorn.parse] " + ex.stack);
+            }
+            try {
+                var ast3 = UglifyJS.AST_Node.from_mozilla_ast(acorn_est);
+            } catch (ex) {
+                assert.fail("[from_acorn] " + ex.stack);
+            }
+            assert.strictEqual(ast3.print_to_string(), ast.print_to_string(), [
+                "acorn:",
+                ast.print_to_string(),
+                ast3.print_to_string(),
+            ].join("\n"));
+        });
+    });
 });

test/mocha/imports.js

@@ -1,3 +1,4 @@
+var acorn = require("acorn");
 var assert = require("assert");
 var UglifyJS = require("../node");
 
@@ -8,15 +9,25 @@ describe("import", function() {
             "import A;",
             "import {};",
             "import `path`;",
+            "{ import 'path'; }",
             "import from 'path';",
+            "if (0) import 'path';",
             "import * from 'path';",
+            "import 'A' from 'path';",
+            "import A-B from 'path';",
             "import A as B from 'path';",
             "import { A }, B from 'path';",
+            "import * as 'A' from 'path';",
+            "import * as A-B from 'path';",
             "import * as A, B from 'path';",
             "import * as A, {} from 'path';",
             "import { * as A } from 'path';",
+            "import { * as 'A' } from 'path';",
+            "import { * as A-B } from 'path';",
+            "function f() { import 'path'; }",
             "import { 42 as A } from 'path';",
             "import { A-B as C } from 'path';",
+            "import { 'A' as 'B' } from 'path';",
         ].forEach(function(code) {
             assert.throws(function() {
                 UglifyJS.parse(code);
@@ -25,4 +36,74 @@ describe("import", function() {
             }, code);
         });
     });
+    it("Should compare `import` statements correctly", function() {
+        [
+            "import 'foo';",
+            "import 'path';",
+            "import A from 'path';",
+            "import { A } from 'path';",
+            "import * as A from 'path';",
+            "import A, { B } from 'path';",
+            "import A, * as B from 'path';",
+            "import { A as B } from 'path';",
+            "import A, { B, C as D } from 'path';",
+        ].forEach(function(c, i, stats) {
+            var s = UglifyJS.parse(c);
+            assert.ok(s instanceof UglifyJS.AST_Toplevel, c);
+            assert.strictEqual(s.body.length, 1, c);
+            assert.ok(s.body[0] instanceof UglifyJS.AST_Import, c);
+            stats.forEach(function(d, j) {
+                var t = UglifyJS.parse(d);
+                assert.ok(t instanceof UglifyJS.AST_Toplevel, d);
+                assert.strictEqual(t.body.length, 1, d);
+                assert.ok(t.body[0] instanceof UglifyJS.AST_Import, d);
+                assert.strictEqual(s.equals(t), i === j, c + "\n" + d);
+            });
+        });
+    });
+    it("Should interoperate with ESTree correctly", function() {
+        [
+            "import A from 'path';",
+            "import * as A from 'path';",
+            "import A, * as B from 'path';",
+            "import { '42' as A, B } from 'path';",
+            "import A, { '42' as B } from 'path';",
+        ].forEach(function(code) {
+            var ast = UglifyJS.parse(code);
+            try {
+                var spidermonkey = ast.to_mozilla_ast();
+            } catch (ex) {
+                assert.fail("[to_mozilla_ast] " + ex.stack);
+            }
+            try {
+                var ast2 = UglifyJS.AST_Node.from_mozilla_ast(spidermonkey);
+            } catch (ex) {
+                assert.fail("[from_mozilla_ast] " + ex.stack);
+            }
+            assert.strictEqual(ast2.print_to_string(), ast.print_to_string(), [
+                "spidermonkey:",
+                ast.print_to_string(),
+                ast2.print_to_string(),
+            ].join("\n"));
+            try {
+                var acorn_est = acorn.parse(code, {
+                    ecmaVersion: "latest",
+                    locations: true,
+                    sourceType: "module",
+                });
+            } catch (ex) {
+                assert.fail("[acorn.parse] " + ex.stack);
+            }
+            try {
+                var ast3 = UglifyJS.AST_Node.from_mozilla_ast(acorn_est);
+            } catch (ex) {
+                assert.fail("[from_acorn] " + ex.stack);
+            }
+            assert.strictEqual(ast3.print_to_string(), ast.print_to_string(), [
+                "acorn:",
+                ast.print_to_string(),
+                ast3.print_to_string(),
+            ].join("\n"));
+        });
+    });
 });

test/mozilla-ast.js

@@ -9,19 +9,22 @@ function beautify(ast) {
     var beautified = UglifyJS.minify(ast, {
         compress: false,
         mangle: false,
+        module: ufuzz.module,
         output: {
+            ast: true,
             beautify: true,
             braces: true,
         },
     });
-    if (beautified.error) return beautified;
-    return UglifyJS.minify(beautified.code, {
-        compress: false,
-        mangle: false,
-        output: {
-            ast: true,
-        },
-    });
+    if (!beautified.error) {
+        var verify = UglifyJS.minify(beautified.code, {
+            compress: false,
+            mangle: false,
+            module: ufuzz.module,
+        });
+        if (verify.error) return verify;
+    }
+    return beautified;
 }
 
 function validate(ast) {
@@ -35,6 +38,7 @@ function validate(ast) {
     return UglifyJS.minify(ast, {
         compress: false,
         mangle: false,
+        module: ufuzz.module,
         output: {
             ast: true,
         },
@@ -57,12 +61,12 @@ function test(input, to_moz, description, skip_on_error, beautified) {
         var ast = UglifyJS.AST_Node.from_mozilla_ast(to_moz(input));
     } catch (e) {
         if (skip_on_error) return true;
-        console.log("//=============================================================");
-        console.log("//", description, "failed... round", round);
-        console.log(e);
-        console.log("// original code");
-        if (beautified === true) console.log("// (beautified)");
-        console.log(input.code);
+        console.error("//=============================================================");
+        console.error("//", description, "failed... round", round);
+        console.error(e);
+        console.error("// original code");
+        if (beautified === true) console.error("// (beautified)");
+        console.error(input.code);
         return false;
     }
     var transformed = validate(ast);
@@ -74,34 +78,34 @@ function test(input, to_moz, description, skip_on_error, beautified) {
                 if (!test(beautified, to_moz, description, skip_on_error, true)) return false;
             }
         }
-        console.log("//=============================================================");
-        console.log("// !!!!!! Failed... round", round);
-        console.log("// original code");
+        console.error("//=============================================================");
+        console.error("// !!!!!! Failed... round", round);
+        console.error("// original code");
         if (beautified.error) {
-            console.log("// !!! beautify failed !!!");
-            console.log(beautified.error.stack);
+            console.error("// !!! beautify failed !!!");
+            console.error(beautified.error.stack);
         } else if (beautified === true) {
-            console.log("// (beautified)");
+            console.error("// (beautified)");
         }
-        console.log(input.raw);
-        console.log();
-        console.log();
-        console.log("//-------------------------------------------------------------");
-        console.log("//", description);
+        console.error(input.raw);
+        console.error();
+        console.error();
+        console.error("//-------------------------------------------------------------");
+        console.error("//", description);
         if (transformed.error) {
-            console.log(transformed.error.stack);
+            console.error(transformed.error.stack);
         } else {
             beautified = beautify(transformed.ast);
             if (beautified.error) {
-                console.log("// !!! beautify failed !!!");
-                console.log(beautified.error.stack);
-                console.log(transformed.code);
+                console.error("// !!! beautify failed !!!");
+                console.error(beautified.error.stack);
+                console.error(transformed.code);
             } else {
-                console.log("// (beautified)");
-                console.log(beautified.code);
+                console.error("// (beautified)");
+                console.error(beautified.code);
             }
         }
-        console.log("!!!!!! Failed... round", round);
+        console.error("!!!!!! Failed... round", round);
         return false;
     }
     return true;
@@ -115,9 +119,29 @@ for (var round = 1; round <= num_iterations; round++) {
     var code = ufuzz.createTopLevelCode();
     minify_options.forEach(function(options) {
         var ok = true;
-        var input = UglifyJS.minify(options ? UglifyJS.minify(code, JSON.parse(options)).code : code, {
+        var minified;
+        if (options) {
+            var o = JSON.parse(options);
+            o.module = ufuzz.module;
+            minified = UglifyJS.minify(code, o);
+            if (minified.error) {
+                console.log("//=============================================================");
+                console.log("// minify() failed... round", round);
+                console.log("// original code");
+                console.log(code);
+                console.log();
+                console.log();
+                console.log("//-------------------------------------------------------------");
+                console.log("minify(options):");
+                console.log(JSON.stringify(o, null, 2));
+                return;
+            }
+            minified = minified.code;
+        }
+        var input = UglifyJS.minify(minified || code, {
             compress: false,
             mangle: false,
+            module: ufuzz.module,
             output: {
                 ast: true,
             },
@@ -125,11 +149,27 @@ for (var round = 1; round <= num_iterations; round++) {
         input.raw = options ? input.code : code;
         if (input.error) {
             ok = false;
-            console.log("//=============================================================");
-            console.log("// minify() failed... round", round);
-            console.log(input.error);
-            console.log("// original code");
-            console.log(code);
+            console.error("//=============================================================");
+            console.error("// parse() failed... round", round);
+            console.error("// original code");
+            console.error(code);
+            console.error();
+            console.error();
+            if (options) {
+                console.error("//-------------------------------------------------------------");
+                console.error("// minified code");
+                console.error(minified);
+                console.error();
+                console.error();
+                console.error("//-------------------------------------------------------------");
+                console.error("minify(options):");
+                console.error(JSON.stringify(o, null, 2));
+                console.error();
+                console.error();
+            }
+            console.error("//-------------------------------------------------------------");
+            console.error("// parse() error");
+            console.error(input.error);
         }
         if (ok) ok = test(input, function(input) {
             return input.ast.to_mozilla_ast();
@@ -141,7 +181,10 @@ for (var round = 1; round <= num_iterations; round++) {
                 sourceType: "module",
             });
         }, "acorn.parse()", !ufuzz.verbose);
-        if (!ok) process.exit(1);
+        if (!ok && isFinite(num_iterations)) {
+            console.log();
+            process.exit(1);
+        }
     });
 }
 console.log();

test/reduce.js

@@ -241,23 +241,6 @@ module.exports = function reduce_test(testcase, minify_options, reduce_options)
             CHANGED = true;
             return node.name;
         }
-        else if (node instanceof U.AST_DestructuredArray) {
-            var expr = node.elements[0];
-            if (expr && !(expr instanceof U.AST_Hole)) {
-                node.start._permute++;
-                CHANGED = true;
-                return expr;
-            }
-        }
-        else if (node instanceof U.AST_DestructuredObject) {
-            // first property's value
-            var expr = node.properties[0];
-            if (expr) {
-                node.start._permute++;
-                CHANGED = true;
-                return expr.value;
-            }
-        }
         else if (node instanceof U.AST_Defun) {
             switch (((node.start._permute += step) * steps | 0) % 2) {
               case 0:
@@ -275,6 +258,23 @@ module.exports = function reduce_test(testcase, minify_options, reduce_options)
                 }
             }
         }
+        else if (node instanceof U.AST_DestructuredArray) {
+            var expr = node.elements[0];
+            if (expr && !(expr instanceof U.AST_Hole)) {
+                node.start._permute++;
+                CHANGED = true;
+                return expr;
+            }
+        }
+        else if (node instanceof U.AST_DestructuredObject) {
+            // first property's value
+            var expr = node.properties[0];
+            if (expr) {
+                node.start._permute++;
+                CHANGED = true;
+                return expr.value;
+            }
+        }
         else if (node instanceof U.AST_DWLoop) {
             var expr = [
                 node.condition,
@@ -296,6 +296,16 @@ module.exports = function reduce_test(testcase, minify_options, reduce_options)
                 return to_statement(expr);
             }
         }
+        else if (node instanceof U.AST_ExportDeclaration) {
+            node.start._permute++;
+            CHANGED = true;
+            return node.body;
+        }
+        else if (node instanceof U.AST_ExportDefault) {
+            node.start._permute++;
+            CHANGED = true;
+            return to_statement(node.body);
+        }
         else if (node instanceof U.AST_Finally) {
             // drop finally block
             node.start._permute++;
@@ -351,6 +361,15 @@ module.exports = function reduce_test(testcase, minify_options, reduce_options)
                 return to_statement(expr);
             }
         }
+        else if (node instanceof U.AST_LabeledStatement) {
+            if (node.body instanceof U.AST_Statement
+                && !has_loopcontrol(node.body, node.body, node)) {
+                // replace labelled statement with its non-labelled body
+                node.start._permute = REPLACEMENTS.length;
+                CHANGED = true;
+                return node.body;
+            }
+        }
         else if (node instanceof U.AST_Object) {
             // first property's value
             var expr = node.properties[0];
@@ -441,13 +460,14 @@ module.exports = function reduce_test(testcase, minify_options, reduce_options)
                 return to_statement(node.definitions[0].value);
             }
         }
-        else if (node instanceof U.AST_LabeledStatement) {
-            if (node.body instanceof U.AST_Statement
-                && !has_loopcontrol(node.body, node.body, node)) {
-                // replace labelled statement with its non-labelled body
-                node.start._permute = REPLACEMENTS.length;
+        else if (node instanceof U.AST_VarDef) {
+            if (node.value) {
+                node.start._permute++;
                 CHANGED = true;
-                return node.body;
+                return new U.AST_VarDef({
+                    name: node.name,
+                    start: {},
+                });
             }
         }
 
@@ -778,9 +798,9 @@ function compare_run_code(code, minify_options, result_cache, max_timeout) {
     function run(code, timeout) {
         if (minify_options.module) code = [
             '"use strict";',
-            "(async function(){",
+            "(async()=>{",
             code,
-            "})();"
+            '})().catch(e=>process.on("exit",()=>{throw e}));',
         ].join("\n");
         return run_code(code, toplevel, result_cache, timeout);
     }

test/ufuzz/index.js

@@ -2095,7 +2095,11 @@ function createVarName(maybe, dontStore) {
 }
 
 if (require.main !== module) {
-    exports.createTopLevelCode = createTopLevelCode;
+    exports.createTopLevelCode = function() {
+        var code = createTopLevelCode();
+        exports.module = async && has_await;
+        return code;
+    };
     exports.num_iterations = num_iterations;
     exports.verbose = verbose;
     return;
@@ -2104,9 +2108,9 @@ if (require.main !== module) {
 function run_code(code, toplevel, timeout) {
     if (async && has_await) code = [
         '"use strict";',
-        "(async function(){",
+        "(async()=>{",
         code,
-        "})();"
+        '})().catch(e=>process.on("exit",()=>{throw e}));',
     ].join("\n");
     return sandbox.run_code(sandbox.patch_module_statements(code), toplevel, timeout);
 }