v2.8.8

include benchmark.js in test suite (#1564 )
- report file sizes and overall run time - exit with non-zero code upon error
2017-03-07 19:58:41 +08:00 · 2017-03-07 19:25:12 +08:00 · 2017-03-07 18:38:27 +08:00 · 2017-03-07 15:37:52 +08:00 · 2017-03-07 03:11:03 +08:00 · 2017-03-07 01:42:33 +08:00
34 changed files with 2692 additions and 337 deletions
--- a/README.md
+++ b/README.md
@@ -75,8 +75,6 @@ The available options are:
  --support-ie8                 Use this flag to support Internet Explorer 6/7/8.
                                Equivalent to setting `screw_ie8: false` in `minify()`
                                for `compress`, `mangle` and `output` options.
-                                Note: `--support-ie8` may generate incorrect code
-                                for `try`/`catch` in ES5 compliant browsers.
  --expr                        Parse a single expression, rather than a
                                program (for parsing JSON)
  -p, --prefix                  Skip prefix for original filenames that appear
@@ -350,6 +348,9 @@ to set `true`; it's effectively a shortcut for `foo=true`).
  comparison are switching. Compression only works if both `comparisons` and
  `unsafe_comps` are both set to true.

+- `unsafe_math` (default: false) -- optimize numerical expressions like
+  `2 * x * 3` into `6 * x`, which may give imprecise floating point results.
+
 - `unsafe_proto` (default: false) -- optimize expressions like
  `Array.prototype.slice.call(a)` into `[].slice.call(a)`

@@ -423,6 +424,9 @@ to set `true`; it's effectively a shortcut for `foo=true`).
  such as `console.info` and/or retain side effects from function arguments
  after dropping the function call then use `pure_funcs` instead.

+- `expression` -- default `false`.  Pass `true` to preserve completion values
+  from terminal statements without `return`, e.g. in bookmarklets.
+
 - `keep_fargs` -- default `true`.  Prevents the
  compressor from discarding unused function arguments.  You need this
  for code which relies on `Function.length`.
@@ -621,7 +625,7 @@ function uglify(ast, options, mangle) {

  // Compression
  uAST.figure_out_scope();
-  uAST = uAST.transform(UglifyJS.Compressor(options));
+  uAST = UglifyJS.Compressor(options).compress(uAST);

  // Mangling (optional)
  if (mangle) {
@@ -865,7 +869,7 @@ toplevel.figure_out_scope()
 Like this:
 ```javascript
 var compressor = UglifyJS.Compressor(options);
-var compressed_ast = toplevel.transform(compressor);
+var compressed_ast = compressor.compress(toplevel);
 ```

 The `options` can be missing.  Available options are discussed above in
--- a/bin/uglifyjs
+++ b/bin/uglifyjs
@@ -8,7 +8,6 @@ var sys = require("util");
 var yargs = require("yargs");
 var fs = require("fs");
 var path = require("path");
-var async = require("async");
 var acorn;
 var screw_ie8 = true;
 var ARGS = yargs
@@ -27,7 +26,7 @@ mangling you need to use `-c` and `-m`.\
    .describe("source-map-include-sources", "Pass this flag if you want to include the content of source files in the source map as sourcesContent property.")
    .describe("in-source-map", "Input source map, useful if you're compressing JS that was generated from some other original code.")
    .describe("screw-ie8", "Do not support Internet Explorer 6/7/8. This flag is enabled by default.")
-    .describe("support-ie8", "Support non-standard Internet Explorer 6/7/8 javascript. Note: may generate incorrect code for try/catch in ES5 compliant browsers.")
+    .describe("support-ie8", "Support non-standard Internet Explorer 6/7/8 javascript.")
    .describe("expr", "Parse a single expression, rather than a program (for parsing JSON)")
    .describe("p", "Skip prefix for original filenames that appear in source maps. \
 For example -p 3 will drop 3 directories from file names and ensure they are relative paths. \
@@ -319,8 +318,11 @@ var STATS = {};
 var TOPLEVEL = null;
 var P_RELATIVE = ARGS.p && ARGS.p == "relative";
 var SOURCES_CONTENT = {};
+var index = 0;

-async.eachLimit(files, 1, function (file, cb) {
+!function cb() {
+    if (index == files.length) return done();
+    var file = files[index++];
    read_whole_file(file, function (err, code) {
        if (err) {
            print_error("ERROR: can't read file: " + file);
@@ -388,7 +390,9 @@ async.eachLimit(files, 1, function (file, cb) {
        });
        cb();
    });
-}, function () {
+}();
+
+function done() {
    var OUTPUT_FILE = ARGS.o;

    var SOURCE_MAP = (ARGS.source_map || ARGS.source_map_inline) ? UglifyJS.SourceMap({
@@ -537,7 +541,7 @@ async.eachLimit(files, 1, function (file, cb) {
            }));
        }
    }
-});
+}

 /* -----[ functions ]----- */

--- a/lib/ast.js
+++ b/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);

@@ -812,9 +837,6 @@ var AST_SymbolAccessor = DEFNODE("SymbolAccessor", null, {

 var AST_SymbolDeclaration = DEFNODE("SymbolDeclaration", "init", {
    $documentation: "A declaration symbol (symbol in var/const, function name or argument, symbol in catch)",
-    $propdoc: {
-        init: "[AST_Node*/S] array of initializers for this declaration."
-    }
 }, AST_Symbol);

 var AST_SymbolVar = DEFNODE("SymbolVar", null, {
--- a/lib/compress.js
+++ b/lib/compress.js
--- a/lib/output.js
+++ b/lib/output.js
@@ -46,17 +46,8 @@
 var EXPECT_DIRECTIVE = /^$|[;{][\s\n]*$/;

 function is_some_comments(comment) {
-    var text = comment.value;
-    var type = comment.type;
-    if (type == "comment2") {
-        // multiline comment
-        return /@preserve|@license|@cc_on/i.test(text);
-    }
-    return type == "comment5";
-}
-
-function is_comment5(comment) {
-    return comment.type == "comment5";
+    // multiline comment
+    return comment.type == "comment2" && /@preserve|@license|@cc_on/i.test(comment.value);
 }

 function OutputStream(options) {
@@ -86,7 +77,7 @@ function OutputStream(options) {
    }, true);

    // Convert comment option to RegExp if neccessary and set up comments filter
-    var comment_filter = options.shebang ? is_comment5 : return_false; // Default case, throw all comments away except shebangs
+    var comment_filter = return_false; // Default case, throw all comments away
    if (options.comments) {
        var comments = options.comments;
        if (typeof options.comments === "string" && /^\/.*\/[a-zA-Z]*$/.test(options.comments)) {
@@ -98,12 +89,12 @@ function OutputStream(options) {
        }
        if (comments instanceof RegExp) {
            comment_filter = function(comment) {
-                return comment.type == "comment5" || comments.test(comment.value);
+                return comment.type != "comment5" && comments.test(comment.value);
            };
        }
        else if (typeof comments === "function") {
            comment_filter = function(comment) {
-                return comment.type == "comment5" || comments(this, comment);
+                return comment.type != "comment5" && comments(this, comment);
            };
        }
        else if (comments === "some") {
@@ -400,10 +391,6 @@ function OutputStream(options) {
        return OUTPUT;
    };

-    if (options.preamble) {
-        print(options.preamble.replace(/\r\n?|[\n\u2028\u2029]|\s*$/g, "\n"));
-    }
-
    var stack = [];
    return {
        get             : get,
@@ -523,6 +510,17 @@ function OutputStream(options) {
                }));
            }

+            if (comments.length > 0 && output.pos() == 0) {
+                if (output.option("shebang") && comments[0].type == "comment5") {
+                    output.print("#!" + comments.shift().value + "\n");
+                    output.indent();
+                }
+                var preamble = output.option("preamble");
+                if (preamble) {
+                    output.print(preamble.replace(/\r\n?|[\n\u2028\u2029]|\s*$/g, "\n"));
+                }
+            }
+
            comments = comments.filter(output.comment_filter, self);

            // Keep single line comments after nlb, after nlb
@@ -547,10 +545,6 @@ function OutputStream(options) {
                        output.space();
                    }
                }
-                else if (output.pos() === 0 && c.type == "comment5" && output.option("shebang")) {
-                    output.print("#!" + c.value + "\n");
-                    output.indent();
-                }
            });
        }
    });
@@ -790,7 +784,9 @@ function OutputStream(options) {
        output.with_parens(function(){
            self.condition.print(output);
        });
-        output.semicolon();
+        if (output.option("beautify") && output.option("screw_ie8")) {
+            output.semicolon();
+        }
    });
    DEFPRINT(AST_While, function(self, output){
        output.print("while");
@@ -923,15 +919,6 @@ function OutputStream(options) {
        // 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;
        while (true) {
            if (b instanceof AST_If) {
--- a/lib/parse.js
+++ b/lib/parse.js
@@ -558,6 +558,11 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
    function next_token(force_regexp) {
        if (force_regexp != null)
            return read_regexp(force_regexp);
+        if (shebang && S.pos == 0 && looking_at("#!")) {
+            start_token();
+            forward(2);
+            skip_line_comment("comment5");
+        }
        for (;;) {
            skip_whitespace();
            start_token();
@@ -589,13 +594,6 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
            if (PUNC_CHARS(ch)) return token("punc", next());
            if (OPERATOR_CHARS(ch)) return read_operator();
            if (code == 92 || is_identifier_start(code)) return read_word();
-            if (shebang) {
-                if (S.pos == 0 && looking_at("#!")) {
-                    forward(2);
-                    skip_line_comment("comment5");
-                    continue;
-                }
-            }
            break;
        }
        parse_error("Unexpected character '" + ch + "'");
--- a/lib/scope.js
+++ b/lib/scope.js
@@ -97,7 +97,7 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
    var labels = new Dictionary();
    var defun = null;
    var tw = new TreeWalker(function(node, descend){
-        if (options.screw_ie8 && node instanceof AST_Catch) {
+        if (node instanceof AST_Catch) {
            var save_scope = scope;
            scope = new AST_Scope(node);
            scope.init_scope_vars();
@@ -154,12 +154,10 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
        }
        else if (node instanceof AST_SymbolVar
                 || node instanceof AST_SymbolConst) {
-            var def = defun.def_variable(node);
-            def.init = tw.parent().value;
+            defun.def_variable(node);
        }
        else if (node instanceof AST_SymbolCatch) {
-            (options.screw_ie8 ? scope : defun)
-                .def_variable(node);
+            scope.def_variable(node);
        }
        else if (node instanceof AST_LabelRef) {
            var sym = labels.get(node.name);
@@ -209,6 +207,23 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
    });
    self.walk(tw);

+    // pass 3: fix up any scoping issue with IE8
+    if (!options.screw_ie8) {
+        self.walk(new TreeWalker(function(node, descend) {
+            if (node instanceof AST_SymbolCatch) {
+                var name = node.name;
+                var scope = node.thedef.scope.parent_scope;
+                var def = scope.find_variable(name) || self.globals.get(name) || scope.def_variable(node);
+                node.thedef.references.forEach(function(ref) {
+                    ref.thedef = def;
+                    ref.reference(options);
+                });
+                node.thedef = def;
+                return true;
+            }
+        }));
+    }
+
    if (options.cache) {
        this.cname = options.cache.cname;
    }
--- a/lib/utils.js
+++ b/lib/utils.js
@@ -185,7 +185,7 @@ function push_uniq(array, el) {

 function string_template(text, props) {
    return text.replace(/\{(.+?)\}/g, function(str, p){
-        return props[p];
+        return props && props[p];
    });
 };

--- a/package.json
+++ b/package.json
@@ -4,7 +4,7 @@
  "homepage": "http://lisperator.net/uglifyjs",
  "author": "Mihai Bazon <mihai.bazon@gmail.com> (http://lisperator.net/)",
  "license": "BSD-2-Clause",
-  "version": "2.8.0",
+  "version": "2.8.8",
  "engines": {
    "node": ">=0.8.0"
  },
@@ -29,7 +29,6 @@
    "LICENSE"
  ],
  "dependencies": {
-    "async": "~0.2.6",
    "source-map": "~0.5.1",
    "uglify-to-browserify": "~1.0.0",
    "yargs": "~3.10.0"
--- a/test/benchmark.js
+++ b/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();
+        });
    });
 });
--- a/test/compress/collapse_vars.js
+++ b/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;
@@ -1141,7 +1143,7 @@ collapse_vars_constants: {
        function f3(x) {
            var b = x.prop;
            sideeffect1();
-            return b + (function() { return -9; })();
+            return b + -9;
        }
    }
 }
@@ -1309,9 +1311,55 @@ 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]);
        })();
    }
 }
