v3.3.1

fixes #2644

.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

README.md

@@ -45,6 +45,7 @@ a double dash to prevent input files being used as option arguments:
 
 ```
     -h, --help                  Print usage information.
+                                `--help options` for details on available options.
     -V, --version               Print version number.
     -p, --parse <options>       Specify parser options:
                                 `acorn`  Use Acorn for parsing.
@@ -110,7 +111,7 @@ a double dash to prevent input files being used as option arguments:
                                 By default UglifyJS will not try to be IE-proof.
     --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.
     --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.
@@ -126,7 +127,7 @@ a double dash to prevent input files being used as option arguments:
                                         the source map.
                                 `url`  If specified, path to the source map to append in
                                        `//# sourceMappingURL`.
-    --stats                     Display operations run time on STDERR.
+    --timings                   Display operations run time on STDERR.
     --toplevel                  Compress and/or mangle variables in top level scope.
     --verbose                   Print diagnostic messages.
     --warn                      Print warning messages.
@@ -149,19 +150,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
@@ -180,8 +181,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
@@ -202,40 +203,68 @@ Example:
 To enable the mangler you need to pass `--mangle` (`-m`).  The following
 (comma-separated) options are supported:
 
-- `toplevel` — mangle names declared in the toplevel 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.
 
 ### CLI mangling property names (`--mangle-props`)
 
-**Note:** this will probably break your code.  Mangling property names is a
+**Note:** THIS WILL PROBABLY BREAK YOUR CODE.  Mangling property names
-separate step, different from variable name mangling.  Pass
+is a separate step, different from variable name mangling.  Pass
-`--mangle-props`.  It will mangle all properties that are seen in some
+`--mangle-props` to enable it.  It will mangle all properties in the
-object literal, or that are assigned to.  For example:
+input code with the exception of built in DOM properties and properties
+in core JavaScript classes.  For example:
 
 ```javascript
+// example.js
 var x = {
-    foo: 1
+    baz_: 0,
+    foo_: 1,
+    calc: function() {
+        return this.foo_ + this.baz_;
+    }
 };
-
+x.bar_ = 2;
-x.bar = 2;
+x["baz_"] = 3;
-x["baz"] = 3;
+console.log(x.calc());
-x[condition ? "moo" : "boo"] = 4;
+```
-console.log(x.something());
+Mangle all properties (except for JavaScript `builtins`):
+```bash
+$ uglifyjs example.js -c -m --mangle-props
+```
+```javascript
+var x={o:0,_:1,l:function(){return this._+this.o}};x.t=2,x.o=3,console.log(x.l());
+```
+Mangle all properties except for `reserved` properties:
+```bash
+$ uglifyjs example.js -c -m --mangle-props reserved=[foo_,bar_]
+```
+```javascript
+var x={o:0,foo_:1,_:function(){return this.foo_+this.o}};x.bar_=2,x.o=3,console.log(x._());
+```
+Mangle all properties matching a `regex`:
+```bash
+$ uglifyjs example.js -c -m --mangle-props regex=/_$/
+```
+```javascript
+var x={o:0,_:1,calc:function(){return this._+this.o}};x.l=2,x.o=3,console.log(x.calc());
 ```
 
-In the above code, `foo`, `bar`, `baz`, `moo` and `boo` will be replaced
+Combining mangle properties options:
-with single characters, while `something()` will be left as is.
+```bash
+$ uglifyjs example.js -c -m --mangle-props regex=/_$/,reserved=[bar_]
+```
+```javascript
+var x={o:0,_:1,calc:function(){return this._+this.o}};x.bar_=2,x.o=3,console.log(x.calc());
+```
 
 In order for this to be of any use, we avoid mangling standard JS names by
 default (`--mangle-props builtins` to override).
@@ -244,7 +273,7 @@ A default exclusion file is provided in `tools/domprops.json` which should
 cover most standard JS and DOM properties defined in various browsers.  Pass
 `--mangle-props domprops` to disable this feature.
 
-You can also use a regular expression to define which property names should be
+A regular expression can be used to define which property names should be
 mangled.  For example, `--mangle-props regex=/^_/` will only mangle property
 names that start with an underscore.
 
@@ -272,9 +301,20 @@ Using quoted property name (`o["foo"]`) reserves the property name (`foo`)
 so that it is not mangled throughout the entire script even when used in an
 unquoted style (`o.foo`). Example:
 
+```javascript
+// stuff.js
+var o = {
+    "foo": 1,
+    bar: 3
+};
+o.foo += o.bar;
+console.log(o.foo);
+```
 ```bash
-$ echo 'var o={"foo":1, bar:3}; o.foo += o.bar; console.log(o.foo);' | uglifyjs --mangle-props keep_quoted -mc
+$ uglifyjs stuff.js --mangle-props keep_quoted -c -m
-var o={foo:1,a:3};o.foo+=o.a,console.log(o.foo);
+```
+```javascript
+var o={foo:1,o:3};o.foo+=o.o,console.log(o.foo);
 ```
 
 ### Debugging property name mangling
@@ -285,6 +325,13 @@ would mangle to `o._$foo$_` with this option. This allows property mangling
 of a large codebase while still being able to debug the code and identify
 where mangling is breaking things.
 
+```bash
+$ uglifyjs stuff.js --mangle-props debug -c -m
+```
+```javascript
+var o={_$foo$_:1,_$bar$_:3};o._$foo$_+=o._$bar$_,console.log(o._$foo$_);
+```
+
 You can also pass a custom suffix using `--mangle-props debug=XYZ`. This would then
 mangle `o.foo` to `o._$foo$XYZ_`. You can change this each time you compile a
 script to identify how a property got mangled. One technique is to pass a
@@ -301,27 +348,134 @@ like this:
 var UglifyJS = require("uglify-js");
 ```
 
-There is a single high level minification function, `minify(files, options)`, which will
+There is a single high level function, **`minify(code, options)`**,
-performs all the steps in a configurable manner.
+which will perform all minification [phases](#minify-options) in a configurable
-Example:
+manner. By default `minify()` will enable the options [`compress`](#compress-options)
+and [`mangle`](#mangle-options). Example:
 ```javascript
-var result = UglifyJS.minify("var b = function() {};");
+var code = "function add(first, second) { return first + second; }";
-console.log(result.code);  // minified output
+var result = UglifyJS.minify(code);
-console.log(result.error); // runtime error
+console.log(result.error); // runtime error, or `undefined` if no error
+console.log(result.code);  // minified output: function add(n,d){return n+d}
 ```
 
-You can also compress multiple files:
+You can `minify` more than one JavaScript file at a time by using an object
+for the first argument where the keys are file names and the values are source
+code:
 ```javascript
-var result = UglifyJS.minify({
+var code = {
-    "file1.js": "var a = function() {};",
+    "file1.js": "function add(first, second) { return first + second; }",
-    "file2.js": "var b = function() {};"
+    "file2.js": "console.log(add(1 + 2, 3 + 4));"
-});
+};
+var result = UglifyJS.minify(code);
 console.log(result.code);
+// function add(d,n){return d+n}console.log(add(3,7));
+```
+
+The `toplevel` option:
+```javascript
+var code = {
+    "file1.js": "function add(first, second) { return first + second; }",
+    "file2.js": "console.log(add(1 + 2, 3 + 4));"
+};
+var options = { toplevel: true };
+var result = UglifyJS.minify(code, options);
+console.log(result.code);
+// 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:
+```javascript
+var code = {
+    "file1.js": "function add(first, second) { return first + second; }",
+    "file2.js": "console.log(add(1 + 2, 3 + 4));"
+};
+var options = {
+    toplevel: true,
+    compress: {
+        global_defs: {
+            "@console.log": "alert"
+        },
+        passes: 2
+    },
+    output: {
+        beautify: false,
+        preamble: "/* uglified */"
+    }
+};
+var result = UglifyJS.minify(code, options);
+console.log(result.code);
+// /* uglified */
+// alert(10);"
+```
+
+To produce warnings:
+```javascript
+var code = "function f(){ var u; return 2 + 3; }";
+var options = { warnings: true };
+var result = UglifyJS.minify(code, options);
+console.log(result.error);    // runtime error, `undefined` in this case
+console.log(result.warnings); // [ 'Dropping unused variable u [0:1,18]' ]
+console.log(result.code);     // function f(){return 5}
+```
+
+An error example:
+```javascript
+var result = UglifyJS.minify({"foo.js" : "if (0) else console.log(1);"});
+console.log(JSON.stringify(result.error));
+// {"message":"Unexpected token: keyword (else)","filename":"foo.js","line":1,"col":7,"pos":7}
+```
+Note: unlike `uglify-js@2.x`, the `3.x` API does not throw errors. To
+achieve a similar effect one could do the following:
+```javascript
+var result = UglifyJS.minify(code, options);
+if (result.error) throw result.error;
 ```
 
 ## Minify options
 
