v2.8.9

Function expression can be assigned to a variable and be given a name. Ensure function name is the reduced variable before clearing it out.

fixes #1573
fixes #1575

.travis.yml

@@ -1,10 +1,13 @@
 language: node_js
 before_install: "npm install -g npm"
 node_js:
-    - "0.12"
     - "0.10"
+    - "0.12"
     - "4"
     - "6"
+    - "7"
+env:
+    - UGLIFYJS_TEST_ALL=1
 matrix:
   fast_finish: true
 sudo: false

lib/ast.js

@@ -91,9 +91,20 @@ var AST_Token = DEFNODE("Token", "type value line col pos endline endcol endpos
 }, null);
 
 var AST_Node = DEFNODE("Node", "start end", {
-    clone: function() {
+    _clone: function(deep) {
+        if (deep) {
+            var self = this.clone();
+            return self.transform(new TreeTransformer(function(node) {
+                if (node !== self) {
+                    return node.clone(true);
+                }
+            }));
+        }
         return new this.CTOR(this);
     },
+    clone: function(deep) {
+        return this._clone(deep);
+    },
     $documentation: "Base class of all AST nodes",
     $propdoc: {
         start: "[AST_Token] The first token of this node",
@@ -199,6 +210,20 @@ var AST_LabeledStatement = DEFNODE("LabeledStatement", "label", {
             this.label._walk(visitor);
             this.body._walk(visitor);
         });
+    },
+    clone: function(deep) {
+        var node = this._clone(deep);
+        if (deep) {
+            var refs = node.label.references;
+            var label = this.label;
+            node.walk(new TreeWalker(function(node) {
+                if (node instanceof AST_LoopControl
+                    && node.label && node.label.thedef === label) {
+                    refs.push(node);
+                }
+            }));
+        }
+        return node;
     }
 }, AST_StatementWithBody);
 

lib/compress.js

@@ -223,6 +223,7 @@ merge(Compressor.prototype, {
 
     AST_Node.DEFMETHOD("reset_opt_flags", function(compressor, rescan){
         var reduce_vars = rescan && compressor.option("reduce_vars");
+        var toplevel = compressor.option("toplevel");
         var ie8 = !compressor.option("screw_ie8");
         var safe_ids = [];
         push();
@@ -244,7 +245,8 @@ merge(Compressor.prototype, {
                 if (node instanceof AST_SymbolRef) {
                     var d = node.definition();
                     d.references.push(node);
-                    if (!d.fixed || isModified(node, 0) || !is_safe(d)) {
+                    if (!d.fixed || !is_safe(d)
+                        || is_modified(node, 0, d.fixed instanceof AST_Lambda)) {
                         d.fixed = false;
                     }
                 }
@@ -260,6 +262,21 @@ merge(Compressor.prototype, {
                         d.fixed = false;
                     }
                 }
+                if (node instanceof AST_Defun) {
+                    var d = node.name.definition();
+                    if (!toplevel && d.global || is_safe(d)) {
+                        d.fixed = false;
+                    } else {
+                        d.fixed = node;
+                        mark_as_safe(d);
+                    }
+                    var save_ids = safe_ids;
+                    safe_ids = [];
+                    push();
+                    descend();
+                    safe_ids = save_ids;
+                    return true;
+                }
                 var iife;
                 if (node instanceof AST_Function
                     && (iife = tw.parent()) instanceof AST_Call
@@ -334,18 +351,22 @@ merge(Compressor.prototype, {
         }
 
         function reset_def(def) {
-            def.fixed = undefined;
+            if (toplevel || !def.global || def.orig[0] instanceof AST_SymbolConst) {
+                def.fixed = undefined;
+            } else {
+                def.fixed = false;
+            }
             def.references = [];
             def.should_replace = undefined;
         }
 
-        function isModified(node, level) {
+        function is_modified(node, level, func) {
             var parent = tw.parent(level);
             if (isLHS(node, parent)
-                || parent instanceof AST_Call && parent.expression === node) {
+                || !func && parent instanceof AST_Call && parent.expression === node) {
                 return true;
             } else if (parent instanceof AST_PropAccess && parent.expression === node) {
-                return isModified(parent, level + 1);
+                return !func && is_modified(parent, level + 1);
             }
         }
     });
@@ -535,10 +556,13 @@ merge(Compressor.prototype, {
                     // Constant single use vars can be replaced in any scope.
                     if (var_decl.value.is_constant()) {
                         var ctt = new TreeTransformer(function(node) {
-                            if (node === ref
-                                && !ctt.find_parent(AST_ForIn)) {
-                                return replace_var(node, ctt.parent(), true);
+                            var parent = ctt.parent();
+                            if (parent instanceof AST_IterationStatement
+                                && (parent.condition === node || parent.init === node)) {
+                                return node;
                             }
+                            if (node === ref)
+                                return replace_var(node, parent, true);
                         });
                         stat.transform(ctt);
                         continue;
@@ -1299,14 +1323,7 @@ merge(Compressor.prototype, {
         def(AST_Statement, function(){
             throw new Error(string_template("Cannot evaluate a statement [{file}:{line},{col}]", this.start));
         });
-        // XXX: AST_Accessor and AST_Function both inherit from AST_Scope,
-        // which itself inherits from AST_Statement; however, they aren't
-        // really statements.  This could bite in other places too. :-(
-        // Wish JS had multiple inheritance.
-        def(AST_Accessor, function(){
-            throw def;
-        });
-        def(AST_Function, function(){
+        def(AST_Lambda, function(){
             throw def;
         });
         function ev(node, compressor) {
@@ -2083,7 +2100,8 @@ merge(Compressor.prototype, {
         def(AST_This, return_null);
         def(AST_Call, function(compressor, first_in_statement){
             if (!this.has_pure_annotation(compressor) && compressor.pure_funcs(this)) {
-                if (this.expression instanceof AST_Function) {
+                if (this.expression instanceof AST_Function
+                    && (!this.expression.name || !this.expression.name.definition().references.length)) {
                     var node = this.clone();
                     node.expression = node.expression.process_expression(false);
                     return node;
@@ -2582,6 +2600,25 @@ merge(Compressor.prototype, {
 
     OPT(AST_Call, function(self, compressor){
         var exp = self.expression;
+        if (compressor.option("reduce_vars")
+            && exp instanceof AST_SymbolRef) {
+            var def = exp.definition();
+            if (def.fixed instanceof AST_Defun) {
+                def.fixed = make_node(AST_Function, def.fixed, def.fixed).clone(true);
+            }
+            if (def.fixed instanceof AST_Function) {
+                exp = def.fixed;
+                if (compressor.option("unused")
+                    && def.references.length == 1
+                    && compressor.find_parent(AST_Scope) === def.scope) {
+                    if (!compressor.option("keep_fnames")
+                        && exp.name && exp.name.definition() === def) {
+                        exp.name = null;
+                    }
+                    self.expression = exp;
+                }
+            }
+        }
         if (compressor.option("unused")
             && exp instanceof AST_Function
             && !exp.uses_arguments
@@ -2833,7 +2870,7 @@ merge(Compressor.prototype, {
             if (self.car instanceof AST_Assign
                 && !self.car.left.has_side_effects(compressor)) {
                 left = self.car.left;
-            } else if (self.car instanceof AST_UnaryPostfix
+            } else if (self.car instanceof AST_Unary
                 && (self.car.operator == "++" || self.car.operator == "--")) {
                 left = self.car.expression;
             }
@@ -2842,11 +2879,15 @@ merge(Compressor.prototype, {
                 var cdr = self.cdr;
                 while (true) {
                     if (cdr.equivalent_to(left)) {
+                        var car = self.car instanceof AST_UnaryPostfix ? make_node(AST_UnaryPrefix, self.car, {
+                            operator: self.car.operator,
+                            expression: left
+                        }) : self.car;
                         if (parent) {
-                            parent[field] = self.car;
+                            parent[field] = car;
                             return self.cdr;
                         }
-                        return self.car;
+                        return car;
                     }
                     if (cdr instanceof AST_Binary && !(cdr instanceof AST_Assign)) {
                         field = cdr.left.is_constant() ? "right" : "left";

lib/output.js

@@ -777,7 +777,7 @@ function OutputStream(options) {
     DEFPRINT(AST_Do, function(self, output){
         output.print("do");
         output.space();
-        self._do_print_body(output);
+        make_block(self.body, output);
         output.space();
         output.print("while");
         output.space();
@@ -904,10 +904,10 @@ function OutputStream(options) {
 
     /* -----[ if ]----- */
     function make_then(self, output) {
-        if (output.option("bracketize")) {
-            make_block(self.body, output);
-            return;
-        }
+        var b = self.body;
+        if (output.option("bracketize")
+            || !output.option("screw_ie8") && b instanceof AST_Do)
+            return make_block(b, output);
         // The squeezer replaces "block"-s that contain only a single
         // statement with the statement itself; technically, the AST
         // is correct, but this can create problems when we output an
@@ -915,18 +915,7 @@ function OutputStream(options) {
         // IF *without* an ELSE block (then the outer ELSE would refer
         // to the inner IF).  This function checks for this case and
         // adds the block brackets if needed.
-        if (!self.body)
-            return output.force_semicolon();
-        if (self.body instanceof AST_Do) {
-            // Unconditionally use the if/do-while workaround for all browsers.
-            // https://github.com/mishoo/UglifyJS/issues/#issue/57 IE
-            // croaks with "syntax error" on code like this: if (foo)
-            // do ... while(cond); else ...  we need block brackets
-            // around do/while
-            make_block(self.body, output);
-            return;
-        }
-        var b = self.body;
+        if (!b) return output.force_semicolon();
         while (true) {
             if (b instanceof AST_If) {
                 if (!b.alternative) {
@@ -1335,15 +1324,7 @@ function OutputStream(options) {
 
     function force_statement(stat, output) {
         if (output.option("bracketize")) {
-            if (!stat || stat instanceof AST_EmptyStatement)
-                output.print("{}");
-            else if (stat instanceof AST_BlockStatement)
-                stat.print(output);
-            else output.with_block(function(){
-                output.indent();
-                stat.print(output);
-                output.newline();
-            });
+            make_block(stat, output);
         } else {
             if (!stat || stat instanceof AST_EmptyStatement)
                 output.force_semicolon();
@@ -1392,11 +1373,11 @@ function OutputStream(options) {
     };
 
     function make_block(stmt, output) {
-        if (stmt instanceof AST_BlockStatement) {
+        if (!stmt || stmt instanceof AST_EmptyStatement)
+            output.print("{}");
+        else if (stmt instanceof AST_BlockStatement)
             stmt.print(output);
-            return;
-        }
-        output.with_block(function(){
+        else output.with_block(function(){
             output.indent();
             stmt.print(output);
             output.newline();

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": "2.8.6",
+  "version": "2.8.9",
   "engines": {
     "node": ">=0.8.0"
   },

test/benchmark.js

@@ -24,26 +24,57 @@ var results = {};
 var remaining = 2 * urls.length;
 function done() {
     if (!--remaining) {
+        var failures = [];
         urls.forEach(function(url) {
+            var info = results[url];
             console.log();
             console.log(url);
-            console.log(results[url].time);
-            console.log("SHA1:", results[url].sha1);
+            console.log(info.log);
+            var elapsed = 0;
+            info.log.replace(/: ([0-9]+\.[0-9]{3})s/g, function(match, time) {
+                elapsed += parseFloat(time);
+            });
+            console.log("Run-time:", elapsed.toFixed(3), "s");
+            console.log("Original:", info.input, "bytes");
+            console.log("Uglified:", info.output, "bytes");
+            console.log("SHA1 sum:", info.sha1);
+            if (info.code) {
+                failures.push(url);
+            }
         });
+        if (failures.length) {
+            console.error("Benchmark failed:");
+            failures.forEach(function(url) {
+                console.error(url);
+            });
+            process.exit(1);
+        }
     }
 }
 urls.forEach(function(url) {
-    results[url] = { time: "" };
+    results[url] = {
+        input: 0,
+        output: 0,
+        log: ""
+    };
     require(url.slice(0, url.indexOf(":"))).get(url, function(res) {
         var uglifyjs = fork("bin/uglifyjs", args, { silent: true });
-        res.pipe(uglifyjs.stdin);
-        uglifyjs.stdout.pipe(createHash("sha1")).on("data", function(data) {
+        res.on("data", function(data) {
+            results[url].input += data.length;
+        }).pipe(uglifyjs.stdin);
+        uglifyjs.stdout.on("data", function(data) {
+            results[url].output += data.length;
+        }).pipe(createHash("sha1")).on("data", function(data) {
             results[url].sha1 = data.toString("hex");
             done();
         });
         uglifyjs.stderr.setEncoding("utf8");
         uglifyjs.stderr.on("data", function(data) {
-            results[url].time += data;
-        }).on("end", done)
+            results[url].log += data;
+        });
+        uglifyjs.on("exit", function(code) {
+            results[url].code = code;
+            done();
+        });
     });
 });

test/compress/collapse_vars.js

@@ -344,9 +344,9 @@ collapse_vars_do_while: {
     }
     input: {
         function f1(y) {
-            // The constant do-while condition `c` will be replaced.
+            // The constant do-while condition `c` will not be replaced.
             var c = 9;
-            do { } while (c === 77);
+            do {} while (c === 77);
         }
         function f2(y) {
             // The non-constant do-while condition `c` will not be replaced.
@@ -381,7 +381,8 @@ collapse_vars_do_while: {
     }
     expect: {
         function f1(y) {
-            do ; while (false);
+            var c = 9;
+            do ; while (77 === c);
         }
         function f2(y) {
             var c = 5 - y;
@@ -418,9 +419,9 @@ collapse_vars_do_while_drop_assign: {
     }
     input: {
         function f1(y) {
-            // The constant do-while condition `c` will be replaced.
+            // The constant do-while condition `c` will be not replaced.
             var c = 9;
-            do { } while (c === 77);
+            do {} while (c === 77);
         }
         function f2(y) {
             // The non-constant do-while condition `c` will not be replaced.
@@ -455,7 +456,8 @@ collapse_vars_do_while_drop_assign: {
     }
     expect: {
         function f1(y) {
-            do ; while (false);
+            var c = 9;
+            do ; while (77 === c);
         }
         function f2(y) {
             var c = 5 - y;
@@ -1309,8 +1311,8 @@ collapse_vars_regexp: {
             };
         }
         (function(){
-            var result, rx = /ab*/g;
-            while (result = rx.exec('acdabcdeabbb'))
+            var result, s = "acdabcdeabbb", rx = /ab*/g;
+            while (result = rx.exec(s))
                 console.log(result[0]);
         })();
     }
@@ -1329,3 +1331,35 @@ issue_1537: {
         for (k in {prop: 'val'});
     }
 }
+
+issue_1562: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var v = 1, B = 2;
+        for (v in objs) f(B);
+
+        var x = 3, C = 10;
+        while(x + 2) bar(C);
+
+        var y = 4, D = 20;
+        do bar(D); while(y + 2);
+
+        var z = 5, E = 30;
+        for (; f(z + 2) ;) bar(E);
+    }
+    expect: {
+        var v = 1;
+        for (v in objs) f(2);
+
+        var x = 3;
+        while(x + 2) bar(10);
+
+        var y = 4;
+        do bar(20); while(y + 2);
+
+        var z = 5;
+        for (; f(z + 2) ;) bar(30);
+    }
+}

test/compress/dead-code.js

@@ -123,6 +123,7 @@ dead_code_const_annotation: {
         conditionals : true,
         evaluate     : true,
         reduce_vars  : true,
+        toplevel     : true,
     };
     input: {
         var unused;
@@ -172,6 +173,7 @@ dead_code_const_annotation_complex_scope: {
         conditionals : true,
         evaluate     : true,
         reduce_vars  : true,
+        toplevel     : true,
     };
     input: {
         var unused_var;

test/compress/issue-1569.js

@@ -0,0 +1,19 @@
+inner_reference: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        !function f(a) {
+            return a && f(a - 1) + a;
+        }(42);
+        !function g(a) {
+            return a;
+        }(42);
+    }
+    expect: {
+        !function f(a) {
+            return a && f(a - 1) + a;
+        }(42);
+        !void 0;
+    }
+}

test/compress/issue-368.js

@@ -21,6 +21,16 @@ collapse: {
             var a;
             a = b(a / 2);
             if (a < 0) {
+                a++;
+                ++c;
+                return c / 2;
+            }
+        }
+        function f4(c) {
+            var a;
+            a = b(a / 2);
+            if (a < 0) {
+                a++;
                 c++;
                 return c / 2;
             }
@@ -35,7 +45,11 @@ collapse: {
         }
         function f3(c) {
             var a;
-            if ((a = b(a / 2)) < 0) return c++ / 2;
+            if ((a = b(a / 2)) < 0) return a++, ++c / 2;
+        }
+        function f4(c) {
+            var a;
+            if ((a = b(a / 2)) < 0) return a++, ++c / 2;
         }
     }
 }

test/compress/loops.js

@@ -240,3 +240,159 @@ issue_1532: {
         }
     }
 }
+
+issue_186: {
+    beautify = {
+        beautify: false,
+        screw_ie8: true,
+    }
+    input: {
+        var x = 3;
+        if (foo())
+            do
+                do
+                    alert(x);
+                while (--x);
+            while (x);
+        else
+            bar();
+    }
+    expect_exact: 'var x=3;if(foo())do{do{alert(x)}while(--x)}while(x);else bar();'
+}
+
+issue_186_ie8: {
+    beautify = {
+        beautify: false,
+        screw_ie8: false,
+    }
+    input: {
+        var x = 3;
+        if (foo())
+            do
+                do
+                    alert(x);
+                while (--x);
+            while (x);
+        else
+            bar();
+    }
+    expect_exact: 'var x=3;if(foo()){do{do{alert(x)}while(--x)}while(x)}else bar();'
+}
+
+issue_186_beautify: {
+    beautify = {
+        beautify: true,
+        screw_ie8: true,
+    }
+    input: {
+        var x = 3;
+        if (foo())
+            do
+                do
+                    alert(x);
+                while (--x);
+            while (x);
+        else
+            bar();
+    }
+    expect_exact: 'var x = 3;\n\nif (foo()) do {\n    do {\n        alert(x);\n    } while (--x);\n} while (x); else bar();'
+}
+
+issue_186_beautify_ie8: {
+    beautify = {
+        beautify: true,
+        screw_ie8: false,
+    }
+    input: {
+        var x = 3;
+        if (foo())
+            do
+                do
+                    alert(x);
+                while (--x);
+            while (x);
+        else
+            bar();
+    }
+    expect_exact: 'var x = 3;\n\nif (foo()) {\n    do {\n        do {\n            alert(x);\n        } while (--x);\n    } while (x);\n} else bar();'
+}
+
+issue_186_bracketize: {
+    beautify = {
+        beautify: false,
+        bracketize: true,
+        screw_ie8: true,
+    }
+    input: {
+        var x = 3;
+        if (foo())
+            do
+                do
+                    alert(x);
+                while (--x);
+            while (x);
+        else
+            bar();
+    }
+    expect_exact: 'var x=3;if(foo()){do{do{alert(x)}while(--x)}while(x)}else{bar()}'
+}
+
+issue_186_bracketize_ie8: {
+    beautify = {
+        beautify: false,
+        bracketize: true,
+        screw_ie8: false,
+    }
+    input: {
+        var x = 3;
+        if (foo())
+            do
+                do
+                    alert(x);
+                while (--x);
+            while (x);
+        else
+            bar();
+    }
+    expect_exact: 'var x=3;if(foo()){do{do{alert(x)}while(--x)}while(x)}else{bar()}'
+}
+
+issue_186_beautify_bracketize: {
+    beautify = {
+        beautify: true,
+        bracketize: true,
+        screw_ie8: true,
+    }
+    input: {
+        var x = 3;
+        if (foo())
+            do
+                do
+                    alert(x);
+                while (--x);
+            while (x);
+        else
+            bar();
+    }
+    expect_exact: 'var x = 3;\n\nif (foo()) {\n    do {\n        do {\n            alert(x);\n        } while (--x);\n    } while (x);\n} else {\n    bar();\n}'
+}
+
+issue_186_beautify_bracketize_ie8: {
+    beautify = {
+        beautify: true,
+        bracketize: true,
+        screw_ie8: false,
+    }
+    input: {
+        var x = 3;
+        if (foo())
+            do
+                do
+                    alert(x);
+                while (--x);
+            while (x);
+        else
+            bar();
+    }
+    expect_exact: 'var x = 3;\n\nif (foo()) {\n    do {\n        do {\n            alert(x);\n        } while (--x);\n    } while (x);\n} else {\n    bar();\n}'
+}

test/compress/reduce_vars.js

@@ -6,6 +6,7 @@ reduce_vars: {
             C : 0
         },
         reduce_vars   : true,
+        toplevel      : true,
         unused        : true
     }
     input: {
@@ -452,22 +453,26 @@ multi_def_2: {
         reduce_vars: true,
     }
     input: {
-        if (code == 16)
-            var bitsLength = 2, bitsOffset = 3, what = len;
-        else if (code == 17)
-            var bitsLength = 3, bitsOffset = 3, what = (len = 0);
-        else if (code == 18)
-            var bitsLength = 7, bitsOffset = 11, what = (len = 0);
-        var repeatLength = this.getBits(bitsLength) + bitsOffset;
+        function f(){
+            if (code == 16)
+                var bitsLength = 2, bitsOffset = 3, what = len;
+            else if (code == 17)
+                var bitsLength = 3, bitsOffset = 3, what = (len = 0);
+            else if (code == 18)
+                var bitsLength = 7, bitsOffset = 11, what = (len = 0);
+            var repeatLength = this.getBits(bitsLength) + bitsOffset;
+        }
     }
     expect: {
-        if (16 == code)
-            var bitsLength = 2, bitsOffset = 3, what = len;
-        else if (17 == code)
-            var bitsLength = 3, bitsOffset = 3, what = (len = 0);
-        else if (18 == code)
-            var bitsLength = 7, bitsOffset = 11, what = (len = 0);
-        var repeatLength = this.getBits(bitsLength) + bitsOffset;
+        function f(){
+            if (16 == code)
+                var bitsLength = 2, bitsOffset = 3, what = len;
+            else if (17 == code)
+                var bitsLength = 3, bitsOffset = 3, what = (len = 0);
+            else if (18 == code)
+                var bitsLength = 7, bitsOffset = 11, what = (len = 0);
+            var repeatLength = this.getBits(bitsLength) + bitsOffset;
+        }
     }
 }
 
@@ -477,12 +482,16 @@ use_before_var: {
         reduce_vars: true,
     }
     input: {
-        console.log(t);
-        var t = 1;
+        function f(){
+            console.log(t);
+            var t = 1;
+        }
     }
     expect: {
-        console.log(t);
-        var t = 1;
+        function f(){
+            console.log(t);
+            var t = 1;
+        }
     }
 }
 
@@ -492,22 +501,20 @@ inner_var_if: {
         reduce_vars: true,
     }
     input: {
-        function f(){
-            return 0;
+        function f(a){
+            if (a)
+                var t = 1;
+            if (!t)
+                console.log(t);
         }
-        if (f())
-            var t = 1;
-        if (!t)
-            console.log(t);
     }
     expect: {
-        function f(){
-            return 0;
+        function f(a){
+            if (a)
+                var t = 1;
+            if (!t)
+                console.log(t);
         }
-        if (f())
-            var t = 1;
-        if (!t)
-            console.log(t);
     }
 }
 
@@ -517,24 +524,22 @@ inner_var_label: {
         reduce_vars: true,
     }
     input: {
-        function f(){
-            return 1;
+        function f(a){
+            l: {
+                if (a) break l;
+                var t = 1;
+            }
+            console.log(t);
         }
-        l: {
-            if (f()) break l;
-            var t = 1;
-        }
-        console.log(t);
     }
     expect: {
-        function f(){
-            return 1;
+        function f(a){
+            l: {
+                if (a) break l;
+                var t = 1;
+            }
+            console.log(t);
         }
-        l: {
-            if (f()) break l;
-            var t = 1;
-        }
-        console.log(t);
     }
 }
 
@@ -544,22 +549,26 @@ inner_var_for: {
         reduce_vars: true,
     }
     input: {
-        var a = 1;
-        x(a, b, d);
-        for (var b = 2, c = 3; x(a, b, c, d); x(a, b, c, d)) {
-            var d = 4, e = 5;
+        function f() {
+            var a = 1;
+            x(a, b, d);
+            for (var b = 2, c = 3; x(a, b, c, d); x(a, b, c, d)) {
+                var d = 4, e = 5;
+                x(a, b, c, d, e);
+            }
             x(a, b, c, d, e);
         }
-        x(a, b, c, d, e)
     }
     expect: {
-        var a = 1;
-        x(1, b, d);
-        for (var b = 2, c = 3; x(1, b, 3, d); x(1, b, 3, d)) {
-            var d = 4, e = 5;
+        function f() {
+            var a = 1;
+            x(1, b, d);
+            for (var b = 2, c = 3; x(1, b, 3, d); x(1, b, 3, d)) {
+                var d = 4, e = 5;
+                x(1, b, 3, d, e);
+            }
             x(1, b, 3, d, e);
         }
-        x(1, b, 3, d, e);
     }
 }
 
@@ -569,24 +578,28 @@ inner_var_for_in_1: {
         reduce_vars: true,
     }
     input: {
-        var a = 1, b = 2;
-        for (b in (function() {
-            return x(a, b, c);
-        })()) {
-            var c = 3, d = 4;
+        function f() {
+            var a = 1, b = 2;
+            for (b in (function() {
+                return x(a, b, c);
+            })()) {
+                var c = 3, d = 4;
+                x(a, b, c, d);
+            }
             x(a, b, c, d);
         }
-        x(a, b, c, d);
     }
     expect: {
-        var a = 1, b = 2;
-        for (b in (function() {
-            return x(1, b, c);
-        })()) {
-            var c = 3, d = 4;
+        function f() {
+            var a = 1, b = 2;
+            for (b in (function() {
+                return x(1, b, c);
+            })()) {
+                var c = 3, d = 4;
+                x(1, b, c, d);
+            }
             x(1, b, c, d);
         }
-        x(1, b, c, d);
     }
 }
 
@@ -596,12 +609,16 @@ inner_var_for_in_2: {
         reduce_vars: true,
     }
     input: {
-        for (var long_name in {})
-            console.log(long_name);
+        function f() {
+            for (var long_name in {})
+                console.log(long_name);
+        }
     }
     expect: {
-        for (var long_name in {})
-            console.log(long_name);
+        function f() {
+            for (var long_name in {})
+                console.log(long_name);
+        }
     }
 }
 
@@ -611,20 +628,24 @@ inner_var_catch: {
         reduce_vars: true,
     }
     input: {
-        try {
-            a();
-        } catch (e) {
-            var b = 1;
+        function f() {
+            try {
+                a();
+            } catch (e) {
+                var b = 1;
+            }
+            console.log(b);
         }
-        console.log(b);
     }
     expect: {
-        try {
-            a();
-        } catch (e) {
-            var b = 1;
+        function f() {
+            try {
+                a();
+            } catch (e) {
+                var b = 1;
+            }
+            console.log(b);
         }
-        console.log(b);
     }
 }
 
@@ -634,14 +655,18 @@ issue_1533_1: {
         reduce_vars: true,
     }
     input: {
-        var id = "";
-        for (id in {break: "me"})
-            console.log(id);
+        function f() {
+            var id = "";
+            for (id in {break: "me"})
+                console.log(id);
+        }
     }
     expect: {
-        var id = "";
-        for (id in {break: "me"})
-            console.log(id);
+        function f() {
+            var id = "";
+            for (id in {break: "me"})
+                console.log(id);
+        }
     }
 }
 
@@ -651,15 +676,471 @@ issue_1533_2: {
         reduce_vars: true,
     }
     input: {
-        var id = "";
-        for (var id in {break: "me"})
+        function f() {
+            var id = "";
+            for (var id in {break: "me"})
+                console.log(id);
             console.log(id);
-        console.log(id);
+        }
     }
     expect: {
-        var id = "";
-        for (var id in {break: "me"})
+        function f() {
+            var id = "";
+            for (var id in {break: "me"})
+                console.log(id);
             console.log(id);
-        console.log(id);
+        }
+    }
+}
+
+toplevel_on: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel:true,
+        unused: true,
+    }
+    input: {
+        var x = 3;
+        console.log(x);
+    }
+    expect: {
+        console.log(3);
+    }
+}
+
+toplevel_off: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel:false,
+        unused: true,
+    }
+    input: {
+        var x = 3;
+        console.log(x);
+    }
+    expect: {
+        var x = 3;
+        console.log(x);
+    }
+}
+
+toplevel_on_loops_1: {
+    options = {
+        evaluate: true,
+        loops: true,
+        reduce_vars: true,
+        toplevel:true,
+        unused: true,
+    }
+    input: {
+        function bar() {
+            console.log("bar:", --x);
+        }
+        var x = 3;
+        do
+            bar();
+        while (x);
+    }
+    expect: {
+        var x = 3;
+        do
+            (function() {
+                console.log("bar:", --x);
+            })();
+        while (x);
+    }
+}
+
+toplevel_off_loops_1: {
+    options = {
+        evaluate: true,
+        loops: true,
+        reduce_vars: true,
+        toplevel:false,
+        unused: true,
+    }
+    input: {
+        function bar() {
+            console.log("bar:", --x);
+        }
+        var x = 3;
+        do
+            bar();
+        while (x);
+    }
+    expect: {
+        function bar() {
+            console.log("bar:", --x);
+        }
+        var x = 3;
+        do
+            bar();
+        while (x);
+    }
+}
+
+toplevel_on_loops_2: {
+    options = {
+        evaluate: true,
+        loops: true,
+        reduce_vars: true,
+        toplevel:true,
+        unused: true,
+    }
+    input: {
+        function bar() {
+            console.log("bar:");
+        }
+        var x = 3;
+        do
+            bar();
+        while (x);
+    }
+    expect: {
+        for (;;) (function() {
+            console.log("bar:");
+        })();
+    }
+}
+
+toplevel_off_loops_2: {
+    options = {
+        evaluate: true,
+        loops: true,
+        reduce_vars: true,
+        toplevel:false,
+        unused: true,
+    }
+    input: {
+        function bar() {
+            console.log("bar:");
+        }
+        var x = 3;
+        do
+            bar();
+        while (x);
+    }
+    expect: {
+        function bar() {
+            console.log("bar:");
+        }
+        var x = 3;
+        do
+            bar();
+        while (x);
+    }
+}
+
+toplevel_on_loops_3: {
+    options = {
+        evaluate: true,
+        loops: true,
+        reduce_vars: true,
+        toplevel:true,
+        unused: true,
+    }
+    input: {
+        var x = 3;
+        while (x) bar();
+    }
+    expect: {
+        for (;;) bar();
+    }
+}
+
+toplevel_off_loops_3: {
+    options = {
+        evaluate: true,
+        loops: true,
+        reduce_vars: true,
+        toplevel:false,
+        unused: true,
+    }
+    input: {
+        var x = 3;
+        while (x) bar();
+    }
+    expect: {
+        var x = 3;
+        for (;x;) bar();
+    }
+}
+
+defun_reference: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+    }
+    input: {
+        function f() {
+            function g() {
+                x();
+                return a;
+            }
+            var a = h();
+            var b = 2;
+            return a + b;
+            function h() {
+                y();
+                return b;
+            }
+        }
+    }
+    expect: {
+        function f() {
+            function g() {
+                x();
+                return a;
+            }
+            var a = h();
+            var b = 2;
+            return a + b;
+            function h() {
+                y();
+                return b;
+            }
+        }
+    }
+}
+
+defun_inline_1: {
+    options = {
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            return g(2) + h();
+            function g(b) {
+                return b;
+            }
+            function h() {
+                return h();
+            }
+        }
+    }
+    expect: {
+        function f() {
+            return function(b) {
+                return b;
+            }(2) + h();
+            function h() {
+                return h();
+            }
+        }
+    }
+}
+
+defun_inline_2: {
+    options = {
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            function g(b) {
+                return b;
+            }
+            function h() {
+                return h();
+            }
+            return g(2) + h();
+        }
+    }
+    expect: {
+        function f() {
+            function h() {
+                return h();
+            }
+            return function(b) {
+                return b;
+            }(2) + h();
+        }
+    }
+}
+
+defun_inline_3: {
+    options = {
+        evaluate: true,
+        passes: 2,
+        reduce_vars: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            return g(2);
+            function g(b) {
+                return b;
+            }
+        }
+    }
+    expect: {
+        function f() {
+            return 2;
+        }
+    }
+}
+
+defun_call: {
+    options = {
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            return g() + h(1) - h(g(), 2, 3);
+            function g() {
+                return 4;
+            }
+            function h(a) {
+                return a;
+            }
+        }
+    }
+    expect: {
+        function f() {
+            return 4 + h(1) - h(4);
+            function h(a) {
+                return a;
+            }
+        }
+    }
+}
+
+defun_redefine: {
+    options = {
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            function g() {
+                return 1;
+            }
+            function h() {
+                return 2;
+            }
+            g = function() {
+                return 3;
+            };
+            return g() + h();
+        }
+    }
+    expect:  {
+        function f() {
+            function g() {
+                return 1;
+            }
+            g = function() {
+                return 3;
+            };
+            return g() + 2;
+        }
+    }
+}
+
+func_inline: {
+    options = {
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            var g = function() {
+                return 1;
+            };
+            console.log(g() + h());
+            var h = function() {
+                return 2;
+            };
+        }
+    }
+    expect: {
+        function f() {
+            console.log(1 + h());
+            var h = function() {
+                return 2;
+            };
+        }
+    }
+}
+
+func_modified: {
+    options = {
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        function f(a) {
+            function a() { return 1; }
+            function b() { return 2; }
+            function c() { return 3; }
+            b.inject = [];
+            c = function() { return 4; };
+            return a() + b() + c();
+        }
+    }
+    expect: {
+        function f(a) {
+            function b() { return 2; }
+            function c() { return 3; }
+            b.inject = [];
+            c = function() { return 4; };
+            return 1 + 2 + c();
+        }
+    }
+}
+
+defun_label: {
+    options = {
+        passes: 2,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        !function() {
+            function f(a) {
+                L: {
+                    if (a) break L;
+                    return 1;
+                }
+            }
+            console.log(f(2));
+        }();
+    }
+    expect: {
+        !function() {
+            console.log(function(a) {
+                L: {
+                    if (a) break L;
+                    return 1;
+                }
+            }(2));
+        }();
+    }
+}
+
+double_reference: {
+    options = {
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            var g = function g() {
+                g();
+            };
+            g();
+        }
+    }
+    expect: {
+        function f() {
+            (function g() {
+                g();
+            })();
+        }
     }
 }

test/mocha/cli.js

@@ -82,7 +82,7 @@ describe("bin/uglifyjs", function () {
        });
     });
     it("Should work with --keep-fnames (mangle & compress)", function (done) {
-       var command = uglifyjscmd + ' test/input/issue-1431/sample.js --keep-fnames -m -c';
+       var command = uglifyjscmd + ' test/input/issue-1431/sample.js --keep-fnames -m -c unused=false';
 
        exec(command, function (err, stdout) {
            if (err) throw err;

test/mocha/glob.js

@@ -3,17 +3,13 @@ var assert = require("assert");
 
 describe("minify() with input file globs", function() {
     it("minify() with one input file glob string.", function() {
-        var result = Uglify.minify("test/input/issue-1242/foo.*", {
-            compress: { collapse_vars: true }
-        });
+        var result = Uglify.minify("test/input/issue-1242/foo.*");
         assert.strictEqual(result.code, 'function foo(o){print("Foo:",2*o)}var print=console.log.bind(console);');
     });
     it("minify() with an array of one input file glob.", function() {
         var result = Uglify.minify([
             "test/input/issue-1242/b*.es5",
-        ], {
-            compress: { collapse_vars: true }
-        });
+        ]);
         assert.strictEqual(result.code, 'function bar(n){return 3*n}function baz(n){return n/2}');
     });
     it("minify() with an array of multiple input file globs.", function() {
@@ -21,8 +17,8 @@ describe("minify() with input file globs", function() {
             "test/input/issue-1242/???.es5",
             "test/input/issue-1242/*.js",
         ], {
-            compress: { collapse_vars: true }
+            compress: { toplevel: true }
         });
-        assert.strictEqual(result.code, 'function bar(n){return 3*n}function baz(n){return n/2}function foo(n){print("Foo:",2*n)}var print=console.log.bind(console);print("qux",bar(3),baz(12)),foo(11);');
+        assert.strictEqual(result.code, 'var print=console.log.bind(console);print("qux",function(n){return 3*n}(3),function(n){return n/2}(12)),function(n){print("Foo:",2*n)}(11);');
     });
 });

test/mocha/release.js

@@ -0,0 +1,54 @@
+var assert = require("assert");
+var spawn = require("child_process").spawn;
+
+if (!process.env.UGLIFYJS_TEST_ALL) return;
+
+function run(command, args, done) {
+    var id = setInterval(function() {
+        process.stdout.write("\0");
+    }, 5 * 60 * 1000);
+    spawn(command, args, {
+        stdio: "ignore"
+    }).on("exit", function(code) {
+        clearInterval(id);
+        assert.strictEqual(code, 0);
+        done();
+    });
+}
+
+describe("test/benchmark.js", function() {
+    this.timeout(5 * 60 * 1000);
+    [
+        "-b",
+        "-b bracketize",
+        "-m",
+        "-mc passes=3",
+        "-mc passes=3,toplevel",
+        "-mc passes=3,unsafe",
+        "-mc keep_fargs=false,passes=3",
+        "-mc keep_fargs=false,passes=3,pure_getters,unsafe,unsafe_comps,unsafe_math,unsafe_proto",
+    ].forEach(function(options) {
+        it("Should pass with options " + options, function(done) {
+            var args = options.split(/ /);
+            args.unshift("test/benchmark.js");
+            run(process.argv[0], args, done);
+        });
+    });
+});
+
+describe("test/jetstream.js", function() {
+    this.timeout(20 * 60 * 1000);
+    it("Should install phantomjs-prebuilt", function(done) {
+        run("npm", ["install", "phantomjs-prebuilt@2.1.14"], done);
+    });
+    [
+        "-mc warnings=false",
+        "-mc keep_fargs=false,passes=3,pure_getters,unsafe,unsafe_comps,unsafe_math,unsafe_proto,warnings=false",
+    ].forEach(function(options) {
+        it("Should pass with options " + options, function(done) {
+            var args = options.split(/ /);
+            args.unshift("test/jetstream.js");
+            run(process.argv[0], args, done);
+        });
+    });
+});