+
+issue_1537: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var k = '';
+        for (k in {prop: 'val'}){}
+    }
+    expect: {
+        var k = '';
+        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);
+    }
+}
--- a/test/compress/concat-strings.js
+++ b/test/compress/concat-strings.js
@@ -164,3 +164,53 @@ concat_6: {
        );
    }
 }
+
+concat_7: {
+    input: {
+        console.log(
+            "" + 1,
+            "" + "1",
+            "" + 1 + 2,
+            "" + 1 + "2",
+            "" + "1" + 2,
+            "" + "1" + "2",
+            "" + (x += "foo")
+        );
+    }
+    expect: {
+        console.log(
+            "" + 1,
+            "1",
+            "" + 1 + 2,
+            1 + "2",
+            "1" + 2,
+            "1" + "2",
+            x += "foo"
+        );
+    }
+}
+
+concat_8: {
+    input: {
+        console.log(
+            1 + "",
+            "1" + "",
+            1 + 2 + "",
+            1 + "2" + "",
+            "1" + 2 + "",
+            "1" + "2" + "",
+            (x += "foo") + ""
+        );
+    }
+    expect: {
+        console.log(
+            1 + "",
+            "1",
+            1 + 2 + "",
+            1 + "2",
+            "1" + 2,
+            "1" + "2",
+            x += "foo"
+        );
+    }
+}
--- a/test/compress/conditionals.js
+++ b/test/compress/conditionals.js
@@ -50,7 +50,8 @@ ifs_3_should_warn: {
        conditionals : true,
        dead_code    : true,
        evaluate     : true,
-        booleans     : true
+        booleans     : true,
+        side_effects : true,
    };
    input: {
        var x, y;
@@ -135,16 +136,28 @@ ifs_6: {
        comparisons: true
    };
    input: {
-        var x;
+        var x, y;
        if (!foo && !bar && !baz && !boo) {
            x = 10;
        } else {
            x = 20;
        }
+        if (y) {
+            x[foo] = 10;
+        } else {
+            x[foo] = 20;
+        }
+        if (foo) {
+            x[bar] = 10;
+        } else {
+            x[bar] = 20;
+        }
    }
    expect: {
-        var x;
+        var x, y;
        x = foo || bar || baz || boo ? 20 : 10;
+        x[foo] = y ? 10 : 20;
+        foo ? x[bar] = 10 : x[bar] = 20;
    }
 }

@@ -159,10 +172,16 @@ cond_1: {
        } else {
            do_something(y);
        }
+        if (some_condition()) {
+            side_effects(x);
+        } else {
+            side_effects(y);
+        }
    }
    expect: {
        var do_something;
        do_something(some_condition() ? x : y);
+        some_condition() ? side_effects(x) : side_effects(y);
    }
 }

@@ -213,10 +232,16 @@ cond_4: {
        } else {
            do_something();
        }
+        if (some_condition()) {
+            side_effects();
+        } else {
+            side_effects();
+        }
    }
    expect: {
        var do_something;
        some_condition(), do_something();
+        some_condition(), side_effects();
    }
 }

