v3.12.2

fixes #4380

README.md

@@ -4,10 +4,12 @@ UglifyJS 3
 UglifyJS is a JavaScript parser, minifier, compressor and beautifier toolkit.
 
 #### Note:
-- **`uglify-js@3` has a simplified [API](#api-reference) and [CLI](#command-line-usage) that is not backwards compatible with [`uglify-js@2`](https://github.com/mishoo/UglifyJS/tree/v2.x)**.
+- **`uglify-js@3` has a simplified [API](#api-reference) and [CLI](#command-line-usage)
+  that is not backwards compatible with [`uglify-js@2`](https://github.com/mishoo/UglifyJS/tree/v2.x)**.
 - **Documentation for UglifyJS `2.x` releases can be found [here](https://github.com/mishoo/UglifyJS/tree/v2.x)**.
-- `uglify-js` only supports JavaScript (ECMAScript 5).
-- To minify ECMAScript 2015 or above, transpile using tools like [Babel](https://babeljs.io/).
+- `uglify-js` supports ECMAScript 5 and some newer language features.
+- To minify ECMAScript 2015 or above, you may need to transpile using tools like
+  [Babel](https://babeljs.io/).
 
 Install
 -------
@@ -135,6 +137,10 @@ a double dash to prevent input files being used as option arguments:
     --toplevel                  Compress and/or mangle variables in top level scope.
     --verbose                   Print diagnostic messages.
     --warn                      Print warning messages.
+    --webkit                    Support non-standard Safari/Webkit.
+                                Equivalent to setting `webkit: true` in `minify()`
+                                for `mangle` and `output` options.
+                                By default UglifyJS will not try to be Safari-proof.
     --wrap <name>               Embed everything in a big function, making the
                                 “exports” and “global” variables available. You
                                 need to pass an argument to this option to
@@ -519,6 +525,9 @@ if (result.error) throw result.error;
 - `warnings` (default `false`) — pass `true` to return compressor warnings
   in `result.warnings`. Use the value `"verbose"` for more detailed warnings.
 
+- `webkit` (default `false`) -- enable workarounds for Safari/WebKit bugs.
+  PhantomJS users should set this option to `true`.
+
 ## Minify options structure
 
 ```javascript
@@ -744,6 +753,8 @@ to be `false` and all symbol names will be omitted.
   annotation `/*@__PURE__*/` or `/*#__PURE__*/` immediately precedes the call. For
   example: `/*@__PURE__*/foo();`
 
+- `spread` (default: `true`) -- flatten spread expressions.
+
 - `strings` (default: `true`) -- compact string concatenations.
 
 - `switches` (default: `true`) -- de-duplicate and remove unreachable `switch` branches
@@ -868,6 +879,8 @@ can pass additional arguments that control the code output:
   }
   ```
 
+- `galio` (default `false`) -- enable workarounds for ANT Galio bugs
+
 - `indent_level` (default `4`)
 
 - `indent_start` (default `0`) -- prefix all lines by that many spaces
@@ -906,8 +919,7 @@ can pass additional arguments that control the code output:
 
 - `shebang` (default `true`) -- preserve shebang `#!` in preamble (bash scripts)
 
-- `webkit` (default `false`) -- enable workarounds for WebKit bugs.
-  PhantomJS users should set this option to `true`.
+- `v8` (default `false`) -- enable workarounds for Chrome & Node.js bugs
 
 - `width` (default `80`) -- only takes effect when beautification is on, this
   specifies an (orientative) line width that the beautifier will try to
@@ -1138,7 +1150,7 @@ To enable fast minify mode with the API use:
 UglifyJS.minify(code, { compress: false, mangle: true });
 ```
 
-#### Source maps and debugging
+### Source maps and debugging
 
 Various `compress` transforms that simplify, rearrange, inline and remove code
 are known to have an adverse effect on debugging with source maps. This is
@@ -1150,6 +1162,10 @@ disable the Uglify `compress` option and just use `mangle`.
 
 To allow for better optimizations, the compiler makes various assumptions:
 
+- The code does not rely on preserving its runtime performance characteristics.
+  Typically uglified code will run faster due to less instructions and easier
+  inlining, but may be slower on rare occasions for a specific platform, e.g.
+  see [`reduce_funcs`](#compress-options).
 - `.toString()` and `.valueOf()` don't have side effects, and for built-in
   objects they have not been overridden.
 - `undefined`, `NaN` and `Infinity` have not been externally redefined.
@@ -1161,6 +1177,18 @@ To allow for better optimizations, the compiler makes various assumptions:
 - Object properties can be added, removed and modified (not prevented with
   `Object.defineProperty()`, `Object.defineProperties()`, `Object.freeze()`,
   `Object.preventExtensions()` or `Object.seal()`).
+- Earlier versions of JavaScript will throw `SyntaxError` with the following:
+  ```js
+  ({
+    p: 42,
+    get p() {},
+  });
+  // SyntaxError: Object literal may not have data and accessor property with
+  //              the same name
+  ```
+  UglifyJS may modify the input which in turn may suppress those errors.
+- Iteration order of keys over an object which contains spread syntax in later
+  versions of Chrome and Node.js may be altered.
 - When `toplevel` is enabled, UglifyJS effectively assumes input code is wrapped
   within `function(){ ... }`, thus forbids aliasing of declared global variables:
   ```js
@@ -1177,3 +1205,7 @@ To allow for better optimizations, the compiler makes various assumptions:
   top.B = "PASS";
   console.log(B);
   ```
+- Use of `arguments` alongside destructuring as function parameters, e.g.
+  `function({}, arguments) {}` will result in `SyntaxError` in earlier versions
+  of Chrome and Node.js - UglifyJS may modify the input which in turn may
+  suppress those errors.

bin/uglifyjs

@@ -111,6 +111,7 @@ function process_option(name, no_value) {
                 "  --validate                               Perform validation during AST manipulations.",
                 "  --verbose                                Print diagnostic messages.",
                 "  --warn                                   Print warning messages.",
+                "  --webkit                                 Support non-standard Safari/Webkit.",
                 "  --wrap <name>                            Embed everything as a function with “exports” corresponding to “name” globally.",
                 "  --reduce-test                            Reduce a standalone test case (assumes cloned repository).",
             ].join("\n"));
@@ -142,6 +143,7 @@ function process_option(name, no_value) {
       case "timings":
       case "toplevel":
       case "validate":
+      case "webkit":
         options[name] = true;
         break;
       case "keep-fnames":

lib/ast.js

@@ -209,7 +209,9 @@ var AST_EmptyStatement = DEFNODE("EmptyStatement", null, {
 
 function must_be_expression(node, prop) {
     if (!(node[prop] instanceof AST_Node)) throw new Error(prop + " must be AST_Node");
-    if (node[prop] instanceof AST_Statement && !(node[prop] instanceof AST_Function)) {
+    if (node[prop] instanceof AST_Hole) throw new Error(prop + " cannot be AST_Hole");
+    if (node[prop] instanceof AST_Spread) throw new Error(prop + " cannot be AST_Spread");
+    if (node[prop] instanceof AST_Statement && !is_function(node[prop])) {
         throw new Error(prop + " cannot be AST_Statement");
     }
 }
@@ -278,7 +280,7 @@ var AST_Block = DEFNODE("Block", "body", {
     _validate: function() {
         this.body.forEach(function(node) {
             if (!(node instanceof AST_Statement)) throw new Error("body must be AST_Statement[]");
-            if (node instanceof AST_Function) throw new Error("body cannot contain AST_Function");
+            if (is_function(node)) throw new Error("body cannot contain AST_Function");
         });
     },
 }, AST_BlockScope);
@@ -294,7 +296,7 @@ var AST_StatementWithBody = DEFNODE("StatementWithBody", "body", {
     },
     _validate: function() {
         if (!(this.body instanceof AST_Statement)) throw new Error("body must be AST_Statement");
-        if (this.body instanceof AST_Function) throw new Error("body cannot be AST_Function");
+        if (is_function(this.body)) throw new Error("body cannot be AST_Function");
     },
 }, AST_BlockScope);
 
@@ -388,7 +390,7 @@ var AST_For = DEFNODE("For", "init condition step", {
         if (this.init != null) {
             if (!(this.init instanceof AST_Node)) throw new Error("init must be AST_Node");
             if (this.init instanceof AST_Statement
-                && !(this.init instanceof AST_Definitions || this.init instanceof AST_Function)) {
+                && !(this.init instanceof AST_Definitions || is_function(this.init))) {
                 throw new Error("init cannot be AST_Statement");
             }
         }
@@ -414,8 +416,12 @@ var AST_ForIn = DEFNODE("ForIn", "init object", {
     _validate: function() {
         if (this.init instanceof AST_Definitions) {
             if (this.init.definitions.length != 1) throw new Error("init must have single declaration");
-        } else if (!(this.init instanceof AST_PropAccess || this.init instanceof AST_SymbolRef)) {
-            throw new Error("init must be assignable");
+        } else {
+            validate_destructured(this.init, function(node) {
+                if (!(node instanceof AST_PropAccess || node instanceof AST_SymbolRef)) {
+                    throw new Error("init must be assignable: " + node.TYPE);
+                }
+            });
         }
         must_be_expression(this, "object");
     },
@@ -496,12 +502,24 @@ var AST_Toplevel = DEFNODE("Toplevel", "globals", {
     }
 }, AST_Scope);
 
-var AST_Lambda = DEFNODE("Lambda", "name argnames uses_arguments length_read", {
+var AST_Lambda = DEFNODE("Lambda", "name argnames length_read uses_arguments", {
     $documentation: "Base class for functions",
     $propdoc: {
         name: "[AST_SymbolDeclaration?] the name of this function",
-        argnames: "[AST_SymbolFunarg*] array of function arguments",
-        uses_arguments: "[boolean/S] tells whether this function accesses the arguments array"
+        argnames: "[(AST_Destructured|AST_SymbolFunarg)*] array of function arguments and/or destructured literals",
+        uses_arguments: "[boolean/S] tells whether this function accesses the arguments array",
+    },
+    each_argname: function(visit) {
+        var tw = new TreeWalker(function(node) {
+            if (node instanceof AST_DestructuredKeyVal) {
+                node.value.walk(tw);
+                return true;
+            }
+            if (node instanceof AST_SymbolFunarg) visit(node);
+        });
+        this.argnames.forEach(function(argname) {
+            argname.walk(tw);
+        });
     },
     walk: function(visitor) {
         var node = this;
@@ -515,7 +533,9 @@ var AST_Lambda = DEFNODE("Lambda", "name argnames uses_arguments length_read", {
     },
     _validate: function() {
         this.argnames.forEach(function(node) {
-            if (!(node instanceof AST_SymbolFunarg)) throw new Error("argnames must be AST_SymbolFunarg[]");
+            validate_destructured(node, function(node) {
+                if (!(node instanceof AST_SymbolFunarg)) throw new Error("argnames must be AST_SymbolFunarg[]");
+            });
         });
     },
 }, AST_Scope);
@@ -527,6 +547,19 @@ var AST_Accessor = DEFNODE("Accessor", null, {
     },
 }, AST_Lambda);
 
+function is_function(node) {
+    return node instanceof AST_AsyncFunction || node instanceof AST_Function;
+}
+
+var AST_AsyncFunction = DEFNODE("AsyncFunction", "inlined", {
+    $documentation: "An asynchronous function expression",
+    _validate: function() {
+        if (this.name != null) {
+            if (!(this.name instanceof AST_SymbolLambda)) throw new Error("name must be AST_SymbolLambda");
+        }
+    },
+}, AST_Lambda);
+
 var AST_Function = DEFNODE("Function", "inlined", {
     $documentation: "A function expression",
     _validate: function() {
@@ -536,6 +569,17 @@ var AST_Function = DEFNODE("Function", "inlined", {
     },
 }, AST_Lambda);
 
+function is_defun(node) {
+    return node instanceof AST_AsyncDefun || node instanceof AST_Defun;
+}
+
+var AST_AsyncDefun = DEFNODE("AsyncDefun", "inlined", {
+    $documentation: "An asynchronous function definition",
+    _validate: function() {
+        if (!(this.name instanceof AST_SymbolDefun)) throw new Error("name must be AST_SymbolDefun");
+    },
+}, AST_Lambda);
+
 var AST_Defun = DEFNODE("Defun", "inlined", {
     $documentation: "A function definition",
     _validate: function() {
@@ -622,7 +666,7 @@ var AST_If = DEFNODE("If", "condition alternative", {
         must_be_expression(this, "condition");
         if (this.alternative != null) {
             if (!(this.alternative instanceof AST_Statement)) throw new Error("alternative must be AST_Statement");
-            if (this.alternative instanceof AST_Function) throw new error("alternative cannot be AST_Function");
+            if (is_function(this.alternative)) throw new error("alternative cannot be AST_Function");
         }
     },
 }, AST_StatementWithBody);
@@ -748,8 +792,10 @@ var AST_Const = DEFNODE("Const", null, {
     _validate: function() {
         this.definitions.forEach(function(node) {
             if (!(node instanceof AST_VarDef)) throw new Error("definitions must be AST_VarDef[]");
-            if (!(node.name instanceof AST_SymbolConst)) throw new Error("name must be AST_SymbolConst");
-            must_be_expression(node, "value");
+            validate_destructured(node.name, function(node) {
+                if (!(node instanceof AST_SymbolConst)) throw new Error("name must be AST_SymbolConst");
+            });
+            if (node.value != null) must_be_expression(node, "value");
         });
     },
 }, AST_Definitions);
@@ -759,7 +805,9 @@ var AST_Let = DEFNODE("Let", null, {
     _validate: function() {
         this.definitions.forEach(function(node) {
             if (!(node instanceof AST_VarDef)) throw new Error("definitions must be AST_VarDef[]");
-            if (!(node.name instanceof AST_SymbolLet)) throw new Error("name must be AST_SymbolLet");
+            validate_destructured(node.name, function(node) {
+                if (!(node instanceof AST_SymbolLet)) throw new Error("name must be AST_SymbolLet");
+            });
             if (node.value != null) must_be_expression(node, "value");
         });
     },
@@ -770,7 +818,9 @@ var AST_Var = DEFNODE("Var", null, {
     _validate: function() {
         this.definitions.forEach(function(node) {
             if (!(node instanceof AST_VarDef)) throw new Error("definitions must be AST_VarDef[]");
-            if (!(node.name instanceof AST_SymbolVar)) throw new Error("name must be AST_SymbolVar");
+            validate_destructured(node.name, function(node) {
+                if (!(node instanceof AST_SymbolVar)) throw new Error("name must be AST_SymbolVar");
+            });
             if (node.value != null) must_be_expression(node, "value");
         });
     },
@@ -793,10 +843,12 @@ var AST_VarDef = DEFNODE("VarDef", "name value", {
 
 /* -----[ OTHER ]----- */
 
-function must_be_expressions(node, prop) {
+function must_be_expressions(node, prop, allow_spread, allow_hole) {
     node[prop].forEach(function(node) {
         if (!(node instanceof AST_Node)) throw new Error(prop + " must be AST_Node[]");
-        if (node instanceof AST_Statement && !(node instanceof AST_Function)) {
+        if (!allow_hole && node instanceof AST_Hole) throw new Error(prop + " cannot be AST_Hole");
+        if (!allow_spread && node instanceof AST_Spread) throw new Error(prop + " cannot be AST_Spread");
+        if (node instanceof AST_Statement && !is_function(node)) {
             throw new Error(prop + " cannot contain AST_Statement");
         }
     });
@@ -819,7 +871,7 @@ var AST_Call = DEFNODE("Call", "expression args pure", {
     },
     _validate: function() {
         must_be_expression(this, "expression");
-        must_be_expressions(this, "args");
+        must_be_expressions(this, "args", true);
     },
 });
 
@@ -896,6 +948,22 @@ var AST_Sub = DEFNODE("Sub", null, {
     },
 }, AST_PropAccess);
 
+var AST_Spread = DEFNODE("Spread", "expression", {
+    $documentation: "Spread expression in array/object literals or function calls",
+    $propdoc: {
+        expression: "[AST_Node] expression to be expanded",
+    },
+    walk: function(visitor) {
+        var node = this;
+        visitor.visit(node, function() {
+            node.expression.walk(visitor);
+        });
+    },
+    _validate: function() {
+        must_be_expression(this, "expression");
+    },
+});
+
 var AST_Unary = DEFNODE("Unary", "operator expression", {
     $documentation: "Base class for unary expressions",
     $propdoc: {
@@ -969,9 +1037,33 @@ var AST_Assign = DEFNODE("Assign", null, {
     $documentation: "An assignment expression — `a = b + 5`",
     _validate: function() {
         if (this.operator.indexOf("=") < 0) throw new Error('operator must contain "="');
+        if (this.left instanceof AST_Destructured) {
+            if (this.operator != "=") throw new Error("invalid destructuring operator: " + this.operator);
+            validate_destructured(this.left, function(node) {
+                if (!(node instanceof AST_PropAccess || node instanceof AST_SymbolRef)) {
+                    throw new Error("left must be assignable: " + node.TYPE);
+                }
+            });
+        }
     },
 }, AST_Binary);
 
+var AST_Await = DEFNODE("Await", "expression", {
+    $documentation: "An await expression",
+    $propdoc: {
+        expression: "[AST_Node] expression with Promise to resolve on",
+    },
+    walk: function(visitor) {
+        var node = this;
+        visitor.visit(node, function() {
+            node.expression.walk(visitor);
+        });
+    },
+    _validate: function() {
+        must_be_expression(this, "expression");
+    },
+});
+
 /* -----[ LITERALS ]----- */
 
 var AST_Array = DEFNODE("Array", "elements", {
@@ -988,14 +1080,65 @@ var AST_Array = DEFNODE("Array", "elements", {
         });
     },
     _validate: function() {
-        must_be_expressions(this, "elements");
+        must_be_expressions(this, "elements", true, true);
     },
 });
 
-var AST_Object = DEFNODE("Object", "properties", {
-    $documentation: "An object literal",
+var AST_Destructured = DEFNODE("Destructured", null, {
+    $documentation: "Base class for destructured literal",
+});
+
+function validate_destructured(node, check) {
+    if (node instanceof AST_DestructuredArray) return node.elements.forEach(function(node) {
+        if (!(node instanceof AST_Hole)) validate_destructured(node, check);
+    });
+    if (node instanceof AST_DestructuredObject) return node.properties.forEach(function(prop) {
+        validate_destructured(prop.value, check);
+    });
+    check(node);
+}
+
+var AST_DestructuredArray = DEFNODE("DestructuredArray", "elements", {
+    $documentation: "A destructured array literal",
     $propdoc: {
-        properties: "[AST_ObjectProperty*] array of properties"
+        elements: "[AST_Node*] array of elements",
+    },
+    walk: function(visitor) {
+        var node = this;
+        visitor.visit(node, function() {
+            node.elements.forEach(function(element) {
+                element.walk(visitor);
+            });
+        });
+    },
+}, AST_Destructured);
+
+var AST_DestructuredKeyVal = DEFNODE("DestructuredKeyVal", "key value", {
+    $documentation: "A key: value destructured property",
+    $propdoc: {
+        key: "[string|AST_Node] property name.  For computed property this is an AST_Node.",
+        value: "[AST_Node] property value",
+    },
+    walk: function(visitor) {
+        var node = this;
+        visitor.visit(node, function() {
+            if (node.key instanceof AST_Node) node.key.walk(visitor);
+            node.value.walk(visitor);
+        });
+    },
+    _validate: function() {
+        if (typeof this.key != "string") {
+            if (!(this.key instanceof AST_Node)) throw new Error("key must be string or AST_Node");
+            must_be_expression(this, "key");
+        }
+        must_be_expression(this, "value");
+    },
+});
+
+var AST_DestructuredObject = DEFNODE("DestructuredObject", "properties", {
+    $documentation: "A destructured object literal",
+    $propdoc: {
+        properties: "[AST_DestructuredKeyVal*] array of properties",
     },
     walk: function(visitor) {
         var node = this;
@@ -1007,7 +1150,29 @@ var AST_Object = DEFNODE("Object", "properties", {
     },
     _validate: function() {
         this.properties.forEach(function(node) {
-            if (!(node instanceof AST_ObjectProperty)) throw new Error("properties must be AST_ObjectProperty[]");
+            if (!(node instanceof AST_DestructuredKeyVal)) throw new Error("properties must be AST_DestructuredKeyVal[]");
+        });
+    },
+}, AST_Destructured);
+
+var AST_Object = DEFNODE("Object", "properties", {
+    $documentation: "An object literal",
+    $propdoc: {
+        properties: "[(AST_ObjectProperty|AST_Spread)*] array of properties"
+    },
+    walk: function(visitor) {
+        var node = this;
+        visitor.visit(node, function() {
+            node.properties.forEach(function(prop) {
+                prop.walk(visitor);
+            });
+        });
+    },
+    _validate: function() {
+        this.properties.forEach(function(node) {
+            if (!(node instanceof AST_ObjectProperty || node instanceof AST_Spread)) {
+                throw new Error("properties must contain AST_ObjectProperty and/or AST_Spread only");
+            }
         });
     },
 });
@@ -1015,24 +1180,28 @@ var AST_Object = DEFNODE("Object", "properties", {
 var AST_ObjectProperty = DEFNODE("ObjectProperty", "key value", {
     $documentation: "Base class for literal object properties",
     $propdoc: {
-        key: "[string|AST_SymbolAccessor] property name. For ObjectKeyVal this is a string. For getters and setters this is an AST_SymbolAccessor.",
-        value: "[AST_Node] property value.  For getters and setters this is an AST_Accessor."
+        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.",
     },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
+            if (node.key instanceof AST_Node) node.key.walk(visitor);
             node.value.walk(visitor);
         });
-    }
-});
-
-var AST_ObjectKeyVal = DEFNODE("ObjectKeyVal", "quote", {
-    $documentation: "A key: value object property",
-    $propdoc: {
-        quote: "[string] the original quote character"
     },
     _validate: function() {
-        if (typeof this.key != "string") throw new Error("key must be string");
+        if (typeof this.key != "string") {
+            if (!(this.key instanceof AST_Node)) throw new Error("key must be string or AST_Node");
+            must_be_expression(this, "key");
+        }
+        if (!(this.value instanceof AST_Node)) throw new Error("value must be AST_Node");
+    },
+});
+
+var AST_ObjectKeyVal = DEFNODE("ObjectKeyVal", null, {
+    $documentation: "A key: value object property",
+    _validate: function() {
         must_be_expression(this, "value");
     },
 }, AST_ObjectProperty);
@@ -1040,7 +1209,6 @@ var AST_ObjectKeyVal = DEFNODE("ObjectKeyVal", "quote", {
 var AST_ObjectSetter = DEFNODE("ObjectSetter", null, {
     $documentation: "An object setter property",
     _validate: function() {
-        if (!(this.key instanceof AST_SymbolAccessor)) throw new Error("key must be AST_SymbolAccessor");
         if (!(this.value instanceof AST_Accessor)) throw new Error("value must be AST_Accessor");
     },
 }, AST_ObjectProperty);
@@ -1048,7 +1216,6 @@ var AST_ObjectSetter = DEFNODE("ObjectSetter", null, {
 var AST_ObjectGetter = DEFNODE("ObjectGetter", null, {
     $documentation: "An object getter property",
     _validate: function() {
-        if (!(this.key instanceof AST_SymbolAccessor)) throw new Error("key must be AST_SymbolAccessor");
         if (!(this.value instanceof AST_Accessor)) throw new Error("value must be AST_Accessor");
     },
 }, AST_ObjectProperty);
@@ -1065,10 +1232,6 @@ var AST_Symbol = DEFNODE("Symbol", "scope name thedef", {
     },
 });
 
-var AST_SymbolAccessor = DEFNODE("SymbolAccessor", null, {
-    $documentation: "The name of a property accessor (setter/getter function)"
-}, AST_Symbol);
-
 var AST_SymbolDeclaration = DEFNODE("SymbolDeclaration", "init", {
     $documentation: "A declaration symbol (symbol in var, function name or argument, symbol in catch)",
 }, AST_Symbol);
@@ -1288,14 +1451,13 @@ TreeWalker.prototype = {
                 || p.tail_node() === self) {
                 self = p;
             } else if (p instanceof AST_Return) {
-                var fn;
-                do {
-                    fn = this.parent(++i);
-                    if (!fn) return false;
-                } while (!(fn instanceof AST_Lambda));
-                if (fn.name) return false;
-                self = this.parent(++i);
-                if (!self || self.TYPE != "Call" || self.expression !== fn) return false;
+                for (var call, fn = p; call = this.parent(++i); fn = call) {
+                    if (call.TYPE == "Call") {
+                        if (!(fn instanceof AST_Lambda) || fn.name) return false;
+                    } else if (fn instanceof AST_Lambda) {
+                        return false;
+                    }
+                }
             } else {
                 return false;
             }

lib/minify.js

@@ -89,6 +89,7 @@ function minify(files, options) {
             toplevel: false,
             validate: false,
             warnings: false,
+            webkit: false,
             wrap: false,
         }, true);
         if (options.validate) AST_Node.enable_validation();
@@ -101,6 +102,7 @@ function minify(files, options) {
         set_shorthand("ie8", options, [ "compress", "mangle", "output" ]);
         set_shorthand("keep_fnames", options, [ "compress", "mangle" ]);
         set_shorthand("toplevel", options, [ "compress", "mangle" ]);
+        set_shorthand("webkit", options, [ "mangle", "output" ]);
         var quoted_props;
         if (options.mangle) {
             options.mangle = defaults(options.mangle, {
@@ -111,6 +113,7 @@ function minify(files, options) {
                 properties: false,
                 reserved: [],
                 toplevel: false,
+                webkit: false,
             }, true);
             if (options.mangle.properties) {
                 if (typeof options.mangle.properties != "object") {

lib/mozilla-ast.js

@@ -115,9 +115,6 @@
                 value    : from_moz(M.value)
             };
             if (M.kind == "init") return new AST_ObjectKeyVal(args);
-            args.key = new AST_SymbolAccessor({
-                name: args.key
-            });
             args.value = new AST_Accessor(args.value);
             if (M.kind == "get") return new AST_ObjectGetter(args);
             if (M.kind == "set") return new AST_ObjectSetter(args);
@@ -385,7 +382,7 @@
     def_to_moz(AST_ObjectProperty, function To_Moz_Property(M) {
         var key = {
             type: "Literal",
-            value: M.key instanceof AST_SymbolAccessor ? M.key.name : M.key
+            value: M.key
         };
         var kind;
         if (M instanceof AST_ObjectKeyVal) {

lib/output.js

@@ -56,6 +56,7 @@ function OutputStream(options) {
         beautify         : false,
         braces           : false,
         comments         : false,
+        galio            : false,
         ie8              : false,
         indent_level     : 4,
         indent_start     : 0,
@@ -69,6 +70,7 @@ function OutputStream(options) {
         semicolons       : true,
         shebang          : true,
         source_map       : null,
+        v8               : false,
         webkit           : false,
         width            : 80,
         wrap_iife        : false,
@@ -499,11 +501,11 @@ function OutputStream(options) {
                 }
             }
             if (/comment[134]/.test(c.type)) {
-                print("//" + c.value.replace(/[@#]__PURE__/g, ' ') + "\n");
+                print("//" + c.value.replace(/[@#]__PURE__/g, " ") + "\n");
                 indent();
                 last_nlb = true;
             } else if (c.type == "comment2") {
-                print("/*" + c.value.replace(/[@#]__PURE__/g, ' ') + "*/");
+                print("/*" + c.value.replace(/[@#]__PURE__/g, " ") + "*/");
                 last_nlb = false;
             }
         });
@@ -557,10 +559,10 @@ function OutputStream(options) {
                 space();
             }
             if (/comment[134]/.test(c.type)) {
-                print("//" + c.value.replace(/[@#]__PURE__/g, ' '));
+                print("//" + c.value.replace(/[@#]__PURE__/g, " "));
                 need_newline_indented = true;
             } else if (c.type == "comment2") {
-                print("/*" + c.value.replace(/[@#]__PURE__/g, ' ') + "*/");
+                print("/*" + c.value.replace(/[@#]__PURE__/g, " ") + "*/");
                 need_space = true;
             }
         });
@@ -610,7 +612,7 @@ function OutputStream(options) {
         },
         parent          : function(n) {
             return stack[stack.length - 2 - (n || 0)];
-        }
+        },
     };
 }
 
@@ -652,36 +654,33 @@ function OutputStream(options) {
     /* -----[ PARENTHESES ]----- */
 
     function PARENS(nodetype, func) {
-        if (Array.isArray(nodetype)) {
-            nodetype.forEach(function(nodetype) {
-                PARENS(nodetype, func);
-            });
-        } else {
-            nodetype.DEFMETHOD("needs_parens", func);
-        }
+        nodetype.DEFMETHOD("needs_parens", func);
     }
 
     PARENS(AST_Node, return_false);
 
     // a function expression needs parens around it when it's provably
     // the first token to appear in a statement.
-    PARENS(AST_Function, function(output) {
+    function needs_parens_function(output) {
         if (!output.has_parens() && first_in_statement(output)) return true;
-        if (output.option('webkit')) {
+        if (output.option("webkit")) {
             var p = output.parent();
             if (p instanceof AST_PropAccess && p.expression === this) return true;
         }
-        if (output.option('wrap_iife')) {
+        if (output.option("wrap_iife")) {
             var p = output.parent();
             if (p instanceof AST_Call && p.expression === this) return true;
         }
-    });
+    }
+    PARENS(AST_AsyncFunction, needs_parens_function);
+    PARENS(AST_Function, needs_parens_function);
 
     // same goes for an object literal, because otherwise it would be
     // interpreted as a block of code.
-    PARENS(AST_Object, function(output) {
+    function needs_parens_obj(output) {
         return !output.has_parens() && first_in_statement(output);
-    });
+    }
+    PARENS(AST_Object, needs_parens_obj);
 
     PARENS(AST_Unary, function(output) {
         var p = output.parent();
@@ -692,6 +691,8 @@ function OutputStream(options) {
         var p = output.parent();
             // [ 1, (2, 3), 4 ] ==> [ 1, 3, 4 ]
         return p instanceof AST_Array
+            // await (foo, bar)
+            || p instanceof AST_Await
             // 1 + (2, 3) + 4 ==> 8
             || p instanceof AST_Binary
             // new (foo, bar) or foo(1, (2, 3), 4)
@@ -699,10 +700,14 @@ function OutputStream(options) {
             // (false, true) ? (a = 10, b = 20) : (c = 30)
             // ==> 20 (side effect, set a := 10 and b := 20)
             || p instanceof AST_Conditional
+            // { [(1, 2)]: 3 }[2] ==> 3
             // { foo: (1, 2) }.foo ==> 2
+            || p instanceof AST_DestructuredKeyVal
             || p instanceof AST_ObjectProperty
             // (1, {foo:2}).foo or (1, {foo:2})["foo"] ==> 2
             || p instanceof AST_PropAccess && p.expression === this
+            // ...(foo, bar, baz)
+            || p instanceof AST_Spread
             // !(foo, bar, baz)
             || p instanceof AST_Unary
             // var a = (1, 2), b = a + a; ==> b == 4
@@ -711,6 +716,8 @@ function OutputStream(options) {
 
     PARENS(AST_Binary, function(output) {
         var p = output.parent();
+        // await (foo && bar)
+        if (p instanceof AST_Await) return true;
         // this deals with precedence: 3 * (2 + 1)
         if (p instanceof AST_Binary) {
             var po = p.operator, pp = PRECEDENCE[po];
@@ -746,7 +753,7 @@ function OutputStream(options) {
         var p = output.parent();
         if (p instanceof AST_New) return p.expression === this;
         // https://bugs.webkit.org/show_bug.cgi?id=123506
-        if (output.option('webkit')) {
+        if (output.option("webkit")) {
             var g = output.parent(1);
             return this.expression instanceof AST_Function
                 && p instanceof AST_PropAccess
@@ -769,24 +776,48 @@ function OutputStream(options) {
         var p = output.parent();
         if (p instanceof AST_PropAccess && p.expression === this) {
             var value = this.value;
-            // https://github.com/mishoo/UglifyJS/issues/115
-            // https://github.com/mishoo/UglifyJS/pull/1009
-            return value < 0 || /^0/.test(make_num(value));
+                // https://github.com/mishoo/UglifyJS/issues/115
+            return value < 0
+                // https://github.com/mishoo/UglifyJS/pull/1009
+                || output.option("galio") && /^0/.test(make_num(value));
         }
     });
 
-    PARENS([ AST_Assign, AST_Conditional ], function(output) {
+    function needs_parens_assign_cond(self, output) {
         var p = output.parent();
+        // await (a = foo)
+        if (p instanceof AST_Await) return true;
         // 1 + (a = 2) + 3 → 6, side effect setting a = 2
         if (p instanceof AST_Binary) return !(p instanceof AST_Assign);
         // (a = func)() —or— new (a = Object)()
-        if (p instanceof AST_Call) return p.expression === this;
+        if (p instanceof AST_Call) return p.expression === self;
         // (a = foo) ? bar : baz
-        if (p instanceof AST_Conditional) return p.condition === this;
+        if (p instanceof AST_Conditional) return p.condition === self;
         // (a = foo)["prop"] —or— (a = foo).prop
-        if (p instanceof AST_PropAccess) return p.expression === this;
+        if (p instanceof AST_PropAccess) return p.expression === self;
         // !(a = false) → true
         if (p instanceof AST_Unary) return true;
+    }
+    PARENS(AST_Assign, function(output) {
+        if (needs_parens_assign_cond(this, output)) return true;
+        //  v8 parser bug   =>     workaround
+        // f([1], [a] = []) => f([1], ([a] = []))
+        if (output.option("v8")) return this.left instanceof AST_Destructured;
+        // ({ p: a } = o);
+        if (this.left instanceof AST_DestructuredObject) return needs_parens_obj(output);
+    });
+    PARENS(AST_Conditional, function(output) {
+        return needs_parens_assign_cond(this, output);
+    });
+
+    PARENS(AST_Await, function(output) {
+        var p = output.parent();
+        // new (await foo)
+        // (await foo)(bar)
+        if (p instanceof AST_Call) return p.expression === this;
+        // (await foo).prop
+        // (await foo)["prop"]
+        if (p instanceof AST_PropAccess) return p.expression === this;
     });
 
     /* -----[ PRINTERS ]----- */
@@ -954,11 +985,7 @@ function OutputStream(options) {
     });
 
     /* -----[ functions ]----- */
-    DEFPRINT(AST_Lambda, function(output, nokeyword) {
-        var self = this;
-        if (!nokeyword) {
-            output.print("function");
-        }
+    function print_lambda(self, output) {
         if (self.name) {
             output.space();
             self.name.print(output);
@@ -971,7 +998,19 @@ function OutputStream(options) {
         });
         output.space();
         print_braced(self, output, true);
+    }
+    DEFPRINT(AST_Lambda, function(output) {
+        output.print("function");
+        print_lambda(this, output);
     });
+    function print_async(output) {
+        output.print("async");
+        output.space();
+        output.print("function");
+        print_lambda(this, output);
+    }
+    DEFPRINT(AST_AsyncDefun, print_async);
+    DEFPRINT(AST_AsyncFunction, print_async);
 
     /* -----[ jumps ]----- */
     function print_jump(kind, prop) {
@@ -1220,6 +1259,10 @@ function OutputStream(options) {
         this.property.print(output);
         output.print("]");
     });
+    DEFPRINT(AST_Spread, function(output) {
+        output.print("...");
+        this.expression.print(output);
+    });
     DEFPRINT(AST_UnaryPrefix, function(output) {
         var op = this.operator;
         var exp = this.expression;
@@ -1255,6 +1298,11 @@ function OutputStream(options) {
         output.colon();
         self.alternative.print(output);
     });
+    DEFPRINT(AST_Await, function(output) {
+        output.print("await");
+        output.space();
+        this.expression.print(output);
+    });
 
     /* -----[ literals ]----- */
     DEFPRINT(AST_Array, function(output) {
@@ -1273,6 +1321,38 @@ function OutputStream(options) {
             output.space();
         } : noop);
     });
+    DEFPRINT(AST_DestructuredArray, function(output) {
+        var a = this.elements, len = a.length;
+        output.with_square(len > 0 ? function() {
+            output.space();
+            a.forEach(function(exp, i) {
+                if (i) output.comma();
+                exp.print(output);
+                // If the final element is a hole, we need to make sure it
+                // doesn't look like a trailing comma, by inserting an actual
+                // trailing comma.
+                if (i === len - 1 && exp instanceof AST_Hole)
+                  output.comma();
+            });
+            output.space();
+        } : noop);
+    });
+    DEFPRINT(AST_DestructuredKeyVal, print_key_value);
+    DEFPRINT(AST_DestructuredObject, function(output) {
+        var props = this.properties;
+        if (props.length > 0) output.with_block(function() {
+            props.forEach(function(prop, i) {
+                if (i) {
+                    output.print(",");
+                    output.newline();
+                }
+                output.indent();
+                prop.print(output);
+            });
+            output.newline();
+        });
+        else print_braced_empty(this, output);
+    });
     DEFPRINT(AST_Object, function(output) {
         var props = this.properties;
         if (props.length > 0) output.with_block(function() {
@@ -1289,35 +1369,44 @@ function OutputStream(options) {
         else print_braced_empty(this, output);
     });
 
-    function print_property_name(key, quote, output) {
-        if (output.option("quote_keys")) {
+    function print_property_key(self, output) {
+        var key = self.key;
+        if (key instanceof AST_Node) {
+            output.with_square(function() {
+                key.print(output);
+            });
+        } else if (output.option("quote_keys")) {
             output.print_string(key);
         } else if ("" + +key == key && key >= 0) {
             output.print(make_num(key));
-        } else if (RESERVED_WORDS[key] ? !output.option("ie8") : is_identifier_string(key)) {
-            if (quote && output.option("keep_quoted_props")) {
-                output.print_string(key, quote);
-            } else {
-                output.print_name(key);
-            }
         } else {
-            output.print_string(key, quote);
+            var quote = self.start && self.start.quote;
+            if (RESERVED_WORDS[key] ? !output.option("ie8") : is_identifier_string(key)) {
+                if (quote && output.option("keep_quoted_props")) {
+                    output.print_string(key, quote);
+                } else {
+                    output.print_name(key);
+                }
+            } else {
+                output.print_string(key, quote);
+            }
         }
     }
 
-    DEFPRINT(AST_ObjectKeyVal, function(output) {
+    function print_key_value(output) {
         var self = this;
-        print_property_name(self.key, self.quote, output);
+        print_property_key(self, output);
         output.colon();
         self.value.print(output);
-    });
+    }
+    DEFPRINT(AST_ObjectKeyVal, print_key_value);
     function print_accessor(type) {
         return function(output) {
             var self = this;
             output.print(type);
             output.space();
-            print_property_name(self.key.name, self.quote, output);
-            self.value._codegen(output, true);
+            print_property_key(self, output);
+            print_lambda(self.value, output);
         };
     }
     DEFPRINT(AST_ObjectGetter, print_accessor("get"));
@@ -1474,6 +1563,7 @@ function OutputStream(options) {
         AST_Constant,
         AST_Debugger,
         AST_Definitions,
+        AST_Destructured,
         AST_Finally,
         AST_Jump,
         AST_Lambda,
@@ -1488,14 +1578,7 @@ function OutputStream(options) {
         output.add_mapping(this.start);
     });
 
-    DEFMAP([
-        AST_ObjectGetter,
-        AST_ObjectSetter,
-     ], function(output) {
-        output.add_mapping(this.start, this.key.name);
-    });
-
-    DEFMAP([ AST_ObjectProperty ], function(output) {
-        output.add_mapping(this.start, this.key);
+    DEFMAP([ AST_DestructuredKeyVal, AST_ObjectProperty ], function(output) {
+        if (typeof this.key == "string") output.add_mapping(this.start, this.key);
     });
 })();

lib/parse.js

@@ -47,7 +47,7 @@
 var KEYWORDS = "break case catch const continue debugger default delete do else finally for function if in instanceof let new return switch throw try typeof var void while with";
 var KEYWORDS_ATOM = "false null true";
 var RESERVED_WORDS = [
-    "abstract boolean byte char class double enum export extends final float goto implements import int interface let long native package private protected public short static super synchronized this throws transient volatile yield",
+    "await abstract boolean byte char class double enum export extends final float goto implements import int interface long native package private protected public short static super synchronized this throws transient volatile yield",
     KEYWORDS_ATOM,
     KEYWORDS,
 ].join(" ");
@@ -501,7 +501,16 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
 
     function handle_dot() {
         next();
-        return is_digit(peek().charCodeAt(0)) ? read_num(".") : token("punc", ".");
+        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", ".");
     }
 
     function read_word() {
@@ -644,13 +653,15 @@ function parse($TEXT, options) {
         input         : typeof $TEXT == "string"
                         ? tokenizer($TEXT, options.filename, options.html5_comments, options.shebang)
                         : $TEXT,
-        token         : null,
-        prev          : null,
-        peeked        : null,
-        in_function   : 0,
+        in_async      : false,
         in_directives : true,
+        in_funarg     : -1,
+        in_function   : 0,
         in_loop       : 0,
-        labels        : []
+        labels        : [],
+        peeked        : null,
+        prev          : null,
+        token         : null,
     };
 
     S.token = next();
@@ -753,7 +764,7 @@ function parse($TEXT, options) {
         }
     }
 
-    var statement = embed_tokens(function(strict_defun) {
+    var statement = embed_tokens(function() {
         handle_regexp();
         switch (S.token.type) {
           case "string":
@@ -777,9 +788,20 @@ function parse($TEXT, options) {
             return simple_statement();
 
           case "name":
-            return is_token(peek(), "punc", ":")
-                ? labeled_statement()
-                : simple_statement();
+            switch (S.token.value) {
+              case "async":
+                if (is_token(peek(), "keyword", "function")) {
+                    next();
+                    next();
+                    return function_(AST_AsyncDefun);
+                }
+              case "await":
+                if (S.in_async) return simple_statement();
+              default:
+                return is_token(peek(), "punc", ":")
+                    ? labeled_statement()
+                    : simple_statement();
+            }
 
           case "punc":
             switch (S.token.value) {
@@ -844,9 +866,6 @@ function parse($TEXT, options) {
                 return for_();
 
               case "function":
-                if (!strict_defun && S.input.has_directive("use strict")) {
-                    croak("In strict mode code, functions can only be declared at top level or immediately within another function.");
-                }
                 next();
                 return function_(AST_Defun);
 
@@ -976,14 +995,16 @@ function parse($TEXT, options) {
         if (!is("punc", ";")) {
             init = is("keyword", "const")
                 ? (next(), const_(true))
+                : is("keyword", "let")
+                ? (next(), let_(true))
                 : is("keyword", "var")
                 ? (next(), var_(true))
                 : expression(true, true);
             if (is("operator", "in")) {
-                if (init instanceof AST_Var) {
+                if (init instanceof AST_Definitions) {
                     if (init.definitions.length > 1)
                         croak("Only one variable declaration allowed in for..in loop", init.start.line, init.start.col, init.start.pos);
-                } else if (!is_assignable(init)) {
+                } else if (!(is_assignable(init) || (init = to_destructured(init)) instanceof AST_Destructured)) {
                     croak("Invalid left-hand side in for..in loop", init.start.line, init.start.col, init.start.pos);
                 }
                 next();
@@ -1018,19 +1039,27 @@ function parse($TEXT, options) {
     }
 
     var function_ = function(ctor) {
-        var in_statement = ctor === AST_Defun;
-        var name = is("name") ? as_symbol(in_statement ? AST_SymbolDefun : AST_SymbolLambda) : null;
-        if (in_statement && !name)
-            expect_token("name");
+        var was_async = S.in_async;
+        var name;
+        if (ctor === AST_AsyncDefun) {
+            name = as_symbol(AST_SymbolDefun);
+            S.in_async = true;
+        } else if (ctor === AST_Defun) {
+            name = as_symbol(AST_SymbolDefun);
+            S.in_async = false;
+        } else {
+            S.in_async = ctor === AST_AsyncFunction;
+            name = as_symbol(AST_SymbolLambda, true);
+        }
         if (name && ctor !== AST_Accessor && !(name instanceof AST_SymbolDeclaration))
             unexpected(prev());
         expect("(");
-        var argnames = [];
-        for (var first = true; !is("punc", ")");) {
-            if (first) first = false; else expect(",");
-            argnames.push(as_symbol(AST_SymbolFunarg));
-        }
-        next();
+        var was_funarg = S.in_funarg;
+        S.in_funarg = S.in_function;
+        var argnames = expr_list(")", !options.strict, false, function() {
+            return maybe_destructured(AST_SymbolFunarg);
+        });
+        S.in_funarg = was_funarg;
         var loop = S.in_loop;
         var labels = S.labels;
         ++S.in_function;
@@ -1038,7 +1067,7 @@ function parse($TEXT, options) {
         S.input.push_directives_stack();
         S.in_loop = 0;
         S.labels = [];
-        var body = block_(true);
+        var body = block_();
         if (S.input.has_directive("use strict")) {
             if (name) strict_verify_symbol(name);
             argnames.forEach(strict_verify_symbol);
@@ -1047,6 +1076,7 @@ function parse($TEXT, options) {
         --S.in_function;
         S.in_loop = loop;
         S.labels = labels;
+        S.in_async = was_async;
         return new ctor({
             name: name,
             argnames: argnames,
@@ -1067,12 +1097,12 @@ function parse($TEXT, options) {
         });
     }
 
-    function block_(strict_defun) {
+    function block_() {
         expect("{");
         var a = [];
         while (!is("punc", "}")) {
             if (is("eof")) expect_token("punc", "}");
-            a.push(statement(strict_defun));
+            a.push(statement());
         }
         next();
         return a;
@@ -1149,16 +1179,16 @@ function parse($TEXT, options) {
         });
     }
 
-    function vardefs(type, no_in, must_init) {
+    function vardefs(type, no_in) {
         var a = [];
         for (;;) {
             var start = S.token;
-            var name = as_symbol(type);
+            var name = maybe_destructured(type);
             var value = null;
             if (is("operator", "=")) {
                 next();
                 value = expression(false, no_in);
-            } else if (must_init) {
+            } else if (!no_in && (type === AST_SymbolConst || name instanceof AST_Destructured)) {
                 croak("Missing initializer in declaration");
             }
             a.push(new AST_VarDef({
@@ -1177,7 +1207,7 @@ function parse($TEXT, options) {
     var const_ = function(no_in) {
         return new AST_Const({
             start       : prev(),
-            definitions : vardefs(AST_SymbolConst, no_in, true),
+            definitions : vardefs(AST_SymbolConst, no_in),
             end         : prev()
         });
     };
@@ -1204,7 +1234,7 @@ function parse($TEXT, options) {
         var newexp = expr_atom(false), args;
         if (is("punc", "(")) {
             next();
-            args = expr_list(")");
+            args = expr_list(")", !options.strict);
         } else {
             args = [];
         }
@@ -1222,7 +1252,7 @@ function parse($TEXT, options) {
         var tok = S.token, ret;
         switch (tok.type) {
           case "name":
-            ret = _make_symbol(AST_SymbolRef);
+            ret = _make_symbol(AST_SymbolRef, tok);
             break;
           case "num":
             ret = new AST_Number({ start: tok, end: tok, value: tok.value });
@@ -1296,9 +1326,16 @@ function parse($TEXT, options) {
             }
             unexpected();
         }
-        if (is("keyword", "function")) {
+        var ctor;
+        if (is("name", "async") && is_token(peek(), "keyword", "function")) {
             next();
-            var func = function_(AST_Function);
+            ctor = AST_AsyncFunction;
+        } else if (is("keyword", "function")) {
+            ctor = AST_Function;
+        }
+        if (ctor) {
+            next();
+            var func = function_(ctor);
             func.start = start;
             func.end = prev();
             return subscripts(func, allow_calls);
@@ -1309,15 +1346,22 @@ function parse($TEXT, options) {
         unexpected();
     };
 
-    function expr_list(closing, allow_trailing_comma, allow_empty) {
+    function expr_list(closing, allow_trailing_comma, allow_empty, parser) {
+        if (!parser) parser = expression;
         var first = true, a = [];
         while (!is("punc", closing)) {
             if (first) first = false; else expect(",");
             if (allow_trailing_comma && is("punc", closing)) break;
-            if (is("punc", ",") && allow_empty) {
+            if (allow_empty && is("punc", ",")) {
                 a.push(new AST_Hole({ start: S.token, end: S.token }));
+            } else if (parser === expression && is("operator", "...")) {
+                a.push(new AST_Spread({
+                    start: S.token,
+                    expression: (next(), parser()),
+                    end: prev(),
+                }));
             } else {
-                a.push(expression(false));
+                a.push(parser());
             }
         }
         next();
@@ -1340,51 +1384,71 @@ function parse($TEXT, options) {
         var first = true, a = [];
         while (!is("punc", "}")) {
             if (first) first = false; else expect(",");
-            if (!options.strict && is("punc", "}"))
-                // allow trailing comma
-                break;
+            // allow trailing comma
+            if (!options.strict && is("punc", "}")) break;
             var start = S.token;
-            var type = start.type;
-            var name = as_property_name();
-            if (type == "name" && !is("punc", ":")) {
-                var key = new AST_SymbolAccessor({
-                    start: S.token,
-                    name: "" + as_property_name(),
-                    end: prev()
-                });
-                if (name == "get") {
-                    a.push(new AST_ObjectGetter({
-                        start : start,
-                        key   : key,
-                        value : create_accessor(),
-                        end   : prev()
-                    }));
-                    continue;
-                }
-                if (name == "set") {
-                    a.push(new AST_ObjectSetter({
-                        start : start,
-                        key   : key,
-                        value : create_accessor(),
-                        end   : prev()
-                    }));
-                    continue;
-                }
+            if (is("operator", "...")) {
+                next();
+                a.push(new AST_Spread({
+                    start: start,
+                    expression: expression(false),
+                    end: prev(),
+                }));
+                continue;
+            }
+            var key = as_property_key();
+            if (is("punc", "(")) {
+                var func_start = S.token;
+                var func = function_(AST_Function);
+                func.start = func_start;
+                func.end = prev();
+                a.push(new AST_ObjectKeyVal({
+                    start: start,
+                    key: key,
+                    value: func,
+                    end: prev(),
+                }));
+                continue;
+            }
+            if (!is("punc", ":") && start.type == "name") switch (key) {
+              case "get":
+                a.push(new AST_ObjectGetter({
+                    start: start,
+                    key: as_property_key(),
+                    value: create_accessor(),
+                    end: prev(),
+                }));
+                continue;
+              case "set":
+                a.push(new AST_ObjectSetter({
+                    start: start,
+                    key: as_property_key(),
+                    value: create_accessor(),
+                    end: prev(),
+                }));
+                continue;
+              default:
+                a.push(new AST_ObjectKeyVal({
+                    start: start,
+                    key: key,
+                    value: _make_symbol(AST_SymbolRef, start),
+                    end: prev(),
+                }));
+                continue;
             }
             expect(":");
             a.push(new AST_ObjectKeyVal({
-                start : start,
-                quote : start.quote,
-                key   : "" + name,
-                value : expression(false),
-                end   : prev()
+                start: start,
+                key: key,
+                value: expression(false),
+                end: prev(),
             }));
         }
         next();
         return new AST_Object({ properties: a });
     });
 
-    function as_property_name() {
+    function as_property_key() {
         var tmp = S.token;
         switch (tmp.type) {
           case "operator":
@@ -1395,7 +1459,13 @@ function parse($TEXT, options) {
           case "keyword":
           case "atom":
             next();
-            return tmp.value;
+            return "" + tmp.value;
+          case "punc":
+            if (tmp.value != "[") unexpected();
+            next();
+            var key = expression(false);
+            expect("]");
+            return key;
           default:
             unexpected();
         }
@@ -1408,12 +1478,13 @@ function parse($TEXT, options) {
         return name;
     }
 
-    function _make_symbol(type) {
-        var name = S.token.value;
-        return new (name == "this" ? AST_This : type)({
-            name  : String(name),
-            start : S.token,
-            end   : S.token
+    function _make_symbol(type, token) {
+        var name = token.value;
+        if (name === "await" && S.in_async) unexpected(token);
+        return new (name === "this" ? AST_This : type)({
+            name: "" + name,
+            start: token,
+            end: token,
         });
     }
 
@@ -1427,7 +1498,7 @@ function parse($TEXT, options) {
             if (!noerror) croak("Name expected");
             return null;
         }
-        var sym = _make_symbol(type);
+        var sym = _make_symbol(type, S.token);
         if (S.input.has_directive("use strict") && sym instanceof AST_SymbolDeclaration) {
             strict_verify_symbol(sym);
         }
@@ -1435,6 +1506,54 @@ function parse($TEXT, options) {
         return sym;
     }
 
+    function maybe_destructured(type) {
+        var start = S.token;
+        if (is("punc", "[")) {
+            next();
+            return new AST_DestructuredArray({
+                start: start,
+                elements: expr_list("]", !options.strict, true, function() {
+                    return maybe_destructured(type);
+                }),
+                end: prev(),
+            });
+        }
+        if (is("punc", "{")) {
+            next();
+            var first = true, a = [];
+            while (!is("punc", "}")) {
+                if (first) first = false; else expect(",");
+                // allow trailing comma
+                if (!options.strict && is("punc", "}")) break;
+                var key_start = S.token;
+                var key = as_property_key();
+                if (!is("punc", ":") && key_start.type == "name") {
+                    a.push(new AST_DestructuredKeyVal({
+                        start: key_start,
+                        key: key,
+                        value: _make_symbol(type, key_start),
+                        end: prev(),
+                    }));
+                    continue;
+                }
+                expect(":");
+                a.push(new AST_DestructuredKeyVal({
+                    start: key_start,
+                    key: key,
+                    value: maybe_destructured(type),
+                    end: prev(),
+                }));
+            }
+            next();
+            return new AST_DestructuredObject({
+                start: start,
+                properties: a,
+                end: prev(),
+            });
+        }
+        return as_symbol(type);
+    }
+
     function mark_pure(call) {
         var start = call.start;
         var comments = start.comments_before;
@@ -1475,7 +1594,7 @@ function parse($TEXT, options) {
             var call = new AST_Call({
                 start      : start,
                 expression : expr,
-                args       : expr_list(")"),
+                args       : expr_list(")", !options.strict),
                 end        : prev()
             });
             mark_pure(call);
@@ -1484,17 +1603,17 @@ function parse($TEXT, options) {
         return expr;
     };
 
-    var maybe_unary = function(allow_calls) {
+    function maybe_unary() {
         var start = S.token;
         if (is("operator") && UNARY_PREFIX[start.value]) {
             next();
             handle_regexp();
-            var ex = make_unary(AST_UnaryPrefix, start, maybe_unary(allow_calls));
+            var ex = make_unary(AST_UnaryPrefix, start, maybe_await());
             ex.start = start;
             ex.end = prev();
             return ex;
         }
-        var val = expr_atom(allow_calls);
+        var val = expr_atom(true);
         while (is("operator") && UNARY_POSTFIX[S.token.value] && !has_newline_before(S.token)) {
             val = make_unary(AST_UnaryPostfix, S.token, val);
             val.start = start;
@@ -1502,7 +1621,7 @@ function parse($TEXT, options) {
             next();
         }
         return val;
-    };
+    }
 
     function make_unary(ctor, token, expr) {
         var op = token.value;
@@ -1520,13 +1639,26 @@ function parse($TEXT, options) {
         return new ctor({ operator: op, expression: expr });
     }
 
+    function maybe_await() {
+        var start = S.token;
+        if (!(S.in_async && is("name", "await"))) return maybe_unary();
+        if (S.in_funarg === S.in_function) croak("Invalid use of await in function argument");
+        S.input.context().regex_allowed = true;
+        next();
+        return new AST_Await({
+            start: start,
+            expression: maybe_await(),
+            end: prev(),
+        });
+    }
+
     var expr_op = function(left, min_prec, no_in) {
         var op = is("operator") ? S.token.value : null;
         if (op == "in" && no_in) op = null;
         var prec = op != null ? PRECEDENCE[op] : null;
         if (prec != null && prec > min_prec) {
             next();
-            var right = expr_op(maybe_unary(true), prec, no_in);
+            var right = expr_op(maybe_await(), prec, no_in);
             return expr_op(new AST_Binary({
                 start    : left.start,
                 left     : left,
@@ -1539,7 +1671,7 @@ function parse($TEXT, options) {
     };
 
     function expr_ops(no_in) {
-        return expr_op(maybe_unary(true), 0, no_in);
+        return expr_op(maybe_await(), 0, no_in);
     }
 
     var maybe_conditional = function(no_in) {
@@ -1564,11 +1696,43 @@ function parse($TEXT, options) {
         return expr instanceof AST_PropAccess || expr instanceof AST_SymbolRef;
     }
 
+    function to_destructured(node) {
+        if (node instanceof AST_Array) {
+            var elements = node.elements.map(to_destructured);
+            return all(elements, function(node) {
+                return node instanceof AST_Destructured || node instanceof AST_Hole || is_assignable(node);
+            }) ? new AST_DestructuredArray({
+                start: node.start,
+                elements: elements,
+                end: node.end,
+            }) : node;
+        }
+        if (!(node instanceof AST_Object)) return node;
+        var props = [];
+        for (var i = 0; i < node.properties.length; i++) {
+            var prop = node.properties[i];
+            if (!(prop instanceof AST_ObjectKeyVal)) return node;
+            var value = to_destructured(prop.value);
+            if (!(value instanceof AST_Destructured || is_assignable(value))) return node;
+            props.push(new AST_DestructuredKeyVal({
+                start: prop.start,
+                key: prop.key,
+                value: value,
+                end: prop.end,
+            }));
+        }
+        return new AST_DestructuredObject({
+            start: node.start,
+            properties: props,
+            end: node.end,
+        });
+    }
+
     var maybe_assign = function(no_in) {
         var start = S.token;
         var left = maybe_conditional(no_in), val = S.token.value;
         if (is("operator") && ASSIGNMENT[val]) {
-            if (is_assignable(left)) {
+            if (is_assignable(left) || val == "=" && (left = to_destructured(left)) instanceof AST_Destructured) {
                 next();
                 return new AST_Assign({
                     start    : start,
@@ -1616,7 +1780,7 @@ function parse($TEXT, options) {
         var body = [];
         S.input.push_directives_stack();
         while (!is("eof"))
-            body.push(statement(true));
+            body.push(statement());
         S.input.pop_directives_stack();
         var end = prev();
         var toplevel = options.toplevel;

lib/propmangle.js

@@ -81,8 +81,8 @@ var builtins = function() {
 
 function reserve_quoted_keys(ast, reserved) {
     ast.walk(new TreeWalker(function(node) {
-        if (node instanceof AST_ObjectKeyVal) {
-            if (node.quote) add(node.key);
+        if (node instanceof AST_ObjectProperty) {
+            if (node.start && node.start.quote) add(node.key);
         } else if (node instanceof AST_Sub) {
             addStrings(node.property, add);
         }
@@ -165,11 +165,8 @@ function mangle_properties(ast, options) {
             }
         } else if (node instanceof AST_Dot) {
             add(node.property);
-        } else if (node instanceof AST_ObjectKeyVal) {
-            add(node.key);
         } else if (node instanceof AST_ObjectProperty) {
-            // setter or getter, since KeyVal is handled above
-            add(node.key.name);
+            if (typeof node.key == "string") add(node.key);
         } else if (node instanceof AST_Sub) {
             addStrings(node.property, add);
         }
@@ -198,11 +195,8 @@ function mangle_properties(ast, options) {
             }
         } else if (node instanceof AST_Dot) {
             node.property = mangle(node.property);
-        } else if (node instanceof AST_ObjectKeyVal) {
-            node.key = mangle(node.key);
         } else if (node instanceof AST_ObjectProperty) {
-            // setter or getter
-            node.key.name = mangle(node.key.name);
+            if (typeof node.key == "string") node.key = mangle(node.key);
         } else if (node instanceof AST_Sub) {
             if (!options.keep_quoted) mangleStrings(node.property);
         }

lib/scope.js

@@ -72,7 +72,7 @@ SymbolDef.prototype = {
             if (def) {
                 this.mangled_name = def.mangled_name || def.name;
             } else {
-                this.mangled_name = next_mangled_name(this.scope, options, this);
+                this.mangled_name = next_mangled_name(this, options);
             }
             if (this.global && cache) {
                 cache.set(this.name, this.mangled_name);
@@ -112,7 +112,7 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options) {
     var next_def_id = 0;
     var scope = self.parent_scope = null;
     var tw = new TreeWalker(function(node, descend) {
-        if (node instanceof AST_Defun) {
+        if (is_defun(node)) {
             node.name.walk(tw);
             walk_scope(function() {
                 node.argnames.forEach(function(argname) {
@@ -190,7 +190,7 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options) {
         function entangle(defun, scope) {
             if (defun === scope) return;
             node.mark_enclosed(options);
-            var def = scope.find_variable(node);
+            var def = scope.find_variable(node.name);
             if (node.thedef === def) return;
             node.thedef = def;
             def.orig.push(node);
@@ -204,18 +204,57 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options) {
 
     // pass 2: find back references and eval
     self.globals = new Dictionary();
+    var in_arg = [];
     var tw = new TreeWalker(function(node) {
+        if (node instanceof AST_Lambda) {
+            in_arg.push(node);
+            node.argnames.forEach(function(argname) {
+                argname.walk(tw);
+            });
+            in_arg.pop();
+            walk_body(node, tw);
+            return true;
+        }
         if (node instanceof AST_LoopControl) {
             if (node.label) node.label.thedef.references.push(node);
             return true;
         }
+        // ensure mangling works if `catch` reuses a scope variable
+        if (node instanceof AST_SymbolCatch) {
+            var def = node.definition().redefined();
+            if (def) for (var s = node.scope; s; s = s.parent_scope) {
+                push_uniq(s.enclosed, def);
+                if (s === def.scope) break;
+            }
+            return true;
+        }
+        // ensure compression works if `const` reuses a scope variable
+        if (node instanceof AST_SymbolConst) {
+            var redef = node.definition().redefined();
+            if (redef) redef.const_redefs = true;
+            return true;
+        }
         if (node instanceof AST_SymbolRef) {
             var name = node.name;
             var sym = node.scope.find_variable(name);
+            for (var i = in_arg.length; i > 0 && sym;) {
+                i = in_arg.lastIndexOf(sym.scope, i - 1);
+                if (i < 0) break;
+                var decl = sym.orig[0];
+                if (decl instanceof AST_SymbolFunarg || decl instanceof AST_SymbolLambda) {
+                    node.in_arg = true;
+                    break;
+                }
+                sym = sym.scope.parent_scope.find_variable(name);
+            }
             if (!sym) {
                 sym = self.def_global(node);
             } else if (name == "arguments" && sym.scope instanceof AST_Lambda) {
-                sym.scope.uses_arguments = true;
+                if (!(tw.parent() instanceof AST_PropAccess)) {
+                    sym.scope.uses_arguments = "d";
+                } else if (!sym.scope.uses_arguments) {
+                    sym.scope.uses_arguments = true;
+                }
             }
             if (name == "eval") {
                 var parent = tw.parent();
@@ -234,21 +273,6 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options) {
             node.reference(options);
             return true;
         }
-        // ensure mangling works if `catch` reuses a scope variable
-        if (node instanceof AST_SymbolCatch) {
-            var def = node.definition().redefined();
-            if (def) for (var s = node.scope; s; s = s.parent_scope) {
-                push_uniq(s.enclosed, def);
-                if (s === def.scope) break;
-            }
-            return true;
-        }
-        // ensure compression works if `const` reuses a scope variable
-        if (node instanceof AST_SymbolConst) {
-            var redef = node.definition().redefined();
-            if (redef) redef.const_redefs = true;
-            return true;
-        }
     });
     self.walk(tw);
 
@@ -366,14 +390,13 @@ AST_Symbol.DEFMETHOD("reference", function(options) {
 });
 
 AST_BlockScope.DEFMETHOD("find_variable", function(name) {
-    if (name instanceof AST_Symbol) name = name.name;
     return this.variables.get(name)
-        || (this.parent_scope && this.parent_scope.find_variable(name));
+        || this.parent_scope && this.parent_scope.find_variable(name);
 });
 
 AST_BlockScope.DEFMETHOD("def_function", function(symbol, init) {
     var def = this.def_variable(symbol, init);
-    if (!def.init || def.init instanceof AST_Defun) def.init = init;
+    if (!def.init || is_defun(def.init)) def.init = init;
     this.functions.set(symbol.name, def);
     return def;
 });
@@ -382,7 +405,7 @@ AST_BlockScope.DEFMETHOD("def_variable", function(symbol, init) {
     var def = this.variables.get(symbol.name);
     if (def) {
         def.orig.push(symbol);
-        if (def.init instanceof AST_Function) def.init = init;
+        if (is_function(def.init)) def.init = init;
     } else {
         def = this.make_def(symbol, init);
         this.variables.set(symbol.name, def);
@@ -408,7 +431,8 @@ function names_in_use(scope, options) {
     return names;
 }
 
-function next_mangled_name(scope, options, def) {
+function next_mangled_name(def, options) {
+    var scope = def.scope;
     var in_use = names_in_use(scope, options);
     var holes = scope.cname_holes;
     var names = Object.create(null);
@@ -461,6 +485,7 @@ function _default_mangler_options(options) {
         keep_fnames : false,
         reserved    : [],
         toplevel    : false,
+        webkit      : false,
     });
     if (!Array.isArray(options.reserved)) options.reserved = [];
     // Never mangle arguments
@@ -495,9 +520,24 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options) {
             return true;
         }
         if (node instanceof AST_BlockScope) {
-            var to_mangle = [];
+            if (options.webkit && node instanceof AST_IterationStatement && node.init instanceof AST_Let) {
+                node.init.definitions.forEach(function(defn) {
+                    defn.name.match_symbol(function(sym) {
+                        if (!(sym instanceof AST_SymbolLet)) return;
+                        var def = sym.definition();
+                        var scope = sym.scope.parent_scope;
+                        var redef = scope.def_variable(sym);
+                        sym.thedef = def;
+                        scope.to_mangle.push(redef);
+                        def.redefined = function() {
+                            return redef;
+                        };
+                    });
+                }, true);
+            }
+            node.to_mangle = [];
             node.variables.each(function(def) {
-                if (!defer_redef(def)) to_mangle.push(def);
+                if (!defer_redef(def)) node.to_mangle.push(def);
             });
             descend();
             if (options.cache && node instanceof AST_Toplevel) {
@@ -508,7 +548,7 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options) {
                 sym.scope = node;
                 sym.reference(options);
             }
-            to_mangle.forEach(mangle);
+            node.to_mangle.forEach(mangle);
             return true;
         }
         if (node instanceof AST_Label) {
@@ -528,13 +568,19 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options) {
         def.mangle(options);
     }
 
-    function defer_redef(def, node) {
+    function defer_redef(def) {
+        var sym = def.orig[0];
         var redef = def.redefined();
-        if (!redef) return false;
+        if (!redef) {
+            if (!(sym instanceof AST_SymbolConst)) return false;
+            var scope = def.scope.resolve();
+            if (def.scope === scope) return false;
+            redef = scope.def_variable(sym);
+            scope.to_mangle.push(redef);
+        }
         redefined.push(def);
         def.references.forEach(reference);
-        var node = def.orig[0];
-        if (node instanceof AST_SymbolCatch || node instanceof AST_SymbolConst) reference(node);
+        if (sym instanceof AST_SymbolCatch || sym instanceof AST_SymbolConst) reference(sym);
         return true;
 
         function reference(sym) {

lib/transform.js

@@ -138,6 +138,9 @@ TreeTransformer.prototype = new TreeWalker;
     DEF(AST_Sequence, function(self, tw) {
         self.expressions = do_list(self.expressions, tw);
     });
+    DEF(AST_Await, function(self, tw) {
+        self.expression = self.expression.transform(tw);
+    });
     DEF(AST_Dot, function(self, tw) {
         self.expression = self.expression.transform(tw);
     });
@@ -145,6 +148,9 @@ TreeTransformer.prototype = new TreeWalker;
         self.expression = self.expression.transform(tw);
         self.property = self.property.transform(tw);
     });
+    DEF(AST_Spread, function(self, tw) {
+        self.expression = self.expression.transform(tw);
+    });
     DEF(AST_Unary, function(self, tw) {
         self.expression = self.expression.transform(tw);
     });
@@ -160,10 +166,21 @@ TreeTransformer.prototype = new TreeWalker;
     DEF(AST_Array, function(self, tw) {
         self.elements = do_list(self.elements, tw);
     });
+    DEF(AST_DestructuredArray, function(self, tw) {
+        self.elements = do_list(self.elements, tw);
+    });
+    DEF(AST_DestructuredKeyVal, function(self, tw) {
+        if (self.key instanceof AST_Node) self.key = self.key.transform(tw);
+        self.value = self.value.transform(tw);
+    });
+    DEF(AST_DestructuredObject, function(self, tw) {
+        self.properties = do_list(self.properties, tw);
+    });
     DEF(AST_Object, function(self, tw) {
         self.properties = do_list(self.properties, tw);
     });
     DEF(AST_ObjectProperty, function(self, tw) {
+        if (self.key instanceof AST_Node) self.key = self.key.transform(tw);
         self.value = self.value.transform(tw);
     });
 })(function(node, descend) {

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.11.5",
+  "version": "3.12.2",
   "engines": {
     "node": ">=0.8.0"
   },

test/compress.js

@@ -63,7 +63,6 @@ function make_code(ast, options) {
 
 function parse_test(file) {
     var script = fs.readFileSync(file, "utf8");
-    // TODO try/catch can be removed after fixing https://github.com/mishoo/UglifyJS/issues/348
     try {
         var ast = U.parse(script, {
             filename: file

test/compress/arguments.js

@@ -807,3 +807,47 @@ issue_4200: {
     }
     expect_stdout: "undefined"
 }
+
+issue_4291_1: {
+    options = {
+        arguments: true,
+        keep_fargs: "strict",
+    }
+    input: {
+        console.log(function() {
+            arguments[0] = "PASS";
+            return arguments;
+        }()[0]);
+    }
+    expect: {
+        console.log(function() {
+            arguments[0] = "PASS";
+            return arguments;
+        }()[0]);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4291_2: {
+    options = {
+        arguments: true,
+        keep_fargs: "strict",
+    }
+    input: {
+        var a = function() {
+            if (arguments[0])
+                arguments[1] = "PASS";
+            return arguments;
+        }(42);
+        console.log(a[1], a[0], a.length);
+    }
+    expect: {
+        var a = function(argument_0) {
+            if (argument_0)
+                arguments[1] = "PASS";
+            return arguments;
+        }(42);
+        console.log(a[1], a[0], a.length);
+    }
+    expect_stdout: "PASS 42 1"
+}

test/compress/async.js

@@ -0,0 +1,498 @@
+await_await: {
+    input: {
+        (async function() {
+            console.log("PASS");
+            await await 42;
+        })();
+    }
+    expect: {
+        (async function() {
+            console.log("PASS");
+            await await 42;
+        })();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=8"
+}
+
+defun_name: {
+    input: {
+        async function await() {
+            console.log("PASS");
+        }
+        await();
+    }
+    expect: {
+        async function await() {
+            console.log("PASS");
+        }
+        await();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=8"
+}
+
+nested_await: {
+    input: {
+        (async function() {
+            console.log(function(await) {
+                return await;
+            }("PASS"));
+        })();
+    }
+    expect: {
+        (async function() {
+            console.log(function(await) {
+                return await;
+            }("PASS"));
+        })();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=8"
+}
+
+reduce_single_use_defun: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        async function f(a) {
+            console.log(a);
+        }
+        f("PASS");
+    }
+    expect: {
+        (async function(a) {
+            console.log(a);
+        })("PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=8"
+}
+
+dont_inline: {
+    options = {
+        inline: true,
+    }
+    input: {
+        (async function() {
+            A;
+        })().catch(function() {});
+        console.log("PASS");
+    }
+    expect: {
+        (async function() {
+            A;
+        })().catch(function() {});
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=8"
+}
+
+evaluate: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = async function() {}();
+        console.log(typeof a);
+    }
+    expect: {
+        var a = async function() {}();
+        console.log(typeof a);
+    }
+    expect_stdout: "object"
+    node_version: ">=8"
+}
+
+negate: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        console && async function() {} && console.log("PASS");
+    }
+    expect: {
+        console && async function() {} && console.log("PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=8"
+}
+
+negate_iife: {
+    options = {
+        negate_iife: true,
+    }
+    input: {
+        (async function() {
+            console.log("PASS");
+        })();
+    }
+    expect: {
+        !async function() {
+            console.log("PASS");
+        }();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=8"
+}
+
+collapse_vars_1: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var a = "FAIL";
+        (async function() {
+            a = "PASS";
+            await 42;
+            return "PASS";
+        })();
+        console.log(a);
+    }
+    expect: {
+        var a = "FAIL";
+        (async function() {
+            a = "PASS";
+            await 42;
+            return "PASS";
+        })();
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=8"
+}
+
+collapse_vars_2: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var a = "FAIL";
+        (async function() {
+            await (a = "PASS");
+            return "PASS";
+        })();
+        console.log(a);
+    }
+    expect: {
+        var a = "FAIL";
+        (async function() {
+            await (a = "PASS");
+            return "PASS";
+        })();
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=8"
+}
+
+collapse_vars_3: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var a = "FAIL";
+        (async function() {
+            await (a = "PASS", 42);
+            return "PASS";
+        })();
+        console.log(a);
+    }
+    expect: {
+        var a = "FAIL";
+        (async function() {
+            await (a = "PASS", 42);
+            return "PASS";
+        })();
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=8"
+}
+
+issue_4335_1: {
+    options = {
+        inline: true,
+    }
+    input: {
+        var await = "PASS";
+        (async function() {
+            console.log(function() {
+                return await;
+            }());
+        })();
+    }
+    expect: {
+        var await = "PASS";
+        (async function() {
+            console.log(function() {
+                return await;
+            }());
+        })();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=8"
+}
+
+issue_4335_2: {
+    options = {
+        inline: true,
+    }
+    input: {
+        (async function() {
+            console.log(function() {
+                function await() {}
+                return "PASS";
+            }());
+        })();
+    }
+    expect: {
+        (async function() {
+            console.log(function() {
+                function await() {}
+                return "PASS";
+            }());
+        })();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=8"
+}
+
+issue_4337: {
+    options = {
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        (function(a) {
+            a();
+        })(async function() {
+            console.log("PASS");
+        });
+    }
+    expect: {
+        (function(a) {
+            (async function() {
+                console.log("PASS");
+            })();
+        })();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=8"
+}
+
+issue_4340: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+    }
+    input: {
+        (async function a(a) {
+            console.log(a || "PASS");
+        })();
+    }
+    expect: {
+        (async function a(a) {
+            console.log(a || "PASS");
+        })();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=8"
+}
+
+call_expression: {
+    input: {
+        console.log(typeof async function(log) {
+            (await log)("FAIL");
+        }(console.log).then);
+    }
+    expect_exact: 'console.log(typeof async function(log){(await log)("FAIL")}(console.log).then);'
+    expect_stdout: "function"
+    node_version: ">=8"
+}
+
+property_access_expression: {
+    input: {
+        console.log(typeof async function(con) {
+            (await con).log("FAIL");
+        }(console).then);
+    }
+    expect_exact: 'console.log(typeof async function(con){(await con).log("FAIL")}(console).then);'
+    expect_stdout: "function"
+    node_version: ">=8"
+}
+
+issue_4347_1: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = "foo";
+        f();
+        a = "bar";
+        f();
+        async function f() {
+            console.log(a);
+        }
+    }
+    expect: {
+        var a = "foo";
+        f();
+        a = "bar";
+        f();
+        async function f() {
+            console.log(a);
+        }
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+    ]
+    node_version: ">=8"
+}
+
+issue_4347_2: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = "PASS";
+        (async function() {
+            throw 42;
+            a = "FAIL";
+        })();
+        console.log(a);
+    }
+    expect: {
+        var a = "PASS";
+        (async function() {
+            throw 42;
+            a = "FAIL";
+        })();
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=8"
+}
+
+issue_4349_1: {
+    input: {
+        console.log(typeof async function() {
+            await /abc/;
+        }().then);
+    }
+    expect_exact: "console.log(typeof async function(){await/abc/}().then);"
+    expect_stdout: "function"
+    node_version: ">=8"
+}
+
+issue_4349_2: {
+    options = {
+        collapse_vars: true,
+        unused: true,
+    }
+    input: {
+        console.log(typeof async function() {
+            (function(a) {
+                this[a];
+            }(await 0));
+        }().then);
+    }
+    expect: {
+        console.log(typeof async function() {
+            (function(a) {
+                this[a];
+            }(await 0));
+        }().then);
+    }
+    expect_stdout: "function"
+    node_version: ">=8"
+}
+
+issue_4349_3: {
+    options = {
+        collapse_vars: true,
+        unused: true,
+    }
+    input: {
+        console.log(typeof function(await) {
+            return async function(a) {
+                this[a];
+            }(await);
+        }(this).then);
+    }
+    expect: {
+        console.log(typeof function(await) {
+            return async function(a) {
+                this[a];
+            }(await);
+        }(this).then);
+    }
+    expect_stdout: "function"
+    node_version: ">=8"
+}
+
+issue_4359: {
+    options = {
+        collapse_vars: true,
+        unused: true,
+    }
+    input: {
+        try {
+            (async function(a) {
+                return a;
+            })(A);
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect: {
+        try {
+            (async function(a) {
+                return a;
+            })(A);
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=8"
+}
+
+issue_4377: {
+    options = {
+        dead_code: true,
+        inline: true,
+        side_effects: true,
+    }
+    input: {
+        console.log(typeof function() {
+            return function() {
+                f;
+                async function f() {}
+                return f();
+            }();
+        }().then);
+    }
+    expect: {
+        console.log(typeof function() {
+            return f();
+            async function f() {}
+        }().then);
+    }
+    expect_stdout: "function"
+    node_version: ">=8"
+}

test/compress/booleans.js

@@ -153,3 +153,31 @@ issue_3690: {
     }
     expect_stdout: "PASS"
 }
+
+issue_4374: {
+    options = {
+        booleans: true,
+        conditionals: true,
+        if_return: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        (function() {
+            console.log(f());
+            function f(a) {
+                if (null) return 0;
+                if (a) return 1;
+                return 0;
+            }
+        })();
+    }
+    expect: {
+        (function() {
+            console.log(function(a) {
+                return !null && a ? 1 : 0;
+            }());
+        })();
+    }
+    expect_stdout: "0"
+}

test/compress/const.js

@@ -1,3 +1,45 @@
+mangle_block: {
+    mangle = {
+        toplevel: false,
+    }
+    input: {
+        var o = "PASS";
+        {
+            const a = "FAIL";
+        }
+        console.log(o);
+    }
+    expect: {
+        var o = "PASS";
+        {
+            const a = "FAIL";
+        }
+        console.log(o);
+    }
+    expect_stdout: "PASS"
+}
+
+mangle_block_toplevel: {
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        var o = "PASS";
+        {
+            const a = "FAIL";
+        }
+        console.log(o);
+    }
+    expect: {
+        var o = "PASS";
+        {
+            const c = "FAIL";
+        }
+        console.log(o);
+    }
+    expect_stdout: "PASS"
+}
+
 mangle_catch_1: {
     mangle = {}
     input: {
@@ -11,8 +53,8 @@ mangle_catch_1: {
     expect: {
         try {
             throw "eeeee";
-        } catch (e) {
-            const o = typeof d;
+        } catch (o) {
+            const e = typeof d;
         }
         console.log(typeof a, typeof b);
     }
@@ -57,6 +99,23 @@ retain_block: {
     expect_stdout: true
 }
 
+retain_catch: {
+    options = {
+        dead_code: true,
+    }
+    input: {
+        try {} catch (a) {
+            const a = "aa";
+        }
+    }
+    expect: {
+        try {} catch (a) {
+            const a = "aa";
+        }
+    }
+    expect_stdout: true
+}
+
 if_dead_branch: {
     options = {
         conditionals: true,
@@ -1135,3 +1194,184 @@ issue_4248: {
     }
     expect_stdout: "PASS"
 }
+
+issue_4261: {
+    options = {
+        inline: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        {
+            const a = 42;
+            (function() {
+                function f() {
+                    console.log(a);
+                }
+                function g() {
+                    while (f());
+                }
+                (function() {
+                    while (g());
+                })();
+            })();
+        }
+    }
+    expect: {
+        {
+            const a = 42;
+            (function() {
+                function g() {
+                    while (void console.log(a));
+                }
+                (function() {
+                    while (g());
+                })();
+            })();
+        }
+    }
+    expect_stdout: "42"
+}
+
+issue_4274_1: {
+    options = {
+        loops: true,
+    }
+    input: {
+        for (;;) {
+            if (console.log("PASS")) {
+                const a = 0;
+            } else {
+                break;
+                var a;
+            }
+        }
+    }
+    expect: {
+        for (; console.log("PASS");) {
+            {
+                const a = 0;
+            }
+            var a;
+        }
+    }
+    expect_stdout: true
+}
+
+issue_4274_2: {
+    options = {
+        loops: true,
+    }
+    input: {
+        for (;;) {
+            if (!console.log("PASS")) {
+                break;
+                var a;
+            } else {
+                const a = 0;
+            }
+        }
+    }
+    expect: {
+        for (; console.log("PASS");) {
+            {
+                const a = 0;
+            }
+            var a;
+        }
+    }
+    expect_stdout: true
+}
+
+issue_4290_1: {
+    options = {
+        unused: true,
+    }
+    input: {
+        const a = 0;
+        var a;
+    }
+    expect: {
+        const a = 0;
+        var a;
+    }
+    expect_stdout: true
+}
+
+issue_4305_1: {
+    options = {
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        (function() {
+            const arguments = function() {
+                while (console.log("PASS"));
+            };
+            arguments();
+        })();
+    }
+    expect: {
+        (function() {
+            const arguments = function() {
+                while (console.log("PASS"));
+            };
+            arguments();
+        })();
+    }
+    expect_stdout: true
+}
+
+issue_4305_2: {
+    options = {
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        (function(a) {
+            const a = function() {
+                while (console.log("aaaaa"));
+            };
+            a();
+        })();
+    }
+    expect: {
+        (function(a) {
+            const a = function() {
+                while (console.log("aaaaa"));
+            };
+            a();
+        })();
+    }
+    expect_stdout: true
+}
+
+issue_4365_1: {
+    options = {
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        const arguments = 42;
+    }
+    expect: {
+        const arguments = 42;
+    }
+    expect_stdout: true
+}
+
+issue_4365_2: {
+    options = {
+        toplevel: true,
+        varify: true,
+    }
+    input: {
+        const arguments = 42;
+    }
+    expect: {
+        const arguments = 42;
+    }
+    expect_stdout: true
+}

test/compress/dead-code.js

@@ -1375,3 +1375,27 @@ issue_4051: {
     }
     expect_stdout: "PASS"
 }
+
+issue_4366: {
+    options = {
+        dead_code: true,
+    }
+    input: {
+        function f() {
+            return "PASS";
+            ({
+                p: 42,
+                get p() {},
+            });
+        }
+        console.log(f());
+    }
+    expect: {
+        function f() {
+            return "PASS";
+        }
+        console.log(f());
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}

test/compress/evaluate.js

@@ -3047,3 +3047,30 @@ issue_4214: {
     }
     expect_stdout: "NaN"
 }
+
+issue_4271: {
+    options = {
+        evaluate: true,
+        unsafe: true,
+    }
+    input: {
+        ({
+            p: null,
+            q: (console.log("foo"), 42),
+            p: function() {}
+        })[console.log("bar"), "p"] && console.log("PASS");
+    }
+    expect: {
+        ({
+            p: null,
+            q: (console.log("foo"), 42),
+            p: function() {}
+        })[console.log("bar"), "p"],
+        console.log("PASS");
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+        "PASS",
+    ]
+}

test/compress/functions.js

@@ -521,7 +521,7 @@ issue_2531_2: {
     options = {
         evaluate: true,
         inline: true,
-        passes: 3,
+        passes: 2,
         reduce_funcs: true,
         reduce_vars: true,
         side_effects: true,
@@ -556,9 +556,10 @@ issue_2531_3: {
     options = {
         evaluate: true,
         inline: true,
-        passes: 3,
+        passes: 2,
         reduce_funcs: true,
         reduce_vars: true,
+        sequences: true,
         side_effects: true,
         toplevel: true,
         unused: true,
@@ -2081,7 +2082,7 @@ issue_3016_1: {
         var b = 1;
         do {
             3[b];
-        } while(0);
+        } while (0);
         console.log(b);
     }
     expect_stdout: "1"
@@ -2112,7 +2113,7 @@ issue_3016_2: {
         do {
             a = 3,
             a[b];
-        } while(0);
+        } while (0);
         var a;
         console.log(b);
     }
@@ -2145,7 +2146,7 @@ issue_3016_2_ie8: {
         do {
             a = 3,
             a[b];
-        } while(0);
+        } while (0);
         var a;
         console.log(b);
     }
@@ -2175,7 +2176,7 @@ issue_3016_3: {
         var b = 1;
         do {
             console.log((a = void 0, a ? "FAIL" : a = "PASS"));
-        } while(b--);
+        } while (b--);
         var a;
     }
     expect_stdout: [
@@ -2208,7 +2209,7 @@ issue_3016_3_ie8: {
         var b = 1;
         do {
             console.log((a = void 0, a ? "FAIL" : a = "PASS"));
-        } while(b--);
+        } while (b--);
         var a;
     }
     expect_stdout: [
@@ -3321,9 +3322,7 @@ issue_3506_1: {
     }
     expect: {
         var a = "FAIL";
-        !function(b) {
-            b && (a = "PASS");
-        }(a);
+        a && (a = "PASS");
         console.log(a);
     }
     expect_stdout: "PASS"
@@ -5115,3 +5114,112 @@ issue_4233: {
     }
     expect_stdout: "number"
 }
+
+issue_4259: {
+    options = {
+        collapse_vars: true,
+        functions: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = function b() {
+            var c = b;
+            for (b in c);
+        };
+        a();
+        console.log(typeof a);
+    }
+    expect: {
+        function a() {
+            for (a in a);
+        }
+        a();
+        console.log(typeof a);
+    }
+    expect_stdout: "function"
+}
+
+issue_4261: {
+    options = {
+        inline: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        try {
+            throw 42;
+        } catch (e) {
+            (function() {
+                function f() {
+                    e.p;
+                }
+                function g() {
+                    while (f());
+                }
+                (function() {
+                    while (console.log(g()));
+                })();
+            })();
+        }
+    }
+    expect: {
+        try {
+            throw 42;
+        } catch (e) {
+            (function() {
+                function g() {
+                    while (void e.p);
+                }
+                (function() {
+                    while (console.log(g()));
+                })();
+            })();
+        }
+    }
+    expect_stdout: true
+}
+
+issue_4265: {
+    options = {
+        conditionals: true,
+        dead_code: true,
+        inline: true,
+        sequences: true,
+    }
+    input: {
+        function f() {
+            console;
+            if ([ function() {
+                return this + console.log(a);
+                a;
+                var a;
+            }() ]);
+            return 0;
+        }
+        f();
+    }
+    expect: {
+        function f() {
+            return console, function() {
+                return console.log(a);
+                var a;
+            }(), 0;
+        }
+        f();
+    }
+    expect_stdout: "undefined"
+}
+
+trailing_comma: {
+    input: {
+        new function(a, b,) {
+            console.log(b, a,);
+        }(42, "PASS",);
+    }
+    expect_exact: 'new function(a,b){console.log(b,a)}(42,"PASS");'
+    expect_stdout: "PASS 42"
+}

test/compress/hoist_props.js

@@ -297,6 +297,33 @@ name_collision_3: {
     expect_stdout: "true 4 6"
 }
 
+name_collision_4: {
+    options = {
+        hoist_props: true,
+        reduce_vars: true,
+    }
+    input: {
+        console.log(function() {
+            var o = {
+                p: 0,
+                q: "PASS",
+            };
+            return function(o_p) {
+                if (!o.p) return o_p;
+            }(o.q);
+        }());
+    }
+    expect: {
+        console.log(function() {
+            var o_p$0 = 0, o_q = "PASS";
+            return function(o_p) {
+                if (!o_p$0) return o_p;
+            }(o_q);
+        }());
+    }
+    expect_stdout: "PASS"
+}
+
 contains_this_1: {
     options = {
         evaluate: true,

test/compress/ie8.js

@@ -588,7 +588,6 @@ issue_3197_1: {
         ie8: false,
     }
     input: {
-        var window = {};
         !function() {
             function Foo() {
                 console.log(this instanceof Foo);
@@ -598,7 +597,6 @@ issue_3197_1: {
         new window.Foo();
     }
     expect: {
-        var window = {};
         window.Foo = function o() {
             console.log(this instanceof o);
         };
@@ -619,7 +617,6 @@ issue_3197_1_ie8: {
         ie8: true,
     }
     input: {
-        var window = {};
         !function() {
             function Foo() {
                 console.log(this instanceof Foo);
@@ -629,7 +626,6 @@ issue_3197_1_ie8: {
         new window.Foo();
     }
     expect: {
-        var window = {};
         window.Foo = function Foo() {
             console.log(this instanceof Foo);
         };

test/compress/keep_fargs.js

@@ -525,7 +525,7 @@ issue_2506: {
         function f0(bar) {
             (function() {
                 (function() {
-                    if (false <= 0/0 & this >> 1 >= 0)
+                    if (false <= NaN & this >> 1 >= 0)
                         c++;
                 })(c++);
             })();
@@ -1452,3 +1452,37 @@ issue_3619: {
     }
     expect_stdout: "PASS"
 }
+
+issue_4353_1: {
+    options = {
+        keep_fargs: "strict",
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        console.log(function f(a) {}.length);
+    }
+    expect: {
+        console.log(function(a) {}.length);
+    }
+    expect_stdout: "1"
+}
+
+issue_4353_2: {
+    options = {
+        keep_fargs: "strict",
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        (function f(a) {
+            while (console.log("PASS"));
+        })();
+    }
+    expect: {
+        (function() {
+            while (console.log("PASS"));
+        })();
+    }
+    expect_stdout: "PASS"
+}

test/compress/let.js

@@ -20,6 +20,26 @@ retain_block: {
     node_version: ">=4"
 }
 
+retain_catch: {
+    options = {
+        dead_code: true,
+    }
+    input: {
+        "use strict";
+        try {} catch (a) {
+            let a = "aa";
+        }
+    }
+    expect: {
+        "use strict";
+        try {} catch (a) {
+            let a = "aa";
+        }
+    }
+    expect_stdout: true
+    node_version: ">=4"
+}
+
 if_dead_branch: {
     options = {
         conditionals: true,
@@ -950,3 +970,261 @@ issue_4248: {
     expect_stdout: "PASS"
     node_version: ">=4"
 }
+
+issue_4274_1: {
+    options = {
+        loops: true,
+    }
+    input: {
+        "use strict";
+        for (;;) {
+            if (console.log("PASS")) {
+                let a;
+            } else {
+                break;
+                var a;
+            }
+        }
+    }
+    expect: {
+        "use strict";
+        for (; console.log("PASS");) {
+            {
+                let a;
+            }
+            var a;
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_4274_2: {
+    options = {
+        loops: true,
+    }
+    input: {
+        "use strict";
+        for (;;) {
+            if (!console.log("PASS")) {
+                break;
+                var a;
+            } else {
+                let a;
+            }
+        }
+    }
+    expect: {
+        "use strict";
+        for (; console.log("PASS");) {
+            {
+                let a;
+            }
+            var a;
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_4276_1: {
+    options = {
+        unused: true,
+    }
+    input: {
+        "use strict";
+        try {
+            let a = b, b;
+            console.log("FAIL");
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect: {
+        "use strict";
+        try {
+            let a = b, b;
+            console.log("FAIL");
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_4276_2: {
+    options = {
+        unused: true,
+    }
+    input: {
+        "use strict";
+        try {
+            let a = f(), b;
+            console.log("FAIL");
+            function f() {
+                return b;
+            }
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect: {
+        "use strict";
+        try {
+            let a = f(), b;
+            console.log("FAIL");
+            function f() {
+                return b;
+            }
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_4290_1: {
+    options = {
+        unused: true,
+    }
+    input: {
+        "use strict";
+        let a;
+        var a;
+    }
+    expect: {
+        "use strict";
+        let a;
+        var a;
+    }
+    expect_stdout: true
+    node_version: ">=4"
+}
+
+issue_4290_2: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        "use strict";
+        try {
+            console.log(function(a) {
+                a = c;
+                let c;
+                return a;
+            }());
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect: {
+        "use strict";
+        try {
+            console.log(function(a) {
+                a = c;
+                let c;
+                return a;
+            }());
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_4305_1: {
+    options = {
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        (function() {
+            let arguments = function() {
+                while (console.log("PASS"));
+            };
+            arguments();
+        })();
+    }
+    expect: {
+        (function() {
+            let arguments = function() {
+                while (console.log("PASS"));
+            };
+            arguments();
+        })();
+    }
+    expect_stdout: true
+    node_version: ">=6"
+}
+
+issue_4305_2: {
+    options = {
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        (function(a) {
+            let a = function() {
+                while (console.log("aaaaa"));
+            };
+            a();
+        })();
+    }
+    expect: {
+        "use strict";
+        (function(a) {
+            let a = function() {
+                while (console.log("aaaaa"));
+            };
+            a();
+        })();
+    }
+    expect_stdout: true
+    node_version: ">=4"
+}
+
+issue_1753: {
+    mangle = {
+        toplevel: false,
+        webkit: true,
+    }
+    input: {
+        "use strict";
+        let l = null;
+        for (let i = 0; i < 1; i++)
+            console.log(i);
+    }
+    expect: {
+        "use strict";
+        let l = null;
+        for (let i = 0; i < 1; i++)
+            console.log(i);
+    }
+    expect_stdout: "0"
+    node_version: ">=4"
+}
+
+issue_1753_toplevel: {
+    mangle = {
+        toplevel: true,
+        webkit: true,
+    }
+    input: {
+        "use strict";
+        let l = null;
+        for (let i = 0; i < 1; i++)
+            console.log(i);
+    }
+    expect: {
+        "use strict";
+        let l = null;
+        for (let e = 0; e < 1; e++)
+            console.log(e);
+    }
+    expect_stdout: "0"
+    node_version: ">=4"
+}

test/compress/loops.js

@@ -1052,6 +1052,7 @@ issue_4084: {
     options = {
         keep_fargs: "strict",
         loops: true,
+        passes: 2,
         reduce_vars: true,
         unused: true,
     }
@@ -1254,3 +1255,28 @@ issue_4240: {
     }
     expect_stdout: "PASS"
 }
+
+issue_4355: {
+    options = {
+        dead_code: true,
+        evaluate: true,
+        loops: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        while (function() {
+            var a;
+            for (a in console.log("PASS"))
+                var b = 0;
+        }())
+            var c;
+    }
+    expect: {
+        (function() {
+            console.log("PASS");
+        })();
+        var c;
+    }
+    expect_stdout: "PASS"
+}

test/compress/numbers.js

@@ -1,49 +1,100 @@
-hex_numbers_in_parentheses_for_prototype_functions: {
+parentheses_for_prototype_functions: {
     beautify = {
         beautify: true,
     }
     input: {
-        function f() {
-            (-2);
-            (-2).toFixed(0);
+        (function() {
+            console.log((-2));
+            console.log((-2).toFixed(0));
 
-            (2);
-            (2).toFixed(0);
+            console.log((2));
+            console.log((2).toFixed(0));
 
-            (0.2);
-            (0.2).toFixed(0);
+            console.log((0.2));
+            console.log((0.2).toFixed(0));
 
-            (2.34e20);
-            (2.34e20).toFixed(0);
+            console.log((2.34e20));
+            console.log((2.34e20).toFixed(0));
 
-            (0.00000002);
-            (0.00000002).toFixed(0);
+            console.log((0.00000002));
+            console.log((0.00000002).toFixed(0));
 
-            (1000000000000000128);
-            (1000000000000000128).toFixed(0);
+            console.log((1000000000000000128));
+            console.log((1000000000000000128).toFixed(0));
 
-            (-1000000000000000128);
-            (-1000000000000000128).toFixed(0);
-        }
+            console.log((-1000000000000000128));
+            console.log((-1000000000000000128).toFixed(0));
+        })();
     }
     expect_exact: [
-        "function f() {",
-        "    -2;",
-        "    (-2).toFixed(0);",
-        "    2;",
-        "    2..toFixed(0);",
-        "    .2;",
-        "    .2.toFixed(0);",
-        "    234e18;",
-        "    234e18.toFixed(0);",
-        "    2e-8;",
-        "    2e-8.toFixed(0);",
-        "    0xde0b6b3a7640080;",
-        "    (0xde0b6b3a7640080).toFixed(0);",
-        "    -0xde0b6b3a7640080;",
-        "    (-0xde0b6b3a7640080).toFixed(0);",
-        "}",
+        "(function() {",
+        "    console.log(-2);",
+        "    console.log((-2).toFixed(0));",
+        "    console.log(2);",
+        "    console.log(2..toFixed(0));",
+        "    console.log(.2);",
+        "    console.log(.2.toFixed(0));",
+        "    console.log(234e18);",
+        "    console.log(234e18.toFixed(0));",
+        "    console.log(2e-8);",
+        "    console.log(2e-8.toFixed(0));",
+        "    console.log(0xde0b6b3a7640080);",
+        "    console.log(0xde0b6b3a7640080.toFixed(0));",
+        "    console.log(-0xde0b6b3a7640080);",
+        "    console.log((-0xde0b6b3a7640080).toFixed(0));",
+        "})();",
     ]
+    expect_stdout: true
+}
+
+parentheses_for_prototype_functions_galio: {
+    beautify = {
+        beautify: true,
+        galio: true,
+    }
+    input: {
+        (function() {
+            console.log((-2));
+            console.log((-2).toFixed(0));
+
+            console.log((2));
+            console.log((2).toFixed(0));
+
+            console.log((0.2));
+            console.log((0.2).toFixed(0));
+
+            console.log((2.34e20));
+            console.log((2.34e20).toFixed(0));
+
+            console.log((0.00000002));
+            console.log((0.00000002).toFixed(0));
+
+            console.log((1000000000000000128));
+            console.log((1000000000000000128).toFixed(0));
+
+            console.log((-1000000000000000128));
+            console.log((-1000000000000000128).toFixed(0));
+        })();
+    }
+    expect_exact: [
+        "(function() {",
+        "    console.log(-2);",
+        "    console.log((-2).toFixed(0));",
+        "    console.log(2);",
+        "    console.log(2..toFixed(0));",
+        "    console.log(.2);",
+        "    console.log(.2.toFixed(0));",
+        "    console.log(234e18);",
+        "    console.log(234e18.toFixed(0));",
+        "    console.log(2e-8);",
+        "    console.log(2e-8.toFixed(0));",
+        "    console.log(0xde0b6b3a7640080);",
+        "    console.log((0xde0b6b3a7640080).toFixed(0));",
+        "    console.log(-0xde0b6b3a7640080);",
+        "    console.log((-0xde0b6b3a7640080).toFixed(0));",
+        "})();",
+    ]
+    expect_stdout: true
 }
 
 comparisons: {

test/compress/objects.js

@@ -45,8 +45,8 @@ duplicate_key_strict: {
         "use strict";
         var o = {
             a: 1,
-            b: 2,
             a: 3,
+            b: 2,
         };
         for (var k in o)
             console.log(k, o[k]);
@@ -221,3 +221,195 @@ numeric_literal: {
         "8 7 8",
     ]
 }
+
+evaluate_computed_key: {
+    options = {
+        evaluate: true,
+        objects: true,
+    }
+    input: {
+        console.log({
+            ["foo" + "bar"]: "PASS",
+        }.foobar);
+    }
+    expect: {
+        console.log({
+            foobar: "PASS",
+        }.foobar);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+keep_computed_key: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        ({
+            [console.log("PASS")]: 42,
+        });
+    }
+    expect: {
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_4269_1: {
+    options = {
+        evaluate: true,
+        objects: true,
+    }
+    input: {
+        console.log({
+            get 0() {
+                return "FAIL";
+            },
+            [0]: "PASS",
+        }[0]);
+    }
+    expect: {
+        console.log({
+            get 0() {
+                return "FAIL";
+            },
+            [0]: "PASS",
+        }[0]);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_4269_2: {
+    options = {
+        evaluate: true,
+        objects: true,
+    }
+    input: {
+        console.log({
+            get [0]() {
+                return "FAIL";
+            },
+            0: "PASS",
+        }[0]);
+    }
+    expect: {
+        console.log({
+            get [0]() {
+                return "FAIL";
+            },
+            0: "PASS",
+        }[0]);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_4269_3: {
+    options = {
+        evaluate: true,
+        objects: true,
+    }
+    input: {
+        console.log({
+            ["foo"]: "bar",
+            get 42() {
+                return "FAIL";
+            },
+            42: "PASS",
+        }[42]);
+    }
+    expect: {
+        console.log({
+            foo: "bar",
+            get [42]() {
+                return "FAIL";
+            },
+            42: "PASS",
+        }[42]);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_4269_4: {
+    options = {
+        evaluate: true,
+        objects: true,
+    }
+    input: {
+        console.log({
+            get 42() {
+                return "FAIL";
+            },
+            ["foo"]: "bar",
+            42: "PASS",
+        }[42]);
+    }
+    expect: {
+        console.log({
+            get 42() {
+                return "FAIL";
+            },
+            foo: "bar",
+            [42]: "PASS",
+        }[42]);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_4269_5: {
+    options = {
+        evaluate: true,
+        objects: true,
+    }
+    input: {
+        console.log({
+            get 42() {
+                return "FAIL";
+            },
+            [console]: "bar",
+            42: "PASS",
+        }[42]);
+    }
+    expect: {
+        console.log({
+            get 42() {
+                return "FAIL";
+            },
+            [console]: "bar",
+            42: "PASS",
+        }[42]);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_4380: {
+    options = {
+        evaluate: true,
+        objects: true,
+    }
+    input: {
+        console.log({
+            get 0() {
+                return "FAIL 1";
+            },
+            0: "FAIL 2",
+            [0]: "PASS",
+        }[0]);
+    }
+    expect: {
+        console.log({
+            get 0() {
+                return "FAIL 1";
+            },
+            [0]: ("FAIL 2", "PASS"),
+        }[0]);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}

test/compress/reduce_vars.js

@@ -1999,7 +1999,7 @@ issue_1606: {
             var a, b;
             function g(){};
             b = 2;
-            x(b);
+            x(2);
         }
     }
 }

test/compress/side_effects.js

@@ -433,3 +433,76 @@ trim_new: {
     }
     expect_stdout: "PASS"
 }
+
+issue_4325: {
+    options = {
+        keep_fargs: "strict",
+        passes: 2,
+        pure_getters: "strict",
+        reduce_vars: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        (function f() {
+            (function(b, c) {
+                try {
+                    c.p = 0;
+                } catch (e) {
+                    console.log("PASS");
+                    return b;
+                }
+                c;
+            })(f++);
+        })();
+    }
+    expect: {
+        (function() {
+            (function() {
+                try {
+                    (void 0).p = 0;
+                } catch (e) {
+                    console.log("PASS");
+                    return;
+                }
+            })();
+        })();
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4366_1: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        ({
+            p: 42,
+            get p() {},
+            q: console.log("PASS"),
+        });
+    }
+    expect: {
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_4366_2: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        ({
+            set p(v) {},
+            q: console.log("PASS"),
+            p: 42,
+        });
+    }
+    expect: {
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}

test/compress/spread.js

@@ -0,0 +1,806 @@
+collapse_vars_1: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var a;
+        [ ...a = "PASS", "PASS"].slice();
+        console.log(a);
+    }
+    expect: {
+        var a;
+        [ ...a = "PASS", "PASS"].slice();
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+collapse_vars_2: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var a = "FAIL";
+        try {
+            a = "PASS";
+            [ ...42, "PASS"].slice();
+        } catch (e) {
+            console.log(a);
+        }
+    }
+    expect: {
+        var a = "FAIL";
+        try {
+            a = "PASS";
+            [ ...42, "PASS"].slice();
+        } catch (e) {
+            console.log(a);
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+collapse_vars_3: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var a = "FAIL";
+        try {
+            [ ...(a = "PASS", 42), "PASS"].slice();
+        } catch (e) {
+            console.log(a);
+        }
+    }
+    expect: {
+        var a = "FAIL";
+        try {
+            [ ...(a = "PASS", 42), "PASS"].slice();
+        } catch (e) {
+            console.log(a);
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+collapse_vars_4: {
+    options = {
+        collapse_vars: true,
+        unused: true,
+    }
+    input: {
+        console.log(function(a) {
+            return a;
+        }(...[ "PASS", "FAIL" ]));
+    }
+    expect: {
+        console.log(function(a) {
+            return a;
+        }(...[ "PASS", "FAIL" ]));
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+dont_inline: {
+    options = {
+        inline: true,
+    }
+    input: {
+        console.log(function(a) {
+            return a;
+        }(...[ "PASS", "FAIL" ]));
+    }
+    expect: {
+        console.log(function(a) {
+            return a;
+        }(...[ "PASS", "FAIL" ]));
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+do_inline: {
+    options = {
+        inline: true,
+        spread: true,
+    }
+    input: {
+        console.log(function(a) {
+            return a;
+        }(...[ "PASS", "FAIL" ]));
+    }
+    expect: {
+        console.log(("FAIL", "PASS"));
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+drop_empty_call_1: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        try {
+            (function() {})(...null);
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect: {
+        try {
+            [ ...null ];
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+drop_empty_call_2: {
+    options = {
+        side_effects: true,
+        spread: true,
+    }
+    input: {
+        (function() {})(...[ console.log("PASS") ]);
+    }
+    expect: {
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+convert_hole: {
+    options = {
+        spread: true,
+    }
+    input: {
+        console.log(...[ "PASS", , 42 ]);
+    }
+    expect: {
+        console.log("PASS", void 0, 42);
+    }
+    expect_stdout: "PASS undefined 42"
+    node_version: ">=6"
+}
+
+keep_property_access: {
+    options = {
+        properties: true,
+        side_effects: true,
+    }
+    input: {
+        console.log(function() {
+            return [ ..."foo" ][0];
+        }());
+    }
+    expect: {
+        console.log(function() {
+            return [ ..."foo" ][0];
+        }());
+    }
+    expect_stdout: "f"
+    node_version: ">=6"
+}
+
+keep_fargs: {
+    options = {
+        keep_fargs: "strict",
+        unused: true,
+    }
+    input: {
+        var a = [ "PASS" ];
+        (function(b, c) {
+            console.log(c);
+        })(console, ...a);
+    }
+    expect: {
+        var a = [ "PASS" ];
+        (function(b, c) {
+            console.log(c);
+        })(console, ...a);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+reduce_vars_1: {
+    options = {
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        console.log(function(b, c) {
+            return c ? "PASS" : "FAIL";
+        }(..."foo"));
+    }
+    expect: {
+        console.log(function(b, c) {
+            return c ? "PASS" : "FAIL";
+        }(..."foo"));
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+reduce_vars_2: {
+    options = {
+        conditionals: true,
+        evaluate: true,
+        reduce_vars: true,
+    }
+    input: {
+        console.log(function(b, c) {
+            return c ? "PASS" : "FAIL";
+        }(..."foo"));
+    }
+    expect: {
+        console.log(function(b, c) {
+            return c ? "PASS" : "FAIL";
+        }(..."foo"));
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+convert_setter: {
+    options = {
+        objects: true,
+        spread: true,
+    }
+    input: {
+        var o = {
+            ...{
+                set PASS(v) {},
+            },
+        };
+        for (var k in o)
+            console.log(k, o[k]);
+    }
+    expect: {
+        var o = {
+            PASS: void 0,
+        };
+        for (var k in o)
+            console.log(k, o[k]);
+    }
+    expect_stdout: "PASS undefined"
+    node_version: ">=8"
+}
+
+keep_getter_1: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        ({
+            ...{
+                get p() {
+                    console.log("PASS");
+                },
+            },
+            get q() {
+                console.log("FAIL");
+            },
+        });
+    }
+    expect: {
+        ({
+            ...{
+                get p() {
+                    console.log("PASS");
+                },
+            },
+        });
+    }
+    expect_stdout: "PASS"
+    node_version: ">=8"
+}
+
+keep_getter_2: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        ({
+            ...(console.log("foo"), {
+                get p() {
+                    console.log("bar");
+                },
+            }),
+        });
+    }
+    expect: {
+        ({
+            ...(console.log("foo"), {
+                get p() {
+                    console.log("bar");
+                },
+            }),
+        });
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+    ]
+    node_version: ">=8"
+}
+
+keep_getter_3: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        ({
+            ...function() {
+                return {
+                    get p() {
+                        console.log("PASS");
+                    },
+                };
+            }(),
+        });
+    }
+    expect: {
+        ({
+            ...function() {
+                return {
+                    get p() {
+                        console.log("PASS");
+                    },
+                };
+            }(),
+        });
+    }
+    expect_stdout: "PASS"
+    node_version: ">=8"
+}
+
+keep_getter_4: {
+    options = {
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+    }
+    input: {
+        var o = {
+            get p() {
+                console.log("PASS");
+            },
+        };
+        ({
+            q: o,
+            ...o,
+        });
+    }
+    expect: {
+        var o = {
+            get p() {
+                console.log("PASS");
+            },
+        };
+        ({
+            ...o,
+        });
+    }
+    expect_stdout: "PASS"
+    node_version: ">=8"
+}
+
+keep_accessor: {
+    options = {
+        objects: true,
+        spread: true,
+    }
+    input: {
+        var o = {
+            ...{
+                get p() {
+                    console.log("GET");
+                    return this.r;
+                },
+                set q(v) {
+                    console.log("SET", v);
+                },
+                r: 42,
+            },
+            r: null,
+        };
+        for (var k in o)
+            console.log(k, o[k]);
+    }
+    expect: {
+        var o = {
+            ...{
+                get p() {
+                    console.log("GET");
+                    return this.r;
+                },
+                set q(v) {
+                    console.log("SET", v);
+                },
+                r: 42,
+            },
+            r: null,
+        };
+        for (var k in o)
+            console.log(k, o[k]);
+    }
+    expect_stdout: [
+        "GET",
+        "p 42",
+        "q undefined",
+        "r null",
+    ]
+    node_version: ">=8"
+}
+
+object_key_order_1: {
+    options = {
+        objects: true,
+        spread: true,
+    }
+    input: {
+        var o = {
+            ...{},
+            a: 1,
+            b: 2,
+            a: 3,
+        };
+        for (var k in o)
+            console.log(k, o[k]);
+    }
+    expect: {
+        var o = {
+            a: (1, 3),
+            b: 2,
+        };
+        for (var k in o)
+            console.log(k, o[k]);
+    }
+    expect_stdout: [
+        "a 3",
+        "b 2",
+    ]
+    node_version: ">=8 <=10"
+}
+
+object_key_order_2: {
+    options = {
+        objects: true,
+        spread: true,
+    }
+    input: {
+        var o = {
+            a: 1,
+            ...{},
+            b: 2,
+            a: 3,
+        };
+        for (var k in o)
+            console.log(k, o[k]);
+    }
+    expect: {
+        var o = {
+            a: (1, 3),
+            b: 2,
+        };
+        for (var k in o)
+            console.log(k, o[k]);
+    }
+    expect_stdout: [
+        "a 3",
+        "b 2",
+    ]
+    node_version: ">=8"
+}
+
+object_key_order_3: {
+    options = {
+        objects: true,
+        spread: true,
+    }
+    input: {
+        var o = {
+            a: 1,
+            b: 2,
+            ...{},
+            a: 3,
+        };
+        for (var k in o)
+            console.log(k, o[k]);
+    }
+    expect: {
+        var o = {
+            a: (1, 3),
+            b: 2,
+        };
+        for (var k in o)
+            console.log(k, o[k]);
+    }
+    expect_stdout: [
+        "a 3",
+        "b 2",
+    ]
+    node_version: ">=8"
+}
+
+object_key_order_4: {
+    options = {
+        objects: true,
+        spread: true,
+    }
+    input: {
+        var o = {
+            a: 1,
+            b: 2,
+            a: 3,
+            ...{},
+        };
+        for (var k in o)
+            console.log(k, o[k]);
+    }
+    expect: {
+        var o = {
+            a: (1, 3),
+            b: 2,
+        };
+        for (var k in o)
+            console.log(k, o[k]);
+    }
+    expect_stdout: [
+        "a 3",
+        "b 2",
+    ]
+    node_version: ">=8"
+}
+
+object_spread_array: {
+    options = {
+        objects: true,
+        spread: true,
+    }
+    input: {
+        var o = {
+            ...[ "foo", "bar" ],
+        };
+        for (var k in o)
+            console.log(k, o[k]);
+    }
+    expect: {
+        var o = {
+            ...[ "foo", "bar" ],
+        };
+        for (var k in o)
+            console.log(k, o[k]);
+    }
+    expect_stdout: [
+        "0 foo",
+        "1 bar",
+    ]
+    node_version: ">=8"
+}
+
+object_spread_string: {
+    options = {
+        objects: true,
+        spread: true,
+    }
+    input: {
+        var o = {
+            ..."foo",
+        };
+        for (var k in o)
+            console.log(k, o[k]);
+    }
+    expect: {
+        var o = {
+            ..."foo",
+        };
+        for (var k in o)
+            console.log(k, o[k]);
+    }
+    expect_stdout: [
+        "0 f",
+        "1 o",
+        "2 o",
+    ]
+    node_version: ">=8"
+}
+
+unused_var_side_effects: {
+    options = {
+        unused: true,
+    }
+    input: {
+        (function f(a) {
+            var b = {
+                ...a,
+            };
+        })({
+            get p() {
+                console.log("PASS");
+            },
+        });
+    }
+    expect: {
+        (function(a) {
+            ({
+                ...a,
+            });
+        })({
+            get p() {
+                console.log("PASS");
+            },
+        });
+    }
+    expect_stdout: "PASS"
+    node_version: ">=8"
+}
+
+issue_4329: {
+    options = {
+        objects: true,
+        spread: true,
+    }
+    input: {
+        console.log({
+            ...{
+                get 0() {
+                    return "FAIL";
+                },
+                ...{
+                    0: "PASS",
+                },
+            },
+        }[0]);
+    }
+    expect: {
+        console.log({
+            ...{
+                get 0() {
+                    return "FAIL";
+                },
+                [0]: "PASS",
+            },
+        }[0]);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=8"
+}
+
+issue_4331: {
+    options = {
+        collapse_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var a = "PASS", b;
+        console,
+        b = a;
+        (function() {
+            a++;
+        })(...a);
+        console.log(b);
+    }
+    expect: {
+        var a = "PASS", b;
+        console;
+        (function() {
+            a++;
+        })(...b = a);
+        console.log(b);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_4342: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        try {
+            new function() {}(...42);
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect: {
+        try {
+            [ ...42 ];
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_4345: {
+    options = {
+        objects: true,
+        spread: true,
+    }
+    input: {
+        console.log({
+            ...{
+                get 42() {
+                    return "FAIL";
+                },
+                ...{},
+                42: "PASS",
+            },
+        }[42]);
+    }
+    expect: {
+        console.log({
+            ...{
+                get 42() {
+                    return "FAIL";
+                },
+                [42]: "PASS",
+            },
+        }[42]);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=8"
+}
+
+issue_4361: {
+    options = {
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        console.log(function() {
+            var a = console.log("foo");
+            console;
+            var b = {
+                ...a,
+            };
+        }());
+    }
+    expect: {
+        console.log(function() {
+            var a = console.log("foo");
+            console;
+            ({
+                ...a,
+            });
+        }());
+    }
+    expect_stdout: [
+        "foo",
+        "undefined",
+    ]
+    node_version: ">=8"
+}
+
+issue_4363: {
+    options = {
+        objects: true,
+        spread: true,
+    }
+    input: {
+        ({
+            ...{
+                set [console.log("PASS")](v) {},
+            },
+        });
+    }
+    expect: {
+        ({
+            [console.log("PASS")]: void 0,
+        });
+    }
+    expect_stdout: "PASS"
+    node_version: ">=8"
+}

test/compress/varify.js

@@ -234,3 +234,178 @@ issue_4191_let: {
     expect_stdout: "function undefined"
     node_version: ">=4"
 }
+
+forin_const_1: {
+    options = {
+        join_vars: true,
+        reduce_vars: true,
+        toplevel: true,
+        varify: true,
+    }
+    input: {
+        const o = {
+            foo: 42,
+            bar: "PASS",
+        };
+        for (const k in o)
+            console.log(k, o[k]);
+    }
+    expect: {
+        var o = {
+            foo: 42,
+            bar: "PASS",
+        };
+        for (const k in o)
+            console.log(k, o[k]);
+    }
+    expect_stdout: true
+    node_version: ">=4"
+}
+
+forin_const_2: {
+    options = {
+        join_vars: true,
+        reduce_vars: true,
+        toplevel: true,
+        varify: true,
+    }
+    input: {
+        const o = {
+            p: 42,
+            q: "PASS",
+        };
+        for (const [ k ] in o)
+            console.log(k, o[k]);
+    }
+    expect: {
+        var o = {
+            p: 42,
+            q: "PASS",
+        }, k;
+        for ([ k ] in o)
+            console.log(k, o[k]);
+    }
+    expect_stdout: [
+        "p 42",
+        "q PASS",
+    ]
+    node_version: ">=6"
+}
+
+forin_let_1: {
+    options = {
+        join_vars: true,
+        reduce_vars: true,
+        toplevel: true,
+        varify: true,
+    }
+    input: {
+        "use strict";
+        let o = {
+            foo: 42,
+            bar: "PASS",
+        };
+        for (let k in o)
+            console.log(k, o[k]);
+    }
+    expect: {
+        "use strict";
+        var o = {
+            foo: 42,
+            bar: "PASS",
+        }, k;
+        for (k in o)
+            console.log(k, o[k]);
+    }
+    expect_stdout: [
+        "foo 42",
+        "bar PASS",
+    ]
+    node_version: ">=4"
+}
+
+forin_let_2: {
+    options = {
+        join_vars: true,
+        reduce_vars: true,
+        toplevel: true,
+        varify: true,
+    }
+    input: {
+        let o = {
+            p: 42,
+            q: "PASS",
+        };
+        for (let [ k ] in o)
+            console.log(k, o[k]);
+    }
+    expect: {
+        var o = {
+            p: 42,
+            q: "PASS",
+        }, k;
+        for ([ k ] in o)
+            console.log(k, o[k]);
+    }
+    expect_stdout: [
+        "p 42",
+        "q PASS",
+    ]
+    node_version: ">=6"
+}
+
+issue_4290_1_const: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        varify: true,
+    }
+    input: {
+        const a = 0;
+        var a;
+    }
+    expect: {
+        const a = 0;
+        var a;
+    }
+    expect_stdout: true
+}
+
+issue_4290_1_let: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        varify: true,
+    }
+    input: {
+        "use strict";
+        let a = 0;
+        var a;
+    }
+    expect: {
+        "use strict";
+        let a = 0;
+        var a;
+    }
+    expect_stdout: true
+    node_version: ">=4"
+}
+
+drop_forin_let: {
+    options = {
+        loops: true,
+        toplevel: true,
+        unused: true,
+        varify: true,
+    }
+    input: {
+        "use strict";
+        for (let a in console.log("PASS"));
+    }
+    expect: {
+        "use strict";
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}

test/mocha/async.js

@@ -0,0 +1,65 @@
+var assert = require("assert");
+var UglifyJS = require("../node");
+
+describe("async", function() {
+    it("Should reject `await` as symbol name within async functions only", function() {
+        [
+            "function await() {}",
+            "function(await) {}",
+            "function() { await; }",
+            "function() { await:{} }",
+            "function() { var await; }",
+            "function() { function await() {} }",
+            "function() { try {} catch (await) {} }",
+        ].forEach(function(code) {
+            var ast = UglifyJS.parse("(" + code + ")();");
+            assert.strictEqual(ast.TYPE, "Toplevel");
+            assert.strictEqual(ast.body.length, 1);
+            assert.strictEqual(ast.body[0].TYPE, "SimpleStatement");
+            assert.strictEqual(ast.body[0].body.TYPE, "Call");
+            assert.strictEqual(ast.body[0].body.expression.TYPE, "Function");
+            assert.throws(function() {
+                UglifyJS.parse("(async " + code + ")();");
+            }, function(e) {
+                return e instanceof UglifyJS.JS_Parse_Error;
+            }, code);
+        });
+    });
+    it("Should reject `await` expression outside of async functions", function() {
+        [
+            "await 42;",
+            "function f() { await 42; }",
+            "async function f() { function g() { await 42; } }",
+        ].forEach(function(code) {
+            assert.throws(function() {
+                UglifyJS.parse(code);
+            }, function(e) {
+                return e instanceof UglifyJS.JS_Parse_Error;
+            }, code);
+        });
+    });
+    it("Should reject `await` expression directly on computed key of function argument", function() {
+        [
+            "function f({ [await 42]: a }) {}",
+            "async function f({ [await 42]: a }) {}",
+        ].forEach(function(code) {
+            assert.throws(function() {
+                UglifyJS.parse(code);
+            }, function(e) {
+                return e instanceof UglifyJS.JS_Parse_Error;
+            }, code);
+        });
+    });
+    it("Should accept `await` expression nested within computed key of function argument", function() {
+        [
+            "function f({ [async function() { await 42; }()]: a }) {}",
+            "async function f({ [async function() { await 42; }()]: a }) {}",
+        ].forEach(function(code) {
+            var ast = UglifyJS.parse(code);
+            assert.strictEqual(ast.TYPE, "Toplevel");
+            assert.strictEqual(ast.body.length, 1);
+            assert.strictEqual(ast.body[0].argnames.length, 1);
+            assert.strictEqual(ast.body[0].argnames[0].TYPE, "DestructuredObject");
+        });
+    });
+});

test/mocha/tokens.js

@@ -5,7 +5,7 @@ describe("tokens", function() {
     it("Should give correct positions for accessors", function() {
         // location               0         1         2         3         4
         //                        01234567890123456789012345678901234567890123456789
-        var ast = UglifyJS.parse("var obj = { get latest() { return undefined; } }");
+        var ast = UglifyJS.parse("var obj = { get [prop]() { return undefined; } }");
         // test all AST_ObjectProperty tokens are set as expected
         var found = false;
         ast.walk(new UglifyJS.TreeWalker(function(node) {
@@ -13,9 +13,9 @@ describe("tokens", function() {
                 found = true;
                 assert.equal(node.start.pos, 12);
                 assert.equal(node.end.endpos, 46);
-                assert(node.key instanceof UglifyJS.AST_SymbolAccessor);
-                assert.equal(node.key.start.pos, 16);
-                assert.equal(node.key.end.endpos, 22);
+                assert(node.key instanceof UglifyJS.AST_SymbolRef);
+                assert.equal(node.key.start.pos, 17);
+                assert.equal(node.key.end.endpos, 21);
                 assert(node.value instanceof UglifyJS.AST_Accessor);
                 assert.equal(node.value.start.pos, 22);
                 assert.equal(node.value.end.endpos, 46);

test/reduce.js

@@ -18,9 +18,18 @@ var sandbox = require("./sandbox");
 
 Error.stackTraceLimit = Infinity;
 module.exports = function reduce_test(testcase, minify_options, reduce_options) {
-    if (testcase instanceof U.AST_Node) testcase = testcase.print_to_string();
     minify_options = minify_options || {};
     reduce_options = reduce_options || {};
+    var print_options = {};
+    [
+        "ie8",
+        "v8",
+        "webkit",
+    ].forEach(function(name) {
+        var value = minify_options[name] || minify_options.output && minify_options.output[name];
+        if (value) print_options[name] = value;
+    });
+    if (testcase instanceof U.AST_Node) testcase = testcase.print_to_string(print_options);
     var max_iterations = reduce_options.max_iterations || 1000;
     var max_timeout = reduce_options.max_timeout || 10000;
     var warnings = [];
@@ -95,6 +104,7 @@ module.exports = function reduce_test(testcase, minify_options, reduce_options)
 
             // quick ignores
             if (node instanceof U.AST_Accessor) return;
+            if (node instanceof U.AST_Destructured) return;
             if (node instanceof U.AST_Directive) return;
             if (!in_list && node instanceof U.AST_EmptyStatement) return;
             if (node instanceof U.AST_Label) return;
@@ -114,6 +124,8 @@ module.exports = function reduce_test(testcase, minify_options, reduce_options)
 
             // ignore lvalues
             if (parent instanceof U.AST_Assign && parent.left === node) return;
+            if (parent instanceof U.AST_DestructuredArray) return;
+            if (parent instanceof U.AST_DestructuredKeyVal && parent.value === node) return;
             if (parent instanceof U.AST_Unary && parent.expression === node) switch (parent.operator) {
               case "++":
               case "--":
@@ -132,7 +144,7 @@ module.exports = function reduce_test(testcase, minify_options, reduce_options)
                 if (expr && !(expr instanceof U.AST_Hole)) {
                     node.start._permute++;
                     CHANGED = true;
-                    return expr;
+                    return expr instanceof U.AST_Spread ? expr.expression : expr;
                 }
             }
             else if (node instanceof U.AST_Binary) {
@@ -161,7 +173,7 @@ module.exports = function reduce_test(testcase, minify_options, reduce_options)
                 ][ ((node.start._permute += step) * steps | 0) % 3 ];
                 if (expr) {
                     CHANGED = true;
-                    return expr;
+                    return expr instanceof U.AST_Spread ? expr.expression : expr;
                 }
                 if (node.expression instanceof U.AST_Function) {
                     // hoist and return expressions from the IIFE function expression
@@ -250,13 +262,23 @@ module.exports = function reduce_test(testcase, minify_options, reduce_options)
                 }
             }
             else if (node instanceof U.AST_ForIn) {
-                var expr = [
-                    node.init,
-                    node.object,
-                    node.body,
-                ][ (node.start._permute * steps | 0) % 3 ];
+                var expr;
+                switch ((node.start._permute * steps | 0) % 3) {
+                  case 0:
+                    if (!(node.init instanceof U.AST_Definitions
+                        && node.init.definitions[0].name instanceof U.AST_Destructured)) {
+                        expr = node.init;
+                    }
+                    break;
+                  case 1:
+                    expr = node.object;
+                    break;
+                  case 2:
+                    if (!has_loopcontrol(node.body, node, parent)) expr = node.body;
+                    break;
+                }
                 node.start._permute += step;
-                if (expr && (expr !== node.body || !has_loopcontrol(expr, node, parent))) {
+                if (expr) {
                     CHANGED = true;
                     return to_statement(expr);
                 }
@@ -368,9 +390,8 @@ module.exports = function reduce_test(testcase, minify_options, reduce_options)
             }
 
             if (in_list) {
-                // special case to drop object properties and switch branches
-                if (parent instanceof U.AST_Object
-                    || parent instanceof U.AST_Switch && parent.expression != node) {
+                // drop switch branches
+                if (parent instanceof U.AST_Switch && parent.expression != node) {
                     node.start._permute++;
                     CHANGED = true;
                     return List.skip;
@@ -389,6 +410,15 @@ module.exports = function reduce_test(testcase, minify_options, reduce_options)
                     CHANGED = true;
                     return List.skip;
                 }
+
+                // skip element/property from (destructured) array/object
+                if (parent instanceof U.AST_Array
+                    || parent instanceof U.AST_Destructured
+                    || parent instanceof U.AST_Object) {
+                    node.start._permute++;
+                    CHANGED = true;
+                    return List.skip;
+                }
             }
 
             // replace this node
@@ -438,7 +468,7 @@ module.exports = function reduce_test(testcase, minify_options, reduce_options)
                         return node;
                     }
                 }));
-                var code = testcase_ast.print_to_string();
+                var code = testcase_ast.print_to_string(print_options);
                 var diff = test_for_diff(code, minify_options, result_cache, max_timeout);
                 if (diff && !diff.timed_out && !diff.error) {
                     testcase = code;
@@ -462,7 +492,7 @@ module.exports = function reduce_test(testcase, minify_options, reduce_options)
                 var code_ast = testcase_ast.clone(true).transform(tt);
                 if (!CHANGED) break;
                 try {
-                    var code = code_ast.print_to_string();
+                    var code = code_ast.print_to_string(print_options);
                 } catch (ex) {
                     // AST is not well formed.
                     // no harm done - just log the error, ignore latest change and continue iterating.
@@ -504,11 +534,13 @@ module.exports = function reduce_test(testcase, minify_options, reduce_options)
         var beautified = U.minify(testcase, {
             compress: false,
             mangle: false,
-            output: {
-                beautify: true,
-                braces: true,
-                comments: true,
-            },
+            output: function() {
+                var options = JSON.parse(JSON.stringify(print_options));
+                options.beautify = true;
+                options.braces = true;
+                options.comments = true;
+                return options;
+            }(),
         });
         testcase = {
             code: testcase,
@@ -597,7 +629,7 @@ function is_timed_out(result) {
 }
 
 function is_statement(node) {
-    return node instanceof U.AST_Statement && !(node instanceof U.AST_Function);
+    return node instanceof U.AST_Statement && !(node instanceof U.AST_AsyncFunction || node instanceof U.AST_Function);
 }
 
 function merge_sequence(array, node) {

test/sandbox.js

@@ -26,17 +26,27 @@ var setupContext = new vm.Script([
 ]).join("\n"));
 
 function createContext() {
-    var ctx = vm.createContext(Object.defineProperty({}, "console", { value: { log: log } }));
+    var ctx = vm.createContext(Object.defineProperties({}, {
+        console: { value: { log: log } },
+        global: { get: self },
+        self: { get: self },
+        window: { get: self },
+    }));
     var global = setupContext.runInContext(ctx);
     return ctx;
 
+    function self() {
+        return this;
+    }
+
     function safe_log(arg, level) {
         if (arg) switch (typeof arg) {
-        case "function":
+          case "function":
             return arg.toString();
-        case "object":
+          case "object":
             if (arg === global) return "[object global]";
             if (/Error$/.test(arg.name)) return arg.toString();
+            if (typeof arg.then == "function") return "[object Promise]";
             arg.constructor.toString();
             if (level--) for (var key in arg) {
                 var desc = Object.getOwnPropertyDescriptor(arg, key);

test/ufuzz/index.js

@@ -126,6 +126,22 @@ for (var i = 2; i < process.argv.length; ++i) {
     }
 }
 
+var SUPPORT = function(matrix) {
+    for (var name in matrix) {
+        matrix[name] = typeof sandbox.run_code(matrix[name]) == "string";
+    }
+    return matrix;
+}({
+    async: "async function f(){}",
+    catch_omit_var: "try {} catch {}",
+    computed_key: "({[0]: 0});",
+    destructuring: "[] = [];",
+    let: "let a;",
+    spread: "[...[]];",
+    spread_object: "({...0});",
+    trailing_comma: "function f(a,) {}",
+});
+
 var VALUES = [
     '"a"',
     '"b"',
@@ -276,6 +292,7 @@ var NO_DEFUN = false;
 var DEFUN_OK = true;
 var DONT_STORE = true;
 var NO_CONST = true;
+var NO_DUPLICATE = true;
 
 var VAR_NAMES = [
     "a",
@@ -297,6 +314,8 @@ var VAR_NAMES = [
     "arguments",
     "Math",
     "parseInt",
+    "async",
+    "await",
 ];
 var INITIAL_NAMES_LEN = VAR_NAMES.length;
 
@@ -313,8 +332,10 @@ var TYPEOF_OUTCOMES = [
     "crap",
 ];
 
+var avoid_vars = [];
 var block_vars = [];
 var unique_vars = [];
+var async = false;
 var loops = 0;
 var funcs = 0;
 var called = Object.create(null);
@@ -333,6 +354,7 @@ function createTopLevelCode() {
     VAR_NAMES.length = INITIAL_NAMES_LEN; // prune any previous names still in the list
     block_vars.length = 0;
     unique_vars.length = 0;
+    async = false;
     loops = 0;
     funcs = 0;
     called = Object.create(null);
@@ -356,20 +378,164 @@ function createFunctions(n, recurmax, allowDefun, canThrow, stmtDepth) {
     return s;
 }
 
-function createParams() {
+function addTrailingComma(list) {
+    return SUPPORT.trailing_comma && list && rng(20) == 0 ? list + "," : list;
+}
+
+function createParams(noDuplicate) {
+    var len = unique_vars.length;
     var params = [];
     for (var n = rng(4); --n >= 0;) {
-        params.push(createVarName(MANDATORY));
+        var name = createVarName(MANDATORY);
+        if (noDuplicate) unique_vars.push(name);
+        params.push(name);
     }
-    return params.join(", ");
+    unique_vars.length = len;
+    return addTrailingComma(params.join(", "));
 }
 
 function createArgs(recurmax, stmtDepth, canThrow) {
+    recurmax--;
     var args = [];
-    for (var n = rng(4); --n >= 0;) {
-        args.push(rng(2) ? createValue() : createExpression(recurmax - 1, COMMA_OK, stmtDepth, canThrow));
+    for (var n = rng(4); --n >= 0;) switch (SUPPORT.spread ? rng(50) : 3) {
+      case 0:
+      case 1:
+        var name = getVarName();
+        if (canThrow && rng(8) === 0) {
+            args.push("..." + name);
+        } else {
+            args.push('...("" + ' + name + ")");
+        }
+        break;
+      case 2:
+        args.push("..." + createArrayLiteral(recurmax, stmtDepth, canThrow));
+        break;
+      default:
+        args.push(rng(2) ? createValue() : createExpression(recurmax, COMMA_OK, stmtDepth, canThrow));
+        break;
+    }
+    return addTrailingComma(args.join(", "));
+}
+
+function createAssignmentPairs(recurmax, noComma, stmtDepth, canThrow, varNames, was_async) {
+    var avoid = [];
+    var len = unique_vars.length;
+    var pairs = createPairs(recurmax);
+    unique_vars.length = len;
+    return pairs;
+
+    function createAssignmentValue(recurmax) {
+        var current = VAR_NAMES;
+        VAR_NAMES = (varNames || VAR_NAMES).slice();
+        var save_async = async;
+        if (was_async != null) async = was_async;
+        var value = varNames && rng(2) ? createValue() : createExpression(recurmax, noComma, stmtDepth, canThrow);
+        async = save_async;
+        VAR_NAMES = current;
+        return value;
+    }
+
+    function createKey(recurmax, keys) {
+        addAvoidVars(avoid);
+        var key;
+        do {
+            key = createObjectKey(recurmax, stmtDepth, canThrow);
+        } while (keys.indexOf(key) >= 0);
+        removeAvoidVars(avoid);
+        return key;
+    }
+
+    function createPairs(recurmax) {
+        var names = [], values = [];
+        var m = rng(4), n = rng(4);
+        if (!varNames) m = Math.max(m, n, 1);
+        for (var i = Math.max(m, n); --i >= 0;) {
+            if (i < m && i < n) {
+                createDestructured(recurmax, names, values);
+                continue;
+            }
+            if (i < m) {
+                unique_vars.push("a", "b", "c", "undefined", "NaN", "Infinity");
+                var name = createVarName(MANDATORY);
+                unique_vars.length -= 6;
+                avoid.push(name);
+                unique_vars.push(name);
+                names.unshift(name);
+            }
+            if (i < n) {
+                values.unshift(createAssignmentValue(recurmax));
+            }
+        }
+        return {
+            names: names,
+            values: values,
+        };
+    }
+
+    function createDestructured(recurmax, names, values) {
+        switch (rng(20)) {
+          case 0:
+            if (--recurmax < 0) {
+                names.unshift("[]");
+                values.unshift('""');
+            } else {
+                var pairs = createPairs(recurmax);
+                while (!rng(10)) {
+                    var index = rng(pairs.names.length + 1);
+                    pairs.names.splice(index, 0, "");
+                    if (index < pairs.values.length) {
+                        pairs.values.splice(index, 0, rng(2) ? createAssignmentValue(recurmax) : "");
+                    } else switch (rng(5)) {
+                      case 0:
+                        pairs.values[index] = createAssignmentValue(recurmax);
+                      case 1:
+                        pairs.values.length = index + 1;
+                    }
+                }
+                names.unshift("[ " + pairs.names.join(", ") + " ]");
+                values.unshift("[ " + pairs.values.join(", ") + " ]");
+            }
+            break;
+          case 1:
+            if (--recurmax < 0) {
+                names.unshift("{}");
+                values.unshift('""');
+            } else {
+                var pairs = createPairs(recurmax);
+                var keys = [];
+                pairs.names.forEach(function(name, index) {
+                    if (/^[[{]/.test(name)) {
+                        var key;
+                        do {
+                            key = KEYS[rng(KEYS.length)];
+                        } while (keys.indexOf(key) >= 0);
+                        keys[index] = key;
+                    }
+                });
+                names.unshift("{ " + addTrailingComma(pairs.names.map(function(name, index) {
+                    var key = index in keys ? keys[index] : rng(10) && createKey(recurmax, keys);
+                    return key ? key + ": " + name : name;
+                }).join(", ")) + " }");
+                var save_async = async;
+                if (was_async != null) async = was_async;
+                values.unshift("{ " + addTrailingComma(pairs.values.map(function(value, index) {
+                    var key = index in keys ? keys[index] : createKey(recurmax, keys);
+                    return key + ": " + value;
+                }).join(", ")) + " }");
+                async = save_async;
+            }
+            break;
+          default:
+            unique_vars.push("a", "b", "c", "undefined", "NaN", "Infinity");
+            var name = createVarName(MANDATORY);
+            unique_vars.length -= 6;
+            avoid.push(name);
+            unique_vars.push(name);
+            names.unshift(name);
+            values.unshift(createAssignmentValue(recurmax));
+            break;
+        }
     }
-    return args.join(", ");
 }
 
 function filterDirective(s) {
@@ -385,15 +551,17 @@ function createBlockVariables(recurmax, stmtDepth, canThrow, fn) {
     unique_vars.push("a", "b", "c", "undefined", "NaN", "Infinity");
     while (!rng(block_vars.length > block_len ? 10 : 100)) {
         var name = createVarName(MANDATORY, DONT_STORE);
-        if (rng(2)) {
-            consts.push(name);
-        } else {
+        if (SUPPORT.let && rng(2)) {
             lets.push(name);
+        } else {
+            consts.push(name);
         }
         block_vars.push(name);
     }
     unique_vars.length -= 6;
     fn(function() {
+        addAvoidVars(consts);
+        addAvoidVars(lets);
         if (rng(2)) {
             return createDefinitions("const", consts) + "\n" + createDefinitions("let", lets) + "\n";
         } else {
@@ -405,28 +573,55 @@ function createBlockVariables(recurmax, stmtDepth, canThrow, fn) {
 
     function createDefinitions(type, names) {
         if (!names.length) return "";
-        var save = VAR_NAMES;
-        VAR_NAMES = VAR_NAMES.filter(function(name) {
-            return names.indexOf(name) < 0;
-        });
-        var len = VAR_NAMES.length;
-        var s = type + " " + names.map(function(name) {
-            var value = createExpression(recurmax, NO_COMMA, stmtDepth, canThrow);
-            VAR_NAMES.push(name);
-            return name + " = " + value;
-        }).join(", ") + ";";
-        VAR_NAMES = save.concat(VAR_NAMES.slice(len));
+        var s = type + " ";
+        switch (SUPPORT.destructuring ? rng(10) : 2) {
+          case 0:
+            while (!rng(10)) names.splice(rng(names.length + 1), 0, "");
+            s += "[ " + names.join(", ") + " ] = [ " + names.map(function() {
+                return rng(10) ? createExpression(recurmax, NO_COMMA, stmtDepth, canThrow) : "";
+            }).join(", ") + " ];";
+            break;
+          case 1:
+            var keys = [];
+            s += "{ " + names.map(function(name, i) {
+                var key = createObjectKey(recurmax, stmtDepth, canThrow);
+                if (!/\[/.test(key)) keys[i] = key;
+                return key + ": " + name;
+            }).join(", ") + "} = { " + names.map(function(name, i) {
+                var key = i in keys ? keys[i] : createObjectKey(recurmax, stmtDepth, canThrow);
+                return key + ": " + createExpression(recurmax, NO_COMMA, stmtDepth, canThrow);
+            }).join(", ") + "};";
+            break;
+          default:
+            s += names.map(function(name) {
+                if (type == "let" && !rng(10)) {
+                    removeAvoidVars([ name ]);
+                    return name;
+                }
+                var value = createExpression(recurmax, NO_COMMA, stmtDepth, canThrow);
+                removeAvoidVars([ name ]);
+                return name + " = " + value;
+            }).join(", ") + ";";
+            break;
+        }
+        removeAvoidVars(names);
         return s;
     }
 }
 
+function makeFunction(name) {
+    return (async ? "async function " : "function ") + name;
+}
+
 function createFunction(recurmax, allowDefun, canThrow, stmtDepth) {
     if (--recurmax < 0) { return ";"; }
     if (!STMT_COUNT_FROM_GLOBAL) stmtDepth = 0;
     var s = [];
-    var name;
+    var name, args;
+    var varNames = VAR_NAMES.slice();
+    var save_async = async;
+    async = SUPPORT.async && rng(50) == 0;
     createBlockVariables(recurmax, stmtDepth, canThrow, function(defns) {
-        var namesLenBefore = VAR_NAMES.length;
         if (allowDefun || rng(5) > 0) {
             name = "f" + funcs++;
         } else {
@@ -434,7 +629,16 @@ function createFunction(recurmax, allowDefun, canThrow, stmtDepth) {
             name = createVarName(MANDATORY, !allowDefun);
             unique_vars.length -= 3;
         }
-        s.push("function " + name + "(" + createParams() + "){", strictMode());
+        var params;
+        if (SUPPORT.destructuring && (!allowDefun || !(name in called)) && rng(2)) {
+            called[name] = false;
+            var pairs = createAssignmentPairs(recurmax, COMMA_OK, stmtDepth, canThrow, varNames, save_async);
+            params = addTrailingComma(pairs.names.join(", "));
+            args = addTrailingComma(pairs.values.join(", "));
+        } else {
+            params = createParams();
+        }
+        s.push(makeFunction(name) + "(" + params + "){", strictMode());
         s.push(defns());
         if (rng(5) === 0) {
             // functions with functions. lower the recursion to prevent a mess.
@@ -445,17 +649,17 @@ function createFunction(recurmax, allowDefun, canThrow, stmtDepth) {
         }
         s.push("}", "");
         s = filterDirective(s).join("\n");
-
-        VAR_NAMES.length = namesLenBefore;
     });
+    async = save_async;
+    VAR_NAMES = varNames;
 
     if (!allowDefun) {
         // avoid "function statements" (decl inside statements)
         s = "var " + createVarName(MANDATORY) + " = " + s;
-        s += "(" + createArgs(recurmax, stmtDepth, canThrow) + ")";
-    } else if (!(name in called) || rng(3) > 0) {
+        s += "(" + (args || createArgs(recurmax, stmtDepth, canThrow)) + ")";
+    } else if (!(name in called) || args || rng(3)) {
         s += "var " + createVarName(MANDATORY) + " = " + name;
-        s += "(" + createArgs(recurmax, stmtDepth, canThrow) + ")";
+        s += "(" + (args || createArgs(recurmax, stmtDepth, canThrow)) + ")";
     }
 
     return s + ";";
@@ -537,17 +741,17 @@ function createStatement(recurmax, canThrow, canBreak, canContinue, cannotReturn
         var label = createLabel(canBreak, canContinue);
         canBreak = label.break || enableLoopControl(canBreak, CAN_BREAK);
         canContinue = label.continue || enableLoopControl(canContinue, CAN_CONTINUE);
-        return "{var brake" + loop + " = 5; " + label.target + "do {" + createStatement(recurmax, canThrow, canBreak, canContinue, cannotReturn, stmtDepth) + "} while ((" + createExpression(recurmax, COMMA_OK, stmtDepth, canThrow) + ") && --brake" + loop + " > 0);}";
+        return "{var brake" + loop + " = 5; " + label.target + "do {" + createStatement(recurmax, canThrow, canBreak, canContinue, cannotReturn, stmtDepth) + "} while (" + createExpression(recurmax, COMMA_OK, stmtDepth, canThrow) + " && --brake" + loop + " > 0);}";
       case STMT_WHILE:
         var label = createLabel(canBreak, canContinue);
         canBreak = label.break || enableLoopControl(canBreak, CAN_BREAK);
         canContinue = label.continue || enableLoopControl(canContinue, CAN_CONTINUE);
-        return "{var brake" + loop + " = 5; " + label.target + "while ((" + createExpression(recurmax, COMMA_OK, stmtDepth, canThrow) + ") && --brake" + loop + " > 0)" + createStatement(recurmax, canThrow, canBreak, canContinue, cannotReturn, stmtDepth) + "}";
+        return "{var brake" + loop + " = 5; " + label.target + "while (" + createExpression(recurmax, COMMA_OK, stmtDepth, canThrow) + " && --brake" + loop + " > 0)" + createStatement(recurmax, canThrow, canBreak, canContinue, cannotReturn, stmtDepth) + "}";
       case STMT_FOR_LOOP:
         var label = createLabel(canBreak, canContinue);
         canBreak = label.break || enableLoopControl(canBreak, CAN_BREAK);
         canContinue = label.continue || enableLoopControl(canContinue, CAN_CONTINUE);
-        return label.target + "for (var brake" + loop + " = 5; (" + createExpression(recurmax, COMMA_OK, stmtDepth, canThrow) + ") && brake" + loop + " > 0; --brake" + loop + ")" + createStatement(recurmax, canThrow, canBreak, canContinue, cannotReturn, stmtDepth);
+        return label.target + "for (var brake" + loop + " = 5; " + createExpression(recurmax, COMMA_OK, stmtDepth, canThrow) + " && brake" + loop + " > 0; --brake" + loop + ")" + createStatement(recurmax, canThrow, canBreak, canContinue, cannotReturn, stmtDepth);
       case STMT_FOR_IN:
         var label = createLabel(canBreak, canContinue);
         canBreak = label.break || enableLoopControl(canBreak, CAN_BREAK);
@@ -556,8 +760,9 @@ function createStatement(recurmax, canThrow, canBreak, canContinue, cannotReturn
         return [
             "{var expr" + loop + " = " + createExpression(recurmax, COMMA_OK, stmtDepth, canThrow) + "; ",
             label.target + " for (",
-            /^key/.test(key) ? "var " : "",
-            key + " in expr" + loop + ") {",
+            !/^key/.test(key) ? rng(10) ? "" : "var " : !SUPPORT.let || rng(10) ? "var " : rng(2) ? "let " : "const ",
+            !SUPPORT.destructuring || rng(10) ? key : rng(5) ? "[ " + key + " ]" : "{ length: " + key + " }",
+            " in expr" + loop + ") {",
             rng(5) > 1 ? "c = 1 + c; var " + createVarName(MANDATORY) + " = expr" + loop + "[" + key + "]; " : "",
             createStatement(recurmax, canThrow, canBreak, canContinue, cannotReturn, stmtDepth),
             "}}",
@@ -571,7 +776,12 @@ function createStatement(recurmax, canThrow, canBreak, canContinue, cannotReturn
         // note: default does not _need_ to be last
         return "switch (" + createExpression(recurmax, COMMA_OK, stmtDepth, canThrow) + ") { " + createSwitchParts(recurmax, 4, canThrow, canBreak, canContinue, cannotReturn, stmtDepth) + "}";
       case STMT_VAR:
-        switch (rng(3)) {
+        if (SUPPORT.destructuring && rng(20) == 0) {
+            var pairs = createAssignmentPairs(recurmax, NO_COMMA, stmtDepth, canThrow);
+            return "var " + pairs.names.map(function(name, index) {
+                return index in pairs.values ? name + " = " + pairs.values[index] : name;
+            }).join(", ") + ";";
+        } else switch (rng(3)) {
           case 0:
             unique_vars.push("c");
             var name = createVarName(MANDATORY);
@@ -628,10 +838,14 @@ function createStatement(recurmax, canThrow, canBreak, canContinue, cannotReturn
             // we have to do go through some trouble here to prevent leaking it
             var nameLenBefore = VAR_NAMES.length;
             createBlockVariables(recurmax, stmtDepth, canThrow, function(defns) {
-                var catchName = createVarName(MANDATORY);
+                if (SUPPORT.catch_omit_var && rng(20) == 0) {
+                    s += " catch { ";
+                } else {
+                    var catchName = createVarName(MANDATORY);
+                    if (!catch_redef) unique_vars.push(catchName);
+                    s += " catch (" + catchName + ") { ";
+                }
                 var freshCatchName = VAR_NAMES.length !== nameLenBefore;
-                if (!catch_redef) unique_vars.push(catchName);
-                s += " catch (" + catchName + ") { ";
                 s += defns() + "\n";
                 s += _createStatements(3, recurmax, canThrow, canBreak, canContinue, cannotReturn, stmtDepth);
                 s += " }";
@@ -687,7 +901,8 @@ function createExpression(recurmax, noComma, stmtDepth, canThrow) {
       case 2:
         return "((c = c + 1) + (" + _createExpression(recurmax, noComma, stmtDepth, canThrow) + "))"; // c only gets incremented
       default:
-        return "(" + _createExpression(recurmax, noComma, stmtDepth, canThrow) + ")";
+        var expr = "(" + _createExpression(recurmax, noComma, stmtDepth, canThrow) + ")";
+        return async && rng(50) == 0 ? "(await" + expr + ")" : expr;
     }
 }
 
@@ -714,14 +929,37 @@ function _createExpression(recurmax, noComma, stmtDepth, canThrow) {
       case p++:
         return getVarName();
       case p++:
-        return getVarName(NO_CONST) + createAssignment() + createExpression(recurmax, COMMA_OK, stmtDepth, canThrow);
+        switch (SUPPORT.destructuring ? rng(20) : 2) {
+          case 0:
+            return [
+                "[ ",
+                new Array(rng(3)).join(","),
+                getVarName(NO_CONST),
+                new Array(rng(3)).join(","),
+                " ] = ",
+                createArrayLiteral(recurmax, stmtDepth, canThrow),
+            ].join("");
+          case 1:
+            return [
+                "{ ",
+                rng(2) ? "" : createObjectKey(recurmax, stmtDepth, canThrow) + ": ",
+                getVarName(NO_CONST),
+                " } = ",
+                createExpression(recurmax, COMMA_OK, stmtDepth, canThrow),
+                " || {}",
+            ].join("");
+          default:
+            return getVarName(NO_CONST) + createAssignment() + createExpression(recurmax, COMMA_OK, stmtDepth, canThrow);
+        }
       case p++:
         return createExpression(recurmax, COMMA_OK, stmtDepth, canThrow);
       case p++:
-        return createExpression(recurmax, noComma, stmtDepth, canThrow) + "?" + createExpression(recurmax, NO_COMMA, stmtDepth, canThrow) + ":" + createExpression(recurmax, noComma, stmtDepth, canThrow);
+        return createExpression(recurmax, noComma, stmtDepth, canThrow) + " ? " + createExpression(recurmax, NO_COMMA, stmtDepth, canThrow) + " : " + createExpression(recurmax, noComma, stmtDepth, canThrow);
       case p++:
       case p++:
         var nameLenBefore = VAR_NAMES.length;
+        var save_async = async;
+        async = SUPPORT.async && rng(50) == 0;
         unique_vars.push("c");
         var name = createVarName(MAYBE); // note: this name is only accessible from _within_ the function. and immutable at that.
         unique_vars.pop();
@@ -729,7 +967,7 @@ function _createExpression(recurmax, noComma, stmtDepth, canThrow) {
         switch (rng(5)) {
           case 0:
             s.push(
-                "(function " + name + "(){",
+                "(" + makeFunction(name) + "(){",
                 strictMode(),
                 createStatements(rng(5) + 1, recurmax, canThrow, CANNOT_BREAK, CANNOT_CONTINUE, CAN_RETURN, stmtDepth),
                 rng(2) == 0 ? "})" : "})()"
@@ -737,7 +975,7 @@ function _createExpression(recurmax, noComma, stmtDepth, canThrow) {
             break;
           case 1:
             s.push(
-                "+function " + name + "(){",
+                "+" + makeFunction(name) + "(){",
                 strictMode(),
                 createStatements(rng(5) + 1, recurmax, canThrow, CANNOT_BREAK, CANNOT_CONTINUE, CAN_RETURN, stmtDepth),
                 "}()"
@@ -745,7 +983,7 @@ function _createExpression(recurmax, noComma, stmtDepth, canThrow) {
             break;
           case 2:
             s.push(
-                "!function " + name + "(){",
+                "!" + makeFunction(name) + "(){",
                 strictMode(),
                 createStatements(rng(5) + 1, recurmax, canThrow, CANNOT_BREAK, CANNOT_CONTINUE, CAN_RETURN, stmtDepth),
                 "}()"
@@ -753,17 +991,18 @@ function _createExpression(recurmax, noComma, stmtDepth, canThrow) {
             break;
           case 3:
             s.push(
-                "void function " + name + "(){",
+                "void " + makeFunction(name) + "(){",
                 strictMode(),
                 createStatements(rng(5) + 1, recurmax, canThrow, CANNOT_BREAK, CANNOT_CONTINUE, CAN_RETURN, stmtDepth),
                 "}()"
             );
             break;
           default:
+            async = false;
             createBlockVariables(recurmax, stmtDepth, canThrow, function(defns) {
                 var instantiate = rng(4) ? "new " : "";
                 s.push(
-                    instantiate + "function " + name + "(){",
+                    instantiate + "function " + name + "(" + createParams() + "){",
                     strictMode(),
                     defns()
                 );
@@ -771,13 +1010,14 @@ function _createExpression(recurmax, noComma, stmtDepth, canThrow) {
                     if (rng(2)) s.push("this." + getDotKey(true) + createAssignment() + _createBinaryExpr(recurmax, noComma, stmtDepth, canThrow) + ";");
                     else  s.push("this[" + createExpression(recurmax, COMMA_OK, stmtDepth, canThrow) + "]" + createAssignment() + _createBinaryExpr(recurmax, noComma, stmtDepth, canThrow) + ";");
                 }
-                s.push(
-                    _createStatements(rng(5) + 1, recurmax, canThrow, CANNOT_BREAK, CANNOT_CONTINUE, CAN_RETURN, stmtDepth),
-                    rng(2) == 0 ? "}" : "}()"
-                );
+                s.push(_createStatements(rng(5) + 1, recurmax, canThrow, CANNOT_BREAK, CANNOT_CONTINUE, CAN_RETURN, stmtDepth));
             });
+            async = save_async;
+            VAR_NAMES.length = nameLenBefore;
+            s.push(rng(2) == 0 ? "}" : "}(" + createArgs(recurmax, stmtDepth, canThrow) + ")");
             break;
         }
+        async = save_async;
         VAR_NAMES.length = nameLenBefore;
         return filterDirective(s).join("\n");
       case p++:
@@ -814,14 +1054,13 @@ function _createExpression(recurmax, noComma, stmtDepth, canThrow) {
       case p++:
         return createUnarySafePrefix() + "(" + createNestedBinaryExpr(recurmax, noComma, stmtDepth, canThrow) + ")";
       case p++:
-        return " ((" + createExpression(recurmax, COMMA_OK, stmtDepth, canThrow) + ") || a || 3).toString() ";
+        return " (" + createExpression(recurmax, COMMA_OK, stmtDepth, canThrow) + " || a || 3).toString() ";
       case p++:
-        return " /[abc4]/.test(((" + createExpression(recurmax, COMMA_OK, stmtDepth, canThrow) + ") || b || 5).toString()) ";
+        return " /[abc4]/.test((" + createExpression(recurmax, COMMA_OK, stmtDepth, canThrow) + " || b || 5).toString()) ";
       case p++:
-        return " /[abc4]/g.exec(((" + createExpression(recurmax, COMMA_OK, stmtDepth, canThrow) + ") || b || 5).toString()) ";
+        return " /[abc4]/g.exec((" + createExpression(recurmax, COMMA_OK, stmtDepth, canThrow) + " || b || 5).toString()) ";
       case p++:
-        return " ((" + createExpression(recurmax, COMMA_OK, stmtDepth, canThrow) +
-            ") || " + rng(10) + ").toString()[" +
+        return " (" + createExpression(recurmax, COMMA_OK, stmtDepth, canThrow) + " || " + rng(10) + ").toString()[" +
             createExpression(recurmax, COMMA_OK, stmtDepth, canThrow) + "] ";
       case p++:
         return createArrayLiteral(recurmax, stmtDepth, canThrow);
@@ -859,7 +1098,10 @@ function _createExpression(recurmax, noComma, stmtDepth, canThrow) {
       case p++:
       case p++:
       case p++:
-        var name = rng(3) == 0 ? getVarName() : "f" + rng(funcs + 2);
+        var name;
+        do {
+            name = rng(3) == 0 ? getVarName() : "f" + rng(funcs + 2);
+        } while (name in called && !called[name]);
         called[name] = true;
         return "typeof " + name + ' == "function" && --_calls_ >= 0 && ' + name + "(" + createArgs(recurmax, stmtDepth, canThrow) + ")";
     }
@@ -869,13 +1111,30 @@ function _createExpression(recurmax, noComma, stmtDepth, canThrow) {
 
 function createArrayLiteral(recurmax, stmtDepth, canThrow) {
     recurmax--;
-    var arr = "[";
-    for (var i = rng(6); --i >= 0;) {
+    var arr = [];
+    for (var i = rng(6); --i >= 0;) switch (SUPPORT.spread ? rng(50) : 3 + rng(47)) {
+      case 0:
+      case 1:
+        var name = getVarName();
+        if (canThrow && rng(8) === 0) {
+            arr.push("..." + name);
+        } else {
+            arr.push('...("" + ' + name + ")");
+        }
+        break;
+      case 2:
+        arr.push("..." + createArrayLiteral(recurmax, stmtDepth, canThrow));
+        break;
+      case 3:
+      case 4:
         // in rare cases produce an array hole element
-        var element = rng(20) ? createExpression(recurmax, COMMA_OK, stmtDepth, canThrow) : "";
-        arr += element + ", ";
+        arr.push("");
+        break;
+      default:
+        arr.push(createExpression(recurmax, COMMA_OK, stmtDepth, canThrow));
+        break;
     }
-    return arr + "]";
+    return "[" + arr.join(", ") + "]";
 }
 
 var SAFE_KEYS = [
@@ -908,21 +1167,30 @@ function getDotKey(assign) {
     return key;
 }
 
-function createAccessor(recurmax, stmtDepth, canThrow) {
+function createObjectKey(recurmax, stmtDepth, canThrow) {
+    if (SUPPORT.computed_key && rng(10) == 0) {
+        return "[" + createExpression(recurmax, NO_COMMA, stmtDepth, canThrow) + "]";
+    }
+    return KEYS[rng(KEYS.length)];
+}
+
+function createObjectFunction(recurmax, stmtDepth, canThrow) {
     var namesLenBefore = VAR_NAMES.length;
     var s;
     createBlockVariables(recurmax, stmtDepth, canThrow, function(defns) {
-        var prop1 = getDotKey();
-        if (rng(2) == 0) {
+        switch (rng(SUPPORT.computed_key ? 3 : 2)) {
+          case 0:
             s = [
-                "get " + prop1 + "(){",
+                "get " + createObjectKey(recurmax, stmtDepth, canThrow) + "(){",
                 strictMode(),
                 defns(),
                 _createStatements(2, recurmax, canThrow, CANNOT_BREAK, CANNOT_CONTINUE, CAN_RETURN, stmtDepth),
                 createStatement(recurmax, canThrow, CANNOT_BREAK, CANNOT_CONTINUE, CAN_RETURN, stmtDepth, STMT_RETURN_ETC),
-                "},"
+                "},",
             ];
-        } else {
+            break;
+          case 1:
+            var prop1 = createObjectKey(recurmax, stmtDepth, canThrow);
             var prop2;
             do {
                 prop2 = getDotKey();
@@ -933,8 +1201,18 @@ function createAccessor(recurmax, stmtDepth, canThrow) {
                 defns(),
                 _createStatements(2, recurmax, canThrow, CANNOT_BREAK, CANNOT_CONTINUE, CAN_RETURN, stmtDepth),
                 "this." + prop2 + createAssignment() + _createBinaryExpr(recurmax, COMMA_OK, stmtDepth, canThrow) + ";",
-                "},"
+                "},",
             ];
+            break;
+          default:
+            s = [
+                createObjectKey(recurmax, stmtDepth, canThrow) + "(" + createParams(NO_DUPLICATE) + "){",
+                strictMode(),
+                defns(),
+                _createStatements(3, recurmax, canThrow, CANNOT_BREAK, CANNOT_CONTINUE, CAN_RETURN, stmtDepth),
+                "},",
+            ]
+            break;
         }
     });
     VAR_NAMES.length = namesLenBefore;
@@ -944,13 +1222,24 @@ function createAccessor(recurmax, stmtDepth, canThrow) {
 function createObjectLiteral(recurmax, stmtDepth, canThrow) {
     recurmax--;
     var obj = ["({"];
-    for (var i = rng(6); --i >= 0;) {
-        if (rng(20) == 0) {
-            obj.push(createAccessor(recurmax, stmtDepth, canThrow));
-        } else {
-            var key = KEYS[rng(KEYS.length)];
-            obj.push(key + ":(" + createExpression(recurmax, COMMA_OK, stmtDepth, canThrow) + "),");
-        }
+    var offset = SUPPORT.spread_object ? 0 : SUPPORT.computed_key ? 2 : 4;
+    for (var i = rng(6); --i >= 0;) switch (offset + rng(50 - offset)) {
+      case 0:
+        obj.push("..." + getVarName() + ",");
+        break;
+      case 1:
+        obj.push("..." + createExpression(recurmax, COMMA_OK, stmtDepth, canThrow) + ",");
+        break;
+      case 2:
+      case 3:
+        obj.push(getVarName() + ",");
+        break;
+      case 4:
+        obj.push(createObjectFunction(recurmax, stmtDepth, canThrow));
+        break;
+      default:
+        obj.push(createObjectKey(recurmax, stmtDepth, canThrow) + ": " + createExpression(recurmax, COMMA_OK, stmtDepth, canThrow) + ",");
+        break;
     }
     obj.push("})");
     return obj.join("\n");
@@ -978,13 +1267,77 @@ function _createSimpleBinaryExpr(recurmax, noComma, stmtDepth, canThrow) {
         return "(" + assignee + createAssignment() + _createBinaryExpr(recurmax, noComma, stmtDepth, canThrow) + ")";
       case 3:
         assignee = getVarName();
-        expr = "(" + assignee + "[" + createExpression(recurmax, COMMA_OK, stmtDepth, canThrow)
-            + "]" + createAssignment() + _createBinaryExpr(recurmax, noComma, stmtDepth, canThrow) + ")";
+        switch (SUPPORT.destructuring ? rng(20) : 2) {
+          case 0:
+            expr = [
+                "([ ",
+                assignee,
+                "[", createExpression(recurmax, COMMA_OK, stmtDepth, canThrow), "]",
+                " ] = [ ",
+                _createBinaryExpr(recurmax, noComma, stmtDepth, canThrow),
+                " ])",
+            ].join("");
+            break;
+          case 1:
+            var key1 = createObjectKey(recurmax, stmtDepth, canThrow);
+            var key2 = /^\[/.test(key1) ? createObjectKey(recurmax, stmtDepth, canThrow) : key1;
+            expr = [
+                "({ ",
+                key1, ": ", assignee,
+                "[", createExpression(recurmax, COMMA_OK, stmtDepth, canThrow), "]",
+                " } = { ",
+                key2, ": ", _createBinaryExpr(recurmax, noComma, stmtDepth, canThrow),
+                " })",
+            ].join("");
+            break;
+          default:
+            expr = [
+                "(",
+                assignee,
+                "[", createExpression(recurmax, COMMA_OK, stmtDepth, canThrow), "]",
+                createAssignment(),
+                _createBinaryExpr(recurmax, noComma, stmtDepth, canThrow),
+                ")",
+            ].join("");
+            break;
+        }
         return canThrow && rng(10) == 0 ? expr : "(" + assignee + " && " + expr + ")";
       case 4:
         assignee = getVarName();
-        expr = "(" + assignee + "." + getDotKey(true) + createAssignment()
-            + _createBinaryExpr(recurmax, noComma, stmtDepth, canThrow) + ")";
+        switch (SUPPORT.destructuring ? rng(20) : 2) {
+          case 0:
+            expr = [
+                "([ ",
+                assignee,
+                ".", getDotKey(true),
+                " ] = [ ",
+                _createBinaryExpr(recurmax, noComma, stmtDepth, canThrow),
+                " ])",
+            ].join("");
+            break;
+          case 1:
+            var key1 = createObjectKey(recurmax, stmtDepth, canThrow);
+            var key2 = /^\[/.test(key1) ? createObjectKey(recurmax, stmtDepth, canThrow) : key1;
+            expr = [
+                "({ ",
+                key1, ": ", assignee,
+                ".", getDotKey(true),
+                " } = { ",
+                key2, ": ", _createBinaryExpr(recurmax, noComma, stmtDepth, canThrow),
+                " })",
+            ].join("");
+            break;
+          default:
+            expr = [
+                "(",
+                assignee,
+                ".", getDotKey(true),
+                createAssignment(),
+                _createBinaryExpr(recurmax, noComma, stmtDepth, canThrow),
+                ")",
+            ].join("");
+            break;
+        }
         return canThrow && rng(10) == 0 ? expr : "(" + assignee + " && " + expr + ")";
       default:
         return _createBinaryExpr(recurmax, noComma, stmtDepth, canThrow);
@@ -1036,10 +1389,25 @@ function createUnaryPostfix() {
     return UNARY_POSTFIX[rng(UNARY_POSTFIX.length)];
 }
 
+function addAvoidVars(names) {
+    avoid_vars = avoid_vars.concat(names);
+}
+
+function removeAvoidVars(names) {
+    names.forEach(function(name) {
+        var index = avoid_vars.lastIndexOf(name);
+        if (index >= 0) avoid_vars.splice(index, 1);
+    });
+}
+
 function getVarName(noConst) {
     // try to get a generated name reachable from current scope. default to just `a`
-    var name = VAR_NAMES[INITIAL_NAMES_LEN + rng(VAR_NAMES.length - INITIAL_NAMES_LEN)];
-    return !name || noConst && block_vars.indexOf(name) >= 0 ? "a" : name;
+    var name, tries = 10;
+    do {
+        if (--tries < 0) return "a";
+        name = VAR_NAMES[INITIAL_NAMES_LEN + rng(VAR_NAMES.length - INITIAL_NAMES_LEN)];
+    } while (!name || avoid_vars.indexOf(name) >= 0 || noConst && block_vars.indexOf(name) >= 0);
+    return name;
 }
 
 function createVarName(maybe, dontStore) {
@@ -1049,7 +1417,7 @@ function createVarName(maybe, dontStore) {
         do {
             name = VAR_NAMES[rng(VAR_NAMES.length)];
             if (suffix) name += "_" + suffix;
-        } while (unique_vars.indexOf(name) >= 0 || block_vars.indexOf(name) >= 0);
+        } while (unique_vars.indexOf(name) >= 0 || block_vars.indexOf(name) >= 0 || async && name == "await");
         if (suffix && !dontStore) VAR_NAMES.push(name);
         return name;
     }
@@ -1077,25 +1445,35 @@ function errorln(msg) {
     writeln(process.stderr, msg);
 }
 
-function try_beautify(code, toplevel, result, printfn) {
-    var beautified = UglifyJS.minify(code, {
-        compress: false,
-        mangle: false,
-        output: {
-            beautify: true,
-            braces: true,
-        },
-    });
+function try_beautify(code, toplevel, result, printfn, options) {
+    var beautified = UglifyJS.minify(code, JSON.parse(beautify_options));
     if (beautified.error) {
         printfn("// !!! beautify failed !!!");
         printfn(beautified.error);
-    } else if (sandbox.same_stdout(sandbox.run_code(beautified.code, toplevel), result)) {
+        beautified = null;
+    } else if (!sandbox.same_stdout(sandbox.run_code(beautified.code, toplevel), result)) {
+        beautified = null;
+    } else if (options) {
+        var uglified = UglifyJS.minify(beautified.code, JSON.parse(options));
+        var expected, actual;
+        if (typeof uglify_code != "string" || uglified.error) {
+            expected = uglify_code;
+            actual = uglified.error;
+        } else {
+            expected = uglify_result;
+            actual = sandbox.run_code(uglified.code, toplevel);
+        }
+        if (!sandbox.same_stdout(expected, actual)) {
+            beautified = null;
+        }
+    }
+    if (beautified) {
         printfn("// (beautified)");
         printfn(beautified.code);
-        return;
+    } else {
+        printfn("//");
+        printfn(code);
     }
-    printfn("//");
-    printfn(code);
 }
 
 var default_options = UglifyJS.default_options();
@@ -1168,37 +1546,7 @@ function log(options) {
     errorln("//=============================================================");
     if (!ok) errorln("// !!!!!! Failed... round " + round);
     errorln("// original code");
-    var beautified = UglifyJS.minify(original_code, {
-        compress: false,
-        mangle: false,
-        output: {
-            beautify: true,
-            braces: true,
-        },
-    });
-    if (beautified.error) {
-        errorln("// !!! beautify failed !!!");
-        errorln(beautified.error);
-        errorln("//");
-        errorln(original_code);
-    } else {
-        var uglified = UglifyJS.minify(beautified.code, JSON.parse(options));
-        var expected, actual;
-        if (typeof uglify_code != "string" || uglified.error) {
-            expected = uglify_code;
-            actual = uglified.error;
-        } else {
-            expected = uglify_result;
-            actual = sandbox.run_code(uglified.code, toplevel);
-        }
-        if (sandbox.same_stdout(expected, actual)) {
-            errorln("// (beautified)");
-            errorln(beautified.code);
-        } else {
-            errorln("//");
-            errorln(original_code);
-        }
-    }
+    try_beautify(original_code, toplevel, original_result, errorln, options);
     errorln();
     errorln();
     errorln("//-------------------------------------------------------------");
@@ -1318,6 +1666,9 @@ function patch_try_catch(orig, toplevel) {
             } else if (result.name == "TypeError" && /'in'/.test(result.message)) {
                 index = result.ufuzz_catch;
                 return orig.slice(0, index) + result.ufuzz_var + ' = new Error("invalid `in`");' + orig.slice(index);
+            } else if (result.name == "TypeError" && /not iterable/.test(result.message)) {
+                index = result.ufuzz_catch;
+                return orig.slice(0, index) + result.ufuzz_var + ' = new Error("spread not iterable");' + orig.slice(index);
             } else if (result.name == "RangeError" && result.message == "Maximum call stack size exceeded") {
                 index = result.ufuzz_try;
                 return orig.slice(0, index) + 'throw new Error("skipping infinite recursion");' + orig.slice(index);
@@ -1327,7 +1678,24 @@ function patch_try_catch(orig, toplevel) {
     }
 }
 
-var minify_options = require("./options.json").map(JSON.stringify);
+var beautify_options = {
+    compress: false,
+    mangle: false,
+    output: {
+        beautify: true,
+        braces: true,
+    },
+};
+var minify_options = require("./options.json");
+if (SUPPORT.destructuring && typeof sandbox.run_code("console.log([ 1 ], {} = 2);") != "string") {
+    beautify_options.output.v8 = true;
+    minify_options.forEach(function(o) {
+        if (!("output" in o)) o.output = {};
+        o.output.v8 = true;
+    });
+}
+beautify_options = JSON.stringify(beautify_options);
+minify_options = minify_options.map(JSON.stringify);
 var original_code, original_result, errored;
 var uglify_code, uglify_result, ok;
 for (var round = 1; round <= num_iterations; round++) {
@@ -1376,6 +1744,7 @@ for (var round = 1; round <= num_iterations; round++) {
                 ok = sandbox.same_stdout(orig_result[toplevel ? 3 : 2], uglify_result);
             }
             // ignore difference in error message caused by `in`
+            // ignore difference in error message caused by spread syntax
             // ignore difference in depth of termination caused by infinite recursion
             if (!ok) {
                 var orig_skipped = patch_try_catch(original_code, toplevel);