-- `warnings` (default `false`) — pass `true` to display compressor warnings.
+- `warnings` (default `false`) — pass `true` to return compressor warnings
+  in `result.warnings`. Use the value `"verbose"` for more detailed warnings.
 
 - `parse` (default `{}`) — pass an object if you wish to specify some
   additional [parse options](#parse-options).
@@ -345,13 +499,22 @@ console.log(result.code);
 - `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.
 
-## Minify option structure
+- `keep_fnames` (default: `false`) - pass `true` to prevent discarding or mangling
+  of function names.  Useful for code relying on `Function.prototype.name`.
+
+## Minify options structure
 
 ```javascript
 {
-    warnings: false,
     parse: {
         // parse options
     },
@@ -371,8 +534,10 @@ console.log(result.code);
     sourceMap: {
         // source map options
     },
+    nameCache: null, // or specify a name cache object
     toplevel: false,
     ie8: false,
+    warnings: false,
 }
 ```
 
@@ -426,99 +591,84 @@ 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
+
 - `html5_comments` (default `true`)
+
 - `shebang` (default `true`) -- support `#!command` as the first line
 
 ## Compress options
 
-- `sequences` (default: true) -- join consecutive simple statements using the
+- `booleans` (default: `true`) -- various optimizations for boolean context,
-  comma operator.  May be set to a positive integer to specify the maximum number
+  for example `!!a ? b : c → a ? b : c`
-  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.
 
-- `properties` -- rewrite property access using the dot notation, for
+- `collapse_vars` (default: `true`) -- Collapse single-use non-constant variables,
-  example `foo["bar"] → foo.bar`
+  side effects permitting.
 
-- `dead_code` -- remove unreachable code
+- `comparisons` (default: `true`) -- apply certain optimizations to binary nodes,
-
+  e.g. `!(a <= b) → a > b` (only when `unsafe_comps`), attempts to negate binary
-- `drop_debugger` -- remove `debugger;` statements
-
-- `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)`
-
-- `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
+- `conditionals` (default: `true`) -- apply optimizations for `if`-s and conditional
+  expressions
 
-- `booleans` -- various optimizations for boolean context, for example `!!a
+- `dead_code` (default: `true`) -- remove unreachable code
-  ? b : c → a ? b : c`
 
-- `loops` -- optimizations for `do`, `while` and `for` loops when we can
+- `drop_console` (default: `false`) -- Pass `true` to discard calls to
-  statically determine the condition
+  `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.
 
-- `unused` -- drop unreferenced functions and variables (simple direct variable
+- `drop_debugger` (default: `true`) -- remove `debugger;` statements
-  assignments do not count as references unless set to `"keep_assign"`)
 
-- `toplevel` -- drop unreferenced functions (`"funcs"`) and/or variables (`"vars"`)
+- `evaluate` (default: `true`) -- attempt to evaluate constant expressions
-  in the toplevel scope (`false` by default, `true` to drop both unreferenced
-  functions and variables)
 
-- `top_retain` -- prevent specific toplevel functions and variables from `unused`
+- `expression` (default: `false`) -- Pass `true` to preserve completion values
-  removal (can be array, comma-separated, RegExp or function. Implies `toplevel`)
+  from terminal statements without `return`, e.g. in bookmarklets.
 
-- `hoist_funs` -- hoist function declarations
+- `global_defs` (default: `{}`) -- see [conditional compilation](#conditional-compilation)
 
-- `hoist_vars` (default: false) -- hoist `var` declarations (this is `false`
+- `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`) -- embed simple functions
 
-- `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 `var` and `const` definitions
+- `keep_fargs` (default: `true`) -- Prevents the compressor from discarding unused
-  when possible.
+  function arguments.  You need this for code which relies on `Function.length`.
 
-- `reduce_vars` -- Improve optimization on variables assigned with and
+- `keep_fnames` (default: `false`) -- Pass `true` to prevent the
-  used as constant values.
+  compressor from discarding function names.  Useful for code relying on
+  `Function.prototype.name`. See also: the `keep_fnames` [mangle option](#mangle).
 
-- `warnings` -- display warnings when dropping unreachable code or unused
+- `keep_infinity` (default: `false`) -- Pass `true` to prevent `Infinity` from
-  declarations etc.
+  being compressed into `1/0`, which may cause performance issues on Chrome.
 
-- `negate_iife` -- negate "Immediately-Called Function Expressions"
+- `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
@@ -529,47 +679,90 @@ 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()`;
+  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_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_Func` (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_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.
+
+- `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 toplevel scope (disabled by
+- `keep_fnames` (default `false`) -- Pass `true` to not mangle function names.
-default).
+  Useful for code relying on `Function.prototype.name`. See also: the `keep_fnames`
+  [compress option](#compress-options).
 
-- `eval` — mangle names visible in scopes where eval or with are used
+- `reserved` (default `[]`) -- Pass an array of identifiers that should be
-(disabled by default).
+  excluded from mangling. Example: `["foo", "bar"]`.
 
-- `keep_fnames` -- default `false`.  Pass `true` to not mangle
+- `toplevel` (default `false`) -- Pass `true` to mangle names declared in the
-function names.  Useful for code relying on `Function.prototype.name`.
+  top level scope.
-See also: the `keep_fnames` [compress option](#compress-options).
 
 Examples:
 
@@ -595,10 +788,19 @@ UglifyJS.minify(code, { mangle: { toplevel: true } }).code;
 
 ### Mangle properties options
 
-- `regex` — Pass a RegExp to only mangle certain names
+- `builtins` (default: `false`) -- Use `true` to allow the mangling of builtin
-- `keep_quoted` — Only mangle unquoted property names
+  DOM properties. Not recommended to override this setting.
-- `debug` — Mangle names with the original name still present. Defaults to `false`.
+
-  Pass an empty string to enable, or a non-empty string to set the suffix.
+- `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
 
@@ -608,48 +810,67 @@ 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.
-- `indent_level` (default 4)
+
-- `indent_start` (default 0) -- prefix all lines by that many spaces
+- `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
+
 - `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.
@@ -695,7 +916,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)
@@ -722,8 +942,8 @@ Another way of doing that is to declare your globals as constants in a
 separate file and include it into the build.  For example you can have a
 `build/defines.js` file with the following:
 ```javascript
-const DEBUG = false;
+var DEBUG = false;
-const PRODUCTION = true;
+var PRODUCTION = true;
 // etc.
 ```
 
@@ -743,7 +963,7 @@ You can also use conditional compilation via the programmatic API. With the diff
 property name is `global_defs` and is a compressor property:
 
 ```javascript
-var result = uglifyJS.minify(fs.readFileSync("input.js", "utf8"), {
+var result = UglifyJS.minify(fs.readFileSync("input.js", "utf8"), {
     compress: {
         dead_code: true,
         global_defs: {
@@ -753,6 +973,32 @@ var result = uglifyJS.minify(fs.readFileSync("input.js", "utf8"), {
 });
 ```
 
+To replace an identifier with an arbitrary non-constant expression it is
+necessary to prefix the `global_defs` key with `"@"` to instruct UglifyJS
+to parse the value as an expression:
+```javascript
+UglifyJS.minify("alert('hello');", {
+    compress: {
+        global_defs: {
+            "@alert": "console.log"
+        }
+    }
+}).code;
+// returns: 'console.log("hello");'
+```
+
+Otherwise it would be replaced as string literal:
+```javascript
+UglifyJS.minify("alert('hello');", {
+    compress: {
+        global_defs: {
+            "alert": "console.log"
+        }
+    }
+}).code;
+// returns: '"console.log"("hello");'
+```
+
 ### Using native Uglify AST with `minify()`
 ```javascript
 // example: parse only, produce native Uglify AST
@@ -822,3 +1068,30 @@ 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 });
+```

bin/uglifyjs

@@ -15,20 +15,31 @@ 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", "enclosed", "inlined", "parent_scope", "scope", "thedef", "uses_eval", "uses_with" ];
 var files = {};
 var options = {
     compress: false,
     mangle: false
 };
-program.version(info.name + ' ' + info.version);
+program.version(info.name + " " + info.version);
 program.parseArgv = program.parse;
 program.parse = undefined;
-program.option("-p, --parse <options>", "Specify parser options.", parse_js("parse", true));
+if (process.argv.indexOf("ast") >= 0) program.helpInformation = UglifyJS.describe_ast;
-program.option("-c, --compress [options]", "Enable compressor/specify compressor options.", parse_js("compress", true));
+else if (process.argv.indexOf("options") >= 0) program.helpInformation = function() {
-program.option("-m, --mangle [options]", "Mangle names/specify mangler options.", parse_js("mangle", true));
+    var text = [];
-program.option("--mangle-props [options]", "Mangle properties/specify mangler options.", parse_js("mangle-props", true));
+    var options = UglifyJS.default_options();
-program.option("-b, --beautify [options]", "Beautify output/specify output options.", parse_js("beautify", true));
+    for (var option in options) {
+        text.push("--" + (option == "output" ? "beautify" : option == "sourceMap" ? "source-map" : option) + " options:");
+        text.push(format_object(options[option]));
+        text.push("");
+    }
+    return text.join("\n");
+};
+program.option("-p, --parse <options>", "Specify parser options.", parse_js());
+program.option("-c, --compress [options]", "Enable compressor/specify compressor options.", parse_js());
+program.option("-m, --mangle [options]", "Mangle names/specify mangler options.", parse_js());
+program.option("--mangle-props [options]", "Mangle properties/specify mangler options.", parse_js());
+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.");
@@ -36,9 +47,10 @@ program.option("-d, --define <expr>[=value]", "Global definitions.", parse_js("d
 program.option("--ie8", "Support non-standard Internet Explorer 8.");
 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("--no-rename", "Disable symbol expansion.");
 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("--stats", "Display operations run time on STDERR.")
+program.option("--timings", "Display operations run time on STDERR.")
 program.option("--toplevel", "Compress and/or mangle variables in toplevel scope.");
 program.option("--verbose", "Print diagnostic messages.");
 program.option("--warn", "Print warning messages.");
@@ -54,11 +66,13 @@ if (!program.output && program.sourceMap && program.sourceMap.url != "inline") {
     "compress",
     "ie8",
     "mangle",
+    "rename",
     "sourceMap",
     "toplevel",
     "wrap"
 ].forEach(function(name) {
     if (name in program) {
+        if (name == "rename" && program[name]) return;
         options[name] = program[name];
     }
 });
@@ -95,17 +109,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 = {
@@ -114,10 +119,10 @@ if (program.output == "ast") {
     };
 }
 if (program.parse) {
-    if (program.parse.acorn || program.parse.spidermonkey) {
+    if (!program.parse.acorn && !program.parse.spidermonkey) {
-        if (program.sourceMap) fatal("ERROR: inline source map only works with built-in parser");
-    } else {
         options.parse = program.parse;
+    } else if (program.sourceMap && program.sourceMap.content == "inline") {
+        fatal("ERROR: inline source map only works with built-in parser");
     }
 }
 var convert_path = function(name) {
@@ -139,7 +144,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) {
@@ -169,9 +174,9 @@ function convert_ast(fn) {
 
 function run() {
     UglifyJS.AST_Node.warn_function = function(msg) {
-        console.error("WARN:", msg);
+        print_error("WARN: " + msg);
     };
-    if (program.stats) program.stats = Date.now();
+    if (program.timings) options.timings = true;
     try {
         if (program.parse) {
             if (program.parse.acorn) {
@@ -198,7 +203,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];
@@ -207,21 +212,22 @@ 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) {
+        print(JSON.stringify(result.ast, function(key, value) {
             if (skip_key(key)) return;
             if (value instanceof UglifyJS.AST_Token) return;
             if (value instanceof UglifyJS.Dictionary) return;
@@ -237,7 +243,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: {
@@ -251,19 +257,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) {
+        print_error("- " + phase + ": " + result.timings[phase].toFixed(3) + "s");
     }
-    if (program.stats) console.error("Elapsed:", Date.now() - program.stats);
 }
 
 function fatal(message) {
     if (message instanceof Error) message = message.stack.replace(/^\S*?Error:/, "ERROR:")
-    console.error(message);
+    print_error(message);
     process.exit(1);
 }
 
@@ -307,7 +313,7 @@ function read_file(path, default_value) {
     }
 }
 
-function parse_js(flag, constants) {
+function parse_js(flag) {
     return function(value, options) {
         options = options || {};
         try {
@@ -325,7 +331,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);
@@ -348,37 +354,51 @@ function parse_js(flag, constants) {
                 }
             }));
         } catch(ex) {
+            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 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);
@@ -299,10 +298,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",
@@ -354,11 +352,11 @@ 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_Defun = DEFNODE("Defun", null, {
+var AST_Defun = DEFNODE("Defun", "inlined", {
     $documentation: "A function definition"
 }, AST_Lambda);
 
@@ -859,7 +857,7 @@ TreeWalker.prototype = {
         if (!ret && descend) {
             descend.call(node);
         }
-        this.pop(node);
+        this.pop();
         return ret;
     },
     parent: function(n) {
@@ -873,9 +871,8 @@ TreeWalker.prototype = {
         }
         this.stack.push(node);
     },
-    pop: function(node) {
+    pop: function() {
-        this.stack.pop();
+        if (this.stack.pop() instanceof AST_Lambda) {
-        if (node instanceof AST_Lambda) {
             this.directives = Object.getPrototypeOf(this.directives);
         }
     },
@@ -901,24 +898,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,31 +27,55 @@ function set_shorthand(name, options, keys) {
     }
 }
 
+function init_cache(cache) {
+    if (!cache) return;
+    if (!("cname" in cache)) cache.cname = -1;
+    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 {
+        cname: cache.cname,
+        props: cache.props.toObject()
+    };
+}
+
 function minify(files, options) {
     var warn_function = AST_Node.warn_function;
     try {
-        if (typeof files == "string") {
-            files = [ files ];
-        }
         options = defaults(options, {
             compress: {},
             ie8: false,
             keep_fnames: false,
             mangle: {},
+            nameCache: null,
             output: {},
             parse: {},
+            rename: undefined,
             sourceMap: false,
+            timings: false,
             toplevel: false,
             warnings: false,
             wrap: false,
         }, true);
+        var timings = options.timings && {
+            start: Date.now()
+        };
+        if (options.rename === undefined) {
+            options.rename = options.compress && options.mangle;
+        }
         set_shorthand("ie8", options, [ "compress", "mangle", "output" ]);
         set_shorthand("keep_fnames", options, [ "compress", "mangle" ]);
         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_fnames: false,
@@ -59,6 +83,21 @@ function minify(files, options) {
                 reserved: [],
                 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, {
@@ -75,13 +114,17 @@ function minify(files, options) {
                 warnings.push(warning);
             };
         }
+        if (timings) timings.parse = Date.now();
         var toplevel;
         if (files instanceof AST_Toplevel) {
             toplevel = files;
         } else {
+            if (typeof files == "string") {
+                files = [ files ];
+            }
             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") {
@@ -92,22 +135,32 @@ 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 (options.compress) {
+        if (timings) timings.rename = Date.now();
+        if (options.rename) {
             toplevel.figure_out_scope(options.mangle);
-            toplevel = new Compressor(options.compress).compress(toplevel);
+            toplevel.expand_names(options.mangle);
         }
+        if (timings) timings.compress = Date.now();
+        if (options.compress) toplevel = new Compressor(options.compress).compress(toplevel);
+        if (timings) timings.scope = Date.now();
+        if (options.mangle) toplevel.figure_out_scope(options.mangle);
+        if (timings) timings.mangle = Date.now();
         if (options.mangle) {
-            toplevel.figure_out_scope(options.mangle);
             base54.reset();
             toplevel.compute_char_frequency(options.mangle);
             toplevel.mangle_names(options.mangle);
-            if (options.mangle.properties) {
+        }
+        if (timings) timings.properties = Date.now();
+        if (options.mangle && options.mangle.properties) {
             toplevel = mangle_properties(toplevel, options.mangle.properties);
         }
-        }
+        if (timings) timings.output = Date.now();
         var result = {};
         if (options.output.ast) {
             result.ast = toplevel;
@@ -123,7 +176,9 @@ function minify(files, options) {
                     root: options.sourceMap.root
                 });
                 if (options.sourceMap.includeSources) {
-                    for (var name in files) {
+                    if (files instanceof AST_Toplevel) {
+                        throw new Error("original source content unavailable");
+                    } else for (var name in files) if (HOP(files, name)) {
                         options.output.source_map.get().setSourceContent(name, files[name]);
                     }
                 }
@@ -142,6 +197,25 @@ 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.rename - timings.parse),
+                rename: 1e-3 * (timings.compress - timings.rename),
+                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),
+                total: 1e-3 * (timings.end - timings.start)
+            }
+        }
         if (warnings.length) {
             result.warnings = warnings;
         }

lib/output.js

@@ -52,6 +52,7 @@ function is_some_comments(comment) {
 
 function OutputStream(options) {
 
+    var readonly = !options;
     options = defaults(options, {
         ascii_only       : false,
         beautify         : false,
@@ -70,6 +71,7 @@ function OutputStream(options) {
         semicolons       : true,
         shebang          : true,
         source_map       : null,
+        webkit           : false,
         width            : 80,
         wrap_iife        : false,
     }, true);
@@ -108,7 +110,7 @@ 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(/[\u0000-\u001f\u007f-\uffff]/g, function(ch) {
             var code = ch.charCodeAt(0).toString(16);
             if (code.length <= 2 && !identifier) {
@@ -119,6 +121,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) {
@@ -139,7 +152,7 @@ function OutputStream(options) {
               case "\u2029": return "\\u2029";
               case "\ufeff": return "\\ufeff";
               case "\0":
-                  return /[0-7]/.test(str.charAt(i+1)) ? "\\x00" : "\\0";
+                  return /[0-9]/.test(str.charAt(i+1)) ? "\\x00" : "\\0";
             }
             return s;
         });
@@ -149,7 +162,7 @@ function OutputStream(options) {
         function quote_double() {
             return '"' + str.replace(/\x22/g, '\\"') + '"';
         }
-        if (options.ascii_only) str = to_ascii(str);
+        str = to_utf8(str);
         switch (options.quote_style) {
           case 1:
             return quote_single();
@@ -174,8 +187,7 @@ function OutputStream(options) {
 
     function make_name(name) {
         name = name.toString();
-        if (options.ascii_only)
+        name = to_utf8(name, true);
-            name = to_ascii(name, true);
         return name;
     };
 
@@ -188,13 +200,47 @@ 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 && [];
+
+    var do_add_mapping = mappings ? function() {
+        mappings.forEach(function(mapping) {
+            try {
+                options.source_map.add(
+                    mapping.token.file,
+                    mapping.line, mapping.col,
+                    mapping.token.line, mapping.token.col,
+                    !mapping.name && mapping.token.type == "name" ? mapping.token.value : mapping.name
+                );
+            } catch(ex) {
+                AST_Node.warn("Couldn't figure out mapping for {file}:{line},{col} → {cline},{ccol} [{name}]", {
+                    file: mapping.token.file,
+                    line: mapping.token.line,
+                    col: mapping.token.col,
+                    cline: mapping.line,
+                    ccol: mapping.col,
+                    name: mapping.name || ""
+                })
+            }
+        });
+        mappings = [];
+    } : noop;
 
     var ensure_line_len = options.max_line_len ? function() {
         if (current_col > options.max_line_len) {
             if (might_add_newline) {
                 var left = OUTPUT.slice(0, might_add_newline);
                 var right = OUTPUT.slice(might_add_newline);
+                if (mappings) {
+                    var delta = right.length - current_col;
+                    mappings.forEach(function(mapping) {
+                        mapping.line++;
+                        mapping.col += delta;
+                    });
+                }
                 OUTPUT = left + "\n" + right;
                 current_line++;
                 current_pos++;
@@ -204,7 +250,10 @@ function OutputStream(options) {
                 AST_Node.warn("Output exceeds {max_line_len} characters", options);
             }
         }
+        if (might_add_newline) {
             might_add_newline = 0;
+            do_add_mapping();
+        }
     } : noop;
 
     var requireSemicolonChars = makePredicate("( [ + * / - , .");
@@ -212,6 +261,20 @@ function OutputStream(options) {
     function print(str) {
         str = String(str);
         var ch = str.charAt(0);
+        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;
@@ -264,6 +327,18 @@ function OutputStream(options) {
             }
             might_need_space = false;
         }
+
+        if (mapping_token) {
+            mappings.push({
+                token: mapping_token,
+                name: mapping_name,
+                line: current_line,
+                col: current_col
+            });
+            mapping_token = false;
+            if (!might_add_newline) do_add_mapping();
+        }
+
         OUTPUT += str;
         current_pos += str.length;
         var a = str.split(/\r?\n/), n = a.length - 1;
@@ -298,7 +373,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;
@@ -358,24 +439,9 @@ function OutputStream(options) {
         space();
     };
 
-    var add_mapping = options.source_map ? function(token, name) {
+    var add_mapping = mappings ? function(token, name) {
-        try {
+        mapping_token = token;
-            if (token) options.source_map.add(
+        mapping_name = name;
-                token.file || "?",
-                current_line, current_col,
-                token.line, token.col,
-                (!name && token.type == "name") ? token.value : name
-            );
-        } catch(ex) {
-            AST_Node.warn("Couldn't figure out mapping for {file}:{line},{col} → {cline},{ccol} [{name}]", {
-                file: token.file,
-                line: token.line,
-                col: token.col,
-                cline: current_line,
-                ccol: current_col,
-                name: name || ""
-            })
-        }
     } : noop;
 
     function get() {
@@ -385,6 +451,116 @@ function OutputStream(options) {
         return OUTPUT;
     };
 
+    function prepend_comments(node) {
+        var self = this;
+        var start = node.start;
+        if (!(start.comments_before && start.comments_before._dumped === self)) {
+            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) {
+                        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 = /(^|\n) *$/.test(OUTPUT);
+            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) {
+            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 || !/(^|\n) *$/.test(OUTPUT))) {
+                    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,
@@ -401,7 +577,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);
@@ -422,7 +598,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 ? noop : append_comments,
         line            : function() { return current_line },
         col             : function() { return current_col },
         pos             : function() { return current_pos },
@@ -445,18 +622,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)) {
@@ -465,84 +647,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) {
@@ -566,6 +682,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;
@@ -632,14 +755,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) {
-                    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 parens;
         }
     });
 
@@ -756,14 +880,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();
@@ -858,7 +989,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);
@@ -989,7 +1120,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);
@@ -1006,12 +1137,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 ]----- */
@@ -1033,19 +1164,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:
         //    https://github.com/mishoo/UglifyJS2/issues/60
-            node.walk(new TreeWalker(function(node){
+        if (noin) node.walk(new TreeWalker(function(node) {
-                if (node instanceof AST_Binary && node.operator == "in")
+            if (parens || node instanceof AST_Scope) return true;
-                    throw output;
+            if (node instanceof AST_Binary && node.operator == "in") {
-            }));
+                parens = true;
-            node.print(output);
+                return true;
-        } catch(ex) {
-            if (ex !== output) throw ex;
-            node.print(output, true);
             }
+        }));
+        node.print(output, parens);
     };
 
     DEFPRINT(AST_VarDef, function(self, output){
@@ -1065,6 +1194,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();
@@ -1104,6 +1236,13 @@ function OutputStream(options) {
     DEFPRINT(AST_Dot, function(self, output){
         var expr = self.expression;
         expr.print(output);
+        var prop = self.property;
+        if (output.option("ie8") && RESERVED_WORDS(prop)) {
+            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(".");
@@ -1112,7 +1251,8 @@ function OutputStream(options) {
             output.print(".");
             // the name after dot would be mapped about here.
             output.add_mapping(self.end);
-        output.print_name(self.property);
+            output.print_name(prop);
+        }
     });
     DEFPRINT(AST_Sub, function(self, output){
         self.expression.print(output);
@@ -1203,9 +1343,8 @@ function OutputStream(options) {
         });
         else output.print("{}");
     });
-    DEFPRINT(AST_ObjectKeyVal, function(self, output){
+
-        var key = self.key;
+    function print_property_name(key, quote, output) {
-        var quote = self.quote;
         if (output.option("quote_keys")) {
             output.print_string(key + "");
         } else if ((typeof key == "number"
@@ -1222,20 +1361,24 @@ function OutputStream(options) {
         } else {
             output.print_string(key, quote);
         }
+    }
+
+    DEFPRINT(AST_ObjectKeyVal, function(self, output){
+        print_property_name(self.key, self.quote, output);
         output.colon();
         self.value.print(output);
     });
-    DEFPRINT(AST_ObjectSetter, function(self, output){
+    AST_ObjectProperty.DEFMETHOD("_print_getter_setter", function(type, output) {
-        output.print("set");
+        output.print(type);
         output.space();
-        self.key.print(output);
+        print_property_name(this.key.name, this.quote, output);
-        self.value._do_print(output, true);
+        this.value._do_print(output, true);
+    });
+    DEFPRINT(AST_ObjectSetter, function(self, output){
+        self._print_getter_setter("set", output);
     });
     DEFPRINT(AST_ObjectGetter, function(self, output){
-        output.print("get");
+        self._print_getter_setter("get", output);
-        output.space();
-        self.key.print(output);
-        self.value._do_print(output, true);
     });
     DEFPRINT(AST_Symbol, function(self, output){
         var def = self.definition();
@@ -1265,9 +1408,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/parse.js

@@ -115,8 +115,6 @@ var PUNC_BEFORE_EXPRESSION = makePredicate(characters("[{(,;:"));
 
 var PUNC_CHARS = makePredicate(characters("[]{}(),;:"));
 
-var REGEXP_MODIFIERS = makePredicate(characters("gmsiy"));
-
 /* -----[ Tokenizer ]----- */
 
 // regexps adapted from http://xregexp.com/plugins/#unicode
@@ -134,6 +132,18 @@ function is_letter(code) {
         || (code >= 0xaa && UNICODE.letter.test(String.fromCharCode(code)));
 };
 
+function is_surrogate_pair_head(code) {
+    if (typeof code == "string")
+        code = code.charCodeAt(0);
+    return code >= 0xd800 && code <= 0xdbff;
+}
+
+function is_surrogate_pair_tail(code) {
+    if (typeof code == "string")
+        code = code.charCodeAt(0);
+    return code >= 0xdc00 && code <= 0xdfff;
+}
+
 function is_digit(code) {
     return code >= 48 && code <= 57;
 };
@@ -307,11 +317,7 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
         }
         if (!is_comment) {
             ret.comments_before = S.comments_before;
-            S.comments_before = [];
+            ret.comments_after = S.comments_before = [];
-            // make note of any newlines in the comments that came before
-            for (var i = 0, len = ret.comments_before.length; i < len; i++) {
-                ret.nlb = ret.nlb || ret.comments_before[i].nlb;
-            }
         }
         S.newline_before = false;
         return new AST_Token(ret);
@@ -684,9 +690,7 @@ var PRECEDENCE = (function(a, ret){
     {}
 );
 
-var STATEMENTS_WITH_LABELS = array_to_hash([ "for", "do", "while", "switch" ]);
+var ATOMIC_START_TOKEN = makePredicate([ "atom", "num", "string", "regexp", "name" ]);
-
-var ATOMIC_START_TOKEN = array_to_hash([ "atom", "num", "string", "regexp", "name" ]);
 
 /* -----[ Parser ]----- */
 
@@ -700,7 +704,7 @@ function parse($TEXT, options) {
         shebang        : true,
         strict         : false,
         toplevel       : null,
-    });
+    }, true);
 
     var S = {
         input         : (typeof $TEXT == "string"
@@ -1014,8 +1018,12 @@ function parse($TEXT, options) {
                 ? (next(), var_(true))
                 : expression(true, true);
             if (is("operator", "in")) {
-                if (init instanceof AST_Var && init.definitions.length > 1)
+                if (init instanceof AST_Var) {
-                    croak("Only one variable declaration allowed in for..in loop");
+                    if (init.definitions.length > 1)
+                        croak("Only one variable declaration allowed in for..in loop", init.start.line, init.start.col, init.start.pos);
+                } else if (!is_assignable(init)) {
+                    croak("Invalid left-hand side in for..in loop", init.start.line, init.start.col, init.start.pos);
+                }
                 next();
                 return for_in(init);
             }
@@ -1054,6 +1062,8 @@ function parse($TEXT, options) {
         var name = is("name") ? as_symbol(in_statement ? AST_SymbolDefun : AST_SymbolLambda) : null;
         if (in_statement && !name)
             unexpected();
+        if (name && ctor !== AST_Accessor && !(name instanceof AST_SymbolDeclaration))
+            unexpected(prev());
         expect("(");
         var argnames = [];
         for (var first = true; !is("punc", ")");) {
@@ -1222,7 +1232,6 @@ function parse($TEXT, options) {
         var tok = S.token, ret;
         switch (tok.type) {
           case "name":
-          case "keyword":
             ret = _make_symbol(AST_SymbolRef);
             break;
           case "num":
@@ -1252,13 +1261,6 @@ function parse($TEXT, options) {
                 break;
             }
             break;
-          case "operator":
-            if (!is_identifier_string(tok.value)) {
-                croak("Invalid getter/setter name: " + tok.value,
-                    tok.line, tok.col, tok.pos);
-            }
-            ret = _make_symbol(AST_SymbolRef);
-            break;
         }
         next();
         return ret;
@@ -1274,9 +1276,26 @@ function parse($TEXT, options) {
               case "(":
                 next();
                 var ex = expression(true);
+                var len = start.comments_before.length;
+                [].unshift.apply(ex.start.comments_before, start.comments_before);
+                start.comments_before = ex.start.comments_before;
+                start.comments_before_length = len;
+                if (len == 0 && start.comments_before.length > 0) {
+                    var comment = start.comments_before[0];
+                    if (!comment.nlb) {
+                        comment.nlb = start.nlb;
+                        start.nlb = false;
+                    }
+                }
+                start.comments_after = ex.start.comments_after;
                 ex.start = start;
-                ex.end = S.token;
                 expect(")");
+                var end = prev();
+                end.comments_before = ex.end.comments_before;
+                [].push.apply(ex.end.comments_after, end.comments_after);
+                end.comments_after = ex.end.comments_after;
+                ex.end = end;
+                if (ex instanceof AST_Call) mark_pure(ex);
                 return subscripts(ex, allow_calls);
               case "[":
                 return subscripts(array_(), allow_calls);
@@ -1292,7 +1311,7 @@ function parse($TEXT, options) {
             func.end = prev();
             return subscripts(func, allow_calls);
         }
-        if (ATOMIC_START_TOKEN[S.token.type]) {
+        if (ATOMIC_START_TOKEN(S.token.type)) {
             return subscripts(as_atom_node(), allow_calls);
         }
         unexpected();
@@ -1424,6 +1443,19 @@ function parse($TEXT, options) {
         return sym;
     };
 
+    function mark_pure(call) {
+        var start = call.start;
+        var comments = start.comments_before;
+        var i = HOP(start, "comments_before_length") ? start.comments_before_length : comments.length;
+        while (--i >= 0) {
+            var comment = comments[i];
+            if (/[@#]__PURE__/.test(comment.value)) {
+                call.pure = comment;
+                break;
+            }
+        }
+    }
+
     var subscripts = function(expr, allow_calls) {
         var start = expr.start;
         if (is("punc", ".")) {
@@ -1448,12 +1480,14 @@ function parse($TEXT, options) {
         }
         if (allow_calls && is("punc", "(")) {
             next();
-            return subscripts(new AST_Call({
+            var call = new AST_Call({
                 start      : start,
                 expression : expr,
                 args       : expr_list(")"),
                 end        : prev()
-            }), true);
+            });
+            mark_pure(call);
+            return subscripts(call, true);
         }
         return expr;
     };

lib/propmangle.js

@@ -67,6 +67,34 @@ 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_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,
@@ -76,9 +104,10 @@ 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;
@@ -90,7 +119,6 @@ function mangle_properties(ast, options) {
     }
 
     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'
@@ -103,12 +131,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
@@ -118,14 +145,13 @@ function mangle_properties(ast, options) {
             add(node.property);
         }
         else if (node instanceof AST_Sub) {
-            addStrings(node.property, keep_quoted);
+            addStrings(node.property, add);
         }
     }));
 
     // 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);
         }
         else if (node instanceof AST_ObjectProperty) {
@@ -135,22 +161,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);
         }
-        // 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
@@ -166,19 +179,13 @@ function mangle_properties(ast, options) {
     }
 
     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)
             || 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);
 
@@ -198,19 +205,16 @@ function mangle_properties(ast, options) {
                 // 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);
-                } while (!can_mangle(mangled) || keep_quoted && mangled in to_keep);
+                } while (!can_mangle(mangled));
             }
 
             cache.props.set(name, mangled);
@@ -218,32 +222,6 @@ function mangle_properties(ast, options) {
         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,15 +43,16 @@
 
 "use strict";
 
-function SymbolDef(scope, index, orig) {
+function SymbolDef(scope, orig) {
     this.name = orig.name;
     this.orig = [ orig ];
+    this.eliminated = 0;
     this.scope = scope;
     this.references = [];
+    this.replaced = 0;
     this.global = false;
     this.mangled_name = null;
     this.undeclared = false;
-    this.index = index;
     this.id = SymbolDef.next_id++;
 };
 
@@ -79,7 +80,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);
@@ -87,6 +88,9 @@ SymbolDef.prototype = {
                 cache.set(this.name, this.mangled_name);
             }
         }
+    },
+    redefined: function() {
+        return this.defun && this.defun.variables.get(this.name);
     }
 };
 
@@ -183,16 +187,8 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
     self.walk(tw);
 
     // pass 2: find back references and eval
-    var func = null;
+    self.globals = new Dictionary();
-    var globals = self.globals = new Dictionary();
     var tw = new TreeWalker(function(node, descend){
-        if (node instanceof AST_Lambda) {
-            var prev_func = func;
-            func = node;
-            descend();
-            func = prev_func;
-            return true;
-        }
         if (node instanceof AST_LoopControl && node.label) {
             node.label.thedef.references.push(node);
             return true;
@@ -205,16 +201,25 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
                 }
             }
             var sym = node.scope.find_variable(name);
-            if (node.scope instanceof AST_Lambda && name == "arguments") {
-                node.scope.uses_arguments = true;
-            }
             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);
             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);
 
@@ -231,6 +236,7 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
                     ref.reference(options);
                 });
                 node.thedef = def;
+                node.reference(options);
                 return true;
             }
         }));
@@ -246,7 +252,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);
@@ -307,7 +313,7 @@ AST_Scope.DEFMETHOD("def_function", function(symbol){
 AST_Scope.DEFMETHOD("def_variable", function(symbol){
     var def;
     if (!this.variables.has(symbol.name)) {
-        def = new SymbolDef(this, this.variables.size(), symbol);
+        def = new SymbolDef(this, symbol);
         this.variables.set(symbol.name, def);
         def.global = !this.parent_scope;
     } else {
@@ -325,7 +331,7 @@ AST_Scope.DEFMETHOD("next_mangled", function(options){
 
         // 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
@@ -357,31 +363,18 @@ AST_Function.DEFMETHOD("next_mangled", function(options, def){
 });
 
 AST_Symbol.DEFMETHOD("unmangleable", function(options){
-    return this.definition().unmangleable(options);
+    var def = this.definition();
+    return !def || def.unmangleable(options);
 });
 
 // labels are always mangleable
-AST_Label.DEFMETHOD("unmangleable", function(){
+AST_Label.DEFMETHOD("unmangleable", return_false);
-    return false;
-});
 
 AST_Symbol.DEFMETHOD("unreferenced", function(){
     return this.definition().references.length == 0
         && !(this.scope.uses_eval || this.scope.uses_with);
 });
 
-AST_Symbol.DEFMETHOD("undeclared", function(){
-    return this.definition().undeclared;
-});
-
-AST_LabelRef.DEFMETHOD("undeclared", function(){
-    return false;
-});
-
-AST_Label.DEFMETHOD("undeclared", function(){
-    return false;
-});
-
 AST_Symbol.DEFMETHOD("definition", function(){
     return this.thedef;
 });
@@ -391,21 +384,22 @@ AST_Symbol.DEFMETHOD("global", function(){
 });
 
 AST_Toplevel.DEFMETHOD("_default_mangler_options", function(options) {
-    return defaults(options, {
+    options = defaults(options, {
         eval        : false,
         ie8         : false,
         keep_fnames : false,
         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
@@ -414,11 +408,7 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options){
     var to_mangle = [];
 
     if (options.cache) {
-        this.globals.each(function(symbol){
+        this.globals.each(collect);
-            if (options.reserved.indexOf(symbol.name) < 0) {
-                to_mangle.push(symbol);
-            }
-        });
     }
 
     var tw = new TreeWalker(function(node, descend){
@@ -430,13 +420,7 @@ 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){
-                if (options.reserved.indexOf(symbol.name) < 0) {
-                    a.push(symbol);
-                }
-            });
-            to_mangle.push.apply(to_mangle, a);
             return;
         }
         if (node instanceof AST_Label) {
@@ -456,107 +440,146 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options){
     if (options.cache) {
         options.cache.cname = this.cname;
     }
+
+    function collect(symbol) {
+        if (!member(symbol.name, options.reserved)) {
+            to_mangle.push(symbol);
+        }
+    }
+});
+
+AST_Toplevel.DEFMETHOD("find_unique_prefix", function(options) {
+    var letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_";
+    var cache = options.cache && options.cache.props;
+    var prefixes = Object.create(null);
+    options.reserved.forEach(add_prefix);
+    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());
+    }));
+    var prefix, i = 0;
+    do {
+        prefix = create_name(i++);
+    } while (prefixes[prefix]);
+    return prefix;
+
+    function add_prefix(name) {
+        if (/[0-9]$/.test(name)) {
+            prefixes[name.replace(/[0-9]+$/, "")] = 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;
+        add_prefix(name);
+    }
+
+    function create_name(num) {
+        var name = "";
+        do {
+            name += letters[num % letters.length];
+            num = Math.floor(num / letters.length);
+        } while (num);
+        return name;
+    }
+});
+
+AST_Toplevel.DEFMETHOD("expand_names", function(options) {
+    options = this._default_mangler_options(options);
+    var prefix = this.find_unique_prefix(options);
+    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 rename(def) {
+        if (def.global || def.unmangleable(options)) return;
+        if (member(def.name, options.reserved)) return;
+        var d = def.redefined();
+        def.name = d ? d.name : prefix + def.id;
+        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_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" + node.key);
-        else if (node instanceof AST_ObjectGetter)
-            base54.consider("get" + node.key);
-        else if (node instanceof AST_ObjectKeyVal)
-            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_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_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];
         }
     };
-    base54.sort = function() {
+    function compare(a, b) {
-        chars = mergeSort(chars, function(a, b){
-            if (is_digit(a) && !is_digit(b)) return 1;
-            if (is_digit(b) && !is_digit(a)) return -1;
         return frequency[b] - frequency[a];
-        });
+    }
+    base54.sort = function() {
+        chars = mergeSort(leading, compare).concat(mergeSort(digits, compare));
     };
     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;
                 descend(x, tw);
-                } else {
+                if (tw.after) {
-                    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;
         });
     };

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) {
@@ -347,7 +324,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

@@ -4,7 +4,7 @@
   "homepage": "http://lisperator.net/uglifyjs",
   "author": "Mihai Bazon <mihai.bazon@gmail.com> (http://lisperator.net/)",
   "license": "BSD-2-Clause",
-  "version": "3.0.8",
+  "version": "3.3.1",
   "engines": {
     "node": ">=0.8.0"
   },
@@ -29,16 +29,16 @@
     "LICENSE"
   ],
   "dependencies": {
-    "commander": "~2.9.0",
+    "commander": "~2.12.1",
-    "source-map": "~0.5.1"
+    "source-map": "~0.6.1"
   },
   "devDependencies": {
-    "acorn": "~5.0.3",
+    "acorn": "~5.2.1",
-    "mocha": "~2.3.4",
+    "mocha": "~3.5.1",
-    "semver": "~5.3.0"
+    "semver": "~5.4.1"
   },
   "scripts": {
     "test": "node test/run-tests.js"
   },
-  "keywords": ["uglify", "uglify-js", "minify", "minifier"]
+  "keywords": ["uglify", "uglify-js", "minify", "minifier", "es5"]
 }

test/benchmark.js

@@ -4,12 +4,14 @@
 "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");
 }
-args.push("--stats");
+args.push("--timings");
 var urls = [
     "https://code.jquery.com/jquery-3.2.1.js",
     "https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.6.4/angular.js",
@@ -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;
@@ -29,14 +32,10 @@ function done() {
             var info = results[url];
             console.log();
             console.log(url);
-            var elapsed = 0;
+            console.log(info.log);
-            console.log(info.log.replace(/Elapsed: ([0-9]+)\s*/g, function(match, time) {
-                elapsed += 1e-3 * parseInt(time);
-                return "";
-            }));
-            console.log("Run-time:", elapsed.toFixed(3), "s");
             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);
@@ -55,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

@@ -128,50 +128,114 @@ constant_join_3: {
 
 for_loop: {
     options = {
+        evaluate: true,
+        reduce_funcs: true,
+        reduce_vars: true,
         unsafe: true,
         unused: true,
-        evaluate    : true,
-        reduce_vars : 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/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/comparing.js

@@ -74,3 +74,41 @@ 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"
+}

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);
             } else {
                 do_something(y);
             }
-        if (some_condition()) {
+            if (some_condition) {
                 side_effects(x);
             } else {
                 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);
             } else {
                 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,151 @@ 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",
+    ]
+}

test/compress/dead-code.js

@@ -31,7 +31,7 @@ dead_code_2_should_warn: {
         function f() {
             g();
             x = 10;
-            throw "foo";
+            throw new Error("foo");
             // completely discarding the `if` would introduce some
             // bugs.  UglifyJS v1 doesn't deal with this issue; in v2
             // we copy any declarations to the upper scope.
@@ -46,16 +46,60 @@ dead_code_2_should_warn: {
                 })();
             }
         }
+        f();
     }
     expect: {
         function f() {
             g();
             x = 10;
-            throw "foo";
+            throw new Error("foo");
             var x;
             function g(){};
         }
+        f();
     }
+    expect_stdout: true
+    node_version: "<=4"
+}
+
+dead_code_2_should_warn_strict: {
+    options = {
+        dead_code: true
+    };
+    input: {
+        "use strict";
+        function f() {
+            g();
+            x = 10;
+            throw new Error("foo");
+            // completely discarding the `if` would introduce some
+            // bugs.  UglifyJS v1 doesn't deal with this issue; in v2
+            // we copy any declarations to the upper scope.
+            if (x) {
+                y();
+                var x;
+                function g(){};
+                // but nested declarations should not be kept.
+                (function(){
+                    var q;
+                    function y(){};
+                })();
+            }
+        }
+        f();
+    }
+    expect: {
+        "use strict";
+        function f() {
+            g();
+            x = 10;
+            throw new Error("foo");
+            var x;
+        }
+        f();
+    }
+    expect_stdout: true
+    node_version: ">=4"
 }
 
 dead_code_constant_boolean_should_warn_more: {
@@ -78,16 +122,55 @@ dead_code_constant_boolean_should_warn_more: {
             foo();
             var moo;
         }
+        bar();
     }
     expect: {
         var foo;
         function 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: "<=4"
+}
+
+dead_code_constant_boolean_should_warn_more_strict: {
+    options = {
+        dead_code    : true,
+        loops        : true,
+        booleans     : true,
+        conditionals : true,
+        evaluate     : true,
+        side_effects : true,
+    };
+    input: {
+        "use strict";
+        while (!((foo && bar) || (x + "0"))) {
+            console.log("unreachable");
+            var foo;
+            function bar() {}
+        }
+        for (var x = 10, y; x && (y || x) && (!typeof x); ++x) {
+            asdf();
+            foo();
+            var moo;
+        }
+        bar();
+    }
+    expect: {
+        "use strict";
+        var foo;
+        // nothing for the while
+        // as for the for, it should keep:
+        var moo;
+        var x = 10, y;
+        bar();
+    }
+    expect_stdout: true
+    node_version: ">=4"
 }
 
 try_catch_finally: {
@@ -95,6 +178,8 @@ try_catch_finally: {
         conditionals: true,
         dead_code: true,
         evaluate: true,
+        passes: 2,
+        side_effects: true,
     }
     input: {
         var a = 1;
@@ -147,3 +232,599 @@ 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",
+    ]
+}
+
+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"
+}

test/compress/drop-unused.js

@@ -179,7 +179,9 @@ keep_fnames: {
 }
 
 drop_assign: {
-    options = { unused: true };
+    options = {
+        unused: true,
+    }
     input: {
         function f1() {
             var a;
@@ -200,7 +202,7 @@ drop_assign: {
             var a;
             return function() {
                 a = 1;
-            }
+            };
         }
     }
     expect: {
@@ -217,16 +219,17 @@ drop_assign: {
             return 1;
         }
         function f5() {
-            var a;
             return function() {
-                a = 1;
+                1;
-            }
+            };
         }
     }
 }
 
 keep_assign: {
-    options = { unused: "keep_assign" };
+    options = {
+        unused: "keep_assign",
+    }
     input: {
         function f1() {
             var a;
@@ -247,7 +250,7 @@ keep_assign: {
             var a;
             return function() {
                 a = 1;
-            }
+            };
         }
     }
     expect: {
@@ -270,19 +273,22 @@ keep_assign: {
             var a;
             return function() {
                 a = 1;
-            }
+            };
         }
     }
 }
 
 drop_toplevel_funcs: {
-    options = { toplevel: "funcs", unused: true };
+    options = {
+        toplevel: "funcs",
+        unused: true,
+    }
     input: {
         var a, b = 1, c = g;
         function f(d) {
             return function() {
                 c = 2;
-            }
+            };
         }
         a = 2;
         function g() {}
@@ -298,13 +304,16 @@ drop_toplevel_funcs: {
 }
 
 drop_toplevel_vars: {
-    options = { toplevel: "vars", unused: true };
+    options = {
+        toplevel: "vars",
+        unused: true,
+    }
     input: {
         var a, b = 1, c = g;
         function f(d) {
             return function() {
                 c = 2;
-            }
+            };
         }
         a = 2;
         function g() {}
@@ -312,11 +321,10 @@ drop_toplevel_vars: {
         console.log(b = 3);
     }
     expect: {
-        var c = g;
         function f(d) {
             return function() {
-                c = 2;
+                2;
-            }
+            };
         }
         2;
         function g() {}
@@ -326,13 +334,17 @@ drop_toplevel_vars: {
 }
 
 drop_toplevel_vars_fargs: {
-    options = { keep_fargs: false, toplevel: "vars", unused: true };
+    options = {
+        keep_fargs: false,
+        toplevel: "vars",
+        unused: true,
+    }
     input: {
         var a, b = 1, c = g;
         function f(d) {
             return function() {
                 c = 2;
-            }
+            };
         }
         a = 2;
         function g() {}
@@ -340,11 +352,10 @@ drop_toplevel_vars_fargs: {
         console.log(b = 3);
     }
     expect: {
-        var c = g;
         function f() {
             return function() {
-                c = 2;
+                2;
-            }
+            };
         }
         2;
         function g() {}
@@ -354,13 +365,16 @@ drop_toplevel_vars_fargs: {
 }
 
 drop_toplevel_all: {
-    options = { toplevel: true, unused: true };
+    options = {
+        toplevel: true,
+        unused: true
+    }
     input: {
         var a, b = 1, c = g;
         function f(d) {
             return function() {
                 c = 2;
-            }
+            };
         }
         a = 2;
         function g() {}
@@ -374,13 +388,16 @@ drop_toplevel_all: {
 }
 
 drop_toplevel_retain: {
-    options = { top_retain: "f,a,o", unused: true };
+    options = {
+        top_retain: "f,a,o",
+        unused: true,
+    }
     input: {
         var a, b = 1, c = g;
         function f(d) {
             return function() {
                 c = 2;
-            }
+            };
         }
         a = 2;
         function g() {}
@@ -388,26 +405,28 @@ drop_toplevel_retain: {
         console.log(b = 3);
     }
     expect: {
-        var a, c = g;
+        var a;
         function f(d) {
             return function() {
-                c = 2;
+                2;
-            }
+            };
         }
         a = 2;
-        function g() {}
         console.log(3);
     }
 }
 
 drop_toplevel_retain_array: {
-    options = { top_retain: [ "f", "a", "o" ], unused: true };
+    options = {
+        top_retain: [ "f", "a", "o" ],
+        unused: true,
+    }
     input: {
         var a, b = 1, c = g;
         function f(d) {
             return function() {
                 c = 2;
-            }
+            };
         }
         a = 2;
         function g() {}
@@ -415,26 +434,28 @@ drop_toplevel_retain_array: {
         console.log(b = 3);
     }
     expect: {
-        var a, c = g;
+        var a;
         function f(d) {
             return function() {
-                c = 2;
+                2;
-            }
+            };
         }
         a = 2;
-        function g() {}
         console.log(3);
     }
 }
 
 drop_toplevel_retain_regex: {
-    options = { top_retain: /^[fao]$/, unused: true };
+    options = {
+        top_retain: /^[fao]$/,
+        unused: true,
+    }
     input: {
         var a, b = 1, c = g;
         function f(d) {
             return function() {
                 c = 2;
-            }
+            };
         }
         a = 2;
         function g() {}
@@ -442,26 +463,29 @@ drop_toplevel_retain_regex: {
         console.log(b = 3);
     }
     expect: {
-        var a, c = g;
+        var a;
         function f(d) {
             return function() {
-                c = 2;
+                2;
-            }
+            };
         }
         a = 2;
-        function g() {}
         console.log(3);
     }
 }
 
 drop_toplevel_all_retain: {
-    options = { toplevel: true, top_retain: "f,a,o", unused: true };
+    options = {
+        toplevel: true,
+        top_retain: "f,a,o",
+        unused: true,
+    }
     input: {
         var a, b = 1, c = g;
         function f(d) {
             return function() {
                 c = 2;
-            }
+            };
         }
         a = 2;
         function g() {}
@@ -469,26 +493,29 @@ drop_toplevel_all_retain: {
         console.log(b = 3);
     }
     expect: {
-        var a, c = g;
+        var a;
         function f(d) {
             return function() {
-                c = 2;
+                2;
-            }
+            };
         }
         a = 2;
-        function g() {}
         console.log(3);
     }
 }
 
 drop_toplevel_funcs_retain: {
-    options = { toplevel: "funcs", top_retain: "f,a,o", unused: true };
+    options = {
+        toplevel: "funcs",
+        top_retain: "f,a,o",
+        unused: true,
+    }
     input: {
         var a, b = 1, c = g;
         function f(d) {
             return function() {
                 c = 2;
-            }
+            };
         }
         a = 2;
         function g() {}
@@ -500,7 +527,7 @@ drop_toplevel_funcs_retain: {
         function f(d) {
             return function() {
                 c = 2;
-            }
+            };
         }
         a = 2;
         function g() {}
@@ -509,13 +536,17 @@ drop_toplevel_funcs_retain: {
 }
 
 drop_toplevel_vars_retain: {
-    options = { toplevel: "vars", top_retain: "f,a,o", unused: true };
+    options = {
+        toplevel: "vars",
+        top_retain: "f,a,o",
+        unused: true,
+    }
     input: {
         var a, b = 1, c = g;
         function f(d) {
             return function() {
                 c = 2;
-            }
+            };
         }
         a = 2;
         function g() {}
@@ -523,11 +554,11 @@ drop_toplevel_vars_retain: {
         console.log(b = 3);
     }
     expect: {
-        var a, c = g;
+        var a;
         function f(d) {
             return function() {
-                c = 2;
+                2;
-            }
+            };
         }
         a = 2;
         function g() {}
@@ -537,13 +568,16 @@ drop_toplevel_vars_retain: {
 }
 
 drop_toplevel_keep_assign: {
-    options = { toplevel: true, unused: "keep_assign" };
+    options = {
+        toplevel: true,
+        unused: "keep_assign",
+    }
     input: {
         var a, b = 1, c = g;
         function f(d) {
             return function() {
                 c = 2;
-            }
+            };
         }
         a = 2;
         function g() {}
@@ -651,7 +685,7 @@ drop_value: {
 
 issue_1539: {
     options = {
-        cascade: true,
+        collapse_vars: true,
         sequences: true,
         side_effects: true,
         unused: true,
@@ -673,6 +707,7 @@ issue_1539: {
 vardef_value: {
     options = {
         keep_fnames: false,
+        reduce_funcs: true,
         reduce_vars: true,
         unused: true,
     }
@@ -697,7 +732,7 @@ vardef_value: {
 
 assign_binding: {
     options = {
-        cascade: true,
+        collapse_vars: true,
         side_effects: true,
         unused: true,
     }
@@ -734,6 +769,7 @@ assign_chain: {
 issue_1583: {
     options = {
         keep_fargs: true,
+        reduce_funcs: true,
         reduce_vars: true,
         unused: true,
     }
@@ -751,10 +787,10 @@ issue_1583: {
     expect: {
         function m(t) {
             (function(e) {
-                t = (function() {
+                (function() {
                     return (function(a) {
-                        return a;
+                        return function(a) {};
-                    })(function(a) {});
+                    })();
                 })();
             })();
         }
@@ -1080,6 +1116,7 @@ var_catch_toplevel: {
     options = {
         conditionals: true,
         negate_iife: true,
+        reduce_funcs: true,
         reduce_vars: true,
         side_effects: true,
         toplevel: true,
@@ -1090,6 +1127,7 @@ var_catch_toplevel: {
             a--;
             try {
                 a++;
+                x();
             } catch(a) {
                 if (a) var a;
                 var a = 10;
@@ -1099,12 +1137,279 @@ var_catch_toplevel: {
     }
     expect: {
         !function() {
-            a--;
             try {
-                a++;
+                x();
             } catch(a) {
                 var a;
             }
         }();
     }
 }
+
+issue_2105_1: {
+    options = {
+        collapse_vars: true,
+        inline: true,
+        passes: 3,
+        reduce_funcs: true,
+        reduce_vars: true,
+        side_effects: 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: function() {
+                console.log;
+                console.log("PASS");
+            }
+        }).prop();
+    }
+    expect_stdout: "PASS"
+}
+
+issue_2105_2: {
+    options = {
+        collapse_vars: true,
+        inline: true,
+        passes: 3,
+        properties: true,
+        pure_getters: "strict",
+        reduce_funcs: true,
+        reduce_vars: true,
+        side_effects: true,
+        unsafe: 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: {
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+issue_2226_1: {
+    options = {
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        function f1() {
+            var a = b;
+            a += c;
+        }
+        function f2(a) {
+            a <<= b;
+        }
+        function f3(a) {
+            --a;
+        }
+        function f4() {
+            var a = b;
+            return a *= c;
+        }
+        function f5(a) {
+            x(a /= b);
+        }
+    }
+    expect: {
+        function f1() {
+            b;
+            c;
+        }
+        function f2(a) {
+            b;
+        }
+        function f3(a) {
+            0;
+        }
+        function f4() {
+            var a = b;
+            return a *= c;
+        }
+        function f5(a) {
+            x(a /= b);
+        }
+    }
+}
+
+issue_2226_2: {
+    options = {
+        collapse_vars: true,
+        sequences: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        console.log(function(a, b) {
+            a += b;
+            return a;
+        }(1, 2));
+    }
+    expect: {
+        console.log(function(a, b) {
+            return a += 2;
+        }(1));
+    }
+    expect_stdout: "3"
+}
+
+issue_2226_3: {
+    options = {
+        collapse_vars: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        console.log(function(a, b) {
+            a += b;
+            return a;
+        }(1, 2));
+    }
+    expect: {
+        console.log(function(a, b) {
+            return a += 2;
+        }(1));
+    }
+    expect_stdout: "3"
+}
+
+issue_2288: {
+    options = {
+        unused: true,
+    }
+    beautify = {
+        beautify: true,
+    }
+    input: {
+        function foo(o) {
+            for (var j = o.a, i = 0; i < 0; i++);
+            for (var i = 0; i < 0; i++);
+        }
+    }
+    expect: {
+        function foo(o) {
+            o.a;
+            for (var i = 0; i < 0; i++);
+            for (i = 0; i < 0; i++);
+        }
+    }
+}
+
+issue_2516_1: {
+    options = {
+        collapse_vars: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        function foo() {
+            function qux(x) {
+                bar.call(null, x);
+            }
+            function bar(x) {
+                var FOUR = 4;
+                var trouble = x || never_called();
+                var value = (FOUR - 1) * trouble;
+                console.log(value == 6 ? "PASS" : value);
+            }
+            Baz = qux;
+        }
+        var Baz;
+        foo();
+        Baz(2);
+    }
+    expect: {
+        function foo() {
+            Baz = function(x) {
+                (function(x) {
+                    var trouble = x || never_called();
+                    var value = (4 - 1) * trouble;
+                    console.log(6 == value ? "PASS" : value);
+                }).call(null, x);
+            };
+        }
+        var Baz;
+        foo();
+        Baz(2);
+    }
+}
+
+issue_2516_2: {
+    options = {
+        collapse_vars: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        passes: 2,
+        unused: true,
+    }
+    input: {
+        function foo() {
+            function qux(x) {
+                bar.call(null, x);
+            }
+            function bar(x) {
+                var FOUR = 4;
+                var trouble = x || never_called();
+                var value = (FOUR - 1) * trouble;
+                console.log(value == 6 ? "PASS" : value);
+            }
+            Baz = qux;
+        }
+        var Baz;
+        foo();
+        Baz(2);
+    }
+    expect: {
+        function foo() {
+            Baz = function(x) {
+                (function(x) {
+                    var value = (4 - 1) * (x || never_called());
+                    console.log(6 == value ? "PASS" : value);
+                }).call(null, x);
+            };
+        }
+        var Baz;
+        foo();
+        Baz(2);
+    }
+}

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;
@@ -251,21 +254,26 @@ unsafe_constant: {
 unsafe_object: {
     options = {
         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
         );
     }
@@ -275,21 +283,26 @@ unsafe_object: {
 unsafe_object_nested: {
     options = {
         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
         );
     }
@@ -299,20 +312,25 @@ unsafe_object_nested: {
 unsafe_object_complex: {
     options = {
         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
         );
@@ -323,21 +341,26 @@ unsafe_object_complex: {
 unsafe_object_repeated: {
     options = {
         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
         );
     }
@@ -347,6 +370,7 @@ unsafe_object_repeated: {
 unsafe_object_accessor: {
     options = {
         evaluate: true,
+        reduce_funcs: true,
         reduce_vars: true,
         unsafe: true,
     }
@@ -370,10 +394,11 @@ unsafe_object_accessor: {
     }
 }
 
-unsafe_function: {
+prop_function: {
     options = {
         evaluate: true,
-        unsafe    : true
+        properties: true,
+        side_effects: true,
     }
     input: {
         console.log(
@@ -386,9 +411,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
@@ -614,10 +639,11 @@ unsafe_string_bad_index: {
     expect_stdout: true
 }
 
-unsafe_prototype_function: {
+prototype_function: {
     options = {
         evaluate: true,
-        unsafe    : true
+        properties: true,
+        side_effects: true,
     }
     input: {
         var a = ({valueOf: 0}) < 1;
@@ -636,14 +662,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,
         toplevel: true,
     }
@@ -665,7 +693,9 @@ call_args: {
 call_args_drop_param: {
     options = {
         evaluate: true,
+        inline: true,
         keep_fargs: false,
+        reduce_funcs: true,
         reduce_vars: true,
         toplevel: true,
         unused: true,
@@ -780,13 +810,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]
         );
     }
 }
@@ -990,3 +1022,321 @@ Infinity_NaN_undefined_LHS: {
         "}",
     ]
 }
+
+issue_1964_1: {
+    options = {
+        evaluate: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        unsafe_regexp: false,
+        unused: true,
+    }
+    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() {
+            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: [
+        "\\s",
+        "b",
+    ]
+}
+
+issue_1964_2: {
+    options = {
+        evaluate: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        unsafe_regexp: true,
+        unused: true,
+    }
+    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: [
+        "\\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
+}
+
+issue_2231_2: {
+    options = {
+        evaluate: true,
+        unsafe: true,
+    }
+    input: {
+        console.log(Object.getOwnPropertyNames(null));
+    }
+    expect: {
+        console.log(Object.getOwnPropertyNames(null));
+    }
+    expect_stdout: true
+}
+
+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:1316,20]",
+        "WARN: Dropping side-effect-free && [test/compress/evaluate.js:1317,20]",
+        "WARN: Dropping side-effect-free && [test/compress/evaluate.js:1318,20]",
+        "WARN: Condition left of && always false [test/compress/evaluate.js:1318,20]",
+        "WARN: Dropping side-effect-free || [test/compress/evaluate.js:1319,20]",
+        "WARN: Dropping side-effect-free || [test/compress/evaluate.js:1320,20]",
+        "WARN: Dropping side-effect-free || [test/compress/evaluate.js:1321,20]",
+        "WARN: Condition left of || always true [test/compress/evaluate.js:1321,20]",
+    ]
+}

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]',
     ]
 }
 
@@ -160,3 +161,39 @@ issue_1801: {
         console.log(!0);
     }
 }
+
+issue_1986: {
+    options = {
+        global_defs: {
+            "@alert": "console.log",
+        },
+    }
+    input: {
+        alert(42);
+    }
+    expect: {
+        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,666 @@
+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"
+}
+
+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_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_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"
+}

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

@@ -302,3 +302,27 @@ issue_1437_conditionals: {
         }
     }
 }
+
+issue_512: {
+    options = {
+        conditionals: true,
+        if_return: true,
+        sequences: true,
+        side_effects: true,
+    }
+    input: {
+        function a() {
+            if (b()) {
+                c();
+                return;
+            }
+            throw e;
+        }
+    }
+    expect: {
+        function a() {
+            if (!b()) throw e;
+            c();
+        }
+    }
+}

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,10 +111,146 @@ 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]",
+    ]
+}
+
+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, side_effects: true
+    }
+    input: {
+        "use strict";
+        function foo(x) {
+            if (x) {
+                return bar();
+                not_called1();
+            } else {
+                return baz();
+                not_called2();
+            }
+            function bar() { return 7; }
+            return not_reached;
+            function UnusedFunction() {}
+            function baz() { return 8; }
+        }
+        console.log(foo(0), foo(1));
+    }
+    expect: {
+        "use strict";
+        function foo(x) {
+            return x ? bar() : baz();
+            function bar() { return 7 }
+            function baz() { return 8 }
+        }
+        console.log(foo(0), foo(1));
+    }
+    expect_stdout: "8 7"
+    expect_warnings: [
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:133,16]",
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:136,16]",
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:139,12]",
+        "WARN: Dropping unused function UnusedFunction [test/compress/issue-1034.js:140,21]",
+    ]
+}
+
+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, side_effects: true,
+        collapse_vars: false, passes: 2, warnings: "verbose"
+    }
+    input: {
+        "use strict";
+        function foo(x) {
+            if (x) {
+                return bar(1);
+                var a = not_called(1);
+            } else {
+                return bar(2);
+                var b = not_called(2);
+            }
+            var c = bar(3);
+            function bar(x) { return 7 - x; }
+            function nope() {}
+            return b || c;
+        }
+        console.log(foo(0), foo(1));
+    }
+    expect: {
+        "use strict";
+        function foo(x) {
+            return bar(x ? 1 : 2);
+            function bar(x) {
+                return 7 - x;
+            }
+        }
+        console.log(foo(0), foo(1));
+    }
+    expect_stdout: "5 6"
+    expect_warnings: [
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:175,16]",
+        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:175,16]",
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:178,16]",
+        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:178,16]",
+        "WARN: Dropping unused variable a [test/compress/issue-1034.js:175,20]",
+        "WARN: Dropping unused function nope [test/compress/issue-1034.js:182,21]",
+        "WARN: pass 0: last_count: Infinity, count: 48",
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:180,12]",
+        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:180,12]",
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:183,12]",
+        "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",
+    ]
+}
+
+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, side_effects: true,
+        collapse_vars: false
+    }
+    input: {
+        "use strict";
+        function foo(x) {
+            if (x) {
+                return bar(1);
+            } else {
+                return bar(2);
+                var b;
+            }
+            var c = bar(3);
+            function bar(x) {
+                return 7 - x;
+            }
+            return b || c;
+        }
+        console.log(foo(0), foo(1));
+    }
+    expect: {
+        "use strict";
+        function foo(x) {
+            return bar(x ? 1 : 2);
+            function bar(x) { return 7 - x; }
+        }
+        console.log(foo(0), foo(1));
+    }
+    expect_stdout: "5 6"
+    expect_warnings: [
+        // duplicate warnings no longer emitted
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:229,16]",
+        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:229,16]",
+        "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

@@ -1,6 +1,7 @@
 const_pragma: {
     options = {
         evaluate: true,
+        reduce_funcs: true,
         reduce_vars: true,
     };
 
@@ -16,6 +17,7 @@ const_pragma: {
 not_const: {
     options = {
         evaluate: true,
+        reduce_funcs: true,
         reduce_vars: true,
     };
 

test/compress/issue-1052.js

@@ -1,90 +1,91 @@
 multiple_functions: {
-    options = { if_return: true, hoist_funs: false };
+    options = {
+        hoist_funs: false,
+        if_return: true,
+    }
     input: {
         ( function() {
             if ( !window ) {
                 return;
             }
-
             function f() {}
             function g() {}
         } )();
     }
     expect: {
         ( function() {
-            function f() {}
-            function g() {}
-
             // NOTE: other compression steps will reduce this
             // down to just `window`.
             if ( window );
+            function f() {}
+            function g() {}
         } )();
     }
 }
 
 single_function: {
-    options = { if_return: true, hoist_funs: false };
+    options = {
+        hoist_funs: false,
+        if_return: true,
+    }
     input: {
         ( function() {
             if ( !window ) {
                 return;
             }
-
             function f() {}
         } )();
     }
     expect: {
         ( function() {
-            function f() {}
-
             if ( window );
+            function f() {}
         } )();
     }
 }
 
 deeply_nested: {
-    options = { if_return: true, hoist_funs: false };
+    options = {
+        hoist_funs: false,
+        if_return: true,
+    }
     input: {
         ( function() {
             if ( !window ) {
                 return;
             }
-
             function f() {}
             function g() {}
-
             if ( !document ) {
                 return;
             }
-
             function h() {}
         } )();
     }
     expect: {
         ( function() {
-            function f() {}
-            function g() {}
-
-            function h() {}
-
             // NOTE: other compression steps will reduce this
             // down to just `window`.
             if ( window )
                 if (document);
+            function f() {}
+            function g() {}
+            function h() {}
         } )();
     }
 }
 
 not_hoisted_when_already_nested: {
-    options = { if_return: true, hoist_funs: false };
+    options = {
+        hoist_funs: false,
+        if_return: true,
+    }
     input: {
         ( function() {
             if ( !window ) {
                 return;
             }
-
             if ( foo ) function f() {}
-
         } )();
     }
     expect: {
@@ -94,3 +95,70 @@ not_hoisted_when_already_nested: {
         } )();
     }
 }
+
+defun_if_return: {
+    options = {
+        hoist_funs: false,
+        if_return: true,
+    }
+    input: {
+        function e() {
+            function f() {}
+            if (!window) return;
+            else function g() {}
+            function h() {}
+        }
+    }
+    expect: {
+        function e() {
+            function f() {}
+            if (window) function g() {}
+            function h() {}
+        }
+    }
+}
+
+defun_hoist_funs: {
+    options = {
+        hoist_funs: true,
+        if_return: true,
+    }
+    input: {
+        function e() {
+            function f() {}
+            if (!window) return;
+            else function g() {}
+            function h() {}
+        }
+    }
+    expect: {
+        function e() {
+            function f() {}
+            function g() {}
+            function h() {}
+            if (window);
+        }
+    }
+}
+
+defun_else_if_return: {
+    options = {
+        hoist_funs: false,
+        if_return: true,
+    }
+    input: {
+        function e() {
+            function f() {}
+            if (window) function g() {}
+            else return;
+            function h() {}
+        }
+    }
+    expect: {
+        function e() {
+            function f() {}
+            if (window) function g() {}
+            function h() {}
+        }
+    }
+}

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-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 = {
+        properties: {
+            debug: "",
             keep_quoted: true,
-        debug: ""
+        },
     }
     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-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-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,
@@ -82,7 +86,7 @@ numeric_literal: {
         '    42: 2,',
         '    "42": 3,',
         '    37: 4,',
-        '    a: 5,',
+        '    o: 5,',
         '    1e42: 6,',
         '    b: 7,',
         '    "1e+42": 8',
@@ -92,7 +96,7 @@ numeric_literal: {
         '',
         '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"]);',
     ]
@@ -105,7 +109,9 @@ numeric_literal: {
 }
 
 identifier: {
-    mangle_props = {}
+    mangle = {
+        properties: true,
+    }
     input: {
         var obj = {
             abstract: 1,
@@ -173,32 +179,32 @@ identifier: {
     }
     expect: {
         var obj = {
-            a: 1,
+            e: 1,
-            b: 2,
+            t: 2,
-            c: 3,
+            n: 3,
-            d: 4,
+            a: 4,
-            e: 5,
+            i: 5,
-            f: 6,
+            o: 6,
-            g: 7,
+            r: 7,
-            h: 8,
+            l: 8,
-            i: 9,
+            s: 9,
-            j: 10,
+            c: 10,
-            k: 11,
+            f: 11,
-            l: 12,
+            u: 12,
-            m: 13,
+            d: 13,
-            n: 14,
+            h: 14,
-            o: 15,
+            p: 15,
-            p: 16,
+            b: 16,
-            q: 17,
+            v: 17,
-            r: 18,
+            w: 18,
-            s: 19,
+            y: 19,
-            t: 20,
+            g: 20,
-            u: 21,
+            m: 21,
-            v: 22,
+            k: 22,
-            w: 23,
+            x: 23,
-            x: 24,
+            j: 24,
-            y: 25,
+            z: 25,
-            z: 26,
+            q: 26,
             A: 27,
             B: 28,
             C: 29,
@@ -229,11 +235,11 @@ identifier: {
             Z: 54,
             $: 55,
             _: 56,
-            aa: 57,
+            ee: 57,
-            ba: 58,
+            te: 58,
-            ca: 59,
+            ne: 59,
-            da: 60,
+            ae: 60,
-            ea: 61,
+            ie: 61,
         };
     }
 }

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-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-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

@@ -148,9 +148,11 @@ parse_do_while_without_semicolon: {
 
 evaluate: {
     options = {
-        loops: true,
         dead_code: true,
         evaluate: true,
+        loops: true,
+        passes: 2,
+        side_effects: true,
     };
     input: {
         while (true) {
@@ -436,3 +438,57 @@ 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"
+}

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

@@ -82,3 +82,19 @@ new_with_unary_prefix: {
     }
     expect_exact: 'var bar=(+new Date).toString(32);';
 }
+
+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/properties.js

@@ -1,7 +1,8 @@
 keep_properties: {
     options = {
-        properties: false
+        evaluate: true,
-    };
+        properties: false,
+    }
     input: {
         a["foo"] = "bar";
     }
@@ -12,9 +13,12 @@ keep_properties: {
 
 dot_properties: {
     options = {
+        evaluate: true,
         properties: true,
+    }
+    beautify = {
         ie8: true,
-    };
+    }
     input: {
         a["foo"] = "bar";
         a["if"] = "if";
@@ -35,9 +39,12 @@ dot_properties: {
 
 dot_properties_es5: {
     options = {
+        evaluate: true,
         properties: true,
+    }
+    beautify = {
         ie8: false,
-    };
+    }
     input: {
         a["foo"] = "bar";
         a["if"] = "if";
@@ -57,8 +64,8 @@ dot_properties_es5: {
 sub_properties: {
     options = {
         evaluate: true,
-        properties: true
+        properties: true,
-    };
+    }
     input: {
         a[0] = 0;
         a["0"] = 1;
@@ -77,18 +84,18 @@ sub_properties: {
         a[3.14] = 3;
         a.if = 4;
         a["foo bar"] = 5;
-        a[NaN] = 6;
+        a.NaN = 6;
-        a[null] = 7;
+        a.null = 7;
         a[void 0] = 8;
     }
 }
 
 evaluate_array_length: {
     options = {
+        evaluate: true,
         properties: true,
         unsafe: true,
-        evaluate: true
+    }
-    };
     input: {
         a = [1, 2, 3].length;
         a = [1, 2, 3].join()["len" + "gth"];
@@ -105,10 +112,10 @@ evaluate_array_length: {
 
 evaluate_string_length: {
     options = {
+        evaluate: true,
         properties: true,
         unsafe: true,
-        evaluate: true
+    }
-    };
     input: {
         a = "foo".length;
         a = ("foo" + "bar")["len" + "gth"];
@@ -124,9 +131,11 @@ evaluate_string_length: {
 }
 
 mangle_properties: {
-    mangle_props = {
+    mangle = {
-        keep_quoted: false
+        properties: {
-    };
+            keep_quoted: false,
+        },
+    }
     input: {
         a["foo"] = "bar";
         a.color = "red";
@@ -137,18 +146,21 @@ mangle_properties: {
     expect: {
         a["a"] = "bar";
         a.b = "red";
-        x = {c: 10};
+        x = {o: 10};
-        a.d(x.c, a.a);
+        a.r(x.o, a.a);
-        a['d']({b: "blue", a: "baz"});
+        a['r']({b: "blue", a: "baz"});
     }
 }
 
 mangle_unquoted_properties: {
     options = {
-        properties: false
+        evaluate: true,
+        properties: false,
     }
-    mangle_props = {
+    mangle = {
-        keep_quoted: true
+        properties: {
+            keep_quoted: true,
+        },
     }
     beautify = {
         beautify: false,
@@ -177,24 +189,26 @@ mangle_unquoted_properties: {
         function f1() {
             a["foo"] = "bar";
             a.color = "red";
-            a.b = 2;
+            a.r = 2;
-            x = {"bar": 10, c: 7};
+            x = {"bar": 10, b: 7};
-            a.c = 9;
+            a.b = 9;
         }
         function f2() {
             a.foo = "bar";
             a['color'] = "red";
-            x = {bar: 10, c: 7};
+            x = {bar: 10, b: 7};
-            a.c = 9;
+            a.b = 9;
-            a.b = 3;
+            a.r = 3;
         }
     }
 }
 
 mangle_debug: {
-    mangle_props = {
+    mangle = {
-        debug: ""
+        properties: {
-    };
+            debug: "",
+        },
+    }
     input: {
         a.foo = "bar";
         x = { baz: "ban" };
@@ -206,9 +220,11 @@ mangle_debug: {
 }
 
 mangle_debug_true: {
-    mangle_props = {
+    mangle = {
-        debug: true
+        properties: {
-    };
+            debug: true,
+        },
+    }
     input: {
         a.foo = "bar";
         x = { baz: "ban" };
@@ -220,9 +236,11 @@ mangle_debug_true: {
 }
 
 mangle_debug_suffix: {
-    mangle_props = {
+    mangle = {
-        debug: "XYZ"
+        properties: {
-    };
+            debug: "XYZ",
+        },
+    }
     input: {
         a.foo = "bar";
         x = { baz: "ban" };
@@ -235,12 +253,15 @@ mangle_debug_suffix: {
 
 mangle_debug_suffix_keep_quoted: {
     options = {
-        properties: false
+        evaluate: true,
+        properties: false,
     }
-    mangle_props = {
+    mangle = {
-        keep_quoted: true,
+        properties: {
             debug: "XYZ",
-        reserved: []
+            keep_quoted: true,
+            reserved: [],
+        },
     }
     beautify = {
         beautify: false,
@@ -555,3 +576,521 @@ native_prototype: {
         "".indexOf.call(e, "bar");
     }
 }
+
+accessor_boolean: {
+    input: {
+        var a = 1;
+        var b = {
+            get true() {
+                return a;
+            },
+            set false(c) {
+                a = c;
+            }
+        };
+        console.log(b.true, b.false = 2, b.true);
+    }
+    expect_exact: 'var a=1;var b={get true(){return a},set false(c){a=c}};console.log(b.true,b.false=2,b.true);'
+    expect_stdout: "1 2 2"
+}
+
+accessor_get_set: {
+    input: {
+        var a = 1;
+        var b = {
+            get set() {
+                return a;
+            },
+            set get(c) {
+                a = c;
+            }
+        };
+        console.log(b.set, b.get = 2, b.set);
+    }
+    expect_exact: 'var a=1;var b={get set(){return a},set get(c){a=c}};console.log(b.set,b.get=2,b.set);'
+    expect_stdout: "1 2 2"
+}
+
+accessor_null_undefined: {
+    input: {
+        var a = 1;
+        var b = {
+            get null() {
+                return a;
+            },
+            set undefined(c) {
+                a = c;
+            }
+        };
+        console.log(b.null, b.undefined = 2, b.null);
+    }
+    expect_exact: 'var a=1;var b={get null(){return a},set undefined(c){a=c}};console.log(b.null,b.undefined=2,b.null);'
+    expect_stdout: "1 2 2"
+}
+
+accessor_number: {
+    input: {
+        var a = 1;
+        var b = {
+            get 42() {
+                return a;
+            },
+            set 42(c) {
+                a = c;
+            }
+        };
+        console.log(b[42], b[42] = 2, b[42]);
+    }
+    expect_exact: 'var a=1;var b={get 42(){return a},set 42(c){a=c}};console.log(b[42],b[42]=2,b[42]);'
+    expect_stdout: "1 2 2"
+}
+
+accessor_string: {
+    input: {
+        var a = 1;
+        var b = {
+            get "a-b"() {
+                return a;
+            },
+            set "a-b"(c) {
+                a = c;
+            }
+        };
+        console.log(b["a-b"], b["a-b"] = 2, b["a-b"]);
+    }
+    expect_exact: 'var a=1;var b={get"a-b"(){return a},set"a-b"(c){a=c}};console.log(b["a-b"],b["a-b"]=2,b["a-b"]);'
+    expect_stdout: "1 2 2"
+}
+
+accessor_this: {
+    input: {
+        var a = 1;
+        var b = {
+            get this() {
+                return a;
+            },
+            set this(c) {
+                a = c;
+            }
+        };
+        console.log(b.this, b.this = 2, b.this);
+    }
+    expect_exact: 'var a=1;var b={get this(){return a},set this(c){a=c}};console.log(b.this,b.this=2,b.this);'
+    expect_stdout: "1 2 2"
+}
+
+issue_2208_1: {
+    options = {
+        inline: true,
+        properties: true,
+        side_effects: true,
+    }
+    input: {
+        console.log({
+            p: function() {
+                return 42;
+            }
+        }.p());
+    }
+    expect: {
+        console.log(42);
+    }
+    expect_stdout: "42"
+}
+
+issue_2208_2: {
+    options = {
+        inline: true,
+        properties: true,
+        side_effects: true,
+    }
+    input: {
+        console.log({
+            a: 42,
+            p: function() {
+                return this.a;
+            }
+        }.p());
+    }
+    expect: {
+        console.log({
+            a: 42,
+            p: function() {
+                return this.a;
+            }
+        }.p());
+    }
+    expect_stdout: "42"
+}
+
+issue_2208_3: {
+    options = {
+        inline: true,
+        properties: true,
+        side_effects: true,
+    }
+    input: {
+        a = 42;
+        console.log({
+            p: function() {
+                return function() {
+                    return this.a;
+                }();
+            }
+        }.p());
+    }
+    expect: {
+        a = 42;
+        console.log(function() {
+            return this.a;
+        }());
+    }
+    expect_stdout: "42"
+}
+
+issue_2208_4: {
+    options = {
+        inline: true,
+        properties: true,
+        side_effects: true,
+    }
+    input: {
+        function foo() {}
+        console.log({
+            a: foo(),
+            p: function() {
+                return 42;
+            }
+        }.p());
+    }
+    expect: {
+        function foo() {}
+        console.log((foo(), function() {
+            return 42;
+        })());
+    }
+    expect_stdout: "42"
+}
+
+issue_2208_5: {
+    options = {
+        inline: true,
+        properties: true,
+        side_effects: true,
+    }
+    input: {
+        console.log({
+            p: "FAIL",
+            p: function() {
+                return 42;
+            }
+        }.p());
+    }
+    expect: {
+        console.log(42);
+    }
+    expect_stdout: "42"
+}
+
+issue_2256: {
+    options = {
+        side_effects: true,
+    }
+    mangle = {
+        properties: {
+            keep_quoted: true,
+        },
+    }
+    input: {
+        ({ "keep": 1 });
+        g.keep = g.change;
+    }
+    expect: {
+        g.keep = g.g;
+    }
+}
+
+lhs_prop_1: {
+    options = {
+        evaluate: true,
+        properties: true,
+    }
+    input: {
+        console.log(++{
+            a: 1
+        }.a);
+    }
+    expect: {
+        console.log(++{
+            a: 1
+        }.a);
+    }
+    expect_stdout: "2"
+}
+
+lhs_prop_2: {
+    options = {
+        evaluate: true,
+        inline: true,
+        properties: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        [1][0] = 42;
+        (function(a) {
+            a.b = "g";
+        })("abc");
+        (function(a) {
+            a[2] = "g";
+        })("def");
+        (function(a) {
+            a[""] = "g";
+        })("ghi");
+    }
+    expect: {
+        [1][0] = 42;
+        "abc".b = "g";
+        "def"[2] = "g";
+        "ghi"[""] = "g";
+    }
+}
+
+literal_duplicate_key_side_effects: {
+    options = {
+        properties: true,
+        side_effects: true,
+    }
+    input: {
+        console.log({
+            a: "FAIL",
+            a: console.log ? "PASS" : "FAIL"
+        }.a);
+    }
+    expect: {
+        console.log(console.log ? "PASS" : "FAIL");
+    }
+    expect_stdout: "PASS"
+}
+
+prop_side_effects_1: {
+    options = {
+        evaluate: true,
+        inline: true,
+        properties: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var C = 1;
+        console.log(C);
+        var obj = {
+            bar: function() {
+                return C + C;
+            }
+        };
+        console.log(obj.bar());
+    }
+    expect: {
+        console.log(1);
+        var obj = {
+            bar: function() {
+                return 2;
+            }
+        };
+        console.log(obj.bar());
+    }
+    expect_stdout: [
+        "1",
+        "2",
+    ]
+}
+
+prop_side_effects_2: {
+    options = {
+        evaluate: true,
+        inline: true,
+        passes: 2,
+        properties: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var C = 1;
+        console.log(C);
+        var obj = {
+            "": function() {
+                return C + C;
+            }
+        };
+        console.log(obj[""]());
+    }
+    expect: {
+        console.log(1);
+        console.log(2);
+    }
+    expect_stdout: [
+        "1",
+        "2",
+    ]
+}
+
+accessor_1: {
+    options = {
+        properties: true,
+    }
+    input: {
+        console.log({
+            a: "FAIL",
+            get a() {
+                return "PASS";
+            }
+        }.a);
+    }
+    expect: {
+        console.log({
+            a: "FAIL",
+            get a() {
+                return "PASS";
+            }
+        }.a);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+accessor_2: {
+    options = {
+        properties: true,
+    }
+    input: {
+        console.log({
+            get a() {
+                return "PASS";
+            },
+            set a(v) {},
+            a: "FAIL"
+        }.a);
+    }
+    expect: {
+        console.log({
+            get a() {
+                return "PASS";
+            },
+            set a(v) {},
+            a: "FAIL"
+        }.a);
+    }
+    expect_stdout: true
+}
+
+array_hole: {
+    options = {
+        properties: true,
+        side_effects: true,
+    }
+    input: {
+        console.log(
+            [ 1, 2, , 3][1],
+            [ 1, 2, , 3][2],
+            [ 1, 2, , 3][3]
+        );
+    }
+    expect: {
+        console.log(2, void 0, 3);
+    }
+    expect_stdout: "2 undefined 3"
+}
+
+new_this: {
+    options = {
+        properties: true,
+        side_effects: true,
+    }
+    input: {
+        new {
+            f: function(a) {
+                this.a = a;
+            }
+        }.f(42);
+    }
+    expect: {
+        new function(a) {
+            this.a = a;
+        }(42);
+    }
+}
+
+issue_2513: {
+    options = {
+        evaluate: true,
+        properties: true,
+    }
+    input: {
+        !function(Infinity, NaN, undefined) {
+            console.log("a"[1/0], "b"["Infinity"]);
+            console.log("c"[0/0], "d"["NaN"]);
+            console.log("e"[void 0], "f"["undefined"]);
+        }(0, 0, 0);
+    }
+    expect: {
+        !function(Infinity, NaN, undefined) {
+            console.log("a"[1/0], "b"[1/0]);
+            console.log("c".NaN, "d".NaN);
+            console.log("e"[void 0], "f"[void 0]);
+        }(0, 0, 0);
+    }
+    expect_stdout: [
+        "undefined undefined",
+        "undefined undefined",
+        "undefined undefined",
+    ]
+}
+
+const_prop_assign_strict: {
+    options = {
+        pure_getters: "strict",
+        side_effects: true,
+    }
+    input: {
+        function Simulator() {
+            /abc/.index = 1;
+            this._aircraft = [];
+        }
+        (function() {}).prototype.destroy = x();
+    }
+    expect: {
+        function Simulator() {
+            this._aircraft = [];
+        }
+        x();
+    }
+}
+
+const_prop_assign_pure: {
+    options = {
+        pure_getters: true,
+        side_effects: true,
+    }
+    input: {
+        function Simulator() {
+            /abc/.index = 1;
+            this._aircraft = [];
+        }
+        (function() {}).prototype.destroy = x();
+    }
+    expect: {
+        function Simulator() {
+            this._aircraft = [];
+        }
+        x();
+    }
+}

test/compress/pure_funcs.js

@@ -293,3 +293,124 @@ 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());",
+    ]
+}

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,432 @@ 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_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_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();
+    }
+}

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
 }
@@ -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,
@@ -710,3 +718,81 @@ issue_27: {
         })(jQuery);
     }
 }
+
+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());
+        }
+    }
+}

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/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,83 @@ 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();
+        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",
+    ]
+}

test/compress/unicode.js

@@ -15,3 +15,50 @@ unicode_parse_variables: {
         var l০ = 3;
     }
 }
+
+issue_2242_1: {
+    beautify = {
+        ascii_only: false,
+    }
+    input: {
+        console.log("\ud83d", "\ude00", "\ud83d\ude00", "\ud83d@\ude00");
+    }
+    expect_exact: 'console.log("\\ud83d","\\ude00","\ud83d\ude00","\\ud83d@\\ude00");'
+}
+
+issue_2242_2: {
+    beautify = {
+        ascii_only: true,
+    }
+    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/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);
+    });
+};

test/input/invalid/for-in_1.js

@@ -0,0 +1,4 @@
+var a, b = [1, 2];
+for (1, 2, a in b) {
+    console.log(a, b[a]);
+}

test/input/invalid/for-in_2.js

@@ -0,0 +1,4 @@
+var c = [1, 2];
+for (var a, b in c) {
+    console.log(a, c[a]);
+}

test/input/issue-2082/sample.js

@@ -0,0 +1 @@
+console.log(x);

test/input/issue-2082/sample.js.map

@@ -0,0 +1 @@
+{"version": 3,"sources": ["index.js"],"mappings": ";"}

test/input/issue-2310/input.js

@@ -0,0 +1,10 @@
+function foo() {
+    return function() {
+        console.log("PASS");
+    };
+}
+
+(function() {
+    var f = foo();
+    f();
+})();

test/input/issue-505/input.js

@@ -0,0 +1,5 @@
+function test(callback) {
+    'aaaaaaaaaaaaaaaa';
+    callback(err, data);
+    callback(err, data);
+}

test/input/issue-505/output.js

@@ -0,0 +1,5 @@
+function test(a){
+"aaaaaaaaaaaaaaaa"
+;a(err,data),a(err,data)
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIjAiXSwibmFtZXMiOlsidGVzdCIsImNhbGxiYWNrIiwiZXJyIiwiZGF0YSJdLCJtYXBwaW5ncyI6IkFBQUEsU0FBU0EsS0FBS0M7QUFDVjtDQUNBQSxFQUFTQyxJQUFLQyxNQUNkRixFQUFTQyxJQUFLQyJ9

test/input/issue-520/output.js

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

test/jetstream.js

@@ -3,7 +3,7 @@
 
 "use strict";
 
-var site = "http://browserbench.org/JetStream/";
+var site = "http://browserbench.org/JetStream";
 if (typeof phantom == "undefined") {
     // workaround for tty output truncation upon process.exit()
     [process.stdout, process.stderr].forEach(function(stream){
@@ -11,25 +11,38 @@ if (typeof phantom == "undefined") {
             stream._handle.setBlocking(true);
     });
     var args = process.argv.slice(2);
+    var debug = args.indexOf("--debug");
+    if (debug >= 0) {
+        args.splice(debug, 1);
+        debug = true;
+    } else {
+        debug = false;
+    }
     if (!args.length) {
-        args.push("-mc");
+        args.push("-mcb", "beautify=false,webkit");
     }
-    args.push("--stats");
+    args.push("--timings");
     var child_process = require("child_process");
-    try {
+    var fetch = require("./fetch");
-        require("phantomjs-prebuilt");
-    } catch(e) {
-        child_process.execSync("npm install phantomjs-prebuilt@2.1.14");
-    }
     var http = require("http");
     var server = http.createServer(function(request, response) {
         request.resume();
-        var url = decodeURIComponent(request.url.slice(1));
+        var url = site + request.url;
+        fetch(url, function(err, res) {
+            if (err) throw err;
+            response.writeHead(200, {
+                "Content-Type": {
+                    css: "text/css",
+                    js: "application/javascript",
+                    png: "image/png"
+                }[url.slice(url.lastIndexOf(".") + 1)] || "text/html; charset=utf-8"
+            });
+            if (/\.js$/.test(url)) {
                 var stderr = "";
                 var uglifyjs = child_process.fork("bin/uglifyjs", args, {
                     silent: true
                 }).on("exit", function(code) {
-            console.log("uglifyjs", url.indexOf(site) == 0 ? url.slice(site.length) : url, args.join(" "));
+                    console.log("uglifyjs", url.slice(site.length + 1), args.join(" "));
                     console.log(stderr);
                     if (code) throw new Error("uglifyjs failed with code " + code);
                 });
@@ -37,20 +50,31 @@ if (typeof phantom == "undefined") {
                     stderr += data;
                 }).setEncoding("utf8");
                 uglifyjs.stdout.pipe(response);
-        http.get(url, function(res) {
                 res.pipe(uglifyjs.stdin);
+            } else {
+                res.pipe(response);
+            }
         });
-    }).listen().on("listening", function() {
+    }).listen();
-        var phantomjs = require("phantomjs-prebuilt");
+    server.on("listening", function() {
-        var program = phantomjs.exec(process.argv[1], server.address().port);
+        var port = server.address().port;
+        if (debug) {
+            console.log("http://localhost:" + port + "/");
+        } else {
+            child_process.exec("npm install phantomjs-prebuilt@2.1.14 --no-save", function(error) {
+                if (error) throw error;
+                var program = require("phantomjs-prebuilt").exec(process.argv[1], port);
                 program.stdout.pipe(process.stdout);
                 program.stderr.pipe(process.stderr);
                 program.on("exit", function(code) {
                     server.close();
                     if (code) throw new Error("JetStream failed!");
                     console.log("JetStream completed successfully.");
+                    process.exit(0);
                 });
             });
+        }
+    });
     server.timeout = 0;
 } else {
     var page = require("webpage").create();
@@ -63,10 +87,6 @@ if (typeof phantom == "undefined") {
         phantom.exit(1);
     };
     var url = "http://localhost:" + require("system").args[1] + "/";
-    page.onResourceRequested = function(requestData, networkRequest) {
-        if (/\.js$/.test(requestData.url))
-            networkRequest.changeUrl(url + encodeURIComponent(requestData.url));
-    }
     page.onConsoleMessage = function(msg) {
         if (/Error:/i.test(msg)) {
             console.error(msg);
@@ -77,8 +97,8 @@ if (typeof phantom == "undefined") {
             phantom.exit();
         }
     };
-    page.open(site, function(status) {
+    page.open(url, function(status) {
-        if (status != "success") phantomjs.exit(1);
+        if (status != "success") phantom.exit(1);
         page.evaluate(function() {
             JetStream.switchToQuick();
             JetStream.start();

test/mocha/cli.js

@@ -9,7 +9,7 @@ function read(path) {
 describe("bin/uglifyjs", function () {
     var uglifyjscmd = '"' + process.argv[0] + '" bin/uglifyjs';
     it("should produce a functional build when using --self", function (done) {
-        this.timeout(15000);
+        this.timeout(30000);
 
         var command = uglifyjscmd + ' --self -cm --wrap WrappedUglifyJS';
 
@@ -19,7 +19,9 @@ describe("bin/uglifyjs", function () {
             eval(stdout);
 
             assert.strictEqual(typeof WrappedUglifyJS, 'object');
-            assert.strictEqual(WrappedUglifyJS.minify("foo([true,,2+3]);").code, "foo([!0,,5]);");
+            var result = WrappedUglifyJS.minify("foo([true,,2+3]);");
+            assert.strictEqual(result.error, undefined);
+            assert.strictEqual(result.code, "foo([!0,,5]);");
 
             done();
         });
@@ -61,7 +63,7 @@ describe("bin/uglifyjs", function () {
             if (err) throw err;
 
             assert.strictEqual(stdout, "var bar=function(){function foo(bar){return bar}return foo}();\n" +
-                "//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInRlc3QvaW5wdXQvaXNzdWUtMTMyMy9zYW1wbGUuanMiXSwibmFtZXMiOlsiYmFyIiwiZm9vIl0sIm1hcHBpbmdzIjoiQUFBQSxHQUFJQSxLQUFNLFdBQ04sUUFBU0MsS0FBS0QsS0FDVixNQUFPQSxLQUdYLE1BQU9DIn0=\n");
+                "//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInRlc3QvaW5wdXQvaXNzdWUtMTMyMy9zYW1wbGUuanMiXSwibmFtZXMiOlsiYmFyIiwiZm9vIl0sIm1hcHBpbmdzIjoiQUFBQSxJQUFJQSxJQUFNLFdBQ04sU0FBU0MsSUFBS0QsS0FDVixPQUFPQSxJQUdYLE9BQU9DLElBTEQifQ==\n");
             done();
         });
     });
@@ -75,6 +77,23 @@ describe("bin/uglifyjs", function () {
             done();
         });
     });
+    it("should not consider source map file content as source map file name (issue #2082)", function (done) {
+        var command = [
+            uglifyjscmd,
+            "test/input/issue-2082/sample.js",
+            "--source-map", "content=test/input/issue-2082/sample.js.map",
+            "--source-map", "url=inline",
+        ].join(" ");
+
+        exec(command, function (err, stdout, stderr) {
+            if (err) throw err;
+
+            var stderrLines = stderr.split('\n');
+            assert.strictEqual(stderrLines[0], 'INFO: Using input source map: test/input/issue-2082/sample.js.map');
+            assert.notStrictEqual(stderrLines[1], 'INFO: Using input source map: {"version": 3,"sources": ["index.js"],"mappings": ";"}');
+            done();
+        });
+    });
     it("Should work with --keep-fnames (mangle only)", function (done) {
         var command = uglifyjscmd + ' test/input/issue-1431/sample.js --keep-fnames -m';
 
@@ -173,7 +192,7 @@ describe("bin/uglifyjs", function () {
 
             assert.strictEqual(stdout, [
                 "var bar=function(){function foo(bar){return bar}return foo}();",
-                "//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInRlc3QvaW5wdXQvaXNzdWUtMTMyMy9zYW1wbGUuanMiXSwibmFtZXMiOlsiYmFyIiwiZm9vIl0sIm1hcHBpbmdzIjoiQUFBQSxHQUFJQSxLQUFNLFdBQ04sUUFBU0MsS0FBS0QsS0FDVixNQUFPQSxLQUdYLE1BQU9DIn0=",
+                "//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInRlc3QvaW5wdXQvaXNzdWUtMTMyMy9zYW1wbGUuanMiXSwibmFtZXMiOlsiYmFyIiwiZm9vIl0sIm1hcHBpbmdzIjoiQUFBQSxJQUFJQSxJQUFNLFdBQ04sU0FBU0MsSUFBS0QsS0FDVixPQUFPQSxJQUdYLE9BQU9DLElBTEQifQ==",
                 "",
             ].join("\n"));
             assert.strictEqual(stderr, "WARN: inline source map not found\n");
@@ -499,6 +518,36 @@ describe("bin/uglifyjs", function () {
             done();
         });
     });
+    it("Should throw syntax error (for-in init)", function(done) {
+        var command = uglifyjscmd + ' test/input/invalid/for-in_1.js';
+
+        exec(command, function (err, stdout, stderr) {
+            assert.ok(err);
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/for-in_1.js:2,5",
+                "for (1, 2, a in b) {",
+                "     ^",
+                "ERROR: Invalid left-hand side in for..in loop"
+            ].join("\n"));
+            done();
+        });
+    });
+    it("Should throw syntax error (for-in var)", function(done) {
+        var command = uglifyjscmd + ' test/input/invalid/for-in_2.js';
+
+        exec(command, function (err, stdout, stderr) {
+            assert.ok(err);
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/for-in_2.js:2,5",
+                "for (var a, b in c) {",
+                "     ^",
+                "ERROR: Only one variable declaration allowed in for..in loop"
+            ].join("\n"));
+            done();
+        });
+    });
     it("Should handle literal string as source map input", function(done) {
         var command = [
             uglifyjscmd,
@@ -512,7 +561,7 @@ describe("bin/uglifyjs", function () {
 
             assert.strictEqual(stdout, [
                 '"use strict";var foo=function foo(x){return"foo "+x};console.log(foo("bar"));',
-                "//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImluZGV4LmpzIl0sIm5hbWVzIjpbImZvbyIsIngiLCJjb25zb2xlIiwibG9nIl0sIm1hcHBpbmdzIjoiWUFBQSxJQUFJQSxLQUFNLFFBQU5BLEtBQU1DLEdBQUEsTUFBSyxPQUFTQSxFQUN4QkMsU0FBUUMsSUFBSUgsSUFBSSJ9",
+                "//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImluZGV4LmpzIl0sIm5hbWVzIjpbImZvbyIsIngiLCJjb25zb2xlIiwibG9nIl0sIm1hcHBpbmdzIjoiYUFBQSxJQUFJQSxJQUFNLFNBQU5BLElBQU1DLEdBQUEsTUFBSyxPQUFTQSxHQUN4QkMsUUFBUUMsSUFBSUgsSUFBSSJ9",
                 ""
             ].join("\n"));
             done();
@@ -524,6 +573,25 @@ describe("bin/uglifyjs", function () {
             return JSON.stringify(map).replace(/"/g, '\\"');
         }
     });
+    it("Should include function calls in source map", function(done) {
+        var command = [
+            uglifyjscmd,
+            "test/input/issue-2310/input.js",
+            "-c",
+            "--source-map", "url=inline",
+        ].join(" ");
+
+        exec(command, function(err, stdout, stderr) {
+            if (err) throw err;
+
+            assert.strictEqual(stdout, [
+                'function foo(){return function(){console.log("PASS")}}foo()();',
+                "//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInRlc3QvaW5wdXQvaXNzdWUtMjMxMC9pbnB1dC5qcyJdLCJuYW1lcyI6WyJmb28iLCJjb25zb2xlIiwibG9nIiwiZiJdLCJtYXBwaW5ncyI6IkFBQUEsU0FBU0EsTUFDTCxPQUFPLFdBQ0hDLFFBQVFDLElBQUksU0FLUkYsS0FDUkcifQ==",
+                ""
+            ].join("\n"));
+            done();
+        });
+    });
     it("Should dump AST as JSON", function(done) {
         var command = uglifyjscmd + " test/input/global_defs/simple.js -mco ast";
         exec(command, function (err, stdout) {
@@ -535,4 +603,51 @@ describe("bin/uglifyjs", function () {
             done();
         });
     });
+    it("Should print supported options on invalid option syntax", function(done) {
+        var command = uglifyjscmd + " test/input/comments/filter.js -b ascii-only";
+        exec(command, function (err, stdout, stderr) {
+            assert.ok(err);
+            assert.strictEqual(stdout, "");
+            assert.ok(/^Supported options:\n[\s\S]*?\nERROR: `ascii-only` is not a supported option/.test(stderr), stderr);
+            done();
+        });
+    });
+    it("Should work with --mangle reserved=[]", function(done) {
+        var command = uglifyjscmd + " test/input/issue-505/input.js -m reserved=[callback]";
+
+        exec(command, function (err, stdout) {
+            if (err) throw err;
+
+            assert.strictEqual(stdout, 'function test(callback){"aaaaaaaaaaaaaaaa";callback(err,data);callback(err,data)}\n');
+            done();
+        });
+    });
+    it("Should work with --mangle reserved=false", function(done) {
+        var command = uglifyjscmd + " test/input/issue-505/input.js -m reserved=false";
+
+        exec(command, function (err, stdout) {
+            if (err) throw err;
+
+            assert.strictEqual(stdout, 'function test(a){"aaaaaaaaaaaaaaaa";a(err,data);a(err,data)}\n');
+            done();
+        });
+    });
+    it("Should fail with --mangle-props reserved=[in]", function(done) {
+        var command = uglifyjscmd + " test/input/issue-505/input.js --mangle-props reserved=[in]";
+        exec(command, function (err, stdout, stderr) {
+            assert.ok(err);
+            assert.strictEqual(stdout, "");
+            assert.ok(/^Supported options:\n[\s\S]*?\nERROR: `reserved=\[in]` is not a supported option/.test(stderr), stderr);
+            done();
+        });
+    });
+    it("Should fail with --define a-b", function(done) {
+        var command = uglifyjscmd + " test/input/issue-505/input.js --define a-b";
+        exec(command, function (err, stdout, stderr) {
+            assert.ok(err);
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr, "Error parsing arguments for 'define': a-b\n");
+            done();
+        });
+    });
 });

test/mocha/comment-filter.js

@@ -14,7 +14,7 @@ describe("comment filters", function() {
 
     it("Should be able to filter commments with the 'some' option", function() {
         var ast = UglifyJS.parse("// foo\n/*@preserve*/\n// bar\n/*@license*/\n//@license with the wrong comment type\n/*@cc_on something*/");
-        assert.strictEqual(ast.print_to_string({comments: "some"}), "/*@preserve*/\n/*@license*/\n/*@cc_on something*/\n");
+        assert.strictEqual(ast.print_to_string({comments: "some"}), "/*@preserve*/\n/*@license*/\n/*@cc_on something*/");
     });
 
     it("Should be able to filter comments by passing a function", function() {
@@ -55,12 +55,12 @@ describe("comment filters", function() {
             return true;
         };
 
-        assert.strictEqual(ast.print_to_string({comments: f}), "#!Random comment\n//test1\n/*test2*/\n");
+        assert.strictEqual(ast.print_to_string({comments: f}), "#!Random comment\n//test1\n/*test2*/");
     });
 
     it("Should never be able to filter comment5 when using 'some' as filter", function() {
         var ast = UglifyJS.parse("#!foo\n//foo\n/*@preserve*/\n/* please hide me */");
-        assert.strictEqual(ast.print_to_string({comments: "some"}), "#!foo\n/*@preserve*/\n");
+        assert.strictEqual(ast.print_to_string({comments: "some"}), "#!foo\n/*@preserve*/");
     });
 
     it("Should have no problem on multiple calls", function() {

test/mocha/comment.js

@@ -47,4 +47,176 @@ describe("Comment", function() {
             }, fail, tests[i]);
         }
     });
+
+    it("Should handle comment within return correctly", function() {
+        var result = uglify.minify([
+            "function unequal(x, y) {",
+            "    return (",
+            "        // Either one",
+            "        x < y",
+            "        ||",
+            "        y < x",
+            "    );",
+            "}",
+        ].join("\n"), {
+            compress: false,
+            mangle: false,
+            output: {
+                beautify: true,
+                comments: "all",
+            },
+        });
+        if (result.error) throw result.error;
+        assert.strictEqual(result.code, [
+            "function unequal(x, y) {",
+            "    // Either one",
+            "    return x < y || y < x;",
+            "}",
+        ].join("\n"));
+    });
+
+    it("Should handle comment folded into return correctly", function() {
+        var result = uglify.minify([
+            "function f() {",
+            "    /* boo */ x();",
+            "    return y();",
+            "}",
+        ].join("\n"), {
+            mangle: false,
+            output: {
+                beautify: true,
+                comments: "all",
+            },
+        });
+        if (result.error) throw result.error;
+        assert.strictEqual(result.code, [
+            "function f() {",
+            "    /* boo */",
+            "    return x(), y();",
+            "}",
+        ].join("\n"));
+    });
+
+    it("Should not drop comments after first OutputStream", function() {
+        var code = "/* boo */\nx();";
+        var ast = uglify.parse(code);
+        var out1 = uglify.OutputStream({
+            beautify: true,
+            comments: "all",
+        });
+        ast.print(out1);
+        var out2 = uglify.OutputStream({
+            beautify: true,
+            comments: "all",
+        });
+        ast.print(out2);
+        assert.strictEqual(out1.get(), code);
+        assert.strictEqual(out2.get(), out1.get());
+    });
+
+    it("Should retain trailing comments", function() {
+        var code = [
+            "if (foo /* lost comment */ && bar /* lost comment */) {",
+            "    // this one is kept",
+            "    {/* lost comment */}",
+            "    !function() {",
+            "        // lost comment",
+            "    }();",
+            "    function baz() {/* lost comment */}",
+            "    // lost comment",
+            "}",
+            "// comments right before EOF are lost as well",
+        ].join("\n");
+        var result = uglify.minify(code, {
+            compress: false,
+            mangle: false,
+            output: {
+                beautify: true,
+                comments: "all",
+            },
+        });
+        if (result.error) throw result.error;
+        assert.strictEqual(result.code, code);
+    });
+
+    it("Should correctly preserve new lines around comments", function() {
+        var tests = [
+            [
+                "// foo",
+                "// bar",
+                "x();",
+            ].join("\n"),
+            [
+                "// foo",
+                "/* bar */",
+                "x();",
+            ].join("\n"),
+            [
+                "// foo",
+                "/* bar */ x();",
+            ].join("\n"),
+            [
+                "/* foo */",
+                "// bar",
+                "x();",
+            ].join("\n"),
+            [
+                "/* foo */ // bar",
+                "x();",
+            ].join("\n"),
+            [
+                "/* foo */",
+                "/* bar */",
+                "x();",
+            ].join("\n"),
+            [
+                "/* foo */",
+                "/* bar */ x();",
+            ].join("\n"),
+            [
+                "/* foo */ /* bar */",
+                "x();",
+            ].join("\n"),
+            "/* foo */ /* bar */ x();",
+        ].forEach(function(code) {
+            var result = uglify.minify(code, {
+                compress: false,
+                mangle: false,
+                output: {
+                    beautify: true,
+                    comments: "all",
+                },
+            });
+            if (result.error) throw result.error;
+            assert.strictEqual(result.code, code);
+        });
+    });
+
+    it("Should preserve new line before comment without beautify", function() {
+        var code = [
+            "function f(){",
+            "/* foo */bar()}",
+        ].join("\n");
+        var result = uglify.minify(code, {
+            compress: false,
+            mangle: false,
+            output: {
+                comments: "all",
+            },
+        });
+        if (result.error) throw result.error;
+        assert.strictEqual(result.code, code);
+    });
+
+    it("Should preserve comments around IIFE", function() {
+        var result = uglify.minify("/*a*/(/*b*/function(){/*c*/}/*d*/)/*e*/();", {
+            compress: false,
+            mangle: false,
+            output: {
+                comments: "all",
+            },
+        });
+        if (result.error) throw result.error;
+        assert.strictEqual(result.code, "/*a*/ /*b*/(function(){/*c*/}/*d*/ /*e*/)();");
+    });
 });

test/mocha/glob.js

@@ -11,7 +11,7 @@ describe("bin/uglifyjs with input file globs", function() {
         exec(command, function(err, stdout) {
             if (err) throw err;
 
-            assert.strictEqual(stdout, 'function foo(o){print("Foo:",2*o)}var print=console.log.bind(console);\n');
+            assert.strictEqual(stdout, 'var print=console.log.bind(console);function foo(o){print("Foo:",2*o)}\n');
             done();
         });
     });
@@ -26,12 +26,12 @@ describe("bin/uglifyjs with input file globs", function() {
         });
     });
     it("bin/uglifyjs with multiple input file globs.", function(done) {
-        var command = uglifyjscmd + ' "test/input/issue-1242/???.es5" "test/input/issue-1242/*.js" -mc toplevel';
+        var command = uglifyjscmd + ' "test/input/issue-1242/???.es5" "test/input/issue-1242/*.js" -mc toplevel,passes=3';
 
         exec(command, function(err, stdout) {
             if (err) throw err;
 
-            assert.strictEqual(stdout, 'var print=console.log.bind(console),a=function(n){return 3*n}(3),b=function(n){return n/2}(12);print("qux",a,b),function(n){print("Foo:",2*n)}(11);\n');
+            assert.strictEqual(stdout, 'var print=console.log.bind(console);print("qux",9,6),print("Foo:",22);\n');
             done();
         });
     });

test/mocha/let.js

@@ -2,29 +2,56 @@ var Uglify = require('../../');
 var assert = require("assert");
 
 describe("let", function() {
-    it("Should not produce `let` as a variable name in mangle", function(done) {
+    this.timeout(30000);
-        this.timeout(10000);
+    it("Should not produce reserved keywords as variable name in mangle", function() {
-
         // Produce a lot of variables in a function and run it through mangle.
-        var s = '"use strict"; function foo() {';
+        var s = '"dddddeeeeelllllooooottttt"; function foo() {';
-        for (var i = 0; i < 21000; ++i) {
+        for (var i = 0; i < 18000; i++) {
             s += "var v" + i + "=0;";
         }
         s += '}';
-        var result = Uglify.minify(s, {compress: false});
+        var result = Uglify.minify(s, {
+            compress: false
+        }).code;
 
         // Verify that select keywords and reserved keywords not produced
-        assert.strictEqual(result.code.indexOf("var let="), -1);
+        [
-        assert.strictEqual(result.code.indexOf("var do="), -1);
+            "do",
-        assert.strictEqual(result.code.indexOf("var var="), -1);
+            "let",
+            "var",
+        ].forEach(function(name) {
+            assert.strictEqual(result.indexOf("var " + name + "="), -1);
+        });
 
         // Verify that the variable names that appeared immediately before
-        // and after the erroneously generated `let` variable name still exist
+        // and after the erroneously generated variable name still exist
         // to show the test generated enough symbols.
-        assert(result.code.indexOf("var ket=") >= 0);
+        [
-        assert(result.code.indexOf("var met=") >= 0);
+            "to", "eo",
-
+            "eet", "fet",
-        done();
+            "rar", "oar",
+        ].forEach(function(name) {
+            assert.notStrictEqual(result.indexOf("var " + name + "="), -1);
+        });
+    });
+    it("Should quote mangled properties that are reserved keywords", function() {
+        var s = '"rrrrrnnnnniiiiiaaaaa";';
+        for (var i = 0; i < 18000; i++) {
+            s += "v.b" + i + ";";
+        }
+        var result = Uglify.minify(s, {
+            compress: false,
+            ie8: true,
+            mangle: {
+                properties: true,
+            }
+        }).code;
+        [
+            "in",
+            "var",
+        ].forEach(function(name) {
+            assert.notStrictEqual(result.indexOf(name), -1);
+            assert.notStrictEqual(result.indexOf('v["' + name + '"]'), -1);
+        });
     });
 });
-

test/mocha/minify.js

@@ -1,6 +1,7 @@
 var Uglify = require('../../');
 var assert = require("assert");
 var readFileSync = require("fs").readFileSync;
+var run_code = require("../sandbox").run_code;
 
 function read(path) {
     return readFileSync(path, "utf8");
@@ -13,6 +14,71 @@ describe("minify", function() {
         assert.strictEqual(result.code, 'function foo(n){return n?3:7}');
     });
 
+    it("Should skip inherited keys from `files`", function() {
+        var files = Object.create({ skip: this });
+        files[0] = "alert(1 + 1)";
+        var result = Uglify.minify(files);
+        assert.strictEqual(result.code, "alert(2);");
+    });
+
+    it("Should work with mangle.cache", function() {
+        var cache = {};
+        var original = "";
+        var compressed = "";
+        [
+            "bar.es5",
+            "baz.es5",
+            "foo.es5",
+            "qux.js",
+        ].forEach(function(file) {
+            var code = read("test/input/issue-1242/" + file);
+            var result = Uglify.minify(code, {
+                mangle: {
+                    cache: cache,
+                    toplevel: true
+                }
+            });
+            if (result.error) throw result.error;
+            original += code;
+            compressed += result.code;
+        });
+        assert.strictEqual(JSON.stringify(cache).slice(0, 20), '{"cname":5,"props":{');
+        assert.strictEqual(compressed, 'function n(n){return 3*n}function r(n){return n/2}var c=console.log.bind(console);function l(o){c("Foo:",2*o)}var f=n(3),i=r(12);c("qux",f,i),l(11);');
+        assert.strictEqual(run_code(compressed), run_code(original));
+    });
+
+    it("Should work with nameCache", function() {
+        var cache = {};
+        var original = "";
+        var compressed = "";
+        [
+            "bar.es5",
+            "baz.es5",
+            "foo.es5",
+            "qux.js",
+        ].forEach(function(file) {
+            var code = read("test/input/issue-1242/" + file);
+            var result = Uglify.minify(code, {
+                mangle: {
+                    toplevel: true
+                },
+                nameCache: cache
+            });
+            if (result.error) throw result.error;
+            original += code;
+            compressed += result.code;
+        });
+        assert.strictEqual(JSON.stringify(cache).slice(0, 28), '{"vars":{"cname":5,"props":{');
+        assert.strictEqual(compressed, 'function n(n){return 3*n}function r(n){return n/2}var c=console.log.bind(console);function l(o){c("Foo:",2*o)}var f=n(3),i=r(12);c("qux",f,i),l(11);');
+        assert.strictEqual(run_code(compressed), run_code(original));
+    });
+
+    it("should not parse invalid use of reserved words", function() {
+        assert.strictEqual(Uglify.minify("function enum(){}").error, undefined);
+        assert.strictEqual(Uglify.minify("function static(){}").error, undefined);
+        assert.strictEqual(Uglify.minify("function this(){}").error.message, "Unexpected token: name (this)");
+    });
+
     describe("keep_quoted_props", function() {
         it("Should preserve quotes in object literals", function() {
             var js = 'var foo = {"x": 1, y: 2, \'z\': 3};';
@@ -64,6 +130,17 @@ describe("minify", function() {
             assert.strictEqual(result.code,
                     'a["foo"]="bar",a.a="red",x={"bar":10};');
         });
+        it("Should not mangle quoted property within dead code", function() {
+            var result = Uglify.minify('({ "keep": 1 }); g.keep = g.change;', {
+                mangle: {
+                    properties: {
+                        keep_quoted: true
+                    }
+                }
+            });
+            if (result.error) throw result.error;
+            assert.strictEqual(result.code, "g.keep=g.g;");
+        });
     });
 
     describe("inSourceMap", function() {
@@ -106,7 +183,7 @@ describe("minify", function() {
                         content: "inline"
                     }
                 });
-                assert.strictEqual(result.code, "var bar=function(){function foo(bar){return bar}return foo}();");
+                assert.strictEqual(result.code, "var bar=function(){return function(bar){return bar}}();");
                 assert.strictEqual(warnings.length, 1);
                 assert.strictEqual(warnings[0], "inline source map not found");
             } finally {
@@ -138,13 +215,25 @@ describe("minify", function() {
             });
             var code = result.code;
             assert.strictEqual(code, "var a=function(n){return n};\n" +
-                "//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIjAiXSwibmFtZXMiOlsiYSIsImZvbyJdLCJtYXBwaW5ncyI6IkFBQUEsR0FBSUEsR0FBSSxTQUFTQyxHQUFPLE1BQU9BIn0=");
+                "//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIjAiXSwibmFtZXMiOlsiYSIsImZvbyJdLCJtYXBwaW5ncyI6IkFBQUEsSUFBSUEsRUFBSSxTQUFTQyxHQUFPLE9BQU9BIn0=");
         });
         it("should not append source map to output js when sourceMapInline is not enabled", function() {
             var result = Uglify.minify('var a = function(foo) { return foo; };');
             var code = result.code;
             assert.strictEqual(code, "var a=function(n){return n};");
         });
+        it("should work with max_line_len", function() {
+            var result = Uglify.minify(read("./test/input/issue-505/input.js"), {
+                output: {
+                    max_line_len: 20
+                },
+                sourceMap: {
+                    url: "inline"
+                }
+            });
+            assert.strictEqual(result.error, undefined);
+            assert.strictEqual(result.code, read("./test/input/issue-505/output.js"));
+        });
     });
 
     describe("#__PURE__", function() {
@@ -158,7 +247,7 @@ describe("minify", function() {
             var code = result.code;
             assert.strictEqual(code, "//  comment1   comment2\nbar();");
         });
-        it("should not drop #__PURE__ hint if function is retained", function() {
+        it("should drop #__PURE__ hint if function is retained", function() {
             var result = Uglify.minify("var a = /*#__PURE__*/(function(){ foo(); })();", {
                 output: {
                     comments: "all",
@@ -166,7 +255,7 @@ describe("minify", function() {
                 }
             });
             var code = result.code;
-            assert.strictEqual(code, "var a=/*#__PURE__*/function(){foo()}();");
+            assert.strictEqual(code, "var a=/* */function(){foo()}();");
         })
     });
 
@@ -181,4 +270,64 @@ describe("minify", function() {
             assert.strictEqual(err.col, 12);
         });
     });
+
+    describe("global_defs", function() {
+        it("should throw for non-trivial expressions", function() {
+            var result = Uglify.minify("alert(42);", {
+                compress: {
+                    global_defs: {
+                        "@alert": "debugger"
+                    }
+                }
+            });
+            var err = result.error;
+            assert.ok(err instanceof Error);
+            assert.strictEqual(err.stack.split(/\n/)[0], "SyntaxError: Unexpected token: keyword (debugger)");
+        });
+        it("should skip inherited properties", function() {
+            var foo = Object.create({ skip: this });
+            foo.bar = 42;
+            var result = Uglify.minify("alert(FOO);", {
+                compress: {
+                    global_defs: {
+                        FOO: foo
+                    }
+                }
+            });
+            assert.strictEqual(result.code, "alert({bar:42});");
+        });
+    });
+
+    describe("collapse_vars", function() {
+        it("Should not produce invalid AST", function() {
+            var code = [
+                "function f(a) {",
+                "    a = x();",
+                "    return a;",
+                "}",
+                "f();",
+            ].join("\n");
+            var ast = Uglify.minify(code, {
+                compress: false,
+                mangle: false,
+                output: {
+                    ast: true
+                },
+            }).ast;
+            assert.strictEqual(ast.TYPE, "Toplevel");
+            assert.strictEqual(ast.body.length, 2);
+            assert.strictEqual(ast.body[0].TYPE, "Defun");
+            assert.strictEqual(ast.body[0].body.length, 2);
+            assert.strictEqual(ast.body[0].body[0].TYPE, "SimpleStatement");
+            var stat = ast.body[0].body[0];
+            Uglify.minify(ast, {
+                compress: {
+                    sequences: false
+                },
+                mangle: false
+            });
+            assert.ok(stat.body);
+            assert.strictEqual(stat.print_to_string(), "a=x()");
+        });
+    });
 });

test/mocha/release.js

@@ -1,23 +1,20 @@
 var assert = require("assert");
+var semver = require("semver");
 var spawn = require("child_process").spawn;
 
 if (!process.env.UGLIFYJS_TEST_ALL) return;
 
 function run(command, args, done) {
-    var id = setInterval(function() {
-        process.stdout.write("\0");
-    }, 5 * 60 * 1000);
     spawn(command, args, {
-        stdio: "ignore"
+        stdio: [ "ignore", 1, 2 ]
     }).on("exit", function(code) {
-        clearInterval(id);
         assert.strictEqual(code, 0);
         done();
     });
 }
 
 describe("test/benchmark.js", function() {
-    this.timeout(5 * 60 * 1000);
+    this.timeout(10 * 60 * 1000);
     [
         "-b",
         "-b bracketize",
@@ -36,11 +33,9 @@ describe("test/benchmark.js", function() {
     });
 });
 
+if (semver.satisfies(process.version, "0.12")) return;
 describe("test/jetstream.js", function() {
     this.timeout(20 * 60 * 1000);
-    it("Should install phantomjs-prebuilt", function(done) {
-        run("npm", ["install", "phantomjs-prebuilt@2.1.14"], done);
-    });
     [
         "-mc",
         "-mc keep_fargs=false,passes=3,pure_getters,unsafe,unsafe_comps,unsafe_math,unsafe_proto",
@@ -48,6 +43,7 @@ describe("test/jetstream.js", function() {
         it("Should pass with options " + options, function(done) {
             var args = options.split(/ /);
             args.unshift("test/jetstream.js");
+            args.push("-b", "beautify=false,webkit");
             run(process.argv[0], args, done);
         });
     });

test/mocha/spidermonkey.js

@@ -4,7 +4,7 @@ var uglify = require("../node");
 
 describe("spidermonkey export/import sanity test", function() {
     it("should produce a functional build when using --self with spidermonkey", function(done) {
-        this.timeout(30000);
+        this.timeout(60000);
 
         var uglifyjs = '"' + process.argv[0] + '" bin/uglifyjs';
         var command = uglifyjs + " --self -cm --wrap SpiderUglify -o spidermonkey | " +
@@ -15,7 +15,9 @@ describe("spidermonkey export/import sanity test", function() {
 
             eval(stdout);
             assert.strictEqual(typeof SpiderUglify, "object");
-            assert.strictEqual(SpiderUglify.minify("foo([true,,2+3]);").code, "foo([!0,,5]);");
+            var result = SpiderUglify.minify("foo([true,,2+3]);");
+            assert.strictEqual(result.error, undefined);
+            assert.strictEqual(result.code, "foo([!0,,5]);");
 
             done();
         });

test/mocha/string-literal.js

@@ -61,9 +61,9 @@ describe("String literals", function() {
         var tests = [
             ['"\\76";', ';">";'],
             ['"\\0"', '"\\0";'],
-            ['"\\08"', '"\\08";'],
+            ['"\\08"', '"\\x008";'],
-            ['"\\008"', '"\\08";'],
+            ['"\\008"', '"\\x008";'],
-            ['"\\0008"', '"\\08";'],
+            ['"\\0008"', '"\\x008";'],
             ['"use strict" === "use strict";\n"\\76";', '"use strict"==="use strict";">";'],
             ['"use\\\n strict";\n"\\07";', ';"use strict";"\07";']
         ];
@@ -75,7 +75,44 @@ describe("String literals", function() {
     });
 
     it("Should not throw error when digit is 8 or 9", function() {
-        assert.equal(UglifyJS.parse('"use strict";"\\08"').print_to_string(), '"use strict";"\\08";');
+        assert.equal(UglifyJS.parse('"use strict";"\\08"').print_to_string(), '"use strict";"\\x008";');
-        assert.equal(UglifyJS.parse('"use strict";"\\09"').print_to_string(), '"use strict";"\\09";');
+        assert.equal(UglifyJS.parse('"use strict";"\\09"').print_to_string(), '"use strict";"\\x009";');
+    });
+
+    it("Should not unescape unpaired surrogates", function() {
+        var code = [];
+        for (var i = 0; i <= 0xF; i++) {
+            code.push("\\u000" + i.toString(16));
+        }
+        for (;i <= 0xFF; i++) {
+            code.push("\\u00" + i.toString(16));
+        }
+        for (;i <= 0xFFF; i++) {
+            code.push("\\u0" + i.toString(16));
+        }
+        for (; i <= 0xFFFF; i++) {
+            code.push("\\u" + i.toString(16));
+        }
+        code = '"' + code.join() + '"';
+        var normal = UglifyJS.minify(code, {
+            compress: false,
+            mangle: false,
+            output: {
+                ascii_only: false
+            }
+        });
+        if (normal.error) throw normal.error;
+        assert.ok(code.length > normal.code.length);
+        assert.strictEqual(eval(code), eval(normal.code));
+        var ascii = UglifyJS.minify(code, {
+            compress: false,
+            mangle: false,
+            output: {
+                ascii_only: false
+            }
+        });
+        if (ascii.error) throw ascii.error;
+        assert.ok(code.length > ascii.code.length);
+        assert.strictEqual(eval(code), eval(ascii.code));
     });
 });

test/run-tests.js

@@ -86,7 +86,6 @@ function run_compress_tests() {
         log_start_file(file);
         function test_case(test) {
             log_test(test.name);
-            U.base54.reset();
             var output_options = test.beautify || {};
             var expect;
             if (test.expect) {
@@ -101,9 +100,6 @@ function run_compress_tests() {
                 quote_style: 3,
                 keep_quoted_props: true
             });
-            if (test.mangle_props) {
-                input = U.mangle_properties(input, test.mangle_props);
-            }
             var options = U.defaults(test.options, {
                 warnings: false
             });
@@ -115,12 +111,26 @@ function run_compress_tests() {
                 };
                 if (!options.warnings) options.warnings = true;
             }
+            if (test.mangle && test.mangle.properties && test.mangle.properties.keep_quoted) {
+                var quoted_props = test.mangle.properties.reserved;
+                if (!Array.isArray(quoted_props)) quoted_props = [];
+                test.mangle.properties.reserved = quoted_props;
+                U.reserve_quoted_keys(input, quoted_props);
+            }
+            if (test.rename) {
+                input.figure_out_scope(test.mangle);
+                input.expand_names(test.mangle);
+            }
             var cmp = new U.Compressor(options, true);
             var output = cmp.compress(input);
             output.figure_out_scope(test.mangle);
             if (test.mangle) {
+                U.base54.reset();
                 output.compute_char_frequency(test.mangle);
                 output.mangle_names(test.mangle);
+                if (test.mangle.properties) {
+                    output = U.mangle_properties(output, test.mangle.properties);
+                }
             }
             output = make_code(output, output_options);
             if (expect != output) {
@@ -294,8 +304,22 @@ function parse_test(file) {
                 if (label.name == "expect_exact" || label.name == "node_version") {
                     test[label.name] = read_string(stat);
                 } else if (label.name == "expect_stdout") {
-                    if (stat.TYPE == "SimpleStatement" && stat.body instanceof U.AST_Boolean) {
+                    var body = stat.body;
-                        test[label.name] = stat.body.value;
+                    if (body instanceof U.AST_Boolean) {
+                        test[label.name] = body.value;
+                    } else if (body instanceof U.AST_Call) {
+                        var ctor = global[body.expression.name];
+                        assert.ok(ctor === Error || ctor.prototype instanceof Error, tmpl("Unsupported expect_stdout format [{line},{col}]", {
+                            line: label.start.line,
+                            col: label.start.col
+                        }));
+                        test[label.name] = ctor.apply(null, body.args.map(function(node) {
+                            assert.ok(node instanceof U.AST_Constant, tmpl("Unsupported expect_stdout format [{line},{col}]", {
+                                line: label.start.line,
+                                col: label.start.col
+                            }));
+                            return node.value;
+                        }));
                     } else {
                         test[label.name] = read_string(stat) + "\n";
                     }

test/sandbox.js

@@ -19,23 +19,26 @@ function safe_log(arg, level) {
 
 var FUNC_TOSTRING = [
     "Function.prototype.toString = Function.prototype.valueOf = function() {",
-    "    var id = 0;",
+    "    var id = 100000;",
     "    return function() {",
     '        if (this === Array) return "[Function: Array]";',
     '        if (this === Object) return "[Function: Object]";',
     "        var i = this.name;",
     '        if (typeof i != "number") {',
     "            i = ++id;",
+].concat(Object.getOwnPropertyDescriptor(Function.prototype, "name").configurable ? [
     '            Object.defineProperty(this, "name", {',
     "                get: function() {",
     "                    return i;",
     "                }",
     "            });",
+] : [], [
     "        }",
     '        return "[Function: " + i + "]";',
     "    }",
     "}();",
-].join("\n");
+    'Object.defineProperty(Function.prototype, "valueOf", { enumerable: false });',
+]).join("\n");
 exports.run_code = function(code) {
     var stdout = "";
     var original_write = process.stdout.write;
@@ -50,7 +53,10 @@ exports.run_code = function(code) {
             "}();",
         ].join("\n"), {
             console: {
-                log: function() {
+                log: function(msg) {
+                    if (arguments.length == 1 && typeof msg == "string") {
+                        return console.log("%s", msg);
+                    }
                     return console.log.apply(console, [].map.call(arguments, function(arg) {
                         return safe_log(arg, 3);
                     }));

test/sourcemaps.js

@@ -1,4 +1,4 @@
-var UglifyJS = require("./node");
+var UglifyJS = require("..");
 var ok = require("assert");
 
 module.exports = function () {
@@ -26,11 +26,11 @@ module.exports = function () {
 }
 
 function source_map(js) {
-    var source_map = UglifyJS.SourceMap();
+    return JSON.parse(UglifyJS.minify(js, {
-    var stream = UglifyJS.OutputStream({ source_map: source_map });
+        compress: false,
-    var parsed = UglifyJS.parse(js);
+        mangle: false,
-    parsed.print(stream);
+        sourceMap: true
-    return JSON.parse(source_map.toString());
+    }).map);
 }
 
 // Run standalone

test/ufuzz.js

@@ -12,7 +12,7 @@
         stream._handle.setBlocking(true);
 });
 
-var UglifyJS = require("./node");
+var UglifyJS = require("..");
 var randomBytes = require("crypto").randomBytes;
 var sandbox = require("./sandbox");
 
@@ -102,23 +102,23 @@ for (var i = 2; i < process.argv.length; ++i) {
       case '--help':
       case '-h':
       case '-?':
-        console.log('** UglifyJS fuzzer help **');
+        println('** UglifyJS fuzzer help **');
-        console.log('Valid options (optional):');
+        println('Valid options (optional):');
-        console.log('<number>: generate this many cases (if used must be first arg)');
+        println('<number>: generate this many cases (if used must be first arg)');
-        console.log('-v: print every generated test case');
+        println('-v: print every generated test case');
-        console.log('-V: print every 100th generated test case');
+        println('-V: print every 100th generated test case');
-        console.log('-t <int>: generate this many toplevels per run (more take longer)');
+        println('-t <int>: generate this many toplevels per run (more take longer)');
-        console.log('-r <int>: maximum recursion depth for generator (higher takes longer)');
+        println('-r <int>: maximum recursion depth for generator (higher takes longer)');
-        console.log('-s1 <statement name>: force the first level statement to be this one (see list below)');
+        println('-s1 <statement name>: force the first level statement to be this one (see list below)');
-        console.log('-s2 <statement name>: force the second level statement to be this one (see list below)');
+        println('-s2 <statement name>: force the second level statement to be this one (see list below)');
-        console.log('--no-catch-redef: do not redefine catch variables');
+        println('--no-catch-redef: do not redefine catch variables');
-        console.log('--no-directive: do not generate directives');
+        println('--no-directive: do not generate directives');
-        console.log('--use-strict: generate "use strict"');
+        println('--use-strict: generate "use strict"');
-        console.log('--stmt-depth-from-func: reset statement depth counter at each function, counts from global otherwise');
+        println('--stmt-depth-from-func: reset statement depth counter at each function, counts from global otherwise');
-        console.log('--only-stmt <statement names>: a comma delimited white list of statements that may be generated');
+        println('--only-stmt <statement names>: a comma delimited white list of statements that may be generated');
-        console.log('--without-stmt <statement names>: a comma delimited black list of statements never to generate');
+        println('--without-stmt <statement names>: a comma delimited black list of statements never to generate');
-        console.log('List of accepted statement names: ' + Object.keys(STMT_ARG_TO_ID));
+        println('List of accepted statement names: ' + Object.keys(STMT_ARG_TO_ID));
-        console.log('** UglifyJS fuzzer exiting **');
+        println('** UglifyJS fuzzer exiting **');
         return 0;
       default:
         // first arg may be a number.
@@ -162,6 +162,7 @@ var VALUES = [
     '"object"',
     '"number"',
     '"function"',
+    'this',
 ];
 
 var BINARY_OPS_NO_COMMA = [
@@ -262,10 +263,8 @@ var CAN_CONTINUE = true;
 var CANNOT_CONTINUE = false;
 var CAN_RETURN = false;
 var CANNOT_RETURN = true;
-var NOT_GLOBAL = true;
+var NO_DEFUN = false;
-var IN_GLOBAL = true;
+var DEFUN_OK = true;
-var ANY_TYPE = false;
-var NO_DECL = true;
 var DONT_STORE = true;
 
 var VAR_NAMES = [
@@ -306,6 +305,7 @@ var TYPEOF_OUTCOMES = [
 var unique_vars = [];
 var loops = 0;
 var funcs = 0;
+var called = Object.create(null);
 var labels = 10000;
 
 function rng(max) {
@@ -322,21 +322,22 @@ function createTopLevelCode() {
     unique_vars.length = 0;
     loops = 0;
     funcs = 0;
+    called = Object.create(null);
     return [
         strictMode(),
-        'var a = 100, b = 10, c = 0;',
+        'var _calls_ = 10, a = 100, b = 10, c = 0;',
         rng(2) == 0
         ? createStatements(3, MAX_GENERATION_RECURSION_DEPTH, CANNOT_THROW, CANNOT_BREAK, CANNOT_CONTINUE, CANNOT_RETURN, 0)
-        : createFunctions(rng(MAX_GENERATED_TOPLEVELS_PER_RUN) + 1, MAX_GENERATION_RECURSION_DEPTH, IN_GLOBAL, ANY_TYPE, CANNOT_THROW, 0),
+        : createFunctions(rng(MAX_GENERATED_TOPLEVELS_PER_RUN) + 1, MAX_GENERATION_RECURSION_DEPTH, DEFUN_OK, CANNOT_THROW, 0),
         'console.log(null, a, b, c);' // preceding `null` makes for a cleaner output (empty string still shows up etc)
     ].join('\n');
 }
 
-function createFunctions(n, recurmax, inGlobal, noDecl, canThrow, stmtDepth) {
+function createFunctions(n, recurmax, allowDefun, canThrow, stmtDepth) {
     if (--recurmax < 0) { return ';'; }
     var s = '';
     while (n-- > 0) {
-        s += createFunction(recurmax, inGlobal, noDecl, canThrow, stmtDepth) + '\n';
+        s += createFunction(recurmax, allowDefun, canThrow, stmtDepth) + '\n';
     }
     return s;
 }
@@ -349,10 +350,10 @@ function createParams() {
     return params.join(', ');
 }
 
-function createArgs() {
+function createArgs(recurmax, stmtDepth, canThrow) {
     var args = [];
     for (var n = rng(4); --n >= 0;) {
-        args.push(createValue());
+        args.push(rng(2) ? createValue() : createExpression(recurmax - 1, COMMA_OK, stmtDepth, canThrow));
     }
     return args.join(', ');
 }
@@ -362,16 +363,16 @@ function filterDirective(s) {
     return s;
 }
 
-function createFunction(recurmax, inGlobal, noDecl, canThrow, stmtDepth) {
+function createFunction(recurmax, allowDefun, canThrow, stmtDepth) {
     if (--recurmax < 0) { return ';'; }
     if (!STMT_COUNT_FROM_GLOBAL) stmtDepth = 0;
-    var func = funcs++;
     var namesLenBefore = VAR_NAMES.length;
     var name;
-    if (inGlobal || rng(5) > 0) name = 'f' + func;
+    if (allowDefun || rng(5) > 0) {
-    else {
+        name = 'f' + funcs++;
+    } else {
         unique_vars.push('a', 'b', 'c');
-        name = createVarName(MANDATORY, noDecl);
+        name = createVarName(MANDATORY, !allowDefun);
         unique_vars.length -= 3;
     }
     var s = [
@@ -380,7 +381,7 @@ function createFunction(recurmax, inGlobal, noDecl, canThrow, stmtDepth) {
     ];
     if (rng(5) === 0) {
         // functions with functions. lower the recursion to prevent a mess.
-        s.push(createFunctions(rng(5) + 1, Math.ceil(recurmax * 0.7), NOT_GLOBAL, ANY_TYPE, canThrow, stmtDepth));
+        s.push(createFunctions(rng(5) + 1, Math.ceil(recurmax * 0.7), DEFUN_OK, canThrow, stmtDepth));
     } else {
         // functions with statements
         s.push(createStatements(3, recurmax, canThrow, CANNOT_BREAK, CANNOT_CONTINUE, CAN_RETURN, stmtDepth));
@@ -390,11 +391,16 @@ function createFunction(recurmax, inGlobal, noDecl, canThrow, stmtDepth) {
 
     VAR_NAMES.length = namesLenBefore;
 
-    if (noDecl) s = 'var ' + createVarName(MANDATORY) + ' = ' + s + '(' + createExpression(recurmax, COMMA_OK, stmtDepth, canThrow) + ');';
+    if (!allowDefun) {
         // avoid "function statements" (decl inside statements)
-    else if (inGlobal || rng(10) > 0) s += 'var ' + createVarName(MANDATORY) + ' = ' + name + '(' + createArgs() + ');';
+        s = 'var ' + createVarName(MANDATORY) + ' = ' + s;
+        s += '(' + createArgs(recurmax, stmtDepth, canThrow) + ')';
+    } else if (!(name in called) || rng(3) > 0) {
+        s += 'var ' + createVarName(MANDATORY) + ' = ' + name;
+        s += '(' + createArgs(recurmax, stmtDepth, canThrow) + ')';
+    }
 
-    return s;
+    return s + ';';
 }
 
 function createStatements(n, recurmax, canThrow, canBreak, canContinue, cannotReturn, stmtDepth) {
@@ -539,7 +545,7 @@ function createStatement(recurmax, canThrow, canBreak, canContinue, cannotReturn
       case STMT_FUNC_EXPR:
         // "In non-strict mode code, functions can only be declared at top level, inside a block, or ..."
         // (dont both with func decls in `if`; it's only a parser thing because you cant call them without a block)
-        return '{' + createFunction(recurmax, NOT_GLOBAL, NO_DECL, canThrow, stmtDepth) + '}';
+        return '{' + createFunction(recurmax, NO_DEFUN, canThrow, stmtDepth) + '}';
       case STMT_TRY:
         // catch var could cause some problems
         // note: the "blocks" are syntactically mandatory for try/catch/finally
@@ -626,6 +632,9 @@ function _createExpression(recurmax, noComma, stmtDepth, canThrow) {
       case p++:
       case p++:
         return createValue();
+      case p++:
+      case p++:
+        return getVarName();
       case p++:
         return createExpression(recurmax, COMMA_OK, stmtDepth, canThrow);
       case p++:
@@ -643,7 +652,7 @@ function _createExpression(recurmax, noComma, stmtDepth, canThrow) {
                 '(function ' + name + '(){',
                 strictMode(),
                 createStatements(rng(5) + 1, recurmax, canThrow, CANNOT_BREAK, CANNOT_CONTINUE, CAN_RETURN, stmtDepth),
-                '})()'
+                rng(2) == 0 ? '})' : '})()'
             );
             break;
           case 1:
@@ -682,7 +691,7 @@ function _createExpression(recurmax, noComma, stmtDepth, canThrow) {
             }
             s.push(
                 createStatements(rng(5) + 1, recurmax, canThrow, CANNOT_BREAK, CANNOT_CONTINUE, CAN_RETURN, stmtDepth),
-                '}'
+                rng(2) == 0 ? '}' : '}()'
             );
             break;
         }
@@ -749,6 +758,13 @@ function _createExpression(recurmax, noComma, stmtDepth, canThrow) {
       case p++:
         var name = getVarName();
         return name + ' && ' + name + '.' + getDotKey();
+      case p++:
+      case p++:
+      case p++:
+      case p++:
+        var name = rng(3) == 0 ? getVarName() : 'f' + rng(funcs + 2);
+        called[name] = true;
+        return 'typeof ' + name + ' == "function" && --_calls_ >= 0 && ' + name + '(' + createArgs(recurmax, stmtDepth, canThrow) + ')';
     }
     _createExpression.N = p;
     return _createExpression(recurmax, noComma, stmtDepth, canThrow);
@@ -941,7 +957,17 @@ if (require.main !== module) {
     return;
 }
 
-function try_beautify(code, result) {
+function println(msg) {
+    if (typeof msg != "undefined") process.stdout.write(msg);
+    process.stdout.write("\n");
+}
+
+function errorln(msg) {
+    if (typeof msg != "undefined") process.stderr.write(msg);
+    process.stderr.write("\n");
+}
+
+function try_beautify(code, result, printfn) {
     var beautified = UglifyJS.minify(code, {
         compress: false,
         mangle: false,
@@ -951,51 +977,34 @@ function try_beautify(code, result) {
         },
     });
     if (beautified.error) {
-        console.log("// !!! beautify failed !!!");
+        printfn("// !!! beautify failed !!!");
-        console.log(beautified.error.stack);
+        printfn(beautified.error.stack);
     } else if (sandbox.same_stdout(sandbox.run_code(beautified.code), result)) {
-        console.log("// (beautified)");
+        printfn("// (beautified)");
-        console.log(beautified.code);
+        printfn(beautified.code);
         return;
     }
-    console.log("//");
+    printfn("//");
-    console.log(code);
+    printfn(code);
 }
 
-function infer_options(ctor) {
+var default_options = UglifyJS.default_options();
-    try {
-        ctor({ 0: 0 });
-    } catch (e) {
-        return e.defs;
-    }
-}
-
-var default_options = {
-    compress: infer_options(UglifyJS.Compressor),
-    mangle: {
-        "cache": null,
-        "eval": false,
-        "ie8": false,
-        "keep_fnames": false,
-        "toplevel": false,
-    },
-    output: infer_options(UglifyJS.OutputStream),
-};
 
 function log_suspects(minify_options, component) {
     var options = component in minify_options ? minify_options[component] : true;
     if (!options) return;
-    options = UglifyJS.defaults(options, default_options[component]);
+    if (typeof options != "object") options = {};
-    var suspects = Object.keys(default_options[component]).filter(function(name) {
+    var defs = default_options[component];
-        if (options[name]) {
+    var suspects = Object.keys(defs).filter(function(name) {
+        if ((name in options ? options : defs)[name]) {
             var m = JSON.parse(JSON.stringify(minify_options));
             var o = JSON.parse(JSON.stringify(options));
             o[name] = false;
             m[component] = o;
             var result = UglifyJS.minify(original_code, m);
             if (result.error) {
-                console.log("Error testing options." + component + "." + name);
+                errorln("Error testing options." + component + "." + name);
-                console.log(result.error);
+                errorln(result.error.stack);
             } else {
                 var r = sandbox.run_code(result.code);
                 return sandbox.same_stdout(original_result, r);
@@ -1003,49 +1012,49 @@ function log_suspects(minify_options, component) {
         }
     });
     if (suspects.length > 0) {
-        console.log("Suspicious", component, "options:");
+        errorln("Suspicious " + component + " options:");
         suspects.forEach(function(name) {
-            console.log("  " + name);
+            errorln("  " + name);
         });
-        console.log();
+        errorln();
     }
 }
 
 function log(options) {
-    if (!ok) console.log('\n\n\n\n\n\n!!!!!!!!!!\n\n\n');
+    if (!ok) errorln('\n\n\n\n\n\n!!!!!!!!!!\n\n\n');
-    console.log("//=============================================================");
+    errorln("//=============================================================");
-    if (!ok) console.log("// !!!!!! Failed... round", round);
+    if (!ok) errorln("// !!!!!! Failed... round " + round);
-    console.log("// original code");
+    errorln("// original code");
-    try_beautify(original_code, original_result);
+    try_beautify(original_code, original_result, errorln);
-    console.log();
+    errorln();
-    console.log();
+    errorln();
-    console.log("//-------------------------------------------------------------");
+    errorln("//-------------------------------------------------------------");
     if (typeof uglify_code == "string") {
-        console.log("// uglified code");
+        errorln("// uglified code");
-        try_beautify(uglify_code, uglify_result);
+        try_beautify(uglify_code, uglify_result, errorln);
-        console.log();
+        errorln();
-        console.log();
+        errorln();
-        console.log("original result:");
+        errorln("original result:");
-        console.log(original_result);
+        errorln(typeof original_result == "string" ? original_result : original_result.stack);
-        console.log("uglified result:");
+        errorln("uglified result:");
-        console.log(uglify_result);
+        errorln(typeof uglify_result == "string" ? uglify_result : uglify_result.stack);
     } else {
-        console.log("// !!! uglify failed !!!");
+        errorln("// !!! uglify failed !!!");
-        console.log(uglify_code.stack);
+        errorln(uglify_code.stack);
         if (typeof original_result != "string") {
-            console.log();
+            errorln();
-            console.log();
+            errorln();
-            console.log("original stacktrace:");
+            errorln("original stacktrace:");
-            console.log(original_result.stack);
+            errorln(original_result.stack);
         }
     }
-    console.log("minify(options):");
+    errorln("minify(options):");
     options = JSON.parse(options);
-    console.log(options);
+    errorln(JSON.stringify(options, null, 2));
-    console.log();
+    errorln();
     if (!ok && typeof uglify_code == "string") {
         Object.keys(default_options).forEach(log_suspects.bind(null, options));
-        console.log("!!!!!! Failed... round", round);
+        errorln("!!!!!! Failed... round " + round);
     }
 }
 
@@ -1075,19 +1084,19 @@ for (var round = 1; round <= num_iterations; round++) {
         }
         if (verbose || (verbose_interval && !(round % INTERVAL_COUNT)) || !ok) log(options);
         else if (typeof original_result != "string") {
-            console.log("//=============================================================");
+            println("//=============================================================");
-            console.log("// original code");
+            println("// original code");
-            try_beautify(original_code, original_result);
+            try_beautify(original_code, original_result, println);
-            console.log();
+            println();
-            console.log();
+            println();
-            console.log("original result:");
+            println("original result:");
-            console.log(original_result);
+            println(original_result.stack);
-            console.log();
+            println();
         }
         if (!ok && isFinite(num_iterations)) {
-            console.log();
+            println();
             process.exit(1);
         }
     });
 }
-console.log();
+println();

test/ufuzz.json

@@ -15,17 +15,12 @@
     },
     {},
     {
-        "compress": {
         "toplevel": true
     },
-        "mangle": {
-            "toplevel": true
-        }
-    },
     {
         "compress": {
             "keep_fargs": false,
-            "passes": 3
+            "passes": 100
         }
     }
 ]

tools/exports.js

@@ -2,4 +2,5 @@ exports["Dictionary"] = Dictionary;
 exports["TreeWalker"] = TreeWalker;
 exports["TreeTransformer"] = TreeTransformer;
 exports["minify"] = minify;
+exports["parse"] = parse;
 exports["_push_uniq"] = push_uniq;

tools/node.js

@@ -61,5 +61,22 @@ function describe_ast() {
         }
     };
     doitem(AST_Node);
-    return out + "";
+    return out + "\n";
 }
+
+function infer_options(options) {
+    var result = UglifyJS.minify("", options);
+    return result.error && result.error.defs;
+}
+
+UglifyJS.default_options = function() {
+    var defs = {};
+    Object.keys(infer_options({ 0: 0 })).forEach(function(component) {
+        var options = {};
+        options[component] = { 0: 0 };
+        if (options = infer_options(options)) {
+            defs[component] = options;
+        }
+    });
+    return defs;
+};