@@ -250,7 +275,8 @@ cond_5: {
 cond_7: {
    options = {
        conditionals: true,
-        evaluate    : true
+        evaluate    : true,
+        side_effects: true,
    };
    input: {
        var x, y, z, a, b;
@@ -714,6 +740,7 @@ issue_1154: {
        conditionals: true,
        evaluate    : true,
        booleans    : true,
+        side_effects: true,
    };
    input: {
        function f1(x) { return x ? -1 : -1; }
@@ -742,7 +769,7 @@ issue_1154: {
        function g2() { return g(), 2; }
        function g3() { return g(), -4; }
        function g4() { return g(), !1; }
-        function g5() { return g(), void 0; }
+        function g5() { return void g(); }
        function g6() { return g(), "number"; }
    }
 }
@@ -750,7 +777,8 @@ issue_1154: {
 no_evaluate: {
    options = {
        conditionals: true,
-        evaluate    : false
+        evaluate    : false,
+        side_effects: true,
    }
    input: {
        function f(b) {
--- a/test/compress/dead-code.js
+++ b/test/compress/dead-code.js
@@ -64,7 +64,8 @@ dead_code_constant_boolean_should_warn_more: {
        loops        : true,
        booleans     : true,
        conditionals : true,
-        evaluate     : true
+        evaluate     : true,
+        side_effects : true,
    };
    input: {
        while (!((foo && bar) || (x + "0"))) {
@@ -122,6 +123,7 @@ dead_code_const_annotation: {
        conditionals : true,
        evaluate     : true,
        reduce_vars  : true,
+        toplevel     : true,
    };
    input: {
        var unused;
@@ -171,6 +173,7 @@ dead_code_const_annotation_complex_scope: {
        conditionals : true,
        evaluate     : true,
        reduce_vars  : true,
+        toplevel     : true,
    };
    input: {
        var unused_var;
--- a/test/compress/drop-unused.js
+++ b/test/compress/drop-unused.js
@@ -632,7 +632,7 @@ iife: {
    }
    expect: {
        function f() {
-            ~function() {}(b);
+            b;
        }
    }
 }
@@ -679,3 +679,24 @@ const_assign: {
        }
    }
 }
+
+issue_1539: {
+    options = {
+        cascade: true,
+        sequences: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            var a, b;
+            a = b = 42;
+            return a;
+        }
+    }
+    expect: {
+        function f() {
+            return 42;
+        }
+    }
+}
--- a/test/compress/evaluate.js
+++ b/test/compress/evaluate.js
@@ -337,6 +337,32 @@ unsafe_object_repeated: {
    }
 }

+unsafe_object_accessor: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        unsafe: true,
+    }
+    input: {
+        function f() {
+            var a = {
+                get b() {},
+                set b() {}
+            };
+            return {a:a};
+        }
+    }
+    expect: {
+        function f() {
+            var a = {
+                get b() {},
+                set b() {}
+            };
+            return {a:a};
+        }
+    }
+}
+
 unsafe_function: {
    options = {
        evaluate  : true,
@@ -614,9 +640,28 @@ call_args: {
    expect: {
        const a = 1;
        console.log(1);
+        +(1, 1);
+    }
+}
+
+call_args_drop_param: {
+    options = {
+        evaluate: true,
+        keep_fargs: false,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        const a = 1;
+        console.log(a);
        +function(a) {
-            return 1;
-        }(1);
+            return a;
+        }(a, b);
+    }
+    expect: {
+        const a = 1;
+        console.log(1);
+        +(b, 1);
    }
 }

@@ -624,25 +669,35 @@ in_boolean_context: {
    options = {
        booleans: true,
        evaluate: true,
+        sequences: true,
+        side_effects: true,
    }
    input: {
-        !42;
-        !"foo";
-        ![1, 2];
-        !/foo/;
-        !b(42);
-        !b("foo");
-        !b([1, 2]);
-        !b(/foo/);
+        console.log(
+            !42,
+            !"foo",
+            ![1, 2],
+            !/foo/,
+            !b(42),
+            !b("foo"),
+            !b([1, 2]),
+            !b(/foo/),
+            ![1, foo()],
+            ![1, foo(), 2]
+        );
    }
    expect: {
-        !1;
-        !1;
-        !1;
-        !1;
-        !b(42);
-        !b("foo");
-        !b([1, 2]);
-        !b(/foo/);
+        console.log(
+            !1,
+            !1,
+            !1,
+            !1,
+            !b(42),
+            !b("foo"),
+            !b([1, 2]),
+            !b(/foo/),
+            ![1, foo()],
+            (foo(), !1)
+        );
    }
 }
--- a/test/compress/functions.js
+++ b/test/compress/functions.js
@@ -6,3 +6,88 @@ non_ascii_function_identifier_name: {
    }
    expect_exact: "function fooλ(δλ){}function λ(δλ){}(function λ(δλ){})();"
 }
+
+iifes_returning_constants_keep_fargs_true: {
+    options = {
+        keep_fargs    : true,
+        side_effects  : true,
+        evaluate      : true,
+        unused        : true,
+        dead_code     : true,
+        conditionals  : true,
+        comparisons   : true,
+        booleans      : true,
+        if_return     : true,
+        join_vars     : true,
+        reduce_vars   : true,
+        cascade       : true,
+    }
+    input: {
+        (function(){ return -1.23; }());
+        console.log( function foo(){ return "okay"; }() );
+        console.log( function foo(x, y, z){ return 123; }() );
+        console.log( function(x, y, z){ return z; }() );
+        console.log( function(x, y, z){ if (x) return y; return z; }(1, 2, 3) );
+        console.log( function(x, y){ return x * y; }(2, 3) );
+        console.log( function(x, y){ return x * y; }(2, 3, a(), b()) );
+    }
+    expect: {
+        console.log("okay");
+        console.log(123);
+        console.log(void 0);
+        console.log(2);
+        console.log(6);
+        console.log((a(), b(), 6));
+    }
+}
+
+iifes_returning_constants_keep_fargs_false: {
+    options = {
+        keep_fargs    : false,
+        side_effects  : true,
+        evaluate      : true,
+        unused        : true,
+        dead_code     : true,
+        conditionals  : true,
+        comparisons   : true,
+        booleans      : true,
+        if_return     : true,
+        join_vars     : true,
+        reduce_vars   : true,
+        cascade       : true,
+    }
+    input: {
+        (function(){ return -1.23; }());
+        console.log( function foo(){ return "okay"; }() );
+        console.log( function foo(x, y, z){ return 123; }() );
+        console.log( function(x, y, z){ return z; }() );
+        console.log( function(x, y, z){ if (x) return y; return z; }(1, 2, 3) );
+        console.log( function(x, y){ return x * y; }(2, 3) );
+        console.log( function(x, y){ return x * y; }(2, 3, a(), b()) );
+    }
+    expect: {
+        console.log("okay");
+        console.log(123);
+        console.log(void 0);
+        console.log(2);
+        console.log(6);
+        console.log((a(), b(), 6));
+    }
+}
+
+issue_485_crashing_1530: {
+    options = {
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+    }
+    input: {
+        (function(a) {
+            if (true) return;
+            var b = 42;
+        })(this);
+    }
+    expect: {
+        this, void 0;
+    }
+}
--- a/test/compress/issue-1261.js
+++ b/test/compress/issue-1261.js
@@ -116,3 +116,61 @@ pure_function_calls_toplevel: {
        "WARN: Dropping unused variable iife1 [test/compress/issue-1261.js:84,12]",
    ]
 }
+
+should_warn: {
+    options = {
+        booleans: true,
+        conditionals: true,
+        evaluate: true,
+        side_effects: true,
+    }
+    input: {
+        /* @__PURE__ */(function(){x})(), void/* @__PURE__ */(function(){y})();
+        /* @__PURE__ */(function(){x})() || true ? foo() : bar();
+        true || /* @__PURE__ */(function(){y})() ? foo() : bar();
+        /* @__PURE__ */(function(){x})() && false ? foo() : bar();
+        false && /* @__PURE__ */(function(){y})() ? foo() : bar();
+        /* @__PURE__ */(function(){x})() + "foo" ? bar() : baz();
+        "foo" + /* @__PURE__ */(function(){y})() ? bar() : baz();
+        /* @__PURE__ */(function(){x})() ? foo() : foo();
+        [/* @__PURE__ */(function(){x})()] ? foo() : bar();
+        !{ foo: /* @__PURE__ */(function(){x})() } ? bar() : baz();
+    }
+    expect: {
+        foo();
+        foo();
+        bar();
+        bar();
+        bar();
+        bar();
+        foo();
+        foo();
+        baz();
+    }
+    expect_warnings: [
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:128,61]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:128,23]",
+        "WARN: Dropping side-effect-free statement [test/compress/issue-1261.js:128,23]",
+        "WARN: Boolean || always true [test/compress/issue-1261.js:129,23]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:129,23]",
+        "WARN: Condition always true [test/compress/issue-1261.js:129,23]",
+        "WARN: Boolean || always true [test/compress/issue-1261.js:130,8]",
+        "WARN: Condition always true [test/compress/issue-1261.js:130,8]",
+        "WARN: Boolean && always false [test/compress/issue-1261.js:131,23]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:131,23]",
+        "WARN: Condition always false [test/compress/issue-1261.js:131,23]",
+        "WARN: Boolean && always false [test/compress/issue-1261.js:132,8]",
+        "WARN: Condition always false [test/compress/issue-1261.js:132,8]",
+        "WARN: + in boolean context always true [test/compress/issue-1261.js:133,23]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:133,23]",
+        "WARN: Condition always true [test/compress/issue-1261.js:133,23]",
+        "WARN: + in boolean context always true [test/compress/issue-1261.js:134,8]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:134,31]",
+        "WARN: Condition always true [test/compress/issue-1261.js:134,8]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:135,23]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:136,24]",
+        "WARN: Condition always true [test/compress/issue-1261.js:136,8]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:137,31]",
+        "WARN: Condition always false [test/compress/issue-1261.js:137,8]",
+    ]
+}
--- a/test/compress/issue-1275.js
+++ b/test/compress/issue-1275.js
@@ -35,7 +35,7 @@ string_plus_optimization: {
                throw "nope";
            }
            try {
-                console.log('0' + throwing_function() ? "yes" : "no");
+                console.log((throwing_function(), "yes"));
            } catch (ex) {
                console.log(ex);
            }
--- a/test/compress/issue-1443.js
+++ b/test/compress/issue-1443.js
@@ -2,6 +2,7 @@

 unsafe_undefined: {
    options = {
+        conditionals: true,
        if_return: true,
        unsafe: true
    }
@@ -19,12 +20,7 @@ unsafe_undefined: {
    expect: {
        function f(n) {
            return function() {
-                if (a)
-                    return b;
-                if (c)
-                    return d;
-                else
-                    return n;
+                return a ? b : c ? d : n;
            };
        }
    }
@@ -32,6 +28,7 @@ unsafe_undefined: {

 keep_fnames: {
    options = {
+        conditionals: true,
        if_return: true,
        unsafe: true
    }
@@ -57,12 +54,7 @@ keep_fnames: {
                function n(n) {
                    return n * n;
                }
-                if (a)
-                    return b;
-                if (c)
-                    return d;
-                else
-                    return r;
+                return a ? b : c ? d : r;
            };
        }
    }
--- a/test/compress/issue-368.js
+++ b/test/compress/issue-368.js
@@ -0,0 +1,55 @@
+collapse: {
+    options = {
+        cascade: true,
+        sequences: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        function f1() {
+            var a;
+            a = typeof b === 'function' ? b() : b;
+            return a !== undefined && c();
+        }
+        function f2(b) {
+            var a;
+            b = c();
+            a = typeof b === 'function' ? b() : b;
+            return 'stirng' == typeof a && d();
+        }
+        function f3(c) {
+            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;
+            }
+        }
+    }
+    expect: {
+        function f1() {
+            return void 0 !== ('function' === typeof b ? b() : b) && c();
+        }
+        function f2(b) {
+            return b = c(), 'stirng' == typeof ('function' === typeof b ? b() : b) && d();
+        }
+        function f3(c) {
+            var a;
+            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;
+        }
+    }
+}
--- a/test/compress/issue-640.js
+++ b/test/compress/issue-640.js
@@ -0,0 +1,317 @@
+cond_5: {
+    options = {
+        conditionals: true,
+        expression: true,
+    }
+    input: {
+        if (some_condition()) {
+            if (some_other_condition()) {
+                do_something();
+            } else {
+                alternate();
+            }
+        } else {
+            alternate();
+        }
+
+        if (some_condition()) {
+            if (some_other_condition()) {
+                do_something();
+            }
+        }
+    }
+    expect: {
+        some_condition() && some_other_condition() ? do_something() : alternate();
+        if (some_condition() && some_other_condition()) do_something();
+    }
+}
+
+dead_code_const_annotation_regex: {
+    options = {
+        booleans     : true,
+        conditionals : true,
+        dead_code    : true,
+        evaluate     : true,
+        expression   : true,
+        loops        : true,
+    }
+    input: {
+        var unused;
+        // @constraint this shouldn't be a constant
+        var CONST_FOO_ANN = false;
+        if (CONST_FOO_ANN) {
+            console.log("reachable");
+        }
+    }
+    expect: {
+        var unused;
+        var CONST_FOO_ANN = !1;
+        if (CONST_FOO_ANN) console.log('reachable');
+    }
+}
+
+drop_console_2: {
+    options = {
+        drop_console: true,
+        expression: true,
+    }
+    input: {
+        console.log('foo');
+        console.log.apply(console, arguments);
+    }
+    expect: {
+        // with regular compression these will be stripped out as well
+        void 0;
+        void 0;
+    }
+}
+
+drop_value: {
+    options = {
+        expression: true,
+        side_effects: true,
+    }
+    input: {
+        (1, [2, foo()], 3, {a:1, b:bar()});
+    }
+    expect: {
+        foo(), {a:1, b:bar()};
+    }
+}
+
+wrongly_optimized: {
+    options = {
+        conditionals: true,
+        booleans: true,
+        evaluate: true,
+        expression: true,
+    }
+    input: {
+        function func() {
+            foo();
+        }
+        if (func() || true) {
+            bar();
+        }
+    }
+    expect: {
+        function func() {
+            foo();
+        }
+        // TODO: optimize to `func(), bar()`
+        if (func(), !0) bar();
+    }
+}
+
+negate_iife_1: {
+    options = {
+        expression: true,
+        negate_iife: true,
+    }
+    input: {
+        (function(){ stuff() })();
+    }
+    expect: {
+        (function(){ stuff() })();
+    }
+}
+
+negate_iife_3: {
+    options = {
+        conditionals: true,
+        expression: true,
+        negate_iife: true,
+    }
+    input: {
+        (function(){ return t })() ? console.log(true) : console.log(false);
+    }
+    expect: {
+        (function(){ return t })() ? console.log(true) : console.log(false);
+    }
+}
+
+negate_iife_3_off: {
+    options = {
+        conditionals: true,
+        expression: true,
+        negate_iife: false,
+    }
+    input: {
+        (function(){ return t })() ? console.log(true) : console.log(false);
+    }
+    expect: {
+        (function(){ return t })() ? console.log(true) : console.log(false);
+    }
+}
+
+negate_iife_4: {
+    options = {
+        conditionals: true,
+        expression: true,
+        negate_iife: true,
+        sequences: true,
+    }
+    input: {
+        (function(){ return t })() ? console.log(true) : console.log(false);
+        (function(){
+            console.log("something");
+        })();
+    }
+    expect: {
+        (function(){ return t })() ? console.log(true) : console.log(false), function(){
+            console.log("something");
+        }();
+    }
+}
+
+negate_iife_5: {
+    options = {
+        conditionals: true,
+        expression: true,
+        negate_iife: true,
+        sequences: true,
+    }
+    input: {
+        if ((function(){ return t })()) {
+            foo(true);
+        } else {
+            bar(false);
+        }
+        (function(){
+            console.log("something");
+        })();
+    }
+    expect: {
+        (function(){ return t })() ? foo(true) : bar(false), function(){
+            console.log("something");
+        }();
+    }
+}
+
+negate_iife_5_off: {
+    options = {
+        conditionals: true,
+        expression: true,
+        negate_iife: false,
+        sequences: true,
+    };
+    input: {
+        if ((function(){ return t })()) {
+            foo(true);
+        } else {
+            bar(false);
+        }
+        (function(){
+            console.log("something");
+        })();
+    }
+    expect: {
+        (function(){ return t })() ? foo(true) : bar(false), function(){
+            console.log("something");
+        }();
+    }
+}
+
+issue_1254_negate_iife_true: {
+    options = {
+        expression: true,
+        negate_iife: true,
+    }
+    input: {
+        (function() {
+            return function() {
+                console.log('test')
+            };
+        })()();
+    }
+    expect_exact: '(function(){return function(){console.log("test")}})()();'
+}
+
+issue_1254_negate_iife_nested: {
+    options = {
+        expression: true,
+        negate_iife: true,
+    }
+    input: {
+        (function() {
+            return function() {
+                console.log('test')
+            };
+        })()()()()();
+    }
+    expect_exact: '(function(){return function(){console.log("test")}})()()()()();'
+}
+
+conditional: {
+    options = {
+        expression: true,
+        pure_funcs: [ "pure" ],
+        side_effects: true,
+    }
+    input: {
+        pure(1 | a() ? 2 & b() : 7 ^ c());
+        pure(1 | a() ? 2 & b() : 5);
+        pure(1 | a() ? 4 : 7 ^ c());
+        pure(1 | a() ? 4 : 5);
+        pure(3 ? 2 & b() : 7 ^ c());
+        pure(3 ? 2 & b() : 5);
+        pure(3 ? 4 : 7 ^ c());
+        pure(3 ? 4 : 5);
+    }
+    expect: {
+        1 | a() ? b() : c();
+        1 | a() && b();
+        1 | a() || c();
+        a();
+        3 ? b() : c();
+        3 && b();
+        3 || c();
+        pure(3 ? 4 : 5);
+    }
+}
+
+limit_1: {
+    options = {
+        expression: true,
+        sequences: 3,
+    }
+    input: {
+        a;
+        b;
+        c;
+        d;
+        e;
+        f;
+        g;
+        h;
+        i;
+        j;
+        k;
+    }
+    expect: {
+        // Turned into a single return statement
+        // so it can no longer be split into lines
+        a,b,c,d,e,f,g,h,i,j,k;
+    }
+}
+
+iife: {
+    options = {
+        expression: true,
+        sequences: true,
+    }
+    input: {
+        x = 42;
+        (function a() {})();
+        !function b() {}();
+        ~function c() {}();
+        +function d() {}();
+        -function e() {}();
+        void function f() {}();
+        typeof function g() {}();
+    }
+    expect: {
+        x = 42, function a() {}(), function b() {}(), function c() {}(),
+        function d() {}(), function e() {}(), function f() {}(), typeof function g() {}();
+    }
+}
--- a/test/compress/loops.js
+++ b/test/compress/loops.js
@@ -213,6 +213,186 @@ evaluate: {
            a();
        for(;;)
            c();
-        d();
+        // rule disabled due to issue_1532
+        do d(); while (false);
    }
 }
+
+issue_1532: {
+    options = {
+        evaluate: true,
+        loops: true,
+    }
+    input: {
+        function f(x, y) {
+            do {
+                if (x) break;
+                foo();
+            } while (false);
+        }
+    }
+    expect: {
+        function f(x, y) {
+            do {
+                if (x) break;
+                foo();
+            } while (false);
+        }
+    }
+}
+
+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 do alert(x); while (--x); 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()) do do alert(x); while (--x) while (x) 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}'
+}
--- a/test/compress/negate-iife.js
+++ b/test/compress/negate-iife.js
@@ -32,16 +32,57 @@ negate_iife_2: {
    }
 }

