v3.12.8

fixes #4644

.github/ISSUE_TEMPLATE.md

@@ -1,25 +0,0 @@
-**Bug report or feature request?**
-
-<!-- Note: sub-optimal but correct code is not a bug -->
-
-**Uglify version (`uglifyjs -V`)**
-
-**JavaScript input**
-
-<!--
-    A complete parsable JS program exhibiting the issue with
-    UglifyJS alone - without third party tools or libraries.
-    Ideally the input should be as small as possible.
-    Post a link to a gist if necessary.
-
-    Issues without a reproducible test case will be closed.
--->
-
-**The `uglifyjs` CLI command executed or `minify()` options used.**
-
-**JavaScript output or error produced.**
-
-<!--
-    Note: `uglify-js` only supports JavaScript.
-    Those wishing to minify ES6+ should transpile first.
--->

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,51 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+<!-- Note: sub-optimal but correct code is not a bug -->
+
+**Uglify version (`uglifyjs -V`)**
+
+**JavaScript input**
+
+<!--
+A complete parsable JS program exhibiting the issue with UglifyJS alone
+- without third party tools or libraries.
+
+Ideally the input should be as small as possible, but may be large if isolating
+the problem proves to be difficult. The most important thing is that the
+standalone program reliably exhibits the bug when minified. Provide a link to a
+gist if necessary.
+
+Solely providing minified output without the original uglify JS input is not
+useful in determining the cause of the problem. Issues without a reproducible
+test case will be closed.
+-->
+
+**The `uglifyjs` CLI command executed or `minify()` options used.**
+
+<!--
+Command-line or API call to UglifyJS without third party tools or libraries.
+
+For users using bundlers or transpilers, you may be able to gather the required
+information through setting the `UGLIFY_BUG_REPORT` environment variable:
+
+    export UGLIFY_BUG_REPORT=1      (bash)
+    set UGLIFY_BUG_REPORT=1         (Command Prompt)
+    $Env:UGLIFY_BUG_REPORT=1        (PowerShell)
+
+before running your usual build process. The resulting "minified" output should
+contain the necessary details for this report.
+-->
+
+**JavaScript output or error produced.**
+
+<!--
+Only minified code that produces different output (or error) from the original
+upon execution would be considered a bug.
+-->

.github/workflows/ci.yml

@@ -1,16 +1,19 @@
 name: CI
-on: [ push, pull_request ]
+on:
+  pull_request:
+  push:
+    branches: [ master ]
 jobs:
   test:
     strategy:
       matrix:
-        node: [ "0.8", "0.10", "0.12", "4", "6", "8", "10", "12", latest ]
+        node: [ '0.8', '0.10', '0.12', '4', '6', '8', '10', '12', latest ]
         os: [ ubuntu-latest, windows-latest ]
         script: [ compress, mocha, release/benchmark, release/jetstream ]
         exclude:
-          - node: "0.8"
+          - node: '0.8'
             script: release/benchmark
-          - node: "0.8"
+          - node: '0.8'
             script: release/jetstream
     name: ${{ matrix.node }} ${{ matrix.os }} ${{ matrix.script }}
     runs-on: ${{ matrix.os }}
@@ -19,14 +22,14 @@ jobs:
       TYPE: ${{ matrix.script }}
     steps:
       - uses: actions/checkout@v2
-      - uses: actions/cache@v1
+      - uses: actions/cache@v2
         with:
           path: tmp
           key: tmp ${{ matrix.script }}
       - name: Perform tests
         shell: bash
         run: |
-          git clone --branch v1.5.4 --depth 1 https://github.com/jasongin/nvs.git ~/.nvs
+          git clone --branch v1.6.0 --depth 1 https://github.com/jasongin/nvs.git ~/.nvs
           while ! timeout 60 bash -c '. ~/.nvs/nvs.sh add $NODE && nvs use $NODE'; do
             cd ~/.nvs
             while !(git clean -xdf); do echo "'git clean' failed - retrying..."; done

.github/workflows/ufuzz.yml

@@ -2,28 +2,52 @@ name: Fuzzing
 on:
   pull_request:
   schedule:
-    - cron: "*/8 * * * *"
+    - cron: '*/5 * * * *'
+env:
+  BASE_URL: https://api.github.com/repos/${{ github.repository }}
+  CAUSE: ${{ github.event_name }}
+  RUN_NUM: ${{ github.run_number }}
+  TOKEN: ${{ github.token }}
 jobs:
   ufuzz:
     strategy:
       fail-fast: false
       matrix:
-        os: [ ubuntu-latest, windows-latest ]
-    name: ${{ matrix.os }}
+        include:
+          - node: latest
+            os: macos-latest
+          - node: '8'
+            os: ubuntu-latest
+          - node: '8'
+            os: ubuntu-latest
+          - node: '8'
+            os: windows-latest
+          - node: '8'
+            os: windows-latest
+    name: ${{ matrix.node }} ${{ matrix.os }}
     runs-on: ${{ matrix.os }}
+    env:
+      NODE: ${{ matrix.node }}
     steps:
       - uses: actions/checkout@v2
+      - name: Install GNU Core Utilities
+        if: ${{ startsWith(matrix.os, 'macos') }}
+        env:
+          HOMEBREW_NO_INSTALL_CLEANUP: 1
+        shell: bash
+        run: |
+          brew install coreutils
       - name: Perform fuzzing
         shell: bash
         run: |
-          git clone --branch v1.5.4 --depth 1 https://github.com/jasongin/nvs.git ~/.nvs
-          while ! timeout 60 bash -c '. ~/.nvs/nvs.sh add 8 && nvs use 8'; do
+          git clone --branch v1.6.0 --depth 1 https://github.com/jasongin/nvs.git ~/.nvs
+          while ! timeout 60 bash -c '. ~/.nvs/nvs.sh add $NODE && nvs use $NODE'; do
             cd ~/.nvs
             while !(git clean -xdf); do echo "'git clean' failed - retrying..."; done
             cd -
           done
           . ~/.nvs/nvs.sh --version
-          nvs use 8
+          nvs use $NODE
           node --version
           npm config set audit false
           npm config set optional false
@@ -32,4 +56,8 @@ jobs:
           npm config set update-notifier false
           npm --version
           while !(npm install); do echo "'npm install' failed - retrying..."; done
-          node test/ufuzz/job 3600000
+          if [[ $CAUSE == "schedule" ]]; then
+            node test/ufuzz/job $BASE_URL $TOKEN $RUN_NUM
+          else
+            node test/ufuzz/job 5000
+          fi

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
 -------
@@ -133,8 +135,16 @@ a double dash to prevent input files being used as option arguments:
                                        `//# sourceMappingURL`.
     --timings                   Display operations run time on STDERR.
     --toplevel                  Compress and/or mangle variables in top level scope.
+    --v8                        Support non-standard Chrome & Node.js
+                                Equivalent to setting `v8: true` in `minify()`
+                                for `mangle` and `output` options.
+                                By default UglifyJS will not try to be v8-proof.
     --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
@@ -212,17 +222,16 @@ Example:
 To enable the mangler you need to pass `--mangle` (`-m`).  The following
 (comma-separated) options are supported:
 
-- `toplevel` (default `false`) -- mangle names declared in the top level scope.
+- `eval` (default `false`) -- mangle names visible in scopes where `eval` or
+  `with` are used.
 
-- `eval` (default `false`) -- mangle names visible in scopes where `eval` or `with` are used.
+- `reserved` (default: `[]`) -- when mangling is enabled but you want to
+  prevent certain names from being mangled, you can declare those names with
+  `--mangle reserved` — pass a comma-separated list of names.  For example:
 
-When mangling is enabled but you want to prevent certain names from being
-mangled, you can declare those names with `--mangle reserved` — pass a
-comma-separated list of names.  For example:
+      uglifyjs ... -m reserved=['$','require','exports']
 
-    uglifyjs ... -m reserved=['$','require','exports']
-
-to prevent the `require`, `exports` and `$` names from being changed.
+  to prevent the `require`, `exports` and `$` names from being changed.
 
 ### CLI mangling property names (`--mangle-props`)
 
@@ -517,9 +526,14 @@ if (result.error) throw result.error;
 - `toplevel` (default `false`) -- set to `true` if you wish to enable top level
   variable and function name mangling and to drop unused variables and functions.
 
+- `v8` (default `false`) -- enable workarounds for Chrome & Node.js bugs.
+
 - `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
@@ -613,7 +627,11 @@ to be `false` and all symbol names will be omitted.
 - `arguments` (default: `true`) -- replace `arguments[index]` with function
   parameter name whenever possible.
 
-- `assignments` (default: `true`) -- apply optimizations to assignment expressions.
+- `arrows` (default: `true`) -- apply optimizations to arrow functions
+
+- `assignments` (default: `true`) -- apply optimizations to assignment expressions
+
+- `awaits` (default: `true`) -- apply optimizations to `await` expressions
 
 - `booleans` (default: `true`) -- various optimizations for boolean context,
   for example `!!a ? b : c → a ? b : c`
@@ -630,6 +648,8 @@ to be `false` and all symbol names will be omitted.
 
 - `dead_code` (default: `true`) -- remove unreachable code
 
+- `default_values` (default: `true`) -- drop overshadowed default values
+
 - `directives` (default: `true`) -- remove redundant or non-standard directives
 
 - `drop_console` (default: `false`) -- Pass `true` to discard calls to
@@ -657,8 +677,8 @@ to be `false` and all symbol names will be omitted.
 - `hoist_props` (default: `true`) -- hoist properties from constant object and
   array literals into regular variables subject to a set of constraints. For example:
   `var o={p:1, q:2}; f(o.p, o.q);` is converted to `f(1, 2);`. Note: `hoist_props`
-  works best with `mangle` enabled, the `compress` option `passes` set to `2` or higher,
-  and the `compress` option `toplevel` enabled.
+  works best with `toplevel` and `mangle` enabled, alongside with `compress` option
+  `passes` set to `2` or higher.
 
 - `hoist_vars` (default: `false`) -- hoist `var` declarations (this is `false`
   by default because it seems to increase the size of the output in general)
@@ -675,13 +695,9 @@ to be `false` and all symbol names will be omitted.
 
 - `join_vars` (default: `true`) -- join consecutive `var` statements
 
-- `keep_fargs` (default: `strict`) -- Discard unused function arguments. Code
-  which relies on `Function.length` will break if this is done indiscriminately,
-  i.e. when passing `true`. Pass `false` to always retain function arguments.
-
-- `keep_fnames` (default: `false`) -- Pass `true` to prevent the
-  compressor from discarding function names.  Useful for code relying on
-  `Function.prototype.name`. See also: the `keep_fnames` [mangle option](#mangle-options).
+- `keep_fargs` (default: `false`) -- discard unused function arguments except
+  when unsafe to do so, e.g. code which relies on `Function.prototype.length`.
+  Pass `true` to always retain function arguments.
 
 - `keep_infinity` (default: `false`) -- Pass `true` to prevent `Infinity` from
   being compressed into `1/0`, which may cause performance issues on Chrome.
@@ -689,6 +705,8 @@ to be `false` and all symbol names will be omitted.
 - `loops` (default: `true`) -- optimizations for `do`, `while` and `for` loops
   when we can statically determine the condition.
 
+- `merge_vars` (default: `true`) -- combine and reuse variables.
+
 - `negate_iife` (default: `true`) -- negate "Immediately-Called Function Expressions"
   where the return value is discarded, to avoid the parens that the
   code generator would insert.
@@ -729,6 +747,8 @@ to be `false` and all symbol names will be omitted.
 - `reduce_vars` (default: `true`) -- Improve optimization on variables assigned with and
   used as constant values.
 
+- `rests` (default: `true`) -- apply optimizations to rest parameters
+
 - `sequences` (default: `true`) -- join consecutive simple statements using the
   comma operator.  May be set to a positive integer to specify the maximum number
   of consecutive comma sequences that will be generated. If this option is set to
@@ -743,18 +763,23 @@ to be `false` and all symbol names will be omitted.
   annotation `/*@__PURE__*/` or `/*#__PURE__*/` immediately precedes the call. For
   example: `/*@__PURE__*/foo();`
 
+- `spreads` (default: `true`) -- flatten spread expressions.
+
 - `strings` (default: `true`) -- compact string concatenations.
 
 - `switches` (default: `true`) -- de-duplicate and remove unreachable `switch` branches
 
-- `toplevel` (default: `false`) -- drop unreferenced functions (`"funcs"`) and/or
-  variables (`"vars"`) in the top level scope (`false` by default, `true` to drop
-  both unreferenced functions and variables)
+- `templates` (default: `true`) -- compact template literals by embedding expressions
+  and/or converting to string literals, e.g. `` `foo ${42}` → "foo 42"``
 
 - `top_retain` (default: `null`) -- prevent specific toplevel functions and
   variables from `unused` removal (can be array, comma-separated, RegExp or
   function. Implies `toplevel`)
 
+- `toplevel` (default: `false`) -- drop unreferenced functions (`"funcs"`) and/or
+  variables (`"vars"`) in the top level scope (`false` by default, `true` to drop
+  both unreferenced functions and variables)
+
 - `typeofs` (default: `true`) -- Transforms `typeof foo == "undefined"` into
   `foo === void 0`.  Note: recommend to set this value to `false` for IE10 and
   earlier versions due to known issues.
@@ -783,15 +808,16 @@ to be `false` and all symbol names will be omitted.
 - `unused` (default: `true`) -- drop unreferenced functions and variables (simple
   direct variable assignments do not count as references unless set to `"keep_assign"`)
 
+- `varify` (default: `true`) -- convert block-scoped declaractions into `var`
+  whenever safe to do so
+
+- `yields` (default: `true`) -- apply optimizations to `yield` expressions
+
 ## Mangle options
 
 - `eval` (default `false`) -- Pass `true` to mangle names visible in scopes
   where `eval` or `with` are used.
 
-- `keep_fnames` (default `false`) -- Pass `true` to not mangle function names.
-  Useful for code relying on `Function.prototype.name`. See also: the `keep_fnames`
-  [compress option](#compress-options).
-
 - `reserved` (default `[]`) -- Pass an array of identifiers that should be
   excluded from mangling. Example: `["foo", "bar"]`.
 
@@ -858,12 +884,14 @@ can pass additional arguments that control the code output:
   comments, `"some"` to preserve multi-line comments that contain `@cc_on`,
   `@license`, or `@preserve` (case-insensitive), a regular expression string
   (e.g. `/^!/`), or a function which returns `boolean`, e.g.
-  ```js
+  ```javascript
   function(node, comment) {
       return comment.value.indexOf("@type " + node.TYPE) >= 0;
   }
   ```
 
+- `galio` (default `false`) -- enable workarounds for ANT Galio bugs
+
 - `indent_level` (default `4`)
 
 - `indent_start` (default `0`) -- prefix all lines by that many spaces
@@ -902,9 +930,6 @@ 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`.
-
 - `width` (default `80`) -- only takes effect when beautification is on, this
   specifies an (orientative) line width that the beautifier will try to
   obey.  It refers to the width of the line text (excluding indentation).
@@ -1130,11 +1155,11 @@ To enable fast minify mode from the CLI use:
 uglifyjs file.js -m
 ```
 To enable fast minify mode with the API use:
-```js
+```javascript
 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
@@ -1146,6 +1171,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.
@@ -1157,3 +1186,98 @@ 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:
+  ```javascript
+  ({
+      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:
+  ```javascript
+  A = "FAIL";
+  var B = "FAIL";
+  // can be `global`, `self`, `window` etc.
+  var top = function() {
+      return this;
+  }();
+  // "PASS"
+  top.A = "PASS";
+  console.log(A);
+  // "FAIL" after compress and/or mangle
+  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.
+- Earlier versions of Chrome and Node.js will throw `ReferenceError` with the
+  following:
+  ```javascript
+  var a;
+  try {
+      throw 42;
+  } catch ({
+      [a]: b,
+      // ReferenceError: a is not defined
+  }) {
+      let a;
+  }
+  ```
+  UglifyJS may modify the input which in turn may suppress those errors.
+- Later versions of JavaScript will throw `SyntaxError` with the following:
+  ```javascript
+  a => {
+      let a;
+  };
+  // SyntaxError: Identifier 'a' has already been declared
+  ```
+  UglifyJS may modify the input which in turn may suppress those errors.
+- Later versions of JavaScript will throw `SyntaxError` with the following:
+  ```javascript
+  try {
+      // ...
+  } catch ({ message: a }) {
+      var a;
+  }
+  // SyntaxError: Identifier 'a' has already been declared
+  ```
+  UglifyJS may modify the input which in turn may suppress those errors.
+- Some versions of Chrome and Node.js will throw `ReferenceError` with the
+  following:
+  ```javascript
+  console.log(((a, b = function() {
+      return a;
+      // ReferenceError: a is not defined
+  }()) => b)());
+  ```
+  UglifyJS may modify the input which in turn may suppress those errors.
+- Some arithmetic operations with `BigInt` may throw `TypeError`:
+  ```javascript
+  1n + 1;
+  // TypeError: can't convert BigInt to number
+  ```
+  UglifyJS may modify the input which in turn may suppress those errors.
+- Some versions of JavaScript will throw `SyntaxError` with the
+  following:
+  ```javascript
+  console.log(String.raw`\uFo`);
+  // SyntaxError: Invalid Unicode escape sequence
+  ```
+  UglifyJS may modify the input which in turn may suppress those errors.
+- Some versions of JavaScript will throw `SyntaxError` with the
+  following:
+  ```javascript
+  try {} catch (e) {
+      for (var e of []);
+  }
+  // SyntaxError: Identifier 'e' has already been declared
+  ```
+  UglifyJS may modify the input which in turn may suppress those errors.

bin/uglifyjs

@@ -3,7 +3,7 @@
 
 "use strict";
 
-require("../tools/exit");
+require("../tools/tty");
 
 var fs = require("fs");
 var info = require("../package.json");
@@ -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":
@@ -263,7 +265,7 @@ if (paths.length) {
     process.stdin.on("data", function(chunk) {
         chunks.push(chunk);
     }).on("end", function() {
-        files = [ chunks.join("") ];
+        files = { STDIN: chunks.join("") };
         run();
     });
     process.stdin.resume();
@@ -276,7 +278,9 @@ function convert_ast(fn) {
 function run() {
     var content = options.sourceMap && options.sourceMap.content;
     if (content && content != "inline") {
-        UglifyJS.AST_Node.info("Using input source map: " + content);
+        UglifyJS.AST_Node.info("Using input source map: {content}", {
+            content : content,
+        });
         options.sourceMap.content = read_file(content, content);
     }
     try {
@@ -342,7 +346,18 @@ function run() {
         }
         fatal(ex);
     } else if (output == "ast") {
-        if (!options.compress && !options.mangle) result.ast.figure_out_scope({});
+        if (!options.compress && !options.mangle) {
+            var toplevel = result.ast;
+            if (!(toplevel instanceof UglifyJS.AST_Toplevel)) {
+                if (!(toplevel instanceof UglifyJS.AST_Statement)) toplevel = new UglifyJS.AST_SimpleStatement({
+                    body: toplevel,
+                });
+                toplevel = new UglifyJS.AST_Toplevel({
+                    body: [ toplevel ],
+                });
+            }
+            toplevel.figure_out_scope({});
+        }
         print(JSON.stringify(result.ast, function(key, value) {
             if (value) switch (key) {
               case "thedef":

lib/minify.js

@@ -33,7 +33,9 @@ function read_source_map(name, toplevel) {
             return to_ascii(match[2]);
         }
     }
-    AST_Node.warn("inline source map not found: " + name);
+    AST_Node.warn("inline source map not found: {name}", {
+        name: name,
+    });
 }
 
 function parse_source_map(content) {
@@ -85,8 +87,10 @@ function minify(files, options) {
             sourceMap: false,
             timings: false,
             toplevel: false,
+            v8: false,
             validate: false,
             warnings: false,
+            webkit: false,
             wrap: false,
         }, true);
         if (options.validate) AST_Node.enable_validation();
@@ -99,6 +103,8 @@ 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("v8", options, [ "mangle", "output" ]);
+        set_shorthand("webkit", options, [ "mangle", "output" ]);
         var quoted_props;
         if (options.mangle) {
             options.mangle = defaults(options.mangle, {
@@ -109,6 +115,8 @@ function minify(files, options) {
                 properties: false,
                 reserved: [],
                 toplevel: false,
+                v8: false,
+                webkit: false,
             }, true);
             if (options.mangle.properties) {
                 if (typeof options.mangle.properties != "object") {
@@ -178,13 +186,17 @@ function minify(files, options) {
             toplevel = toplevel[action](option);
             files[toplevel.start.file] = toplevel.print_to_string().replace(orig, "");
         });
+        if (options.validate) toplevel.validate_ast();
         if (timings) timings.rename = Date.now();
         if (options.rename) {
             toplevel.figure_out_scope(options.mangle);
             toplevel.expand_names(options.mangle);
         }
         if (timings) timings.compress = Date.now();
-        if (options.compress) toplevel = new Compressor(options.compress).compress(toplevel);
+        if (options.compress) {
+            toplevel = new Compressor(options.compress).compress(toplevel);
+            if (options.validate) toplevel.validate_ast();
+        }
         if (timings) timings.scope = Date.now();
         if (options.mangle) toplevel.figure_out_scope(options.mangle);
         if (timings) timings.mangle = Date.now();
@@ -193,9 +205,7 @@ function minify(files, options) {
             toplevel.mangle_names(options.mangle);
         }
         if (timings) timings.properties = Date.now();
-        if (options.mangle && options.mangle.properties) {
-            toplevel = mangle_properties(toplevel, options.mangle.properties);
-        }
+        if (options.mangle && options.mangle.properties) mangle_properties(toplevel, options.mangle.properties);
         if (timings) timings.output = Date.now();
         var result = {};
         if (options.output.ast) {
@@ -256,6 +266,7 @@ function minify(files, options) {
     } catch (ex) {
         return { error: ex };
     } finally {
+        AST_Node.log_function();
         AST_Node.disable_validation();
     }
 }

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/propmangle.js

@@ -43,7 +43,8 @@
 
 "use strict";
 
-function find_builtins(reserved) {
+var builtins = function() {
+    var names = [];
     // NaN will be included due to Number.NaN
     [
         "null",
@@ -67,19 +68,21 @@ function find_builtins(reserved) {
     ].forEach(function(ctor) {
         Object.getOwnPropertyNames(ctor).map(add);
         if (ctor.prototype) {
+            Object.getOwnPropertyNames(new ctor()).map(add);
             Object.getOwnPropertyNames(ctor.prototype).map(add);
         }
     });
+    return makePredicate(names);
 
     function add(name) {
-        push_uniq(reserved, name);
+        names.push(name);
     }
-}
+}();
 
 function reserve_quoted_keys(ast, reserved) {
     ast.walk(new TreeWalker(function(node) {
-        if (node instanceof AST_ObjectKeyVal && 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);
         }
@@ -91,17 +94,14 @@ function reserve_quoted_keys(ast, reserved) {
 }
 
 function addStrings(node, add) {
-    node.walk(new TreeWalker(function(node) {
-        if (node instanceof AST_Sequence) {
-            addStrings(node.tail_node(), add);
-        } else if (node instanceof AST_String) {
-            add(node.value);
-        } else if (node instanceof AST_Conditional) {
-            addStrings(node.consequent, add);
-            addStrings(node.alternative, add);
-        }
-        return true;
-    }));
+    if (node instanceof AST_Conditional) {
+        addStrings(node.consequent, add);
+        addStrings(node.alternative, add);
+    } else if (node instanceof AST_Sequence) {
+        addStrings(node.tail_node(), add);
+    } else if (node instanceof AST_String) {
+        add(node.value);
+    }
 }
 
 function mangle_properties(ast, options) {
@@ -110,21 +110,21 @@ function mangle_properties(ast, options) {
         cache: null,
         debug: false,
         keep_quoted: false,
-        only_cache: false,
         regex: null,
         reserved: null,
     }, true);
 
-    var reserved = options.reserved;
-    if (!Array.isArray(reserved)) reserved = [];
-    if (!options.builtins) find_builtins(reserved);
+    var reserved = Object.create(options.builtins ? null : builtins);
+    if (Array.isArray(options.reserved)) options.reserved.forEach(function(name) {
+        reserved[name] = true;
+    });
 
     var cname = -1;
     var cache;
     if (options.cache) {
         cache = options.cache.props;
-        cache.each(function(mangled_name) {
-            push_uniq(reserved, mangled_name);
+        cache.each(function(name) {
+            reserved[name] = true;
         });
     } else {
         cache = new Dictionary();
@@ -139,62 +139,86 @@ function mangle_properties(ast, options) {
     var debug_suffix;
     if (debug) debug_suffix = options.debug === true ? "" : options.debug;
 
-    var names_to_mangle = [];
-    var unmangleable = [];
+    var names_to_mangle = Object.create(null);
+    var unmangleable = Object.create(reserved);
 
     // step 1: find candidates to mangle
     ast.walk(new TreeWalker(function(node) {
-        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 (node instanceof AST_Binary) {
+            if (node.operator == "in") addStrings(node.left, add);
+        } else if (node.TYPE == "Call") {
+            var exp = node.expression;
+            if (exp instanceof AST_Dot) switch (exp.property) {
+              case "defineProperty":
+              case "getOwnPropertyDescriptor":
+                if (node.args.length < 2) break;
+                exp = exp.expression;
+                if (!(exp instanceof AST_SymbolRef)) break;
+                if (exp.name != "Object") break;
+                if (!exp.definition().undeclared) break;
+                addStrings(node.args[1], add);
+                break;
+              case "hasOwnProperty":
+                if (node.args.length < 1) break;
+                addStrings(node.args[0], add);
+                break;
+            }
         } else if (node instanceof AST_Dot) {
             add(node.property);
+        } else if (node instanceof AST_ObjectProperty) {
+            if (typeof node.key == "string") add(node.key);
         } else if (node instanceof AST_Sub) {
             addStrings(node.property, add);
-        } else if (node instanceof AST_Call
-            && node.expression.print_to_string() == "Object.defineProperty") {
-            addStrings(node.args[1], add);
         }
     }));
 
-    // step 2: transform the tree, renaming properties
-    return ast.transform(new TreeTransformer(function(node) {
-        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);
+    // step 2: renaming properties
+    ast.walk(new TreeWalker(function(node) {
+        if (node instanceof AST_Binary) {
+            if (node.operator == "in") mangleStrings(node.left);
+        } else if (node.TYPE == "Call") {
+            var exp = node.expression;
+            if (exp instanceof AST_Dot) switch (exp.property) {
+              case "defineProperty":
+              case "getOwnPropertyDescriptor":
+                if (node.args.length < 2) break;
+                exp = exp.expression;
+                if (!(exp instanceof AST_SymbolRef)) break;
+                if (exp.name != "Object") break;
+                if (!exp.definition().undeclared) break;
+                mangleStrings(node.args[1]);
+                break;
+              case "hasOwnProperty":
+                if (node.args.length < 1) break;
+                mangleStrings(node.args[0]);
+                break;
+            }
         } else if (node instanceof AST_Dot) {
             node.property = mangle(node.property);
-        } else if (!options.keep_quoted && node instanceof AST_Sub) {
-            node.property = mangleStrings(node.property);
-        } else if (node instanceof AST_Call
-            && node.expression.print_to_string() == "Object.defineProperty") {
-            node.args[1] = mangleStrings(node.args[1]);
+        } else if (node instanceof AST_ObjectProperty) {
+            if (typeof node.key == "string") node.key = mangle(node.key);
+        } else if (node instanceof AST_Sub) {
+            if (!options.keep_quoted) mangleStrings(node.property);
         }
     }));
 
     // only function declarations after this line
 
     function can_mangle(name) {
-        if (unmangleable.indexOf(name) >= 0) return false;
-        if (reserved.indexOf(name) >= 0) return false;
-        if (options.only_cache) return cache.has(name);
+        if (unmangleable[name]) return false;
         if (/^-?[0-9]+(\.[0-9]+)?(e[+-][0-9]+)?$/.test(name)) return false;
         return true;
     }
 
     function should_mangle(name) {
+        if (reserved[name]) return false;
         if (regex && !regex.test(name)) return false;
-        if (reserved.indexOf(name) >= 0) return false;
-        return cache.has(name) || names_to_mangle.indexOf(name) >= 0;
+        return cache.has(name) || names_to_mangle[name];
     }
 
     function add(name) {
-        if (can_mangle(name)) push_uniq(names_to_mangle, name);
-        if (!should_mangle(name)) push_uniq(unmangleable, name);
+        if (can_mangle(name)) names_to_mangle[name] = true;
+        if (!should_mangle(name)) unmangleable[name] = true;
     }
 
     function mangle(name) {
@@ -204,7 +228,7 @@ function mangle_properties(ast, options) {
         var mangled = cache.get(name);
         if (!mangled) {
             if (debug) {
-                // debug mode: use a prefix and suffix to preserve readability, e.g. o.foo -> o._$foo$NNN_.
+                // debug mode: use a prefix and suffix to preserve readability, e.g. o.foo ---> o._$foo$NNN_.
                 var debug_mangled = "_$" + name + "$" + debug_suffix + "_";
                 if (can_mangle(debug_mangled)) mangled = debug_mangled;
             }
@@ -218,17 +242,13 @@ function mangle_properties(ast, options) {
     }
 
     function mangleStrings(node) {
-        return node.transform(new TreeTransformer(function(node) {
-            if (node instanceof AST_Sequence) {
-                var last = node.expressions.length - 1;
-                node.expressions[last] = mangleStrings(node.expressions[last]);
-            } else if (node instanceof AST_String) {
-                node.value = mangle(node.value);
-            } else if (node instanceof AST_Conditional) {
-                node.consequent = mangleStrings(node.consequent);
-                node.alternative = mangleStrings(node.alternative);
-            }
-            return node;
-        }));
+        if (node instanceof AST_Sequence) {
+            mangleStrings(node.expressions.tail_node());
+        } else if (node instanceof AST_String) {
+            node.value = mangle(node.value);
+        } else if (node instanceof AST_Conditional) {
+            mangleStrings(node.consequent);
+            mangleStrings(node.alternative);
+        }
     }
 }

lib/scope.js

@@ -48,7 +48,6 @@ function SymbolDef(id, scope, orig, init) {
     this.global = false;
     this.id = id;
     this.init = init;
-    this.lambda = orig instanceof AST_SymbolLambda;
     this.mangled_name = null;
     this.name = orig.name;
     this.orig = [ orig ];
@@ -59,6 +58,37 @@ function SymbolDef(id, scope, orig, init) {
 }
 
 SymbolDef.prototype = {
+    forEach: function(fn) {
+        this.orig.forEach(fn);
+        this.references.forEach(fn);
+    },
+    mangle: function(options) {
+        var cache = options.cache && options.cache.props;
+        if (this.global && cache && cache.has(this.name)) {
+            this.mangled_name = cache.get(this.name);
+        } else if (!this.mangled_name && !this.unmangleable(options)) {
+            var def = this.redefined();
+            if (def) {
+                this.mangled_name = def.mangled_name || def.name;
+            } else {
+                this.mangled_name = next_mangled_name(this, options);
+            }
+            if (this.global && cache) {
+                cache.set(this.name, this.mangled_name);
+            }
+        }
+    },
+    redefined: function() {
+        var scope = this.defun;
+        if (!scope) return;
+        var name = this.name;
+        var def = scope.variables.get(name)
+            || scope instanceof AST_Toplevel && scope.globals.get(name)
+            || this.orig[0] instanceof AST_SymbolConst && find_if(function(def) {
+                return def.name == name;
+            }, scope.enclosed);
+        if (def && def !== this) return def.redefined() || def;
+    },
     unmangleable: function(options) {
         return this.global && !options.toplevel
             || this.undeclared
@@ -67,27 +97,18 @@ SymbolDef.prototype = {
                 && (this.orig[0] instanceof AST_SymbolLambda
                     || this.orig[0] instanceof AST_SymbolDefun);
     },
-    mangle: function(options) {
-        var cache = options.cache && options.cache.props;
-        if (this.global && cache && cache.has(this.name)) {
-            this.mangled_name = cache.get(this.name);
-        } else if (!this.mangled_name && !this.unmangleable(options)) {
-            var def;
-            if (def = this.redefined()) {
-                this.mangled_name = def.mangled_name || def.name;
-            } else {
-                this.mangled_name = next_mangled_name(this.scope, options, this);
-            }
-            if (this.global && cache) {
-                cache.set(this.name, this.mangled_name);
-            }
-        }
-    },
-    redefined: function() {
-        return this.defun && this.defun.variables.get(this.name);
-    }
 };
 
+var unary_side_effects = makePredicate("delete ++ --");
+
+function is_lhs(node, parent) {
+    if (parent instanceof AST_Assign) return parent.left === node && node;
+    if (parent instanceof AST_DefaultValue) return parent.name === node && node;
+    if (parent instanceof AST_Destructured) return node;
+    if (parent instanceof AST_DestructuredKeyVal) return node;
+    if (parent instanceof AST_Unary) return unary_side_effects[parent.operator] && parent.expression;
+}
+
 AST_Toplevel.DEFMETHOD("figure_out_scope", function(options) {
     options = defaults(options, {
         cache: null,
@@ -96,30 +117,47 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options) {
 
     // pass 1: setup scope chaining and handle definitions
     var self = this;
-    var scope = self.parent_scope = null;
     var defun = null;
+    var next_def_id = 0;
+    var scope = self.parent_scope = null;
     var tw = new TreeWalker(function(node, descend) {
-        if (node instanceof AST_Catch) {
-            var save_scope = scope;
-            scope = new AST_Scope(node);
-            scope.init_scope_vars(save_scope);
-            descend();
-            scope = save_scope;
+        if (node instanceof AST_LambdaDefinition) {
+            node.name.walk(tw);
+            walk_scope(function() {
+                node.argnames.forEach(function(argname) {
+                    argname.walk(tw);
+                });
+                if (node.rest) node.rest.walk(tw);
+                walk_body(node, tw);
+            });
             return true;
         }
-        if (node instanceof AST_Scope) {
-            node.init_scope_vars(scope);
-            var save_scope = scope;
-            var save_defun = defun;
-            defun = scope = node;
+        if (node instanceof AST_SwitchBranch) {
+            node.init_vars(scope);
             descend();
-            scope = save_scope;
-            defun = save_defun;
+            return true;
+        }
+        if (node instanceof AST_Try) {
+            walk_scope(function() {
+                walk_body(node, tw);
+            });
+            if (node.bcatch) node.bcatch.walk(tw);
+            if (node.bfinally) node.bfinally.walk(tw);
             return true;
         }
         if (node instanceof AST_With) {
-            for (var s = scope; s; s = s.parent_scope) s.uses_with = true;
-            return;
+            var s = scope;
+            do {
+                s = s.resolve();
+                if (s.uses_with) break;
+                s.uses_with = true;
+            } while (s = s.parent_scope);
+            walk_scope(descend);
+            return true;
+        }
+        if (node instanceof AST_BlockScope) {
+            walk_scope(descend);
+            return true;
         }
         if (node instanceof AST_Symbol) {
             node.scope = scope;
@@ -128,51 +166,135 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options) {
             node.thedef = node;
             node.references = [];
         }
-        if (node instanceof AST_SymbolDefun) {
-            // This should be defined in the parent scope, as we encounter the
-            // AST_Defun node before getting to its AST_Symbol.
-            (node.scope = defun.parent_scope.resolve()).def_function(node, defun);
+        if (node instanceof AST_SymbolCatch) {
+            scope.def_variable(node).defun = defun;
+        } else if (node instanceof AST_SymbolConst) {
+            scope.def_variable(node).defun = defun;
+        } else if (node instanceof AST_SymbolDefun) {
+            defun.def_function(node, tw.parent());
+            entangle(defun, scope);
+        } else if (node instanceof AST_SymbolFunarg) {
+            defun.def_variable(node);
+            entangle(defun, scope);
         } else if (node instanceof AST_SymbolLambda) {
             var def = defun.def_function(node, node.name == "arguments" ? undefined : defun);
             if (options.ie8) def.defun = defun.parent_scope.resolve();
+        } else if (node instanceof AST_SymbolLet) {
+            scope.def_variable(node);
         } else if (node instanceof AST_SymbolVar) {
-            defun.def_variable(node, node.TYPE == "SymbolVar" ? null : undefined);
-            if (defun !== scope) {
-                node.mark_enclosed(options);
-                var def = scope.find_variable(node);
-                if (node.thedef !== def) {
-                    node.thedef = def;
-                }
-                node.reference(options);
-            }
-        } else if (node instanceof AST_SymbolCatch) {
-            scope.def_variable(node).defun = defun;
+            defun.def_variable(node, null);
+            entangle(defun, scope);
+        }
+
+        function walk_scope(descend) {
+            node.init_vars(scope);
+            var save_defun = defun;
+            var save_scope = scope;
+            if (node instanceof AST_Scope) defun = node;
+            scope = node;
+            descend();
+            scope = save_scope;
+            defun = save_defun;
+        }
+
+        function entangle(defun, scope) {
+            if (defun === scope) return;
+            node.mark_enclosed(options);
+            var def = scope.find_variable(node.name);
+            if (node.thedef === def) return;
+            node.thedef = def;
+            def.orig.push(node);
+            node.mark_enclosed(options);
         }
     });
-    self.next_def_id = 0;
+    self.make_def = function(orig, init) {
+        return new SymbolDef(++next_def_id, this, orig, init);
+    };
     self.walk(tw);
 
     // pass 2: find back references and eval
     self.globals = new Dictionary();
+    var in_arg = [];
     var tw = new TreeWalker(function(node) {
+        if (node instanceof AST_Catch) {
+            if (!(node.argname instanceof AST_Destructured)) return;
+            in_arg.push(node);
+            node.argname.walk(tw);
+            in_arg.pop();
+            walk_body(node, tw);
+            return true;
+        }
+        if (node instanceof AST_Lambda) {
+            in_arg.push(node);
+            node.argnames.forEach(function(argname) {
+                argname.walk(tw);
+            });
+            if (node.rest) node.rest.walk(tw);
+            in_arg.pop();
+            walk_lambda(node, tw);
+            return true;
+        }
         if (node instanceof AST_LoopControl) {
             if (node.label) node.label.thedef.references.push(node);
             return true;
         }
+        if (node instanceof AST_SymbolDeclaration) {
+            if (node instanceof AST_SymbolCatch) {
+                // ensure mangling works if `catch` reuses a scope variable
+                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;
+                }
+            } else if (node instanceof AST_SymbolConst) {
+                // ensure compression works if `const` reuses a scope variable
+                var redef = node.definition().redefined();
+                if (redef) redef.const_redefs = true;
+            }
+            if (node.name != "arguments") return true;
+            var parent = node instanceof AST_SymbolVar && tw.parent();
+            if (parent instanceof AST_VarDef && !parent.value) return true;
+            var sym = node.scope.resolve().find_variable("arguments");
+            if (sym && is_arguments(sym)) sym.scope.uses_arguments = 3;
+            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_SymbolCatch
+                    || 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 (sym.scope instanceof AST_Lambda && name == "arguments") {
-                sym.scope.uses_arguments = true;
+            } else if (name == "arguments" && is_arguments(sym)) {
+                var parent = tw.parent();
+                if (is_lhs(node, parent)) {
+                    sym.scope.uses_arguments = 3;
+                } else if (sym.scope.uses_arguments < 2
+                    && !(parent instanceof AST_PropAccess && parent.expression === node)) {
+                    sym.scope.uses_arguments = 2;
+                } else if (!sym.scope.uses_arguments) {
+                    sym.scope.uses_arguments = true;
+                }
             }
             if (name == "eval") {
                 var parent = tw.parent();
                 if (parent.TYPE == "Call" && parent.expression === node) {
-                    for (var s = node.scope; s && !s.uses_eval; s = s.parent_scope) {
+                    var s = node.scope;
+                    do {
+                        s = s.resolve();
+                        if (s.uses_eval) break;
                         s.uses_eval = true;
-                    }
+                    } while (s = s.parent_scope);
                 } else if (sym.undeclared) {
                     self.uses_eval = true;
                 }
@@ -181,15 +303,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;
-        }
     });
     self.walk(tw);
 
@@ -205,8 +318,9 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options) {
         }
         if (node instanceof AST_SymbolLambda) {
             var def = node.thedef;
-            redefine(node, node.scope.parent_scope.resolve());
-            if (typeof node.thedef.init !== "undefined") {
+            if (!redefine(node, node.scope.parent_scope.resolve())) {
+                delete def.defun;
+            } else if (typeof node.thedef.init !== "undefined") {
                 node.thedef.init = false;
             } else if (def.init) {
                 node.thedef.init = def.init;
@@ -215,13 +329,22 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options) {
         }
     }));
 
+    function is_arguments(sym) {
+        return sym.orig[0] instanceof AST_SymbolFunarg
+            && !(sym.orig[1] instanceof AST_SymbolFunarg || sym.orig[2] instanceof AST_SymbolFunarg)
+            && !is_arrow(sym.scope);
+    }
+
     function redefine(node, scope) {
         var name = node.name;
         var old_def = node.thedef;
+        if (!all(old_def.orig, function(sym) {
+            return !(sym instanceof AST_SymbolConst || sym instanceof AST_SymbolLet);
+        })) return false;
         var new_def = scope.find_variable(name);
         if (new_def) {
-            var redef;
-            while (redef = new_def.redefined()) new_def = redef;
+            var redef = new_def.redefined();
+            if (redef) new_def = redef;
         } else {
             new_def = self.globals.get(name);
         }
@@ -230,21 +353,17 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options) {
         } else {
             new_def = scope.def_variable(node);
         }
-        old_def.orig.concat(old_def.references).forEach(function(node) {
+        old_def.defun = new_def.scope;
+        old_def.forEach(function(node) {
+            node.redef = old_def;
             node.thedef = new_def;
             node.reference(options);
         });
-        if (old_def.lambda) new_def.lambda = true;
         if (new_def.undeclared) self.variables.set(name, new_def);
+        return true;
     }
 });
 
-AST_Scope.DEFMETHOD("make_def", function(orig, init) {
-    var top = this;
-    while (top.parent_scope) top = top.parent_scope;
-    return new SymbolDef(++top.next_def_id, this, orig, init);
-});
-
 AST_Toplevel.DEFMETHOD("def_global", function(node) {
     var globals = this.globals, name = node.name;
     if (globals.has(name)) {
@@ -258,24 +377,41 @@ AST_Toplevel.DEFMETHOD("def_global", function(node) {
     }
 });
 
-AST_Scope.DEFMETHOD("init_scope_vars", function(parent_scope) {
-    this.variables = new Dictionary();  // map name to AST_SymbolVar (variables defined in this scope; includes functions)
-    this.functions = new Dictionary();  // map name to AST_SymbolDefun (functions defined in this scope)
-    this.uses_with = false;             // will be set to true if this or some nested scope uses the `with` statement
-    this.uses_eval = false;             // will be set to true if this or nested scope uses the global `eval`
-    this.parent_scope = parent_scope;   // the parent scope
-    this.enclosed = [];                 // a list of variables from this or outer scope(s) that are referenced from this or inner scopes
-    this.cname = -1;                    // the current index for mangling functions/variables
-});
+function init_block_vars(scope, parent) {
+    scope.enclosed = [];                            // variables from this or outer scope(s) that are referenced from this or inner scopes
+    scope.parent_scope = parent;                    // the parent scope (null if this is the top level)
+    scope.functions = new Dictionary();             // map name to AST_SymbolDefun (functions defined in this scope)
+    scope.variables = new Dictionary();             // map name to AST_SymbolVar (variables defined in this scope; includes functions)
+    if (parent) scope.make_def = parent.make_def;   // top-level tracking of SymbolDef instances
+}
 
-AST_Lambda.DEFMETHOD("init_scope_vars", function() {
-    AST_Scope.prototype.init_scope_vars.apply(this, arguments);
+function init_scope_vars(scope, parent) {
+    init_block_vars(scope, parent);
+    scope.uses_eval = false;                        // will be set to true if this or nested scope uses the global `eval`
+    scope.uses_with = false;                        // will be set to true if this or some nested scope uses the `with` statement
+}
+
+AST_BlockScope.DEFMETHOD("init_vars", function(parent_scope) {
+    init_block_vars(this, parent_scope);
+});
+AST_Scope.DEFMETHOD("init_vars", function(parent_scope) {
+    init_scope_vars(this, parent_scope);
+});
+AST_Arrow.DEFMETHOD("init_vars", function(parent_scope) {
+    init_scope_vars(this, parent_scope);
+});
+AST_AsyncArrow.DEFMETHOD("init_vars", function(parent_scope) {
+    init_scope_vars(this, parent_scope);
+});
+AST_Lambda.DEFMETHOD("init_vars", function(parent_scope) {
+    init_scope_vars(this, parent_scope);
     this.uses_arguments = false;
     this.def_variable(new AST_SymbolFunarg({
         name: "arguments",
         start: this.start,
-        end: this.end
+        end: this.end,
     }));
+    return this;
 });
 
 AST_Symbol.DEFMETHOD("mark_enclosed", function(options) {
@@ -296,24 +432,23 @@ AST_Symbol.DEFMETHOD("reference", function(options) {
     this.mark_enclosed(options);
 });
 
-AST_Scope.DEFMETHOD("find_variable", function(name) {
-    if (name instanceof AST_Symbol) name = name.name;
+AST_BlockScope.DEFMETHOD("find_variable", function(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_Scope.DEFMETHOD("def_function", function(symbol, init) {
+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 || def.init instanceof AST_LambdaDefinition) def.init = init;
     this.functions.set(symbol.name, def);
     return def;
 });
 
-AST_Scope.DEFMETHOD("def_variable", function(symbol, init) {
+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 (def.init instanceof AST_LambdaExpression) def.init = init;
     } else {
         def = this.make_def(symbol, init);
         this.variables.set(symbol.name, def);
@@ -322,17 +457,12 @@ AST_Scope.DEFMETHOD("def_variable", function(symbol, init) {
     return symbol.thedef = def;
 });
 
-AST_Lambda.DEFMETHOD("resolve", return_this);
-AST_Scope.DEFMETHOD("resolve", function() {
-    return this.parent_scope.resolve();
-});
-AST_Toplevel.DEFMETHOD("resolve", return_this);
-
 function names_in_use(scope, options) {
     var names = scope.names_in_use;
     if (!names) {
-        scope.names_in_use = names = Object.create(scope.mangled_names || null);
+        scope.cname = -1;
         scope.cname_holes = [];
+        scope.names_in_use = names = Object.create(null);
         var cache = options.cache && options.cache.props;
         scope.enclosed.forEach(function(def) {
             if (def.unmangleable(options)) names[def.name] = true;
@@ -344,12 +474,13 @@ 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);
     var scopes = [ scope ];
-    def.references.forEach(function(sym) {
+    def.forEach(function(sym) {
         var scope = sym.scope;
         do {
             if (scopes.indexOf(scope) < 0) {
@@ -365,7 +496,7 @@ function next_mangled_name(scope, options, def) {
         name = base54(holes[i]);
         if (names[name]) continue;
         holes.splice(i, 1);
-        scope.names_in_use[name] = true;
+        in_use[name] = true;
         return name;
     }
     while (true) {
@@ -374,7 +505,7 @@ function next_mangled_name(scope, options, def) {
         if (!names[name]) break;
         holes.push(scope.cname);
     }
-    scope.names_in_use[name] = true;
+    in_use[name] = true;
     return name;
 }
 
@@ -386,18 +517,10 @@ AST_Symbol.DEFMETHOD("unmangleable", function(options) {
 // labels are always mangleable
 AST_Label.DEFMETHOD("unmangleable", return_false);
 
-AST_Symbol.DEFMETHOD("unreferenced", function() {
-    return !this.definition().references.length && !this.scope.pinned();
-});
-
 AST_Symbol.DEFMETHOD("definition", function() {
     return this.thedef;
 });
 
-AST_Symbol.DEFMETHOD("global", function() {
-    return this.definition().global;
-});
-
 function _default_mangler_options(options) {
     options = defaults(options, {
         eval        : false,
@@ -405,6 +528,8 @@ function _default_mangler_options(options) {
         keep_fnames : false,
         reserved    : [],
         toplevel    : false,
+        v8          : false,
+        webkit      : false,
     });
     if (!Array.isArray(options.reserved)) options.reserved = [];
     // Never mangle arguments
@@ -423,7 +548,7 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options) {
     var lname = -1;
 
     if (options.cache && options.cache.props) {
-        var mangled_names = this.mangled_names = Object.create(null);
+        var mangled_names = names_in_use(this, options);
         options.cache.props.each(function(mangled_name) {
             mangled_names[mangled_name] = true;
         });
@@ -435,10 +560,29 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options) {
             // lname is incremented when we get to the AST_Label
             var save_nesting = lname;
             descend();
-            lname = save_nesting;
+            if (!options.v8 || !in_label(tw)) lname = save_nesting;
             return true;
         }
-        if (node instanceof AST_Scope) {
+        if (node instanceof AST_BlockScope) {
+            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)) node.to_mangle.push(def);
+            });
             descend();
             if (options.cache && node instanceof AST_Toplevel) {
                 node.globals.each(mangle);
@@ -448,9 +592,7 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options) {
                 sym.scope = node;
                 sym.reference(options);
             }
-            node.variables.each(function(def) {
-                if (!defer_redef(def)) mangle(def);
-            });
+            node.to_mangle.forEach(mangle);
             return true;
         }
         if (node instanceof AST_Label) {
@@ -461,13 +603,6 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options) {
             node.mangled_name = name;
             return true;
         }
-        if (!options.ie8 && node instanceof AST_Catch) {
-            var def = node.argname.definition();
-            var redef = defer_redef(def, node.argname);
-            descend();
-            if (!redef) mangle(def);
-            return true;
-        }
     });
     this.walk(tw);
     redefined.forEach(mangle);
@@ -477,12 +612,20 @@ 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;
+            if (def.scope.parent_scope.find_variable(sym.name)) return false;
+            redef = scope.def_variable(sym);
+            scope.to_mangle.push(redef);
+        }
         redefined.push(def);
         def.references.forEach(reference);
-        if (node) reference(node);
+        if (sym instanceof AST_SymbolCatch || sym instanceof AST_SymbolConst) reference(sym);
         return true;
 
         function reference(sym) {
@@ -491,16 +634,23 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options) {
             sym.thedef = def;
         }
     }
+
+    function in_label(tw) {
+        var level = 0, parent;
+        while (parent = tw.parent(level++)) {
+            if (parent instanceof AST_Block) return parent instanceof AST_Toplevel && !options.toplevel;
+            if (parent instanceof AST_LabeledStatement) return true;
+        }
+    }
 });
 
 AST_Toplevel.DEFMETHOD("find_colliding_names", function(options) {
     var cache = options.cache && options.cache.props;
-    var avoid = Object.create(null);
+    var avoid = Object.create(RESERVED_WORDS);
     options.reserved.forEach(to_avoid);
     this.globals.each(add_def);
     this.walk(new TreeWalker(function(node) {
-        if (node instanceof AST_Scope) node.variables.each(add_def);
-        if (node instanceof AST_SymbolCatch) add_def(node.definition());
+        if (node instanceof AST_BlockScope) node.variables.each(add_def);
     }));
     return avoid;
 
@@ -524,15 +674,14 @@ AST_Toplevel.DEFMETHOD("expand_names", function(options) {
     var cname = 0;
     this.globals.each(rename);
     this.walk(new TreeWalker(function(node) {
-        if (node instanceof AST_Scope) node.variables.each(rename);
-        if (node instanceof AST_SymbolCatch) rename(node.definition());
+        if (node instanceof AST_BlockScope) node.variables.each(rename);
     }));
 
     function next_name() {
         var name;
         do {
             name = base54(cname++);
-        } while (avoid[name] || RESERVED_WORDS[name]);
+        } while (avoid[name]);
         return name;
     }
 
@@ -543,7 +692,7 @@ AST_Toplevel.DEFMETHOD("expand_names", function(options) {
         var redef = def.redefined();
         var name = redef ? redef.rename || redef.name : next_name();
         def.rename = name;
-        def.orig.concat(def.references).forEach(function(sym) {
+        def.forEach(function(sym) {
             if (sym.definition() === def) sym.name = name;
         });
     }
@@ -557,22 +706,24 @@ AST_Sequence.DEFMETHOD("tail_node", function() {
 AST_Toplevel.DEFMETHOD("compute_char_frequency", function(options) {
     options = _default_mangler_options(options);
     base54.reset();
+    var fn = AST_Symbol.prototype.add_source_map;
     try {
-        AST_Node.prototype.print = function(stream, force_parens) {
-            this._print(stream, force_parens);
-            if (this instanceof AST_Symbol && !this.unmangleable(options)) {
-                base54.consider(this.name, -1);
-            } else if (options.properties) {
-                if (this instanceof AST_Dot) {
-                    base54.consider(this.property, -1);
-                } else if (this instanceof AST_Sub) {
-                    skip_string(this.property);
-                }
-            }
+        AST_Symbol.prototype.add_source_map = function() {
+            if (!this.unmangleable(options)) base54.consider(this.name, -1);
         };
+        if (options.properties) {
+            AST_Dot.prototype.add_source_map = function() {
+                base54.consider(this.property, -1);
+            };
+            AST_Sub.prototype.add_source_map = function() {
+                skip_string(this.property);
+            };
+        }
         base54.consider(this.print_to_string(), 1);
     } finally {
-        AST_Node.prototype.print = AST_Node.prototype._print;
+        AST_Symbol.prototype.add_source_map = fn;
+        delete AST_Dot.prototype.add_source_map;
+        delete AST_Sub.prototype.add_source_map;
     }
     base54.sort();
 

lib/sourcemap.js

@@ -144,7 +144,9 @@ function SourceMap(options) {
             add(source, gen_line, gen_col, orig_line, orig_col, name);
         } : add,
         setSourceContent: sources_content ? function(source, content) {
-            sources_content[source] = content;
+            if (!(source in sources_content)) {
+                sources_content[source] = content;
+            }
         } : noop,
         toString: function() {
             return JSON.stringify({

lib/transform.js

@@ -82,7 +82,7 @@ TreeTransformer.prototype = new TreeWalker;
         if (self.step) self.step = self.step.transform(tw);
         self.body = self.body.transform(tw);
     });
-    DEF(AST_ForIn, function(self, tw) {
+    DEF(AST_ForEnumeration, function(self, tw) {
         self.init = self.init.transform(tw);
         self.object = self.object.transform(tw);
         self.body = self.body.transform(tw);
@@ -116,7 +116,7 @@ TreeTransformer.prototype = new TreeWalker;
         if (self.bfinally) self.bfinally = self.bfinally.transform(tw);
     });
     DEF(AST_Catch, function(self, tw) {
-        self.argname = self.argname.transform(tw);
+        if (self.argname) self.argname = self.argname.transform(tw);
         self.body = do_list(self.body, tw);
     });
     DEF(AST_Definitions, function(self, tw) {
@@ -126,11 +126,27 @@ TreeTransformer.prototype = new TreeWalker;
         self.name = self.name.transform(tw);
         if (self.value) self.value = self.value.transform(tw);
     });
+    DEF(AST_DefaultValue, function(self, tw) {
+        self.name = self.name.transform(tw);
+        self.value = self.value.transform(tw);
+    });
     DEF(AST_Lambda, function(self, tw) {
         if (self.name) self.name = self.name.transform(tw);
         self.argnames = do_list(self.argnames, tw);
+        if (self.rest) self.rest = self.rest.transform(tw);
         self.body = do_list(self.body, tw);
     });
+    function transform_arrow(self, tw) {
+        self.argnames = do_list(self.argnames, tw);
+        if (self.rest) self.rest = self.rest.transform(tw);
+        if (self.value) {
+            self.value = self.value.transform(tw);
+        } else {
+            self.body = do_list(self.body, tw);
+        }
+    }
+    DEF(AST_Arrow, transform_arrow);
+    DEF(AST_AsyncArrow, transform_arrow);
     DEF(AST_Call, function(self, tw) {
         self.expression = self.expression.transform(tw);
         self.args = do_list(self.args, tw);
@@ -138,6 +154,12 @@ 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_Yield, function(self, tw) {
+        if (self.expression) self.expression = self.expression.transform(tw);
+    });
     DEF(AST_Dot, function(self, tw) {
         self.expression = self.expression.transform(tw);
     });
@@ -145,6 +167,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,12 +185,29 @@ 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);
+        if (self.rest) self.rest = self.rest.transform(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);
+        if (self.rest) self.rest = self.rest.transform(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);
     });
+    DEF(AST_Template, function(self, tw) {
+        if (self.tag) self.tag = self.tag.transform(tw);
+        self.expressions = do_list(self.expressions, tw);
+    });
 })(function(node, descend) {
     node.DEFMETHOD("transform", function(tw, in_list) {
         var x, y;

lib/utils.js

@@ -112,51 +112,29 @@ function return_this() { return this; }
 function return_null() { return null; }
 
 var List = (function() {
-    function List(a, f, backwards) {
-        var ret = [], top = [], i;
-        function doit() {
+    function List(a, f) {
+        var ret = [];
+        for (var i = 0; i < a.length; i++) {
             var val = f(a[i], i);
-            var is_last = val instanceof Last;
-            if (is_last) val = val.v;
-            if (val instanceof AtTop) {
-                val = val.v;
-                if (val instanceof Splice) {
-                    top.push.apply(top, backwards ? val.v.slice().reverse() : val.v);
-                } else {
-                    top.push(val);
-                }
-            } else if (val !== skip) {
-                if (val instanceof Splice) {
-                    ret.push.apply(ret, backwards ? val.v.slice().reverse() : val.v);
-                } else {
-                    ret.push(val);
-                }
-            }
-            return is_last;
-        }
-        if (Array.isArray(a)) {
-            if (backwards) {
-                for (i = a.length; --i >= 0;) if (doit()) break;
-                ret.reverse();
-                top.reverse();
+            if (val === skip) continue;
+            if (val instanceof Splice) {
+                ret.push.apply(ret, val.v);
             } else {
-                for (i = 0; i < a.length; ++i) if (doit()) break;
+                ret.push(val);
             }
-        } else {
-            for (i in a) if (HOP(a, i)) if (doit()) break;
         }
-        return top.concat(ret);
+        return ret;
     }
     List.is_op = function(val) {
-        return val === skip || val instanceof AtTop || val instanceof Last || val instanceof Splice;
+        return val === skip || val instanceof Splice;
+    };
+    List.splice = function(val) {
+        return new Splice(val);
     };
-    List.at_top = function(val) { return new AtTop(val); };
-    List.splice = function(val) { return new Splice(val); };
-    List.last = function(val) { return new Last(val); };
     var skip = List.skip = {};
-    function AtTop(val) { this.v = val; }
-    function Splice(val) { this.v = val; }
-    function Last(val) { this.v = val; }
+    function Splice(val) {
+        this.v = val;
+    }
     return List;
 })();
 
@@ -165,8 +143,9 @@ function push_uniq(array, el) {
 }
 
 function string_template(text, props) {
-    return text.replace(/\{(.+?)\}/g, function(str, p) {
-        return props && props[p];
+    return text.replace(/\{([^}]+)\}/g, function(str, p) {
+        var value = props[p];
+        return value instanceof AST_Node ? value.print_to_string() : value;
     });
 }
 
@@ -259,13 +238,15 @@ function HOP(obj, prop) {
 // return true if the node at the top of the stack (that means the
 // innermost node in the current output) is lexically the first in
 // a statement.
-function first_in_statement(stack) {
+function first_in_statement(stack, arrow) {
     var node = stack.parent(-1);
     for (var i = 0, p; p = stack.parent(i++); node = p) {
-        if (p.TYPE == "Call") {
-            if (p.expression === node) continue;
+        if (is_arrow(p)) {
+            return arrow && p.value === node;
         } else if (p instanceof AST_Binary) {
             if (p.left === node) continue;
+        } else if (p.TYPE == "Call") {
+            if (p.expression === node) continue;
         } else if (p instanceof AST_Conditional) {
             if (p.condition === node) continue;
         } else if (p instanceof AST_PropAccess) {
@@ -274,6 +255,8 @@ function first_in_statement(stack) {
             if (p.expressions[0] === node) continue;
         } else if (p instanceof AST_Statement) {
             return p.body === node;
+        } else if (p instanceof AST_Template) {
+            if (p.tag === node) continue;
         } else if (p instanceof AST_UnaryPostfix) {
             if (p.expression === node) continue;
         }

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

test/compress.js

@@ -1,6 +1,6 @@
 "use strict";
 
-require("../tools/exit");
+require("../tools/tty");
 
 var assert = require("assert");
 var child_process = require("child_process");
@@ -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
@@ -210,7 +209,7 @@ function reminify(orig_options, input_code, input_formatted, stdout) {
         } else {
             var toplevel = sandbox.has_toplevel(options);
             var expected = stdout[toplevel ? 1 : 0];
-            var actual = run_code(result.code, toplevel);
+            var actual = sandbox.run_code(result.code, toplevel);
             if (typeof expected != "string" && typeof actual != "string" && expected.name == actual.name) {
                 actual = expected;
             }
@@ -245,11 +244,6 @@ function reminify(orig_options, input_code, input_formatted, stdout) {
     return true;
 }
 
-function run_code(code, toplevel) {
-    var result = sandbox.run_code(code, toplevel);
-    return typeof result == "string" ? result.replace(/\u001b\[\d+m/g, "") : result;
-}
-
 function test_case(test) {
     log("    Running test [{name}]", { name: test.name });
     U.AST_Node.enable_validation();
@@ -269,6 +263,7 @@ function test_case(test) {
         quote_style: 3,
     });
     try {
+        input.validate_ast();
         U.parse(input_code);
     } catch (ex) {
         log([
@@ -311,12 +306,11 @@ function test_case(test) {
     if (test.mangle) {
         output.compute_char_frequency(test.mangle);
         output.mangle_names(test.mangle);
-        if (test.mangle.properties) {
-            output = U.mangle_properties(output, test.mangle.properties);
-        }
+        if (test.mangle.properties) U.mangle_properties(output, test.mangle.properties);
     }
-    output = make_code(output, output_options);
-    if (expect != output) {
+    var output_code = make_code(output, output_options);
+    U.AST_Node.log_function();
+    if (expect != output_code) {
         log([
             "!!! failed",
             "---INPUT---",
@@ -329,14 +323,15 @@ function test_case(test) {
             "",
         ].join("\n"), {
             input: input_formatted,
-            output: output,
+            output: output_code,
             expected: expect
         });
         return false;
     }
     // expect == output
     try {
-        U.parse(output);
+        output.validate_ast();
+        U.parse(output_code);
     } catch (ex) {
         log([
             "!!! Test matched expected result but cannot parse output",
@@ -350,7 +345,7 @@ function test_case(test) {
             "",
         ].join("\n"), {
             input: input_formatted,
-            output: output,
+            output: output_code,
             error: ex,
         });
         return false;
@@ -380,13 +375,13 @@ function test_case(test) {
         }
     }
     if (test.expect_stdout && (!test.node_version || semver.satisfies(process.version, test.node_version))) {
-        var stdout = [ run_code(input_code), run_code(input_code, true) ];
+        var stdout = [ sandbox.run_code(input_code), sandbox.run_code(input_code, true) ];
         var toplevel = sandbox.has_toplevel({
             compress: test.options,
             mangle: test.mangle
         });
         var actual = stdout[toplevel ? 1 : 0];
-        if (test.expect_stdout === true) {
+        if (test.expect_stdout === true || test.expect_stdout instanceof Error && test.expect_stdout.name === actual.name) {
             test.expect_stdout = actual;
         }
         if (!sandbox.same_stdout(test.expect_stdout, actual)) {
@@ -409,7 +404,7 @@ function test_case(test) {
             });
             return false;
         }
-        actual = run_code(output, toplevel);
+        actual = sandbox.run_code(output_code, toplevel);
         if (!sandbox.same_stdout(test.expect_stdout, actual)) {
             log([
                 "!!! failed",

test/compress/arguments.js

@@ -78,7 +78,7 @@ replace_index_strict: {
     ]
 }
 
-replace_index_keep_fargs: {
+replace_index_drop_fargs_1: {
     options = {
         arguments: true,
         evaluate: true,
@@ -101,6 +101,13 @@ replace_index_keep_fargs: {
             var arguments;
             console.log(arguments[1], arguments["1"], arguments["foo"]);
         })("bar", 42);
+        (function() {
+            var arguments = {
+                1: "foo",
+                foo: "bar",
+            };
+            console.log(arguments[1], arguments["1"], arguments["foo"]);
+        })("bar", 42);
     }
     expect: {
         var arguments = [];
@@ -114,8 +121,15 @@ replace_index_keep_fargs: {
         (function(arguments) {
             console.log(arguments[1], arguments[1], arguments.foo);
         })("bar", 42);
-        (function() {
+        (function(argument_0, argument_1) {
             var arguments;
+            console.log(argument_1, argument_1, arguments.foo);
+        })("bar", 42);
+        (function() {
+            var arguments = {
+                1: "foo",
+                foo: "bar",
+            };
             console.log(arguments[1], arguments[1], arguments.foo);
         })("bar", 42);
     }
@@ -125,10 +139,11 @@ replace_index_keep_fargs: {
         "42 42 undefined",
         "a a undefined",
         "42 42 undefined",
+        "foo foo bar",
     ]
 }
 
-replace_index_keep_fargs_strict: {
+replace_index_drop_fargs_2: {
     options = {
         arguments: true,
         evaluate: true,
@@ -412,7 +427,7 @@ issue_3273_global_strict_reduce_vars: {
     ]
 }
 
-issue_3273_keep_fargs_false: {
+issue_3273_drop_fargs_1: {
     options = {
         arguments: true,
         keep_fargs: false,
@@ -435,10 +450,10 @@ issue_3273_keep_fargs_false: {
     expect_stdout: "1"
 }
 
-issue_3273_keep_fargs_strict: {
+issue_3273_drop_fargs_2: {
     options = {
         arguments: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         reduce_vars: true,
     }
     input: {
@@ -633,7 +648,7 @@ issue_3282_2_passes: {
 issue_3420_1: {
     options = {
         arguments: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
     }
     input: {
         console.log(function() {
@@ -655,7 +670,7 @@ issue_3420_1: {
 issue_3420_2: {
     options = {
         arguments: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
     }
     input: {
         var foo = function() {
@@ -675,7 +690,7 @@ issue_3420_2: {
 issue_3420_3: {
     options = {
         arguments: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
     }
     input: {
         "use strict";
@@ -697,7 +712,7 @@ issue_3420_3: {
 issue_3420_4: {
     options = {
         arguments: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
     }
     input: {
         !function() {
@@ -722,7 +737,7 @@ issue_3420_4: {
 issue_3420_5: {
     options = {
         arguments: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
     }
     input: {
         "use strict";
@@ -749,7 +764,7 @@ issue_3420_5: {
 issue_3420_6: {
     options = {
         arguments: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
     }
     input: {
         console.log(function() {
@@ -767,7 +782,7 @@ issue_3420_6: {
 issue_3420_7: {
     options = {
         arguments: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
     }
     input: {
         "use strict";
@@ -783,3 +798,182 @@ issue_3420_7: {
     }
     expect_stdout: "true"
 }
+
+issue_4200: {
+    options = {
+        arguments: true,
+        keep_fargs: false,
+    }
+    input: {
+        var o = {
+            get p() {
+                return arguments[0];
+            },
+        };
+        console.log(o.p);
+    }
+    expect: {
+        var o = {
+            get p() {
+                return arguments[0];
+            },
+        };
+        console.log(o.p);
+    }
+    expect_stdout: "undefined"
+}
+
+issue_4291_1: {
+    options = {
+        arguments: true,
+        keep_fargs: false,
+    }
+    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: false,
+    }
+    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"
+}
+
+issue_4397: {
+    options = {
+        arguments: true,
+        keep_fargs: false,
+    }
+    input: {
+        console.log(typeof function() {
+            arguments += 0;
+            return arguments[0];
+        }());
+    }
+    expect: {
+        console.log(typeof function() {
+            arguments += 0;
+            return arguments[0];
+        }());
+    }
+    expect_stdout: "string"
+}
+
+issue_4410_1: {
+    options = {
+        arguments: true,
+        conditionals: true,
+        evaluate: true,
+        reduce_vars: true,
+    }
+    input: {
+        (function(a) {
+            console.log(arguments[0] === (a = 0) ? "FAIL" : "PASS");
+        })(1);
+    }
+    expect: {
+        (function(a) {
+            console.log(a === (a = 0) ? "FAIL" : "PASS");
+        })(1);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4410_2: {
+    options = {
+        arguments: true,
+        conditionals: true,
+        evaluate: true,
+        reduce_vars: true,
+    }
+    input: {
+        (function f(a) {
+            console.log(arguments[0] === (a = 0) ? "FAIL" : "PASS");
+        })(1);
+    }
+    expect: {
+        (function f(a) {
+            console.log(arguments[0] === (a = 0) ? "FAIL" : "PASS");
+        })(1);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4410_3: {
+    options = {
+        arguments: true,
+    }
+    input: {
+        var a = 1;
+        (function f(b) {
+            a-- && f();
+            for (var c = 2; c--;)
+                switch (arguments[0]) {
+                  case b = 42:
+                  case 42:
+                    console.log("PASS");
+                }
+        })(null);
+    }
+    expect: {
+        var a = 1;
+        (function f(b) {
+            a-- && f();
+            for (var c = 2; c--;)
+                switch (arguments[0]) {
+                  case b = 42:
+                  case 42:
+                    console.log("PASS");
+                }
+        })(null);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4432: {
+    options = {
+        arguments: true,
+        reduce_vars: true,
+    }
+    input: {
+        console.log(function(a) {
+            for (a in { FAIL: 42 });
+            return arguments[0];
+        }() || "PASS");
+    }
+    expect: {
+        console.log(function(a) {
+            for (a in { FAIL: 42 });
+            return arguments[0];
+        }() || "PASS");
+    }
+    expect_stdout: "PASS"
+}

test/compress/arrays.js

@@ -13,9 +13,10 @@ holes_and_undefined: {
     }
 }
 
-constant_join: {
+constant_join_1: {
     options = {
         evaluate: true,
+        side_effects: true,
         strings: true,
         unsafe: true,
     }
@@ -57,7 +58,7 @@ constant_join: {
         var c5 = [ boo() + bar() + "foo", 1, 2, 3, "bar", bar() + "foo" ].join();
         var c6 = [ "1,2,,,foo,bar", baz() ].join();
         var d = "foo-3bar-baz";
-        var e = [].join(foo + bar);
+        var e = (foo, bar, "");
         var f = "";
         var g = "";
     }

test/compress/arrows.js

@@ -0,0 +1,696 @@
+no_funarg: {
+    input: {
+        (() => console.log(42))();
+    }
+    expect_exact: "(()=>console.log(42))();"
+    expect_stdout: "42"
+    node_version: ">=4"
+}
+
+single_funarg: {
+    input: {
+        (a => console.log(a))(42);
+    }
+    expect_exact: "(a=>console.log(a))(42);"
+    expect_stdout: "42"
+    node_version: ">=4"
+}
+
+multiple_funargs: {
+    input: {
+        ((a, b) => console.log(a, b))("foo", "bar");
+    }
+    expect_exact: '((a,b)=>console.log(a,b))("foo","bar");'
+    expect_stdout: "foo bar"
+    node_version: ">=4"
+}
+
+destructured_funarg: {
+    input: {
+        (([ a, b, c ]) => console.log(a, b, c))("foo");
+    }
+    expect_exact: '(([a,b,c])=>console.log(a,b,c))("foo");'
+    expect_stdout: "f o o"
+    node_version: ">=6"
+}
+
+await_parenthesis: {
+    input: {
+        async function f() {
+            await (a => a);
+        }
+    }
+    expect_exact: "async function f(){await(a=>a)}"
+}
+
+for_parenthesis_init: {
+    input: {
+        for (a => (a in a); console.log(42););
+    }
+    expect_exact: "for((a=>a in a);console.log(42););"
+    expect_stdout: "42"
+    node_version: ">=4"
+}
+
+for_parenthesis_condition: {
+    input: {
+        for (console.log(42); a => (a in a);)
+            break;
+    }
+    expect_exact: "for(console.log(42);a=>a in a;)break;"
+    expect_stdout: "42"
+    node_version: ">=4"
+}
+
+for_parenthesis_step: {
+    input: {
+        for (; console.log(42); a => (a in a));
+    }
+    expect_exact: "for(;console.log(42);a=>a in a);"
+    expect_stdout: "42"
+    node_version: ">=4"
+}
+
+for_assign_parenthesis_init: {
+    input: {
+        for (f = a => (a in a); console.log(42););
+    }
+    expect_exact: "for((f=a=>a in a);console.log(42););"
+    expect_stdout: "42"
+    node_version: ">=4"
+}
+
+for_assign_parenthesis_condition: {
+    input: {
+        for (console.log(42); f = a => (a in a);)
+            break;
+    }
+    expect_exact: "for(console.log(42);f=a=>a in a;)break;"
+    expect_stdout: "42"
+    node_version: ">=4"
+}
+
+for_assign_parenthesis_step: {
+    input: {
+        for (; console.log(42); f = a => (a in a));
+    }
+    expect_exact: "for(;console.log(42);f=a=>a in a);"
+    expect_stdout: "42"
+    node_version: ">=4"
+}
+
+for_declaration_parenthesis_init: {
+    input: {
+        for (var f = a => (a in a); console.log(42););
+    }
+    expect_exact: "for(var f=(a=>a in a);console.log(42););"
+    expect_stdout: "42"
+    node_version: ">=4"
+}
+
+for_statement_parenthesis_init: {
+    input: {
+        for (a => {
+            a in a;
+        }; console.log(42););
+    }
+    expect_exact: "for(a=>{a in a};console.log(42););"
+    expect_stdout: "42"
+    node_version: ">=4"
+}
+
+body_call: {
+    input: {
+        (() => {
+            console.log("foo");
+            console.log("bar");
+        })();
+    }
+    expect_exact: '(()=>{console.log("foo");console.log("bar")})();'
+    expect_stdout: [
+        "foo",
+        "bar",
+    ]
+    node_version: ">=4"
+}
+
+body_conditional: {
+    input: {
+        console.log((a => {}) ? "PASS" : "FAIL");
+    }
+    expect_exact: 'console.log((a=>{})?"PASS":"FAIL");'
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+destructured_object_value: {
+    input: {
+        console.log((a => ({} = a))(42));
+    }
+    expect_exact: "console.log((a=>({}=a))(42));"
+    expect_stdout: "42"
+    node_version: ">=6"
+}
+
+function_value: {
+    input: {
+        console.log((a => function() {
+            return a;
+        })(42)());
+    }
+    expect_exact: "console.log((a=>function(){return a})(42)());"
+    expect_stdout: "42"
+    node_version: ">=4"
+}
+
+in_value: {
+    input: {
+        console.log((a => a in {
+            foo: 42,
+        })("foo"));
+    }
+    expect_exact: 'console.log((a=>a in{foo:42})("foo"));'
+    expect_stdout: "true"
+    node_version: ">=4"
+}
+
+object_value: {
+    input: {
+        console.log((() => ({
+            4: 2,
+        }))()[4]);
+    }
+    expect_exact: "console.log((()=>({4:2}))()[4]);"
+    expect_stdout: "2"
+    node_version: ">=4"
+}
+
+object_first_in_value: {
+    input: {
+        console.log((a => ({
+            p: a,
+        }.p ? "FAIL" : "PASS"))());
+    }
+    expect_exact: 'console.log((a=>({p:a}).p?"FAIL":"PASS")());'
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+sequence_value: {
+    input: {
+        console.log((a => (console.log("foo"), a))("bar"));
+    }
+    expect_exact: 'console.log((a=>(console.log("foo"),a))("bar"));'
+    expect_stdout: [
+        "foo",
+        "bar",
+    ]
+    node_version: ">=4"
+}
+
+side_effects_value: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        console.log((a => function() {
+            return a;
+        })(42)());
+    }
+    expect: {
+        console.log((a => function() {
+            return a;
+        })(42)());
+    }
+    expect_stdout: "42"
+    node_version: ">=4"
+}
+
+arrow_property: {
+    input: {
+        console.log((a => 42).prototype);
+    }
+    expect_exact: "console.log((a=>42).prototype);"
+    expect_stdout: "undefined"
+    node_version: ">=4"
+}
+
+assign_arrow: {
+    input: {
+        var f = a => a;
+        console.log(f(42));
+    }
+    expect_exact: "var f=a=>a;console.log(f(42));"
+    expect_stdout: "42"
+    node_version: ">=4"
+}
+
+binary_arrow: {
+    input: {
+        console.log(4 || (() => 2));
+    }
+    expect_exact: "console.log(4||(()=>2));"
+    expect_stdout: "4"
+    node_version: ">=4"
+}
+
+unary_arrow: {
+    input: {
+        console.log(+(() => 42));
+    }
+    expect_exact: "console.log(+(()=>42));"
+    expect_stdout: "NaN"
+    node_version: ">=4"
+}
+
+trailing_comma: {
+    input: {
+        ((a,) => console.log(a))(42);
+    }
+    expect_exact: "(a=>console.log(a))(42);"
+    expect_stdout: "42"
+    node_version: ">=4"
+}
+
+drop_arguments: {
+    options = {
+        arguments: true,
+        keep_fargs: false,
+    }
+    input: {
+        console.log(function() {
+            return () => arguments[0];
+        }("PASS")("FAIL"));
+    }
+    expect: {
+        console.log(function(argument_0) {
+            return () => argument_0;
+        }("PASS")("FAIL"));
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+funarg_arguments: {
+    options = {
+        inline: true,
+    }
+    input: {
+        console.log((arguments => arguments)(42));
+    }
+    expect: {
+        console.log(42);
+    }
+    expect_stdout: "42"
+    node_version: ">=4"
+}
+
+inline_arguments: {
+    options = {
+        inline: true,
+    }
+    input: {
+        console.log(function() {
+            return () => arguments[0];
+        }("PASS")("FAIL"));
+    }
+    expect: {
+        console.log(function() {
+            return () => arguments[0];
+        }("PASS")("FAIL"));
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+var_arguments: {
+    options = {
+        inline: true,
+        properties: true,
+        reduce_vars: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        console.log(function() {
+            return () => {
+                var arguments = [ "PASS" ];
+                return arguments;
+            };
+        }("FAIL 1")("FAIL 2")[0]);
+    }
+    expect: {
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+negate: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        if (!console ? 0 : () => 1)
+            console.log("PASS");
+    }
+    expect: {
+        (console ? () => 1 : 0) && console.log("PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+inline_this: {
+    options = {
+        inline: true,
+    }
+    input: {
+        var o = {
+            p: function() {
+                return function() {
+                    return () => this.q;
+                }();
+            },
+            q: "FAIL",
+        };
+        q = "PASS";
+        console.log(o.p()());
+    }
+    expect: {
+        var o = {
+            p: function() {
+                return function() {
+                    return () => this.q;
+                }();
+            },
+            q: "FAIL",
+        };
+        q = "PASS";
+        console.log(o.p()());
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+trim_body: {
+    options = {
+        arrows: true,
+        if_return: true,
+        side_effects: true,
+    }
+    input: {
+        var f = a => {
+            return a;
+        };
+        var g = b => void b;
+        console.log(f("PASS"), g("FAIL"));
+    }
+    expect: {
+        var f = a => a;
+        var g = b => {};
+        console.log(f("PASS"), g("FAIL"));
+    }
+    expect_stdout: "PASS undefined"
+    node_version: ">=4"
+}
+
+collapse_value: {
+    options = {
+        arrows: true,
+        collapse_vars: true,
+        keep_fargs: false,
+        unused: true,
+    }
+    input: {
+        var a = 42;
+        console.log((b => Math.floor(b))(a));
+    }
+    expect: {
+        var a = 42;
+        console.log((() => Math.floor(a))());
+    }
+    expect_stdout: "42"
+    node_version: ">=4"
+}
+
+collapse_property_lambda: {
+    options = {
+        collapse_vars: true,
+        pure_getters: "strict",
+    }
+    input: {
+        console.log(function f() {
+            f.g = () => 42;
+            return f.g();
+        }());
+    }
+    expect: {
+        console.log(function f() {
+            return (f.g = () => 42)();
+        }());
+    }
+    expect_stdout: "42"
+    node_version: ">=4"
+}
+
+drop_return: {
+    options = {
+        arrows: true,
+        side_effects: true,
+    }
+    input: {
+        (a => {
+            while (!console);
+            return console.log(a);
+        })(42);
+    }
+    expect: {
+        (a => {
+            while (!console);
+            console.log(a);
+        })(42);
+    }
+    expect_stdout: "42"
+    node_version: ">=4"
+}
+
+drop_value: {
+    options = {
+        arrows: true,
+        side_effects: true,
+    }
+    input: {
+        ((a, b) => a + b)(console.log(42));
+    }
+    expect: {
+        ((a, b) => {})(console.log(42));
+    }
+    expect_stdout: "42"
+    node_version: ">=4"
+}
+
+reduce_iife_1: {
+    options = {
+        evaluate: true,
+        keep_fargs: false,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        (a => console.log(a + a))(21);
+    }
+    expect: {
+        (() => console.log(42))();
+    }
+    expect_stdout: "42"
+    node_version: ">=4"
+}
+
+reduce_iife_2: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = 21;
+        (() => console.log(a + a))();
+    }
+    expect: {
+        (() => console.log(42))();
+    }
+    expect_stdout: "42"
+    node_version: ">=4"
+}
+
+reduce_iife_3: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = "foo";
+        (() => {
+            console.log(a);
+            console.log(a);
+        })();
+        a = "bar";
+    }
+    expect: {
+        (() => {
+            console.log("foo");
+            console.log("foo");
+        })();
+    }
+    expect_stdout: [
+        "foo",
+        "foo",
+    ]
+    node_version: ">=4"
+}
+
+single_use_recursive: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            return (() => f)();
+        }
+        console.log(typeof f());
+    }
+    expect: {
+        console.log(typeof function f() {
+            return (() => f)();
+        }());
+    }
+    expect_stdout: "function"
+    node_version: ">=4"
+}
+
+issue_4388: {
+    options = {
+        inline: true,
+        toplevel: true,
+    }
+    input: {
+        (arguments => console.log(arguments && arguments))();
+    }
+    expect: {
+        (arguments => console.log(arguments && arguments))();
+    }
+    expect_stdout: "undefined"
+    node_version: ">=4"
+}
+
+issue_4390: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        function log() {
+            console.log.apply(console, arguments);
+        }
+        var a = 42, b = "FAIL";
+        b = "PASS";
+        (c => log(b, c))(a);
+        log(b);
+    }
+    expect: {
+        function log() {
+            console.log.apply(console, arguments);
+        }
+        var a = 42, b = "FAIL";
+        b = "PASS";
+        (c => log(b, c))(a);
+        log(b);
+    }
+    expect_stdout: [
+        "PASS 42",
+        "PASS",
+    ]
+    node_version: ">=4"
+}
+
+issue_4401: {
+    options = {
+        merge_vars: true,
+    }
+    input: {
+        (function() {
+            var a = (b => b(a))(console.log || a);
+            var c = console.log;
+            c && c(typeof b);
+        })();
+    }
+    expect: {
+        (function() {
+            var a = (b => b(a))(console.log || a);
+            var c = console.log;
+            c && c(typeof b);
+        })();
+    }
+    expect_stdout: [
+        "undefined",
+        "undefined",
+    ]
+    node_version: ">=4"
+}
+
+issue_4448: {
+    options = {
+        pure_getters: "strict",
+        side_effects: true,
+    }
+    input: {
+        var A;
+        try {
+            (arguments => {
+                arguments[0];
+            })(A);
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect: {
+        var A;
+        try {
+            (arguments => {
+                arguments[0];
+            })(A);
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_4476: {
+    options = {
+        arguments: true,
+    }
+    input: {
+        (function(a, b) {
+            (a => {
+                console.log(arguments[0], a);
+            })(b);
+        })("foo", "bar");
+    }
+    expect: {
+        (function(a, b) {
+            (a => {
+                console.log(arguments[0], a);
+            })(b);
+        })("foo", "bar");
+    }
+    expect_stdout: "foo bar"
+    node_version: ">=4"
+}

test/compress/ascii.js

@@ -1,35 +0,0 @@
-ascii_only_true: {
-    options = {}
-    beautify = {
-        ascii_only : true,
-        ie8        : false,
-        beautify   : false,
-    }
-    input: {
-        function f() {
-            return "\x000\x001\x007\x008\x00" +
-                   "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f" +
-                   "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f" +
-                   "\x20\x21\x22\x23 ... \x7d\x7e\x7f\x80\x81 ... \xfe\xff\u0fff\uffff";
-        }
-    }
-    expect_exact: 'function f(){return"\\x000\\x001\\x007\\x008\\0"+"\\0\\x01\\x02\\x03\\x04\\x05\\x06\\x07\\b\\t\\n\\v\\f\\r\\x0e\\x0f"+"\\x10\\x11\\x12\\x13\\x14\\x15\\x16\\x17\\x18\\x19\\x1a\\x1b\\x1c\\x1d\\x1e\\x1f"+\' !"# ... }~\\x7f\\x80\\x81 ... \\xfe\\xff\\u0fff\\uffff\'}'
-}
-
-ascii_only_false: {
-    options = {}
-    beautify = {
-        ascii_only : false,
-        ie8        : false,
-        beautify   : false,
-    }
-    input: {
-        function f() {
-            return "\x000\x001\x007\x008\x00" +
-                   "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f" +
-                   "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f" +
-                   "\x20\x21\x22\x23 ... \x7d\x7e\x7f\x80\x81 ... \xfe\xff\u0fff\uffff";
-        }
-    }
-    expect_exact: 'function f(){return"\\x000\\x001\\x007\\x008\\0"+"\\0\x01\x02\x03\x04\x05\x06\x07\\b\\t\\n\\v\\f\\r\x0e\x0f"+"\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f"+\' !"# ... }~\x7f\x80\x81 ... \xfe\xff\u0fff\uffff\'}'
-}

test/compress/asm.js

@@ -76,9 +76,8 @@ asm_mixed: {
                 start = start | 0;
                 end = end | 0;
                 var sum = 0.0, p = 0, q = 0;
-                for (p = start << 3, q = end << 3; (p | 0) < (q | 0); p = p + 8 | 0) {
+                for (p = start << 3, q = end << 3; (p | 0) < (q | 0); p = p + 8 | 0)
                     sum = sum + +log(values[p >> 3]);
-                }
                 return +sum;
             }
             function geometricMean(start, end) {
@@ -91,11 +90,12 @@ asm_mixed: {
         function no_asm_GeometricMean(stdlib, foreign, buffer) {
             function logSum(start, end) {
                 start |= 0, end |= 0;
-                for (var sum = 0, p = 0, q = 0, p = start << 3, q = end << 3; (0 | p) < (0 | q); p = p + 8 | 0) sum += +log(values[p >> 3]);
+                for (var sum = 0, p = 0, q = 0, p = start << 3, q = end << 3; (0 | p) < (0 | q); p = p + 8 | 0)
+                    sum += +log(values[p >> 3]);
                 return +sum;
             }
             function geometricMean(start, end) {
-                return start |= 0, end |= 0, +exp(logSum(start, end) / (end - start | 0));
+                return start |= 0, end |= 0, +exp(+logSum(start, end) / (end - start | 0));
             }
             var exp = stdlib.Math.exp, log = stdlib.Math.log, values = new stdlib.Float64Array(buffer);
             return { geometricMean: geometricMean };

test/compress/assignments.js

@@ -461,3 +461,17 @@ issue_3949_2: {
     }
     expect_stdout: "100"
 }
+
+issue_4521: {
+    options = {
+        assignments: true,
+        dead_code: true,
+    }
+    input: {
+        var a = (a = 42 | a) ? console.log(a) : 0;
+    }
+    expect: {
+        var a = (a |= 42) ? console.log(a) : 0;
+    }
+    expect_stdout: "42"
+}

test/compress/bigint.js

@@ -0,0 +1,62 @@
+arithmetic: {
+    input: {
+        console.log(((1n + 0x2n) * (0o3n - -4n)) >> (5n - 6n));
+    }
+    expect_exact: "console.log((1n+0x2n)*(0o3n- -4n)>>5n-6n);"
+    expect_stdout: "42n"
+    node_version: ">=10"
+}
+
+minus_dot: {
+    input: {
+        console.log(typeof -42n.toString(), typeof (-42n).toString());
+    }
+    expect_exact: "console.log(typeof-42n.toString(),typeof(-42n).toString());"
+    expect_stdout: "number string"
+    node_version: ">=10"
+}
+
+evaluate: {
+    options = {
+        evaluate: true,
+        unsafe: true,
+    }
+    input: {
+        console.log((0xDEAD_BEEFn).toString(16));
+    }
+    expect: {
+        console.log(0xdeadbeefn.toString(16));
+    }
+    expect_stdout: "deadbeef"
+    node_version: ">=10"
+}
+
+Number: {
+    options = {
+        unsafe: true,
+    }
+    input: {
+        console.log(Number(-0xfeed_dead_beef_badn));
+    }
+    expect: {
+        console.log(+("" + -0xfeed_dead_beef_badn));
+    }
+    expect_stdout: "-1148098955808013200"
+    node_version: ">=10"
+}
+
+issue_4590: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        A = 1;
+        0n || console.log("PASS");
+    }
+    expect: {
+        A = 1;
+        0n || console.log("PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=10"
+}

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/collapse_vars.js

@@ -62,18 +62,18 @@ collapse_vars_side_effects_1: {
     expect: {
         function f1() {
             var s = "abcdef", i = 2;
-            console.log.bind(console)(s.charAt(i++), s.charAt(i++), s.charAt(4), 7);
+            console.log.bind(console)(s.charAt(i++), s.charAt(+i), s.charAt(4), 7);
         }
         function f2() {
             var s = "abcdef", i = 2;
-            console.log.bind(console)(s.charAt(i++), 5, s.charAt(i++), s.charAt(i++), 7);
+            console.log.bind(console)(s.charAt(i++), 5, s.charAt(i++), s.charAt(+i), 7);
         }
         function f3() {
             var s = "abcdef",
                 i = 2,
                 log = console.log.bind(console),
                 x = s.charAt(i++),
-                y = s.charAt(i++);
+                y = s.charAt(+i);
             log(x, s.charAt(4), y, 7);
         }
         function f4() {
@@ -346,9 +346,8 @@ collapse_vars_if: {
             return "x" != "Bar" + x / 4 ? g9 : g5;
         }
         function f3(x) {
-            if (x) {
+            if (x)
                 return 1;
-            }
             return 2;
         }
     }
@@ -1599,7 +1598,7 @@ collapse_vars_constants: {
     }
 }
 
-collapse_vars_arguments: {
+collapse_vars_arguments_1: {
     options = {
         booleans: true,
         collapse_vars: true,
@@ -1636,6 +1635,78 @@ collapse_vars_arguments: {
     expect_stdout: true
 }
 
+collapse_vars_arguments_2: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        function log(a, b) {
+            console.log(b);
+        }
+        function f(c) {
+            var d = arguments[0];
+            c = "FAIL";
+            log(c, d);
+        }
+        f();
+        f("PASS");
+    }
+    expect: {
+        function log(a, b) {
+            console.log(b);
+        }
+        function f(c) {
+            var d = arguments[0];
+            log(c = "FAIL", d);
+        }
+        f();
+        f("PASS");
+    }
+    expect_stdout: [
+        "undefined",
+        "PASS",
+    ]
+}
+
+collapse_vars_arguments_3: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        function log(a, b) {
+            console.log(b);
+        }
+        function f(c) {
+            var args = arguments;
+            console.log(c);
+            var d = args[0];
+            c = "FAIL";
+            log(c, d);
+        }
+        f();
+        f("PASS");
+    }
+    expect: {
+        function log(a, b) {
+            console.log(b);
+        }
+        function f(c) {
+            var args = arguments;
+            console.log(c);
+            var d = args[0];
+            log(c = "FAIL", d);
+        }
+        f();
+        f("PASS");
+    }
+    expect_stdout: [
+        "undefined",
+        "undefined",
+        "PASS",
+        "PASS",
+    ]
+}
+
 collapse_vars_short_circuit: {
     options = {
         booleans: true,
@@ -3001,7 +3072,6 @@ issue_2298: {
     expect: {
         !function() {
             (function() {
-                0;
                 try {
                     !function(b) {
                         (void 0)[1] = "foo";
@@ -3075,8 +3145,8 @@ issue_2313_2: {
         var c = 0;
         !function a() {
             a && c++;
-            var a = 0;
-            a && c++;
+            var a;
+            (a = 0) && c++;
         }();
         console.log(c);
     }
@@ -4121,9 +4191,8 @@ issue_2436_11: {
             if (isCollection(arg1)) {
                 var size = arg1, max = arg2, min = 0, res = _randomDataForMatrix(size.valueOf(), min, max, _randomInt);
                 return size && true === size.isMatrix ? matrix(res) : res;
-            } else {
+            } else
                 return _randomInt(min = arg1, max = arg2);
-            }
         }
     }
 }
@@ -4204,8 +4273,8 @@ issue_2436_14: {
         var b = {};
         (function() {
             a && function(c, d) {
-                console.log(c, d);
-            }(b, a);
+                console.log(b, d);
+            }(0, a);
         })();
     }
     expect_stdout: true
@@ -4239,9 +4308,8 @@ issue_2497: {
         function sample() {
             if (true)
                 for (var i = 0; i < 1; ++i)
-                    for (var k = 0; k < 1; ++k) {
+                    for (var k = 0; k < 1; ++k)
                         value = (value = 1) ? value + 1 : 0;
-                    }
             else
                 for (i = 0; i < 1; ++i)
                     for (k = 0; k < 1; ++k)
@@ -5434,8 +5502,7 @@ collapse_rhs_lhs_2: {
     expect: {
         var b = 1;
         (function f(f) {
-            f = b;
-            f[b] = 0;
+            b[b] = 0;
         })();
         console.log("PASS");
     }
@@ -5541,6 +5608,7 @@ collapse_rhs_array: {
 collapse_rhs_boolean_1: {
     options = {
         collapse_vars: true,
+        evaluate: true,
     }
     input: {
         var a, b;
@@ -5566,6 +5634,7 @@ collapse_rhs_boolean_1: {
 collapse_rhs_boolean_2: {
     options = {
         collapse_vars: true,
+        evaluate: true,
     }
     input: {
         var a;
@@ -5600,6 +5669,7 @@ collapse_rhs_boolean_3: {
         booleans: true,
         collapse_vars: true,
         conditionals: true,
+        evaluate: true,
     }
     input: {
         var a, f, g, h, i, n, s, t, x, y;
@@ -5653,6 +5723,7 @@ collapse_rhs_function: {
 collapse_rhs_number: {
     options = {
         collapse_vars: true,
+        evaluate: true,
     }
     input: {
         var a, b;
@@ -5732,6 +5803,7 @@ collapse_rhs_regexp: {
 collapse_rhs_string: {
     options = {
         collapse_vars: true,
+        evaluate: true,
     }
     input: {
         var a, b;
@@ -5807,6 +5879,7 @@ collapse_rhs_this: {
 collapse_rhs_undefined: {
     options = {
         collapse_vars: true,
+        side_effects: true,
     }
     input: {
         var a, b;
@@ -5928,7 +6001,7 @@ issue_3215_1: {
         }());
     }
     expect: {
-        console.log(typeof 42);
+        console.log("number");
     }
     expect_stdout: "number"
 }
@@ -8280,3 +8353,406 @@ issue_3976: {
     }
     expect_stdout: "PASS"
 }
+
+issue_4012: {
+    options = {
+        collapse_vars: true,
+        dead_code: true,
+        evaluate: true,
+    }
+    input: {
+        (function(a) {
+            try {
+                throw 2;
+            } catch (b) {
+                a = "PASS";
+                if (--b)
+                    return;
+                if (3);
+            } finally {
+                console.log(a);
+            }
+        })();
+    }
+    expect: {
+        (function(a) {
+            try {
+                throw 2;
+            } catch (b) {
+                a = "PASS";
+                if (--b)
+                    return;
+                if (3);
+            } finally {
+                console.log(a);
+            }
+        })();
+    }
+    expect_stdout: "PASS"
+}
+
+global_assign: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        this.A = "FAIL";
+        A = "PASS";
+        B = "FAIL";
+        console.log(A);
+    }
+    expect: {
+        this.A = "FAIL";
+        A = "PASS";
+        B = "FAIL";
+        console.log(A);
+    }
+    expect_stdout: "PASS"
+}
+
+global_read: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var a = 0;
+        a = this.A;
+        A = 1;
+        a ? console.log("FAIL") : console.log("PASS");
+    }
+    expect: {
+        var a = 0;
+        a = this.A;
+        A = 1;
+        a ? console.log("FAIL") : console.log("PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4038: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var a = 0;
+        a = this;
+        a = a.A;
+        A = 1;
+        a ? console.log("FAIL") : console.log("PASS");
+    }
+    expect: {
+        var a = 0;
+        a = (a = this).A;
+        A = 1;
+        a ? console.log("FAIL") : console.log("PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4040: {
+    options = {
+        collapse_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var a = console.log("PASS") && a.p;
+        delete NaN;
+    }
+    expect: {
+        var a = console.log("PASS") && a.p;
+        delete NaN;
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4047_1: {
+    options = {
+        collapse_vars: true,
+        evaluate: true,
+        inline: true,
+        reduce_vars: true,
+        sequences: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var b = 1;
+        console.log(+function(a) {
+            b = a;
+            (a >>= 0) && console.log("PASS");
+        }(--b + (0 !== typeof A)));
+    }
+    expect: {
+        var b = 1;
+        var a;
+        console.log((a = --b + ((a = 0) !== typeof A), +void ((a >>= 0) && console.log("PASS"))));
+    }
+    expect_stdout: [
+        "PASS",
+        "NaN",
+    ]
+}
+
+issue_4047_2: {
+    options = {
+        collapse_vars: true,
+        evaluate: true,
+        inline: true,
+        passes: 2,
+        reduce_vars: true,
+        sequences: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var b = 1;
+        console.log(+function(a) {
+            b = a;
+            (a >>= 0) && console.log("PASS");
+        }(--b + (0 !== typeof A)));
+    }
+    expect: {
+        var a;
+        console.log((a = +(0 !== typeof A), +void ((a >>= 0) && console.log("PASS"))));
+    }
+    expect_stdout: [
+        "PASS",
+        "NaN",
+    ]
+}
+
+issue_4051: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        try {
+            var a = (b = b.p, "FAIL"), b = b;
+        } catch (e) {}
+        console.log(a);
+    }
+    expect: {
+        try {
+            var a = (b = b.p, "FAIL"), b = b;
+        } catch (e) {}
+        console.log(a);
+    }
+    expect_stdout: "undefined"
+}
+
+issue_4070: {
+    options = {
+        collapse_vars: true,
+        pure_getters: "strict",
+        reduce_vars: true,
+    }
+    input: {
+        console.log(function f() {
+            function g() {}
+            g.p++;
+            return f.p = g.p;
+        }());
+    }
+    expect: {
+        console.log(function f() {
+            function g() {}
+            return f.p = ++g.p;
+        }());
+    }
+    expect_stdout: "NaN"
+}
+
+issue_4242: {
+    options = {
+        collapse_vars: true,
+        conditionals: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        console.log(function() {
+            if (console)
+                var a = function(){}, b = (!1 === console || a)();
+        }());
+    }
+    expect: {
+        console.log(function() {
+            console && (!1 === console || function(){})();
+        }());
+    }
+    expect_stdout: "undefined"
+}
+
+issue_4248: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var a = 0;
+        try {
+            a = 1;
+            b[1];
+        } catch (e) {
+            console.log(a);
+        }
+    }
+    expect: {
+        var a = 0;
+        try {
+            a = 1;
+            b[1];
+        } catch (e) {
+            console.log(a);
+        }
+    }
+    expect_stdout: "1"
+}
+
+issue_4430_1: {
+    options = {
+        collapse_vars: true,
+        pure_getters: "strict",
+    }
+    input: {
+        function f(a) {
+            switch (a = 1, arguments[0]) {
+              case 1:
+                return "PASS";
+              case 2:
+                return "FAIL";
+            }
+        }
+        console.log(f(2));
+    }
+    expect: {
+        function f(a) {
+            switch (a = 1, arguments[0]) {
+              case 1:
+                return "PASS";
+              case 2:
+                return "FAIL";
+            }
+        }
+        console.log(f(2));
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4430_2: {
+    options = {
+        collapse_vars: true,
+        pure_getters: "strict",
+    }
+    input: {
+        function f(a) {
+            switch (a = 0, arguments[0]) {
+              case 0:
+                return "PASS";
+              case 1:
+                return "FAIL";
+            }
+        }
+        console.log(f(1));
+    }
+    expect: {
+        function f(a) {
+            switch (arguments[a = 0]) {
+              case 0:
+                return "PASS";
+              case 1:
+                return "FAIL";
+            }
+        }
+        console.log(f(1));
+    }
+    expect_stdout: "PASS"
+}
+
+collapse_and_assign: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var log = console.log;
+        var a = {
+            p: "PASS",
+        };
+        console && (a = a.p);
+        log(a);
+    }
+    expect: {
+        var log = console.log;
+        var a = {
+            p: "PASS",
+        };
+        log(a = console ? a.p : a);
+    }
+    expect_stdout: "PASS"
+}
+
+collapse_or_assign: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var log = console.log;
+        var a = {
+            p: "PASS",
+        };
+        a.q || (a = a.p);
+        log(a);
+    }
+    expect: {
+        var log = console.log;
+        var a = {
+            p: "PASS",
+        };
+        log(a = !a.q ? a.p : a);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4586_1: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var a = 42;
+        (function f(b) {
+            var b = a;
+            if (b === arguments[0])
+                console.log("PASS");
+        })(console);
+    }
+    expect: {
+        var a = 42;
+        (function f(b) {
+            var b = a;
+            if (b === arguments[0])
+                console.log("PASS");
+        })(console);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4586_2: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var a = 42;
+        (function f(b) {
+            b = a;
+            if (b === arguments[0])
+                console.log("PASS");
+        })(console);
+    }
+    expect: {
+        var a = 42;
+        (function f(b) {
+            if ((b = a) === arguments[0])
+                console.log("PASS");
+        })(console);
+    }
+    expect_stdout: "PASS"
+}

test/compress/comparisons.js

@@ -123,6 +123,29 @@ self_comparison_3: {
     ]
 }
 
+self_comparison_4: {
+    options = {
+        booleans: true,
+        comparisons: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var o = {};
+        console.log(o == o, o != o);
+        console.log(o === o, o !== o);
+    }
+    expect: {
+        console.log(!0, !1);
+        console.log(!0, !1);
+    }
+    expect_stdout: [
+        "true false",
+        "true false",
+    ]
+}
+
 issue_2857_1: {
     options = {
         comparisons: true,

test/compress/concat-strings.js

@@ -238,6 +238,41 @@ concat_8: {
     expect_stdout: true
 }
 
+concat_9: {
+    options = {
+        booleans: true,
+        evaluate: true,
+        reduce_vars: true,
+        strings: true,
+        toplevel: true,
+    }
+    input: {
+        var a = "foo";
+        console.log(
+            12 + (34 + a),
+            null + (34 + a),
+            12 + (null + a),
+            false + (34 + a),
+            12 + (false + a),
+            "bar" + (34 + a),
+            12 + ("bar" + a)
+        );
+    }
+    expect: {
+        var a = "foo";
+        console.log(
+            "1234" + a,
+            "null34" + a,
+            "12null" + a,
+            !1 + (34 + a),
+            12 + (!1 + a),
+            "bar34" + a,
+            "12bar" + a
+        );
+    }
+    expect_stdout: true
+}
+
 issue_3689: {
     options = {
         strings: true,

test/compress/conditionals.js

@@ -55,14 +55,15 @@ ifs_3_should_warn: {
     }
     input: {
         var x, y;
-        if (x && !(x + "1") && y) { // 1
+        // 1
+        if (x && !(x + "1") && y) {
             var qq;
             foo();
         } else {
             bar();
         }
-
-        if (x || !!(x + "1") || y) { // 2
+        // 2
+        if (x || !!(x + "1") || y) {
             foo();
         } else {
             var jj;
@@ -71,9 +72,25 @@ ifs_3_should_warn: {
     }
     expect: {
         var x, y;
-        var qq; bar();          // 1
-        var jj; foo();          // 2
+        // 1
+        var qq; bar();
+        // 2
+        foo(); var jj;
     }
+    expect_warnings: [
+        "WARN: + in boolean context always true [test/compress/conditionals.js:3,18]",
+        "WARN: Boolean && always false [test/compress/conditionals.js:3,12]",
+        "WARN: Condition left of && always false [test/compress/conditionals.js:3,12]",
+        "WARN: Condition always false [test/compress/conditionals.js:3,12]",
+        "WARN: Dropping unreachable code [test/compress/conditionals.js:3,34]",
+        "WARN: + in boolean context always true [test/compress/conditionals.js:10,19]",
+        "WARN: Boolean || always true [test/compress/conditionals.js:10,12]",
+        "WARN: Condition left of || always true [test/compress/conditionals.js:10,12]",
+        "WARN: Condition always true [test/compress/conditionals.js:10,12]",
+        "WARN: Dropping unreachable code [test/compress/conditionals.js:12,15]",
+        "WARN: Dropping side-effect-free statement [test/compress/conditionals.js:3,12]",
+        "WARN: Dropping side-effect-free statement [test/compress/conditionals.js:10,12]",
+    ]
 }
 
 ifs_4: {
@@ -783,6 +800,28 @@ cond_12: {
     }
 }
 
+cond_13: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        x ? y(a) : z(a);
+        x ? y.f(a) : z.f(a);
+        x ? y.f(a) : z.g(a);
+        x ? y.f()(a) : z.g()(a);
+        x ? y.f.u(a) : z.g.u(a);
+        x ? y.f().u(a) : z.g().u(a);
+    }
+    expect: {
+        (x ? y : z)(a);
+        (x ? y : z).f(a);
+        x ? y.f(a) : z.g(a);
+        (x ? y.f() : z.g())(a);
+        (x ? y.f : z.g).u(a);
+        (x ? y.f() : z.g()).u(a);
+    }
+}
+
 ternary_boolean_consequent: {
     options = {
         booleans: true,
@@ -1137,7 +1176,7 @@ issue_1645_2: {
     expect_stdout: true
 }
 
-condition_symbol_matches_consequent: {
+condition_matches_consequent: {
     options = {
         conditionals: true,
     }
@@ -1166,6 +1205,35 @@ condition_symbol_matches_consequent: {
     expect_stdout: "3 7 true 4"
 }
 
+condition_matches_alternative: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        function foo(x, y) {
+            return x.p ? y[0] : x.p;
+        }
+        function bar() {
+            return g ? h : g;
+        }
+        var g = 4;
+        var h = 5;
+        console.log(foo({ p: 3 }, [ null ]), foo({ p: 0 }, [ 7 ]), foo({ p: true } , [ false ]), bar());
+    }
+    expect: {
+        function foo(x, y) {
+            return x.p && y[0];
+        }
+        function bar() {
+            return g && h;
+        }
+        var g = 4;
+        var h = 5;
+        console.log(foo({ p: 3 }, [ null ]), foo({ p: 0 }, [ 7 ]), foo({ p: true } , [ false ]), bar());
+    }
+    expect_stdout: "null 0 false 5"
+}
+
 delete_conditional_1: {
     options = {
         booleans: true,

test/compress/dead-code.js

@@ -59,6 +59,9 @@ dead_code_2_should_warn: {
         f();
     }
     expect_stdout: true
+    expect_warnings: [
+        "WARN: Dropping unreachable code [test/compress/dead-code.js:8,12]",
+    ]
     node_version: "<=4"
 }
 
@@ -89,11 +92,21 @@ dead_code_constant_boolean_should_warn_more: {
         function bar() {}
         // nothing for the while
         // as for the for, it should keep:
-        var moo;
         var x = 10, y;
+        var moo;
         bar();
     }
     expect_stdout: true
+    expect_warnings: [
+        "WARN: + in boolean context always true [test/compress/dead-code.js:1,33]",
+        "WARN: Boolean || always true [test/compress/dead-code.js:1,16]",
+        "WARN: Dropping unreachable code [test/compress/dead-code.js:1,45]",
+        "WARN: Boolean expression always true [test/compress/dead-code.js:6,47]",
+        "WARN: Boolean && always false [test/compress/dead-code.js:6,28]",
+        "WARN: Dropping unreachable code [test/compress/dead-code.js:6,63]",
+        "WARN: Dropping side-effect-free statement [test/compress/dead-code.js:1,15]",
+        "WARN: Dropping side-effect-free statement [test/compress/dead-code.js:6,28]",
+    ]
     node_version: "<=4"
 }
 
@@ -712,7 +725,7 @@ issue_2749: {
     expect: {
         var a = 2, c = "PASS";
         while (a--)
-            b = void 0, b ? c = "FAIL" : b = 1;
+            b = void 0, b ? c = "FAIL" : 1;
         var b;
         console.log(c);
     }
@@ -1341,3 +1354,66 @@ issue_3967: {
     }
     expect_stdout: "PASS"
 }
+
+issue_4051: {
+    options = {
+        dead_code: true,
+    }
+    input: {
+        try {
+            delete (A = A);
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect: {
+        try {
+            delete (A = A);
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    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"
+}
+
+issue_4570: {
+    options = {
+        dead_code: true,
+        inline: true,
+    }
+    input: {
+        var a = function(b) {
+            return a += b;
+        }() ? 0 : a;
+        console.log(a);
+    }
+    expect: {
+        var a = (a += void 0) ? 0 : a;
+        console.log(a);
+    }
+    expect_stdout: "NaN"
+}

test/compress/drop-unused.js

@@ -4,15 +4,16 @@ unused_funarg_1: {
         unused: true,
     }
     input: {
-        function f(a, b, c, d, e) {
+        console.log(function f(a, b, c, d, e) {
             return a + b;
-        }
+        }(14, 28));
     }
     expect: {
-        function f(a, b) {
+        console.log(function(a, b) {
             return a + b;
-        }
+        }(14, 28));
     }
+    expect_stdout: "42"
 }
 
 unused_funarg_2: {
@@ -21,15 +22,16 @@ unused_funarg_2: {
         unused: true,
     }
     input: {
-        function f(a, b, c, d, e) {
+        console.log(function f(a, b, c, d, e) {
             return a + c;
-        }
+        }(14, 21, 28));
     }
     expect: {
-        function f(a, b, c) {
+        console.log(function(a, c) {
             return a + c;
-        }
+        }(14, 28));
     }
+    expect_stdout: "42"
 }
 
 unused_nested_function: {
@@ -357,37 +359,6 @@ drop_toplevel_vars: {
     }
 }
 
-drop_toplevel_vars_fargs: {
-    options = {
-        keep_fargs: false,
-        toplevel: "vars",
-        unused: true,
-    }
-    input: {
-        var a, b = 1, c = g;
-        function f(d) {
-            return function() {
-                c = 2;
-            };
-        }
-        a = 2;
-        function g() {}
-        function h() {}
-        console.log(b = 3);
-    }
-    expect: {
-        function f() {
-            return function() {
-                2;
-            };
-        }
-        2;
-        function g() {}
-        function h() {}
-        console.log(3);
-    }
-}
-
 drop_toplevel_all: {
     options = {
         toplevel: true,
@@ -625,13 +596,14 @@ drop_fargs: {
         unused: true,
     }
     input: {
-        function f(a) {
+        console.log(function f(a) {
             var b = a;
-        }
+        }());
     }
     expect: {
-        function f() {}
+        console.log(function() {}());
     }
+    expect_stdout: "undefined"
 }
 
 drop_fnames: {
@@ -1729,8 +1701,8 @@ chained_3: {
     }
     expect: {
         console.log(function(a, b) {
-            var c = 2;
-            b++;
+            var c = b;
+            +b;
             return c;
         }(0, 2));
     }
@@ -1997,7 +1969,7 @@ issue_3146_4: {
     expect_stdout: "PASS"
 }
 
-issue_3192: {
+issue_3192_1: {
     options = {
         unused: true,
     }
@@ -2025,6 +1997,26 @@ issue_3192: {
     ]
 }
 
+issue_3192_2: {
+    options = {
+        keep_fargs: false,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        (function(a) {
+            console.log(a = "foo", arguments[0]);
+        })("bar");
+    }
+    expect: {
+        "use strict";
+        (function() {
+            console.log("foo", arguments[0]);
+        })("bar");
+    }
+    expect_stdout: "foo bar"
+}
+
 issue_3233: {
     options = {
         pure_getters: "strict",
@@ -2146,6 +2138,7 @@ issue_3497: {
 issue_3515_1: {
     options = {
         collapse_vars: true,
+        evaluate: true,
         reduce_vars: true,
         unused: true,
     }
@@ -2161,8 +2154,7 @@ issue_3515_1: {
     expect: {
         var c = 0;
         (function() {
-            this[c++] = 0;
-            for (var key20 in !0);
+            for (var key20 in !(this[c++] = 0));
         })();
         console.log(c);
     }
@@ -2198,6 +2190,7 @@ issue_3515_2: {
 issue_3515_3: {
     options = {
         collapse_vars: true,
+        evaluate: true,
         unused: true,
     }
     input: {
@@ -2265,6 +2258,7 @@ function_assign: {
 issue_3598: {
     options = {
         collapse_vars: true,
+        evaluate: true,
         reduce_vars: true,
         unused: true,
     }
@@ -2416,7 +2410,7 @@ issue_3673: {
 
 issue_3746: {
     options = {
-        keep_fargs: "strict",
+        keep_fargs: false,
         side_effects: true,
         unused: true,
     }
@@ -2678,8 +2672,7 @@ issue_3956: {
         })();
     }
     expect: {
-        var c, d;
-        c += 0,
+        var d;
         console.log(NaN),
         d = 1 ^ console.log(1),
         console.log(d);
@@ -2694,7 +2687,7 @@ issue_3956: {
 issue_3962_1: {
     options = {
         evaluate: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         reduce_vars: true,
         toplevel: true,
         unused: true,
@@ -2712,13 +2705,13 @@ issue_3962_1: {
     }
     expect: {
         var a = 0;
-        a = (function(c) {
+        (function(c) {
             do {
                 console;
                 0..toString();
             } while (0);
             if (c) console.log("PASS");
-        })((a--, 1));
+        })(1);
         void 0;
     }
     expect_stdout: "PASS"
@@ -2726,7 +2719,7 @@ issue_3962_1: {
 
 issue_3962_2: {
     options = {
-        keep_fargs: "strict",
+        keep_fargs: false,
         reduce_vars: true,
         side_effects: true,
         toplevel: true,
@@ -2745,13 +2738,13 @@ issue_3962_2: {
     }
     expect: {
         var a = 0;
-        a = (function(c) {
+        (function(c) {
             do {
                 console;
                 0..toString();
             } while (0);
             if (c) console.log("PASS");
-        })((a--, 1));
+        })(1);
     }
     expect_stdout: "PASS"
 }
@@ -2789,3 +2782,472 @@ issue_3986: {
     }
     expect_stdout: "0"
 }
+
+issue_4017: {
+    options = {
+        pure_getters: "strict",
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        var a = 0;
+        console.log(function f() {
+            var b = c &= 0;
+            var c = a++ + (A = a);
+            var d = c && c[f];
+        }());
+    }
+    expect: {
+        var a = 0;
+        console.log(function() {
+            c &= 0;
+            var c;
+            a++,
+            A = a;
+        }());
+    }
+    expect_stdout: "undefined"
+}
+
+issue_4025: {
+    options = {
+        collapse_vars: true,
+        evaluate: true,
+        passes: 2,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = 0, b = 0, c = 0, d = a++;
+        try {
+            var e = console.log(c), f = b;
+        } finally {
+            var d = b = 1, d = c + 1;
+            c = 0;
+        }
+        console.log(a, b, d);
+    }
+    expect: {
+        var c = 0;
+        try {
+            console.log(c);
+        } finally {
+            var d = c + 1;
+            c = 0;
+        }
+        console.log(1, 1, d);
+    }
+    expect_stdout: [
+        "0",
+        "1 1 1",
+    ]
+}
+
+forin_var_1: {
+    options = {
+        unused: true,
+    }
+    input: {
+        var k;
+        for (k in [ 1, 2 ])
+            console.log(k);
+        for (k in { PASS: 3 })
+            console.log(k);
+        console.log(k);
+    }
+    expect: {
+        for (var k in [ 1, 2 ])
+            console.log(k);
+        for (k in { PASS: 3 })
+            console.log(k);
+        console.log(k);
+    }
+    expect_stdout: [
+        "0",
+        "1",
+        "PASS",
+        "PASS",
+    ]
+}
+
+forin_var_2: {
+    options = {
+        unused: true,
+    }
+    input: {
+        console.log(function() {
+            switch (0) {
+              case function() {
+                    for (a in 0);
+                }:
+                var b = 0;
+            }
+            for (var c = 0; a;);
+            var a;
+        }());
+    }
+    expect: {
+        console.log(function() {
+            switch (0) {
+              case function() {
+                    for (a in 0);
+                }:
+            }
+            for (; a;);
+            var a;
+        }());
+    }
+    expect_stdout: "undefined"
+}
+
+issue_4133: {
+    options = {
+        evaluate: true,
+        merge_vars: true,
+        pure_getters: "strict",
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = 1;
+        var b = [ a-- ], c = b && b[c];
+        console.log(a);
+    }
+    expect: {
+        var b = 1;
+        console.log(0);
+    }
+    expect_stdout: "0"
+}
+
+issue_4144: {
+    options = {
+        keep_fargs: false,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        (function(a, b) {
+            var b = console, c = ++b;
+        })(console.log("PASS"), 0);
+    }
+    expect: {
+        (function(b) {
+            b = console,
+            ++b;
+        })(console.log("PASS"));
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4146: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f(a, b) {
+            function g() {}
+            var a = g;
+            var c = b;
+            c.p;
+            console.log(typeof a);
+        }
+        f("FAIL", 42);
+    }
+    expect: {
+        (function(a, b) {
+            a = function () {};
+            var c = b;
+            c.p;
+            console.log(typeof a);
+        })(0, 42);
+    }
+    expect_stdout: "function"
+}
+
+var_catch_redefined: {
+    options = {
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = "FAIL";
+        try {
+            throw "PASS";
+        } catch (a) {
+            function f() {
+                return a;
+            }
+            console.log(a);
+        }
+        f();
+    }
+    expect: {
+        var a = "FAIL";
+        try {
+            throw "PASS";
+        } catch (a) {
+            function f() {
+                return a;
+            }
+            console.log(a);
+        }
+        f();
+    }
+    expect_stdout: "PASS"
+}
+
+single_use_catch_redefined: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = 1;
+        try {
+            throw 2;
+        } catch (a) {
+            function g() {
+                return a;
+            }
+        }
+        console.log(g());
+    }
+    expect: {
+        var a = 1;
+        try {
+            throw 2;
+        } catch (a) {
+            function g() {
+                return a;
+            }
+        }
+        console.log(g());
+    }
+    expect_stdout: true
+}
+
+issue_4184: {
+    options = {
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        (function() {
+            var a = function() {}, b = [ a, 1 && b, a = {} ];
+            try {
+                throw 42;
+            } catch (a) {
+                {
+                    console.log(a);
+                }
+            }
+        })();
+    }
+    expect: {
+        (function() {
+            var b = [ function() {}, 1 && b, {} ];
+            try {
+                throw 42;
+            } catch (a) {
+                console.log(a);
+            }
+        })();
+    }
+    expect_stdout: "42"
+}
+
+issue_4235: {
+    options = {
+        inline: true,
+        reduce_vars: true,
+        unused: true,
+        varify: true,
+    }
+    input: {
+        (function() {
+            {
+                const f = 0;
+            }
+            (function f() {
+                var f = console.log(f);
+            })();
+        })();
+    }
+    expect: {
+        (function() {
+            f = console.log(f),
+            void 0;
+            var f;
+        })();
+    }
+    expect_stdout: "undefined"
+}
+
+issue_4404: {
+    options = {
+        pure_getters: "strict",
+        unused: true,
+    }
+    input: {
+        function f(a) {
+            arguments[0] = "PASS";
+            console.log(a);
+        }
+        f("FAIL");
+    }
+    expect: {
+        function f(a) {
+            arguments[0] = "PASS";
+            console.log(a);
+        }
+        f("FAIL");
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4413: {
+    options = {
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        console.log(function f(arguments) {
+            var arguments = function() {};
+            return arguments.length;
+        }());
+    }
+    expect: {
+        console.log(function(arguments) {
+            return function() {}.length;
+        }());
+    }
+    expect_stdout: "0"
+}
+
+issue_4464_1: {
+    options = {
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        function f(a) {
+            var a = function() {};
+            return [ arguments, a ];
+        }
+        console.log(typeof f()[1]);
+    }
+    expect: {
+        function f(a) {
+            a = function() {};
+            return [ arguments, a ];
+        }
+        console.log(typeof f()[1]);
+    }
+    expect_stdout: "function"
+}
+
+issue_4464_2: {
+    options = {
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        function f(a) {
+            var a = function() {};
+            return [ arguments, a ];
+        }
+        console.log(typeof f(42)[0][0]);
+    }
+    expect: {
+        function f(a) {
+            a = function() {};
+            return [ arguments, a ];
+        }
+        console.log(typeof f(42)[0][0]);
+    }
+    expect_stdout: "function"
+}
+
+issue_4464_3: {
+    options = {
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        (function a(a) {
+            var a = function() {};
+            return [ arguments[0], a ];
+        })(42).forEach(function(b) {
+            console.log(typeof b);
+        });
+    }
+    expect: {
+        (function(a) {
+            a = function() {};
+            return [ arguments[0], a ];
+        })(42).forEach(function(b) {
+            console.log(typeof b);
+        });
+    }
+    expect_stdout: [
+        "function",
+        "function",
+    ]
+}
+
+issue_4558_1: {
+    options = {
+        evaluate: true,
+        pure_getters: true,
+        reduce_vars: true,
+        sequences: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = 0;
+        var b = 1, b = c >>>= a;
+        var c = 0;
+        b && 0[a++],
+        console.log(a);
+    }
+    expect: {
+        var a = 0;
+        var b = c >>>= a;
+        var c;
+        b && a++,
+        console.log(a);
+    }
+    expect_stdout: "0"
+}
+
+issue_4558_2: {
+    options = {
+        evaluate: true,
+        ie8: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        (function() {
+            var a = 1;
+            var b = (a = NaN) || (console.log("PASS"), 2);
+            return a;
+        })();
+    }
+    expect: {
+        (function() {
+            var a;
+            (a = NaN) || console.log("PASS");
+            return a;
+        })();
+    }
+    expect_stdout: "PASS"
+}

test/compress/evaluate.js

@@ -703,6 +703,7 @@ prototype_function: {
         var g = 0();
         var h = 0();
     }
+    expect_stdout: true
 }
 
 call_args: {
@@ -2800,7 +2801,7 @@ operator_in: {
         console.log("PASS" in { });
         console.log("FAIL" in { });
         console.log("toString" in { });
-        console.log(true);
+        console.log("toString" in { toString: 3 });
     }
     expect_stdout: [
         "true",
@@ -2833,3 +2834,345 @@ issue_3997: {
     }
     expect_stdout: "string"
 }
+
+issue_4035: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+    }
+    input: {
+        var a = 0;
+        (function() {
+            var b = --a;
+            console.log(delete (0 + b));
+            console.log(delete (1 * b));
+            console.log(delete (b + 0));
+            console.log(delete (b - 0));
+            console.log(delete (b / 1));
+        })();
+    }
+    expect: {
+        var a = 0;
+        (function() {
+            var b = --a;
+            console.log((0 + b, true));
+            console.log((1 * b, true));
+            console.log((0 + b, true));
+            console.log((b - 0, true));
+            console.log((b / 1, true));
+        })();
+    }
+    expect_stdout: [
+        "true",
+        "true",
+        "true",
+        "true",
+        "true",
+    ]
+}
+
+issue_4067: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        unsafe: true,
+    }
+    input: {
+        (function(a) {
+            (function(b) {
+                b[0] += 0;
+                console.log(+a);
+            })(a);
+        })([]);
+    }
+    expect: {
+        (function(a) {
+            (function(b) {
+                b[0] += 0;
+                console.log(+a);
+            })(a);
+        })([]);
+    }
+    expect_stdout: "NaN"
+}
+
+issue_4077: {
+    options = {
+        evaluate: true,
+        unsafe: true,
+    }
+    input: {
+        console.log((a = []) - (a[0]++, 1) || "PASS");
+    }
+    expect: {
+        console.log((a = []) - (a[0]++, 1) || "PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4119_1: {
+    options = {
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unsafe: true,
+    }
+    input: {
+        var a, b;
+        b = a = [];
+        a[0] += 0;
+        if (+b + 1) {
+            console.log("FAIL");
+        } else {
+            console.log("PASS");
+        }
+    }
+    expect: {
+        var a, b;
+        b = a = [];
+        a[0] += 0;
+        +b + 1 ? console.log("FAIL") : console.log("PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4119_2: {
+    options = {
+        conditionals: true,
+        evaluate: true,
+        reduce_vars: true,
+        unsafe: true,
+    }
+    input: {
+        var a;
+        (function(b) {
+            a[0] += 0;
+            console.log(+b + 1 ? "FAIL" : "PASS");
+        })(a = []);
+    }
+    expect: {
+        var a;
+        (function(b) {
+            a[0] += 0;
+            console.log(+b + 1 ? "FAIL" : "PASS");
+        })(a = []);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4119_3: {
+    options = {
+        conditionals: true,
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unsafe: true,
+    }
+    input: {
+        var a, b;
+        b = a = {
+            p: 42,
+        };
+        delete a.p;
+        console.log(b.p ? "FAIL" : "PASS");
+    }
+    expect: {
+        var a, b;
+        b = a = {
+            p: 42,
+        };
+        delete a.p;
+        console.log(b.p ? "FAIL" : "PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4119_4: {
+    options = {
+        booleans: true,
+        conditionals: true,
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var a, b;
+        b = a = {
+            p: 42,
+        };
+        delete a.p;
+        console.log(!b ? "FAIL" : "PASS");
+    }
+    expect: {
+        var a, b;
+        b = a = {
+            p: 42,
+        };
+        delete a.p;
+        console.log((b, 0, "PASS"));
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4214: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f(a) {
+            return function() {
+                try {
+                    return a;
+                } finally {
+                    var b = 0;
+                }
+            }(a++ && this());
+        }
+        var c = f();
+        console.log(c);
+    }
+    expect: {
+        var c = function(a) {
+            return function() {
+                try {
+                    return a;
+                } finally {}
+            }(a++ && this());
+        }();
+        console.log(c);
+    }
+    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",
+    ]
+}
+
+issue_4393: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+    }
+    input: {
+        (function f(a) {
+            a = "PASS";
+            console.log(arguments[0]);
+        })("FAIL");
+    }
+    expect: {
+        (function f(a) {
+            a = "PASS";
+            console.log(arguments[0]);
+        })("FAIL");
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4422: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        console.log(function f(a) {
+            a = "FAIL 1";
+            arguments[0] = "PASS";
+            return a;
+        }("FAIL 2"));
+    }
+    expect: {
+        console.log(function(a) {
+            a = "FAIL 1";
+            arguments[0] = "PASS";
+            return a;
+        }("FAIL 2"));
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4480: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        var a = function f(b) {
+            b = "FAIL";
+            arguments[0] = "PASS";
+            var arguments = 0;
+            console.log(b);
+        }(a);
+    }
+    expect: {
+        var a = function(b) {
+            b = "FAIL";
+            arguments[0] = "PASS";
+            var arguments = 0;
+            console.log(b);
+        }(a);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4552: {
+    options = {
+        evaluate: true,
+        keep_fnames: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = function f(b) {
+            return function() {
+                b++;
+                try {
+                    return b;
+                } catch (e) {}
+            }();
+        }();
+        console.log(a);
+    }
+    expect: {
+        var a = function f(b) {
+            return function() {
+                b++;
+                try {
+                    return b;
+                } catch (e) {}
+            }();
+        }();
+        console.log(a);
+    }
+    expect_stdout: "NaN"
+}

test/compress/exponentiation.js

@@ -0,0 +1,58 @@
+precedence_1: {
+    input: {
+        console.log(-4 ** 3 ** 2);
+    }
+    expect_exact: "console.log((-4)**3**2);"
+    expect_stdout: "-262144"
+    node_version: ">=8"
+}
+
+precedence_2: {
+    input: {
+        console.log(-4 ** (3 ** 2));
+    }
+    expect_exact: "console.log((-4)**3**2);"
+    expect_stdout: "-262144"
+    node_version: ">=8"
+}
+
+precedence_3: {
+    input: {
+        console.log(-(4 ** 3) ** 2);
+    }
+    expect_exact: "console.log((-(4**3))**2);"
+    expect_stdout: "4096"
+    node_version: ">=8"
+}
+
+precedence_4: {
+    input: {
+        console.log((-4 ** 3) ** 2);
+    }
+    expect_exact: "console.log(((-4)**3)**2);"
+    expect_stdout: "4096"
+    node_version: ">=8"
+}
+
+await: {
+    input: {
+        (async a => a * await a ** ++a % a)(2).then(console.log);
+    }
+    expect_exact: "(async a=>a*(await a)**++a%a)(2).then(console.log);"
+    expect_stdout: "1"
+    node_version: ">=8"
+}
+
+evaluate: {
+    options = {
+        evaluate: true,
+    }
+    input: {
+        console.log(1 + 2 ** 3 - 4);
+    }
+    expect: {
+        console.log(5);
+    }
+    expect_stdout: "5"
+    node_version: ">=8"
+}

test/compress/functions.js

@@ -229,7 +229,7 @@ issue_203: {
     }
     expect: {
         var m = {};
-        var fn = Function("n,o", "o.exports=42");
+        var fn = Function("n,o,t", "o.exports=42");
         fn(null, m, m.exports);
         console.log(m.exports);
     }
@@ -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,
@@ -1483,8 +1484,7 @@ issue_2663_2: {
     }
     expect: {
         (function() {
-            var i;
-            for (i in { a: 1, b: 2, c: 3 })
+            for (var i in { a: 1, b: 2, c: 3 })
                 j = i, console.log(j);
             var j;
         })();
@@ -2082,7 +2082,7 @@ issue_3016_1: {
         var b = 1;
         do {
             3[b];
-        } while(0);
+        } while (0);
         console.log(b);
     }
     expect_stdout: "1"
@@ -2113,7 +2113,7 @@ issue_3016_2: {
         do {
             a = 3,
             a[b];
-        } while(0);
+        } while (0);
         var a;
         console.log(b);
     }
@@ -2146,7 +2146,7 @@ issue_3016_2_ie8: {
         do {
             a = 3,
             a[b];
-        } while(0);
+        } while (0);
         var a;
         console.log(b);
     }
@@ -2175,8 +2175,8 @@ issue_3016_3: {
     expect: {
         var b = 1;
         do {
-            console.log((a = void 0, a ? "FAIL" : a = "PASS"));
-        } while(b--);
+            console.log((a = void 0, a ? "FAIL" : "PASS"));
+        } while (b--);
         var a;
     }
     expect_stdout: [
@@ -2208,8 +2208,8 @@ issue_3016_3_ie8: {
     expect: {
         var b = 1;
         do {
-            console.log((a = void 0, a ? "FAIL" : a = "PASS"));
-        } while(b--);
+            console.log((a = void 0, a ? "FAIL" : "PASS"));
+        } while (b--);
         var a;
     }
     expect_stdout: [
@@ -2677,7 +2677,7 @@ cross_references_3: {
                 };
                 return Math.square(n) + Math.cube(n);
             };
-        }(Math)(2));
+        }()(2));
         console.log(Math.square(3), Math.cube(3));
     }
     expect_stdout: [
@@ -3322,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"
@@ -4232,7 +4230,7 @@ substitute: {
 substitute_add_farg: {
     options = {
         inline: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
     }
     input: {
         function f(g) {
@@ -4413,7 +4411,9 @@ substitute_drop_farg: {
                 return f;
             },
             function() {
-                return f;
+                return function(d, e) {
+                    return f(d, e);
+                };
             },
         ].forEach(function(g) {
             console.log(g()(o), g().call(o, o));
@@ -4596,7 +4596,7 @@ substitute_use_strict: {
 issue_3833: {
     options = {
         inline: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         reduce_vars: true,
         toplevel: true,
         unused: true,
@@ -4747,3 +4747,663 @@ issue_3929: {
     }
     expect_stdout: "function"
 }
+
+issue_4006: {
+    options = {
+        dead_code: true,
+        evaluate: true,
+        inline: true,
+        keep_fargs: false,
+        reduce_vars: true,
+        sequences: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        var a = 0;
+        (function() {
+            (function(b, c) {
+                for (var k in console.log(c), 0)
+                    return b += 0;
+            })(0, --a);
+            return a ? 0 : --a;
+        })();
+    }
+    expect: {
+        var a = 0;
+        (function(c) {
+            for (var k in console.log(c), 0)
+                return;
+        })(--a), a || --a;
+    }
+    expect_stdout: "-1"
+}
+
+issue_4155: {
+    options = {
+        functions: true,
+        inline: true,
+        merge_vars: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        (function() {
+            var a;
+            (function() {
+                console.log(a);
+            })(a);
+            var b = function() {};
+            b && console.log(typeof b);
+        })();
+    }
+    expect: {
+        (function() {
+            void console.log(b);
+            var b = function() {};
+            b && console.log(typeof b);
+        })();
+    }
+    expect_stdout: [
+        "undefined",
+        "function",
+    ]
+}
+
+issue_4159: {
+    options = {
+        collapse_vars: true,
+        inline: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = 42, c = function(b) {
+            (b = a) && console.log(a++, b);
+        }(c = a);
+    }
+    expect: {
+        var a = 42;
+        (b = a) && console.log(a++, b);
+        var b;
+    }
+    expect_stdout: "42 42"
+}
+
+direct_inline: {
+    options = {
+        inline: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        function f(a, b) {
+            function g(c) {
+                return c >> 1;
+            }
+            return g(a) + g(b);
+        }
+        console.log(f(13, 31));
+    }
+    expect: {
+        function f(a, b) {
+            return (a >> 1) + (b >> 1);
+        }
+        console.log(f(13, 31));
+    }
+    expect_stdout: "21"
+}
+
+direct_inline_catch_redefined: {
+    options = {
+        inline: true,
+        reduce_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var a = 1;
+        function f() {
+            return a;
+        }
+        try {
+            throw 2;
+        } catch (a) {
+            function g() {
+                return a;
+            }
+            console.log(a, f(), g());
+        }
+        console.log(a, f(), g());
+    }
+    expect: {
+        var a = 1;
+        function f() {
+            return a;
+        }
+        try {
+            throw 2;
+        } catch (a) {
+            function g() {
+                return a;
+            }
+            console.log(a, f(), g());
+        }
+        console.log(a, a, g());
+    }
+    expect_stdout: true
+}
+
+issue_4171_1: {
+    options = {
+        functions: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        console.log(function(a) {
+            try {
+                while (a)
+                    var e = function() {};
+            } catch (e) {
+                return function() {
+                    return e;
+                };
+            }
+        }(!console));
+    }
+    expect: {
+        console.log(function(a) {
+            try {
+                while (a)
+                    var e = function() {};
+            } catch (e) {
+                return function() {
+                    return e;
+                };
+            }
+        }(!console));
+    }
+    expect_stdout: "undefined"
+}
+
+issue_4171_2: {
+    options = {
+        functions: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        console.log(function(a) {
+            try {
+                while (a);
+            } catch (e) {
+                return function() {
+                    return e;
+                };
+            } finally {
+                var e = function() {};
+            }
+        }(!console));
+    }
+    expect: {
+        console.log(function(a) {
+            try {
+                while (a);
+            } catch (e) {
+                return function() {
+                    return e;
+                };
+            } finally {
+                function e() {}
+            }
+        }(!console));
+    }
+    expect_stdout: "undefined"
+}
+
+catch_defun: {
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        try {
+            throw 42;
+        } catch (a) {
+            function f() {
+                return typeof a;
+            }
+        }
+        console.log(f());
+    }
+    expect: {
+        try {
+            throw 42;
+        } catch (o) {
+            function t() {
+                return typeof o;
+            }
+        }
+        console.log(t());
+    }
+    expect_stdout: true
+}
+
+catch_no_argname: {
+    options = {
+        inline: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = "PASS";
+        function f() {
+            return a;
+        }
+        try {
+            throw a;
+        } catch {
+            function g() {
+                return a;
+            }
+            console.log(a, f(), g());
+        }
+        console.log(a, f(), g());
+    }
+    expect: {
+        var a = "PASS";
+        try {
+            throw a;
+        } catch {
+            console.log(a, a, a);
+        }
+        console.log(a, a, a);
+    }
+    expect_stdout: [
+        "PASS PASS PASS",
+        "PASS PASS PASS",
+    ]
+    node_version: ">=10"
+}
+
+issue_4186: {
+    options = {
+        conditionals: true,
+        inline: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        sequences: true,
+        unused: true,
+    }
+    input: {
+        console.log(typeof function() {
+            return function() {
+                function f() {
+                    if (1)
+                        g();
+                    else
+                        (function() {
+                            return f;
+                        });
+                }
+                return f;
+                function g() {
+                    if (1) {
+                        if (0)
+                            h;
+                        else
+                            h();
+                        var key = 0;
+                    }
+                }
+                function h() {
+                    return factory;
+                }
+            };
+        }()());
+    }
+    expect: {
+        console.log(typeof function() {
+            return function f() {
+                1 ? void (1 && (0 ? h : h(), 0)) : function() {
+                    return f;
+                };
+            };
+            function h() {
+                return factory;
+            }
+        }());
+    }
+    expect_stdout: "function"
+}
+
+issue_4233: {
+    options = {
+        functions: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        (function() {
+            try {
+                var a = function() {};
+                try {
+                    throw 42;
+                } catch (a) {
+                    (function() {
+                        console.log(typeof a);
+                    })();
+                    var a;
+                }
+            } catch (e) {}
+        })();
+    }
+    expect: {
+        (function() {
+            try {
+                var a = function() {};
+                try {
+                    throw 42;
+                } catch (a) {
+                    (function() {
+                        console.log(typeof a);
+                    })();
+                    var a;
+                }
+            } catch (e) {}
+        })();
+    }
+    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: {
+        var a = function b() {
+            for (b in b);
+        }
+        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"
+}
+
+issue_4451: {
+    options = {
+        functions: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = function f() {
+            for (f in "foo")
+                return f;
+        };
+        while (console.log(typeof a()));
+    }
+    expect: {
+        var a = function f() {
+            for (f in "foo")
+                return f;
+        };
+        while (console.log(typeof a()));
+    }
+    expect_stdout: "function"
+}
+
+issue_4471: {
+    options = {
+        inline: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        f(f());
+        function f() {
+            return g();
+        }
+        function g() {
+            {
+                console.log("PASS");
+            }
+        }
+    }
+    expect: {
+        f(g());
+        function f() {
+            return g();
+        }
+        function g() {
+            console.log("PASS");
+        }
+    }
+    expect_stdout: [
+        "PASS",
+        "PASS",
+    ]
+}
+
+issue_4612_1: {
+    options = {
+        evaluate: true,
+        inline: true,
+        reduce_vars: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        console.log(function() {
+            function f() {
+                return g();
+            }
+            function g(a) {
+                return a || f();
+            }
+            return g("PASS");
+        }());
+    }
+    expect: {
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4612_2: {
+    options = {
+        evaluate: true,
+        inline: true,
+        reduce_vars: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        console.log(function() {
+            function fn() {
+                return h();
+            }
+            function g() {
+                return fn();
+            }
+            function h(a) {
+                return a || fn();
+            }
+            return h("PASS");
+        }());
+    }
+    expect: {
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4612_3: {
+    options = {
+        inline: true,
+        reduce_vars: true,
+    }
+    input: {
+        console.log(typeof function() {
+            return g();
+            function f() {
+                return g;
+            }
+            function g() {
+                {
+                    return f;
+                }
+            }
+        }());
+    }
+    expect: {
+        console.log(typeof function() {
+            return g();
+            function f() {
+                return g;
+            }
+            function g() {
+                return f;
+            }
+        }());
+    }
+    expect_stdout: "function"
+}
+
+issue_4612_4: {
+    options = {
+        booleans: true,
+        evaluate: true,
+        reduce_vars: true,
+    }
+    input: {
+        console.log(function() {
+            function f() {
+                return h();
+            }
+            function g() {
+                {
+                    return h();
+                }
+            }
+            function h() {
+                {
+                    return g();
+                }
+            }
+        }());
+    }
+    expect: {
+        console.log(function() {
+            function f() {
+                return h();
+            }
+            function g() {
+                return h();
+            }
+            function h() {
+                return g();
+            }
+        }());
+    }
+    expect_stdout: "undefined"
+}

test/compress/global_defs.js

@@ -12,6 +12,20 @@ must_replace: {
     }
 }
 
+repeated_nodes: {
+    options = {
+        global_defs: {
+            "@N": "rand()",
+        },
+    }
+    input: {
+        console.log(N, N);
+    }
+    expect: {
+        console.log(rand(), rand());
+    }
+}
+
 keyword: {
     options = {
         global_defs: {

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,
@@ -1016,3 +1043,28 @@ issue_3945_2: {
     }
     expect_stdout: "undefined"
 }
+
+issue_4023: {
+    options = {
+        comparisons: true,
+        hoist_props: true,
+        inline: true,
+        reduce_vars: true,
+        toplevel: true,
+        typeofs: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            var a = function() {
+                return { p: 0 };
+            }();
+            return console.log("undefined" != typeof a);
+        }
+        f();
+    }
+    expect: {
+        console.log(void 0 !== {});
+    }
+    expect_stdout: "true"
+}

test/compress/hoist_vars.js

@@ -89,6 +89,31 @@ sequences_funs: {
     }
 }
 
+catch_var: {
+    options = {
+        dead_code: true,
+        hoist_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = "PASS";
+        try {
+            a;
+        } catch (a) {
+            var a = 0;
+            a;
+        }
+        console.log(a);
+    }
+    expect: {
+        var a = "PASS";
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+}
+
 issue_2295: {
     options = {
         collapse_vars: true,
@@ -109,3 +134,76 @@ issue_2295: {
         }
     }
 }
+
+issue_4487: {
+    options = {
+        functions: true,
+        hoist_vars: true,
+        keep_fnames: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = function f() {
+            var f = console.log(typeof f);
+        };
+        var b = a();
+    }
+    expect: {
+        function a() {
+            var a = console.log(typeof a);
+        }
+        a();
+    }
+    expect_stdout: "undefined"
+}
+
+issue_4489: {
+    options = {
+        collapse_vars: true,
+        evaluate: true,
+        hoist_vars: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        A = 0;
+        var o = !0 || null;
+        for (var k in o);
+        console.log(k);
+    }
+    expect: {
+        !(A = 0);
+        for (var k in true);
+        console.log(k);
+    }
+    expect_stdout: "undefined"
+}
+
+issue_4517: {
+    options = {
+        collapse_vars: true,
+        hoist_vars: true,
+        join_vars: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        console.log(function() {
+            var a = 2;
+            A = a;
+            var b = typeof !1;
+            return A + b;
+        }());
+    }
+    expect: {
+        console.log(function() {
+            var a = 2;
+            A = a;
+            return A + typeof !1;
+        }());
+    }
+    expect_stdout: "2boolean"
+}

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);
         };
@@ -2544,12 +2540,12 @@ issue_3999: {
     expect: {
         (function() {
             (function f() {
-                for (var c = 0; c < 2; c++)
+                for (var o = 0; o < 2; o++)
                     try {
                         f[0];
                     } catch (f) {
                         var f = 0;
-                        console.log(c);
+                        console.log(o);
                     }
             })();
         })(typeof f);
@@ -2593,3 +2589,333 @@ issue_4001: {
     }
     expect_stdout: "undefined"
 }
+
+issue_4015: {
+    rename = true
+    mangle = {
+        ie8: true,
+        toplevel: true,
+    }
+    input: {
+        var n, a = 0, b;
+        function f() {
+            try {
+                throw 0;
+            } catch (b) {
+                (function g() {
+                    (function b() {
+                        a++;
+                    })();
+                })();
+            }
+        }
+        f();
+        console.log(a);
+    }
+    expect: {
+        var n, o = 0, c;
+        function t() {
+            try {
+                throw 0;
+            } catch (c) {
+                (function n() {
+                    (function c() {
+                        o++;
+                    })();
+                })();
+            }
+        }
+        t();
+        console.log(o);
+    }
+    expect_stdout: "1"
+}
+
+issue_4019: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    mangle = {
+        ie8: true,
+        toplevel: true,
+    }
+    input: {
+        var a = function() {
+            try {
+                console.log("FAIL");
+            } catch (b) {}
+        }, a = (console.log(a.length), ++a);
+    }
+    expect: {
+        var o = function() {
+            try {
+                console.log("FAIL");
+            } catch (o) {}
+        }, o = (console.log(o.length), ++o);
+    }
+    expect_stdout: "0"
+}
+
+issue_4028: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    mangle = {
+        ie8: true,
+    }
+    input: {
+        function a() {
+            try {
+                A;
+            } catch (e) {}
+        }
+        var b = a += a;
+        console.log(typeof b);
+    }
+    expect: {
+        function a() {
+            try {
+                A;
+            } catch (a) {}
+        }
+        var b = a += a;
+        console.log(typeof b);
+    }
+    expect_stdout: "string"
+}
+
+issue_2737: {
+    options = {
+        ie8: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        (function(a) {
+            a();
+        })(function f() {
+            console.log(typeof f);
+        });
+    }
+    expect: {
+        (function(a) {
+            a();
+        })(function f() {
+            console.log(typeof f);
+        });
+    }
+    expect_stdout: "function"
+}
+
+single_use_catch_redefined: {
+    options = {
+        ie8: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = 1;
+        try {
+            throw 2;
+        } catch (a) {
+            function g() {
+                return a;
+            }
+        }
+        console.log(g());
+    }
+    expect: {
+        var a = 1;
+        try {
+            throw 2;
+        } catch (a) {
+            function g() {
+                return a;
+            }
+        }
+        console.log(g());
+    }
+    expect_stdout: true
+}
+
+single_use_inline_catch_redefined: {
+    options = {
+        ie8: true,
+        inline: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = 1;
+        try {
+            throw 2;
+        } catch (a) {
+            function g() {
+                return a;
+            }
+        }
+        console.log(g());
+    }
+    expect: {
+        var a = 1;
+        try {
+            throw 2;
+        } catch (a) {
+            function g() {
+                return a;
+            }
+        }
+        console.log(g());
+    }
+    expect_stdout: true
+}
+
+direct_inline_catch_redefined: {
+    options = {
+        ie8: true,
+        inline: true,
+        reduce_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var a = 1;
+        function f() {
+            return a;
+        }
+        try {
+            throw 2;
+        } catch (a) {
+            function g() {
+                return a;
+            }
+            console.log(a, f(), g());
+        }
+        console.log(a, f(), g());
+    }
+    expect: {
+        var a = 1;
+        function f() {
+            return a;
+        }
+        try {
+            throw 2;
+        } catch (a) {
+            function g() {
+                return a;
+            }
+            console.log(a, f(), g());
+        }
+        console.log(a, a, g());
+    }
+    expect_stdout: true
+}
+
+issue_4186: {
+    options = {
+        dead_code: true,
+        evaluate: true,
+        ie8: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    mangle = {
+        ie8: true,
+        toplevel: true,
+    }
+    input: {
+        function f() {
+            (function NaN() {
+                var a = 1;
+                while (a--)
+                    try {} finally {
+                        console.log(0/0);
+                        var b;
+                    }
+            })(f);
+        }
+        f();
+        NaN;
+    }
+    expect: {
+        (function() {
+            (function NaN() {
+                var n = 1;
+                while (n--)
+                    console.log(0/0);
+            })();
+        })();
+        NaN;
+    }
+    expect_stdout: "NaN"
+}
+
+issue_4235: {
+    options = {
+        ie8: true,
+        unused: true,
+    }
+    input: {
+        try {} catch (e) {}
+        console.log(function e() {
+            var e = 0;
+        }());
+    }
+    expect: {
+        try {} catch (e) {}
+        console.log(function e() {}());
+    }
+    expect_stdout: "undefined"
+}
+
+issue_4250: {
+    options = {
+        ie8: true,
+        loops: true,
+        unused: true,
+    }
+    input: {
+        console.log(function f() {
+            (function() {
+                for (f in "f");
+            })();
+            return f;
+            var f;
+        }());
+    }
+    expect: {
+        console.log(function f() {
+            (function() {
+                for (f in "f");
+            })();
+            return f;
+            var f;
+        }());
+    }
+    expect_stdout: "0"
+}
+
+issue_4568: {
+    options = {
+        ie8: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        console.log(typeof f, function(a) {
+            return a.length;
+        }([ function f() {} ]));
+    }
+    expect: {
+        console.log(typeof f, function(a) {
+            return a.length;
+        }([ function f() {} ]));
+    }
+    expect_stdout: "undefined 1"
+}

test/compress/if_return.js

@@ -594,3 +594,157 @@ iife_if_return_simple: {
     }
     expect_stdout: "PASS"
 }
+
+nested_if_break: {
+    options = {
+        if_return: true,
+    }
+    input: {
+        for (var i = 0; i < 3; i++)
+            L1: if ("number" == typeof i) {
+                if (0 === i) break L1;
+                console.log(i);
+            }
+    }
+    expect: {
+        for (var i = 0; i < 3; i++)
+            L1: if ("number" == typeof i)
+                if (0 !== i) console.log(i);
+    }
+    expect_stdout: [
+        "1",
+        "2",
+    ]
+}
+
+nested_if_continue: {
+    options = {
+        conditionals: true,
+        if_return: true,
+        join_vars: true,
+        loops: true,
+    }
+    input: {
+        function f(n) {
+            var i = 0;
+            do {
+                if ("number" == typeof n) {
+                    if (0 === n) {
+                        console.log("even", i);
+                        continue;
+                    }
+                    if (1 === n) {
+                        console.log("odd", i);
+                        continue;
+                    }
+                    i++;
+                }
+            } while (0 <= (n -= 2));
+        }
+        f(37);
+        f(42);
+    }
+    expect: {
+        function f(n) {
+            for (var i = 0;
+                "number" == typeof n
+                    && (0 !== n
+                        ? 1 !== n
+                            ? i++
+                            : console.log("odd", i)
+                        : console.log("even", i)),
+                0 <= (n -= 2););
+        }
+        f(37);
+        f(42);
+    }
+    expect_stdout: [
+        "odd 18",
+        "even 21",
+    ]
+}
+
+nested_if_return: {
+    options = {
+        conditionals: true,
+        if_return: true,
+    }
+    input: {
+        function f() {
+            if (A) {
+                if (B)
+                    return B;
+                if (C)
+                    return D;
+                if (E)
+                    return F;
+                if (G)
+                    return H;
+                if (I) {
+                    if (J)
+                        return K;
+                    return;
+                }
+                if (L) {
+                    if (M)
+                        return;
+                    return N;
+                }
+            }
+        }
+    }
+    expect: {
+        function f() {
+            if (A)
+                return B || (C ? D : E ? F : G ? H : I ? J ? K : void 0 : L && !M ? N : void 0);
+        }
+    }
+}
+
+issue_866_1: {
+    options = {
+        conditionals: true,
+        if_return: true,
+        sequences: false,
+    };
+    input: {
+        function f(a) {
+            if (a)
+                return "";
+            console.log(a);
+        }
+    }
+    expect: {
+        function f(a) {
+            if (a)
+                return "";
+            console.log(a);
+        }
+    }
+}
+
+issue_866_2: {
+    options = {
+        conditionals: true,
+        if_return: true,
+        sequences: true,
+    }
+    input: {
+        (function() {
+            if (a)
+                if (b)
+                    c;
+                else
+                    return d;
+        })();
+    }
+    expect: {
+        (function() {
+            if (a) {
+                if (!b)
+                    return d;
+                c;
+            }
+        })();
+    }
+}

test/compress/issue-1034.js

@@ -39,7 +39,7 @@ non_hoisted_function_after_return: {
         "WARN: Dropping unreachable code [test/compress/issue-1034.js:4,16]",
         "WARN: Dropping unreachable code [test/compress/issue-1034.js:7,16]",
         "WARN: Dropping unreachable code [test/compress/issue-1034.js:10,12]",
-        "WARN: Dropping unused function UnusedFunction [test/compress/issue-1034.js:11,21]"
+        "WARN: Dropping unused function UnusedFunction [test/compress/issue-1034.js:11,21]",
     ]
 }
 
@@ -84,19 +84,16 @@ non_hoisted_function_after_return_2a: {
         }
     }
     expect_warnings: [
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:4,16]",
-        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:4,16]",
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:7,16]",
-        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:7,16]",
+        "WARN: Dropping initialization in unreachable code [test/compress/issue-1034.js:4,16]",
+        "WARN: Dropping initialization in unreachable code [test/compress/issue-1034.js:7,16]",
         "WARN: Dropping unused variable a [test/compress/issue-1034.js:4,20]",
         "WARN: Dropping unused function nope [test/compress/issue-1034.js:11,21]",
-        "INFO: pass 0: last_count: Infinity, count: 36",
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:9,12]",
-        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:9,12]",
+        "INFO: pass 0: last_count: Infinity, count: 35",
+        "WARN: Dropping initialization in unreachable code [test/compress/issue-1034.js:9,12]",
         "WARN: Dropping unreachable code [test/compress/issue-1034.js:12,12]",
         "INFO: Dropping unused variable b [test/compress/issue-1034.js:7,20]",
         "INFO: Dropping unused variable c [test/compress/issue-1034.js:9,16]",
-        "INFO: pass 1: last_count: 36, count: 18",
+        "INFO: pass 1: last_count: 35, count: 18",
     ]
 }
 
@@ -138,10 +135,7 @@ non_hoisted_function_after_return_2b: {
         }
     }
     expect_warnings: [
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:6,16]",
-        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:6,16]",
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:8,12]",
-        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:8,12]",
+        "WARN: Dropping initialization in unreachable code [test/compress/issue-1034.js:8,12]",
         "WARN: Dropping unreachable code [test/compress/issue-1034.js:12,12]",
     ]
 }
@@ -242,19 +236,16 @@ non_hoisted_function_after_return_2a_strict: {
     }
     expect_stdout: "5 6"
     expect_warnings: [
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:5,16]",
-        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:5,16]",
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:8,16]",
-        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:8,16]",
+        "WARN: Dropping initialization in unreachable code [test/compress/issue-1034.js:5,16]",
+        "WARN: Dropping initialization in unreachable code [test/compress/issue-1034.js:8,16]",
         "WARN: Dropping unused variable a [test/compress/issue-1034.js:5,20]",
         "WARN: Dropping unused function nope [test/compress/issue-1034.js:12,21]",
-        "INFO: pass 0: last_count: Infinity, count: 47",
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:10,12]",
-        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:10,12]",
+        "INFO: pass 0: last_count: Infinity, count: 46",
+        "WARN: Dropping initialization in unreachable code [test/compress/issue-1034.js:10,12]",
         "WARN: Dropping unreachable code [test/compress/issue-1034.js:13,12]",
         "INFO: Dropping unused variable b [test/compress/issue-1034.js:8,20]",
         "INFO: Dropping unused variable c [test/compress/issue-1034.js:10,16]",
-        "INFO: pass 1: last_count: 47, count: 29",
+        "INFO: pass 1: last_count: 46, count: 29",
     ]
 }
 
@@ -301,10 +292,7 @@ non_hoisted_function_after_return_2b_strict: {
     }
     expect_stdout: "5 6"
     expect_warnings: [
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:7,16]",
-        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:7,16]",
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:9,12]",
-        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:9,12]",
+        "WARN: Dropping initialization in unreachable code [test/compress/issue-1034.js:9,12]",
         "WARN: Dropping unreachable code [test/compress/issue-1034.js:13,12]",
     ]
 }

test/compress/issue-1052.js

@@ -16,7 +16,7 @@ multiple_functions: {
         ( function() {
             // NOTE: other compression steps will reduce this
             // down to just `window`.
-            if ( window );
+            if ( !window );
             function f() {}
             function g() {}
         } )();
@@ -38,7 +38,7 @@ single_function: {
     }
     expect: {
         ( function() {
-            if ( window );
+            if ( !window );
             function f() {}
         } )();
     }
@@ -67,7 +67,7 @@ deeply_nested: {
             // NOTE: other compression steps will reduce this
             // down to just `window`.
             if ( window )
-                if (document);
+                if ( !document );
             function f() {}
             function g() {}
             function h() {}

test/compress/issue-1105.js

@@ -151,15 +151,18 @@ Infinity_not_in_with_scope: {
         unused: true,
     }
     input: {
-        var o = { Infinity: 'oInfinity' };
+        var o = { Infinity: "FAIL" };
         var vInfinity = "Infinity";
         vInfinity = Infinity;
+        console.log(vInfinity);
     }
     expect: {
-        var o = { Infinity: 'oInfinity' }
-        var vInfinity = "Infinity"
-        vInfinity = 1/0
+        var o = { Infinity: "FAIL" };
+        var vInfinity = "Infinity";
+        vInfinity = 1/0;
+        console.log(vInfinity);
     }
+    expect_stdout: "Infinity"
 }
 
 Infinity_in_with_scope: {
@@ -167,15 +170,18 @@ Infinity_in_with_scope: {
         unused: true,
     }
     input: {
-        var o = { Infinity: 'oInfinity' };
+        var o = { Infinity: "PASS" };
         var vInfinity = "Infinity";
         with (o) { vInfinity = Infinity; }
+        console.log(vInfinity);
     }
     expect: {
-        var o = { Infinity: 'oInfinity' }
-        var vInfinity = "Infinity"
-        with (o) vInfinity = Infinity
+        var o = { Infinity: "PASS" };
+        var vInfinity = "Infinity";
+        with (o) vInfinity = Infinity;
+        console.log(vInfinity);
     }
+    expect_stdout: "PASS"
 }
 
 assorted_Infinity_NaN_undefined_in_with_scope: {

test/compress/issue-269.js

@@ -17,7 +17,7 @@ issue_269_1: {
     expect: {
         var x = {};
         console.log(
-            x + "", +x, !!x,
+            "" + x, +("" + x), !!x,
             "", 0, false
         );
     }

test/compress/issue-976.js

@@ -63,42 +63,81 @@ eval_unused: {
         unused: true,
     }
     input: {
-        function f1(a, eval, c, d, e) {
-            return a('c') + eval;
-        }
-        function f2(a, b, c, d, e) {
-            return a + eval('c');
-        }
-        function f3(a, eval, c, d, e) {
-            return a + eval('c');
+        function o(k) {
+            return { c: 14 }[k];
         }
+        console.log(function f1(a, eval, c, d, e) {
+            return a("c") + eval;
+        }(o, 28, true));
+        console.log(function f2(a, b, c, d, e) {
+            return a + eval("c");
+        }(14, true, 28));
+        console.log(function f3(a, eval, c, d, e) {
+            return a + eval("c");
+        }(28, o, true));
     }
     expect: {
-        function f1(a, eval) {
-            return a('c') + eval;
-        }
-        function f2(a, b, c, d, e) {
-            return a + eval('c');
-        }
-        function f3(a, eval, c, d, e) {
-            return a + eval('c');
+        function o(k) {
+            return { c: 14 }[k];
         }
+        console.log(function(a, eval) {
+            return a("c") + eval;
+        }(o, 28));
+        console.log(function f2(a, b, c, d, e) {
+            return a + eval("c");
+        }(14, true, 28));
+        console.log(function f3(a, eval, c, d, e) {
+            return a + eval("c");
+        }(28, o, true));
     }
+    expect_stdout: [
+        "42",
+        "42",
+        "42",
+    ]
 }
 
 eval_mangle: {
-    mangle = {
-    };
-    input: {
-        function f1(a, eval, c, d, e) {
-            return a('c') + eval;
-        }
-        function f2(a, b, c, d, e) {
-            return a + eval('c');
-        }
-        function f3(a, eval, c, d, e) {
-            return a + eval('c');
-        }
+    mangle = {}
+    beautify = {
+        beautify: true,
     }
-    expect_exact: 'function f1(n,c,e,a,f){return n("c")+c}function f2(a,b,c,d,e){return a+eval("c")}function f3(a,eval,c,d,e){return a+eval("c")}'
+    input: {
+        function o(k) {
+            return { cc: 14 }[k + "c"];
+        }
+        console.log(function f1(a, eval, c, d, e) {
+            return a("c") + eval;
+        }(o, 28, true));
+        console.log(function f2(a, b, c, d, e) {
+            return a + eval("c");
+        }(14, true, 28));
+        console.log(function f3(a, eval, c, d, e) {
+            return a + eval("c");
+        }(28, o, true));
+    }
+    expect_exact: [
+        "function o(o) {",
+        "    return {",
+        "        cc: 14",
+        '    }[o + "c"];',
+        "}",
+        "",
+        "console.log(function o(c, e, n, r, t) {",
+        '    return c("c") + e;',
+        "}(o, 28, true));",
+        "",
+        "console.log(function f2(a, b, c, d, e) {",
+        '    return a + eval("c");',
+        "}(14, true, 28));",
+        "",
+        "console.log(function f3(a, eval, c, d, e) {",
+        '    return a + eval("c");',
+        "}(28, o, true));",
+    ]
+    expect_stdout: [
+        "42",
+        "42",
+        "42",
+    ]
 }

test/compress/join_vars.js

@@ -277,8 +277,8 @@ join_object_assignments_forin: {
     }
     expect: {
         console.log(function() {
-            var o = { a: "PASS" };
-            for (var a in o)
+            var o = { a: "PASS" }, a;
+            for (a in o)
                 return o[a];
         }());
     }
@@ -790,7 +790,7 @@ issue_3795: {
         dead_code: true,
         evaluate: true,
         join_vars: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         loops: true,
         passes: 2,
         reduce_vars: true,
@@ -1055,3 +1055,75 @@ issue_3916: {
     }
     expect_stdout: "object PASS true PASS"
 }
+
+assign_var: {
+    options = {
+        join_vars: true,
+    }
+    input: {
+        b = "foo";
+        var a = [ , "bar" ];
+        console.log(b);
+        for (var b in a)
+            console.log(b, a[b]);
+    }
+    expect: {
+        var b = "foo", a = [ , "bar" ], b;
+        console.log(b);
+        for (b in a)
+            console.log(b, a[b]);
+    }
+    expect_stdout: [
+        "foo",
+        "1 bar",
+    ]
+}
+
+assign_for_var: {
+    options = {
+        join_vars: true,
+    }
+    input: {
+        i = "foo",
+        a = new Array(i, "bar");
+        for (var i = 2; --i >= 0;) {
+            console.log(a[i]);
+            for (var a in i);
+        }
+    }
+    expect: {
+        for (var i = "foo", a = new Array(i, "bar"), i = 2; --i >= 0;) {
+            console.log(a[i]);
+            for (var a in i);
+        }
+    }
+    expect_stdout: [
+        "bar",
+        "foo",
+    ]
+}
+
+assign_sequence_var: {
+    options = {
+        join_vars: true,
+    }
+    input: {
+        var a = 0, b = 1;
+        console.log(a),
+        a++,
+        b = 2;
+        var c = 3;
+        console.log(a, b, c);
+    }
+    expect: {
+        var a = 0, b = 1;
+        console.log(a),
+        a++;
+        var b = 2, c = 3;
+        console.log(a, b, c);
+    }
+    expect_stdout: [
+        "0",
+        "1 2 3",
+    ]
+}

test/compress/keep_fargs.js

@@ -18,43 +18,6 @@ keep_fargs_false: {
         function j(e) {}
         console.log(h(), i().length, j.length);
     }
-    expect: {
-        console.log(function f() {
-            return f.length;
-        }(), function g() {
-            return g;
-        }().length);
-        function h() {
-            return h.length;
-        }
-        function i() {
-            return i;
-        }
-        function j() {}
-        console.log(h(), i().length, j.length);
-    }
-}
-
-keep_fargs_strict: {
-    options = {
-        keep_fargs: "strict",
-        unused: true,
-    }
-    input: {
-        console.log(function f(a) {
-            return f.length;
-        }(), function g(b) {
-            return g;
-        }().length);
-        function h(c) {
-            return h.length;
-        }
-        function i(d) {
-            return i;
-        }
-        function j(e) {}
-        console.log(h(), i().length, j.length);
-    }
     expect: {
         console.log(function f(a) {
             return f.length;
@@ -117,61 +80,11 @@ keep_fargs_true: {
     ]
 }
 
-replace_index: {
-    options = {
-        arguments: true,
-        evaluate: true,
-        keep_fargs: "strict",
-        properties: true,
-    }
-    input: {
-        var arguments = [];
-        console.log(arguments[0]);
-        (function() {
-            console.log(arguments[1], arguments["1"], arguments["foo"]);
-        })("bar", 42);
-        (function(a, b) {
-            console.log(arguments[1], arguments["1"], arguments["foo"]);
-        })("bar", 42);
-        (function(arguments) {
-            console.log(arguments[1], arguments["1"], arguments["foo"]);
-        })("bar", 42);
-        (function() {
-            var arguments;
-            console.log(arguments[1], arguments["1"], arguments["foo"]);
-        })("bar", 42);
-    }
-    expect: {
-        var arguments = [];
-        console.log(arguments[0]);
-        (function(argument_0, argument_1) {
-            console.log(argument_1, argument_1, arguments.foo);
-        })("bar", 42);
-        (function(a, b) {
-            console.log(b, b, arguments.foo);
-        })("bar", 42);
-        (function(arguments) {
-            console.log(arguments[1], arguments[1], arguments.foo);
-        })("bar", 42);
-        (function() {
-            var arguments;
-            console.log(arguments[1], arguments[1], arguments.foo);
-        })("bar", 42);
-    }
-    expect_stdout: [
-        "undefined",
-        "42 42 undefined",
-        "42 42 undefined",
-        "a a undefined",
-        "42 42 undefined",
-    ]
-}
-
 replace_index_strict: {
     options = {
         arguments: true,
         evaluate: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         properties: true,
         reduce_vars: true,
     }
@@ -202,7 +115,7 @@ replace_index_strict: {
 issue_1858: {
     options = {
         collapse_vars: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         pure_getters: true,
         unused: true,
     }
@@ -224,7 +137,7 @@ issue_1858: {
 issue_2187_2: {
     options = {
         collapse_vars: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         unused: true,
     }
     input: {
@@ -245,7 +158,7 @@ issue_2187_2: {
 issue_2203_2: {
     options = {
         collapse_vars: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         unused: true,
     }
     input: {
@@ -280,7 +193,7 @@ issue_2203_2: {
 issue_2298: {
     options = {
         collapse_vars: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         passes: 2,
         reduce_funcs: true,
         reduce_vars: true,
@@ -306,7 +219,6 @@ issue_2298: {
     expect: {
         !function() {
             (function() {
-                0;
                 try {
                     !function() {
                         (void 0)[1] = "foo";
@@ -324,7 +236,7 @@ issue_2298: {
 issue_2319_1: {
     options = {
         collapse_vars: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         unused: true,
     }
     input: {
@@ -347,7 +259,7 @@ issue_2319_1: {
 issue_2319_2: {
     options = {
         collapse_vars: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         unused: true,
     }
     input: {
@@ -372,7 +284,7 @@ issue_2319_2: {
 issue_2319_3: {
     options = {
         collapse_vars: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         unused: true,
     }
     input: {
@@ -397,7 +309,7 @@ issue_2319_3: {
 issue_2425_1: {
     options = {
         collapse_vars: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         unused: true,
     }
     input: {
@@ -420,7 +332,7 @@ issue_2425_1: {
 issue_2425_2: {
     options = {
         collapse_vars: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         unused: true,
     }
     input: {
@@ -443,7 +355,7 @@ issue_2425_2: {
 issue_2425_3: {
     options = {
         collapse_vars: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         unused: true,
     }
     input: {
@@ -466,7 +378,7 @@ issue_2425_3: {
 issue_2436_13: {
     options = {
         collapse_vars: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         passes: 2,
         reduce_vars: true,
         unused: true,
@@ -500,7 +412,7 @@ issue_2436_13: {
 issue_2506: {
     options = {
         collapse_vars: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         passes: 2,
         reduce_vars: true,
         unused: true,
@@ -526,7 +438,7 @@ issue_2506: {
         function f0(bar) {
             (function() {
                 (function() {
-                    if (false <= 0/0 & this >> 1 >= 0)
+                    if (false <= NaN & this >> 1 >= 0)
                         c++;
                 })(c++);
             })();
@@ -539,7 +451,7 @@ issue_2506: {
 
 issue_2226_1: {
     options = {
-        keep_fargs: "strict",
+        keep_fargs: false,
         side_effects: true,
         unused: true,
     }
@@ -586,7 +498,7 @@ issue_2226_1: {
 issue_2226_2: {
     options = {
         collapse_vars: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         sequences: true,
         side_effects: true,
         unused: true,
@@ -608,7 +520,7 @@ issue_2226_2: {
 issue_2226_3: {
     options = {
         collapse_vars: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         side_effects: true,
         unused: true,
     }
@@ -628,7 +540,7 @@ issue_2226_3: {
 
 issue_3192: {
     options = {
-        keep_fargs: "strict",
+        keep_fargs: false,
         unused: true,
     }
     input: {
@@ -658,7 +570,7 @@ issue_3192: {
 if_increment: {
     options = {
         evaluate: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         reduce_vars: true,
         unused: true,
     }
@@ -680,7 +592,7 @@ if_increment: {
 try_increment: {
     options = {
         evaluate: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         reduce_vars: true,
         unused: true,
     }
@@ -704,7 +616,7 @@ try_increment: {
 issue_2630_3: {
     options = {
         inline: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         reduce_vars: true,
         unused: true,
     }
@@ -741,7 +653,7 @@ issue_2630_3: {
 issue_3364: {
     options = {
         functions: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         reduce_vars: true,
         toplevel: true,
         unused: true,
@@ -806,7 +718,7 @@ issue_3364: {
 
 defun_label: {
     options = {
-        keep_fargs: "strict",
+        keep_fargs: false,
         passes: 2,
         reduce_funcs: true,
         reduce_vars: true,
@@ -838,7 +750,7 @@ defun_label: {
 
 iife_func_side_effects: {
     options = {
-        keep_fargs: "strict",
+        keep_fargs: false,
         reduce_funcs: true,
         reduce_vars: true,
         unused: true,
@@ -890,7 +802,7 @@ iife_func_side_effects: {
 issue_1595_1: {
     options = {
         evaluate: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         reduce_funcs: true,
         reduce_vars: true,
         unused: true,
@@ -910,7 +822,7 @@ issue_1595_1: {
 issue_1595_2: {
     options = {
         evaluate: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         reduce_funcs: true,
         reduce_vars: true,
         unused: true,
@@ -930,7 +842,7 @@ issue_1595_2: {
 issue_1595_3: {
     options = {
         evaluate: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         passes: 2,
         reduce_funcs: true,
         reduce_vars: true,
@@ -951,7 +863,7 @@ issue_1595_3: {
 issue_1595_4: {
     options = {
         evaluate: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         reduce_funcs: true,
         reduce_vars: true,
         unused: true,
@@ -973,7 +885,7 @@ issue_1595_4: {
 
 duplicate_lambda_defun_name_1: {
     options = {
-        keep_fargs: "strict",
+        keep_fargs: false,
         reduce_vars: true,
     }
     input: {
@@ -993,7 +905,7 @@ duplicate_lambda_defun_name_1: {
 
 duplicate_lambda_defun_name_2: {
     options = {
-        keep_fargs: "strict",
+        keep_fargs: false,
         passes: 2,
         reduce_vars: true,
         unused: true,
@@ -1014,7 +926,7 @@ duplicate_lambda_defun_name_2: {
 
 function_name_mangle: {
     options = {
-        keep_fargs: "strict",
+        keep_fargs: false,
         keep_fnames: true,
         reduce_vars: true,
         unused: true,
@@ -1032,7 +944,7 @@ function_name_mangle: {
 
 function_name_mangle_ie8: {
     options = {
-        keep_fargs: "strict",
+        keep_fargs: false,
         keep_fnames: true,
         reduce_vars: true,
         unused: true,
@@ -1053,7 +965,7 @@ function_name_mangle_ie8: {
 
 issue_3420_1: {
     options = {
-        keep_fargs: "strict",
+        keep_fargs: false,
         unused: true,
     }
     input: {
@@ -1076,7 +988,7 @@ issue_3420_1: {
 issue_3420_2: {
     options = {
         inline: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         unused: true,
     }
     input: {
@@ -1097,7 +1009,7 @@ issue_3420_2: {
 issue_3420_3: {
     options = {
         inline: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         reduce_vars: true,
         unused: true,
     }
@@ -1119,7 +1031,7 @@ issue_3420_3: {
 
 issue_3423_1: {
     options = {
-        keep_fargs: "strict",
+        keep_fargs: false,
         unused: true,
     }
     input: {
@@ -1139,7 +1051,7 @@ issue_3423_1: {
 
 issue_3423_2: {
     options = {
-        keep_fargs: "strict",
+        keep_fargs: false,
         unused: true,
     }
     input: {
@@ -1166,7 +1078,7 @@ collapse_vars_repeated: {
         hoist_funs: true,
         if_return: true,
         join_vars: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         loops: true,
         properties: true,
         reduce_funcs: true,
@@ -1213,7 +1125,7 @@ collapse_vars_repeated: {
 chained_3: {
     options = {
         collapse_vars: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         unused: true,
     }
     input: {
@@ -1237,7 +1149,7 @@ replace_all_var_scope: {
     rename = true
     options = {
         collapse_vars: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         unused: true,
     }
     mangle = {}
@@ -1266,7 +1178,7 @@ replace_all_var_scope: {
 
 issue_1583: {
     options = {
-        keep_fargs: "strict",
+        keep_fargs: false,
         passes: 2,
         reduce_funcs: true,
         reduce_vars: true,
@@ -1303,7 +1215,7 @@ issues_3267_1: {
         dead_code: true,
         evaluate: true,
         inline: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         reduce_vars: true,
         sequences: true,
         side_effects: true,
@@ -1332,7 +1244,7 @@ issues_3267_1: {
 
 trailing_argument_side_effects: {
     options = {
-        keep_fargs: "strict",
+        keep_fargs: false,
         unused: true,
     }
     input: {
@@ -1356,7 +1268,7 @@ trailing_argument_side_effects: {
 
 recursive_iife_1: {
     options = {
-        keep_fargs: "strict",
+        keep_fargs: false,
         reduce_vars: true,
         unused: true,
     }
@@ -1375,7 +1287,7 @@ recursive_iife_1: {
 
 recursive_iife_2: {
     options = {
-        keep_fargs: "strict",
+        keep_fargs: false,
         reduce_vars: true,
         unused: true,
     }
@@ -1453,3 +1365,37 @@ issue_3619: {
     }
     expect_stdout: "PASS"
 }
+
+issue_4353_1: {
+    options = {
+        keep_fargs: false,
+        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: false,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        (function f(a) {
+            while (console.log("PASS"));
+        })();
+    }
+    expect: {
+        (function() {
+            while (console.log("PASS"));
+        })();
+    }
+    expect_stdout: "PASS"
+}

test/compress/labels.js

@@ -207,3 +207,123 @@ labels_10: {
         }
     }
 }
+
+issue_4466_1: {
+    mangle = {
+        v8: false,
+    }
+    input: {
+        A: if (console.log("PASS"))
+            B:;
+        else
+            C:;
+    }
+    expect: {
+        e: if (console.log("PASS"))
+            l:;
+        else
+            l:;
+    }
+    expect_stdout: "PASS"
+    node_version: ">=12"
+}
+
+issue_4466_1_v8: {
+    mangle = {
+        v8: true,
+    }
+    input: {
+        A: if (console.log("PASS"))
+            B:;
+        else
+            C:;
+    }
+    expect: {
+        e: if (console.log("PASS"))
+            l:;
+        else
+            o:;
+    }
+    expect_stdout: "PASS"
+    node_version: ">=12"
+}
+
+issue_4466_2: {
+    mangle = {
+        toplevel: false,
+        v8: false,
+    }
+    input: {
+        if (console.log("PASS"))
+            A:;
+        else
+            B:;
+    }
+    expect: {
+        if (console.log("PASS"))
+            e:;
+        else
+            e:;
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4466_2_v8: {
+    mangle = {
+        toplevel: false,
+        v8: true,
+    }
+    input: {
+        if (console.log("PASS"))
+            A:;
+        else
+            B:;
+    }
+    expect: {
+        if (console.log("PASS"))
+            e:;
+        else
+            l:;
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4466_2_toplevel: {
+    mangle = {
+        toplevel: true,
+        v8: false,
+    }
+    input: {
+        if (console.log("PASS"))
+            A:;
+        else
+            B:;
+    }
+    expect: {
+        if (console.log("PASS"))
+            e:;
+        else
+            e:;
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4466_2_toplevel_v8: {
+    mangle = {
+        toplevel: true,
+        v8: true,
+    }
+    input: {
+        if (console.log("PASS"))
+            A:;
+        else
+            B:;
+    }
+    expect: {
+        if (console.log("PASS"))
+            e:;
+        else
+            e:;
+    }
+    expect_stdout: "PASS"
+}

test/compress/loops.js

@@ -201,7 +201,7 @@ evaluate: {
     }
 }
 
-issue_1532: {
+issue_1532_1: {
     options = {
         evaluate: true,
         loops: true,
@@ -210,18 +210,56 @@ issue_1532: {
         function f(x, y) {
             do {
                 if (x) break;
-                foo();
+                console.log(y);
             } while (false);
         }
+        f(null, "PASS");
+        f(42, "FAIL");
+    }
+    expect: {
+        function f(x, y) {
+            for (; !x && (console.log(y), false););
+        }
+        f(null, "PASS");
+        f(42, "FAIL");
+    }
+    expect_stdout: "PASS"
+}
+
+issue_1532_2: {
+    options = {
+        evaluate: true,
+        loops: true,
+    }
+    input: {
+        function f(x, y) {
+            do {
+                if (x) {
+                    console.log(x);
+                    break;
+                }
+                console.log(y);
+            } while (false);
+        }
+        f(null, "PASS");
+        f(42, "FAIL");
     }
     expect: {
         function f(x, y) {
             do {
-                if (x) break;
-                foo();
-            } while (false);
+                if (x) {
+                    console.log(x);
+                    break;
+                }
+            } while (console.log(y), false);
         }
+        f(null, "PASS");
+        f(42, "FAIL");
     }
+    expect_stdout: [
+        "PASS",
+        "42",
+    ]
 }
 
 issue_186: {
@@ -509,8 +547,8 @@ dead_code_condition: {
         console.log(a);
     }
     expect: {
-        var c;
         var a = 0, b = 5;
+        var c;
         a += 1, 0,
         console.log(a);
     }
@@ -756,10 +794,55 @@ empty_for_in_side_effects: {
     expect_warnings: [
         "WARN: Dropping unused variable b [test/compress/loops.js:4,16]",
         "INFO: Dropping unused loop variable a [test/compress/loops.js:1,17]",
-        "WARN: Side effects in object of for-in loop [test/compress/loops.js:1,17]",
+        "WARN: Side effects in object of for-in loop [test/compress/loops.js:2,17]",
     ]
 }
 
+empty_for_in_prop_init: {
+    options = {
+        loops: true,
+        pure_getters: "strict",
+        unused: true,
+    }
+    input: {
+        console.log(function f() {
+            var a = "bar";
+            for ((a, f)[a] in console.log("foo"));
+            return a;
+        }());
+    }
+    expect: {
+        console.log(function() {
+            var a = "bar";
+            console.log("foo");
+            return a;
+        }());
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+    ]
+    expect_warnings: [
+        "INFO: Dropping unused loop variable f [test/compress/loops.js:3,21]",
+        "WARN: Side effects in object of for-in loop [test/compress/loops.js:3,30]",
+    ]
+}
+
+for_of: {
+    input: {
+        var async = [ "PASS", 42 ];
+        async.p = "FAIL";
+        for (async of (null, async))
+            console.log(async);
+    }
+    expect_exact: 'var async=["PASS",42];async.p="FAIL";for(async of(null,async))console.log(async);'
+    expect_stdout: [
+        "PASS",
+        "42",
+    ]
+    node_version: ">=0.12"
+}
+
 issue_3631_1: {
     options = {
         dead_code: true,
@@ -933,3 +1016,312 @@ issue_3634_2: {
     }
     expect_stdout: "1"
 }
+
+issue_4075: {
+    options = {
+        loops: true,
+        unused: true,
+    }
+    input: {
+        var a = "FAIL";
+        (function() {
+            for (a in { PASS: 0 });
+        })()
+        console.log(a);
+    }
+    expect: {
+        var a = "FAIL";
+        (function() {
+            for (a in { PASS: 0 });
+        })()
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4082: {
+    options = {
+        keep_fargs: false,
+        loops: true,
+        unused: true,
+    }
+    input: {
+        var a = "PASS";
+        (function(a) {
+            for (a in "foo")
+                var b;
+        })();
+        console.log(a);
+    }
+    expect: {
+        var a = "PASS";
+        (function(a) {
+            for (a in "foo");
+        })();
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4084: {
+    options = {
+        keep_fargs: false,
+        loops: true,
+        passes: 2,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        console.log(function() {
+            function f(a) {
+                var b = a++;
+                for (a in "foo");
+            }
+            f();
+            return typeof a;
+        }());
+    }
+    expect: {
+        console.log(function() {
+            (function() {
+                0;
+            })();
+            return typeof a;
+        }());
+    }
+    expect_stdout: "undefined"
+}
+
+issue_4091_1: {
+    options = {
+        loops: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        try {
+            throw "FAIL";
+        } catch (e) {
+            for (var e in 42);
+        }
+        console.log(e && e);
+    }
+    expect: {
+        try {
+            throw "FAIL";
+        } catch (e) {
+            var e;
+        }
+        console.log(e && e);
+    }
+    expect_stdout: "undefined"
+}
+
+issue_4091_2: {
+    options = {
+        loops: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        try {
+            throw "FAIL";
+        } catch (e) {
+            for (e in 42);
+            var e;
+        }
+        console.log(e && e);
+    }
+    expect: {
+        try {
+            throw "FAIL";
+        } catch (e) {
+            var e;
+        }
+        console.log(e && e);
+    }
+    expect_stdout: "undefined"
+}
+
+issue_4182_1: {
+    options = {
+        loops: true,
+    }
+    input: {
+        (function() {
+            do {
+                try {
+                    return;
+                } finally {
+                    continue;
+                }
+                console.log("FAIL");
+            } while (0);
+            console.log("PASS");
+        })();
+    }
+    expect: {
+        (function() {
+            do {
+                try {
+                    return;
+                } finally {
+                    continue;
+                }
+                console.log("FAIL");
+            } while (0);
+            console.log("PASS");
+        })();
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4182_2: {
+    options = {
+        loops: true,
+    }
+    input: {
+        (function() {
+            L: do {
+                do {
+                    try {
+                        return;
+                    } finally {
+                        continue L;
+                    }
+                    console.log("FAIL");
+                } while (0);
+                console.log("FAIL");
+            } while (0);
+            console.log("PASS");
+        })();
+    }
+    expect: {
+        (function() {
+            L: do {
+                do {
+                    try {
+                        return;
+                    } finally {
+                        continue L;
+                    }
+                } while (console.log("FAIL"), 0);
+                console.log("FAIL");
+            } while (0);
+            console.log("PASS");
+        })();
+    }
+    expect_stdout: "PASS"
+}
+
+do_continue: {
+    options = {
+        loops: true,
+    }
+    input: {
+        try {
+            do {
+                continue;
+            } while ([ A ]);
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect: {
+        try {
+            do {
+                continue;
+            } while ([ A ]);
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4240: {
+    options = {
+        loops: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        (function(a) {
+            function f() {
+                var o = { PASS: 42 };
+                for (a in o);
+            }
+            (function() {
+                if (f());
+            })();
+            console.log(a);
+        })();
+    }
+    expect: {
+        (function(a) {
+            (function() {
+                if (function() {
+                    for (a in { PASS: 42 });
+                }());
+            })();
+            console.log(a);
+        })();
+    }
+    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"
+}
+
+issue_4564: {
+    options = {
+        loops: true,
+        unused: true,
+    }
+    input: {
+        try {
+            throw null;
+        } catch (a) {
+            var a;
+            (function() {
+                for (a in "foo");
+            })();
+            console.log(a);
+        }
+    }
+    expect: {
+        try {
+            throw null;
+        } catch (a) {
+            var a;
+            (function() {
+                for (a in "foo");
+            })();
+            console.log(a);
+        }
+    }
+    expect_stdout: "2"
+}

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: {
@@ -91,7 +142,7 @@ evaluate_1: {
     expect: {
         console.log(
             x + 1 + 2,
-            2 * x,
+            2 * +x,
             +x + 1 + 2,
             1 + x + 2 + 3,
             3 | x,
@@ -130,7 +181,7 @@ evaluate_1_unsafe_math: {
     expect: {
         console.log(
             x + 1 + 2,
-            2 * x,
+            2 * +x,
             +x + 3,
             1 + x + 2 + 3,
             3 | x,
@@ -148,45 +199,52 @@ evaluate_1_unsafe_math: {
 evaluate_2: {
     options = {
         evaluate: true,
+        reduce_vars: true,
         unsafe_math: false,
     }
     input: {
-        var x = "42", y = null;
-        [
-            x + 1 + 2,
-            x * 1 * 2,
-            +x + 1 + 2,
-            1 + x + 2 + 3,
-            1 | x | 2 | 3,
-            1 + x-- + 2 + 3,
-            1 + (x*y + 2) + 3,
-            1 + (2 + x + 3),
-            1 + (2 + ~x + 3),
-            -y + (2 + ~x + 3),
-            1 & (2 & x & 3),
-            1 + (2 + (x |= 0) + 3),
-        ].forEach(function(n) {
-            console.log(typeof n, n);
-        });
+        function f(num) {
+            var x = "" + num, y = null;
+            [
+                x + 1 + 2,
+                x * 1 * 2,
+                +x + 1 + 2,
+                1 + x + 2 + 3,
+                1 | x | 2 | 3,
+                1 + x-- + 2 + 3,
+                1 + (x*y + 2) + 3,
+                1 + (2 + x + 3),
+                1 + (2 + ~x + 3),
+                -y + (2 + ~x + 3),
+                1 & (2 & x & 3),
+                1 + (2 + (x |= 0) + 3),
+            ].forEach(function(n) {
+                console.log(typeof n, n);
+            });
+        }
+        f(42);
     }
     expect: {
-        var x = "42", y = null;
-        [
-            x + 1 + 2,
-            2 * x,
-            +x + 1 + 2,
-            1 + x + 2 + 3,
-            3 | x,
-            1 + x-- + 2 + 3,
-            x*y + 2 + 1 + 3,
-            1 + (2 + x + 3),
-            2 + ~x + 3 + 1,
-            2 + ~x + 3 - y,
-            0 & x,
-            2 + (x |= 0) + 3 + 1,
-        ].forEach(function(n) {
-            console.log(typeof n, n);
-        });
+        function f(num) {
+            var x = "" + num, y = null;
+            [
+                x + "12",
+                2 * x,
+                +x + 1 + 2,
+                1 + x + "23",
+                3 | x,
+                1 + x-- + 2 + 3,
+                x*y + 2 + 1 + 3,
+                2 + x + 3 + 1,
+                2 + ~x + 3 + 1,
+                2 + ~x + 3,
+                0 & x,
+                2 + (x |= 0) + 3 + 1,
+            ].forEach(function(n) {
+                console.log(typeof n, n);
+            });
+        }
+        f(42);
     }
     expect_stdout: [
         "string 4212",
@@ -207,45 +265,52 @@ evaluate_2: {
 evaluate_2_unsafe_math: {
     options = {
         evaluate: true,
+        reduce_vars: true,
         unsafe_math: true,
     }
     input: {
-        var x = "42", y = null;
-        [
-            x + 1 + 2,
-            x * 1 * 2,
-            +x + 1 + 2,
-            1 + x + 2 + 3,
-            1 | x | 2 | 3,
-            1 + x-- + 2 + 3,
-            1 + (x*y + 2) + 3,
-            1 + (2 + x + 3),
-            1 + (2 + ~x + 3),
-            -y + (2 + ~x + 3),
-            1 & (2 & x & 3),
-            1 + (2 + (x |= 0) + 3),
-        ].forEach(function(n) {
-            console.log(typeof n, n);
-        });
+        function f(num) {
+            var x = "" + num, y = null;
+            [
+                x + 1 + 2,
+                x * 1 * 2,
+                +x + 1 + 2,
+                1 + x + 2 + 3,
+                1 | x | 2 | 3,
+                1 + x-- + 2 + 3,
+                1 + (x*y + 2) + 3,
+                1 + (2 + x + 3),
+                1 + (2 + ~x + 3),
+                -y + (2 + ~x + 3),
+                1 & (2 & x & 3),
+                1 + (2 + (x |= 0) + 3),
+            ].forEach(function(n) {
+                console.log(typeof n, n);
+            });
+        }
+        f(42);
     }
     expect: {
-        var x = "42", y = null;
-        [
-            x + 1 + 2,
-            2 * x,
-            +x + 3,
-            1 + x + 2 + 3,
-            3 | x,
-            6 + x--,
-            x*y + 6,
-            1 + (2 + x + 3),
-            6 + ~x,
-            5 + ~x - y,
-            0 & x,
-            6 + (x |= 0),
-        ].forEach(function(n) {
-            console.log(typeof n, n);
-        });
+        function f(num) {
+            var x = "" + num, y = null;
+            [
+                x + "12",
+                2 * x,
+                +x + 3,
+                1 + x + "23",
+                3 | x,
+                6 + x--,
+                x*y + 6,
+                6 + x,
+                6 + ~x,
+                5 + ~x,
+                0 & x,
+                6 + (x |= 0),
+            ].forEach(function(n) {
+                console.log(typeof n, n);
+            });
+        }
+        f(42);
     }
     expect_stdout: [
         "string 4212",
@@ -273,7 +338,7 @@ evaluate_3: {
         console.log(1 + Number(x) + 2);
     }
     expect: {
-        console.log(+x + 3);
+        console.log(+("" + x) + 3);
     }
 }
 
@@ -310,45 +375,52 @@ evaluate_4: {
 evaluate_5: {
     options = {
         evaluate: true,
+        reduce_vars: true,
         unsafe_math: false,
     }
     input: {
-        var a = "1";
-        [
-            +a + 2 + 3,
-            +a + 2 - 3,
-            +a - 2 + 3,
-            +a - 2 - 3,
-            2 + +a + 3,
-            2 + +a - 3,
-            2 - +a + 3,
-            2 - +a - 3,
-            2 + 3 + +a,
-            2 + 3 - +a,
-            2 - 3 + +a,
-            2 - 3 - +a,
-        ].forEach(function(n) {
-            console.log(typeof n, n);
-        });
+        function f(num) {
+            var a = "" + num;
+            [
+                +a + 2 + 3,
+                +a + 2 - 3,
+                +a - 2 + 3,
+                +a - 2 - 3,
+                2 + +a + 3,
+                2 + +a - 3,
+                2 - +a + 3,
+                2 - +a - 3,
+                2 + 3 + +a,
+                2 + 3 - +a,
+                2 - 3 + +a,
+                2 - 3 - +a,
+            ].forEach(function(n) {
+                console.log(typeof n, n);
+            });
+        }
+        f(1);
     }
     expect: {
-        var a = "1";
-        [
-            +a + 2 + 3,
-            +a + 2 - 3,
-            a - 2 + 3,
-            a - 2 - 3,
-            +a + 2 + 3,
-            +a + 2 - 3,
-            2 - a + 3,
-            2 - a - 3,
-            +a + 5,
-            5 - a,
-            +a - 1,
-            -1 - a,
-        ].forEach(function(n) {
-            console.log(typeof n, n);
-        });
+        function f(num) {
+            var a = "" + num;
+            [
+                +a + 2 + 3,
+                +a + 2 - 3,
+                a - 2 + 3,
+                a - 2 - 3,
+                +a + 2 + 3,
+                +a + 2 - 3,
+                2 - a + 3,
+                2 - a - 3,
+                +a + 5,
+                5 - a,
+                +a - 1,
+                -1 - a,
+            ].forEach(function(n) {
+                console.log(typeof n, n);
+            });
+        }
+        f(1);
     }
     expect_stdout: [
         "number 6",
@@ -369,45 +441,52 @@ evaluate_5: {
 evaluate_5_unsafe_math: {
     options = {
         evaluate: true,
+        reduce_vars: true,
         unsafe_math: true,
     }
     input: {
-        var a = "1";
-        [
-            +a + 2 + 3,
-            +a + 2 - 3,
-            +a - 2 + 3,
-            +a - 2 - 3,
-            2 + +a + 3,
-            2 + +a - 3,
-            2 - +a + 3,
-            2 - +a - 3,
-            2 + 3 + +a,
-            2 + 3 - +a,
-            2 - 3 + +a,
-            2 - 3 - +a,
-        ].forEach(function(n) {
-            console.log(typeof n, n);
-        });
+        function f(num) {
+            var a = "" + num;
+            [
+                +a + 2 + 3,
+                +a + 2 - 3,
+                +a - 2 + 3,
+                +a - 2 - 3,
+                2 + +a + 3,
+                2 + +a - 3,
+                2 - +a + 3,
+                2 - +a - 3,
+                2 + 3 + +a,
+                2 + 3 - +a,
+                2 - 3 + +a,
+                2 - 3 - +a,
+            ].forEach(function(n) {
+                console.log(typeof n, n);
+            });
+        }
+        f(1);
     }
     expect: {
-        var a = "1";
-        [
-            +a + 5,
-            +a + -1,
-            a - -1,
-            a - 5,
-            +a + 5,
-            +a + -1,
-            5 - a,
-            -1 - a,
-            +a + 5,
-            5 - a,
-            +a - 1,
-            -1 - a,
-        ].forEach(function(n) {
-            console.log(typeof n, n);
-        });
+        function f(num) {
+            var a = "" + num;
+            [
+                +a + 5,
+                +a + -1,
+                a - -1,
+                a - 5,
+                +a + 5,
+                +a + -1,
+                5 - a,
+                -1 - a,
+                +a + 5,
+                5 - a,
+                +a - 1,
+                -1 - a,
+            ].forEach(function(n) {
+                console.log(typeof n, n);
+            });
+        }
+        f(1);
     }
     expect_stdout: [
         "number 6",
@@ -546,37 +625,44 @@ evaluate_6_unsafe_math: {
 evaluate_7: {
     options = {
         evaluate: true,
+        reduce_vars: true,
         unsafe_math: false,
     }
     input: {
-        var x = "42", y;
-        [
-            +x + 2 + (3 + !y),
-            +x + 2 + (3 - !y),
-            +x + 2 - (3 + !y),
-            +x + 2 - (3 - !y),
-            +x - 2 + (3 + !y),
-            +x - 2 + (3 - !y),
-            +x - 2 - (3 + !y),
-            +x - 2 - (3 - !y),
-        ].forEach(function(n) {
-            console.log(typeof n, n);
-        });
+        function f(num, y) {
+            var x = "" + num;
+            [
+                +x + 2 + (3 + !y),
+                +x + 2 + (3 - !y),
+                +x + 2 - (3 + !y),
+                +x + 2 - (3 - !y),
+                +x - 2 + (3 + !y),
+                +x - 2 + (3 - !y),
+                +x - 2 - (3 + !y),
+                +x - 2 - (3 - !y),
+            ].forEach(function(n) {
+                console.log(typeof n, n);
+            });
+        }
+        f(42);
     }
     expect: {
-        var x = "42", y;
-        [
-            +x + 2 + (3 + !y),
-            +x + 2 + (3 - !y),
-            +x + 2 - (3 + !y),
-            +x + 2 - (3 - !y),
-            x - 2 + (3 + !y),
-            x - 2 + (3 - !y),
-            x - 2 - (3 + !y),
-            x - 2 - (3 - !y),
-        ].forEach(function(n) {
-            console.log(typeof n, n);
-        });
+        function f(num, y) {
+            var x = "" + num;
+            [
+                +x + 2 + (3 + !y),
+                +x + 2 + (3 - !y),
+                +x + 2 - (3 + !y),
+                +x + 2 - (3 - !y),
+                x - 2 + (3 + !y),
+                x - 2 + (3 - !y),
+                x - 2 - (3 + !y),
+                x - 2 - (3 - !y),
+            ].forEach(function(n) {
+                console.log(typeof n, n);
+            });
+        }
+        f(42);
     }
     expect_stdout: [
         "number 48",
@@ -593,37 +679,44 @@ evaluate_7: {
 evaluate_7_unsafe_math: {
     options = {
         evaluate: true,
+        reduce_vars: true,
         unsafe_math: true,
     }
     input: {
-        var x = "42", y;
-        [
-            +x + 2 + (3 + !y),
-            +x + 2 + (3 - !y),
-            +x + 2 - (3 + !y),
-            +x + 2 - (3 - !y),
-            +x - 2 + (3 + !y),
-            +x - 2 + (3 - !y),
-            +x - 2 - (3 + !y),
-            +x - 2 - (3 - !y),
-        ].forEach(function(n) {
-            console.log(typeof n, n);
-        });
+        function f(num, y) {
+            var x = "" + num;
+            [
+                +x + 2 + (3 + !y),
+                +x + 2 + (3 - !y),
+                +x + 2 - (3 + !y),
+                +x + 2 - (3 - !y),
+                +x - 2 + (3 + !y),
+                +x - 2 + (3 - !y),
+                +x - 2 - (3 + !y),
+                +x - 2 - (3 - !y),
+            ].forEach(function(n) {
+                console.log(typeof n, n);
+            });
+        }
+        f(42);
     }
     expect: {
-        var x = "42", y;
-        [
-            +x + 5 + !y,
-            +x + 5 - !y,
-            +x + -1 - !y,
-            +x + -1 + !y,
-            x - -1 + !y,
-            x - -1 - !y,
-            x - 5 - !y,
-            x - 5 + !y,
-        ].forEach(function(n) {
-            console.log(typeof n, n);
-        });
+        function f(num, y) {
+            var x = "" + num;
+            [
+                +x + 5 + !y,
+                +x + 5 - !y,
+                +x + -1 - !y,
+                +x + -1 + !y,
+                x - -1 + !y,
+                x - -1 - !y,
+                x - 5 - !y,
+                x - 5 + !y,
+            ].forEach(function(n) {
+                console.log(typeof n, n);
+            });
+        }
+        f(42);
     }
     expect_stdout: [
         "number 48",
@@ -637,6 +730,22 @@ evaluate_7_unsafe_math: {
     ]
 }
 
+evaluate_8_unsafe_math: {
+    options = {
+        evaluate: true,
+        unsafe_math: true,
+    }
+    input: {
+        var a = [ "42" ];
+        console.log(a * (1 / 7));
+    }
+    expect: {
+        var a = [ "42" ];
+        console.log(+a / 7);
+    }
+    expect_stdout: "6"
+}
+
 NaN_redefined: {
     options = {
         evaluate: true,
@@ -1251,3 +1360,101 @@ issue_3695: {
     }
     expect_stdout: "NaN"
 }
+
+issue_4137: {
+    options = {
+        evaluate: true,
+    }
+    input: {
+        console.log(+(A = []) * (A[0] = 1));
+    }
+    expect: {
+        console.log(+(A = []) * (A[0] = 1));
+    }
+    expect_stdout: "0"
+}
+
+issue_4142: {
+    options = {
+        evaluate: true,
+    }
+    input: {
+        console.log("" + +(0 === console));
+    }
+    expect: {
+        console.log("" + +(0 === console));
+    }
+    expect_stdout: "0"
+}
+
+issue_4542_1: {
+    options = {
+        evaluate: true,
+        unsafe_math: true,
+    }
+    input: {
+        console.log(function(a) {
+            return a / (1 / (a[0] = 2));
+        }([ 3 ]));
+    }
+    expect: {
+        console.log(function(a) {
+            return a / (1 / (a[0] = 2));
+        }([ 3 ]));
+    }
+    expect_stdout: "4"
+}
+
+issue_4542_2: {
+    options = {
+        evaluate: true,
+        unsafe_math: true,
+    }
+    input: {
+        console.log(function(a) {
+            return a / (1 / --a[0]);
+        }([ 3 ]));
+    }
+    expect: {
+        console.log(function(a) {
+            return a / (1 / --a[0]);
+        }([ 3 ]));
+    }
+    expect_stdout: "4"
+}
+
+issue_4542_3: {
+    options = {
+        evaluate: true,
+        unsafe_math: true,
+    }
+    input: {
+        console.log(function(a) {
+            return a / (0 / (a[0] = 0, 1));
+        }([ 1 ]));
+    }
+    expect: {
+        console.log(function(a) {
+            return a / (0 / (a[0] = 0, 1));
+        }([ 1 ]));
+    }
+    expect_stdout: "NaN"
+}
+
+issue_4542_4: {
+    options = {
+        evaluate: true,
+        unsafe_math: true,
+    }
+    input: {
+        console.log(function(a) {
+            return a / (1 / (a.length = 1));
+        }([ 2, 3 ]));
+    }
+    expect: {
+        console.log(function(a) {
+            return a / (1 / (a.length = 1));
+        }([ 2, 3 ]));
+    }
+    expect_stdout: "2"
+}

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,237 @@ 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"
+}
+
+shorthand_keywords: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unsafe: true,
+        unused: true,
+    }
+    input: {
+        var async = 1, get = 2, set = 3, o = {
+            async,
+            get,
+            set,
+        };
+        console.log(o.async, o.get, o.set);
+    }
+    expect: {
+        console.log(1, 2, 3);
+    }
+    expect_stdout: "1 2 3"
+    node_version: ">=6"
+}
+
+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"
+}
+
+issue_4415: {
+    options = {
+        evaluate: true,
+        objects: true,
+    }
+    input: {
+        console.log({
+            ["00"]: "FAIL",
+        }[0] || "PASS");
+    }
+    expect: {
+        console.log({
+            "00": "FAIL",
+        }[0] || "PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}

test/compress/properties.js

@@ -130,7 +130,7 @@ evaluate_string_length: {
     }
 }
 
-mangle_properties: {
+mangle_properties_1: {
     mangle = {
         properties: {
             keep_quoted: false,
@@ -152,6 +152,53 @@ mangle_properties: {
     }
 }
 
+mangle_properties_2: {
+    mangle = {
+        properties: {
+            reserved: [
+                "value",
+            ]
+        },
+    }
+    input: {
+        var o = {
+            prop1: 1,
+        };
+        Object.defineProperty(o, "prop2", {
+            value: 2,
+        });
+        Object.defineProperties(o, {
+            prop3: {
+                value: 3,
+            },
+        });
+        console.log("prop1", o.prop1, "prop1" in o);
+        console.log("prop2", o.prop2, o.hasOwnProperty("prop2"));
+        console.log("prop3", o.prop3, Object.getOwnPropertyDescriptor(o, "prop3").value);
+    }
+    expect: {
+        var o = {
+            o: 1,
+        };
+        Object.defineProperty(o, "p", {
+            value: 2,
+        });
+        Object.defineProperties(o, {
+            r: {
+                value: 3,
+            },
+        });
+        console.log("prop1", o.o, "o" in o);
+        console.log("prop2", o.p, o.hasOwnProperty("p"));
+        console.log("prop3", o.r, Object.getOwnPropertyDescriptor(o, "r").value);
+    }
+    expect_stdout: [
+        "prop1 1 true",
+        "prop2 2 true",
+        "prop3 3 3",
+    ]
+}
+
 mangle_unquoted_properties: {
     options = {
         evaluate: true,
@@ -1076,11 +1123,7 @@ new_this: {
             }
         }.f(42);
     }
-    expect: {
-        new function(a) {
-            this.a = a;
-        }(42);
-    }
+    expect: {}
 }
 
 issue_2513: {

test/compress/pure_funcs.js

@@ -685,7 +685,7 @@ issue_3858: {
     options = {
         collapse_vars: true,
         inline: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         unused: true,
     }
     input: {
@@ -711,7 +711,7 @@ inline_pure_call_1: {
     options = {
         collapse_vars: true,
         inline: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         reduce_vars: true,
         sequences: true,
         side_effects: true,
@@ -733,7 +733,7 @@ inline_pure_call_2: {
     options = {
         collapse_vars: true,
         inline: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         reduce_vars: true,
         sequences: true,
         side_effects: true,
@@ -756,7 +756,7 @@ inline_pure_call_3: {
         collapse_vars: true,
         evaluate: true,
         inline: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         passes: 2,
         reduce_vars: true,
         toplevel: true,

test/compress/pure_getters.js

@@ -248,6 +248,35 @@ issue_2110_2: {
     expect_stdout: "function"
 }
 
+issue_2110_3: {
+    options = {
+        collapse_vars: true,
+        pure_getters: "strict",
+        reduce_vars: true,
+    }
+    input: {
+        function g() {
+            return this;
+        }
+        console.log(typeof function() {
+            function f() {}
+            f.g = g;
+            return f.g();
+        }());
+    }
+    expect: {
+        function g() {
+            return this;
+        }
+        console.log(typeof function() {
+            function f() {}
+            f.g = g;
+            return f.g();
+        }());
+    }
+    expect_stdout: "function"
+}
+
 set_immutable_1: {
     options = {
         collapse_vars: true,
@@ -848,9 +877,8 @@ collapse_vars_1_true: {
     }
     expect: {
         function f(a, b) {
-            for (;;) {
+            for (;;)
                 if (a.g() || b.p) break;
-            }
         }
     }
 }
@@ -980,6 +1008,7 @@ collapse_vars_2_strict: {
 collapse_rhs_true: {
     options = {
         collapse_vars: true,
+        evaluate: true,
         pure_getters: true,
     }
     input: {
@@ -1016,6 +1045,7 @@ collapse_rhs_true: {
 collapse_rhs_false: {
     options = {
         collapse_vars: true,
+        evaluate: true,
         pure_getters: false,
     }
     input: {
@@ -1052,6 +1082,7 @@ collapse_rhs_false: {
 collapse_rhs_strict: {
     options = {
         collapse_vars: true,
+        evaluate: true,
         pure_getters: "strict",
     }
     input: {
@@ -1088,6 +1119,7 @@ collapse_rhs_strict: {
 collapse_rhs_setter: {
     options = {
         collapse_vars: true,
+        evaluate: true,
         pure_getters: "strict",
     }
     input: {
@@ -1209,3 +1241,32 @@ issue_3427: {
     expect: {}
     expect_stdout: true
 }
+
+issue_4440: {
+    options = {
+        pure_getters: "strict",
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        try {
+            (function() {
+                arguments = null;
+                console.log(arguments.p = "FAIL");
+            })();
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect: {
+        try {
+            (function() {
+                arguments = null;
+                console.log(arguments.p = "FAIL");
+            })();
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect_stdout: "PASS"
+}

test/compress/reduce_vars.js

@@ -120,7 +120,7 @@ modified: {
     expect: {
         function f0() {
             var b = 2;
-            b++;
+            +b;
             console.log(2);
             console.log(4);
         }
@@ -1624,7 +1624,7 @@ defun_label: {
     expect_stdout: true
 }
 
-double_reference: {
+double_reference_1: {
     options = {
         reduce_funcs: true,
         reduce_vars: true,
@@ -1638,6 +1638,32 @@ double_reference: {
             g();
         }
     }
+    expect: {
+        function f() {
+            var g = function g() {
+                g();
+            };
+            g();
+        }
+    }
+}
+
+double_reference_2: {
+    options = {
+        functions: true,
+        passes: 2,
+        reduce_funcs: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            var g = function g() {
+                g();
+            };
+            g();
+        }
+    }
     expect: {
         function f() {
             (function g() {
@@ -1647,6 +1673,60 @@ double_reference: {
     }
 }
 
+double_reference_3: {
+    options = {
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var x = function f() {
+            return f;
+        };
+        function g() {
+            return x();
+        }
+        console.log(g() === g());
+    }
+    expect: {
+        var x = function f() {
+            return f;
+        };
+        function g() {
+            return x();
+        }
+        console.log(g() === g());
+    }
+    expect_stdout: "true"
+}
+
+double_reference_4: {
+    options = {
+        comparisons: true,
+        functions: true,
+        inline: true,
+        passes: 2,
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var x = function f() {
+            return f;
+        };
+        function g() {
+            return x();
+        }
+        console.log(g() === g());
+    }
+    expect: {
+        console.log(true);
+    }
+    expect_stdout: "true"
+}
+
 iife_arguments_1: {
     options = {
         reduce_funcs: true,
@@ -1686,8 +1766,35 @@ iife_arguments_2: {
     }
     expect: {
         (function() {
-            console.log(function f() {
+            var x = function f() {
                 return f;
+            };
+            console.log(x() === arguments[0]);
+        })();
+    }
+    expect_stdout: true
+}
+
+iife_arguments_3: {
+    options = {
+        functions: true,
+        passes: 2,
+        reduce_funcs: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        (function() {
+            var x = function f() {
+                return f;
+            };
+            console.log(x() === arguments[0]);
+        })();
+    }
+    expect: {
+        (function() {
+            console.log(function x() {
+                return x;
             }() === arguments[0]);
         })();
     }
@@ -1892,7 +1999,7 @@ issue_1606: {
             var a, b;
             function g(){};
             b = 2;
-            x(b);
+            x(2);
         }
     }
 }
@@ -2031,6 +2138,7 @@ issue_1670_4: {
 
 issue_1670_5: {
     options = {
+        conditionals: true,
         dead_code: true,
         evaluate: true,
         keep_fargs: false,
@@ -2062,11 +2170,13 @@ issue_1670_5: {
 
 issue_1670_6: {
     options = {
+        conditionals: true,
         dead_code: true,
         evaluate: true,
         keep_fargs: false,
         reduce_funcs: true,
         reduce_vars: true,
+        sequences: true,
         side_effects: true,
         switches: true,
         unused: true,
@@ -2084,10 +2194,9 @@ issue_1670_6: {
         })(1);
     }
     expect: {
-        (function(a) {
-            a = 1;
-            console.log(a);
-        })(1);
+        (function() {
+            console.log(1);
+        })();
     }
     expect_stdout: "1"
 }
@@ -2264,7 +2373,7 @@ redefine_farg_1: {
         function f(a) {
             return typeof a;
         }
-        function g() {
+        function g(a) {
             return "number";
         }
         function h(a, b) {
@@ -2306,7 +2415,7 @@ redefine_farg_2: {
         console.log(typeof [], "number",function(a, b) {
             a = b;
             return typeof a;
-        }([]));
+        }());
     }
     expect_stdout: "object number undefined"
 }
@@ -2351,6 +2460,7 @@ delay_def: {
         evaluate: true,
         reduce_funcs: true,
         reduce_vars: true,
+        side_effects: true,
         unused: true,
     }
     input: {
@@ -5265,11 +5375,11 @@ defun_catch_4: {
         try {
             throw 42;
         } catch (a) {
+            function a() {}
             console.log(a);
         }
     }
-    expect_stdout: "42"
-    node_version: "<=4"
+    expect_stdout: true
 }
 
 defun_catch_5: {
@@ -5291,10 +5401,10 @@ defun_catch_5: {
             throw 42;
         } catch (a) {
             console.log(a);
+            function a() {}
         }
     }
-    expect_stdout: "42"
-    node_version: "<=4"
+    expect_stdout: true
 }
 
 defun_catch_6: {
@@ -5481,7 +5591,7 @@ lvalues_def_1: {
     }
     expect: {
         var b = 1;
-        var a = b++, b = NaN;
+        var a = +b, b = NaN;
         console.log(a, b);
     }
     expect_stdout: "1 NaN"
@@ -6819,7 +6929,7 @@ issue_3622: {
     options = {
         evaluate: true,
         inline: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         reduce_vars: true,
         sequences: true,
         toplevel: true,
@@ -7087,7 +7197,7 @@ issue_3894: {
 issue_3922: {
     options = {
         evaluate: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         pure_getters: "strict",
         reduce_vars: true,
         side_effects: true,
@@ -7383,3 +7493,141 @@ issue_3974: {
     }
     expect_stdout: "PASS"
 }
+
+issue_4030: {
+    options = {
+        collapse_vars: true,
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a;
+        {
+            delete (a = "PASS");
+            A = "PASS";
+        }
+        console.log(A);
+    }
+    expect: {
+        A = "PASS";
+        console.log(A);
+    }
+    expect_stdout: "PASS"
+}
+
+global_assign: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        A = "FAIL";
+        this.A = "PASS";
+        console.log(A);
+    }
+    expect: {
+        A = "FAIL";
+        this.A = "PASS";
+        console.log(A);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4188_1: {
+    options = {
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        (function() {
+            try {
+                while (A)
+                    var a = function() {}, b = a;
+            } catch (a) {
+                console.log(function() {
+                    return typeof a;
+                }(), typeof b);
+            }
+        })();
+    }
+    expect: {
+        (function() {
+            try {
+                while (A)
+                    var a = function() {}, b = a;
+            } catch (a) {
+                console.log(function() {
+                    return typeof a;
+                }(), typeof b);
+            }
+        })();
+    }
+    expect_stdout: "object undefined"
+}
+
+issue_4188_2: {
+    options = {
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        (function() {
+            try {
+                throw 42;
+            } catch (a) {
+                console.log(function() {
+                    return typeof a;
+                }(), typeof b);
+            }
+            while (!console)
+                var a = function() {}, b = a;
+        })();
+    }
+    expect: {
+        (function() {
+            try {
+                throw 42;
+            } catch (a) {
+                console.log(function() {
+                    return typeof a;
+                }(), typeof b);
+            }
+            while (!console)
+                var a = function() {}, b = a;
+        })();
+    }
+    expect_stdout: "number undefined"
+}
+
+issue_4568: {
+    options = {
+        booleans: true,
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        loops: true,
+        passes: 2,
+        reduce_vars: true,
+        sequences: true,
+        unused: true,
+    }
+    input: {
+        (function(a) {
+            a && console.log("FAIL");
+            if (1)
+                do {
+                    if (!console.log("PASS")) break;
+                } while (1);
+        })(!(0 !== delete NaN));
+    }
+    expect: {
+        (function(a) {
+            for (a && console.log("FAIL"), 1; console.log("PASS"); ) 1;
+        })(!(0 !== delete NaN));
+    }
+    expect_stdout: "PASS"
+}

test/compress/rests.js

@@ -0,0 +1,765 @@
+arrow_1: {
+    input: {
+        console.log.apply(console, ((...a) => a)("PASS", 42));
+    }
+    expect_exact: 'console.log.apply(console,((...a)=>a)("PASS",42));'
+    expect_stdout: "PASS 42"
+    node_version: ">=6"
+}
+
+arrow_2: {
+    input: {
+        console.log.apply(console, ((a, ...b) => b)("FAIL", "PASS", 42));
+    }
+    expect_exact: 'console.log.apply(console,((a,...b)=>b)("FAIL","PASS",42));'
+    expect_stdout: "PASS 42"
+    node_version: ">=6"
+}
+
+arrow_destructured_array_1: {
+    input: {
+        console.log.apply(console, (([ ...a ]) => a)("PASS"));
+    }
+    expect_exact: 'console.log.apply(console,(([...a])=>a)("PASS"));'
+    expect_stdout: "P A S S"
+    node_version: ">=6"
+}
+
+arrow_destructured_array_2: {
+    input: {
+        console.log.apply(console, (([ a, ...b ]) => b)([ "FAIL", "PASS", 42 ]));
+    }
+    expect_exact: 'console.log.apply(console,(([a,...b])=>b)(["FAIL","PASS",42]));'
+    expect_stdout: "PASS 42"
+    node_version: ">=6"
+}
+
+arrow_destructured_array_3: {
+    input: {
+        console.log((([ [ ...a ] = "FAIL" ]) => a)([ "PASS" ]).join("|"));
+    }
+    expect_exact: 'console.log((([[...a]="FAIL"])=>a)(["PASS"]).join("|"));'
+    expect_stdout: "P|A|S|S"
+    node_version: ">=6"
+}
+
+arrow_destructured_object_1: {
+    input: {
+        var f = ({ ...a }) => a, o = f({ PASS: 42 });
+        for (var k in o)
+            console.log(k, o[k]);
+    }
+    expect_exact: "var f=({...a})=>a,o=f({PASS:42});for(var k in o)console.log(k,o[k]);"
+    expect_stdout: "PASS 42"
+    node_version: ">=8"
+}
+
+arrow_destructured_object_2: {
+    input: {
+        var f = ({ FAIL: a, ...b }) => b, o = f({ PASS: 42, FAIL: null });
+        for (var k in o)
+            console.log(k, o[k]);
+    }
+    expect_exact: "var f=({FAIL:a,...b})=>b,o=f({PASS:42,FAIL:null});for(var k in o)console.log(k,o[k]);"
+    expect_stdout: "PASS 42"
+    node_version: ">=8"
+}
+
+arrow_destructured_object_3: {
+    input: {
+        var f = ([ { ...a } = [ "FAIL" ] ]) => a;
+        var o = f([ "PASS" ]);
+        for (var k in o)
+            console.log(k, o[k]);
+    }
+    expect_exact: 'var f=([{...a}=["FAIL"]])=>a;var o=f(["PASS"]);for(var k in o)console.log(k,o[k]);'
+    expect_stdout: [
+        "0 P",
+        "1 A",
+        "2 S",
+        "3 S",
+    ]
+    node_version: ">=8"
+}
+
+funarg_1: {
+    input: {
+        console.log.apply(console, function(...a) {
+            return a;
+        }("PASS", 42));
+    }
+    expect_exact: 'console.log.apply(console,function(...a){return a}("PASS",42));'
+    expect_stdout: "PASS 42"
+    node_version: ">=6"
+}
+
+funarg_2: {
+    input: {
+        console.log.apply(console, function(a, ...b) {
+            return b;
+        }("FAIL", "PASS", 42));
+    }
+    expect_exact: 'console.log.apply(console,function(a,...b){return b}("FAIL","PASS",42));'
+    expect_stdout: "PASS 42"
+    node_version: ">=6"
+}
+
+destructured_array_1: {
+    input: {
+        var [ ...a ] = [ "PASS", 42 ];
+        console.log.apply(console, a);
+    }
+    expect_exact: 'var[...a]=["PASS",42];console.log.apply(console,a);'
+    expect_stdout: "PASS 42"
+    node_version: ">=6"
+}
+
+destructured_array_2: {
+    input: {
+        var [ a, ...b ] = [ "FAIL", "PASS", 42 ];
+        console.log.apply(console, b);
+    }
+    expect_exact: 'var[a,...b]=["FAIL","PASS",42];console.log.apply(console,b);'
+    expect_stdout: "PASS 42"
+    node_version: ">=6"
+}
+
+destructured_object_1: {
+    input: {
+        var { ...a } = [ "FAIL", "PASS", 42 ];
+        console.log(a[1], a[2]);
+    }
+    expect_exact: 'var{...a}=["FAIL","PASS",42];console.log(a[1],a[2]);'
+    expect_stdout: "PASS 42"
+    node_version: ">=8"
+}
+
+destructured_object_2: {
+    input: {
+        var { 0: a, ...b } = [ "FAIL", "PASS", 42 ];
+        console.log(b[1], b[2]);
+    }
+    expect_exact: 'var{0:a,...b}=["FAIL","PASS",42];console.log(b[1],b[2]);'
+    expect_stdout: "PASS 42"
+    node_version: ">=8"
+}
+
+drop_fargs: {
+    options = {
+        keep_fargs: false,
+        rests: true,
+        unused: true,
+    }
+    input: {
+        console.log(function(a, ...b) {
+            return b[0];
+        }("FAIL", "PASS"));
+    }
+    expect: {
+        console.log(function(b) {
+            return b[0];
+        }([ "PASS" ]));
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+inline: {
+    options = {
+        inline: true,
+        toplevel: true,
+    }
+    input: {
+        console.log(function(a, ...[ b, c ]) {
+            return c + b + a;
+        }("SS", "A", "P"));
+    }
+    expect: {
+        console.log(([ a, ...[ b, c ] ] = [ "SS", "A", "P" ], c + b + a));
+        var a, b, c;
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+retain_var: {
+    options = {
+        unused: true,
+    }
+    input: {
+        var [ ...a ] = [ "PASS" ];
+        console.log(a[0]);
+    }
+    expect: {
+        var [ ...a ] = [ "PASS" ];
+        console.log(a[0]);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+reduce_destructured_array: {
+    options = {
+        reduce_vars: true,
+        rests: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var [ ...a ] = [ "PASS" ];
+        console.log(a[0]);
+    }
+    expect: {
+        console.log([ "PASS" ][0]);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+reduce_destructured_object: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var { ...a } = [ "PASS" ];
+        console.log(a[0]);
+    }
+    expect: {
+        var { ...a } = [ "PASS" ];
+        console.log(a[0]);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=8"
+}
+
+retain_destructured_array: {
+    options = {
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var [ a, ...b ] = [ "FAIL", "PASS", 42 ];
+        console.log.apply(console, b);
+    }
+    expect: {
+        var [ , ...b ] = [ "FAIL", "PASS", 42 ];
+        console.log.apply(console, b);
+    }
+    expect_stdout: "PASS 42"
+    node_version: ">=6"
+}
+
+retain_destructured_object_1: {
+    options = {
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var { 0: a, ...b } = [ "FAIL", "PASS", 42 ];
+        for (var k in b)
+            console.log(k, b[k]);
+    }
+    expect: {
+        var { 0: a, ...b } = [ "FAIL", "PASS", 42 ];
+        for (var k in b)
+            console.log(k, b[k]);
+    }
+    expect_stdout: [
+        "1 PASS",
+        "2 42",
+    ]
+    node_version: ">=8"
+}
+
+retain_destructured_object_2: {
+    options = {
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var { foo: [ a ], ...b } = { foo: [ "FAIL" ], bar: "PASS", baz: 42 };
+        for (var k in b)
+            console.log(k, b[k]);
+    }
+    expect: {
+        var { foo: [], ...b } = { foo: [ "FAIL" ], bar: "PASS", baz: 42 };
+        for (var k in b)
+            console.log(k, b[k]);
+    }
+    expect_stdout: [
+        "bar PASS",
+        "baz 42",
+    ]
+    node_version: ">=8"
+}
+
+retain_funarg_destructured_array_1: {
+    options = {
+        inline: true,
+        keep_fargs: false,
+        pure_getters: "strict",
+        unused: true,
+    }
+    input: {
+        console.log((([ ...a ]) => a)([ "PASS" ])[0]);
+    }
+    expect: {
+        console.log((([ ...a ]) => a)([ "PASS" ])[0]);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+retain_funarg_destructured_array_2: {
+    options = {
+        unused: true,
+    }
+    input: {
+        console.log(function([ a, ...b ]) {
+            return b;
+        }("bar")[1]);
+    }
+    expect: {
+        console.log(function([ , ...b ]) {
+            return b;
+        }("bar")[1]);
+    }
+    expect_stdout: "r"
+    node_version: ">=6"
+}
+
+retain_funarg_destructured_object_1: {
+    options = {
+        inline: true,
+        keep_fargs: false,
+        pure_getters: "strict",
+        unused: true,
+    }
+    input: {
+        console.log((({ ...a }) => a)([ "PASS" ])[0]);
+    }
+    expect: {
+        console.log((({ ...a }) => a)([ "PASS" ])[0]);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=8"
+}
+
+retain_funarg_destructured_object_2: {
+    options = {
+        unused: true,
+    }
+    input: {
+        console.log(function({ p: a, ... b }) {
+            return b;
+        }({ p: "FAIL" }).p || "PASS");
+    }
+    expect: {
+        console.log(function({ p: a, ... b }) {
+            return b;
+        }({ p: "FAIL" }).p || "PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=8"
+}
+
+drop_unused_call_args_1: {
+    options = {
+        rests: true,
+        unused: true,
+    }
+    input: {
+        (function(...a) {
+            console.log(a[0]);
+        })(42, console.log("PASS"));
+    }
+    expect: {
+        (function(a) {
+            console.log(a[0]);
+        })([ 42, console.log("PASS") ]);
+    }
+    expect_stdout: [
+        "PASS",
+        "42",
+    ]
+    node_version: ">=6"
+}
+
+drop_unused_call_args_2: {
+    options = {
+        keep_fargs: false,
+        rests: true,
+        unused: true,
+    }
+    input: {
+        console.log(function(a, ...b) {
+            return b;
+        }(console).length);
+    }
+    expect: {
+        console.log(function(b) {
+            return b;
+        }((console, [])).length);
+    }
+    expect_stdout: "0"
+    node_version: ">=6"
+}
+
+merge_funarg: {
+    options = {
+        merge_vars: true,
+    }
+    input: {
+        (function(...a) {
+            var b = a.length;
+            console.log(b);
+        })();
+    }
+    expect: {
+        (function(...b) {
+            var b = b.length;
+            console.log(b);
+        })();
+    }
+    expect_stdout: "0"
+    node_version: ">=6"
+}
+
+merge_funarg_destructured_array: {
+    options = {
+        merge_vars: true,
+    }
+    input: {
+        (function([ ...a ]) {
+            var b = a.length;
+            console.log(b);
+        })([]);
+    }
+    expect: {
+        (function([ ...b ]) {
+            var b = b.length;
+            console.log(b);
+        })([]);
+    }
+    expect_stdout: "0"
+    node_version: ">=6"
+}
+
+merge_funarg_destructured_object: {
+    options = {
+        merge_vars: true,
+    }
+    input: {
+        (function({ ...a }) {
+            var b = a[0];
+            console.log(b);
+        })([ "PASS" ]);
+    }
+    expect: {
+        (function({ ...b }) {
+            var b = b[0];
+            console.log(b);
+        })([ "PASS" ]);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=8"
+}
+
+keep_arguments: {
+    options = {
+        arguments: true,
+        keep_fargs: false,
+    }
+    input: {
+        (function(...[ {} ]) {
+            console.log(arguments[0]);
+        })("PASS");
+    }
+    expect: {
+        (function(...[ {} ]) {
+            console.log(arguments[0]);
+        })("PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+drop_rest_array: {
+    options = {
+        rests: true,
+    }
+    input: {
+        var [ ...[ a ]] = [ "PASS" ];
+        console.log(a);
+    }
+    expect: {
+        var [ a ] = [ "PASS" ];
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+drop_rest_arrow: {
+    options = {
+        arrows: true,
+        keep_fargs: false,
+        reduce_vars: true,
+        rests: true,
+    }
+    input: {
+        console.log(((...[ a ]) => a)("PASS"));
+    }
+    expect: {
+        console.log((a => a)("PASS"));
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+drop_rest_lambda: {
+    options = {
+        keep_fargs: false,
+        reduce_vars: true,
+        rests: true,
+        toplevel: true,
+    }
+    input: {
+        function f(...[ a ]) {
+            return a;
+        }
+        console.log(f("PASS"), f(42));
+    }
+    expect: {
+        function f(a) {
+            return a;
+        }
+        console.log(f("PASS"), f(42));
+    }
+    expect_stdout: "PASS 42"
+    node_version: ">=6"
+}
+
+issue_4525_1: {
+    options = {
+        arguments: true,
+    }
+    input: {
+        console.log(function(a, ...[]) {
+            a = "FAIL";
+            return arguments[0];
+        }("PASS"));
+    }
+    expect: {
+        console.log(function(a, ...[]) {
+            a = "FAIL";
+            return arguments[0];
+        }("PASS"));
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_4525_2: {
+    options = {
+        unused: true,
+    }
+    input: {
+        console.log(function(a, ...[]) {
+            a = "FAIL";
+            return arguments[0];
+        }("PASS"));
+    }
+    expect: {
+        console.log(function(a, ...[]) {
+            a = "FAIL";
+            return arguments[0];
+        }("PASS"));
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_4538: {
+    options = {
+        rests: true,
+        unused: true,
+    }
+    input: {
+        console.log(typeof function f(...a) {
+            return a.p, f;
+        }()());
+    }
+    expect: {
+        console.log(typeof function f(...a) {
+            return a.p, f;
+        }()());
+    }
+    expect_stdout: "function"
+    node_version: ">=6"
+}
+
+issue_4544_1: {
+    options = {
+        keep_fnames: true,
+        side_effects: true,
+    }
+    input: {
+        try {
+            (function f(...[ {} ]) {})();
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect: {
+        try {
+            [ ...[ {} ] ] = [];
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_4544_2: {
+    options = {
+        keep_fnames: true,
+        side_effects: true,
+    }
+    input: {
+        try {
+            (function f(a, ...[ {} ]) {})([]);
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect: {
+        try {
+            [ , ...[ {} ] ] = [ [] ];
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_4562: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        rests: true,
+        unsafe: true,
+    }
+    input: {
+        console.log((([ ...[ a ] ]) => a)("foo"));
+    }
+    expect: {
+        console.log((([ a ]) => a)("foo"));
+    }
+    expect_stdout: "f"
+    node_version: ">=6"
+}
+
+issue_4575: {
+    options = {
+        collapse_vars: true,
+        ie8: true,
+        reduce_vars: true,
+        rests: true,
+        unused: true,
+    }
+    input: {
+        A = "PASS";
+        (function() {
+            var a = 0, b = a;
+            var c = function a(...b) {
+                A;
+                var d = A;
+                console.log(d, b.length);
+            }();
+        })();
+    }
+    expect: {
+        A = "PASS";
+        (function() {
+            (function(b) {
+                A;
+                var d = A;
+                console.log(d, b.length);
+            })([]);
+        })();
+    }
+    expect_stdout: "PASS 0"
+    node_version: ">=6"
+}
+
+issue_4621: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        (function f(a, ...{
+            [console.log(a)]: b,
+        }) {})("PASS");
+    }
+    expect: {
+        (function f(a, ...{
+            [console.log(a)]: b,
+        }) {})("PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_4644_1: {
+    options = {
+        evaluate: true,
+    }
+    input: {
+        var a = "FAIL";
+        (function f(b, ...{
+            [a = "PASS"]: c,
+        }) {
+            return b;
+        })();
+        console.log(a);
+    }
+    expect: {
+        var a = "FAIL";
+        (function f(b, ...{
+            [a = "PASS"]: c,
+        }) {
+            return b;
+        })();
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_4644_2: {
+    options = {
+        evaluate: true,
+        unsafe: true,
+    }
+    input: {
+        console.log(function(...a) {
+            return a[1];
+        }("FAIL", "PASS"), function(...b) {
+            return b.length;
+        }(), function(c, ...d) {
+            return d[0];
+        }("FAIL"));
+    }
+    expect: {
+        console.log("PASS", 0, function(c, ...d) {
+            return d[0];
+        }("FAIL"));
+    }
+    expect_stdout: "PASS 0 undefined"
+    node_version: ">=6"
+}

test/compress/sandbox.js

@@ -13,6 +13,23 @@ console_log: {
     ]
 }
 
+console_log_console: {
+    input: {
+        var log = console.log;
+        log(console);
+        log(typeof console.log);
+    }
+    expect: {
+        var log = console.log;
+        log(console);
+        log(typeof console.log);
+    }
+    expect_stdout: [
+        "{ log: 'function(){}' }",
+        "function",
+    ]
+}
+
 typeof_arguments: {
     options = {
         evaluate: true,
@@ -80,3 +97,78 @@ log_global: {
     }
     expect_stdout: "[object global]"
 }
+
+log_nested: {
+    options = {
+        unused: true,
+    }
+    input: {
+        var o = { p: 42 };
+        for (var i = 0; i < 10; i++)
+            o = {
+                p: o,
+                q: function foo() {},
+            };
+        console.log(o);
+    }
+    expect: {
+        var o = { p: 42 };
+        for (var i = 0; i < 10; i++)
+            o = {
+                p: o,
+                q: function() {},
+            };
+        console.log(o);
+    }
+    expect_stdout: true
+}
+
+timers: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var count = 0, interval = 1000, duration = 3210;
+        var timer = setInterval(function() {
+            console.log(++count);
+        }, interval);
+        setTimeout(function() {
+            clearInterval(timer);
+        }, duration);
+    }
+    expect: {
+        var count = 0;
+        var timer = setInterval(function() {
+            console.log(++count);
+        }, 1000);
+        setTimeout(function() {
+            clearInterval(timer);
+        }, 3210);
+    }
+    expect_stdout: [
+        "1",
+        "2",
+        "3",
+    ]
+    node_version: ">=0.12"
+}
+
+issue_4054: {
+    input: {
+        console.log({
+            set p(v) {
+                throw "FAIL";
+            },
+        });
+    }
+    expect: {
+        console.log({
+            set p(v) {
+                throw "FAIL";
+            },
+        });
+    }
+    expect_stdout: "{ p: [Setter] }"
+}

test/compress/sequences.js

@@ -877,7 +877,7 @@ for_init_var: {
     expect_stdout: "PASS"
 }
 
-forin: {
+forin_1: {
     options = {
         sequences: true,
     }
@@ -895,6 +895,49 @@ forin: {
     expect_stdout: "PASS"
 }
 
+forin_2: {
+    options = {
+        evaluate: true,
+        inline: true,
+        reduce_vars: true,
+        sequences: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var o = {
+            p: 1,
+            q: 2,
+        };
+        var k = "k";
+        for ((console.log("exp"), o)[function() {
+            console.log("prop");
+            return k;
+        }()] in function() {
+            console.log("obj");
+            return o;
+        }())
+            console.log(o.k, o[o.k]);
+    }
+    expect: {
+        var o = {
+            p: 1,
+            q: 2,
+        };
+        for ((console.log("exp"), o)[console.log("prop"), "k"] in console.log("obj"), o)
+            console.log(o.k, o[o.k]);
+    }
+    expect_stdout: [
+        "obj",
+        "exp",
+        "prop",
+        "p 1",
+        "exp",
+        "prop",
+        "q 2",
+    ]
+}
+
 call: {
     options = {
         sequences: true,
@@ -1112,3 +1155,25 @@ issue_3703: {
     }
     expect_stdout: "PASS"
 }
+
+issue_4079: {
+    options = {
+        sequences: true,
+        side_effects: true,
+    }
+    input: {
+        try {
+            typeof (0, A);
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect: {
+        try {
+            A;
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect_stdout: "PASS"
+}

test/compress/side_effects.js

@@ -245,6 +245,31 @@ unsafe_builtin_2: {
     expect_stdout: "object PASS PASS"
 }
 
+unsafe_builtin_3: {
+    options = {
+        conditionals: true,
+        side_effects: true,
+        toplevel: true,
+        unsafe: true,
+    }
+    input: {
+        var o = {};
+        if (42 < Math.random())
+            o.p = "FAIL";
+        else
+            o.p = "PASS";
+        for (var k in o)
+            console.log(k, o[k]);
+    }
+    expect: {
+        var o = {};
+        o.p = 42 < Math.random() ? "FAIL" : "PASS";
+        for (var k in o)
+            console.log(k, o[k]);
+    }
+    expect_stdout: "p PASS"
+}
+
 unsafe_string_replace: {
     options = {
         side_effects: true,
@@ -298,7 +323,7 @@ operator_in: {
     expect_stdout: "PASS"
 }
 
-issue_3983: {
+issue_3983_1: {
     options = {
         collapse_vars: true,
         conditionals: true,
@@ -323,7 +348,161 @@ issue_3983: {
     }
     expect: {
         var a = "PASS";
+        g();
+        function g() {}
         console.log(a);
     }
     expect_stdout: "PASS"
 }
+
+issue_3983_2: {
+    options = {
+        collapse_vars: true,
+        conditionals: true,
+        evaluate: true,
+        inline: true,
+        passes: 2,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = "PASS";
+        function f() {
+            g && g();
+        }
+        f();
+        function g() {
+            0 ? a : 0;
+        }
+        var b = a;
+        console.log(a);
+    }
+    expect: {
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4008: {
+    options = {
+        collapse_vars: true,
+        evaluate: true,
+        inline: true,
+        pure_getters: "strict",
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+    }
+    input: {
+        var a = "PASS";
+        function f(b, b) {
+            console.log(b);
+        }
+        f && f(a && a[a]);
+        console.log(a);
+    }
+    expect: {
+        var a = "PASS";
+        function f(b, b) {
+            console.log(b);
+        }
+        f(a[a]);
+        console.log(a);
+    }
+    expect_stdout: [
+        "undefined",
+        "PASS",
+    ]
+}
+
+trim_new: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        new function(a) {
+            console.log(a);
+        }("PASS");
+    }
+    expect: {
+        (function(a) {
+            console.log(a);
+        })("PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4325: {
+    options = {
+        keep_fargs: false,
+        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/spreads.js

@@ -0,0 +1,949 @@
+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"
+}
+
+conditionals_farg: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        function log(msg) {
+            console.log(msg);
+        }
+        var a = 42, b = [ "PASS" ], c = [ "FAIL" ];
+        a ? log(...b) : log(...c);
+    }
+    expect: {
+        function log(msg) {
+            console.log(msg);
+        }
+        var a = 42, b = [ "PASS" ], c = [ "FAIL" ];
+        log(...a ? b : c);
+    }
+    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,
+        spreads: 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,
+        spreads: true,
+    }
+    input: {
+        (function() {})(...[ console.log("PASS") ]);
+    }
+    expect: {
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+convert_hole: {
+    options = {
+        spreads: 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: false,
+        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,
+        spreads: 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,
+        spreads: 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,
+        spreads: 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,
+        spreads: 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,
+        spreads: 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,
+        spreads: 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,
+        spreads: 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,
+        spreads: 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,
+        spreads: 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,
+        spreads: 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,
+        spreads: true,
+    }
+    input: {
+        ({
+            ...{
+                set [console.log("PASS")](v) {},
+            },
+        });
+    }
+    expect: {
+        ({
+            [console.log("PASS")]: void 0,
+        });
+    }
+    expect_stdout: "PASS"
+    node_version: ">=8"
+}
+
+issue_4556: {
+    options = {
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        console.log(function() {
+            var a = "" + [ a++ ];
+            var b = [ ...a ];
+        }());
+    }
+    expect: {
+        console.log(function() {
+            var a;
+        }());
+    }
+    expect_stdout: "undefined"
+    node_version: ">=6"
+}
+
+issue_4560_1: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var a = 0;
+        (function(...{
+            [a++]: {},
+        }) {})(2);
+        console.log(a);
+    }
+    expect: {
+        var a = 0;
+        (function(...{
+            [a++]: {},
+        }) {})(2);
+        console.log(a);
+    }
+    expect_stdout: "1"
+    node_version: ">=6"
+}
+
+issue_4560_2: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = 0;
+        (function(...{
+            [a++]: {},
+        }) {})(2);
+        console.log(a);
+    }
+    expect: {
+        var a = 0;
+        (function(...{
+            [a++]: {},
+        }) {})(2);
+        console.log(a);
+    }
+    expect_stdout: "1"
+    node_version: ">=6"
+}
+
+issue_4560_3: {
+    options = {
+        collapse_vars: true,
+        reduce_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var a = 0, b;
+        [ ...{
+            [a++]: b,
+        } ] = [ "PASS" ];
+        console.log(b);
+    }
+    expect: {
+        var a = 0, b;
+        [ ...{
+            [a++]: b,
+        } ] = [ "PASS" ];
+        console.log(b);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_4614: {
+    options = {
+        pure_getters: "strict",
+        side_effects: true,
+    }
+    input: {
+        try {
+            (function(...[]) {
+                var arguments;
+                arguments[0];
+            })();
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect: {
+        try {
+            (function(...[]) {
+                var arguments;
+                arguments[0];
+            })();
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect_stdout: true
+    node_version: ">=6"
+}

test/compress/switch.js

@@ -1,5 +1,6 @@
 constant_switch_1: {
     options = {
+        conditionals: true,
         dead_code: true,
         evaluate: true,
         side_effects: true,
@@ -19,6 +20,7 @@ constant_switch_1: {
 
 constant_switch_2: {
     options = {
+        conditionals: true,
         dead_code: true,
         evaluate: true,
         side_effects: true,
@@ -39,6 +41,7 @@ constant_switch_2: {
 
 constant_switch_3: {
     options = {
+        conditionals: true,
         dead_code: true,
         evaluate: true,
         side_effects: true,
@@ -60,6 +63,7 @@ constant_switch_3: {
 
 constant_switch_4: {
     options = {
+        conditionals: true,
         dead_code: true,
         evaluate: true,
         side_effects: true,
@@ -86,6 +90,7 @@ constant_switch_4: {
 
 constant_switch_5: {
     options = {
+        conditionals: true,
         dead_code: true,
         evaluate: true,
         side_effects: true,
@@ -120,6 +125,7 @@ constant_switch_5: {
 
 constant_switch_6: {
     options = {
+        conditionals: true,
         dead_code: true,
         evaluate: true,
         side_effects: true,
@@ -154,6 +160,7 @@ constant_switch_6: {
 
 constant_switch_7: {
     options = {
+        conditionals: true,
         dead_code: true,
         evaluate: true,
         side_effects: true,
@@ -197,6 +204,7 @@ constant_switch_7: {
 
 constant_switch_8: {
     options = {
+        conditionals: true,
         dead_code: true,
         evaluate: true,
         side_effects: true,
@@ -226,6 +234,7 @@ constant_switch_8: {
 
 constant_switch_9: {
     options = {
+        conditionals: true,
         dead_code: true,
         evaluate: true,
         side_effects: true,
@@ -315,6 +324,7 @@ keep_default: {
 
 issue_1663: {
     options = {
+        conditionals: true,
         dead_code: true,
         evaluate: true,
         side_effects: true,
@@ -551,6 +561,7 @@ issue_441_2: {
 
 issue_1674: {
     options = {
+        conditionals: true,
         dead_code: true,
         evaluate: true,
         side_effects: true,
@@ -876,6 +887,7 @@ beautify: {
 
 issue_1758: {
     options = {
+        conditionals: true,
         dead_code: true,
         switches: true,
     }
@@ -898,15 +910,16 @@ issue_1758: {
 
 issue_2535: {
     options = {
+        conditionals: true,
         dead_code: true,
         evaluate: true,
         switches: true,
     }
     input: {
         switch(w(), 42) {
-            case 13: x();
-            case 42: y();
-            default: z();
+          case 13: x();
+          case 42: y();
+          default: z();
         }
     }
     expect: {
@@ -919,6 +932,7 @@ issue_2535: {
 
 issue_1750: {
     options = {
+        conditionals: true,
         dead_code: true,
         evaluate: true,
         switches: true,
@@ -963,6 +977,7 @@ drop_switch_1: {
 
 drop_switch_2: {
     options = {
+        conditionals: true,
         dead_code: true,
         switches: true,
     }
@@ -1007,6 +1022,7 @@ drop_switch_3: {
 
 drop_switch_4: {
     options = {
+        conditionals: true,
         dead_code: true,
         switches: true,
     }
@@ -1028,3 +1044,140 @@ drop_switch_4: {
     }
     expect_stdout: "PASS"
 }
+
+drop_switch_5: {
+    options = {
+        conditionals: true,
+        dead_code: true,
+        switches: true,
+    }
+    input: {
+        switch (A) {
+          case B:
+            x();
+          default:
+        }
+        switch (C) {
+          default:
+            y();
+          case D:
+        }
+    }
+    expect: {
+        A === B && x();
+        C !== D && y();
+    }
+}
+
+drop_switch_6: {
+    options = {
+        conditionals: true,
+        dead_code: true,
+        switches: true,
+    }
+    input: {
+        switch (A) {
+          case B:
+          default:
+            x();
+        }
+        switch (C) {
+          default:
+          case D:
+            y();
+        }
+    }
+    expect: {
+        A === B;
+        x();
+        C !== D;
+        y();
+    }
+}
+
+drop_switch_7: {
+    options = {
+        conditionals: true,
+        dead_code: true,
+        switches: true,
+    }
+    input: {
+        switch (A) {
+          case B:
+            w();
+          default:
+            x();
+        }
+        switch (C) {
+          default:
+            y();
+          case D:
+            z();
+        }
+    }
+    expect: {
+        A === B && w();
+        x();
+        C !== D && y();
+        z();
+    }
+}
+
+drop_switch_8: {
+    options = {
+        conditionals: true,
+        dead_code: true,
+        switches: true,
+    }
+    input: {
+        switch (A) {
+          case B:
+            w();
+            break;
+          default:
+            x();
+        }
+        switch (C) {
+          default:
+            y();
+            break;
+          case D:
+            z();
+        }
+    }
+    expect: {
+        (A === B ? w : x)();
+        (C !== D ? y : z)();
+    }
+}
+
+issue_4059: {
+    options = {
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        switches: true,
+    }
+    input: {
+        switch (0) {
+          default:
+          case 1:
+            break;
+          case a:
+            break;
+            var a;
+        }
+        console.log("PASS");
+    }
+    expect: {
+        switch (0) {
+          default:
+            break;
+          case a:
+            break;
+            var a;
+        }
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+}

test/compress/templates.js

@@ -0,0 +1,300 @@
+simple: {
+    input: {
+        console.log(`foo
+        bar\nbaz`);
+    }
+    expect_exact: "console.log(`foo\n        bar\\nbaz`);"
+    expect_stdout: [
+        "foo",
+        "        bar",
+        "baz",
+    ]
+    node_version: ">=4"
+}
+
+placeholder: {
+    input: {
+        console.log(`foo ${ function(a, b) {
+            return a * b;
+        }(6, 7) }`);
+    }
+    expect_exact: "console.log(`foo ${function(a,b){return a*b}(6,7)}`);"
+    expect_stdout: "foo 42"
+    node_version: ">=4"
+}
+
+nested: {
+    input: {
+        console.log(`P${`A${"S"}`}S`);
+    }
+    expect_exact: 'console.log(`P${`A${"S"}`}S`);'
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+tagged: {
+    input: {
+        console.log(String.raw`foo\nbar`);
+    }
+    expect_exact: "console.log(String.raw`foo\\nbar`);"
+    expect_stdout: "foo\\nbar"
+    node_version: ">=4"
+}
+
+tagged_chain: {
+    input: {
+        function f(strings) {
+            return strings.join("") || f;
+        }
+        console.log(f```${42}``pass`.toUpperCase());
+    }
+    expect_exact: 'function f(strings){return strings.join("")||f}console.log(f```${42}``pass`.toUpperCase());'
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+tag_parenthesis_arrow: {
+    input: {
+        console.log((s => s.raw[0])`\tPASS`.slice(2));
+    }
+    expect_exact: "console.log((s=>s.raw[0])`\\tPASS`.slice(2));"
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+tag_parenthesis_new: {
+    input: {
+        (new function() {
+            return console.log;
+        })`foo`;
+    }
+    expect_exact: "(new function(){return console.log})`foo`;"
+    expect_stdout: true
+    node_version: ">=4"
+}
+
+malformed_escape: {
+    input: {
+        (function(s) {
+            s.forEach((c, i) => console.log(i, c, s.raw[i]));
+            return () => console.log(arguments);
+        })`\uFo${42}`();
+    }
+    expect_exact: "(function(s){s.forEach((c,i)=>console.log(i,c,s.raw[i]));return()=>console.log(arguments)})`\\uFo${42}`();"
+    expect_stdout: true
+    node_version: ">=4"
+}
+
+evaluate: {
+    options = {
+        evaluate: true,
+        templates: false,
+    }
+    input: {
+        console.log(`foo ${ function(a, b) {
+            return a * b;
+        }(6, 7) }`);
+    }
+    expect: {
+        console.log(`foo ${42}`);
+    }
+    expect_stdout: "foo 42"
+    node_version: ">=4"
+}
+
+evaluate_templates: {
+    options = {
+        evaluate: true,
+        templates: true,
+    }
+    input: {
+        console.log(`foo ${ function(a, b) {
+            return a * b;
+        }(6, 7) }`);
+    }
+    expect: {
+        console.log("foo 42");
+    }
+    expect_stdout: "foo 42"
+    node_version: ">=4"
+}
+
+partial_evaluate: {
+    options = {
+        evaluate: true,
+        templates: true,
+    }
+    input: {
+        console.log(`${6 * 7} foo ${console ? `PA` + "SS" : `FA` + `IL`}`);
+    }
+    expect: {
+        console.log(`42 foo ${console ? "PASS" : "FAIL"}`);
+    }
+    expect_stdout: "42 foo PASS"
+    node_version: ">=4"
+}
+
+malformed_evaluate_1: {
+    options = {
+        evaluate: true,
+        templates: true,
+    }
+    input: {
+        console.log(`\67 ${6 * 7}`);
+    }
+    expect: {
+        console.log(`\67 42`);
+    }
+    expect_stdout: true
+    node_version: ">=4"
+}
+
+malformed_evaluate_2: {
+    options = {
+        evaluate: true,
+        templates: true,
+    }
+    input: {
+        console.log(`\u0${0}b${5}`);
+    }
+    expect: {
+        console.log(`\u0${0}b5`);
+    }
+    expect_stdout: true
+    node_version: ">=4"
+}
+
+malformed_evaluate_3: {
+    options = {
+        evaluate: true,
+        templates: true,
+    }
+    input: {
+        console.log(`\u${0}b${5}`);
+    }
+    expect: {
+        console.log(`\u0b5`);
+    }
+    expect_stdout: true
+    node_version: ">=4"
+}
+
+malformed_evaluate_4: {
+    options = {
+        evaluate: true,
+        templates: true,
+        unsafe: true,
+    }
+    input: {
+        console.log(String.raw`\u0${0}b${5}`);
+    }
+    expect: {
+        console.log("\\u00b5");
+    }
+    expect_stdout: "\\u00b5"
+    node_version: ">=8"
+}
+
+unsafe_evaluate: {
+    options = {
+        evaluate: true,
+        templates: true,
+        unsafe: true,
+    }
+    input: {
+        console.log(String.raw`\uFo`);
+    }
+    expect: {
+        console.log("\\uFo");
+    }
+    expect_stdout: "\\uFo"
+    node_version: ">=8"
+}
+
+side_effects: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        `42`;
+        `${console.log("foo")}`;
+        console.log`\nbar`;
+    }
+    expect: {
+        console.log("foo");
+        console.log`\nbar`;
+    }
+    expect_stdout: true
+    node_version: ">=4"
+}
+
+unsafe_side_effects: {
+    options = {
+        side_effects: true,
+        unsafe: true,
+    }
+    input: {
+        `42`;
+        `${console.log("foo")}`;
+        String.raw`\nbar`;
+    }
+    expect: {
+        console.log("foo");
+    }
+    expect_stdout: "foo"
+    node_version: ">=4"
+}
+
+issue_4604: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var a = 0, log = console.log;
+        a = "FAIL";
+        (function() {
+            a = "PASS";
+        })``;
+        log(a);
+    }
+    expect: {
+        var a = 0, log = console.log;
+        a = "FAIL";
+        (function() {
+            a = "PASS";
+        })``;
+        log(a);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_4606: {
+    options = {
+        evaluate: true,
+        templates: true,
+    }
+    input: {
+        console.log(`${typeof A} ${"\r"} ${"\\"} ${"`"}`);
+    }
+    expect: {
+        console.log(`${typeof A} \r \\ \``);
+    }
+    expect_stdout: "undefined \r \\ `"
+    node_version: ">=4"
+}
+
+issue_4630: {
+    options = {
+        evaluate: true,
+        templates: true,
+    }
+    input: {
+        console.log(`${/PASS/}`);
+    }
+    expect: {
+        console.log("/PASS/");
+    }
+    expect_stdout: "/PASS/"
+    node_version: ">=4"
+}

test/compress/unicode.js

@@ -1,3 +1,37 @@
+ascii_only_false: {
+    options = {}
+    beautify = {
+        ascii_only: false,
+    }
+    input: {
+        console.log(
+            "\x000\x001\x007\x008\x00",
+            "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f",
+            "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f",
+            "\x20\x21\x22\x23 ... \x7d\x7e\x7f\x80\x81 ... \xfe\xff\u0fff\uffff"
+        );
+    }
+    expect_exact: 'console.log("\\x000\\x001\\x007\\x008\\0","\\0\x01\x02\x03\x04\x05\x06\x07\\b\\t\\n\\v\\f\\r\x0e\x0f","\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f",\' !"# ... }~\x7f\x80\x81 ... \xfe\xff\u0fff\uffff\');'
+    expect_stdout: true
+}
+
+ascii_only_true: {
+    options = {}
+    beautify = {
+        ascii_only: true,
+    }
+    input: {
+        console.log(
+            "\x000\x001\x007\x008\x00",
+            "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f",
+            "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f",
+            "\x20\x21\x22\x23 ... \x7d\x7e\x7f\x80\x81 ... \xfe\xff\u0fff\uffff"
+        );
+    }
+    expect_exact: 'console.log("\\x000\\x001\\x007\\x008\\0","\\0\\x01\\x02\\x03\\x04\\x05\\x06\\x07\\b\\t\\n\\v\\f\\r\\x0e\\x0f","\\x10\\x11\\x12\\x13\\x14\\x15\\x16\\x17\\x18\\x19\\x1a\\x1b\\x1c\\x1d\\x1e\\x1f",\' !"# ... }~\\x7f\\x80\\x81 ... \\xfe\\xff\\u0fff\\uffff\');'
+    expect_stdout: true
+}
+
 unicode_parse_variables: {
     options = {}
     input: {
@@ -141,3 +175,35 @@ issue_2569: {
     }
     expect_exact: 'new RegExp("[\\udc42-\\udcaa\\udd74-\\udd96\\ude45-\\ude4f\\udea3-\\udecc]");'
 }
+
+surrogate_pair: {
+    beautify = {
+        ascii_only: false,
+    }
+    input: {
+        var \u{2f800} = {
+            \u{2f801}: "\u{100000}",
+        };
+        \u{2f800}.\u{2f802} = "\u{100001}";
+        console.log(typeof \u{2f800}, \u{2f800}.\u{2f801}, \u{2f800}["\u{2f802}"]);
+    }
+    expect_exact: 'var \ud87e\udc00={"\ud87e\udc01":"\udbc0\udc00"};\ud87e\udc00.\ud87e\udc02="\udbc0\udc01";console.log(typeof \ud87e\udc00,\ud87e\udc00.\ud87e\udc01,\ud87e\udc00["\ud87e\udc02"]);'
+    expect_stdout: "object \udbc0\udc00 \udbc0\udc01"
+    node_version: ">=4"
+}
+
+surrogate_pair_ascii: {
+    beautify = {
+        ascii_only: true,
+    }
+    input: {
+        var \u{2f800} = {
+            \u{2f801}: "\u{100000}",
+        };
+        \u{2f800}.\u{2f802} = "\u{100001}";
+        console.log(typeof \u{2f800}, \u{2f800}.\u{2f801}, \u{2f800}["\u{2f802}"]);
+    }
+    expect_exact: 'var \\u{2f800}={"\\ud87e\\udc01":"\\udbc0\\udc00"};\\u{2f800}.\\u{2f802}="\\udbc0\\udc01";console.log(typeof \\u{2f800},\\u{2f800}.\\u{2f801},\\u{2f800}["\\ud87e\\udc02"]);'
+    expect_stdout: "object \udbc0\udc00 \udbc0\udc01"
+    node_version: ">=4"
+}

test/compress/varify.js

@@ -0,0 +1,411 @@
+reduce_merge_const: {
+    options = {
+        merge_vars: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+        varify: true,
+    }
+    input: {
+        const a = console;
+        console.log(typeof a);
+        var b = typeof a;
+        console.log(b);
+    }
+    expect: {
+        var b = console;
+        console.log(typeof b);
+        b = typeof b;
+        console.log(b);
+    }
+    expect_stdout: [
+        "object",
+        "object",
+    ]
+}
+
+reduce_merge_let: {
+    options = {
+        merge_vars: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+        varify: true,
+    }
+    input: {
+        "use strict";
+        let a = console;
+        console.log(typeof a);
+        var b = typeof a;
+        console.log(b);
+    }
+    expect: {
+        "use strict";
+        var b = console;
+        console.log(typeof b);
+        b = typeof b;
+        console.log(b);
+    }
+    expect_stdout: [
+        "object",
+        "object",
+    ]
+    node_version: ">=4"
+}
+
+reduce_block_const: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        varify: true,
+    }
+    input: {
+        {
+            const a = typeof console;
+            console.log(a);
+        }
+    }
+    expect: {
+        var a = typeof console;
+        console.log(a);
+    }
+    expect_stdout: "object"
+}
+
+reduce_block_let: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        varify: true,
+    }
+    input: {
+        "use strict";
+        {
+            let a = typeof console;
+            console.log(a);
+        }
+    }
+    expect: {
+        "use strict";
+        var a = typeof console;
+        console.log(a);
+    }
+    expect_stdout: "object"
+    node_version: ">=4"
+}
+
+hoist_props_const: {
+    options = {
+        hoist_props: true,
+        passes: 2,
+        reduce_vars: true,
+        toplevel: true,
+        varify: true,
+    }
+    input: {
+        {
+            const o = {
+                p: "PASS",
+            };
+            console.log(o.p);
+        }
+    }
+    expect: {
+        var o_p = "PASS";
+        console.log(o_p);
+    }
+    expect_stdout: "PASS"
+}
+
+hoist_props_let: {
+    options = {
+        hoist_props: true,
+        passes: 2,
+        reduce_vars: true,
+        toplevel: true,
+        varify: true,
+    }
+    input: {
+        "use strict";
+        {
+            let o = {
+                p: "PASS",
+            };
+            console.log(o.p);
+        }
+    }
+    expect: {
+        "use strict";
+        var o_p = "PASS";
+        console.log(o_p);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+scope_adjustment_const: {
+    options = {
+        conditionals: true,
+        inline: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+        varify: true,
+    }
+    input: {
+        for (var k in [ 42 ])
+            console.log(function f() {
+                if (k) {
+                    const a = 0;
+                }
+            }());
+    }
+    expect: {
+        for (var k in [ 42 ])
+            console.log(void (k && 0));
+    }
+    expect_stdout: "undefined"
+}
+
+scope_adjustment_let: {
+    options = {
+        conditionals: true,
+        inline: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+        varify: true,
+    }
+    input: {
+        "use strict";
+        for (var k in [ 42 ])
+            console.log(function f() {
+                if (k) {
+                    let a = 0;
+                }
+            }());
+    }
+    expect: {
+        "use strict";
+        for (var k in [ 42 ])
+            console.log(void (k && 0));
+    }
+    expect_stdout: "undefined"
+    node_version: ">=4"
+}
+
+issue_4191_const: {
+    options = {
+        functions: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+        varify: true,
+    }
+    input: {
+        const a = function() {};
+        console.log(typeof a, a());
+    }
+    expect: {
+        function a() {};
+        console.log(typeof a, a());
+    }
+    expect_stdout: "function undefined"
+}
+
+issue_4191_let: {
+    options = {
+        functions: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+        varify: true,
+    }
+    input: {
+        "use strict";
+        let a = function() {};
+        console.log(typeof a, a());
+    }
+    expect: {
+        "use strict";
+        function a() {};
+        console.log(typeof a, a());
+    }
+    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/compress/yields.js

@@ -0,0 +1,952 @@
+binary: {
+    input: {
+        var a = function*() {
+            console.log(6 * (yield "PA" + "SS"));
+        }();
+        console.log(a.next("FAIL").value);
+        console.log(a.next(7).done);
+    }
+    expect_exact: 'var a=function*(){console.log(6*(yield"PA"+"SS"))}();console.log(a.next("FAIL").value);console.log(a.next(7).done);'
+    expect_stdout: [
+        "PASS",
+        "42",
+        "true",
+    ]
+    node_version: ">=4"
+}
+
+empty_yield: {
+    input: {
+        var a = function*() {
+            yield;
+            console.log(yield);
+            yield
+            "FAIL 1";
+        }();
+        console.log(a.next("FAIL 2").value);
+        console.log(a.next("FAIL 3").value);
+        console.log(a.next("PASS").value);
+        console.log(a.next("FAIL 4").done);
+    }
+    expect_exact: 'var a=function*(){yield;console.log(yield);yield;"FAIL 1"}();console.log(a.next("FAIL 2").value);console.log(a.next("FAIL 3").value);console.log(a.next("PASS").value);console.log(a.next("FAIL 4").done);'
+    expect_stdout: [
+        "undefined",
+        "undefined",
+        "PASS",
+        "undefined",
+        "true",
+    ]
+    node_version: ">=4"
+}
+
+empty_yield_conditional: {
+    input: {
+        var a = function*() {
+            console.log((yield) ? yield : yield);
+        }();
+        console.log(a.next("FAIL 1").value);
+        console.log(a.next("FAIL 2").value);
+        console.log(a.next("PASS").value);
+        console.log(a.next("FAIL 3").done);
+    }
+    expect_exact: 'var a=function*(){console.log((yield)?yield:yield)}();console.log(a.next("FAIL 1").value);console.log(a.next("FAIL 2").value);console.log(a.next("PASS").value);console.log(a.next("FAIL 3").done);'
+    expect_stdout: [
+        "undefined",
+        "undefined",
+        "PASS",
+        "undefined",
+        "true",
+    ]
+    node_version: ">=4"
+}
+
+nested_yield: {
+    input: {
+        console.log(function*() {
+            (yield*
+            f())
+            function* f() {
+                return "FAIL";
+            }
+            yield*
+            f();
+            yield *f();
+        }().next().value || "PASS");
+    }
+    expect_exact: 'console.log(function*(){yield*f();function*f(){return"FAIL"}yield*f();yield*f()}().next().value||"PASS");'
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+pause_resume: {
+    input: {
+        function* f() {
+            console.log(yield "PASS");
+        }
+        var a = f();
+        console.log(a.next("FAIL").value);
+        console.log(a.next(42).done);
+    }
+    expect_exact: 'function*f(){console.log(yield"PASS")}var a=f();console.log(a.next("FAIL").value);console.log(a.next(42).done);'
+    expect_stdout: [
+        "PASS",
+        "42",
+        "true",
+    ]
+    node_version: ">=4"
+}
+
+arrow_yield: {
+    input: {
+        yield = "PASS";
+        console.log(function*() {
+            return () => yield || "FAIL";
+        }().next().value());
+    }
+    expect_exact: 'yield="PASS";console.log(function*(){return()=>yield||"FAIL"}().next().value());'
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+for_of: {
+    input: {
+        function* f() {
+            if (yield "PASS") yield "FAIL 1";
+            yield 42;
+            return "FAIL 2";
+        }
+        for (var a of f())
+            console.log(a);
+    }
+    expect_exact: 'function*f(){if(yield"PASS")yield"FAIL 1";yield 42;return"FAIL 2"}for(var a of f())console.log(a);'
+    expect_stdout: [
+        "PASS",
+        "42",
+    ]
+    node_version: ">=4"
+}
+
+for_await_of: {
+    input: {
+        async function* f() {
+            if (yield "PASS") yield "FAIL 1";
+            yield {
+                then: function(r) {
+                    r(42);
+                },
+            };
+            return "FAIL 2";
+        }
+        (async function(a) {
+            for await (a of f())
+                console.log(a);
+        })();
+    }
+    expect_exact: 'async function*f(){if(yield"PASS")yield"FAIL 1";yield{then:function(r){r(42)}};return"FAIL 2"}(async function(a){for await(a of f())console.log(a)})();'
+    expect_stdout: [
+        "PASS",
+        "42",
+    ]
+    node_version: ">=10"
+}
+
+collapse_vars_1: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var a = "FAIL";
+        (function*() {
+            a = "PASS";
+            yield 42;
+            return "PASS";
+        })().next();
+        console.log(a);
+    }
+    expect: {
+        var a = "FAIL";
+        (function*() {
+            a = "PASS";
+            yield 42;
+            return "PASS";
+        })().next();
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+collapse_vars_2: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var a = "FAIL";
+        (function*() {
+            yield (a = "PASS");
+            return "PASS";
+        })().next();
+        console.log(a);
+    }
+    expect: {
+        var a = "FAIL";
+        (function*() {
+            yield (a = "PASS");
+            return "PASS";
+        })().next();
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+collapse_vars_3: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var a = "FAIL";
+        (function*() {
+            yield (a = "PASS", 42);
+            return "PASS";
+        })().next();
+        console.log(a);
+    }
+    expect: {
+        var a = "FAIL";
+        (function*() {
+            yield (a = "PASS", 42);
+            return "PASS";
+        })().next();
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+collapse_vars_4: {
+    options = {
+        collapse_vars: true,
+        unused: true,
+    }
+    input: {
+        var a = "FAIL";
+        var b = function*(c) {
+            return c;
+        }(a = "PASS");
+        console.log(a, b.next().done);
+    }
+    expect: {
+        var a = "FAIL";
+        var b = function*(c) {
+            return c;
+        }(a = "PASS");
+        console.log(a, b.next().done);
+    }
+    expect_stdout: "PASS true"
+    node_version: ">=4"
+}
+
+collapse_property_lambda: {
+    options = {
+        collapse_vars: true,
+        pure_getters: "strict",
+    }
+    input: {
+        console.log(function* f() {
+            f.g = () => 42;
+            return f.g();
+        }().next().value);
+    }
+    expect: {
+        console.log(function* f() {
+            return (f.g = () => 42)();
+        }().next().value);
+    }
+    expect_stdout: "42"
+    node_version: ">=4"
+}
+
+defun_name: {
+    input: {
+        function* yield() {
+            console.log("PASS");
+        }
+        yield().next();
+    }
+    expect: {
+        function* yield() {
+            console.log("PASS");
+        }
+        yield().next();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+drop_fname: {
+    rename = true
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        function* yield() {
+            console.log("PASS");
+        }
+        yield().next();
+    }
+    expect: {
+        (function*() {
+            console.log("PASS");
+        })().next();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+keep_fname: {
+    options = {
+        keep_fnames: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function* yield() {
+            console.log("PASS");
+        }
+        yield().next();
+    }
+    expect: {
+        function* yield() {
+            console.log("PASS");
+        }
+        yield().next();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+evaluate: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = function*() {}();
+        console.log(typeof a);
+    }
+    expect: {
+        var a = function*() {}();
+        console.log(typeof a);
+    }
+    expect_stdout: "object"
+    node_version: ">=4"
+}
+
+functions: {
+    options = {
+        functions: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        !function*() {
+            var a = function* a() {
+                return a && "a";
+            };
+            var b = function* x() {
+                return !!x;
+            };
+            var c = function*(c) {
+                return c;
+            };
+            if (yield* c(yield* b(yield* a()))) {
+                var d = function*() {};
+                var e = function* y() {
+                    return typeof y;
+                };
+                var f = function*(f) {
+                    return f;
+                };
+                console.log(yield* a(yield* d()), yield* b(yield* e()), yield* c(yield* f(42)), typeof d, yield* e(), typeof f);
+            }
+        }().next();
+    }
+    expect: {
+        !function*() {
+            function* a() {
+                return a && "a";
+            }
+            function* b() {
+                return !!b;
+            }
+            var c = function*(c) {
+                return c;
+            };
+            if (yield* c(yield* b(yield* a()))) {
+                function* d() {}
+                function* e() {
+                    return typeof e;
+                }
+                var f = function*(f) {
+                    return f;
+                };
+                console.log(yield* a(yield* d()), yield* b(yield* e()), yield* c(yield* f(42)), typeof d, yield* e(), typeof f);
+            }
+        }().next();
+    }
+    expect_stdout: "a true 42 function function function"
+    node_version: ">=4"
+}
+
+functions_use_strict: {
+    options = {
+        functions: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        !function*() {
+            var a = function* a() {
+                return a && "a";
+            };
+            var b = function* x() {
+                return !!x;
+            };
+            var c = function*(c) {
+                return c;
+            };
+            if (yield* c(yield* b(yield* a()))) {
+                var d = function*() {};
+                var e = function* y() {
+                    return typeof y;
+                };
+                var f = function*(f) {
+                    return f;
+                };
+                console.log(yield* a(yield* d()), yield* b(yield* e()), yield* c(yield* f(42)), typeof d, yield* e(), typeof f);
+            }
+        }().next();
+    }
+    expect: {
+        "use strict";
+        !function*() {
+            function* a() {
+                return a && "a";
+            }
+            function* b() {
+                return !!b;
+            }
+            var c = function*(c) {
+                return c;
+            };
+            if (yield* c(yield* b(yield* a()))) {
+                var d = function*() {};
+                var e = function* y() {
+                    return typeof y;
+                };
+                var f = function*(f) {
+                    return f;
+                };
+                console.log(yield* a(yield* d()), yield* b(yield* e()), yield* c(yield* f(42)), typeof d, yield* e(), typeof f);
+            }
+        }().next();
+    }
+    expect_stdout: "a true 42 function function function"
+    node_version: ">=4"
+}
+
+negate_iife: {
+    options = {
+        negate_iife: true,
+        side_effects: true,
+    }
+    input: {
+        (function*(a) {
+            console.log(a);
+        })("PASS").next();
+    }
+    expect: {
+        !function*(a) {
+            console.log(a);
+        }("PASS").next();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+reduce_iife_1: {
+    options = {
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        console.log(function*(a) {
+            yield a;
+        }(42).next().value);
+    }
+    expect: {
+        console.log(function*(a) {
+            yield 42;
+        }().next().value);
+    }
+    expect_stdout: "42"
+    node_version: ">=4"
+}
+
+reduce_iife_2: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = "PASS";
+        (function*() {
+            a = "FAIL";
+        })();
+        console.log(a);
+    }
+    expect: {
+        var a = "PASS";
+        (function*() {
+            a = "FAIL";
+        })();
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+reduce_single_use_defun: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function* f(a) {
+            console.log(a);
+        }
+        f("PASS").next();
+    }
+    expect: {
+        (function*(a) {
+            console.log(a);
+        })("PASS").next();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+reduce_tagged: {
+    options = {
+        reduce_funcs: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        function* f() {
+            function g() {
+                h`foo`;
+            }
+            g();
+            function h(s) {
+                console.log(s[0]);
+            }
+            h([ "bar" ]);
+        }
+        f().next();
+    }
+    expect: {
+        function* f() {
+            (function() {
+                h`foo`;
+            })();
+            function h(s) {
+                console.log(s[0]);
+            }
+            h([ "bar" ]);
+        }
+        f().next();
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+    ]
+    node_version: ">=4"
+}
+
+reduce_tagged_async: {
+    options = {
+        reduce_funcs: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        async function* f() {
+            function g() {
+                h`foo`;
+            }
+            g();
+            function h(s) {
+                console.log(s[0]);
+            }
+            h([ "bar" ]);
+        }
+        f().next();
+    }
+    expect: {
+        async function* f() {
+            (function() {
+                h`foo`;
+            })();
+            function h(s) {
+                console.log(s[0]);
+            }
+            h([ "bar" ]);
+        }
+        f().next();
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+    ]
+    node_version: ">=10"
+}
+
+lift_sequence: {
+    options = {
+        sequences: true,
+        yields: true,
+    }
+    input: {
+        console.log(function*() {
+            yield (console, "PASS");
+        }().next().value);
+    }
+    expect: {
+        console.log(function*() {
+            console, yield "PASS";
+        }().next().value);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+inline_nested_yield: {
+    options = {
+        inline: true,
+        sequences: true,
+        yields: true,
+    }
+    input: {
+        var a = function*() {
+            yield* function*() {
+                yield "foo";
+                return "FAIL";
+            }();
+        }(), b;
+        do {
+            b = a.next();
+            console.log(b.value);
+        } while (!b.done);
+    }
+    expect: {
+        var a = function*() {
+            yield "foo",
+            "FAIL";
+        }(), b;
+        do {
+            b = a.next(),
+            console.log(b.value);
+        } while (!b.done);
+    }
+    expect_stdout: [
+        "foo",
+        "undefined",
+    ]
+    node_version: ">=4"
+}
+
+drop_body: {
+    options = {
+        side_effects: true,
+        yields: true,
+    }
+    input: {
+        (function*([ , a = console.log("foo") ]) {
+            console.log("bar");
+        })([ console.log("baz") ]);
+    }
+    expect: {
+        [ [ , 0[0] = console.log("foo") ] ] = [ [ console.log("baz") ] ];
+    }
+    expect_stdout: [
+        "baz",
+        "foo",
+    ]
+    node_version: ">=6"
+}
+
+drop_unused_call: {
+    options = {
+        inline: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+        yields: true,
+    }
+    input: {
+        var a = function*(){}(console.log("PASS"));
+    }
+    expect: {
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_4454_1: {
+    rename = false
+    options = {
+        merge_vars: true,
+    }
+    input: {
+        function f(a) {
+            (function*(b = console.log(a)) {})();
+            var yield = 42..toString();
+            console.log(yield);
+        }
+        f("PASS");
+    }
+    expect: {
+        function f(a) {
+            (function*(b = console.log(a)) {})();
+            var yield = 42..toString();
+            console.log(yield);
+        }
+        f("PASS");
+    }
+    expect_stdout: [
+        "PASS",
+        "42",
+    ]
+    node_version: ">=6"
+}
+
+issue_4454_2: {
+    rename = true
+    options = {
+        merge_vars: true,
+    }
+    input: {
+        function f(a) {
+            (function*(b = console.log(a)) {})();
+            var yield = 42..toString();
+            console.log(yield);
+        }
+        f("PASS");
+    }
+    expect: {
+        function f(b) {
+            (function*(c = console.log(b)) {})();
+            var b = 42..toString();
+            console.log(b);
+        }
+        f("PASS");
+    }
+    expect_stdout: [
+        "PASS",
+        "42",
+    ]
+    node_version: ">=6"
+}
+
+issue_4618: {
+    options = {
+        functions: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        console.log(typeof function() {
+            var yield = function* f() {
+                console || f();
+            };
+            console.log;
+            return yield;
+        }());
+    }
+    expect: {
+        console.log(typeof function() {
+            var yield = function* f() {
+                console || f();
+            };
+            console.log;
+            return yield;
+        }());
+    }
+    expect_stdout: "function"
+    node_version: ">=4"
+}
+
+issue_4623: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        if (console ? function*() {} : 0)
+            console.log("PASS");
+    }
+    expect: {
+        (console ? function*() {} : 0) && console.log("PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_4633: {
+    options = {
+        collapse_vars: true,
+        unused: true,
+    }
+    input: {
+        var a = function*() {
+            (function(log) {
+                log(typeof this);
+            })(yield "PASS");
+        }();
+        console.log(a.next().value);
+        a.next(console.log);
+    }
+    expect: {
+        var a = function*() {
+            (function(log) {
+                log(typeof this);
+            })(yield "PASS");
+        }();
+        console.log(a.next().value);
+        a.next(console.log);
+    }
+    expect_stdout: [
+        "PASS",
+        "object",
+    ]
+    node_version: ">=4"
+}
+
+issue_4639_1: {
+    options = {
+        inline: true,
+    }
+    input: {
+        console.log(function*() {
+            return function() {
+                return yield => "PASS";
+            }();
+        }().next().value());
+    }
+    expect: {
+        console.log(function*() {
+            return function() {
+                return yield => "PASS";
+            }();
+        }().next().value());
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_4639_2: {
+    options = {
+        inline: true,
+    }
+    input: {
+        (function*() {
+            console.log(function() {
+                return typeof yield;
+            }());
+        })().next();
+    }
+    expect: {
+        (function*() {
+            console.log(function() {
+                return typeof yield;
+            }());
+        })().next();
+    }
+    expect_stdout: "undefined"
+    node_version: ">=4"
+}
+
+issue_4641_1: {
+    options = {
+        sequences: true,
+    }
+    input: {
+        console.log(typeof async function*() {
+            try {
+                console.log("foo");
+                return;
+            } finally {
+                console.log("bar");
+            }
+        }().next().then);
+    }
+    expect: {
+        console.log(typeof async function*() {
+            try {
+                console.log("foo");
+                return;
+            } finally {
+                console.log("bar");
+            }
+        }().next().then);
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+        "function",
+    ]
+    node_version: ">=10"
+}
+
+issue_4641_2: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        console.log(typeof async function*() {
+            try {
+                return void "FAIL";
+            } finally {
+                console.log("PASS");
+            }
+        }().next().then);
+    }
+    expect: {
+        console.log(typeof async function*() {
+            try {
+                return void 0;
+            } finally {
+                console.log("PASS");
+            }
+        }().next().then);
+    }
+    expect_stdout: [
+        "function",
+        "PASS",
+    ]
+    node_version: ">=10"
+}

test/input/invalid/destructured_var.js

@@ -0,0 +1,8 @@
+function f() {
+    var { eval } = null;
+}
+
+function g() {
+    "use strict";
+    var { eval } = 42;
+}

test/input/invalid/for-of_1.js

@@ -0,0 +1,3 @@
+var a = [ 1 ], b;
+for (b = 2 of a)
+    console.log(b);

test/input/invalid/for-of_2.js

@@ -0,0 +1,3 @@
+var a = [ 1 ];
+for (var b = 2 of a)
+    console.log(b);

test/input/invalid/switch.js

@@ -0,0 +1,4 @@
+switch (0) {
+  default:
+  default:
+}

test/input/issue-3294/output.js

@@ -1,2 +1,2 @@
-new function(){console.log(3)};
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0ZGluIl0sInNvdXJjZXNDb250ZW50IjpbImNsYXNzIEZvbyB7IGNvbnN0cnVjdG9yKCl7Y29uc29sZS5sb2coMSsyKTt9IH0gbmV3IEZvbygpO1xuIl0sIm5hbWVzIjpbImNvbnNvbGUiLCJsb2ciXSwibWFwcGluZ3MiOiJBQUErQyxJQUFyQyxXQUFnQkEsUUFBUUMsSUFBSSJ9
+console.log(3);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0ZGluIl0sInNvdXJjZXNDb250ZW50IjpbImNsYXNzIEZvbyB7IGNvbnN0cnVjdG9yKCl7Y29uc29sZS5sb2coMSsyKTt9IH0gbmV3IEZvbygpO1xuIl0sIm5hbWVzIjpbImNvbnNvbGUiLCJsb2ciXSwibWFwcGluZ3MiOiJBQUEwQkEsUUFBUUMsSUFBSSJ9

test/input/issue-520/output.js

@@ -1,2 +1,2 @@
-new function(){console.log(3)};
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0ZGluIl0sInNvdXJjZXNDb250ZW50IjpbImNsYXNzIEZvbyB7IGNvbnN0cnVjdG9yKCl7Y29uc29sZS5sb2coMSsyKTt9IH0gbmV3IEZvbygpO1xuIl0sIm5hbWVzIjpbImNvbnNvbGUiLCJsb2ciXSwibWFwcGluZ3MiOiJBQUErQyxJQUFyQyxXQUFnQkEsUUFBUUMsSUFBSSJ9
+console.log(3);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0ZGluIl0sInNvdXJjZXNDb250ZW50IjpbImNsYXNzIEZvbyB7IGNvbnN0cnVjdG9yKCl7Y29uc29sZS5sb2coMSsyKTt9IH0gbmV3IEZvbygpO1xuIl0sIm5hbWVzIjpbImNvbnNvbGUiLCJsb2ciXSwibWFwcGluZ3MiOiJBQUEwQkEsUUFBUUMsSUFBSSJ9

test/input/reduce/destructured_assign.js

@@ -0,0 +1,3 @@
+var o = {};
+[ o[1 + .1 + .1] ] = [ 42 ];
+console.log(o[1.2]);

test/input/reduce/destructured_assign.reduced.js

@@ -0,0 +1,17 @@
+// (beautified)
+var o = {};
+
+[ o[1 + .1 + .1] ] = [];
+
+console.log(o);
+// output: { '1.2000000000000002': undefined }
+// 
+// minify: { '1.2': undefined }
+// 
+// options: {
+//   "compress": {
+//     "unsafe_math": true
+//   },
+//   "mangle": false,
+//   "validate": true
+// }

test/input/reduce/destructured_catch.js

@@ -0,0 +1,7 @@
+try {
+    "foo" in 42;
+} catch ({
+    message,
+}) {
+    console.log(message);
+}

test/input/reduce/destructured_catch.reduced.js

@@ -0,0 +1,13 @@
+// (beautified)
+try {
+    1 in 0;
+} catch (message) {
+    console.log(message);
+}
+// output: TypeError: Cannot use 'in' operator to search for '1' in 0
+// 
+// minify: TypeError: Cannot use 'in' operator to search for '0' in 0
+// 
+// options: {
+//   "mangle": false
+// }

test/input/reduce/diff_error.js

@@ -1,5 +1,5 @@
-(function f(a) {
-    do {
-        console.log(f.length);
-    } while (console.log(f += 0));
-})();
+console.log(function(undefined) {
+    return undefined[function() {
+        {}
+    }] || 1 + .1 + .1;
+}(42));

test/input/reduce/diff_error.reduced.js

@@ -1,19 +1,14 @@
 // (beautified)
-(function f(a) {
-    do {
-        console.log(f.length);
-    } while (console.log(f += 0));
-})();
-// output: 1
-// function(){}0
+console.log(function() {
+    return 1 + .1 + .1;
+}());
+// output: 1.2000000000000002
 // 
-// minify: 0
-// function(){}0
+// minify: 1.2
 // 
 // options: {
 //   "compress": {
-//     "keep_fargs": false,
-//     "unsafe": true
+//     "unsafe_math": true
 //   },
 //   "mangle": false
 // }

test/input/reduce/label.js

@@ -1,9 +1,3 @@
-var o = this;
-
-for (var k in o) L17060: {
-    a++;
+UNUSED: {
+    console.log(0 - .1 - .1 - .1);
 }
-
-var a;
-
-console.log(k);

test/input/reduce/label.reduced.js

@@ -1,15 +1,12 @@
 // (beautified)
-var o = this;
-
-for (var k in o) {}
-
-var a;
-
-console.log(k);
-// output: a
+console.log(0 - 1 - .1 - .1);
+// output: -1.2000000000000002
 // 
-// minify: k
+// minify: -1.2
 // 
 // options: {
+//   "compress": {
+//     "unsafe_math": true
+//   },
 //   "mangle": false
 // }

test/input/reduce/setter.js

@@ -1,8 +1,5 @@
-console.log(function f(a) {
-    ({
-        set p(v) {
-            f++;
-        }
-    });
-    return f.length;
-}());
+({
+    set p(v) {
+        console.log(+v + .1 + .1);
+    }
+}).p = 1;

test/input/reduce/setter.reduced.js

@@ -1,20 +1,16 @@
 // (beautified)
-console.log(function f(a) {
-    ({
-        set p(v) {
-            f++;
-        }
-    });
-    return f.length;
-}());
-// output: 1
+({
+    set p(v) {
+        console.log(1 + .1 + .1);
+    }
+}).p = 0;
+// output: 1.2000000000000002
 // 
-// minify: 0
+// minify: 1.2
 // 
 // options: {
 //   "compress": {
-//     "keep_fargs": false,
-//     "unsafe": true
+//     "unsafe_math": true
 //   },
 //   "mangle": false
 // }

test/jetstream.js

@@ -5,7 +5,7 @@
 
 var site = "https://browserbench.org/JetStream1.1";
 if (typeof phantom == "undefined") {
-    require("../tools/exit");
+    require("../tools/tty");
     var args = process.argv.slice(2);
     var debug = args.indexOf("--debug");
     if (debug < 0) {
@@ -60,7 +60,7 @@ if (typeof phantom == "undefined") {
         var port = server.address().port;
         if (debug) {
             console.log("http://localhost:" + port + "/");
-        } else {
+        } else (function install() {
             child_process.spawn(process.platform == "win32" ? "npm.cmd" : "npm", [
                 "install",
                 "phantomjs-prebuilt@2.1.14",
@@ -71,7 +71,10 @@ if (typeof phantom == "undefined") {
             ], {
                 stdio: [ "ignore", 1, 2 ]
             }).on("exit", function(code) {
-                if (code) throw new Error("npm install failed!");
+                if (code) {
+                    console.log("npm install failed with code", code);
+                    return install();
+                }
                 var program = require("phantomjs-prebuilt").exec(process.argv[1], port);
                 program.stdout.pipe(process.stdout);
                 program.stderr.pipe(process.stderr);
@@ -82,7 +85,7 @@ if (typeof phantom == "undefined") {
                     process.exit(0);
                 });
             });
-        }
+        })();
     });
     server.timeout = 0;
 } else {

test/mocha/awaits.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/bug-report.js

@@ -0,0 +1,40 @@
+var assert = require("assert");
+var exec = require("child_process").exec;
+
+describe("UGLIFY_BUG_REPORT", function() {
+    var env = Object.create(process.env);
+    env.UGLIFY_BUG_REPORT = 1;
+    it("Should generate bug report via API", function(done) {
+        exec('"' + process.argv[0] + '"', { env: env }, function(err, stdout) {
+            if (err) throw err;
+            assert.strictEqual(stdout, [
+                "// UGLIFY_BUG_REPORT",
+                "// <<undefined>>",
+                "",
+                "//-------------------------------------------------------------",
+                "// INPUT CODE",
+                "...---...",
+                "",
+            ].join("\n"));
+            done();
+        }).stdin.end('console.log(require("./").minify("...---...").code);');
+    });
+    it("Should generate bug report via CLI", function(done) {
+        exec('"' + process.argv[0] + '" bin/uglifyjs -mc', { env: env }, function(err, stdout) {
+            if (err) throw err;
+            assert.strictEqual(stdout, [
+                "// UGLIFY_BUG_REPORT",
+                "// {",
+                '//   "mangle": {},',
+                '//   "compress": {}',
+                "// }",
+                "",
+                "//-------------------------------------------------------------",
+                "// STDIN",
+                "...---...",
+                "",
+            ].join("\n"));
+            done();
+        }).stdin.end("...---...");
+    });
+});

test/mocha/cli.js

@@ -56,7 +56,7 @@ describe("bin/uglifyjs", function() {
             "--source-map", [
                 "names=true",
                 "url=inline",
-            ].join(","),
+            ].join(),
         ].join(" "), function(err, stdout) {
             if (err) throw err;
             var expected = [
@@ -84,7 +84,7 @@ describe("bin/uglifyjs", function() {
             "--source-map", [
                 "names=false",
                 "url=inline",
-            ].join(","),
+            ].join(),
         ].join(" "), function(err, stdout) {
             if (err) throw err;
             var expected = [
@@ -171,7 +171,7 @@ describe("bin/uglifyjs", function() {
                 "content=" + mapFile,
                 "includeSources",
                 "url=inline",
-            ].join(","),
+            ].join(),
         ].join(" ");
 
         var child = exec(command, function(err, stdout) {
@@ -330,55 +330,63 @@ describe("bin/uglifyjs", function() {
         });
     });
     it("Should fail with invalid syntax", function(done) {
-        var command = uglifyjscmd + ' test/input/invalid/simple.js';
+        var command = uglifyjscmd + " test/input/invalid/simple.js";
         exec(command, function(err, stdout, stderr) {
             assert.ok(err);
-            var lines = stderr.split(/\n/);
-            assert.strictEqual(lines[0], "Parse error at test/input/invalid/simple.js:1,12");
-            assert.strictEqual(lines[1], "function f(a{}");
-            assert.strictEqual(lines[2], "            ^");
-            assert.strictEqual(lines[3], "ERROR: Unexpected token: punc «{», expected: punc «,»");
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/simple.js:1,12",
+                "function f(a{}",
+                "            ^",
+                "ERROR: Unexpected token: punc «{», expected: punc «,»",
+            ].join("\n"));
             done();
         });
     });
     it("Should fail with correct marking of tabs", function(done) {
-        var command = uglifyjscmd + ' test/input/invalid/tab.js';
+        var command = uglifyjscmd + " test/input/invalid/tab.js";
         exec(command, function(err, stdout, stderr) {
             assert.ok(err);
-            var lines = stderr.split(/\n/);
-            assert.strictEqual(lines[0], "Parse error at test/input/invalid/tab.js:1,12");
-            assert.strictEqual(lines[1], "\t\tfoo(\txyz, 0abc);");
-            assert.strictEqual(lines[2], "\t\t    \t     ^");
-            assert.strictEqual(lines[3], "ERROR: Invalid syntax: 0abc");
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/tab.js:1,12",
+                "\t\tfoo(\txyz, 0abc);",
+                "\t\t    \t     ^",
+                "ERROR: Invalid syntax: 0abc",
+            ].join("\n"));
             done();
         });
     });
     it("Should fail with correct marking at start of line", function(done) {
-        var command = uglifyjscmd + ' test/input/invalid/eof.js';
+        var command = uglifyjscmd + " test/input/invalid/eof.js";
         exec(command, function(err, stdout, stderr) {
             assert.ok(err);
-            var lines = stderr.split(/\n/);
-            assert.strictEqual(lines[0], "Parse error at test/input/invalid/eof.js:2,0");
-            assert.strictEqual(lines[1], "foo, bar(");
-            assert.strictEqual(lines[2], "         ^");
-            assert.strictEqual(lines[3], "ERROR: Unexpected token: eof");
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/eof.js:2,0",
+                "foo, bar(",
+                "         ^",
+                "ERROR: Unexpected token: eof",
+            ].join("\n"));
             done();
         });
     });
     it("Should fail with a missing loop body", function(done) {
-        var command = uglifyjscmd + ' test/input/invalid/loop-no-body.js';
+        var command = uglifyjscmd + " test/input/invalid/loop-no-body.js";
         exec(command, function(err, stdout, stderr) {
             assert.ok(err);
-            var lines = stderr.split(/\n/);
-            assert.strictEqual(lines[0], "Parse error at test/input/invalid/loop-no-body.js:2,0");
-            assert.strictEqual(lines[1], "for (var i = 0; i < 1; i++) ");
-            assert.strictEqual(lines[2], "                            ^");
-            assert.strictEqual(lines[3], "ERROR: Unexpected token: eof");
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/loop-no-body.js:2,0",
+                "for (var i = 0; i < 1; i++) ",
+                "                            ^",
+                "ERROR: Unexpected token: eof",
+            ].join("\n"));
             done();
         });
     });
     it("Should throw syntax error (5--)", function(done) {
-        var command = uglifyjscmd + ' test/input/invalid/assign_1.js';
+        var command = uglifyjscmd + " test/input/invalid/assign_1.js";
         exec(command, function(err, stdout, stderr) {
             assert.ok(err);
             assert.strictEqual(stdout, "");
@@ -386,13 +394,13 @@ describe("bin/uglifyjs", function() {
                 "Parse error at test/input/invalid/assign_1.js:1,18",
                 "console.log(1 || 5--);",
                 "                  ^",
-                "ERROR: Invalid use of -- operator"
+                "ERROR: Invalid use of -- operator",
             ].join("\n"));
             done();
         });
     });
     it("Should throw syntax error (Math.random() /= 2)", function(done) {
-        var command = uglifyjscmd + ' test/input/invalid/assign_2.js';
+        var command = uglifyjscmd + " test/input/invalid/assign_2.js";
         exec(command, function(err, stdout, stderr) {
             assert.ok(err);
             assert.strictEqual(stdout, "");
@@ -400,13 +408,13 @@ describe("bin/uglifyjs", function() {
                 "Parse error at test/input/invalid/assign_2.js:1,32",
                 "console.log(2 || (Math.random() /= 2));",
                 "                                ^",
-                "ERROR: Invalid assignment"
+                "ERROR: Invalid assignment",
             ].join("\n"));
             done();
         });
     });
     it("Should throw syntax error (++this)", function(done) {
-        var command = uglifyjscmd + ' test/input/invalid/assign_3.js';
+        var command = uglifyjscmd + " test/input/invalid/assign_3.js";
         exec(command, function(err, stdout, stderr) {
             assert.ok(err);
             assert.strictEqual(stdout, "");
@@ -414,13 +422,13 @@ describe("bin/uglifyjs", function() {
                 "Parse error at test/input/invalid/assign_3.js:1,17",
                 "console.log(3 || ++this);",
                 "                 ^",
-                "ERROR: Invalid use of ++ operator"
+                "ERROR: Invalid use of ++ operator",
             ].join("\n"));
             done();
         });
     });
     it("Should throw syntax error (++null)", function(done) {
-        var command = uglifyjscmd + ' test/input/invalid/assign_4.js';
+        var command = uglifyjscmd + " test/input/invalid/assign_4.js";
         exec(command, function(err, stdout, stderr) {
             assert.ok(err);
             assert.strictEqual(stdout, "");
@@ -428,13 +436,13 @@ describe("bin/uglifyjs", function() {
                 "Parse error at test/input/invalid/assign_4.js:1,0",
                 "++null",
                 "^",
-                "ERROR: Invalid use of ++ operator"
+                "ERROR: Invalid use of ++ operator",
             ].join("\n"));
             done();
         });
     });
     it("Should throw syntax error (a.=)", function(done) {
-        var command = uglifyjscmd + ' test/input/invalid/dot_1.js';
+        var command = uglifyjscmd + " test/input/invalid/dot_1.js";
         exec(command, function(err, stdout, stderr) {
             assert.ok(err);
             assert.strictEqual(stdout, "");
@@ -442,13 +450,13 @@ describe("bin/uglifyjs", function() {
                 "Parse error at test/input/invalid/dot_1.js:1,2",
                 "a.=",
                 "  ^",
-                "ERROR: Unexpected token: operator «=», expected: name"
+                "ERROR: Unexpected token: operator «=», expected: name",
             ].join("\n"));
             done();
         });
     });
     it("Should throw syntax error (%.a)", function(done) {
-        var command = uglifyjscmd + ' test/input/invalid/dot_2.js';
+        var command = uglifyjscmd + " test/input/invalid/dot_2.js";
         exec(command, function(err, stdout, stderr) {
             assert.ok(err);
             assert.strictEqual(stdout, "");
@@ -456,13 +464,13 @@ describe("bin/uglifyjs", function() {
                 "Parse error at test/input/invalid/dot_2.js:1,0",
                 "%.a;",
                 "^",
-                "ERROR: Unexpected token: operator «%»"
+                "ERROR: Unexpected token: operator «%»",
             ].join("\n"));
             done();
         });
     });
     it("Should throw syntax error (a./();)", function(done) {
-        var command = uglifyjscmd + ' test/input/invalid/dot_3.js';
+        var command = uglifyjscmd + " test/input/invalid/dot_3.js";
         exec(command, function(err, stdout, stderr) {
             assert.ok(err);
             assert.strictEqual(stdout, "");
@@ -470,13 +478,13 @@ describe("bin/uglifyjs", function() {
                 "Parse error at test/input/invalid/dot_3.js:1,2",
                 "a./();",
                 "  ^",
-                "ERROR: Unexpected token: operator «/», expected: name"
+                "ERROR: Unexpected token: operator «/», expected: name",
             ].join("\n"));
             done();
         });
     });
     it("Should throw syntax error ({%: 1})", function(done) {
-        var command = uglifyjscmd + ' test/input/invalid/object.js';
+        var command = uglifyjscmd + " test/input/invalid/object.js";
         exec(command, function(err, stdout, stderr) {
             assert.ok(err);
             assert.strictEqual(stdout, "");
@@ -484,13 +492,13 @@ describe("bin/uglifyjs", function() {
                 "Parse error at test/input/invalid/object.js:1,13",
                 "console.log({%: 1});",
                 "             ^",
-                "ERROR: Unexpected token: operator «%»"
+                "ERROR: Unexpected token: operator «%»",
             ].join("\n"));
             done();
         });
     });
     it("Should throw syntax error (delete x)", function(done) {
-        var command = uglifyjscmd + ' test/input/invalid/delete.js';
+        var command = uglifyjscmd + " test/input/invalid/delete.js";
         exec(command, function(err, stdout, stderr) {
             assert.ok(err);
             assert.strictEqual(stdout, "");
@@ -498,13 +506,13 @@ describe("bin/uglifyjs", function() {
                 "Parse error at test/input/invalid/delete.js:13,11",
                 "    delete x;",
                 "           ^",
-                "ERROR: Calling delete on expression not allowed in strict mode"
+                "ERROR: Calling delete on expression not allowed in strict mode",
             ].join("\n"));
             done();
         });
     });
     it("Should throw syntax error (function g(arguments))", function(done) {
-        var command = uglifyjscmd + ' test/input/invalid/function_1.js';
+        var command = uglifyjscmd + " test/input/invalid/function_1.js";
         exec(command, function(err, stdout, stderr) {
             assert.ok(err);
             assert.strictEqual(stdout, "");
@@ -512,13 +520,13 @@ describe("bin/uglifyjs", function() {
                 "Parse error at test/input/invalid/function_1.js:4,11",
                 "function g(arguments) {",
                 "           ^",
-                "ERROR: Unexpected arguments in strict mode"
+                "ERROR: Unexpected arguments in strict mode",
             ].join("\n"));
             done();
         });
     });
     it("Should throw syntax error (function eval())", function(done) {
-        var command = uglifyjscmd + ' test/input/invalid/function_2.js';
+        var command = uglifyjscmd + " test/input/invalid/function_2.js";
         exec(command, function(err, stdout, stderr) {
             assert.ok(err);
             assert.strictEqual(stdout, "");
@@ -526,13 +534,13 @@ describe("bin/uglifyjs", function() {
                 "Parse error at test/input/invalid/function_2.js:4,9",
                 "function eval() {",
                 "         ^",
-                "ERROR: Unexpected eval in strict mode"
+                "ERROR: Unexpected eval in strict mode",
             ].join("\n"));
             done();
         });
     });
     it("Should throw syntax error (iife arguments())", function(done) {
-        var command = uglifyjscmd + ' test/input/invalid/function_3.js';
+        var command = uglifyjscmd + " test/input/invalid/function_3.js";
         exec(command, function(err, stdout, stderr) {
             assert.ok(err);
             assert.strictEqual(stdout, "");
@@ -540,13 +548,13 @@ describe("bin/uglifyjs", function() {
                 "Parse error at test/input/invalid/function_3.js:4,10",
                 "!function arguments() {",
                 "          ^",
-                "ERROR: Unexpected arguments in strict mode"
+                "ERROR: Unexpected arguments in strict mode",
             ].join("\n"));
             done();
         });
     });
     it("Should throw syntax error (catch (eval))", function(done) {
-        var command = uglifyjscmd + ' test/input/invalid/try.js';
+        var command = uglifyjscmd + " test/input/invalid/try.js";
         exec(command, function(err, stdout, stderr) {
             assert.ok(err);
             assert.strictEqual(stdout, "");
@@ -554,13 +562,13 @@ describe("bin/uglifyjs", function() {
                 "Parse error at test/input/invalid/try.js:7,18",
                 "    try {} catch (eval) {}",
                 "                  ^",
-                "ERROR: Unexpected eval in strict mode"
+                "ERROR: Unexpected eval in strict mode",
             ].join("\n"));
             done();
         });
     });
     it("Should throw syntax error (var eval)", function(done) {
-        var command = uglifyjscmd + ' test/input/invalid/var.js';
+        var command = uglifyjscmd + " test/input/invalid/var.js";
         exec(command, function(err, stdout, stderr) {
             assert.ok(err);
             assert.strictEqual(stdout, "");
@@ -568,13 +576,27 @@ describe("bin/uglifyjs", function() {
                 "Parse error at test/input/invalid/var.js:7,8",
                 "    var eval;",
                 "        ^",
-                "ERROR: Unexpected eval in strict mode"
+                "ERROR: Unexpected eval in strict mode",
+            ].join("\n"));
+            done();
+        });
+    });
+    it("Should throw syntax error (var { eval })", function(done) {
+        var command = uglifyjscmd + " test/input/invalid/destructured_var.js";
+        exec(command, function(err, stdout, stderr) {
+            assert.ok(err);
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/destructured_var.js:7,10",
+                "    var { eval } = 42;",
+                "          ^",
+                "ERROR: Unexpected eval in strict mode",
             ].join("\n"));
             done();
         });
     });
     it("Should throw syntax error (else)", function(done) {
-        var command = uglifyjscmd + ' test/input/invalid/else.js';
+        var command = uglifyjscmd + " test/input/invalid/else.js";
         exec(command, function(err, stdout, stderr) {
             assert.ok(err);
             assert.strictEqual(stdout, "");
@@ -582,13 +604,13 @@ describe("bin/uglifyjs", function() {
                 "Parse error at test/input/invalid/else.js:1,7",
                 "if (0) else 1;",
                 "       ^",
-                "ERROR: Unexpected token: keyword «else»"
+                "ERROR: Unexpected token: keyword «else»",
             ].join("\n"));
             done();
         });
     });
     it("Should throw syntax error (return)", function(done) {
-        var command = uglifyjscmd + ' test/input/invalid/return.js';
+        var command = uglifyjscmd + " test/input/invalid/return.js";
         exec(command, function(err, stdout, stderr) {
             assert.ok(err);
             assert.strictEqual(stdout, "");
@@ -596,13 +618,13 @@ describe("bin/uglifyjs", function() {
                 "Parse error at test/input/invalid/return.js:1,0",
                 "return 42;",
                 "^",
-                "ERROR: 'return' outside of function"
+                "ERROR: 'return' outside of function",
             ].join("\n"));
             done();
         });
     });
     it("Should throw syntax error (for-in init)", function(done) {
-        var command = uglifyjscmd + ' test/input/invalid/for-in_1.js';
+        var command = uglifyjscmd + " test/input/invalid/for-in_1.js";
         exec(command, function(err, stdout, stderr) {
             assert.ok(err);
             assert.strictEqual(stdout, "");
@@ -610,13 +632,13 @@ describe("bin/uglifyjs", function() {
                 "Parse error at test/input/invalid/for-in_1.js:2,5",
                 "for (1, 2, a in b) {",
                 "     ^",
-                "ERROR: Invalid left-hand side in for..in loop"
+                "ERROR: Invalid left-hand side in for..in/of loop",
             ].join("\n"));
             done();
         });
     });
     it("Should throw syntax error (for-in var)", function(done) {
-        var command = uglifyjscmd + ' test/input/invalid/for-in_2.js';
+        var command = uglifyjscmd + " test/input/invalid/for-in_2.js";
         exec(command, function(err, stdout, stderr) {
             assert.ok(err);
             assert.strictEqual(stdout, "");
@@ -624,7 +646,49 @@ describe("bin/uglifyjs", function() {
                 "Parse error at test/input/invalid/for-in_2.js:2,5",
                 "for (var a, b in c) {",
                 "     ^",
-                "ERROR: Only one variable declaration allowed in for..in loop"
+                "ERROR: Only one variable declaration allowed in for..in/of loop",
+            ].join("\n"));
+            done();
+        });
+    });
+    it("Should throw syntax error (for-of init)", function(done) {
+        var command = uglifyjscmd + " test/input/invalid/for-of_1.js";
+        exec(command, function(err, stdout, stderr) {
+            assert.ok(err);
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/for-of_1.js:2,5",
+                "for (b = 2 of a)",
+                "     ^",
+                "ERROR: Invalid left-hand side in for..in/of loop",
+            ].join("\n"));
+            done();
+        });
+    });
+    it("Should throw syntax error (for-of var)", function(done) {
+        var command = uglifyjscmd + " test/input/invalid/for-of_2.js";
+        exec(command, function(err, stdout, stderr) {
+            assert.ok(err);
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/for-of_2.js:2,13",
+                "for (var b = 2 of a)",
+                "             ^",
+                "ERROR: No initializers allowed in for..of loop",
+            ].join("\n"));
+            done();
+        });
+    });
+    it("Should throw syntax error (switch defaults)", function(done) {
+        var command = uglifyjscmd + " test/input/invalid/switch.js";
+        exec(command, function(err, stdout, stderr) {
+            assert.ok(err);
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/switch.js:3,2",
+                "  default:",
+                "  ^",
+                "ERROR: More than one default clause in switch statement",
             ].join("\n"));
             done();
         });

test/mocha/getter-setter.js

@@ -3,7 +3,7 @@ var UglifyJS = require("../node");
 
 describe("Getters and setters", function() {
     it("Should not accept operator symbols as getter/setter name", function() {
-        var illegalOperators = [
+        [
             "++",
             "--",
             "+",
@@ -42,43 +42,26 @@ describe("Getters and setters", function() {
             "&=",
             "&&",
             "||"
-        ];
-        var generator = function() {
-            var results = [];
-
-            for (var i in illegalOperators) {
-                results.push({
-                    code: "var obj = { get " + illegalOperators[i] + "() { return test; }};",
-                    operator: illegalOperators[i],
-                    method: "get"
-                });
-                results.push({
-                    code: "var obj = { set " + illegalOperators[i] + "(value) { test = value}};",
-                    operator: illegalOperators[i],
-                    method: "set"
-                });
-            }
-
-            return results;
-        };
-        var testCase = function(data) {
-            return function() {
-                UglifyJS.parse(data.code);
-            };
-        };
-        var fail = function(data) {
-            return function(e) {
+        ].reduce(function(tests, illegalOperator) {
+            tests.push({
+                code: "var obj = { get " + illegalOperator + "() { return test; }};",
+                operator: illegalOperator,
+            });
+            tests.push({
+                code: "var obj = { set " + illegalOperator + "(value) { test = value; }};",
+                operator: illegalOperator,
+            });
+            return tests;
+        }, []).forEach(function(test) {
+            assert.throws(function() {
+                UglifyJS.parse(test.code);
+            }, test.operator == "=" ? function(e) {
                 return e instanceof UglifyJS.JS_Parse_Error
-                    && e.message === "Unexpected token: operator «" + data.operator + "»";
-            };
-        };
-        var errorMessage = function(data) {
-            return "Expected but didn't get a syntax error while parsing following line:\n" + data.code;
-        };
-        var tests = generator();
-        for (var i = 0; i < tests.length; i++) {
-            var test = tests[i];
-            assert.throws(testCase(test), fail(test), errorMessage(test));
-        }
+                    && /^Unexpected token: punc «{», expected: punc «.*?»$/.test(e.message);
+            } : function(e) {
+                return e instanceof UglifyJS.JS_Parse_Error
+                    && e.message === "Unexpected token: operator «" + test.operator + "»";
+            }, "Expected but didn't get a syntax error while parsing following line:\n" + test.code);
+        });
     });
 });

test/mocha/number-literal.js

@@ -28,4 +28,74 @@ describe("Number literals", function() {
             assert.throws(test(inputs[i]), error, inputs[i]);
         }
     });
+    it("Should parse binary, hexadecimal, octal and underscore correctly", function() {
+        [
+            "42",
+            "4_2",
+            "052",
+            "0o52",
+            "0O52",
+            "0o5_2",
+            "0x2a",
+            "0X2A",
+            "0x2_a",
+            "0b101010",
+            "0B101010",
+            "0b101_010",
+            "0.0000000042e+10",
+            "0.0000000042E+10",
+            "0.0_000000042e+10",
+            "0.0000000042e+1_0",
+            "0.000_000_004_2e+1_0",
+            "0.000_000_004_2e+1_0-0B101_010+0x2_A-0o5_2+4_2",
+        ].forEach(function(code) {
+            var result = UglifyJS.minify(code, {
+                compress: {
+                    expression: true,
+                },
+            });
+            if (result.error) throw result.error;
+            assert.strictEqual(result.code, "42;");
+        });
+    });
+    it("Should reject invalid use of underscore", function() {
+        [
+            "_42",
+            "_+42",
+            "+_42",
+        ].forEach(function(code) {
+            var node = UglifyJS.parse(code, {
+                expression: true,
+            });
+            assert.ok(!node.is_constant(), code);
+            assert.ok(!(node instanceof UglifyJS.AST_Statement), code);
+        });
+        [
+            "42_",
+            "4__2",
+            "0_52",
+            "05_2",
+            "0_o52",
+            "0o_52",
+            "0.0000000042_e10",
+            "0.0000000042e_10",
+            "0.0000000042e_+10",
+            "0.0000000042e+_10",
+        ].forEach(function(code) {
+            assert.throws(function() {
+                UglifyJS.parse(code);
+            }, function(e) {
+                return e instanceof UglifyJS.JS_Parse_Error;
+            }, code);
+        });
+    });
+    it("Should reject invalid syntax under expression=true", function() {
+        assert.throws(function() {
+            UglifyJS.parse("42.g", {
+                expression: true,
+            });
+        }, function(e) {
+            return e instanceof UglifyJS.JS_Parse_Error;
+        });
+    });
 });

test/mocha/reduce.js

@@ -24,6 +24,9 @@ describe("test/reduce.js", function() {
     });
     it("Should eliminate unreferenced labels", function() {
         var result = reduce_test(read("test/input/reduce/label.js"), {
+            compress: {
+                unsafe_math: true,
+            },
             mangle: false,
         }, {
             verbose: false,
@@ -34,8 +37,7 @@ describe("test/reduce.js", function() {
     it("Should retain setter arguments", function() {
         var result = reduce_test(read("test/input/reduce/setter.js"), {
             compress: {
-                keep_fargs: false,
-                unsafe: true,
+                unsafe_math: true,
             },
             mangle: false,
         }, {
@@ -107,28 +109,24 @@ describe("test/reduce.js", function() {
     });
     it("Should print correct output for irreducible test case", function() {
         var result = reduce_test([
-            "console.log(function f(a) {",
-            "    return f.length;",
-            "}());",
+            "console.log(1 + .1 + .1);",
         ].join("\n"), {
             compress: {
-                keep_fargs: false,
+                unsafe_math: true,
             },
             mangle: false,
         });
         if (result.error) throw result.error;
         assert.strictEqual(result.code, [
             "// (beautified)",
-            "console.log(function f(a) {",
-            "    return f.length;",
-            "}());",
-            "// output: 1",
+            "console.log(1 + .1 + .1);",
+            "// output: 1.2000000000000002",
             "// ",
-            "// minify: 0",
+            "// minify: 1.2",
             "// ",
             "// options: {",
             '//   "compress": {',
-            '//     "keep_fargs": false',
+            '//     "unsafe_math": true',
             "//   },",
             '//   "mangle": false',
             "// }",
@@ -296,12 +294,44 @@ describe("test/reduce.js", function() {
             "// }",
         ]).join("\n"));
     });
+    it("Should maintain block-scope for const & let", function() {
+        if (semver.satisfies(process.version, "<4")) return;
+        var code = [
+            '"use strict";',
+            "",
+            "L: for (let a = (1 - .8).toString(); ;) {",
+            "    if (!console.log(a)) {",
+            "        break L;",
+            "    }",
+            "}",
+        ].join("\n");
+        var result = reduce_test(code, {
+            compress: {
+                unsafe_math: true,
+            },
+            mangle: false,
+        });
+        if (result.error) throw result.error;
+        assert.strictEqual(result.code, [
+            "// (beautified)",
+            code,
+            "// output: 0.19999999999999996",
+            "// ",
+            "// minify: 0.2",
+            "// ",
+            "// options: {",
+            '//   "compress": {',
+            '//     "unsafe_math": true',
+            '//   },',
+            '//   "mangle": false',
+            "// }",
+        ].join("\n"));
+    });
     it("Should handle corner cases when intermediate case differs only in Error.message", function() {
         if (semver.satisfies(process.version, "<=0.10")) return;
         var result = reduce_test(read("test/input/reduce/diff_error.js"), {
             compress: {
-                keep_fargs: false,
-                unsafe: true,
+                unsafe_math: true,
             },
             mangle: false,
         }, {
@@ -310,4 +340,24 @@ describe("test/reduce.js", function() {
         if (result.error) throw result.error;
         assert.strictEqual(result.code, read("test/input/reduce/diff_error.reduced.js"));
     });
+    it("Should maintain valid LHS in destructuring assignments", function() {
+        if (semver.satisfies(process.version, "<6")) return;
+        var result = reduce_test(read("test/input/reduce/destructured_assign.js"), {
+            compress: {
+                unsafe_math: true,
+            },
+            mangle: false,
+            validate: true,
+        });
+        if (result.error) throw result.error;
+        assert.strictEqual(result.code, read("test/input/reduce/destructured_assign.reduced.js"));
+    });
+    it("Should handle destructured catch expressions", function() {
+        if (semver.satisfies(process.version, "<6")) return;
+        var result = reduce_test(read("test/input/reduce/destructured_catch.js"), {
+            mangle: false,
+        });
+        if (result.error) throw result.error;
+        assert.strictEqual(result.code, read("test/input/reduce/destructured_catch.reduced.js"));
+    });
 });

test/mocha/sourcemaps.js

@@ -244,6 +244,39 @@ describe("sourcemaps", function() {
             assert.strictEqual(result.code, '(function(){console.log("hello")}).call(this);');
             assert.strictEqual(result.map, '{"version":3,"sources":["main.coffee"],"names":["console","log"],"mappings":"CAAA,WAAAA,QAAQC,IAAI"}');
         });
+        it("Should not overwrite existing sourcesContent", function() {
+            var result = UglifyJS.minify({
+                "in.js": [
+                    '"use strict";',
+                    "",
+                    "var _window$foo = window.foo,",
+                    "    a = _window$foo[0],",
+                    "    b = _window$foo[1];",
+                ].join("\n"),
+            }, {
+                compress: false,
+                mangle: false,
+                sourceMap: {
+                    content: {
+                        version: 3,
+                        sources: [ "in.js" ],
+                        names: [
+                            "window",
+                            "foo",
+                            "a",
+                            "b",
+                        ],
+                        mappings: ";;kBAAaA,MAAM,CAACC,G;IAAfC,C;IAAGC,C",
+                        file: "in.js",
+                        sourcesContent: [ "let [a, b] = window.foo;\n" ],
+                    },
+                    includeSources: true,
+                },
+            });
+            if (result.error) throw result.error;
+            assert.strictEqual(result.code, '"use strict";var _window$foo=window.foo,a=_window$foo[0],b=_window$foo[1];');
+            assert.strictEqual(result.map, '{"version":3,"sources":["in.js"],"sourcesContent":["let [a, b] = window.foo;\\n"],"names":["window","foo","a","b"],"mappings":"6BAAaA,OAAOC,IAAfC,E,eAAGC,E"}');
+        });
     });
 
     describe("sourceMapInline", function() {

test/mocha/string-literal.js

@@ -1,64 +1,58 @@
 var assert = require("assert");
+var run_code = require("../sandbox").run_code;
 var UglifyJS = require("../node");
 
 describe("String literals", function() {
     it("Should throw syntax error if a string literal contains a newline", function() {
-        var inputs = [
+        [
             "'\n'",
             "'\r'",
             '"\r\n"',
             "'\u2028'",
-            '"\u2029"'
-        ];
-
-        var test = function(input) {
-            return function() {
+            '"\u2029"',
+        ].forEach(function(input) {
+            assert.throws(function() {
                 var ast = UglifyJS.parse(input);
-            };
-        };
-
-        var error = function(e) {
-            return e instanceof UglifyJS.JS_Parse_Error
-                && e.message === "Unterminated string constant";
-        };
-
-        for (var input in inputs) {
-            assert.throws(test(inputs[input]), error);
-        }
+            }, function(e) {
+                return e instanceof UglifyJS.JS_Parse_Error
+                    && e.message === "Unterminated string constant";
+            });
+        });
+    });
+    it("Should handle line continuation correctly", function() {
+        [
+            '"\\\r"',
+            '"\\\n"',
+            '"\\\r\n"',
+        ].forEach(function(str) {
+            var code = "console.log(" + str + ");";
+            var result = UglifyJS.minify(code);
+            if (result.error) throw result.error;
+            assert.strictEqual(run_code(result.code), run_code(code));
+        });
     });
-
     it("Should not throw syntax error if a string has a line continuation", function() {
-        var output = UglifyJS.parse('var a = "a\\\nb";').print_to_string();
-        assert.equal(output, 'var a="ab";');
+        var ast = UglifyJS.parse('var a = "a\\\nb";');
+        assert.equal(ast.print_to_string(), 'var a="ab";');
     });
-
     it("Should throw error in strict mode if string contains escaped octalIntegerLiteral", function() {
-        var inputs = [
+        [
             '"use strict";\n"\\76";',
             '"use strict";\nvar foo = "\\76";',
             '"use strict";\n"\\1";',
             '"use strict";\n"\\07";',
-            '"use strict";\n"\\011"'
-        ];
-
-        var test = function(input) {
-            return function() {
+            '"use strict";\n"\\011"',
+        ].forEach(function(input) {
+            assert.throws(function() {
                 var output = UglifyJS.parse(input);
-            }
-        };
-
-        var error = function(e) {
-            return e instanceof UglifyJS.JS_Parse_Error
-                && e.message === "Legacy octal escape sequences are not allowed in strict mode";
-        }
-
-        for (var input in inputs) {
-            assert.throws(test(inputs[input]), error);
-        }
+            }, function(e) {
+                return e instanceof UglifyJS.JS_Parse_Error
+                    && e.message === "Legacy octal escape sequences are not allowed in strict mode";
+            });
+        });
     });
-
     it("Should not throw error outside strict mode if string contains escaped octalIntegerLiteral", function() {
-        var tests = [
+        [
             [ ';"\\76";', ';">";' ],
             [ ';"\\0";', ';"\\0";' ],
             [ ';"\\08"', ';"\\x008";' ],
@@ -66,19 +60,15 @@ describe("String literals", function() {
             [ ';"\\0008"', ';"\\x008";' ],
             [ ';"use\\\n strict";\n"\\07";', ';"use strict";"\07";' ],
             [ '"use strict" === "use strict";\n"\\76";', '"use strict"==="use strict";">";' ],
-        ];
-
-        for (var test in tests) {
-            var output = UglifyJS.parse(tests[test][0]).print_to_string();
-            assert.equal(output, tests[test][1]);
-        }
+        ].forEach(function(test) {
+            var ast = UglifyJS.parse(test[0]);
+            assert.equal(ast.print_to_string(), test[1]);
+        });
     });
-
     it("Should not throw error when digit is 8 or 9", function() {
         assert.equal(UglifyJS.parse('"use strict";;"\\08"').print_to_string(), '"use strict";;"\\x008";');
         assert.equal(UglifyJS.parse('"use strict";;"\\09"').print_to_string(), '"use strict";;"\\x009";');
     });
-
     it("Should not unescape unpaired surrogates", function() {
         var code = [];
         for (var i = 0; i <= 0xF; i++) {
@@ -115,4 +105,33 @@ describe("String literals", function() {
         assert.ok(code.length > ascii.code.length);
         assert.strictEqual(eval(code), eval(ascii.code));
     });
+    it("Should reject invalid Unicode escape sequence", function() {
+        [
+            'var foo = "\\u-111"',
+            'var bar = "\\u{-1}"',
+            'var baz = "\\ugggg"',
+        ].forEach(function(test) {
+            assert.throws(function() {
+                UglifyJS.parse(test);
+            }, function(e) {
+                return e instanceof UglifyJS.JS_Parse_Error
+                    && /^Invalid escape sequence: \\u/.test(e.message);
+            }, test);
+        });
+    });
+    it("Should reject invalid code points in Unicode escape sequence", function() {
+        [
+            // A bit over the valid range
+            '"\\u{110000}"',
+            // 32-bit overflow resulting in "a"
+            '"\\u{100000061}"',
+        ].forEach(function(test) {
+            assert.throws(function() {
+                UglifyJS.parse(test);
+            }, function(e) {
+                return e instanceof UglifyJS.JS_Parse_Error
+                    && /^Invalid escape sequence: \\u{1/.test(e.message);
+            }, test);
+        });
+    });
 });

test/mocha/templates.js

@@ -0,0 +1,67 @@
+var assert = require("assert");
+var run_code = require("../sandbox").run_code;
+var semver = require("semver");
+var UglifyJS = require("../node");
+
+describe("Template literals", function() {
+    it("Should reject invalid literal", function() {
+        [
+            "`foo\\`",
+            "`foo${bar`",
+            "`foo${bar}",
+        ].forEach(function(input) {
+            assert.throws(function() {
+                UglifyJS.parse(input);
+            }, function(e) {
+                return e instanceof UglifyJS.JS_Parse_Error
+                    && e.message === "Unterminated template literal";
+            }, input);
+        });
+    });
+    it("Should reject invalid expression", function() {
+        [
+            "`foo${bar;}`",
+            "`foo${42bar}`",
+        ].forEach(function(input) {
+            assert.throws(function() {
+                UglifyJS.parse(input);
+            }, function(e) {
+                return e instanceof UglifyJS.JS_Parse_Error;
+            }, input);
+        });
+    });
+    it("Should process line-break characters correctly", function() {
+        [
+            // native line breaks
+            [ "`foo\nbar`", "`foo\nbar`" ],
+            [ "`foo\rbar`", "`foo\rbar`" ],
+            [ "`foo\r\nbar`", "`foo\nbar`" ],
+            [ "`foo\r\n\rbar`", "`foo\n\rbar`" ],
+            // escaped line breaks
+            [ "`foo\\nbar`", "`foo\\nbar`" ],
+            [ "`foo\\rbar`", "`foo\\rbar`" ],
+            [ "`foo\r\\nbar`", "`foo\r\\nbar`" ],
+            [ "`foo\\r\nbar`", "`foo\\r\nbar`" ],
+            [ "`foo\\r\\nbar`", "`foo\\r\\nbar`" ],
+            // continuation
+            [ "`foo\\\nbar`", "`foo\\\nbar`" ],
+            [ "`foo\\\rbar`", "`foo\\\rbar`" ],
+            [ "`foo\\\r\nbar`", "`foo\\\nbar`" ],
+            [ "`foo\\\r\n\rbar`", "`foo\\\n\rbar`" ],
+            [ "`foo\\\\nbar`", "`foo\\\\nbar`" ],
+            [ "`foo\\\\rbar`", "`foo\\\\rbar`" ],
+            [ "`foo\\\\r\nbar`", "`foo\\\\r\nbar`" ],
+        ].forEach(function(test) {
+            var input = "console.log(" + test[0] + ");";
+            var result = UglifyJS.minify(input, {
+                compress: false,
+                mangle: false,
+            });
+            if (result.error) throw result.error;
+            var expected = "console.log(" + test[1] + ");";
+            assert.strictEqual(result.code, expected, test[0]);
+            if (semver.satisfies(process.version, "<4")) return;
+            assert.strictEqual(run_code(result.code), run_code(input), test[0]);
+        });
+    });
+});

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/mocha/with.js

@@ -17,7 +17,7 @@ describe("With", function() {
         var ast = UglifyJS.parse("with(e) {f(1, 2)}");
         ast.figure_out_scope();
         assert.equal(ast.uses_with, true);
-        assert.equal(ast.body[0].expression.scope.uses_with, true);
-        assert.equal(ast.body[0].body.body[0].body.expression.scope.uses_with, true);
+        assert.equal(ast.body[0].expression.scope.resolve().uses_with, true);
+        assert.equal(ast.body[0].body.body[0].body.expression.scope.resolve().uses_with, true);
     });
 });