fix collapse_vars regression in destructuring (#2897 )

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

-Copyright 2012-2013 (c) Mihai Bazon <mihai.bazon@gmail.com>
+Copyright 2012-2018 (c) Mihai Bazon <mihai.bazon@gmail.com>

 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions
--- a/README.md
+++ b/README.md
@@ -67,7 +67,7 @@ a double dash to prevent input files being used as option arguments:
                                `debug`  Add debug prefix and suffix.
                                `domprops`  Mangle property names that overlaps
                                            with DOM properties.
-                                `keep_quoted`  Only mangle unquoted properies.
+                                `keep_quoted`  Only mangle unquoted properties.
                                `regex`  Only mangle matched property names.
                                `reserved`  List of names that should not be mangled.
    -b, --beautify [options]    Beautify output/specify output options:
@@ -782,7 +782,7 @@ 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_Func` (default: `false`) -- compress and mangle `Function(args, code)`
+- `unsafe_Function` (default: `false`) -- compress and mangle `Function(args, code)`
  when both `args` and `code` are string literals.

 - `unsafe_math` (default: `false`) -- optimize numerical expressions like
@@ -801,6 +801,10 @@ 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.

+- `unsafe_undefined` (default: `false`) -- substitute `void 0` if there is a
+  variable named `undefined` in scope (variable name will be mangled, typically
+  reduced to a single character)
+
 - `unused` (default: `true`) -- drop unreferenced functions and variables (simple
  direct variable assignments do not count as references unless set to `"keep_assign"`)

@@ -993,9 +997,6 @@ when this flag is on:
 - `new Object()` → `{}`
 - `String(exp)` or `exp.toString()` → `"" + exp`
 - `new Object/RegExp/Function/Error/Array (...)` → we discard the `new`
- `void 0` → `undefined` (if there is a variable named "undefined" in
-  scope; we do it because the variable name will be mangled, typically
-  reduced to a single character)

 ### Conditional compilation

@@ -1172,3 +1173,27 @@ To enable fast minify mode with the API use:
 ```js
 UglifyJS.minify(code, { compress: false, mangle: true });
 ```
+
+#### Source maps and debugging
+
+Various `compress` transforms that simplify, rearrange, inline and remove code
+are known to have an adverse effect on debugging with source maps. This is
+expected as code is optimized and mappings are often simply not possible as
+some code no longer exists. For highest fidelity in source map debugging
+disable the Uglify `compress` option and just use `mangle`.
+
+### Compiler assumptions
+
+To allow for better optimizations, the compiler makes various assumptions:
+
+- `.toString()` and `.valueOf()` don't have side effects, and for built-in
+  objects they have not been overridden.
+- `undefined`, `NaN` and `Infinity` have not been externally redefined.
+- `arguments.callee`, `arguments.caller` and `Function.prototype.caller` are not used.
+- The code doesn't expect the contents of `Function.prototype.toString()` or
+  `Error.prototype.stack` to be anything in particular.
+- Getting and setting properties on a plain object does not cause other side effects
+  (using `.watch()` or `Proxy`).
+- Object properties can be added, removed and modified (not prevented with
+  `Object.defineProperty()`, `Object.defineProperties()`, `Object.freeze()`,
+  `Object.preventExtensions()` or `Object.seal()`).
--- a/bin/uglifyjs
+++ b/bin/uglifyjs
@@ -11,7 +11,7 @@ var path = require("path");
 var program = require("commander");
 var UglifyJS = require("../tools/node");

-var skip_keys = [ "cname", "enclosed", "inlined", "parent_scope", "scope", "thedef", "uses_eval", "uses_with" ];
+var skip_keys = [ "cname", "inlined", "parent_scope", "scope", "uses_eval", "uses_with" ];
 var files = {};
 var options = {
    compress: false,
@@ -45,6 +45,7 @@ program.option("--ie8", "Support non-standard Internet Explorer 8.");
 program.option("--keep-classnames", "Do not mangle/drop class names.");
 program.option("--keep-fnames", "Do not mangle/drop function names. Useful for code relying on Function.prototype.name.");
 program.option("--name-cache <file>", "File to hold mangled name mappings.");
+program.option("--rename", "Force symbol expansion.");
 program.option("--no-rename", "Disable symbol expansion.");
 program.option("--safari10", "Support non-standard Safari 10.");
 program.option("--self", "Build UglifyJS as a library (implies --wrap UglifyJS)");
@@ -65,14 +66,12 @@ if (!program.output && program.sourceMap && program.sourceMap.url != "inline") {
    "compress",
    "ie8",
    "mangle",
-    "rename",
    "safari10",
    "sourceMap",
    "toplevel",
    "wrap"
 ].forEach(function(name) {
    if (name in program) {
-        if (name == "rename" && program[name]) return;
        options[name] = program[name];
    }
 });
@@ -132,6 +131,11 @@ if (program.parse) {
        fatal("ERROR: inline source map only works with built-in parser");
    }
 }
+if (~program.rawArgs.indexOf("--rename")) {
+    options.rename = true;
+} else if (!program.rename) {
+    options.rename = false;
+}
 var convert_path = function(name) {
    return name;
 };
@@ -234,7 +238,20 @@ function run() {
        }
        fatal(ex);
    } else if (program.output == "ast") {
+        if (!options.compress && !options.mangle) {
+            result.ast.figure_out_scope({});
+        }
        print(JSON.stringify(result.ast, function(key, value) {
+            if (value) switch (key) {
+              case "thedef":
+                return symdef(value);
+              case "enclosed":
+                return value.length ? value.map(symdef) : undefined;
+              case "variables":
+              case "functions":
+              case "globals":
+                return value.size() ? value.map(symdef) : undefined;
+            }
            if (skip_key(key)) return;
            if (value instanceof UglifyJS.AST_Token) return;
            if (value instanceof UglifyJS.Dictionary) return;
@@ -242,6 +259,11 @@ function run() {
                var result = {
                    _class: "AST_" + value.TYPE
                };
+                if (value.block_scope) {
+                    result.variables = value.block_scope.variables;
+                    result.functions = value.block_scope.functions;
+                    result.enclosed = value.block_scope.enclosed;
+                }
                value.CTOR.PROPS.forEach(function(prop) {
                    result[prop] = value[prop];
                });
@@ -388,6 +410,12 @@ function skip_key(key) {
    return skip_keys.indexOf(key) >= 0;
 }

+function symdef(def) {
+    var ret = (1e6 + def.id) + " " + def.name;
+    if (def.mangled_name) ret += " " + def.mangled_name;
+    return ret;
+}
+
 function format_object(obj) {
    var lines = [];
    var padding = "";
--- a/lib/ast.js
+++ b/lib/ast.js
@@ -267,11 +267,10 @@ var AST_For = DEFNODE("For", "init condition step", {
    }
 }, AST_IterationStatement);

-var AST_ForIn = DEFNODE("ForIn", "init name object", {
+var AST_ForIn = DEFNODE("ForIn", "init object", {
    $documentation: "A `for ... in` statement",
    $propdoc: {
        init: "[AST_Node] the `for/in` initialization code",
-        name: "[AST_SymbolRef?] the loop variable, only if `init` is AST_Var",
        object: "[AST_Node] the object that we're looping through"
    },
    _walk: function(visitor) {
@@ -319,6 +318,13 @@ var AST_Scope = DEFNODE("Scope", "variables functions uses_with uses_eval parent
            self = self.parent_scope;
        }
        return self;
+    },
+    clone: function(deep) {
+        var node = this._clone(deep);
+        if (this.variables) node.variables = this.variables.clone();
+        if (this.functions) node.functions = this.functions.clone();
+        if (this.enclosed) node.enclosed = this.enclosed.slice();
+        return node;
    }
 }, AST_Block);

@@ -863,8 +869,8 @@ var AST_Object = DEFNODE("Object", "properties", {
 var AST_ObjectProperty = DEFNODE("ObjectProperty", "key value", {
    $documentation: "Base class for literal object properties",
    $propdoc: {
-        key: "[string|AST_Node] the property name converted to a string for ObjectKeyVal. For setters, getters and computed property this is an arbitrary AST_Node",
-        value: "[AST_Node] property value.  For setters and getters this is an AST_Accessor."
+        key: "[string|AST_Node] property name. For ObjectKeyVal this is a string. For getters, setters and computed property this is an AST_Node.",
+        value: "[AST_Node] property value.  For getters and setters this is an AST_Accessor."
    },
    _walk: function(visitor) {
        return visitor._visit(this, function(){
--- a/lib/compress.js
+++ b/lib/compress.js
--- a/lib/minify.js
+++ b/lib/minify.js
@@ -151,7 +151,9 @@ function minify(files, options) {
            toplevel = toplevel.wrap_commonjs(options.wrap);
        }
        if (timings) timings.rename = Date.now();
-        if (options.rename) {
+        // disable rename on harmony due to expand_names bug in for-of loops
+        // https://github.com/mishoo/UglifyJS2/issues/2794
+        if (0 && options.rename) {
            toplevel.figure_out_scope(options.mangle);
            toplevel.expand_names(options.mangle);
        }
--- a/lib/output.js
+++ b/lib/output.js
@@ -472,83 +472,87 @@ function OutputStream(options) {
        return OUTPUT;
    };

+    function has_nlb() {
+        var index = OUTPUT.lastIndexOf("\n");
+        return /^ *$/.test(OUTPUT.slice(index + 1));
+    }
+
    function prepend_comments(node) {
        var self = this;
        var start = node.start;
        if (!start) return;
-        if (!(start.comments_before && start.comments_before._dumped === self)) {
-            var comments = start.comments_before;
-            if (!comments) {
-                comments = start.comments_before = [];
-            }
-            comments._dumped = self;
+        if (start.comments_before && start.comments_before._dumped === self) return;
+        var comments = start.comments_before;
+        if (!comments) {
+            comments = start.comments_before = [];
+        }
+        comments._dumped = self;

-            if (node instanceof AST_Exit && node.value) {
-                var tw = new TreeWalker(function(node) {
-                    var parent = tw.parent();
-                    if (parent instanceof AST_Exit
-                        || parent instanceof AST_Binary && parent.left === node
-                        || parent.TYPE == "Call" && parent.expression === node
-                        || parent instanceof AST_Conditional && parent.condition === node
-                        || parent instanceof AST_Dot && parent.expression === node
-                        || parent instanceof AST_Sequence && parent.expressions[0] === node
-                        || parent instanceof AST_Sub && parent.expression === node
-                        || parent instanceof AST_UnaryPostfix) {
-                        if (!node.start) return;
-                        var text = node.start.comments_before;
-                        if (text && text._dumped !== self) {
-                            text._dumped = self;
-                            comments = comments.concat(text);
-                        }
-                    } else {
-                        return true;
+        if (node instanceof AST_Exit && node.value) {
+            var tw = new TreeWalker(function(node) {
+                var parent = tw.parent();
+                if (parent instanceof AST_Exit
+                    || parent instanceof AST_Binary && parent.left === node
+                    || parent.TYPE == "Call" && parent.expression === node
+                    || parent instanceof AST_Conditional && parent.condition === node
+                    || parent instanceof AST_Dot && parent.expression === node
+                    || parent instanceof AST_Sequence && parent.expressions[0] === node
+                    || parent instanceof AST_Sub && parent.expression === node
+                    || parent instanceof AST_UnaryPostfix) {
+                    if (!node.start) return;
+                    var text = node.start.comments_before;
+                    if (text && text._dumped !== self) {
+                        text._dumped = self;
+                        comments = comments.concat(text);
                    }
-                });
-                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;
+                } else {
+                    return true;
                }
            });
+            tw.push(node);
+            node.value.walk(tw);
+        }
+
+        if (current_pos == 0) {
+            if (comments.length > 0 && options.shebang && comments[0].type == "comment5") {
+                print("#!" + comments.shift().value + "\n");
+                indent();
+            }
+            var preamble = options.preamble;
+            if (preamble) {
+                print(preamble.replace(/\r\n?|[\n\u2028\u2029]|\s*$/g, "\n"));
+            }
+        }
+
+        comments = comments.filter(comment_filter, node);
+        if (comments.length == 0) return;
+        var last_nlb = has_nlb();
+        comments.forEach(function(c, i) {
            if (!last_nlb) {
-                if (start.nlb) {
+                if (c.nlb) {
                    print("\n");
                    indent();
-                } else {
+                    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();
+            }
        }
    }

@@ -557,35 +561,33 @@ function OutputStream(options) {
        var token = node.end;
        if (!token) return;
        var comments = token[tail ? "comments_before" : "comments_after"];
-        if (comments
-            && comments._dumped !== self
-            && (node instanceof AST_Statement || all(comments, function(c) {
-                return !/comment[134]/.test(c.type);
-            }))) {
-            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;
-        }
+        if (!comments || comments._dumped === self) return;
+        if (!(node instanceof AST_Statement || all(comments, function(c) {
+            return !/comment[134]/.test(c.type);
+        }))) return;
+        comments._dumped = self;
+        var insert = OUTPUT.length;
+        comments.filter(comment_filter, node).forEach(function(c, i) {
+            need_space = false;
+            if (need_newline_indented) {
+                print("\n");
+                indent();
+                need_newline_indented = false;
+            } else if (c.nlb && (i > 0 || !has_nlb())) {
+                print("\n");
+                indent();
+            } else if (i > 0 || !tail) {
+                space();
+            }
+            if (/comment[134]/.test(c.type)) {
+                print("//" + c.value.replace(/[@#]__PURE__/g, ' '));
+                need_newline_indented = true;
+            } else if (c.type == "comment2") {
+                print("/*" + c.value.replace(/[@#]__PURE__/g, ' ') + "*/");
+                need_space = true;
+            }
+        });
+        if (OUTPUT.length > insert) newline_insert = insert;
    }

    var stack = [];
@@ -769,6 +771,8 @@ function OutputStream(options) {
            || p instanceof AST_Arrow                         // x => (x, x)
            || p instanceof AST_DefaultAssign                 // x => (x = (0, function(){}))
            || p instanceof AST_Expansion                     // [...(a, b)]
+            || p instanceof AST_ForOf && this === p.object    // for (e of (foo, bar)) {}
+            || p instanceof AST_Yield                         // yield (foo, bar)
        ;
    });

@@ -1049,11 +1053,7 @@ function OutputStream(options) {
        output.with_parens(function(){
            self.init.print(output);
            output.space();
-            if (self instanceof AST_ForOf) {
-                output.print("of");
-            } else {
-                output.print("in");
-            }
+            output.print(self instanceof AST_ForOf ? "of" : "in");
            output.space();
            self.object.print(output);
        });
@@ -1683,11 +1683,8 @@ function OutputStream(options) {

    function print_property_name(key, quote, output) {
        if (output.option("quote_keys")) {
-            output.print_string(key + "");
-        } else if ((typeof key == "number"
-                    || !output.option("beautify")
-                    && +key + "" == key)
-                   && parseFloat(key) >= 0) {
+            output.print_string(key);
+        } else if ("" + +key == key && key >= 0) {
            output.print(make_num(key));
        } else if (RESERVED_WORDS(key) ? !output.option("ie8") : is_identifier_string(key)) {
            if (quote && output.option("keep_quoted_props")) {
--- a/lib/parse.js
+++ b/lib/parse.js
@@ -1276,12 +1276,10 @@ function parse($TEXT, options) {
    };

    function for_in(init) {
-        var lhs = init instanceof AST_Definitions ? init.definitions[0].name : null;
        var obj = expression(true);
        expect(")");
        return new AST_ForIn({
            init   : init,
-            name   : lhs,
            object : obj,
            body   : in_loop(statement)
        });
@@ -1862,7 +1860,7 @@ function parse($TEXT, options) {
                    name  : as_symbol(sym_type),
                    value : is("operator", "=")
                        ? (next(), expression(false, no_in))
-                        : !no_in && kind === "const" && S.input.has_directive("use strict")
+                        : !no_in && kind === "const"
                            ? croak("Missing initializer in const declaration") : null,
                    end   : prev()
                });
@@ -2226,7 +2224,7 @@ function parse($TEXT, options) {
            a.push(new AST_ObjectKeyVal({
                start: start,
                quote: start.quote,
-                key: name,
+                key: name instanceof AST_Node ? name : "" + name,
                value: value,
                end: prev()
            }));
@@ -2283,7 +2281,7 @@ function parse($TEXT, options) {
            if (typeof name === "string" || typeof name === "number") {
                return new AST_SymbolMethod({
                    start: token,
-                    name: name,
+                    name: "" + name,
                    end: prev()
                });
            } else if (name === null) {
--- a/lib/scope.js
+++ b/lib/scope.js
@@ -202,7 +202,7 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
            || node instanceof AST_SymbolConst) {
            var def;
            if (node instanceof AST_SymbolBlockDeclaration) {
-                def = scope.def_variable(node);
+                def = scope.def_variable(node, null);
            } else {
                def = defun.def_variable(node, node.TYPE == "SymbolVar" ? null : undefined);
            }
@@ -383,6 +383,11 @@ AST_Lambda.DEFMETHOD("init_scope_vars", function(){
    }));
 });

+AST_Arrow.DEFMETHOD("init_scope_vars", function(){
+    AST_Scope.prototype.init_scope_vars.apply(this, arguments);
+    this.uses_arguments = false;
+});
+
 AST_Symbol.DEFMETHOD("mark_enclosed", function(options) {
    var def = this.definition();
    var s = this.scope;
@@ -411,7 +416,7 @@ AST_Scope.DEFMETHOD("find_variable", function(name){

 AST_Scope.DEFMETHOD("def_function", function(symbol, init){
    var def = this.def_variable(symbol, init);
-    if (!def.init) def.init = init;
+    if (!def.init || def.init instanceof AST_Defun) def.init = init;
    this.functions.set(symbol.name, def);
    return def;
 });
@@ -550,24 +555,23 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options){
            node.variables.each(collect);
            return;
        }
+        if (node.is_block_scope()) {
+            node.block_scope.variables.each(collect);
+            return;
+        }
        if (node instanceof AST_Label) {
            var name;
            do name = base54(++lname); while (!is_identifier(name));
            node.mangled_name = name;
            return true;
        }
-        var mangle_with_block_scope =
-            (!options.ie8 && node instanceof AST_SymbolCatch) ||
-            node instanceof AST_SymbolBlockDeclaration;
-        if (mangle_with_block_scope && options.reserved.indexOf(node.name) < 0) {
+        if (!options.ie8 && node instanceof AST_SymbolCatch) {
            to_mangle.push(node.definition());
            return;
        }
    });
    this.walk(tw);
-    to_mangle.forEach(function(def){
-        def.mangle(options);
-    });
+    to_mangle.forEach(function(def){ def.mangle(options) });

    function collect(symbol) {
        if (!member(symbol.name, options.reserved)) {
@@ -576,59 +580,55 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options){
    }
 });

-AST_Toplevel.DEFMETHOD("find_unique_prefix", function(options) {
-    var letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_";
+AST_Toplevel.DEFMETHOD("find_colliding_names", function(options) {
    var cache = options.cache && options.cache.props;
-    var prefixes = Object.create(null);
-    options.reserved.forEach(add_prefix);
+    var avoid = Object.create(null);
+    options.reserved.forEach(to_avoid);
    this.globals.each(add_def);
    this.walk(new TreeWalker(function(node) {
        if (node instanceof AST_Scope) node.variables.each(add_def);
        if (node instanceof AST_SymbolCatch) add_def(node.definition());
    }));
-    var prefix, i = 0;
-    do {
-        prefix = create_name(i++);
-    } while (prefixes[prefix]);
-    return prefix;
+    return avoid;

-    function add_prefix(name) {
-        if (/[0-9]$/.test(name)) {
-            prefixes[name.replace(/[0-9]+$/, "")] = true;
-        }
+    function to_avoid(name) {
+        avoid[name] = true;
    }

    function add_def(def) {
        var name = def.name;
        if (def.global && cache && cache.has(name)) name = cache.get(name);
        else if (!def.unmangleable(options)) return;
-        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;
+        to_avoid(name);
    }
 });

 AST_Toplevel.DEFMETHOD("expand_names", function(options) {
+    base54.reset();
+    base54.sort();
    options = this._default_mangler_options(options);
-    var prefix = this.find_unique_prefix(options);
+    var avoid = this.find_colliding_names(options);
+    var cname = 0;
    this.globals.each(rename);
    this.walk(new TreeWalker(function(node) {
        if (node instanceof AST_Scope) node.variables.each(rename);
        if (node instanceof AST_SymbolCatch) rename(node.definition());
    }));

+    function next_name() {
+        var name;
+        do {
+            name = base54(cname++);
+        } while (avoid[name] || !is_identifier(name));
+        return name;
+    }
+
    function rename(def) {
-        if (def.global || def.unmangleable(options)) return;
+        if (def.global && options.cache) return;
+        if (def.unmangleable(options)) return;
        if (member(def.name, options.reserved)) return;
        var d = def.redefined();
-        def.name = d ? d.name : prefix + def.id;
+        def.name = d ? d.name : next_name();
        def.orig.forEach(function(sym) {
            sym.name = def.name;
        });
--- a/lib/utils.js
+++ b/lib/utils.js
@@ -303,6 +303,13 @@ Dictionary.prototype = {
            ret.push(f(this._values[i], i.substr(1)));
        return ret;
    },
+    clone: function() {
+        var ret = new Dictionary();
+        for (var i in this._values)
+            ret._values[i] = this._values[i];
+        ret._size = this._size;
+        return ret;
+    },
    toObject: function() { return this._values }
 };
 Dictionary.fromObject = function(obj) {
--- a/package.json
+++ b/package.json
@@ -4,17 +4,15 @@
  "homepage": "https://github.com/mishoo/UglifyJS2/tree/harmony",
  "author": "Mihai Bazon <mihai.bazon@gmail.com> (http://lisperator.net/)",
  "license": "BSD-2-Clause",
-  "version": "3.3.5",
+  "version": "3.3.10",
  "engines": {
    "node": ">=0.8.0"
  },
  "maintainers": [
+    "Alex Lam <alexlamsl@gmail.com>",
    "Mihai Bazon <mihai.bazon@gmail.com> (http://lisperator.net/)"
  ],
-  "repository": "git+https://github.com/mishoo/UglifyJS2.git#harmony",
-  "bugs": {
-    "url": "https://github.com/mishoo/UglifyJS2/issues"
-  },
+  "repository": "https://github.com/mishoo/UglifyJS2.git#harmony",
  "main": "tools/node.js",
  "bin": {
    "uglifyjs": "bin/uglifyjs"
@@ -26,13 +24,13 @@
    "LICENSE"
  ],
  "dependencies": {
-    "commander": "~2.12.1",
+    "commander": "~2.14.1",
    "source-map": "~0.6.1"
  },
  "devDependencies": {
-    "acorn": "~5.2.1",
+    "acorn": "~5.4.1",
    "mocha": "~3.5.1",
-    "semver": "~5.4.1"
+    "semver": "~5.5.0"
  },
  "scripts": {
    "test": "node test/run-tests.js"
--- a/test/compress/block-scope.js
+++ b/test/compress/block-scope.js
@@ -41,7 +41,7 @@ do_not_remove_anon_blocks_if_they_have_decls: {
                var x;
            }
            {
-                const y;
+                const y = 1;
                class Zee {};
            }
        }
@@ -59,7 +59,7 @@ do_not_remove_anon_blocks_if_they_have_decls: {
            }
            var x;
            {
-                const y;
+                const y = 1;
                class Zee {}
            }
        }
@@ -77,12 +77,12 @@ remove_unused_in_global_block: {
    input: {
        {
            let x;
-            const y;
+            const y = 1;
            class Zee {};
            var w;
        }
        let ex;
-        const why;
+        const why = 2;
        class Zed {};
        var wut;
        console.log(x, y, Zee);
@@ -90,7 +90,7 @@ remove_unused_in_global_block: {
    expect: {
        var w;
        let ex;
-        const why;
+        const why = 2;
        class Zed {};
        var wut;
        console.log(x, y, Zee);
--- a/test/compress/blocks.js
+++ b/test/compress/blocks.js
@@ -75,6 +75,7 @@ issue_1664: {
    }
    expect_stdout: "1"
    node_version: ">=6"
+    reminify: false // FIXME - block scoped function
 }

 issue_1672_for: {
--- a/test/compress/collapse_vars.js
+++ b/test/compress/collapse_vars.js
@@ -52,13 +52,8 @@ collapse_vars_side_effects_1: {
            console.log.bind(console)(s.charAt(i++), s.charAt(i++), s.charAt(i++), 7);
        }
        function f2() {
-            var log = console.log.bind(console),
-                s = "abcdef",
-                i = 2,
-                x = s.charAt(i++),
-                y = s.charAt(i++),
-                z = s.charAt(i++);
-            log(x, i, y, z, 7);
+            var s = "abcdef", i = 2;
+            console.log.bind(console)(s.charAt(i++), 5, s.charAt(i++), s.charAt(i++), 7);
        }
        function f3() {
            var s = "abcdef",
@@ -72,7 +67,7 @@ collapse_vars_side_effects_1: {
            var i = 10,
                x = i += 2,
                y = i += 3;
-            console.log.bind(console)(x, i += 4, y, i);
+            console.log.bind(console)(x, i += 4, y, 19);
        }
        f1(), f2(), f3(), f4();
    }
@@ -2296,6 +2291,7 @@ toplevel_single_reference: {
 unused_orig: {
    options = {
        collapse_vars: true,
+        dead_code: true,
        passes: 2,
        reduce_funcs: true,
        reduce_vars: true,
@@ -2323,7 +2319,7 @@ unused_orig: {
            var c = b;
            for (var d in c) {
                var a;
-                return --b + (a = c[0]);
+                return --b + c[0];
            }
            a && a.NaN;
        }([2]), a);
@@ -4313,3 +4309,513 @@ replace_all_var: {
    }
    expect_stdout: "PASS"
 }
+
+cascade_statement: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        function f1(a, b) {
+            var c;
+            if (a)
+                return c = b, c || a;
+            else
+                c = a, c(b);
+        }
+        function f2(a, b) {
+            var c;
+            while (a)
+                c = b, a = c + b;
+            do
+                throw c = a + b, c;
+            while (c);
+        }
+        function f3(a, b) {
+            for (; a < b; a++)
+                if (c = a, c && b)
+                    var c = (c = b(a), c);
+        }
+    }
+    expect: {
+        function f1(a, b) {
+            var c;
+            if (a)
+                return (c = b) || a;
+            else
+                (c = a)(b);
+        }
+        function f2(a, b) {
+            var c;
+            while (a)
+                a = (c = b) + b;
+            do
+                throw c = a + b;
+            while (c);
+        }
+        function f3(a, b) {
+            for (; a < b; a++)
+                if ((c = a) && b)
+                    var c = c = b(a);
+        }
+    }
+}
+
+cascade_forin: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var a;
+        function f(b) {
+            return [ b, b, b ];
+        }
+        for (var c in a = console, f(a))
+            console.log(c);
+    }
+    expect: {
+        var a;
+        function f(b) {
+            return [ b, b, b ];
+        }
+        for (var c in f(a = console))
+            console.log(c);
+    }
+    expect_stdout: [
+        "0",
+        "1",
+        "2",
+    ]
+}
+
+unsafe_builtin: {
+    options = {
+        collapse_vars: true,
+        pure_getters: "strict",
+        unsafe: true,
+        unused: true,
+    }
+    input: {
+        function f(a) {
+            var b = Math.abs(a);
+            return Math.pow(b, 2);
+        }
+        console.log(f(-1), f(2));
+    }
+    expect: {
+        function f(a) {
+            return Math.pow(Math.abs(a), 2);
+        }
+        console.log(f(-1), f(2));
+    }
+    expect_stdout: "1 4"
+}
+
+return_1: {
+    options = {
+        collapse_vars: true,
+        unused: true,
+    }
+    input: {
+        var log = console.log;
+        function f(b, c) {
+            var a = c;
+            if (b) return b;
+            log(a);
+        }
+        f(false, 1);
+        f(true, 2);
+    }
+    expect: {
+        var log = console.log;
+        function f(b, c) {
+            if (b) return b;
+            log(c);
+        }
+        f(false, 1);
+        f(true, 2);
+    }
+    expect_stdout: "1"
+}
+
+return_2: {
+    options = {
+        collapse_vars: true,
+        unused: true,
+    }
+    input: {
+        var log = console.log;
+        function f(b, c) {
+            var a = c();
+            if (b) return b;
+            log(a);
+        }
+        f(false, function() { return 1 });
+        f(true, function() { return 2 });
+    }
+    expect: {
+        var log = console.log;
+        function f(b, c) {
+            var a = c();
+            if (b) return b;
+            log(a);
+        }
+        f(false, function() { return 1 });
+        f(true, function() { return 2 });
+    }
+    expect_stdout: "1"
+}
+
+return_3: {
+    options = {
+        collapse_vars: true,
+        unused: true,
+    }
+    input: {
+        var log = console.log;
+        function f(b, c) {
+            var a = b <<= c;
+            if (b) return b;
+            log(a);
+        }
+        f(false, 1);
+        f(true, 2);
+    }
+    expect: {
+        var log = console.log;
+        function f(b, c) {
+            var a = b <<= c;
+            if (b) return b;
+            log(a);
+        }
+        f(false, 1);
+        f(true, 2);
+    }
+    expect_stdout: "0"
+}
+
+return_4: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var a = "FAIL";
+        (function(b) {
+            a = "PASS";
+            return;
+            b(a);
+        })();
+        console.log(a);
+    }
+    expect: {
+        var a = "FAIL";
+        (function(b) {
+            a = "PASS";
+            return;
+            b(a);
+        })();
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_2858: {
+    options = {
+        collapse_vars: true,
+        unused: true,
+    }
+    input: {
+        var b;
+        (function() {
+            function f() {
+                a++;
+            }
+            f();
+            var c = f();
+            var a = void 0;
+            c || (b = a);
+        })();
+        console.log(b);
+    }
+    expect: {
+        var b;
+        (function() {
+            function f() {
+                a++;
+            }
+            f();
+            var c = f();
+            var a = void 0;
+            c || (b = a);
+        })();
+        console.log(b);
+    }
+    expect_stdout: "undefined"
+}
+
+cond_branch_1: {
+    options = {
+        collapse_vars: true,
+        sequences: true,
+        unused: true,
+    }
+    input: {
+        function f1(b, c) {
+            var log = console.log;
+            var a = ++c;
+            if (b) b++;
+            log(a, b);
+        }
+        function f2(b, c) {
+            var log = console.log;
+            var a = ++c;
+            b && b++;
+            log(a, b);
+        }
+        function f3(b, c) {
+            var log = console.log;
+            var a = ++c;
+            b ? b++ : b--;
+            log(a, b);
+        }
+        f1(1, 2);
+        f2(3, 4);
+        f3(5, 6);
+    }
+    expect: {
+        function f1(b, c) {
+            if (b) b++;
+            (0, console.log)(++c, b);
+        }
+        function f2(b, c) {
+            b && b++,
+            (0, console.log)(++c, b);
+        }
+        function f3(b, c) {
+            b ? b++ : b--,
+            (0, console.log)(++c, b);
+        }
+        f1(1, 2),
+        f2(3, 4),
+        f3(5, 6);
+    }
+    expect_stdout: [
+        "3 2",
+        "5 4",
+        "7 6",
+    ]
+}
+
+cond_branch_2: {
+    options = {
+        collapse_vars: true,
+        sequences: true,
+        unused: true,
+    }
+    input: {
+        function f1(b, c) {
+            var log = console.log;
+            var a = ++c;
+            if (b) b += a;
+            log(a, b);
+        }
+        function f2(b, c) {
+            var log = console.log;
+            var a = ++c;
+            b && (b += a);
+            log(a, b);
+        }
+        function f3(b, c) {
+            var log = console.log;
+            var a = ++c;
+            b ? b += a : b--;
+            log(a, b);
+        }
+        f1(1, 2);
+        f2(3, 4);
+        f3(5, 6);
+    }
+    expect: {
+        function f1(b, c) {
+            var a = ++c;
+            if (b) b += a;
+            (0, console.log)(a, b);
+        }
+        function f2(b, c) {
+            var a = ++c;
+            b && (b += a),
+            (0, console.log)(a, b);
+        }
+        function f3(b, c) {
+            var a = ++c;
+            b ? b += a : b--,
+            (0, console.log)(a, b);
+        }
+        f1(1, 2),
+        f2(3, 4),
+        f3(5, 6);
+    }
+    expect_stdout: [
+        "3 4",
+        "5 8",
+        "7 12",
+    ]
+}
+
+cond_branch_switch: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var c = 0;
+        if (c = 1 + c, 0) switch (c = 1 + c) {
+        }
+        console.log(c);
+    }
+    expect: {
+        var c = 0;
+        if (c = 1 + c, 0) switch (c = 1 + c) {
+        }
+        console.log(c);
+    }
+    expect_stdout: "1"
+}
+
+issue_2873_1: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var b = 1, c = 0;
+        do {
+            c++;
+            if (!--b) break;
+            c = 1 + c;
+        } while (0);
+        console.log(b, c);
+    }
+    expect: {
+        var b = 1, c = 0;
+        do {
+            c++;
+            if (!--b) break;
+            c = 1 + c;
+        } while (0);
+        console.log(b, c);
+    }
+    expect_stdout: "0 1"
+}
+
+issue_2873_2: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var b = 1, c = 0;
+        do {
+            c++;
+            if (!--b) continue;
+            c = 1 + c;
+        } while (0);
+        console.log(b, c);
+    }
+    expect: {
+        var b = 1, c = 0;
+        do {
+            c++;
+            if (!--b) continue;
+            c = 1 + c;
+        } while (0);
+        console.log(b, c);
+    }
+    expect_stdout: "0 1"
+}
+
+issue_2878: {
+    options = {
+        collapse_vars: true,
+        sequences: true,
+    }
+    input: {
+        var c = 0;
+        (function (a, b) {
+            function f2() {
+                if (a) c++;
+            }
+            b = f2();
+            a = 1;
+            b && b.b;
+            f2();
+        })();
+        console.log(c);
+    }
+    expect: {
+        var c = 0;
+        (function (a, b) {
+            function f2() {
+                if (a) c++;
+            }
+            b = f2(),
+            a = 1,
+            b && b.b,
+            f2();
+        })(),
+        console.log(c);
+    }
+    expect_stdout: "1"
+}
+
+issue_2891_1: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var a = "PASS", b;
+        try {
+            b = c.p = 0;
+            a = "FAIL";
+            b();
+        } catch (e) {
+        }
+        console.log(a);
+    }
+    expect: {
+        var a = "PASS", b;
+        try {
+            b = c.p = 0;
+            a = "FAIL";
+            b();
+        } catch (e) {
+        }
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_2891_2: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        "use strict";
+        var a = "PASS", b;
+        try {
+            b = c = 0;
+            a = "FAIL";
+            b();
+        } catch (e) {
+        }
+        console.log(a);
+    }
+    expect: {
+        "use strict";
+        var a = "PASS", b;
+        try {
+            b = c = 0;
+            a = "FAIL";
+            b();
+        } catch (e) {
+        }
+        console.log(a);
+    }
+    expect_stdout: true
+}
--- a/test/compress/comparing.js
+++ b/test/compress/comparing.js
@@ -112,3 +112,206 @@ self_comparison_2: {
    }
    expect_stdout: "false true"
 }
+
+issue_2857_1: {
+    options = {
+        comparisons: true,
+    }
+    input: {
+        function f1(a) {
+            a === undefined || a === null;
+            a === undefined || a !== null;
+            a !== undefined || a === null;
+            a !== undefined || a !== null;
+            a === undefined && a === null;
+            a === undefined && a !== null;
+            a !== undefined && a === null;
+            a !== undefined && a !== null;
+        }
+        function f2(a) {
+            a === null || a === undefined;
+            a === null || a !== undefined;
+            a !== null || a === undefined;
+            a !== null || a !== undefined;
+            a === null && a === undefined;
+            a === null && a !== undefined;
+            a !== null && a === undefined;
+            a !== null && a !== undefined;
+        }
+    }
+    expect: {
+        function f1(a) {
+            null == a;
+            void 0 === a || null !== a;
+            void 0 !== a || null === a;
+            void 0 !== a || null !== a;
+            void 0 === a && null === a;
+            void 0 === a && null !== a;
+            void 0 !== a && null === a;
+            null != a;
+        }
+        function f2(a) {
+            null == a;
+            null === a || void 0 !== a;
+            null !== a || void 0 === a;
+            null !== a || void 0 !== a;
+            null === a && void 0 === a;
+            null === a && void 0 !== a;
+            null !== a && void 0 === a;
+            null != a;
+        }
+    }
+}
+
+issue_2857_2: {
+    options = {
+        comparisons: true,
+    }
+    input: {
+        function f(a, p) {
+            a === undefined || a === null || p;
+            a === undefined || a !== null || p;
+            a !== undefined || a === null || p;
+            a !== undefined || a !== null || p;
+            a === undefined && a === null || p;
+            a === undefined && a !== null || p;
+            a !== undefined && a === null || p;
+            a !== undefined && a !== null || p;
+        }
+    }
+    expect: {
+        function f(a, p) {
+            null == a || p;
+            void 0 === a || null !== a || p;
+            void 0 !== a || null === a || p;
+            void 0 !== a || null !== a || p;
+            void 0 === a && null === a || p;
+            void 0 === a && null !== a || p;
+            void 0 !== a && null === a || p;
+            null != a || p;
+        }
+    }
+}
+
+issue_2857_3: {
+    options = {
+        comparisons: true,
+    }
+    input: {
+        function f(a, p) {
+            a === undefined || a === null && p;
+            a === undefined || a !== null && p;
+            a !== undefined || a === null && p;
+            a !== undefined || a !== null && p;
+            a === undefined && a === null && p;
+            a === undefined && a !== null && p;
+            a !== undefined && a === null && p;
+            a !== undefined && a !== null && p;
+        }
+    }
+    expect: {
+        function f(a, p) {
+            void 0 === a || null === a && p;
+            void 0 === a || null !== a && p;
+            void 0 !== a || null === a && p;
+            void 0 !== a || null !== a && p;
+            void 0 === a && null === a && p;
+            void 0 === a && null !== a && p;
+            void 0 !== a && null === a && p;
+            null != a && p;
+        }
+    }
+}
+
+issue_2857_4: {
+    options = {
+        comparisons: true,
+    }
+    input: {
+        function f(a, p) {
+            p || a === undefined || a === null;
+            p || a === undefined || a !== null;
+            p || a !== undefined || a === null;
+            p || a !== undefined || a !== null;
+            p || a === undefined && a === null;
+            p || a === undefined && a !== null;
+            p || a !== undefined && a === null;
+            p || a !== undefined && a !== null;
+        }
+    }
+    expect: {
+        function f(a, p) {
+            p || null == a;
+            p || void 0 === a || null !== a;
+            p || void 0 !== a || null === a;
+            p || void 0 !== a || null !== a;
+            p || void 0 === a && null === a;
+            p || void 0 === a && null !== a;
+            p || void 0 !== a && null === a;
+            p || null != a;
+        }
+    }
+}
+
+issue_2857_5: {
+    options = {
+        comparisons: true,
+    }
+    input: {
+        function f(a, p) {
+            p && a === undefined || a === null;
+            p && a === undefined || a !== null;
+            p && a !== undefined || a === null;
+            p && a !== undefined || a !== null;
+            p && a === undefined && a === null;
+            p && a === undefined && a !== null;
+            p && a !== undefined && a === null;
+            p && a !== undefined && a !== null;
+        }
+    }
+    expect: {
+        function f(a, p) {
+            p && void 0 === a || null === a;
+            p && void 0 === a || null !== a;
+            p && void 0 !== a || null === a;
+            p && void 0 !== a || null !== a;
+            p && void 0 === a && null === a;
+            p && void 0 === a && null !== a;
+            p && void 0 !== a && null === a;
+            p && null != a;
+        }
+    }
+}
+
+issue_2857_6: {
+    options = {
+        comparisons: true,
+        pure_getters: "strict",
+        reduce_vars: true,
+    }
+    input: {
+        function f(a) {
+            if (({}).b === undefined || {}.b === null)
+                return a.b !== undefined && a.b !== null;
+        }
+        console.log(f({
+            a: [ null ],
+            get b() {
+                return this.a.shift();
+            }
+        }));
+    }
+    expect: {
+        function f(a) {
+            if (null == {}.b)
+                return void 0 !== a.b && null !== a.b;
+        }
+        console.log(f({
+            a: [ null ],
+            get b() {
+                return this.a.shift();
+            }
+        }));
+    }
+    expect_stdout: "true"
+}
--- a/test/compress/conditionals.js
+++ b/test/compress/conditionals.js
@@ -1224,3 +1224,46 @@ hoist_decl: {
        x() ? y() : z();
    }
 }
+
+to_and_or: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        var values = [
+            0,
+            null,
+            true,
+            "foo",
+            false,
+            -1 / 0,
+            void 0,
+        ];
+        values.forEach(function(x) {
+            values.forEach(function(y) {
+                values.forEach(function(z) {
+                    console.log(x ? y || z : z);
+                });
+            });
+        });
+    }
+    expect: {
+        var values = [
+            0,
+            null,
+            true,
+            "foo",
+            false,
+            -1 / 0,
+            void 0,
+        ];
+        values.forEach(function(x) {
+            values.forEach(function(y) {
+                values.forEach(function(z) {
+                    console.log(x && y || z);
+                });
+            });
+        });
+    }
+    expect_stdout: true
+}
--- a/test/compress/dead-code.js
+++ b/test/compress/dead-code.js
@@ -60,6 +60,7 @@ dead_code_2_should_warn: {
    }
    expect_stdout: true
    node_version: ">=6"
+    reminify: false // FIXME - block scoped function
 }

 dead_code_2_should_warn_strict: {
@@ -100,6 +101,7 @@ dead_code_2_should_warn_strict: {
    }
    expect_stdout: true
    node_version: ">=4"
+    reminify: false // FIXME - block scoped function
 }

 dead_code_constant_boolean_should_warn_more: {
@@ -135,6 +137,7 @@ dead_code_constant_boolean_should_warn_more: {
    }
    expect_stdout: true
    node_version: ">=6"
+    reminify: false // FIXME - block scoped function
 }

 dead_code_constant_boolean_should_warn_more_strict: {
@@ -171,6 +174,7 @@ dead_code_constant_boolean_should_warn_more_strict: {
    }
    expect_stdout: true
    node_version: ">=4"
+    reminify: false // FIXME - block scoped function
 }

 dead_code_block_decls_die: {
@@ -1128,3 +1132,87 @@ issue_2701: {
    }
    expect_stdout: "function"
 }
+
+issue_2749: {
+    options = {
+        dead_code: true,
+        inline: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = 2, c = "PASS";
+        while (a--)
+            (function() {
+                return b ? c = "FAIL" : b = 1;
+                try {
+                } catch (b) {
+                    var b;
+                }
+            })();
+        console.log(c);
+    }
+    expect: {
+        var a = 2, c = "PASS";
+        while (a--)
+            b = void 0, b ? c = "FAIL" : b = 1;
+        var b;
+        console.log(c);
+    }
+    expect_stdout: "PASS"
+}
+
+unsafe_builtin: {
+    options = {
+        side_effects: true,
+        unsafe: true,
+    }
+    input: {
+        (!w).constructor(x);
+        Math.abs(y);
+        [ 1, 2, z ].valueOf();
+    }
+    expect: {
+        w, x;
+        y;
+        z;
+    }
+}
+
+issue_2860_1: {
+    options = {
+        dead_code: true,
+        evaluate: true,
+        reduce_vars: true,
+    }
+    input: {
+        console.log(function(a) {
+            return a ^= 1;
+        }());
+    }
+    expect: {
+        console.log(function(a) {
+            return 1 ^ a;
+        }());
+    }
+    expect_stdout: "1"
+}
+
+issue_2860_2: {
+    options = {
+        dead_code: true,
+        evaluate: true,
+        inline: true,
+        passes: 2,
+        reduce_vars: true,
+    }
+    input: {
+        console.log(function(a) {
+            return a ^= 1;
+        }());
+    }
+    expect: {
+        console.log(1);
+    }
+    expect_stdout: "1"
+}
--- a/test/compress/destructuring.js
+++ b/test/compress/destructuring.js
@@ -439,6 +439,39 @@ mangle_destructuring_decl: {
    node_version: ">=6"
 }

+mangle_destructuring_decl_collapse_vars: {
+    options = {
+        collapse_vars: true,
+        evaluate: true,
+        unused: true,
+    }
+    mangle = {
+    }
+    input: {
+        function test(opts) {
+            let a = opts.a || { e: 7, n: 8 };
+            let { t, e, n, s =  5 + 4, o, r } = a;
+            console.log(t, e, n, s, o, r);
+        }
+        test({a: { t: 1, e: 2, n: 3, s: 4, o: 5, r: 6 }});
+        test({});
+    }
+    expect: {
+        function test(t) {
+            let e = t.a || { e: 7, n: 8 };
+            let {t: n,  e: o,  n: s,  s: l = 9,  o: a,  r: c} = e;
+            console.log(n, o, s, l, a, c);
+        }
+        test({ a: { t: 1, e: 2, n: 3, s: 4, o: 5, r: 6 } });
+        test({});
+    }
+    expect_stdout: [
+        "1 2 3 4 5 6",
+        "undefined 7 8 9 undefined undefined",
+    ]
+    node_version: ">=6"
+}
+
 mangle_destructuring_assign_toplevel_true: {
    options = {
        toplevel: true,
--- a/test/compress/drop-unused.js
+++ b/test/compress/drop-unused.js
@@ -215,7 +215,7 @@ unused_block_decls: {
    input: {
        function foo() {
            {
-                const x;
+                const x = 1;
            }
            {
                let y;
@@ -2018,3 +2018,78 @@ cascade_drop_assign: {
    }
    expect_stdout: "PASS"
 }
+
+chained_3: {
+    options = {
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        console.log(function(a, b) {
+            var c = a, c = b;
+            b++;
+            return c;
+        }(1, 2));
+    }
+    expect: {
+        console.log(function(a, b) {
+            var c = b;
+            b++;
+            return c;
+        }(0, 2));
+    }
+    expect_stdout: "2"
+}
+
+issue_2768: {
+    options = {
+        inline: true,
+        reduce_vars: true,
+        sequences: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = "FAIL", c = 1;
+        var c = function(b) {
+            var d = b = a;
+            var e = --b + (d && (a = "PASS"));
+        }();
+        console.log(a, typeof c);
+    }
+    expect: {
+        var a = "FAIL";
+        var c = (d = a, 0, void (d && (a = "PASS")));
+        var d;
+        console.log(a, typeof c);
+    }
+    expect_stdout: "PASS undefined"
+}
+
+issue_2846: {
+    options = {
+        collapse_vars: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f(a, b) {
+            var a = 0;
+            b && b(a);
+            return a++;
+        }
+        var c = f();
+        console.log(c);
+    }
+    expect: {
+        var c = function(a, b) {
+            a = 0;
+            b && b(a);
+            return a++;
+        }();
+        console.log(c);
+    }
+    expect_stdout: "0"
+}
--- a/test/compress/evaluate.js
+++ b/test/compress/evaluate.js
@@ -1287,6 +1287,9 @@ issue_2231_1: {
        console.log(Object.keys(void 0));
    }
    expect_stdout: true
+    expect_warnings: [
+        "WARN: Error evaluating Object.keys(void 0) [test/compress/evaluate.js:1284,20]",
+    ]
 }

 issue_2231_2: {
@@ -1301,6 +1304,23 @@ issue_2231_2: {
        console.log(Object.getOwnPropertyNames(null));
    }
    expect_stdout: true
+    expect_warnings: [
+        "WARN: Error evaluating Object.getOwnPropertyNames(null) [test/compress/evaluate.js:1301,20]",
+    ]
+}
+
+issue_2231_3: {
+    options = {
+        evaluate: true,
+        unsafe: true,
+    }
+    input: {
+        console.log(Object.keys({ foo: "bar" })[0]);
+    }
+    expect: {
+        console.log("foo");
+    }
+    expect_stdout: "foo"
 }

 self_comparison_1: {
@@ -1423,13 +1443,82 @@ issue_2535_3: {
    }
    expect_stdout: true
    expect_warnings: [
-        "WARN: Dropping side-effect-free && [test/compress/evaluate.js:1409,20]",
-        "WARN: Dropping side-effect-free && [test/compress/evaluate.js:1410,20]",
-        "WARN: Dropping side-effect-free && [test/compress/evaluate.js:1411,20]",
-        "WARN: Condition left of && always false [test/compress/evaluate.js:1411,20]",
-        "WARN: Dropping side-effect-free || [test/compress/evaluate.js:1412,20]",
-        "WARN: Dropping side-effect-free || [test/compress/evaluate.js:1413,20]",
-        "WARN: Dropping side-effect-free || [test/compress/evaluate.js:1414,20]",
-        "WARN: Condition left of || always true [test/compress/evaluate.js:1414,20]",
+        "WARN: Dropping side-effect-free && [test/compress/evaluate.js:1429,20]",
+        "WARN: Dropping side-effect-free && [test/compress/evaluate.js:1430,20]",
+        "WARN: Dropping side-effect-free && [test/compress/evaluate.js:1431,20]",
+        "WARN: Condition left of && always false [test/compress/evaluate.js:1431,20]",
+        "WARN: Dropping side-effect-free || [test/compress/evaluate.js:1432,20]",
+        "WARN: Dropping side-effect-free || [test/compress/evaluate.js:1433,20]",
+        "WARN: Dropping side-effect-free || [test/compress/evaluate.js:1434,20]",
+        "WARN: Condition left of || always true [test/compress/evaluate.js:1434,20]",
+    ]
+}
+
+issue_2822: {
+    options = {
+        evaluate: true,
+        unsafe: true,
+    }
+    input: {
+        console.log([ function() {}, "PASS", "FAIL" ][1]);
+    }
+    expect: {
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+string_case: {
+    options = {
+        evaluate: true,
+        unsafe: true,
+    }
+    input: {
+        console.log("İ".toLowerCase().charCodeAt(0));
+        console.log("I".toLowerCase().charCodeAt(0));
+        console.log("Ş".toLowerCase().charCodeAt(0));
+        console.log("Ğ".toLowerCase().charCodeAt(0));
+        console.log("Ü".toLowerCase().charCodeAt(0));
+        console.log("Ö".toLowerCase().charCodeAt(0));
+        console.log("Ç".toLowerCase().charCodeAt(0));
+        console.log("i".toUpperCase().charCodeAt(0));
+        console.log("ı".toUpperCase().charCodeAt(0));
+        console.log("ş".toUpperCase().charCodeAt(0));
+        console.log("ğ".toUpperCase().charCodeAt(0));
+        console.log("ü".toUpperCase().charCodeAt(0));
+        console.log("ö".toUpperCase().charCodeAt(0));
+        console.log("ç".toUpperCase().charCodeAt(0));
+    }
+    expect: {
+        console.log(105);
+        console.log(105);
+        console.log(351);
+        console.log(287);
+        console.log(252);
+        console.log(246);
+        console.log(231);
+        console.log(73);
+        console.log(73);
+        console.log(350);
+        console.log(286);
+        console.log(220);
+        console.log(214);
+        console.log(199);
+    }
+    expect_stdout: [
+        "105",
+        "105",
+        "351",
+        "287",
+        "252",
+        "246",
+        "231",
+        "73",
+        "73",
+        "350",
+        "286",
+        "220",
+        "214",
+        "199",
    ]
 }
--- a/test/compress/functions.js
+++ b/test/compress/functions.js
@@ -258,7 +258,7 @@ issue_203: {
    options = {
        keep_fargs: false,
        side_effects: true,
-        unsafe_Func: true,
+        unsafe_Function: true,
        unused: true,
    }
    input: {
@@ -1516,9 +1516,11 @@ issue_2647_2: {
    }
    expect: {
        (function() {
-            console.log((() => (x = "pass", x.toUpperCase()))());
-            var x;
-        })();
+            function foo(x) {
+                return x.toUpperCase();
+            }
+            console.log((() => foo("pass"))());
+        }());
    }
    expect_stdout: "PASS"
    node_version: ">=4"
@@ -2117,3 +2119,41 @@ issue_2737_2: {
    }
    expect_stdout: "PASS"
 }
+
+issue_2783: {
+    options = {
+        collapse_vars: true,
+        conditionals: true,
+        if_return: true,
+        inline: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        (function() {
+            return g;
+            function f(a) {
+                var b = a.b;
+                if (b) return b;
+                return a;
+            }
+            function g(o, i) {
+                while (i--) {
+                    console.log(f(o));
+                }
+            }
+        })()({ b: "PASS" }, 1);
+    }
+    expect: {
+        (function() {
+            return function(o,i) {
+                while (i--) console.log(f(o));
+            };
+            function f(a) {
+                var b = a.b;
+                return b || a;
+            }
+        })()({ b: "PASS" },1);
+    }
+    expect_stdout: "PASS"
+}
--- a/test/compress/harmony.js
+++ b/test/compress/harmony.js
@@ -1212,3 +1212,392 @@ issue_2676: {
        (class {}).a = 42;
    }
 }
+
+issue_2762: {
+    mangle = {}
+    input: {
+        var bar = 1, T = true;
+        (function() {
+            if (T) {
+                const a = function() {
+                    var foo = bar;
+                    console.log(foo, a.prop, b.prop);
+                };
+                a.prop = 2;
+                const b = { prop: 3 };
+                a();
+            }
+        })();
+    }
+    expect: {
+        var bar = 1, T = true;
+        (function() {
+            if (T) {
+                const o = function() {
+                    var p = bar;
+                    console.log(p, o.prop, r.prop);
+                };
+                o.prop = 2;
+                const r = { prop: 3 };
+                o();
+            }
+        })();
+    }
+    expect_stdout: "1 2 3"
+}
+
+issue_2794_1: {
+    options = {
+        collapse_vars: true,
+        evaluate: true,
+        inline: true,
+        passes: 1,
+        properties: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: false,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        function foo() {
+            for (const a of func(value)) {
+                console.log(a);
+            }
+            function func(va) {
+                return doSomething(va);
+            }
+        }
+        function doSomething(x) {
+            return [ x, 2 * x, 3 * x ];
+        }
+        const value = 10;
+        foo();
+    }
+    expect: {
+        function foo() {
+            for (const a of doSomething(value)) console.log(a);
+        }
+        function doSomething(x) {
+            return [ x, 2 * x, 3 * x ];
+        }
+        const value = 10;
+        foo();
+    }
+    expect_stdout: [
+        "10",
+        "20",
+        "30",
+    ]
+    node_version: ">=6"
+}
+
+issue_2794_2: {
+    mangle = {
+        toplevel: false,
+    }
+    options = {
+        collapse_vars: true,
+        evaluate: true,
+        inline: true,
+        passes: 1,
+        properties: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: false,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        function foo() {
+            for (const a of func(value)) {
+                console.log(a);
+            }
+            function func(va) {
+                return doSomething(va);
+            }
+        }
+        function doSomething(x) {
+            return [ x, 2 * x, 3 * x ];
+        }
+        const value = 10;
+        foo();
+    }
+    expect: {
+        function foo() {
+            for (const o of doSomething(value)) console.log(o);
+        }
+        function doSomething(o) {
+            return [ o, 2 * o, 3 * o ];
+        }
+        const value = 10;
+        foo();
+    }
+    expect_stdout: [
+        "10",
+        "20",
+        "30",
+    ]
+    node_version: ">=6"
+}
+
+issue_2794_3: {
+    mangle = {
+        toplevel: true,
+    }
+    options = {
+        collapse_vars: true,
+        evaluate: true,
+        inline: 3,
+        passes: 3,
+        properties: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        function foo() {
+            for (const a of func(value)) {
+                console.log(a);
+            }
+            function func(va) {
+                return doSomething(va);
+            }
+        }
+        function doSomething(x) {
+            return [ x, 2 * x, 3 * x ];
+        }
+        const value = 10;
+        foo();
+    }
+    expect: {
+        (function() {
+            for (const o of [ 10, 20, 30 ]) console.log(o);
+        })();
+    }
+    expect_stdout: [
+        "10",
+        "20",
+        "30",
+    ]
+    node_version: ">=6"
+}
+
+issue_2794_4: {
+    options = {}
+    input: {
+        for (var x of ([1, 2], [3, 4])) {
+            console.log(x);
+        }
+    }
+    expect_exact: "for(var x of([1,2],[3,4]))console.log(x);"
+    expect_stdout: [
+        "3",
+        "4",
+    ]
+    node_version: ">=6"
+}
+
+issue_2794_5: {
+    mangle = {}
+    options = {
+        evaluate: true,
+        passes: 1,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        for (var x of ([1, 2], [3, 4])) {
+            console.log(x);
+        }
+    }
+    expect_exact: "for(var x of[3,4])console.log(x);"
+    expect_stdout: [
+        "3",
+        "4",
+    ]
+    node_version: ">=6"
+}
+
+issue_2794_6: {
+    options = {
+    }
+    input: {
+        // TODO (or not): have parser flag invalid for-of expression.
+        // Consider it an uglify extension in the meantime.
+        for (let e of [1,2], [3,4,5]) {
+            console.log(e);
+        }
+    }
+    expect_exact: "for(let e of([1,2],[3,4,5]))console.log(e);"
+    expect_stdout: [
+        "3",
+        "4",
+        "5",
+    ]
+    node_version: ">=6"
+}
+
+inline_arrow_using_arguments: {
+    options = {
+        evaluate: true,
+        inline: 1,
+        reduce_funcs: true,
+        reduce_vars: true,
+        sequences: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        (function(){
+            ((x) => {
+                console.log.apply(console, arguments),
+                console.log(x);
+            })(4);
+        })(3, 2, 1);
+    }
+    expect: {
+        (function(){
+            console.log.apply(console, arguments),
+            console.log(4);
+        })(3, 2, 1);
+    }
+    expect_stdout: [
+        "3 2 1",
+        "4",
+    ]
+    node_version: ">=6"
+}
+
+issue_2874_1: {
+    options = {
+        collapse_vars: true,
+        evaluate: true,
+        inline: 3,
+        reduce_funcs: true,
+        reduce_vars: true,
+        sequences: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        (function() {
+            function foo() {
+                let letters = ["A", "B", "C"];
+                let result = [2, 1, 0].map(key => bar(letters[key] + key));
+                return result;
+            }
+            function bar(value) {
+                return () => console.log(value);
+            }
+            foo().map(fn => fn());
+        })();
+    }
+    expect: {
+        (function() {
+            (function() {
+                let letters = [ "A", "B", "C" ];
+                return [ 2, 1, 0 ].map(key => (function(value) {
+                    return () => console.log(value);
+                })(letters[key] + key));
+            })().map(fn => fn());
+        })();
+    }
+    expect_stdout: [
+        "C2",
+        "B1",
+        "A0",
+    ]
+    node_version: ">=6"
+}
+
+issue_2874_2: {
+    options = {
+        collapse_vars: true,
+        evaluate: true,
+        inline: 3,
+        reduce_funcs: true,
+        reduce_vars: true,
+        sequences: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        (function() {
+            let keys = [];
+            function foo() {
+                var result = [2, 1, 0].map(value => {
+                    keys.push(value);
+                    return bar();
+                });
+                return result;
+            }
+            function bar() {
+                var letters = ["A", "B", "C"], key = keys.shift();
+                return () => console.log(letters[key] + key);
+            }
+            foo().map(fn => fn());
+        })();
+    }
+    expect: {
+        (function() {
+            let keys = [];
+            [ 2, 1, 0 ].map(value => {
+                return keys.push(value), function() {
+                    var letters = [ "A", "B", "C" ], key = keys.shift();
+                    return () => console.log(letters[key] + key);
+                }();
+            }).map(fn => fn());
+        })();
+    }
+    expect_stdout: [
+        "C2",
+        "B1",
+        "A0",
+    ]
+    node_version: ">=6"
+}
+
+issue_2874_3: {
+    options = {
+        collapse_vars: true,
+        evaluate: true,
+        inline: 3,
+        reduce_funcs: false,
+        reduce_vars: true,
+        sequences: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            return x + y;
+        }
+        let x, y;
+        let a = (z) => {
+            x = "A";
+            y = z;
+            console.log(f());
+        }
+        a(1);
+        a(2);
+    }
+    expect: {
+        let x, y;
+        let a = z => {
+            x = "A",
+            y = z,
+            console.log(x + y);
+        };
+        a(1),
+        a(2);
+    }
+    expect_stdout: [
+        "A1",
+        "A2",
+    ]
+    node_version: ">=6"
+}
--- a/test/compress/hoist_props.js
+++ b/test/compress/hoist_props.js
@@ -897,3 +897,25 @@ toplevel_var: {
    }
    expect_stdout: "3"
 }
+
+undefined_key: {
+    options = {
+        evaluate: true,
+        hoist_props: true,
+        join_vars: true,
+        passes: 4,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a, o = {};
+        o[a] = 1;
+        o.b = 2;
+        console.log(o[a] + o.b);
+    }
+    expect: {
+        console.log(3);
+    }
+    expect_stdout: "3"
+}
--- a/test/compress/if_return.js
+++ b/test/compress/if_return.js
@@ -454,3 +454,39 @@ if_if_return_return: {
        }
    }
 }
+
+issue_2747: {
+    options = {
+        conditionals: true,
+        if_return: true,
+        sequences: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        function f(baz) {
+            if (baz === 0) {
+                return null;
+            }
+            let r;
+            if (baz > 2) {
+                r = 4;
+            } else {
+                r = 5;
+            }
+            return r;
+        }
+        console.log(f(0), f(1), f(3));
+    }
+    expect: {
+        "use strict";
+        function f(baz) {
+            if (0 === baz) return null;
+            let r;
+            return r = baz > 2 ? 4 : 5, r;
+        }
+        console.log(f(0), f(1), f(3));
+    }
+    expect_stdout: "null 5 4"
+    node_version: ">=4"
+}
--- a/test/compress/issue-1443.js
+++ b/test/compress/issue-1443.js
@@ -4,7 +4,7 @@ unsafe_undefined: {
    options = {
        conditionals: true,
        if_return: true,
-        unsafe: true
+        unsafe_undefined: true,
    }
    mangle = {}
    input: {
@@ -30,7 +30,7 @@ keep_fnames: {
    options = {
        conditionals: true,
        if_return: true,
-        unsafe: true
+        unsafe_undefined: true,
    }
    mangle = {
        keep_fnames: true
--- a/test/compress/issue-1466.js
+++ b/test/compress/issue-1466.js
@@ -38,6 +38,7 @@ same_variable_in_multiple_for_loop: {
        }
    }
    expect_stdout: true
+    node_version: ">=6"
 }

 same_variable_in_multiple_forOf: {
@@ -79,6 +80,7 @@ same_variable_in_multiple_forOf: {
        }
    }
    expect_stdout: true
+    node_version: ">=6"
 }

 same_variable_in_multiple_forIn: {
@@ -120,6 +122,7 @@ same_variable_in_multiple_forIn: {
        }
    }
    expect_stdout: true
+    node_version: ">=6"
 }

 different_variable_in_multiple_for_loop: {
@@ -162,6 +165,7 @@ different_variable_in_multiple_for_loop: {
        }
    }
    expect_stdout: true
+    node_version: ">=6"
 }

 different_variable_in_multiple_forOf: {
@@ -203,6 +207,7 @@ different_variable_in_multiple_forOf: {
        }
    }
    expect_stdout: true
+    node_version: ">=6"
 }

 different_variable_in_multiple_forIn: {
@@ -244,6 +249,175 @@ different_variable_in_multiple_forIn: {
        }
    }
    expect_stdout: true
+    node_version: ">=6"
+}
+
+same_variable_in_multiple_forOf_sequences_let: {
+    options = {
+        hoist_funs: true,
+        dead_code: true,
+        conditionals: true,
+        comparisons: true,
+        evaluate: true,
+        booleans: true,
+        loops: true,
+        unused: true,
+        keep_fargs: true,
+        if_return: true,
+        join_vars: true,
+        sequences: true,
+        side_effects: true,
+        collapse_vars: true,
+    }
+    mangle = {}
+    input: {
+        var test = [ "a", "b", "c" ];
+        for (let tmp of test) {
+            console.log(tmp);
+            let dd;
+            dd = [ "e", "f", "g" ];
+            for (let tmp of dd) {
+                console.log(tmp);
+            }
+        }
+    }
+    expect: {
+        var test = [ "a", "b", "c" ];
+        for (let o of test) {
+            let e;
+            console.log(o), e = [ "e", "f", "g" ];
+            for (let o of e)
+                console.log(o);
+        }
+    }
+    expect_stdout: true
+    node_version: ">=6"
+}
+
+same_variable_in_multiple_forOf_sequences_const: {
+    options = {
+        hoist_funs: true,
+        dead_code: true,
+        conditionals: true,
+        comparisons: true,
+        evaluate: true,
+        booleans: true,
+        loops: true,
+        unused: true,
+        keep_fargs: true,
+        if_return: true,
+        join_vars: true,
+        sequences: true,
+        side_effects: true,
+        collapse_vars: true,
+    }
+    mangle = {}
+    input: {
+        var test = [ "a", "b", "c" ];
+        for (const tmp of test) {
+            console.log(tmp);
+            let dd;
+            dd = [ "e", "f", "g" ];
+            for (const tmp of dd) {
+                console.log(tmp);
+            }
+        }
+    }
+    expect: {
+        var test = [ "a", "b", "c" ];
+        for (const o of test) {
+            let t;
+            console.log(o), t = [ "e", "f", "g" ];
+            for (const o of t)
+                console.log(o);
+        }
+    }
+    expect_stdout: true
+    node_version: ">=6"
+}
+
+same_variable_in_multiple_forIn_sequences_let: {
+    options = {
+        hoist_funs: true,
+        dead_code: true,
+        conditionals: true,
+        comparisons: true,
+        evaluate: true,
+        booleans: true,
+        loops: true,
+        unused: false,
+        keep_fargs: true,
+        if_return: true,
+        join_vars: true,
+        sequences: true,
+        side_effects: true,
+        collapse_vars: true,
+    }
+    mangle = {}
+    input: {
+        var test = [ "a", "b", "c" ];
+        for (let tmp in test) {
+            console.log(tmp);
+            let dd;
+            dd = [ "e", "f", "g" ];
+            for (let tmp in test) {
+                console.log(tmp);
+            }
+        }
+    }
+    expect: {
+        var test = [ "a", "b", "c" ];
+        for (let e in test) {
+            let t;
+            console.log(e), t = [ "e", "f", "g" ];
+            for (let e in test)
+                console.log(e);
+        }
+    }
+    expect_stdout: true
+    node_version: ">=6"
+}
+
+same_variable_in_multiple_forIn_sequences_const: {
+    options = {
+        hoist_funs: true,
+        dead_code: true,
+        conditionals: true,
+        comparisons: true,
+        evaluate: true,
+        booleans: true,
+        loops: true,
+        unused: false,
+        keep_fargs: true,
+        if_return: true,
+        join_vars: true,
+        sequences: true,
+        side_effects: true,
+        collapse_vars: true,
+    }
+    mangle = {}
+    input: {
+        var test = [ "a", "b", "c" ];
+        for (const tmp in test) {
+            console.log(tmp);
+            let dd;
+            dd = [ "e", "f", "g" ];
+            for (const tmp in test) {
+                console.log(tmp);
+            }
+        }
+    }
+    expect: {
+        var test = [ "a", "b", "c" ];
+        for (const o in test) {
+            let t;
+            console.log(o), t = [ "e", "f", "g" ];
+            for (const o in test)
+                console.log(o);
+        }
+    }
+    expect_stdout: true
+    node_version: ">=6"
 }

 more_variable_in_multiple_for: {
@@ -281,4 +455,5 @@ more_variable_in_multiple_for: {
        }
    }
    expect_stdout: true
+    node_version: ">=6"
 }
--- a/test/compress/issue-1588.js
+++ b/test/compress/issue-1588.js
@@ -61,7 +61,7 @@ unsafe_undefined: {
    options = {
        conditionals: true,
        if_return: true,
-        unsafe: true,
+        unsafe_undefined: true,
    }
    mangle = {}
    input: {
--- a/test/compress/issue-1770.js
+++ b/test/compress/issue-1770.js
@@ -84,12 +84,12 @@ numeric_literal: {
        '    0: 0,',
        '    "-0": 1,',
        '    42: 2,',
-        '    "42": 3,',
+        '    42: 3,',
        '    37: 4,',
        '    o: 5,',
        '    1e42: 6,',
        '    b: 7,',
-        '    "1e+42": 8',
+        '    1e42: 8',
        '};',
        '',
        'console.log(obj[-0], obj[-""], obj["-0"]);',
--- a/test/compress/issue-203.js
+++ b/test/compress/issue-203.js
@@ -2,7 +2,7 @@
 compress_new_function: {
    options = {
        unsafe: true,
-        unsafe_Func: true,
+        unsafe_Function: true,
    }
    input: {
        new Function("aa, bb", 'return aa;');
@@ -15,7 +15,7 @@ compress_new_function: {
 compress_new_function_with_destruct: {
    options = {
        unsafe: true,
-        unsafe_Func: true,
+        unsafe_Function: true,
        ecma: 6
    }
    beautify = {
@@ -38,7 +38,7 @@ compress_new_function_with_destruct_arrows: {
        arrows: true,
        unsafe_arrows: true,
        unsafe: true,
-        unsafe_Func: true,
+        unsafe_Function: true,
        ecma: 6,
    }
    beautify = {
--- a/test/compress/issue-2871.js
+++ b/test/compress/issue-2871.js
@@ -0,0 +1,37 @@
+comparison_with_undefined: {
+    options = {
+        comparisons: true,
+    }
+    input: {
+        a == undefined;
+        a != undefined;
+        a === undefined;
+        a !== undefined;
+
+        undefined == a;
+        undefined != a;
+        undefined === a;
+        undefined !== a;
+
+        void 0 == a;
+        void 0 != a;
+        void 0 === a;
+        void 0 !== a;
+    }
+    expect: {
+        null == a;
+        null != a;
+        void 0 === a;
+        void 0 !== a;
+
+        null == a;
+        null != a;
+        void 0 === a;
+        void 0 !== a;
+
+        null == a;
+        null != a;
+        void 0 === a;
+        void 0 !== a;
+    }
+}
--- a/test/compress/loops.js
+++ b/test/compress/loops.js
@@ -536,3 +536,182 @@ dead_code_condition: {
    }
    expect_stdout: "1"
 }
+
+issue_2740_1: {
+    options = {
+        dead_code: true,
+        loops: true,
+    }
+    input: {
+        for (; ; ) break;
+        for (a(); ; ) break;
+        for (; b(); ) break;
+        for (c(); d(); ) break;
+        for (; ; e()) break;
+        for (f(); ; g()) break;
+        for (; h(); i()) break;
+        for (j(); k(); l()) break;
+    }
+    expect: {
+        a();
+        b();
+        c();
+        d();
+        f();
+        h();
+        j();
+        k();
+    }
+}
+
+issue_2740_2: {
+    options = {
+        dead_code: true,
+        loops: true,
+        passes: 2,
+    }
+    input: {
+        L1: while (x()) {
+            break L1;
+        }
+    }
+    expect: {
+        x();
+    }
+}
+
+issue_2740_3: {
+    options = {
+        dead_code: true,
+        loops: true,
+    }
+    input: {
+        L1: for (var x = 0; x < 3; x++) {
+            L2: for (var y = 0; y < 2; y++) {
+                break L1;
+            }
+        }
+        console.log(x, y);
+    }
+    expect: {
+        L1: for (var x = 0; x < 3; x++)
+            for (var y = 0; y < 2; y++)
+                break L1;
+        console.log(x, y);
+    }
+    expect_stdout: "0 0"
+}
+
+issue_2740_4: {
+    options = {
+        dead_code: true,
+        loops: true,
+        passes: 2,
+    }
+    input: {
+        L1: for (var x = 0; x < 3; x++) {
+            L2: for (var y = 0; y < 2; y++) {
+                break L2;
+            }
+        }
+        console.log(x, y);
+    }
+    expect: {
+        for (var x = 0; x < 3; x++) {
+            var y = 0;
+            y < 2;
+        }
+        console.log(x, y);
+    }
+    expect_stdout: "3 0"
+}
+
+issue_2740_5: {
+    options = {
+        dead_code: true,
+        loops: true,
+        passes: 2,
+    }
+    input: {
+        L1: for (var x = 0; x < 3; x++) {
+            break L1;
+            L2: for (var y = 0; y < 2; y++) {
+                break L2;
+            }
+        }
+        console.log(x, y);
+    }
+    expect: {
+        var x = 0;
+        x < 3;
+        var y;
+        console.log(x,y);
+    }
+    expect_stdout: "0 undefined"
+}
+
+issue_2740_6: {
+    options = {
+        dead_code: true,
+        loops: true,
+    }
+    input: {
+        const a = 9, b = 0;
+        for (const a = 1; a < 3; ++b) break;
+        console.log(a, b);
+    }
+    expect: {
+        const a = 9, b = 0;
+        {
+            const a = 1;
+            a < 3;
+        }
+        console.log(a, b);
+    }
+    expect_stdout: "9 0"
+    node_version: ">=6"
+}
+
+issue_2740_7: {
+    options = {
+        dead_code: true,
+        loops: true,
+    }
+    input: {
+        let a = 9, b = 0;
+        for (const a = 1; a < 3; ++b) break;
+        console.log(a, b);
+    }
+    expect: {
+        let a = 9, b = 0;
+        {
+            const a = 1;
+            a < 3;
+        }
+        console.log(a, b);
+    }
+    expect_stdout: "9 0"
+    node_version: ">=6"
+}
+
+issue_2740_8: {
+    options = {
+        dead_code: true,
+        loops: true,
+    }
+    input: {
+        var a = 9, b = 0;
+        for (const a = 1; a < 3; ++b) break;
+        console.log(a, b);
+    }
+    expect: {
+        var a = 9, b = 0;
+        {
+            const a = 1;
+            a < 3;
+        }
+        console.log(a, b);
+    }
+    expect_stdout: "9 0"
+    node_version: ">=6"
+}
--- a/test/compress/properties.js
+++ b/test/compress/properties.js
@@ -585,6 +585,25 @@ native_prototype: {
    }
 }

+native_prototype_lhs: {
+    options = {
+        unsafe_proto: true,
+    }
+    input: {
+        console.log(function() {
+            Function.prototype.bar = "PASS";
+            return function() {};
+        }().bar);
+    }
+    expect: {
+        console.log(function() {
+            Function.prototype.bar = "PASS";
+            return function() {};
+        }().bar);
+    }
+    expect_stdout: "PASS"
+}
+
 accessor_boolean: {
    input: {
        var a = 1;
@@ -1377,3 +1396,501 @@ const_prop_assign_pure: {
        x();
    }
 }
+
+join_object_assignments_1: {
+    options = {
+        evaluate: true,
+        join_vars: true,
+    }
+    input: {
+        console.log(function() {
+            var x = {
+                a: 1,
+                c: (console.log("c"), "C"),
+            };
+            x.b = 2;
+            x[3] = function() {
+                console.log(x);
+            },
+            x["a"] = /foo/,
+            x.bar = x;
+            return x;
+        }());
+    }
+    expect: {
+        console.log(function() {
+            var x = {
+                a: 1,
+                c: (console.log("c"), "C"),
+                b: 2,
+                3: function() {
+                    console.log(x);
+                },
+                a: /foo/,
+            };
+            x.bar = x;
+            return x;
+        }());
+    }
+    expect_stdout: true
+}
+
+join_object_assignments_2: {
+    options = {
+        evaluate: true,
+        hoist_props: true,
+        join_vars: true,
+        passes: 3,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var o = {
+            foo: 1,
+        };
+        o.bar = 2;
+        o.baz = 3;
+        console.log(o.foo, o.bar + o.bar, o.foo * o.bar * o.baz);
+    }
+    expect: {
+        console.log(1, 4, 6);
+    }
+    expect_stdout: "1 4 6"
+}
+
+join_object_assignments_3: {
+    options = {
+        evaluate: true,
+        join_vars: true,
+    }
+    input: {
+        console.log(function() {
+            var o = {
+                a: "PASS",
+            }, a = o.a;
+            o.a = "FAIL";
+            return a;
+        }());
+    }
+    expect: {
+        console.log(function() {
+            var o = {
+                a: "PASS",
+            }, a = o.a;
+            o.a = "FAIL";
+            return a;
+        }());
+    }
+    expect_stdout: "PASS"
+}
+
+join_object_assignments_return_1: {
+    options = {
+        join_vars: true,
+    }
+    input: {
+        console.log(function() {
+            var o = {
+                p: 3
+            };
+            return o.q = "foo";
+        }());
+    }
+    expect: {
+        console.log(function() {
+            var o = {
+                p: 3,
+                q: "foo"
+            };
+            return o.q;
+        }());
+    }
+    expect_stdout: "foo"
+}
+
+join_object_assignments_return_2: {
+    options = {
+        join_vars: true,
+    }
+    input: {
+        console.log(function() {
+            var o = {
+                p: 3
+            };
+            return o.q = /foo/,
+            o.r = "bar";
+        }());
+    }
+    expect: {
+        console.log(function() {
+            var o = {
+                p: 3,
+                q: /foo/,
+                r: "bar"
+            };
+            return o.r;
+        }());
+    }
+    expect_stdout: "bar"
+}
+
+join_object_assignments_return_3: {
+    options = {
+        join_vars: true,
+    }
+    input: {
+        console.log(function() {
+            var o = {
+                p: 3
+            };
+            return o.q = "foo",
+            o.p += "",
+            console.log(o.q),
+            o.p;
+        }());
+    }
+    expect: {
+        console.log(function() {
+            var o = {
+                p: 3,
+                q: "foo"
+            };
+            return o.p += "",
+            console.log(o.q),
+            o.p;
+        }());
+    }
+    expect_stdout: [
+        "foo",
+        "3",
+    ]
+}
+
+join_object_assignments_for: {
+    options = {
+        join_vars: true,
+    }
+    input: {
+        console.log(function() {
+            var o = {
+                p: 3
+            };
+            for (o.q = "foo"; console.log(o.q););
+            return o.p;
+        }());
+    }
+    expect: {
+        console.log(function() {
+            for (var o = {
+                p: 3,
+                q: "foo"
+            }; console.log(o.q););
+            return o.p;
+        }());
+    }
+    expect_stdout: [
+        "foo",
+        "3",
+    ]
+}
+
+join_object_assignments_if: {
+    options = {
+        join_vars: true,
+    }
+    input: {
+        console.log(function() {
+            var o = {};
+            if (o.a = "PASS") return o.a;
+        }())
+    }
+    expect: {
+        console.log(function() {
+            var o = { a: "PASS" };
+            if (o.a) return o.a;
+        }());
+    }
+    expect_stdout: "PASS"
+}
+
+join_object_assignments_forin: {
+    options = {
+        join_vars: true,
+    }
+    input: {
+        console.log(function() {
+            var o = {};
+            for (var a in o.a = "PASS", o)
+                return o[a];
+        }())
+    }
+    expect: {
+        console.log(function() {
+            var o = { a: "PASS" };
+            for (var a in o)
+                return o[a];
+        }());
+    }
+    expect_stdout: "PASS"
+}
+
+join_object_assignments_negative: {
+    options = {
+        evaluate: true,
+        join_vars: true,
+        properties: true,
+    }
+    input: {
+        var o = {};
+        o[0] = 0;
+        o[-0] = 1;
+        o[-1] = 2;
+        console.log(o[0], o[-0], o[-1]);
+    }
+    expect: {
+        var o = {
+            0: 0,
+            0: 1,
+            "-1": 2
+        };
+        console.log(o[0], o[-0], o[-1]);
+    }
+    expect_stdout: "1 1 2"
+}
+
+join_object_assignments_NaN_1: {
+    options = {
+        join_vars: true,
+    }
+    input: {
+        var o = {};
+        o[NaN] = 1;
+        o[0/0] = 2;
+        console.log(o[NaN], o[NaN]);
+    }
+    expect: {
+        var o = {};
+        o[NaN] = 1;
+        o[0/0] = 2;
+        console.log(o[NaN], o[NaN]);
+    }
+    expect_stdout: "2 2"
+}
+
+join_object_assignments_NaN_2: {
+    options = {
+        evaluate: true,
+        join_vars: true,
+        properties: true,
+    }
+    input: {
+        var o = {};
+        o[NaN] = 1;
+        o[0/0] = 2;
+        console.log(o[NaN], o[NaN]);
+    }
+    expect: {
+        var o = {
+            NaN: 1,
+            NaN: 2
+        };
+        console.log(o.NaN, o.NaN);
+    }
+    expect_stdout: "2 2"
+}
+
+join_object_assignments_null_0: {
+    options = {
+        join_vars: true,
+    }
+    input: {
+        var o = {};
+        o[null] = 1;
+        console.log(o[null]);
+    }
+    expect: {
+        var o = {};
+        o[null] = 1;
+        console.log(o[null]);
+    }
+    expect_stdout: "1"
+}
+
+join_object_assignments_null_1: {
+    options = {
+        evaluate: true,
+        join_vars: true,
+        properties: true,
+    }
+    input: {
+        var o = {};
+        o[null] = 1;
+        console.log(o[null]);
+    }
+    expect: {
+        var o = {
+            null: 1
+        };
+        console.log(o.null);
+    }
+    expect_stdout: "1"
+}
+
+join_object_assignments_void_0: {
+    options = {
+        evaluate: true,
+        join_vars: true,
+    }
+    input: {
+        var o = {};
+        o[void 0] = 1;
+        console.log(o[void 0]);
+    }
+    expect: {
+        var o = {
+            undefined: 1
+        };
+        console.log(o[void 0]);
+    }
+    expect_stdout: "1"
+}
+
+join_object_assignments_undefined_1: {
+    options = {
+        join_vars: true,
+    }
+    input: {
+        var o = {};
+        o[undefined] = 1;
+        console.log(o[undefined]);
+    }
+    expect: {
+        var o = {};
+        o[void 0] = 1;
+        console.log(o[void 0]);
+    }
+    expect_stdout: "1"
+}
+
+join_object_assignments_undefined_2: {
+    options = {
+        evaluate: true,
+        join_vars: true,
+        properties: true,
+    }
+    input: {
+        var o = {};
+        o[undefined] = 1;
+        console.log(o[undefined]);
+    }
+    expect: {
+        var o = {
+            undefined : 1
+        };
+        console.log(o[void 0]);
+    }
+    expect_stdout: "1"
+}
+
+join_object_assignments_Infinity: {
+    options = {
+        evaluate: true,
+        join_vars: true,
+        properties: true,
+    }
+    input: {
+        var o = {};
+        o[Infinity] = 1;
+        o[1/0] = 2;
+        o[-Infinity] = 3;
+        o[-1/0] = 4;
+        console.log(o[Infinity], o[1/0], o[-Infinity], o[-1/0]);
+    }
+    expect: {
+        var o = {
+            Infinity: 1,
+            Infinity: 2,
+            "-Infinity": 3,
+            "-Infinity": 4
+        };
+        console.log(o[1/0], o[1/0], o[-1/0], o[-1/0]);
+    }
+    expect_stdout: "2 2 4 4"
+}
+
+join_object_assignments_regex: {
+    options = {
+        evaluate: true,
+        join_vars: true,
+        properties: true,
+    }
+    input: {
+        var o = {};
+        o[/rx/] = 1;
+        console.log(o[/rx/]);
+    }
+    expect: {
+        var o = {
+            "/rx/": 1
+        };
+        console.log(o[/rx/]);
+    }
+    expect_stdout: "1"
+}
+
+issue_2816: {
+    options = {
+        join_vars: true,
+    }
+    input: {
+        "use strict";
+        var o = {
+            a: 1
+        };
+        o.b = 2;
+        o.a = 3;
+        o.c = 4;
+        console.log(o.a, o.b, o.c);
+    }
+    expect: {
+        "use strict";
+        var o = {
+            a: 1,
+            b: 2
+        };
+        o.a = 3;
+        o.c = 4;
+        console.log(o.a, o.b, o.c);
+    }
+    expect_stdout: "3 2 4"
+}
+
+issue_2816_ecma6: {
+    options = {
+        ecma: "6",
+        join_vars: true,
+    }
+    input: {
+        "use strict";
+        var o = {
+            a: 1
+        };
+        o.b = 2;
+        o.a = 3;
+        o.c = 4;
+        console.log(o.a, o.b, o.c);
+    }
+    expect: {
+        "use strict";
+        var o = {
+            a: 1,
+            b: 2,
+            a: 3,
+            c: 4
+        };
+        console.log(o.a, o.b, o.c);
+    }
+    expect_stdout: "3 2 4"
+    node_version: ">=4"
+}
--- a/test/compress/pure_getters.js
+++ b/test/compress/pure_getters.js
@@ -818,3 +818,30 @@ issue_2678: {
    }
    expect_stdout: "PASS"
 }
+
+issue_2838: {
+    options = {
+        pure_getters: true,
+        side_effects: true,
+    }
+    input: {
+        function f(a, b) {
+            (a || b).c = "PASS";
+            (function() {
+                return f(a, b);
+            }).prototype.foo = "bar";
+        }
+        var o = {};
+        f(null, o);
+        console.log(o.c);
+    }
+    expect: {
+        function f(a, b) {
+            (a || b).c = "PASS";
+        }
+        var o = {};
+        f(null, o);
+        console.log(o.c);
+    }
+    expect_stdout: "PASS"
+}
--- a/test/compress/reduce_vars.js
+++ b/test/compress/reduce_vars.js
@@ -76,14 +76,12 @@ modified: {
            console.log(a + 1);
            console.log(b + 1);
        }
-
        function f1() {
            var a = 1, b = 2;
            --b;
            console.log(a + 1);
            console.log(b + 1);
        }
-
        function f2() {
            var a = 1, b = 2, c = 3;
            b = c;
@@ -92,7 +90,6 @@ modified: {
            console.log(a + c);
            console.log(a + b + c);
        }
-
        function f3() {
            var a = 1, b = 2, c = 3;
            b *= c;
@@ -101,7 +98,6 @@ modified: {
            console.log(a + c);
            console.log(a + b + c);
        }
-
        function f4() {
            var a = 1, b = 2, c = 3;
            if (a) {
@@ -114,28 +110,26 @@ modified: {
            console.log(a + c);
            console.log(a + b + c);
        }
-
        function f5(a) {
            B = a;
-            console.log(A ? 'yes' : 'no');
-            console.log(B ? 'yes' : 'no');
+            console.log(typeof A ? "yes" : "no");
+            console.log(typeof B ? "yes" : "no");
        }
+        f0(), f1(), f2(), f3(), f4(), f5();
    }
    expect: {
        function f0() {
            var b = 2;
            b++;
            console.log(2);
-            console.log(b + 1);
+            console.log(4);
        }
-
        function f1() {
            var b = 2;
            --b;
            console.log(2);
-            console.log(b + 1);
+            console.log(2);
        }
-
        function f2() {
            3;
            console.log(4);
@@ -143,16 +137,14 @@ modified: {
            console.log(4);
            console.log(7);
        }
-
        function f3() {
            var b = 2;
            b *= 3;
-            console.log(1 + b);
-            console.log(b + 3);
+            console.log(7);
+            console.log(9);
            console.log(4);
-            console.log(1 + b + 3);
+            console.log(10);
        }
-
        function f4() {
            var b = 2, c = 3;
            b = c;
@@ -161,13 +153,33 @@ modified: {
            console.log(1 + c);
            console.log(1 + b + c);
        }
-
        function f5(a) {
            B = a;
-            console.log(A ? 'yes' : 'no');
-            console.log(B ? 'yes' : 'no');
+            console.log(typeof A ? "yes" : "no");
+            console.log(typeof B ? "yes" : "no");
        }
+        f0(), f1(), f2(), f3(), f4(), f5();
    }
+    expect_stdout: [
+        "2",
+        "4",
+        "2",
+        "2",
+        "4",
+        "6",
+        "4",
+        "7",
+        "7",
+        "9",
+        "4",
+        "10",
+        "4",
+        "6",
+        "4",
+        "7",
+        "yes",
+        "yes",
+    ]
 }

 unsafe_evaluate: {
@@ -745,7 +757,7 @@ iife: {
    expect: {
        !function(a, b, c) {
            b++;
-            console.log(0, 1 * b, 5);
+            console.log(0, 3, 5);
        }(1, 2, 3);
    }
    expect_stdout: true
@@ -766,7 +778,7 @@ iife_new: {
    expect: {
        var A = new function(a, b, c) {
            b++;
-            console.log(0, 1 * b, 5);
+            console.log(0, 3, 5);
        }(1, 2, 3);
    }
    expect_stdout: true
@@ -5809,3 +5821,305 @@ duplicate_lambda_defun_name_2: {
    }
    expect_stdout: "0"
 }
+
+issue_2757_1: {
+    options = {
+        evaluate: true,
+        inline: true,
+        reduce_vars: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        let u;
+        (function() {
+            let v;
+            console.log(u, v);
+        })();
+    }
+    expect: {
+        let u;
+        console.log(u, void 0);
+    }
+    expect_stdout: "undefined undefined"
+    node_version: ">=6"
+}
+
+issue_2757_2: {
+    options = {
+        conditionals: true,
+        evaluate: true,
+        inline: true,
+        passes: 2,
+        reduce_vars: true,
+        sequences: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        (function() {
+            let bar;
+            const unused = function() {
+                bar = true;
+            };
+            if (!bar) {
+                console.log(1);
+            }
+            console.log(2);
+        }());
+    }
+    expect: {
+        console.log(1),
+        console.log(2);
+    }
+    expect_stdout: [
+        "1",
+        "2",
+    ]
+    node_version: ">=6"
+}
+
+issue_2774: {
+    options = {
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        console.log({
+            get a() {
+                var b;
+                (b = true) && b.c;
+                b = void 0;
+            }
+        }.a);
+    }
+    expect: {
+        console.log({
+            get a() {
+                var b;
+                (b = true) && b.c;
+                b = void 0;
+            }
+        }.a);
+    }
+    expect_stdout: "undefined"
+}
+
+issue_2799_1: {
+    options = {
+        reduce_funcs: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        console.log(function() {
+            return f;
+            function f(n) {
+                function g(i) {
+                    return i && i + g(i - 1);
+                }
+                function h(j) {
+                    return g(j);
+                }
+                return h(n);
+            }
+        }()(5));
+    }
+    expect: {
+        console.log(function() {
+            return function(n) {
+                return function(j) {
+                    return function g(i) {
+                        return i && i + g(i - 1);
+                    }(j);
+                }(n);
+            }
+        }()(5));
+    }
+    expect_stdout: "15"
+}
+
+issue_2799_2: {
+    options = {
+        reduce_vars: true,
+        unsafe_proto: true,
+        unused: true,
+    }
+    input: {
+        (function() {
+            function foo() {
+                Function.prototype.call.apply(console.log, [ null, "PASS" ]);
+            }
+            foo();
+        })();
+    }
+    expect: {
+        (function() {
+            (function() {
+                (function() {}).call.apply(console.log, [ null, "PASS" ]);
+            })();
+        })();
+    }
+    expect_stdout: "PASS"
+}
+
+issue_2836: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            return "FAIL";
+        }
+        console.log(f());
+        function f() {
+            return "PASS";
+        }
+    }
+    expect: {
+        console.log(function() {
+            return "PASS";
+        }());
+    }
+    expect_stdout: "PASS"
+}
+
+lvalues_def_1: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var b = 1;
+        var a = b++, b = NaN;
+        console.log(a, b);
+    }
+    expect: {
+        var b = 1;
+        var a = b++;
+        b = NaN;
+        console.log(a, b);
+    }
+    expect_stdout: "1 NaN"
+}
+
+lvalues_def_2: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var b = 1;
+        var a = b += 1, b = NaN;
+        console.log(a, b);
+    }
+    expect: {
+        var b = 1;
+        var a = b += 1;
+        b = NaN;
+        console.log(a, b);
+    }
+    expect_stdout: "2 NaN"
+}
+
+chained_assignments: {
+    options = {
+        evaluate: true,
+        inline: true,
+        reduce_vars: true,
+        sequences: true,
+        side_effects: true,
+        toplevel: true,
+        unsafe: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            var a = [0x5e, 0xad, 0xbe, 0xef];
+            var b = 0;
+            b |= a[0];
+            b <<= 8;
+            b |= a[1];
+            b <<= 8;
+            b |= a[2];
+            b <<= 8;
+            b |= a[3];
+            return b;
+        }
+        console.log(f().toString(16));
+    }
+    expect: {
+        console.log("5eadbeef");
+    }
+    expect_stdout: "5eadbeef"
+}
+
+issue_2860_1: {
+    options = {
+        dead_code: true,
+        evaluate: true,
+        reduce_vars: true,
+    }
+    input: {
+        console.log(function(a) {
+            return a ^= 1;
+            a ^= 2;
+        }());
+    }
+    expect: {
+        console.log(function(a) {
+            return 1 ^ a;
+        }());
+    }
+    expect_stdout: "1"
+}
+
+issue_2860_2: {
+    options = {
+        dead_code: true,
+        evaluate: true,
+        inline: true,
+        passes: 2,
+        reduce_vars: true,
+    }
+    input: {
+        console.log(function(a) {
+            return a ^= 1;
+            a ^= 2;
+        }());
+    }
+    expect: {
+        console.log(1);
+    }
+    expect_stdout: "1"
+}
+
+issue_2869: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+    }
+    input: {
+        var c = "FAIL";
+        (function f(a) {
+            var a;
+            if (!f) a = 0;
+            if (a) c = "PASS";
+        })(1);
+        console.log(c);
+    }
+    expect: {
+        var c = "FAIL";
+        (function f(a) {
+            var a;
+            if (!f) a = 0;
+            if (a) c = "PASS";
+        })(1);
+        console.log(c);
+    }
+    expect_stdout: "PASS"
+}
--- a/test/compress/sequences.js
+++ b/test/compress/sequences.js
@@ -288,7 +288,7 @@ unsafe_undefined: {
        if_return: true,
        sequences: true,
        side_effects: true,
-        unsafe: true,
+        unsafe_undefined: true,
    }
    input: {
        function f(undefined) {
@@ -883,3 +883,21 @@ for_init_var: {
    }
    expect_stdout: "PASS"
 }
+
+forin: {
+    options = {
+        sequences: true,
+    }
+    input: {
+        var o = [];
+        o.push("PASS");
+        for (var a in o)
+            console.log(o[a]);
+    }
+    expect: {
+        var o = [];
+        for (var a in o.push("PASS"), o)
+            console.log(o[a]);
+    }
+    expect_stdout: "PASS"
+}
--- a/test/compress/yield.js
+++ b/test/compress/yield.js
@@ -211,3 +211,43 @@ issue_2689: {
    }
    expect_exact: "function*y(){return new(yield x())}"
 }
+
+issue_2832: {
+    beautify = {
+        beautify: true,
+    }
+    input: {
+        function* gen(i) {
+            const result = yield (x = i, -x);
+            var x;
+            console.log(x);
+            console.log(result);
+            yield 2;
+        }
+        var x = gen(1);
+        console.log(x.next("first").value);
+        console.log(x.next("second").value);
+    }
+    expect_exact: [
+        "function* gen(i) {",
+        "    const result = yield (x = i, -x);",
+        "    var x;",
+        "    console.log(x);",
+        "    console.log(result);",
+        "    yield 2;",
+        "}",
+        "",
+        "var x = gen(1);",
+        "",
+        'console.log(x.next("first").value);',
+        "",
+        'console.log(x.next("second").value);',
+    ]
+    expect_stdout: [
+        "-1",
+        "1",
+        "second",
+        "2",
+    ]
+    node_version: ">=4"
+}
--- a/test/input/invalid/const.js
+++ b/test/input/invalid/const.js
@@ -1,8 +1,3 @@
 function f() {
    const a;
 }
-
-function g() {
-    "use strict";
-    const a;
-}
--- a/test/input/rename/input.js
+++ b/test/input/rename/input.js
@@ -0,0 +1,6 @@
+function f(x) {
+    return g(x);
+    function g(x) {
+        return x;
+    }
+}
--- a/test/mocha.js
+++ b/test/mocha.js
@@ -1,29 +1,24 @@
-var Mocha = require('mocha'),
-    fs = require('fs'),
-    path = require('path');
+var fs = require("fs");
+var Mocha = require("mocha");
+var path = require("path");

-// Instantiate a Mocha instance.
-var mocha = new Mocha({});
+// Instantiate a Mocha instance
+var mocha = new Mocha({
+    timeout: 5000
+});
+var testDir = __dirname + "/mocha/";

-var testDir = __dirname + '/mocha/';
-
-// Add each .js file to the mocha instance
-fs.readdirSync(testDir).filter(function(file){
-    // Only keep the .js files
-    return file.substr(-3) === '.js';
-
-}).forEach(function(file){
-    mocha.addFile(
-        path.join(testDir, file)
-    );
+// Add each .js file to the Mocha instance
+fs.readdirSync(testDir).filter(function(file) {
+    return /\.js$/.test(file);
+}).forEach(function(file) {
+    mocha.addFile(path.join(testDir, file));
 });

 module.exports = function() {
    mocha.run(function(failures) {
-        if (failures !== 0) {
-            process.on('exit', function () {
-                process.exit(failures);
-            });
-        }
+        if (failures) process.on("exit", function() {
+            process.exit(failures);
+        });
    });
-};
+};
--- a/test/mocha/cli.js
+++ b/test/mocha/cli.js
@@ -408,7 +408,7 @@ describe("bin/uglifyjs", function () {
            assert.ok(err);
            assert.strictEqual(stdout, "");
            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
-                "Parse error at test/input/invalid/const.js:7,11",
+                "Parse error at test/input/invalid/const.js:2,11",
                "    const a;",
                "           ^",
                "ERROR: Missing initializer in const declaration"
--- a/test/mocha/minify.js
+++ b/test/mocha/minify.js
@@ -404,4 +404,19 @@ describe("minify", function() {
            assert.strictEqual(stat.print_to_string(), "a=x()");
        });
    });
+
+    // rename is disabled on harmony due to expand_names bug in for-of loops
+    if (0) describe("rename", function() {
+        it("Should be repeatable", function() {
+            var code = "!function(x){return x(x)}(y);";
+            for (var i = 0; i < 2; i++) {
+                assert.strictEqual(Uglify.minify(code, {
+                    compress: {
+                        toplevel: true,
+                    },
+                    rename: true,
+                }).code, "var a;(a=y)(a);");
+            }
+        });
+    });
 });
--- a/test/run-tests.js
+++ b/test/run-tests.js
@@ -208,6 +208,9 @@ function run_compress_tests() {
                    });
                    return false;
                }
+                if (test.reminify && !reminify(test.options, input_code, input_formatted, test.expect_stdout)) {
+                    return false;
+                }
            }
            return true;
        }
@@ -261,6 +264,16 @@ function parse_test(file) {
        }));
    }

+    function read_boolean(stat) {
+        if (stat.TYPE == "SimpleStatement") {
+            var body = stat.body;
+            if (body instanceof U.AST_Boolean) {
+                return body.value;
+            }
+        }
+        throw new Error("Should be boolean");
+    }
+
    function read_string(stat) {
        if (stat.TYPE == "SimpleStatement") {
            var body = stat.body;
@@ -279,7 +292,11 @@ function parse_test(file) {
    }

    function get_one_test(name, block) {
-        var test = { name: name, options: {} };
+        var test = {
+            name: name,
+            options: {},
+            reminify: true,
+        };
        var tw = new U.TreeWalker(function(node, descend){
            if (node instanceof U.AST_Assign) {
                if (!(node.left instanceof U.AST_SymbolRef)) {
@@ -299,6 +316,7 @@ function parse_test(file) {
                        "expect_warnings",
                        "expect_stdout",
                        "node_version",
+                        "reminify",
                    ].indexOf(label.name) >= 0,
                    tmpl("Unsupported label {name} [{line},{col}]", {
                        name: label.name,
@@ -309,6 +327,9 @@ function parse_test(file) {
                var stat = node.body;
                if (label.name == "expect_exact" || label.name == "node_version") {
                    test[label.name] = read_string(stat);
+                } else if (label.name == "reminify") {
+                    var value = read_boolean(stat);
+                    test.reminify = value == null || value;
                } else if (label.name == "expect_stdout") {
                    var body = stat.body;
                    if (body instanceof U.AST_Boolean) {
@@ -358,14 +379,17 @@ function evaluate(code) {
 function reminify(orig_options, input_code, input_formatted, expect_stdout) {
    for (var i = 0; i < minify_options.length; i++) {
        var options = JSON.parse(minify_options[i]);
-        if (options.compress) [
-            "keep_fargs",
-            "keep_fnames",
-        ].forEach(function(name) {
-            if (name in orig_options) {
-                options.compress[name] = orig_options[name];
-            }
-        });
+        options.keep_fnames = orig_options.keep_fnames;
+        options.keep_classnames = orig_options.keep_classnames;
+        if (orig_options.compress) {
+            options.compress.keep_classnames = orig_options.compress.keep_classnames;
+            options.compress.keep_fargs = orig_options.compress.keep_fargs;
+            options.compress.keep_fnames = orig_options.compress.keep_fnames;
+        }
+        if (orig_options.mangle) {
+            options.mangle.keep_classnames = orig_options.mangle.keep_classnames;
+            options.mangle.keep_fnames = orig_options.mangle.keep_fnames;
+        }
        var options_formatted = JSON.stringify(options, null, 4);
        var result = U.minify(input_code, options);
        if (result.error) {
--- a/test/sandbox.js
+++ b/test/sandbox.js
@@ -17,24 +17,30 @@ function safe_log(arg, level) {
    return arg;
 }

+function strip_func_ids(text) {
+    return text.toString().replace(/F[0-9]{6}N/g, "<F<>N>");
+}
+
 var FUNC_TOSTRING = [
+    "[ Array, Boolean, Error, Function, Number, Object, RegExp, String].forEach(function(f) {",
+    "    f.toString = Function.prototype.toString;",
+    "    f.valueOf = Function.prototype.valueOf;",
+    "});",
    "Function.prototype.toString = Function.prototype.valueOf = function() {",
    "    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;",
+    "        var n = this.name;",
+    '        if (!/^F[0-9]{6}N$/.test(n)) {',
+    '            n = "F" + ++id + "N";',
 ].concat(Object.getOwnPropertyDescriptor(Function.prototype, "name").configurable ? [
    '            Object.defineProperty(this, "name", {',
    "                get: function() {",
-    "                    return i;",
+    "                    return n;",
    "                }",
    "            });",
 ] : [], [
    "        }",
-    '        return "[Function: " + i + "]";',
+    '        return "[Function: " + n + "]";',
    "    }",
    "}();",
    'Object.defineProperty(Function.prototype, "valueOf", { enumerable: false });',
@@ -77,7 +83,7 @@ exports.same_stdout = semver.satisfies(process.version, "0.12") ? function(expec
        expected = expected.message.slice(expected.message.lastIndexOf("\n") + 1);
        actual = actual.message.slice(actual.message.lastIndexOf("\n") + 1);
    }
-    return expected == actual;
+    return strip_func_ids(expected) == strip_func_ids(actual);
 } : function(expected, actual) {
-    return typeof expected == typeof actual && expected.toString() == actual.toString();
+    return typeof expected == typeof actual && strip_func_ids(expected) == strip_func_ids(actual);
 };
--- a/test/travis-ufuzz.js
+++ b/test/travis-ufuzz.js
@@ -0,0 +1,82 @@
+"use strict";
+
+var child_process = require("child_process");
+var https = require("https");
+var url = require("url");
+
+var period = 45 * 60 * 1000;
+var wait = 2 * 60 * 1000;
+var ping = 5 * 60 * 1000;
+if (process.argv[2] == "run") {
+    var endTime = Date.now() + period;
+    for (var i = 0; i < 2; i++) spawn(endTime);
+} else if (process.argv.length > 2) {
+    var token = process.argv[2];
+    var branch = process.argv[3] || "v" + require("../package.json").version;
+    var repository = encodeURIComponent(process.argv[4] || "mishoo/UglifyJS2");
+    var concurrency = process.argv[5] || 1;
+    (function request() {
+        setTimeout(request, (period + wait) / concurrency);
+        var options = url.parse("https://api.travis-ci.org/repo/" + repository + "/requests");
+        options.method = "POST";
+        options.headers = {
+            "Content-Type": "application/json",
+            "Travis-API-Version": 3,
+            "Authorization": "token " + token
+        };
+        https.request(options, function(res) {
+            console.log("HTTP", res.statusCode);
+            console.log(JSON.stringify(res.headers, null, 2));
+            console.log();
+            res.setEncoding("utf8");
+            res.on("data", console.log);
+        }).on("error", console.error).end(JSON.stringify({
+            request: {
+                message: "ufuzz testing (when idle)",
+                branch: branch,
+                config: {
+                    merge_mode: "replace",
+                    language: "node_js",
+                    node_js: "9",
+                    sudo: false,
+                    script: "node test/travis-ufuzz run"
+                }
+            }
+        }));
+    })();
+} else {
+    console.log("Usage: test/travis-ufuzz.js <token> [branch] [repository] [concurrency]");
+}
+
+function spawn(endTime) {
+    var child = child_process.spawn("node", [
+        "--max-old-space-size=2048",
+        "test/ufuzz"
+    ], {
+        stdio: [ "ignore", "pipe", "pipe" ]
+    }).on("exit", respawn);
+    var line = "";
+    child.stdout.on("data", function(data) {
+        line += data;
+    });
+    child.stderr.on("data", function() {
+        process.exitCode = 1;
+    }).pipe(process.stdout);
+    var keepAlive = setInterval(function() {
+        var end = line.lastIndexOf("\r");
+        console.log(line.slice(line.lastIndexOf("\r", end - 1) + 1, end));
+        line = line.slice(end + 1);
+    }, ping);
+    var timer = setTimeout(function() {
+        clearInterval(keepAlive);
+        child.removeListener("exit", respawn);
+        child.kill();
+    }, endTime - Date.now());
+
+    function respawn() {
+        console.log(line);
+        clearInterval(keepAlive);
+        clearTimeout(timer);
+        spawn(endTime);
+    }
+}
--- a/test/ufuzz.js
+++ b/test/ufuzz.js
@@ -998,10 +998,11 @@ function log_suspects(minify_options, component) {
    if (typeof options != "object") options = {};
    var defs = default_options[component];
    var suspects = Object.keys(defs).filter(function(name) {
-        if ((name in options ? options : defs)[name]) {
+        var flip = name == "keep_fargs";
+        if (flip ? name in options : (name in options ? options : defs)[name]) {
            var m = JSON.parse(JSON.stringify(minify_options));
            var o = JSON.parse(JSON.stringify(options));
-            o[name] = false;
+            o[name] = flip;
            m[component] = o;
            var result = UglifyJS.minify(original_code, m);
            if (result.error) {
@@ -1022,6 +1023,23 @@ function log_suspects(minify_options, component) {
    }
 }

+function log_rename(options) {
+    var m = JSON.parse(JSON.stringify(options));
+    m.rename = false;
+    var result = UglifyJS.minify(original_code, m);
+    if (result.error) {
+        errorln("Error testing options.rename");
+        errorln(result.error.stack);
+    } else {
+        var r = sandbox.run_code(result.code);
+        if (sandbox.same_stdout(original_result, r)) {
+            errorln("Suspicious options:");
+            errorln("  rename");
+            errorln();
+        }
+    }
+}
+
 function log(options) {
    if (!ok) errorln('\n\n\n\n\n\n!!!!!!!!!!\n\n\n');
    errorln("//=============================================================");
@@ -1056,6 +1074,7 @@ function log(options) {
    errorln();
    if (!ok && typeof uglify_code == "string") {
        Object.keys(default_options).forEach(log_suspects.bind(null, options));
+        log_rename(options);
        errorln("!!!!!! Failed... round " + round);
    }
 }
--- a/test/ufuzz.json
+++ b/test/ufuzz.json
@@ -5,7 +5,8 @@
        "output": {
            "beautify": true,
            "bracketize": true
-        }
+        },
+        "rename": true
    },
    {
        "compress": false
@@ -20,7 +21,13 @@
    {
        "compress": {
            "keep_fargs": false,
-            "passes": 100
+            "passes": 1e6,
+            "sequences": 1e6,
+            "unsafe": true,
+            "unsafe_Function": true,
+            "unsafe_math": true,
+            "unsafe_proto": true,
+            "unsafe_regexp": true
        }
    }
 ]
Author	SHA1	Message	Date
kzc	569757d14d	fix `collapse_vars` regression in destructuring (#2897 ) fixes #2896	2018-02-09 04:28:35 +08:00
Alex Lam S.L	aebc916215	harmony-v3.3.10	2018-02-08 19:51:03 +08:00
alexlamsl	ebf5096864	fix tests	2018-02-08 18:29:44 +08:00
alexlamsl	630b09050f	Merge branch 'master' into harmony-v3.3.10	2018-02-08 18:26:42 +08:00
Alex Lam S.L	0cfbd79aa1	v3.3.10	2018-02-08 10:16:16 +00:00
Alex Lam S.L	d66d86f20b	account for exceptions in `AST_Assign.left` (#2892 ) fixes #2891	2018-02-08 03:31:51 +08:00
Alex Lam S.L	905325d3e2	update dependencies (#2889 ) acorn 5.4.1 commander 2.14.1 semver 5.5.0	2018-02-07 18:13:18 +08:00
Alex Lam S.L	dea0cc0662	mention file encoding (#2887 )	2018-02-06 16:48:49 +08:00
Alex Lam S.L	d69d8007d6	evaluate `to{Low,Upp}erCase()` under `unsafe` (#2886 )	2018-02-06 15:57:15 +08:00
Dan	c0b8f2a16d	add information on testing and code style (#2885 ) fixes #2884	2018-02-06 14:19:28 +08:00
Dan	cb0257dbbf	describe a few compiler assumptions (#2883 )	2018-02-06 14:19:03 +08:00
kzc	149a569ac8	fix `inline` within arrow functions (#2881 ) fixes #2874	2018-02-05 15:01:30 +08:00
Dan	9637f51b68	change `undefined == x` to `null == x` (#2882 ) fixes #2871	2018-02-05 15:00:23 +08:00
Alex Lam S.L	3026bd8975	improve exceptional flow compression by `collapse_vars` (#2880 )	2018-02-04 04:18:22 +08:00
Alex Lam S.L	78a44d5ab0	maintain order between side-effects and externally observable assignments (#2879 ) fixes #2878	2018-02-04 03:58:49 +08:00
kzc	4b3c0652b7	fix `arguments` in arrow functions (#2877 )	2018-02-03 14:51:19 +08:00
Alex Lam S.L	7e13c0db40	handle `break` & `continue` in `collapse_vars` (#2875 ) fixes #2873	2018-02-03 07:58:43 +08:00
Alex Lam S.L	e6a2e9e4d0	allow `collapse_vars` across conditional branches (#2867 )	2018-02-03 02:44:40 +08:00
Alex Lam S.L	e773f03927	fix assignment logic in `reduce_vars` (#2872 ) fixes #2869	2018-02-03 01:33:09 +08:00
Alex Lam S.L	b16380d669	fix missing corner case in #2855 (#2868 )	2018-02-02 18:08:56 +08:00
Ryan Gunn	334b07a3db	Update License Copyright Year to 2018 (#2866 )	2018-02-02 16:30:01 +08:00
Alex Lam S.L	3cc1527f00	always test for `rename` (#2865 )	2018-02-01 21:42:55 +08:00
Alex Lam S.L	525a61fb55	better fix for #2858 (#2864 )	2018-02-01 20:06:36 +08:00
Alex Lam S.L	c3a002ff97	account for side-effects in `comparisons` of `null` & `undefined` (#2863 )	2018-02-01 19:15:17 +08:00
Alex Lam S.L	fad6766a90	simplify comparisons with `undefined` & `null` (#2862 ) fixes #2857	2018-02-01 16:50:54 +08:00
Alex Lam S.L	aa664dea0a	avoid `evaluate` of compound assignment after `dead_code` transform (#2861 ) fixes #2860	2018-02-01 16:18:29 +08:00
Alex Lam S.L	102f994b9d	account for declaration assignment in `collapse_vars` (#2859 ) fixes #2858	2018-02-01 15:09:53 +08:00
Alex Lam S.L	2a4c68be4f	relax `collapse_vars` on `AST_Exit` (#2855 ) First introduced in #1862 to stop assignments to migrate beyond `return` or `throw`. Since then `collapse_vars` has been improved to handle various side-effect-related corner cases.	2018-01-31 23:49:59 +08:00
Alex Lam S.L	541e6011af	improve symbol replacement heuristic (#2851 )	2018-01-29 17:41:15 +08:00
Alex Lam S.L	6fa3fbeae8	compress chained compound assignments (#2850 )	2018-01-29 15:13:25 +08:00
Alex Lam S.L	8e595171b9	harmony-v3.3.9	2018-01-27 22:56:06 +08:00
alexlamsl	6973abbfe1	Merge branch 'master' into harmony-v3.3.9	2018-01-27 20:58:49 +08:00
Alex Lam S.L	4eb4cb656c	v3.3.9	2018-01-27 12:56:34 +00:00
Alex Lam S.L	193612ac67	fix accounting after conversion to assignment (#2847 ) Missing reference to `AST_SymbolRef` created by `unused` causes `collapse_vars` to misbehave. fixes #2846	2018-01-26 14:21:11 +08:00
Alex Lam S.L	95cfce68ea	backport of #2835 (#2841 )	2018-01-23 05:45:45 +08:00
kzc	e0461dc3c8	fix for-in/of regression with let or const loop variable (#2840 ) fixes #2835	2018-01-23 05:45:02 +08:00
Alex Lam S.L	ec4202590d	drop assignments to constant expressions only (#2839 ) fixes #2838	2018-01-23 02:49:54 +08:00
Alex Lam S.L	5e2cd07d6f	handle duplicate function declarations correctly (#2837 ) fixes #2836	2018-01-23 01:28:09 +08:00
kzc	bea9dbd812	enable reminify on harmony branch to avoid regressions (#2834 ) - can skip known test failures with `reminify: false`	2018-01-22 18:20:29 +08:00
Alex Lam S.L	bc01a85ba0	add parenthesis around sequence in `yield` (#2833 ) fixes #2832	2018-01-22 14:57:23 +08:00
Alex Lam S.L	c7c7960b5f	harmony-v3.3.8	2018-01-21 16:44:17 +08:00
alexlamsl	fc98d212db	allow duplicate property names in object literals for ES6+	2018-01-21 15:58:14 +08:00
alexlamsl	13accdd745	fix tests	2018-01-21 15:53:32 +08:00
alexlamsl	287ec730f7	Merge branch 'master' into harmony-v3.3.8	2018-01-21 15:52:25 +08:00
Alex Lam S.L	06166df999	v3.3.8	2018-01-21 07:08:01 +00:00
Alex Lam S.L	e2dc9cf091	fix `unsafe` `evaluate` of `AST_Array` (#2825 ) fixes #2822	2018-01-21 01:39:44 +08:00
Alex Lam S.L	069df27bf1	enable `unsafe` for `test/ufuzz.js` (#2819 ) - introduce `unsafe_undefined` - safer `.toString()` compression Miscellaneous - rename `unsafe_Function`	2018-01-19 23:47:42 +08:00
Alex Lam S.L	3e7873217c	improve `unused` on built-in functions (#2817 )	2018-01-19 20:41:57 +08:00
Alex Lam S.L	e21bab7ce6	avoid duplicate property names in object literals under "use strict" (#2818 ) fixes #2816	2018-01-19 20:13:50 +08:00
Alex Lam S.L	ac9a168fba	fix & improve `test/ufuzz.js` (#2815 ) - use correct `options` when testing `rename` - mask arbitrarily assigned function IDs to reduce rate of false positives	2018-01-19 16:51:59 +08:00
Alex Lam S.L	81b64549ce	fix time-out for respawned `test/ufuzz.js` (#2814 )	2018-01-19 06:11:19 +08:00
Alex Lam S.L	082e004b87	compress `undefined` property names (#2811 ) - enforce property names as string - handle `void 0` as `undefined` in `hoist_props` & `reduce_vars`	2018-01-19 00:36:30 +08:00
kzc	983e69128b	fix `join_vars` property assignment for negative array index (#2810 ) fixes #2790	2018-01-18 21:52:54 +08:00
Alex Lam S.L	b335912e86	enhance `test/ufuzz.js` (#2808 ) - standalone test for `rename` - handle `keep_fargs` & `rename` upon failure	2018-01-18 14:08:05 +08:00
Alex Lam S.L	cc07f3b806	faster output of comments (#2806 )	2018-01-18 02:57:33 +08:00
Alex Lam S.L	07e4b64f3a	fix `AST_Scope.clone()` (#2803 ) fixes #2799	2018-01-17 21:33:13 +08:00
Alex Lam S.L	d3ce2bc9e7	suppress `unsafe_proto` for LHS expressions (#2804 )	2018-01-17 20:41:51 +08:00
Alex Lam S.L	cff3bf4914	configure `rename` with CLI (#2802 )	2018-01-17 15:12:22 +08:00
kzc	4f57d8746b	fix various for-of bugs (#2800 ) - disable `rename` pass on harmony due to problem with for-of loops fixes #2794	2018-01-17 14:46:23 +08:00
Alex Lam S.L	79cfac77bd	extend `join_vars` & `sequences` (#2798 )	2018-01-17 13:58:27 +08:00
Alex Lam S.L	224c14d49d	improve `mocha` tests (#2797 ) - workaround sporadic delays from Travis CI	2018-01-16 17:51:25 +08:00
Alex Lam S.L	7857354d85	improve `test/travis-ufuzz.js` (#2795 ) - print usage - support concurrent jobs - improve instance utilisation - resume after V8 self-destruct	2018-01-16 17:33:21 +08:00
Alex Lam S.L	b4aef753e7	general improvements around `AST_ForIn` (#2796 ) - compress using `collapse_vars` - remove unused `name` - simplify `loop_body`	2018-01-16 17:03:12 +08:00
Joël Galeran	424173d311	fix typo in README (#2792 )	2018-01-16 10:29:38 +08:00
Alex Lam S.L	ec7cd1dcf7	handle VM failure gracefully (#2791 )	2018-01-15 23:41:39 +08:00
Alex Lam S.L	7def684730	improve `test/travis-ufuzz.js` (#2789 ) - wait for instance to boot - run on forked repositories - workaround `request_limit_reached`	2018-01-15 19:18:21 +08:00
Alex Lam S.L	10f961c27b	enhance `collapse_vars` (#2788 )	2018-01-15 18:47:23 +08:00
Alex Lam S.L	b483678ca7	avoid suboptimal termination in `passes` (#2787 )	2018-01-15 16:42:31 +08:00
Alex Lam S.L	cbbe6fad60	avoid double counting within single-use functions (#2785 ) fixes #2783	2018-01-15 16:42:15 +08:00
Alex Lam S.L	f96929c031	improve `test/travis-ufuzz.js` (#2786 ) - use more RAM - show progress in console - report failure as job status	2018-01-15 15:08:35 +08:00
Alex Lam S.L	2b6657e967	run `test/ufuzz.js` when Travis CI is idle (#2784 )	2018-01-15 08:52:11 +08:00
Alex Lam S.L	1b2e6b81a2	harmony-v3.3.7	2018-01-14 19:24:49 +08:00
alexlamsl	f9e9898dc1	Merge branch 'master' into harmony-v3.3.7	2018-01-14 17:15:16 +08:00
Alex Lam S.L	7c0c92943f	v3.3.7	2018-01-14 09:13:26 +00:00
Alex Lam S.L	62a66dfff4	fix & extend `join_vars` for object assigments (#2781 )	2018-01-14 17:11:31 +08:00
kzc	c44d78db55	add `block_scope` to `--output ast` (#2780 )	2018-01-14 15:37:18 +08:00
Alex Lam S.L	8c763bf2b5	fix `mangle` of block-scoped variables (#2779 ) fixes #2762	2018-01-14 12:12:29 +08:00
kzc	2cab348341	improve SymbolDef info in `--output ast` (#2778 ) * SymbolDef info (a.k.a. `thedef`) is now represented as a string containing `"ID name [mangled_name]"`. * Enhance display of `globals`, `variables`, `functions` and `enclosed`. * `SymbolDef.next_id` starts at `1` and the `id` is adjusted for `-o ast` display.	2018-01-14 01:40:51 +08:00
Alex Lam S.L	aa1786dedf	harmony-v3.3.6	2018-01-13 23:40:14 +08:00
alexlamsl	0d5df271a1	add tests for #2740	2018-01-13 22:59:01 +08:00
alexlamsl	b56e1f178f	add test for #2747	2018-01-13 22:58:52 +08:00
alexlamsl	9acace2cb6	fix test	2018-01-13 13:57:05 +08:00
alexlamsl	0f2be1456c	Merge branch 'master' into harmony-v3.3.6	2018-01-13 13:53:31 +08:00
Alex Lam S.L	460218a3f8	v3.3.6	2018-01-13 05:37:42 +00:00
Alex Lam S.L	e49416e4aa	fix `reduce_vars` on `AST_Accessor` (#2776 ) fixes #2774	2018-01-13 02:46:14 +08:00
kzc	d4d7d99b70	add SymbolDef IDs to --output ast (#2772 )	2018-01-12 15:41:09 +08:00
Alex Lam S.L	6a696d0a7b	fix output of imported AST (#2771 )	2018-01-12 01:05:49 +08:00
Alex Lam S.L	1c9e13f47d	update dependencies (#2770 ) - acorn@5.3.0 - commander@2.13.0	2018-01-12 00:32:17 +08:00
Alex Lam S.L	b757450cd8	fix nested `unused` assignments (#2769 ) fixes #2768	2018-01-11 23:13:44 +08:00
Alex Lam S.L	23ec484806	fix corner case in #2763 (#2766 )	2018-01-11 21:18:08 +08:00
Alex Lam S.L	f1e1bb419a	join object assignments (#2763 )	2018-01-11 17:08:21 +08:00
Alex Lam S.L	6a0af85c8b	skip only `var`s in `if_return` (#2759 ) fixes #2747	2018-01-10 19:08:46 +08:00
Alex Lam S.L	1eb15f46f1	fix `reduce_vars` with uninitialized `let` variables (#2760 ) fixes #2757	2018-01-10 18:40:54 +08:00
Alex Lam S.L	09269be974	enhance `conditionals` (#2758 ) `x ? y \|\| z : z` --> `x && y \|\| z`	2018-01-10 16:59:57 +08:00
kzc	137cb73d1f	have parser trap `const` declaration without value (#2756 ) fixes #2751	2018-01-10 12:31:46 +08:00
Alex Lam S.L	bf832cde16	improve synergy between `compress` and `rename` (#2755 )	2018-01-09 17:55:41 +08:00
Alex Lam S.L	2972d58dbb	patch variable declaractions extracted within `catch` (#2753 ) fixes #2749	2018-01-09 13:54:35 +08:00
Alex Lam S.L	2e22d38a02	improve `rename` reproducibility (#2754 ) fixes #2752	2018-01-09 13:53:05 +08:00
Alex Lam S.L	ce27bcd69a	compress loops with immediate `break` (#2746 ) fixes #2740	2018-01-08 14:30:18 +08:00