+negate_iife_2_side_effects: {
+    options = {
+        negate_iife: true,
+        side_effects: true,
+    }
+    input: {
+        (function(){ return {} })().x = 10; // should not transform this one
+    }
+    expect: {
+        (function(){ return {} })().x = 10;
+    }
+}
+
 negate_iife_3: {
    options = {
        negate_iife: true,
        conditionals: true
    };
+    input: {
+        (function(){ return t })() ? console.log(true) : console.log(false);
+    }
+    expect: {
+        !function(){ return t }() ? console.log(false) : console.log(true);
+    }
+}
+
+negate_iife_3_evaluate: {
+    options = {
+        conditionals: true,
+        evaluate: true,
+        negate_iife: true,
+    }
    input: {
        (function(){ return true })() ? console.log(true) : console.log(false);
    }
    expect: {
-        !function(){ return true }() ? console.log(false) : console.log(true);
+        console.log(true);
+    }
+}
+
+negate_iife_3_side_effects: {
+    options = {
+        conditionals: true,
+        negate_iife: true,
+        side_effects: true,
+    }
+    input: {
+        (function(){ return t })() ? console.log(true) : console.log(false);
+    }
+    expect: {
+        !function(){ return t }() ? console.log(false) : console.log(true);
    }
 }

@@ -50,11 +91,25 @@ negate_iife_3_off: {
        negate_iife: false,
        conditionals: true,
    };
