v3.2.0

fix argument/atom collision by properties (#2514 )
fixes #2513
2017-11-26 04:08:35 +08:00 · 2017-11-25 22:52:46 +08:00 · 2017-11-25 19:07:46 +08:00 · 2017-11-24 14:07:39 +08:00 · 2017-11-24 07:26:22 +08:00 · 2017-11-24 07:03:37 +08:00
34 changed files with 5488 additions and 652 deletions
--- a/.github/ISSUE_TEMPLATE.md
+++ b/.github/ISSUE_TEMPLATE.md
@@ -15,6 +15,8 @@
    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.**
--- a/README.md
+++ b/README.md
@@ -221,7 +221,7 @@ to prevent the `require`, `exports` and `$` names from being changed.
 is a separate step, different from variable name mangling.  Pass
 `--mangle-props` to enable it.  It will mangle all properties in the
 input code with the exception of built in DOM properties and properties
-in core javascript classes.  For example:
+in core JavaScript classes.  For example:

 ```javascript
 // example.js
@@ -236,7 +236,7 @@ x.bar_ = 2;
 x["baz_"] = 3;
 console.log(x.calc());
 ```
-Mangle all properties (except for javascript `builtins`):
+Mangle all properties (except for JavaScript `builtins`):
 ```bash
 $ uglifyjs example.js -c -m --mangle-props
 ```
@@ -515,7 +515,6 @@ if (result.error) throw result.error;

 ```javascript
 {
-    warnings: false,
    parse: {
        // parse options
    },
@@ -538,6 +537,7 @@ if (result.error) throw result.error;
    nameCache: null, // or specify a name cache object
    toplevel: false,
    ie8: false,
+    warnings: false,
 }
 ```

@@ -598,17 +598,17 @@ If you're using the `X-SourceMap` header instead, you can just omit `sourceMap.u

 ## Compress options

- `booleans` (default: `true`) -- various optimizations for boolean context, for example `!!a
-  ? b : c → a ? b : c`
+- `booleans` (default: `true`) -- various optimizations for boolean context,
+  for example `!!a ? b : c → a ? b : c`

- `cascade` (default: `true`) -- small optimization for sequences, transform `x, x` into `x`
-  and `x = something(), x` into `x = something()`
+- `cascade` (default: `true`) -- small optimization for sequences, transform
+  `x, x` into `x` and `x = something(), x` into `x = something()`

- `collapse_vars` (default: `true`) -- Collapse single-use non-constant variables - side
-  effects permitting.
+- `collapse_vars` (default: `true`) -- Collapse single-use non-constant variables,
+  side effects permitting.

- `comparisons` (default: `true`) -- apply certain optimizations to binary nodes, for example:
-  `!(a <= b) → a > b` (only when `unsafe_comps`), attempts to negate binary
+- `comparisons` (default: `true`) -- apply certain optimizations to binary nodes,
+  e.g. `!(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.

 - `conditionals` (default: `true`) -- apply optimizations for `if`-s and conditional
@@ -616,7 +616,7 @@ If you're using the `X-SourceMap` header instead, you can just omit `sourceMap.u

 - `dead_code` (default: `true`) -- remove unreachable code

- `drop_console` (default: `false`) -- default `false`.  Pass `true` to discard calls to
+- `drop_console` (default: `false`) -- Pass `true` to discard calls to
  `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.
@@ -625,13 +625,19 @@ If you're using the `X-SourceMap` header instead, you can just omit `sourceMap.u

 - `evaluate` (default: `true`) -- attempt to evaluate constant expressions

- `expression` (default: `false`) -- default `false`.  Pass `true` to preserve completion values
+- `expression` (default: `false`) -- Pass `true` to preserve completion values
  from terminal statements without `return`, e.g. in bookmarklets.

 - `global_defs` (default: `{}`) -- see [conditional compilation](#conditional-compilation)

 - `hoist_funs` (default: `true`) -- 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)

@@ -641,15 +647,18 @@ If you're using the `X-SourceMap` header instead, you can just omit `sourceMap.u

 - `join_vars` (default: `true`) -- join consecutive `var` statements

- `keep_fargs` (default: `true`) -- default `true`.  Prevents the
-  compressor from discarding unused function arguments.  You need this
-  for code which relies on `Function.length`.
+- `keep_fargs` (default: `true`) -- Prevents the compressor from discarding unused
+  function arguments.  You need this for code which relies on `Function.length`.

- `keep_infinity` (default: `false`) -- default `false`. Pass `true` to prevent `Infinity` from
+- `keep_fnames` (default: `false`) -- Pass `true` to prevent the
+  compressor from discarding function names.  Useful for code relying on
+  `Function.prototype.name`. See also: the `keep_fnames` [mangle option](#mangle).
+
+- `keep_infinity` (default: `false`) -- Pass `true` to prevent `Infinity` from
  being compressed into `1/0`, which may cause performance issues on Chrome.

- `loops` (default: `true`) -- optimizations for `do`, `while` and `for` loops when we can
-  statically determine the condition
+- `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
@@ -679,6 +688,12 @@ If you're using the `X-SourceMap` header instead, you can just omit `sourceMap.u
  Specify `"strict"` to treat `foo.bar` as side-effect-free only when
  `foo` is certain to not throw, i.e. not `null` or `undefined`.

+- `reduce_funcs` (default: `true`) -- Allows single-use functions to be
+  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.
+
 - `reduce_vars` (default: `true`) -- Improve optimization on variables assigned with and
  used as constant values.

@@ -691,24 +706,27 @@ If you're using the `X-SourceMap` header instead, you can just omit `sourceMap.u
  occasions the default sequences limit leads to very slow compress times in which
  case a value of `20` or less is recommended.

- `side_effects` (default: `true`) -- default `true`. Pass `false` to disable potentially dropping
+- `side_effects` (default: `true`) -- Pass `false` to disable potentially dropping
  functions marked as "pure".  A function call is marked as "pure" if a comment
  annotation `/*@__PURE__*/` or `/*#__PURE__*/` immediately precedes the call. For
  example: `/*@__PURE__*/foo();`

 - `switches` (default: `true`) -- de-duplicate and remove unreachable `switch` branches

- `toplevel` (default: `false`) -- drop unreferenced functions (`"funcs"`) and/or variables (`"vars"`)
-  in the top level scope (`false` by default, `true` to drop both unreferenced
-  functions and variables)
+- `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`)
+- `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`) -- default `true`.  Transforms `typeof foo == "undefined"` into
+- `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`,
@@ -716,8 +734,6 @@ If you're using the `X-SourceMap` header instead, you can just omit `sourceMap.u
  comparison are switching. Compression only works if both `comparisons` and
  `unsafe_comps` are both set to true.

