harmony-v3.3.10

fixes #2891

.github/ISSUE_TEMPLATE.md

@@ -8,7 +8,16 @@
 
 **Uglify version (`uglifyjs -V`)**
 
-**JavaScript input**  <!-- ideally as small as possible -->
+**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.**
 

.travis.yml

@@ -4,8 +4,11 @@ node_js:
     - "0.12"
     - "4"
     - "6"
+    - "8"
 env:
     - UGLIFYJS_TEST_ALL=1
 matrix:
   fast_finish: true
 sudo: false
+cache:
+  directories: tmp

CONTRIBUTING.md

@@ -0,0 +1,61 @@
+Contributing
+============
+
+## Documentation
+
+Every new feature and API change should be accompanied by a README additon.
+
+## Testing
+
+All features and bugs should have tests that verify the fix. You can run all
+tests using `npm test`.
+
+The most common type of test are tests that verify input and output of the
+Uglify transforms. These tests exist in `test/compress`. New tests can be added
+either to an existing file or in a new file `issue-xxx.js`.
+
+Tests that cannot be expressed as a simple AST can be found in `test/mocha`.
+
+## Code style
+
+- File encoding must be `UTF-8`.
+- `LF` is always used as a line ending.
+- Statements end with semicolons.
+- Indentation uses 4 spaces, switch `case` 2 spaces.
+- Identifiers use `snake_case`.
+- Strings use double quotes (`"`).
+- Use a trailing comma for multiline array and object literals to minimize diffs.
+- The Uglify code only uses ES5, even in the `harmony` branch.
+- Line length should be at most 80 cols, except when it is easier to read a
+  longer line.
+- If both sides of a comparison are of the same type, `==` and `!=` are used.
+- Multiline conditions place `&&` and `||` first on the line.
+
+**Example feature**
+
+```js
+OPT(AST_Debugger, function(self, compressor) {
+    if (compressor.option("drop_debugger"))
+        return make_node(AST_EmptyStatement, self);
+    return self;
+});
+```
+
+**Example test case**
+
+```js
+drop_debugger: {
+    options = {
+        drop_debugger: true,
+    }
+    input: {
+        debugger;
+        if (foo) debugger;
+    }
+    expect: {
+        if (foo);
+    }
+}
+```
+
+

LICENSE

@@ -1,6 +1,6 @@
 UglifyJS is released under the BSD license:
 
-Copyright 2012-2013 (c) Mihai Bazon <mihai.bazon@gmail.com>
+Copyright 2012-2018 (c) Mihai Bazon <mihai.bazon@gmail.com>
 
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions

README.md

@@ -1,11 +1,11 @@
 uglify-es
 =========
 
-**uglify-es** is an ECMAScript 2015 parser, minifier, compressor and beautifier toolkit.
+A JavaScript parser, mangler/compressor and beautifier toolkit for ES6+.
 
 #### Note:
-- **The `uglify-es` API and CLI is compatible with `uglify-js@3.x`.**
+- **`uglify-es` is API/CLI compatible with `uglify-js@3`.**
-- **`uglify-es` is not backwards compatible with the `uglify-js@2.x` API and CLI.**
+- **`uglify-es` is not backwards compatible with `uglify-js@2`.**
 
 Install
 -------
@@ -67,7 +67,7 @@ a double dash to prevent input files being used as option arguments:
                                 `debug`  Add debug prefix and suffix.
                                 `domprops`  Mangle property names that overlaps
                                             with DOM properties.
-                                `keep_quoted`  Only mangle unquoted properies.
+                                `keep_quoted`  Only mangle unquoted properties.
                                 `regex`  Only mangle matched property names.
                                 `reserved`  List of names that should not be mangled.
     -b, --beautify [options]    Beautify output/specify output options:
@@ -102,13 +102,20 @@ a double dash to prevent input files being used as option arguments:
                                 sequences.
     --config-file <file>        Read `minify()` options from JSON file.
     -d, --define <expr>[=value] Global definitions.
+    --ecma <version>            Specify ECMAScript release: 5, 6, 7 or 8.
     --ie8                       Support non-standard Internet Explorer 8.
                                 Equivalent to setting `ie8: true` in `minify()`
                                 for `compress`, `mangle` and `output` options.
                                 By default UglifyJS will not try to be IE-proof.
+    --keep-classnames           Do not mangle/drop class names.
     --keep-fnames               Do not mangle/drop function names.  Useful for
                                 code relying on Function.prototype.name.
-    --name-cache                File to hold mangled name mappings.
+    --name-cache <file>         File to hold mangled name mappings.
+    --safari10                  Support non-standard Safari 10/11.
+                                Equivalent to setting `safari10: true` in `minify()`
+                                for `mangle` and `output` options.
+                                By default `uglify-es` will not work around
+                                Safari 10/11 bugs.
     --self                      Build UglifyJS as a library (implies --wrap UglifyJS)
     --source-map [options]      Enable source map/specify source map options:
                                 `base`  Path to compute relative paths from input files.
@@ -147,19 +154,19 @@ debugging your compressed JavaScript.  To get a source map, pass
 
 Additional options:
 
-- `--source-map filename=<NAME>` to specify the name of the source map.
+- `--source-map "filename='<NAME>'"` to specify the name of the source map.
 
-- `--source-map root=<URL>` to pass the URL where the original files can be found.
+- `--source-map "root='<URL>'"` to pass the URL where the original files can be found.
+
+- `--source-map "url='<URL>'"` to specify the URL where the source map can be found.
   Otherwise UglifyJS assumes HTTP `X-SourceMap` is being used and will omit the
   `//# sourceMappingURL=` directive.
 
-- `--source-map url=<URL>` to specify the URL where the source map can be found.
-
 For example:
 
     uglifyjs js/file1.js js/file2.js \
              -o foo.min.js -c -m \
-             --source-map root="http://foo.com/src",url=foo.min.js.map
+             --source-map "root='http://foo.com/src',url='foo.min.js.map'"
 
 The above will compress and mangle `file1.js` and `file2.js`, will drop the
 output in `foo.min.js` and the source map in `foo.min.js.map`.  The source
@@ -178,8 +185,8 @@ CoffeeScript → compiled JS, UglifyJS can generate a map from CoffeeScript →
 compressed JS by mapping every token in the compiled JS to its original
 location.
 
-To use this feature pass `--source-map content="/path/to/input/source.map"`
+To use this feature pass `--source-map "content='/path/to/input/source.map'"`
-or `--source-map content=inline` if the source map is included inline with
+or `--source-map "content=inline"` if the source map is included inline with
 the sources.
 
 ## CLI compress options
@@ -200,17 +207,15 @@ Example:
 To enable the mangler you need to pass `--mangle` (`-m`).  The following
 (comma-separated) options are supported:
 
-- `toplevel` — mangle names declared in the top level scope (disabled by
+- `toplevel` (default `false`) -- mangle names declared in the top level scope.
-  default).
 
-- `eval` — 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.
-  (disabled by 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:
 
-    uglifyjs ... -m reserved=[$,require,exports]
+    uglifyjs ... -m reserved=['$','require','exports']
 
 to prevent the `require`, `exports` and `$` names from being changed.
 
@@ -220,7 +225,7 @@ to prevent the `require`, `exports` and `$` names from being changed.
 is a separate step, different from variable name mangling.  Pass
 `--mangle-props` to enable it.  It will mangle all properties in the
 input code with the exception of built in DOM properties and properties
-in core javascript classes.  For example:
+in core JavaScript classes.  For example:
 
 ```javascript
 // example.js
@@ -235,7 +240,7 @@ x.bar_ = 2;
 x["baz_"] = 3;
 console.log(x.calc());
 ```
-Mangle all properties (except for javascript `builtins`):
+Mangle all properties (except for JavaScript `builtins`):
 ```bash
 $ uglifyjs example.js -c -m --mangle-props
 ```
@@ -380,7 +385,47 @@ var code = {
 var options = { toplevel: true };
 var result = UglifyJS.minify(code, options);
 console.log(result.code);
-// console.log(function(n,o){return n+o}(3,7));
+// console.log(3+7);
+```
+
+The `nameCache` option:
+```javascript
+var options = {
+    mangle: {
+        toplevel: true,
+    },
+    nameCache: {}
+};
+var result1 = UglifyJS.minify({
+    "file1.js": "function add(first, second) { return first + second; }"
+}, options);
+var result2 = UglifyJS.minify({
+    "file2.js": "console.log(add(1 + 2, 3 + 4));"
+}, options);
+console.log(result1.code);
+// function n(n,r){return n+r}
+console.log(result2.code);
+// console.log(n(3,7));
+```
+
+You may persist the name cache to the file system in the following way:
+```javascript
+var cacheFileName = "/tmp/cache.json";
+var options = {
+    mangle: {
+        properties: true,
+    },
+    nameCache: JSON.parse(fs.readFileSync(cacheFileName, "utf8"))
+};
+fs.writeFileSync("part1.js", UglifyJS.minify({
+    "file1.js": fs.readFileSync("file1.js", "utf8"),
+    "file2.js": fs.readFileSync("file2.js", "utf8")
+}, options).code, "utf8");
+fs.writeFileSync("part2.js", UglifyJS.minify({
+    "file3.js": fs.readFileSync("file3.js", "utf8"),
+    "file4.js": fs.readFileSync("file4.js", "utf8")
+}, options).code, "utf8");
+fs.writeFileSync(cacheFileName, JSON.stringify(options.nameCache), "utf8");
 ```
 
 An example of a combination of `minify()` options:
@@ -433,6 +478,9 @@ if (result.error) throw result.error;
 
 ## Minify options
 
+- `ecma` (default `undefined`) - pass `5`, `6`, `7` or `8` to override `parse`,
+  `compress` and `output` options.
+
 - `warnings` (default `false`) — pass `true` to return compressor warnings
   in `result.warnings`. Use the value `"verbose"` for more detailed warnings.
 
@@ -458,13 +506,31 @@ 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.
 
+- `nameCache` (default `null`) - pass an empty object `{}` or a previously
+  used `nameCache` object if you wish to cache mangled variable and
+  property names across multiple invocations of `minify()`. Note: this is
+  a read/write property. `minify()` will read the name cache state of this
+  object and update it during minification so that it may be
+  reused or externally persisted by the user.
+
 - `ie8` (default `false`) - set to `true` to support IE8.
 
+- `keep_classnames` (default: `undefined`) - pass `true` to prevent discarding or mangling
+  of class names.
+
+- `keep_fnames` (default: `false`) - pass `true` to prevent discarding or mangling
+  of function names.  Useful for code relying on `Function.prototype.name`. If the
+  top level minify option `keep_classnames` is `undefined` it will be overriden with
+  the value of the top level minify option `keep_fnames`.
+
+- `safari10` (default: `false`) - pass `true` to work around Safari 10/11 bugs in
+  loop scoping and `await`. See `safari10` options in [`mangle`](#mangle-options)
+  and [`output`](#output-options) for details.
+
 ## Minify options structure
 
 ```javascript
 {
-    warnings: false,
     parse: {
         // parse options
     },
@@ -484,8 +550,14 @@ if (result.error) throw result.error;
     sourceMap: {
         // source map options
     },
-    toplevel: false,
+    ecma: 5, // specify one of: 5, 6, 7 or 8
+    keep_classnames: false,
+    keep_fnames: false,
     ie8: false,
+    nameCache: null, // or specify a name cache object
+    safari10: false,
+    toplevel: false,
+    warnings: false,
 }
 ```
 
@@ -539,102 +611,109 @@ If you're using the `X-SourceMap` header instead, you can just omit `sourceMap.u
 ## Parse options
 
 - `bare_returns` (default `false`) -- support top level `return` statements
+
+- `ecma` (default: `8`) -- specify one of `5`, `6`, `7` or `8`. Note: this setting
+  is not presently enforced except for ES8 optional trailing commas in function
+  parameter lists and calls with `ecma` `8`.
+
 - `html5_comments` (default `true`)
+
 - `shebang` (default `true`) -- support `#!command` as the first line
 
 ## Compress options
 
-- `sequences` (default: true) -- join consecutive simple statements using the
+- `arrows` (default: `true`) -- Converts `()=>{return x}` to `()=>x`. Class
-  comma operator.  May be set to a positive integer to specify the maximum number
+  and object literal methods will also be converted to arrow expressions if
-  of consecutive comma sequences that will be generated. If this option is set to
+  the resultant code is shorter: `m(){return x}` becomes `m:()=>x`.
-  `true` then the default `sequences` limit is `200`. Set option to `false` or `0`
+  This transform requires that the `ecma` compress option is set to `6` or greater.
-  to disable. The smallest `sequences` length is `2`. A `sequences` value of `1`
-  is grandfathered to be equivalent to `true` and as such means `200`. On rare
-  occasions the default sequences limit leads to very slow compress times in which
-  case a value of `20` or less is recommended.
 
-- `properties` -- rewrite property access using the dot notation, for
+- `booleans` (default: `true`) -- various optimizations for boolean context,
-  example `foo["bar"] → foo.bar`
+  for example `!!a ? b : c → a ? b : c`
 
-- `dead_code` -- remove unreachable code
+- `collapse_vars` (default: `true`) -- Collapse single-use non-constant variables,
+  side effects permitting.
 
-- `drop_debugger` -- remove `debugger;` statements
+- `comparisons` (default: `true`) -- apply certain optimizations to binary nodes,
-
+  e.g. `!(a <= b) → a > b` (only when `unsafe_comps`), attempts to negate binary
-- `unsafe` (default: false) -- apply "unsafe" transformations (discussion below)
-
-- `unsafe_comps` (default: false) -- Reverse `<` and `<=` to `>` and `>=` to
-  allow improved compression. This might be unsafe when an at least one of two
-  operands is an object with computed values due the use of methods like `get`,
-  or `valueOf`. This could cause change in execution order after operands in the
-  comparison are switching. Compression only works if both `comparisons` and
-  `unsafe_comps` are both set to true.
-
-- `unsafe_math` (default: false) -- optimize numerical expressions like
-  `2 * x * 3` into `6 * x`, which may give imprecise floating point results.
-
-- `unsafe_proto` (default: false) -- optimize expressions like
-  `Array.prototype.slice.call(a)` into `[].slice.call(a)`
-
-- `unsafe_regexp` (default: false) -- enable substitutions of variables with
-  `RegExp` values the same way as if they are constants.
-
-- `conditionals` -- apply optimizations for `if`-s and conditional
-  expressions
-
-- `comparisons` -- apply certain optimizations to binary nodes, for example:
-  `!(a <= b) → a > b` (only when `unsafe_comps`), attempts to negate binary
   nodes, e.g. `a = !b && !c && !d && !e → a=!(b||c||d||e)` etc.
 
-- `evaluate` -- attempt to evaluate constant expressions
+- `computed_props` (default: `true`) -- Transforms constant computed properties
+  into regular ones: `{["computed"]: 1}` is converted to `{computed: 1}`.
 
-- `booleans` -- various optimizations for boolean context, for example `!!a
+- `conditionals` (default: `true`) -- apply optimizations for `if`-s and conditional
-  ? b : c → a ? b : c`
+  expressions
 
-- `loops` -- optimizations for `do`, `while` and `for` loops when we can
+- `dead_code` (default: `true`) -- remove unreachable code
-  statically determine the condition
 
-- `unused` -- drop unreferenced functions and variables (simple direct variable
+- `drop_console` (default: `false`) -- Pass `true` to discard calls to
-  assignments do not count as references unless set to `"keep_assign"`)
+  `console.*` functions. If you wish to drop a specific function call
+  such as `console.info` and/or retain side effects from function arguments
+  after dropping the function call then use `pure_funcs` instead.
 
-- `toplevel` -- drop unreferenced functions (`"funcs"`) and/or variables (`"vars"`)
+- `drop_debugger` (default: `true`) -- remove `debugger;` statements
-  in the top level scope (`false` by default, `true` to drop both unreferenced
-  functions and variables)
 
-- `top_retain` -- prevent specific toplevel functions and variables from `unused`
+- `ecma` (default: `5`) -- Pass `6` or greater to enable `compress` options that
-  removal (can be array, comma-separated, RegExp or function. Implies `toplevel`)
+  will transform ES5 code into smaller ES6+ equivalent forms.
 
-- `hoist_funs` -- hoist function declarations
+- `evaluate` (default: `true`) -- attempt to evaluate constant expressions
 
-- `hoist_vars` (default: false) -- hoist `var` declarations (this is `false`
+- `expression` (default: `false`) -- Pass `true` to preserve completion values
+  from terminal statements without `return`, e.g. in bookmarklets.
+
+- `global_defs` (default: `{}`) -- see [conditional compilation](#conditional-compilation)
+
+- `hoist_funs` (default: `false`) -- hoist function declarations
+
+- `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.
+
+- `hoist_vars` (default: `false`) -- hoist `var` declarations (this is `false`
   by default because it seems to increase the size of the output in general)
 
-- `if_return` -- optimizations for if/return and if/continue
+- `if_return` (default: `true`) -- optimizations for if/return and if/continue
 
-- `join_vars` -- join consecutive `var` statements
+- `inline` (default: `true`) -- inline calls to function with simple/`return` statement:
+  - `false` -- same as `0`
+  - `0` -- disabled inlining
+  - `1` -- inline simple functions
+  - `2` -- inline functions with arguments
+  - `3` -- inline functions with arguments and variables
+  - `true` -- same as `3`
 
-- `cascade` -- small optimization for sequences, transform `x, x` into `x`
+- `join_vars` (default: `true`) -- join consecutive `var` statements
-  and `x = something(), x` into `x = something()`
 
-- `collapse_vars` -- Collapse single-use non-constant variables - side
+- `keep_classnames` (default: `false`) -- Pass `true` to prevent the
-  effects permitting.
+  compressor from discarding class names.  See also: the `keep_classnames`
+  [mangle option](#mangle).
 
-- `reduce_vars` -- Improve optimization on variables assigned with and
+- `keep_fargs` (default: `true`) -- Prevents the compressor from discarding unused
-  used as constant values.
+  function arguments.  You need this for code which relies on `Function.length`.
 
-- `warnings` -- display warnings when dropping unreachable code or unused
+- `keep_fnames` (default: `false`) -- Pass `true` to prevent the
-  declarations etc.
+  compressor from discarding function names.  Useful for code relying on
+  `Function.prototype.name`. See also: the `keep_fnames` [mangle option](#mangle).
 
-- `negate_iife` -- negate "Immediately-Called Function Expressions"
+- `keep_infinity` (default: `false`) -- Pass `true` to prevent `Infinity` from
+  being compressed into `1/0`, which may cause performance issues on Chrome.
+
+- `loops` (default: `true`) -- optimizations for `do`, `while` and `for` loops
+  when we can statically determine the condition.
+
+- `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.
 
-- `pure_getters` -- the default is `false`.  If you pass `true` for
+- `passes` (default: `1`) -- The maximum number of times to run compress.
-  this, UglifyJS will assume that object property access
+  In some cases more than one pass leads to further compressed code.  Keep in
-  (e.g. `foo.bar` or `foo["bar"]`) doesn't have any side effects.
+  mind more passes will take more time.
-  Specify `"strict"` to treat `foo.bar` as side-effect-free only when
-  `foo` is certain to not throw, i.e. not `null` or `undefined`.
 
-- `pure_funcs` -- default `null`.  You can pass an array of names and
+- `properties` (default: `true`) -- rewrite property access using the dot notation, for
+  example `foo["bar"] → foo.bar`
+
+- `pure_funcs` (default: `null`) -- You can pass an array of names and
   UglifyJS will assume that those functions do not produce side
   effects.  DANGER: will not check if the name is redefined in scope.
   An example case here, for instance `var q = Math.floor(a/b)`.  If
@@ -645,47 +724,115 @@ If you're using the `X-SourceMap` header instead, you can just omit `sourceMap.u
   statement would get discarded.  The current implementation adds some
   overhead (compression will be slower).
 
-- `drop_console` -- default `false`.  Pass `true` to discard calls to
+- `pure_getters` (default: `"strict"`) -- If you pass `true` for
-  `console.*` functions. If you wish to drop a specific function call
+  this, UglifyJS will assume that object property access
-  such as `console.info` and/or retain side effects from function arguments
+  (e.g. `foo.bar` or `foo["bar"]`) doesn't have any side effects.
-  after dropping the function call then use `pure_funcs` instead.
+  Specify `"strict"` to treat `foo.bar` as side-effect-free only when
+  `foo` is certain to not throw, i.e. not `null` or `undefined`.
 
-- `expression` -- default `false`.  Pass `true` to preserve completion values
+- `reduce_funcs` (default: `true`) -- Allows single-use functions to be
-  from terminal statements without `return`, e.g. in bookmarklets.
+  inlined as function expressions when permissible allowing further
+  optimization.  Enabled by default.  Option depends on `reduce_vars`
+  being enabled.  Some code runs faster in the Chrome V8 engine if this
+  option is disabled.  Does not negatively impact other major browsers.
 
-- `keep_fargs` -- default `true`.  Prevents the
+- `reduce_vars` (default: `true`) -- Improve optimization on variables assigned with and
-  compressor from discarding unused function arguments.  You need this
+  used as constant values.
-  for code which relies on `Function.length`.
 
-- `keep_fnames` -- default `false`.  Pass `true` to prevent the
+- `sequences` (default: `true`) -- join consecutive simple statements using the
-  compressor from discarding function names.  Useful for code relying on
+  comma operator.  May be set to a positive integer to specify the maximum number
-  `Function.prototype.name`. See also: the `keep_fnames` [mangle option](#mangle).
+  of consecutive comma sequences that will be generated. If this option is set to
+  `true` then the default `sequences` limit is `200`. Set option to `false` or `0`
+  to disable. The smallest `sequences` length is `2`. A `sequences` value of `1`
+  is grandfathered to be equivalent to `true` and as such means `200`. On rare
+  occasions the default sequences limit leads to very slow compress times in which
+  case a value of `20` or less is recommended.
 
-- `passes` -- default `1`. Number of times to run compress with a maximum of 3.
+- `side_effects` (default: `true`) -- Pass `false` to disable potentially dropping
-  In some cases more than one pass leads to further compressed code.  Keep in
-  mind more passes will take more time.
-
-- `keep_infinity` -- default `false`. Pass `true` to prevent `Infinity` from
-  being compressed into `1/0`, which may cause performance issues on Chrome.
-
-- `side_effects` -- default `true`. Pass `false` to disable potentially dropping
   functions marked as "pure".  A function call is marked as "pure" if a comment
   annotation `/*@__PURE__*/` or `/*#__PURE__*/` immediately precedes the call. For
   example: `/*@__PURE__*/foo();`
 
+- `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)
+
+- `top_retain` (default: `null`) -- prevent specific toplevel functions and
+  variables from `unused` removal (can be array, comma-separated, RegExp or
+  function. Implies `toplevel`)
+
+- `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.
+
+- `unsafe` (default: `false`) -- apply "unsafe" transformations (discussion below)
+
+- `unsafe_arrows` (default: `false`) -- Convert ES5 style anonymous function
+  expressions to arrow functions if the function body does not reference `this`.
+  Note: it is not always safe to perform this conversion if code relies on the
+  the function having a `prototype`, which arrow functions lack.
+  This transform requires that the `ecma` compress option is set to `6` or greater.
+
+- `unsafe_comps` (default: `false`) -- Reverse `<` and `<=` to `>` and `>=` to
+  allow improved compression. This might be unsafe when an at least one of two
+  operands is an object with computed values due the use of methods like `get`,
+  or `valueOf`. This could cause change in execution order after operands in the
+  comparison are switching. Compression only works if both `comparisons` and
+  `unsafe_comps` are both set to true.
+
+- `unsafe_Function` (default: `false`) -- compress and mangle `Function(args, code)`
+  when both `args` and `code` are string literals.
+
+- `unsafe_math` (default: `false`) -- optimize numerical expressions like
+  `2 * x * 3` into `6 * x`, which may give imprecise floating point results.
+
+- `unsafe_methods` (default: false) -- Converts `{ m: function(){} }` to
+  `{ m(){} }`. `ecma` must be set to `6` or greater to enable this transform.
+  If `unsafe_methods` is a RegExp then key/value pairs with keys matching the
+  RegExp will be converted to concise methods.
+  Note: if enabled there is a risk of getting a "`<method name>` is not a
+  constructor" TypeError should any code try to `new` the former function.
+
+- `unsafe_proto` (default: `false`) -- optimize expressions like
+  `Array.prototype.slice.call(a)` into `[].slice.call(a)`
+
+- `unsafe_regexp` (default: `false`) -- enable substitutions of variables with
+  `RegExp` values the same way as if they are constants.
+
+- `unsafe_undefined` (default: `false`) -- substitute `void 0` if there is a
+  variable named `undefined` in scope (variable name will be mangled, typically
+  reduced to a single character)
+
+- `unused` (default: `true`) -- drop unreferenced functions and variables (simple
+  direct variable assignments do not count as references unless set to `"keep_assign"`)
+
+- `warnings` (default: `false`) -- display warnings when dropping unreachable
+  code or unused declarations etc.
+
 ## Mangle options
 
-- `reserved` - pass an array of identifiers that should be excluded from mangling
+- `eval` (default `false`) -- Pass `true` to mangle names visible in scopes
+  where `eval` or `with` are used.
 
-- `toplevel` — mangle names declared in the top level scope (disabled by
+- `keep_classnames` (default `false`) -- Pass `true` to not mangle class names.
-default).
+  See also: the `keep_classnames` [compress option](#compress-options).
 
-- `eval` — mangle names visible in scopes where eval or with are used
+- `keep_fnames` (default `false`) -- Pass `true` to not mangle function names.
-(disabled by default).
+  Useful for code relying on `Function.prototype.name`. See also: the `keep_fnames`
+  [compress option](#compress-options).
 
-- `keep_fnames` -- default `false`.  Pass `true` to not mangle
+- `reserved` (default `[]`) -- Pass an array of identifiers that should be
-function names.  Useful for code relying on `Function.prototype.name`.
+  excluded from mangling. Example: `["foo", "bar"]`.
-See also: the `keep_fnames` [compress option](#compress-options).
+
+- `toplevel` (default `false`) -- Pass `true` to mangle names declared in the
+  top level scope.
+
+- `safari10` (default `false`) -- Pass `true` to work around the Safari 10 loop
+  iterator [bug](https://bugs.webkit.org/show_bug.cgi?id=171041)
+  "Cannot declare a let variable twice".
+  See also: the `safari10` [output option](#output-options).
 
 Examples:
 
@@ -711,16 +858,20 @@ UglifyJS.minify(code, { mangle: { toplevel: true } }).code;
 
 ### Mangle properties options
 
-- `reserved` (default: `[]`) -- Do not mangle property names listed in the
-  `reserved` array.
-- `regex` (default: `null`) -— Pass a RegExp literal to only mangle property
-  names matching the regular expression.
-- `keep_quoted` (default: `false`) -— Only mangle unquoted property names.
-- `debug` (default: `false`) -— Mangle names with the original name still present.
-  Pass an empty string `""` to enable, or a non-empty string to set the debug suffix.
 - `builtins` (default: `false`) -- Use `true` to allow the mangling of builtin
   DOM properties. Not recommended to override this setting.
 
+- `debug` (default: `false`) -— Mangle names with the original name still present.
+  Pass an empty string `""` to enable, or a non-empty string to set the debug suffix.
+
+- `keep_quoted` (default: `false`) -— Only mangle unquoted property names.
+
+- `regex` (default: `null`) -— Pass a RegExp literal to only mangle property
+  names matching the regular expression.
+
+- `reserved` (default: `[]`) -- Do not mangle property names listed in the
+  `reserved` array.
+
 ## Output options
 
 The code generator tries to output shortest code possible by default.  In
@@ -729,51 +880,78 @@ can pass additional arguments that control the code output:
 
 - `ascii_only` (default `false`) -- escape Unicode characters in strings and
   regexps (affects directives with non-ascii characters becoming invalid)
+
 - `beautify` (default `true`) -- whether to actually beautify the output.
   Passing `-b` will set this to true, but you might need to pass `-b` even
   when you want to generate minified code, in order to specify additional
   arguments, so you can use `-b beautify=false` to override it.
+
 - `bracketize` (default `false`) -- always insert brackets in `if`, `for`,
   `do`, `while` or `with` statements, even if their body is a single
   statement.
+
 - `comments` (default `false`) -- pass `true` or `"all"` to preserve all
   comments, `"some"` to preserve some comments, a regular expression string
   (e.g. `/^!/`) or a function.
-- `ecma` (default `5`) -- set output printing mode.  This will only change the
+
-  output in direct control of the beautifier.  Non-compatible features in the
+- `ecma` (default `5`) -- set output printing mode. Set `ecma` to `6` or
-  abstract syntax tree will still be outputted as is.
+  greater to emit shorthand object properties - i.e.: `{a}` instead of `{a: a}`.
-- `indent_level` (default 4)
+  The `ecma` option will only change the output in direct control of the
-- `indent_start` (default 0) -- prefix all lines by that many spaces
+  beautifier. Non-compatible features in the abstract syntax tree will still
+  be output as is. For example: an `ecma` setting of `5` will **not** convert
+  ES6+ code to ES5.
+
+- `indent_level` (default `4`)
+
+- `indent_start` (default `0`) -- prefix all lines by that many spaces
+
 - `inline_script` (default `false`) -- escape the slash in occurrences of
   `</script` in strings
+
 - `keep_quoted_props` (default `false`) -- when turned on, prevents stripping
   quotes from property names in object literals.
+
 - `max_line_len` (default `false`) -- maximum line length (for uglified code)
+
 - `preamble` (default `null`) -- when passed it must be a string and
   it will be prepended to the output literally.  The source map will
   adjust for this text.  Can be used to insert a comment containing
   licensing information, for example.
+
 - `preserve_line` (default `false`) -- pass `true` to preserve lines, but it
   only works if `beautify` is set to `false`.
+
 - `quote_keys` (default `false`) -- pass `true` to quote all keys in literal
   objects
+
 - `quote_style` (default `0`) -- preferred quote style for strings (affects
   quoted property names and directives as well):
   - `0` -- prefers double quotes, switches to single quotes when there are
-    more double quotes in the string itself.
+    more double quotes in the string itself. `0` is best for gzip size.
   - `1` -- always use single quotes
   - `2` -- always use double quotes
   - `3` -- always use the original quotes
+
+- `safari10` (default `false`) -- set this option to `true` to work around
+  the [Safari 10/11 await bug](https://bugs.webkit.org/show_bug.cgi?id=176685).
+  See also: the `safari10` [mangle option](#mangle-options).
+
 - `semicolons` (default `true`) -- separate statements with semicolons.  If
   you pass `false` then whenever possible we will use a newline instead of a
   semicolon, leading to more readable output of uglified code (size before
   gzip could be smaller; size after gzip insignificantly larger).
+
 - `shebang` (default `true`) -- preserve shebang `#!` in preamble (bash scripts)
-- `width` (default 80) -- only takes effect when beautification is on, this
+
+- `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).
   It doesn't work very well currently, but it does make the code generated
   by UglifyJS more readable.
+
 - `wrap_iife` (default `false`) -- pass `true` to wrap immediately invoked
   function expressions. See
   [#640](https://github.com/mishoo/UglifyJS2/issues/640) for more details.
@@ -819,10 +997,6 @@ when this flag is on:
 - `new Object()` → `{}`
 - `String(exp)` or `exp.toString()` → `"" + exp`
 - `new Object/RegExp/Function/Error/Array (...)` → we discard the `new`
-- `typeof foo == "undefined"` → `foo === void 0`
-- `void 0` → `undefined` (if there is a variable named "undefined" in
-  scope; we do it because the variable name will be mangled, typically
-  reduced to a single character)
 
 ### Conditional compilation
 
@@ -972,3 +1146,54 @@ in total it's a bit more than just using UglifyJS's own parser.
 
 [acorn]: https://github.com/ternjs/acorn
 [sm-spec]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k
+
+### Uglify Fast Minify Mode
+
+It's not well known, but whitespace removal and symbol mangling accounts
+for 95% of the size reduction in minified code for most JavaScript - not
+elaborate code transforms. One can simply disable `compress` to speed up
+Uglify builds by 3 to 4 times. In this fast `mangle`-only mode Uglify has
+comparable minify speeds and gzip sizes to
+[`butternut`](https://www.npmjs.com/package/butternut):
+
+| d3.js | minify size | gzip size | minify time (seconds) |
+| --- | ---: | ---: | ---: |
+| original | 451,131 | 108,733 | - |
+| uglify-js@3.0.24 mangle=false, compress=false | 316,600 | 85,245 | 0.70 |
+| uglify-js@3.0.24 mangle=true, compress=false | 220,216 | 72,730 | 1.13 |
+| butternut@0.4.6 | 217,568 | 72,738 | 1.41 |
+| uglify-js@3.0.24 mangle=true, compress=true | 212,511 | 71,560 | 3.36 |
+| babili@0.1.4 | 210,713 | 72,140 | 12.64 |
+
+To enable fast minify mode from the CLI use:
+```
+uglifyjs file.js -m
+```
+To enable fast minify mode with the API use:
+```js
+UglifyJS.minify(code, { compress: false, mangle: true });
+```
+
+#### 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
+expected as code is optimized and mappings are often simply not possible as
+some code no longer exists. For highest fidelity in source map debugging
+disable the Uglify `compress` option and just use `mangle`.
+
+### Compiler assumptions
+
+To allow for better optimizations, the compiler makes various assumptions:
+
+- `.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.
+- `arguments.callee`, `arguments.caller` and `Function.prototype.caller` are not used.
+- The code doesn't expect the contents of `Function.prototype.toString()` or
+  `Error.prototype.stack` to be anything in particular.
+- Getting and setting properties on a plain object does not cause other side effects
+  (using `.watch()` or `Proxy`).
+- Object properties can be added, removed and modified (not prevented with
+  `Object.defineProperty()`, `Object.defineProperties()`, `Object.freeze()`,
+  `Object.preventExtensions()` or `Object.seal()`).

appveyor.yml

@@ -1,24 +1,20 @@
 environment:
   matrix:
-  - nodejs_version: "0.10"
+    - nodejs_version: "0.10"
-  - nodejs_version: "0.12"
+    - nodejs_version: "0.12"
-  - nodejs_version: "4.0"
+    - nodejs_version: "4"
-  - nodejs_version: "6.0"
+    - nodejs_version: "6"
-
+    - nodejs_version: "8"
+install:
+  - ps: Install-Product node $env:nodejs_version
+  - set UGLIFYJS_TEST_ALL=1
+  - npm install
+build: off
+cache:
+  - tmp
 matrix:
   fast_finish: true
-
-platform:
-  - x86
-  - x64
-
-install:
-  - ps: Install-Product node $env:nodejs_version $env:platform
-  - npm install
-
 test_script:
   - node --version
   - npm --version
   - npm test
-
-build: off

bin/uglifyjs

@@ -3,11 +3,7 @@
 
 "use strict";
 
-// workaround for tty output truncation upon process.exit()
+require("../tools/exit");
-[process.stdout, process.stderr].forEach(function(stream){
-    if (stream._handle && stream._handle.setBlocking)
-        stream._handle.setBlocking(true);
-});
 
 var fs = require("fs");
 var info = require("../package.json");
@@ -15,7 +11,7 @@ var path = require("path");
 var program = require("commander");
 var UglifyJS = require("../tools/node");
 
-var skip_keys = [ "cname", "enclosed", "parent_scope", "scope", "thedef", "uses_eval", "uses_with" ];
+var skip_keys = [ "cname", "inlined", "parent_scope", "scope", "uses_eval", "uses_with" ];
 var files = {};
 var options = {
     compress: false,
@@ -30,30 +26,28 @@ else if (process.argv.indexOf("options") >= 0) program.helpInformation = functio
     var options = UglifyJS.default_options();
     for (var option in options) {
         text.push("--" + (option == "output" ? "beautify" : option == "sourceMap" ? "source-map" : option) + " options:");
-        var defs = options[option];
+        text.push(format_object(options[option]));
-        var padding = "";
-        Object.keys(defs).map(function(name) {
-            if (padding.length < name.length) padding = Array(name.length + 1).join(" ");
-            return [ name, JSON.stringify(defs[name]) ];
-        }).forEach(function(tokens) {
-            text.push("  " + tokens[0] + padding.slice(tokens[0].length - 2) + tokens[1]);
-        });
         text.push("");
     }
     return text.join("\n");
 };
-program.option("-p, --parse <options>", "Specify parser options.", parse_js("parse", true));
+program.option("-p, --parse <options>", "Specify parser options.", parse_js());
-program.option("-c, --compress [options]", "Enable compressor/specify compressor options.", parse_js("compress", true));
+program.option("-c, --compress [options]", "Enable compressor/specify compressor options.", parse_js());
-program.option("-m, --mangle [options]", "Mangle names/specify mangler options.", parse_js("mangle", true));
+program.option("-m, --mangle [options]", "Mangle names/specify mangler options.", parse_js());
-program.option("--mangle-props [options]", "Mangle properties/specify mangler options.", parse_js("mangle-props", true));
+program.option("--mangle-props [options]", "Mangle properties/specify mangler options.", parse_js());
-program.option("-b, --beautify [options]", "Beautify output/specify output options.", parse_js("beautify", true));
+program.option("-b, --beautify [options]", "Beautify output/specify output options.", parse_js());
 program.option("-o, --output <file>", "Output file (default STDOUT).");
 program.option("--comments [filter]", "Preserve copyright comments in the output.");
 program.option("--config-file <file>", "Read minify() options from JSON file.");
 program.option("-d, --define <expr>[=value]", "Global definitions.", parse_js("define"));
+program.option("--ecma <version>", "Specify ECMAScript release: 5, 6, 7 or 8.");
 program.option("--ie8", "Support non-standard Internet Explorer 8.");
+program.option("--keep-classnames", "Do not mangle/drop class names.");
 program.option("--keep-fnames", "Do not mangle/drop function names. Useful for code relying on Function.prototype.name.");
 program.option("--name-cache <file>", "File to hold mangled name mappings.");
+program.option("--rename", "Force symbol expansion.");
+program.option("--no-rename", "Disable symbol expansion.");
+program.option("--safari10", "Support non-standard Safari 10.");
 program.option("--self", "Build UglifyJS as a library (implies --wrap UglifyJS)");
 program.option("--source-map [options]", "Enable source map/specify source map options.", parse_source_map());
 program.option("--timings", "Display operations run time on STDERR.")
@@ -72,6 +66,7 @@ if (!program.output && program.sourceMap && program.sourceMap.url != "inline") {
     "compress",
     "ie8",
     "mangle",
+    "safari10",
     "sourceMap",
     "toplevel",
     "wrap"
@@ -80,6 +75,10 @@ if (!program.output && program.sourceMap && program.sourceMap.url != "inline") {
         options[name] = program[name];
     }
 });
+if ("ecma" in program) {
+    if (program.ecma != (program.ecma | 0)) fatal("ERROR: ecma must be an integer");
+    options.ecma = program.ecma | 0;
+}
 if (program.beautify) {
     options.output = typeof program.beautify == "object" ? program.beautify : {};
     if (!("beautify" in options.output)) {
@@ -97,6 +96,9 @@ if (program.define) {
         options.compress.global_defs[expr] = program.define[expr];
     }
 }
+if (program.keepClassnames) {
+    options.keep_classnames = true;
+}
 if (program.keepFnames) {
     options.keep_fnames = true;
 }
@@ -113,17 +115,8 @@ if (program.mangleProps) {
     if (typeof options.mangle != "object") options.mangle = {};
     options.mangle.properties = program.mangleProps;
 }
-var cache;
 if (program.nameCache) {
-    cache = JSON.parse(read_file(program.nameCache, "{}"));
+    options.nameCache = JSON.parse(read_file(program.nameCache, "{}"));
-    if (options.mangle) {
-        if (typeof options.mangle != "object") options.mangle = {};
-        options.mangle.cache = to_cache("vars");
-        if (options.mangle.properties) {
-            if (typeof options.mangle.properties != "object") options.mangle.properties = {};
-            options.mangle.properties.cache = to_cache("props");
-        }
-    }
 }
 if (program.output == "ast") {
     options.output = {
@@ -138,6 +131,11 @@ if (program.parse) {
         fatal("ERROR: inline source map only works with built-in parser");
     }
 }
+if (~program.rawArgs.indexOf("--rename")) {
+    options.rename = true;
+} else if (!program.rename) {
+    options.rename = false;
+}
 var convert_path = function(name) {
     return name;
 };
@@ -157,7 +155,7 @@ if (program.verbose) {
 }
 if (program.self) {
     if (program.args.length) {
-        console.error("WARN: Ignoring input files since --self was passed");
+        print_error("WARN: Ignoring input files since --self was passed");
     }
     if (!options.wrap) options.wrap = "UglifyJS";
     simple_glob(UglifyJS.FILES).forEach(function(name) {
@@ -187,7 +185,7 @@ function convert_ast(fn) {
 
 function run() {
     UglifyJS.AST_Node.warn_function = function(msg) {
-        console.error("WARN:", msg);
+        print_error("WARN: " + msg);
     };
     if (program.timings) options.timings = true;
     try {
@@ -216,7 +214,7 @@ function run() {
     if (result.error) {
         var ex = result.error;
         if (ex.name == "SyntaxError") {
-            console.error("Parse error at " + ex.filename + ":" + ex.line + "," + ex.col);
+            print_error("Parse error at " + ex.filename + ":" + ex.line + "," + ex.col);
             var col = ex.col;
             var lines = files[ex.filename].split(/\r?\n/);
             var line = lines[ex.line - 1];
@@ -225,21 +223,35 @@ function run() {
                 col = line.length;
             }
             if (line) {
-                if (col > 40) {
+                var limit = 70;
-                    line = line.slice(col - 40);
+                if (col > limit) {
-                    col = 40;
+                    line = line.slice(col - limit);
+                    col = limit;
                 }
-                console.error(line.slice(0, 80));
+                print_error(line.slice(0, 80));
-                console.error(line.slice(0, col).replace(/\S/g, " ") + "^");
+                print_error(line.slice(0, col).replace(/\S/g, " ") + "^");
             }
         }
         if (ex.defs) {
-            console.error("Supported options:");
+            print_error("Supported options:");
-            console.error(ex.defs);
+            print_error(format_object(ex.defs));
         }
         fatal(ex);
     } else if (program.output == "ast") {
-        console.log(JSON.stringify(result.ast, function(key, value) {
+        if (!options.compress && !options.mangle) {
+            result.ast.figure_out_scope({});
+        }
+        print(JSON.stringify(result.ast, function(key, value) {
+            if (value) switch (key) {
+              case "thedef":
+                return symdef(value);
+              case "enclosed":
+                return value.length ? value.map(symdef) : undefined;
+              case "variables":
+              case "functions":
+              case "globals":
+                return value.size() ? value.map(symdef) : undefined;
+            }
             if (skip_key(key)) return;
             if (value instanceof UglifyJS.AST_Token) return;
             if (value instanceof UglifyJS.Dictionary) return;
@@ -247,6 +259,11 @@ function run() {
                 var result = {
                     _class: "AST_" + value.TYPE
                 };
+                if (value.block_scope) {
+                    result.variables = value.block_scope.variables;
+                    result.functions = value.block_scope.functions;
+                    result.enclosed = value.block_scope.enclosed;
+                }
                 value.CTOR.PROPS.forEach(function(prop) {
                     result[prop] = value[prop];
                 });
@@ -255,7 +272,7 @@ function run() {
             return value;
         }, 2));
     } else if (program.output == "spidermonkey") {
-        console.log(JSON.stringify(UglifyJS.minify(result.code, {
+        print(JSON.stringify(UglifyJS.minify(result.code, {
             compress: false,
             mangle: false,
             output: {
@@ -269,21 +286,19 @@ function run() {
             fs.writeFileSync(program.output + ".map", result.map);
         }
     } else {
-        console.log(result.code);
+        print(result.code);
     }
     if (program.nameCache) {
-        fs.writeFileSync(program.nameCache, JSON.stringify(cache, function(key, value) {
+        fs.writeFileSync(program.nameCache, JSON.stringify(options.nameCache));
-            return value instanceof UglifyJS.Dictionary ? value.toObject() : value;
-        }));
     }
     if (result.timings) for (var phase in result.timings) {
-        console.error("- " + phase + ": " + result.timings[phase].toFixed(3) + "s");
+        print_error("- " + phase + ": " + result.timings[phase].toFixed(3) + "s");
     }
 }
 
 function fatal(message) {
     if (message instanceof Error) message = message.stack.replace(/^\S*?Error:/, "ERROR:")
-    console.error(message);
+    print_error(message);
     process.exit(1);
 }
 
@@ -327,7 +342,7 @@ function read_file(path, default_value) {
     }
 }
 
-function parse_js(flag, constants) {
+function parse_js(flag) {
     return function(value, options) {
         options = options || {};
         try {
@@ -345,7 +360,7 @@ function parse_js(flag, constants) {
                 if (node instanceof UglifyJS.AST_Assign) {
                     var name = node.left.print_to_string();
                     var value = node.right;
-                    if (!constants) {
+                    if (flag) {
                         options[name] = value;
                     } else if (value instanceof UglifyJS.AST_Array) {
                         options[name] = value.elements.map(to_string);
@@ -368,37 +383,57 @@ function parse_js(flag, constants) {
                 }
             }));
         } catch(ex) {
-            options[value] = null;
+            if (flag) {
+                fatal("Error parsing arguments for '" + flag + "': " + value);
+            } else {
+                options[value] = null;
+            }
         }
         return options;
     }
 }
 
 function parse_source_map() {
-    var parse = parse_js("sourceMap", true);
+    var parse = parse_js();
     return function(value, options) {
-        var hasContent = options && options.sourceMap && "content" in options.sourceMap;
+        var hasContent = options && "content" in options;
         var settings = parse(value, options);
         if (!hasContent && settings.content && settings.content != "inline") {
-            console.error("INFO: Using input source map:", settings.content);
+            print_error("INFO: Using input source map: " + settings.content);
             settings.content = read_file(settings.content, settings.content);
         }
         return settings;
     }
 }
 
-function to_cache(key) {
-    if (cache[key]) {
-        cache[key].props = UglifyJS.Dictionary.fromObject(cache[key].props);
-    } else {
-        cache[key] = {
-            cname: -1,
-            props: new UglifyJS.Dictionary()
-        };
-    }
-    return cache[key];
-}
-
 function skip_key(key) {
     return skip_keys.indexOf(key) >= 0;
 }
+
+function symdef(def) {
+    var ret = (1e6 + def.id) + " " + def.name;
+    if (def.mangled_name) ret += " " + def.mangled_name;
+    return ret;
+}
+
+function format_object(obj) {
+    var lines = [];
+    var padding = "";
+    Object.keys(obj).map(function(name) {
+        if (padding.length < name.length) padding = Array(name.length + 1).join(" ");
+        return [ name, JSON.stringify(obj[name]) ];
+    }).forEach(function(tokens) {
+        lines.push("  " + tokens[0] + padding.slice(tokens[0].length - 2) + tokens[1]);
+    });
+    return lines.join("\n");
+}
+
+function print_error(msg) {
+    process.stderr.write(msg);
+    process.stderr.write("\n");
+}
+
+function print(txt) {
+    process.stdout.write(txt);
+    process.stdout.write("\n");
+}

lib/ast.js

@@ -87,7 +87,7 @@ function DEFNODE(type, props, methods, base) {
     return ctor;
 };
 
-var AST_Token = DEFNODE("Token", "type value line col pos endline endcol endpos nlb comments_before file raw", {
+var AST_Token = DEFNODE("Token", "type value line col pos endline endcol endpos nlb comments_before comments_after file raw", {
 }, null);
 
 var AST_Node = DEFNODE("Node", "start end", {
@@ -134,11 +134,10 @@ var AST_Debugger = DEFNODE("Debugger", null, {
     $documentation: "Represents a debugger statement",
 }, AST_Statement);
 
-var AST_Directive = DEFNODE("Directive", "value scope quote", {
+var AST_Directive = DEFNODE("Directive", "value quote", {
     $documentation: "Represents a directive, like \"use strict\";",
     $propdoc: {
         value: "[string] The value of this directive as a plain string (it's not an AST_String!)",
-        scope: "[AST_Scope/S] The scope that this directive affects",
         quote: "[string] the original quote character"
     },
 }, AST_Statement);
@@ -268,11 +267,10 @@ var AST_For = DEFNODE("For", "init condition step", {
     }
 }, AST_IterationStatement);
 
-var AST_ForIn = DEFNODE("ForIn", "init name object", {
+var AST_ForIn = DEFNODE("ForIn", "init object", {
     $documentation: "A `for ... in` statement",
     $propdoc: {
         init: "[AST_Node] the `for/in` initialization code",
-        name: "[AST_SymbolRef?] the loop variable, only if `init` is AST_Var",
         object: "[AST_Node] the object that we're looping through"
     },
     _walk: function(visitor) {
@@ -303,10 +301,9 @@ var AST_With = DEFNODE("With", "expression", {
 
 /* -----[ scope and functions ]----- */
 
-var AST_Scope = DEFNODE("Scope", "directives variables functions uses_with uses_eval parent_scope enclosed cname", {
+var AST_Scope = DEFNODE("Scope", "variables functions uses_with uses_eval parent_scope enclosed cname", {
     $documentation: "Base class for all statements introducing a lexical scope",
     $propdoc: {
-        directives: "[string*/S] an array of directives declared in this scope",
         variables: "[Object/S] a map of name -> SymbolDef for all variables/functions defined in this scope",
         functions: "[Object/S] like `variables`, but only lists function declarations",
         uses_with: "[boolean/S] tells whether this scope uses the `with` statement",
@@ -315,12 +312,19 @@ var AST_Scope = DEFNODE("Scope", "directives variables functions uses_with uses_
         enclosed: "[SymbolDef*/S] a list of all symbol definitions that are accessed from this scope or any subscopes",
         cname: "[integer/S] current index for mangling variables (used internally by the mangler)",
     },
-    get_defun_scope: function () {
+    get_defun_scope: function() {
         var self = this;
-        while (self.is_block_scope() && self.parent_scope) {
+        while (self.is_block_scope()) {
             self = self.parent_scope;
         }
         return self;
+    },
+    clone: function(deep) {
+        var node = this._clone(deep);
+        if (this.variables) node.variables = this.variables.clone();
+        if (this.functions) node.functions = this.functions.clone();
+        if (this.enclosed) node.enclosed = this.enclosed.slice();
+        return node;
     }
 }, AST_Block);
 
@@ -345,7 +349,7 @@ var AST_Toplevel = DEFNODE("Toplevel", "globals", {
 var AST_Expansion = DEFNODE("Expansion", "expression", {
     $documentation: "An expandible argument, such as ...rest, a splat, such as [1,2,...all], or an expansion in a variable declaration, such as var [first, ...rest] = list",
     $propdoc: {
-        expression: "AST_Symbol the thing to be expanded"
+        expression: "[AST_Node] the thing to be expanded"
     },
     _walk: function(visitor) {
         var self = this;
@@ -355,13 +359,14 @@ var AST_Expansion = DEFNODE("Expansion", "expression", {
     }
 });
 
-var AST_Lambda = DEFNODE("Lambda", "name argnames uses_arguments is_generator", {
+var AST_Lambda = DEFNODE("Lambda", "name argnames uses_arguments is_generator async", {
     $documentation: "Base class for functions",
     $propdoc: {
-        is_generator: "[boolean] is generatorFn or not",
         name: "[AST_SymbolDeclaration?] the name of this function",
         argnames: "[AST_SymbolFunarg|AST_Destructuring|AST_Expansion|AST_DefaultAssign*] array of function arguments, destructurings, or expanding arguments",
-        uses_arguments: "[boolean/S] tells whether this function accesses the arguments array"
+        uses_arguments: "[boolean/S] tells whether this function accesses the arguments array",
+        is_generator: "[boolean] is this a generator method",
+        async: "[boolean] is this method async",
     },
     args_as_names: function () {
         var out = [];
@@ -390,15 +395,15 @@ var AST_Accessor = DEFNODE("Accessor", null, {
     $documentation: "A setter/getter function.  The `name` property is always null."
 }, AST_Lambda);
 
-var AST_Function = DEFNODE("Function", null, {
+var AST_Function = DEFNODE("Function", "inlined", {
     $documentation: "A function expression"
 }, AST_Lambda);
 
-var AST_Arrow = DEFNODE("Arrow", null, {
+var AST_Arrow = DEFNODE("Arrow", "inlined", {
     $documentation: "An ES6 Arrow function ((a) => b)"
 }, AST_Lambda);
 
-var AST_Defun = DEFNODE("Defun", null, {
+var AST_Defun = DEFNODE("Defun", "inlined", {
     $documentation: "A function definition"
 }, AST_Lambda);
 
@@ -445,14 +450,12 @@ var AST_PrefixedTemplateString = DEFNODE("PrefixedTemplateString", "template_str
 var AST_TemplateString = DEFNODE("TemplateString", "segments", {
     $documentation: "A template string literal",
     $propdoc: {
-        segments: "[AST_TemplateSegment|AST_Expression]* One or more segments, starting with AST_TemplateSegment. AST_Expression may follow AST_TemplateSegment, but each AST_Expression must be followed by AST_TemplateSegment."
+        segments: "[AST_Node*] One or more segments, starting with AST_TemplateSegment. AST_Node may follow AST_TemplateSegment, but each AST_Node must be followed by AST_TemplateSegment."
     },
     _walk: function(visitor) {
         return visitor._visit(this, function(){
-            this.segments.forEach(function(seg, i){
+            this.segments.forEach(function(seg){
-                if (i % 2 !== 0) {
+                seg._walk(visitor);
-                    seg._walk(visitor);
-                }
             });
         });
     }
@@ -628,11 +631,11 @@ var AST_Const = DEFNODE("Const", null, {
     $documentation: "A `const` statement"
 }, AST_Definitions);
 
-var AST_NameImport = DEFNODE("NameImport", "foreign_name name", {
+var AST_NameMapping = DEFNODE("NameMapping", "foreign_name name", {
-    $documentation: "The part of the import statement that imports names from a module.",
+    $documentation: "The part of the export/import statement that declare names from a module.",
     $propdoc: {
-        foreign_name: "[AST_SymbolImportForeign] The name being imported (as specified in the module)",
+        foreign_name: "[AST_SymbolExportForeign|AST_SymbolImportForeign] The name being exported/imported (as specified in the module)",
-        name: "[AST_SymbolImport] The name as it becomes available to this module."
+        name: "[AST_SymbolExport|AST_SymbolImport] The name as it is visible to this module."
     },
     _walk: function (visitor) {
         return visitor._visit(this, function() {
@@ -646,7 +649,7 @@ var AST_Import = DEFNODE("Import", "imported_name imported_names module_name", {
     $documentation: "An `import` statement",
     $propdoc: {
         imported_name: "[AST_SymbolImport] The name of the variable holding the module's default export.",
-        imported_names: "[AST_NameImport*] The names of non-default imported variables",
+        imported_names: "[AST_NameMapping*] The names of non-default imported variables",
         module_name: "[AST_String] String literal describing where this module came from",
     },
     _walk: function(visitor) {
@@ -655,7 +658,7 @@ var AST_Import = DEFNODE("Import", "imported_name imported_names module_name", {
                 this.imported_name._walk(visitor);
             }
             if (this.imported_names) {
-                this.imported_names.forEach(function (name_import) {
+                this.imported_names.forEach(function(name_import) {
                     name_import._walk(visitor);
                 });
             }
@@ -669,7 +672,7 @@ var AST_Export = DEFNODE("Export", "exported_definition exported_value is_defaul
     $propdoc: {
         exported_definition: "[AST_Defun|AST_Definitions|AST_DefClass?] An exported definition",
         exported_value: "[AST_Node?] An exported value",
-        exported_names: "[AST_NameImport*?] List of exported names",
+        exported_names: "[AST_NameMapping*?] List of exported names",
         module_name: "[AST_String?] Name of the file to load exports from",
         is_default: "[Boolean] Whether this is the default exported value of this module"
     },
@@ -681,6 +684,14 @@ var AST_Export = DEFNODE("Export", "exported_definition exported_value is_defaul
             if (this.exported_value) {
                 this.exported_value._walk(visitor);
             }
+            if (this.exported_names) {
+                this.exported_names.forEach(function(name_export) {
+                    name_export._walk(visitor);
+                });
+            }
+            if (this.module_name) {
+                this.module_name._walk(visitor);
+            }
         });
     }
 }, AST_Statement);
@@ -688,7 +699,7 @@ var AST_Export = DEFNODE("Export", "exported_definition exported_value is_defaul
 var AST_VarDef = DEFNODE("VarDef", "name value", {
     $documentation: "A variable declaration; only appears in a AST_Definitions node",
     $propdoc: {
-        name: "[AST_SymbolVar|AST_SymbolConst|AST_Destructuring] name of the variable",
+        name: "[AST_Destructuring|AST_SymbolConst|AST_SymbolLet|AST_SymbolVar] name of the variable",
         value: "[AST_Node?] initializer, or null of there's no initializer"
     },
     _walk: function(visitor) {
@@ -858,8 +869,8 @@ var AST_Object = DEFNODE("Object", "properties", {
 var AST_ObjectProperty = DEFNODE("ObjectProperty", "key value", {
     $documentation: "Base class for literal object properties",
     $propdoc: {
-        key: "[string|AST_Node] the property name converted to a string for ObjectKeyVal. For setters, getters and computed property this is an arbitrary AST_Node",
+        key: "[string|AST_Node] property name. For ObjectKeyVal this is a string. For getters, setters and computed property this is an AST_Node.",
-        value: "[AST_Node] property value.  For setters and getters this is an AST_Accessor."
+        value: "[AST_Node] property value.  For getters and setters this is an AST_Accessor."
     },
     _walk: function(visitor) {
         return visitor._visit(this, function(){
@@ -893,16 +904,17 @@ var AST_ObjectGetter = DEFNODE("ObjectGetter", "quote static", {
     $documentation: "An object getter property",
 }, AST_ObjectProperty);
 
-var AST_ConciseMethod = DEFNODE("ConciseMethod", "quote static is_generator", {
+var AST_ConciseMethod = DEFNODE("ConciseMethod", "quote static is_generator async", {
     $propdoc: {
         quote: "[string|undefined] the original quote character, if any",
-        static: "[boolean] whether this method is static (classes only)",
+        static: "[boolean] is this method static (classes only)",
-        is_generator: "[boolean] is generatorFn or not",
+        is_generator: "[boolean] is this a generator method",
+        async: "[boolean] is this method async",
     },
     $documentation: "An ES6 concise method inside an object or class"
 }, AST_ObjectProperty);
 
-var AST_Class = DEFNODE("Class", "name extends properties", {
+var AST_Class = DEFNODE("Class", "name extends properties inlined", {
     $propdoc: {
         name: "[AST_SymbolClass|AST_SymbolDefClass?] optional class name.",
         extends: "[AST_Node]? optional parent class",
@@ -994,7 +1006,7 @@ var AST_SymbolCatch = DEFNODE("SymbolCatch", null, {
 }, AST_SymbolBlockDeclaration);
 
 var AST_SymbolImport = DEFNODE("SymbolImport", null, {
-    $documentation: "Symbol refering to an imported name",
+    $documentation: "Symbol referring to an imported name",
 }, AST_SymbolBlockDeclaration);
 
 var AST_SymbolImportForeign = DEFNODE("SymbolImportForeign", null, {
@@ -1016,6 +1028,14 @@ var AST_SymbolRef = DEFNODE("SymbolRef", null, {
     $documentation: "Reference to some symbol (not definition/declaration)",
 }, AST_Symbol);
 
+var AST_SymbolExport = DEFNODE("SymbolExport", null, {
+    $documentation: "Symbol referring to a name to export",
+}, AST_SymbolRef);
+
+var AST_SymbolExportForeign = DEFNODE("SymbolExportForeign", null, {
+    $documentation: "A symbol exported from this module, but it is used in the other module, and its real name is irrelevant for this module's purposes",
+}, AST_Symbol);
+
 var AST_LabelRef = DEFNODE("LabelRef", null, {
     $documentation: "Reference to a label symbol",
 }, AST_Symbol);
@@ -1026,7 +1046,7 @@ var AST_This = DEFNODE("This", null, {
 
 var AST_Super = DEFNODE("Super", null, {
     $documentation: "The `super` symbol",
-}, AST_Symbol);
+}, AST_This);
 
 var AST_Constant = DEFNODE("Constant", null, {
     $documentation: "Base class for all constants",
@@ -1101,7 +1121,17 @@ var AST_True = DEFNODE("True", null, {
     value: true
 }, AST_Boolean);
 
-/* -----[ Yield ]----- */
+var AST_Await = DEFNODE("Await", "expression", {
+    $documentation: "An `await` statement",
+    $propdoc: {
+        expression: "[AST_Node] the mandatory expression being awaited",
+    },
+    _walk: function(visitor) {
+        return visitor._visit(this, function(){
+            this.expression._walk(visitor);
+        });
+    }
+});
 
 var AST_Yield = DEFNODE("Yield", "expression is_star", {
     $documentation: "A `yield` statement",
@@ -1132,7 +1162,7 @@ TreeWalker.prototype = {
         if (!ret && descend) {
             descend.call(node);
         }
-        this.pop(node);
+        this.pop();
         return ret;
     },
     parent: function(n) {
@@ -1151,8 +1181,8 @@ TreeWalker.prototype = {
         }
         this.stack.push(node);
     },
-    pop: function(node) {
+    pop: function() {
-        this.stack.pop();
+        var node = this.stack.pop();
         if (node instanceof AST_Lambda || node instanceof AST_Class) {
             this.directives = Object.getPrototypeOf(this.directives);
         }
@@ -1179,24 +1209,6 @@ TreeWalker.prototype = {
             }
         }
     },
-    in_boolean_context: function() {
-        var stack = this.stack;
-        var i = stack.length, self = stack[--i];
-        while (i > 0) {
-            var p = stack[--i];
-            if ((p instanceof AST_If           && p.condition === self) ||
-                (p instanceof AST_Conditional  && p.condition === self) ||
-                (p instanceof AST_DWLoop       && p.condition === self) ||
-                (p instanceof AST_For          && p.condition === self) ||
-                (p instanceof AST_UnaryPrefix  && p.operator == "!" && p.expression === self))
-            {
-                return true;
-            }
-            if (!(p instanceof AST_Binary && (p.operator == "&&" || p.operator == "||")))
-                return false;
-            self = p;
-        }
-    },
     loopcontrol_target: function(node) {
         var stack = this.stack;
         if (node.label) for (var i = stack.length; --i >= 0;) {

lib/minify.js

@@ -27,16 +27,36 @@ function set_shorthand(name, options, keys) {
     }
 }
 
+function init_cache(cache) {
+    if (!cache) return;
+    if (!("props" in cache)) {
+        cache.props = new Dictionary();
+    } else if (!(cache.props instanceof Dictionary)) {
+        cache.props = Dictionary.fromObject(cache.props);
+    }
+}
+
+function to_json(cache) {
+    return {
+        props: cache.props.toObject()
+    };
+}
+
 function minify(files, options) {
     var warn_function = AST_Node.warn_function;
     try {
         options = defaults(options, {
             compress: {},
+            ecma: undefined,
             ie8: false,
+            keep_classnames: undefined,
             keep_fnames: false,
             mangle: {},
+            nameCache: null,
             output: {},
             parse: {},
+            rename: undefined,
+            safari10: false,
             sourceMap: false,
             timings: false,
             toplevel: false,
@@ -46,13 +66,23 @@ function minify(files, options) {
         var timings = options.timings && {
             start: Date.now()
         };
+        if (options.keep_classnames === undefined) {
+            options.keep_classnames = options.keep_fnames;
+        }
+        if (options.rename === undefined) {
+            options.rename = options.compress && options.mangle;
+        }
+        set_shorthand("ecma", options, [ "parse", "compress", "output" ]);
         set_shorthand("ie8", options, [ "compress", "mangle", "output" ]);
+        set_shorthand("keep_classnames", options, [ "compress", "mangle" ]);
         set_shorthand("keep_fnames", options, [ "compress", "mangle" ]);
+        set_shorthand("safari10", options, [ "mangle", "output" ]);
         set_shorthand("toplevel", options, [ "compress", "mangle" ]);
         set_shorthand("warnings", options, [ "compress" ]);
+        var quoted_props;
         if (options.mangle) {
             options.mangle = defaults(options.mangle, {
-                cache: null,
+                cache: options.nameCache && (options.nameCache.vars || {}),
                 eval: false,
                 ie8: false,
                 keep_classnames: false,
@@ -62,6 +92,21 @@ function minify(files, options) {
                 safari10: false,
                 toplevel: false,
             }, true);
+            if (options.mangle.properties) {
+                if (typeof options.mangle.properties != "object") {
+                    options.mangle.properties = {};
+                }
+                if (options.mangle.properties.keep_quoted) {
+                    quoted_props = options.mangle.properties.reserved;
+                    if (!Array.isArray(quoted_props)) quoted_props = [];
+                    options.mangle.properties.reserved = quoted_props;
+                }
+                if (options.nameCache && !("cache" in options.mangle.properties)) {
+                    options.mangle.properties.cache = options.nameCache.props || {};
+                }
+            }
+            init_cache(options.mangle.cache);
+            init_cache(options.mangle.properties.cache);
         }
         if (options.sourceMap) {
             options.sourceMap = defaults(options.sourceMap, {
@@ -88,7 +133,7 @@ function minify(files, options) {
             }
             options.parse = options.parse || {};
             options.parse.toplevel = null;
-            for (var name in files) {
+            for (var name in files) if (HOP(files, name)) {
                 options.parse.filename = name;
                 options.parse.toplevel = parse(files[name], options.parse);
                 if (options.sourceMap && options.sourceMap.content == "inline") {
@@ -99,14 +144,22 @@ function minify(files, options) {
             }
             toplevel = options.parse.toplevel;
         }
+        if (quoted_props) {
+            reserve_quoted_keys(toplevel, quoted_props);
+        }
         if (options.wrap) {
             toplevel = toplevel.wrap_commonjs(options.wrap);
         }
-        if (timings) timings.scope1 = Date.now();
+        if (timings) timings.rename = Date.now();
-        if (options.compress) toplevel.figure_out_scope(options.mangle);
+        // disable rename on harmony due to expand_names bug in for-of loops
+        // https://github.com/mishoo/UglifyJS2/issues/2794
+        if (0 && 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 (timings) timings.scope2 = Date.now();
+        if (timings) timings.scope = Date.now();
         if (options.mangle) toplevel.figure_out_scope(options.mangle);
         if (timings) timings.mangle = Date.now();
         if (options.mangle) {
@@ -136,7 +189,7 @@ function minify(files, options) {
                 if (options.sourceMap.includeSources) {
                     if (files instanceof AST_Toplevel) {
                         throw new Error("original source content unavailable");
-                    } else for (var name in files) {
+                    } else for (var name in files) if (HOP(files, name)) {
                         options.output.source_map.get().setSourceContent(name, files[name]);
                     }
                 }
@@ -155,12 +208,19 @@ function minify(files, options) {
                 }
             }
         }
+        if (options.nameCache && options.mangle) {
+            if (options.mangle.cache) options.nameCache.vars = to_json(options.mangle.cache);
+            if (options.mangle.properties && options.mangle.properties.cache) {
+                options.nameCache.props = to_json(options.mangle.properties.cache);
+            }
+        }
         if (timings) {
             timings.end = Date.now();
             result.timings = {
-                parse: 1e-3 * (timings.scope1 - timings.parse),
+                parse: 1e-3 * (timings.rename - timings.parse),
-                scope: 1e-3 * (timings.compress - timings.scope1 + timings.mangle - timings.scope2),
+                rename: 1e-3 * (timings.compress - timings.rename),
-                compress: 1e-3 * (timings.scope2 - timings.compress),
+                compress: 1e-3 * (timings.scope - timings.compress),
+                scope: 1e-3 * (timings.mangle - timings.scope),
                 mangle: 1e-3 * (timings.properties - timings.mangle),
                 properties: 1e-3 * (timings.output - timings.properties),
                 output: 1e-3 * (timings.end - timings.output),

lib/output.js

@@ -52,9 +52,9 @@ function is_some_comments(comment) {
 
 function OutputStream(options) {
 
+    var readonly = !options;
     options = defaults(options, {
         ascii_only       : false,
-        ascii_identifiers: undefined,
         beautify         : false,
         bracketize       : false,
         comments         : false,
@@ -69,17 +69,16 @@ function OutputStream(options) {
         preserve_line    : false,
         quote_keys       : false,
         quote_style      : 0,
+        safari10         : false,
         semicolons       : true,
         shebang          : true,
         shorthand        : undefined,
         source_map       : null,
+        webkit           : false,
         width            : 80,
         wrap_iife        : false,
     }, true);
 
-    if (typeof options.ascii_identifiers === 'undefined')
-        options.ascii_identifiers = options.ascii_only;
-
     if (options.shorthand === undefined)
         options.shorthand = options.ecma > 5;
 
@@ -117,20 +116,16 @@ function OutputStream(options) {
     var current_pos = 0;
     var OUTPUT = "";
 
-    function to_ascii(str, identifier) {
+    var to_utf8 = options.ascii_only ? function(str, identifier) {
-        return str.replace(/[\ud800-\udbff][\udc00-\udfff]|[\u0000-\u001f\u007f-\uffff]/g, function(ch) {
+        if (options.ecma >= 6) {
-            var code = get_full_char_code(ch, 0).toString(16);
+            str = str.replace(/[\ud800-\udbff][\udc00-\udfff]/g, function(ch) {
-
+                var code = get_full_char_code(ch, 0).toString(16);
-            if ((identifier && code.length === 1 && options.ecma >= 6) || code.length > 4) {
-                if (options.ecma < 6) {
-                    if (identifier) {
-                        return ch; // no \u{} support
-                    }
-                    return "\\u" + ch.charCodeAt(0).toString(16) + "\\u"
-                        + ch.charCodeAt(1).toString(16);
-                }
                 return "\\u{" + code + "}";
-            } else if (code.length <= 2 && !identifier) {
+            });
+        }
+        return str.replace(/[\u0000-\u001f\u007f-\uffff]/g, function(ch) {
+            var code = ch.charCodeAt(0).toString(16);
+            if (code.length <= 2 && !identifier) {
                 while (code.length < 2) code = "0" + code;
                 return "\\x" + code;
             } else {
@@ -138,6 +133,17 @@ function OutputStream(options) {
                 return "\\u" + code;
             }
         });
+    } : function(str) {
+        var s = "";
+        for (var i = 0, len = str.length; i < len; i++) {
+            if (is_surrogate_pair_head(str[i]) && !is_surrogate_pair_tail(str[i + 1])
+                || is_surrogate_pair_tail(str[i]) && !is_surrogate_pair_head(str[i - 1])) {
+                s += "\\u" + str.charCodeAt(i).toString(16);
+            } else {
+                s += str[i];
+            }
+        }
+        return s;
     };
 
     function make_string(str, quote) {
@@ -158,7 +164,7 @@ function OutputStream(options) {
               case "\u2029": return "\\u2029";
               case "\ufeff": return "\\ufeff";
               case "\0":
-                  return /[0-7]/.test(get_full_char(str, i+1)) ? "\\x00" : "\\0";
+                  return /[0-9]/.test(get_full_char(str, i+1)) ? "\\x00" : "\\0";
             }
             return s;
         });
@@ -171,7 +177,7 @@ function OutputStream(options) {
         function quote_template() {
             return '`' + str.replace(/`/g, '\\`') + '`';
         }
-        if (options.ascii_only) str = to_ascii(str);
+        str = to_utf8(str);
         if (quote === "`") return quote_template();
         switch (options.quote_style) {
           case 1:
@@ -197,8 +203,7 @@ function OutputStream(options) {
 
     function make_name(name) {
         name = name.toString();
-        if (options.ascii_identifiers)
+        name = to_utf8(name, true);
-            name = to_ascii(name, true);
         return name;
     };
 
@@ -211,6 +216,9 @@ function OutputStream(options) {
     var might_need_space = false;
     var might_need_semicolon = false;
     var might_add_newline = 0;
+    var need_newline_indented = false;
+    var need_space = false;
+    var newline_insert = -1;
     var last = "";
     var mapping_token, mapping_name, mappings = options.source_map && [];
 
@@ -264,12 +272,27 @@ function OutputStream(options) {
         }
     } : noop;
 
-    var requireSemicolonChars = makePredicate("( [ + * / - , .");
+    var requireSemicolonChars = makePredicate("( [ + * / - , . `");
 
     function print(str) {
         str = String(str);
         var ch = get_full_char(str, 0);
         var prev = get_full_char(last, last.length - 1);
+        if (need_newline_indented && ch) {
+            need_newline_indented = false;
+            if (ch != "\n") {
+                print("\n");
+                indent();
+            }
+        }
+        if (need_space && ch) {
+            need_space = false;
+            if (!/[\s;})]/.test(ch)) {
+                space();
+            }
+        }
+        newline_insert = -1;
+        var prev = last.charAt(last.length - 1);
         if (might_need_semicolon) {
             might_need_semicolon = false;
 
@@ -371,7 +394,13 @@ function OutputStream(options) {
     } : function(col, cont) { return cont() };
 
     var newline = options.beautify ? function() {
-        print("\n");
+        if (newline_insert < 0) return print("\n");
+        if (OUTPUT[newline_insert] != "\n") {
+            OUTPUT = OUTPUT.slice(0, newline_insert) + "\n" + OUTPUT.slice(newline_insert);
+            current_pos++;
+            current_line++;
+        }
+        newline_insert++;
     } : options.max_line_len ? function() {
         ensure_line_len();
         might_add_newline = OUTPUT.length;
@@ -443,6 +472,124 @@ function OutputStream(options) {
         return OUTPUT;
     };
 
+    function has_nlb() {
+        var index = OUTPUT.lastIndexOf("\n");
+        return /^ *$/.test(OUTPUT.slice(index + 1));
+    }
+
+    function prepend_comments(node) {
+        var self = this;
+        var start = node.start;
+        if (!start) return;
+        if (start.comments_before && start.comments_before._dumped === self) return;
+        var comments = start.comments_before;
+        if (!comments) {
+            comments = start.comments_before = [];
+        }
+        comments._dumped = self;
+
+        if (node instanceof AST_Exit && node.value) {
+            var tw = new TreeWalker(function(node) {
+                var parent = tw.parent();
+                if (parent instanceof AST_Exit
+                    || parent instanceof AST_Binary && parent.left === node
+                    || parent.TYPE == "Call" && parent.expression === node
+                    || parent instanceof AST_Conditional && parent.condition === node
+                    || parent instanceof AST_Dot && parent.expression === node
+                    || parent instanceof AST_Sequence && parent.expressions[0] === node
+                    || parent instanceof AST_Sub && parent.expression === node
+                    || parent instanceof AST_UnaryPostfix) {
+                    if (!node.start) return;
+                    var text = node.start.comments_before;
+                    if (text && text._dumped !== self) {
+                        text._dumped = self;
+                        comments = comments.concat(text);
+                    }
+                } else {
+                    return true;
+                }
+            });
+            tw.push(node);
+            node.value.walk(tw);
+        }
+
+        if (current_pos == 0) {
+            if (comments.length > 0 && options.shebang && comments[0].type == "comment5") {
+                print("#!" + comments.shift().value + "\n");
+                indent();
+            }
+            var preamble = options.preamble;
+            if (preamble) {
+                print(preamble.replace(/\r\n?|[\n\u2028\u2029]|\s*$/g, "\n"));
+            }
+        }
+
+        comments = comments.filter(comment_filter, node);
+        if (comments.length == 0) return;
+        var last_nlb = has_nlb();
+        comments.forEach(function(c, i) {
+            if (!last_nlb) {
+                if (c.nlb) {
+                    print("\n");
+                    indent();
+                    last_nlb = true;
+                } else if (i > 0) {
+                    space();
+                }
+            }
+            if (/comment[134]/.test(c.type)) {
+                print("//" + c.value.replace(/[@#]__PURE__/g, ' ') + "\n");
+                indent();
+                last_nlb = true;
+            } else if (c.type == "comment2") {
+                print("/*" + c.value.replace(/[@#]__PURE__/g, ' ') + "*/");
+                last_nlb = false;
+            }
+        });
+        if (!last_nlb) {
+            if (start.nlb) {
+                print("\n");
+                indent();
+            } else {
+                space();
+            }
+        }
+    }
+
+    function append_comments(node, tail) {
+        var self = this;
+        var token = node.end;
+        if (!token) return;
+        var comments = token[tail ? "comments_before" : "comments_after"];
+        if (!comments || comments._dumped === self) return;
+        if (!(node instanceof AST_Statement || all(comments, function(c) {
+            return !/comment[134]/.test(c.type);
+        }))) return;
+        comments._dumped = self;
+        var insert = OUTPUT.length;
+        comments.filter(comment_filter, node).forEach(function(c, i) {
+            need_space = false;
+            if (need_newline_indented) {
+                print("\n");
+                indent();
+                need_newline_indented = false;
+            } else if (c.nlb && (i > 0 || !has_nlb())) {
+                print("\n");
+                indent();
+            } else if (i > 0 || !tail) {
+                space();
+            }
+            if (/comment[134]/.test(c.type)) {
+                print("//" + c.value.replace(/[@#]__PURE__/g, ' '));
+                need_newline_indented = true;
+            } else if (c.type == "comment2") {
+                print("/*" + c.value.replace(/[@#]__PURE__/g, ' ') + "*/");
+                need_space = true;
+            }
+        });
+        if (OUTPUT.length > insert) newline_insert = insert;
+    }
+
     var stack = [];
     return {
         get             : get,
@@ -460,7 +607,7 @@ function OutputStream(options) {
         last            : function() { return last },
         semicolon       : semicolon,
         force_semicolon : force_semicolon,
-        to_ascii        : to_ascii,
+        to_utf8         : to_utf8,
         print_name      : function(name) { print(make_name(name)) },
         print_string    : function(str, quote, escape_directive) {
             var encoded = encode_string(str, quote);
@@ -485,7 +632,8 @@ function OutputStream(options) {
         with_square     : with_square,
         add_mapping     : add_mapping,
         option          : function(opt) { return options[opt] },
-        comment_filter  : comment_filter,
+        prepend_comments: readonly ? noop : prepend_comments,
+        append_comments : readonly || comment_filter === return_false ? noop : append_comments,
         line            : function() { return current_line },
         col             : function() { return current_col },
         pos             : function() { return current_pos },
@@ -508,18 +656,23 @@ function OutputStream(options) {
         nodetype.DEFMETHOD("_codegen", generator);
     };
 
-    var use_asm = false;
     var in_directive = false;
+    var active_scope = null;
+    var use_asm = null;
 
     AST_Node.DEFMETHOD("print", function(stream, force_parens){
-        var self = this, generator = self._codegen, prev_use_asm = use_asm;
+        var self = this, generator = self._codegen;
-        if (self instanceof AST_Directive && self.value == "use asm" && stream.parent() instanceof AST_Scope) {
+        if (self instanceof AST_Scope) {
-            use_asm = true;
+            active_scope = self;
+        }
+        else if (!use_asm && self instanceof AST_Directive && self.value == "use asm") {
+            use_asm = active_scope;
         }
         function doit() {
-            self.add_comments(stream);
+            stream.prepend_comments(self);
             self.add_source_map(stream);
             generator(self, stream);
+            stream.append_comments(self);
         }
         stream.push_node(self);
         if (force_parens || self.needs_parens(stream)) {
@@ -528,84 +681,18 @@ function OutputStream(options) {
             doit();
         }
         stream.pop_node();
-        if (self instanceof AST_Scope) {
+        if (self === use_asm) {
-            use_asm = prev_use_asm;
+            use_asm = null;
         }
     });
+    AST_Node.DEFMETHOD("_print", AST_Node.prototype.print);
 
     AST_Node.DEFMETHOD("print_to_string", function(options){
         var s = OutputStream(options);
-        if (!options) s._readonly = true;
         this.print(s);
         return s.get();
     });
 
-    /* -----[ comments ]----- */
-
-    AST_Node.DEFMETHOD("add_comments", function(output){
-        if (output._readonly) return;
-        var self = this;
-        var start = self.start;
-        if (start && !start._comments_dumped) {
-            start._comments_dumped = true;
-            var comments = start.comments_before || [];
-
-            // XXX: ugly fix for https://github.com/mishoo/UglifyJS2/issues/112
-            //               and https://github.com/mishoo/UglifyJS2/issues/372
-            if (self instanceof AST_Exit && self.value) {
-                self.value.walk(new TreeWalker(function(node){
-                    if (node.start && node.start.comments_before) {
-                        comments = comments.concat(node.start.comments_before);
-                        node.start.comments_before = [];
-                    }
-                    if (node instanceof AST_Function ||
-                        node instanceof AST_Array ||
-                        node instanceof AST_Object)
-                    {
-                        return true; // don't go inside.
-                    }
-                }));
-            }
-
-            if (output.pos() == 0) {
-                if (comments.length > 0 && output.option("shebang") && comments[0].type == "comment5") {
-                    output.print("#!" + comments.shift().value + "\n");
-                    output.indent();
-                }
-                var preamble = output.option("preamble");
-                if (preamble) {
-                    output.print(preamble.replace(/\r\n?|[\n\u2028\u2029]|\s*$/g, "\n"));
-                }
-            }
-
-            comments = comments.filter(output.comment_filter, self);
-
-            // Keep single line comments after nlb, after nlb
-            if (!output.option("beautify") && comments.length > 0 &&
-                /comment[134]/.test(comments[0].type) &&
-                output.col() !== 0 && comments[0].nlb)
-            {
-                output.print("\n");
-            }
-
-            comments.forEach(function(c){
-                if (/comment[134]/.test(c.type)) {
-                    output.print("//" + c.value + "\n");
-                    output.indent();
-                }
-                else if (c.type == "comment2") {
-                    output.print("/*" + c.value + "*/");
-                    if (start.nlb) {
-                        output.print("\n");
-                        output.indent();
-                    } else {
-                        output.space();
-                    }
-                }
-            });
-        }
-    });
-
     /* -----[ PARENTHESES ]----- */
 
     function PARENS(nodetype, func) {
@@ -618,9 +705,7 @@ function OutputStream(options) {
         }
     };
 
-    PARENS(AST_Node, function(){
+    PARENS(AST_Node, return_false);
-        return false;
-    });
 
     // a function expression needs parens around it when it's provably
     // the first token to appear in a statement.
@@ -629,6 +714,13 @@ function OutputStream(options) {
             return true;
         }
 
+        if (output.option('webkit')) {
+            var p = output.parent();
+            if (p instanceof AST_PropAccess && p.expression === this) {
+                return true;
+            }
+        }
+
         if (output.option('wrap_iife')) {
             var p = output.parent();
             return p instanceof AST_Call && p.expression === this;
@@ -644,9 +736,7 @@ function OutputStream(options) {
 
     // same goes for an object literal, because otherwise it would be
     // interpreted as a block of code.
-    PARENS(AST_Object, function(output){
+    PARENS([ AST_ClassExpression, AST_Object ], first_in_statement);
-        return first_in_statement(output);
-    });
 
     PARENS(AST_Unary, function(output){
         var p = output.parent();
@@ -660,6 +750,13 @@ function OutputStream(options) {
                 && this.operator !== "--";
     });
 
+    PARENS(AST_Await, function(output){
+        var p = output.parent();
+        return p instanceof AST_PropAccess && p.expression === this
+            || p instanceof AST_Call && p.expression === this
+            || output.option("safari10") && p instanceof AST_UnaryPrefix;
+    });
+
     PARENS(AST_Sequence, function(output){
         var p = output.parent();
         return p instanceof AST_Call                          // (foo, bar)() or foo(1, (2, 3), 4)
@@ -673,6 +770,9 @@ function OutputStream(options) {
                                                                * ==> 20 (side effect, set a := 10 and b := 20) */
             || p instanceof AST_Arrow                         // x => (x, x)
             || p instanceof AST_DefaultAssign                 // x => (x = (0, function(){}))
+            || p instanceof AST_Expansion                     // [...(a, b)]
+            || p instanceof AST_ForOf && this === p.object    // for (e of (foo, bar)) {}
+            || p instanceof AST_Yield                         // yield (foo, bar)
         ;
     });
 
@@ -705,6 +805,10 @@ function OutputStream(options) {
         // a = yield 3
         if (p instanceof AST_Binary && p.operator !== "=")
             return true;
+        // (yield 1)()
+        // new (yield 1)()
+        if (p instanceof AST_Call && p.expression === this)
+            return true;
         // (yield 1) ? yield 2 : yield 3
         if (p instanceof AST_Conditional && p.condition === this)
             return true;
@@ -726,14 +830,15 @@ function OutputStream(options) {
             // parens around it too, otherwise the call will be
             // interpreted as passing the arguments to the upper New
             // expression.
-            try {
+            var parens = false;
-                this.walk(new TreeWalker(function(node){
+            this.walk(new TreeWalker(function(node) {
-                    if (node instanceof AST_Call) throw p;
+                if (parens || node instanceof AST_Scope) return true;
-                }));
+                if (node instanceof AST_Call) {
-            } catch(ex) {
+                    parens = true;
-                if (ex !== p) throw ex;
+                    return true;
-                return true;
+                }
-            }
+            }));
+            return parens;
         }
     });
 
@@ -805,17 +910,15 @@ function OutputStream(options) {
 
     DEFPRINT(AST_Destructuring, function (self, output) {
         output.print(self.is_array ? "[" : "{");
-        var first = true;
         var len = self.names.length;
         self.names.forEach(function (name, i) {
-            if (first) first = false; else { output.comma(); output.space(); }
+            if (i > 0) output.comma();
             name.print(output);
             // If the final element is a hole, we need to make sure it
             // doesn't look like a trailing comma, by inserting an actual
             // trailing comma.
-            if (i === len - 1 && name instanceof AST_Hole)
+            if (i == len - 1 && name instanceof AST_Hole) output.comma();
-              output.comma();
+        });
-        })
         output.print(self.is_array ? "]" : "}");
     });
 
@@ -875,14 +978,21 @@ function OutputStream(options) {
         self.body.print(output);
         output.semicolon();
     });
-    function print_bracketed(body, output, allow_directives) {
+    function print_bracketed(self, output, allow_directives) {
-        if (body.length > 0) output.with_block(function(){
+        if (self.body.length > 0) {
-            display_body(body, false, output, allow_directives);
+            output.with_block(function() {
-        });
+                display_body(self.body, false, output, allow_directives);
-        else output.print("{}");
+            });
+        } else {
+            output.print("{");
+            output.with_indent(output.next_indent(), function() {
+                output.append_comments(self, true);
+            });
+            output.print("}");
+        }
     };
     DEFPRINT(AST_BlockStatement, function(self, output){
-        print_bracketed(self.body, output);
+        print_bracketed(self, output);
     });
     DEFPRINT(AST_EmptyStatement, function(self, output){
         output.semicolon();
@@ -943,11 +1053,7 @@ function OutputStream(options) {
         output.with_parens(function(){
             self.init.print(output);
             output.space();
-            if (self instanceof AST_ForOf) {
+            output.print(self instanceof AST_ForOf ? "of" : "in");
-                output.print("of");
-            } else {
-                output.print("in");
-            }
             output.space();
             self.object.print(output);
         });
@@ -968,8 +1074,12 @@ function OutputStream(options) {
     AST_Lambda.DEFMETHOD("_do_print", function(output, nokeyword){
         var self = this;
         if (!nokeyword) {
+            if (self.async) {
+                output.print("async");
+                output.space();
+            }
             output.print("function");
-            if (this.is_generator) {
+            if (self.is_generator) {
                 output.star();
             }
             if (self.name) {
@@ -990,7 +1100,7 @@ function OutputStream(options) {
             });
         });
         output.space();
-        print_bracketed(self.body, output, true);
+        print_bracketed(self, output, true);
     });
     DEFPRINT(AST_Lambda, function(self, output){
         self._do_print(output);
@@ -1025,6 +1135,10 @@ function OutputStream(options) {
             parent instanceof AST_Unary ||
             (parent instanceof AST_Call && self === parent.expression);
         if (needs_parens) { output.print("(") }
+        if (self.async) {
+            output.print("async");
+            output.space();
+        }
         if (self.argnames.length === 1 && self.argnames[0] instanceof AST_Symbol) {
             self.argnames[0].print(output);
         } else {
@@ -1039,9 +1153,9 @@ function OutputStream(options) {
         output.print('=>');
         output.space();
         if (self.body instanceof AST_Node) {
-            this.body.print(output);
+            self.body.print(output);
         } else {
-            print_bracketed(this.body, output);
+            print_bracketed(self, output);
         }
         if (needs_parens) { output.print(")") }
     });
@@ -1073,6 +1187,22 @@ function OutputStream(options) {
         }
     });
 
+    DEFPRINT(AST_Await, function(self, output){
+        output.print("await");
+        output.space();
+        var e = self.expression;
+        var parens = !(
+               e instanceof AST_Call
+            || e instanceof AST_SymbolRef
+            || e instanceof AST_PropAccess
+            || e instanceof AST_Unary
+            || e instanceof AST_Constant
+        );
+        if (parens) output.print("(");
+        self.expression.print(output);
+        if (parens) output.print(")");
+    });
+
     /* -----[ loop control ]----- */
     AST_LoopControl.DEFMETHOD("_do_print", function(output, kind){
         output.print(kind);
@@ -1182,7 +1312,7 @@ function OutputStream(options) {
     DEFPRINT(AST_Try, function(self, output){
         output.print("try");
         output.space();
-        print_bracketed(self.body, output);
+        print_bracketed(self, output);
         if (self.bcatch) {
             output.space();
             self.bcatch.print(output);
@@ -1199,12 +1329,12 @@ function OutputStream(options) {
             self.argname.print(output);
         });
         output.space();
-        print_bracketed(self.body, output);
+        print_bracketed(self, output);
     });
     DEFPRINT(AST_Finally, function(self, output){
         output.print("finally");
         output.space();
-        print_bracketed(self.body, output);
+        print_bracketed(self, output);
     });
 
     /* -----[ var/const ]----- */
@@ -1250,7 +1380,6 @@ function OutputStream(options) {
                     name_import.print(output);
                     if (i < self.imported_names.length - 1) {
                         output.print(",");
-                        output.space();
                     }
                 });
                 output.space();
@@ -1266,17 +1395,26 @@ function OutputStream(options) {
         output.semicolon();
     });
 
-    DEFPRINT(AST_NameImport, function(self, output) {
+    DEFPRINT(AST_NameMapping, function(self, output) {
+        var is_import = output.parent() instanceof AST_Import;
         var definition = self.name.definition();
         var names_are_different =
             (definition && definition.mangled_name || self.name.name) !==
             self.foreign_name.name;
         if (names_are_different) {
-            output.print(self.foreign_name.name);
+            if (is_import) {
+                output.print(self.foreign_name.name);
+            } else {
+                self.name.print(output);
+            }
             output.space();
             output.print("as");
             output.space();
-            self.name.print(output);
+            if (is_import) {
+                self.name.print(output);
+            } else {
+                output.print(self.foreign_name.name);
+            }
         } else {
             self.name.print(output);
         }
@@ -1290,29 +1428,26 @@ function OutputStream(options) {
             output.space();
         }
         if (self.exported_names) {
-            output.space();
-
             if (self.exported_names.length === 1 && self.exported_names[0].name.name === "*") {
                 self.exported_names[0].print(output);
             } else {
                 output.print("{");
-                self.exported_names.forEach(function (name_import, i) {
+                self.exported_names.forEach(function(name_export, i) {
                     output.space();
-                    name_import.print(output);
+                    name_export.print(output);
                     if (i < self.exported_names.length - 1) {
                         output.print(",");
-                        output.space();
                     }
                 });
                 output.space();
                 output.print("}");
             }
-            output.space();
         }
         else if (self.exported_value) {
             self.exported_value.print(output);
         } else if (self.exported_definition) {
             self.exported_definition.print(output);
+            if (self.exported_definition instanceof AST_Definitions) return;
         }
         if (self.module_name) {
             output.space();
@@ -1324,19 +1459,17 @@ function OutputStream(options) {
     });
 
     function parenthesize_for_noin(node, output, noin) {
-        if (!noin) node.print(output);
+        var parens = false;
-        else try {
+        // need to take some precautions here:
-            // need to take some precautions here:
+        //    https://github.com/mishoo/UglifyJS2/issues/60
-            //    https://github.com/mishoo/UglifyJS2/issues/60
+        if (noin) node.walk(new TreeWalker(function(node) {
-            node.walk(new TreeWalker(function(node){
+            if (parens || node instanceof AST_Scope) return true;
-                if (node instanceof AST_Binary && node.operator == "in")
+            if (node instanceof AST_Binary && node.operator == "in") {
-                    throw output;
+                parens = true;
-            }));
+                return true;
-            node.print(output);
+            }
-        } catch(ex) {
+        }));
-            if (ex !== output) throw ex;
+        node.print(output, parens);
-            node.print(output, true);
-        }
     };
 
     DEFPRINT(AST_VarDef, function(self, output){
@@ -1356,6 +1489,9 @@ function OutputStream(options) {
         self.expression.print(output);
         if (self instanceof AST_New && !need_constructor_parens(self, output))
             return;
+        if (self.expression instanceof AST_Call || self.expression instanceof AST_Lambda) {
+            output.add_mapping(self.start);
+        }
         output.with_parens(function(){
             self.args.forEach(function(expr, i){
                 if (i) output.comma();
@@ -1395,15 +1531,23 @@ function OutputStream(options) {
     DEFPRINT(AST_Dot, function(self, output){
         var expr = self.expression;
         expr.print(output);
-        if (expr instanceof AST_Number && expr.getValue() >= 0) {
+        var prop = self.property;
-            if (!/[xa-f.)]/i.test(output.last())) {
+        if (output.option("ie8") && RESERVED_WORDS(prop)) {
-                output.print(".");
+            output.print("[");
+            output.add_mapping(self.end);
+            output.print_string(prop);
+            output.print("]");
+        } else {
+            if (expr instanceof AST_Number && expr.getValue() >= 0) {
+                if (!/[xa-f.)]/i.test(output.last())) {
+                    output.print(".");
+                }
             }
+            output.print(".");
+            // the name after dot would be mapped about here.
+            output.add_mapping(self.end);
+            output.print_name(prop);
         }
-        output.print(".");
-        // the name after dot would be mapped about here.
-        output.add_mapping(self.end);
-        output.print_name(self.property);
     });
     DEFPRINT(AST_Sub, function(self, output){
         self.expression.print(output);
@@ -1536,13 +1680,11 @@ function OutputStream(options) {
     DEFPRINT(AST_NewTarget, function(self, output) {
         output.print("new.target");
     });
-    AST_ObjectProperty.DEFMETHOD("print_property_name", function(key, quote, output) {
+
+    function print_property_name(key, quote, output) {
         if (output.option("quote_keys")) {
-            output.print_string(key + "");
+            output.print_string(key);
-        } else if ((typeof key == "number"
+        } else if ("" + +key == key && key >= 0) {
-                    || !output.option("beautify")
-                    && +key + "" == key)
-                   && parseFloat(key) >= 0) {
             output.print(make_num(key));
         } else if (RESERVED_WORDS(key) ? !output.option("ie8") : is_identifier_string(key)) {
             if (quote && output.option("keep_quoted_props")) {
@@ -1553,7 +1695,8 @@ function OutputStream(options) {
         } else {
             output.print_string(key, quote);
         }
-    });
+    }
+
     DEFPRINT(AST_ObjectKeyVal, function(self, output){
         function get_name(self) {
             var def = self.definition();
@@ -1564,9 +1707,10 @@ function OutputStream(options) {
         if (allowShortHand &&
             self.value instanceof AST_Symbol &&
             is_identifier_string(self.key) &&
-            get_name(self.value) === self.key
+            get_name(self.value) === self.key &&
+            is_identifier(self.key)
         ) {
-            self.print_property_name(self.key, self.quote, output);
+            print_property_name(self.key, self.quote, output);
 
         } else if (allowShortHand &&
             self.value instanceof AST_DefaultAssign &&
@@ -1574,12 +1718,14 @@ function OutputStream(options) {
             is_identifier_string(self.key) &&
             get_name(self.value.left) === self.key
         ) {
-            self.print_property_name(self.key, self.quote, output);
+            print_property_name(self.key, self.quote, output);
+            output.space();
             output.print("=");
+            output.space();
             self.value.right.print(output);
         } else {
             if (!(self.key instanceof AST_Node)) {
-                self.print_property_name(self.key, self.quote, output);
+                print_property_name(self.key, self.quote, output);
             } else {
                 output.with_square(function() {
                     self.key.print(output);
@@ -1589,15 +1735,18 @@ function OutputStream(options) {
             self.value.print(output);
         }
     });
-    AST_ObjectProperty.DEFMETHOD("_print_getter_setter", function(type, self, output) {
+    AST_ObjectProperty.DEFMETHOD("_print_getter_setter", function(type, output) {
+        var self = this;
         if (self.static) {
             output.print("static");
             output.space();
         }
-        output.print(type);
+        if (type) {
-        output.space();
+            output.print(type);
+            output.space();
+        }
         if (self.key instanceof AST_SymbolMethod) {
-            self.print_property_name(self.key.name, self.quote, output);
+            print_property_name(self.key.name, self.quote, output);
         } else {
             output.with_square(function() {
                 self.key.print(output);
@@ -1606,27 +1755,13 @@ function OutputStream(options) {
         self.value._do_print(output, true);
     });
     DEFPRINT(AST_ObjectSetter, function(self, output){
-        self._print_getter_setter("set", self, output);
+        self._print_getter_setter("set", output);
     });
     DEFPRINT(AST_ObjectGetter, function(self, output){
-        self._print_getter_setter("get", self, output);
+        self._print_getter_setter("get", output);
     });
     DEFPRINT(AST_ConciseMethod, function(self, output){
-        if (self.static) {
+        self._print_getter_setter(self.is_generator && "*" || self.async && "async", output);
-            output.print("static");
-            output.space();
-        }
-        if (self.is_generator) {
-            output.print("*");
-        }
-        if (self.key instanceof AST_SymbolMethod) {
-            self.print_property_name(self.key.name, self.quote, output);
-        } else {
-            output.with_square(function() {
-                self.key.print(output);
-            });
-        }
-        self.value._do_print(output, true);
     });
     AST_Symbol.DEFMETHOD("_do_print", function(output){
         var def = this.definition();
@@ -1635,9 +1770,6 @@ function OutputStream(options) {
     DEFPRINT(AST_Symbol, function (self, output) {
         self._do_print(output);
     });
-    DEFPRINT(AST_SymbolDeclaration, function(self, output){
-        self._do_print(output);
-    });
     DEFPRINT(AST_Hole, noop);
     DEFPRINT(AST_This, function(self, output){
         output.print("this");
@@ -1665,9 +1797,7 @@ function OutputStream(options) {
         if (regexp.raw_source) {
             str = "/" + regexp.raw_source + str.slice(str.lastIndexOf("/"));
         }
-        if (output.option("ascii_only")) {
+        str = output.to_utf8(str);
-            str = output.to_ascii(str);
-        }
         output.print(str);
         var p = output.parent();
         if (p instanceof AST_Binary && /^in/.test(p.operator) && p.left === self)

lib/propmangle.js

@@ -85,6 +85,36 @@ function find_builtins(reserved) {
     }
 }
 
+function reserve_quoted_keys(ast, reserved) {
+    function add(name) {
+        push_uniq(reserved, name);
+    }
+
+    ast.walk(new TreeWalker(function(node) {
+        if (node instanceof AST_ObjectKeyVal && node.quote) {
+            add(node.key);
+        } else if (node instanceof AST_ObjectProperty && node.quote) {
+            add(node.key.name);
+        } else if (node instanceof AST_Sub) {
+            addStrings(node.property, add);
+        }
+    }));
+}
+
+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;
+    }));
+}
+
 function mangle_properties(ast, options) {
     options = defaults(options, {
         builtins: false,
@@ -94,21 +124,24 @@ function mangle_properties(ast, options) {
         only_cache: false,
         regex: null,
         reserved: null,
-    });
+    }, true);
 
-    var reserved = options.reserved || [];
+    var reserved = options.reserved;
+    if (!Array.isArray(reserved)) reserved = [];
     if (!options.builtins) find_builtins(reserved);
 
-    var cache = options.cache;
+    var cname = -1;
-    if (cache == null) {
+    var cache;
-        cache = {
+    if (options.cache) {
-            cname: -1,
+        cache = options.cache.props;
-            props: new Dictionary()
+        cache.each(function(mangled_name) {
-        };
+            push_uniq(reserved, mangled_name);
+        });
+    } else {
+        cache = new Dictionary();
     }
 
     var regex = options.regex;
-    var keep_quoted = options.keep_quoted;
 
     // note debug is either false (disabled), or a string of the debug suffix to use (enabled).
     // note debug may be enabled as an empty string, which is falsey. Also treat passing 'true'
@@ -121,12 +154,11 @@ function mangle_properties(ast, options) {
 
     var names_to_mangle = [];
     var unmangleable = [];
-    var to_keep = {};
 
     // step 1: find candidates to mangle
     ast.walk(new TreeWalker(function(node){
         if (node instanceof AST_ObjectKeyVal) {
-            add(node.key, keep_quoted && node.quote);
+            add(node.key);
         }
         else if (node instanceof AST_ObjectProperty) {
             // setter or getter, since KeyVal is handled above
@@ -136,18 +168,14 @@ function mangle_properties(ast, options) {
             add(node.property);
         }
         else if (node instanceof AST_Sub) {
-            addStrings(node.property, keep_quoted);
+            addStrings(node.property, add);
-        }
-        else if (node instanceof AST_ConciseMethod) {
-            add(node.name.name);
         }
     }));
 
     // step 2: transform the tree, renaming properties
     return ast.transform(new TreeTransformer(function(node){
         if (node instanceof AST_ObjectKeyVal) {
-            if (!(keep_quoted && node.quote))
+            node.key = mangle(node.key);
-                node.key = mangle(node.key);
         }
         else if (node instanceof AST_ObjectProperty) {
             // setter or getter
@@ -156,27 +184,9 @@ function mangle_properties(ast, options) {
         else if (node instanceof AST_Dot) {
             node.property = mangle(node.property);
         }
-        else if (node instanceof AST_Sub) {
+        else if (!options.keep_quoted && node instanceof AST_Sub) {
-            if (!keep_quoted)
+            node.property = mangleStrings(node.property);
-                node.property = mangleStrings(node.property);
         }
-        else if (node instanceof AST_ConciseMethod) {
-            if (should_mangle(node.name.name)) {
-                node.name.name = mangle(node.name.name);
-            }
-        }
-        // else if (node instanceof AST_String) {
-        //     if (should_mangle(node.value)) {
-        //         AST_Node.warn(
-        //             "Found \"{prop}\" property candidate for mangling in an arbitrary string [{file}:{line},{col}]", {
-        //                 file : node.start.file,
-        //                 line : node.start.line,
-        //                 col  : node.start.col,
-        //                 prop : node.value
-        //             }
-        //         );
-        //     }
-        // }
     }));
 
     // only function declarations after this line
@@ -185,26 +195,20 @@ function mangle_properties(ast, options) {
         if (unmangleable.indexOf(name) >= 0) return false;
         if (reserved.indexOf(name) >= 0) return false;
         if (options.only_cache) {
-            return cache.props.has(name);
+            return cache.has(name);
         }
         if (/^-?[0-9]+(\.[0-9]+)?(e[+-][0-9]+)?$/.test(name)) return false;
         return true;
     }
 
     function should_mangle(name) {
-        if (keep_quoted && name in to_keep) return false;
         if (regex && !regex.test(name)) return false;
         if (reserved.indexOf(name) >= 0) return false;
-        return cache.props.has(name)
+        return cache.has(name)
             || names_to_mangle.indexOf(name) >= 0;
     }
 
-    function add(name, keep) {
+    function add(name) {
-        if (keep) {
-            to_keep[name] = true;
-            return;
-        }
-
         if (can_mangle(name))
             push_uniq(names_to_mangle, name);
 
@@ -218,58 +222,29 @@ function mangle_properties(ast, options) {
             return name;
         }
 
-        var mangled = cache.props.get(name);
+        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_.
                 var debug_mangled = "_$" + name + "$" + debug_name_suffix + "_";
 
-                if (can_mangle(debug_mangled) && !(keep_quoted && debug_mangled in to_keep)) {
+                if (can_mangle(debug_mangled)) {
                     mangled = debug_mangled;
                 }
             }
 
             // either debug mode is off, or it is on and we could not use the mangled name
             if (!mangled) {
-                // Note: `can_mangle()` does not check if the name collides with the `to_keep` set
-                // (filled with quoted properties when `keep_quoted` is set). Make sure we add this
-                // check so we don't collide with a quoted name.
                 do {
-                    mangled = base54(++cache.cname);
+                    mangled = base54(++cname);
-                } while (!can_mangle(mangled) || keep_quoted && mangled in to_keep);
+                } while (!can_mangle(mangled));
             }
 
-            cache.props.set(name, mangled);
+            cache.set(name, mangled);
         }
         return mangled;
     }
 
-    function addStrings(node, keep) {
-        var out = {};
-        try {
-            (function walk(node){
-                node.walk(new TreeWalker(function(node){
-                    if (node instanceof AST_Sequence) {
-                        walk(node.expressions[node.expressions.length - 1]);
-                        return true;
-                    }
-                    if (node instanceof AST_String) {
-                        add(node.value, keep);
-                        return true;
-                    }
-                    if (node instanceof AST_Conditional) {
-                        walk(node.consequent);
-                        walk(node.alternative);
-                        return true;
-                    }
-                    throw out;
-                }));
-            })(node);
-        } catch(ex) {
-            if (ex !== out) throw ex;
-        }
-    }
-
     function mangleStrings(node) {
         return node.transform(new TreeTransformer(function(node){
             if (node instanceof AST_Sequence) {

lib/scope.js

@@ -43,17 +43,18 @@
 
 "use strict";
 
-function SymbolDef(scope, index, orig) {
+function SymbolDef(scope, orig, init) {
     this.name = orig.name;
     this.orig = [ orig ];
+    this.init = init;
+    this.eliminated = 0;
     this.scope = scope;
     this.references = [];
+    this.replaced = 0;
     this.global = false;
     this.export = false;
     this.mangled_name = null;
-    this.object_destructuring_arg = false;
     this.undeclared = false;
-    this.index = index;
     this.id = SymbolDef.next_id++;
 };
 
@@ -65,7 +66,6 @@ SymbolDef.prototype = {
 
         return (this.global && !options.toplevel)
             || this.export
-            || this.object_destructuring_arg
             || this.undeclared
             || (!options.eval && (this.scope.uses_eval || this.scope.uses_with))
             || (options.keep_fnames
@@ -87,7 +87,7 @@ SymbolDef.prototype = {
             if (options.ie8 && sym instanceof AST_SymbolLambda)
                 s = s.parent_scope;
             var def;
-            if (this.defun && (def = this.defun.variables.get(this.name))) {
+            if (def = this.redefined()) {
                 this.mangled_name = def.mangled_name || def.name;
             } else
                 this.mangled_name = s.next_mangled(options, this);
@@ -95,6 +95,9 @@ SymbolDef.prototype = {
                 cache.set(this.name, this.mangled_name);
             }
         }
+    },
+    redefined: function() {
+        return this.defun && this.defun.variables.get(this.name);
     }
 };
 
@@ -115,7 +118,7 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
     var tw = new TreeWalker(function(node, descend){
         if (node.is_block_scope()) {
             var save_scope = scope;
-            scope = new AST_Scope(node);
+            node.block_scope = scope = new AST_Scope(node);
             scope.init_scope_vars(save_scope);
             if (!(node instanceof AST_Scope)) {
                 scope.uses_with = save_scope.uses_with;
@@ -131,7 +134,7 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
             scope = save_scope;
             return true;
         }
-        if (node instanceof AST_Destructuring && node.is_array === false) {
+        if (node instanceof AST_Destructuring) {
             in_destructuring = node;  // These don't nest
             descend();
             in_destructuring = null;
@@ -168,15 +171,12 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
         if (node instanceof AST_Symbol) {
             node.scope = scope;
         }
-        if (node instanceof AST_SymbolFunarg) {
-            node.object_destructuring_arg = !!in_destructuring;
-        }
         if (node instanceof AST_Label) {
             node.thedef = node;
             node.references = [];
         }
         if (node instanceof AST_SymbolLambda) {
-            defun.def_function(node);
+            defun.def_function(node, node.name == "arguments" ? undefined : defun);
         }
         else if (node instanceof AST_SymbolDefun) {
             // Careful here, the scope where this should be defined is
@@ -184,14 +184,10 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
             // scope when we encounter the AST_Defun node (which is
             // instanceof AST_Scope) but we get to the symbol a bit
             // later.
-            var parent_lambda = defun.parent_scope;
+            mark_export((node.scope = defun.parent_scope.get_defun_scope()).def_function(node, defun), 1);
-            while (parent_lambda.is_block_scope()) {
-                parent_lambda = parent_lambda.parent_scope;
-            }
-            mark_export((node.scope = parent_lambda).def_function(node), 1);
         }
         else if (node instanceof AST_SymbolClass) {
-            mark_export(defun.def_variable(node), 1);
+            mark_export(defun.def_variable(node, defun), 1);
         }
         else if (node instanceof AST_SymbolImport) {
             scope.def_variable(node);
@@ -199,12 +195,32 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
         else if (node instanceof AST_SymbolDefClass) {
             // This deals with the name of the class being available
             // inside the class.
-            mark_export((node.scope = defun.parent_scope).def_function(node), 1);
+            mark_export((node.scope = defun.parent_scope).def_function(node, defun), 1);
         }
         else if (node instanceof AST_SymbolVar
             || node instanceof AST_SymbolLet
             || node instanceof AST_SymbolConst) {
-            var def = ((node instanceof AST_SymbolBlockDeclaration) ? scope : defun).def_variable(node);
+            var def;
+            if (node instanceof AST_SymbolBlockDeclaration) {
+                def = scope.def_variable(node, null);
+            } else {
+                def = defun.def_variable(node, node.TYPE == "SymbolVar" ? null : undefined);
+            }
+            if (!all(def.orig, function(sym) {
+                if (sym === node) return true;
+                if (node instanceof AST_SymbolBlockDeclaration) {
+                    return sym instanceof AST_SymbolLambda;
+                }
+                return !(sym instanceof AST_SymbolLet || sym instanceof AST_SymbolConst);
+            })) {
+                js_error(
+                    node.name + " redeclared",
+                    node.start.file,
+                    node.start.line,
+                    node.start.col,
+                    node.start.pos
+                );
+            }
             if (!(node instanceof AST_SymbolFunarg)) mark_export(def, 2);
             def.destructuring = in_destructuring;
             if (defun !== scope) {
@@ -228,10 +244,25 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
             }));
             node.thedef = sym;
         }
+        if (!(scope instanceof AST_Toplevel) && (node instanceof AST_Export || node instanceof AST_Import)) {
+            js_error(
+                node.TYPE + " statement may only appear at top level",
+                node.start.file,
+                node.start.line,
+                node.start.col,
+                node.start.pos
+            );
+        }
 
         function mark_export(def, level) {
+            if (in_destructuring) {
+                var i = 0;
+                do {
+                    level++;
+                } while (tw.parent(i++) !== in_destructuring);
+            }
             var node = tw.parent(level);
-            def.export = node instanceof AST_Export && !node.is_default;
+            def.export = node instanceof AST_Export;
         }
     });
     self.walk(tw);
@@ -250,17 +281,31 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
                     s.uses_eval = true;
                 }
             }
-            var sym = node.scope.find_variable(name);
+            var sym;
-            if (node.scope instanceof AST_Lambda && name == "arguments") {
+            if (tw.parent() instanceof AST_NameMapping && tw.parent(1).module_name
-                node.scope.uses_arguments = true;
+                || !(sym = node.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;
             }
             node.thedef = sym;
             node.reference(options);
+            if (node.scope.is_block_scope()
+                && !(sym.orig[0] instanceof AST_SymbolBlockDeclaration)) {
+                node.scope = node.scope.get_defun_scope();
+            }
             return true;
         }
+        // ensure mangling works if catch reuses a scope variable
+        var def;
+        if (node instanceof AST_SymbolCatch && (def = node.definition().redefined())) {
+            var s = node.scope;
+            while (s) {
+                push_uniq(s.enclosed, def);
+                if (s === def.scope) break;
+                s = s.parent_scope;
+            }
+        }
     });
     self.walk(tw);
 
@@ -277,6 +322,7 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
                     ref.reference(options);
                 });
                 node.thedef = def;
+                node.reference(options);
                 return true;
             }
         }));
@@ -294,10 +340,6 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
             });
         }
     }
-
-    if (options.cache) {
-        this.cname = options.cache.cname;
-    }
 });
 
 AST_Toplevel.DEFMETHOD("def_global", function(node){
@@ -305,7 +347,7 @@ AST_Toplevel.DEFMETHOD("def_global", function(node){
     if (globals.has(name)) {
         return globals.get(name);
     } else {
-        var g = new SymbolDef(this, globals.size(), node);
+        var g = new SymbolDef(this, node);
         g.undeclared = true;
         g.global = true;
         globals.set(name, g);
@@ -334,13 +376,18 @@ AST_IterationStatement.DEFMETHOD("is_block_scope", return_true);
 AST_Lambda.DEFMETHOD("init_scope_vars", function(){
     AST_Scope.prototype.init_scope_vars.apply(this, arguments);
     this.uses_arguments = false;
-    this.def_variable(new AST_SymbolConst({
+    this.def_variable(new AST_SymbolFunarg({
         name: "arguments",
         start: this.start,
         end: this.end
     }));
 });
 
+AST_Arrow.DEFMETHOD("init_scope_vars", function(){
+    AST_Scope.prototype.init_scope_vars.apply(this, arguments);
+    this.uses_arguments = false;
+});
+
 AST_Symbol.DEFMETHOD("mark_enclosed", function(options) {
     var def = this.definition();
     var s = this.scope;
@@ -367,35 +414,37 @@ AST_Scope.DEFMETHOD("find_variable", function(name){
         || (this.parent_scope && this.parent_scope.find_variable(name));
 });
 
-AST_Scope.DEFMETHOD("def_function", function(symbol){
+AST_Scope.DEFMETHOD("def_function", function(symbol, init){
-    var def = this.def_variable(symbol);
+    var def = this.def_variable(symbol, init);
+    if (!def.init || def.init instanceof AST_Defun) def.init = init;
     this.functions.set(symbol.name, def);
     return def;
 });
 
-AST_Scope.DEFMETHOD("def_variable", function(symbol){
+AST_Scope.DEFMETHOD("def_variable", function(symbol, init){
-    var def;
+    var def = this.variables.get(symbol.name);
-    if (!this.variables.has(symbol.name)) {
+    if (def) {
-        def = new SymbolDef(this, this.variables.size(), symbol);
-        this.variables.set(symbol.name, def);
-        def.object_destructuring_arg = symbol.object_destructuring_arg;
-        def.global = !this.parent_scope;
-    } else {
-        def = this.variables.get(symbol.name);
         def.orig.push(symbol);
+        if (def.init && (def.scope !== symbol.scope || def.init instanceof AST_Function)) {
+            def.init = init;
+        }
+    } else {
+        def = new SymbolDef(this, symbol, init);
+        this.variables.set(symbol.name, def);
+        def.global = !this.parent_scope;
     }
     return symbol.thedef = def;
 });
 
-AST_Scope.DEFMETHOD("next_mangled", function(options){
+function next_mangled(scope, options) {
-    var ext = this.enclosed;
+    var ext = scope.enclosed;
     out: while (true) {
-        var m = base54(++this.cname);
+        var m = base54(++scope.cname);
         if (!is_identifier(m)) continue; // skip over "do"
 
         // https://github.com/mishoo/UglifyJS2/issues/242 -- do not
         // shadow a name reserved from mangling.
-        if (options.reserved.indexOf(m) >= 0) continue;
+        if (member(m, options.reserved)) continue;
 
         // we must ensure that the mangled name does not shadow a name
         // from some parent scope that is referenced in this or in
@@ -407,6 +456,18 @@ AST_Scope.DEFMETHOD("next_mangled", function(options){
         }
         return m;
     }
+}
+
+AST_Scope.DEFMETHOD("next_mangled", function(options){
+    return next_mangled(this, options);
+});
+
+AST_Toplevel.DEFMETHOD("next_mangled", function(options){
+    var name;
+    do {
+        name = next_mangled(this, options);
+    } while (member(name, this.mangled_names));
+    return name;
 });
 
 AST_Function.DEFMETHOD("next_mangled", function(options, def){
@@ -420,7 +481,7 @@ AST_Function.DEFMETHOD("next_mangled", function(options, def){
     var tricky_name = tricky_def ? tricky_def.mangled_name || tricky_def.name : null;
 
     while (true) {
-        var name = AST_Lambda.prototype.next_mangled.call(this, options, def);
+        var name = next_mangled(this, options);
         if (!tricky_name || tricky_name != name)
             return name;
     }
@@ -428,7 +489,7 @@ AST_Function.DEFMETHOD("next_mangled", function(options, def){
 
 AST_Symbol.DEFMETHOD("unmangleable", function(options){
     var def = this.definition();
-    return def && def.unmangleable(options);
+    return !def || def.unmangleable(options);
 });
 
 // labels are always mangleable
@@ -439,14 +500,6 @@ AST_Symbol.DEFMETHOD("unreferenced", function(){
         && !(this.scope.uses_eval || this.scope.uses_with);
 });
 
-AST_Symbol.DEFMETHOD("undeclared", function(){
-    return this.definition().undeclared;
-});
-
-AST_LabelRef.DEFMETHOD("undeclared", return_false);
-
-AST_Label.DEFMETHOD("undeclared", return_false);
-
 AST_Symbol.DEFMETHOD("definition", function(){
     return this.thedef;
 });
@@ -455,8 +508,8 @@ AST_Symbol.DEFMETHOD("global", function(){
     return this.definition().global;
 });
 
-AST_Toplevel.DEFMETHOD("_default_mangler_options", function(options){
+AST_Toplevel.DEFMETHOD("_default_mangler_options", function(options) {
-    return defaults(options, {
+    options = defaults(options, {
         eval        : false,
         ie8         : false,
         keep_classnames: false,
@@ -464,14 +517,15 @@ AST_Toplevel.DEFMETHOD("_default_mangler_options", function(options){
         reserved    : [],
         toplevel    : false,
     });
+    if (!Array.isArray(options.reserved)) options.reserved = [];
+    // Never mangle arguments
+    push_uniq(options.reserved, "arguments");
+    return options;
 });
 
 AST_Toplevel.DEFMETHOD("mangle_names", function(options){
     options = this._default_mangler_options(options);
 
-    // Never mangle arguments
-    options.reserved.push('arguments');
-
     // We only need to mangle declaration nodes.  Special logic wired
     // into the code generator will display the mangled name if it's
     // present (and for AST_SymbolRef-s it'll use the mangled name of
@@ -479,12 +533,14 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options){
     var lname = -1;
     var to_mangle = [];
 
+    var mangled_names = this.mangled_names = [];
     if (options.cache) {
-        this.globals.each(function(symbol){
+        this.globals.each(collect);
-            if (options.reserved.indexOf(symbol.name) < 0) {
+        if (options.cache.props) {
-                to_mangle.push(symbol);
+            options.cache.props.each(function(mangled_name) {
-            }
+                push_uniq(mangled_names, mangled_name);
-        });
+            });
+        }
     }
 
     var tw = new TreeWalker(function(node, descend){
@@ -496,13 +552,11 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options){
             return true;        // don't descend again in TreeWalker
         }
         if (node instanceof AST_Scope) {
-            var p = tw.parent(), a = [];
+            node.variables.each(collect);
-            node.variables.each(function(symbol){
+            return;
-                if (options.reserved.indexOf(symbol.name) < 0) {
+        }
-                    a.push(symbol);
+        if (node.is_block_scope()) {
-                }
+            node.block_scope.variables.each(collect);
-            });
-            to_mangle.push.apply(to_mangle, a);
             return;
         }
         if (node instanceof AST_Label) {
@@ -511,131 +565,149 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options){
             node.mangled_name = name;
             return true;
         }
-        var mangle_with_block_scope =
+        if (!options.ie8 && node instanceof AST_SymbolCatch) {
-            (!options.ie8 && node instanceof AST_SymbolCatch) ||
-            node instanceof AST_SymbolBlockDeclaration;
-        if (mangle_with_block_scope) {
             to_mangle.push(node.definition());
             return;
         }
     });
     this.walk(tw);
-    to_mangle.forEach(function(def){
+    to_mangle.forEach(function(def){ def.mangle(options) });
-        def.mangle(options);
-    });
 
-    if (options.cache) {
+    function collect(symbol) {
-        options.cache.cname = this.cname;
+        if (!member(symbol.name, options.reserved)) {
+            to_mangle.push(symbol);
+        }
     }
 });
 
+AST_Toplevel.DEFMETHOD("find_colliding_names", function(options) {
+    var cache = options.cache && options.cache.props;
+    var avoid = Object.create(null);
+    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());
+    }));
+    return avoid;
+
+    function to_avoid(name) {
+        avoid[name] = true;
+    }
+
+    function add_def(def) {
+        var name = def.name;
+        if (def.global && cache && cache.has(name)) name = cache.get(name);
+        else if (!def.unmangleable(options)) return;
+        to_avoid(name);
+    }
+});
+
+AST_Toplevel.DEFMETHOD("expand_names", function(options) {
+    base54.reset();
+    base54.sort();
+    options = this._default_mangler_options(options);
+    var avoid = this.find_colliding_names(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());
+    }));
+
+    function next_name() {
+        var name;
+        do {
+            name = base54(cname++);
+        } while (avoid[name] || !is_identifier(name));
+        return name;
+    }
+
+    function rename(def) {
+        if (def.global && options.cache) return;
+        if (def.unmangleable(options)) return;
+        if (member(def.name, options.reserved)) return;
+        var d = def.redefined();
+        def.name = d ? d.name : next_name();
+        def.orig.forEach(function(sym) {
+            sym.name = def.name;
+        });
+        def.references.forEach(function(sym) {
+            sym.name = def.name;
+        });
+    }
+});
+
+AST_Node.DEFMETHOD("tail_node", return_this);
+AST_Sequence.DEFMETHOD("tail_node", function() {
+    return this.expressions[this.expressions.length - 1];
+});
+
 AST_Toplevel.DEFMETHOD("compute_char_frequency", function(options){
     options = this._default_mangler_options(options);
-    var tw = new TreeWalker(function(node){
+    try {
-        if (node instanceof AST_Constant)
+        AST_Node.prototype.print = function(stream, force_parens) {
-            base54.consider(node.print_to_string());
+            this._print(stream, force_parens);
-        else if (node instanceof AST_Return)
+            if (this instanceof AST_Symbol && !this.unmangleable(options)) {
-            base54.consider("return");
+                base54.consider(this.name, -1);
-        else if (node instanceof AST_Throw)
+            } else if (options.properties) {
-            base54.consider("throw");
+                if (this instanceof AST_Dot) {
-        else if (node instanceof AST_Continue)
+                    base54.consider(this.property, -1);
-            base54.consider("continue");
+                } else if (this instanceof AST_Sub) {
-        else if (node instanceof AST_Break)
+                    skip_string(this.property);
-            base54.consider("break");
+                }
-        else if (node instanceof AST_Debugger)
+            }
-            base54.consider("debugger");
+        };
-        else if (node instanceof AST_Directive)
+        base54.consider(this.print_to_string(), 1);
-            base54.consider(node.value);
+    } finally {
-        else if (node instanceof AST_While)
+        AST_Node.prototype.print = AST_Node.prototype._print;
-            base54.consider("while");
+    }
-        else if (node instanceof AST_Do)
-            base54.consider("do while");
-        else if (node instanceof AST_If) {
-            base54.consider("if");
-            if (node.alternative) base54.consider("else");
-        }
-        else if (node instanceof AST_Var)
-            base54.consider("var");
-        else if (node instanceof AST_Const)
-            base54.consider("const");
-        else if (node instanceof AST_Lambda)
-            base54.consider("function");
-        else if (node instanceof AST_For)
-            base54.consider("for");
-        else if (node instanceof AST_ForIn)
-            base54.consider("for in");
-        else if (node instanceof AST_Switch)
-            base54.consider("switch");
-        else if (node instanceof AST_Case)
-            base54.consider("case");
-        else if (node instanceof AST_Default)
-            base54.consider("default");
-        else if (node instanceof AST_With)
-            base54.consider("with");
-        else if (node instanceof AST_ObjectSetter)
-            base54.consider("set" + (typeof node.key === "string" ? node.key : ""));
-        else if (node instanceof AST_ObjectGetter)
-            base54.consider("get" + (typeof node.key === "string" ? node.key : ""));
-        else if (node instanceof AST_ObjectKeyVal && typeof node.key === "string")
-            base54.consider(node.key);
-        else if (node instanceof AST_ConciseMethod && typeof node.key === "string")
-            base54.consider(node.key);
-        else if (node instanceof AST_New)
-            base54.consider("new");
-        else if (node instanceof AST_This)
-            base54.consider("this");
-        else if (node instanceof AST_Super)
-            base54.consider("super");
-        else if (node instanceof AST_Try)
-            base54.consider("try");
-        else if (node instanceof AST_Catch)
-            base54.consider("catch");
-        else if (node instanceof AST_Finally)
-            base54.consider("finally");
-        else if (node instanceof AST_Yield)
-            base54.consider("yield");
-        else if (node instanceof AST_Symbol && node.unmangleable(options))
-            base54.consider(node.name);
-        else if (node instanceof AST_Unary || node instanceof AST_Binary)
-            base54.consider(node.operator);
-        else if (node instanceof AST_Dot)
-            base54.consider(node.property);
-    });
-    this.walk(tw);
     base54.sort();
+
+    function skip_string(node) {
+        if (node instanceof AST_String) {
+            base54.consider(node.value, -1);
+        } else if (node instanceof AST_Conditional) {
+            skip_string(node.consequent);
+            skip_string(node.alternative);
+        } else if (node instanceof AST_Sequence) {
+            skip_string(node.tail_node());
+        }
+    }
 });
 
 var base54 = (function() {
-    var string = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_0123456789";
+    var leading = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_".split("");
+    var digits = "0123456789".split("");
     var chars, frequency;
     function reset() {
         frequency = Object.create(null);
-        chars = string.split("").map(function(ch){ return ch.charCodeAt(0) });
+        leading.forEach(function(ch) {
-        chars.forEach(function(ch){ frequency[ch] = 0 });
+            frequency[ch] = 0;
+        });
+        digits.forEach(function(ch) {
+            frequency[ch] = 0;
+        });
     }
-    base54.consider = function(str){
+    base54.consider = function(str, delta) {
         for (var i = str.length; --i >= 0;) {
-            var code = str.charCodeAt(i);
+            frequency[str[i]] += delta;
-            if (code in frequency) ++frequency[code];
         }
     };
+    function compare(a, b) {
+        return frequency[b] - frequency[a];
+    }
     base54.sort = function() {
-        chars = mergeSort(chars, function(a, b){
+        chars = mergeSort(leading, compare).concat(mergeSort(digits, compare));
-            if (is_digit(a) && !is_digit(b)) return 1;
-            if (is_digit(b) && !is_digit(a)) return -1;
-            return frequency[b] - frequency[a];
-        });
     };
     base54.reset = reset;
     reset();
-    base54.get = function(){ return chars };
-    base54.freq = function(){ return frequency };
     function base54(num) {
         var ret = "", base = 54;
         num++;
         do {
             num--;
-            ret += String.fromCharCode(chars[num % base]);
+            ret += chars[num % base];
             num = Math.floor(num / base);
             base = 64;
         } while (num > 0);

lib/transform.js

@@ -60,17 +60,14 @@ TreeTransformer.prototype = new TreeWalker;
             tw.push(this);
             if (tw.before) x = tw.before(this, descend, in_list);
             if (x === undefined) {
-                if (!tw.after) {
+                x = this;
-                    x = this;
+                descend(x, tw);
-                    descend(x, tw);
+                if (tw.after) {
-                } else {
-                    tw.stack[tw.stack.length - 1] = x = this;
-                    descend(x, tw);
                     y = tw.after(x, in_list);
                     if (y !== undefined) x = y;
                 }
             }
-            tw.pop(this);
+            tw.pop();
             return x;
         });
     };
@@ -199,6 +196,10 @@ TreeTransformer.prototype = new TreeWalker;
         if (self.expression) self.expression = self.expression.transform(tw);
     });
 
+    _(AST_Await, function(self, tw){
+        self.expression = self.expression.transform(tw);
+    });
+
     _(AST_Unary, function(self, tw){
         self.expression = self.expression.transform(tw);
     });
@@ -239,17 +240,26 @@ TreeTransformer.prototype = new TreeWalker;
         self.expression = self.expression.transform(tw);
     });
 
-    _(AST_Export, function(self, tw){
+    _(AST_NameMapping, function(self, tw) {
+        self.foreign_name = self.foreign_name.transform(tw);
+        self.name = self.name.transform(tw);
+    });
+
+    _(AST_Import, function(self, tw) {
+        if (self.imported_name) self.imported_name = self.imported_name.transform(tw);
+        if (self.imported_names) do_list(self.imported_names, tw);
+        self.module_name = self.module_name.transform(tw);
+    });
+
+    _(AST_Export, function(self, tw) {
         if (self.exported_definition) self.exported_definition = self.exported_definition.transform(tw);
         if (self.exported_value) self.exported_value = self.exported_value.transform(tw);
+        if (self.exported_names) do_list(self.exported_names, tw);
+        if (self.module_name) self.module_name = self.module_name.transform(tw);
     });
 
     _(AST_TemplateString, function(self, tw) {
-        for (var i = 0; i < self.segments.length; i++) {
+        self.segments = do_list(self.segments, tw);
-            if (!(self.segments[i] instanceof AST_TemplateSegment)) {
-                self.segments[i] = self.segments[i].transform(tw);
-            }
-        }
     });
 
     _(AST_PrefixedTemplateString, function(self, tw) {

lib/utils.js

@@ -43,17 +43,6 @@
 
 "use strict";
 
-function array_to_hash(a) {
-    var ret = Object.create(null);
-    for (var i = 0; i < a.length; ++i)
-        ret[a[i]] = true;
-    return ret;
-};
-
-function slice(a, start) {
-    return Array.prototype.slice.call(a, start || 0);
-};
-
 function characters(str) {
     return str.split("");
 };
@@ -221,18 +210,6 @@ function mergeSort(array, cmp) {
     return _ms(array);
 };
 
-function set_difference(a, b) {
-    return a.filter(function(el){
-        return b.indexOf(el) < 0;
-    });
-};
-
-function set_intersection(a, b) {
-    return a.filter(function(el){
-        return b.indexOf(el) >= 0;
-    });
-};
-
 // this function is taken from Acorn [1], written by Marijn Haverbeke
 // [1] https://github.com/marijnh/acorn
 function makePredicate(words) {
@@ -326,6 +303,13 @@ Dictionary.prototype = {
             ret.push(f(this._values[i], i.substr(1)));
         return ret;
     },
+    clone: function() {
+        var ret = new Dictionary();
+        for (var i in this._values)
+            ret._values[i] = this._values[i];
+        ret._size = this._size;
+        return ret;
+    },
     toObject: function() { return this._values }
 };
 Dictionary.fromObject = function(obj) {
@@ -347,7 +331,7 @@ function first_in_statement(stack) {
         if (p instanceof AST_Statement && p.body === node)
             return true;
         if ((p instanceof AST_Sequence      && p.expressions[0] === node) ||
-            (p instanceof AST_Call          && p.expression === node && !(p instanceof AST_New) ) ||
+            (p.TYPE == "Call"               && p.expression === node ) ||
             (p instanceof AST_Dot           && p.expression === node ) ||
             (p instanceof AST_Sub           && p.expression === node ) ||
             (p instanceof AST_Conditional   && p.condition === node  ) ||

package.json

@@ -1,23 +1,18 @@
 {
   "name": "uglify-es",
-  "description": "JavaScript parser, mangler/compressor and beautifier toolkit",
+  "description": "JavaScript parser, mangler/compressor and beautifier toolkit for ES6+",
   "homepage": "https://github.com/mishoo/UglifyJS2/tree/harmony",
   "author": "Mihai Bazon <mihai.bazon@gmail.com> (http://lisperator.net/)",
   "license": "BSD-2-Clause",
-  "version": "3.0.13",
+  "version": "3.3.10",
   "engines": {
     "node": ">=0.8.0"
   },
   "maintainers": [
+    "Alex Lam <alexlamsl@gmail.com>",
     "Mihai Bazon <mihai.bazon@gmail.com> (http://lisperator.net/)"
   ],
-  "repository": {
+  "repository": "https://github.com/mishoo/UglifyJS2.git#harmony",
-    "type": "git",
-    "url": "https://github.com/mishoo/UglifyJS2.git"
-  },
-  "bugs": {
-    "url": "https://github.com/mishoo/UglifyJS2/issues"
-  },
   "main": "tools/node.js",
   "bin": {
     "uglifyjs": "bin/uglifyjs"
@@ -29,16 +24,33 @@
     "LICENSE"
   ],
   "dependencies": {
-    "commander": "~2.9.0",
+    "commander": "~2.14.1",
-    "source-map": "~0.5.1"
+    "source-map": "~0.6.1"
   },
   "devDependencies": {
-    "acorn": "~5.0.3",
+    "acorn": "~5.4.1",
-    "mocha": "~2.3.4",
+    "mocha": "~3.5.1",
-    "semver": "~5.3.0"
+    "semver": "~5.5.0"
   },
   "scripts": {
     "test": "node test/run-tests.js"
   },
-  "keywords": ["uglify", "uglify-js", "uglify-es", "minify", "minifier", "es5", "es6", "es2015"]
+  "keywords": [
+    "uglify",
+    "uglify-es",
+    "uglify-js",
+    "minify",
+    "minifier",
+    "javascript",
+    "ecmascript",
+    "es5",
+    "es6",
+    "es7",
+    "es8",
+    "es2015",
+    "es2016",
+    "es2017",
+    "async",
+    "await"
+  ]
 }

test/benchmark.js

@@ -4,7 +4,9 @@
 "use strict";
 
 var createHash = require("crypto").createHash;
+var fetch = require("./fetch");
 var fork = require("child_process").fork;
+var zlib = require("zlib");
 var args = process.argv.slice(2);
 if (!args.length) {
     args.push("-mc");
@@ -19,6 +21,7 @@ var urls = [
     "http://builds.emberjs.com/tags/v2.11.0/ember.prod.js",
     "https://cdn.jsdelivr.net/lodash/4.17.4/lodash.js",
     "https://cdnjs.cloudflare.com/ajax/libs/d3/4.5.0/d3.js",
+    "https://raw.githubusercontent.com/kangax/html-minifier/v3.5.7/dist/htmlminifier.js",
 ];
 var results = {};
 var remaining = 2 * urls.length;
@@ -32,6 +35,7 @@ function done() {
             console.log(info.log);
             console.log("Original:", info.input, "bytes");
             console.log("Uglified:", info.output, "bytes");
+            console.log("GZipped: ", info.gzip, "bytes");
             console.log("SHA1 sum:", info.sha1);
             if (info.code) {
                 failures.push(url);
@@ -50,15 +54,21 @@ urls.forEach(function(url) {
     results[url] = {
         input: 0,
         output: 0,
+        gzip: 0,
         log: ""
     };
-    require(url.slice(0, url.indexOf(":"))).get(url, function(res) {
+    fetch(url, function(err, res) {
+        if (err) throw err;
         var uglifyjs = fork("bin/uglifyjs", args, { silent: true });
         res.on("data", function(data) {
             results[url].input += data.length;
         }).pipe(uglifyjs.stdin);
         uglifyjs.stdout.on("data", function(data) {
             results[url].output += data.length;
+        }).pipe(zlib.createGzip({
+            level: zlib.Z_BEST_COMPRESSION
+        })).on("data", function(data) {
+            results[url].gzip += data.length;
         }).pipe(createHash("sha1")).on("data", function(data) {
             results[url].sha1 = data.toString("hex");
             done();

test/compress/arrays.js

@@ -203,50 +203,114 @@ constant_join_3: {
 
 for_loop: {
     options = {
-        unsafe      : true,
+        evaluate: true,
-        unused      : true,
+        reduce_funcs: true,
-        evaluate    : true,
+        reduce_vars: true,
-        reduce_vars : true
+        unsafe: true,
+        unused: true,
     };
     input: {
         function f0() {
             var a = [1, 2, 3];
-            for (var i = 0; i < a.length; i++) {
+            var b = 0;
-                console.log(a[i]);
+            for (var i = 0; i < a.length; i++)
-            }
+                b += a[i];
+            return b;
         }
-
         function f1() {
             var a = [1, 2, 3];
-            for (var i = 0, len = a.length; i < len; i++) {
+            var b = 0;
-                console.log(a[i]);
+            for (var i = 0, len = a.length; i < len; i++)
-            }
+                b += a[i];
+            return b;
         }
-
-        function f2() {
-            var a = [1, 2, 3];
-            for (var i = 0; i < a.length; i++) {
-                a[i]++;
-            }
-        }
-    }
-    expect: {
-        function f0() {
-            var a = [1, 2, 3];
-            for (var i = 0; i < 3; i++)
-                console.log(a[i]);
-        }
-
-        function f1() {
-            var a = [1, 2, 3];
-            for (var i = 0; i < 3; i++)
-                console.log(a[i]);
-        }
-
         function f2() {
             var a = [1, 2, 3];
             for (var i = 0; i < a.length; i++)
                 a[i]++;
+            return a[2];
         }
+        console.log(f0(), f1(), f2());
     }
+    expect: {
+        function f0() {
+            var a = [1, 2, 3];
+            var b = 0;
+            for (var i = 0; i < 3; i++)
+                b += a[i];
+            return b;
+        }
+        function f1() {
+            var a = [1, 2, 3];
+            var b = 0;
+            for (var i = 0; i < 3; i++)
+                b += a[i];
+            return b;
+        }
+        function f2() {
+            var a = [1, 2, 3];
+            for (var i = 0; i < a.length; i++)
+                a[i]++;
+            return a[2];
+        }
+        console.log(f0(), f1(), f2());
+    }
+    expect_stdout: "6 6 4"
+}
+
+index: {
+    options = {
+        evaluate: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unsafe: true,
+        unused: true,
+    }
+    input: {
+        var a = [ 1, 2 ];
+        console.log(a[0], a[1]);
+    }
+    expect: {
+        console.log(1, 2);
+    }
+    expect_stdout: "1 2"
+}
+
+length: {
+    options = {
+        evaluate: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unsafe: true,
+        unused: true,
+    }
+    input: {
+        var a = [ 1, 2 ];
+        console.log(a.length);
+    }
+    expect: {
+        console.log(2);
+    }
+    expect_stdout: "2"
+}
+
+index_length: {
+    options = {
+        evaluate: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unsafe: true,
+        unused: true,
+    }
+    input: {
+        var a = [ 1, 2 ];
+        console.log(a[0], a.length);
+    }
+    expect: {
+        console.log(1, 2);
+    }
+    expect_stdout: "1 2"
 }

test/compress/arrow.js

@@ -135,3 +135,522 @@ arrow_with_regexp: {
         num => /\d{11,14}/.test( num )
     }
 }
+
+arrow_unused: {
+    options = {
+        toplevel: false,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        top => dog;
+        let fn = a => { console.log(a * a); };
+        let u = (x, y) => x - y + g;
+        (() => { console.log("0"); })();
+        !function(x) {
+            (() => { console.log("1"); })();
+            let unused = x => { console.log(x); };
+            let baz = e => e + e;
+            console.log(baz(x));
+        }(1);
+        fn(3);
+    }
+    expect: {
+        let fn = a => { console.log(a * a); };
+        let u = (x, y) => x - y + g;
+        (() => { console.log("0"); })();
+        !function(x) {
+            (() => { console.log("1"); })();
+            let baz = e => e + e;
+            console.log(baz(x));
+        }(1);
+        fn(3);
+    }
+    expect_stdout: [ "0", "1", "2", "9" ]
+    node_version: ">=6"
+}
+
+arrow_unused_toplevel: {
+    options = {
+        toplevel: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        top => dog;
+        let fn = a => { console.log(a * a); };
+        let u = (x, y) => x - y + g;
+        (() => { console.log("0"); })();
+        !function(x) {
+            (() => { console.log("1"); })();
+            let unused = x => { console.log(x); };
+            let baz = e => e + e;
+            console.log(baz(x));
+        }(1);
+        fn(3);
+    }
+    expect: {
+        let fn = a => { console.log(a * a); };
+        (() => { console.log("0"); })();
+        !function(x) {
+            (() => { console.log("1"); })();
+            let baz = e => e + e;
+            console.log(baz(x));
+        }(1);
+        fn(3);
+    }
+    expect_stdout: [ "0", "1", "2", "9" ]
+    node_version: ">=6"
+}
+
+no_leading_parentheses: {
+    input: {
+        (x,y) => x(y);
+        async (x,y) => await x(y);
+    }
+    expect_exact: "(x,y)=>x(y);async(x,y)=>await x(y);"
+}
+
+async_identifiers: {
+    options = {
+        unsafe_arrows: true,
+        ecma: 6,
+    }
+    input: {
+        var async = function(x){ console.log("async", x); };
+        var await = function(x){ console.log("await", x); };
+        async(1);
+        await(2);
+    }
+    expect: {
+        var async = x => { console.log("async", x); };
+        var await = x => { console.log("await", x); };
+        async(1);
+        await(2);
+    }
+    expect_stdout: [
+        "async 1",
+        "await 2",
+    ]
+    node_version: ">=4"
+}
+
+async_function_expression: {
+    options = {
+        unsafe_arrows: true,
+        ecma: 6,
+        evaluate: true,
+        side_effects: true,
+    }
+    input: {
+        var named = async function foo() {
+            await bar(1 + 0) + (2 + 0);
+        }
+        var anon = async function() {
+            await (1 + 0) + bar(2 + 0);
+        }
+    }
+    expect: {
+        var named = async function foo() {
+            await bar(1);
+        };
+        var anon = async () => {
+            await 1, bar(2);
+        };
+    }
+}
+
+issue_27: {
+    options = {
+        unsafe_arrows: true,
+        collapse_vars: true,
+        ecma: 6,
+        unused: true,
+    }
+    input: {
+        (function(jQuery) {
+            var $;
+            $ = jQuery;
+            $("body").addClass("foo");
+        })(jQuery);
+    }
+    expect: {
+        (jQuery => {
+            jQuery("body").addClass("foo");
+        })(jQuery);
+    }
+}
+
+issue_2105_1: {
+    options = {
+        unsafe_arrows: true,
+        collapse_vars: true,
+        ecma: 6,
+        inline: true,
+        passes: 3,
+        reduce_funcs: true,
+        reduce_vars: true,
+        side_effects: true,
+        unsafe_methods: true,
+        unused: true,
+    }
+    input: {
+        !function(factory) {
+            factory();
+        }( function() {
+            return function(fn) {
+                fn()().prop();
+            }( function() {
+                function bar() {
+                    var quux = function() {
+                        console.log("PASS");
+                    }, foo = function() {
+                        console.log;
+                        quux();
+                    };
+                    return { prop: foo };
+                }
+                return bar;
+            } );
+        });
+    }
+    expect: {
+        ({
+            prop() {
+                console.log;
+                console.log("PASS");
+            }
+        }).prop();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_2105_2: {
+    options = {
+        collapse_vars: true,
+        inline: true,
+        passes: 2,
+        reduce_funcs: true,
+        reduce_vars: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        ((factory) => {
+            factory();
+        })( () => {
+            return ((fn) => {
+                fn()().prop();
+            })( () => {
+                let bar = () => {
+                    var quux = () => {
+                        console.log("PASS");
+                    }, foo = () => {
+                        console.log;
+                        quux();
+                    };
+                    return { prop: foo };
+                };
+                return bar;
+            } );
+        });
+    }
+    expect: {
+        ({
+            prop: () => {
+                console.log;
+                console.log("PASS");
+            }
+        }).prop();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_2136_2: {
+    options = {
+        arrows: true,
+        collapse_vars: true,
+        ecma: 6,
+        inline: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        function f(x) {
+            console.log(x);
+        }
+        !function(a, ...b) {
+            f(b[0]);
+        }(1, 2, 3);
+    }
+    expect: {
+        function f(x) {
+            console.log(x);
+        }
+        f([2,3][0]);
+    }
+    expect_stdout: "2"
+    node_version: ">=6"
+}
+
+issue_2136_3: {
+    options = {
+        arrows: true,
+        collapse_vars: true,
+        ecma: 6,
+        evaluate: true,
+        inline: true,
+        passes: 3,
+        reduce_funcs: true,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unsafe: true,
+        unused: true,
+    }
+    input: {
+        function f(x) {
+            console.log(x);
+        }
+        !function(a, ...b) {
+            f(b[0]);
+        }(1, 2, 3);
+    }
+    expect: {
+        console.log(2);
+    }
+    expect_stdout: "2"
+    node_version: ">=6"
+}
+
+call_args: {
+    options = {
+        arrows: true,
+        ecma: 6,
+        evaluate: true,
+        inline: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+    }
+    input: {
+        const a = 1;
+        console.log(a);
+        +function(a) {
+            return a;
+        }(a);
+    }
+    expect: {
+        const a = 1;
+        console.log(1);
+        +(1, 1);
+    }
+    expect_stdout: true
+}
+
+call_args_drop_param: {
+    options = {
+        arrows: true,
+        ecma: 6,
+        evaluate: true,
+        inline: true,
+        keep_fargs: false,
+        reduce_funcs: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        const a = 1;
+        console.log(a);
+        +function(a) {
+            return a;
+        }(a, b);
+    }
+    expect: {
+        const a = 1;
+        console.log(1);
+        +(b, 1);
+    }
+    expect_stdout: true
+}
+
+issue_485_crashing_1530: {
+    options = {
+        arrows: true,
+        conditionals: true,
+        dead_code: true,
+        ecma: 6,
+        evaluate: true,
+        inline: true,
+        side_effects: true,
+    }
+    input: {
+        (function(a) {
+            if (true) return;
+            var b = 42;
+        })(this);
+    }
+    expect: {}
+}
+
+issue_2084: {
+    options = {
+        unsafe_arrows: true,
+        collapse_vars: true,
+        conditionals: true,
+        ecma: 6,
+        evaluate: true,
+        inline: true,
+        passes: 2,
+        reduce_funcs: true,
+        reduce_vars: true,
+        sequences: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        var c = 0;
+        !function() {
+            !function(c) {
+                c = 1 + c;
+                var c = 0;
+                function f14(a_1) {
+                    if (c = 1 + c, 0 !== 23..toString())
+                        c = 1 + c, a_1 && (a_1[0] = 0);
+                }
+                f14();
+            }(-1);
+        }();
+        console.log(c);
+    }
+    expect: {
+        var c = 0;
+        ((c) => {
+            c = 1 + c,
+            c = 1 + (c = 0),
+            0 !== 23..toString() && (c = 1 + c);
+        })(-1),
+        console.log(c);
+    }
+    expect_stdout: "0"
+    node_version: ">=4"
+}
+
+export_default_object_expression: {
+    options = {
+        arrows: true,
+        evaluate: true,
+    }
+    input: {
+        export default {
+            foo: 1 + 2,
+            bar() { return 4; },
+            get baz() { return this.foo; },
+        };
+    }
+    expect_exact: "export default{foo:3,bar:()=>4,get baz(){return this.foo}};"
+}
+
+concise_methods_with_computed_property2: {
+    options = {
+        arrows: true,
+        evaluate: true,
+    }
+    input: {
+        var foo = {
+            [[1]](v) {
+                return v;
+            }
+        };
+        console.log(foo[[1]]("PASS"));
+    }
+    expect_exact: 'var foo={[[1]]:v=>v};console.log(foo[[1]]("PASS"));'
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+async_object_literal: {
+    options = {
+        arrows: true,
+        unsafe_arrows: true,
+        ecma: 6,
+        evaluate: true,
+    }
+    input: {
+        var obj = {
+            async a() {
+                return await foo(1 + 0);
+            },
+            anon: async function() {
+                return await foo(2 + 0);
+            }
+        };
+    }
+    expect: {
+        var obj = {
+            a: async () => await foo(1),
+            anon: async () => await foo(2)
+        };
+    }
+}
+
+issue_2271: {
+    options = {
+        arrows: true,
+        ecma: 6,
+        evaluate: true,
+        unsafe_arrows: false,
+    }
+    input: {
+        var Foo = function() {};
+        Foo.prototype.set = function(value) {
+            this.value = value;
+            return this;
+        }
+        Foo.prototype.print = function() {
+            console.log(this.value);
+        }
+        new Foo().set("PASS").print();
+    }
+    expect: {
+        var Foo = function() {};
+        Foo.prototype.set = function(value) {
+            this.value = value;
+            return this;
+        }
+        Foo.prototype.print = function() {
+            console.log(this.value);
+        }
+        new Foo().set("PASS").print();
+    }
+    expect_stdout: "PASS"
+}
+
+concise_method_with_super: {
+    options = {
+        arrows: true,
+    }
+    input: {
+        var o = {
+            f: "FAIL",
+            g() {
+                return super.f;
+            }
+        }
+        Object.setPrototypeOf(o, { f: "PASS" });
+        console.log(o.g());
+    }
+    expect: {
+        var o = {
+            f: "FAIL",
+            g() {
+                return super.f;
+            }
+        }
+        Object.setPrototypeOf(o, { f: "PASS" });
+        console.log(o.g());
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}

test/compress/ascii.js

@@ -13,7 +13,7 @@ ascii_only_true: {
                    "\x20\x21\x22\x23 ... \x7d\x7e\x7f\x80\x81 ... \xfe\xff\u0fff\uffff";
         }
     }
-    expect_exact: 'function f(){return"\\x000\\x001\\x007\\08\\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_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: {
@@ -31,5 +31,5 @@ ascii_only_false: {
                    "\x20\x21\x22\x23 ... \x7d\x7e\x7f\x80\x81 ... \xfe\xff\u0fff\uffff";
         }
     }
-    expect_exact: 'function f(){return"\\x000\\x001\\x007\\08\\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_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

@@ -16,7 +16,6 @@ asm_mixed: {
         hoist_vars    : true,
         if_return     : true,
         join_vars     : true,
-        cascade       : true,
         side_effects  : true,
         negate_iife   : true
     };
@@ -104,3 +103,65 @@ asm_mixed: {
     }
 }
 
+asm_toplevel: {
+    options = {}
+    input: {
+        "use asm";
+        0.0;
+        function f() {
+            0.0;
+            (function(){
+                0.0;
+            });
+        }
+        0.0;
+    }
+    expect_exact: '"use asm";0.0;function f(){0.0;(function(){0.0})}0.0;'
+}
+
+asm_function_expression: {
+    options = {}
+    input: {
+        0.0;
+        var a = function() {
+            "use asm";
+            0.0;
+        }
+        function f() {
+            0.0;
+            return function(){
+                "use asm";
+                0.0;
+            }
+            0.0;
+        }
+        0.0;
+    }
+    expect_exact: '0;var a=function(){"use asm";0.0};function f(){0;return function(){"use asm";0.0};0}0;'
+}
+
+asm_nested_functions: {
+    options = {}
+    input: {
+        0.0;
+        function a() {
+            "use asm";
+            0.0;
+        }
+        0.0;
+        function b() {
+            0.0;
+            function c(){
+                "use asm";
+                0.0;
+            }
+            0.0;
+            function d(){
+                0.0;
+            }
+            0.0;
+        }
+        0.0;
+    }
+    expect_exact: '0;function a(){"use asm";0.0}0;function b(){0;function c(){"use asm";0.0}0;function d(){0}0}0;'
+}

test/compress/async.js

@@ -0,0 +1,323 @@
+await_precedence: {
+    input: {
+        async function f1() { await x + y; }
+        async function f2() { await (x + y); }
+    }
+    expect_exact: "async function f1(){await x+y}async function f2(){await(x+y)}"
+}
+
+await_precedence_prop: {
+    input: {
+        async function f1(){ return (await foo()).bar; }
+        async function f2(){ return (await foo().bar); }
+    }
+    expect_exact: "async function f1(){return(await foo()).bar}async function f2(){return await foo().bar}"
+}
+
+await_precedence_call: {
+    input: {
+        async function f3(){ return (await foo())(); }
+        async function f4(){ return await (foo()()); }
+    }
+    expect_exact: "async function f3(){return(await foo())()}async function f4(){return await foo()()}"
+}
+
+async_function_declaration: {
+    options = {
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        async function f0() {}
+        async function f1() { await x + y; }
+        async function f2() { await (x + y); }
+        async function f3() { await x + await y; }
+        async function f4() { await (x + await y); }
+        async function f5() { await x; await y; }
+        async function f6() { await x, await y; }
+    }
+    expect: {
+        async function f0() {}
+        async function f1() { await x, y; }
+        async function f2() { await (x + y); }
+        async function f3() { await x, await y; }
+        async function f4() { await (x + await y); }
+        async function f5() { await x; await y; }
+        async function f6() { await x, await y; }
+    }
+}
+
+async_function_expression: {
+    options = {
+        evaluate: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        var named = async function foo() {
+            await bar(1 + 0) + (2 + 0);
+        }
+        var anon = async function() {
+            await (1 + 0) + bar(2 + 0);
+        }
+    }
+    expect: {
+        var named = async function() {
+            await bar(1);
+        };
+        var anon = async function() {
+            await 1, bar(2);
+        };
+    }
+}
+
+async_class: {
+    options = {
+        evaluate: true,
+    }
+    input: {
+        class Foo {
+            async m1() {
+                return await foo(1 + 2);
+            }
+            static async m2() {
+                return await foo(3 + 4);
+            }
+        }
+    }
+    expect: {
+        class Foo {
+            async m1() {
+                return await foo(3);
+            }
+            static async m2() {
+                return await foo(7);
+            }
+        }
+    }
+}
+
+async_object_literal: {
+    options = {
+        evaluate: true,
+    }
+    input: {
+        var obj = {
+            async a() {
+                await foo(1 + 0);
+            },
+            anon: async function(){
+                await foo(2 + 0);
+            }
+        };
+    }
+    expect: {
+        var obj = {
+            async a() {
+                await foo(1);
+            },
+            anon: async function() {
+                await foo(2);
+            }
+        };
+    }
+}
+
+async_export: {
+    input: {
+        export async function run() {};
+        export default async function def() {};
+    }
+    expect: {
+        export async function run() {};
+        export default async function def() {};
+    }
+}
+
+async_inline: {
+    options = {
+        collapse_vars: true,
+        conditionals: true,
+        evaluate: true,
+        inline: true,
+        negate_iife: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        (async function(){ return await 3; })();
+        (async function(x){ await console.log(x); })(4);
+
+        function echo(x) { return x; }
+        echo( async function(){ return await 1; }() );
+        echo( async function(x){ await console.log(x); }(2) );
+
+        function top() { console.log("top"); }
+        top();
+
+        async function async_top() { console.log("async_top"); }
+        async_top();
+    }
+    expect: {
+        !async function(){await 3}();
+        !async function(x){await console.log(4)}();
+
+        function echo(x){return x}
+        echo(async function(){return await 1}());
+        echo(async function(x){await console.log(2)}());
+
+        console.log("top");
+
+        !async function(){console.log("async_top")}();
+    }
+    expect_stdout: [
+        "4",
+        "2",
+        "top",
+        "async_top",
+    ]
+    node_version: ">=8"
+}
+
+async_identifiers: {
+    input: {
+        var async = function(x){ console.log("async", x); };
+        var await = function(x){ console.log("await", x); };
+        async(1);
+        await(2);
+    }
+    expect: {
+        var async = function(x){ console.log("async", x); };
+        var await = function(x){ console.log("await", x); };
+        async(1);
+        await(2);
+    }
+    expect_stdout: [
+        "async 1",
+        "await 2",
+    ]
+}
+
+async_shorthand_property: {
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        function print(o) { console.log(o.async + " " + o.await); }
+        var async = "Async", await = "Await";
+
+        print({ async });
+        print({ await });
+        print({ async, await });
+        print({ await, async });
+
+        print({ async: async });
+        print({ await: await });
+        print({ async: async, await: await });
+        print({ await: await, async: async });
+    }
+    expect: {
+        function a(a) { console.log(a.async + " " + a.await); }
+        var n = "Async", c = "Await";
+
+        a({ async: n });
+        a({ await: c });
+        a({ async: n, await: c });
+        a({ await: c, async: n });
+
+        a({ async: n });
+        a({ await: c });
+        a({ async: n, await: c });
+        a({ await: c, async: n });
+    }
+    expect_stdout: [
+        "Async undefined",
+        "undefined Await",
+        "Async Await",
+        "Async Await",
+        "Async undefined",
+        "undefined Await",
+        "Async Await",
+        "Async Await",
+    ]
+    node_version: ">=4"
+}
+
+async_arrow: {
+    input: {
+        let a1 = async x => await foo(x);
+        let a2 = async () => await bar();
+        let a3 = async (x) => await baz(x);
+        let a4 = async (x, y) => { await far(x, y); }
+        let a5 = async ({x = [1], y: z = 2}) => { await wow(x, z); }
+    }
+    expect: {
+        let a1 = async x => await foo(x);
+        let a2 = async () => await bar();
+        let a3 = async (x) => await baz(x);
+        let a4 = async (x, y) => { await far(x, y); }
+        let a5 = async ({x = [1], y: z = 2}) => { await wow(x, z); }
+    }
+}
+
+async_arrow_wait: {
+    input: {
+        var a = async (x, y) => await x(y);
+    }
+    expect_exact: "var a=async(x,y)=>await x(y);"
+}
+
+async_arrow_iife: {
+    input: {
+        (async () => {
+            await fetch({});
+        })();
+    }
+    expect_exact: "(async()=>{await fetch({})})();"
+}
+
+async_arrow_iife_negate_iife: {
+    options = {
+        negate_iife: true,
+    }
+    input: {
+        (async () => {
+            await fetch();
+        })();
+        (() => {
+            plain();
+        })();
+    }
+    expect_exact: "(async()=>{await fetch()})();(()=>{plain()})();"
+}
+
+issue_2344_1: {
+    beautify = {
+        safari10: false,
+    }
+    input: {
+        async () => {
+            +await x;
+            await y;
+            return await z;
+        };
+    }
+    expect_exact: "async()=>{+await x;await y;return await z};"
+}
+
+issue_2344_2: {
+    beautify = {
+        safari10: true,
+    }
+    input: {
+        async () => {
+            +await x;
+            await y;
+            return await z;
+        };
+    }
+    expect_exact: "async()=>{+(await x);await y;return await z};"
+}

test/compress/block-scope.js

@@ -41,7 +41,7 @@ do_not_remove_anon_blocks_if_they_have_decls: {
                 var x;
             }
             {
-                const y;
+                const y = 1;
                 class Zee {};
             }
         }
@@ -59,7 +59,7 @@ do_not_remove_anon_blocks_if_they_have_decls: {
             }
             var x;
             {
-                const y;
+                const y = 1;
                 class Zee {}
             }
         }
@@ -77,12 +77,12 @@ remove_unused_in_global_block: {
     input: {
         {
             let x;
-            const y;
+            const y = 1;
             class Zee {};
             var w;
         }
         let ex;
-        const why;
+        const why = 2;
         class Zed {};
         var wut;
         console.log(x, y, Zee);
@@ -90,7 +90,7 @@ remove_unused_in_global_block: {
     expect: {
         var w;
         let ex;
-        const why;
+        const why = 2;
         class Zed {};
         var wut;
         console.log(x, y, Zee);
@@ -104,34 +104,36 @@ regression_block_scope_resolves: {
     };
     input: {
         (function () {
-            if(1) {
+            if (1) {
                 let x;
-                const y;
+                const y = 1;
                 class Zee {};
             }
-            if(1) {
+            if (1) {
                 let ex;
-                const why;
+                const why = 2;
                 class Zi {};
             }
-            console.log(x, y, Zee, ex, why, Zi);
+            console.log(typeof x, typeof y, typeof Zee, typeof ex, typeof why, typeof Zi);
         }());
     }
     expect: {
         (function () {
             if (1) {
-                let o;
+                let e;
-                const n;
+                const o = 1;
-                class c {};
+                class t {};
             }
             if (1) {
-                let o;
+                let e;
-                const n;
+                const o = 2;
-                class c {};
+                class t {};
             }
-            console.log(x, y, Zee, ex, why, Zi);
+            console.log(typeof x, typeof y, typeof Zee, typeof ex, typeof why, typeof Zi);
         }());
     }
+    expect_stdout: "undefined undefined undefined undefined undefined undefined"
+    node_version: ">=6"
 }
 
 switch_block_scope_mangler: {
@@ -153,25 +155,37 @@ switch_block_scope_mangler: {
                     console.log(cat);
             }
         };
+        fn(1);
+        fn(2);
+        fn(3);
     }
     expect: {
-        var fn = function(o) {
+        var fn = function(e) {
-            switch (o) {
+            switch (e) {
               case 1:
-                let e = o + 1
+                let l = e + 1
-                let c = o + 4;
+                let o = e + 4;
-                console.log(e, c);
+                console.log(l, o);
                 break;
 
               case 2:
-                let l = o + 2;
+                let n = e + 2;
-                console.log(l);
+                console.log(n);
                 break;
 
               default:
-                let a = o + 3;
+                let c = e + 3;
-                console.log(a);
+                console.log(c);
             }
         };
+        fn(1);
+        fn(2);
+        fn(3);
     }
+    expect_stdout: [
+        "2 5",
+        "4",
+        "6",
+    ]
+    node_version: ">=6"
 }

test/compress/blocks.js

@@ -47,3 +47,143 @@ keep_some_blocks: {
         } else stuff();
     }
 }
+
+issue_1664: {
+    input: {
+        var a = 1;
+        function f() {
+            if (undefined) a = 2;
+            {
+                function undefined() {}
+                undefined();
+            }
+        }
+        f();
+        console.log(a);
+    }
+    expect: {
+        var a = 1;
+        function f() {
+            if (undefined) a = 2;
+            {
+                function undefined() {}
+                undefined();
+            }
+        }
+        f();
+        console.log(a);
+    }
+    expect_stdout: "1"
+    node_version: ">=6"
+    reminify: false // FIXME - block scoped function
+}
+
+issue_1672_for: {
+    input: {
+        switch (function() {
+            return xxx;
+        }) {
+          case xxx:
+            for (; console.log("FAIL");) {
+                function xxx() {}
+            }
+            break;
+        }
+    }
+    expect: {
+        switch (function() {
+            return xxx;
+        }) {
+          case xxx:
+            for (; console.log("FAIL");) {
+                function xxx() {}
+            }
+            break;
+        }
+    }
+    expect_stdout: true
+    node_version: ">=6"
+}
+
+issue_1672_for_strict: {
+    input: {
+        "use strict";
+        switch (function() {
+            return xxx;
+        }) {
+          case xxx:
+            for (; console.log("FAIL");) {
+                function xxx() {}
+            }
+            break;
+        }
+    }
+    expect: {
+        "use strict";
+        switch (function() {
+            return xxx;
+        }) {
+          case xxx:
+            for (; console.log("FAIL");) {
+                function xxx() {}
+            }
+            break;
+        }
+    }
+    expect_stdout: true
+    node_version: ">=6"
+}
+
+issue_1672_if: {
+    input: {
+        switch (function() {
+            return xxx;
+        }) {
+          case xxx:
+            if (console.log("FAIL")) {
+                function xxx() {}
+            }
+            break;
+        }
+    }
+    expect: {
+        switch (function() {
+            return xxx;
+        }) {
+          case xxx:
+            if (console.log("FAIL")) function xxx() {}
+            break;
+        }
+    }
+    expect_stdout: true
+    node_version: ">=6"
+}
+
+issue_1672_if_strict: {
+    input: {
+        "use strict";
+        switch (function() {
+            return xxx;
+        }) {
+          case xxx:
+            if (console.log("FAIL")) {
+                function xxx() {}
+            }
+            break;
+        }
+    }
+    expect: {
+        "use strict";
+        switch (function() {
+            return xxx;
+        }) {
+          case xxx:
+            if (console.log("FAIL")) {
+                function xxx() {}
+            }
+            break;
+        }
+    }
+    expect_stdout: true
+    node_version: ">=6"
+}

test/compress/comparing.js

@@ -74,3 +74,244 @@ dont_change_in_or_instanceof_expressions: {
         null instanceof null;
     }
 }
+
+self_comparison_1: {
+    options = {
+        comparisons: true,
+    }
+    input: {
+        a === a;
+        a !== b;
+        b.c === a.c;
+        b.c !== b.c;
+    }
+    expect: {
+        a == a;
+        a !== b;
+        b.c === a.c;
+        b.c != b.c;
+    }
+}
+
+self_comparison_2: {
+    options = {
+        comparisons: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+    }
+    input: {
+        function f() {}
+        var o = {};
+        console.log(f != f, o === o);
+    }
+    expect: {
+        function f() {}
+        var o = {};
+        console.log(false, true);
+    }
+    expect_stdout: "false true"
+}
+
+issue_2857_1: {
+    options = {
+        comparisons: true,
+    }
+    input: {
+        function f1(a) {
+            a === undefined || a === null;
+            a === undefined || a !== null;
+            a !== undefined || a === null;
+            a !== undefined || a !== null;
+            a === undefined && a === null;
+            a === undefined && a !== null;
+            a !== undefined && a === null;
+            a !== undefined && a !== null;
+        }
+        function f2(a) {
+            a === null || a === undefined;
+            a === null || a !== undefined;
+            a !== null || a === undefined;
+            a !== null || a !== undefined;
+            a === null && a === undefined;
+            a === null && a !== undefined;
+            a !== null && a === undefined;
+            a !== null && a !== undefined;
+        }
+    }
+    expect: {
+        function f1(a) {
+            null == a;
+            void 0 === a || null !== a;
+            void 0 !== a || null === a;
+            void 0 !== a || null !== a;
+            void 0 === a && null === a;
+            void 0 === a && null !== a;
+            void 0 !== a && null === a;
+            null != a;
+        }
+        function f2(a) {
+            null == a;
+            null === a || void 0 !== a;
+            null !== a || void 0 === a;
+            null !== a || void 0 !== a;
+            null === a && void 0 === a;
+            null === a && void 0 !== a;
+            null !== a && void 0 === a;
+            null != a;
+        }
+    }
+}
+
+issue_2857_2: {
+    options = {
+        comparisons: true,
+    }
+    input: {
+        function f(a, p) {
+            a === undefined || a === null || p;
+            a === undefined || a !== null || p;
+            a !== undefined || a === null || p;
+            a !== undefined || a !== null || p;
+            a === undefined && a === null || p;
+            a === undefined && a !== null || p;
+            a !== undefined && a === null || p;
+            a !== undefined && a !== null || p;
+        }
+    }
+    expect: {
+        function f(a, p) {
+            null == a || p;
+            void 0 === a || null !== a || p;
+            void 0 !== a || null === a || p;
+            void 0 !== a || null !== a || p;
+            void 0 === a && null === a || p;
+            void 0 === a && null !== a || p;
+            void 0 !== a && null === a || p;
+            null != a || p;
+        }
+    }
+}
+
+issue_2857_3: {
+    options = {
+        comparisons: true,
+    }
+    input: {
+        function f(a, p) {
+            a === undefined || a === null && p;
+            a === undefined || a !== null && p;
+            a !== undefined || a === null && p;
+            a !== undefined || a !== null && p;
+            a === undefined && a === null && p;
+            a === undefined && a !== null && p;
+            a !== undefined && a === null && p;
+            a !== undefined && a !== null && p;
+        }
+    }
+    expect: {
+        function f(a, p) {
+            void 0 === a || null === a && p;
+            void 0 === a || null !== a && p;
+            void 0 !== a || null === a && p;
+            void 0 !== a || null !== a && p;
+            void 0 === a && null === a && p;
+            void 0 === a && null !== a && p;
+            void 0 !== a && null === a && p;
+            null != a && p;
+        }
+    }
+}
+
+issue_2857_4: {
+    options = {
+        comparisons: true,
+    }
+    input: {
+        function f(a, p) {
+            p || a === undefined || a === null;
+            p || a === undefined || a !== null;
+            p || a !== undefined || a === null;
+            p || a !== undefined || a !== null;
+            p || a === undefined && a === null;
+            p || a === undefined && a !== null;
+            p || a !== undefined && a === null;
+            p || a !== undefined && a !== null;
+        }
+    }
+    expect: {
+        function f(a, p) {
+            p || null == a;
+            p || void 0 === a || null !== a;
+            p || void 0 !== a || null === a;
+            p || void 0 !== a || null !== a;
+            p || void 0 === a && null === a;
+            p || void 0 === a && null !== a;
+            p || void 0 !== a && null === a;
+            p || null != a;
+        }
+    }
+}
+
+issue_2857_5: {
+    options = {
+        comparisons: true,
+    }
+    input: {
+        function f(a, p) {
+            p && a === undefined || a === null;
+            p && a === undefined || a !== null;
+            p && a !== undefined || a === null;
+            p && a !== undefined || a !== null;
+            p && a === undefined && a === null;
+            p && a === undefined && a !== null;
+            p && a !== undefined && a === null;
+            p && a !== undefined && a !== null;
+        }
+    }
+    expect: {
+        function f(a, p) {
+            p && void 0 === a || null === a;
+            p && void 0 === a || null !== a;
+            p && void 0 !== a || null === a;
+            p && void 0 !== a || null !== a;
+            p && void 0 === a && null === a;
+            p && void 0 === a && null !== a;
+            p && void 0 !== a && null === a;
+            p && null != a;
+        }
+    }
+}
+
+issue_2857_6: {
+    options = {
+        comparisons: true,
+        pure_getters: "strict",
+        reduce_vars: true,
+    }
+    input: {
+        function f(a) {
+            if (({}).b === undefined || {}.b === null)
+                return a.b !== undefined && a.b !== null;
+        }
+        console.log(f({
+            a: [ null ],
+            get b() {
+                return this.a.shift();
+            }
+        }));
+    }
+    expect: {
+        function f(a) {
+            if (null == {}.b)
+                return void 0 !== a.b && null !== a.b;
+        }
+        console.log(f({
+            a: [ null ],
+            get b() {
+                return this.a.shift();
+            }
+        }));
+    }
+    expect_stdout: "true"
+}

test/compress/concat-strings.js

@@ -21,7 +21,7 @@ concat_1: {
         var c = 1 + x() + 2 + "boo";
         var d = 1 + x() + 2 + 3 + "boo";
         var e = 1 + x() + 2 + "X3boo";
-        var f = "\x00360\08\0";
+        var f = "\x00360\x008\0";
     }
 }
 

test/compress/conditionals.js

@@ -166,22 +166,24 @@ cond_1: {
         conditionals: true
     };
     input: {
-        var do_something; // if undeclared it's assumed to have side-effects
+        function foo(do_something, some_condition) {
-        if (some_condition()) {
+            if (some_condition) {
-            do_something(x);
+                do_something(x);
-        } else {
+            } else {
-            do_something(y);
+                do_something(y);
-        }
+            }
-        if (some_condition()) {
+            if (some_condition) {
-            side_effects(x);
+                side_effects(x);
-        } else {
+            } else {
-            side_effects(y);
+                side_effects(y);
+            }
         }
     }
     expect: {
-        var do_something;
+        function foo(do_something, some_condition) {
-        do_something(some_condition() ? x : y);
+            do_something(some_condition ? x : y);
-        some_condition() ? side_effects(x) : side_effects(y);
+            some_condition ? side_effects(x) : side_effects(y);
+        }
     }
 }
 
@@ -190,16 +192,18 @@ cond_2: {
         conditionals: true
     };
     input: {
-        var x, FooBar;
+        function foo(x, FooBar, some_condition) {
-        if (some_condition()) {
+            if (some_condition) {
-            x = new FooBar(1);
+                x = new FooBar(1);
-        } else {
+            } else {
-            x = new FooBar(2);
+                x = new FooBar(2);
+            }
         }
     }
     expect: {
-        var x, FooBar;
+        function foo(x, FooBar, some_condition) {
-        x = new FooBar(some_condition() ? 1 : 2);
+            x = new FooBar(some_condition ? 1 : 2);
+        }
     }
 }
 
@@ -605,11 +609,47 @@ cond_8c: {
     }
 }
 
+cond_9: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        function f(x, y) {
+            g() ? x(1) : x(2);
+            x ? (y || x)() : (y || x)();
+            x ? y(a, b) : y(d, b, c);
+            x ? y(a, b, c) : y(a, b, c);
+            x ? y(a, b, c) : y(a, b, f);
+            x ? y(a, b, c) : y(a, e, c);
+            x ? y(a, b, c) : y(a, e, f);
+            x ? y(a, b, c) : y(d, b, c);
+            x ? y(a, b, c) : y(d, b, f);
+            x ? y(a, b, c) : y(d, e, c);
+            x ? y(a, b, c) : y(d, e, f);
+        }
+    }
+    expect: {
+        function f(x, y) {
+            g() ? x(1) : x(2);
+            x, (y || x)();
+            x ? y(a, b) : y(d, b, c);
+            x, y(a, b, c);
+            y(a, b, x ? c : f);
+            y(a, x ? b : e, c);
+            x ? y(a, b, c) : y(a, e, f);
+            y(x ? a : d, b, c);
+            x ? y(a, b, c) : y(d, b, f);
+            x ? y(a, b, c) : y(d, e, c);
+            x ? y(a, b, c) : y(d, e, f);
+        }
+    }
+}
+
 ternary_boolean_consequent: {
     options = {
         collapse_vars:true, sequences:true, properties:true, dead_code:true, conditionals:true,
         comparisons:true, evaluate:true, booleans:true, loops:true, unused:true, hoist_funs:true,
-        keep_fargs:true, if_return:true, join_vars:true, cascade:true, side_effects:true
+        keep_fargs:true, if_return:true, join_vars:true, side_effects:true
     }
     input: {
         function f1() { return a == b ? true : x; }
@@ -637,7 +677,7 @@ ternary_boolean_alternative: {
     options = {
         collapse_vars:true, sequences:true, properties:true, dead_code:true, conditionals:true,
         comparisons:true, evaluate:true, booleans:true, loops:true, unused:true, hoist_funs:true,
-        keep_fargs:true, if_return:true, join_vars:true, cascade:true, side_effects:true
+        keep_fargs:true, if_return:true, join_vars:true, side_effects:true
     }
     input: {
         function f1() { return a == b ? x : true; }
@@ -1015,3 +1055,215 @@ delete_conditional_2: {
     }
     expect_stdout: true
 }
+
+issue_2535_1: {
+    options = {
+        booleans: true,
+        conditionals: true,
+        evaluate: true,
+        passes: 2,
+        side_effects: true,
+    }
+    input: {
+        if (true || x()) y();
+        if (true && x()) y();
+        if (x() || true) y();
+        if (x() && true) y();
+        if (false || x()) y();
+        if (false && x()) y();
+        if (x() || false) y();
+        if (x() && false) y();
+    }
+    expect: {
+        y();
+        x() && y();
+        (x(), 1) && y();
+        x() && y();
+        x() && y();
+        x() && y();
+        (x(), 0) && y();
+    }
+}
+
+issue_2535_2: {
+    options = {
+        booleans: true,
+        conditionals: true,
+        evaluate: true,
+        side_effects: true,
+    }
+    input: {
+        function x() {}
+        function y() {
+            return "foo";
+        }
+        console.log((x() || true) || y());
+        console.log((y() || true) || x());
+        console.log((x() || true) && y());
+        console.log((y() || true) && x());
+        console.log((x() && true) || y());
+        console.log((y() && true) || x());
+        console.log((x() && true) && y());
+        console.log((y() && true) && x());
+        console.log((x() || false) || y());
+        console.log((y() || false) || x());
+        console.log((x() || false) && y());
+        console.log((y() || false) && x());
+        console.log((x() && false) || y());
+        console.log((y() && false) || x());
+        console.log((x() && false) && y());
+        console.log((y() && false) && x());
+    }
+    expect: {
+        function x() {}
+        function y() {
+            return "foo";
+        }
+        console.log(x() || !0);
+        console.log(y() || !0);
+        console.log((x(), y()));
+        console.log((y(), x()));
+        console.log(!!x() || y());
+        console.log(!!y() || x());
+        console.log(x() && y());
+        console.log(y() && x());
+        console.log(x() || y());
+        console.log(y() || x());
+        console.log(!!x() && y());
+        console.log(!!y() && x());
+        console.log((x(), y()));
+        console.log((y(), x()));
+        console.log(x() && !1);
+        console.log(y() && !1);
+    }
+    expect_stdout: [
+        "true",
+        "foo",
+        "foo",
+        "undefined",
+        "foo",
+        "true",
+        "undefined",
+        "undefined",
+        "foo",
+        "foo",
+        "false",
+        "undefined",
+        "foo",
+        "undefined",
+        "undefined",
+        "false",
+    ]
+}
+
+issue_2560: {
+    options = {
+        conditionals: true,
+        inline: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function log(x) {
+            console.log(x);
+        }
+        function foo() {
+            return log;
+        }
+        function bar() {
+            if (x !== (x = foo())) {
+                x(1);
+            } else {
+                x(2);
+            }
+        }
+        var x = function() {
+            console.log("init");
+        };
+        bar();
+        bar();
+    }
+    expect: {
+        function log(x) {
+            console.log(x);
+        }
+        function bar() {
+            x !== (x = log) ? x(1) : x(2);
+        }
+        var x = function() {
+            console.log("init");
+        };
+        bar();
+        bar();
+    }
+    expect_stdout: [
+        "1",
+        "2",
+    ]
+}
+
+hoist_decl: {
+    options = {
+        conditionals: true,
+        join_vars: true,
+        sequences: true,
+    }
+    input: {
+        if (x()) {
+            var a;
+            y();
+        } else {
+            z();
+            var b;
+        }
+    }
+    expect: {
+        var a, b;
+        x() ? y() : z();
+    }
+}
+
+to_and_or: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        var values = [
+            0,
+            null,
+            true,
+            "foo",
+            false,
+            -1 / 0,
+            void 0,
+        ];
+        values.forEach(function(x) {
+            values.forEach(function(y) {
+                values.forEach(function(z) {
+                    console.log(x ? y || z : z);
+                });
+            });
+        });
+    }
+    expect: {
+        var values = [
+            0,
+            null,
+            true,
+            "foo",
+            false,
+            -1 / 0,
+            void 0,
+        ];
+        values.forEach(function(x) {
+            values.forEach(function(y) {
+                values.forEach(function(z) {
+                    console.log(x && y || z);
+                });
+            });
+        });
+    }
+    expect_stdout: true
+}

test/compress/const.js

@@ -12,6 +12,7 @@ issue_1191: {
         join_vars     : true,
         sequences     : false,
         collapse_vars : false,
+        reduce_funcs  : true,
         reduce_vars   : true,
     }
     input: {
@@ -44,6 +45,7 @@ issue_1194: {
         join_vars     : true,
         sequences     : false,
         collapse_vars : false,
+        reduce_funcs  : true,
         reduce_vars   : true,
     }
     input: {
@@ -72,6 +74,7 @@ issue_1396: {
         join_vars     : true,
         sequences     : false,
         collapse_vars : false,
+        reduce_funcs  : true,
         reduce_vars   : true,
     }
     input: {
@@ -143,6 +146,7 @@ regexp_literal_not_const: {
         join_vars     : true,
         sequences     : false,
         collapse_vars : false,
+        reduce_funcs  : true,
         reduce_vars   : true,
     }
     input: {

test/compress/dead-code.js

@@ -60,6 +60,7 @@ dead_code_2_should_warn: {
     }
     expect_stdout: true
     node_version: ">=6"
+    reminify: false // FIXME - block scoped function
 }
 
 dead_code_2_should_warn_strict: {
@@ -100,6 +101,7 @@ dead_code_2_should_warn_strict: {
     }
     expect_stdout: true
     node_version: ">=4"
+    reminify: false // FIXME - block scoped function
 }
 
 dead_code_constant_boolean_should_warn_more: {
@@ -129,12 +131,13 @@ dead_code_constant_boolean_should_warn_more: {
         var bar;
         // nothing for the while
         // as for the for, it should keep:
-        var x = 10, y;
         var moo;
+        var x = 10, y;
         bar();
     }
     expect_stdout: true
     node_version: ">=6"
+    reminify: false // FIXME - block scoped function
 }
 
 dead_code_constant_boolean_should_warn_more_strict: {
@@ -165,20 +168,22 @@ dead_code_constant_boolean_should_warn_more_strict: {
         var foo;
         // nothing for the while
         // as for the for, it should keep:
-        var x = 10, y;
         var moo;
+        var x = 10, y;
         bar();
     }
     expect_stdout: true
     node_version: ">=4"
+    reminify: false // FIXME - block scoped function
 }
 
 dead_code_block_decls_die: {
     options = {
-        dead_code    : true,
+        booleans: true,
-        conditionals : true,
+        conditionals: true,
-        booleans     : true,
+        dead_code: true,
-        evaluate     : true
+        evaluate: true,
+        side_effects: true,
     };
     input: {
         if (0) {
@@ -197,12 +202,14 @@ dead_code_block_decls_die: {
 
 dead_code_const_declaration: {
     options = {
-        dead_code    : true,
+        booleans: true,
-        loops        : true,
+        conditionals: true,
-        booleans     : true,
+        dead_code: true,
-        conditionals : true,
+        evaluate: true,
-        evaluate     : true,
+        loops: true,
-        reduce_vars  : true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        side_effects: true,
     };
     input: {
         var unused;
@@ -224,13 +231,15 @@ dead_code_const_declaration: {
 
 dead_code_const_annotation: {
     options = {
-        dead_code    : true,
+        booleans: true,
-        loops        : true,
+        conditionals: true,
-        booleans     : true,
+        dead_code: true,
-        conditionals : true,
+        evaluate: true,
-        evaluate     : true,
+        loops: true,
-        reduce_vars  : true,
+        reduce_funcs: true,
-        toplevel     : true,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
     };
     input: {
         var unused;
@@ -276,13 +285,16 @@ dead_code_const_annotation_regex: {
 
 dead_code_const_annotation_complex_scope: {
     options = {
-        dead_code    : true,
+        booleans: true,
-        loops        : true,
+        conditionals: true,
-        booleans     : true,
+        dead_code: true,
-        conditionals : true,
+        evaluate: true,
-        evaluate     : true,
+        loops: true,
-        reduce_vars  : true,
+        reduce_funcs: true,
-        toplevel     : true,
+        reduce_vars: true,
+        sequences: true,
+        side_effects: true,
+        toplevel: true,
     };
     input: {
         var unused_var;
@@ -325,6 +337,8 @@ try_catch_finally: {
         conditionals: true,
         dead_code: true,
         evaluate: true,
+        passes: 2,
+        side_effects: true,
     }
     input: {
         var a = 1;
@@ -377,3 +391,828 @@ accessor: {
     }
     expect: {}
 }
+
+issue_2233_1: {
+    options = {
+        pure_getters: "strict",
+        side_effects: true,
+        unsafe: true,
+    }
+    input: {
+        Array.isArray;
+        Boolean;
+        console.log;
+        Date;
+        decodeURI;
+        decodeURIComponent;
+        encodeURI;
+        encodeURIComponent;
+        Error.name;
+        escape;
+        eval;
+        EvalError;
+        Function.length;
+        isFinite;
+        isNaN;
+        JSON;
+        Math.random;
+        Number.isNaN;
+        parseFloat;
+        parseInt;
+        RegExp;
+        Object.defineProperty;
+        String.fromCharCode;
+        RangeError;
+        ReferenceError;
+        SyntaxError;
+        TypeError;
+        unescape;
+        URIError;
+    }
+    expect: {}
+    expect_stdout: true
+}
+
+global_timeout_and_interval_symbols: {
+    options = {
+        pure_getters: "strict",
+        side_effects: true,
+        unsafe: true,
+    }
+    input: {
+        // These global symbols do not exist in the test sandbox
+        // and must be tested separately.
+        clearInterval;
+        clearTimeout;
+        setInterval;
+        setTimeout;
+    }
+    expect: {}
+}
+
+issue_2233_2: {
+    options = {
+        pure_getters: "strict",
+        reduce_funcs: true,
+        reduce_vars: true,
+        side_effects: true,
+        unsafe: true,
+        unused: true,
+    }
+    input: {
+        var RegExp;
+        Array.isArray;
+        RegExp;
+        UndeclaredGlobal;
+        function foo() {
+            var Number;
+            AnotherUndeclaredGlobal;
+            Math.sin;
+            Number.isNaN;
+        }
+    }
+    expect: {
+        var RegExp;
+        UndeclaredGlobal;
+        function foo() {
+            var Number;
+            AnotherUndeclaredGlobal;
+            Number.isNaN;
+        }
+    }
+}
+
+issue_2233_3: {
+    options = {
+        pure_getters: "strict",
+        reduce_funcs: true,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unsafe: true,
+        unused: true,
+    }
+    input: {
+        var RegExp;
+        Array.isArray;
+        RegExp;
+        UndeclaredGlobal;
+        function foo() {
+            var Number;
+            AnotherUndeclaredGlobal;
+            Math.sin;
+            Number.isNaN;
+        }
+    }
+    expect: {
+        UndeclaredGlobal;
+    }
+}
+
+global_fns: {
+    options = {
+        side_effects: true,
+        unsafe: true,
+    }
+    input: {
+        Boolean(1, 2);
+        decodeURI(1, 2);
+        decodeURIComponent(1, 2);
+        Date(1, 2);
+        encodeURI(1, 2);
+        encodeURIComponent(1, 2);
+        Error(1, 2);
+        escape(1, 2);
+        EvalError(1, 2);
+        isFinite(1, 2);
+        isNaN(1, 2);
+        Number(1, 2);
+        Object(1, 2);
+        parseFloat(1, 2);
+        parseInt(1, 2);
+        RangeError(1, 2);
+        ReferenceError(1, 2);
+        String(1, 2);
+        SyntaxError(1, 2);
+        TypeError(1, 2);
+        unescape(1, 2);
+        URIError(1, 2);
+        try {
+            Function(1, 2);
+        } catch (e) {
+            console.log(e.name);
+        }
+        try {
+            RegExp(1, 2);
+        } catch (e) {
+            console.log(e.name);
+        }
+        try {
+            Array(NaN);
+        } catch (e) {
+            console.log(e.name);
+        }
+    }
+    expect: {
+        try {
+            Function(1, 2);
+        } catch (e) {
+            console.log(e.name);
+        }
+        try {
+            RegExp(1, 2);
+        } catch (e) {
+            console.log(e.name);
+        }
+        try {
+            Array(NaN);
+        } catch (e) {
+            console.log(e.name);
+        }
+    }
+    expect_stdout: [
+        "SyntaxError",
+        "SyntaxError",
+        "RangeError",
+    ]
+}
+
+issue_2383_1: {
+    options = {
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        side_effects: true,
+    }
+    input: {
+        if (0) {
+            var {x, y} = foo();
+        }
+    }
+    expect: {
+        var x, y;
+    }
+}
+
+issue_2383_2: {
+    options = {
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        side_effects: true,
+    }
+    input: {
+        if (0) {
+            var {
+                x = 0,
+                y: [ w, , { z, p: q = 7 } ] = [ 1, 2, { z: 3 } ]
+            } = {};
+        }
+        console.log(x, q, w, z);
+    }
+    expect: {
+        var x, w, z, q;
+        console.log(x, q, w, z);
+    }
+    expect_stdout: "undefined undefined undefined undefined"
+    node_version: ">=6"
+}
+
+issue_2383_3: {
+    options = {
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        side_effects: true,
+    }
+    input: {
+        var b = 7, y = 8;
+        if (0) {
+            var a = 1, [ x, y, z ] = [ 2, 3, 4 ], b = 5;
+        }
+        console.log(a, x, y, z, b);
+    }
+    expect: {
+        var b = 7, y = 8;
+        var a, x, y, z, b;
+        console.log(a, x, y, z, b);
+    }
+    expect_stdout: "undefined undefined 8 undefined 7"
+    node_version: ">=6"
+}
+
+collapse_vars_assignment: {
+    options = {
+        collapse_vars: true,
+        dead_code: true,
+        passes: 2,
+        unused: true,
+    }
+    input: {
+        function f0(c) {
+            var a = 3 / c;
+            return a = a;
+        }
+    }
+    expect: {
+        function f0(c) {
+            return 3 / c;
+        }
+    }
+}
+
+collapse_vars_lvalues_drop_assign: {
+    options = {
+        collapse_vars: true,
+        dead_code: true,
+        unused: true,
+    }
+    input: {
+        function f0(x) { var i = ++x; return x += i; }
+        function f1(x) { var a = (x -= 3); return x += a; }
+        function f2(x) { var z = x, a = ++z; return z += a; }
+    }
+    expect: {
+        function f0(x) { var i = ++x; return x + i; }
+        function f1(x) { var a = (x -= 3); return x + a; }
+        function f2(x) { var z = x, a = ++z; return z + a; }
+    }
+}
+
+collapse_vars_misc1: {
+    options = {
+        collapse_vars: true,
+        dead_code: true,
+        unused: true,
+    }
+    input: {
+        function f10(x) { var a = 5, b = 3; return a += b; }
+        function f11(x) { var a = 5, b = 3; return a += --b; }
+    }
+    expect: {
+        function f10(x) { return 5 + 3; }
+        function f11(x) { var b = 3; return 5 + --b; }
+    }
+}
+
+return_assignment: {
+    options = {
+        dead_code: true,
+        unused: true,
+    }
+    input: {
+        function f1(a, b, c) {
+            return a = x(), b = y(), b = a && (c >>= 5);
+        }
+        function f2() {
+            return e = x();
+        }
+        function f3(e) {
+            return e = x();
+        }
+        function f4() {
+            var e;
+            return e = x();
+        }
+        function f5(a) {
+            try {
+                return a = x();
+            } catch (b) {
+                console.log(a);
+            }
+        }
+        function f6(a) {
+            try {
+                return a = x();
+            } finally {
+                console.log(a);
+            }
+        }
+        function y() {
+            console.log("y");
+        }
+        function test(inc) {
+            var counter = 0;
+            x = function() {
+                counter += inc;
+                if (inc < 0) throw counter;
+                return counter;
+            };
+            [ f1, f2, f3, f4, f5, f6 ].forEach(function(f, i) {
+                e = null;
+                try {
+                    i += 1;
+                    console.log("result " + f(10 * i, 100 * i, 1000 * i));
+                } catch (x) {
+                    console.log("caught " + x);
+                }
+                if (null !== e) console.log("e: " + e);
+            });
+        }
+        var x, e;
+        test(1);
+        test(-1);
+    }
+    expect: {
+        function f1(a, b, c) {
+            return a = x(), y(), a && (c >> 5);
+        }
+        function f2() {
+            return e = x();
+        }
+        function f3(e) {
+            return x();
+        }
+        function f4() {
+            return x();
+        }
+        function f5(a) {
+            try {
+                return x();
+            } catch (b) {
+                console.log(a);
+            }
+        }
+        function f6(a) {
+            try {
+                return a = x();
+            } finally {
+                console.log(a);
+            }
+        }
+        function y() {
+            console.log("y");
+        }
+        function test(inc) {
+            var counter = 0;
+            x = function() {
+                counter += inc;
+                if (inc < 0) throw counter;
+                return counter;
+            };
+            [ f1, f2, f3, f4, f5, f6 ].forEach(function(f, i) {
+                e = null;
+                try {
+                    i += 1;
+                    console.log("result " + f(10 * i, 100 * i, 1000 * i));
+                } catch (x) {
+                    console.log("caught " + x);
+                }
+                if (null !== e) console.log("e: " + e);
+            });
+        }
+        var x, e;
+        test(1);
+        test(-1);
+    }
+    expect_stdout: [
+        "y",
+        "result 31",
+        "result 2",
+        "e: 2",
+        "result 3",
+        "result 4",
+        "result 5",
+        "6",
+        "result 6",
+        "caught -1",
+        "caught -2",
+        "caught -3",
+        "caught -4",
+        "50",
+        "result undefined",
+        "60",
+        "caught -6",
+    ]
+}
+
+throw_assignment: {
+    options = {
+        dead_code: true,
+        unused: true,
+    }
+    input: {
+        function f1() {
+            throw a = x();
+        }
+        function f2(a) {
+            throw a = x();
+        }
+        function f3() {
+            var a;
+            throw a = x();
+        }
+        function f4() {
+            try {
+                throw a = x();
+            } catch (b) {
+                console.log(a);
+            }
+        }
+        function f5(a) {
+            try {
+                throw a = x();
+            } catch (b) {
+                console.log(a);
+            }
+        }
+        function f6() {
+            var a;
+            try {
+                throw a = x();
+            } catch (b) {
+                console.log(a);
+            }
+        }
+        function f7() {
+            try {
+                throw a = x();
+            } finally {
+                console.log(a);
+            }
+        }
+        function f8(a) {
+            try {
+                throw a = x();
+            } finally {
+                console.log(a);
+            }
+        }
+        function f9() {
+            var a;
+            try {
+                throw a = x();
+            } finally {
+                console.log(a);
+            }
+        }
+        function test(inc) {
+            var counter = 0;
+            x = function() {
+                counter += inc;
+                if (inc < 0) throw counter;
+                return counter;
+            };
+            [ f1, f2, f3, f4, f5, f6, f7, f8, f9 ].forEach(function(f, i) {
+                a = null;
+                try {
+                    f(10 * (1 + i));
+                } catch (x) {
+                    console.log("caught " + x);
+                }
+                if (null !== a) console.log("a: " + a);
+            });
+        }
+        var x, a;
+        test(1);
+        test(-1);
+    }
+    expect: {
+        function f1() {
+            throw a = x();
+        }
+        function f2(a) {
+            throw x();
+        }
+        function f3() {
+            throw x();
+        }
+        function f4() {
+            try {
+                throw a = x();
+            } catch (b) {
+                console.log(a);
+            }
+        }
+        function f5(a) {
+            try {
+                throw a = x();
+            } catch (b) {
+                console.log(a);
+            }
+        }
+        function f6() {
+            var a;
+            try {
+                throw a = x();
+            } catch (b) {
+                console.log(a);
+            }
+        }
+        function f7() {
+            try {
+                throw a = x();
+            } finally {
+                console.log(a);
+            }
+        }
+        function f8(a) {
+            try {
+                throw a = x();
+            } finally {
+                console.log(a);
+            }
+        }
+        function f9() {
+            var a;
+            try {
+                throw a = x();
+            } finally {
+                console.log(a);
+            }
+        }
+        function test(inc) {
+            var counter = 0;
+            x = function() {
+                counter += inc;
+                if (inc < 0) throw counter;
+                return counter;
+            };
+            [ f1, f2, f3, f4, f5, f6, f7, f8, f9 ].forEach(function(f, i) {
+                a = null;
+                try {
+                    f(10 * (1 + i));
+                } catch (x) {
+                    console.log("caught " + x);
+                }
+                if (null !== a) console.log("a: " + a);
+            });
+        }
+        var x, a;
+        test(1);
+        test(-1);
+    }
+    expect_stdout: [
+        "caught 1",
+        "a: 1",
+        "caught 2",
+        "caught 3",
+        "4",
+        "a: 4",
+        "5",
+        "6",
+        "7",
+        "caught 7",
+        "a: 7",
+        "8",
+        "caught 8",
+        "9",
+        "caught 9",
+        "caught -1",
+        "caught -2",
+        "caught -3",
+        "null",
+        "50",
+        "undefined",
+        "null",
+        "caught -7",
+        "80",
+        "caught -8",
+        "undefined",
+        "caught -9",
+    ]
+}
+
+issue_2597: {
+    options = {
+        dead_code: true,
+    }
+    input: {
+        function f(b) {
+            try {
+                try {
+                    throw "foo";
+                } catch (e) {
+                    return b = true;
+                }
+            } finally {
+                b && (a = "PASS");
+            }
+        }
+        var a = "FAIL";
+        f();
+        console.log(a);
+    }
+    expect: {
+        function f(b) {
+            try {
+                try {
+                    throw "foo";
+                } catch (e) {
+                    return b = true;
+                }
+            } finally {
+                b && (a = "PASS");
+            }
+        }
+        var a = "FAIL";
+        f();
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_2666: {
+    options = {
+        dead_code: true,
+    }
+    input: {
+        function f(a) {
+            return a = {
+                p: function() {
+                    return a;
+                }
+            };
+        }
+        console.log(typeof f().p());
+    }
+    expect: {
+        function f(a) {
+            return a = {
+                p: function() {
+                    return a;
+                }
+            };
+        }
+        console.log(typeof f().p());
+    }
+    expect_stdout: "object"
+}
+
+issue_2692: {
+    options = {
+        dead_code: true,
+        reduce_vars: false,
+    }
+    input: {
+        function f(a) {
+            return a = g;
+            function g() {
+                return a;
+            }
+        }
+        console.log(typeof f()());
+    }
+    expect: {
+        function f(a) {
+            return a = g;
+            function g() {
+                return a;
+            }
+        }
+        console.log(typeof f()());
+    }
+    expect_stdout: "function"
+}
+
+issue_2701: {
+    options = {
+        dead_code: true,
+        inline: false,
+    }
+    input: {
+        function f(a) {
+            return a = function() {
+                return function() {
+                    return a;
+                };
+            }();
+        }
+        console.log(typeof f()());
+    }
+    expect: {
+        function f(a) {
+            return a = function() {
+                return function() {
+                    return a;
+                };
+            }();
+        }
+        console.log(typeof f()());
+    }
+    expect_stdout: "function"
+}
+
+issue_2749: {
+    options = {
+        dead_code: true,
+        inline: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = 2, c = "PASS";
+        while (a--)
+            (function() {
+                return b ? c = "FAIL" : b = 1;
+                try {
+                } catch (b) {
+                    var b;
+                }
+            })();
+        console.log(c);
+    }
+    expect: {
+        var a = 2, c = "PASS";
+        while (a--)
+            b = void 0, b ? c = "FAIL" : b = 1;
+        var b;
+        console.log(c);
+    }
+    expect_stdout: "PASS"
+}
+
+unsafe_builtin: {
+    options = {
+        side_effects: true,
+        unsafe: true,
+    }
+    input: {
+        (!w).constructor(x);
+        Math.abs(y);
+        [ 1, 2, z ].valueOf();
+    }
+    expect: {
+        w, x;
+        y;
+        z;
+    }
+}
+
+issue_2860_1: {
+    options = {
+        dead_code: true,
+        evaluate: true,
+        reduce_vars: true,
+    }
+    input: {
+        console.log(function(a) {
+            return a ^= 1;
+        }());
+    }
+    expect: {
+        console.log(function(a) {
+            return 1 ^ a;
+        }());
+    }
+    expect_stdout: "1"
+}
+
+issue_2860_2: {
+    options = {
+        dead_code: true,
+        evaluate: true,
+        inline: true,
+        passes: 2,
+        reduce_vars: true,
+    }
+    input: {
+        console.log(function(a) {
+            return a ^= 1;
+        }());
+    }
+    expect: {
+        console.log(1);
+    }
+    expect_stdout: "1"
+}

test/compress/destructuring.js

@@ -65,10 +65,10 @@ nested_destructuring_objects: {
     }
     input: {
         const [{a},b] = c;
-        let [{a},b] = c;
+        let [{d},e] = f;
-        var [{a},b] = c;
+        var [{g},h] = i;
     }
-    expect_exact: 'const[{a},b]=c;let[{a},b]=c;var[{a},b]=c;';
+    expect_exact: 'const[{a},b]=c;let[{d},e]=f;var[{g},h]=i;';
 }
 
 destructuring_constdef_in_loops: {
@@ -262,6 +262,7 @@ destructuring_dont_evaluate_with_undefined_as_default_assignment: {
 
 reduce_vars: {
     options = {
+        reduce_funcs: true,
         reduce_vars: true,
     }
     input: {
@@ -274,8 +275,8 @@ reduce_vars: {
         var {aa, bb: {cc, dd}} = {aa:1, bb: {cc:2, dd: 3}};
         ({aa, bb: {cc, dd}} = {aa:1, bb: {cc:2, dd: 3}});
         const [{a},b] = c;
-        let [{a},b] = c;
+        let [{d},e] = f;
-        var [{a},b] = c;
+        var [{g},h] = i;
         [{a},b] = c;
         for (const [x,y] in pairs);
         for (let [x,y] in pairs);
@@ -292,8 +293,8 @@ reduce_vars: {
         var {aa, bb: {cc, dd}} = {aa:1, bb: {cc:2, dd: 3}};
         ({aa, bb: {cc, dd}} = {aa:1, bb: {cc:2, dd: 3}});
         const [{a},b] = c;
-        let [{a},b] = c;
+        let [{d},e] = f;
-        var [{a},b] = c;
+        var [{g},h] = i;
         [{a},b] = c;
         for (const [x,y] in pairs);
         for (let [x,y] in pairs);
@@ -425,8 +426,8 @@ mangle_destructuring_decl: {
     expect: {
         function test(t) {
             let e = t.a || { e: 7, n: 8 };
-            let {t: n,  e: o,  n: s,  s: a = 9,  o: c,  r: l} = e;
+            let {t: n,  e: o,  n: s,  s: l = 9,  o: a,  r: c} = e;
-            console.log(n, o, s, a, c, l);
+            console.log(n, o, s, l, a, c);
         }
         test({ a: { t: 1, e: 2, n: 3, s: 4, o: 5, r: 6 } });
         test({});
@@ -462,15 +463,15 @@ mangle_destructuring_assign_toplevel_true: {
         test({});
     }
     expect: {
-        function n(n) {
+        function e(e) {
-            let t, a, c;
+            let l, s, a;
-            let l = n.a || { e: 7, n: 8 };
+            let c = e.a || { e: 7, n: 8 };
-            ({t: o,  e,  n: s,  s: t = 9,  o: a,  r: c} = l);
+            ({t: n,  e: o,  n: t,  s: l = 9,  o: s,  r: a} = c);
-            console.log(o, e, s, t, a, c);
+            console.log(n, o, t, l, s, a);
         }
-        let o, e, s;
+        let n, o, t;
-        n({ a: { t: 1, e: 2, n: 3, s: 4, o: 5, r: 6 } });
+        e({ a: { t: 1, e: 2, n: 3, s: 4, o: 5, r: 6 } });
-        n({});
+        e({});
     }
     expect_stdout: [
         "1 2 3 4 5 6",
@@ -504,10 +505,10 @@ mangle_destructuring_assign_toplevel_false: {
     }
     expect: {
         function test(o) {
-            let s, a, c;
+            let s, l, a;
-            let l = o.a || { e: 7, n: 8 };
+            let c = o.a || { e: 7, n: 8 };
-            ({t,  e,  n,  s = 9,  o: a,  r: c} = l);
+            ({t,  e,  n,  s = 9,  o: l,  r: a} = c);
-            console.log(t, e, n, s, a, c);
+            console.log(t, e, n, s, l, a);
         }
         let t, e, n;
         test({ a: { t: 1, e: 2, n: 3, s: 4, o: 5, r: 6 } });
@@ -543,3 +544,119 @@ mangle_destructuring_decl_array: {
     expect_stdout: "8 7 6 undefined 2 [ 3 ]"
     node_version: ">=6"
 }
+
+anon_func_with_destructuring_args: {
+    options = {
+        evaluate: true,
+        unused: true,
+        toplevel: true,
+    }
+    mangle = {
+        toplevel: true,
+    }
+    beautify = {
+        ecma: 5,
+    }
+    input: {
+        (function({foo = 1 + 0, bar = 2}, [car = 3, far = 4]) {
+            console.log(foo, bar, car, far);
+        })({bar: 5 - 0}, [, 6]);
+    }
+    expect: {
+        (function({foo: o = 1, bar: n = 2}, [a = 3, b = 4]) {
+            console.log(o, n, a, b);
+        })({bar: 5}, [, 6]);
+    }
+    expect_stdout: "1 5 3 6"
+    node_version: ">=6"
+}
+
+arrow_func_with_destructuring_args: {
+    options = {
+        evaluate: true,
+        unused: true,
+        toplevel: true,
+    }
+    mangle = {
+        toplevel: true,
+    }
+    beautify = {
+        ecma: 5,
+    }
+    input: {
+        (({foo = 1 + 0, bar = 2}, [car = 3, far = 4]) => {
+            console.log(foo, bar, car, far);
+        })({bar: 5 - 0}, [, 6]);
+    }
+    expect: {
+        (({foo: o = 1, bar: a = 2}, [b = 3, l = 4]) => {
+            console.log(o, a, b, l);
+        })({bar: 5}, [, 6]);
+    }
+    expect_stdout: "1 5 3 6"
+    node_version: ">=6"
+}
+
+issue_2044_ecma_5: {
+    beautify = {
+        beautify: false,
+        ecma: 5,
+    }
+    input: {
+        ({x : a = 1, y = 2 + b, z = 3 - c} = obj);
+    }
+    expect_exact: "({x:a=1,y:y=2+b,z:z=3-c}=obj);"
+}
+
+issue_2044_ecma_6: {
+    beautify = {
+        beautify: false,
+        ecma: 6,
+    }
+    input: {
+        ({x : a = 1, y = 2 + b, z = 3 - c} = obj);
+    }
+    expect_exact: "({x:a=1,y=2+b,z=3-c}=obj);"
+}
+
+issue_2044_ecma_5_beautify: {
+    beautify = {
+        beautify: true,
+        ecma: 5,
+    }
+    input: {
+        ({x : a = 1, y = 2 + b, z = 3 - c} = obj);
+    }
+    expect_exact: "({x: a = 1, y: y = 2 + b, z: z = 3 - c} = obj);"
+}
+
+issue_2044_ecma_6_beautify: {
+    beautify = {
+        beautify: true,
+        ecma: 6,
+    }
+    input: {
+        ({x : a = 1, y = 2 + b, z = 3 - c} = obj);
+    }
+    expect_exact: "({x: a = 1, y = 2 + b, z = 3 - c} = obj);"
+}
+
+issue_2140: {
+    options = {
+        unused: true,
+    }
+    input: {
+        !function() {
+            var t = {};
+            console.log(([t.a] = [42])[0]);
+        }();
+    }
+    expect: {
+        !function() {
+            var t = {};
+            console.log(([t.a] = [42])[0]);
+        }();
+    }
+    expect_stdout: "42"
+    node_version: ">=6"
+}

test/compress/evaluate.js

@@ -1,6 +1,7 @@
 and: {
     options = {
-        evaluate: true
+        evaluate: true,
+        side_effects: true,
     }
     input: {
         var a;
@@ -76,7 +77,8 @@ and: {
 
 or: {
     options = {
-        evaluate: true
+        evaluate: true,
+        side_effects: true,
     }
     input: {
         var a;
@@ -158,7 +160,8 @@ or: {
 
 unary_prefix: {
     options = {
-        evaluate: true
+        evaluate: true,
+        side_effects: true,
     }
     input: {
         a = !0 && b;
@@ -344,22 +347,27 @@ unsafe_constant: {
 
 unsafe_object: {
     options = {
-        evaluate  : true,
+        evaluate: true,
-        unsafe    : true
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unsafe: true,
     }
     input: {
+        var o = { a: 1 };
         console.log(
-            ({a:1}) + 1,
+            o + 1,
-            ({a:1}).a + 1,
+            o.a + 1,
-            ({a:1}).b + 1,
+            o.b + 1,
-            ({a:1}).a.b + 1
+            o.a.b + 1
         );
     }
     expect: {
+        var o = { a: 1 };
         console.log(
-            ({a:1}) + 1,
+            o + 1,
             2,
-            ({a:1}).b + 1,
+            o.b + 1,
             1..b + 1
         );
     }
@@ -368,22 +376,27 @@ unsafe_object: {
 
 unsafe_object_nested: {
     options = {
-        evaluate  : true,
+        evaluate: true,
-        unsafe    : true
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unsafe: true,
     }
     input: {
+        var o = { a: { b: 1 } };
         console.log(
-            ({a:{b:1}}) + 1,
+            o + 1,
-            ({a:{b:1}}).a + 1,
+            o.a + 1,
-            ({a:{b:1}}).b + 1,
+            o.b + 1,
-            ({a:{b:1}}).a.b + 1
+            o.a.b + 1
         );
     }
     expect: {
+        var o = { a: { b: 1 } };
         console.log(
-            ({a:{b:1}}) + 1,
+            o + 1,
-            ({a:{b:1}}).a + 1,
+            o.a + 1,
-            ({a:{b:1}}).b + 1,
+            o.b + 1,
             2
         );
     }
@@ -392,21 +405,26 @@ unsafe_object_nested: {
 
 unsafe_object_complex: {
     options = {
-        evaluate  : true,
+        evaluate: true,
-        unsafe    : true
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unsafe: true,
     }
     input: {
+        var o = { a: { b: 1 }, b: 1 };
         console.log(
-            ({a:{b:1},b:1}) + 1,
+            o + 1,
-            ({a:{b:1},b:1}).a + 1,
+            o.a + 1,
-            ({a:{b:1},b:1}).b + 1,
+            o.b + 1,
-            ({a:{b:1},b:1}).a.b + 1
+            o.a.b + 1
         );
     }
     expect: {
+        var o = { a: { b: 1 }, b: 1 };
         console.log(
-            ({a:{b:1},b:1}) + 1,
+            o + 1,
-            ({a:{b:1},b:1}).a + 1,
+            o.a + 1,
             2,
             2
         );
@@ -416,22 +434,27 @@ unsafe_object_complex: {
 
 unsafe_object_repeated: {
     options = {
-        evaluate  : true,
+        evaluate: true,
-        unsafe    : true
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unsafe: true,
     }
     input: {
+        var o = { a: { b: 1 }, a: 1 };
         console.log(
-            ({a:{b:1},a:1}) + 1,
+            o + 1,
-            ({a:{b:1},a:1}).a + 1,
+            o.a + 1,
-            ({a:{b:1},a:1}).b + 1,
+            o.b + 1,
-            ({a:{b:1},a:1}).a.b + 1
+            o.a.b + 1
         );
     }
     expect: {
+        var o = { a: { b: 1 }, a: 1 };
         console.log(
-            ({a:{b:1},a:1}) + 1,
+            o + 1,
             2,
-            ({a:{b:1},a:1}).b + 1,
+            o.b + 1,
             1..b + 1
         );
     }
@@ -441,6 +464,7 @@ unsafe_object_repeated: {
 unsafe_object_accessor: {
     options = {
         evaluate: true,
+        reduce_funcs: true,
         reduce_vars: true,
         unsafe: true,
     }
@@ -464,10 +488,11 @@ unsafe_object_accessor: {
     }
 }
 
-unsafe_function: {
+prop_function: {
     options = {
-        evaluate  : true,
+        evaluate: true,
-        unsafe    : true
+        properties: true,
+        side_effects: true,
     }
     input: {
         console.log(
@@ -480,9 +505,9 @@ unsafe_function: {
     expect: {
         console.log(
             ({a:{b:1},b:function(){}}) + 1,
-            ({a:{b:1},b:function(){}}).a + 1,
+            ({b:1}) + 1,
-            ({a:{b:1},b:function(){}}).b + 1,
+            function(){} + 1,
-            ({a:{b:1},b:function(){}}).a.b + 1
+            2
         );
     }
     expect_stdout: true
@@ -708,10 +733,11 @@ unsafe_string_bad_index: {
     expect_stdout: true
 }
 
-unsafe_prototype_function: {
+prototype_function: {
     options = {
-        evaluate  : true,
+        evaluate: true,
-        unsafe    : true
+        properties: true,
+        side_effects: true,
     }
     input: {
         var a = ({valueOf: 0}) < 1;
@@ -730,14 +756,16 @@ unsafe_prototype_function: {
         var d = ({toString: 0}) + "";
         var e = (({valueOf: 0}) + "")[2];
         var f = (({toString: 0}) + "")[2];
-        var g = ({valueOf: 0}).valueOf();
+        var g = 0();
-        var h = "" + ({toString: 0});
+        var h = 0();
     }
 }
 
 call_args: {
     options = {
         evaluate: true,
+        inline: true,
+        reduce_funcs: true,
         reduce_vars: true,
     }
     input: {
@@ -758,7 +786,9 @@ call_args: {
 call_args_drop_param: {
     options = {
         evaluate: true,
+        inline: true,
         keep_fargs: false,
+        reduce_funcs: true,
         reduce_vars: true,
         unused: true,
     }
@@ -873,13 +903,15 @@ unsafe_charAt_noop: {
     input: {
         console.log(
             s.charAt(0),
-            "string".charAt(x)
+            "string".charAt(x),
+            (typeof x).charAt()
         );
     }
     expect: {
         console.log(
             s.charAt(0),
-            "string".charAt(x)
+            "string".charAt(x),
+            (typeof x)[0]
         );
     }
 }
@@ -1087,6 +1119,7 @@ Infinity_NaN_undefined_LHS: {
 issue_1964_1: {
     options = {
         evaluate: true,
+        reduce_funcs: true,
         reduce_vars: true,
         unsafe_regexp: false,
         unused: true,
@@ -1094,6 +1127,7 @@ issue_1964_1: {
     input: {
         function f() {
             var long_variable_name = /\s/;
+            console.log(long_variable_name.source);
             return "a b c".split(long_variable_name)[1];
         }
         console.log(f());
@@ -1101,16 +1135,21 @@ issue_1964_1: {
     expect: {
         function f() {
             var long_variable_name = /\s/;
+            console.log(long_variable_name.source);
             return "a b c".split(long_variable_name)[1];
         }
         console.log(f());
     }
-    expect_stdout: "b"
+    expect_stdout: [
+        "\\s",
+        "b",
+    ]
 }
 
 issue_1964_2: {
     options = {
         evaluate: true,
+        reduce_funcs: true,
         reduce_vars: true,
         unsafe_regexp: true,
         unused: true,
@@ -1118,15 +1157,368 @@ issue_1964_2: {
     input: {
         function f() {
             var long_variable_name = /\s/;
+            console.log(long_variable_name.source);
             return "a b c".split(long_variable_name)[1];
         }
         console.log(f());
     }
     expect: {
         function f() {
+            console.log(/\s/.source);
             return "a b c".split(/\s/)[1];
         }
         console.log(f());
     }
-    expect_stdout: "b"
+    expect_stdout: [
+        "\\s",
+        "b",
+    ]
+}
+
+array_slice_index: {
+    options = {
+        evaluate: true,
+        unsafe: true,
+    }
+    input: {
+        console.log([1,2,3].slice(1)[1]);
+    }
+    expect: {
+        console.log(3);
+    }
+    expect_stdout: "3"
+}
+
+string_charCodeAt: {
+    options = {
+        evaluate: true,
+        unsafe: true,
+    }
+    input: {
+        console.log("foo".charCodeAt("bar".length));
+    }
+    expect: {
+        console.log(NaN);
+    }
+    expect_stdout: "NaN"
+}
+
+issue_2207_1: {
+    options = {
+        evaluate: true,
+        unsafe: true,
+    }
+    input: {
+        console.log(String.fromCharCode(65));
+        console.log(Math.max(3, 6, 2, 7, 3, 4));
+        console.log(Math.cos(1.2345));
+        console.log(Math.cos(1.2345) - Math.sin(4.321));
+        console.log(Math.pow(Math.PI, Math.E - Math.LN10));
+    }
+    expect: {
+        console.log("A");
+        console.log(7);
+        console.log(Math.cos(1.2345));
+        console.log(1.2543732512566947);
+        console.log(1.6093984514472044);
+    }
+    expect_stdout: true
+}
+
+issue_2207_2: {
+    options = {
+        evaluate: true,
+        unsafe: true,
+    }
+    input: {
+        console.log(Math.E);
+        console.log(Math.LN10);
+        console.log(Math.LN2);
+        console.log(Math.LOG2E);
+        console.log(Math.LOG10E);
+        console.log(Math.PI);
+        console.log(Math.SQRT1_2);
+        console.log(Math.SQRT2);
+    }
+    expect: {
+        console.log(Math.E);
+        console.log(Math.LN10);
+        console.log(Math.LN2);
+        console.log(Math.LOG2E);
+        console.log(Math.LOG10E);
+        console.log(Math.PI);
+        console.log(Math.SQRT1_2);
+        console.log(Math.SQRT2);
+    }
+    expect_stdout: true
+}
+
+issue_2207_3: {
+    options = {
+        evaluate: true,
+        unsafe: true,
+    }
+    input: {
+        console.log(Number.MAX_VALUE);
+        console.log(Number.MIN_VALUE);
+        console.log(Number.NaN);
+        console.log(Number.NEGATIVE_INFINITY);
+        console.log(Number.POSITIVE_INFINITY);
+    }
+    expect: {
+        console.log(Number.MAX_VALUE);
+        console.log(5e-324);
+        console.log(NaN);
+        console.log(-1/0);
+        console.log(1/0);
+    }
+    expect_stdout: true
+}
+
+issue_2231_1: {
+    options = {
+        evaluate: true,
+        unsafe: true,
+    }
+    input: {
+        console.log(Object.keys(void 0));
+    }
+    expect: {
+        console.log(Object.keys(void 0));
+    }
+    expect_stdout: true
+    expect_warnings: [
+        "WARN: Error evaluating Object.keys(void 0) [test/compress/evaluate.js:1284,20]",
+    ]
+}
+
+issue_2231_2: {
+    options = {
+        evaluate: true,
+        unsafe: true,
+    }
+    input: {
+        console.log(Object.getOwnPropertyNames(null));
+    }
+    expect: {
+        console.log(Object.getOwnPropertyNames(null));
+    }
+    expect_stdout: true
+    expect_warnings: [
+        "WARN: Error evaluating Object.getOwnPropertyNames(null) [test/compress/evaluate.js:1301,20]",
+    ]
+}
+
+issue_2231_3: {
+    options = {
+        evaluate: true,
+        unsafe: true,
+    }
+    input: {
+        console.log(Object.keys({ foo: "bar" })[0]);
+    }
+    expect: {
+        console.log("foo");
+    }
+    expect_stdout: "foo"
+}
+
+self_comparison_1: {
+    options = {
+        evaluate: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unsafe: true,
+        unused: true,
+    }
+    input: {
+        var o = { n: NaN };
+        console.log(o.n == o.n, o.n === o.n, o.n != o.n, o.n !== o.n, typeof o.n);
+    }
+    expect: {
+        console.log(false, false, true, true, "number");
+    }
+    expect_stdout: "false false true true 'number'"
+}
+
+self_comparison_2: {
+    options = {
+        evaluate: true,
+        hoist_props: true,
+        passes: 2,
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var o = { n: NaN };
+        console.log(o.n == o.n, o.n === o.n, o.n != o.n, o.n !== o.n, typeof o.n);
+    }
+    expect: {
+        console.log(false, false, true, true, "number");
+    }
+    expect_stdout: "false false true true 'number'"
+}
+
+issue_2535_1: {
+    options = {
+        booleans: true,
+        evaluate: true,
+        sequences: true,
+        side_effects: true,
+    }
+    input: {
+        if ((x() || true) || y()) z();
+        if ((x() || true) && y()) z();
+        if ((x() && true) || y()) z();
+        if ((x() && true) && y()) z();
+        if ((x() || false) || y()) z();
+        if ((x() || false) && y()) z();
+        if ((x() && false) || y()) z();
+        if ((x() && false) && y()) z();
+    }
+    expect: {
+        if (x(), 1) z();
+        if (x(), y()) z();
+        if (x() || y()) z();
+        if (x() && y()) z();
+        if (x() || y()) z();
+        if (x() && y()) z();
+        if (x(), y()) z();
+        if (x(), 0) z();
+    }
+}
+
+issue_2535_2: {
+    options = {
+        booleans: true,
+        evaluate: true,
+        sequences: true,
+        side_effects: true,
+    }
+    input: {
+        (x() || true) || y();
+        (x() || true) && y();
+        (x() && true) || y();
+        (x() && true) && y();
+        (x() || false) || y();
+        (x() || false) && y();
+        (x() && false) || y();
+        (x() && false) && y();
+    }
+    expect: {
+        x(),
+        x(), y(),
+        x() || y(),
+        x() && y(),
+        x() || y(),
+        x() && y(),
+        x(), y(),
+        x();
+    }
+}
+
+issue_2535_3: {
+    options = {
+        booleans: true,
+        evaluate: true,
+    }
+    input: {
+        console.log(Object(1) && 1 && 2);
+        console.log(Object(1) && true && 1 && 2 && Object(2));
+        console.log(Object(1) && true && 1 && null && 2 && Object(2));
+        console.log(2 == Object(1) || 0 || void 0 || null);
+        console.log(2 == Object(1) || 0 || void 0 || null || Object(2));
+        console.log(2 == Object(1) || 0 || void 0 || "ok" || null || Object(2));
+    }
+    expect: {
+        console.log(Object(1) && 2);
+        console.log(Object(1) && Object(2));
+        console.log(Object(1) && null);
+        console.log(2 == Object(1) || null);
+        console.log(2 == Object(1) || Object(2));
+        console.log(2 == Object(1) || "ok");
+    }
+    expect_stdout: true
+    expect_warnings: [
+        "WARN: Dropping side-effect-free && [test/compress/evaluate.js:1429,20]",
+        "WARN: Dropping side-effect-free && [test/compress/evaluate.js:1430,20]",
+        "WARN: Dropping side-effect-free && [test/compress/evaluate.js:1431,20]",
+        "WARN: Condition left of && always false [test/compress/evaluate.js:1431,20]",
+        "WARN: Dropping side-effect-free || [test/compress/evaluate.js:1432,20]",
+        "WARN: Dropping side-effect-free || [test/compress/evaluate.js:1433,20]",
+        "WARN: Dropping side-effect-free || [test/compress/evaluate.js:1434,20]",
+        "WARN: Condition left of || always true [test/compress/evaluate.js:1434,20]",
+    ]
+}
+
+issue_2822: {
+    options = {
+        evaluate: true,
+        unsafe: true,
+    }
+    input: {
+        console.log([ function() {}, "PASS", "FAIL" ][1]);
+    }
+    expect: {
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+string_case: {
+    options = {
+        evaluate: true,
+        unsafe: true,
+    }
+    input: {
+        console.log("İ".toLowerCase().charCodeAt(0));
+        console.log("I".toLowerCase().charCodeAt(0));
+        console.log("Ş".toLowerCase().charCodeAt(0));
+        console.log("Ğ".toLowerCase().charCodeAt(0));
+        console.log("Ü".toLowerCase().charCodeAt(0));
+        console.log("Ö".toLowerCase().charCodeAt(0));
+        console.log("Ç".toLowerCase().charCodeAt(0));
+        console.log("i".toUpperCase().charCodeAt(0));
+        console.log("ı".toUpperCase().charCodeAt(0));
+        console.log("ş".toUpperCase().charCodeAt(0));
+        console.log("ğ".toUpperCase().charCodeAt(0));
+        console.log("ü".toUpperCase().charCodeAt(0));
+        console.log("ö".toUpperCase().charCodeAt(0));
+        console.log("ç".toUpperCase().charCodeAt(0));
+    }
+    expect: {
+        console.log(105);
+        console.log(105);
+        console.log(351);
+        console.log(287);
+        console.log(252);
+        console.log(246);
+        console.log(231);
+        console.log(73);
+        console.log(73);
+        console.log(350);
+        console.log(286);
+        console.log(220);
+        console.log(214);
+        console.log(199);
+    }
+    expect_stdout: [
+        "105",
+        "105",
+        "351",
+        "287",
+        "252",
+        "246",
+        "231",
+        "73",
+        "73",
+        "350",
+        "286",
+        "220",
+        "214",
+        "199",
+    ]
 }

test/compress/expansions.js

@@ -26,3 +26,46 @@ expand_parameters: {
     expect_exact: "(function(a,...b){});(function(...args){});"
 }
 
+avoid_spread_in_ternary: {
+    options = {
+        comparisons: true,
+        conditionals: true,
+        evaluate: true,
+    }
+    input: {
+        function print(...x) {
+            console.log(...x);
+        }
+        var a = [1, 2], b = [3, 4], m = Math;
+
+        if (m)
+            print(a);
+        else
+            print(b);
+
+        if (m)
+            print(...a);
+        else
+            print(b);
+
+        if (m.no_such_property)
+            print(a);
+        else
+            print(...b);
+    }
+    expect: {
+        function print(...x) {
+            console.log(...x);
+        }
+        var a = [ 1, 2 ], b = [ 3, 4 ], m = Math;
+        print(m ? a : b);
+        m ? print(...a) : print(b);
+        m.no_such_property ? print(a) : print(...b);
+    }
+    expect_stdout: [
+        "[ 1, 2 ]",
+        "1 2",
+        "3 4",
+    ]
+    node_version: ">=6"
+}

test/compress/export.js

@@ -0,0 +1,446 @@
+issue_2038_1: {
+    options = {
+        toplevel: true,
+        unused: true,
+    }
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        export var V = 1;
+        export let L = 2;
+        export const C = 3;
+    }
+    expect: {
+        export var V = 1;
+        export let L = 2;
+        export const C = 3;
+    }
+}
+
+issue_2038_2: {
+    options = {
+        toplevel: true,
+        unused: true,
+    }
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        let LET = 1;
+        const CONST = 2;
+        var VAR = 3;
+        export { LET, CONST, VAR };
+    }
+    expect: {
+        let t = 1;
+        const e = 2;
+        var o = 3;
+        export { t as LET, e as CONST, o as VAR };
+    }
+}
+
+issue_2126: {
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        import { foo as bar, cat as dog } from "stuff";
+        console.log(bar, dog);
+        export { bar as qux };
+        export { dog };
+    }
+    expect: {
+        import { foo as o, cat as s } from "stuff";
+        console.log(o, s);
+        export { o as qux };
+        export { s as dog };
+    }
+}
+
+beautify: {
+    beautify = {
+        beautify: true,
+    }
+    input: {
+        export { A as B, C as D };
+    }
+    expect_exact: "export { A as B, C as D };"
+}
+
+issue_2131: {
+    options = {
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function no() {
+            console.log(42);
+        }
+        function go() {
+            console.log(42);
+        }
+        var X = 1, Y = 2;
+        export function main() {
+            go(X);
+        };
+    }
+    expect: {
+        function go() {
+            console.log(42);
+        }
+        var X = 1;
+        export function main() {
+            go(X);
+        };
+    }
+}
+
+issue_2129: {
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        export const { keys } = Object;
+    }
+    expect: {
+        export const { keys } = Object;
+    }
+}
+
+async_func: {
+    options = {
+        keep_fargs: false,
+        unused: true,
+    }
+    input: {
+        export async function Foo(x){};
+    }
+    expect: {
+        export async function Foo(){};
+    }
+}
+
+issue_2134_1: {
+    options = {
+        keep_fargs: false,
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        export function Foo(x){};
+        Foo.prototype = {};
+    }
+    expect: {
+        export function Foo(){};
+        Foo.prototype = {};
+    }
+}
+
+issue_2134_2: {
+    options = {
+        keep_fargs: false,
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        export async function Foo(x){};
+        Foo.prototype = {};
+    }
+    expect: {
+        export async function Foo(){};
+        Foo.prototype = {};
+    }
+}
+
+redirection: {
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        let foo = 1, bar = 2;
+        export { foo as delete };
+        export { bar as default };
+        export { foo as var } from "module.js";
+    }
+    expect: {
+        let e = 1, o = 2;
+        export { e as delete };
+        export { o as default };
+        export { foo as var } from "module.js";
+    }
+}
+
+keyword_invalid_1: {
+    input: {
+        export { default };
+    }
+    expect: {
+        export { default };
+    }
+}
+
+keyword_invalid_2: {
+    input: {
+        export { default as Alias };
+    }
+    expect: {
+        export { default as Alias };
+    }
+}
+
+keyword_invalid_3: {
+    input: {
+        export { default as default };
+    }
+    expect: {
+        export { default as default };
+    }
+}
+
+keyword_valid_1: {
+    input: {
+        export { default } from "module.js";
+    }
+    expect: {
+        export { default } from "module.js";
+    }
+}
+
+keyword_valid_2: {
+    input: {
+        export { default as Alias } from "module.js";
+    }
+    expect: {
+        export { default as Alias } from "module.js";
+    }
+}
+
+keyword_valid_3: {
+    input: {
+        export { default as default } from "module.js";
+    }
+    expect: {
+        export { default as default } from "module.js";
+    }
+}
+
+dynamic_import: {
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        import traditional from './traditional.js';
+        function imp(x) {
+            return import(x);
+        }
+        import("module_for_side_effects.js");
+        let dynamic = import("some/module.js");
+        dynamic.foo();
+    }
+    expect: {
+        import o from "./traditional.js";
+        function t(o) {
+            return import(o);
+        }
+        import("module_for_side_effects.js");
+        let r = import("some/module.js");
+        r.foo();
+    }
+}
+
+trailing_comma: {
+    beautify = {
+        beautify: true,
+    }
+    input: {
+        export const a = 1;
+    }
+    expect_exact: "export const a = 1;"
+}
+
+export_default_anonymous_function: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        export default function () {
+            foo();
+        }
+    }
+    expect_exact: "export default function(){foo()};"
+}
+
+export_default_arrow: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        export default () => foo();
+    }
+    expect_exact: "export default()=>foo();"
+}
+
+export_default_anonymous_generator: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        export default function * () {
+            yield foo();
+        }
+    }
+    expect_exact: "export default function*(){yield foo()};"
+}
+
+export_default_anonymous_async_function: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        export default async function() {
+            return await foo();
+        }
+    }
+    expect_exact: "export default async function(){return await foo()};"
+}
+
+export_default_async_arrow_function: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        export default async () => await foo();
+    }
+    expect_exact: "export default async()=>await foo();"
+}
+
+export_default_named_generator: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        export default function * gen() {
+            yield foo();
+        }
+    }
+    expect_exact: "export default function*gen(){yield foo()};"
+}
+
+export_default_named_async_function: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        export default async function bar() {
+            return await foo();
+        }
+    }
+    expect_exact: "export default async function bar(){return await foo()};"
+}
+
+export_default_anonymous_class: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        export default class {
+            constructor() {
+                foo();
+            }
+        };
+    }
+    expect_exact: "export default class{constructor(){foo()}};"
+}
+
+export_default_anonymous_function_not_call: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        export default function(){}(foo);
+    }
+    // FIXME: should be `export default function(){};foo;`
+    expect_exact: "export default function(){}(foo);"
+}
+
+export_default_anonymous_generator_not_call: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        export default function*(){}(foo);
+    }
+    // agrees with `acorn` and `babylon 7`
+    expect_exact: "export default function*(){};foo;"
+}
+
+export_default_anonymous_async_function_not_call: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        export default async function(){}(foo);
+    }
+    // agrees with `acorn` and `babylon 7`
+    expect_exact: "export default async function(){};foo;"
+}

test/compress/global_defs.js

@@ -37,6 +37,7 @@ object: {
                 VALUE: 42,
             },
         },
+        side_effects: true,
         unsafe: true,
     }
     input: {
@@ -140,9 +141,9 @@ mixed: {
         console.log(CONFIG);
     }
     expect_warnings: [
-        'WARN: global_defs CONFIG.VALUE redefined [test/compress/global_defs.js:126,22]',
         'WARN: global_defs CONFIG.VALUE redefined [test/compress/global_defs.js:127,22]',
-        'WARN: global_defs CONFIG.VALUE redefined [test/compress/global_defs.js:129,8]',
+        'WARN: global_defs CONFIG.VALUE redefined [test/compress/global_defs.js:128,22]',
+        'WARN: global_defs CONFIG.VALUE redefined [test/compress/global_defs.js:130,8]',
     ]
 }
 
@@ -174,3 +175,25 @@ issue_1986: {
         console.log(42);
     }
 }
+
+issue_2167: {
+    options = {
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        global_defs: {
+            "@isDevMode": "function(){}",
+        },
+        passes: 2,
+        side_effects: true,
+    }
+    input: {
+        if (isDevMode()) {
+            greetOverlord();
+        }
+        doWork();
+    }
+    expect: {
+        doWork();
+    }
+}

test/compress/hoist_props.js

@@ -0,0 +1,921 @@
+issue_2377_1: {
+    options = {
+        evaluate: true,
+        inline: true,
+        hoist_props: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var obj = {
+            foo: 1,
+            bar: 2,
+            square: function(x) {
+                return x * x;
+            },
+            cube: function(x) {
+                return x * x * x;
+            },
+        };
+        console.log(obj.foo, obj.cube(3));
+    }
+    expect: {
+        var obj_foo = 1, obj_cube = function(x) {
+            return x * x * x;
+        };
+        console.log(obj_foo, obj_cube(3));
+    }
+    expect_stdout: "1 27"
+}
+
+issue_2377_2: {
+    options = {
+        evaluate: true,
+        inline: true,
+        hoist_props: true,
+        passes: 2,
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var obj = {
+            foo: 1,
+            bar: 2,
+            square: function(x) {
+                return x * x;
+            },
+            cube: function(x) {
+                return x * x * x;
+            },
+        };
+        console.log(obj.foo, obj.cube(3));
+    }
+    expect: {
+        console.log(1, (x = 3, x * x * x));
+        var x;
+    }
+    expect_stdout: "1 27"
+}
+
+issue_2377_3: {
+    options = {
+        evaluate: true,
+        inline: true,
+        hoist_props: true,
+        passes: 4,
+        reduce_funcs: true,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var obj = {
+            foo: 1,
+            bar: 2,
+            square: function(x) {
+                return x * x;
+            },
+            cube: function(x) {
+                return x * x * x;
+            },
+        };
+        console.log(obj.foo, obj.cube(3));
+    }
+    expect: {
+        console.log(1, 27);
+    }
+    expect_stdout: "1 27"
+}
+
+direct_access_1: {
+    options = {
+        hoist_props: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = 0;
+        var obj = {
+            a: 1,
+            b: 2,
+        };
+        for (var k in obj) a++;
+        console.log(a, obj.a);
+    }
+    expect: {
+        var a = 0;
+        var obj = {
+            a: 1,
+            b: 2,
+        };
+        for (var k in obj) a++;
+        console.log(a, obj.a);
+    }
+    expect_stdout: "2 1"
+}
+
+direct_access_2: {
+    options = {
+        hoist_props: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var o = { a: 1 };
+        var f = function(k) {
+            if (o[k]) return "PASS";
+        };
+        console.log(f("a"));
+    }
+    expect: {
+        var o = { a: 1 };
+        console.log(function(k) {
+            if (o[k]) return "PASS";
+        }("a"));
+    }
+    expect_stdout: "PASS"
+}
+
+direct_access_3: {
+    options = {
+        hoist_props: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var o = { a: 1 };
+        o.b;
+        console.log(o.a);
+    }
+    expect: {
+        var o = { a: 1 };
+        o.b;
+        console.log(o.a);
+    }
+    expect_stdout: "1"
+}
+
+single_use: {
+    options = {
+        hoist_props: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var obj = {
+            bar: function() {
+                return 42;
+            },
+        };
+        console.log(obj.bar());
+    }
+    expect: {
+        console.log({
+            bar: function() {
+                return 42;
+            },
+        }.bar());
+    }
+}
+
+name_collision_1: {
+    options = {
+        hoist_props: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var obj_foo = 1;
+        var obj_bar = 2;
+        function f() {
+            var obj = {
+                foo: 3,
+                bar: 4,
+                "b-r": 5,
+                "b+r": 6,
+                "b!r": 7,
+            };
+            console.log(obj_foo, obj.foo, obj.bar, obj["b-r"], obj["b+r"], obj["b!r"]);
+        }
+        f();
+    }
+    expect: {
+        var obj_foo = 1;
+        var obj_bar = 2;
+        function f() {
+            var obj_foo$0 = 3,
+                obj_bar = 4,
+                obj_b_r = 5,
+                obj_b_r$0 = 6,
+                obj_b_r$1 = 7;
+            console.log(obj_foo, obj_foo$0, obj_bar, obj_b_r, obj_b_r$0, obj_b_r$1);
+        }
+        f();
+    }
+    expect_stdout: "1 3 4 5 6 7"
+}
+
+name_collision_2: {
+    options = {
+        hoist_props: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var o = {
+            p: 1,
+            0: function(x) {
+                return x;
+            },
+            1: function(x) {
+                return x + 1;
+            }
+        }, o__$0 = 2, o__$1 = 3;
+        console.log(o.p === o.p, o[0](4), o[1](5), o__$0, o__$1);
+    }
+    expect: {
+        var o_p = 1,
+            o__ = function(x) {
+                return x;
+            },
+            o__$2 = function(x) {
+                return x + 1;
+            },
+            o__$0 = 2,
+            o__$1 = 3;
+        console.log(o_p === o_p, o__(4), o__$2(5), o__$0, o__$1);
+    }
+    expect_stdout: "true 4 6 2 3"
+}
+
+name_collision_3: {
+    options = {
+        hoist_props: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var o = {
+            p: 1,
+            0: function(x) {
+                return x;
+            },
+            1: function(x) {
+                return x + 1;
+            }
+        }, o__$0 = 2, o__$1 = 3;
+        console.log(o.p === o.p, o[0](4), o[1](5));
+    }
+    expect: {
+        var o_p = 1,
+            o__ = function(x) {
+                return x;
+            },
+            o__$2 = function(x) {
+                return x + 1;
+            },
+            o__$0 = 2,
+            o__$1 = 3;
+        console.log(o_p === o_p, o__(4), o__$2(5));
+    }
+    expect_stdout: "true 4 6"
+}
+
+contains_this_1: {
+    options = {
+        evaluate: true,
+        hoist_props: true,
+        inline: true,
+        passes: 2,
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var o = {
+            u: function() {
+                return this === this;
+            },
+            p: 1
+        };
+        console.log(o.p, o.p);
+    }
+    expect: {
+        console.log(1, 1);
+    }
+    expect_stdout: "1 1"
+}
+
+contains_this_2: {
+    options = {
+        evaluate: true,
+        hoist_props: true,
+        inline: true,
+        passes: 2,
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var o = {
+            u: function() {
+                return this === this;
+            },
+            p: 1
+        };
+        console.log(o.p, o.p, o.u);
+    }
+    expect: {
+        console.log(1, 1, function() {
+            return this === this;
+        });
+    }
+    expect_stdout: true
+}
+
+contains_this_3: {
+    options = {
+        evaluate: true,
+        hoist_props: true,
+        inline: true,
+        passes: 2,
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var o = {
+            u: function() {
+                return this === this;
+            },
+            p: 1
+        };
+        console.log(o.p, o.p, o.u());
+    }
+    expect: {
+        var o = {
+            u: function() {
+                return this === this;
+            },
+            p: 1
+        };
+        console.log(o.p, o.p, o.u());
+    }
+    expect_stdout: "1 1 true"
+}
+
+hoist_class: {
+    options = {
+        comparisons: true,
+        evaluate: true,
+        hoist_props: true,
+        inline: true,
+        keep_classnames: true,
+        keep_fnames: true,
+        passes: 2,
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function run(c, v) {
+            return new c(v).value;
+        }
+        var o = {
+            p: class Foo {
+                constructor(value) {
+                    this.value = value * 10;
+                }
+            },
+            x: 1,
+            y: 2,
+        };
+        console.log(o.p.name, o.p === o.p, run(o.p, o.x), run(o.p, o.y));
+    }
+    expect: {
+        function run(c, v) {
+            return new c(v).value;
+        }
+        var o_p = class Foo {
+            constructor(value) {
+                this.value = 10 * value;
+            }
+        };
+        console.log(o_p.name, true, run(o_p, 1), run(o_p, 2));
+    }
+    node_version: ">=6"
+    expect_stdout: "Foo true 10 20"
+}
+
+hoist_class_with_new: {
+    options = {
+        comparisons: true,
+        evaluate: true,
+        hoist_props: true,
+        inline: true,
+        keep_classnames: true,
+        keep_fnames: true,
+        passes: 2,
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var o = {
+            p: class Foo {
+                constructor(value) {
+                    this.value = value * 10;
+                }
+            },
+            x: 1,
+            y: 2,
+        };
+        console.log(o.p.name, o.p === o.p, new o.p(o.x).value, new o.p(o.y).value);
+    }
+    expect: {
+        var o_p = class Foo {
+            constructor(value) {
+                this.value = 10 * value;
+            }
+        };
+        console.log(o_p.name, true, new o_p(1).value, new o_p(2).value);
+    }
+    node_version: ">=6"
+    expect_stdout: "Foo true 10 20"
+}
+
+hoist_function_with_call: {
+    options = {
+        comparisons: true,
+        evaluate: true,
+        hoist_props: true,
+        inline: true,
+        keep_fnames: true,
+        passes: 2,
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var o = {
+            p: function Foo(value) {
+                return 10 * value;
+            },
+            x: 1,
+            y: 2
+        };
+        console.log(o.p.name, o.p === o.p, o.p(o.x), o.p(o.y));
+    }
+    expect: {
+        var o = {
+            p: function Foo(value) {
+                return 10 * value;
+            },
+            x: 1,
+            y: 2
+        };
+        console.log(o.p.name, o.p == o.p, o.p(o.x), o.p(o.y));
+    }
+    expect_stdout: "Foo true 10 20"
+}
+
+new_this: {
+    options = {
+        evaluate: true,
+        hoist_props: true,
+        inline: true,
+        passes: 2,
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var o = {
+            a: 1,
+            b: 2,
+            f: function(a) {
+                this.b = a;
+            }
+        };
+        console.log(new o.f(o.a).b, o.b);
+    }
+    expect: {
+        console.log(new function(a) {
+            this.b = a;
+        }(1).b, 2);
+    }
+    expect_stdout: "1 2"
+}
+
+issue_2462: {
+    options = {
+        hoist_props: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+    }
+    input: {
+        export const Foo = {
+            a: 1,
+            b: () => 2
+        };
+    }
+    expect: {
+        export const Foo = {
+            a: 1,
+            b: () => 2
+        };
+    }
+}
+
+issue_2473_1: {
+    options = {
+        hoist_props: false,
+        reduce_vars: true,
+        top_retain: [ "x", "y" ],
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var x = {};
+        var y = [];
+        var z = {};
+    }
+    expect: {
+        var x = {};
+        var y = [];
+    }
+}
+
+issue_2473_2: {
+    options = {
+        hoist_props: true,
+        reduce_vars: true,
+        top_retain: [ "x", "y" ],
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var x = {};
+        var y = [];
+        var z = {};
+    }
+    expect: {
+        var x = {};
+        var y = [];
+    }
+}
+
+issue_2473_3: {
+    options = {
+        hoist_props: true,
+        reduce_vars: true,
+        top_retain: "o",
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var o = {
+            a: 1,
+            b: 2,
+        };
+        console.log(o.a, o.b);
+    }
+    expect: {
+        var o = {
+            a: 1,
+            b: 2,
+        };
+        console.log(o.a, o.b);
+    }
+    expect_stdout: "1 2"
+}
+
+issue_2473_4: {
+    options = {
+        hoist_props: true,
+        reduce_vars: true,
+        top_retain: "o",
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        (function() {
+            var o = {
+                a: 1,
+                b: 2,
+            };
+            console.log(o.a, o.b);
+        })();
+    }
+    expect: {
+        (function() {
+            var o_a = 1, o_b = 2;
+            console.log(o_a, o_b);
+        })();
+    }
+    expect_stdout: "1 2"
+}
+
+issue_2508_1: {
+    options = {
+        collapse_vars: true,
+        hoist_props: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var o = {
+            a: [ 1 ],
+            f: function(x) {
+                console.log(x);
+            }
+        };
+        o.f(o.a);
+    }
+    expect: {
+        (function(x) {
+            console.log(x);
+        })([ 1 ]);
+    }
+    expect_stdout: true
+}
+
+issue_2508_2: {
+    options = {
+        collapse_vars: true,
+        hoist_props: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var o = {
+            a: { b: 2 },
+            f: function(x) {
+                console.log(x);
+            }
+        };
+        o.f(o.a);
+    }
+    expect: {
+        (function(x) {
+            console.log(x);
+        })({ b: 2 });
+    }
+    expect_stdout: true
+}
+
+issue_2508_3: {
+    options = {
+        collapse_vars: true,
+        hoist_props: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var o = {
+            a: [ o ],
+            f: function(x) {
+                console.log(x);
+            }
+        };
+        o.f(o.a);
+    }
+    expect: {
+        var o = {
+            a: [ o ],
+            f: function(x) {
+                console.log(x);
+            }
+        };
+        o.f(o.a);
+    }
+    expect_stdout: true
+}
+
+issue_2508_4: {
+    options = {
+        collapse_vars: true,
+        hoist_props: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var o = {
+            a: { b: o },
+            f: function(x) {
+                console.log(x);
+            }
+        };
+        o.f(o.a);
+    }
+    expect: {
+        var o = {
+            a: { b: o },
+            f: function(x) {
+                console.log(x);
+            }
+        };
+        o.f(o.a);
+    }
+    expect_stdout: true
+}
+
+issue_2508_5: {
+    options = {
+        collapse_vars: true,
+        hoist_props: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var o = {
+            f: function(x) {
+                console.log(x);
+            }
+        };
+        o.f(o.f);
+    }
+    expect: {
+        var o_f = function(x) {
+            console.log(x);
+        };
+        o_f(o_f);
+    }
+    expect_stdout: true
+}
+
+issue_2508_6: {
+    options = {
+        collapse_vars: true,
+        hoist_props: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var o = {
+            f: x => {
+                console.log(x);
+            }
+        };
+        o.f(o.f);
+    }
+    expect: {
+        var o_f = x => {
+            console.log(x);
+        };
+        o_f(o_f);
+    }
+    expect_stdout: true
+}
+
+issue_2519: {
+    options = {
+        collapse_vars: true,
+        evaluate: true,
+        hoist_props: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        function testFunc() {
+            var dimensions = {
+                minX: 5,
+                maxX: 6,
+            };
+            var scale = 1;
+            var d = {
+                x: (dimensions.maxX + dimensions.minX) / 2,
+            };
+            return d.x * scale;
+        }
+        console.log(testFunc());
+    }
+    expect: {
+        function testFunc() {
+            return 1 * ((6 + 5) / 2);
+        }
+        console.log(testFunc());
+    }
+    expect_stdout: "5.5"
+}
+
+toplevel_const: {
+    options = {
+        hoist_props: true,
+        reduce_vars: true,
+        toplevel: false,
+    }
+    input: {
+        const a = {
+            b: 1,
+            c: 2
+        };
+        console.log(a.b + a.c);
+    }
+    expect: {
+        const a = {
+            b: 1,
+            c: 2
+        };
+        console.log(a.b + a.c);
+    }
+    expect_stdout: "3"
+}
+
+toplevel_let: {
+    options = {
+        hoist_props: true,
+        reduce_vars: true,
+        toplevel: false,
+    }
+    input: {
+        let a = {
+            b: 1,
+            c: 2
+        };
+        console.log(a.b + a.c);
+    }
+    expect: {
+        let a = {
+            b: 1,
+            c: 2
+        };
+        console.log(a.b + a.c);
+    }
+    expect_stdout: "3"
+    node_version: ">=6"
+}
+
+toplevel_var: {
+    options = {
+        hoist_props: true,
+        reduce_vars: true,
+        toplevel: false,
+    }
+    input: {
+        var a = {
+            b: 1,
+            c: 2
+        };
+        console.log(a.b + a.c);
+    }
+    expect: {
+        var a = {
+            b: 1,
+            c: 2
+        };
+        console.log(a.b + a.c);
+    }
+    expect_stdout: "3"
+}
+
+undefined_key: {
+    options = {
+        evaluate: true,
+        hoist_props: true,
+        join_vars: true,
+        passes: 4,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a, o = {};
+        o[a] = 1;
+        o.b = 2;
+        console.log(o[a] + o.b);
+    }
+    expect: {
+        console.log(3);
+    }
+    expect_stdout: "3"
+}

test/compress/hoist_vars.js

@@ -88,3 +88,24 @@ sequences_funs: {
         }
     }
 }
+
+issue_2295: {
+    options = {
+        collapse_vars: true,
+        hoist_vars: true,
+    }
+    input: {
+        function foo(o) {
+            var a = o.a;
+            if (a) return a;
+            var a = 1;
+        }
+    }
+    expect: {
+        function foo(o) {
+            var a = o.a;
+            if (a) return a;
+            a = 1;
+        }
+    }
+}

test/compress/if_return.js

@@ -384,3 +384,109 @@ issue_1317_strict: {
     expect_stdout: "1"
     node_version: ">=4"
 }
+
+if_var_return: {
+    options = {
+        conditionals: true,
+        if_return: true,
+        join_vars: true,
+        sequences: true,
+    }
+    input: {
+        function f() {
+            var a;
+            return;
+            var b;
+        }
+        function g() {
+            var a;
+            if (u()) {
+                var b;
+                return v();
+                var c;
+            }
+            var d;
+            if (w()) {
+                var e;
+                return x();
+                var f;
+            } else {
+                var g;
+                y();
+                var h;
+            }
+            var i;
+            z();
+            var j;
+        }
+    }
+    expect: {
+        function f() {
+            var a, b;
+        }
+        function g() {
+            var a, b, c, d, e, f, g, h, i, j;
+            return u() ? v() : w() ? x() : (y(), z(), void 0);
+        }
+    }
+}
+
+if_if_return_return: {
+    options = {
+        conditionals: true,
+        if_return: true,
+    }
+    input: {
+        function f(a, b) {
+            if (a) {
+                if (b)
+                    return b;
+                return;
+            }
+            g();
+        }
+    }
+    expect: {
+        function f(a, b) {
+            if (a)
+                return b || void 0;
+            g();
+        }
+    }
+}
+
+issue_2747: {
+    options = {
+        conditionals: true,
+        if_return: true,
+        sequences: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        function f(baz) {
+            if (baz === 0) {
+                return null;
+            }
+            let r;
+            if (baz > 2) {
+                r = 4;
+            } else {
+                r = 5;
+            }
+            return r;
+        }
+        console.log(f(0), f(1), f(3));
+    }
+    expect: {
+        "use strict";
+        function f(baz) {
+            if (0 === baz) return null;
+            let r;
+            return r = baz > 2 ? 4 : 5, r;
+        }
+        console.log(f(0), f(1), f(3));
+    }
+    expect_stdout: "null 5 4"
+    node_version: ">=4"
+}

test/compress/issue-1034.js

@@ -2,7 +2,7 @@ non_hoisted_function_after_return: {
     options = {
         hoist_funs: false, dead_code: true, conditionals: true, comparisons: true,
         evaluate: true, booleans: true, loops: true, unused: true, keep_fargs: true,
-        if_return: true, join_vars: true, cascade: true, side_effects: true
+        if_return: true, join_vars: true, side_effects: true
     }
     input: {
         function foo(x) {
@@ -38,7 +38,7 @@ non_hoisted_function_after_return_2a: {
     options = {
         hoist_funs: false, dead_code: true, conditionals: true, comparisons: true,
         evaluate: true, booleans: true, loops: true, unused: true, keep_fargs: true,
-        if_return: true, join_vars: true, cascade: true, side_effects: true,
+        if_return: true, join_vars: true, side_effects: true,
         collapse_vars: false, passes: 2, warnings: "verbose"
     }
     input: {
@@ -71,11 +71,13 @@ non_hoisted_function_after_return_2a: {
         "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:51,16]",
         "WARN: Dropping unused variable a [test/compress/issue-1034.js:48,20]",
         "WARN: Dropping unused function nope [test/compress/issue-1034.js:55,21]",
+        "WARN: pass 0: last_count: Infinity, count: 37",
         "WARN: Dropping unreachable code [test/compress/issue-1034.js:53,12]",
         "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:53,12]",
         "WARN: Dropping unreachable code [test/compress/issue-1034.js:56,12]",
         "WARN: Dropping unused variable b [test/compress/issue-1034.js:51,20]",
         "WARN: Dropping unused variable c [test/compress/issue-1034.js:53,16]",
+        "WARN: pass 1: last_count: 37, count: 18",
     ]
 }
 
@@ -83,7 +85,7 @@ non_hoisted_function_after_return_2b: {
     options = {
         hoist_funs: false, dead_code: true, conditionals: true, comparisons: true,
         evaluate: true, booleans: true, loops: true, unused: true, keep_fargs: true,
-        if_return: true, join_vars: true, cascade: true, side_effects: true,
+        if_return: true, join_vars: true, side_effects: true,
         collapse_vars: false
     }
     input: {
@@ -109,11 +111,11 @@ non_hoisted_function_after_return_2b: {
     }
     expect_warnings: [
         // duplicate warnings no longer emitted
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:95,16]",
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:97,16]",
-        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:95,16]",
+        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:97,16]",
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:97,12]",
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:99,12]",
-        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:97,12]",
+        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:99,12]",
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:101,12]",
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:103,12]",
     ]
 }
 
@@ -121,7 +123,7 @@ non_hoisted_function_after_return_strict: {
     options = {
         hoist_funs: false, dead_code: true, conditionals: true, comparisons: true,
         evaluate: true, booleans: true, loops: true, unused: true, keep_fargs: true,
-        if_return: true, join_vars: true, cascade: true, side_effects: true
+        if_return: true, join_vars: true, side_effects: true
     }
     input: {
         "use strict";
@@ -151,10 +153,10 @@ non_hoisted_function_after_return_strict: {
     }
     expect_stdout: "8 7"
     expect_warnings: [
-        'WARN: Dropping unreachable code [test/compress/issue-1034.js:131,16]',
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:133,16]",
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:134,16]",
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:136,16]",
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:137,12]",
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:139,12]",
-        "WARN: Dropping unused function UnusedFunction [test/compress/issue-1034.js:138,21]"
+        "WARN: Dropping unused function UnusedFunction [test/compress/issue-1034.js:140,21]",
     ]
 }
 
@@ -162,7 +164,7 @@ non_hoisted_function_after_return_2a_strict: {
     options = {
         hoist_funs: false, dead_code: true, conditionals: true, comparisons: true,
         evaluate: true, booleans: true, loops: true, unused: true, keep_fargs: true,
-        if_return: true, join_vars: true, cascade: true, side_effects: true,
+        if_return: true, join_vars: true, side_effects: true,
         collapse_vars: false, passes: 2, warnings: "verbose"
     }
     input: {
@@ -194,17 +196,19 @@ non_hoisted_function_after_return_2a_strict: {
     }
     expect_stdout: "5 6"
     expect_warnings: [
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:173,16]",
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:175,16]",
-        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:173,16]",
+        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:175,16]",
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:176,16]",
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:178,16]",
-        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:176,16]",
+        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:178,16]",
-        "WARN: Dropping unused variable a [test/compress/issue-1034.js:173,20]",
+        "WARN: Dropping unused variable a [test/compress/issue-1034.js:175,20]",
-        "WARN: Dropping unused function nope [test/compress/issue-1034.js:180,21]",
+        "WARN: Dropping unused function nope [test/compress/issue-1034.js:182,21]",
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:178,12]",
+        "WARN: pass 0: last_count: Infinity, count: 48",
-        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:178,12]",
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:180,12]",
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:181,12]",
+        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:180,12]",
-        "WARN: Dropping unused variable b [test/compress/issue-1034.js:176,20]",
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:183,12]",
-        "WARN: Dropping unused variable c [test/compress/issue-1034.js:178,16]",
+        "WARN: Dropping unused variable b [test/compress/issue-1034.js:178,20]",
+        "WARN: Dropping unused variable c [test/compress/issue-1034.js:180,16]",
+        "WARN: pass 1: last_count: 48, count: 29",
     ]
 }
 
@@ -212,7 +216,7 @@ non_hoisted_function_after_return_2b_strict: {
     options = {
         hoist_funs: false, dead_code: true, conditionals: true, comparisons: true,
         evaluate: true, booleans: true, loops: true, unused: true, keep_fargs: true,
-        if_return: true, join_vars: true, cascade: true, side_effects: true,
+        if_return: true, join_vars: true, side_effects: true,
         collapse_vars: false
     }
     input: {
@@ -243,10 +247,10 @@ non_hoisted_function_after_return_2b_strict: {
     expect_stdout: "5 6"
     expect_warnings: [
         // duplicate warnings no longer emitted
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:225,16]",
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:229,16]",
-        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:225,16]",
+        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:229,16]",
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:227,12]",
-        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:227,12]",
         "WARN: Dropping unreachable code [test/compress/issue-1034.js:231,12]",
+        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:231,12]",
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:235,12]",
     ]
 }

test/compress/issue-1041.js

@@ -14,6 +14,7 @@ const_declaration: {
 const_pragma: {
     options = {
         evaluate: true,
+        reduce_funcs: true,
         reduce_vars: true,
     };
 
@@ -29,6 +30,7 @@ const_pragma: {
 not_const: {
     options = {
         evaluate: true,
+        reduce_funcs: true,
         reduce_vars: true,
     };
 

test/compress/issue-1105.js

@@ -190,7 +190,6 @@ assorted_Infinity_NaN_undefined_in_with_scope: {
         keep_fargs:    true,
         if_return:     true,
         join_vars:     true,
-        cascade:       true,
         side_effects:  true,
         sequences:     false,
         keep_infinity: false,
@@ -253,7 +252,6 @@ assorted_Infinity_NaN_undefined_in_with_scope_keep_infinity: {
         keep_fargs:    true,
         if_return:     true,
         join_vars:     true,
-        cascade:       true,
         side_effects:  true,
         sequences:     false,
         keep_infinity: true,

test/compress/issue-1212.js

@@ -14,7 +14,7 @@ issue_1212_debug_false: {
         keep_fargs    : true,
         if_return     : true,
         join_vars     : true,
-        cascade       : true,
+        collapse_vars : true,
         side_effects  : true,
     }
     input: {
@@ -52,7 +52,7 @@ issue_1212_debug_true: {
         keep_fargs    : true,
         if_return     : true,
         join_vars     : true,
-        cascade       : true,
+        collapse_vars : true,
         side_effects  : true,
     }
     input: {

test/compress/issue-1261.js

@@ -8,7 +8,6 @@ pure_function_calls: {
         unused       : true,
         if_return    : true,
         join_vars    : true,
-        cascade      : true,
         negate_iife  : true,
     }
     input: {
@@ -49,13 +48,13 @@ pure_function_calls: {
         a.b(), f.g();
     }
     expect_warnings: [
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:17,8]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:16,8]",
-        "WARN: Dropping side-effect-free statement [test/compress/issue-1261.js:17,8]",
+        "WARN: Dropping side-effect-free statement [test/compress/issue-1261.js:16,8]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:30,37]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:29,37]",
-        "WARN: Dropping unused variable iife2 [test/compress/issue-1261.js:30,16]",
+        "WARN: Dropping unused variable iife2 [test/compress/issue-1261.js:29,16]",
-        "WARN: Dropping side-effect-free statement [test/compress/issue-1261.js:28,8]",
+        "WARN: Dropping side-effect-free statement [test/compress/issue-1261.js:27,8]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:38,8]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:37,8]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:39,31]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:38,31]",
     ]
 }
 
@@ -69,7 +68,6 @@ pure_function_calls_toplevel: {
         unused       : true,
         if_return    : true,
         join_vars    : true,
-        cascade      : true,
         negate_iife  : true,
         toplevel     : true,
     }
@@ -96,6 +94,13 @@ pure_function_calls_toplevel: {
             })();
         })();
 
+        // pure top-level calls will be dropped regardless of the leading comments position
+        var MyClass = /*#__PURE__*//*@class*/(function(){
+            function MyClass() {}
+            MyClass.prototype.method = function() {};
+            return MyClass;
+        })();
+
         // comment #__PURE__ comment
         bar(), baz(), quux();
         a.b(), /* @__PURE__ */ c.d.e(), f.g();
@@ -105,15 +110,17 @@ pure_function_calls_toplevel: {
         a.b(), f.g();
     }
     expect_warnings: [
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:79,8]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:77,8]",
-        "WARN: Dropping side-effect-free statement [test/compress/issue-1261.js:79,8]",
+        "WARN: Dropping side-effect-free statement [test/compress/issue-1261.js:77,8]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:92,37]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:90,37]",
-        "WARN: Dropping unused variable iife2 [test/compress/issue-1261.js:92,16]",
+        "WARN: Dropping unused variable iife2 [test/compress/issue-1261.js:90,16]",
-        "WARN: Dropping side-effect-free statement [test/compress/issue-1261.js:90,8]",
+        "WARN: Dropping side-effect-free statement [test/compress/issue-1261.js:88,8]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:100,8]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:105,8]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:101,31]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:106,31]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:84,33]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:82,33]",
-        "WARN: Dropping unused variable iife1 [test/compress/issue-1261.js:84,12]",
+        "WARN: Dropping unused variable iife1 [test/compress/issue-1261.js:82,12]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:98,45]",
+        "WARN: Dropping unused variable MyClass [test/compress/issue-1261.js:98,12]",
     ]
 }
 
@@ -148,29 +155,29 @@ should_warn: {
         baz();
     }
     expect_warnings: [
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:128,61]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:135,61]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:128,23]",
-        "WARN: Dropping side-effect-free statement [test/compress/issue-1261.js:128,23]",
-        "WARN: Boolean || always true [test/compress/issue-1261.js:129,23]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:129,23]",
-        "WARN: Condition always true [test/compress/issue-1261.js:129,23]",
-        "WARN: Condition left of || always true [test/compress/issue-1261.js:130,8]",
-        "WARN: Condition always true [test/compress/issue-1261.js:130,8]",
-        "WARN: Boolean && always false [test/compress/issue-1261.js:131,23]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:131,23]",
-        "WARN: Condition always false [test/compress/issue-1261.js:131,23]",
-        "WARN: Condition left of && always false [test/compress/issue-1261.js:132,8]",
-        "WARN: Condition always false [test/compress/issue-1261.js:132,8]",
-        "WARN: + in boolean context always true [test/compress/issue-1261.js:133,23]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:133,23]",
-        "WARN: Condition always true [test/compress/issue-1261.js:133,23]",
-        "WARN: + in boolean context always true [test/compress/issue-1261.js:134,8]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:134,31]",
-        "WARN: Condition always true [test/compress/issue-1261.js:134,8]",
         "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:135,23]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:136,24]",
+        "WARN: Dropping side-effect-free statement [test/compress/issue-1261.js:135,23]",
-        "WARN: Condition always true [test/compress/issue-1261.js:136,8]",
+        "WARN: Boolean || always true [test/compress/issue-1261.js:136,23]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:137,31]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:136,23]",
-        "WARN: Condition always false [test/compress/issue-1261.js:137,8]",
+        "WARN: Condition always true [test/compress/issue-1261.js:136,23]",
+        "WARN: Condition left of || always true [test/compress/issue-1261.js:137,8]",
+        "WARN: Condition always true [test/compress/issue-1261.js:137,8]",
+        "WARN: Boolean && always false [test/compress/issue-1261.js:138,23]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:138,23]",
+        "WARN: Condition always false [test/compress/issue-1261.js:138,23]",
+        "WARN: Condition left of && always false [test/compress/issue-1261.js:139,8]",
+        "WARN: Condition always false [test/compress/issue-1261.js:139,8]",
+        "WARN: + in boolean context always true [test/compress/issue-1261.js:140,23]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:140,23]",
+        "WARN: Condition always true [test/compress/issue-1261.js:140,23]",
+        "WARN: + in boolean context always true [test/compress/issue-1261.js:141,8]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:141,31]",
+        "WARN: Condition always true [test/compress/issue-1261.js:141,8]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:142,23]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:143,24]",
+        "WARN: Condition always true [test/compress/issue-1261.js:143,8]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:144,31]",
+        "WARN: Condition always false [test/compress/issue-1261.js:144,8]",
     ]
 }

test/compress/issue-1275.js

@@ -9,7 +9,6 @@ string_plus_optimization: {
         unused        : true,
         if_return     : true,
         join_vars     : true,
-        cascade       : true,
         hoist_funs    : true,
     };
     input: {

test/compress/issue-1321.js

@@ -1,6 +1,8 @@
 issue_1321_no_debug: {
-    mangle_props = {
+    mangle = {
-        keep_quoted: true
+        properties: {
+            keep_quoted: true,
+        },
     }
     input: {
         var x = {};
@@ -10,17 +12,19 @@ issue_1321_no_debug: {
     }
     expect: {
         var x = {};
-        x.b = 1;
+        x.x = 1;
-        x["a"] = 2 * x.b;
+        x["a"] = 2 * x.x;
-        console.log(x.b, x["a"]);
+        console.log(x.x, x["a"]);
     }
     expect_stdout: true
 }
 
 issue_1321_debug: {
-    mangle_props = {
+    mangle = {
-        keep_quoted: true,
+        properties: {
-        debug: ""
+            debug: "",
+            keep_quoted: true,
+        },
     }
     input: {
         var x = {};
@@ -30,16 +34,18 @@ issue_1321_debug: {
     }
     expect: {
         var x = {};
-        x.a = 1;
+        x.x = 1;
-        x["_$foo$_"] = 2 * x.a;
+        x["_$foo$_"] = 2 * x.x;
-        console.log(x.a, x["_$foo$_"]);
+        console.log(x.x, x["_$foo$_"]);
     }
     expect_stdout: true
 }
 
 issue_1321_with_quoted: {
-    mangle_props = {
+    mangle = {
-        keep_quoted: false
+        properties: {
+            keep_quoted: false,
+        },
     }
     input: {
         var x = {};
@@ -49,9 +55,9 @@ issue_1321_with_quoted: {
     }
     expect: {
         var x = {};
-        x.a = 1;
+        x.x = 1;
-        x["b"] = 2 * x.a;
+        x["o"] = 2 * x.x;
-        console.log(x.a, x["b"]);
+        console.log(x.x, x["o"]);
     }
     expect_stdout: true
 }

test/compress/issue-1443.js

@@ -4,7 +4,7 @@ unsafe_undefined: {
     options = {
         conditionals: true,
         if_return: true,
-        unsafe: true
+        unsafe_undefined: true,
     }
     mangle = {}
     input: {
@@ -30,7 +30,7 @@ keep_fnames: {
     options = {
         conditionals: true,
         if_return: true,
-        unsafe: true
+        unsafe_undefined: true,
     }
     mangle = {
         keep_fnames: true

test/compress/issue-1446.js

@@ -1,6 +1,7 @@
 typeof_eq_undefined: {
     options = {
-        comparisons: true
+        comparisons: true,
+        typeofs: true,
     }
     input: {
         var a = typeof b != "undefined";
@@ -24,6 +25,7 @@ typeof_eq_undefined_ie8: {
     options = {
         comparisons: true,
         ie8: true,
+        typeofs: true,
     }
     input: {
         var a = typeof b != "undefined";
@@ -45,7 +47,8 @@ typeof_eq_undefined_ie8: {
 
 undefined_redefined: {
     options = {
-        comparisons: true
+        comparisons: true,
+        typeofs: true,
     }
     input: {
         function f(undefined) {
@@ -58,7 +61,8 @@ undefined_redefined: {
 
 undefined_redefined_mangle: {
     options = {
-        comparisons: true
+        comparisons: true,
+        typeofs: true,
     }
     mangle = {}
     input: {

test/compress/issue-1447.js

@@ -32,7 +32,6 @@ conditional_false_stray_else_in_loop: {
         hoist_vars   : true,
         join_vars    : true,
         if_return    : true,
-        cascade      : true,
         conditionals : false,
     }
     input: {

test/compress/issue-1466.js

@@ -11,7 +11,6 @@ same_variable_in_multiple_for_loop: {
         keep_fargs: true,
         if_return: true,
         join_vars: true,
-        cascade: true,
         side_effects: true,
         collapse_vars: true,
     }
@@ -33,12 +32,13 @@ same_variable_in_multiple_for_loop: {
             console.log(o, l);
             for (let o = 0; o < 2; o++) {
                 console.log(o, l);
-                let c = 2;
+                let e = 2;
-                console.log(c);
+                console.log(e);
             }
         }
     }
     expect_stdout: true
+    node_version: ">=6"
 }
 
 same_variable_in_multiple_forOf: {
@@ -54,7 +54,6 @@ same_variable_in_multiple_forOf: {
         keep_fargs: true,
         if_return: true,
         join_vars: true,
-        cascade: true,
         side_effects: true,
         collapse_vars: true,
     }
@@ -81,6 +80,7 @@ same_variable_in_multiple_forOf: {
         }
     }
     expect_stdout: true
+    node_version: ">=6"
 }
 
 same_variable_in_multiple_forIn: {
@@ -96,7 +96,6 @@ same_variable_in_multiple_forIn: {
         keep_fargs: true,
         if_return: true,
         join_vars: true,
-        cascade: true,
         side_effects: true,
         collapse_vars: true,
     }
@@ -114,15 +113,16 @@ same_variable_in_multiple_forIn: {
     }
     expect: {
         var test = [ "a", "b", "c" ];
-        for (let o in test) {
+        for (let e in test) {
-            console.log(o);
+            console.log(e);
-            let e;
+            let t;
-            e = [ "e", "f", "g" ];
+            t = [ "e", "f", "g" ];
-            for (let o in test)
+            for (let e in test)
-                console.log(o);
+                console.log(e);
         }
     }
     expect_stdout: true
+    node_version: ">=6"
 }
 
 different_variable_in_multiple_for_loop: {
@@ -138,7 +138,6 @@ different_variable_in_multiple_for_loop: {
         keep_fargs: true,
         if_return: true,
         join_vars: true,
-        cascade: true,
         side_effects: true,
         collapse_vars: true,
     }
@@ -160,12 +159,13 @@ different_variable_in_multiple_for_loop: {
             console.log(o, l);
             for (let o = 0; o < 2; o++) {
                 console.log(o, l);
-                let c = 2;
+                let e = 2;
-                console.log(c);
+                console.log(e);
             }
         }
     }
     expect_stdout: true
+    node_version: ">=6"
 }
 
 different_variable_in_multiple_forOf: {
@@ -181,7 +181,6 @@ different_variable_in_multiple_forOf: {
         keep_fargs: true,
         if_return: true,
         join_vars: true,
-        cascade: true,
         side_effects: true,
         collapse_vars: true,
     }
@@ -208,6 +207,7 @@ different_variable_in_multiple_forOf: {
         }
     }
     expect_stdout: true
+    node_version: ">=6"
 }
 
 different_variable_in_multiple_forIn: {
@@ -223,7 +223,6 @@ different_variable_in_multiple_forIn: {
         keep_fargs: true,
         if_return: true,
         join_vars: true,
-        cascade: true,
         side_effects: true,
         collapse_vars: true,
     }
@@ -241,15 +240,184 @@ different_variable_in_multiple_forIn: {
     }
     expect: {
         var test = [ "a", "b", "c" ];
-        for (let o in test) {
+        for (let e in test) {
-            console.log(o);
+            console.log(e);
+            let t;
+            t = [ "e", "f", "g" ];
+            for (let e in test)
+                console.log(e);
+        }
+    }
+    expect_stdout: true
+    node_version: ">=6"
+}
+
+same_variable_in_multiple_forOf_sequences_let: {
+    options = {
+        hoist_funs: true,
+        dead_code: true,
+        conditionals: true,
+        comparisons: true,
+        evaluate: true,
+        booleans: true,
+        loops: true,
+        unused: true,
+        keep_fargs: true,
+        if_return: true,
+        join_vars: true,
+        sequences: true,
+        side_effects: true,
+        collapse_vars: true,
+    }
+    mangle = {}
+    input: {
+        var test = [ "a", "b", "c" ];
+        for (let tmp of test) {
+            console.log(tmp);
+            let dd;
+            dd = [ "e", "f", "g" ];
+            for (let tmp of dd) {
+                console.log(tmp);
+            }
+        }
+    }
+    expect: {
+        var test = [ "a", "b", "c" ];
+        for (let o of test) {
             let e;
-            e = [ "e", "f", "g" ];
+            console.log(o), e = [ "e", "f", "g" ];
-            for (let o in test)
+            for (let o of e)
                 console.log(o);
         }
     }
     expect_stdout: true
+    node_version: ">=6"
+}
+
+same_variable_in_multiple_forOf_sequences_const: {
+    options = {
+        hoist_funs: true,
+        dead_code: true,
+        conditionals: true,
+        comparisons: true,
+        evaluate: true,
+        booleans: true,
+        loops: true,
+        unused: true,
+        keep_fargs: true,
+        if_return: true,
+        join_vars: true,
+        sequences: true,
+        side_effects: true,
+        collapse_vars: true,
+    }
+    mangle = {}
+    input: {
+        var test = [ "a", "b", "c" ];
+        for (const tmp of test) {
+            console.log(tmp);
+            let dd;
+            dd = [ "e", "f", "g" ];
+            for (const tmp of dd) {
+                console.log(tmp);
+            }
+        }
+    }
+    expect: {
+        var test = [ "a", "b", "c" ];
+        for (const o of test) {
+            let t;
+            console.log(o), t = [ "e", "f", "g" ];
+            for (const o of t)
+                console.log(o);
+        }
+    }
+    expect_stdout: true
+    node_version: ">=6"
+}
+
+same_variable_in_multiple_forIn_sequences_let: {
+    options = {
+        hoist_funs: true,
+        dead_code: true,
+        conditionals: true,
+        comparisons: true,
+        evaluate: true,
+        booleans: true,
+        loops: true,
+        unused: false,
+        keep_fargs: true,
+        if_return: true,
+        join_vars: true,
+        sequences: true,
+        side_effects: true,
+        collapse_vars: true,
+    }
+    mangle = {}
+    input: {
+        var test = [ "a", "b", "c" ];
+        for (let tmp in test) {
+            console.log(tmp);
+            let dd;
+            dd = [ "e", "f", "g" ];
+            for (let tmp in test) {
+                console.log(tmp);
+            }
+        }
+    }
+    expect: {
+        var test = [ "a", "b", "c" ];
+        for (let e in test) {
+            let t;
+            console.log(e), t = [ "e", "f", "g" ];
+            for (let e in test)
+                console.log(e);
+        }
+    }
+    expect_stdout: true
+    node_version: ">=6"
+}
+
+same_variable_in_multiple_forIn_sequences_const: {
+    options = {
+        hoist_funs: true,
+        dead_code: true,
+        conditionals: true,
+        comparisons: true,
+        evaluate: true,
+        booleans: true,
+        loops: true,
+        unused: false,
+        keep_fargs: true,
+        if_return: true,
+        join_vars: true,
+        sequences: true,
+        side_effects: true,
+        collapse_vars: true,
+    }
+    mangle = {}
+    input: {
+        var test = [ "a", "b", "c" ];
+        for (const tmp in test) {
+            console.log(tmp);
+            let dd;
+            dd = [ "e", "f", "g" ];
+            for (const tmp in test) {
+                console.log(tmp);
+            }
+        }
+    }
+    expect: {
+        var test = [ "a", "b", "c" ];
+        for (const o in test) {
+            let t;
+            console.log(o), t = [ "e", "f", "g" ];
+            for (const o in test)
+                console.log(o);
+        }
+    }
+    expect_stdout: true
+    node_version: ">=6"
 }
 
 more_variable_in_multiple_for: {
@@ -265,7 +433,6 @@ more_variable_in_multiple_for: {
         keep_fargs: true,
         if_return: true,
         join_vars: true,
-        cascade: true,
         side_effects: true,
         collapse_vars: true,
     }
@@ -281,11 +448,12 @@ more_variable_in_multiple_for: {
     }
     expect: {
         for (let o = 9, l = 0; l < 20; l += o) {
-            let c = o++ + l;
+            let e = o++ + l;
-            console.log(o, c, l);
+            console.log(o, e, l);
-            for (let l = c, e = c * c, f = 0; f < 10; f++)
+            for (let l = e, t = e * e, c = 0; c < 10; c++)
-                console.log(o, c, e, l, f);
+                console.log(o, e, t, l, c);
         }
     }
     expect_stdout: true
+    node_version: ">=6"
 }

test/compress/issue-1588.js

@@ -61,7 +61,7 @@ unsafe_undefined: {
     options = {
         conditionals: true,
         if_return: true,
-        unsafe: true,
+        unsafe_undefined: true,
     }
     mangle = {}
     input: {

test/compress/issue-1609.js

@@ -2,6 +2,7 @@ chained_evaluation_1: {
     options = {
         collapse_vars: true,
         evaluate: true,
+        reduce_funcs: true,
         reduce_vars: true,
         unused: true,
     }
@@ -28,6 +29,7 @@ chained_evaluation_2: {
     options = {
         collapse_vars: true,
         evaluate: true,
+        reduce_funcs: true,
         reduce_vars: true,
         unused: true,
     }

test/compress/issue-1639.js

@@ -2,7 +2,7 @@
 issue_1639_1: {
     options = {
         booleans: true,
-        cascade: true,
+        collapse_vars: true,
         conditionals: true,
         evaluate: true,
         join_vars: true,
@@ -26,7 +26,7 @@ issue_1639_1: {
     }
     expect: {
         for (var a = 100, b = 10, L1 = 5; --L1 > 0;)
-            if (--b, !1) var ignore = 0;
+            if (--b, 0) var ignore = 0;
         console.log(a, b);
     }
     expect_stdout: true
@@ -35,7 +35,7 @@ issue_1639_1: {
 issue_1639_2: {
     options = {
         booleans: true,
-        cascade: true,
+        collapse_vars: true,
         conditionals: true,
         evaluate: true,
         join_vars: true,
@@ -57,7 +57,7 @@ issue_1639_2: {
     expect: {
         var a = 100, b = 10;
         function f19() {
-            ++a, 1;
+            ++a, 0;
         }
         f19(),
         console.log(a, b);
@@ -68,7 +68,7 @@ issue_1639_2: {
 issue_1639_3: {
     options = {
         booleans: true,
-        cascade: true,
+        collapse_vars: true,
         conditionals: true,
         evaluate: true,
         sequences: true,

test/compress/issue-1656.js

@@ -1,7 +1,6 @@
 f7: {
     options = {
         booleans: true,
-        cascade: true,
         collapse_vars: true,
         comparisons: true,
         conditionals: true,
@@ -15,6 +14,7 @@ f7: {
         negate_iife: true,
         passes: 3,
         properties: true,
+        reduce_funcs: true,
         reduce_vars: true,
         sequences: true,
         side_effects: true,
@@ -38,7 +38,7 @@ f7: {
         "var b = 10;",
         "",
         "!function() {",
-        "    for (;b = 100, !1; ) ;",
+        "    b = 100;",
         "}(), console.log(100, b);",
     ]
     expect_stdout: true

test/compress/issue-1673.js

@@ -1,5 +1,6 @@
 side_effects_catch: {
     options = {
+        reduce_funcs: true,
         reduce_vars: true,
         side_effects: true,
         unused: true,
@@ -34,6 +35,7 @@ side_effects_catch: {
 
 side_effects_else: {
     options = {
+        reduce_funcs: true,
         reduce_vars: true,
         side_effects: true,
         unused: true,
@@ -62,6 +64,7 @@ side_effects_else: {
 
 side_effects_finally: {
     options = {
+        reduce_funcs: true,
         reduce_vars: true,
         side_effects: true,
         unused: true,
@@ -98,6 +101,7 @@ side_effects_finally: {
 
 side_effects_label: {
     options = {
+        reduce_funcs: true,
         reduce_vars: true,
         side_effects: true,
         unused: true,
@@ -130,6 +134,7 @@ side_effects_label: {
 
 side_effects_switch: {
     options = {
+        reduce_funcs: true,
         reduce_vars: true,
         side_effects: true,
         unused: true,

test/compress/issue-1750.js

@@ -7,7 +7,7 @@ case_1: {
     input: {
         var a = 0, b = 1;
         switch (true) {
-          case a, true:
+          case a || true:
           default:
             b = 2;
           case true:
@@ -17,7 +17,7 @@ case_1: {
     expect: {
         var a = 0, b = 1;
         switch (true) {
-          case a, true:
+          case a || true:
             b = 2;
         }
         console.log(a, b);

test/compress/issue-1770.js

@@ -1,5 +1,7 @@
 mangle_props: {
-    mangle_props = {}
+    mangle = {
+        properties: true,
+    }
     input: {
         var obj = {
             undefined: 1,
@@ -54,10 +56,12 @@ mangle_props: {
 }
 
 numeric_literal: {
+    mangle = {
+        properties: true,
+    }
     beautify = {
         beautify: true,
     }
-    mangle_props = {}
     input: {
         var obj = {
             0: 0,
@@ -80,19 +84,19 @@ numeric_literal: {
         '    0: 0,',
         '    "-0": 1,',
         '    42: 2,',
-        '    "42": 3,',
+        '    42: 3,',
         '    37: 4,',
-        '    a: 5,',
+        '    o: 5,',
         '    1e42: 6,',
         '    b: 7,',
-        '    "1e+42": 8',
+        '    1e42: 8',
         '};',
         '',
         'console.log(obj[-0], obj[-""], obj["-0"]);',
         '',
         'console.log(obj[42], obj["42"]);',
         '',
-        'console.log(obj[37], obj["a"], obj[37], obj["37"]);',
+        'console.log(obj[37], obj["o"], obj[37], obj["37"]);',
         '',
         'console.log(obj[1e42], obj["b"], obj["1e+42"]);',
     ]

test/compress/issue-1787.js

@@ -1,6 +1,8 @@
 unary_prefix: {
     options = {
         evaluate: true,
+        inline: true,
+        reduce_funcs: true,
         reduce_vars: true,
         unused: true,
     }

test/compress/issue-1833.js

@@ -1,6 +1,7 @@
 iife_for: {
     options = {
         negate_iife: true,
+        reduce_funcs: true,
         reduce_vars: true,
         toplevel: true,
         unused: true,
@@ -26,6 +27,7 @@ iife_for: {
 iife_for_in: {
     options = {
         negate_iife: true,
+        reduce_funcs: true,
         reduce_vars: true,
         toplevel: true,
         unused: true,
@@ -51,6 +53,7 @@ iife_for_in: {
 iife_do: {
     options = {
         negate_iife: true,
+        reduce_funcs: true,
         reduce_vars: true,
         toplevel: true,
         unused: true,
@@ -80,6 +83,7 @@ iife_do: {
 iife_while: {
     options = {
         negate_iife: true,
+        reduce_funcs: true,
         reduce_vars: true,
         toplevel: true,
         unused: true,
@@ -130,5 +134,5 @@ label_while: {
             L: while (0) continue L;
         }
     }
-    expect_exact: "function f(){L:;}"
+    expect_exact: "function f(){L:0}"
 }

test/compress/issue-2001.js

@@ -45,7 +45,7 @@ export_default_func_1: {
     input: {
         export default function f(){};
     }
-    expect_exact: "export default function(){};"
+    expect_exact: "export default function f(){};"
 }
 
 export_default_func_2: {
@@ -58,7 +58,7 @@ export_default_func_2: {
     input: {
         export default function f(){}(1);
     }
-    expect_exact: "export default function(){};1;"
+    expect_exact: "export default function f(){};1;"
 }
 
 export_default_func_3: {
@@ -71,7 +71,7 @@ export_default_func_3: {
     input: {
         export default function f(){}(1);
     }
-    expect_exact: "export default function(){};"
+    expect_exact: "export default function f(){};"
 }
 
 export_class_1: {
@@ -121,7 +121,7 @@ export_default_class_1: {
     input: {
         export default class C {};
     }
-    expect_exact: "export default class{};"
+    expect_exact: "export default class C{};"
 }
 
 export_default_class_2: {
@@ -134,7 +134,7 @@ export_default_class_2: {
     input: {
         export default class C {}(1);
     }
-    expect_exact: "export default class{};1;"
+    expect_exact: "export default class C{};1;"
 }
 
 export_default_class_3: {
@@ -147,7 +147,7 @@ export_default_class_3: {
     input: {
         export default class C {}(1);
     }
-    expect_exact: "export default class{};"
+    expect_exact: "export default class C{};"
 }
 
 export_mangle_1: {
@@ -159,7 +159,7 @@ export_mangle_1: {
             return one - two;
         };
     }
-    expect_exact: "export function foo(n,o){return n-o};"
+    expect_exact: "export function foo(o,n){return o-n};"
 }
 
 export_mangle_2: {
@@ -171,12 +171,13 @@ export_mangle_2: {
             return one - two;
         };
     }
-    expect_exact: "export default function n(n,r){return n-r};"
+    expect_exact: "export default function foo(o,t){return o-t};"
 }
 
 export_mangle_3: {
     options = {
         collapse_vars: true,
+        unused: true,
     }
     mangle = {
         toplevel: true,
@@ -189,12 +190,13 @@ export_mangle_3: {
             }
         };
     }
-    expect_exact: "export class C{go(n,r){return n-r+n}};"
+    expect_exact: "export class C{go(r,e){return r-e+r}};"
 }
 
 export_mangle_4: {
     options = {
         collapse_vars: true,
+        unused: true,
     }
     mangle = {
         toplevel: true,
@@ -207,7 +209,7 @@ export_mangle_4: {
             }
         };
     }
-    expect_exact: "export default class n{go(n,r){return n-r+n}};"
+    expect_exact: "export default class C{go(e,r){return e-r+e}};"
 }
 
 export_mangle_5: {
@@ -221,7 +223,7 @@ export_mangle_5: {
             }
         };
     }
-    expect_exact: "export default{prop:function(n,r){return n-r}};"
+    expect_exact: "export default{prop:function(r,t){return r-t}};"
 }
 
 export_mangle_6: {
@@ -232,7 +234,7 @@ export_mangle_6: {
         var baz = 2;
         export let foo = 1, bar = baz;
     }
-    expect_exact: "var a=2;export let foo=1,bar=a;"
+    expect_exact: "var o=2;export let foo=1,bar=o;"
 }
 
 export_toplevel_1: {
@@ -247,7 +249,7 @@ export_toplevel_1: {
     }
     expect: {
         export function g(){};
-        export default function(){};
+        export default function h(){};
     }
 }
 
@@ -263,7 +265,7 @@ export_toplevel_2: {
     }
     expect: {
         export class B {};
-        export default class {};
+        export default class C {};
     }
 }
 

test/compress/issue-203.js

@@ -1,19 +1,21 @@
 
 compress_new_function: {
     options = {
-        unsafe: true
+        unsafe: true,
+        unsafe_Function: true,
     }
     input: {
         new Function("aa, bb", 'return aa;');
     }
     expect: {
-        Function("a", "b", "return a");
+        Function("n,r", "return n");
     }
 }
 
 compress_new_function_with_destruct: {
     options = {
         unsafe: true,
+        unsafe_Function: true,
         ecma: 6
     }
     beautify = {
@@ -25,10 +27,31 @@ compress_new_function_with_destruct: {
         new Function("[[aa]], [{bb}]", 'return aa;');
     }
     expect: {
-        Function("a", "[b]", "return a");
+        Function("n,[r]", "return n");
-        Function("a", "{bb}", "return a");
+        Function("n,{bb:b}", "return n");
-        Function("[[a]]", "[{bb}]", 'return a');
+        Function("[[n]],[{bb:b}]", "return n");
     }
 }
 
-
+compress_new_function_with_destruct_arrows: {
+    options = {
+        arrows: true,
+        unsafe_arrows: true,
+        unsafe: true,
+        unsafe_Function: true,
+        ecma: 6,
+    }
+    beautify = {
+        ecma: 6
+    }
+    input: {
+        new Function("aa, [bb]", 'return aa;');
+        new Function("aa, {bb}", 'return aa;');
+        new Function("[[aa]], [{bb}]", 'return aa;');
+    }
+    expect: {
+        Function("n,[a]", "return n");
+        Function("b,{bb:n}", "return b");
+        Function("[[b]],[{bb:n}]", "return b");
+    }
+}

test/compress/issue-2652.js

@@ -0,0 +1,33 @@
+insert_semicolon: {
+    beautify = {
+        beautify: true,
+        comments: "all",
+    }
+    input: {
+        var a
+        /* foo */ var b
+    }
+    expect_exact: [
+        "var a",
+        "/* foo */;",
+        "",
+        "var b;",
+    ]
+}
+
+unary_postfix: {
+    beautify = {
+        beautify: true,
+        comments: "all",
+    }
+    input: {
+        a
+        /* foo */++b
+    }
+    expect_exact: [
+        "a",
+        "/* foo */;",
+        "",
+        "++b;",
+    ]
+}

test/compress/issue-269.js

@@ -64,3 +64,27 @@ strings_concat: {
 		);
 	}
 }
+
+regexp: {
+	options = {
+		evaluate: true,
+		unsafe: true,
+	}
+	input: {
+		RegExp("foo");
+		RegExp("bar", "ig");
+		RegExp(foo);
+		RegExp("bar", ig);
+		RegExp("should", "fail");
+	}
+	expect: {
+		/foo/;
+		/bar/ig;
+		RegExp(foo);
+		RegExp("bar", ig);
+		RegExp("should", "fail");
+	}
+	expect_warnings: [
+		'WARN: Error converting RegExp("should","fail") [test/compress/issue-269.js:78,2]',
+	]
+}

test/compress/issue-2719.js

@@ -0,0 +1,32 @@
+warn: {
+    options = {
+        evaluate: true,
+        inline: true,
+        passes: 2,
+        properties: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            return g();
+        }
+        function g() {
+            return g["call" + "er"].arguments;
+        }
+        // 3
+        console.log(f(1, 2, 3).length);
+    }
+    expect: {
+        // TypeError: Cannot read property 'arguments' of null
+        console.log(function g() {
+            return g.caller.arguments;
+        }().length);
+    }
+    expect_warnings: [
+        "WARN: Function.protoype.caller not supported [test/compress/issue-2719.js:17,19]",
+        "WARN: Function.protoype.arguments not supported [test/compress/issue-2719.js:17,19]",
+    ]
+}

test/compress/issue-281.js

@@ -0,0 +1,498 @@
+collapse_vars_constants: {
+    options = {
+        collapse_vars: true,
+        evaluate: true,
+        inline: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        function f1(x) {
+            var a = 4, b = x.prop, c = 5, d = sideeffect1(), e = sideeffect2();
+            return b + (function() { return d - a * e - c; })();
+        }
+        function f2(x) {
+            var a = 4, b = x.prop, c = 5, not_used = sideeffect1(), e = sideeffect2();
+            return b + (function() { return -a * e - c; })();
+        }
+    }
+    expect: {
+        function f1(x) {
+            var b = x.prop, d = sideeffect1(), e = sideeffect2();
+            return b + (d - 4 * e - 5);
+        }
+        function f2(x) {
+            var b = x.prop;
+            sideeffect1();
+            return b + (-4 * sideeffect2() - 5);
+        }
+    }
+}
+
+modified: {
+    options = {
+        collapse_vars: true,
+        inline: true,
+        unused: true,
+    }
+    input: {
+        function f5(b) {
+            var a = function() {
+                return b;
+            }();
+            return b++ + a;
+        }
+        console.log(f5(1));
+    }
+    expect: {
+        function f5(b) {
+            var a = b;
+            return b++ + a;
+        }
+        console.log(f5(1));
+    }
+    expect_stdout: "2"
+}
+
+ref_scope: {
+    options = {
+        collapse_vars: true,
+        inline: true,
+        unused: true,
+    }
+    input: {
+        console.log(function() {
+            var a = 1, b = 2, c = 3;
+            var a = c++, b = b /= a;
+            return function() {
+                return a;
+            }() + b;
+        }());
+    }
+    expect: {
+        console.log(function() {
+            var a = 1, b = 2, c = 3;
+            b = b /= a = c++;
+            return a + b;
+        }());
+    }
+    expect_stdout: true
+}
+
+safe_undefined: {
+    options = {
+        conditionals: true,
+        if_return: true,
+        inline: true,
+        unsafe: false,
+        unused: true,
+    }
+    mangle = {}
+    input: {
+        var a, c;
+        console.log(function(undefined) {
+            return function() {
+                if (a)
+                    return b;
+                if (c)
+                    return d;
+            };
+        }(1)());
+    }
+    expect: {
+        var a, c;
+        console.log(a ? b : c ? d : void 0);
+    }
+    expect_stdout: true
+}
+
+negate_iife_3: {
+    options = {
+        conditionals: true,
+        expression: true,
+        inline: true,
+        negate_iife: true,
+    }
+    input: {
+        (function(){ return t })() ? console.log(true) : console.log(false);
+    }
+    expect: {
+        t ? console.log(true) : console.log(false);
+    }
+}
+
+negate_iife_3_off: {
+    options = {
+        conditionals: true,
+        expression: true,
+        inline: true,
+        negate_iife: false,
+    }
+    input: {
+        (function(){ return t })() ? console.log(true) : console.log(false);
+    }
+    expect: {
+        t ? console.log(true) : console.log(false);
+    }
+}
+
+negate_iife_4: {
+    options = {
+        conditionals: true,
+        expression: true,
+        inline: true,
+        negate_iife: true,
+        sequences: true,
+    }
+    input: {
+        (function(){ return t })() ? console.log(true) : console.log(false);
+        (function(){
+            console.log("something");
+        })();
+    }
+    expect: {
+        t ? console.log(true) : console.log(false), void console.log("something");
+    }
+}
+
+negate_iife_5: {
+    options = {
+        conditionals: true,
+        expression: true,
+        inline: true,
+        negate_iife: true,
+        sequences: true,
+    }
+    input: {
+        if ((function(){ return t })()) {
+            foo(true);
+        } else {
+            bar(false);
+        }
+        (function(){
+            console.log("something");
+        })();
+    }
+    expect: {
+        t ? foo(true) : bar(false), void console.log("something");
+    }
+}
+
+negate_iife_5_off: {
+    options = {
+        conditionals: true,
+        expression: true,
+        inline: true,
+        negate_iife: false,
+        sequences: true,
+    };
+    input: {
+        if ((function(){ return t })()) {
+            foo(true);
+        } else {
+            bar(false);
+        }
+        (function(){
+            console.log("something");
+        })();
+    }
+    expect: {
+        t ? foo(true) : bar(false), void console.log("something");
+    }
+}
+
+issue_1254_negate_iife_true: {
+    options = {
+        expression: true,
+        inline: true,
+        negate_iife: true,
+    }
+    input: {
+        (function() {
+            return function() {
+                console.log('test')
+            };
+        })()();
+    }
+    expect_exact: 'void console.log("test");'
+    expect_stdout: true
+}
+
+issue_1254_negate_iife_nested: {
+    options = {
+        expression: true,
+        inline: true,
+        negate_iife: true,
+    }
+    input: {
+        (function() {
+            return function() {
+                console.log('test')
+            };
+        })()()()()();
+    }
+    expect_exact: '(void console.log("test"))()()();'
+}
+
+negate_iife_issue_1073: {
+    options = {
+        conditionals: true,
+        evaluate: true,
+        inline: true,
+        negate_iife: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        sequences: true,
+        unused: true,
+    };
+    input: {
+        new (function(a) {
+            return function Foo() {
+                this.x = a;
+                console.log(this);
+            };
+        }(7))();
+    }
+    expect: {
+        new function() {
+            this.x = 7,
+            console.log(this);
+        }();
+    }
+    expect_stdout: true
+}
+
+issue_1288_side_effects: {
+    options = {
+        conditionals: true,
+        evaluate: true,
+        inline: true,
+        negate_iife: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        side_effects: true,
+        unused: true,
+    };
+    input: {
+        if (w) ;
+        else {
+            (function f() {})();
+        }
+        if (!x) {
+            (function() {
+                x = {};
+            })();
+        }
+        if (y)
+            (function() {})();
+        else
+            (function(z) {
+                return z;
+            })(0);
+    }
+    expect: {
+        w;
+        x || (x = {});
+        y;
+    }
+}
+
+inner_var_for_in_1: {
+    options = {
+        evaluate: true,
+        inline: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+    }
+    input: {
+        function f() {
+            var a = 1, b = 2;
+            for (b in (function() {
+                return x(a, b, c);
+            })()) {
+                var c = 3, d = 4;
+                x(a, b, c, d);
+            }
+            x(a, b, c, d);
+        }
+    }
+    expect: {
+        function f() {
+            var a = 1, b = 2;
+            for (b in x(1, b, c)) {
+                var c = 3, d = 4;
+                x(1, b, c, d);
+            }
+            x(1, b, c, d);
+        }
+    }
+}
+
+issue_1595_3: {
+    options = {
+        evaluate: true,
+        inline: true,
+        passes: 2,
+        reduce_funcs: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        (function f(a) {
+            return g(a + 1);
+        })(2);
+    }
+    expect: {
+        g(3);
+    }
+}
+
+issue_1758: {
+    options = {
+        inline: true,
+        sequences: true,
+        side_effects: true,
+    }
+    input: {
+        console.log(function(c) {
+            var undefined = 42;
+            return function() {
+                c--;
+                c--, c.toString();
+                return;
+            }();
+        }());
+    }
+    expect: {
+        console.log(function(c) {
+            var undefined = 42;
+            return c--, c--, void c.toString();
+        }());
+    }
+    expect_stdout: "undefined"
+}
+wrap_iife: {
+    options = {
+        inline: true,
+        negate_iife: false,
+    }
+    beautify = {
+        wrap_iife: true,
+    }
+    input: {
+        (function() {
+            return function() {
+                console.log('test')
+            };
+        })()();
+    }
+    expect_exact: 'void console.log("test");'
+}
+
+wrap_iife_in_expression: {
+    options = {
+        inline: true,
+        negate_iife: false,
+    }
+    beautify = {
+        wrap_iife: true,
+    }
+    input: {
+        foo = (function () {
+            return bar();
+        })();
+    }
+    expect_exact: 'foo=bar();'
+}
+
+wrap_iife_in_return_call: {
+    options = {
+        inline: true,
+        negate_iife: false,
+    }
+    beautify = {
+        wrap_iife: true,
+    }
+    input: {
+        (function() {
+            return (function() {
+                console.log('test')
+            })();
+        })()();
+    }
+    expect_exact: '(void console.log("test"))();'
+}
+
+pure_annotation_1: {
+    options = {
+        inline: true,
+        side_effects: true,
+    }
+    input: {
+        /*@__PURE__*/(function() {
+            console.log("hello");
+        }());
+    }
+    expect_exact: ""
+}
+
+pure_annotation_2: {
+    options = {
+        collapse_vars: true,
+        inline: true,
+        side_effects: true,
+    }
+    input: {
+        /*@__PURE__*/(function(n) {
+            console.log("hello", n);
+        }(42));
+    }
+    expect_exact: ""
+}
+
+drop_fargs: {
+    options = {
+        collapse_vars: true,
+        inline: true,
+        keep_fargs: false,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        var a = 1;
+        !function(a_1) {
+            a++;
+        }(a++ + (a && a.var));
+        console.log(a);
+    }
+    expect: {
+        var a = 1;
+        ++a && a.var, a++;
+        console.log(a);
+    }
+    expect_stdout: "3"
+}
+
+keep_fargs: {
+    options = {
+        collapse_vars: true,
+        inline: true,
+        keep_fargs: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        var a = 1;
+        !function(a_1) {
+            a++;
+        }(a++ + (a && a.var));
+        console.log(a);
+    }
+    expect: {
+        var a = 1;
+        ++a && a.var, a++;
+        console.log(a);
+    }
+    expect_stdout: "3"
+}

test/compress/issue-2871.js

@@ -0,0 +1,37 @@
+comparison_with_undefined: {
+    options = {
+        comparisons: true,
+    }
+    input: {
+        a == undefined;
+        a != undefined;
+        a === undefined;
+        a !== undefined;
+
+        undefined == a;
+        undefined != a;
+        undefined === a;
+        undefined !== a;
+
+        void 0 == a;
+        void 0 != a;
+        void 0 === a;
+        void 0 !== a;
+    }
+    expect: {
+        null == a;
+        null != a;
+        void 0 === a;
+        void 0 !== a;
+
+        null == a;
+        null != a;
+        void 0 === a;
+        void 0 !== a;
+
+        null == a;
+        null != a;
+        void 0 === a;
+        void 0 !== a;
+    }
+}

test/compress/issue-368.js

@@ -1,6 +1,6 @@
 collapse: {
     options = {
-        cascade: true,
+        collapse_vars: true,
         sequences: true,
         side_effects: true,
         unused: true,
@@ -41,7 +41,7 @@ collapse: {
             return void 0 !== ('function' === typeof b ? b() : b) && c();
         }
         function f2(b) {
-            return b = c(), 'stirng' == typeof ('function' === typeof b ? b() : b) && d();
+            return 'stirng' == typeof ('function' === typeof (b = c()) ? b() : b) && d();
         }
         function f3(c) {
             var a;

test/compress/issue-637.js

@@ -17,6 +17,6 @@ wrongly_optimized: {
             foo();
         }
         // TODO: optimize to `func(), bar()`
-        (func(), 0) || bar();
+        (func(), 1) && bar();
     }
 }

test/compress/issue-640.js

@@ -100,7 +100,7 @@ wrongly_optimized: {
             foo();
         }
         // TODO: optimize to `func(), bar()`
-        if (func(), !0) bar();
+        if (func(), 1) bar();
     }
 }
 

test/compress/issue-747.js

@@ -1,37 +1,45 @@
 dont_reuse_prop: {
-    mangle_props = {
+    mangle = {
-        regex: /asd/
+        properties: {
-    };
+            regex: /asd/,
-
+        },
+    }
     input: {
+        "aaaaaaaaaabbbbb";
         var obj = {};
         obj.a = 123;
         obj.asd = 256;
         console.log(obj.a);
     }
     expect: {
+        "aaaaaaaaaabbbbb";
         var obj = {};
         obj.a = 123;
         obj.b = 256;
         console.log(obj.a);
     }
+    expect_stdout: "123"
 }
 
 unmangleable_props_should_always_be_reserved: {
-    mangle_props = {
+    mangle = {
-        regex: /asd/
+        properties: {
-    };
+            regex: /asd/,
-
+        },
+    }
     input: {
+        "aaaaaaaaaabbbbb";
         var obj = {};
         obj.asd = 256;
         obj.a = 123;
         console.log(obj.a);
     }
     expect: {
+        "aaaaaaaaaabbbbb";
         var obj = {};
         obj.b = 256;
         obj.a = 123;
         console.log(obj.a);
     }
+    expect_stdout: "123"
 }

test/compress/issue-892.js

@@ -18,7 +18,6 @@ dont_mangle_arguments: {
         hoist_vars    : true,
         if_return     : true,
         join_vars     : true,
-        cascade       : true,
         side_effects  : true,
         negate_iife   : false
     };

test/compress/issue-973.js

@@ -1,7 +1,8 @@
 this_binding_conditionals: {
     options = {
         conditionals: true,
-        evaluate    : true
+        evaluate: true,
+        side_effects: true,
     };
     input: {
         (1 && a)();
@@ -51,6 +52,7 @@ this_binding_collapse_vars: {
     options = {
         collapse_vars: true,
         toplevel: true,
+        unused: true,
     };
     input: {
         var c = a; c();

test/compress/issue-976.js

@@ -2,7 +2,7 @@ eval_collapse_vars: {
     options = {
         collapse_vars:true, sequences:false, properties:true, dead_code:true, conditionals:true,
         comparisons:true, evaluate:true, booleans:true, loops:true, unused:true, hoist_funs:true,
-        keep_fargs:true, if_return:true, join_vars:true, cascade:true, side_effects:true
+        keep_fargs:true, if_return:true, join_vars:true, side_effects:true
     };
     input: {
         function f1() {

test/compress/issue-979.js

@@ -2,7 +2,7 @@ issue979_reported: {
     options = {
         sequences:true, properties:true, dead_code:true, conditionals:true,
         comparisons:true, evaluate:true, booleans:true, loops:true, unused:true, hoist_funs:true,
-        keep_fargs:true, if_return:true, join_vars:true, cascade:true, side_effects:true
+        keep_fargs:true, if_return:true, join_vars:true, side_effects:true
     }
     input: {
         function f1() {
@@ -32,7 +32,7 @@ issue979_test_negated_is_best: {
     options = {
         sequences:true, properties:true, dead_code:true, conditionals:true,
         comparisons:true, evaluate:true, booleans:true, loops:true, unused:true, hoist_funs:true,
-        keep_fargs:true, if_return:true, join_vars:true, cascade:true, side_effects:true
+        keep_fargs:true, if_return:true, join_vars:true, side_effects:true
     }
     input: {
         function f3() {

test/compress/loops.js

@@ -192,9 +192,11 @@ keep_collapse_const_in_own_block_scope_2: {
 
 evaluate: {
     options = {
-        loops: true,
         dead_code: true,
         evaluate: true,
+        loops: true,
+        passes: 2,
+        side_effects: true,
     };
     input: {
         while (true) {
@@ -480,3 +482,236 @@ do_switch: {
         } while (false);
     }
 }
+
+in_parenthesis_1: {
+    input: {
+        for (("foo" in {});0;);
+    }
+    expect_exact: 'for(("foo"in{});0;);'
+}
+
+in_parenthesis_2: {
+    input: {
+        for ((function(){ "foo" in {}; });0;);
+    }
+    expect_exact: 'for(function(){"foo"in{}};0;);'
+}
+
+init_side_effects: {
+    options = {
+        loops: true,
+        side_effects: true,
+    };
+    input: {
+        for (function() {}(), i = 0; i < 5; i++) console.log(i);
+        for (function() {}(); i < 10; i++) console.log(i);
+    }
+    expect: {
+        for (i = 0; i < 5; i++) console.log(i);
+        for (; i < 10; i++) console.log(i);
+    }
+    expect_stdout: true
+}
+
+dead_code_condition: {
+    options = {
+        dead_code: true,
+        evaluate: true,
+        loops: true,
+        sequences: true,
+    }
+    input: {
+        for (var a = 0, b = 5; (a += 1, 3) - 3 && b > 0; b--) {
+            var c = function() {
+                b--;
+            }(a++);
+        }
+        console.log(a);
+    }
+    expect: {
+        var c;
+        var a = 0, b = 5;
+        a += 1, 0,
+        console.log(a);
+    }
+    expect_stdout: "1"
+}
+
+issue_2740_1: {
+    options = {
+        dead_code: true,
+        loops: true,
+    }
+    input: {
+        for (; ; ) break;
+        for (a(); ; ) break;
+        for (; b(); ) break;
+        for (c(); d(); ) break;
+        for (; ; e()) break;
+        for (f(); ; g()) break;
+        for (; h(); i()) break;
+        for (j(); k(); l()) break;
+    }
+    expect: {
+        a();
+        b();
+        c();
+        d();
+        f();
+        h();
+        j();
+        k();
+    }
+}
+
+issue_2740_2: {
+    options = {
+        dead_code: true,
+        loops: true,
+        passes: 2,
+    }
+    input: {
+        L1: while (x()) {
+            break L1;
+        }
+    }
+    expect: {
+        x();
+    }
+}
+
+issue_2740_3: {
+    options = {
+        dead_code: true,
+        loops: true,
+    }
+    input: {
+        L1: for (var x = 0; x < 3; x++) {
+            L2: for (var y = 0; y < 2; y++) {
+                break L1;
+            }
+        }
+        console.log(x, y);
+    }
+    expect: {
+        L1: for (var x = 0; x < 3; x++)
+            for (var y = 0; y < 2; y++)
+                break L1;
+        console.log(x, y);
+    }
+    expect_stdout: "0 0"
+}
+
+issue_2740_4: {
+    options = {
+        dead_code: true,
+        loops: true,
+        passes: 2,
+    }
+    input: {
+        L1: for (var x = 0; x < 3; x++) {
+            L2: for (var y = 0; y < 2; y++) {
+                break L2;
+            }
+        }
+        console.log(x, y);
+    }
+    expect: {
+        for (var x = 0; x < 3; x++) {
+            var y = 0;
+            y < 2;
+        }
+        console.log(x, y);
+    }
+    expect_stdout: "3 0"
+}
+
+issue_2740_5: {
+    options = {
+        dead_code: true,
+        loops: true,
+        passes: 2,
+    }
+    input: {
+        L1: for (var x = 0; x < 3; x++) {
+            break L1;
+            L2: for (var y = 0; y < 2; y++) {
+                break L2;
+            }
+        }
+        console.log(x, y);
+    }
+    expect: {
+        var x = 0;
+        x < 3;
+        var y;
+        console.log(x,y);
+    }
+    expect_stdout: "0 undefined"
+}
+
+issue_2740_6: {
+    options = {
+        dead_code: true,
+        loops: true,
+    }
+    input: {
+        const a = 9, b = 0;
+        for (const a = 1; a < 3; ++b) break;
+        console.log(a, b);
+    }
+    expect: {
+        const a = 9, b = 0;
+        {
+            const a = 1;
+            a < 3;
+        }
+        console.log(a, b);
+    }
+    expect_stdout: "9 0"
+    node_version: ">=6"
+}
+
+issue_2740_7: {
+    options = {
+        dead_code: true,
+        loops: true,
+    }
+    input: {
+        let a = 9, b = 0;
+        for (const a = 1; a < 3; ++b) break;
+        console.log(a, b);
+    }
+    expect: {
+        let a = 9, b = 0;
+        {
+            const a = 1;
+            a < 3;
+        }
+        console.log(a, b);
+    }
+    expect_stdout: "9 0"
+    node_version: ">=6"
+}
+
+issue_2740_8: {
+    options = {
+        dead_code: true,
+        loops: true,
+    }
+    input: {
+        var a = 9, b = 0;
+        for (const a = 1; a < 3; ++b) break;
+        console.log(a, b);
+    }
+    expect: {
+        var a = 9, b = 0;
+        {
+            const a = 1;
+            a < 3;
+        }
+        console.log(a, b);
+    }
+    expect_stdout: "9 0"
+    node_version: ">=6"
+}

test/compress/negate-iife.js

@@ -22,7 +22,8 @@ negate_iife_1_off: {
 
 negate_iife_2: {
     options = {
-        negate_iife: true
+        inline: true,
+        negate_iife: true,
     };
     input: {
         (function(){ return {} })().x = 10;
@@ -32,6 +33,7 @@ negate_iife_2: {
 
 negate_iife_2_side_effects: {
     options = {
+        inline: true,
         negate_iife: true,
         side_effects: true,
     }
@@ -58,6 +60,7 @@ negate_iife_3_evaluate: {
     options = {
         conditionals: true,
         evaluate: true,
+        inline: true,
         negate_iife: true,
     }
     input: {
@@ -100,6 +103,7 @@ negate_iife_3_off_evaluate: {
     options = {
         conditionals: true,
         evaluate: true,
+        inline: true,
         negate_iife: false,
     }
     input: {

test/compress/new.js

@@ -98,3 +98,19 @@ new_with_assignement_expression: {
         new y([a, b] = [3, 4]);
     }
 }
+
+dot_parenthesis_1: {
+    input: {
+        console.log(new (Math.random().constructor) instanceof Number);
+    }
+    expect_exact: "console.log(new(Math.random().constructor)instanceof Number);"
+    expect_stdout: "true"
+}
+
+dot_parenthesis_2: {
+    input: {
+        console.log(typeof new function(){Math.random()}.constructor);
+    }
+    expect_exact: "console.log(typeof new function(){Math.random()}.constructor);"
+    expect_stdout: "function"
+}

test/compress/node_version.js

@@ -1,4 +1,4 @@
-eval_let: {
+eval_let_6: {
     input: {
         eval("let a;");
         console.log();
@@ -10,3 +10,29 @@ eval_let: {
     expect_stdout: ""
     node_version: ">=6"
 }
+
+eval_let_4: {
+    input: {
+        eval("let a;");
+        console.log();
+    }
+    expect: {
+        eval("let a;");
+        console.log();
+    }
+    expect_stdout: SyntaxError("Block-scoped declarations (let, const, function, class) not yet supported outside strict mode")
+    node_version: "4"
+}
+
+eval_let_0: {
+    input: {
+        eval("let a;");
+        console.log();
+    }
+    expect: {
+        eval("let a;");
+        console.log();
+    }
+    expect_stdout: SyntaxError("Unexpected identifier")
+    node_version: "<=0.12"
+}

test/compress/object.js

@@ -105,7 +105,7 @@ getter_setter_mangler: {
             };
         }
     }
-    expect_exact: "function f(n,t){return{get:n,set:t,get g(){},set s(n){},c,a:1,m(){}}}"
+    expect_exact: "function f(t,e){return{get:t,set:e,get g(){},set s(t){},c,a:1,m(){}}}"
 }
 
 use_shorthand_opportunity: {
@@ -126,6 +126,67 @@ computed_property_names: {
     expect_exact: 'obj({["x"+"x"]:6});'
 }
 
+convert_computed_props_to_regular_ones: {
+    options = {
+        booleans: true,
+        computed_props: true,
+        evaluate: true,
+    }
+    input: {
+        var o = {
+            ["hi"]: 0,
+            ["A" + 1]: 1,
+            [/B/]: 2,
+            [100 + 23]: 3,
+            [1 + .5]: 4,
+            [Math.PI]: 5,
+            [undefined]: 6,
+            [true]: 7,
+            [false]: 8,
+            [null]: 9,
+            [Infinity]: 10,
+            [NaN]: 11,
+        };
+        for (var k in o) {
+            console.log(k, o[k]);
+        }
+    }
+    expect: {
+        var o = {
+            hi: 0,
+            A1: 1,
+            [/B/]: 2,
+            123: 3,
+            1.5: 4,
+            [Math.PI]: 5,
+
+            // leave these problematic cases as is
+            [void 0]: 6,
+            [!0]: 7,
+            [!1]: 8,
+            [null]: 9,
+            [1 / 0]: 10,
+            [NaN]: 11
+        };
+        for (var k in o) console.log(k, o[k]);
+    }
+    expect_stdout: [
+        "123 3",
+        "hi 0",
+        "A1 1",
+        "/B/ 2",
+        "1.5 4",
+        "3.141592653589793 5",
+        "undefined 6",
+        "true 7",
+        "false 8",
+        "null 9",
+        "Infinity 10",
+        "NaN 11",
+    ]
+    node_version: ">=6"
+}
+
 computed_property_names_evaluated_1: {
     options = {
         evaluate: true
@@ -284,9 +345,11 @@ concise_methods_with_various_property_names: {
 }
 
 concise_methods_and_mangle_props: {
-    mangle_props = {
+    mangle = {
-        regex: /_/
+        properties: {
-    };
+            regex: /_/,
+        },
+    }
     input: {
         function x() {
             obj = {
@@ -297,7 +360,7 @@ concise_methods_and_mangle_props: {
     expect: {
         function x() {
             obj = {
-                a() { return 1; }
+                o() { return 1; }
             }
         }
     }
@@ -510,3 +573,443 @@ variable_as_computed_property: {
     }
     expect_exact: "function getLine(header){return{[header]:{}}}"
 }
+
+prop_func_to_concise_method: {
+    options = {
+        ecma: 6,
+        unsafe_methods: true,
+    }
+    input: {
+        ({
+            emit: function NamedFunctionExpression() {
+                console.log("PASS");
+            },
+            run: function() {
+                this.emit();
+            }
+        }).run();
+    }
+    expect: {
+        ({
+            emit: function NamedFunctionExpression() {
+                console.log("PASS");
+            },
+            run() {
+                this.emit();
+            }
+        }).run();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+prop_arrow_to_concise_method: {
+    options = {
+        ecma: 6,
+        unsafe_methods: true,
+    }
+    input: {
+        ({
+            run: () => {
+                console.log("PASS");
+            }
+        }).run();
+    }
+    expect: {
+        ({
+            run() {
+                console.log("PASS");
+            }
+        }).run();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+concise_method_to_prop_arrow: {
+    options = {
+        arrows: true,
+        ecma: 6,
+    }
+    input: {
+        console.log(({ a: () => 1 }).a());
+        console.log(({ a: () => { return 2; } }).a());
+        console.log(({ a() { return 3; } }).a());
+        console.log(({ a() { return this.b; }, b: 4 }).a());
+    }
+    expect: {
+        console.log({ a: () => 1 }.a());
+        console.log({ a: () => 2 }.a());
+        console.log({ a: () => 3 }.a());
+        console.log({ a() { return this.b; }, b: 4 }.a());
+    }
+    expect_stdout: [
+        "1",
+        "2",
+        "3",
+        "4",
+    ]
+    node_version: ">=4"
+}
+
+prop_func_to_async_concise_method: {
+    options = {
+        ecma: 8,
+        unsafe_methods: true,
+    }
+    input: {
+        ({
+            run: async function() {
+                console.log("PASS");
+            }
+        }).run();
+    }
+    expect: {
+        ({
+            async run() {
+                console.log("PASS");
+            }
+        }).run();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=8"
+}
+
+prop_func_to_concise_method_various: {
+    options = {
+        ecma: 6,
+        unsafe_methods: true,
+    }
+    input: {
+        ({
+            null: function(x, y){ x(y); },
+            123: function(x, y){ x(y); },
+            "A B": function(x, y){ x(y); },
+            p1: function(x, y){ x(y); },
+            p2: function*(x, y){ yield x(y); },
+            p3: async function(x, y){ await x(y); },
+            [c1]: function(x, y){ x(y); },
+            [c2]: function*(x, y){ yield x(y); },
+            [c3]: async function(x, y){ await x(y); },
+        });
+    }
+    expect: {
+        ({
+            null(x, y) { x(y); },
+            123(x, y) { x(y); },
+            "A B"(x, y) { x(y); },
+            p1(x, y) { x(y); },
+            *p2(x, y) { yield x(y); },
+            async p3(x, y) { await x(y); },
+            [c1](x, y) { x(y); },
+            *[c2](x, y) { yield x(y); },
+            async [c3](x, y) { await x(y); },
+        });
+    }
+}
+
+prop_arrows_to_concise_method_various: {
+    options = {
+        ecma: 6,
+        unsafe_methods: true,
+    }
+    input: {
+        ({
+            null: (x, y) => { x(y); },
+            123: (x, y) => { x(y); },
+            "A B": (x, y) => { x(y); },
+            p1: (x, y) => { x(y); },
+            p3: async (x, y) => { await x(y); },
+            [c1]: (x, y) => { x(y); },
+            [c3]: async (x, y) => { await x(y); },
+        });
+    }
+    expect: {
+        ({
+            null(x, y) { x(y); },
+            123(x, y) { x(y); },
+            "A B"(x, y) { x(y); },
+            p1(x, y) { x(y); },
+            async p3(x, y) { await x(y); },
+            [c1](x, y) { x(y); },
+            async [c3](x, y) { await x(y); },
+        });
+    }
+}
+
+prop_arrow_with_this: {
+    options = {
+        ecma: 6,
+        unsafe_methods: true,
+    }
+    input: {
+        function run(arg) {
+            console.log(arg === this ? "global" : arg === foo ? "foo" : arg);
+        }
+        var foo = {
+            func_no_this: function() { run(); },
+            func_with_this: function() { run(this); },
+            arrow_no_this: () => { run(); },
+            arrow_with_this: () => { run(this); },
+        };
+        for (var key in foo) foo[key]();
+    }
+    expect: {
+        function run(arg) {
+            console.log(arg === this ? "global" : arg === foo ? "foo" : arg);
+        }
+        var foo = {
+            func_no_this() { run(); },
+            func_with_this() { run(this); },
+            arrow_no_this() { run(); },
+            arrow_with_this: () => { run(this); },
+        };
+        for (var key in foo) foo[key]();
+    }
+    expect_stdout: [
+        "undefined",
+        "foo",
+        "undefined",
+        "global",
+    ]
+    node_version: ">=4"
+}
+
+prop_arrow_with_nested_this: {
+    options = {
+        ecma: 6,
+        unsafe_methods: true,
+    }
+    input: {
+        function run(arg) {
+            console.log(arg === this ? "global" : arg === foo ? "foo" : arg);
+        }
+        var foo = {
+            func_func_this: function() { (function() { run(this); })(); },
+            func_arrow_this: function() { (() => { run(this); })(); },
+            arrow_func_this: () => { (function() { run(this); })(); },
+            arrow_arrow_this: () => { (() => { run(this); })(); },
+        };
+        for (var key in foo) foo[key]();
+    }
+    expect: {
+        function run(arg) {
+            console.log(arg === this ? "global" : arg === foo ? "foo" : arg);
+        }
+        var foo = {
+            func_func_this() { (function() { run(this); })(); },
+            func_arrow_this() { (() => { run(this); })(); },
+            arrow_func_this() { (function() { run(this); })(); },
+            arrow_arrow_this: () => { (() => { run(this); })(); },
+        };
+        for (var key in foo) foo[key]();
+    }
+    expect_stdout: [
+        "global",
+        "foo",
+        "global",
+        "global",
+    ]
+    node_version: ">=4"
+}
+
+issue_2554_1: {
+    options = {
+        computed_props: true,
+        evaluate: true,
+    }
+    input: {
+        var obj = {
+            ["x" + ""]: 1,
+            ["method" + ""]() {
+                this.s = "PASS";
+            },
+            get ["g" + ""]() {
+                return this.x;
+            },
+            set ["s" + ""](value) {
+                this.x = value;
+            }
+        };
+        obj.method();
+        console.log(obj.g);
+    }
+    expect: {
+        var obj = {
+            x: 1,
+            method() {
+                this.s = "PASS";
+            },
+            get g() {
+                return this.x;
+            },
+            set s(value) {
+                this.x = value;
+            }
+        };
+        obj.method();
+        console.log(obj.g);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_2554_2: {
+    options = {
+        computed_props: true,
+        evaluate: true,
+    }
+    input: {
+        var instance = new class {
+            constructor() {
+                this.x = 2;
+            }
+            ["method" + ""]() {
+                this.s = "PASS";
+            }
+            get ["g" + ""]() {
+                return this.x;
+            }
+            set ["s" + ""](value) {
+                this.x = value;
+            }
+        }();
+        instance.method();
+        console.log(instance.g);
+    }
+    expect: {
+        var instance = new class {
+            constructor() {
+                this.x = 2;
+            }
+            method() {
+                this.s = "PASS";
+            }
+            get g() {
+                return this.x;
+            }
+            set s(value) {
+                this.x = value;
+            }
+        }();
+        instance.method();
+        console.log(instance.g);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_2554_3: {
+    options = {
+        computed_props: true,
+        evaluate: true,
+    }
+    input: {
+        var foo = {
+            [1 + 0]: 1,
+            [2 + 0]() {
+                this[4] = "PASS";
+            },
+            get [3 + 0]() {
+                return this[1];
+            },
+            set [4 + 0](value) {
+                this[1] = value;
+            }
+        };
+        foo[2]();
+        console.log(foo[3]);
+    }
+    expect: {
+        var foo = {
+            1: 1,
+            2() {
+                this[4] = "PASS";
+            },
+            get 3() {
+                return this[1];
+            },
+            set 4(value) {
+                this[1] = value;
+            }
+        };
+        foo[2]();
+        console.log(foo[3]);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_2554_4: {
+    options = {
+        computed_props: true,
+        evaluate: true,
+    }
+    input: {
+        var bar = new class {
+            constructor() {
+                this[1] = 2;
+            }
+            [2 + 0]() {
+                this[4] = "PASS";
+            }
+            get [3 + 0]() {
+                return this[1];
+            }
+            set [4 + 0](value) {
+                this[1] = value;
+            }
+        }();
+        bar[2]();
+        console.log(bar[3]);
+    }
+    expect: {
+        var bar = new class {
+            constructor() {
+                this[1] = 2;
+            }
+            2() {
+                this[4] = "PASS";
+            }
+            get 3() {
+                return this[1];
+            }
+            set 4(value) {
+                this[1] = value;
+            }
+        }();
+        bar[2]();
+        console.log(bar[3]);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_2554_5: {
+    options = {
+        computed_props: true,
+        evaluate: true,
+    }
+    input: {
+        new class {
+            ["constructor"]() {
+                console.log("FAIL");
+            }
+            "constructor"() {
+                console.log("PASS");
+            }
+        }();
+    }
+    expect: {
+        new class {
+            ["constructor"]() {
+                console.log("FAIL");
+            }
+            constructor() {
+                console.log("PASS");
+            }
+        }();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}

test/compress/parameters.js

@@ -1,4 +1,7 @@
 arrow_functions: {
+    options = {
+        arrows: true,
+    }
     input: {
         (a) => b;  // 1 args
         (a, b) => c;  // n args
@@ -13,6 +16,9 @@ arrow_functions: {
 }
 
 arrow_return: {
+    options = {
+        arrows: true,
+    }
     input: {
         () => {};
         () => { return; };
@@ -136,11 +142,11 @@ destructuring_arguments_3: {
     }
     input: {
         function fn3({x: {y: {z: {} = 42}}}) {}
-        const { cover = (function () {}), xCover = (0, function() {})  } = {};
+        const { a = (function () {}), b = (0, function() {})  } = {};
-        let { cover = (function () {}), xCover = (0, function() {})  } = {};
+        let { c = (function () {}), d = (0, function() {})  } = {};
-        var { cover = (function () {}), xCover = (0, function() {})  } = {};
+        var { e = (function () {}), f = (0, function() {})  } = {};
     }
-    expect_exact: "function fn3({x:{y:{z:{}=42}}}){}const{cover=function(){},xCover=(0,function(){})}={};let{cover=function(){},xCover=(0,function(){})}={};var{cover=function(){},xCover=(0,function(){})}={};"
+    expect_exact: "function fn3({x:{y:{z:{}=42}}}){}const{a=function(){},b=(0,function(){})}={};let{c=function(){},d=(0,function(){})}={};var{e=function(){},f=(0,function(){})}={};"
 }
 
 default_arguments: {

test/compress/pure_funcs.js

@@ -293,3 +293,245 @@ unary: {
         bar();
     }
 }
+
+issue_2629_1: {
+    options = {
+        side_effects: true,
+    }
+    beautify = {
+        comments: "all",
+    }
+    input: {
+        /*@__PURE__*/ a();
+        /*@__PURE__*/ (b());
+        (/*@__PURE__*/ c)();
+        (/*@__PURE__*/ d());
+    }
+    expect_exact: [
+        "/* */c();",
+    ]
+}
+
+issue_2629_2: {
+    options = {
+        side_effects: true,
+    }
+    beautify = {
+        comments: "all",
+    }
+    input: {
+        /*@__PURE__*/ a(1)(2)(3);
+        /*@__PURE__*/ (b(1))(2)(3);
+        /*@__PURE__*/ (c(1)(2))(3);
+        /*@__PURE__*/ (d(1)(2)(3));
+        (/*@__PURE__*/ e)(1)(2)(3);
+        (/*@__PURE__*/ f(1))(2)(3);
+        (/*@__PURE__*/ g(1)(2))(3);
+        (/*@__PURE__*/ h(1)(2)(3));
+    }
+    expect_exact: [
+        "/* */e(1)(2)(3);",
+        "/* */f(1)(2)(3);",
+        "/* */g(1)(2)(3);",
+    ]
+}
+
+issue_2629_3: {
+    options = {
+        side_effects: true,
+    }
+    beautify = {
+        comments: "all",
+    }
+    input: {
+        /*@__PURE__*/ a.x(1).y(2).z(3);
+        /*@__PURE__*/ (b.x)(1).y(2).z(3);
+        /*@__PURE__*/ (c.x(1)).y(2).z(3);
+        /*@__PURE__*/ (d.x(1).y)(2).z(3);
+        /*@__PURE__*/ (e.x(1).y(2)).z(3);
+        /*@__PURE__*/ (f.x(1).y(2).z)(3);
+        /*@__PURE__*/ (g.x(1).y(2).z(3));
+        (/*@__PURE__*/ h).x(1).y(2).z(3);
+        (/*@__PURE__*/ i.x)(1).y(2).z(3);
+        (/*@__PURE__*/ j.x(1)).y(2).z(3);
+        (/*@__PURE__*/ k.x(1).y)(2).z(3);
+        (/*@__PURE__*/ l.x(1).y(2)).z(3);
+        (/*@__PURE__*/ m.x(1).y(2).z)(3);
+        (/*@__PURE__*/ n.x(1).y(2).z(3));
+    }
+    expect_exact: [
+        "/* */h.x(1).y(2).z(3);",
+        "/* */i.x(1).y(2).z(3);",
+        "/* */j.x(1).y(2).z(3);",
+        "/* */k.x(1).y(2).z(3);",
+        "/* */l.x(1).y(2).z(3);",
+        "/* */m.x(1).y(2).z(3);",
+    ]
+}
+
+issue_2629_4: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        (/*@__PURE__*/ x(), y());
+        (w(), /*@__PURE__*/ x(), y());
+    }
+    expect: {
+        y();
+        w(), y();
+    }
+}
+
+issue_2629_5: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        [ /*@__PURE__*/ x() ];
+        [ /*@__PURE__*/ x(), y() ];
+        [ w(), /*@__PURE__*/ x(), y() ];
+    }
+    expect: {
+        y();
+        w(), y();
+    }
+}
+
+issue_2638: {
+    options = {
+        side_effects: true,
+    }
+    beautify = {
+        comments: "all",
+    }
+    input: {
+        /*@__PURE__*/(g() || h())(x(), y());
+        (/*@__PURE__*/ (a() || b()))(c(), d());
+    }
+    expect_exact: [
+        "/* */x(),y();",
+        "/* */(a()||b())(c(),d());",
+    ]
+}
+
+issue_2705_1: {
+    options = {
+        side_effects: true,
+    }
+    beautify = {
+        comments: "all",
+    }
+    input: {
+        /*@__PURE__*/ new a();
+        /*@__PURE__*/ (new b());
+        new (/*@__PURE__*/ c)();
+        (/*@__PURE__*/ new d());
+    }
+    expect_exact: [
+        "new/* */c;",
+    ]
+}
+
+issue_2705_2: {
+    options = {
+        side_effects: true,
+    }
+    beautify = {
+        comments: "all",
+    }
+    input: {
+        /*@__PURE__*/ new a(1)(2)(3);
+        /*@__PURE__*/ new (b(1))(2)(3);
+        /*@__PURE__*/ new (c(1)(2))(3);
+        /*@__PURE__*/ new (d(1)(2)(3));
+        new (/*@__PURE__*/ e)(1)(2)(3);
+        (/*@__PURE__*/ new f(1))(2)(3);
+        (/*@__PURE__*/ new g(1)(2))(3);
+        (/*@__PURE__*/ new h(1)(2)(3));
+    }
+    expect_exact: [
+        "new/* */e(1)(2)(3);",
+        "/* */new f(1)(2)(3);",
+        "/* */new g(1)(2)(3);",
+    ]
+}
+
+issue_2705_3: {
+    options = {
+        side_effects: true,
+    }
+    beautify = {
+        comments: "all",
+    }
+    input: {
+        /*@__PURE__*/ new a.x(1).y(2).z(3);
+        /*@__PURE__*/ new (b.x)(1).y(2).z(3);
+        /*@__PURE__*/ new (c.x(1)).y(2).z(3);
+        /*@__PURE__*/ new (d.x(1).y)(2).z(3);
+        /*@__PURE__*/ new (e.x(1).y(2)).z(3);
+        /*@__PURE__*/ new (f.x(1).y(2).z)(3);
+        /*@__PURE__*/ new (g.x(1).y(2).z(3));
+        new (/*@__PURE__*/ h).x(1).y(2).z(3);
+        /* */ new (/*@__PURE__*/ i.x)(1).y(2).z(3);
+        (/*@__PURE__*/ new j.x(1)).y(2).z(3);
+        (/*@__PURE__*/ new k.x(1).y)(2).z(3);
+        (/*@__PURE__*/ new l.x(1).y(2)).z(3);
+        (/*@__PURE__*/ new m.x(1).y(2).z)(3);
+        (/*@__PURE__*/ new n.x(1).y(2).z(3));
+    }
+    expect_exact: [
+        "new/* */h.x(1).y(2).z(3);",
+        "/* */new/* */i.x(1).y(2).z(3);",
+        "/* */new j.x(1).y(2).z(3);",
+        "/* */new k.x(1).y(2).z(3);",
+        "/* */new l.x(1).y(2).z(3);",
+        "/* */new m.x(1).y(2).z(3);",
+    ]
+}
+
+issue_2705_4: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        (/*@__PURE__*/ new x(), y());
+        (w(), /*@__PURE__*/ new x(), y());
+    }
+    expect: {
+        y();
+        w(), y();
+    }
+}
+
+issue_2705_5: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        [ /*@__PURE__*/ new x() ];
+        [ /*@__PURE__*/ new x(), y() ];
+        [ w(), /*@__PURE__*/ new x(), y() ];
+    }
+    expect: {
+        y();
+        w(), y();
+    }
+}
+
+issue_2705_6: {
+    options = {
+        side_effects: true,
+    }
+    beautify = {
+        comments: "all",
+    }
+    input: {
+        /*@__PURE__*/new (g() || h())(x(), y());
+        /* */ new (/*@__PURE__*/ (a() || b()))(c(), d());
+    }
+    expect_exact: [
+        "/* */x(),y();",
+        "/* */new(/* */a()||b())(c(),d());",
+    ]
+}

test/compress/pure_getters.js

@@ -1,6 +1,7 @@
 strict: {
     options = {
         pure_getters: "strict",
+        reduce_funcs: false,
         reduce_vars: false,
         side_effects: true,
         toplevel: true,
@@ -30,6 +31,7 @@ strict: {
 strict_reduce_vars: {
     options = {
         pure_getters: "strict",
+        reduce_funcs: true,
         reduce_vars: true,
         side_effects: true,
         toplevel: true,
@@ -58,6 +60,7 @@ strict_reduce_vars: {
 unsafe: {
     options = {
         pure_getters: true,
+        reduce_funcs: false,
         reduce_vars: false,
         side_effects: true,
         toplevel: true,
@@ -84,6 +87,7 @@ unsafe: {
 unsafe_reduce_vars: {
     options = {
         pure_getters: true,
+        reduce_funcs: true,
         reduce_vars: true,
         side_effects: true,
         toplevel: true,
@@ -178,3 +182,666 @@ impure_getter_2: {
     }
     expect: {}
 }
+
+issue_2110_1: {
+    options = {
+        collapse_vars: true,
+        pure_getters: "strict",
+        sequences: true,
+        side_effects: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            function f() {}
+            function g() {
+                return this;
+            }
+            f.g = g;
+            return f.g();
+        }
+        console.log(typeof f());
+    }
+    expect: {
+        function f() {
+            function f() {}
+            return f.g = function() {
+                return this;
+            }, f.g();
+        }
+        console.log(typeof f());
+    }
+    expect_stdout: "function"
+}
+
+issue_2110_2: {
+    options = {
+        collapse_vars: true,
+        pure_getters: "strict",
+        reduce_funcs: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            function f() {}
+            function g() {
+                return this;
+            }
+            f.g = g;
+            return f.g();
+        }
+        console.log(typeof f());
+    }
+    expect: {
+        function f() {
+            function f() {}
+            f.g = function() {
+                return this;
+            };
+            return f.g();
+        }
+        console.log(typeof f());
+    }
+    expect_stdout: "function"
+}
+
+set_immutable_1: {
+    options = {
+        collapse_vars: true,
+        evaluate: true,
+        pure_getters: "strict",
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = 1;
+        a.foo += "";
+        if (a.foo) console.log("FAIL");
+        else console.log("PASS");
+    }
+    expect: {
+        1..foo += "";
+        if (1..foo) console.log("FAIL");
+        else console.log("PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+set_immutable_2: {
+    options = {
+        collapse_vars: true,
+        conditionals: true,
+        pure_getters: "strict",
+        reduce_funcs: true,
+        reduce_vars: true,
+        sequences: true,
+        side_effects: true,
+        toplevel: true,
+    }
+    input: {
+        var a = 1;
+        a.foo += "";
+        if (a.foo) console.log("FAIL");
+        else console.log("PASS");
+    }
+    expect: {
+        var a = 1;
+        a.foo += "", a.foo ? console.log("FAIL") : console.log("PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+set_immutable_3: {
+    options = {
+        collapse_vars: true,
+        evaluate: true,
+        pure_getters: "strict",
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        var a = 1;
+        a.foo += "";
+        if (a.foo) console.log("FAIL");
+        else console.log("PASS");
+    }
+    expect: {
+        "use strict";
+        1..foo += "";
+        if (1..foo) console.log("FAIL");
+        else console.log("PASS");
+    }
+    expect_stdout: true
+}
+
+set_immutable_4: {
+    options = {
+        collapse_vars: true,
+        conditionals: true,
+        pure_getters: "strict",
+        reduce_funcs: true,
+        reduce_vars: true,
+        sequences: true,
+        side_effects: true,
+        toplevel: true,
+    }
+    input: {
+        "use strict";
+        var a = 1;
+        a.foo += "";
+        if (a.foo) console.log("FAIL");
+        else console.log("PASS");
+    }
+    expect: {
+        "use strict";
+        var a = 1;
+        a.foo += "", a.foo ? console.log("FAIL") : console.log("PASS");
+    }
+    expect_stdout: true
+}
+
+set_immutable_5: {
+    options = {
+        collapse_vars: true,
+        conditionals: true,
+        evaluate: true,
+        pure_getters: "strict",
+        reduce_funcs: true,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        var a = 1;
+        a.foo += "";
+        if (a.foo) console.log("FAIL");
+        else console.log("PASS");
+    }
+    expect: {
+        "use strict";
+        1..foo += "";
+        1..foo ? console.log("FAIL") : console.log("PASS");
+    }
+    expect_stdout: true
+}
+
+set_immutable_6: {
+    options = {
+        collapse_vars: true,
+        conditionals: true,
+        evaluate: true,
+        pure_getters: "strict",
+        reduce_funcs: true,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = 1;
+        a.foo += "";
+        if (a.foo) console.log("FAIL");
+        else console.log("PASS");
+    }
+    expect: {
+        1..foo ? console.log("FAIL") : console.log("PASS");
+    }
+    expect_stdout: true
+}
+
+set_mutable_1: {
+    options = {
+        collapse_vars: true,
+        evaluate: true,
+        pure_getters: "strict",
+        reduce_funcs: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        !function a() {
+            a.foo += "";
+            if (a.foo) console.log("PASS");
+            else console.log("FAIL");
+        }();
+    }
+    expect: {
+        !function a() {
+            if (a.foo += "") console.log("PASS");
+            else console.log("FAIL");
+        }();
+    }
+    expect_stdout: "PASS"
+}
+
+set_mutable_2: {
+    options = {
+        collapse_vars: true,
+        conditionals: true,
+        pure_getters: "strict",
+        reduce_funcs: true,
+        reduce_vars: true,
+        sequences: true,
+        side_effects: true,
+    }
+    input: {
+        !function a() {
+            a.foo += "";
+            if (a.foo) console.log("PASS");
+            else console.log("FAIL");
+        }();
+    }
+    expect: {
+        !function a() {
+            (a.foo += "") ? console.log("PASS") : console.log("FAIL");
+        }();
+    }
+    expect_stdout: "PASS"
+}
+
+issue_2265_1: {
+    options = {
+        pure_getters: "strict",
+        side_effects: true,
+    }
+    input: {
+        ({ ...{} }).p;
+        ({ ...g }).p;
+    }
+    expect: {
+        ({ ...g }).p;
+    }
+}
+
+issue_2265_2: {
+    options = {
+        pure_getters: "strict",
+        reduce_funcs: true,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+    }
+    input: {
+        var a = {
+            get b() {
+                throw 0;
+            }
+        };
+        ({...a}).b;
+    }
+    expect: {
+        var a = {
+            get b() {
+                throw 0;
+            }
+        };
+        ({...a}).b;
+    }
+}
+
+issue_2265_3: {
+    options = {
+        pure_getters: "strict",
+        reduce_funcs: true,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = {
+            set b() {
+                throw 0;
+            }
+        };
+        ({...a}).b;
+    }
+    expect: {}
+}
+
+issue_2265_4: {
+    options = {
+        pure_getters: "strict",
+        reduce_funcs: true,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = { b: 1 };
+        ({...a}).b;
+    }
+    expect: {}
+}
+
+issue_2313_1: {
+    options = {
+        collapse_vars: true,
+        conditionals: true,
+        pure_getters: "strict",
+        sequences: true,
+        side_effects: true,
+    }
+    input: {
+        function x() {
+            console.log(1);
+            return {
+                y: function() {
+                    console.log(2);
+                    return {
+                        z: 0
+                    };
+                }
+            };
+        }
+        x().y().z++;
+        if (x().y().z) {
+            console.log(3);
+        }
+    }
+    expect: {
+        function x() {
+            return console.log(1), {
+                y: function() {
+                    return console.log(2), {
+                        z: 0
+                    };
+                }
+            };
+        }
+        x().y().z++,
+        x().y().z && console.log(3);
+    }
+    expect_stdout: [
+        "1",
+        "2",
+        "1",
+        "2",
+    ]
+}
+
+issue_2313_2: {
+    options = {
+        collapse_vars: true,
+        conditionals: true,
+        pure_getters: true,
+        sequences: true,
+        side_effects: true,
+    }
+    input: {
+        function x() {
+            console.log(1);
+            return {
+                y: function() {
+                    console.log(2);
+                    return {
+                        z: 0
+                    };
+                }
+            };
+        }
+        x().y().z++;
+        if (x().y().z) {
+            console.log(3);
+        }
+    }
+    expect: {
+        function x() {
+            return console.log(1), {
+                y: function() {
+                    return console.log(2), {
+                        z: 0
+                    };
+                }
+            };
+        }
+        x().y().z++,
+        x().y().z && console.log(3);
+    }
+    expect_stdout: [
+        "1",
+        "2",
+        "1",
+        "2",
+    ]
+}
+
+issue_2313_3: {
+    options = {
+        collapse_vars: true,
+        conditionals: true,
+        pure_getters: "strict",
+    }
+    input: {
+        function x() {
+            console.log(1);
+            return {
+                y: function() {
+                    console.log(2);
+                    return {
+                        z: 0
+                    };
+                }
+            };
+        }
+        x().y().z++;
+        if (x().y().z) {
+            console.log(3);
+        }
+    }
+    expect: {
+        function x() {
+            console.log(1);
+            return {
+                y: function() {
+                    console.log(2);
+                    return {
+                        z: 0
+                    };
+                }
+            };
+        }
+        x().y().z++;
+        x().y().z && console.log(3);
+    }
+    expect_stdout: [
+        "1",
+        "2",
+        "1",
+        "2",
+    ]
+}
+
+issue_2313_4: {
+    options = {
+        collapse_vars: true,
+        conditionals: true,
+        pure_getters: true,
+    }
+    input: {
+        function x() {
+            console.log(1);
+            return {
+                y: function() {
+                    console.log(2);
+                    return {
+                        z: 0
+                    };
+                }
+            };
+        }
+        x().y().z++;
+        if (x().y().z) {
+            console.log(3);
+        }
+    }
+    expect: {
+        function x() {
+            console.log(1);
+            return {
+                y: function() {
+                    console.log(2);
+                    return {
+                        z: 0
+                    };
+                }
+            };
+        }
+        x().y().z++;
+        x().y().z && console.log(3);
+    }
+    expect_stdout: [
+        "1",
+        "2",
+        "1",
+        "2",
+    ]
+}
+
+issue_2313_5: {
+    options = {
+        pure_getters: "strict",
+        side_effects: true,
+    }
+    input: {
+        x().y++;
+        x().y;
+    }
+    expect: {
+        x().y++;
+        x().y;
+    }
+}
+
+issue_2313_6: {
+    options = {
+        pure_getters: true,
+        side_effects: true,
+    }
+    input: {
+        x().y++;
+        x().y;
+    }
+    expect: {
+        x().y++;
+        x();
+    }
+}
+
+issue_2313_7: {
+    options = {
+        collapse_vars: true,
+        conditionals: true,
+        pure_getters: true,
+    }
+    input: {
+        var a = 0, b = 0;
+        class foo {
+            get c() {
+                a++;
+                return 42;
+            }
+            set c(c) {
+                b++;
+            }
+        }
+        class bar extends foo {
+            d() {
+                super.c++;
+                if (super.c) console.log(a, b);
+            }
+        }
+        new bar().d();
+    }
+    expect: {
+        var a = 0, b = 0;
+        class foo {
+            get c() {
+                a++;
+                return 42;
+            }
+            set c(c) {
+                b++;
+            }
+        }
+        class bar extends foo {
+            d() {
+                super.c++;
+                super.c && console.log(a, b);
+            }
+        }
+        new bar().d();
+    }
+    expect_stdout: "2 1"
+    node_version: ">=6"
+}
+
+issue_2678: {
+    options = {
+        pure_getters: "strict",
+        side_effects: true,
+    }
+    input: {
+        var a = 1, c = "FAIL";
+        (function f() {
+            (a-- && f()).p;
+            return {
+                get p() {
+                    c = "PASS";
+                }
+            };
+        })();
+        console.log(c);
+    }
+    expect: {
+        var a = 1, c = "FAIL";
+        (function f() {
+            (a-- && f()).p;
+            return {
+                get p() {
+                    c = "PASS";
+                }
+            };
+        })();
+        console.log(c);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_2838: {
+    options = {
+        pure_getters: true,
+        side_effects: true,
+    }
+    input: {
+        function f(a, b) {
+            (a || b).c = "PASS";
+            (function() {
+                return f(a, b);
+            }).prototype.foo = "bar";
+        }
+        var o = {};
+        f(null, o);
+        console.log(o.c);
+    }
+    expect: {
+        function f(a, b) {
+            (a || b).c = "PASS";
+        }
+        var o = {};
+        f(null, o);
+        console.log(o.c);
+    }
+    expect_stdout: "PASS"
+}

test/compress/rename.js

@@ -0,0 +1,536 @@
+mangle_catch: {
+    rename = true
+    options = {
+        ie8: false,
+        toplevel: false,
+    }
+    mangle = {
+        ie8: false,
+        toplevel: false,
+    }
+    input: {
+        var a = "FAIL";
+        try {
+            throw 1;
+        } catch (args) {
+            a = "PASS";
+        }
+        console.log(a);
+    }
+    expect_exact: 'var a="FAIL";try{throw 1}catch(o){a="PASS"}console.log(a);'
+    expect_stdout: "PASS"
+}
+
+mangle_catch_ie8: {
+    rename = true
+    options = {
+        ie8: true,
+        toplevel: false,
+    }
+    mangle = {
+        ie8: true,
+        toplevel: false,
+    }
+    input: {
+        var a = "FAIL";
+        try {
+            throw 1;
+        } catch (args) {
+            a = "PASS";
+        }
+        console.log(a);
+    }
+    expect_exact: 'var a="FAIL";try{throw 1}catch(args){a="PASS"}console.log(a);'
+    expect_stdout: "PASS"
+}
+
+mangle_catch_var: {
+    rename = true
+    options = {
+        ie8: false,
+        toplevel: false,
+    }
+    mangle = {
+        ie8: false,
+        toplevel: false,
+    }
+    input: {
+        var a = "FAIL";
+        try {
+            throw 1;
+        } catch (args) {
+            var a = "PASS";
+        }
+        console.log(a);
+    }
+    expect_exact: 'var a="FAIL";try{throw 1}catch(o){var a="PASS"}console.log(a);'
+    expect_stdout: "PASS"
+}
+
+mangle_catch_var_ie8: {
+    rename = true
+    options = {
+        ie8: true,
+        toplevel: false,
+    }
+    mangle = {
+        ie8: true,
+        toplevel: false,
+    }
+    input: {
+        var a = "FAIL";
+        try {
+            throw 1;
+        } catch (args) {
+            var a = "PASS";
+        }
+        console.log(a);
+    }
+    expect_exact: 'var a="FAIL";try{throw 1}catch(args){var a="PASS"}console.log(a);'
+    expect_stdout: "PASS"
+}
+
+mangle_catch_toplevel: {
+    rename = true
+    options = {
+        ie8: false,
+        toplevel: true,
+    }
+    mangle = {
+        ie8: false,
+        toplevel: true,
+    }
+    input: {
+        var a = "FAIL";
+        try {
+            throw 1;
+        } catch (args) {
+            a = "PASS";
+        }
+        console.log(a);
+    }
+    expect_exact: 'var o="FAIL";try{throw 1}catch(c){o="PASS"}console.log(o);'
+    expect_stdout: "PASS"
+}
+
+mangle_catch_ie8_toplevel: {
+    rename = true
+    options = {
+        ie8: true,
+        toplevel: true,
+    }
+    mangle = {
+        ie8: true,
+        toplevel: true,
+    }
+    input: {
+        var a = "FAIL";
+        try {
+            throw 1;
+        } catch (args) {
+            a = "PASS";
+        }
+        console.log(a);
+    }
+    expect_exact: 'var o="FAIL";try{throw 1}catch(c){o="PASS"}console.log(o);'
+    expect_stdout: "PASS"
+}
+
+mangle_catch_var_toplevel: {
+    rename = true
+    options = {
+        ie8: false,
+        toplevel: true,
+    }
+    mangle = {
+        ie8: false,
+        toplevel: true,
+    }
+    input: {
+        var a = "FAIL";
+        try {
+            throw 1;
+        } catch (args) {
+            var a = "PASS";
+        }
+        console.log(a);
+    }
+    expect_exact: 'var o="FAIL";try{throw 1}catch(r){var o="PASS"}console.log(o);'
+    expect_stdout: "PASS"
+}
+
+mangle_catch_var_ie8_toplevel: {
+    rename = true
+    options = {
+        ie8: true,
+        toplevel: true,
+    }
+    mangle = {
+        ie8: true,
+        toplevel: true,
+    }
+    input: {
+        var a = "FAIL";
+        try {
+            throw 1;
+        } catch (args) {
+            var a = "PASS";
+        }
+        console.log(a);
+    }
+    expect_exact: 'var o="FAIL";try{throw 1}catch(r){var o="PASS"}console.log(o);'
+    expect_stdout: "PASS"
+}
+
+mangle_catch_redef_1: {
+    rename = true
+    options = {
+        ie8: false,
+        toplevel: false,
+    }
+    mangle = {
+        ie8: false,
+        toplevel: false,
+    }
+    input: {
+        var a = "PASS";
+        try {
+            throw "FAIL1";
+        } catch (a) {
+            var a = "FAIL2";
+        }
+        console.log(a);
+    }
+    expect_exact: 'var a="PASS";try{throw"FAIL1"}catch(a){var a="FAIL2"}console.log(a);'
+    expect_stdout: "PASS"
+}
+
+mangle_catch_redef_1_ie8: {
+    rename = true
+    options = {
+        ie8: true,
+        toplevel: false,
+    }
+    mangle = {
+        ie8: true,
+        toplevel: false,
+    }
+    input: {
+        var a = "PASS";
+        try {
+            throw "FAIL1";
+        } catch (a) {
+            var a = "FAIL2";
+        }
+        console.log(a);
+    }
+    expect_exact: 'var a="PASS";try{throw"FAIL1"}catch(a){var a="FAIL2"}console.log(a);'
+    expect_stdout: "PASS"
+}
+
+mangle_catch_redef_1_toplevel: {
+    rename = true
+    options = {
+        ie8: false,
+        toplevel: true,
+    }
+    mangle = {
+        ie8: false,
+        toplevel: true,
+    }
+    input: {
+        var a = "PASS";
+        try {
+            throw "FAIL1";
+        } catch (a) {
+            var a = "FAIL2";
+        }
+        console.log(a);
+    }
+    expect_exact: 'var o="PASS";try{throw"FAIL1"}catch(o){var o="FAIL2"}console.log(o);'
+    expect_stdout: "PASS"
+}
+
+mangle_catch_redef_1_ie8_toplevel: {
+    rename = true
+    options = {
+        ie8: true,
+        toplevel: true,
+    }
+    mangle = {
+        ie8: true,
+        toplevel: true,
+    }
+    input: {
+        var a = "PASS";
+        try {
+            throw "FAIL1";
+        } catch (a) {
+            var a = "FAIL2";
+        }
+        console.log(a);
+    }
+    expect_exact: 'var o="PASS";try{throw"FAIL1"}catch(o){var o="FAIL2"}console.log(o);'
+    expect_stdout: "PASS"
+}
+
+mangle_catch_redef_2: {
+    rename = true
+    options = {
+        ie8: false,
+        toplevel: false,
+    }
+    mangle = {
+        ie8: false,
+        toplevel: false,
+    }
+    input: {
+        try {
+            throw "FAIL1";
+        } catch (a) {
+            var a = "FAIL2";
+        }
+        console.log(a);
+    }
+    expect_exact: 'try{throw"FAIL1"}catch(a){var a="FAIL2"}console.log(a);'
+    expect_stdout: "undefined"
+}
+
+mangle_catch_redef_2_ie8: {
+    rename = true
+    options = {
+        ie8: true,
+        toplevel: false,
+    }
+    mangle = {
+        ie8: true,
+        toplevel: false,
+    }
+    input: {
+        try {
+            throw "FAIL1";
+        } catch (a) {
+            var a = "FAIL2";
+        }
+        console.log(a);
+    }
+    expect_exact: 'try{throw"FAIL1"}catch(a){var a="FAIL2"}console.log(a);'
+    expect_stdout: "undefined"
+}
+
+mangle_catch_redef_2_toplevel: {
+    rename = true
+    options = {
+        ie8: false,
+        toplevel: true,
+    }
+    mangle = {
+        ie8: false,
+        toplevel: true,
+    }
+    input: {
+        try {
+            throw "FAIL1";
+        } catch (a) {
+            var a = "FAIL2";
+        }
+        console.log(a);
+    }
+    expect_exact: 'try{throw"FAIL1"}catch(o){var o="FAIL2"}console.log(o);'
+    expect_stdout: "undefined"
+}
+
+mangle_catch_redef_2_ie8_toplevel: {
+    rename = true
+    options = {
+        ie8: true,
+        toplevel: true,
+    }
+    mangle = {
+        ie8: true,
+        toplevel: true,
+    }
+    input: {
+        try {
+            throw "FAIL1";
+        } catch (a) {
+            var a = "FAIL2";
+        }
+        console.log(a);
+    }
+    expect_exact: 'try{throw"FAIL1"}catch(o){var o="FAIL2"}console.log(o);'
+    expect_stdout: "undefined"
+}
+
+issue_2120_1: {
+    rename = true
+    mangle = {
+        ie8: false,
+    }
+    input: {
+        "aaaaaaaa";
+        var a = 1, b = "FAIL";
+        try {
+            throw 1;
+        } catch (c) {
+            try {
+                throw 0;
+            } catch (a) {
+                if (c) b = "PASS";
+            }
+        }
+        console.log(b);
+    }
+    expect: {
+        "aaaaaaaa";
+        var a = 1, b = "FAIL";
+        try {
+            throw 1;
+        } catch (t) {
+            try {
+                throw 0;
+            } catch (a) {
+                if (t) b = "PASS";
+            }
+        }
+        console.log(b);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_2120_2: {
+    rename = true
+    mangle = {
+        ie8: true,
+    }
+    input: {
+        "aaaaaaaa";
+        var a = 1, b = "FAIL";
+        try {
+            throw 1;
+        } catch (c) {
+            try {
+                throw 0;
+            } catch (a) {
+                if (c) b = "PASS";
+            }
+        }
+        console.log(b);
+    }
+    expect: {
+        "aaaaaaaa";
+        var a = 1, b = "FAIL";
+        try {
+            throw 1;
+        } catch (c) {
+            try {
+                throw 0;
+            } catch (a) {
+                if (c) b = "PASS";
+            }
+        }
+        console.log(b);
+    }
+    expect_stdout: "PASS"
+}
+function_iife_catch: {
+    rename = true
+    mangle = {
+        ie8: false,
+    }
+    input: {
+        function f(n) {
+            !function() {
+                try {
+                    throw 0;
+                } catch (n) {
+                    var a = 1;
+                    console.log(n, a);
+                }
+            }();
+        }
+        f();
+    }
+    expect_exact: "function f(o){!function(){try{throw 0}catch(c){var o=1;console.log(c,o)}}()}f();"
+    expect_stdout: "0 1"
+}
+
+function_iife_catch_ie8: {
+    rename = true
+    mangle = {
+        ie8: true,
+    }
+    input: {
+        function f(n) {
+            !function() {
+                try {
+                    throw 0;
+                } catch (n) {
+                    var a = 1;
+                    console.log(n, a);
+                }
+            }();
+        }
+        f();
+    }
+    expect_exact: "function f(o){!function(){try{throw 0}catch(o){var c=1;console.log(o,c)}}()}f();"
+    expect_stdout: "0 1"
+}
+
+function_catch_catch: {
+    rename = true
+    mangle = {
+        ie8: false,
+    }
+    input: {
+        var o = 0;
+        function f() {
+            try {
+                throw 1;
+            } catch (c) {
+                try {
+                    throw 2;
+                } catch (o) {
+                    var o = 3;
+                    console.log(o);
+                }
+            }
+            console.log(o);
+        }
+        f();
+    }
+    expect_exact: "var o=0;function f(){try{throw 1}catch(c){try{throw 2}catch(o){var o=3;console.log(o)}}console.log(o)}f();"
+    expect_stdout: [
+        "3",
+        "undefined",
+    ]
+}
+
+function_catch_catch_ie8: {
+    rename = true
+    mangle = {
+        ie8: true,
+    }
+    input: {
+        var o = 0;
+        function f() {
+            try {
+                throw 1;
+            } catch (c) {
+                try {
+                    throw 2;
+                } catch (o) {
+                    var o = 3;
+                    console.log(o);
+                }
+            }
+            console.log(o);
+        }
+        f();
+    }
+    expect_exact: "var o=0;function f(){try{throw 1}catch(c){try{throw 2}catch(o){var o=3;console.log(o)}}console.log(o)}f();"
+    expect_stdout: [
+        "3",
+        "undefined",
+    ]
+}

test/compress/return_undefined.js

@@ -17,7 +17,6 @@ return_undefined: {
         keep_fnames   : false,
         hoist_vars    : true,
         join_vars     : true,
-        cascade       : true,
         negate_iife   : true
     };
     input: {
@@ -122,3 +121,25 @@ return_undefined: {
         }
     }
 }
+
+return_void: {
+    options = {
+        if_return: true,
+        inline: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            function g() {
+                h();
+            }
+            return g();
+        }
+    }
+    expect: {
+        function f() {
+            h();
+        }
+    }
+}

test/compress/sandbox.js

@@ -0,0 +1,14 @@
+console_log: {
+    input: {
+        console.log("%% %s");
+        console.log("%% %s", "%s");
+    }
+    expect: {
+        console.log("%% %s");
+        console.log("%% %s", "%s");
+    }
+    expect_stdout: [
+        "%% %s",
+        "% %s",
+    ]
+}

test/compress/screw-ie8.js

@@ -187,6 +187,7 @@ dont_screw_try_catch_undefined: {
 reduce_vars: {
     options = {
         evaluate: true,
+        reduce_funcs: true,
         reduce_vars: true,
         ie8: true,
         unused: true,
@@ -255,3 +256,139 @@ issue_1586_2: {
     }
     expect_exact: "function f(){try{x()}catch(c){console.log(c.message)}}"
 }
+
+issue_2120_1: {
+    mangle = {
+        ie8: false,
+    }
+    input: {
+        "aaaaaaaa";
+        var a = 1, b = "FAIL";
+        try {
+            throw 1;
+        } catch (c) {
+            try {
+                throw 0;
+            } catch (a) {
+                if (c) b = "PASS";
+            }
+        }
+        console.log(b);
+    }
+    expect: {
+        "aaaaaaaa";
+        var a = 1, b = "FAIL";
+        try {
+            throw 1;
+        } catch (t) {
+            try {
+                throw 0;
+            } catch (a) {
+                if (t) b = "PASS";
+            }
+        }
+        console.log(b);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_2120_2: {
+    mangle = {
+        ie8: true,
+    }
+    input: {
+        "aaaaaaaa";
+        var a = 1, b = "FAIL";
+        try {
+            throw 1;
+        } catch (c) {
+            try {
+                throw 0;
+            } catch (a) {
+                if (c) b = "PASS";
+            }
+        }
+        console.log(b);
+    }
+    expect: {
+        "aaaaaaaa";
+        var a = 1, b = "FAIL";
+        try {
+            throw 1;
+        } catch (c) {
+            try {
+                throw 0;
+            } catch (a) {
+                if (c) b = "PASS";
+            }
+        }
+        console.log(b);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_2254_1: {
+    mangle = {
+        ie8: false,
+    }
+    input: {
+        "eeeeee";
+        try {
+            console.log(f("PASS"));
+        } catch (e) {}
+        function f(s) {
+            try {
+                throw "FAIL";
+            } catch (e) {
+                return s;
+            }
+        }
+    }
+    expect: {
+        "eeeeee";
+        try {
+            console.log(f("PASS"));
+        } catch (e) {}
+        function f(e) {
+            try {
+                throw "FAIL";
+            } catch (t) {
+                return e;
+            }
+        }
+    }
+    expect_stdout: "PASS"
+}
+
+issue_2254_2: {
+    mangle = {
+        ie8: true,
+    }
+    input: {
+        "eeeeee";
+        try {
+            console.log(f("PASS"));
+        } catch (e) {}
+        function f(s) {
+            try {
+                throw "FAIL";
+            } catch (e) {
+                return s;
+            }
+        }
+    }
+    expect: {
+        "eeeeee";
+        try {
+            console.log(f("PASS"));
+        } catch (e) {}
+        function f(t) {
+            try {
+                throw "FAIL";
+            } catch (e) {
+                return t;
+            }
+        }
+    }
+    expect_stdout: "PASS"
+}

test/compress/sequences.js

@@ -176,6 +176,11 @@ for_sequences: {
         // 4
         x = (foo in bar);
         for (y = 5; false;);
+        // 5
+        x = function() {
+            foo in bar;
+        };
+        for (y = 5; false;);
     }
     expect: {
         // 1
@@ -188,6 +193,10 @@ for_sequences: {
         // 4
         x = (foo in bar);
         for (y = 5; false;);
+        // 5
+        for (x = function() {
+            foo in bar;
+        }, y = 5; false;);
     }
 }
 
@@ -243,13 +252,12 @@ negate_iife_for: {
     input: {
         (function() {})();
         for (i = 0; i < 5; i++) console.log(i);
-
         (function() {})();
-        for (; i < 5; i++) console.log(i);
+        for (; i < 10; i++) console.log(i);
     }
     expect: {
         for (!function() {}(), i = 0; i < 5; i++) console.log(i);
-        for (function() {}(); i < 5; i++) console.log(i);
+        for (!function() {}(); i < 10; i++) console.log(i);
     }
     expect_stdout: true
 }
@@ -280,7 +288,7 @@ unsafe_undefined: {
         if_return: true,
         sequences: true,
         side_effects: true,
-        unsafe: true,
+        unsafe_undefined: true,
     }
     input: {
         function f(undefined) {
@@ -309,7 +317,7 @@ unsafe_undefined: {
 
 issue_1685: {
     options = {
-        cascade: true,
+        collapse_vars: true,
         side_effects: true,
     }
     input: {
@@ -333,7 +341,7 @@ issue_1685: {
 
 func_def_1: {
     options = {
-        cascade: true,
+        collapse_vars: true,
         side_effects: true,
     }
     input: {
@@ -353,7 +361,7 @@ func_def_1: {
 
 func_def_2: {
     options = {
-        cascade: true,
+        collapse_vars: true,
         side_effects: true,
     }
     input: {
@@ -371,7 +379,7 @@ func_def_2: {
 
 func_def_3: {
     options = {
-        cascade: true,
+        collapse_vars: true,
         side_effects: true,
     }
     input: {
@@ -393,7 +401,7 @@ func_def_3: {
 
 func_def_4: {
     options = {
-        cascade: true,
+        collapse_vars: true,
         side_effects: true,
     }
     input: {
@@ -419,7 +427,7 @@ func_def_4: {
 
 func_def_5: {
     options = {
-        cascade: true,
+        collapse_vars: true,
         side_effects: true,
     }
     input: {
@@ -626,7 +634,7 @@ side_effects: {
 
 side_effects_cascade_1: {
     options = {
-        cascade: true,
+        collapse_vars: true,
         conditionals: true,
         sequences: true,
         side_effects: true,
@@ -647,7 +655,7 @@ side_effects_cascade_1: {
 
 side_effects_cascade_2: {
     options = {
-        cascade: true,
+        collapse_vars: true,
         side_effects: true,
     }
     input: {
@@ -669,7 +677,7 @@ side_effects_cascade_2: {
 
 side_effects_cascade_3: {
     options = {
-        cascade: true,
+        collapse_vars: true,
         conditionals: true,
         side_effects: true,
     }
@@ -684,14 +692,14 @@ side_effects_cascade_3: {
     expect: {
         function f(a, b) {
             !(b += a) && ((b = a) || (b -= a, b ^= a)),
-            --a;
+            a--;
         }
     }
 }
 
 issue_27: {
     options = {
-        cascade: true,
+        collapse_vars: true,
         passes: 2,
         sequences: true,
         side_effects: true,
@@ -713,7 +721,7 @@ issue_27: {
 
 reassign_const: {
     options = {
-        cascade: true,
+        collapse_vars: true,
         sequences: true,
         side_effects: true,
     }
@@ -734,3 +742,162 @@ reassign_const: {
     }
     expect_stdout: true
 }
+
+issue_2062: {
+    options = {
+        booleans: true,
+        collapse_vars: true,
+        conditionals: true,
+        side_effects: true,
+    }
+    input: {
+        var a = 1;
+        if ([ a || a++ + a--, a++ + a--, a && a.var ]);
+        console.log(a);
+    }
+    expect: {
+        var a = 1;
+        a || (a++, a--), a++, --a && a.var;
+        console.log(a);
+    }
+    expect_stdout: "1"
+}
+
+issue_2313: {
+    options = {
+        collapse_vars: true,
+        sequences: true,
+        side_effects: true,
+    }
+    input: {
+        var a = 0, b = 0;
+        var foo = {
+            get c() {
+                a++;
+                return 42;
+            },
+            set c(c) {
+                b++;
+            },
+            d: function() {
+                this.c++;
+                if (this.c) console.log(a, b);
+            }
+        }
+        foo.d();
+    }
+    expect: {
+        var a = 0, b = 0;
+        var foo = {
+            get c() {
+                return a++, 42;
+            },
+            set c(c) {
+                b++;
+            },
+            d: function() {
+                if (this.c++, this.c) console.log(a, b);
+            }
+        }
+        foo.d();
+    }
+    expect_stdout: "2 1"
+}
+
+cascade_assignment_in_return: {
+    options = {
+        collapse_vars: true,
+        unused: true,
+    }
+    input: {
+        function f(a, b) {
+            return a = x(), b(a);
+        }
+    }
+    expect: {
+        function f(a, b) {
+            return b(x());
+        }
+    }
+}
+
+hoist_defun: {
+    options = {
+        join_vars: true,
+        sequences: true,
+    }
+    input: {
+        x();
+        function f() {}
+        y();
+    }
+    expect: {
+        function f() {}
+        x(), y();
+    }
+}
+
+hoist_decl: {
+    options = {
+        join_vars: true,
+        sequences: true,
+    }
+    input: {
+        var a;
+        w();
+        var b = x();
+        y();
+        for (var c; 0;) z();
+        var d;
+    }
+    expect: {
+        var a;
+        w();
+        var b = x(), c, d;
+        for (y(); 0;) z();
+    }
+}
+
+for_init_var: {
+    options = {
+        join_vars: true,
+        unused: false,
+    }
+    input: {
+        var a = "PASS";
+        (function() {
+            var b = 42;
+            for (var c = 5; c > 0;) c--;
+            a = "FAIL";
+            var a;
+        })();
+        console.log(a);
+    }
+    expect: {
+        var a = "PASS";
+        (function() {
+            for (var b = 42, c = 5, a; c > 0;) c--;
+            a = "FAIL";
+        })();
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+}
+
+forin: {
+    options = {
+        sequences: true,
+    }
+    input: {
+        var o = [];
+        o.push("PASS");
+        for (var a in o)
+            console.log(o[a]);
+    }
+    expect: {
+        var o = [];
+        for (var a in o.push("PASS"), o)
+            console.log(o[a]);
+    }
+    expect_stdout: "PASS"
+}

test/compress/switch.js

@@ -714,6 +714,7 @@ issue_1705_2: {
     options = {
         dead_code: true,
         evaluate: true,
+        reduce_funcs: true,
         reduce_vars: true,
         sequences: true,
         side_effects: true,
@@ -816,3 +817,50 @@ issue_1758: {
     }
     expect_stdout: "0 3"
 }
+
+issue_2535: {
+    options = {
+        evaluate: true,
+        dead_code: true,
+        switches: true,
+    }
+    input: {
+        switch(w(), 42) {
+            case 13: x();
+            case 42: y();
+            default: z();
+        }
+    }
+    expect: {
+        w(), 42;
+        42;
+        y();
+        z();
+    }
+}
+
+issue_1750: {
+    options = {
+        dead_code: true,
+        evaluate: true,
+        switches: true,
+    }
+    input: {
+        var a = 0, b = 1;
+        switch (true) {
+          case a, true:
+          default:
+            b = 2;
+          case true:
+        }
+        console.log(a, b);
+    }
+    expect: {
+        var a = 0, b = 1;
+        true;
+        a, true;
+        b = 2;
+        console.log(a, b);
+    }
+    expect_stdout: "0 2"
+}

test/compress/template-string.js

@@ -59,7 +59,7 @@ template_string_with_constant_expression: {
         var foo = `${4 + 4} equals 4 + 4`;
     }
     expect: {
-        var foo = `8 equals 4 + 4`;
+        var foo = "8 equals 4 + 4";
     }
 }
 
@@ -89,21 +89,21 @@ template_string_with_predefined_constants: {
         var c = `${4**14}`; // 8 in template vs 9 chars - 268435456
     }
     expect: {
-        var foo = `This is undefined`;
+        var foo = "This is undefined";
-        var bar = `This is NaN`;
+        var bar = "This is NaN";
-        var baz = `This is null`;
+        var baz = "This is null";
         var foofoo = `This is ${1/0}`;
         var foobar = "This is ${1/0}";
         var foobaz = 'This is ${1/0}';
         var barfoo = "This is ${NaN}";
         var bazfoo = "This is ${null}";
         var bazbaz = `This is ${1/0}`;
-        var barbar = `This is NaN`;
+        var barbar = "This is NaN";
         var barbar = "This is ${0/0}";
         var barber = 'This is ${0/0}';
 
-        var a = `4194304`;
+        var a = "4194304";
-        var b = `16777216`; // Potential for further concatentation
+        var b = "16777216"; // Potential for further concatentation
         var c = `${4**14}`; // Not worth converting
     }
 }
@@ -123,7 +123,7 @@ template_string_evaluate_with_many_segments: {
     }
     expect: {
         var foo = `Hello ${guest()}, welcome to ${location()}.`;
-        var bar = `1234567890`;
+        var bar = "1234567890";
         var baz = `${foobar()}${foobar()}${foobar()}${foobar()}`;
         var buzz = `1${foobar()}2${foobar()}3${foobar()}`;
     }
@@ -159,7 +159,7 @@ template_string_to_normal_string: {
         var bar = "Decimals " + `${1}${2}${3}${4}${5}${6}${7}${8}${9}${0}`;
     }
     expect: {
-        var foo = `This is undefined`;
+        var foo = "This is undefined";
         var bar = "Decimals 1234567890";
     }
 }
@@ -192,7 +192,7 @@ evaluate_nested_templates: {
         var baz = `${`${`${`foo`}`}`}`;
     }
     expect: {
-        var baz = `foo`;
+        var baz = "foo";
     }
 }
 
@@ -241,8 +241,8 @@ enforce_double_quotes_and_evaluate: {
         var baz = `Hello ${world()}`;
     }
     expect: {
-        var foo = `Hello world`;
+        var foo = "Hello world";
-        var bar = `Hello world`;
+        var bar = "Hello world";
         var baz = `Hello ${world()}`;
     }
 }
@@ -260,8 +260,8 @@ enforce_single_quotes_and_evaluate: {
         var baz = `Hello ${world()}`;
     }
     expect: {
-        var foo = `Hello world`;
+        var foo = "Hello world";
-        var bar = `Hello world`;
+        var bar = "Hello world";
         var baz = `Hello ${world()}`;
     }
 }
@@ -339,7 +339,7 @@ escape_dollar_curly: {
         console.log(`${1-0}\${2-0}$\{3-0}${4-0}`)
         console.log(`$${""}{not an expression}`)
     }
-    expect_exact: "console.log(`\\${ beep }`);console.log(`1\\${2-0}\\${3-0}4`);console.log(`\\${not an expression}`);"
+    expect_exact: 'console.log("${ beep }");console.log("1${2-0}${3-0}4");console.log("${not an expression}");'
 }
 
 template_starting_with_newline: {
@@ -400,3 +400,109 @@ issue_1856_ascii_only: {
     }
     expect_exact: "console.log(`\\\\n\\\\r\\\\u2028\\\\u2029\\n\\r\\u2028\\u2029`);"
 }
+
+side_effects: {
+    options = {
+        evaluate: true,
+        side_effects: true,
+    }
+    input: {
+        `t1`;
+        tag`t2`;
+        `t${3}`;
+        tag`t${4}`;
+        console.log(`
+t${5}`);
+        function f(a) {
+            `t6${a}`;
+            a = `t7${a}` & a;
+            a = `t8${b}` | a;
+            a = f`t9${a}` ^ a;
+        }
+    }
+    expect: {
+        tag`t2`;
+        tag`t${4}`;
+        console.log("\nt5");
+        function f(a) {
+            a &= `t7${a}`;
+            a = `t8${b}` | a;
+            a = f`t9${a}` ^ a;
+        }
+    }
+}
+
+simple_string: {
+    options = {
+        computed_props: true,
+        evaluate: true,
+        properties: true,
+    }
+    input: {
+        console.log({[`foo`]: 1}[`foo`], `hi` == "hi", `world`);
+    }
+    expect: {
+        console.log([ 1 ][0], true, "world");
+    }
+    expect_stdout: "1 true 'world'"
+    node_version: ">=4"
+}
+
+semicolons: {
+    beautify = {
+        semicolons: false,
+    }
+    input: {
+        foo;
+        `bar`;
+    }
+    expect_exact: "foo;`bar`\n"
+}
+
+regex_1: {
+    input: {
+        console.log(`${/a/} ${6/2} ${/b/.test("b")} ${1?/c/:/d/}`);
+    }
+    expect_exact: 'console.log(`${/a/} ${6/2} ${/b/.test("b")} ${1?/c/:/d/}`);'
+    expect_stdout: "/a/ 3 true /c/"
+    node_version: ">=4"
+}
+
+regex_2: {
+    options = {
+        evaluate: true,
+        unsafe: true,
+    }
+    input: {
+        console.log(`${/a/} ${6/2} ${/b/.test("b")} ${1?/c/:/d/}`);
+    }
+    expect: {
+        console.log("/a/ 3 true /c/");
+    }
+    expect_stdout: "/a/ 3 true /c/"
+    node_version: ">=4"
+}
+
+sequence_1: {
+    input: {
+        console.log(`${1,2} ${/a/,/b/}`);
+    }
+    expect_exact: 'console.log(`${1,2} ${/a/,/b/}`);'
+    expect_stdout: "2 /b/"
+    node_version: ">=4"
+}
+
+sequence_2: {
+    options = {
+        evaluate: true,
+        side_effects: true,
+    }
+    input: {
+        console.log(`${1,2} ${/a/,/b/}`);
+    }
+    expect: {
+        console.log("2 /b/");
+    }
+    expect_stdout: "2 /b/"
+    node_version: ">=4"
+}

test/compress/transform.js

@@ -45,9 +45,9 @@ condition_evaluate: {
         if (void 0 == null);
     }
     expect: {
-        while (!1);
+        while (0);
-        for (; !0;);
+        for (; 1;);
-        if (!0);
+        if (1);
     }
 }
 
@@ -68,6 +68,7 @@ label_if_break: {
         conditionals: true,
         dead_code: true,
         evaluate: true,
+        side_effects: true,
     }
     input: {
         L: if (true) {

test/compress/typeof.js

@@ -1,6 +1,7 @@
 typeof_evaluation: {
     options = {
-        evaluate: true
+        evaluate: true,
+        typeofs: true,
     };
     input: {
         a = typeof 1;
@@ -44,7 +45,7 @@ typeof_in_boolean_context: {
         function f2() { return g(), "Yes"; }
         foo();
         console.log(1);
-        var a = !(console.log(2), !0);
+        var a = !(console.log(2), 1);
         foo();
     }
 }
@@ -57,6 +58,246 @@ issue_1668: {
         if (typeof bar);
     }
     expect: {
-        if (!0);
+        if (1);
     }
 }
+
+typeof_defun_1: {
+    options = {
+        evaluate: true,
+        inline: true,
+        passes: 2,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        typeofs: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            console.log("YES");
+        }
+        function g() {
+            h = 42;
+            console.log("NOPE");
+        }
+        function h() {
+            console.log("YUP");
+        }
+        g = 42;
+        "function" == typeof f && f();
+        "function" == typeof g && g();
+        "function" == typeof h && h();
+    }
+    expect: {
+        function g() {
+            h = 42;
+            console.log("NOPE");
+        }
+        function h() {
+            console.log("YUP");
+        }
+        g = 42;
+        console.log("YES");
+        "function" == typeof g && g();
+        "function" == typeof h && h();
+    }
+    expect_stdout: [
+        "YES",
+        "YUP",
+    ]
+}
+
+typeof_defun_2: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        typeofs: true,
+    }
+    input: {
+        var f = function() {
+            console.log(x);
+        };
+        var x = 0;
+        x++ < 2 && typeof f == "function" && f();
+        x++ < 2 && typeof f == "function" && f();
+        x++ < 2 && typeof f == "function" && f();
+    }
+    expect: {
+        var f = function() {
+            console.log(x);
+        };
+        var x = 0;
+        x++ < 2 && f();
+        x++ < 2 && f();
+        x++ < 2 && f();
+    }
+    expect_stdout: [
+        "1",
+        "2",
+    ]
+}
+
+duplicate_defun_arg_name: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        typeofs: true,
+    }
+    input: {
+        function long_name(long_name) {
+            return typeof long_name;
+        }
+        console.log(typeof long_name, long_name());
+    }
+    expect: {
+        function long_name(long_name) {
+            return typeof long_name;
+        }
+        console.log(typeof long_name, long_name());
+    }
+    expect_stdout: "function undefined"
+}
+
+duplicate_lambda_arg_name: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        typeofs: true,
+    }
+    input: {
+        console.log(function long_name(long_name) {
+            return typeof long_name;
+        }());
+    }
+    expect: {
+        console.log(function long_name(long_name) {
+            return typeof long_name;
+        }());
+    }
+    expect_stdout: "undefined"
+}
+
+issue_2728_1: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        typeofs: true,
+    }
+    input: {
+        (function arguments() {
+            console.log(typeof arguments);
+        })();
+    }
+    expect: {
+        (function arguments() {
+            console.log(typeof arguments);
+        })();
+    }
+    expect_stdout: "object"
+}
+
+issue_2728_2: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        typeofs: true,
+    }
+    input: {
+        function arguments() {
+            return typeof arguments;
+        }
+        console.log(typeof arguments, arguments());
+    }
+    expect: {
+        function arguments() {
+            return typeof arguments;
+        }
+        console.log(typeof arguments, arguments());
+    }
+    expect_stdout: "function object"
+}
+
+issue_2728_3: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        typeofs: true,
+    }
+    input: {
+        (function() {
+            function arguments() {
+            }
+            console.log(typeof arguments);
+        })();
+    }
+    expect: {
+        (function() {
+            function arguments() {
+            }
+            console.log("function");
+        })();
+    }
+    expect_stdout: "function"
+}
+
+issue_2728_4: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        typeofs: true,
+    }
+    input: {
+        function arguments() {
+        }
+        console.log(typeof arguments);
+    }
+    expect: {
+        function arguments() {
+        }
+        console.log("function");
+    }
+    expect_stdout: "function"
+}
+
+issue_2728_5: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        typeofs: true,
+    }
+    input: {
+        (function arguments(arguments) {
+            console.log(typeof arguments);
+        })();
+    }
+    expect: {
+        (function arguments(arguments) {
+            console.log(typeof arguments);
+        })();
+    }
+    expect_stdout: "undefined"
+}
+
+issue_2728_6: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        typeofs: true,
+    }
+    input: {
+        function arguments(arguments) {
+            return typeof arguments;
+        }
+        console.log(typeof arguments, arguments());
+    }
+    expect: {
+        function arguments(arguments) {
+            return typeof arguments;
+        }
+        console.log(typeof arguments, arguments());
+    }
+    expect_stdout: "function undefined"
+}

test/compress/unicode.js

@@ -43,15 +43,6 @@ unicode_string_literals: {
     expect_exact: 'var a="6 length unicode character: \\u{101111}";'
 }
 
-// Don't escape identifiers below es6 (or in this case double escaped in expect_exact)
-unicode_output_es5_surrogates: {
-    beautify = {ascii_only: true, ecma: 5}
-    input: {
-        var \u{10000} = "6 length unicode character: \u{10FFFF}";
-    }
-    expect_exact: 'var \u{10000}="6 length unicode character: \\udbff\\udfff";'
-}
-
 check_escape_style: {
     beautify = {ascii_only: true, ecma: 6}
     input: {
@@ -65,20 +56,6 @@ check_escape_style: {
     expect_exact: 'var a="\\x01";var \\ua0081="\\x10";var \\u0100="\\u0100";var \\u1000="\\u1000";var \\u{10000}="\\u{10000}";var \\u{2f800}="\\u{100000}";'
 }
 
-// Don't escape identifiers below es6, no escaped identifiers support and no \u{} syntax
-check_escape_style_es5: {
-    beautify = {ascii_only: true, ecma: 5}
-    input: {
-        var a = "\x01";
-        var \ua0081 = "\x10"; // \u0081 only in ID_Continue
-        var \u0100 = "\u0100";
-        var \u1000 = "\u1000";
-        var \u{10000} = "\u{10000}"; // Identifier won't be escaped in es 5.1
-        var \u{2f800} = "\u{100000}"; // Same
-    }
-    expect_exact: 'var a="\\x01";var \\ua0081="\\x10";var \\u0100="\\u0100";var \\u1000="\\u1000";var \ud800\udc00="\\ud800\\udc00";var \ud87e\udc00="\\udbc0\\udc00";'
-}
-
 ID_continue_with_surrogate_pair: {
     beautify = {ascii_only: true, ecma: 6}
     input: {
@@ -103,18 +80,49 @@ non_escape_2_non_escape: {
     expect_exact: 'var µþ="µþ";'
 }
 
-non_escape_2_half_escape1: {
+issue_2242_1: {
-    beautify = {ascii_only: false, ascii_identifiers: true, ecma: 6}
+    beautify = {
-    input: {
+        ascii_only: false,
-        var µþ = "µþ";
     }
-    expect_exact: 'var \\u00b5\\u00fe="µþ";'
+    input: {
+        console.log("\ud83d", "\ude00", "\ud83d\ude00", "\ud83d@\ude00");
+    }
+    expect_exact: 'console.log("\\ud83d","\\ude00","\ud83d\ude00","\\ud83d@\\ude00");'
 }
 
-non_escape_2_half_escape2: {
+issue_2242_2: {
-    beautify = {ascii_only: true, ascii_identifiers: false, ecma: 6}
+    beautify = {
-    input: {
+        ascii_only: true,
-        var µþ = "µþ";
     }
-    expect_exact: 'var µþ="\\xb5\\xfe";'
+    input: {
+        console.log("\ud83d", "\ude00", "\ud83d\ude00", "\ud83d@\ude00");
+    }
+    expect_exact: 'console.log("\\ud83d","\\ude00","\\ud83d\\ude00","\\ud83d@\\ude00");'
+}
+
+issue_2242_3: {
+    options = {
+        evaluate: false,
+    }
+    input: {
+        console.log("\ud83d" + "\ude00", "\ud83d" + "@" + "\ude00");
+    }
+    expect_exact: 'console.log("\\ud83d"+"\\ude00","\\ud83d"+"@"+"\\ude00");'
+}
+
+issue_2242_4: {
+    options = {
+        evaluate: true,
+    }
+    input: {
+        console.log("\ud83d" + "\ude00", "\ud83d" + "@" + "\ude00");
+    }
+    expect_exact: 'console.log("\ud83d\ude00","\\ud83d@\\ude00");'
+}
+
+issue_2569: {
+    input: {
+        new RegExp("[\udc42-\udcaa\udd74-\udd96\ude45-\ude4f\udea3-\udecc]");
+    }
+    expect_exact: 'new RegExp("[\\udc42-\\udcaa\\udd74-\\udd96\\ude45-\\ude4f\\udea3-\\udecc]");'
 }

test/compress/yield.js

@@ -88,9 +88,8 @@ yield_before_punctuators: {
         })();
         function* g1() { (yield) }
         function* g2() { [yield] }
-        function* g3() { return {yield} } // Added return to avoid {} drop
+        function* g3() { yield, yield; }
-        function* g4() { yield, yield; }
+        function* g4() { (yield) ? yield : yield; }
-        function* g5() { (yield) ? yield : yield; }
     }
     expect: {
         iter = (function*() {
@@ -98,9 +97,8 @@ yield_before_punctuators: {
         })();
         function* g1() { (yield) }
         function* g2() { [yield] }
-        function* g3() { return {yield} }
+        function* g3() { yield, yield; }
-        function* g4() { yield, yield; }
+        function* g4() { (yield) ? yield : yield; }
-        function* g5() { (yield) ? yield : yield; }
     }
 }
 
@@ -199,3 +197,57 @@ yield_as_ES5_property: {
     expect_exact: '"use strict";console.log({yield:42}.yield);'
     expect_stdout: "42"
 }
+
+issue_2689: {
+    options = {
+        collapse_vars: true,
+        unused: true,
+    }
+    input: {
+        function* y() {
+            var t = yield x();
+            return new t();
+        }
+    }
+    expect_exact: "function*y(){return new(yield x())}"
+}
+
+issue_2832: {
+    beautify = {
+        beautify: true,
+    }
+    input: {
+        function* gen(i) {
+            const result = yield (x = i, -x);
+            var x;
+            console.log(x);
+            console.log(result);
+            yield 2;
+        }
+        var x = gen(1);
+        console.log(x.next("first").value);
+        console.log(x.next("second").value);
+    }
+    expect_exact: [
+        "function* gen(i) {",
+        "    const result = yield (x = i, -x);",
+        "    var x;",
+        "    console.log(x);",
+        "    console.log(result);",
+        "    yield 2;",
+        "}",
+        "",
+        "var x = gen(1);",
+        "",
+        'console.log(x.next("first").value);',
+        "",
+        'console.log(x.next("second").value);',
+    ]
+    expect_stdout: [
+        "-1",
+        "1",
+        "second",
+        "2",
+    ]
+    node_version: ">=4"
+}

test/exports.js

@@ -8,6 +8,7 @@ exports["defaults"] = defaults;
 exports["mangle_properties"] = mangle_properties;
 exports["minify"] = minify;
 exports["parse"] = parse;
+exports["reserve_quoted_keys"] = reserve_quoted_keys;
 exports["string_template"] = string_template;
 exports["tokenizer"] = tokenizer;
 exports["is_identifier"] = is_identifier;

test/fetch.js

@@ -0,0 +1,31 @@
+var fs = require("fs");
+var path = require("path");
+
+try {
+    fs.mkdirSync("./tmp");
+} catch (e) {
+    if (e.code != "EEXIST") throw e;
+}
+
+function local(url) {
+    return path.join("./tmp", encodeURIComponent(url));
+}
+
+function read(url) {
+    return fs.createReadStream(local(url));
+}
+
+module.exports = function(url, callback) {
+    var result = read(url);
+    result.on("error", function(e) {
+        if (e.code != "ENOENT") return callback(e);
+        require(url.slice(0, url.indexOf(":"))).get(url, function(res) {
+            if (res.statusCode !== 200) return callback(res);
+            res.pipe(fs.createWriteStream(local(url)).on("close", function() {
+                callback(null, read(url));
+            }));
+        });
+    }).on("open", function() {
+        callback(null, result);
+    });
+};