+    input: {
+        (function(){ return t })() ? console.log(true) : console.log(false);
+    }
+    expect: {
+        !function(){ return t }() ? console.log(false) : console.log(true);
+    }
+}
+
+negate_iife_3_off_evaluate: {
+    options = {
+        conditionals: true,
+        evaluate: true,
+        negate_iife: false,
+    }
    input: {
        (function(){ return true })() ? console.log(true) : console.log(false);
    }
    expect: {
-        !function(){ return true }() ? console.log(false) : console.log(true);
+        console.log(true);
    }
 }

@@ -65,13 +120,13 @@ negate_iife_4: {
        sequences: true
    };
    input: {
-        (function(){ return true })() ? console.log(true) : console.log(false);
+        (function(){ return t })() ? console.log(true) : console.log(false);
        (function(){
            console.log("something");
        })();
    }
    expect: {
-        !function(){ return true }() ? console.log(false) : console.log(true), function(){
+        !function(){ return t }() ? console.log(false) : console.log(true), function(){
            console.log("something");
        }();
    }
@@ -86,7 +141,7 @@ sequence_off: {
    };
    input: {
        function f() {
-            (function(){ return true })() ? console.log(true) : console.log(false);
+            (function(){ return t })() ? console.log(true) : console.log(false);
            (function(){
                console.log("something");
            })();
@@ -95,19 +150,19 @@ sequence_off: {
            (function(){
                console.log("something");
            })();
-            (function(){ return true })() ? console.log(true) : console.log(false);
+            (function(){ return t })() ? console.log(true) : console.log(false);
        }
    }
    expect: {
        function f() {
-            !function(){ return true }() ? console.log(false) : console.log(true), function(){
+            !function(){ return t }() ? console.log(false) : console.log(true), function(){
                console.log("something");
            }();
        }
        function g() {
            (function(){
                console.log("something");
-            })(), function(){ return true }() ? console.log(true) : console.log(false);
+            })(), function(){ return t }() ? console.log(true) : console.log(false);
        }
    }
 }
