v3.4.5

fixes #3206

.travis.yml

@@ -1,14 +1,34 @@
-language: node_js
-node_js:
-    - "0.10"
-    - "0.12"
-    - "4"
-    - "6"
-    - "8"
-env:
-    - UGLIFYJS_TEST_ALL=1
+addons:
+  apt:
+    sources:
+      - ubuntu-toolchain-r-test
+    packages:
+      - libstdc++-4.9-dev
+cache:
+  directories: tmp
+language: generic
 matrix:
   fast_finish: true
 sudo: false
-cache:
-  directories: tmp
+env:
+  global:
+    - UGLIFYJS_TEST_ALL=1
+  matrix:
+    - NODEJS_VER=node/0.10
+    - NODEJS_VER=node/0.12
+    - NODEJS_VER=node/4
+    - NODEJS_VER=node/6
+    - NODEJS_VER=node/8
+    - NODEJS_VER=node/latest
+before_install:
+  - git clone --branch v1.4.2 --depth 1 https://github.com/jasongin/nvs.git ~/.nvs
+  - . ~/.nvs/nvs.sh
+  - nvs --version
+install:
+  - nvs add $NODEJS_VER
+  - nvs use $NODEJS_VER
+  - node --version
+  - npm --version --no-update-notifier
+  - npm install --no-optional --no-save --no-update-notifier
+script:
+  - npm test --no-update-notifier

README.md

@@ -620,6 +620,8 @@ If you're using the `X-SourceMap` header instead, you can just omit `sourceMap.u
 
 - `dead_code` (default: `true`) -- remove unreachable code
 
+- `directives` (default: `true`) -- remove redundant or non-standard directives
+
 - `drop_console` (default: `false`) -- Pass `true` to discard calls to
   `console.*` functions. If you wish to drop a specific function call
   such as `console.info` and/or retain side effects from function arguments
@@ -855,8 +857,8 @@ can pass additional arguments that control the code output:
   adjust for this text.  Can be used to insert a comment containing
   licensing information, for example.
 
-- `preserve_line` (default `false`) -- pass `true` to preserve lines, but it
-  only works if `beautify` is set to `false`.
+- `preserve_line` (default `false`) -- pass `true` to retain line numbering on
+  a best effort basis.
 
 - `quote_keys` (default `false`) -- pass `true` to quote all keys in literal
   objects

appveyor.yml

@@ -1,20 +1,25 @@
 environment:
+  UGLIFYJS_TEST_ALL: 1
   matrix:
-    - nodejs_version: "0.10"
-    - nodejs_version: "0.12"
-    - nodejs_version: "4"
-    - nodejs_version: "6"
-    - nodejs_version: "8"
+    - NODEJS_VER: node/0.10
+    - NODEJS_VER: node/0.12
+    - NODEJS_VER: node/4
+    - NODEJS_VER: node/6
+    - NODEJS_VER: node/8
+    - NODEJS_VER: node/latest
 install:
-  - ps: Install-Product node $env:nodejs_version
-  - set UGLIFYJS_TEST_ALL=1
-  - npm install
+  - git clone --branch v1.4.2 --depth 1 https://github.com/jasongin/nvs.git %LOCALAPPDATA%\nvs
+  - set PATH=%LOCALAPPDATA%\nvs;%PATH%
+  - nvs --version
+  - nvs add %NODEJS_VER%
+  - nvs use %NODEJS_VER%
+  - node --version
+  - npm --version --no-update-notifier
+  - npm install --no-optional --no-save --no-update-notifier
 build: off
 cache:
   - tmp
 matrix:
   fast_finish: true
 test_script:
-  - node --version
-  - npm --version
-  - npm test
+  - npm test --no-update-notifier

bin/uglifyjs

@@ -100,7 +100,7 @@ if (program.mangleProps) {
         if (typeof program.mangleProps != "object") program.mangleProps = {};
         if (!Array.isArray(program.mangleProps.reserved)) program.mangleProps.reserved = [];
         require("../tools/domprops").forEach(function(name) {
-            UglifyJS._push_uniq(program.mangleProps.reserved, name);
+            UglifyJS.push_uniq(program.mangleProps.reserved, name);
         });
     }
     if (typeof options.mangle != "object") options.mangle = {};

lib/ast.js