- `unsafe` (default: `false`) -- apply "unsafe" transformations (discussion below)
-
 - `unsafe_Func` (default: `false`) -- compress and mangle `Function(args, code)`
  when both `args` and `code` are string literals.

@@ -730,23 +746,27 @@ If you're using the `X-SourceMap` header instead, you can just omit `sourceMap.u
 - `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"`)
+- `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.
+- `warnings` (default: `false`) -- display warnings when dropping unreachable
+  code or unused declarations etc.

 ## Mangle options

- `reserved` (default `[]`). Pass an array of identifiers that should be
+- `eval` (default `false`) -- Pass `true` to mangle names visible in scopes
+  where `eval` or `with` are used.
+
+- `keep_fnames` (default `false`) -- Pass `true` to not mangle function names.
+  Useful for code relying on `Function.prototype.name`. See also: the `keep_fnames`
+  [compress option](#compress-options).
+
+- `reserved` (default `[]`) -- Pass an array of identifiers that should be
  excluded from mangling. Example: `["foo", "bar"]`.

- `toplevel` (default `false`). Pass `true` to mangle names declared in the
+- `toplevel` (default `false`) -- Pass `true` to mangle names declared in the
  top level scope.

- `eval` (default `false`). Pass `true` to mangle names visible in scopes
-  where `eval` or `with` are used.
-
 Examples:

 ```javascript
@@ -845,6 +865,9 @@ can pass additional arguments that control the code output:

 - `shebang` (default `true`) -- preserve shebang `#!` in preamble (bash scripts)

+- `webkit` (default `false`) -- enable workarounds for WebKit bugs.
+  PhantomJS users should set this option to `true`.
+
 - `width` (default `80`) -- only takes effect when beautification is on, this
  specifies an (orientative) line width that the beautifier will try to
  obey.  It refers to the width of the line text (excluding indentation).
@@ -1052,7 +1075,7 @@ in total it's a bit more than just using UglifyJS's own parser.
 ### 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
+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
--- a/bin/uglifyjs
+++ b/bin/uglifyjs
@@ -15,7 +15,7 @@ var path = require("path");
 var program = require("commander");
 var UglifyJS = require("../tools/node");

-var skip_keys = [ "cname", "enclosed", "parent_scope", "scope", "thedef", "uses_eval", "uses_with" ];
+var skip_keys = [ "cname", "enclosed", "inlined", "parent_scope", "scope", "thedef", "uses_eval", "uses_with" ];
 var files = {};
 var options = {
    compress: false,
@@ -47,6 +47,7 @@ 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("--timings", "Display operations run time on STDERR.")
@@ -65,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];
    }
 });
--- a/lib/ast.js
+++ b/lib/ast.js
@@ -352,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);