@@ -119,7 +174,7 @@ negate_iife_5: {
        conditionals: true,
    };
    input: {
-        if ((function(){ return true })()) {
+        if ((function(){ return t })()) {
            foo(true);
        } else {
            bar(false);
@@ -129,7 +184,7 @@ negate_iife_5: {
        })();
    }
    expect: {
-        !function(){ return true }() ? bar(false) : foo(true), function(){
+        !function(){ return t }() ? bar(false) : foo(true), function(){
            console.log("something");
        }();
    }
@@ -142,7 +197,7 @@ negate_iife_5_off: {
        conditionals: true,
    };
    input: {
-        if ((function(){ return true })()) {
+        if ((function(){ return t })()) {
            foo(true);
        } else {
            bar(false);
@@ -152,7 +207,7 @@ negate_iife_5_off: {
        })();
    }
    expect: {
-        !function(){ return true }() ? bar(false) : foo(true), function(){
+        !function(){ return t }() ? bar(false) : foo(true), function(){
            console.log("something");
        }();
    }
@@ -320,3 +375,35 @@ issue_1288: {
        }(0);
    }
 }
+
+issue_1288_side_effects: {
+    options = {
+        conditionals: true,
+        negate_iife: true,
+        side_effects: true,
+    }
+    input: {
+        if (w) ;
+        else {
+            (function f() {})();
+        }
+        if (!x) {
+            (function() {
+                x = {};
+            })();
+        }
+        if (y)
+            (function() {})();
+        else
+            (function(z) {
+                return z;
+            })(0);
+    }
+    expect: {
+        w;
+        x || function() {
+            x = {};
+        }();
+        y;
+    }
+}
--- a/test/compress/numbers.js
+++ b/test/compress/numbers.js
@@ -17,3 +17,139 @@ hex_numbers_in_parentheses_for_prototype_functions: {
    }
    expect_exact: "-2;(-2).toFixed(0);2;2..toFixed(0);.2;.2.toFixed(0);2e-8;2e-8.toFixed(0);0xde0b6b3a7640080;(0xde0b6b3a7640080).toFixed(0);"
 }
+
+comparisons: {
+    options = {
+        comparisons: true,
+    }
+    input: {
+        console.log(
+            ~x === 42,
+            x % n === 42
+        );
+    }
+    expect: {
+        console.log(
+            42 == ~x,
+            x % n == 42
+        );
+    }
+}
+
+evaluate_1: {
+    options = {
+        evaluate: true,
+        unsafe_math: false,
+    }
+    input: {
+        console.log(
+            x + 1 + 2,
+            x * 1 * 2,
+            +x + 1 + 2,
+            1 + x + 2 + 3,
+            1 | x | 2 | 3,
+            1 + x-- + 2 + 3,
+            1 + (x*y + 2) + 3,
+            1 + (2 + x + 3),
+            1 + (2 + ~x + 3),
+            -y + (2 + ~x + 3),
+            1 & (2 & x & 3),
+            1 + (2 + (x |= 0) + 3)
+        );
+    }
+    expect: {
+        console.log(
+            x + 1 + 2,
+            1 * x * 2,
+            +x + 1 + 2,
+            1 + x + 2 + 3,
+            3 | x,
+            1 + x-- + 2 + 3,
+            x*y + 2 + 1 + 3,
+            1 + (2 + x + 3),
+            2 + ~x + 3 + 1,
+            -y + (2 + ~x + 3),
+            0 & x,
+            2 + (x |= 0) + 3 + 1
+        );
+    }
+}
+
+evaluate_2: {
+    options = {
+        evaluate: true,
+        unsafe_math: true,
+    }
+    input: {
+        console.log(
+            x + 1 + 2,
+            x * 1 * 2,
+            +x + 1 + 2,
+            1 + x + 2 + 3,
+            1 | x | 2 | 3,
+            1 + x-- + 2 + 3,
+            1 + (x*y + 2) + 3,
+            1 + (2 + x + 3),
+            1 & (2 & x & 3),
+            1 + (2 + (x |= 0) + 3)
+        );
+    }
+    expect: {
+        console.log(
+            x + 1 + 2,
+            2 * x,
+            3 + +x,
+            1 + x + 2 + 3,
+            3 | x,
+            6 + x--,
+            6 + x*y,
+            1 + (2 + x + 3),
+            0 & x,
+            6 + (x |= 0)
+        );
+    }
+}
+
+evaluate_3: {
+    options = {
+        evaluate: true,
+        unsafe: true,
+        unsafe_math: true,
+    }
+    input: {
+        console.log(1 + Number(x) + 2);
+    }
+    expect: {
+        console.log(3 + +x);
+    }
+}
+
+evaluate_4: {
+    options = {
+        evaluate: true,
+    }
+    input: {
+        console.log(
+            1+ +a,
+            +a+1,
+            1+-a,
+            -a+1,
+            +a+ +b,
+            +a+-b,
+            -a+ +b,
+            -a+-b
+        );
+    }
+    expect: {
+        console.log(
+            +a+1,
+            +a+1,
+            1-a,
+            1-a,
+            +a+ +b,
+            +a-b,
+            -a+ +b,
+            -a-b
+        );
+    }
+}
--- a/test/compress/reduce_vars.js
+++ b/test/compress/reduce_vars.js
@@ -6,6 +6,7 @@ reduce_vars: {
            C : 0
        },
        reduce_vars   : true,
+        toplevel      : true,
        unused        : true
    }
    input: {
@@ -452,21 +453,672 @@ 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;
+        }
+    }
+}
+
+use_before_var: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+    }
+    input: {
+        function f(){
+            console.log(t);
+            var t = 1;
+        }
+    }
+    expect: {
+        function f(){
+            console.log(t);
+            var t = 1;
+        }
+    }
+}
+
+inner_var_if: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+    }
+    input: {
+        function f(a){
+            if (a)
+                var t = 1;
+            if (!t)
+                console.log(t);
+        }
+    }
+    expect: {
+        function f(a){
+            if (a)
+                var t = 1;
+            if (!t)
+                console.log(t);
+        }
+    }
+}
+
+inner_var_label: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+    }
+    input: {
+        function f(a){
+            l: {
+                if (a) break l;
+                var t = 1;
+            }
+            console.log(t);
+        }
+    }
+    expect: {
+        function f(a){
+            l: {
+                if (a) break l;
+                var t = 1;
+            }
+            console.log(t);
+        }
+    }
+}
+
+inner_var_for: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+    }
+    input: {
+        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);
+        }
+    }
+    expect: {
+        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);
+        }
+    }
+}
+
+inner_var_for_in_1: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+    }
+    input: {
+        function f() {
+            var a = 1, b = 2;
+            for (b in (function() {
+                return x(a, b, c);
+            })()) {
+                var c = 3, d = 4;
+                x(a, b, c, d);
+            }
+            x(a, b, c, d);
+        }
+    }
+    expect: {
+        function f() {
+            var a = 1, b = 2;
+            for (b in (function() {
+                return x(1, b, c);
+            })()) {
+                var c = 3, d = 4;
+                x(1, b, c, d);
+            }
+            x(1, b, c, d);
+        }
+    }
+}
+
+inner_var_for_in_2: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+    }
+    input: {
+        function f() {
+            for (var long_name in {})
+                console.log(long_name);
+        }
+    }
+    expect: {
+        function f() {
+            for (var long_name in {})
+                console.log(long_name);
+        }
+    }
+}
+
+inner_var_catch: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+    }
+    input: {
+        function f() {
+            try {
+                a();
+            } catch (e) {
+                var b = 1;
+            }
+            console.log(b);
+        }
+    }
+    expect: {
+        function f() {
+            try {
+                a();
+            } catch (e) {
+                var b = 1;
+            }
+            console.log(b);
+        }
+    }
+}
+
+issue_1533_1: {
+    options = {
+        collapse_vars: true,
+        reduce_vars: true,
+    }
+    input: {
+        function f() {
+            var id = "";
+            for (id in {break: "me"})
+                console.log(id);
+        }
+    }
+    expect: {
+        function f() {
+            var id = "";
+            for (id in {break: "me"})
+                console.log(id);
+        }
+    }
+}
+
+issue_1533_2: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+    }
+    input: {
+        function f() {
+            var id = "";
+            for (var id in {break: "me"})
+                console.log(id);
+            console.log(id);
+        }
+    }
+    expect: {
+        function f() {
+            var id = "";
+            for (var id in {break: "me"})
+                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));
+        }();
    }
 }