@@ -328,7 +328,7 @@ var AST_Toplevel = DEFNODE("Toplevel", "globals", {
         var body = this.body;
         var wrapped_tl = "(function(exports){'$ORIG';})(typeof " + name + "=='undefined'?(" + name + "={}):" + name + ");";
         wrapped_tl = parse(wrapped_tl);
-        wrapped_tl = wrapped_tl.transform(new TreeTransformer(function before(node) {
+        wrapped_tl = wrapped_tl.transform(new TreeTransformer(function(node) {
             if (node instanceof AST_Directive && node.value == "$ORIG") {
                 return MAP.splice(body);
             }

lib/compress.js

@@ -54,6 +54,7 @@ function Compressor(options, false_by_default) {
         comparisons   : !false_by_default,
         conditionals  : !false_by_default,
         dead_code     : !false_by_default,
+        directives    : !false_by_default,
         drop_console  : false,
         drop_debugger : !false_by_default,
         evaluate      : !false_by_default,
@@ -335,13 +336,10 @@ merge(Compressor.prototype, {
             def.chained = false;
             def.direct_access = false;
             def.escaped = false;
-            if (def.scope.pinned()) {
-                def.fixed = false;
-            } else if (!compressor.exposed(def)) {
-                def.fixed = def.init;
-            } else {
-                def.fixed = false;
-            }
+            def.fixed = !def.scope.pinned()
+                && !compressor.exposed(def)
+                && !(def.init instanceof AST_Function && def.init !== def.scope)
+                && def.init;
             if (def.fixed instanceof AST_Defun && !all(def.references, function(ref) {
                 var scope = ref.scope;
                 do {
@@ -424,6 +422,7 @@ merge(Compressor.prototype, {
         }
 
         function safe_to_read(tw, def) {
+            if (def.single_use == "m") return false;
             if (tw.safe_ids[def.id]) {
                 if (def.fixed == null) {
                     var orig = def.orig[0];
@@ -704,7 +703,7 @@ merge(Compressor.prototype, {
                 tw.loop_ids[d.id] = tw.in_loop;
             }
             var value;
-            if (d.fixed === undefined || !safe_to_read(tw, d) || d.single_use == "m") {
+            if (d.fixed === undefined || !safe_to_read(tw, d)) {
                 d.fixed = false;
             } else if (d.fixed) {
                 value = this.fixed_value();
@@ -2264,29 +2263,35 @@ merge(Compressor.prototype, {
 
     // methods to determine whether an expression has a boolean result type
     (function(def) {
-        var unary_bool = makePredicate("! delete");
-        var binary_bool = makePredicate("in instanceof == != === !== < <= >= >");
         def(AST_Node, return_false);
+        def(AST_Assign, function(compressor) {
+            return this.operator == "=" && this.right.is_boolean(compressor);
+        });
+        var binary = makePredicate("in instanceof == != === !== < <= >= >");
+        def(AST_Binary, function(compressor) {
+            return binary[this.operator] || lazy_op[this.operator]
+                && this.left.is_boolean(compressor)
+                && this.right.is_boolean(compressor);
+        });
+        def(AST_Boolean, return_true);
+        var fn = makePredicate("every hasOwnProperty isPrototypeOf propertyIsEnumerable some");
+        def(AST_Call, function(compressor) {
+            if (!compressor.option("unsafe")) return false;
+            var exp = this.expression;
+            return exp instanceof AST_Dot && (fn[exp.property]
+                || exp.property == "test" && exp.expression instanceof AST_RegExp);
+        });
+        def(AST_Conditional, function(compressor) {
+            return this.consequent.is_boolean(compressor) && this.alternative.is_boolean(compressor);
+        });
+        def(AST_New, return_false);
+        def(AST_Sequence, function(compressor) {
+            return this.tail_node().is_boolean(compressor);
+        });
+        var unary = makePredicate("! delete");
         def(AST_UnaryPrefix, function() {
-            return unary_bool[this.operator];
+            return unary[this.operator];
         });
-        def(AST_Binary, function() {
-            return binary_bool[this.operator]
-                || lazy_op[this.operator]
-                    && this.left.is_boolean()
-                    && this.right.is_boolean();
-        });
-        def(AST_Conditional, function() {
-            return this.consequent.is_boolean() && this.alternative.is_boolean();
-        });
-        def(AST_Assign, function() {
-            return this.operator == "=" && this.right.is_boolean();
-        });
-        def(AST_Sequence, function() {
-            return this.tail_node().is_boolean();
-        });
-        def(AST_True, return_true);
-        def(AST_False, return_true);
     })(function(node, func) {
         node.DEFMETHOD("is_boolean", func);
     });
@@ -2294,27 +2299,80 @@ merge(Compressor.prototype, {
     // methods to determine if an expression has a numeric result type
     (function(def) {
         def(AST_Node, return_false);
-        def(AST_Number, return_true);
-        var unary = makePredicate("+ - ~ ++ --");
-        def(AST_Unary, function() {
-            return unary[this.operator];
-        });
         var binary = makePredicate("- * / % & | ^ << >> >>>");
+        def(AST_Assign, function(compressor) {
+            return binary[this.operator.slice(0, -1)]
+                || this.operator == "=" && this.right.is_number(compressor);
+        });
         def(AST_Binary, function(compressor) {
             return binary[this.operator] || this.operator == "+"
                 && this.left.is_number(compressor)
                 && this.right.is_number(compressor);
         });
-        def(AST_Assign, function(compressor) {
-            return binary[this.operator.slice(0, -1)]
-                || this.operator == "=" && this.right.is_number(compressor);
-        });
-        def(AST_Sequence, function(compressor) {
-            return this.tail_node().is_number(compressor);
+        var fn = makePredicate([
+            "charCodeAt",
+            "getDate",
+            "getDay",
+            "getFullYear",
+            "getHours",
+            "getMilliseconds",
+            "getMinutes",
+            "getMonth",
+            "getSeconds",
+            "getTime",
+            "getTimezoneOffset",
+            "getUTCDate",
+            "getUTCDay",
+            "getUTCFullYear",
+            "getUTCHours",
+            "getUTCMilliseconds",
+            "getUTCMinutes",
+            "getUTCMonth",
+            "getUTCSeconds",
+            "getYear",
+            "indexOf",
+            "lastIndexOf",
+            "localeCompare",
+            "push",
+            "search",
+            "setDate",
+            "setFullYear",
+            "setHours",
+            "setMilliseconds",
+            "setMinutes",
+            "setMonth",
+            "setSeconds",
+            "setTime",
+            "setUTCDate",
+            "setUTCFullYear",
+            "setUTCHours",
+            "setUTCMilliseconds",
+            "setUTCMinutes",
+            "setUTCMonth",
+            "setUTCSeconds",
+            "setYear",
+            "toExponential",
+            "toFixed",
+            "toPrecision",
+        ]);
+        def(AST_Call, function(compressor) {
+            if (!compressor.option("unsafe")) return false;
+            var exp = this.expression;
+            return exp instanceof AST_Dot && (fn[exp.property]
+                || is_undeclared_ref(exp.expression) && exp.expression.name == "Math");
         });
         def(AST_Conditional, function(compressor) {
             return this.consequent.is_number(compressor) && this.alternative.is_number(compressor);
         });
+        def(AST_New, return_false);
+        def(AST_Number, return_true);
+        def(AST_Sequence, function(compressor) {
+            return this.tail_node().is_number(compressor);
+        });
+        var unary = makePredicate("+ - ~ ++ --");
+        def(AST_Unary, function() {
+            return unary[this.operator];
+        });
     })(function(node, func) {
         node.DEFMETHOD("is_number", func);
     });
@@ -2902,7 +2960,7 @@ merge(Compressor.prototype, {
         var map;
         if (expr instanceof AST_Array) {
             map = native_fns.Array;
-        } else if (expr.is_boolean()) {
+        } else if (expr.is_boolean(compressor)) {
             map = native_fns.Boolean;
         } else if (expr.is_number(compressor)) {
             map = native_fns.Number;
@@ -3205,8 +3263,10 @@ merge(Compressor.prototype, {
 
     /* -----[ optimizers ]----- */
 
+    var directives = makePredicate(["use asm", "use strict"]);
     OPT(AST_Directive, function(self, compressor) {
-        if (compressor.has_directive(self.value) !== self) {
+        if (compressor.option("directives")
+            && (!directives[self.value] || compressor.has_directive(self.value) !== self)) {
             return make_node(AST_EmptyStatement, self);
         }
         return self;
@@ -3353,202 +3413,201 @@ merge(Compressor.prototype, {
             });
         }
         // pass 3: we should drop declarations not in_use
-        var tt = new TreeTransformer(
-            function before(node, descend, in_list) {
-                var parent = tt.parent();
-                if (drop_vars) {
-                    var props = [], sym = assign_as_unused(node, props);
-                    if (sym instanceof AST_SymbolRef) {
-                        var def = sym.definition();
-                        var in_use = def.id in in_use_ids;
-                        var value = null;
-                        if (node instanceof AST_Assign) {
-                            if (!in_use || node.left === sym && def.id in fixed_ids && fixed_ids[def.id] !== node) {
-                                value = node.right;
-                            }
-                        } else if (!in_use) {
-                            value = make_node(AST_Number, node, {
-                                value: 0
-                            });
+        var tt = new TreeTransformer(function(node, descend, in_list) {
+            var parent = tt.parent();
+            if (drop_vars) {
+                var props = [], sym = assign_as_unused(node, props);
+                if (sym instanceof AST_SymbolRef) {
+                    var def = sym.definition();
+                    var in_use = def.id in in_use_ids;
+                    var value = null;
+                    if (node instanceof AST_Assign) {
+                        if (!in_use || node.left === sym && def.id in fixed_ids && fixed_ids[def.id] !== node) {
+                            value = node.right;
                         }
-                        if (value) {
-                            props.push(value);
-                            return maintain_this_binding(compressor, parent, node, make_sequence(node, props.map(function(prop) {
-                                return prop.transform(tt);
-                            })));
-                        }
-                    }
-                }
-                if (scope !== self) return;
-                if (node instanceof AST_Function
-                    && node.name
-                    && !compressor.option("keep_fnames")) {
-                    var def = node.name.definition();
-                    // any declarations with same name will overshadow
-                    // name of this anonymous function and can therefore
-                    // never be used anywhere
-                    if (!(def.id in in_use_ids) || def.orig.length > 1) node.name = null;
-                }
-                if (node instanceof AST_Lambda && !(node instanceof AST_Accessor)) {
-                    var trim = !compressor.option("keep_fargs");
-                    for (var a = node.argnames, i = a.length; --i >= 0;) {
-                        var sym = a[i];
-                        if (!(sym.definition().id in in_use_ids)) {
-                            sym.__unused = true;
-                            if (trim) {
-                                a.pop();
-                                compressor[sym.unreferenced() ? "warn" : "info"]("Dropping unused function argument {name} [{file}:{line},{col}]", template(sym));
-                            }
-                        } else {
-                            trim = false;
-                        }
-                    }
-                }
-                if (drop_funcs && node instanceof AST_Defun && node !== self) {
-                    var def = node.name.definition();
-                    if (!(def.id in in_use_ids)) {
-                        compressor[node.name.unreferenced() ? "warn" : "info"]("Dropping unused function {name} [{file}:{line},{col}]", template(node.name));
-                        def.eliminated++;
-                        return make_node(AST_EmptyStatement, node);
-                    }
-                }
-                if (node instanceof AST_Definitions && !(parent instanceof AST_ForIn && parent.init === node)) {
-                    // place uninitialized names at the start
-                    var body = [], head = [], tail = [];
-                    // for unused names whose initialization has
-                    // side effects, we can cascade the init. code
-                    // into the next one, or next statement.
-                    var side_effects = [];
-                    node.definitions.forEach(function(def) {
-                        if (def.value) def.value = def.value.transform(tt);
-                        var sym = def.name.definition();
-                        if (!drop_vars || sym.id in in_use_ids) {
-                            if (def.value && sym.id in fixed_ids && fixed_ids[sym.id] !== def) {
-                                def.value = def.value.drop_side_effect_free(compressor);
-                            }
-                            if (def.name instanceof AST_SymbolVar) {
-                                var var_defs = var_defs_by_id.get(sym.id);
-                                if (var_defs.length > 1 && (!def.value || sym.orig.indexOf(def.name) > sym.eliminated)) {
-                                    compressor.warn("Dropping duplicated definition of variable {name} [{file}:{line},{col}]", template(def.name));
-                                    if (def.value) {
-                                        var ref = make_node(AST_SymbolRef, def.name, def.name);
-                                        sym.references.push(ref);
-                                        var assign = make_node(AST_Assign, def, {
-                                            operator: "=",
-                                            left: ref,
-                                            right: def.value
-                                        });
-                                        if (fixed_ids[sym.id] === def) {
-                                            fixed_ids[sym.id] = assign;
-                                        }
-                                        side_effects.push(assign.transform(tt));
-                                    }
-                                    remove(var_defs, def);
-                                    sym.eliminated++;
-                                    return;
-                                }
-                            }
-                            if (def.value) {
-                                if (side_effects.length > 0) {
-                                    if (tail.length > 0) {
-                                        side_effects.push(def.value);
-                                        def.value = make_sequence(def.value, side_effects);
-                                    } else {
-                                        body.push(make_node(AST_SimpleStatement, node, {
-                                            body: make_sequence(node, side_effects)
-                                        }));
-                                    }
-                                    side_effects = [];
-                                }
-                                tail.push(def);
-                            } else {
-                                head.push(def);
-                            }
-                        } else if (sym.orig[0] instanceof AST_SymbolCatch) {
-                            var value = def.value && def.value.drop_side_effect_free(compressor);
-                            if (value) side_effects.push(value);
-                            def.value = null;
-                            head.push(def);
-                        } else {
-                            var value = def.value && def.value.drop_side_effect_free(compressor);
-                            if (value) {
-                                compressor.warn("Side effects in initialization of unused variable {name} [{file}:{line},{col}]", template(def.name));
-                                side_effects.push(value);
-                            } else {
-                                compressor[def.name.unreferenced() ? "warn" : "info"]("Dropping unused variable {name} [{file}:{line},{col}]", template(def.name));
-                            }
-                            sym.eliminated++;
-                        }
-                    });
-                    if (head.length > 0 || tail.length > 0) {
-                        node.definitions = head.concat(tail);
-                        body.push(node);
-                    }
-                    if (side_effects.length > 0) {
-                        body.push(make_node(AST_SimpleStatement, node, {
-                            body: make_sequence(node, side_effects)
-                        }));
-                    }
-                    switch (body.length) {
-                      case 0:
-                        return in_list ? MAP.skip : make_node(AST_EmptyStatement, node);
-                      case 1:
-                        return body[0];
-                      default:
-                        return in_list ? MAP.splice(body) : make_node(AST_BlockStatement, node, {
-                            body: body
+                    } else if (!in_use) {
+                        value = make_node(AST_Number, node, {
+                            value: 0
                         });
                     }
-                }
-                // certain combination of unused name + side effect leads to:
-                //    https://github.com/mishoo/UglifyJS2/issues/44
-                //    https://github.com/mishoo/UglifyJS2/issues/1830
-                //    https://github.com/mishoo/UglifyJS2/issues/1838
-                // that's an invalid AST.
-                // We fix it at this stage by moving the `var` outside the `for`.
-                if (node instanceof AST_For) {
-                    descend(node, this);
-                    var block;
-                    if (node.init instanceof AST_BlockStatement) {
-                        block = node.init;
-                        node.init = block.body.pop();
-                        block.body.push(node);
+                    if (value) {
+                        props.push(value);
+                        return maintain_this_binding(compressor, parent, node, make_sequence(node, props.map(function(prop) {
+                            return prop.transform(tt);
+                        })));
                     }
-                    if (node.init instanceof AST_SimpleStatement) {
-                        node.init = node.init.body;
-                    } else if (is_empty(node.init)) {
-                        node.init = null;
-                    }
-                    return !block ? node : in_list ? MAP.splice(block.body) : block;
-                }
-                if (node instanceof AST_LabeledStatement && node.body instanceof AST_For) {
-                    descend(node, this);
-                    if (node.body instanceof AST_BlockStatement) {
-                        var block = node.body;
-                        node.body = block.body.pop();
-                        block.body.push(node);
-                        return in_list ? MAP.splice(block.body) : block;
-                    }
-                    return node;
-                }
-                if (node instanceof AST_Scope) {
-                    var save_scope = scope;
-                    scope = node;
-                    descend(node, this);
-                    scope = save_scope;
-                    return node;
-                }
-
-                function template(sym) {
-                    return {
-                        name : sym.name,
-                        file : sym.start.file,
-                        line : sym.start.line,
-                        col  : sym.start.col
-                    };
                 }
             }
-        );
+            if (scope !== self) return;
+            if (node instanceof AST_Function
+                && node.name
+                && !compressor.option("ie8")
+                && !compressor.option("keep_fnames")) {
+                var def = node.name.definition();
+                // any declarations with same name will overshadow
+                // name of this anonymous function and can therefore
+                // never be used anywhere
+                if (!(def.id in in_use_ids) || def.orig.length > 1) node.name = null;
+            }
+            if (node instanceof AST_Lambda && !(node instanceof AST_Accessor)) {
+                var trim = !compressor.option("keep_fargs");
+                for (var a = node.argnames, i = a.length; --i >= 0;) {
+                    var sym = a[i];
+                    if (!(sym.definition().id in in_use_ids)) {
+                        sym.__unused = true;
+                        if (trim) {
+                            a.pop();
+                            compressor[sym.unreferenced() ? "warn" : "info"]("Dropping unused function argument {name} [{file}:{line},{col}]", template(sym));
+                        }
+                    } else {
+                        trim = false;
+                    }
+                }
+            }
+            if (drop_funcs && node instanceof AST_Defun && node !== self) {
+                var def = node.name.definition();
+                if (!(def.id in in_use_ids)) {
+                    compressor[node.name.unreferenced() ? "warn" : "info"]("Dropping unused function {name} [{file}:{line},{col}]", template(node.name));
+                    def.eliminated++;
+                    return make_node(AST_EmptyStatement, node);
+                }
+            }
+            if (node instanceof AST_Definitions && !(parent instanceof AST_ForIn && parent.init === node)) {
+                // place uninitialized names at the start
+                var body = [], head = [], tail = [];
+                // for unused names whose initialization has
+                // side effects, we can cascade the init. code
+                // into the next one, or next statement.
+                var side_effects = [];
+                node.definitions.forEach(function(def) {
+                    if (def.value) def.value = def.value.transform(tt);
+                    var sym = def.name.definition();
+                    if (!drop_vars || sym.id in in_use_ids) {
+                        if (def.value && sym.id in fixed_ids && fixed_ids[sym.id] !== def) {
+                            def.value = def.value.drop_side_effect_free(compressor);
+                        }
+                        if (def.name instanceof AST_SymbolVar) {
+                            var var_defs = var_defs_by_id.get(sym.id);
+                            if (var_defs.length > 1 && (!def.value || sym.orig.indexOf(def.name) > sym.eliminated)) {
+                                compressor.warn("Dropping duplicated definition of variable {name} [{file}:{line},{col}]", template(def.name));
+                                if (def.value) {
+                                    var ref = make_node(AST_SymbolRef, def.name, def.name);
+                                    sym.references.push(ref);
+                                    var assign = make_node(AST_Assign, def, {
+                                        operator: "=",
+                                        left: ref,
+                                        right: def.value
+                                    });
+                                    if (fixed_ids[sym.id] === def) {
+                                        fixed_ids[sym.id] = assign;
+                                    }
+                                    side_effects.push(assign.transform(tt));
+                                }
+                                remove(var_defs, def);
+                                sym.eliminated++;
+                                return;
+                            }
+                        }
+                        if (def.value) {
+                            if (side_effects.length > 0) {
+                                if (tail.length > 0) {
+                                    side_effects.push(def.value);
+                                    def.value = make_sequence(def.value, side_effects);
+                                } else {
+                                    body.push(make_node(AST_SimpleStatement, node, {
+                                        body: make_sequence(node, side_effects)
+                                    }));
+                                }
+                                side_effects = [];
+                            }
+                            tail.push(def);
+                        } else {
+                            head.push(def);
+                        }
+                    } else if (sym.orig[0] instanceof AST_SymbolCatch) {
+                        var value = def.value && def.value.drop_side_effect_free(compressor);
+                        if (value) side_effects.push(value);
+                        def.value = null;
+                        head.push(def);
+                    } else {
+                        var value = def.value && def.value.drop_side_effect_free(compressor);
+                        if (value) {
+                            compressor.warn("Side effects in initialization of unused variable {name} [{file}:{line},{col}]", template(def.name));
+                            side_effects.push(value);
+                        } else {
+                            compressor[def.name.unreferenced() ? "warn" : "info"]("Dropping unused variable {name} [{file}:{line},{col}]", template(def.name));
+                        }
+                        sym.eliminated++;
+                    }
+                });
+                if (head.length > 0 || tail.length > 0) {
+                    node.definitions = head.concat(tail);
+                    body.push(node);
+                }
+                if (side_effects.length > 0) {
+                    body.push(make_node(AST_SimpleStatement, node, {
+                        body: make_sequence(node, side_effects)
+                    }));
+                }
+                switch (body.length) {
+                  case 0:
+                    return in_list ? MAP.skip : make_node(AST_EmptyStatement, node);
+                  case 1:
+                    return body[0];
+                  default:
+                    return in_list ? MAP.splice(body) : make_node(AST_BlockStatement, node, {
+                        body: body
+                    });
+                }
+            }
+            // certain combination of unused name + side effect leads to:
+            //    https://github.com/mishoo/UglifyJS2/issues/44
+            //    https://github.com/mishoo/UglifyJS2/issues/1830
+            //    https://github.com/mishoo/UglifyJS2/issues/1838
+            // that's an invalid AST.
+            // We fix it at this stage by moving the `var` outside the `for`.
+            if (node instanceof AST_For) {
+                descend(node, this);
+                var block;
+                if (node.init instanceof AST_BlockStatement) {
+                    block = node.init;
+                    node.init = block.body.pop();
+                    block.body.push(node);
+                }
+                if (node.init instanceof AST_SimpleStatement) {
+                    node.init = node.init.body;
+                } else if (is_empty(node.init)) {
+                    node.init = null;
+                }
+                return !block ? node : in_list ? MAP.splice(block.body) : block;
+            }
+            if (node instanceof AST_LabeledStatement && node.body instanceof AST_For) {
+                descend(node, this);
+                if (node.body instanceof AST_BlockStatement) {
+                    var block = node.body;
+                    node.body = block.body.pop();
+                    block.body.push(node);
+                    return in_list ? MAP.splice(block.body) : block;
+                }
+                return node;
+            }
+            if (node instanceof AST_Scope) {
+                var save_scope = scope;
+                scope = node;
+                descend(node, this);
+                scope = save_scope;
+                return node;
+            }
+
+            function template(sym) {
+                return {
+                    name : sym.name,
+                    file : sym.start.file,
+                    line : sym.start.line,
+                    col  : sym.start.col
+                };
+            }
+        });
         self.transform(tt);
 
         function verify_safe_usage(def, read, modified) {
@@ -3866,8 +3925,39 @@ merge(Compressor.prototype, {
         }
 
         def(AST_Node, return_this);
-        def(AST_Constant, return_null);
-        def(AST_This, return_null);
+        def(AST_Accessor, return_null);
+        def(AST_Array, function(compressor, first_in_statement) {
+            var values = trim(this.elements, compressor, first_in_statement);
+            return values && make_sequence(this, values);
+        });
+        def(AST_Assign, function(compressor) {
+            var left = this.left;
+            if (left.has_side_effects(compressor)
+                || compressor.has_directive("use strict")
+                    && left instanceof AST_PropAccess
+                    && left.expression.is_constant()) {
+                return this;
+            }
+            this.write_only = true;
+            if (root_expr(left).is_constant_expression(compressor.find_parent(AST_Scope))) {
+                return this.right.drop_side_effect_free(compressor);
+            }
+            return this;
+        });
+        def(AST_Binary, function(compressor, first_in_statement) {
+            var right = this.right.drop_side_effect_free(compressor);
+            if (!right) return this.left.drop_side_effect_free(compressor, first_in_statement);
+            if (lazy_op[this.operator]) {
+                if (right === this.right) return this;
+                var node = this.clone();
+                node.right = right;
+                return node;
+            } else {
+                var left = this.left.drop_side_effect_free(compressor, first_in_statement);
+                if (!left) return this.right.drop_side_effect_free(compressor, first_in_statement);
+                return make_sequence(this, [ left, right ]);
+            }
+        });
         def(AST_Call, function(compressor, first_in_statement) {
             if (!this.is_expr_pure(compressor)) {
                 if (this.expression.is_call_pure(compressor)) {
@@ -3898,36 +3988,6 @@ merge(Compressor.prototype, {
             var args = trim(this.args, compressor, first_in_statement);
             return args && make_sequence(this, args);
         });
-        def(AST_Accessor, return_null);
-        def(AST_Function, return_null);
-        def(AST_Binary, function(compressor, first_in_statement) {
-            var right = this.right.drop_side_effect_free(compressor);
-            if (!right) return this.left.drop_side_effect_free(compressor, first_in_statement);
-            if (lazy_op[this.operator]) {
-                if (right === this.right) return this;
-                var node = this.clone();
-                node.right = right;
-                return node;
-            } else {
-                var left = this.left.drop_side_effect_free(compressor, first_in_statement);
-                if (!left) return this.right.drop_side_effect_free(compressor, first_in_statement);
-                return make_sequence(this, [ left, right ]);
-            }
-        });
-        def(AST_Assign, function(compressor) {
-            var left = this.left;
-            if (left.has_side_effects(compressor)
-                || compressor.has_directive("use strict")
-                    && left instanceof AST_PropAccess
-                    && left.expression.is_constant()) {
-                return this;
-            }
-            this.write_only = true;
-            if (root_expr(left).is_constant_expression(compressor.find_parent(AST_Scope))) {
-                return this.right.drop_side_effect_free(compressor);
-            }
-            return this;
-        });
         def(AST_Conditional, function(compressor) {
             var consequent = this.consequent.drop_side_effect_free(compressor);
             var alternative = this.alternative.drop_side_effect_free(compressor);
@@ -3947,6 +4007,14 @@ merge(Compressor.prototype, {
             node.alternative = alternative;
             return node;
         });
+        def(AST_Constant, return_null);
+        def(AST_Dot, function(compressor, first_in_statement) {
+            if (this.expression.may_throw_on_access(compressor)) return this;
+            return this.expression.drop_side_effect_free(compressor, first_in_statement);
+        });
+        def(AST_Function, function(compressor) {
+            return this.name && compressor.option("ie8") ? this : null;
+        });
         def(AST_Unary, function(compressor, first_in_statement) {
             if (unary_side_effects[this.operator]) {
                 this.write_only = !this.expression.has_side_effects(compressor);
@@ -3960,9 +4028,6 @@ merge(Compressor.prototype, {
             }
             return expression;
         });
-        def(AST_SymbolRef, function(compressor) {
-            return this.is_declared(compressor) ? null : this;
-        });
         def(AST_Object, function(compressor, first_in_statement) {
             var values = trim(this.properties, compressor, first_in_statement);
             return values && make_sequence(this, values);
@@ -3970,22 +4035,6 @@ merge(Compressor.prototype, {
         def(AST_ObjectProperty, function(compressor, first_in_statement) {
             return this.value.drop_side_effect_free(compressor, first_in_statement);
         });
-        def(AST_Array, function(compressor, first_in_statement) {
-            var values = trim(this.elements, compressor, first_in_statement);
-            return values && make_sequence(this, values);
-        });
-        def(AST_Dot, function(compressor, first_in_statement) {
-            if (this.expression.may_throw_on_access(compressor)) return this;
-            return this.expression.drop_side_effect_free(compressor, first_in_statement);
-        });
-        def(AST_Sub, function(compressor, first_in_statement) {
-            if (this.expression.may_throw_on_access(compressor)) return this;
-            var expression = this.expression.drop_side_effect_free(compressor, first_in_statement);
-            if (!expression) return this.property.drop_side_effect_free(compressor, first_in_statement);
-            var property = this.property.drop_side_effect_free(compressor);
-            if (!property) return expression;
-            return make_sequence(this, [ expression, property ]);
-        });
         def(AST_Sequence, function(compressor) {
             var last = this.tail_node();
             var expr = last.drop_side_effect_free(compressor);
@@ -3994,6 +4043,18 @@ merge(Compressor.prototype, {
             if (expr) expressions.push(expr);
             return make_sequence(this, expressions);
         });
+        def(AST_Sub, function(compressor, first_in_statement) {
+            if (this.expression.may_throw_on_access(compressor)) return this;
+            var expression = this.expression.drop_side_effect_free(compressor, first_in_statement);
+            if (!expression) return this.property.drop_side_effect_free(compressor, first_in_statement);
+            var property = this.property.drop_side_effect_free(compressor);
+            if (!property) return expression;
+            return make_sequence(this, [ expression, property ]);
+        });
+        def(AST_SymbolRef, function(compressor) {
+            return this.is_declared(compressor) ? null : this;
+        });
+        def(AST_This, return_null);
     })(function(node, func) {
         node.DEFMETHOD("drop_side_effect_free", func);
     });
@@ -5247,7 +5308,7 @@ merge(Compressor.prototype, {
             var is_strict_comparison = true;
             if ((self.left.is_string(compressor) && self.right.is_string(compressor)) ||
                 (self.left.is_number(compressor) && self.right.is_number(compressor)) ||
-                (self.left.is_boolean() && self.right.is_boolean()) ||
+                (self.left.is_boolean(compressor) && self.right.is_boolean(compressor)) ||
                 self.left.equivalent_to(self.right)) {
                 self.operator = self.operator.substr(0, 2);
             }
@@ -5328,7 +5389,7 @@ merge(Compressor.prototype, {
                 ]).optimize(compressor);
             }
         }
-        if (compressor.option("comparisons") && self.is_boolean()) {
+        if (compressor.option("comparisons") && self.is_boolean(compressor)) {
             if (!(compressor.parent() instanceof AST_Binary)
                 || compressor.parent() instanceof AST_Assign) {
                 var negated = make_node(AST_UnaryPrefix, self, {
@@ -6102,7 +6163,7 @@ merge(Compressor.prototype, {
         return self;
 
         function booleanize(node) {
-            if (node.is_boolean()) return node;
+            if (node.is_boolean(compressor)) return node;
             // !!expression
             return make_node(AST_UnaryPrefix, node, {
                 operator: "!",

lib/output.js

@@ -198,16 +198,24 @@ function OutputStream(options) {
     /* -----[ beautification/minification ]----- */
 
     var has_parens = false;
+    var line_end = 0;
+    var line_fixed = true;
     var might_need_space = false;
     var might_need_semicolon = false;
-    var might_add_newline = 0;
     var need_newline_indented = false;
     var need_space = false;
     var newline_insert = -1;
     var last = "";
     var mapping_token, mapping_name, mappings = options.source_map && [];
 
-    var do_add_mapping = mappings ? function() {
+    var adjust_mappings = mappings ? function(line, col) {
+        mappings.forEach(function(mapping) {
+            mapping.line += line;
+            mapping.col += col;
+        });
+    } : noop;
+
+    var flush_mappings = mappings ? function() {
         mappings.forEach(function(mapping) {
             try {
                 options.source_map.add(
@@ -230,31 +238,30 @@ function OutputStream(options) {
         mappings = [];
     } : noop;
 
-    var ensure_line_len = options.max_line_len ? function() {
-        if (current_col > options.max_line_len) {
-            if (might_add_newline) {
-                var left = OUTPUT.slice(0, might_add_newline);
-                var right = OUTPUT.slice(might_add_newline);
-                if (mappings) {
-                    var delta = right.length - current_col;
-                    mappings.forEach(function(mapping) {
-                        mapping.line++;
-                        mapping.col += delta;
-                    });
-                }
-                OUTPUT = left + "\n" + right;
-                current_line++;
-                current_pos++;
-                current_col = right.length;
-            }
+    function insert_newlines(count) {
+        var index = OUTPUT.lastIndexOf("\n");
+        if (line_end < index) line_end = index;
+        var left = OUTPUT.slice(0, line_end);
+        var right = OUTPUT.slice(line_end);
+        adjust_mappings(count, right.length - current_col);
+        current_line += count;
+        current_pos += count;
+        current_col = right.length;
+        OUTPUT = left;
+        while (count--) OUTPUT += "\n";
+        OUTPUT += right;
+    }
+
+    var fix_line = options.max_line_len ? function() {
+        if (line_fixed) {
             if (current_col > options.max_line_len) {
                 AST_Node.warn("Output exceeds {max_line_len} characters", options);
             }
+            return;
         }
-        if (might_add_newline) {
-            might_add_newline = 0;
-            do_add_mapping();
-        }
+        if (current_col > options.max_line_len) insert_newlines(1);
+        line_fixed = true;
+        flush_mappings();
     } : noop;
 
     var requireSemicolonChars = makePredicate("( [ + * / - , .");
@@ -286,7 +293,7 @@ function OutputStream(options) {
                     current_col++;
                     current_pos++;
                 } else {
-                    ensure_line_len();
+                    fix_line();
                     OUTPUT += "\n";
                     current_pos++;
                     current_line++;
@@ -304,18 +311,6 @@ function OutputStream(options) {
             }
         }
 
-        if (!options.beautify && options.preserve_line && stack[stack.length - 1]) {
-            var target_line = stack[stack.length - 1].start.line;
-            while (current_line < target_line) {
-                ensure_line_len();
-                OUTPUT += "\n";
-                current_pos++;
-                current_line++;
-                current_col = 0;
-                might_need_space = false;
-            }
-        }
-
         if (might_need_space) {
             if ((is_identifier_char(prev)
                     && (is_identifier_char(ch) || ch == "\\"))
@@ -337,7 +332,7 @@ function OutputStream(options) {
                 col: current_col
             });
             mapping_token = false;
-            if (!might_add_newline) do_add_mapping();
+            if (line_fixed) flush_mappings();
         }
 
         OUTPUT += str;
@@ -347,7 +342,7 @@ function OutputStream(options) {
         current_line += n;
         current_col += a[0].length;
         if (n > 0) {
-            ensure_line_len();
+            fix_line();
             current_col = a[n].length;
         }
         last = str;
@@ -374,9 +369,10 @@ function OutputStream(options) {
         return ret;
     } : function(col, cont) { return cont() };
 
-    var may_add_newline = options.max_line_len ? function() {
-        ensure_line_len();
-        might_add_newline = OUTPUT.length;
+    var may_add_newline = options.max_line_len || options.preserve_line ? function() {
+        fix_line();
+        line_end = OUTPUT.length;
+        line_fixed = false;
     } : noop;
 
     var newline = options.beautify ? function() {
@@ -455,9 +451,7 @@ function OutputStream(options) {
     } : noop;
 
     function get() {
-        if (might_add_newline) {
-            ensure_line_len();
-        }
+        if (!line_fixed) fix_line();
         return OUTPUT;
     }
 
@@ -622,7 +616,14 @@ function OutputStream(options) {
         col             : function() { return current_col },
         pos             : function() { return current_pos },
         push_node       : function(node) { stack.push(node) },
-        pop_node        : function() { return stack.pop() },
+        pop_node        : options.preserve_line ? function() {
+            var node = stack.pop();
+            if (node.start && node.start.line > current_line) {
+                insert_newlines(node.start.line - current_line);
+            }
+        } : function() {
+            stack.pop();
+        },
         parent          : function(n) {
             return stack[stack.length - 2 - (n || 0)];
         }

lib/utils.js

@@ -162,8 +162,7 @@ var MAP = (function() {
 })();
 
 function push_uniq(array, el) {
-    if (array.indexOf(el) < 0)
-        array.push(el);
+    if (array.indexOf(el) < 0) return array.push(el);
 }
 
 function string_template(text, props) {

package.json

@@ -3,7 +3,7 @@
   "description": "JavaScript parser, mangler/compressor and beautifier toolkit",
   "author": "Mihai Bazon <mihai.bazon@gmail.com> (http://lisperator.net/)",
   "license": "BSD-2-Clause",
-  "version": "3.4.2",
+  "version": "3.4.5",
   "engines": {
     "node": ">=0.8.0"
   },
@@ -23,11 +23,11 @@
     "LICENSE"
   ],
   "dependencies": {
-    "commander": "~2.15.0",
+    "commander": "~2.16.0",
     "source-map": "~0.6.1"
   },
   "devDependencies": {
-    "acorn": "~5.5.3",
+    "acorn": "~5.7.1",
     "semver": "~5.5.0"
   },
   "scripts": {

test/compress/arrays.js

@@ -15,9 +15,9 @@ holes_and_undefined: {
 
 constant_join: {
     options = {
-        unsafe   : true,
-        evaluate : true
-    };
+        evaluate: true,
+        unsafe: true,
+    }
     input: {
         var a = [ "foo", "bar", "baz" ].join("");
         var a1 = [ "foo", "bar", "baz" ].join();
@@ -64,9 +64,9 @@ constant_join: {
 
 constant_join_2: {
     options = {
-        unsafe   : true,
-        evaluate : true
-    };
+        evaluate: true,
+        unsafe: true,
+    }
     input: {
         var a = [ "foo", "bar", boo(), "baz", "x", "y" ].join("");
         var b = [ "foo", "bar", boo(), "baz", "x", "y" ].join("-");
@@ -93,9 +93,9 @@ constant_join_2: {
 
 constant_join_3: {
     options = {
-        unsafe: true,
         evaluate: true,
-    };
+        unsafe: true,
+    }
     input: {
         var a = [ null ].join();
         var b = [ , ].join();
@@ -133,7 +133,7 @@ for_loop: {
         reduce_vars: true,
         unsafe: true,
         unused: true,
-    };
+    }
     input: {
         function f0() {
             var a = [1, 2, 3];

test/compress/asm.js

@@ -1,24 +1,24 @@
 asm_mixed: {
     options = {
-        sequences     : true,
-        properties    : true,
-        dead_code     : true,
-        drop_debugger : true,
-        conditionals  : true,
-        comparisons   : true,
-        evaluate      : true,
-        booleans      : true,
-        loops         : true,
-        unused        : true,
-        hoist_funs    : true,
-        keep_fargs    : true,
-        keep_fnames   : false,
-        hoist_vars    : true,
-        if_return     : true,
-        join_vars     : true,
-        side_effects  : true,
-        negate_iife   : true
-    };
+        booleans: true,
+        comparisons: true,
+        conditionals: true,
+        dead_code: true,
+        drop_debugger: true,
+        evaluate: true,
+        hoist_funs: true,
+        hoist_vars: true,
+        if_return: true,
+        join_vars: true,
+        keep_fargs: true,
+        keep_fnames: false,
+        loops: true,
+        negate_iife: true,
+        properties: true,
+        sequences: true,
+        side_effects: true,
+        unused: true,
+    }
     input: {
         // adapted from http://asmjs.org/spec/latest/
         function asm_GeometricMean(stdlib, foreign, buffer) {

test/compress/collapse_vars.js

@@ -1,9 +1,22 @@
 collapse_vars_side_effects_1: {
     options = {
-        collapse_vars:true, sequences:true, properties:true, dead_code:true, conditionals:true,
-        comparisons:true, evaluate:true, booleans:true, loops:true, unused:true, hoist_funs:true,
-        keep_fargs:true, if_return:true, join_vars:true, side_effects:true,
-        reduce_funcs: true, reduce_vars:true
+        booleans: true,
+        collapse_vars: true,
+        comparisons: true,
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        hoist_funs: true,
+        if_return: true,
+        join_vars: true,
+        keep_fargs: true,
+        loops: true,
+        properties: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        sequences: true,
+        side_effects: true,
+        unused: true,
     }
     input: {
         function f1() {
@@ -76,9 +89,21 @@ collapse_vars_side_effects_1: {
 
 collapse_vars_side_effects_2: {
     options = {
-        collapse_vars:true, sequences:true, properties:true, dead_code:true, conditionals:true,
-        comparisons:true, evaluate:true, booleans:true, loops:true, unused:true, hoist_funs:true,
-        keep_fargs:true, if_return:true, join_vars:true, side_effects:true
+        booleans: true,
+        collapse_vars: true,
+        comparisons: true,
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        hoist_funs: true,
+        if_return: true,
+        join_vars: true,
+        keep_fargs: true,
+        loops: true,
+        properties: true,
+        sequences: true,
+        side_effects: true,
+        unused: true,
     }
     input: {
         function fn(x) { return console.log(x), x; }
@@ -144,10 +169,24 @@ collapse_vars_side_effects_2: {
 
 collapse_vars_issue_721: {
     options = {
-        collapse_vars:true, sequences:true, properties:true, dead_code:true, conditionals:true,
-        comparisons:true, evaluate:true, booleans:true, loops:true, unused:true, hoist_funs:true,
-        keep_fargs:true, if_return:true, join_vars:true, side_effects:true,
-        reduce_funcs: true, reduce_vars:true, passes:2
+        booleans: true,
+        collapse_vars: true,
+        comparisons: true,
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        hoist_funs: true,
+        if_return: true,
+        join_vars: true,
+        keep_fargs: true,
+        loops: true,
+        passes: 2,
+        properties: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        sequences: true,
+        side_effects: true,
+        unused: true,
     }
     input: {
         define(["require", "exports", 'handlebars'], function(require, exports, hb) {
@@ -211,10 +250,23 @@ collapse_vars_issue_721: {
 
 collapse_vars_properties: {
     options = {
-        collapse_vars:true, sequences:true, properties:true, dead_code:true, conditionals:true,
-        comparisons:true, evaluate:true, booleans:true, loops:true, unused:true, hoist_funs:true,
-        keep_fargs:true, if_return:true, join_vars:true, side_effects:true,
-        reduce_funcs: true, reduce_vars:true
+        booleans: true,
+        collapse_vars: true,
+        comparisons: true,
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        hoist_funs: true,
+        if_return: true,
+        join_vars: true,
+        keep_fargs: true,
+        loops: true,
+        properties: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        sequences: true,
+        side_effects: true,
+        unused: true,
     }
     input: {
         function f1(obj) {
@@ -239,10 +291,23 @@ collapse_vars_properties: {
 
 collapse_vars_if: {
     options = {
-        collapse_vars:true, sequences:true, properties:true, dead_code:true, conditionals:true,
-        comparisons:true, evaluate:true, booleans:true, loops:true, unused:true, hoist_funs:true,
-        keep_fargs:true, if_return:true, join_vars:true, side_effects:true,
-        reduce_funcs: true, reduce_vars:true
+        booleans: true,
+        collapse_vars: true,
+        comparisons: true,
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        hoist_funs: true,
+        if_return: true,
+        join_vars: true,
+        keep_fargs: true,
+        loops: true,
+        properties: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        sequences: true,
+        side_effects: true,
+        unused: true,
     }
     input: {
         function f1() {
@@ -290,10 +355,23 @@ collapse_vars_if: {
 
 collapse_vars_while: {
     options = {
-        collapse_vars:true, sequences:true, properties:true, dead_code:true, conditionals:true,
-        comparisons:true, evaluate:true, booleans:true, loops:false, unused:true, hoist_funs:true,
-        keep_fargs:true, if_return:true, join_vars:true, side_effects:true,
-        reduce_funcs: true, reduce_vars:true
+        booleans: true,
+        collapse_vars: true,
+        comparisons: true,
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        hoist_funs: true,
+        if_return: true,
+        join_vars: true,
+        keep_fargs: true,
+        loops: false,
+        properties: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        sequences: true,
+        side_effects: true,
+        unused: true,
     }
     input: {
         function f1(y) {
@@ -339,10 +417,21 @@ collapse_vars_while: {
 
 collapse_vars_do_while: {
     options = {
-        collapse_vars:true, sequences:true, properties:true, dead_code:true, conditionals:true,
-        comparisons:true, evaluate:true, booleans:false, loops:false, unused:"keep_assign",
-        hoist_funs:true, keep_fargs:true, if_return:true, join_vars:true,
-        side_effects:true
+        booleans: false,
+        collapse_vars: true,
+        comparisons: true,
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        hoist_funs: true,
+        if_return: true,
+        join_vars: true,
+        keep_fargs: true,
+        loops: false,
+        properties: true,
+        sequences: true,
+        side_effects: true,
+        unused: "keep_assign",
     }
     input: {
         function f1(y) {
@@ -415,9 +504,21 @@ collapse_vars_do_while: {
 
 collapse_vars_do_while_drop_assign: {
     options = {
-        collapse_vars:true, sequences:true, properties:true, dead_code:true, conditionals:true,
-        comparisons:true, evaluate:true, booleans:false, loops:false, unused:true, hoist_funs:true,
-        keep_fargs:true, if_return:true, join_vars:true, side_effects:true
+        booleans: false,
+        collapse_vars: true,
+        comparisons: true,
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        hoist_funs: true,
+        if_return: true,
+        join_vars: true,
+        keep_fargs: true,
+        loops: false,
+        properties: true,
+        sequences: true,
+        side_effects: true,
+        unused: true,
     }
     input: {
         function f1(y) {
@@ -490,9 +591,21 @@ collapse_vars_do_while_drop_assign: {
 
 collapse_vars_seq: {
     options = {
-        collapse_vars:true, sequences:true, properties:true, dead_code:true, conditionals:true,
-        comparisons:true, evaluate:true, booleans:true, loops:true, unused:true, hoist_funs:true,
-        keep_fargs:true, if_return:true, join_vars:true, side_effects:true
+        booleans: true,
+        collapse_vars: true,
+        comparisons: true,
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        hoist_funs: true,
+        if_return: true,
+        join_vars: true,
+        keep_fargs: true,
+        loops: true,
+        properties: true,
+        sequences: true,
+        side_effects: true,
+        unused: true,
     }
     input: {
         var f1 = function(x, y) {
@@ -514,9 +627,21 @@ collapse_vars_seq: {
 
 collapse_vars_throw: {
     options = {
-        collapse_vars:true, sequences:true, properties:true, dead_code:true, conditionals:true,
-        comparisons:true, evaluate:true, booleans:true, loops:true, unused:true, hoist_funs:true,
-        keep_fargs:true, if_return:true, join_vars:true, side_effects:true
+        booleans: true,
+        collapse_vars: true,
+        comparisons: true,
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        hoist_funs: true,
+        if_return: true,
+        join_vars: true,
+        keep_fargs: true,
+        loops: true,
+        properties: true,
+        sequences: true,
+        side_effects: true,
+        unused: true,
     }
     input: {
         var f1 = function(x, y) {
@@ -546,9 +671,21 @@ collapse_vars_throw: {
 
 collapse_vars_switch: {
     options = {
-        collapse_vars:true, sequences:true, properties:true, dead_code:true, conditionals:true,
-        comparisons:true, evaluate:true, booleans:true, loops:true, unused:true, hoist_funs:true,
-        keep_fargs:true, if_return:true, join_vars:true, side_effects:true
+        booleans: true,
+        collapse_vars: true,
+        comparisons: true,
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        hoist_funs: true,
+        if_return: true,
+        join_vars: true,
+        keep_fargs: true,
+        loops: true,
+        properties: true,
+        sequences: true,
+        side_effects: true,
+        unused: true,
     }
     input: {
         function f1() {
@@ -586,9 +723,20 @@ collapse_vars_switch: {
 
 collapse_vars_assignment: {
     options = {
-        collapse_vars:true, sequences:true, properties:true, conditionals:true,
-        comparisons:true, evaluate:true, booleans:true, loops:true, unused:true, hoist_funs:true,
-        keep_fargs:true, if_return:true, join_vars:true, side_effects:true
+        booleans: true,
+        collapse_vars: true,
+        comparisons: true,
+        conditionals: true,
+        evaluate: true,
+        hoist_funs: true,
+        if_return: true,
+        join_vars: true,
+        keep_fargs: true,
+        loops: true,
+        properties: true,
+        sequences: true,
+        side_effects: true,
+        unused: true,
     }
     input: {
         function log(x) { return console.log(x), x; }
@@ -659,10 +807,20 @@ collapse_vars_assignment: {
 
 collapse_vars_lvalues: {
     options = {
-        collapse_vars:true, sequences:true, properties:true, conditionals:true,
-        comparisons:true, evaluate:true, booleans:true, loops:true, unused:"keep_assign",
-        hoist_funs:true, keep_fargs:true, if_return:true, join_vars:true,
-        side_effects:true
+        booleans: true,
+        collapse_vars: true,
+        comparisons: true,
+        conditionals: true,
+        evaluate: true,
+        hoist_funs: true,
+        if_return: true,
+        join_vars: true,
+        keep_fargs: true,
+        loops: true,
+        properties: true,
+        sequences: true,
+        side_effects: true,
+        unused: "keep_assign",
     }
     input: {
         function f0(x) { var i = ++x; return x += i; }
@@ -692,9 +850,21 @@ collapse_vars_lvalues: {
 
 collapse_vars_lvalues_drop_assign: {
     options = {
-        collapse_vars:true, sequences:true, properties:true, conditionals:true,
-        comparisons:true, evaluate:true, booleans:true, loops:true, unused:true, hoist_funs:true,
-        keep_fargs:true, if_return:true, join_vars:true, side_effects:true, passes:3
+        booleans: true,
+        collapse_vars: true,
+        comparisons: true,
+        conditionals: true,
+        evaluate: true,
+        hoist_funs: true,
+        if_return: true,
+        join_vars: true,
+        keep_fargs: true,
+        loops: true,
+        passes: 3,
+        properties: true,
+        sequences: true,
+        side_effects: true,
+        unused: true,
     }
     input: {
         function f0(x) { var i = ++x; return x += i; }
@@ -724,10 +894,22 @@ collapse_vars_lvalues_drop_assign: {
 
 collapse_vars_misc1: {
     options = {
-        collapse_vars:true, sequences:true, properties:true, conditionals:true,
-        comparisons:true, evaluate:true, booleans:true, loops:true, unused:true, hoist_funs:true,
-        keep_fargs:true, if_return:true, join_vars:true, side_effects:true,
-        reduce_funcs: true, reduce_vars:true
+        booleans: true,
+        collapse_vars: true,
+        comparisons: true,
+        conditionals: true,
+        evaluate: true,
+        hoist_funs: true,
+        if_return: true,
+        join_vars: true,
+        keep_fargs: true,
+        loops: true,
+        properties: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        sequences: true,
+        side_effects: true,
+        unused: true,
     }
     input: {
         function f0(o, a, h) {
@@ -771,10 +953,21 @@ collapse_vars_misc1: {
 
 collapse_vars_self_reference: {
     options = {
-        collapse_vars:true, unused:false,
-        sequences:true, properties:true, dead_code:true, conditionals:true,
-        comparisons:true, evaluate:true, booleans:true, loops:true, hoist_funs:true,
-        keep_fargs:true, if_return:true, join_vars:true, side_effects:true
+        booleans: true,
+        collapse_vars: true,
+        comparisons: true,
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        hoist_funs: true,
+        if_return: true,
+        join_vars: true,
+        keep_fargs: true,
+        loops: true,
+        properties: true,
+        sequences: true,
+        side_effects: true,
+        unused: false,
     }
     input: {
         // avoid bug in self-referential declaration.
@@ -802,10 +995,23 @@ collapse_vars_self_reference: {
 
 collapse_vars_repeated: {
     options = {
-        collapse_vars:true, sequences:true, properties:true, dead_code:true, conditionals:true,
-        comparisons:true, evaluate:true, booleans:true, loops:true, unused:true, hoist_funs:true,
-        keep_fargs:true, if_return:true, join_vars:true, side_effects:true,
-        reduce_funcs: true, reduce_vars:true
+        booleans: true,
+        collapse_vars: true,
+        comparisons: true,
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        hoist_funs: true,
+        if_return: true,
+        join_vars: true,
+        keep_fargs: true,
+        loops: true,
+        properties: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        sequences: true,
+        side_effects: true,
+        unused: true,
     }
     input: {
         function f1() {
@@ -845,10 +1051,23 @@ collapse_vars_repeated: {
 
 collapse_vars_closures: {
     options = {
-        collapse_vars:true, sequences:true, properties:true, dead_code:true, conditionals:true,
-        comparisons:true, evaluate:true, booleans:true, loops:true, unused:true, hoist_funs:true,
-        keep_fargs:true, if_return:true, join_vars:true, side_effects:true,
-        reduce_funcs: true, reduce_vars:true
+        booleans: true,
+        collapse_vars: true,
+        comparisons: true,
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        hoist_funs: true,
+        if_return: true,
+        join_vars: true,
+        keep_fargs: true,
+        loops: true,
+        properties: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        sequences: true,
+        side_effects: true,
+        unused: true,
     }
     input: {
         function constant_vars_can_be_replaced_in_any_scope() {
@@ -873,9 +1092,21 @@ collapse_vars_closures: {
 
 collapse_vars_unary: {
     options = {
-        collapse_vars:true, sequences:true, properties:true, dead_code:true, conditionals:true,
-        comparisons:true, evaluate:true, booleans:true, loops:true, unused:true, hoist_funs:true,
-        keep_fargs:true, if_return:true, join_vars:true, side_effects:true
+        booleans: true,
+        collapse_vars: true,
+        comparisons: true,
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        hoist_funs: true,
+        if_return: true,
+        join_vars: true,
+        keep_fargs: true,
+        loops: true,
+        properties: true,
+        sequences: true,
+        side_effects: true,
+        unused: true,
     }
     input: {
         function f0(o, p) {
@@ -936,10 +1167,23 @@ collapse_vars_unary: {
 
 collapse_vars_try: {
     options = {
-        collapse_vars:true, sequences:true, properties:true, dead_code:true, conditionals:true,
-        comparisons:true, evaluate:true, booleans:true, loops:true, unused:true, hoist_funs:true,
-        keep_fargs:true, if_return:true, join_vars:true, side_effects:true,
-        reduce_funcs: true, reduce_vars:true
+        booleans: true,
+        collapse_vars: true,
+        comparisons: true,
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        hoist_funs: true,
+        if_return: true,
+        join_vars: true,
+        keep_fargs: true,
+        loops: true,
+        properties: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        sequences: true,
+        side_effects: true,
+        unused: true,
     }
     input: {
         function f1() {
@@ -992,9 +1236,21 @@ collapse_vars_try: {
 
 collapse_vars_array: {
     options = {
-        collapse_vars:true, sequences:true, properties:true, dead_code:true, conditionals:true,
-        comparisons:true, evaluate:true, booleans:true, loops:true, unused:true, hoist_funs:true,
-        keep_fargs:true, if_return:true, join_vars:true, side_effects:true
+        booleans: true,
+        collapse_vars: true,
+        comparisons: true,
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        hoist_funs: true,
+        if_return: true,
+        join_vars: true,
+        keep_fargs: true,
+        loops: true,
+        properties: true,
+        sequences: true,
+        side_effects: true,
+        unused: true,
     }
     input: {
         function f1(x, y) {
@@ -1026,9 +1282,21 @@ collapse_vars_array: {
 
 collapse_vars_object: {
     options = {
-        collapse_vars:true, sequences:true, properties:true, dead_code:true, conditionals:true,
-        comparisons:true, evaluate:true, booleans:true, loops:true, unused:true, hoist_funs:true,
-        keep_fargs:true, if_return:true, join_vars:true, side_effects:true
+        booleans: true,
+        collapse_vars: true,
+        comparisons: true,
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        hoist_funs: true,
+        if_return: true,
+        join_vars: true,
+        keep_fargs: true,
+        loops: true,
+        properties: true,
+        sequences: true,
+        side_effects: true,
+        unused: true,
     }
     input: {
         function f0(x, y) {
@@ -1094,9 +1362,21 @@ collapse_vars_object: {
 
 collapse_vars_eval_and_with: {
     options = {
-        collapse_vars:true, sequences:false, properties:true, dead_code:true, conditionals:true,
-        comparisons:true, evaluate:true, booleans:true, loops:true, unused:true, hoist_funs:true,
-        keep_fargs:true, if_return:true, join_vars:true, side_effects:true
+        booleans: true,
+        collapse_vars: true,
+        comparisons: true,
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        hoist_funs: true,
+        if_return: true,
+        join_vars: true,
+        keep_fargs: true,
+        loops: true,
+        properties: true,
+        sequences: false,
+        side_effects: true,
+        unused: true,
     }
     input: {
         // Don't attempt to collapse vars in presence of eval() or with statement.
@@ -1134,10 +1414,23 @@ collapse_vars_eval_and_with: {
 
 collapse_vars_constants: {
     options = {
-        collapse_vars:true, sequences:true, properties:true, dead_code:true, conditionals:true,
-        comparisons:true, evaluate:true, booleans:true, loops:true, unused:true, hoist_funs:true,
-        keep_fargs:true, if_return:true, join_vars:true, side_effects:true,
-        reduce_funcs: true, reduce_vars:true
+        booleans: true,
+        collapse_vars: true,
+        comparisons: true,
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        hoist_funs: true,
+        if_return: true,
+        join_vars: true,
+        keep_fargs: true,
+        loops: true,
+        properties: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        sequences: true,
+        side_effects: true,
+        unused: true,
     }
     input: {
         function f1(x) {
@@ -1172,10 +1465,24 @@ collapse_vars_constants: {
 
 collapse_vars_arguments: {
     options = {
-        collapse_vars:true, sequences:true, properties:true, dead_code:true, conditionals:true,
-        comparisons:true, evaluate:true, booleans:true, loops:true, unused:true, hoist_funs:true,
-        keep_fargs:true, if_return:true, join_vars:true, side_effects:true,
-        toplevel:true, reduce_funcs: true, reduce_vars:true
+        booleans: true,
+        collapse_vars: true,
+        comparisons: true,
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        hoist_funs: true,
+        if_return: true,
+        join_vars: true,
+        keep_fargs: true,
+        loops: true,
+        properties: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        sequences: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
     }
     input: {
         var outer = function() {
@@ -1195,9 +1502,21 @@ collapse_vars_arguments: {
 
 collapse_vars_short_circuit: {
     options = {
-        collapse_vars:true, sequences:true, properties:true, dead_code:true, conditionals:true,
-        comparisons:true, evaluate:true, booleans:true, loops:true, unused:true, hoist_funs:true,
-        keep_fargs:true, if_return:true, join_vars:true, side_effects:true
+        booleans: true,
+        collapse_vars: true,
+        comparisons: true,
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        hoist_funs: true,
+        if_return: true,
+        join_vars: true,
+        keep_fargs: true,
+        loops: true,
+        properties: true,
+        sequences: true,
+        side_effects: true,
+        unused: true,
     }
     input: {
         function f0(x) { var a = foo(), b = bar(); return b || x; }
@@ -1237,20 +1556,20 @@ collapse_vars_short_circuit: {
 
 collapse_vars_short_circuited_conditions: {
     options = {
+        booleans: true,
         collapse_vars: true,
-        sequences:     false,
-        dead_code:     true,
-        conditionals:  false,
-        comparisons:   false,
-        evaluate:      true,
-        booleans:      true,
-        loops:         true,
-        unused:        true,
-        hoist_funs:    true,
-        keep_fargs:    true,
-        if_return:     false,
-        join_vars:     true,
-        side_effects:  true,
+        comparisons: false,
+        conditionals: false,
+        dead_code: true,
+        evaluate: true,
+        hoist_funs: true,
+        if_return: false,
+        join_vars: true,
+        keep_fargs: true,
+        loops: true,
+        sequences: false,
+        side_effects: true,
+        unused: true,
     }
     input: {
         function c1(x) { var a = foo(), b = bar(), c = baz(); return a ? b : c; }
@@ -1286,21 +1605,21 @@ collapse_vars_short_circuited_conditions: {
 
 collapse_vars_regexp: {
     options = {
-        booleans:      true,
+        booleans: true,
         collapse_vars: true,
-        comparisons:   true,
-        conditionals:  true,
-        dead_code:     true,
-        evaluate:      true,
-        if_return:     true,
-        join_vars:     true,
-        hoist_funs:    true,
-        keep_fargs:    true,
-        loops:         false,
-        reduce_funcs:  true,
-        reduce_vars:   true,
-        side_effects:  true,
-        unused:        true,
+        comparisons: true,
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        hoist_funs: true,
+        if_return: true,
+        join_vars: true,
+        keep_fargs: true,
+        loops: false,
+        reduce_funcs: true,
+        reduce_vars: true,
+        side_effects: true,
+        unused: true,
     }
     input: {
         function f1() {
@@ -1692,9 +2011,21 @@ iife_2: {
 
 var_defs: {
     options = {
-        collapse_vars:true, sequences:true, properties:true, dead_code:true, conditionals:true,
-        comparisons:true, evaluate:true, booleans:true, loops:true, unused:true, hoist_funs:true,
-        keep_fargs:true, if_return:true, join_vars:true, side_effects:true
+        booleans: true,
+        collapse_vars: true,
+        comparisons: true,
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        hoist_funs: true,
+        if_return: true,
+        join_vars: true,
+        keep_fargs: true,
+        loops: true,
+        properties: true,
+        sequences: true,
+        side_effects: true,
+        unused: true,
     }
     input: {
         var f1 = function(x, y) {
@@ -2825,8 +3156,8 @@ issue_2364_5: {
     options = {
         collapse_vars: true,
         evaluate: true,
-        pure_getters: true,
         properties: true,
+        pure_getters: true,
         reduce_funcs: true,
         reduce_vars: true,
         unused: true,
@@ -3133,8 +3464,8 @@ issue_2437_1: {
         passes: 2,
         reduce_funcs: true,
         reduce_vars: true,
-        side_effects: true,
         sequences: true,
+        side_effects: true,
         toplevel: true,
         unused: true,
     }
@@ -3183,8 +3514,8 @@ issue_2437_2: {
         passes: 2,
         reduce_funcs: true,
         reduce_vars: true,
-        side_effects: true,
         sequences: true,
+        side_effects: true,
         toplevel: true,
         unused: true,
     }
@@ -3417,8 +3748,8 @@ issue_2436_6: {
         pure_getters: "strict",
         reduce_vars: true,
         toplevel: true,
-        unused: true,
         unsafe: true,
+        unused: true,
     }
     input: {
         var o = {

test/compress/comparing.js

@@ -295,3 +295,31 @@ issue_2857_6: {
     }
     expect_stdout: "true"
 }
+
+is_boolean_unsafe: {
+    options = {
+        comparisons: true,
+        unsafe: true,
+    }
+    input: {
+        console.log(/foo/.test("bar") === [].isPrototypeOf({}));
+    }
+    expect: {
+        console.log(/foo/.test("bar") == [].isPrototypeOf({}));
+    }
+    expect_stdout: "true"
+}
+
+is_number_unsafe: {
+    options = {
+        comparisons: true,
+        unsafe: true,
+    }
+    input: {
+        console.log(Math.acos(42) !== "foo".charCodeAt(4));
+    }
+    expect: {
+        console.log(Math.acos(42) != "foo".charCodeAt(4));
+    }
+    expect_stdout: "true"
+}

test/compress/concat-strings.js

@@ -1,7 +1,7 @@
 concat_1: {
     options = {
-        evaluate: true
-    };
+        evaluate: true,
+    }
     input: {
         var a = "foo" + "bar" + x() + "moo" + "foo" + y() + "x" + "y" + "z" + q();
         var b = "foo" + 1 + x() + 2 + "boo";
@@ -26,7 +26,7 @@ concat_1: {
 }
 
 concat_2: {
-    options = {};
+    options = {}
     input: {
         console.log(
             1 + (2 + 3),
@@ -55,7 +55,7 @@ concat_2: {
 }
 
 concat_3: {
-    options = {};
+    options = {}
     input: {
         console.log(
             1 + 2 + (3 + 4 + 5),
@@ -84,7 +84,7 @@ concat_3: {
 }
 
 concat_4: {
-    options = {};
+    options = {}
     input: {
         console.log(
             1 + "2" + (3 + 4 + 5),
@@ -113,7 +113,7 @@ concat_4: {
 }
 
 concat_5: {
-    options = {};
+    options = {}
     input: {
         console.log(
             "1" + 2 + (3 + 4 + 5),
@@ -142,7 +142,7 @@ concat_5: {
 }
 
 concat_6: {
-    options = {};
+    options = {}
     input: {
         console.log(
             "1" + "2" + (3 + 4 + 5),

test/compress/conditionals.js

@@ -1,7 +1,7 @@
 ifs_1: {
     options = {
-        conditionals: true
-    };
+        conditionals: true,
+    }
     input: {
         if (foo) bar();
         if (!foo); else bar();
@@ -18,8 +18,8 @@ ifs_1: {
 
 ifs_2: {
     options = {
-        conditionals: true
-    };
+        conditionals: true,
+    }
     input: {
         if (foo) {
             x();
@@ -47,12 +47,12 @@ ifs_2: {
 
 ifs_3_should_warn: {
     options = {
-        conditionals : true,
-        dead_code    : true,
-        evaluate     : true,
-        booleans     : true,
-        side_effects : true,
-    };
+        booleans: true,
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        side_effects: true,
+    }
     input: {
         var x, y;
         if (x && !(x + "1") && y) { // 1
@@ -78,8 +78,8 @@ ifs_3_should_warn: {
 
 ifs_4: {
     options = {
-        conditionals: true
-    };
+        conditionals: true,
+    }
     input: {
         if (foo && bar) {
             x(foo)[10].bar.baz = something();
@@ -95,10 +95,10 @@ ifs_4: {
 
 ifs_5: {
     options = {
-        if_return: true,
-        conditionals: true,
         comparisons: true,
-    };
+        conditionals: true,
+        if_return: true,
+    }
     input: {
         function f() {
             if (foo) return;
@@ -132,9 +132,9 @@ ifs_5: {
 
 ifs_6: {
     options = {
+        comparisons: true,
         conditionals: true,
-        comparisons: true
-    };
+    }
     input: {
         var x, y;
         if (!foo && !bar && !baz && !boo) {
@@ -163,8 +163,8 @@ ifs_6: {
 
 cond_1: {
     options = {
-        conditionals: true
-    };
+        conditionals: true,
+    }
     input: {
         function foo(do_something, some_condition) {
             if (some_condition) {
@@ -189,8 +189,8 @@ cond_1: {
 
 cond_2: {
     options = {
-        conditionals: true
-    };
+        conditionals: true,
+    }
     input: {
         function foo(x, FooBar, some_condition) {
             if (some_condition) {
@@ -209,8 +209,8 @@ cond_2: {
 
 cond_3: {
     options = {
-        conditionals: true
-    };
+        conditionals: true,
+    }
     input: {
         var FooBar;
         if (some_condition()) {
@@ -227,8 +227,8 @@ cond_3: {
 
 cond_4: {
     options = {
-        conditionals: true
-    };
+        conditionals: true,
+    }
     input: {
         var do_something;
         if (some_condition()) {
@@ -251,8 +251,8 @@ cond_4: {
 
 cond_5: {
     options = {
-        conditionals: true
-    };
+        conditionals: true,
+    }
     input: {
         if (some_condition()) {
             if (some_other_condition()) {
@@ -279,9 +279,9 @@ cond_5: {
 cond_7: {
     options = {
         conditionals: true,
-        evaluate    : true,
+        evaluate: true,
         side_effects: true,
-    };
+    }
     input: {
         var x, y, z, a, b;
         // compress these
@@ -342,8 +342,8 @@ cond_7: {
 cond_7_1: {
     options = {
         conditionals: true,
-        evaluate    : true
-    };
+        evaluate: true,
+    }
     input: {
         var x;
         // access to global should be assumed to have side effects
@@ -361,10 +361,10 @@ cond_7_1: {
 
 cond_8: {
     options = {
+        booleans: false,
         conditionals: true,
-        evaluate    : true,
-        booleans    : false
-    };
+        evaluate: true,
+    }
     input: {
         var a;
         // compress these
@@ -445,10 +445,10 @@ cond_8: {
 
 cond_8b: {
     options = {
+        booleans: true,
         conditionals: true,
-        evaluate    : true,
-        booleans    : true
-    };
+        evaluate: true,
+    }
     input: {
         var a;
         // compress these
@@ -528,10 +528,10 @@ cond_8b: {
 
 cond_8c: {
     options = {
+        booleans: false,
         conditionals: true,
-        evaluate    : false,
-        booleans    : false
-    };
+        evaluate: false,
+    }
     input: {
         var a;
         // compress these
@@ -647,9 +647,21 @@ cond_9: {
 
 ternary_boolean_consequent: {
     options = {
-        collapse_vars:true, sequences:true, properties:true, dead_code:true, conditionals:true,
-        comparisons:true, evaluate:true, booleans:true, loops:true, unused:true, hoist_funs:true,
-        keep_fargs:true, if_return:true, join_vars:true, side_effects:true
+        booleans: true,
+        collapse_vars: true,
+        comparisons: true,
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        hoist_funs: true,
+        if_return: true,
+        join_vars: true,
+        keep_fargs: true,
+        loops: true,
+        properties: true,
+        sequences: true,
+        side_effects: true,
+        unused: true,
     }
     input: {
         function f1() { return a == b ? true : x; }
@@ -675,9 +687,21 @@ ternary_boolean_consequent: {
 
 ternary_boolean_alternative: {
     options = {
-        collapse_vars:true, sequences:true, properties:true, dead_code:true, conditionals:true,
-        comparisons:true, evaluate:true, booleans:true, loops:true, unused:true, hoist_funs:true,
-        keep_fargs:true, if_return:true, join_vars:true, side_effects:true
+        booleans: true,
+        collapse_vars: true,
+        comparisons: true,
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        hoist_funs: true,
+        if_return: true,
+        join_vars: true,
+        keep_fargs: true,
+        loops: true,
+        properties: true,
+        sequences: true,
+        side_effects: true,
+        unused: true,
     }
     input: {
         function f1() { return a == b ? x : true; }
@@ -778,11 +802,11 @@ trivial_boolean_ternary_expressions : {
 
 issue_1154: {
     options = {
+        booleans: true,
         conditionals: true,
-        evaluate    : true,
-        booleans    : true,
+        evaluate: true,
         side_effects: true,
-    };
+    }
     input: {
         function f1(x) { return x ? -1 : -1; }
         function f2(x) { return x ? +2 : +2; }
@@ -818,7 +842,7 @@ issue_1154: {
 no_evaluate: {
     options = {
         conditionals: true,
-        evaluate    : false,
+        evaluate: false,
         side_effects: true,
     }
     input: {

test/compress/dead-code.js

@@ -1,7 +1,7 @@
 dead_code_1: {
     options = {
-        dead_code: true
-    };
+        dead_code: true,
+    }
     input: {
         function f() {
             a();
@@ -25,8 +25,8 @@ dead_code_1: {
 
 dead_code_2_should_warn: {
     options = {
-        dead_code: true
-    };
+        dead_code: true,
+    }
     input: {
         function f() {
             g();
@@ -64,13 +64,13 @@ dead_code_2_should_warn: {
 
 dead_code_constant_boolean_should_warn_more: {
     options = {
-        dead_code    : true,
-        loops        : true,
-        booleans     : true,
-        conditionals : true,
-        evaluate     : true,
-        side_effects : true,
-    };
+        booleans: true,
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        loops: true,
+        side_effects: true,
+    }
     input: {
         while (!((foo && bar) || (x + "0"))) {
             console.log("unreachable");

test/compress/debugger.js

@@ -1,7 +1,7 @@
 keep_debugger: {
     options = {
-        drop_debugger: false
-    };
+        drop_debugger: false,
+    }
     input: {
         debugger;
     }
@@ -12,8 +12,8 @@ keep_debugger: {
 
 drop_debugger: {
     options = {
-        drop_debugger: true
-    };
+        drop_debugger: true,
+    }
     input: {
         debugger;
         if (foo) debugger;

test/compress/drop-console.js

@@ -1,5 +1,5 @@
 drop_console_1: {
-    options = {};
+    options = {}
     input: {
         console.log('foo');
         console.log.apply(console, arguments);
@@ -11,7 +11,9 @@ drop_console_1: {
 }
 
 drop_console_2: {
-    options = { drop_console: true };
+    options = {
+        drop_console: true,
+    }
     input: {
         console.log('foo');
         console.log.apply(console, arguments);

test/compress/drop-unused.js

@@ -1,5 +1,8 @@
 unused_funarg_1: {
-    options = { unused: true, keep_fargs: false };
+    options = {
+        keep_fargs: false,
+        unused: true,
+    }
     input: {
         function f(a, b, c, d, e) {
             return a + b;
@@ -13,7 +16,10 @@ unused_funarg_1: {
 }
 
 unused_funarg_2: {
-    options = { unused: true, keep_fargs: false };
+    options = {
+        keep_fargs: false,
+        unused: true,
+    }
     input: {
         function f(a, b, c, d, e) {
             return a + c;
@@ -27,7 +33,9 @@ unused_funarg_2: {
 }
 
 unused_nested_function: {
-    options = { unused: true };
+    options = {
+        unused: true,
+    }
     input: {
         function f(x, y) {
             function g() {
@@ -44,7 +52,9 @@ unused_nested_function: {
 }
 
 unused_circular_references_1: {
-    options = { unused: true };
+    options = {
+        unused: true,
+    }
     input: {
         function f(x, y) {
             // circular reference
@@ -65,7 +75,9 @@ unused_circular_references_1: {
 }
 
 unused_circular_references_2: {
-    options = { unused: true };
+    options = {
+        unused: true,
+    }
     input: {
         function f(x, y) {
             var foo = 1, bar = baz, baz = foo + bar, qwe = moo();
@@ -81,7 +93,9 @@ unused_circular_references_2: {
 }
 
 unused_circular_references_3: {
-    options = { unused: true };
+    options = {
+        unused: true,
+    }
     input: {
         function f(x, y) {
             var g = function() { return h() };
@@ -97,7 +111,9 @@ unused_circular_references_3: {
 }
 
 unused_keep_setter_arg: {
-    options = { unused: true };
+    options = {
+        unused: true,
+    }
     input: {
         var x = {
             _foo: null,
@@ -121,7 +137,9 @@ unused_keep_setter_arg: {
 }
 
 unused_var_in_catch: {
-    options = { unused: true };
+    options = {
+        unused: true,
+    }
     input: {
         function foo() {
             try {
@@ -141,7 +159,9 @@ unused_var_in_catch: {
 }
 
 used_var_in_catch: {
-    options = { unused: true };
+    options = {
+        unused: true,
+    }
     input: {
         function foo() {
             try {
@@ -165,7 +185,11 @@ used_var_in_catch: {
 }
 
 keep_fnames: {
-    options = { unused: true, keep_fnames: true, unsafe: true };
+    options = {
+        keep_fnames: true,
+        unsafe: true,
+        unused: true,
+    }
     input: {
         function foo() {
             return function bar(baz) {};
@@ -367,7 +391,7 @@ drop_toplevel_vars_fargs: {
 drop_toplevel_all: {
     options = {
         toplevel: true,
-        unused: true
+        unused: true,
     }
     input: {
         var a, b = 1, c = g;
@@ -418,7 +442,11 @@ drop_toplevel_retain: {
 
 drop_toplevel_retain_array: {
     options = {
-        top_retain: [ "f", "a", "o" ],
+        top_retain: [
+            "f",
+            "a",
+            "o"
+        ],
         unused: true,
     }
     input: {
@@ -476,8 +504,8 @@ drop_toplevel_retain_regex: {
 
 drop_toplevel_all_retain: {
     options = {
-        toplevel: true,
         top_retain: "f,a,o",
+        toplevel: true,
         unused: true,
     }
     input: {
@@ -506,8 +534,8 @@ drop_toplevel_all_retain: {
 
 drop_toplevel_funcs_retain: {
     options = {
-        toplevel: "funcs",
         top_retain: "f,a,o",
+        toplevel: "funcs",
         unused: true,
     }
     input: {
@@ -537,8 +565,8 @@ drop_toplevel_funcs_retain: {
 
 drop_toplevel_vars_retain: {
     options = {
-        toplevel: "vars",
         top_retain: "f,a,o",
+        toplevel: "vars",
         unused: true,
     }
     input: {
@@ -1377,9 +1405,9 @@ issue_2516_1: {
 issue_2516_2: {
     options = {
         collapse_vars: true,
+        passes: 2,
         reduce_funcs: true,
         reduce_vars: true,
-        passes: 2,
         unused: true,
     }
     input: {

test/compress/evaluate.js

@@ -186,7 +186,9 @@ unary_prefix: {
 }
 
 negative_zero: {
-    options = { evaluate: true }
+    options = {
+        evaluate: true,
+    }
     input: {
         console.log(
             -"",
@@ -207,7 +209,9 @@ negative_zero: {
 }
 
 positive_zero: {
-    options = { evaluate: true }
+    options = {
+        evaluate: true,
+    }
     input: {
         console.log(
             +"",
@@ -229,8 +233,8 @@ positive_zero: {
 
 unsafe_constant: {
     options = {
-        evaluate  : true,
-        unsafe    : true
+        evaluate: true,
+        unsafe: true,
     }
     input: {
         console.log(
@@ -421,8 +425,8 @@ prop_function: {
 
 unsafe_integer_key: {
     options = {
-        evaluate  : true,
-        unsafe    : true
+        evaluate: true,
+        unsafe: true,
     }
     input: {
         console.log(
@@ -449,8 +453,8 @@ unsafe_integer_key: {
 
 unsafe_integer_key_complex: {
     options = {
-        evaluate  : true,
-        unsafe    : true
+        evaluate: true,
+        unsafe: true,
     }
     input: {
         console.log(
@@ -477,8 +481,8 @@ unsafe_integer_key_complex: {
 
 unsafe_float_key: {
     options = {
-        evaluate  : true,
-        unsafe    : true
+        evaluate: true,
+        unsafe: true,
     }
     input: {
         console.log(
@@ -505,8 +509,8 @@ unsafe_float_key: {
 
 unsafe_float_key_complex: {
     options = {
-        evaluate  : true,
-        unsafe    : true
+        evaluate: true,
+        unsafe: true,
     }
     input: {
         console.log(
@@ -533,8 +537,8 @@ unsafe_float_key_complex: {
 
 unsafe_array: {
     options = {
-        evaluate  : true,
-        unsafe    : true
+        evaluate: true,
+        unsafe: true,
     }
     input: {
         console.log(
@@ -569,8 +573,8 @@ unsafe_array: {
 
 unsafe_string: {
     options = {
-        evaluate  : true,
-        unsafe    : true
+        evaluate: true,
+        unsafe: true,
     }
     input: {
         console.log(
@@ -597,8 +601,8 @@ unsafe_string: {
 
 unsafe_array_bad_index: {
     options = {
-        evaluate  : true,
-        unsafe    : true
+        evaluate: true,
+        unsafe: true,
     }
     input: {
         console.log(
@@ -619,8 +623,8 @@ unsafe_array_bad_index: {
 
 unsafe_string_bad_index: {
     options = {
-        evaluate  : true,
-        unsafe    : true
+        evaluate: true,
+        unsafe: true,
     }
     input: {
         console.log(
@@ -754,8 +758,8 @@ in_boolean_context: {
 
 unsafe_charAt: {
     options = {
-        evaluate  : true,
-        unsafe    : true
+        evaluate: true,
+        unsafe: true,
     }
     input: {
         console.log(
@@ -782,8 +786,8 @@ unsafe_charAt: {
 
 unsafe_charAt_bad_index: {
     options = {
-        evaluate  : true,
-        unsafe    : true
+        evaluate: true,
+        unsafe: true,
     }
     input: {
         console.log(
@@ -804,8 +808,8 @@ unsafe_charAt_bad_index: {
 
 unsafe_charAt_noop: {
     options = {
-        evaluate  : true,
-        unsafe    : true
+        evaluate: true,
+        unsafe: true,
     }
     input: {
         console.log(
@@ -1195,7 +1199,7 @@ issue_2231_1: {
     }
     expect_stdout: true
     expect_warnings: [
-        "WARN: Error evaluating Object.keys(void 0) [test/compress/evaluate.js:1191,20]",
+        "WARN: Error evaluating Object.keys(void 0) [test/compress/evaluate.js:1,20]",
     ]
 }
 
@@ -1212,7 +1216,7 @@ issue_2231_2: {
     }
     expect_stdout: true
     expect_warnings: [
-        "WARN: Error evaluating Object.getOwnPropertyNames(null) [test/compress/evaluate.js:1208,20]",
+        "WARN: Error evaluating Object.getOwnPropertyNames(null) [test/compress/evaluate.js:1,20]",
     ]
 }
 
@@ -1350,14 +1354,14 @@ issue_2535_3: {
     }
     expect_stdout: true
     expect_warnings: [
-        "WARN: Dropping side-effect-free && [test/compress/evaluate.js:1336,20]",
-        "WARN: Dropping side-effect-free && [test/compress/evaluate.js:1337,20]",
-        "WARN: Dropping side-effect-free && [test/compress/evaluate.js:1338,20]",
-        "WARN: Condition left of && always false [test/compress/evaluate.js:1338,20]",
-        "WARN: Dropping side-effect-free || [test/compress/evaluate.js:1339,20]",
-        "WARN: Dropping side-effect-free || [test/compress/evaluate.js:1340,20]",
-        "WARN: Dropping side-effect-free || [test/compress/evaluate.js:1341,20]",
-        "WARN: Condition left of || always true [test/compress/evaluate.js:1341,20]",
+        "WARN: Dropping side-effect-free && [test/compress/evaluate.js:1,20]",
+        "WARN: Dropping side-effect-free && [test/compress/evaluate.js:2,20]",
+        "WARN: Dropping side-effect-free && [test/compress/evaluate.js:3,20]",
+        "WARN: Condition left of && always false [test/compress/evaluate.js:3,20]",
+        "WARN: Dropping side-effect-free || [test/compress/evaluate.js:4,20]",
+        "WARN: Dropping side-effect-free || [test/compress/evaluate.js:5,20]",
+        "WARN: Dropping side-effect-free || [test/compress/evaluate.js:6,20]",
+        "WARN: Condition left of || always true [test/compress/evaluate.js:6,20]",
     ]
 }
 

test/compress/functions.js

@@ -9,20 +9,20 @@ non_ascii_function_identifier_name: {
 
 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_funcs  : true,
-        reduce_vars   : true,
-        collapse_vars : true,
-        inline        : true,
+        booleans: true,
+        collapse_vars: true,
+        comparisons: true,
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        if_return: true,
+        inline: true,
+        join_vars: true,
+        keep_fargs: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        side_effects: true,
+        unused: true,
     }
     input: {
         (function(){ return -1.23; }());
@@ -46,20 +46,20 @@ iifes_returning_constants_keep_fargs_true: {
 
 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_funcs  : true,
-        reduce_vars   : true,
-        collapse_vars : true,
-        inline        : true,
+        booleans: true,
+        collapse_vars: true,
+        comparisons: true,
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        if_return: true,
+        inline: true,
+        join_vars: true,
+        keep_fargs: false,
+        reduce_funcs: true,
+        reduce_vars: true,
+        side_effects: true,
+        unused: true,
     }
     input: {
         (function(){ return -1.23; }());
@@ -1175,8 +1175,8 @@ issue_2620_3: {
 issue_2620_4: {
     rename = true,
     options = {
-        evaluate: true,
         dead_code: true,
+        evaluate: true,
         inline: true,
         passes: 2,
         reduce_vars: true,
@@ -2025,6 +2025,7 @@ deduplicate_parenthesis: {
 
 drop_lone_use_strict: {
     options = {
+        directives: true,
         side_effects: true,
     }
     input: {
@@ -2052,6 +2053,27 @@ drop_lone_use_strict: {
     }
 }
 
+issue_3166: {
+    options = {
+        directives: true,
+    }
+    input: {
+        "foo";
+        "use strict";
+        function f() {
+            "use strict";
+            "bar";
+            "use asm";
+        }
+    }
+    expect: {
+        "use strict";
+        function f() {
+            "use asm";
+        }
+    }
+}
+
 issue_3016_1: {
     options = {
         inline: true,

test/compress/global_defs.js

@@ -2,7 +2,7 @@ must_replace: {
     options = {
         global_defs: {
             D: "foo bar",
-        }
+        },
     }
     input: {
         console.log(D);
@@ -141,9 +141,9 @@ mixed: {
         console.log(CONFIG);
     }
     expect_warnings: [
-        'WARN: global_defs CONFIG.VALUE redefined [test/compress/global_defs.js:127,22]',
-        'WARN: global_defs CONFIG.VALUE redefined [test/compress/global_defs.js:128,22]',
-        'WARN: global_defs CONFIG.VALUE redefined [test/compress/global_defs.js:130,8]',
+        "WARN: global_defs CONFIG.VALUE redefined [test/compress/global_defs.js:4,22]",
+        "WARN: global_defs CONFIG.VALUE redefined [test/compress/global_defs.js:5,22]",
+        "WARN: global_defs CONFIG.VALUE redefined [test/compress/global_defs.js:7,8]",
     ]
 }
 

test/compress/hoist_props.js

@@ -1,8 +1,8 @@
 issue_2377_1: {
     options = {
         evaluate: true,
-        inline: true,
         hoist_props: true,
+        inline: true,
         reduce_funcs: true,
         reduce_vars: true,
         toplevel: true,
@@ -33,8 +33,8 @@ issue_2377_1: {
 issue_2377_2: {
     options = {
         evaluate: true,
-        inline: true,
         hoist_props: true,
+        inline: true,
         passes: 2,
         reduce_funcs: true,
         reduce_vars: true,
@@ -64,8 +64,8 @@ issue_2377_2: {
 issue_2377_3: {
     options = {
         evaluate: true,
-        inline: true,
         hoist_props: true,
+        inline: true,
         passes: 4,
         reduce_funcs: true,
         reduce_vars: true,
@@ -416,7 +416,10 @@ issue_2473_1: {
     options = {
         hoist_props: false,
         reduce_vars: true,
-        top_retain: [ "x", "y" ],
+        top_retain: [
+            "x",
+            "y"
+        ],
         toplevel: true,
         unused: true,
     }
@@ -435,7 +438,10 @@ issue_2473_2: {
     options = {
         hoist_props: true,
         reduce_vars: true,
-        top_retain: [ "x", "y" ],
+        top_retain: [
+            "x",
+            "y"
+        ],
         toplevel: true,
         unused: true,
     }
@@ -746,9 +752,9 @@ issue_3046: {
 issue_3071_1: {
     options = {
         evaluate: true,
+        hoist_props: true,
         inline: true,
         join_vars: true,
-        hoist_props: true,
         passes: 3,
         reduce_vars: true,
         sequences: true,
@@ -773,9 +779,9 @@ issue_3071_1: {
 issue_3071_2: {
     options = {
         evaluate: true,
+        hoist_props: true,
         inline: true,
         join_vars: true,
-        hoist_props: true,
         passes: 3,
         reduce_vars: true,
         sequences: true,
@@ -800,9 +806,9 @@ issue_3071_2: {
 issue_3071_2_toplevel: {
     options = {
         evaluate: true,
+        hoist_props: true,
         inline: true,
         join_vars: true,
-        hoist_props: true,
         passes: 3,
         reduce_vars: true,
         sequences: true,

test/compress/ie8.js

@@ -187,9 +187,9 @@ dont_screw_try_catch_undefined: {
 reduce_vars: {
     options = {
         evaluate: true,
+        ie8: true,
         reduce_funcs: true,
         reduce_vars: true,
-        ie8: true,
         unused: true,
     }
     mangle = {
@@ -666,3 +666,48 @@ issue_3197_2_ie8: {
     }
     expect_stdout: "true"
 }
+
+issue_3206_1: {
+    options = {
+        evaluate: true,
+        ie8: false,
+        reduce_vars: true,
+        typeofs: true,
+        unused: true,
+    }
+    input: {
+        console.log(function() {
+            var foo = function bar() {};
+            return "function" == typeof bar;
+        }());
+    }
+    expect: {
+        console.log(function() {
+            return "function" == typeof bar;
+        }());
+    }
+    expect_stdout: "false"
+}
+
+issue_3206_2: {
+    options = {
+        evaluate: true,
+        ie8: true,
+        reduce_vars: true,
+        typeofs: true,
+        unused: true,
+    }
+    input: {
+        console.log(function() {
+            var foo = function bar() {};
+            return "function" == typeof bar;
+        }());
+    }
+    expect: {
+        console.log(function() {
+            (function bar() {});
+            return "function" == typeof bar;
+        }());
+    }
+    expect_stdout: "false"
+}

test/compress/if_return.js

@@ -1,14 +1,14 @@
 if_return_1: {
     options = {
-        if_return    : true,
-        sequences    : true,
-        conditionals : true,
-        comparisons  : true,
-        evaluate     : true,
-        booleans     : true,
-        unused       : true,
-        side_effects : true,
-        dead_code    : true,
+        booleans: true,
+        comparisons: true,
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        if_return: true,
+        sequences: true,
+        side_effects: true,
+        unused: true,
     }
     input: {
         function f(x) {
@@ -24,15 +24,15 @@ if_return_1: {
 
 if_return_2: {
     options = {
-        if_return    : true,
-        sequences    : true,
-        conditionals : true,
-        comparisons  : true,
-        evaluate     : true,
-        booleans     : true,
-        unused       : true,
-        side_effects : true,
-        dead_code    : true,
+        booleans: true,
+        comparisons: true,
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        if_return: true,
+        sequences: true,
+        side_effects: true,
+        unused: true,
     }
     input: {
         function f(x, y) {
@@ -49,15 +49,15 @@ if_return_2: {
 
 if_return_3: {
     options = {
-        if_return    : true,
-        sequences    : true,
-        conditionals : true,
-        comparisons  : true,
-        evaluate     : true,
-        booleans     : true,
-        unused       : true,
-        side_effects : true,
-        dead_code    : true,
+        booleans: true,
+        comparisons: true,
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        if_return: true,
+        sequences: true,
+        side_effects: true,
+        unused: true,
     }
     input: {
         function f(x) {
@@ -75,15 +75,15 @@ if_return_3: {
 
 if_return_4: {
     options = {
-        if_return    : true,
-        sequences    : true,
-        conditionals : true,
-        comparisons  : true,
-        evaluate     : true,
-        booleans     : true,
-        unused       : true,
-        side_effects : true,
-        dead_code    : true,
+        booleans: true,
+        comparisons: true,
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        if_return: true,
+        sequences: true,
+        side_effects: true,
+        unused: true,
     }
     input: {
         function f(x, y) {
@@ -100,15 +100,15 @@ if_return_4: {
 
 if_return_5: {
     options = {
-        if_return    : true,
-        sequences    : true,
-        conditionals : true,
-        comparisons  : true,
-        evaluate     : true,
-        booleans     : true,
-        unused       : true,
-        side_effects : true,
-        dead_code    : true,
+        booleans: true,
+        comparisons: true,
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        if_return: true,
+        sequences: true,
+        side_effects: true,
+        unused: true,
     }
     input: {
         function f() {
@@ -126,15 +126,15 @@ if_return_5: {
 
 if_return_6: {
     options = {
-        if_return    : true,
-        sequences    : true,
-        conditionals : true,
-        comparisons  : true,
-        evaluate     : true,
-        booleans     : true,
-        unused       : true,
-        side_effects : true,
-        dead_code    : true,
+        booleans: true,
+        comparisons: true,
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        if_return: true,
+        sequences: true,
+        side_effects: true,
+        unused: true,
     }
     input: {
         function f(x) {
@@ -150,15 +150,15 @@ if_return_6: {
 
 if_return_7: {
     options = {
-        if_return    : true,
-        sequences    : true,
-        conditionals : true,
-        comparisons  : true,
-        evaluate     : true,
-        booleans     : true,
-        unused       : true,
-        side_effects : true,
-        dead_code    : true,
+        booleans: true,
+        comparisons: true,
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        if_return: true,
+        sequences: true,
+        side_effects: true,
+        unused: true,
     }
     input: {
         function f(x) {
@@ -176,10 +176,10 @@ if_return_7: {
 
 if_return_8: {
     options = {
-        if_return:     true,
-        sequences:     true,
-        conditionals:  true,
-        side_effects : true,
+        conditionals: true,
+        if_return: true,
+        sequences: true,
+        side_effects: true,
     }
     input: {
         function f(e) {
@@ -220,15 +220,15 @@ if_return_8: {
 
 issue_1089: {
     options = {
-        if_return    : true,
-        sequences    : true,
-        conditionals : true,
-        comparisons  : true,
-        evaluate     : true,
-        booleans     : true,
-        unused       : true,
-        side_effects : true,
-        dead_code    : true,
+        booleans: true,
+        comparisons: true,
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        if_return: true,
+        sequences: true,
+        side_effects: true,
+        unused: true,
     }
     input: {
         function x() {
@@ -251,9 +251,9 @@ issue_1089: {
 
 issue_1437: {
     options = {
-        if_return    : true,
-        sequences    : true,
-        conditionals : false
+        conditionals: false,
+        if_return: true,
+        sequences: true,
     }
     input: {
         function x() {
@@ -281,9 +281,9 @@ issue_1437: {
 
 issue_1437_conditionals: {
     options = {
-        conditionals : true,
-        if_return    : true,
-        sequences    : true
+        conditionals: true,
+        if_return: true,
+        sequences: true,
     }
     input: {
         function x() {

test/compress/issue-1034.js

@@ -1,8 +1,17 @@
 non_hoisted_function_after_return: {
     options = {
-        hoist_funs: false, dead_code: true, conditionals: true, comparisons: true,
-        evaluate: true, booleans: true, loops: true, unused: true, keep_fargs: true,
-        if_return: true, join_vars: true, side_effects: true
+        booleans: true,
+        comparisons: true,
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        hoist_funs: false,
+        if_return: true,
+        join_vars: true,
+        keep_fargs: true,
+        loops: true,
+        side_effects: true,
+        unused: true,
     }
     input: {
         function foo(x) {
@@ -27,19 +36,30 @@ non_hoisted_function_after_return: {
         }
     }
     expect_warnings: [
-        'WARN: Dropping unreachable code [test/compress/issue-1034.js:11,16]',
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:14,16]",
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:17,12]",
-        "WARN: Dropping unused function UnusedFunction [test/compress/issue-1034.js:18,21]"
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:4,16]",
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:7,16]",
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:10,12]",
+        "WARN: Dropping unused function UnusedFunction [test/compress/issue-1034.js:11,21]"
     ]
 }
 
 non_hoisted_function_after_return_2a: {
     options = {
-        hoist_funs: false, dead_code: true, conditionals: true, comparisons: true,
-        evaluate: true, booleans: true, loops: true, unused: true, keep_fargs: true,
-        if_return: true, join_vars: true, side_effects: true,
-        collapse_vars: false, passes: 2, warnings: "verbose"
+        booleans: true,
+        collapse_vars: false,
+        comparisons: true,
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        hoist_funs: false,
+        if_return: true,
+        join_vars: true,
+        keep_fargs: true,
+        loops: true,
+        passes: 2,
+        side_effects: true,
+        unused: true,
+        warnings: "verbose",
     }
     input: {
         function foo(x) {
@@ -65,28 +85,37 @@ non_hoisted_function_after_return_2a: {
         }
     }
     expect_warnings: [
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:48,16]",
-        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:48,16]",
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:51,16]",
-        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:51,16]",
-        "WARN: Dropping unused variable a [test/compress/issue-1034.js:48,20]",
-        "WARN: Dropping unused function nope [test/compress/issue-1034.js:55,21]",
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:4,16]",
+        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:4,16]",
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:7,16]",
+        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:7,16]",
+        "WARN: Dropping unused variable a [test/compress/issue-1034.js:4,20]",
+        "WARN: Dropping unused function nope [test/compress/issue-1034.js:11,21]",
         "WARN: pass 0: last_count: Infinity, count: 37",
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:53,12]",
-        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:53,12]",
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:56,12]",
-        "WARN: Dropping unused variable b [test/compress/issue-1034.js:51,20]",
-        "WARN: Dropping unused variable c [test/compress/issue-1034.js:53,16]",
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:9,12]",
+        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:9,12]",
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:12,12]",
+        "WARN: Dropping unused variable b [test/compress/issue-1034.js:7,20]",
+        "WARN: Dropping unused variable c [test/compress/issue-1034.js:9,16]",
         "WARN: pass 1: last_count: 37, count: 18",
     ]
 }
 
 non_hoisted_function_after_return_2b: {
     options = {
-        hoist_funs: false, dead_code: true, conditionals: true, comparisons: true,
-        evaluate: true, booleans: true, loops: true, unused: true, keep_fargs: true,
-        if_return: true, join_vars: true, side_effects: true,
-        collapse_vars: false
+        booleans: true,
+        collapse_vars: false,
+        comparisons: true,
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        hoist_funs: false,
+        if_return: true,
+        join_vars: true,
+        keep_fargs: true,
+        loops: true,
+        side_effects: true,
+        unused: true,
     }
     input: {
         function foo(x) {
@@ -110,20 +139,28 @@ non_hoisted_function_after_return_2b: {
         }
     }
     expect_warnings: [
-        // duplicate warnings no longer emitted
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:97,16]",
-        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:97,16]",
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:99,12]",
-        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:99,12]",
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:103,12]",
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:6,16]",
+        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:6,16]",
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:8,12]",
+        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:8,12]",
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:12,12]",
     ]
 }
 
 non_hoisted_function_after_return_strict: {
     options = {
-        hoist_funs: false, dead_code: true, conditionals: true, comparisons: true,
-        evaluate: true, booleans: true, loops: true, unused: true, keep_fargs: true,
-        if_return: true, join_vars: true, side_effects: true
+        booleans: true,
+        comparisons: true,
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        hoist_funs: false,
+        if_return: true,
+        join_vars: true,
+        keep_fargs: true,
+        loops: true,
+        side_effects: true,
+        unused: true,
     }
     input: {
         "use strict";
@@ -153,19 +190,30 @@ non_hoisted_function_after_return_strict: {
     }
     expect_stdout: "8 7"
     expect_warnings: [
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:133,16]",
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:136,16]",
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:139,12]",
-        "WARN: Dropping unused function UnusedFunction [test/compress/issue-1034.js:140,21]",
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:5,16]",
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:8,16]",
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:11,12]",
+        "WARN: Dropping unused function UnusedFunction [test/compress/issue-1034.js:12,21]",
     ]
 }
 
 non_hoisted_function_after_return_2a_strict: {
     options = {
-        hoist_funs: false, dead_code: true, conditionals: true, comparisons: true,
-        evaluate: true, booleans: true, loops: true, unused: true, keep_fargs: true,
-        if_return: true, join_vars: true, side_effects: true,
-        collapse_vars: false, passes: 2, warnings: "verbose"
+        booleans: true,
+        collapse_vars: false,
+        comparisons: true,
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        hoist_funs: false,
+        if_return: true,
+        join_vars: true,
+        keep_fargs: true,
+        loops: true,
+        passes: 2,
+        side_effects: true,
+        unused: true,
+        warnings: "verbose",
     }
     input: {
         "use strict";
@@ -196,28 +244,37 @@ non_hoisted_function_after_return_2a_strict: {
     }
     expect_stdout: "5 6"
     expect_warnings: [
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:175,16]",
-        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:175,16]",
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:178,16]",
-        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:178,16]",
-        "WARN: Dropping unused variable a [test/compress/issue-1034.js:175,20]",
-        "WARN: Dropping unused function nope [test/compress/issue-1034.js:182,21]",
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:5,16]",
+        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:5,16]",
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:8,16]",
+        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:8,16]",
+        "WARN: Dropping unused variable a [test/compress/issue-1034.js:5,20]",
+        "WARN: Dropping unused function nope [test/compress/issue-1034.js:12,21]",
         "WARN: pass 0: last_count: Infinity, count: 48",
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:180,12]",
-        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:180,12]",
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:183,12]",
-        "WARN: Dropping unused variable b [test/compress/issue-1034.js:178,20]",
-        "WARN: Dropping unused variable c [test/compress/issue-1034.js:180,16]",
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:10,12]",
+        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:10,12]",
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:13,12]",
+        "WARN: Dropping unused variable b [test/compress/issue-1034.js:8,20]",
+        "WARN: Dropping unused variable c [test/compress/issue-1034.js:10,16]",
         "WARN: pass 1: last_count: 48, count: 29",
     ]
 }
 
 non_hoisted_function_after_return_2b_strict: {
     options = {
-        hoist_funs: false, dead_code: true, conditionals: true, comparisons: true,
-        evaluate: true, booleans: true, loops: true, unused: true, keep_fargs: true,
-        if_return: true, join_vars: true, side_effects: true,
-        collapse_vars: false
+        booleans: true,
+        collapse_vars: false,
+        comparisons: true,
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        hoist_funs: false,
+        if_return: true,
+        join_vars: true,
+        keep_fargs: true,
+        loops: true,
+        side_effects: true,
+        unused: true,
     }
     input: {
         "use strict";
@@ -246,11 +303,10 @@ non_hoisted_function_after_return_2b_strict: {
     }
     expect_stdout: "5 6"
     expect_warnings: [
-        // duplicate warnings no longer emitted
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:229,16]",
-        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:229,16]",
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:231,12]",
-        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:231,12]",
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:235,12]",
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:7,16]",
+        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:7,16]",
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:9,12]",
+        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:9,12]",
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:13,12]",
     ]
 }

test/compress/issue-1041.js

@@ -3,7 +3,7 @@ const_pragma: {
         evaluate: true,
         reduce_funcs: true,
         reduce_vars: true,
-    };
+    }
 
     input: {
         /** @const */ var goog = goog || {};
@@ -19,7 +19,7 @@ not_const: {
         evaluate: true,
         reduce_funcs: true,
         reduce_vars: true,
-    };
+    }
 
     input: {
         var goog = goog || {};

test/compress/issue-1105.js

@@ -1,6 +1,6 @@
 with_in_global_scope: {
     options = {
-        unused: true
+        unused: true,
     }
     input: {
         var o = 42;
@@ -18,7 +18,7 @@ with_in_global_scope: {
 }
 with_in_function_scope: {
     options = {
-        unused: true
+        unused: true,
     }
     input: {
         function foo() {
@@ -40,7 +40,7 @@ with_in_function_scope: {
 }
 compress_with_with_in_other_scope: {
     options = {
-        unused: true
+        unused: true,
     }
     input: {
         function foo() {
@@ -69,7 +69,7 @@ compress_with_with_in_other_scope: {
 }
 with_using_existing_variable_outside_scope: {
     options = {
-        unused: true
+        unused: true,
     }
     input: {
         function f() {
@@ -99,7 +99,7 @@ with_using_existing_variable_outside_scope: {
 }
 check_drop_unused_in_peer_function: {
     options = {
-        unused: true
+        unused: true,
     }
     input: {
         function outer() {
@@ -148,7 +148,7 @@ check_drop_unused_in_peer_function: {
 
 Infinity_not_in_with_scope: {
     options = {
-        unused: true
+        unused: true,
     }
     input: {
         var o = { Infinity: 'oInfinity' };
@@ -164,7 +164,7 @@ Infinity_not_in_with_scope: {
 
 Infinity_in_with_scope: {
     options = {
-        unused: true
+        unused: true,
     }
     input: {
         var o = { Infinity: 'oInfinity' };
@@ -180,19 +180,19 @@ Infinity_in_with_scope: {
 
 assorted_Infinity_NaN_undefined_in_with_scope: {
     options = {
-        unused:        true,
-        evaluate:      true,
-        dead_code:     true,
-        conditionals:  true,
-        comparisons:   true,
-        booleans:      true,
-        hoist_funs:    true,
-        keep_fargs:    true,
-        if_return:     true,
-        join_vars:     true,
-        side_effects:  true,
-        sequences:     false,
+        booleans: true,
+        comparisons: true,
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        hoist_funs: true,
+        if_return: true,
+        join_vars: true,
+        keep_fargs: true,
         keep_infinity: false,
+        sequences: false,
+        side_effects: true,
+        unused: true,
     }
     input: {
         var f = console.log;
@@ -242,19 +242,19 @@ assorted_Infinity_NaN_undefined_in_with_scope: {
 
 assorted_Infinity_NaN_undefined_in_with_scope_keep_infinity: {
     options = {
-        unused:        true,
-        evaluate:      true,
-        dead_code:     true,
-        conditionals:  true,
-        comparisons:   true,
-        booleans:      true,
-        hoist_funs:    true,
-        keep_fargs:    true,
-        if_return:     true,
-        join_vars:     true,
-        side_effects:  true,
-        sequences:     false,
+        booleans: true,
+        comparisons: true,
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        hoist_funs: true,
+        if_return: true,
+        join_vars: true,
+        keep_fargs: true,
         keep_infinity: true,
+        sequences: false,
+        side_effects: true,
+        unused: true,
     }
     input: {
         var f = console.log;

test/compress/issue-12.js

@@ -1,11 +1,15 @@
 keep_name_of_getter: {
-    options = { unused: true };
+    options = {
+        unused: true,
+    }
     input: { a = { get foo () {} } }
     expect: { a = { get foo () {} } }
 }
 
 keep_name_of_setter: {
-    options = { unused: true };
+    options = {
+        unused: true,
+    }
     input: { a = { set foo () {} } }
     expect: { a = { set foo () {} } }
 }

test/compress/issue-1202.js

@@ -1,7 +1,7 @@
 mangle_keep_fnames_false: {
     options = {
-        keep_fnames : true,
-        keep_fargs  : true,
+        keep_fargs: true,
+        keep_fnames: true,
     }
     mangle = {
         keep_fnames : false,
@@ -26,8 +26,8 @@ mangle_keep_fnames_false: {
 
 mangle_keep_fnames_true: {
     options = {
-        keep_fnames : true,
-        keep_fargs  : true,
+        keep_fargs: true,
+        keep_fnames: true,
     }
     mangle = {
         keep_fnames : true,

test/compress/issue-1261.js

@@ -1,14 +1,14 @@
 pure_function_calls: {
     options = {
-        evaluate     : true,
-        conditionals : true,
-        comparisons  : true,
-        side_effects : true,
-        booleans     : true,
-        unused       : true,
-        if_return    : true,
-        join_vars    : true,
-        negate_iife  : true,
+        booleans: true,
+        comparisons: true,
+        conditionals: true,
+        evaluate: true,
+        if_return: true,
+        join_vars: true,
+        negate_iife: true,
+        side_effects: true,
+        unused: true,
     }
     input: {
         // pure top-level IIFE will be dropped
@@ -48,28 +48,28 @@ pure_function_calls: {
         a.b(), f.g();
     }
     expect_warnings: [
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:16,8]",
-        "WARN: Dropping side-effect-free statement [test/compress/issue-1261.js:16,8]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:29,37]",
-        "WARN: Dropping unused variable iife2 [test/compress/issue-1261.js:29,16]",
-        "WARN: Dropping side-effect-free statement [test/compress/issue-1261.js:27,8]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:37,8]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:38,31]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:3,8]",
+        "WARN: Dropping side-effect-free statement [test/compress/issue-1261.js:3,8]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:16,37]",
+        "WARN: Dropping unused variable iife2 [test/compress/issue-1261.js:16,16]",
+        "WARN: Dropping side-effect-free statement [test/compress/issue-1261.js:14,8]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:24,8]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:25,31]",
     ]
 }
 
 pure_function_calls_toplevel: {
     options = {
-        evaluate     : true,
-        conditionals : true,
-        comparisons  : true,
-        side_effects : true,
-        booleans     : true,
-        unused       : true,
-        if_return    : true,
-        join_vars    : true,
-        negate_iife  : true,
-        toplevel     : true,
+        booleans: true,
+        comparisons: true,
+        conditionals: true,
+        evaluate: true,
+        if_return: true,
+        join_vars: true,
+        negate_iife: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
     }
     input: {
         // pure top-level IIFE will be dropped
@@ -110,17 +110,17 @@ pure_function_calls_toplevel: {
         a.b(), f.g();
     }
     expect_warnings: [
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:77,8]",
-        "WARN: Dropping side-effect-free statement [test/compress/issue-1261.js:77,8]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:90,37]",
-        "WARN: Dropping unused variable iife2 [test/compress/issue-1261.js:90,16]",
-        "WARN: Dropping side-effect-free statement [test/compress/issue-1261.js:88,8]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:105,8]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:106,31]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:82,33]",
-        "WARN: Dropping unused variable iife1 [test/compress/issue-1261.js:82,12]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:98,45]",
-        "WARN: Dropping unused variable MyClass [test/compress/issue-1261.js:98,12]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:3,8]",
+        "WARN: Dropping side-effect-free statement [test/compress/issue-1261.js:3,8]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:16,37]",
+        "WARN: Dropping unused variable iife2 [test/compress/issue-1261.js:16,16]",
+        "WARN: Dropping side-effect-free statement [test/compress/issue-1261.js:14,8]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:31,8]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:32,31]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:8,33]",
+        "WARN: Dropping unused variable iife1 [test/compress/issue-1261.js:8,12]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:24,45]",
+        "WARN: Dropping unused variable MyClass [test/compress/issue-1261.js:24,12]",
     ]
 }
 
@@ -155,29 +155,29 @@ should_warn: {
         baz();
     }
     expect_warnings: [
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:135,61]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:135,23]",
-        "WARN: Dropping side-effect-free statement [test/compress/issue-1261.js:135,23]",
-        "WARN: Boolean || always true [test/compress/issue-1261.js:136,23]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:136,23]",
-        "WARN: Condition always true [test/compress/issue-1261.js:136,23]",
-        "WARN: Condition left of || always true [test/compress/issue-1261.js:137,8]",
-        "WARN: Condition always true [test/compress/issue-1261.js:137,8]",
-        "WARN: Boolean && always false [test/compress/issue-1261.js:138,23]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:138,23]",
-        "WARN: Condition always false [test/compress/issue-1261.js:138,23]",
-        "WARN: Condition left of && always false [test/compress/issue-1261.js:139,8]",
-        "WARN: Condition always false [test/compress/issue-1261.js:139,8]",
-        "WARN: + in boolean context always true [test/compress/issue-1261.js:140,23]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:140,23]",
-        "WARN: Condition always true [test/compress/issue-1261.js:140,23]",
-        "WARN: + in boolean context always true [test/compress/issue-1261.js:141,8]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:141,31]",
-        "WARN: Condition always true [test/compress/issue-1261.js:141,8]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:142,23]",
-        "WARN: Condition always true [test/compress/issue-1261.js:143,8]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:143,24]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:144,31]",
-        "WARN: Condition always false [test/compress/issue-1261.js:144,8]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:1,61]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:1,23]",
+        "WARN: Dropping side-effect-free statement [test/compress/issue-1261.js:1,23]",
+        "WARN: Boolean || always true [test/compress/issue-1261.js:2,23]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:2,23]",
+        "WARN: Condition always true [test/compress/issue-1261.js:2,23]",
+        "WARN: Condition left of || always true [test/compress/issue-1261.js:3,8]",
+        "WARN: Condition always true [test/compress/issue-1261.js:3,8]",
+        "WARN: Boolean && always false [test/compress/issue-1261.js:4,23]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:4,23]",
+        "WARN: Condition always false [test/compress/issue-1261.js:4,23]",
+        "WARN: Condition left of && always false [test/compress/issue-1261.js:5,8]",
+        "WARN: Condition always false [test/compress/issue-1261.js:5,8]",
+        "WARN: + in boolean context always true [test/compress/issue-1261.js:6,23]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:6,23]",
+        "WARN: Condition always true [test/compress/issue-1261.js:6,23]",
+        "WARN: + in boolean context always true [test/compress/issue-1261.js:7,8]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:7,31]",
+        "WARN: Condition always true [test/compress/issue-1261.js:7,8]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:8,23]",
+        "WARN: Condition always true [test/compress/issue-1261.js:9,8]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:9,24]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:10,31]",
+        "WARN: Condition always false [test/compress/issue-1261.js:10,8]",
     ]
 }

test/compress/issue-1275.js

@@ -1,16 +1,16 @@
 string_plus_optimization: {
     options = {
-        side_effects  : true,
-        evaluate      : true,
-        conditionals  : true,
-        comparisons   : true,
-        dead_code     : true,
-        booleans      : true,
-        unused        : true,
-        if_return     : true,
-        join_vars     : true,
-        hoist_funs    : true,
-    };
+        booleans: true,
+        comparisons: true,
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        hoist_funs: true,
+        if_return: true,
+        join_vars: true,
+        side_effects: true,
+        unused: true,
+    }
     input: {
         function foo(anything) {
             function throwing_function() {

test/compress/issue-143.js

@@ -15,7 +15,7 @@
 tranformation_sort_order_equal: {
     options = {
         comparisons: true,
-    };
+    }
 
     input: { (a = parseInt('100')) == a }
     expect: { (a = parseInt('100')) == a }
@@ -24,7 +24,7 @@ tranformation_sort_order_equal: {
 tranformation_sort_order_unequal: {
     options = {
         comparisons: true,
-    };
+    }
 
     input: { (a = parseInt('100')) != a }
     expect: { (a = parseInt('100')) != a }
@@ -33,7 +33,7 @@ tranformation_sort_order_unequal: {
 tranformation_sort_order_lesser_or_equal: {
     options = {
         comparisons: true,
-    };
+    }
 
     input: { (a = parseInt('100')) <= a }
     expect: { (a = parseInt('100')) <= a }
@@ -41,7 +41,7 @@ tranformation_sort_order_lesser_or_equal: {
 tranformation_sort_order_greater_or_equal: {
     options = {
         comparisons: true,
-    };
+    }
 
     input: { (a = parseInt('100')) >= a }
     expect: { (a = parseInt('100')) >= a }

test/compress/issue-1431.js

@@ -1,6 +1,6 @@
 level_zero: {
     options = {
-        keep_fnames: true
+        keep_fnames: true,
     }
     mangle = {
         keep_fnames: true
@@ -29,7 +29,7 @@ level_zero: {
 
 level_one: {
     options = {
-        keep_fnames: true
+        keep_fnames: true,
     }
     mangle = {
         keep_fnames: true
@@ -58,7 +58,7 @@ level_one: {
 
 level_two: {
     options = {
-        keep_fnames: true
+        keep_fnames: true,
     }
     mangle = {
         keep_fnames: true
@@ -97,7 +97,7 @@ level_two: {
 
 level_three: {
     options = {
-        keep_fnames: true
+        keep_fnames: true,
     }
     mangle = {
         keep_fnames: true

test/compress/issue-1447.js

@@ -22,17 +22,17 @@ else_with_empty_statement: {
 
 conditional_false_stray_else_in_loop: {
     options = {
-        evaluate     : true,
-        comparisons  : true,
-        booleans     : true,
-        unused       : true,
-        loops        : true,
-        side_effects : true,
-        dead_code    : true,
-        hoist_vars   : true,
-        join_vars    : true,
-        if_return    : true,
-        conditionals : false,
+        booleans: true,
+        comparisons: true,
+        conditionals: false,
+        dead_code: true,
+        evaluate: true,
+        hoist_vars: true,
+        if_return: true,
+        join_vars: true,
+        loops: true,
+        side_effects: true,
+        unused: true,
     }
     input: {
         for (var i = 1; i <= 4; ++i) {

test/compress/issue-1833.js

@@ -125,8 +125,8 @@ label_do: {
 
 label_while: {
     options = {
-        evaluate: true,
         dead_code: true,
+        evaluate: true,
         loops: true,
     }
     input: {

test/compress/issue-208.js

@@ -1,6 +1,8 @@
 do_not_update_lhs: {
     options = {
-        global_defs: { DEBUG: 0 }
+        global_defs: {
+            DEBUG: 0,
+        },
     }
     input: {
         DEBUG++;
@@ -16,7 +18,9 @@ do_not_update_lhs: {
 
 do_update_rhs: {
     options = {
-        global_defs: { DEBUG: 0 }
+        global_defs: {
+            DEBUG: 0,
+        },
     }
     input: {
         MY_DEBUG = DEBUG;
@@ -35,7 +39,7 @@ mixed: {
             DEBUG: 0,
             ENV: 1,
             FOO: 2,
-        }
+        },
     }
     input: {
         var ENV = 3;
@@ -60,11 +64,11 @@ mixed: {
         x = 0;
     }
     expect_warnings: [
-        'WARN: global_defs ENV redefined [test/compress/issue-208.js:41,12]',
-        'WARN: global_defs FOO redefined [test/compress/issue-208.js:42,12]',
-        'WARN: global_defs FOO redefined [test/compress/issue-208.js:44,10]',
-        'WARN: global_defs DEBUG redefined [test/compress/issue-208.js:45,8]',
-        'WARN: global_defs DEBUG redefined [test/compress/issue-208.js:46,8]',
-        'WARN: global_defs DEBUG redefined [test/compress/issue-208.js:47,8]',
+        "WARN: global_defs ENV redefined [test/compress/issue-208.js:1,12]",
+        "WARN: global_defs FOO redefined [test/compress/issue-208.js:2,12]",
+        "WARN: global_defs FOO redefined [test/compress/issue-208.js:4,10]",
+        "WARN: global_defs DEBUG redefined [test/compress/issue-208.js:5,8]",
+        "WARN: global_defs DEBUG redefined [test/compress/issue-208.js:6,8]",
+        "WARN: global_defs DEBUG redefined [test/compress/issue-208.js:7,8]",
     ]
 }

test/compress/issue-22.js

@@ -1,5 +1,7 @@
 return_with_no_value_in_if_body: {
-    options = { conditionals: true };
+    options = {
+        conditionals: true,
+    }
     input: {
         function foo(bar) {
             if (bar) {

test/compress/issue-267.js

@@ -1,5 +1,7 @@
 issue_267: {
-    options = { comparisons: true };
+    options = {
+        comparisons: true,
+    }
     input: {
         x = a % b / b * c * 2;
         x = a % b * 2

test/compress/issue-269.js

@@ -1,5 +1,7 @@
 issue_269_1: {
-	options = {unsafe: true};
+	options = {
+        unsafe: true,
+    }
 	input: {
 		f(
 			String(x),
@@ -20,7 +22,9 @@ issue_269_1: {
 }
 
 issue_269_dangers: {
-	options = {unsafe: true};
+	options = {
+        unsafe: true,
+    }
 	input: {
 		f(
 			String(x, x),
@@ -34,7 +38,9 @@ issue_269_dangers: {
 }
 
 issue_269_in_scope: {
-	options = {unsafe: true};
+	options = {
+        unsafe: true,
+    }
 	input: {
 		var String, Number, Boolean;
 		f(
@@ -50,7 +56,9 @@ issue_269_in_scope: {
 }
 
 strings_concat: {
-	options = {unsafe: true};
+	options = {
+        unsafe: true,
+    }
 	input: {
 		f(
 			String(x + 'str'),
@@ -67,9 +75,9 @@ strings_concat: {
 
 regexp: {
 	options = {
-		evaluate: true,
-		unsafe: true,
-	}
+        evaluate: true,
+        unsafe: true,
+    }
 	input: {
 		RegExp("foo");
 		RegExp("bar", "ig");
@@ -85,6 +93,6 @@ regexp: {
 		RegExp("should", "fail");
 	}
 	expect_warnings: [
-		'WARN: Error converting RegExp("should","fail") [test/compress/issue-269.js:78,2]',
+		'WARN: Error converting RegExp("should","fail") [test/compress/issue-269.js:5,2]',
 	]
 }

test/compress/issue-2719.js

@@ -26,7 +26,7 @@ warn: {
         }().length);
     }
     expect_warnings: [
-        "WARN: Function.protoype.caller not supported [test/compress/issue-2719.js:17,19]",
-        "WARN: Function.protoype.arguments not supported [test/compress/issue-2719.js:17,19]",
+        "WARN: Function.protoype.caller not supported [test/compress/issue-2719.js:5,19]",
+        "WARN: Function.protoype.arguments not supported [test/compress/issue-2719.js:5,19]",
     ]
 }

test/compress/issue-281.js

@@ -186,7 +186,7 @@ negate_iife_5_off: {
         inline: true,
         negate_iife: false,
         sequences: true,
-    };
+    }
     input: {
         if ((function(){ return t })()) {
             foo(true);
@@ -245,7 +245,7 @@ negate_iife_issue_1073: {
         reduce_vars: true,
         sequences: true,
         unused: true,
-    };
+    }
     input: {
         new (function(a) {
             return function Foo() {
@@ -273,7 +273,7 @@ issue_1288_side_effects: {
         reduce_vars: true,
         side_effects: true,
         unused: true,
-    };
+    }
     input: {
         if (w) ;
         else {

test/compress/issue-44.js

@@ -1,5 +1,7 @@
 issue_44_valid_ast_1: {
-    options = { unused: true };
+    options = {
+        unused: true,
+    }
     input: {
         function a(b) {
             for (var i = 0, e = b.qoo(); ; i++) {}
@@ -14,7 +16,9 @@ issue_44_valid_ast_1: {
 }
 
 issue_44_valid_ast_2: {
-    options = { unused: true };
+    options = {
+        unused: true,
+    }
     input: {
         function a(b) {
             if (foo) for (var i = 0, e = b.qoo(); ; i++) {}

test/compress/issue-59.js

@@ -1,8 +1,8 @@
 keep_continue: {
     options = {
         dead_code: true,
-        evaluate: true
-    };
+        evaluate: true,
+    }
     input: {
         while (a) {
             if (b) {

test/compress/issue-597.js

@@ -1,5 +1,5 @@
 NaN_and_Infinity_must_have_parens: {
-    options = {};
+    options = {}
     input: {
         Infinity.toString();
         NaN.toString();
@@ -11,7 +11,7 @@ NaN_and_Infinity_must_have_parens: {
 }
 
 NaN_and_Infinity_should_not_be_replaced_when_they_are_redefined: {
-    options = {};
+    options = {}
     input: {
         var Infinity, NaN;
         Infinity.toString();

test/compress/issue-611.js

@@ -1,8 +1,8 @@
 issue_611: {
   options = {
-    sequences: true,
-    side_effects: true
-  };
+        sequences: true,
+        side_effects: true,
+    }
   input: {
     define(function() {
       function fn() {}

test/compress/issue-637.js

@@ -1,9 +1,9 @@
 wrongly_optimized: {
     options = {
-        conditionals: true,
         booleans: true,
-        evaluate: true
-    };
+        conditionals: true,
+        evaluate: true,
+    }
     input: {
         function func() {
             foo();

test/compress/issue-640.js

@@ -28,12 +28,12 @@ cond_5: {
 
 dead_code_const_annotation_regex: {
     options = {
-        booleans     : true,
-        conditionals : true,
-        dead_code    : true,
-        evaluate     : true,
-        expression   : true,
-        loops        : true,
+        booleans: true,
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        expression: true,
+        loops: true,
     }
     input: {
         var unused;
@@ -82,8 +82,8 @@ drop_value: {
 
 wrongly_optimized: {
     options = {
-        conditionals: true,
         booleans: true,
+        conditionals: true,
         evaluate: true,
         expression: true,
     }
@@ -195,7 +195,7 @@ negate_iife_5_off: {
         expression: true,
         negate_iife: false,
         sequences: true,
-    };
+    }
     input: {
         if ((function(){ return t })()) {
             foo(true);
@@ -248,7 +248,9 @@ issue_1254_negate_iife_nested: {
 conditional: {
     options = {
         expression: true,
-        pure_funcs: [ "pure" ],
+        pure_funcs: [
+            "pure"
+        ],
         side_effects: true,
     }
     input: {

test/compress/issue-751.js

@@ -1,7 +1,7 @@
 negate_booleans_1: {
     options = {
-        comparisons: true
-    };
+        comparisons: true,
+    }
     input: {
         var a = !a || !b || !c || !d || !e || !f;
     }
@@ -12,8 +12,8 @@ negate_booleans_1: {
 
 negate_booleans_2: {
     options = {
-        comparisons: true
-    };
+        comparisons: true,
+    }
     input: {
         var match = !x &&       // should not touch this one
             (!z || c) &&

test/compress/issue-892.js

@@ -2,25 +2,25 @@ dont_mangle_arguments: {
     mangle = {
     };
     options = {
-        sequences     : true,
-        properties    : true,
-        dead_code     : true,
-        drop_debugger : true,
-        conditionals  : true,
-        comparisons   : true,
-        evaluate      : true,
-        booleans      : true,
-        loops         : true,
-        unused        : true,
-        hoist_funs    : true,
-        keep_fargs    : true,
-        keep_fnames   : false,
-        hoist_vars    : true,
-        if_return     : true,
-        join_vars     : true,
-        side_effects  : true,
-        negate_iife   : false
-    };
+        booleans: true,
+        comparisons: true,
+        conditionals: true,
+        dead_code: true,
+        drop_debugger: true,
+        evaluate: true,
+        hoist_funs: true,
+        hoist_vars: true,
+        if_return: true,
+        join_vars: true,
+        keep_fargs: true,
+        keep_fnames: false,
+        loops: true,
+        negate_iife: false,
+        properties: true,
+        sequences: true,
+        side_effects: true,
+        unused: true,
+    }
     input: {
         (function(){
             var arguments = arguments, not_arguments = 9;

test/compress/issue-913.js

@@ -1,8 +1,8 @@
 keep_var_for_in: {
     options = {
         hoist_vars: true,
-        unused: true
-    };
+        unused: true,
+    }
     input: {
         (function(obj){
             var foo = 5;

test/compress/issue-973.js

@@ -72,7 +72,7 @@ this_binding_collapse_vars: {
 
 this_binding_side_effects: {
     options = {
-        side_effects : true
+        side_effects: true,
     }
     input: {
         (function(foo) {

test/compress/issue-976.js

@@ -1,9 +1,21 @@
 eval_collapse_vars: {
     options = {
-        collapse_vars:true, sequences:false, properties:true, dead_code:true, conditionals:true,
-        comparisons:true, evaluate:true, booleans:true, loops:true, unused:true, hoist_funs:true,
-        keep_fargs:true, if_return:true, join_vars:true, side_effects:true
-    };
+        booleans: true,
+        collapse_vars: true,
+        comparisons: true,
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        hoist_funs: true,
+        if_return: true,
+        join_vars: true,
+        keep_fargs: true,
+        loops: true,
+        properties: true,
+        sequences: false,
+        side_effects: true,
+        unused: true,
+    }
     input: {
         function f1() {
             var e = 7;
@@ -46,7 +58,10 @@ eval_collapse_vars: {
 }
 
 eval_unused: {
-    options = { unused: true, keep_fargs: false };
+    options = {
+        keep_fargs: false,
+        unused: true,
+    }
     input: {
         function f1(a, eval, c, d, e) {
             return a('c') + eval;

test/compress/issue-979.js

@@ -1,8 +1,19 @@
 issue979_reported: {
     options = {
-        sequences:true, properties:true, dead_code:true, conditionals:true,
-        comparisons:true, evaluate:true, booleans:true, loops:true, unused:true, hoist_funs:true,
-        keep_fargs:true, if_return:true, join_vars:true, side_effects:true
+        booleans: true,
+        comparisons: true,
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        hoist_funs: true,
+        if_return: true,
+        join_vars: true,
+        keep_fargs: true,
+        loops: true,
+        properties: true,
+        sequences: true,
+        side_effects: true,
+        unused: true,
     }
     input: {
         function f1() {
@@ -30,9 +41,20 @@ issue979_reported: {
 
 issue979_test_negated_is_best: {
     options = {
-        sequences:true, properties:true, dead_code:true, conditionals:true,
-        comparisons:true, evaluate:true, booleans:true, loops:true, unused:true, hoist_funs:true,
-        keep_fargs:true, if_return:true, join_vars:true, side_effects:true
+        booleans: true,
+        comparisons: true,
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        hoist_funs: true,
+        if_return: true,
+        join_vars: true,
+        keep_fargs: true,
+        loops: true,
+        properties: true,
+        sequences: true,
+        side_effects: true,
+        unused: true,
     }
     input: {
         function f3() {

test/compress/labels.js

@@ -1,5 +1,9 @@
 labels_1: {
-    options = { if_return: true, conditionals: true, dead_code: true };
+    options = {
+        conditionals: true,
+        dead_code: true,
+        if_return: true,
+    }
     input: {
         out: {
             if (foo) break out;
@@ -13,7 +17,11 @@ labels_1: {
 }
 
 labels_2: {
-    options = { if_return: true, conditionals: true, dead_code: true };
+    options = {
+        conditionals: true,
+        dead_code: true,
+        if_return: true,
+    }
     input: {
         out: {
             if (foo) print("stuff");
@@ -30,7 +38,11 @@ labels_2: {
 }
 
 labels_3: {
-    options = { if_return: true, conditionals: true, dead_code: true };
+    options = {
+        conditionals: true,
+        dead_code: true,
+        if_return: true,
+    }
     input: {
         for (var i = 0; i < 5; ++i) {
             if (i < 3) continue;
@@ -45,7 +57,11 @@ labels_3: {
 }
 
 labels_4: {
-    options = { if_return: true, conditionals: true, dead_code: true };
+    options = {
+        conditionals: true,
+        dead_code: true,
+        if_return: true,
+    }
     input: {
         out: for (var i = 0; i < 5; ++i) {
             if (i < 3) continue out;
@@ -60,7 +76,11 @@ labels_4: {
 }
 
 labels_5: {
-    options = { if_return: true, conditionals: true, dead_code: true };
+    options = {
+        conditionals: true,
+        dead_code: true,
+        if_return: true,
+    }
     // should keep the break-s in the following
     input: {
         while (foo) {
@@ -92,7 +112,11 @@ labels_6: {
 }
 
 labels_7: {
-    options = { if_return: true, conditionals: true, dead_code: true };
+    options = {
+        conditionals: true,
+        dead_code: true,
+        if_return: true,
+    }
     input: {
         while (foo) {
             x();
@@ -109,7 +133,11 @@ labels_7: {
 }
 
 labels_8: {
-    options = { if_return: true, conditionals: true, dead_code: true };
+    options = {
+        conditionals: true,
+        dead_code: true,
+        if_return: true,
+    }
     input: {
         while (foo) {
             x();
@@ -127,7 +155,11 @@ labels_8: {
 }
 
 labels_9: {
-    options = { if_return: true, conditionals: true, dead_code: true };
+    options = {
+        conditionals: true,
+        dead_code: true,
+        if_return: true,
+    }
     input: {
         out: while (foo) {
             x();
@@ -146,7 +178,11 @@ labels_9: {
 }
 
 labels_10: {
-    options = { if_return: true, conditionals: true, dead_code: true };
+    options = {
+        conditionals: true,
+        dead_code: true,
+        if_return: true,
+    }
     input: {
         out: while (foo) {
             x();

test/compress/loops.js

@@ -1,5 +1,7 @@
 while_becomes_for: {
-    options = { loops: true };
+    options = {
+        loops: true,
+    }
     input: {
         while (foo()) bar();
     }
@@ -9,7 +11,9 @@ while_becomes_for: {
 }
 
 drop_if_break_1: {
-    options = { loops: true };
+    options = {
+        loops: true,
+    }
     input: {
         for (;;)
             if (foo()) break;
@@ -20,7 +24,9 @@ drop_if_break_1: {
 }
 
 drop_if_break_2: {
-    options = { loops: true };
+    options = {
+        loops: true,
+    }
     input: {
         for (;bar();)
             if (foo()) break;
@@ -31,7 +37,9 @@ drop_if_break_2: {
 }
 
 drop_if_break_3: {
-    options = { loops: true };
+    options = {
+        loops: true,
+    }
     input: {
         for (;bar();) {
             if (foo()) break;
@@ -48,7 +56,10 @@ drop_if_break_3: {
 }
 
 drop_if_break_4: {
-    options = { loops: true, sequences: true };
+    options = {
+        loops: true,
+        sequences: true,
+    }
     input: {
         for (;bar();) {
             x();
@@ -64,7 +75,9 @@ drop_if_break_4: {
 }
 
 drop_if_else_break_1: {
-    options = { loops: true };
+    options = {
+        loops: true,
+    }
     input: {
         for (;;) if (foo()) bar(); else break;
     }
@@ -74,7 +87,9 @@ drop_if_else_break_1: {
 }
 
 drop_if_else_break_2: {
-    options = { loops: true };
+    options = {
+        loops: true,
+    }
     input: {
         for (;bar();) {
             if (foo()) baz();
@@ -87,7 +102,9 @@ drop_if_else_break_2: {
 }
 
 drop_if_else_break_3: {
-    options = { loops: true };
+    options = {
+        loops: true,
+    }
     input: {
         for (;bar();) {
             if (foo()) baz();
@@ -106,7 +123,10 @@ drop_if_else_break_3: {
 }
 
 drop_if_else_break_4: {
-    options = { loops: true, sequences: true };
+    options = {
+        loops: true,
+        sequences: true,
+    }
     input: {
         for (;bar();) {
             x();
@@ -123,7 +143,9 @@ drop_if_else_break_4: {
 }
 
 parse_do_while_with_semicolon: {
-    options = { loops: false };
+    options = {
+        loops: false,
+    }
     input: {
         do {
             x();
@@ -135,7 +157,9 @@ parse_do_while_with_semicolon: {
 }
 
 parse_do_while_without_semicolon: {
-    options = { loops: false };
+    options = {
+        loops: false,
+    }
     input: {
         do {
             x();
@@ -153,7 +177,7 @@ evaluate: {
         loops: true,
         passes: 2,
         side_effects: true,
-    };
+    }
     input: {
         while (true) {
             a();
@@ -457,7 +481,7 @@ init_side_effects: {
     options = {
         loops: true,
         side_effects: true,
-    };
+    }
     input: {
         for (function() {}(), i = 0; i < 5; i++) console.log(i);
         for (function() {}(); i < 10; i++) console.log(i);

test/compress/negate-iife.js

@@ -1,7 +1,7 @@
 negate_iife_1: {
     options = {
-        negate_iife: true
-    };
+        negate_iife: true,
+    }
     input: {
         (function(){ stuff() })();
     }
@@ -13,7 +13,7 @@ negate_iife_1: {
 negate_iife_1_off: {
     options = {
         negate_iife: false,
-    };
+    }
     input: {
         (function(){ stuff() })();
     }
@@ -24,7 +24,7 @@ negate_iife_2: {
     options = {
         inline: true,
         negate_iife: true,
-    };
+    }
     input: {
         (function(){ return {} })().x = 10;
     }
@@ -45,9 +45,9 @@ negate_iife_2_side_effects: {
 
 negate_iife_3: {
     options = {
+        conditionals: true,
         negate_iife: true,
-        conditionals: true
-    };
+    }
     input: {
         (function(){ return t })() ? console.log(true) : console.log(false);
     }
@@ -88,9 +88,9 @@ negate_iife_3_side_effects: {
 
 negate_iife_3_off: {
     options = {
-        negate_iife: false,
         conditionals: true,
-    };
+        negate_iife: false,
+    }
     input: {
         (function(){ return t })() ? console.log(true) : console.log(false);
     }
@@ -117,10 +117,10 @@ negate_iife_3_off_evaluate: {
 
 negate_iife_4: {
     options = {
-        negate_iife: true,
         conditionals: true,
-        sequences: true
-    };
+        negate_iife: true,
+        sequences: true,
+    }
     input: {
         (function(){ return t })() ? console.log(true) : console.log(false);
         (function(){
@@ -136,11 +136,11 @@ negate_iife_4: {
 
 sequence_off: {
     options = {
-        negate_iife: false,
         conditionals: true,
-        sequences: true,
+        negate_iife: false,
         passes: 2,
-    };
+        sequences: true,
+    }
     input: {
         function f() {
             (function(){ return t })() ? console.log(true) : console.log(false);
@@ -171,10 +171,10 @@ sequence_off: {
 
 negate_iife_5: {
     options = {
+        conditionals: true,
         negate_iife: true,
         sequences: true,
-        conditionals: true,
-    };
+    }
     input: {
         if ((function(){ return t })()) {
             foo(true);
@@ -194,10 +194,10 @@ negate_iife_5: {
 
 negate_iife_5_off: {
     options = {
+        conditionals: true,
         negate_iife: false,
         sequences: true,
-        conditionals: true,
-    };
+    }
     input: {
         if ((function(){ return t })()) {
             foo(true);
@@ -217,10 +217,10 @@ negate_iife_5_off: {
 
 negate_iife_nested: {
     options = {
+        conditionals: true,
         negate_iife: true,
         sequences: true,
-        conditionals: true,
-    };
+    }
     input: {
         function Foo(f) {
             this.f = f;
@@ -250,10 +250,10 @@ negate_iife_nested: {
 
 negate_iife_nested_off: {
     options = {
+        conditionals: true,
         negate_iife: false,
         sequences: true,
-        conditionals: true,
-    };
+    }
     input: {
         function Foo(f) {
             this.f = f;
@@ -283,10 +283,10 @@ negate_iife_nested_off: {
 
 negate_iife_issue_1073: {
     options = {
+        conditionals: true,
         negate_iife: true,
         sequences: true,
-        conditionals: true,
-    };
+    }
     input: {
         new (function(a) {
             return function Foo() {
@@ -356,7 +356,7 @@ issue_1288: {
         conditionals: true,
         negate_iife: true,
         side_effects: false,
-    };
+    }
     input: {
         if (w) ;
         else {

test/compress/new.js

@@ -36,7 +36,9 @@ new_statements_3: {
 }
 
 new_with_rewritten_true_value: {
-    options = { booleans: true }
+    options = {
+        booleans: true,
+    }
     input: {
         new true;
     }

test/compress/preserve_line.js

@@ -0,0 +1,181 @@
+return_1: {
+    beautify = {
+        beautify: false,
+        preserve_line: true,
+    }
+    input: {
+        console.log(function f() {
+            return (
+                f.toString() != 42
+            );
+        }());
+    }
+    expect_exact: [
+        "console.log(function f(){",
+        "",
+        "return 42!=f.toString()}());",
+    ]
+    expect_stdout: "true"
+}
+
+return_2: {
+    beautify = {
+        beautify: true,
+        preserve_line: true,
+    }
+    input: {
+        console.log(function f() {
+            return (
+                f.toString() != 42
+            );
+        }());
+    }
+    expect_exact: [
+        "console.log(function f() {",
+        "",
+        "    return 42 != f.toString();",
+        "}());",
+    ]
+    expect_stdout: "true"
+}
+
+return_3: {
+    options = {}
+    beautify = {
+        beautify: false,
+        preserve_line: true,
+    }
+    input: {
+        console.log(function f() {
+            return (
+                f.toString() != 42
+            );
+        }());
+    }
+    expect_exact: [
+        "console.log(function f(){",
+        "",
+        "return 42!=f.toString()}());",
+    ]
+    expect_stdout: "true"
+}
+
+return_4: {
+    options = {}
+    beautify = {
+        beautify: true,
+        preserve_line: true,
+    }
+    input: {
+        console.log(function f() {
+            return (
+                f.toString() != 42
+            );
+        }());
+    }
+    expect_exact: [
+        "console.log(function f() {",
+        "",
+        "    return 42 != f.toString();",
+        "}());",
+    ]
+    expect_stdout: "true"
+}
+
+return_5: {
+    beautify = {
+        beautify: false,
+        preserve_line: true,
+    }
+    input: {
+        _is_selected = function(tags, slug) {
+            var ref;
+            return (ref = _.find(tags, {
+                slug: slug
+            })) != null ? ref.selected : void 0;
+        };
+    }
+    expect_exact: [
+        "_is_selected=function(tags,slug){",
+        "var ref",
+        "",
+        "",
+        ";return null!=(ref=_.find(tags,{slug:slug}))?ref.selected:void 0};",
+    ]
+}
+
+return_6: {
+    beautify = {
+        beautify: true,
+        preserve_line: true,
+    }
+    input: {
+        _is_selected = function(tags, slug) {
+            var ref;
+            return (ref = _.find(tags, {
+                slug: slug
+            })) != null ? ref.selected : void 0;
+        };
+    }
+    expect_exact: [
+        "_is_selected = function(tags, slug) {",
+        "    var ref;",
+        "",
+        "",
+        "    return null != (ref = _.find(tags, {",
+        "        slug: slug",
+        "    })) ? ref.selected : void 0;",
+        "};",
+    ]
+}
+
+return_7: {
+    options = {}
+    mangle = {}
+    beautify = {
+        beautify: false,
+        preserve_line: true,
+    }
+    input: {
+        _is_selected = function(tags, slug) {
+            var ref;
+            return (ref = _.find(tags, {
+                slug: slug
+            })) != null ? ref.selected : void 0;
+        };
+    }
+    expect_exact: [
+        "_is_selected=function(e,l){",
+        "var n",
+        "",
+        "",
+        ";return null!=(n=_.find(e,{slug:l}))?n.selected:void 0};",
+    ]
+}
+
+return_8: {
+    options = {}
+    mangle = {}
+    beautify = {
+        beautify: true,
+        preserve_line: true,
+    }
+    input: {
+        _is_selected = function(tags, slug) {
+            var ref;
+            return (ref = _.find(tags, {
+                slug: slug
+            })) != null ? ref.selected : void 0;
+        };
+    }
+    expect_exact: [
+        "_is_selected = function(e, l) {",
+        "    var n;",
+        "",
+        "",
+        "    return null != (n = _.find(e, {",
+        "        slug: l",
+        "    })) ? n.selected : void 0;",
+        "};",
+    ]
+}

test/compress/pure_getters.js

@@ -187,10 +187,10 @@ issue_2110_1: {
     options = {
         collapse_vars: true,
         pure_getters: "strict",
-        sequences: true,
-        side_effects: true,
         reduce_funcs: true,
         reduce_vars: true,
+        sequences: true,
+        side_effects: true,
         unused: true,
     }
     input: {

test/compress/reduce_vars.js

@@ -1,15 +1,15 @@
 reduce_vars: {
     options = {
-        conditionals  : true,
-        evaluate      : true,
-        inline        : true,
-        global_defs   : {
-            C : 0
+        conditionals: true,
+        evaluate: true,
+        global_defs: {
+            C: 0,
         },
-        reduce_funcs  : true,
-        reduce_vars   : true,
-        toplevel      : true,
-        unused        : true
+        inline: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
     }
     input: {
         var A = 1;
@@ -63,11 +63,11 @@ reduce_vars: {
 
 modified: {
     options = {
-        conditionals  : true,
-        evaluate      : true,
-        reduce_funcs  : true,
-        reduce_vars   : true,
-        unused        : true,
+        conditionals: true,
+        evaluate: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        unused: true,
     }
     input: {
         function f0() {
@@ -184,12 +184,12 @@ modified: {
 
 unsafe_evaluate: {
     options = {
-        evaluate     : true,
-        reduce_funcs : true,
-        reduce_vars  : true,
-        side_effects : true,
-        unsafe       : true,
-        unused       : true
+        evaluate: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        side_effects: true,
+        unsafe: true,
+        unused: true,
     }
     input: {
         function f0(){
@@ -344,10 +344,10 @@ unsafe_evaluate_unknown: {
 
 unsafe_evaluate_object_1: {
     options = {
-        evaluate     : true,
-        reduce_funcs : true,
-        reduce_vars  : true,
-        unsafe       : true
+        evaluate: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        unsafe: true,
     }
     input: {
         function f0(){
@@ -463,10 +463,10 @@ unsafe_evaluate_object_3: {
 
 unsafe_evaluate_array_1: {
     options = {
-        evaluate     : true,
-        reduce_funcs : true,
-        reduce_vars  : true,
-        unsafe       : true
+        evaluate: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        unsafe: true,
     }
     input: {
         function f0(){
@@ -642,11 +642,11 @@ unsafe_evaluate_array_5: {
 
 unsafe_evaluate_equality_1: {
     options = {
-        evaluate     : true,
-        reduce_funcs : true,
-        reduce_vars  : true,
-        unsafe       : true,
-        unused       : true
+        evaluate: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        unsafe: true,
+        unused: true,
     }
     input: {
         function f0() {
@@ -674,12 +674,12 @@ unsafe_evaluate_equality_1: {
 unsafe_evaluate_equality_2: {
     options = {
         collapse_vars: true,
-        evaluate     : true,
-        passes       : 2,
-        reduce_funcs : true,
-        reduce_vars  : true,
-        unsafe       : true,
-        unused       : true
+        evaluate: true,
+        passes: 2,
+        reduce_funcs: true,
+        reduce_vars: true,
+        unsafe: true,
+        unused: true,
     }
     input: {
         function f2() {
@@ -1130,7 +1130,7 @@ toplevel_on: {
         evaluate: true,
         reduce_funcs: true,
         reduce_vars: true,
-        toplevel:true,
+        toplevel: true,
         unused: true,
     }
     input: {
@@ -1148,7 +1148,7 @@ toplevel_off: {
         evaluate: true,
         reduce_funcs: true,
         reduce_vars: true,
-        toplevel:false,
+        toplevel: false,
         unused: true,
     }
     input: {
@@ -1168,7 +1168,7 @@ toplevel_on_loops_1: {
         loops: true,
         reduce_funcs: true,
         reduce_vars: true,
-        toplevel:true,
+        toplevel: true,
         unused: true,
     }
     input: {
@@ -1196,7 +1196,7 @@ toplevel_off_loops_1: {
         loops: true,
         reduce_funcs: true,
         reduce_vars: true,
-        toplevel:false,
+        toplevel: false,
         unused: true,
     }
     input: {
@@ -1225,7 +1225,7 @@ toplevel_on_loops_2: {
         reduce_funcs: true,
         reduce_vars: true,
         side_effects: true,
-        toplevel:true,
+        toplevel: true,
         unused: true,
     }
     input: {
@@ -1251,7 +1251,7 @@ toplevel_off_loops_2: {
         loops: true,
         reduce_funcs: true,
         reduce_vars: true,
-        toplevel:false,
+        toplevel: false,
         unused: true,
     }
     input: {
@@ -1278,7 +1278,7 @@ toplevel_on_loops_3: {
         loops: true,
         reduce_funcs: true,
         reduce_vars: true,
-        toplevel:true,
+        toplevel: true,
         unused: true,
     }
     input: {
@@ -1296,7 +1296,7 @@ toplevel_off_loops_3: {
         loops: true,
         reduce_funcs: true,
         reduce_vars: true,
-        toplevel:false,
+        toplevel: false,
         unused: true,
     }
     input: {
@@ -1560,6 +1560,32 @@ func_modified: {
     expect_stdout: "7"
 }
 
+unused_modified: {
+    options = {
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        console.log(function() {
+            var b = 1, c = "FAIL";
+            if (0 || b--)
+                c = "PASS";
+            b = 1;
+            return c;
+        }());
+    }
+    expect: {
+        console.log(function() {
+            var b = 1, c = "FAIL";
+            if (0 || b--)
+                c = "PASS";
+            b = 1;
+            return c;
+        }());
+    }
+    expect_stdout: "PASS"
+}
+
 defun_label: {
     options = {
         passes: 2,
@@ -1868,8 +1894,8 @@ issue_1670_1: {
     options = {
         comparisons: true,
         conditionals: true,
-        evaluate: true,
         dead_code: true,
+        evaluate: true,
         reduce_funcs: true,
         reduce_vars: true,
         side_effects: true,
@@ -1901,8 +1927,8 @@ issue_1670_1: {
 issue_1670_2: {
     options = {
         conditionals: true,
-        evaluate: true,
         dead_code: true,
+        evaluate: true,
         passes: 2,
         reduce_funcs: true,
         reduce_vars: true,
@@ -1934,8 +1960,8 @@ issue_1670_3: {
     options = {
         comparisons: true,
         conditionals: true,
-        evaluate: true,
         dead_code: true,
+        evaluate: true,
         reduce_funcs: true,
         reduce_vars: true,
         side_effects: true,
@@ -1967,8 +1993,8 @@ issue_1670_3: {
 issue_1670_4: {
     options = {
         conditionals: true,
-        evaluate: true,
         dead_code: true,
+        evaluate: true,
         passes: 2,
         reduce_funcs: true,
         reduce_vars: true,

test/compress/return_undefined.js

@@ -1,24 +1,24 @@
 return_undefined: {
     options = {
-        sequences     : false,
-        if_return     : true,
-        evaluate      : true,
-        dead_code     : true,
-        conditionals  : true,
-        comparisons   : true,
-        booleans      : true,
-        unused        : true,
-        side_effects  : true,
-        properties    : true,
-        drop_debugger : true,
-        loops         : true,
-        hoist_funs    : true,
-        keep_fargs    : true,
-        keep_fnames   : false,
-        hoist_vars    : true,
-        join_vars     : true,
-        negate_iife   : true
-    };
+        booleans: true,
+        comparisons: true,
+        conditionals: true,
+        dead_code: true,
+        drop_debugger: true,
+        evaluate: true,
+        hoist_funs: true,
+        hoist_vars: true,
+        if_return: true,
+        join_vars: true,
+        keep_fargs: true,
+        keep_fnames: false,
+        loops: true,
+        negate_iife: true,
+        properties: true,
+        sequences: false,
+        side_effects: true,
+        unused: true,
+    }
     input: {
         function f0() {
         }

test/compress/sequences.js

@@ -1,7 +1,7 @@
 make_sequences_1: {
     options = {
-        sequences: true
-    };
+        sequences: true,
+    }
     input: {
         foo();
         bar();
@@ -14,8 +14,8 @@ make_sequences_1: {
 
 make_sequences_2: {
     options = {
-        sequences: true
-    };
+        sequences: true,
+    }
     input: {
         if (boo) {
             foo();
@@ -35,8 +35,8 @@ make_sequences_2: {
 
 make_sequences_3: {
     options = {
-        sequences: true
-    };
+        sequences: true,
+    }
     input: {
         function f() {
             foo();
@@ -61,8 +61,8 @@ make_sequences_3: {
 
 make_sequences_4: {
     options = {
-        sequences: true
-    };
+        sequences: true,
+    }
     input: {
         x = 5;
         if (y) z();
@@ -90,7 +90,9 @@ make_sequences_4: {
 }
 
 lift_sequences_1: {
-    options = { sequences: true };
+    options = {
+        sequences: true,
+    }
     input: {
         var foo, x, y, bar;
         foo = !(x(), y(), bar());
@@ -102,7 +104,10 @@ lift_sequences_1: {
 }
 
 lift_sequences_2: {
-    options = { sequences: true, evaluate: true };
+    options = {
+        evaluate: true,
+        sequences: true,
+    }
     input: {
         var foo = 1, bar;
         foo.x = (foo = {}, 10);
@@ -119,7 +124,10 @@ lift_sequences_2: {
 }
 
 lift_sequences_3: {
-    options = { sequences: true, conditionals: true };
+    options = {
+        conditionals: true,
+        sequences: true,
+    }
     input: {
         var x, foo, bar, baz;
         x = (foo(), bar(), baz()) ? 10 : 20;
@@ -131,7 +139,9 @@ lift_sequences_3: {
 }
 
 lift_sequences_4: {
-    options = { side_effects: true };
+    options = {
+        side_effects: true,
+    }
     input: {
         var x, foo, bar, baz;
         x = (foo, bar, baz);
@@ -160,7 +170,9 @@ lift_sequences_5: {
 }
 
 for_sequences: {
-    options = { sequences: true };
+    options = {
+        sequences: true,
+    }
     input: {
         // 1
         foo();
@@ -203,7 +215,7 @@ for_sequences: {
 limit_1: {
     options = {
         sequences: 3,
-    };
+    }
     input: {
         a;
         b;
@@ -228,7 +240,7 @@ limit_1: {
 limit_2: {
     options = {
         sequences: 3,
-    };
+    }
     input: {
         a, b;
         c, d;
@@ -246,9 +258,9 @@ limit_2: {
 
 negate_iife_for: {
     options = {
-        sequences: true,
         negate_iife: true,
-    };
+        sequences: true,
+    }
     input: {
         (function() {})();
         for (i = 0; i < 5; i++) console.log(i);
@@ -265,7 +277,7 @@ negate_iife_for: {
 iife: {
     options = {
         sequences: true,
-    };
+    }
     input: {
         x = 42;
         (function a() {})();

test/compress/switch.js

@@ -820,8 +820,8 @@ issue_1758: {
 
 issue_2535: {
     options = {
-        evaluate: true,
         dead_code: true,
+        evaluate: true,
         switches: true,
     }
     input: {

test/compress/typeof.js

@@ -2,7 +2,7 @@ typeof_evaluation: {
     options = {
         evaluate: true,
         typeofs: true,
-    };
+    }
     input: {
         a = typeof 1;
         b = typeof 'test';
@@ -27,11 +27,11 @@ typeof_evaluation: {
 
 typeof_in_boolean_context: {
     options = {
-        booleans     : true,
-        evaluate     : true,
-        conditionals : true,
-        side_effects : true,
-    };
+        booleans: true,
+        conditionals: true,
+        evaluate: true,
+        side_effects: true,
+    }
     input: {
         function f1(x) { return typeof x ? "yes" : "no"; }
         function f2() { return typeof g()? "Yes" : "No"; }

test/compress/unicode.js

@@ -1,5 +1,5 @@
 unicode_parse_variables: {
-    options = {};
+    options = {}
     input: {
         var a = {};
         a.你好 = 456;

test/exports.js

@@ -1,14 +1,16 @@
-exports["Compressor"] = Compressor;
-exports["JS_Parse_Error"] = JS_Parse_Error;
-exports["OutputStream"] = OutputStream;
-exports["SourceMap"] = SourceMap;
-exports["TreeWalker"] = TreeWalker;
 exports["base54"] = base54;
+exports["Compressor"] = Compressor;
 exports["defaults"] = defaults;
+exports["is_identifier"] = is_identifier;
+exports["JS_Parse_Error"] = JS_Parse_Error;
 exports["mangle_properties"] = mangle_properties;
 exports["minify"] = minify;
+exports["OutputStream"] = OutputStream;
 exports["parse"] = parse;
+exports["push_uniq"] = push_uniq;
 exports["reserve_quoted_keys"] = reserve_quoted_keys;
+exports["SourceMap"] = SourceMap;
 exports["string_template"] = string_template;
 exports["tokenizer"] = tokenizer;
-exports["is_identifier"] = is_identifier;
+exports["TreeTransformer"] = TreeTransformer;
+exports["TreeWalker"] = TreeWalker;

test/mocha/cli.js

@@ -8,7 +8,7 @@ function read(path) {
 
 describe("bin/uglifyjs", function() {
     var uglifyjscmd = '"' + process.argv[0] + '" bin/uglifyjs';
-    it("should produce a functional build when using --self", function(done) {
+    it("Should produce a functional build when using --self", function(done) {
         this.timeout(30000);
         var command = uglifyjscmd + ' --self -cm --wrap WrappedUglifyJS';
         exec(command, function(err, stdout) {
@@ -68,7 +68,7 @@ describe("bin/uglifyjs", function() {
             done();
         });
     });
-    it("should not append source map to output when not using --source-map url=inline", function(done) {
+    it("Should not append source map to output when not using --source-map url=inline", function(done) {
         var command = uglifyjscmd + ' test/input/issue-1323/sample.js';
         exec(command, function(err, stdout) {
             if (err) throw err;
@@ -76,7 +76,7 @@ describe("bin/uglifyjs", function() {
             done();
         });
     });
-    it("should not consider source map file content as source map file name (issue #2082)", function(done) {
+    it("Should not consider source map file content as source map file name (issue #2082)", function(done) {
         var command = [
             uglifyjscmd,
             "test/input/issue-2082/sample.js",

test/mocha/directives.js

@@ -2,14 +2,12 @@ var assert = require("assert");
 var UglifyJS = require("../node");
 
 describe("Directives", function() {
-    it ("Should allow tokenizer to store directives state", function() {
+    it("Should allow tokenizer to store directives state", function() {
         var tokenizer = UglifyJS.tokenizer("", "foo.js");
-
         // Stack level 0
         assert.strictEqual(tokenizer.has_directive("use strict"), false);
         assert.strictEqual(tokenizer.has_directive("use asm"), false);
         assert.strictEqual(tokenizer.has_directive("use thing"), false);
-
         // Stack level 2
         tokenizer.push_directives_stack();
         tokenizer.push_directives_stack();
@@ -17,7 +15,6 @@ describe("Directives", function() {
         assert.strictEqual(tokenizer.has_directive("use strict"), true);
         assert.strictEqual(tokenizer.has_directive("use asm"), false);
         assert.strictEqual(tokenizer.has_directive("use thing"), false);
-
         // Stack level 3
         tokenizer.push_directives_stack();
         tokenizer.add_directive("use strict");
@@ -25,13 +22,11 @@ describe("Directives", function() {
         assert.strictEqual(tokenizer.has_directive("use strict"), true);
         assert.strictEqual(tokenizer.has_directive("use asm"), true);
         assert.strictEqual(tokenizer.has_directive("use thing"), false);
-
         // Stack level 2
         tokenizer.pop_directives_stack();
         assert.strictEqual(tokenizer.has_directive("use strict"), true);
         assert.strictEqual(tokenizer.has_directive("use asm"), false);
         assert.strictEqual(tokenizer.has_directive("use thing"), false);
-
         // Stack level 3
         tokenizer.push_directives_stack();
         tokenizer.add_directive("use thing");
@@ -39,152 +34,138 @@ describe("Directives", function() {
         assert.strictEqual(tokenizer.has_directive("use strict"), true);
         assert.strictEqual(tokenizer.has_directive("use asm"), false); // Directives are strict!
         assert.strictEqual(tokenizer.has_directive("use thing"), true);
-
         // Stack level 2
         tokenizer.pop_directives_stack();
         assert.strictEqual(tokenizer.has_directive("use strict"), true);
         assert.strictEqual(tokenizer.has_directive("use asm"), false);
         assert.strictEqual(tokenizer.has_directive("use thing"), false);
-
         // Stack level 1
         tokenizer.pop_directives_stack();
         assert.strictEqual(tokenizer.has_directive("use strict"), false);
         assert.strictEqual(tokenizer.has_directive("use asm"), false);
         assert.strictEqual(tokenizer.has_directive("use thing"), false);
-
         // Stack level 0
         tokenizer.pop_directives_stack();
         assert.strictEqual(tokenizer.has_directive("use strict"), false);
         assert.strictEqual(tokenizer.has_directive("use asm"), false);
         assert.strictEqual(tokenizer.has_directive("use thing"), false);
     });
-
     it("Should know which strings are directive and which ones are not", function() {
-        var test_directive = function(tokenizer, test) {
-            test.directives.map(function(directive) {
-                assert.strictEqual(tokenizer.has_directive(directive), true, directive + " in " + test.input);
-            });
-            test.non_directives.map(function(fake_directive) {
-                assert.strictEqual(tokenizer.has_directive(fake_directive), false, fake_directive + " in " + test.input);
-            });
-        }
-
-        var tests = [
-            {
-                input: '"use strict"\n',
-                directives: ["use strict"],
-                non_directives: ["use asm"]
-            },
-            {
-                input: '"use\\\nstrict";',
-                directives: [],
-                non_directives: ["use strict", "use\nstrict", "use \nstrict", "use asm"]
-            },
-            {
-                input: '"use strict"\n"use asm"\n"use bar"\n',
-                directives: ["use strict", "use asm", "use bar"],
-                non_directives: ["use foo", "use\\x20strict"]
-            },
-            {
-                input: '"use \\\nstrict";"use strict";',
-                directives: [],
-                non_directives: ["use strict", "use\nstrict", "use \nstrict", "use asm"]
-            },
-            {
-                input: '"\\76";',
-                directives: [],
-                non_directives: [">", "\\76"]
-            },
-            {
-                input: '"use strict"', // no ; or newline
-                directives: [],
-                non_directives: ["use strict", "use\nstrict", "use \nstrict", "use asm"]
-            },
-            {
-                input: ';"use strict"',
-                directives: [],
-                non_directives: ["use strict", "use\nstrict", "use \nstrict", "use asm"]
-            },
+        [
+            [
+                '"use strict"\n',
+                [ "use strict"],
+                [ "use asm"]
+            ],
+            [
+                '"use\\\nstrict";',
+                [],
+                [ "use strict", "use\nstrict", "use \nstrict", "use asm" ]
+            ],
+            [
+                '"use strict"\n"use asm"\n"use bar"\n',
+                [ "use strict", "use asm", "use bar" ],
+                [ "use foo", "use\\x20strict" ]
+            ],
+            [
+                '"use \\\nstrict";"use strict";',
+                [],
+                [ "use strict", "use\nstrict", "use \nstrict", "use asm" ]
+            ],
+            [
+                '"\\76";',
+                [],
+                [ ">", "\\76" ]
+            ],
+            [
+                // no ; or newline
+                '"use strict"',
+                [],
+                [ "use strict", "use\nstrict", "use \nstrict", "use asm" ]
+            ],
+            [
+                ';"use strict"',
+                [],
+                [ "use strict", "use\nstrict", "use \nstrict", "use asm" ]
+            ],
             // Duplicate above code but put it in a function
-            {
-                input: 'function foo() {"use strict"\n',
-                directives: ["use strict"],
-                non_directives: ["use asm"]
-            },
-            {
-                input: 'function foo() {"use\\\nstrict";',
-                directives: [],
-                non_directives: ["use strict", "use\nstrict", "use \nstrict", "use asm"]
-            },
-            {
-                input: 'function foo() {"use strict"\n"use asm"\n"use bar"\n',
-                directives: ["use strict", "use asm", "use bar"],
-                non_directives: ["use foo", "use\\x20strict"]
-            },
-            {
-                input: 'function foo() {"use \\\nstrict";"use strict";',
-                directives: [],
-                non_directives: ["use strict", "use\nstrict", "use \nstrict", "use asm"]
-            },
-            {
-                input: 'var foo = function() {"\\76";',
-                directives: [],
-                non_directives: [">", "\\76"]
-            },
-            {
-                input: 'var foo = function() {"use strict"', // no ; or newline
-                directives: [],
-                non_directives: ["use strict", "use\nstrict", "use \nstrict", "use asm"]
-            },
-            {
-                input: 'var foo = function() {;"use strict"',
-                directives: [],
-                non_directives: ["use strict", "use\nstrict", "use \nstrict", "use asm"]
-            },
+            [
+                'function foo() {"use strict"\n',
+                [ "use strict" ],
+                [ "use asm" ]
+            ],
+            [
+                'function foo() {"use\\\nstrict";',
+                [],
+                [ "use strict", "use\nstrict", "use \nstrict", "use asm" ]
+            ],
+            [
+                'function foo() {"use strict"\n"use asm"\n"use bar"\n',
+                [ "use strict", "use asm", "use bar" ],
+                [ "use foo", "use\\x20strict" ]
+            ],
+            [
+                'function foo() {"use \\\nstrict";"use strict";',
+                [],
+                [ "use strict", "use\nstrict", "use \nstrict", "use asm" ]
+            ],
+            [
+                'var foo = function() {"\\76";',
+                [],
+                [ ">", "\\76" ]
+            ],
+            [
+                'var foo = function() {"use strict"', // no ; or newline
+                [],
+                [ "use strict", "use\nstrict", "use \nstrict", "use asm" ]
+            ],
+            [
+                'var foo = function() {;"use strict"',
+                [],
+                [ "use strict", "use\nstrict", "use \nstrict", "use asm" ]
+            ],
             // Special cases
-            {
-                input: '"1";"2";"3";"4";;"5"',
-                directives: ["1", "2", "3", "4"],
-                non_directives: ["5", "6", "use strict", "use asm"]
-            },
-            {
-                input: 'if(1){"use strict";',
-                directives: [],
-                non_directives: ["use strict", "use\nstrict", "use \nstrict", "use asm"]
-            },
-            {
-                input: '"use strict";try{"use asm";',
-                directives: ["use strict"],
-                non_directives: ["use\nstrict", "use \nstrict", "use asm"]
-            }
-        ];
-
-        for (var i = 0; i < tests.length; i++) {
-            // Fail parser deliberately to get state at failure
-            var tokenizer = UglifyJS.tokenizer(tests[i].input + "]", "foo.js");
-
-            try {
-                var parser = UglifyJS.parse(tokenizer);
-                throw new Error("Expected parser to fail");
-            } catch (e) {
-                assert.strictEqual(e instanceof UglifyJS.JS_Parse_Error, true);
-                assert.strictEqual(e.message, "Unexpected token: punc (])");
-            }
-
-            test_directive(tokenizer, tests[i]);
-        }
+            [
+                '"1";"2";"3";"4";;"5"',
+                [ "1", "2", "3", "4" ],
+                [ "5", "6", "use strict", "use asm" ]
+            ],
+            [
+                'if(1){"use strict";',
+                [],
+                [ "use strict", "use\nstrict", "use \nstrict", "use asm" ]
+            ],
+            [
+                '"use strict";try{"use asm";',
+                [ "use strict" ],
+                [ "use\nstrict", "use \nstrict", "use asm" ]
+            ],
+        ].forEach(function(test) {
+            var tokenizer = UglifyJS.tokenizer(test[0] + "]", "foo.js");
+            assert.throws(function() {
+                UglifyJS.parse(tokenizer);
+            }, function(e) {
+                return e instanceof UglifyJS.JS_Parse_Error
+                    && e.message === "Unexpected token: punc (])"
+            }, test[0]);
+            test[1].forEach(function(directive) {
+                assert.strictEqual(tokenizer.has_directive(directive), true, directive + " in " + test[0]);
+            });
+            test[2].forEach(function(fake_directive) {
+                assert.strictEqual(tokenizer.has_directive(fake_directive), false, fake_directive + " in " + test[0]);
+            });
+        });
     });
-
     it("Should test EXPECT_DIRECTIVE RegExp", function() {
         [
-            ["", true],
-            ["'test';", true],
-            ["'test';;", true],
-            ["'tests';\n", true],
-            ["'tests'", false],
-            ["'tests';   \n\t", true],
-            ["'tests';\n\n", true],
-            ["\n\n\"use strict\";\n\n", true]
+            [ "", true ],
+            [ "'test';", true ],
+            [ "'test';;", true ],
+            [ "'tests';\n", true ],
+            [ "'tests'", false ],
+            [ "'tests';   \n\t", true ],
+            [ "'tests';\n\n", true ],
+            [ "\n\n\"use strict\";\n\n", true ],
         ].forEach(function(test) {
             var out = UglifyJS.OutputStream();
             out.print(test[0]);
@@ -192,19 +173,33 @@ describe("Directives", function() {
             assert.strictEqual(out.get() === test[0] + ';""', test[1], test[0]);
         });
     });
-
     it("Should only print 2 semicolons spread over 2 lines in beautify mode", function() {
-        assert.strictEqual(
-            UglifyJS.minify(
-                '"use strict";\'use strict\';"use strict";"use strict";;\'use strict\';console.log(\'use strict\');',
-                {output: {beautify: true, quote_style: 3}, compress: false}
-            ).code,
-            '"use strict";\n\n\'use strict\';\n\n"use strict";\n\n"use strict";\n\n;\'use strict\';\n\nconsole.log(\'use strict\');'
-        );
+        var result = UglifyJS.minify([
+            '"use strict";',
+            "'use strict';",
+            '"use strict";',
+            '"use strict";;',
+            "'use strict';",
+            "console.log('use strict');"
+        ].join(""), {
+            compress: false,
+            output: {
+                beautify: true,
+                quote_style: 3
+            }
+        });
+        if (result.error) throw result.error;
+        assert.strictEqual(result.code, [
+            '"use strict";',
+            "'use strict';",
+            '"use strict";',
+            '"use strict";',
+            ";'use strict';",
+            "console.log('use strict');"
+        ].join("\n\n"));
     });
-
     it("Should not add double semicolons in non-scoped block statements to avoid strings becoming directives", function() {
-        var tests = [
+        [
             [
                 '{"use\x20strict"}',
                 '{"use strict"}'
@@ -221,26 +216,27 @@ describe("Directives", function() {
                 'if(1){"use\x20strict"} else {"use strict"}',
                 'if(1){"use strict"}else{"use strict"}'
             ]
-        ];
-
-        for (var i = 0; i < tests.length; i++) {
-            assert.strictEqual(
-                UglifyJS.minify(tests[i][0], {compress: false, mangle: false}).code,
-                tests[i][1],
-                tests[i][0]
-            );
-        }
+        ].forEach(function(test) {
+            var result = UglifyJS.minify(test[0], {
+                compress: false,
+                mangle: false
+            });
+            if (result.error) throw result.error;
+            assert.strictEqual(result.code, test[1], test[0]);
+        });
     });
-
     it("Should add double semicolon when relying on automatic semicolon insertion", function() {
-        var code = UglifyJS.minify('"use strict";"use\\x20strict";',
-            {output: {semicolons: false}, compress: false}
-        ).code;
-        assert.strictEqual(code, '"use strict";;"use strict"\n');
+        var result = UglifyJS.minify('"use strict";"use\\x20strict";', {
+            compress: false,
+            output: {
+                semicolons: false
+            }
+        });
+        if (result.error) throw result.error;
+        assert.strictEqual(result.code, '"use strict";;"use strict"\n');
     });
-
     it("Should check quote style of directives", function() {
-        var tests = [
+        [
             // 0. Prefer double quotes, unless string contains more double quotes than single quotes
             [
                 '"testing something";',
@@ -337,45 +333,53 @@ describe("Directives", function() {
                 3,
                 "'\"use strict\"';",
             ],
-        ];
-        for (var i = 0; i < tests.length; i++) {
-            assert.strictEqual(
-                UglifyJS.minify(tests[i][0], {output:{quote_style: tests[i][1]}, compress: false}).code,
-                tests[i][2],
-                tests[i][0] + " using mode " + tests[i][1]
-            );
-        }
+        ].forEach(function(test) {
+            var result = UglifyJS.minify(test[0], {
+                compress: false,
+                output: {
+                    quote_style: test[1]
+                }
+            });
+            if (result.error) throw result.error;
+            assert.strictEqual(result.code, test[2], test[0] + " using mode " + test[1]);
+        });
     });
     it("Should be able to compress without side effects", function() {
-        // NOTE: the "use asm" directive disables any optimisation after being defined
-        var tests = [
+        [
             [
                 '"use strict";"use strict";"use strict";"use foo";"use strict";;"use sloppy";doSomething("foo");',
-                '"use strict";"use foo";doSomething("foo");',
-                'function f(){ "use strict" }',
-                'function f(){ "use asm" }',
-                'function f(){ "use nondirective" }',
-                'function f(){ ;"use strict" }',
-                'function f(){ "use \n"; }',
+                '"use strict";doSomething("foo");'
             ],
             [
-                 // Nothing gets optimised in the compressor because "use asm" is the first statement
+                // Nothing gets optimised in the compressor because "use asm" is the first statement
                 '"use asm";"use\\x20strict";1+1;',
-                '"use asm";;"use strict";1+1;', // Yet, the parser noticed that "use strict" wasn't a directive
-                'function f(){"use strict"}',
-                'function f(){"use asm"}',
-                'function f(){"use nondirective"}',
-                'function f(){}',
-                'function f(){}',
-            ]
-        ];
-
-        for (var i = 0; i < tests.length; i++) {
-            assert.strictEqual(
-                UglifyJS.minify(tests[i][0]).code,
-                tests[i][1],
-                tests[i][0]
-            );
-        }
+                // Yet, the parser noticed that "use strict" wasn't a directive
+                '"use asm";;"use strict";1+1;',
+            ],
+            [
+                'function f(){ "use strict" }',
+                'function f(){}'
+            ],
+            [
+                'function f(){ "use asm" }',
+                'function f(){"use asm"}'
+            ],
+            [
+                'function f(){ "use nondirective" }',
+                'function f(){}'
+            ],
+            [
+                'function f(){ ;"use strict" }',
+                'function f(){}'
+            ],
+            [
+                'function f(){ "use \\n"; }',
+                'function f(){}'
+            ],
+        ].forEach(function(test) {
+            var result = UglifyJS.minify(test[0]);
+            if (result.error) throw result.error;
+            assert.strictEqual(result.code, test[1], test[0]);
+        });
     });
 });

test/mocha/glob.js

@@ -35,7 +35,7 @@ describe("bin/uglifyjs with input file globs", function() {
             done();
         });
     });
-    it("should throw with non-matching glob string", function(done) {
+    it("Should throw with non-matching glob string", function(done) {
         var command = uglifyjscmd + ' "test/input/issue-1242/blah.*"';
 
         exec(command, function(err, stdout, stderr) {
@@ -53,7 +53,7 @@ describe("bin/uglifyjs with input file globs", function() {
             done();
         });
     });
-    it("should handle special characters in glob string", function(done) {
+    it("Should handle special characters in glob string", function(done) {
         var command = uglifyjscmd + ' "test/input/issue-1632/^{*}[???](*)+$.??" -cm';
 
         exec(command, function(err, stdout) {
@@ -63,7 +63,7 @@ describe("bin/uglifyjs with input file globs", function() {
             done();
         });
     });
-    it("should handle array of glob strings - matching and otherwise", function(done) {
+    it("Should handle array of glob strings - matching and otherwise", function(done) {
         var dir = "test/input/issue-1242";
         var command = uglifyjscmd + ' "' + [
             path.join(dir, "b*.es5"),

test/mocha/minify.js

@@ -187,7 +187,7 @@ describe("minify", function() {
     });
 
     describe("#__PURE__", function() {
-        it("should drop #__PURE__ hint after use", function() {
+        it("Should drop #__PURE__ hint after use", function() {
             var result = UglifyJS.minify('//@__PURE__ comment1 #__PURE__ comment2\n foo(), bar();', {
                 output: {
                     comments: "all",
@@ -197,7 +197,7 @@ describe("minify", function() {
             var code = result.code;
             assert.strictEqual(code, "//  comment1   comment2\nbar();");
         });
-        it("should drop #__PURE__ hint if function is retained", function() {
+        it("Should drop #__PURE__ hint if function is retained", function() {
             var result = UglifyJS.minify("var a = /*#__PURE__*/(function(){ foo(); })();", {
                 output: {
                     comments: "all",
@@ -210,7 +210,7 @@ describe("minify", function() {
     });
 
     describe("JS_Parse_Error", function() {
-        it("should return syntax error", function() {
+        it("Should return syntax error", function() {
             var result = UglifyJS.minify("function f(a{}");
             var err = result.error;
             assert.ok(err instanceof Error);
@@ -219,7 +219,7 @@ describe("minify", function() {
             assert.strictEqual(err.line, 1);
             assert.strictEqual(err.col, 12);
         });
-        it("should reject duplicated label name", function() {
+        it("Should reject duplicated label name", function() {
             var result = UglifyJS.minify("L:{L:{}}");
             var err = result.error;
             assert.ok(err instanceof Error);
@@ -231,7 +231,7 @@ describe("minify", function() {
     });
 
     describe("global_defs", function() {
-        it("should throw for non-trivial expressions", function() {
+        it("Should throw for non-trivial expressions", function() {
             var result = UglifyJS.minify("alert(42);", {
                 compress: {
                     global_defs: {
@@ -243,7 +243,7 @@ describe("minify", function() {
             assert.ok(err instanceof Error);
             assert.strictEqual(err.stack.split(/\n/)[0], "SyntaxError: Unexpected token: keyword (debugger)");
         });
-        it("should skip inherited properties", function() {
+        it("Should skip inherited properties", function() {
             var foo = Object.create({ skip: this });
             foo.bar = 42;
             var result = UglifyJS.minify("alert(FOO);", {

test/mocha/sourcemaps.js

@@ -53,7 +53,6 @@ describe("sourcemaps", function() {
         assert.strictEqual(map.version, 3);
         assert.deepEqual(map.names, [ "x" ]);
     });
-
     it("Should give correct names", function() {
         var map = source_map([
             "({",
@@ -67,7 +66,6 @@ describe("sourcemaps", function() {
         ].join("\n"));
         assert.deepEqual(map.names, [ "enabled", "x" ]);
     });
-
     it("Should mark array/object literals", function() {
         var result = UglifyJS.minify([
             "var obj = {};",
@@ -80,7 +78,6 @@ describe("sourcemaps", function() {
         assert.strictEqual(result.code, "({}).wat([]);");
         assert.strictEqual(result.map, '{"version":3,"sources":["0"],"names":["wat"],"mappings":"CAAU,IACNA,IAAI"}');
     });
-
     it("Should give correct sourceRoot", function() {
         var code = "console.log(42);";
         var result = UglifyJS.minify(code, {
@@ -212,6 +209,9 @@ describe("sourcemaps", function() {
         });
         it("Should work with max_line_len", function() {
             var result = UglifyJS.minify(read("./test/input/issue-505/input.js"), {
+                compress: {
+                    directives: false,
+                },
                 output: {
                     max_line_len: 20
                 },
@@ -261,7 +261,6 @@ describe("sourcemaps", function() {
             var map = prepare_map(orig);
             assert.equal(map.sourceContentFor("index.js"), orig.sourcesContent[0]);
         });
-
         it("Should copy sourcesContent if sources are relative", function() {
             var relativeMap = get_map();
             relativeMap.sources = ['./index.js'];
@@ -270,7 +269,6 @@ describe("sourcemaps", function() {
             assert.equal(map.sourcesContent.length, 1);
             assert.equal(map.sourceContentFor("index.js"), relativeMap.sourcesContent[0]);
         });
-
         it("Should not have invalid mappings from inputSourceMap", function() {
             var map = prepare_map(get_map());
             // The original source has only 2 lines, check that mappings don't have more lines

test/mocha/spidermonkey.js

@@ -3,7 +3,7 @@ var exec = require("child_process").exec;
 var UglifyJS = require("../..");
 
 describe("spidermonkey export/import sanity test", function() {
-    it("should produce a functional build when using --self with spidermonkey", function(done) {
+    it("Should produce a functional build when using --self with spidermonkey", function(done) {
         this.timeout(60000);
 
         var uglifyjs = '"' + process.argv[0] + '" bin/uglifyjs';
@@ -23,7 +23,7 @@ describe("spidermonkey export/import sanity test", function() {
         });
     });
 
-    it("should not add unnecessary escape slashes to regexps", function() {
+    it("Should not add unnecessary escape slashes to regexps", function() {
         var input = "/[\\\\/]/;";
         var ast = UglifyJS.parse(input).to_mozilla_ast();
         assert.equal(

test/run-tests.js

@@ -23,68 +23,200 @@ require("./mocha.js");
 
 /* -----[ utils ]----- */
 
-function tmpl() {
-    return U.string_template.apply(this, arguments);
+function evaluate(code) {
+    if (code instanceof U.AST_Node) code = make_code(code, { beautify: true });
+    return new Function("return(" + code + ")")();
 }
 
 function log() {
-    var txt = tmpl.apply(this, arguments);
-    console.log("%s", txt);
+    console.log("%s", tmpl.apply(null, arguments));
 }
 
-function log_directory(dir) {
-    log("*** Entering [{dir}]", { dir: dir });
+function make_code(ast, options) {
+    var stream = U.OutputStream(options);
+    ast.print(stream);
+    return stream.get();
 }
 
-function log_start_file(file) {
-    log("--- {file}", { file: file });
-}
-
-function log_test(name) {
-    log("    Running test [{name}]", { name: name });
-}
-
-function find_test_files(dir) {
-    return fs.readdirSync(dir).filter(function(name) {
-        return /\.js$/i.test(name);
-    });
-}
-
-function test_directory(dir) {
-    return path.resolve(tests_dir, dir);
-}
-
-function as_toplevel(input, mangle_options) {
-    if (!(input instanceof U.AST_BlockStatement))
-        throw new Error("Unsupported input syntax");
-    for (var i = 0; i < input.body.length; i++) {
-        var stat = input.body[i];
-        if (stat instanceof U.AST_SimpleStatement && stat.body instanceof U.AST_String)
-            input.body[i] = new U.AST_Directive(stat.body);
-        else break;
+function parse_test(file) {
+    var script = fs.readFileSync(file, "utf8");
+    // TODO try/catch can be removed after fixing https://github.com/mishoo/UglifyJS2/issues/348
+    try {
+        var ast = U.parse(script, {
+            filename: file
+        });
+    } catch (e) {
+        console.log("Caught error while parsing tests in " + file + "\n");
+        console.log(e);
+        throw e;
     }
-    var toplevel = new U.AST_Toplevel(input);
-    toplevel.figure_out_scope(mangle_options);
-    return toplevel;
+    var tests = {};
+    var tw = new U.TreeWalker(function(node, descend) {
+        if (node instanceof U.AST_LabeledStatement
+            && tw.parent() instanceof U.AST_Toplevel) {
+            var name = node.label.name;
+            if (name in tests) {
+                throw new Error('Duplicated test name "' + name + '" in ' + file);
+            }
+            tests[name] = get_one_test(name, node.body);
+            return true;
+        }
+        if (!(node instanceof U.AST_Toplevel)) croak(node);
+    });
+    ast.walk(tw);
+    return tests;
+
+    function croak(node) {
+        throw new Error(tmpl("Can't understand test file {file} [{line},{col}]\n{code}", {
+            file: file,
+            line: node.start.line,
+            col: node.start.col,
+            code: make_code(node, { beautify: false })
+        }));
+    }
+
+    function read_string(stat) {
+        if (stat.TYPE == "SimpleStatement") {
+            var body = stat.body;
+            switch(body.TYPE) {
+              case "String":
+                return body.value;
+              case "Array":
+                return body.elements.map(function(element) {
+                    if (element.TYPE !== "String")
+                        throw new Error("Should be array of strings");
+                    return element.value;
+                }).join("\n");
+            }
+        }
+        throw new Error("Should be string or array of strings");
+    }
+
+    function get_one_test(name, block) {
+        var test = { name: name, options: {} };
+        var tw = new U.TreeWalker(function(node, descend) {
+            if (node instanceof U.AST_Assign) {
+                if (!(node.left instanceof U.AST_SymbolRef)) {
+                    croak(node);
+                }
+                var name = node.left.name;
+                test[name] = evaluate(node.right);
+                return true;
+            }
+            if (node instanceof U.AST_LabeledStatement) {
+                var label = node.label;
+                assert.ok([
+                    "input",
+                    "expect",
+                    "expect_exact",
+                    "expect_warnings",
+                    "expect_stdout",
+                    "node_version",
+                ].indexOf(label.name) >= 0, tmpl("Unsupported label {name} [{line},{col}]", {
+                    name: label.name,
+                    line: label.start.line,
+                    col: label.start.col
+                }));
+                var stat = node.body;
+                if (label.name == "expect_exact" || label.name == "node_version") {
+                    test[label.name] = read_string(stat);
+                } else if (label.name == "expect_stdout") {
+                    var body = stat.body;
+                    if (body instanceof U.AST_Boolean) {
+                        test[label.name] = body.value;
+                    } else if (body instanceof U.AST_Call) {
+                        var ctor = global[body.expression.name];
+                        assert.ok(ctor === Error || ctor.prototype instanceof Error, tmpl("Unsupported expect_stdout format [{line},{col}]", {
+                            line: label.start.line,
+                            col: label.start.col
+                        }));
+                        test[label.name] = ctor.apply(null, body.args.map(function(node) {
+                            assert.ok(node instanceof U.AST_Constant, tmpl("Unsupported expect_stdout format [{line},{col}]", {
+                                line: label.start.line,
+                                col: label.start.col
+                            }));
+                            return node.value;
+                        }));
+                    } else {
+                        test[label.name] = read_string(stat) + "\n";
+                    }
+                } else {
+                    test[label.name] = stat;
+                }
+                return true;
+            }
+        });
+        block.walk(tw);
+        return test;
+    }
+}
+
+// Try to reminify original input with standard options
+// to see if it matches expect_stdout.
+function reminify(orig_options, input_code, input_formatted, expect_stdout) {
+    for (var i = 0; i < minify_options.length; i++) {
+        var options = JSON.parse(minify_options[i]);
+        if (options.compress) [
+            "keep_fargs",
+            "keep_fnames",
+        ].forEach(function(name) {
+            if (name in orig_options) {
+                options.compress[name] = orig_options[name];
+            }
+        });
+        var options_formatted = JSON.stringify(options, null, 4);
+        var result = U.minify(input_code, options);
+        if (result.error) {
+            log("!!! failed input reminify\n---INPUT---\n{input}\n---OPTIONS---\n{options}\n--ERROR---\n{error}\n\n", {
+                input: input_formatted,
+                options: options_formatted,
+                error: result.error,
+            });
+            return false;
+        } else {
+            var stdout = run_code(result.code);
+            if (typeof expect_stdout != "string" && typeof stdout != "string" && expect_stdout.name == stdout.name) {
+                stdout = expect_stdout;
+            }
+            if (!sandbox.same_stdout(expect_stdout, stdout)) {
+                log("!!! failed running reminified input\n---INPUT---\n{input}\n---OPTIONS---\n{options}\n---OUTPUT---\n{output}\n---EXPECTED {expected_type}---\n{expected}\n---ACTUAL {actual_type}---\n{actual}\n\n", {
+                    input: input_formatted,
+                    options: options_formatted,
+                    output: result.code,
+                    expected_type: typeof expect_stdout == "string" ? "STDOUT" : "ERROR",
+                    expected: expect_stdout,
+                    actual_type: typeof stdout == "string" ? "STDOUT" : "ERROR",
+                    actual: stdout,
+                });
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
+function run_code(code) {
+    var result = sandbox.run_code(code, true);
+    return typeof result == "string" ? result.replace(/\u001b\[\d+m/g, "") : result;
 }
 
 function run_compress_tests() {
-    var dir = test_directory("compress");
-    log_directory("compress");
-    var files = find_test_files(dir);
-    function test_file(file) {
-        log_start_file(file);
+    var dir = path.resolve(tests_dir, "compress");
+    fs.readdirSync(dir).filter(function(name) {
+        return /\.js$/i.test(name);
+    }).forEach(function(file) {
+        log("--- {file}", { file: file });
         function test_case(test) {
-            log_test(test.name);
+            log("    Running test [{name}]", { name: test.name });
             var output_options = test.beautify || {};
             var expect;
             if (test.expect) {
-                expect = make_code(as_toplevel(test.expect, test.mangle), output_options);
+                expect = make_code(to_toplevel(test.expect, test.mangle), output_options);
             } else {
                 expect = test.expect_exact;
             }
-            var input = as_toplevel(test.input, test.mangle);
-            var input_code = make_code(input, output_options);
+            var input = to_toplevel(test.input, test.mangle);
+            var input_code = make_code(input);
             var input_formatted = make_code(test.input, {
                 beautify: true,
                 quote_style: 3,
@@ -209,185 +341,27 @@ function run_compress_tests() {
                 failed_files[file] = 1;
             }
         }
-    }
-    files.forEach(function(file) {
-        test_file(file);
     });
 }
 
-function parse_test(file) {
-    var script = fs.readFileSync(file, "utf8");
-    // TODO try/catch can be removed after fixing https://github.com/mishoo/UglifyJS2/issues/348
-    try {
-        var ast = U.parse(script, {
-            filename: file
-        });
-    } catch (e) {
-        console.log("Caught error while parsing tests in " + file + "\n");
-        console.log(e);
-        throw e;
-    }
-    var tests = {};
-    var tw = new U.TreeWalker(function(node, descend) {
-        if (node instanceof U.AST_LabeledStatement
-            && tw.parent() instanceof U.AST_Toplevel) {
-            var name = node.label.name;
-            if (name in tests) {
-                throw new Error('Duplicated test name "' + name + '" in ' + file);
-            }
-            tests[name] = get_one_test(name, node.body);
-            return true;
-        }
-        if (!(node instanceof U.AST_Toplevel)) croak(node);
-    });
-    ast.walk(tw);
-    return tests;
-
-    function croak(node) {
-        throw new Error(tmpl("Can't understand test file {file} [{line},{col}]\n{code}", {
-            file: file,
-            line: node.start.line,
-            col: node.start.col,
-            code: make_code(node, { beautify: false })
-        }));
-    }
-
-    function read_string(stat) {
-        if (stat.TYPE == "SimpleStatement") {
-            var body = stat.body;
-            switch(body.TYPE) {
-              case "String":
-                return body.value;
-              case "Array":
-                return body.elements.map(function(element) {
-                    if (element.TYPE !== "String")
-                        throw new Error("Should be array of strings");
-                    return element.value;
-                }).join("\n");
-            }
-        }
-        throw new Error("Should be string or array of strings");
-    }
-
-    function get_one_test(name, block) {
-        var test = { name: name, options: {} };
-        var tw = new U.TreeWalker(function(node, descend) {
-            if (node instanceof U.AST_Assign) {
-                if (!(node.left instanceof U.AST_SymbolRef)) {
-                    croak(node);
-                }
-                var name = node.left.name;
-                test[name] = evaluate(node.right);
-                return true;
-            }
-            if (node instanceof U.AST_LabeledStatement) {
-                var label = node.label;
-                assert.ok(
-                    [
-                        "input",
-                        "expect",
-                        "expect_exact",
-                        "expect_warnings",
-                        "expect_stdout",
-                        "node_version",
-                    ].indexOf(label.name) >= 0,
-                    tmpl("Unsupported label {name} [{line},{col}]", {
-                        name: label.name,
-                        line: label.start.line,
-                        col: label.start.col
-                    })
-                );
-                var stat = node.body;
-                if (label.name == "expect_exact" || label.name == "node_version") {
-                    test[label.name] = read_string(stat);
-                } else if (label.name == "expect_stdout") {
-                    var body = stat.body;
-                    if (body instanceof U.AST_Boolean) {
-                        test[label.name] = body.value;
-                    } else if (body instanceof U.AST_Call) {
-                        var ctor = global[body.expression.name];
-                        assert.ok(ctor === Error || ctor.prototype instanceof Error, tmpl("Unsupported expect_stdout format [{line},{col}]", {
-                            line: label.start.line,
-                            col: label.start.col
-                        }));
-                        test[label.name] = ctor.apply(null, body.args.map(function(node) {
-                            assert.ok(node instanceof U.AST_Constant, tmpl("Unsupported expect_stdout format [{line},{col}]", {
-                                line: label.start.line,
-                                col: label.start.col
-                            }));
-                            return node.value;
-                        }));
-                    } else {
-                        test[label.name] = read_string(stat) + "\n";
-                    }
-                } else {
-                    test[label.name] = stat;
-                }
-                return true;
-            }
-        });
-        block.walk(tw);
-        return test;
-    };
+function tmpl() {
+    return U.string_template.apply(null, arguments);
 }
 
-function make_code(ast, options) {
-    var stream = U.OutputStream(options);
-    ast.print(stream);
-    return stream.get();
-}
-
-function evaluate(code) {
-    if (code instanceof U.AST_Node)
-        code = make_code(code, { beautify: true });
-    return new Function("return(" + code + ")")();
-}
-
-function run_code(code) {
-    var result = sandbox.run_code(code, true);
-    return typeof result == "string" ? result.replace(/\u001b\[\d+m/g, "") : result;
-}
-
-// Try to reminify original input with standard options
-// to see if it matches expect_stdout.
-function reminify(orig_options, input_code, input_formatted, expect_stdout) {
-    for (var i = 0; i < minify_options.length; i++) {
-        var options = JSON.parse(minify_options[i]);
-        if (options.compress) [
-            "keep_fargs",
-            "keep_fnames",
-        ].forEach(function(name) {
-            if (name in orig_options) {
-                options.compress[name] = orig_options[name];
-            }
-        });
-        var options_formatted = JSON.stringify(options, null, 4);
-        var result = U.minify(input_code, options);
-        if (result.error) {
-            log("!!! failed input reminify\n---INPUT---\n{input}\n---OPTIONS---\n{options}\n--ERROR---\n{error}\n\n", {
-                input: input_formatted,
-                options: options_formatted,
-                error: result.error,
-            });
-            return false;
+function to_toplevel(input, mangle_options) {
+    if (!(input instanceof U.AST_BlockStatement)) throw new Error("Unsupported input syntax");
+    var directive = true;
+    var offset = input.start.line;
+    var tokens = [];
+    var toplevel = new U.AST_Toplevel(input.transform(new U.TreeTransformer(function(node) {
+        if (U.push_uniq(tokens, node.start)) node.start.line -= offset;
+        if (!directive || node === input) return;
+        if (node instanceof U.AST_SimpleStatement && node.body instanceof U.AST_String) {
+            return new U.AST_Directive(node.body);
         } else {
-            var stdout = run_code(result.code);
-            if (typeof expect_stdout != "string" && typeof stdout != "string" && expect_stdout.name == stdout.name) {
-                stdout = expect_stdout;
-            }
-            if (!sandbox.same_stdout(expect_stdout, stdout)) {
-                log("!!! failed running reminified input\n---INPUT---\n{input}\n---OPTIONS---\n{options}\n---OUTPUT---\n{output}\n---EXPECTED {expected_type}---\n{expected}\n---ACTUAL {actual_type}---\n{actual}\n\n", {
-                    input: input_formatted,
-                    options: options_formatted,
-                    output: result.code,
-                    expected_type: typeof expect_stdout == "string" ? "STDOUT" : "ERROR",
-                    expected: expect_stdout,
-                    actual_type: typeof stdout == "string" ? "STDOUT" : "ERROR",
-                    actual: stdout,
-                });
-                return false;
-            }
+            directive = false;
         }
-    }
-    return true;
+    })));
+    toplevel.figure_out_scope(mangle_options);
+    return toplevel;
 }

test/sandbox.js

@@ -79,7 +79,7 @@ exports.run_code = function(code, reuse) {
         return ex;
     } finally {
         process.stdout.write = original_write;
-        if (!reuse || /prototype/.test(code)) {
+        if (!reuse || code.indexOf(".prototype") >= 0) {
             context = null;
         } else for (var key in context) {
             delete context[key];

test/travis-ufuzz.js

@@ -15,6 +15,7 @@ if (process.argv[2] == "run") {
     var branch = process.argv[3] || "v" + require("../package.json").version;
     var repository = encodeURIComponent(process.argv[4] || "mishoo/UglifyJS2");
     var concurrency = process.argv[5] || 1;
+    var platform = process.argv[6] || "node/latest";
     (function request() {
         setTimeout(request, (period + wait) / concurrency);
         var options = url.parse("https://api.travis-ci.org/repo/" + repository + "/requests");
@@ -32,20 +33,18 @@ if (process.argv[2] == "run") {
             res.on("data", console.log);
         }).on("error", console.error).end(JSON.stringify({
             request: {
-                message: "ufuzz testing (when idle)",
+                message: "ufuzz testing",
                 branch: branch,
                 config: {
-                    merge_mode: "replace",
-                    language: "node_js",
-                    node_js: "9",
-                    sudo: false,
+                    cache: false,
+                    env: "NODEJS_VER=" + platform,
                     script: "node test/travis-ufuzz run"
                 }
             }
         }));
     })();
 } else {
-    console.log("Usage: test/travis-ufuzz.js <token> [branch] [repository] [concurrency]");
+    console.log("Usage: test/travis-ufuzz.js <token> [branch] [repository] [concurrency] [platform]");
 }
 
 function spawn(endTime) {

tools/exports.js

@@ -1,6 +1,6 @@
 exports["Dictionary"] = Dictionary;
-exports["TreeWalker"] = TreeWalker;
-exports["TreeTransformer"] = TreeTransformer;
 exports["minify"] = minify;
 exports["parse"] = parse;
-exports["_push_uniq"] = push_uniq;
+exports["push_uniq"] = push_uniq;
+exports["TreeTransformer"] = TreeTransformer;
+exports["TreeWalker"] = TreeWalker;

tools/node.js

@@ -1,7 +1,6 @@
 var fs = require("fs");
 
-var UglifyJS = exports;
-var FILES = UglifyJS.FILES = [
+exports.FILES = [
     "../lib/utils.js",
     "../lib/ast.js",
     "../lib/parse.js",
@@ -19,15 +18,12 @@ var FILES = UglifyJS.FILES = [
 });
 
 new Function("MOZ_SourceMap", "exports", function() {
-    var code = FILES.map(function(file) {
+    var code = exports.FILES.map(function(file) {
         return fs.readFileSync(file, "utf8");
     });
     code.push("exports.describe_ast = " + describe_ast.toString());
     return code.join("\n\n");
-}())(
-    require("source-map"),
-    UglifyJS
-);
+}())(require("source-map"), exports);
 
 function describe_ast() {
     var out = OutputStream({ beautify: true });
@@ -65,11 +61,11 @@ function describe_ast() {
 }
 
 function infer_options(options) {
-    var result = UglifyJS.minify("", options);
+    var result = exports.minify("", options);
     return result.error && result.error.defs;
 }
 
-UglifyJS.default_options = function() {
+exports.default_options = function() {
     var defs = {};
     Object.keys(infer_options({ 0: 0 })).forEach(function(component) {
         var options = {};