v3.3.10

fixes #2891

CONTRIBUTING.md

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

LICENSE

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

README.md

@@ -70,7 +70,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:
@@ -737,7 +737,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
@@ -749,6 +749,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"`)
 
@@ -922,9 +926,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
 
@@ -1101,3 +1102,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()`).

bin/uglifyjs

@@ -43,6 +43,7 @@ program.option("-d, --define <expr>[=value]", "Global definitions.", parse_js("d
 program.option("--ie8", "Support non-standard Internet Explorer 8.");
 program.option("--keep-fnames", "Do not mangle/drop function names. Useful for code relying on Function.prototype.name.");
 program.option("--name-cache <file>", "File to hold mangled name mappings.");
+program.option("--rename", "Force symbol expansion.");
 program.option("--no-rename", "Disable symbol expansion.");
 program.option("--self", "Build UglifyJS as a library (implies --wrap UglifyJS)");
 program.option("--source-map [options]", "Enable source map/specify source map options.", parse_source_map());
@@ -62,13 +63,11 @@ if (!program.output && program.sourceMap && program.sourceMap.url != "inline") {
     "compress",
     "ie8",
     "mangle",
-    "rename",
     "sourceMap",
     "toplevel",
     "wrap"
 ].forEach(function(name) {
     if (name in program) {
-        if (name == "rename" && program[name]) return;
         options[name] = program[name];
     }
 });
@@ -121,6 +120,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;
 };
@@ -227,28 +231,15 @@ function run() {
             result.ast.figure_out_scope({});
         }
         print(JSON.stringify(result.ast, function(key, value) {
-            switch (key) {
+            if (value) switch (key) {
               case "thedef":
-                if (typeof value == "object" && typeof value.id == "number") {
-                    return value.id;
-                }
-                return;
+                return symdef(value);
               case "enclosed":
-                return value.map(function(sym){
-                    return sym.id;
-                });
+                return value.length ? value.map(symdef) : undefined;
               case "variables":
               case "functions":
               case "globals":
-                if (value && value.size()) {
-                    var ret = {};
-                    value.each(function(val, key) {
-                        // key/val inverted for readability.
-                        ret[val.id] = key;
-                    });
-                    return ret;
-                }
-                return;
+                return value.size() ? value.map(symdef) : undefined;
             }
             if (skip_key(key)) return;
             if (value instanceof UglifyJS.AST_Token) return;
@@ -403,6 +394,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 = "";

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) {
@@ -309,6 +308,13 @@ var AST_Scope = DEFNODE("Scope", "variables functions uses_with uses_eval parent
         enclosed: "[SymbolDef*/S] a list of all symbol definitions that are accessed from this scope or any subscopes",
         cname: "[integer/S] current index for mangling variables (used internally by the mangler)",
     },
+    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);
 
 var AST_Toplevel = DEFNODE("Toplevel", "globals", {
@@ -683,8 +689,8 @@ var AST_Object = DEFNODE("Object", "properties", {
 var AST_ObjectProperty = DEFNODE("ObjectProperty", "key value", {
     $documentation: "Base class for literal object properties",
     $propdoc: {
-        key: "[string] the property name converted to a string for ObjectKeyVal.  For setters and getters this is an AST_SymbolAccessor.",
-        value: "[AST_Node] property value.  For setters and getters this is an AST_Accessor."
+        key: "[string|AST_SymbolAccessor] property name. For ObjectKeyVal this is a string. For getters and setters this is an AST_SymbolAccessor.",
+        value: "[AST_Node] property value.  For getters and setters this is an AST_Accessor."
     },
     _walk: function(visitor) {
         return visitor._visit(this, function(){

lib/output.js

@@ -451,6 +451,11 @@ 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;
@@ -499,7 +504,7 @@ function OutputStream(options) {
 
         comments = comments.filter(comment_filter, node);
         if (comments.length == 0) return;
-        var last_nlb = /(^|\n) *$/.test(OUTPUT);
+        var last_nlb = has_nlb();
         comments.forEach(function(c, i) {
             if (!last_nlb) {
                 if (c.nlb) {
@@ -546,7 +551,7 @@ function OutputStream(options) {
                 print("\n");
                 indent();
                 need_newline_indented = false;
-            } else if (c.nlb && (i > 0 || !/(^|\n) *$/.test(OUTPUT))) {
+            } else if (c.nlb && (i > 0 || !has_nlb())) {
                 print("\n");
                 indent();
             } else if (i > 0 || !tail) {
@@ -1344,11 +1349,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")) {

lib/parse.js

@@ -1054,12 +1054,10 @@ function parse($TEXT, options) {
     };
 
     function for_in(init) {
-        var lhs = init instanceof AST_Var ? init.definitions[0].name : null;
         var obj = expression(true);
         expect(")");
         return new AST_ForIn({
             init   : init,
-            name   : lhs,
             object : obj,
             body   : in_loop(statement)
         });
@@ -1367,7 +1365,7 @@ function parse($TEXT, options) {
             if (type == "name" && !is("punc", ":")) {
                 var key = new AST_SymbolAccessor({
                     start: S.token,
-                    name: as_property_name(),
+                    name: "" + as_property_name(),
                     end: prev()
                 });
                 if (name == "get") {
@@ -1393,7 +1391,7 @@ function parse($TEXT, options) {
             a.push(new AST_ObjectKeyVal({
                 start : start,
                 quote : start.quote,
-                key   : name,
+                key   : "" + name,
                 value : expression(false),
                 end   : prev()
             }));

lib/scope.js

@@ -57,7 +57,7 @@ function SymbolDef(scope, orig, init) {
     this.id = SymbolDef.next_id++;
 };
 
-SymbolDef.next_id = 1e6;
+SymbolDef.next_id = 1;
 
 SymbolDef.prototype = {
     unmangleable: function(options) {
@@ -305,7 +305,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;
 });

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

package.json

@@ -4,7 +4,7 @@
   "homepage": "http://lisperator.net/uglifyjs",
   "author": "Mihai Bazon <mihai.bazon@gmail.com> (http://lisperator.net/)",
   "license": "BSD-2-Clause",
-  "version": "3.3.6",
+  "version": "3.3.10",
   "engines": {
     "node": ">=0.8.0"
   },
@@ -24,13 +24,13 @@
     "LICENSE"
   ],
   "dependencies": {
-    "commander": "~2.13.0",
+    "commander": "~2.14.1",
     "source-map": "~0.6.1"
   },
   "devDependencies": {
-    "acorn": "~5.3.0",
+    "acorn": "~5.4.1",
     "mocha": "~3.5.1",
-    "semver": "~5.4.1"
+    "semver": "~5.5.0"
   },
   "scripts": {
     "test": "node test/run-tests.js"

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();
     }
@@ -4012,3 +4007,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
+}

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"
+}

test/compress/dead-code.js

@@ -862,3 +862,58 @@ issue_2749: {
     }
     expect_stdout: "PASS"
 }
+
+unsafe_builtin: {
+    options = {
+        side_effects: true,
+        unsafe: true,
+    }
+    input: {
+        (!w).constructor(x);
+        Math.abs(y);
+        [ 1, 2, z ].valueOf();
+    }
+    expect: {
+        w, x;
+        y;
+        z;
+    }
+}
+
+issue_2860_1: {
+    options = {
+        dead_code: true,
+        evaluate: true,
+        reduce_vars: true,
+    }
+    input: {
+        console.log(function(a) {
+            return a ^= 1;
+        }());
+    }
+    expect: {
+        console.log(function(a) {
+            return 1 ^ a;
+        }());
+    }
+    expect_stdout: "1"
+}
+
+issue_2860_2: {
+    options = {
+        dead_code: true,
+        evaluate: true,
+        inline: true,
+        passes: 2,
+        reduce_vars: true,
+    }
+    input: {
+        console.log(function(a) {
+            return a ^= 1;
+        }());
+    }
+    expect: {
+        console.log(1);
+    }
+    expect_stdout: "1"
+}

test/compress/drop-unused.js

@@ -1692,3 +1692,30 @@ issue_2768: {
     }
     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"
+}

test/compress/evaluate.js

@@ -1194,6 +1194,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:1191,20]",
+    ]
 }
 
 issue_2231_2: {
@@ -1208,6 +1211,23 @@ issue_2231_2: {
         console.log(Object.getOwnPropertyNames(null));
     }
     expect_stdout: true
+    expect_warnings: [
+        "WARN: Error evaluating Object.getOwnPropertyNames(null) [test/compress/evaluate.js:1208,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: {
@@ -1330,13 +1350,82 @@ issue_2535_3: {
     }
     expect_stdout: true
     expect_warnings: [
-        "WARN: Dropping side-effect-free && [test/compress/evaluate.js:1316,20]",
-        "WARN: Dropping side-effect-free && [test/compress/evaluate.js:1317,20]",
-        "WARN: Dropping side-effect-free && [test/compress/evaluate.js:1318,20]",
-        "WARN: Condition left of && always false [test/compress/evaluate.js:1318,20]",
-        "WARN: Dropping side-effect-free || [test/compress/evaluate.js:1319,20]",
-        "WARN: Dropping side-effect-free || [test/compress/evaluate.js:1320,20]",
-        "WARN: Dropping side-effect-free || [test/compress/evaluate.js:1321,20]",
-        "WARN: Condition left of || always true [test/compress/evaluate.js:1321,20]",
+        "WARN: Dropping side-effect-free && [test/compress/evaluate.js:1336,20]",
+        "WARN: Dropping side-effect-free && [test/compress/evaluate.js:1337,20]",
+        "WARN: Dropping side-effect-free && [test/compress/evaluate.js:1338,20]",
+        "WARN: Condition left of && always false [test/compress/evaluate.js:1338,20]",
+        "WARN: Dropping side-effect-free || [test/compress/evaluate.js:1339,20]",
+        "WARN: Dropping side-effect-free || [test/compress/evaluate.js:1340,20]",
+        "WARN: Dropping side-effect-free || [test/compress/evaluate.js:1341,20]",
+        "WARN: Condition left of || always true [test/compress/evaluate.js:1341,20]",
+    ]
+}
+
+issue_2822: {
+    options = {
+        evaluate: true,
+        unsafe: true,
+    }
+    input: {
+        console.log([ function() {}, "PASS", "FAIL" ][1]);
+    }
+    expect: {
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+string_case: {
+    options = {
+        evaluate: true,
+        unsafe: true,
+    }
+    input: {
+        console.log("İ".toLowerCase().charCodeAt(0));
+        console.log("I".toLowerCase().charCodeAt(0));
+        console.log("Ş".toLowerCase().charCodeAt(0));
+        console.log("Ğ".toLowerCase().charCodeAt(0));
+        console.log("Ü".toLowerCase().charCodeAt(0));
+        console.log("Ö".toLowerCase().charCodeAt(0));
+        console.log("Ç".toLowerCase().charCodeAt(0));
+        console.log("i".toUpperCase().charCodeAt(0));
+        console.log("ı".toUpperCase().charCodeAt(0));
+        console.log("ş".toUpperCase().charCodeAt(0));
+        console.log("ğ".toUpperCase().charCodeAt(0));
+        console.log("ü".toUpperCase().charCodeAt(0));
+        console.log("ö".toUpperCase().charCodeAt(0));
+        console.log("ç".toUpperCase().charCodeAt(0));
+    }
+    expect: {
+        console.log(105);
+        console.log(105);
+        console.log(351);
+        console.log(287);
+        console.log(252);
+        console.log(246);
+        console.log(231);
+        console.log(73);
+        console.log(73);
+        console.log(350);
+        console.log(286);
+        console.log(220);
+        console.log(214);
+        console.log(199);
+    }
+    expect_stdout: [
+        "105",
+        "105",
+        "351",
+        "287",
+        "252",
+        "246",
+        "231",
+        "73",
+        "73",
+        "350",
+        "286",
+        "220",
+        "214",
+        "199",
     ]
 }

test/compress/functions.js

@@ -218,7 +218,7 @@ issue_203: {
     options = {
         keep_fargs: false,
         side_effects: true,
-        unsafe_Func: true,
+        unsafe_Function: true,
         unused: true,
     }
     input: {
@@ -1951,3 +1951,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"
+}

test/compress/hoist_props.js

@@ -664,3 +664,25 @@ issue_2519: {
     }
     expect_stdout: "5.5"
 }
+
+undefined_key: {
+    options = {
+        evaluate: true,
+        hoist_props: true,
+        join_vars: true,
+        passes: 4,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a, o = {};
+        o[a] = 1;
+        o.b = 2;
+        console.log(o[a] + o.b);
+    }
+    expect: {
+        console.log(3);
+    }
+    expect_stdout: "3"
+}

test/compress/issue-1443.js

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

test/compress/issue-1588.js

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

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"]);',

test/compress/issue-2871.js

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

test/compress/properties.js

@@ -583,6 +583,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;
@@ -1188,3 +1207,384 @@ join_object_assignments_3: {
     }
     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"
+}

test/compress/pure_getters.js

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

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
@@ -5302,3 +5314,222 @@ issue_2774: {
     }
     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"
+}

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) {
@@ -859,3 +859,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"
+}

test/input/rename/input.js

@@ -0,0 +1,6 @@
+function f(x) {
+    return g(x);
+    function g(x) {
+        return x;
+    }
+}

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
+// Add each .js file to the Mocha instance
 fs.readdirSync(testDir).filter(function(file) {
-    // Only keep the .js files
-    return file.substr(-3) === '.js';
-
+    return /\.js$/.test(file);
 }).forEach(function(file) {
-    mocha.addFile(
-        path.join(testDir, file)
-    );
+    mocha.addFile(path.join(testDir, file));
 });
 
 module.exports = function() {
     mocha.run(function(failures) {
-        if (failures !== 0) {
-            process.on('exit', function () {
+        if (failures) process.on("exit", function() {
             process.exit(failures);
         });
-        }
     });
 };

test/mocha/cli.js

@@ -650,4 +650,36 @@ describe("bin/uglifyjs", function () {
             done();
         });
     });
+    it("Should work with explicit --rename", function(done) {
+        var command = uglifyjscmd + " test/input/rename/input.js --rename";
+        exec(command, function(err, stdout, stderr) {
+            if (err) throw err;
+            assert.strictEqual(stdout, "function f(a){return b(a);function b(c){return c}}\n");
+            done();
+        });
+    });
+    it("Should work with explicit --no-rename", function(done) {
+        var command = uglifyjscmd + " test/input/rename/input.js -mc --no-rename";
+        exec(command, function(err, stdout, stderr) {
+            if (err) throw err;
+            assert.strictEqual(stdout, "function f(n){return function(n){return n}(n)}\n");
+            done();
+        });
+    });
+    it("Should work with implicit --rename", function(done) {
+        var command = uglifyjscmd + " test/input/rename/input.js -mc";
+        exec(command, function(err, stdout, stderr) {
+            if (err) throw err;
+            assert.strictEqual(stdout, "function f(n){return n}\n");
+            done();
+        });
+    });
+    it("Should work with implicit --no-rename", function(done) {
+        var command = uglifyjscmd + " test/input/rename/input.js -c";
+        exec(command, function(err, stdout, stderr) {
+            if (err) throw err;
+            assert.strictEqual(stdout, "function f(x){return function(x){return x}(x)}\n");
+            done();
+        });
+    });
 });

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);
 };

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);
+    }
+}

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);
     }
 }

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