--- a/test/compress/screw-ie8.js
+++ b/test/compress/screw-ie8.js
@@ -17,6 +17,26 @@ dont_screw: {
    expect_exact: 'f("\\x0B");';
 }

+do_screw_constants: {
+    options = {
+        screw_ie8: true,
+    }
+    input: {
+        f(undefined, Infinity);
+    }
+    expect_exact: "f(void 0,1/0);"
+}
+
+dont_screw_constants: {
+    options = {
+        screw_ie8: false,
+    }
+    input: {
+        f(undefined, Infinity);
+    }
+    expect_exact: "f(undefined,Infinity);"
+}
+
 do_screw_try_catch: {
    options = { screw_ie8: true };
    mangle = { screw_ie8: true };
@@ -46,8 +66,6 @@ do_screw_try_catch: {
 }

 dont_screw_try_catch: {
-    // This test is known to generate incorrect code for screw_ie8=false.
-    // Update expected result in the event this bug is ever fixed.
    options = { screw_ie8: false };
    mangle = { screw_ie8: false };
    beautify = { screw_ie8: false };
@@ -64,11 +82,11 @@ dont_screw_try_catch: {
    }
    expect: {
        bad = function(n){
-            return function(n){
+            return function(t){
                try{
-                    t()
-                } catch(t) {
-                    n(t)
+                    n()
+                } catch(n) {
+                    t(n)
                }
            }
        };
@@ -104,8 +122,6 @@ do_screw_try_catch_undefined: {
 }

 dont_screw_try_catch_undefined: {
-    // This test is known to generate incorrect code for screw_ie8=false.
-    // Update expected result in the event this bug is ever fixed.
    options = { screw_ie8: false };
    mangle = { screw_ie8: false };
    beautify = { screw_ie8: false };
@@ -121,14 +137,48 @@ dont_screw_try_catch_undefined: {
        };
    }
    expect: {
-        function a(o){
+        function a(n){
            try{
                throw "Stuff"
-            } catch (n) {
-                console.log("caught: "+n)
+            } catch (undefined) {
+                console.log("caught: " + undefined)
            }
-            console.log("undefined is " + n);
-            return o === n
+            console.log("undefined is " + undefined);
+            return n === undefined
+        }
+    }
+}
+
+reduce_vars: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        screw_ie8: false,
+        unused: true,
+    }
+    mangle = {
+        screw_ie8: false,
+    }
+    input: {
+        function f() {
+            var a;
+            try {
+                x();
+            } catch (a) {
+                y();
+            }
+            alert(a);
+        }
+    }
+    expect: {
+        function f() {
+            var t;
+            try {
+                x();
+            } catch (t) {
+                y();
+            }
+            alert(t);
        }
    }
 }
--- a/test/compress/sequences.js
+++ b/test/compress/sequences.js
@@ -248,6 +248,39 @@ iife: {
    }
    expect: {
        x = 42, function a() {}(), function b() {}(), function c() {}(),
-        function d() {}(), function e() {}(), function f() {}(), function g() {}()
+        function d() {}(), function e() {}(), function f() {}(), function g() {}();
+    }
+}
+
+unsafe_undefined: {
+    options = {
+        conditionals: true,
+        if_return: true,
+        sequences: true,
+        side_effects: true,
+        unsafe: true,
+    }
+    input: {
+        function f(undefined) {
+            if (a)
+                return b;
+            if (c)
+                return d;
+        }
+        function g(undefined) {
+            if (a)
+                return b;
+            if (c)
+                return d;
+            e();
+        }
+    }
+    expect: {
+        function f(undefined) {
+            return a ? b : c ? d : undefined;
+        }
+        function g(undefined) {
+            return a ? b : c ? d : void e();
+        }
    }
 }
--- a/test/compress/typeof.js
+++ b/test/compress/typeof.js
@@ -29,6 +29,7 @@ typeof_in_boolean_context: {
        booleans     : true,
        evaluate     : true,
        conditionals : true,
+        side_effects : true,
    };
    input: {
        function f1(x) { return typeof x ? "yes" : "no"; }
@@ -36,12 +37,14 @@ typeof_in_boolean_context: {
        typeof 0 ? foo() : bar();
        !typeof console.log(1);
        var a = !typeof console.log(2);
+        if (typeof (1 + foo()));
    }
    expect: {
        function f1(x) { return "yes"; }
        function f2() { return g(), "Yes"; }
        foo();
-        !(console.log(1), !0);
+        console.log(1);
        var a = !(console.log(2), !0);
+        foo();
    }
 }
--- a/test/mocha/benchmark.js
+++ b/test/mocha/benchmark.js
@@ -0,0 +1,24 @@
+var assert = require("assert");
+var exec = require("child_process").exec;
+
+describe("test/benchmark.js", function() {
+    this.timeout(120000);
+    var command = '"' + process.argv[0] + '" test/benchmark.js ';
+    [
+        "-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(args) {
+        it("Should pass with options " + args, function(done) {
+            exec(command + args, function(err) {
+                if (err) throw err;
+                done();
+            });
+        });
+    });
+});
--- a/test/mocha/cli.js
+++ b/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;
--- a/test/mocha/comment-filter.js
+++ b/test/mocha/comment-filter.js
@@ -72,4 +72,12 @@ describe("comment filters", function() {
        assert.strictEqual(UglifyJS.parse("/* ok */ function a(){}").print_to_string(options), "/* ok */function a(){}");
        assert.strictEqual(UglifyJS.parse("/* ok */ function a(){}").print_to_string(options), "/* ok */function a(){}");
    });
+
+    it("Should handle shebang and preamble correctly", function() {
+        var code = UglifyJS.minify("#!/usr/bin/node\nvar x = 10;", {
+            fromString: true,
+            output: { preamble: "/* Build */" }
+        }).code;
+        assert.strictEqual(code, "#!/usr/bin/node\n/* Build */\nvar x=10;");
+    })
 });
--- a/test/mocha/glob.js
+++ b/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);');
    });
 });
--- a/test/mocha/minify.js
+++ b/test/mocha/minify.js
@@ -154,6 +154,17 @@ describe("minify", function() {
            var code = result.code;
            assert.strictEqual(code, "//  comment1   comment2\nbar();");
        });
+        it("should not drop #__PURE__ hint if function is retained", function() {
+            var result = Uglify.minify("var a = /*#__PURE__*/(function(){ foo(); })();", {
+                fromString: true,
+                output: {
+                    comments: "all",
+                    beautify: false,
+                }
+            });
+            var code = result.code;
+            assert.strictEqual(code, "var a=/*#__PURE__*/function(){foo()}();");
+        })
    });

    describe("JS_Parse_Error", function() {
@@ -171,4 +182,13 @@ describe("minify", function() {
        });
    });

+    describe("Compressor", function() {
+        it("should be backward compatible with ast.transform(compressor)", function() {
+            var ast = Uglify.parse("function f(a){for(var i=0;i<a;i++)console.log(i)}");
+            ast.figure_out_scope();
+            ast = ast.transform(Uglify.Compressor());
+            assert.strictEqual(ast.print_to_string(), "function f(a){for(var i=0;i<a;i++)console.log(i)}");
+        });
+    })
+
 });