--- a/lib/compress.js
+++ b/lib/compress.js
--- a/lib/minify.js
+++ b/lib/minify.js
@@ -55,6 +55,7 @@ function minify(files, options) {
            nameCache: null,
            output: {},
            parse: {},
+            rename: undefined,
            sourceMap: false,
            timings: false,
            toplevel: false,
@@ -64,6 +65,9 @@ function minify(files, options) {
        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" ]);
@@ -137,11 +141,14 @@ function minify(files, options) {
        if (options.wrap) {
            toplevel = toplevel.wrap_commonjs(options.wrap);
        }
-        if (timings) timings.scope1 = Date.now();
-        if (options.compress) toplevel.figure_out_scope(options.mangle);
+        if (timings) timings.rename = Date.now();
+        if (options.rename) {
+            toplevel.figure_out_scope(options.mangle);
+            toplevel.expand_names(options.mangle);
+        }
        if (timings) timings.compress = Date.now();
        if (options.compress) toplevel = new Compressor(options.compress).compress(toplevel);
-        if (timings) timings.scope2 = Date.now();
+        if (timings) timings.scope = Date.now();
        if (options.mangle) toplevel.figure_out_scope(options.mangle);
        if (timings) timings.mangle = Date.now();
        if (options.mangle) {
@@ -199,9 +206,10 @@ function minify(files, options) {
        if (timings) {
            timings.end = Date.now();
            result.timings = {
-                parse: 1e-3 * (timings.scope1 - timings.parse),
-                scope: 1e-3 * (timings.compress - timings.scope1 + timings.mangle - timings.scope2),
-                compress: 1e-3 * (timings.scope2 - timings.compress),
+                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),
--- a/lib/scope.js
+++ b/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++;
 };

@@ -251,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);
@@ -312,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 {
@@ -330,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
@@ -382,7 +383,7 @@ AST_Symbol.DEFMETHOD("global", function(){
    return this.definition().global;
 });

-AST_Toplevel.DEFMETHOD("_default_mangler_options", function(options){
+AST_Toplevel.DEFMETHOD("_default_mangler_options", function(options) {
    options = defaults(options, {
        eval        : false,
        ie8         : false,
@@ -391,15 +392,14 @@ AST_Toplevel.DEFMETHOD("_default_mangler_options", function(options){
        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
@@ -408,11 +408,7 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options){
    var to_mangle = [];

    if (options.cache) {
-        this.globals.each(function(symbol){
-            if (options.reserved.indexOf(symbol.name) < 0) {
-                to_mangle.push(symbol);
-            }
-        });
+        this.globals.each(collect);
    }

    var tw = new TreeWalker(function(node, descend){
@@ -424,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(function(symbol){
-                if (options.reserved.indexOf(symbol.name) < 0) {
-                    a.push(symbol);
-                }
-            });
-            to_mangle.push.apply(to_mangle, a);
+            node.variables.each(collect);
            return;
        }
        if (node instanceof AST_Label) {
@@ -450,6 +440,74 @@ 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_Toplevel.DEFMETHOD("compute_char_frequency", function(options){
--- a/package.json
+++ b/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.1.4",
+  "version": "3.2.0",
  "engines": {
    "node": ">=0.8.0"
  },
@@ -29,11 +29,11 @@
    "LICENSE"
  ],
  "dependencies": {
-    "commander": "~2.11.0",
+    "commander": "~2.12.1",
    "source-map": "~0.6.1"
  },
  "devDependencies": {
-    "acorn": "~5.1.1",
+    "acorn": "~5.2.1",
    "mocha": "~3.5.1",
    "semver": "~5.4.1"
  },
--- a/test/compress/arrays.js
+++ b/test/compress/arrays.js
@@ -128,50 +128,114 @@ constant_join_3: {

 for_loop: {
    options = {
-        unsafe      : true,
-        unused      : true,
-        evaluate    : true,
-        reduce_vars : true
+        evaluate: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        unsafe: true,
+        unused: true,
    };
    input: {
        function f0() {
            var a = [1, 2, 3];
-            for (var i = 0; i < a.length; i++) {
-                console.log(a[i]);
-            }
+            var b = 0;
+            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++) {
-                console.log(a[i]);
-            }
+            var b = 0;
+            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"
 }
--- a/test/compress/collapse_vars.js
+++ b/test/compress/collapse_vars.js
--- a/test/compress/comparing.js
+++ b/test/compress/comparing.js
@@ -73,4 +73,42 @@ dont_change_in_or_instanceof_expressions: {
        1 instanceof 1;
        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"
+}
--- a/test/compress/dead-code.js
+++ b/test/compress/dead-code.js
@@ -292,6 +292,7 @@ global_timeout_and_interval_symbols: {
 issue_2233_2: {
    options = {
        pure_getters: "strict",
+        reduce_funcs: true,
        reduce_vars: true,
        side_effects: true,
        unsafe: true,
@@ -323,6 +324,7 @@ issue_2233_2: {
 issue_2233_3: {
    options = {
        pure_getters: "strict",
+        reduce_funcs: true,
        reduce_vars: true,
        side_effects: true,
        toplevel: true,
--- a/test/compress/drop-unused.js
+++ b/test/compress/drop-unused.js
@@ -673,6 +673,7 @@ issue_1539: {
 vardef_value: {
    options = {
        keep_fnames: false,
+        reduce_funcs: true,
        reduce_vars: true,
        unused: true,
    }
@@ -734,6 +735,7 @@ assign_chain: {
 issue_1583: {
    options = {
        keep_fargs: true,
+        reduce_funcs: true,
        reduce_vars: true,
        unused: true,
    }
@@ -1080,6 +1082,7 @@ var_catch_toplevel: {
    options = {
        conditionals: true,
        negate_iife: true,
+        reduce_funcs: true,
        reduce_vars: true,
        side_effects: true,
        toplevel: true,
@@ -1109,11 +1112,12 @@ var_catch_toplevel: {
    }
 }

-issue_2105: {
+issue_2105_1: {
    options = {
        collapse_vars: true,
        inline: true,
        passes: 3,
+        reduce_funcs: true,
        reduce_vars: true,
        side_effects: true,
        unused: true,
@@ -1139,17 +1143,51 @@ issue_2105: {
        });
    }
    expect: {
-        (function() {
-            var quux = function() {
+        ({
+            prop: function() {
+                console.log;
                console.log("PASS");
-            };
-            return {
-                prop: function() {
-                    console.log;
-                    quux();
+            }
+        }).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 };
                }
-            };
-        })().prop();
+                return bar;
+            } );
+        });
+    }
+    expect: {
+        console.log("PASS");
    }
    expect_stdout: "PASS"
 }
--- a/test/compress/evaluate.js
+++ b/test/compress/evaluate.js
@@ -251,6 +251,7 @@ unsafe_constant: {
 unsafe_object: {
    options = {
        evaluate: true,
+        reduce_funcs: true,
        reduce_vars: true,
        toplevel: true,
        unsafe: true,
@@ -279,6 +280,7 @@ unsafe_object: {
 unsafe_object_nested: {
    options = {
        evaluate: true,
+        reduce_funcs: true,
        reduce_vars: true,
        toplevel: true,
        unsafe: true,
@@ -307,6 +309,7 @@ unsafe_object_nested: {
 unsafe_object_complex: {
    options = {
        evaluate: true,
+        reduce_funcs: true,
        reduce_vars: true,
        toplevel: true,
        unsafe: true,
@@ -335,6 +338,7 @@ unsafe_object_complex: {
 unsafe_object_repeated: {
    options = {
        evaluate: true,
+        reduce_funcs: true,
        reduce_vars: true,
        toplevel: true,
        unsafe: true,
@@ -363,6 +367,7 @@ unsafe_object_repeated: {
 unsafe_object_accessor: {
    options = {
        evaluate: true,
+        reduce_funcs: true,
        reduce_vars: true,
        unsafe: true,
    }
@@ -386,10 +391,11 @@ unsafe_object_accessor: {
    }
 }

-unsafe_function: {
+prop_function: {
    options = {
-        evaluate  : true,
-        unsafe    : true
+        evaluate: true,
+        properties: true,
+        side_effects: true,
    }
    input: {
        console.log(
@@ -402,9 +408,9 @@ unsafe_function: {
    expect: {
        console.log(
            ({a:{b:1},b:function(){}}) + 1,
-            ({b:function(){}}, {b:1}) + 1,
-            ({a:{b:1}}, function(){}) + 1,
-            ({b:function(){}}, {b:1}).b + 1
+            ({b:1}) + 1,
+            function(){} + 1,
+            2
        );
    }
    expect_stdout: true
@@ -630,10 +636,11 @@ unsafe_string_bad_index: {
    expect_stdout: true
 }

-unsafe_prototype_function: {
+prototype_function: {
    options = {
-        evaluate  : true,
-        unsafe    : true
+        evaluate: true,
+        properties: true,
+        side_effects: true,
    }
    input: {
        var a = ({valueOf: 0}) < 1;
@@ -652,8 +659,8 @@ unsafe_prototype_function: {
        var d = ({toString: 0}) + "";
        var e = (({valueOf: 0}) + "")[2];
        var f = (({toString: 0}) + "")[2];
-        var g = ({}, 0)();
-        var h = ({}, 0)();
+        var g = 0();
+        var h = 0();
    }
 }

@@ -661,6 +668,7 @@ call_args: {
    options = {
        evaluate: true,
        inline: true,
+        reduce_funcs: true,
        reduce_vars: true,
        toplevel: true,
    }
@@ -684,6 +692,7 @@ call_args_drop_param: {
        evaluate: true,
        inline: true,
        keep_fargs: false,
+        reduce_funcs: true,
        reduce_vars: true,
        toplevel: true,
        unused: true,
@@ -1014,6 +1023,7 @@ Infinity_NaN_undefined_LHS: {
 issue_1964_1: {
    options = {
        evaluate: true,
+        reduce_funcs: true,
        reduce_vars: true,
        unsafe_regexp: false,
        unused: true,
@@ -1043,6 +1053,7 @@ issue_1964_1: {
 issue_1964_2: {
    options = {
        evaluate: true,
+        reduce_funcs: true,
        reduce_vars: true,
        unsafe_regexp: true,
        unused: true,
@@ -1195,3 +1206,42 @@ issue_2231_2: {
    }
    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'"
+}
--- a/test/compress/functions.js
+++ b/test/compress/functions.js
@@ -19,6 +19,7 @@ iifes_returning_constants_keep_fargs_true: {
        booleans      : true,
        if_return     : true,
        join_vars     : true,
+        reduce_funcs  : true,
        reduce_vars   : true,
        cascade       : true,
        inline        : true,
@@ -55,6 +56,7 @@ iifes_returning_constants_keep_fargs_false: {
        booleans      : true,
        if_return     : true,
        join_vars     : true,
+        reduce_funcs  : true,
        reduce_vars   : true,
        cascade       : true,
        inline        : true,
@@ -101,6 +103,7 @@ issue_1841_1: {
    options = {
        keep_fargs: false,
        pure_getters: "strict",
+        reduce_funcs: true,
        reduce_vars: true,
        unused: true,
    }
@@ -127,6 +130,7 @@ issue_1841_2: {
    options = {
        keep_fargs: false,
        pure_getters: false,
+        reduce_funcs: true,
        reduce_vars: true,
        unused: true,
    }
@@ -151,13 +155,14 @@ issue_1841_2: {

 function_returning_constant_literal: {
    options = {
-        reduce_vars: true,
-        unsafe: true,
-        toplevel: true,
-        evaluate: true,
-        cascade: true,
-        unused: true,
        inline: true,
+        passes: 2,
+        properties: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
    }
    input: {
        function greeter() {
@@ -305,6 +310,7 @@ issue_2084: {
        evaluate: true,
        inline: true,
        passes: 2,
+        reduce_funcs: true,
        reduce_vars: true,
        sequences: true,
        side_effects: true,
@@ -340,6 +346,7 @@ issue_2084: {
 issue_2097: {
    options = {
        negate_iife: true,
+        reduce_funcs: true,
        reduce_vars: true,
        toplevel: true,
        unused: true,
@@ -508,3 +515,42 @@ issue_2114_2: {
    }
    expect_stdout: "2"
 }
+
+issue_2428: {
+    options = {
+        collapse_vars: true,
+        inline: true,
+        passes: 3,
+        pure_getters: "strict",
+        reduce_funcs: true,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unsafe: true,
+        unused: true,
+    }
+    input: {
+        function bar(k) {
+            console.log(k);
+        }
+        function foo(x) {
+            return bar(x);
+        }
+        function baz(a) {
+            foo(a);
+        }
+        baz(42);
+        baz("PASS");
+    }
+    expect: {
+        function baz(a) {
+            console.log(a);
+        }
+        baz(42);
+        baz("PASS");
+    }
+    expect_stdout: [
+        "42",
+        "PASS",
+    ]
+}
--- a/test/compress/hoist_props.js
+++ b/test/compress/hoist_props.js
@@ -0,0 +1,635 @@
+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, function(x) {
+            return x * x * x;
+        }(3));
+    }
+    expect_stdout: "1 27"
+}
+
+issue_2377_3: {
+    options = {
+        evaluate: true,
+        inline: true,
+        hoist_props: true,
+        passes: 3,
+        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, 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
+}
--- a/test/compress/issue-1041.js
+++ b/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,
    };

--- a/test/compress/issue-1609.js
+++ b/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,
    }
--- a/test/compress/issue-1656.js
+++ b/test/compress/issue-1656.js
@@ -15,6 +15,7 @@ f7: {
        negate_iife: true,
        passes: 3,
        properties: true,
+        reduce_funcs: true,
        reduce_vars: true,
        sequences: true,
        side_effects: true,
--- a/test/compress/issue-1673.js
+++ b/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,
--- a/test/compress/issue-1787.js
+++ b/test/compress/issue-1787.js
@@ -2,6 +2,7 @@ unary_prefix: {
    options = {
        evaluate: true,
        inline: true,
+        reduce_funcs: true,
        reduce_vars: true,
        unused: true,
    }
--- a/test/compress/issue-1833.js
+++ b/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,
--- a/test/compress/issue-281.js
+++ b/test/compress/issue-281.js
@@ -3,6 +3,7 @@ collapse_vars_constants: {
        collapse_vars: true,
        evaluate: true,
        inline: true,
+        reduce_funcs: true,
        reduce_vars: true,
        unused: true,
    }
@@ -240,6 +241,7 @@ negate_iife_issue_1073: {
        evaluate: true,
        inline: true,
        negate_iife: true,
+        reduce_funcs: true,
        reduce_vars: true,
        sequences: true,
        unused: true,
@@ -267,6 +269,7 @@ issue_1288_side_effects: {
        evaluate: true,
        inline: true,
        negate_iife: true,
+        reduce_funcs: true,
        reduce_vars: true,
        side_effects: true,
        unused: true,
@@ -299,6 +302,7 @@ inner_var_for_in_1: {
    options = {
        evaluate: true,
        inline: true,
+        reduce_funcs: true,
        reduce_vars: true,
    }
    input: {
@@ -330,6 +334,7 @@ issue_1595_3: {
        evaluate: true,
        inline: true,
        passes: 2,
+        reduce_funcs: true,
        reduce_vars: true,
        unused: true,
    }
--- a/test/compress/issue-973.js
+++ b/test/compress/issue-973.js
@@ -51,6 +51,7 @@ this_binding_collapse_vars: {
    options = {
        collapse_vars: true,
        toplevel: true,
+        unused: true,
    };
    input: {
        var c = a; c();
--- a/test/compress/properties.js
+++ b/test/compress/properties.js
@@ -1,7 +1,8 @@
 keep_properties: {
    options = {
-        properties: false
-    };
+        evaluate: true,
+        properties: false,
+    }
    input: {
        a["foo"] = "bar";
    }
@@ -12,6 +13,7 @@ keep_properties: {

 dot_properties: {
    options = {
+        evaluate: true,
        properties: true,
    }
    beautify = {
@@ -37,6 +39,7 @@ dot_properties: {

 dot_properties_es5: {
    options = {
+        evaluate: true,
        properties: true,
    }
    beautify = {
@@ -61,8 +64,8 @@ dot_properties_es5: {
 sub_properties: {
    options = {
        evaluate: true,
-        properties: true
-    };
+        properties: true,
+    }
    input: {
        a[0] = 0;
        a["0"] = 1;
@@ -81,18 +84,18 @@ sub_properties: {
        a[3.14] = 3;
        a.if = 4;
        a["foo bar"] = 5;
-        a[NaN] = 6;
-        a[null] = 7;
+        a.NaN = 6;
+        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"];
@@ -109,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"];
@@ -151,7 +154,8 @@ mangle_properties: {

 mangle_unquoted_properties: {
    options = {
-        properties: false
+        evaluate: true,
+        properties: false,
    }
    mangle = {
        properties: {
@@ -249,7 +253,8 @@ mangle_debug_suffix: {

 mangle_debug_suffix_keep_quoted: {
    options = {
-        properties: false
+        evaluate: true,
+        properties: false,
    }
    mangle = {
        properties: {
@@ -677,8 +682,8 @@ accessor_this: {
 issue_2208_1: {
    options = {
        inline: true,
+        properties: true,
        side_effects: true,
-        unsafe: true,
    }
    input: {
        console.log({
@@ -696,8 +701,8 @@ issue_2208_1: {
 issue_2208_2: {
    options = {
        inline: true,
+        properties: true,
        side_effects: true,
-        unsafe: true,
    }
    input: {
        console.log({
@@ -721,8 +726,8 @@ issue_2208_2: {
 issue_2208_3: {
    options = {
        inline: true,
+        properties: true,
        side_effects: true,
-        unsafe: true,
    }
    input: {
        a = 42;
@@ -746,8 +751,8 @@ issue_2208_3: {
 issue_2208_4: {
    options = {
        inline: true,
+        properties: true,
        side_effects: true,
-        unsafe: true,
    }
    input: {
        function foo() {}
@@ -770,8 +775,8 @@ issue_2208_4: {
 issue_2208_5: {
    options = {
        inline: true,
+        properties: true,
        side_effects: true,
-        unsafe: true,
    }
    input: {
        console.log({
@@ -804,3 +809,248 @@ issue_2256: {
        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",
+    ]
+}
--- a/test/compress/pure_getters.js
+++ b/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,
@@ -185,6 +189,7 @@ issue_2110_1: {
        pure_getters: "strict",
        sequences: true,
        side_effects: true,
+        reduce_funcs: true,
        reduce_vars: true,
        unused: true,
    }
@@ -215,6 +220,7 @@ issue_2110_2: {
    options = {
        collapse_vars: true,
        pure_getters: "strict",
+        reduce_funcs: true,
        reduce_vars: true,
        unused: true,
    }
@@ -247,6 +253,7 @@ set_immutable_1: {
        collapse_vars: true,
        evaluate: true,
        pure_getters: "strict",
+        reduce_funcs: true,
        reduce_vars: true,
        toplevel: true,
        unused: true,
@@ -270,6 +277,7 @@ set_immutable_2: {
        cascade: true,
        conditionals: true,
        pure_getters: "strict",
+        reduce_funcs: true,
        reduce_vars: true,
        sequences: true,
        side_effects: true,
@@ -293,6 +301,7 @@ set_immutable_3: {
        collapse_vars: true,
        evaluate: true,
        pure_getters: "strict",
+        reduce_funcs: true,
        reduce_vars: true,
        toplevel: true,
        unused: true,
@@ -318,6 +327,7 @@ set_immutable_4: {
        cascade: true,
        conditionals: true,
        pure_getters: "strict",
+        reduce_funcs: true,
        reduce_vars: true,
        sequences: true,
        side_effects: true,
@@ -343,6 +353,7 @@ set_mutable_1: {
        collapse_vars: true,
        evaluate: true,
        pure_getters: "strict",
+        reduce_funcs: true,
        reduce_vars: true,
        unused: true,
    }
@@ -367,6 +378,7 @@ set_mutable_2: {
        cascade: true,
        conditionals: true,
        pure_getters: "strict",
+        reduce_funcs: true,
        reduce_vars: true,
        sequences: true,
        side_effects: true,
--- a/test/compress/reduce_vars.js
+++ b/test/compress/reduce_vars.js
--- a/test/compress/rename.js
+++ b/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",
+    ]
+}
--- a/test/compress/screw-ie8.js
+++ b/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,
--- a/test/compress/switch.js
+++ b/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,
--- a/test/mocha/minify.js
+++ b/test/mocha/minify.js
@@ -297,4 +297,37 @@ describe("minify", function() {
            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()");
+        });
+    });
 });
--- a/test/run-tests.js
+++ b/test/run-tests.js
@@ -117,6 +117,10 @@ function run_compress_tests() {
                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);
--- a/test/ufuzz.js
+++ b/test/ufuzz.js
@@ -162,6 +162,7 @@ var VALUES = [
    '"object"',
    '"number"',
    '"function"',
+    'this',
 ];

 var BINARY_OPS_NO_COMMA = [
@@ -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(', ');
 }
@@ -390,9 +391,10 @@ 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 (noDecl) s = 'var ' + createVarName(MANDATORY) + ' = ' + s;
    // avoid "function statements" (decl inside statements)
-    else if (inGlobal || rng(10) > 0) s += 'var ' + createVarName(MANDATORY) + ' = ' + name + '(' + createArgs() + ');';
+    else if (inGlobal || rng(10) > 0) s += 'var ' + createVarName(MANDATORY) + ' = ' + name;
+    s += '(' + createArgs(recurmax, stmtDepth, canThrow) + ');';

    return s;
 }
@@ -626,6 +628,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++:
--- a/test/ufuzz.json
+++ b/test/ufuzz.json
@@ -16,11 +16,9 @@
    {},
    {
        "compress": {
-            "toplevel": true
+            "hoist_props": true
        },
-        "mangle": {
-            "toplevel": true
-        }
+        "toplevel": true
    },
    {
        "compress": {
Author	SHA1	Message	Date
Alex Lam S.L	b37a68c84f	v3.2.0	2017-11-26 04:08:35 +08:00
Alex Lam S.L	c141ae6f8d	fix argument/atom collision by `properties` (#2514 ) fixes #2513	2017-11-25 22:52:46 +08:00
Alex Lam S.L	97c464dbf5	fix wording and formatting (#2512 )	2017-11-25 19:07:46 +08:00
Alex Lam S.L	3b28b915eb	extend escape analysis on constant expression properties (#2509 ) fixes #2508	2017-11-24 14:07:39 +08:00
Alex Lam S.L	eb001dc1d9	fix argument/atom collision by `collapse_vars` (#2507 ) fixes #2506	2017-11-24 07:26:22 +08:00
Alex Lam S.L	aa9bdf416e	make `AST_Lambda.contains_this()` less magical (#2505 )	2017-11-24 07:03:37 +08:00
Alex Lam S.L	8987780db6	eliminate invalid state caching in `collapse_vars` (#2502 ) fixes #2497	2017-11-24 04:12:37 +08:00
Alex Lam S.L	30cfea2e7a	fix `rename` (#2501 ) - suppress spurious `rename` from `commander` - handle `AST_SymbolCatch` correctly	2017-11-24 03:05:43 +08:00
Alex Lam S.L	f4e2fb9864	expand symbol space to improve compression (#2460 ) - give globally distinct names to distinct variables - improve ability to compress cross-scoped - introduce `options.rename` to `minify()` - default `true` if both `compress` & `mangle`	2017-11-19 19:29:51 +08:00
Alex Lam S.L	b80062c490	enable `hoist_props` by default (#2492 )	2017-11-19 14:56:23 +08:00
Alex Lam S.L	667fc4d08b	v3.1.10	2017-11-18 23:56:33 +08:00
kzc	6142117cdd	document the `webkit` output option (#2490 ) - workaround for WebKit bugs - PhantomJS users should enable this output option closes #2489	2017-11-17 13:46:49 +08:00
Alex Lam S.L	ae28a24c7f	fix cross-scope inlining of `AST_Function`s (#2486 ) fixes #2485	2017-11-16 10:04:30 +08:00
Alex Lam S.L	ebe761cad0	minor consolidations (#2484 ) - unique symbol generation - `unsafe` on `AST_Call`	2017-11-16 04:37:37 +08:00
kzc	fa7a7c5c5a	Update ISSUE_TEMPLATE.md (#2481 )	2017-11-15 06:00:51 +08:00
kzc	557636f3b7	update documentation for `reduce_funcs` (#2478 )	2017-11-14 16:03:25 +08:00
Alex Lam S.L	49fbe9c5ac	fix replacement logic in `collapse_vars` (#2475 )	2017-11-13 07:37:42 +08:00
Alex Lam S.L	2ac5086831	fix `top_retain` on `hoist_props` (#2474 ) fixes #2473	2017-11-13 00:59:41 +08:00
Alex Lam S.L	c6cfa04d10	allow symbol replacement on multiple occurrences (#2472 ) - all-or-nothing replacement - avoid unmangleable names fixes #2436	2017-11-12 22:31:47 +08:00
Alex Lam S.L	346fa12e0e	v3.1.9	2017-11-11 15:31:13 +08:00
Alex Lam S.L	cda27b0970	extend `reduce_funcs` to cover cross-scope substitutions (#2469 ) fixes #2468	2017-11-11 15:30:17 +08:00
Alex Lam S.L	3c74047368	implement compress option `reduce_funcs` (#2466 ) - inline single-use function declarations as expressions when permissible - depend on `reduce_vars` - enabled by default - disable for speed critical code fixes #2464	2017-11-11 05:59:35 +08:00
Alex Lam S.L	94525d859f	fix object literal tracing in `reduce_vars` (#2461 )	2017-11-10 05:47:10 +08:00
Alex Lam S.L	1127a2caf3	fix multiple nested function substitutions (#2458 ) fixes #2449	2017-11-09 23:30:00 +08:00
Alex Lam S.L	246d9d4e83	remove hack in `collapse_vars` (#2457 ) fixes #2456	2017-11-09 20:00:58 +08:00
Alex Lam S.L	4c0b0177b6	preserve function identity in `reduce_vars` (#2451 ) fixes #2450	2017-11-08 03:28:46 +08:00
Alex Lam S.L	38bfb73f06	v3.1.8	2017-11-07 03:55:16 +08:00
Alex Lam S.L	bbedbf4ea0	handle circular `function` reference gracefully (#2446 ) fixes #2442	2017-11-07 02:37:23 +08:00
Alex Lam S.L	2cfb5aa7da	account for `eval` & `with` in `reduce_vars` (#2441 ) fixes #2440	2017-11-06 16:10:57 +08:00
Alex Lam S.L	6c45101870	consolidate & enhance `unused` (#2439 ) - defer declaration removal in `collapse_vars` - account for `AST_SymbolFunarg` in deduplication - private accounting for `collapse_vars` - avoid issues with identity reference due to deep cloning fixes #2437	2017-11-06 14:25:10 +08:00
Alex Lam S.L	2c2fd89e34	inline single-use functions that are not constant expressions (#2434 ) fixes #2428	2017-11-05 22:14:11 +08:00
Alex Lam S.L	f46281e2b7	v3.1.7	2017-11-05 15:03:19 +08:00
Alex Lam S.L	25a18883f5	tweak #2424 (#2432 )	2017-11-05 12:49:14 +08:00
Alex Lam S.L	5b4b07e9a7	extend function inlining safety checks (#2430 )	2017-11-05 06:18:45 +08:00
Alex Lam S.L	a8aa28a7a6	consolidate single-use `function` reduction (#2427 ) fixes #2423	2017-11-05 04:27:01 +08:00
Alex Lam S.L	fe5a68f9d5	maintain call argument order in `collapse_vars` (#2426 ) fixes #2425	2017-11-05 00:00:18 +08:00
Alex Lam S.L	71e61153b1	improve variations on call arguments for `ufuzz` (#2424 )	2017-11-04 16:29:42 +08:00
Alex Lam S.L	c8b6f4733d	reduce `this` within functions (#2421 ) - only replace same-scope usages - augment `test/ufuzz.js` to test for `this` fixes #2420	2017-11-04 00:31:37 +08:00
Alex Lam S.L	a48f87abf2	compress `new` `function` containing `this` (#2417 )	2017-10-30 23:19:27 +08:00
Alex Lam S.L	2fd927a7cc	v3.1.6	2017-10-29 12:38:10 +08:00
Alex Lam S.L	8428326ea1	enhance `properties` (#2412 ) - trim array items only if `side_effects` - extend to non-identifier properties	2017-10-29 04:11:26 +08:00
Alex Lam S.L	31f8209193	remove dead code (#2405 )	2017-10-27 14:28:09 +08:00
Alex Lam S.L	9b0f86f5a1	fix `reduce_vars` on `AST_Array.length` (#2404 )	2017-10-27 02:33:37 +08:00
Alex Lam S.L	ee082ace1b	compress self comparisons (#2398 )	2017-10-26 01:16:12 +08:00
kzc	ae67a49850	document compress option `hoist_props` (#2399 )	2017-10-25 14:03:43 +08:00
Alex Lam S.L	4178289c38	implement `hoist_props` (#2396 ) fixes #2377	2017-10-25 03:38:11 +08:00
Alex Lam S.L	74ae16f9f8	fix `unsafe` `reduce_vars` on arrays & objects (#2397 )	2017-10-24 22:10:36 +08:00
Tom MacWright	1968203d83	docs: Fix spelling and style (#2395 )	2017-10-24 04:59:12 +08:00
Alex Lam S.L	86ea38a259	enhance `unsafe` `evaluate` of arrays & objects (#2394 )	2017-10-24 02:58:30 +08:00
Alex Lam S.L	8a713e449f	deduplicate declarations regardless of `toplevel` (#2393 )	2017-10-23 01:00:50 +08:00
Alex Lam S.L	24aa07855b	safer `properties` transform (#2391 ) `{ a: x, b: y }.a` => `[ x, y ][0]` - `x` cannot be function containing `this` `[ x, y, z ][1]` => `(x, z, y)` - only if `z` is side-effect-free	2017-10-22 20:10:13 +08:00
Alex Lam S.L	5fd723f143	fix `unsafe` expansion of object literals (#2390 )	2017-10-22 15:00:36 +08:00
Alex Lam S.L	516eaef50c	fix `unsafe` evaluation of `AST_Sub` (#2389 )	2017-10-22 13:14:15 +08:00
Alex Lam S.L	4ae1fb3ed8	fix `unsafe` evaluation of objects (#2388 )	2017-10-22 04:19:40 +08:00
Alex Lam S.L	011123223b	fix `unsafe` escape analysis in `reduce_vars` (#2387 )	2017-10-22 03:23:31 +08:00
Alex Lam S.L	96439ca246	v3.1.5	2017-10-22 00:27:26 +08:00
Alex Lam S.L	c927cea632	`unsafe` fix-ups for #2351 (#2379 )	2017-10-21 04:08:26 +08:00
Alex Lam S.L	9f4b98f8e4	backport #2374 (#2376 )	2017-10-19 23:02:27 +08:00
Alex Lam S.L	0f2ef3367c	enhance `collapse_vars` around lazy operations (#2369 )	2017-10-19 04:52:00 +08:00
Alex Lam S.L	7e5b5cac97	fix `AST_PropAccess` in `collapse_vars` (take 3) (#2375 ) Suppress scanning beyond assignment to `a.b`	2017-10-18 02:54:51 +08:00
Alex Lam S.L	c1346e06b7	clean up lazy operator detection (#2373 )	2017-10-17 23:25:45 +08:00
Alex Lam S.L	0d2fe8e3ef	fix `AST_PropAccess` in `collapse_vars` (take 2) (#2372 ) fixes #2364	2017-10-17 22:59:15 +08:00
Alex Lam S.L	f2b9c11e2a	fix `AST_PropAccess` in `collapse_vars` (#2370 ) fixes #2364	2017-10-17 18:33:03 +08:00
Alex Lam S.L	fe647b083e	account for side-effects from `AST_This` in `collapse_vars` (#2365 )	2017-10-17 01:18:55 +08:00