Author	SHA1	Message	Date
Alex Lam S.L	144052ca49	v2.8.8	2017-03-07 19:58:41 +08:00
Alex Lam S.L	65c848cc6f	include benchmark.js in test suite (#1564 ) - report file sizes and overall run time - exit with non-zero code upon error	2017-03-07 19:25:12 +08:00
Alex Lam S.L	8a8a94a596	fix deep cloning of labels (#1565 ) `AST_Label.references` get `.initialize()` to `[]` every time after `.clone()` So walk down the tree to pick up the cloned `AST_LoopControl` pieces and put it back together.	2017-03-07 18:38:27 +08:00
Alex Lam S.L	8153b7bd8a	transform function calls to IIFEs (#1560 ) - expose function body to call sites for potential optimisations - suppress substitution of variable used within `AST_Defun`	2017-03-07 15:37:52 +08:00
Alex Lam S.L	d787d70127	avoid substitution of global variables (#1557 ) - unless `toplevel` is enabled - global `const` works as before	2017-03-07 03:11:03 +08:00
kzc	3ac2421932	collapse_vars: do not replace a constant in loop condition or init (#1562 )	2017-03-07 01:42:33 +08:00
Alex Lam S.L	a9fc9ddc33	suppress semicolons after do/while (#1556 ) - unless both `beautify` & `screw-ie8` are enabled - deprecate workaround for if-do-while-else fixes #186	2017-03-06 17:31:35 +08:00
Alex Lam S.L	a5d62a3fc6	v2.8.7	2017-03-05 17:17:08 +08:00
Alex Lam S.L	067e5a5762	fixup for #1553 (#1555 ) - `++a` is the one that is foldable - transform `a++` into `++a` for better optimisation	2017-03-05 17:15:37 +08:00
Alex Lam S.L	33b5f31984	v2.8.6	2017-03-05 15:48:28 +08:00
Alex Lam S.L	35a849dc48	collapse assignment with adjacent subsequent usage (#1553 ) - consolidate `cascade` optimisations - support ++/-- postfixes - remove redundant optimisation identified in #1460 fixes #368	2017-03-05 14:56:14 +08:00
Alex Lam S.L	b70591be1a	handle variable declaration within catch blocks (#1546 ) accounts for IE8- scoping	2017-03-05 13:13:44 +08:00
Alex Lam S.L	b33e7f88e6	improve `unsafe` on undefined (#1548 ) `unsafe` turns undefined keyword into a variable of the same name if found, but that interferes with other related optimisations. Keep track of such transformations to ensure zero information loss in the process.	2017-03-05 13:09:27 +08:00
Alex Lam S.L	1f0333e9f1	stay safe with constants in IE8- (#1547 ) - `undefined` etc. can be redefined at top-level for IE8-, so disable related optimisations - fixed `--support-ie8` catch mangle bug	2017-03-05 12:51:11 +08:00
Alex Lam S.L	eb98a7f2f3	fix handling of shebang and preamble (#1545 ) fixes #1332	2017-03-05 12:16:02 +08:00
Alex Lam S.L	78d1bb92d4	fix a corner case in #1530 (#1552 )	2017-03-05 12:12:59 +08:00
Alex Lam S.L	ea9ab9fb0e	resolve issue with outdated version of async (#1549 ) fixes #746	2017-03-05 01:54:20 +08:00
kzc	ce54c9ccee	disallow collapse_vars constant replacement in for-in statements (#1543 )	2017-03-04 02:39:54 +08:00
Alex Lam S.L	07accd2fbb	process code with implicit return statement (#1522 ) Bookmarklet for instance implicitedly assumes a "completion value" without using `return`. The `expression` option now supports such use cases. Optimisations on IIFEs also enhanced. fixes #354 fixes #543 fixes #625 fixes #628 fixes #640 closes #1293	2017-03-03 18:13:07 +08:00
Alex Lam S.L	18059cc94f	compress numerical expressions (#1513 ) safe operations - `a === b` => `a == b` - `a + -b` => `a - b` - `-a + b` => `b - a` - `a+ +b` => `+b+a` associative operations (bit-wise operations are safe, otherwise `unsafe_math`) - `a + (b + c)` => `(a + b) + c` - `(n + 2) + 3` => `5 + n` - `(2 * n) * 3` => `6 * n` - `(a \| 1) \| (2 \| d)` => `(3 \| a) \| b` fixes #412	2017-03-03 18:04:32 +08:00
Alex Lam S.L	b5e0e8c203	facilitate fix for #1531 (#1542 )	2017-03-03 07:12:24 +08:00
Alex Lam S.L	e5cb9275df	v2.8.5	2017-03-03 05:14:21 +08:00
Alex Lam S.L	17b81350d4	fix chained assignment with `unused` (#1540 ) When #1450 optimises `a=b=42`, it stops after the first variable even if both are unused. fixes #1539	2017-03-03 04:45:20 +08:00
kzc	4d63d4f5b3	collapse_vars should not replace constant in for-in init section (#1538 ) fixes #1537	2017-03-03 03:51:15 +08:00
Alex Lam S.L	70d72ad806	properly cover all cases of for-in loop variables (#1536 )	2017-03-03 02:39:57 +08:00
Alex Lam S.L	fe9227a41b	fix reference marking in for-in loops (#1535 ) fixes #1533	2017-03-03 00:56:06 +08:00
Alex Lam S.L	b49e142a26	disable do{...}while(false) optimisation (#1534 ) - fails to handle `break` in body fixes #1532	2017-03-03 00:54:41 +08:00
kzc	ee3b39b909	optimize trivial IIFEs returning constants (#1530 )	2017-03-02 15:11:40 +08:00
Alex Lam S.L	9699ffb1af	trim unused invocation parameters (#1526 )	2017-03-02 11:33:59 +08:00
Alex Lam S.L	fdc9b9413b	minor improvement to string optimisation (#1514 ) - "" + "a" => "a" - "" + a + "b" => a + "b" - "a" + "" => "a" (improving on #45)	2017-03-02 11:31:39 +08:00
Alex Lam S.L	40ceddb48a	v2.8.4	2017-03-02 00:24:49 +08:00
Alex Lam S.L	7aa69117e1	fix corner cases in `reduce_vars` (#1524 ) Avoid variable substitution in the following cases: - use of variable before declaration - declaration within conditional code blocks - declaration within loop body fixes #1518 fixes #1525	2017-03-02 00:20:53 +08:00
Alex Lam S.L	bff7ad67bb	v2.8.3	2017-03-01 15:28:46 +08:00
Alex Lam S.L	c2334baa48	fix crash on missing `props` to `string_template()` (#1523 ) Patched up `make_node()` without `orig`. There may be other cases where `start` could be missing, so make it print "undefined" instead of crashing. fixes #1518	2017-03-01 15:25:26 +08:00
Alex Lam S.L	fb2b6c7c6f	v2.8.2	2017-03-01 04:46:12 +08:00
Alex Lam S.L	f5cbe19b75	invert `reduce_vars` tracking flag (#1519 ) Modules like webpack and grunt-contrib-uglify still uses `ast.transform(compressor)` before `Compressor.compress(ast)` was introduced. Workaround this compatibility issue by deactivating `reduce_vars` in such case. Also fix use case with omitted `options` when calling `Compressor()`. fixes #1516	2017-03-01 04:12:10 +08:00
Alex Lam S.L	b34fa11a13	fix `evaluate` on object getter & setter (#1515 )	2017-03-01 02:03:47 +08:00
Alex Lam S.L	320984c5f5	v2.8.1	2017-03-01 00:27:08 +08:00
Alex Lam S.L	4365a51237	temporarily disables `reduce_vars` (#1517 ) ... as we investigate #1516	2017-03-01 00:25:43 +08:00
Alex Lam S.L	858e6c78a4	warn & drop `#__PURE__` iff IIFE is dropped (#1511 ) - consolidate `side-effects` optimisations - improve string `+` optimisation - enhance literal & `conditionals` optimisations	2017-02-28 02:25:44 +08:00