v3.7.1

fixes #3600

.github/workflows/ci.yml

@@ -14,13 +14,17 @@ jobs:
       TYPE: ${{ matrix.script }}
     steps:
       - uses: actions/checkout@v1
-      - shell: bash
+      - uses: actions/cache@v1
+        with:
+          path: tmp
+          key: tmp ${{ matrix.script }}
+      - name: Perform tests
+        shell: bash
         run: |
-          git clone --branch v1.5.2 --depth 1 https://github.com/jasongin/nvs.git ~/.nvs
-          . ~/.nvs/nvs.sh
-          nvs --version
-          nvs add node/$NODE
-          nvs use node/$NODE
+          git clone --branch v1.5.3 --depth 1 https://github.com/jasongin/nvs.git ~/.nvs
+          . ~/.nvs/nvs.sh --version
+          nvs add $NODE
+          nvs use $NODE
           node --version
           npm --version --no-update-notifier
           npm install --no-audit --no-optional --no-save --no-update-notifier

.github/workflows/ufuzz.yml

@@ -12,13 +12,13 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - uses: actions/checkout@v1
-      - shell: bash
+      - name: Perform fuzzing
+        shell: bash
         run: |
-          git clone --branch v1.5.2 --depth 1 https://github.com/jasongin/nvs.git ~/.nvs
-          . ~/.nvs/nvs.sh
-          nvs --version
-          nvs add node
-          nvs use node
+          git clone --branch v1.5.3 --depth 1 https://github.com/jasongin/nvs.git ~/.nvs
+          . ~/.nvs/nvs.sh --version
+          nvs add 10
+          nvs use 10
           node --version
           npm --version --no-update-notifier
           npm install --no-audit --no-optional --no-save --no-update-notifier

.travis.yml

@@ -1,46 +0,0 @@
-cache:
-  directories: tmp
-language: shell
-matrix:
-  fast_finish: true
-env:
-  - NODE=0.10   TYPE=compress
-  - NODE=0.10   TYPE=mocha
-  - NODE=0.10   TYPE=release/benchmark
-  - NODE=0.10   TYPE=release/jetstream
-  - NODE=0.12   TYPE=compress
-  - NODE=0.12   TYPE=mocha
-  - NODE=0.12   TYPE=release/benchmark
-  - NODE=0.12   TYPE=release/jetstream
-  - NODE=4      TYPE=compress
-  - NODE=4      TYPE=mocha
-  - NODE=4      TYPE=release/benchmark
-  - NODE=4      TYPE=release/jetstream
-  - NODE=6      TYPE=compress
-  - NODE=6      TYPE=mocha
-  - NODE=6      TYPE=release/benchmark
-  - NODE=6      TYPE=release/jetstream
-  - NODE=8      TYPE=compress
-  - NODE=8      TYPE=mocha
-  - NODE=8      TYPE=release/benchmark
-  - NODE=8      TYPE=release/jetstream
-  - NODE=10     TYPE=compress
-  - NODE=10     TYPE=mocha
-  - NODE=10     TYPE=release/benchmark
-  - NODE=10     TYPE=release/jetstream
-  - NODE=latest TYPE=compress
-  - NODE=latest TYPE=mocha
-  - NODE=latest TYPE=release/benchmark
-  - NODE=latest TYPE=release/jetstream
-before_install:
-  - git clone --branch v1.5.2 --depth 1 https://github.com/jasongin/nvs.git ~/.nvs
-  - . ~/.nvs/nvs.sh
-  - nvs --version
-install:
-  - nvs add node/$NODE
-  - nvs use node/$NODE
-  - node --version
-  - npm --version --no-update-notifier
-  - npm install --no-audit --no-optional --no-save --no-update-notifier
-script:
-  - node test/$TYPE

README.md

@@ -478,42 +478,42 @@ if (result.error) throw result.error;
 
 ## Minify options
 
-- `warnings` (default `false`) — pass `true` to return compressor warnings
-  in `result.warnings`. Use the value `"verbose"` for more detailed warnings.
-
-- `parse` (default `{}`) — pass an object if you wish to specify some
-  additional [parse options](#parse-options).
-
 - `compress` (default `{}`) — pass `false` to skip compressing entirely.
   Pass an object to specify custom [compress options](#compress-options).
 
+- `ie8` (default `false`) -- set to `true` to support IE8.
+
+- `keep_fnames` (default: `false`) -- pass `true` to prevent discarding or mangling
+  of function names.  Useful for code relying on `Function.prototype.name`.
+
 - `mangle` (default `true`) — pass `false` to skip mangling names, or pass
   an object to specify [mangle options](#mangle-options) (see below).
 
   - `mangle.properties` (default `false`) — a subcategory of the mangle option.
     Pass an object to specify custom [mangle property options](#mangle-properties-options).
 
-- `output` (default `null`) — pass an object if you wish to specify
-  additional [output options](#output-options).  The defaults are optimized
-  for best compression.
-
-- `sourceMap` (default `false`) - pass an object if you wish to specify
-  [source map options](#source-map-options).
-
-- `toplevel` (default `false`) - set to `true` if you wish to enable top level
-  variable and function name mangling and to drop unused variables and functions.
-
-- `nameCache` (default `null`) - pass an empty object `{}` or a previously
+- `nameCache` (default `null`) -- pass an empty object `{}` or a previously
   used `nameCache` object if you wish to cache mangled variable and
   property names across multiple invocations of `minify()`. Note: this is
   a read/write property. `minify()` will read the name cache state of this
   object and update it during minification so that it may be
   reused or externally persisted by the user.
 
-- `ie8` (default `false`) - set to `true` to support IE8.
+- `output` (default `null`) — pass an object if you wish to specify
+  additional [output options](#output-options).  The defaults are optimized
+  for best compression.
 
-- `keep_fnames` (default: `false`) - pass `true` to prevent discarding or mangling
-  of function names.  Useful for code relying on `Function.prototype.name`.
+- `parse` (default `{}`) — pass an object if you wish to specify some
+  additional [parse options](#parse-options).
+
+- `sourceMap` (default `false`) -- pass an object if you wish to specify
+  [source map options](#source-map-options).
+
+- `toplevel` (default `false`) -- set to `true` if you wish to enable top level
+  variable and function name mangling and to drop unused variables and functions.
+
+- `warnings` (default `false`) — pass `true` to return compressor warnings
+  in `result.warnings`. Use the value `"verbose"` for more detailed warnings.
 
 ## Minify options structure
 
@@ -631,7 +631,10 @@ If you're using the `X-SourceMap` header instead, you can just omit `sourceMap.u
 
 - `drop_debugger` (default: `true`) -- remove `debugger;` statements
 
-- `evaluate` (default: `true`) -- attempt to evaluate constant expressions
+- `evaluate` (default: `true`) -- Evaluate expression for shorter constant
+  representation. Pass `"eager"` to always replace function calls whenever
+  possible, or a positive integer to specify an upper bound for each individual
+  evaluation in number of characters.
 
 - `expression` (default: `false`) -- Pass `true` to preserve completion values
   from terminal statements without `return`, e.g. in bookmarklets.
@@ -682,6 +685,8 @@ If you're using the `X-SourceMap` header instead, you can just omit `sourceMap.u
   where the return value is discarded, to avoid the parens that the
   code generator would insert.
 
+- `objects` (default: `true`) -- compact duplicate keys in object literals.
+
 - `passes` (default: `1`) -- The maximum number of times to run compress.
   In some cases more than one pass leads to further compressed code.  Keep in
   mind more passes will take more time.

appveyor.yml

@@ -1,74 +1,5 @@
 build: off
-cache:
-  - tmp
 matrix:
   fast_finish: true
-environment:
-  matrix:
-    - NODE: 0.10
-      TYPE: compress
-    - NODE: 0.10
-      TYPE: mocha
-    - NODE: 0.10
-      TYPE: release/benchmark
-    - NODE: 0.10
-      TYPE: release/jetstream
-    - NODE: 0.12
-      TYPE: compress
-    - NODE: 0.12
-      TYPE: mocha
-    - NODE: 0.12
-      TYPE: release/benchmark
-    - NODE: 0.12
-      TYPE: release/jetstream
-    - NODE: 4
-      TYPE: compress
-    - NODE: 4
-      TYPE: mocha
-    - NODE: 4
-      TYPE: release/benchmark
-    - NODE: 4
-      TYPE: release/jetstream
-    - NODE: 6
-      TYPE: compress
-    - NODE: 6
-      TYPE: mocha
-    - NODE: 6
-      TYPE: release/benchmark
-    - NODE: 6
-      TYPE: release/jetstream
-    - NODE: 8
-      TYPE: compress
-    - NODE: 8
-      TYPE: mocha
-    - NODE: 8
-      TYPE: release/benchmark
-    - NODE: 8
-      TYPE: release/jetstream
-    - NODE: 10
-      TYPE: compress
-    - NODE: 10
-      TYPE: mocha
-    - NODE: 10
-      TYPE: release/benchmark
-    - NODE: 10
-      TYPE: release/jetstream
-    - NODE: latest
-      TYPE: compress
-    - NODE: latest
-      TYPE: mocha
-    - NODE: latest
-      TYPE: release/benchmark
-    - NODE: latest
-      TYPE: release/jetstream
-install:
-  - git clone --branch v1.5.2 --depth 1 https://github.com/jasongin/nvs.git %LOCALAPPDATA%\nvs
-  - set PATH=%LOCALAPPDATA%\nvs;%PATH%
-  - nvs --version
-  - nvs add node/%NODE%
-  - nvs use node/%NODE%
-  - node --version
-  - npm --version --no-update-notifier
-  - npm install --no-audit --no-optional --no-save --no-update-notifier
 test_script:
-  - node test/%TYPE%
+  - echo No longer in use

lib/minify.js

@@ -252,7 +252,7 @@ function minify(files, options) {
                 properties: 1e-3 * (timings.output - timings.properties),
                 output: 1e-3 * (timings.end - timings.output),
                 total: 1e-3 * (timings.end - timings.start)
-            }
+            };
         }
         if (warnings.length) {
             result.warnings = warnings;

lib/output.js

@@ -711,16 +711,23 @@ function OutputStream(options) {
 
     PARENS(AST_Sequence, function(output) {
         var p = output.parent();
-        return p instanceof AST_Call             // (foo, bar)() or foo(1, (2, 3), 4)
-            || p instanceof AST_Unary            // !(foo, bar, baz)
-            || p instanceof AST_Binary           // 1 + (2, 3) + 4 ==> 8
-            || p instanceof AST_VarDef           // var a = (1, 2), b = a + a; ==> b == 4
-            || p instanceof AST_PropAccess       // (1, {foo:2}).foo or (1, {foo:2})["foo"] ==> 2
-            || p instanceof AST_Array            // [ 1, (2, 3), 4 ] ==> [ 1, 3, 4 ]
-            || p instanceof AST_ObjectProperty   // { foo: (1, 2) }.foo ==> 2
-            || p instanceof AST_Conditional      /* (false, true) ? (a = 10, b = 20) : (c = 30)
-                                                  * ==> 20 (side effect, set a := 10 and b := 20) */
-        ;
+            // (foo, bar)() or foo(1, (2, 3), 4)
+        return p instanceof AST_Call
+            // !(foo, bar, baz)
+            || p instanceof AST_Unary
+            // 1 + (2, 3) + 4 ==> 8
+            || p instanceof AST_Binary
+            // var a = (1, 2), b = a + a; ==> b == 4
+            || p instanceof AST_VarDef
+            // (1, {foo:2}).foo or (1, {foo:2})["foo"] ==> 2
+            || p instanceof AST_PropAccess && p.expression === this
+            // [ 1, (2, 3), 4 ] ==> [ 1, 3, 4 ]
+            || p instanceof AST_Array
+            // { foo: (1, 2) }.foo ==> 2
+            || p instanceof AST_ObjectProperty
+            // (false, true) ? (a = 10, b = 20) : (c = 30)
+            // ==> 20 (side effect, set a := 10 and b := 20)
+            || p instanceof AST_Conditional;
     });
 
     PARENS(AST_Binary, function(output) {

lib/parse.js

@@ -787,20 +787,18 @@ function parse($TEXT, options) {
         handle_regexp();
         switch (S.token.type) {
           case "string":
-            if (S.in_directives) {
-                var token = peek();
-                if (S.token.raw.indexOf("\\") == -1
-                    && (is_token(token, "punc", ";")
-                        || is_token(token, "punc", "}")
-                        || has_newline_before(token)
-                        || is_token(token, "eof"))) {
-                    S.input.add_directive(S.token.value);
+            var dir = S.in_directives;
+            var body = expression(true);
+            if (dir) {
+                var token = body.start;
+                if (body instanceof AST_String && token.raw.indexOf("\\") == -1) {
+                    S.input.add_directive(token.value);
                 } else {
-                    S.in_directives = false;
+                    S.in_directives = dir = false;
                 }
             }
-            var dir = S.in_directives, stat = simple_statement();
-            return dir ? new AST_Directive(stat.body) : stat;
+            semicolon();
+            return dir ? new AST_Directive(body) : new AST_SimpleStatement({ body: body });
           case "num":
           case "regexp":
           case "operator":
@@ -965,8 +963,10 @@ function parse($TEXT, options) {
         return new AST_LabeledStatement({ body: stat, label: label });
     }
 
-    function simple_statement(tmp) {
-        return new AST_SimpleStatement({ body: (tmp = expression(true), semicolon(), tmp) });
+    function simple_statement() {
+        var body = expression(true);
+        semicolon();
+        return new AST_SimpleStatement({ body: body });
     }
 
     function break_cont(type) {
@@ -1253,6 +1253,7 @@ function parse($TEXT, options) {
                 var ex = expression(true);
                 var len = start.comments_before.length;
                 [].unshift.apply(ex.start.comments_before, start.comments_before);
+                start.comments_before.length = 0;
                 start.comments_before = ex.start.comments_before;
                 start.comments_before_length = len;
                 if (len == 0 && start.comments_before.length > 0) {
@@ -1268,6 +1269,7 @@ function parse($TEXT, options) {
                 var end = prev();
                 end.comments_before = ex.end.comments_before;
                 [].push.apply(ex.end.comments_after, end.comments_after);
+                end.comments_after.length = 0;
                 end.comments_after = ex.end.comments_after;
                 ex.end = end;
                 if (ex instanceof AST_Call) mark_pure(ex);

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.6.5",
+  "version": "3.7.1",
   "engines": {
     "node": ">=0.8.0"
   },

test/compress/assignment.js

@@ -290,26 +290,60 @@ increment_decrement_2: {
     expect_stdout: "42"
 }
 
-issue_3375: {
+issue_3375_1: {
     options = {
         assignments: true,
         reduce_vars: true,
     }
     input: {
-        console.log(typeof function(b) {
+        function p(o) {
+            console.log(typeof o, o);
+        }
+        p(function(b) {
             var a = b += 1;
             --b;
             return a;
         }("object"));
     }
     expect: {
-        console.log(typeof function(b) {
+        function p(o) {
+            console.log(typeof o, o);
+        }
+        p(function(b) {
             var a = b += 1;
             --b;
             return a;
         }("object"));
     }
-    expect_stdout: "string"
+    expect_stdout: "string object1"
+}
+
+issue_3375_2: {
+    options = {
+        assignments: true,
+        reduce_vars: true,
+    }
+    input: {
+        function p(o) {
+            console.log(typeof o, o);
+        }
+        p(function(b) {
+            var a = b -= 1;
+            --b;
+            return a;
+        }("object"));
+    }
+    expect: {
+        function p(o) {
+            console.log(typeof o, o);
+        }
+        p(function(b) {
+            var a = --b;
+            --b;
+            return a;
+        }("object"));
+    }
+    expect_stdout: "number NaN"
 }
 
 issue_3427: {

test/compress/collapse_vars.js

@@ -669,7 +669,7 @@ collapse_vars_throw: {
     expect_stdout: "13"
 }
 
-collapse_vars_switch: {
+collapse_vars_switch_1: {
     options = {
         booleans: true,
         collapse_vars: true,
@@ -721,6 +721,31 @@ collapse_vars_switch: {
     }
 }
 
+collapse_vars_switch_2: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var c = 0;
+        (function(b) {
+            switch (b && [ b = 0, (c++, 0) ]) {
+              case c = 1 + c:
+            }
+        })();
+        console.log(c);
+    }
+    expect: {
+        var c = 0;
+        (function(b) {
+            switch (b && [ b = 0, (c++, 0) ]) {
+              case c = 1 + c:
+            }
+        })();
+        console.log(c);
+    }
+    expect_stdout: "1"
+}
+
 collapse_vars_assignment: {
     options = {
         booleans: true,
@@ -1234,7 +1259,7 @@ collapse_vars_try: {
     }
 }
 
-collapse_vars_array: {
+collapse_vars_array_1: {
     options = {
         booleans: true,
         collapse_vars: true,
@@ -1280,7 +1305,57 @@ collapse_vars_array: {
     }
 }
 
-collapse_vars_object: {
+collapse_vars_array_2: {
+    options = {
+        collapse_vars: true,
+        unused: true,
+    }
+    input: {
+        function f(a) {
+            var b;
+            return [ (b = a, b.g()) ];
+        }
+        console.log(f({
+            g: function() {
+                return "PASS";
+            }
+        })[0]);
+    }
+    expect: {
+        function f(a) {
+            return [ a.g() ];
+        }
+        console.log(f({
+            g: function() {
+                return "PASS";
+            }
+        })[0]);
+    }
+    expect_stdout: "PASS"
+}
+
+collapse_vars_array_3: {
+    options = {
+        collapse_vars: true,
+        unused: true,
+    }
+    input: {
+        function f(a) {
+            var b;
+            return [ b = a, b, b ];
+        }
+        console.log(f().length);
+    }
+    expect: {
+        function f(a) {
+            return [ a, a, a ];
+        }
+        console.log(f().length);
+    }
+    expect_stdout: "3"
+}
+
+collapse_vars_object_1: {
     options = {
         booleans: true,
         collapse_vars: true,
@@ -1360,6 +1435,68 @@ collapse_vars_object: {
     }
 }
 
+collapse_vars_object_2: {
+    options = {
+        collapse_vars: true,
+        unused: true,
+    }
+    input: {
+        function f(a) {
+            var b;
+            return {
+                p: (b = a, b.g())
+            };
+        }
+        console.log(f({
+            g: function() {
+                return "PASS";
+            }
+        }).p);
+    }
+    expect: {
+        function f(a) {
+            return {
+                p: a.g()
+            };
+        }
+        console.log(f({
+            g: function() {
+                return "PASS";
+            }
+        }).p);
+    }
+    expect_stdout: "PASS"
+}
+
+collapse_vars_object_3: {
+    options = {
+        collapse_vars: true,
+        unused: true,
+    }
+    input: {
+        function f(a) {
+            var b;
+            return {
+                p: b = a,
+                q: b,
+                r: b,
+            };
+        }
+        console.log(f("PASS").r);
+    }
+    expect: {
+        function f(a) {
+            return {
+                p: a,
+                q: a,
+                r: a,
+            };
+        }
+        console.log(f("PASS").r);
+    }
+    expect_stdout: "PASS"
+}
+
 collapse_vars_eval_and_with: {
     options = {
         booleans: true,
@@ -1458,7 +1595,7 @@ collapse_vars_constants: {
         function f3(x) {
             var b = x.prop;
             sideeffect1();
-            return b + (function() { return -9; })();
+            return b + -9;
         }
     }
 }
@@ -1633,21 +1770,32 @@ collapse_vars_regexp: {
                 return rx.exec(s);
             };
         }
+        function f3() {
+            var rx = /ab*/g;
+            return function() {
+                return rx;
+            };
+        }
         (function() {
             var result;
-            var s = 'acdabcdeabbb';
+            var s = "acdabcdeabbb";
             var rx = /ab*/g;
-            while (result = rx.exec(s)) {
+            while (result = rx.exec(s))
                 console.log(result[0]);
-            }
         })();
         (function() {
             var result;
-            var s = 'acdabcdeabbb';
+            var s = "acdabcdeabbb";
             var rx = f2();
-            while (result = rx(s)) {
+            while (result = rx(s))
+                console.log(result[0]);
+        })();
+        (function() {
+            var result;
+            var s = "acdabcdeabbb";
+            var rx = f3();
+            while (result = rx().exec(s))
                 console.log(result[0]);
-            }
         })();
     }
     expect: {
@@ -1660,6 +1808,12 @@ collapse_vars_regexp: {
                 return rx.exec(s);
             };
         }
+        function f3() {
+            var rx = /ab*/g;
+            return function() {
+                return rx;
+            };
+        }
         (function() {
             var result, rx = /ab*/g;
             while (result = rx.exec("acdabcdeabbb"))
@@ -1670,8 +1824,23 @@ collapse_vars_regexp: {
             while (result = rx("acdabcdeabbb"))
                 console.log(result[0]);
         })();
+        (function() {
+            var result, rx = f3();
+            while (result = rx().exec("acdabcdeabbb"))
+                console.log(result[0]);
+        })();
     }
-    expect_stdout: true
+    expect_stdout: [
+        "a",
+        "ab",
+        "abbb",
+        "a",
+        "ab",
+        "abbb",
+        "a",
+        "ab",
+        "abbb",
+    ]
 }
 
 issue_1537: {
@@ -3852,10 +4021,9 @@ issue_2436_9: {
     expect: {
         var o = console;
         console.log({
-            x: (c = o).a,
-            y: c.b,
+            x: o.a,
+            y: o.b,
         });
-        var c;
     }
     expect_stdout: true
 }
@@ -5748,7 +5916,7 @@ issue_3215_1: {
         }());
     }
     expect: {
-        console.log("number");
+        console.log(typeof 42);
     }
     expect_stdout: "number"
 }
@@ -6134,7 +6302,7 @@ assign_left: {
     }
     expect: {
         console.log(function(a, b) {
-            (b = a).p.q = "PASS";
+            a.p.q = "PASS";
             return a.p.q;
         }({p: {}}));
     }
@@ -6147,12 +6315,12 @@ sub_property: {
     }
     input: {
         console.log(function(a, b) {
-            return a[(b = a, b.length - 1)];
+            return a[b = a, b.length - 1];
         }([ "FAIL", "PASS" ]));
     }
     expect: {
         console.log(function(a, b) {
-            return a[(b = a).length - 1];
+            return a[a.length - 1];
         }([ "FAIL", "PASS" ]));
     }
     expect_stdout: "PASS"
@@ -6238,7 +6406,7 @@ issue_3439_2: {
     expect_stdout: "number"
 }
 
-cond_sequence_return: {
+cond_sequence_return_1: {
     options = {
         collapse_vars: true,
     }
@@ -6259,6 +6427,27 @@ cond_sequence_return: {
     expect_stdout: "2"
 }
 
+cond_sequence_return_2: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        console.log(function(n) {
+            var c = 0;
+            for (var k in [0, 1])
+                if (c += 1, k == n) return c;
+        }(1));
+    }
+    expect: {
+        console.log(function(n) {
+            var c = 0;
+            for (var k in [0, 1])
+                if (c += 1, k == n) return c;
+        }(1));
+    }
+    expect_stdout: "2"
+}
+
 issue_3520: {
     options = {
         collapse_vars: true,
@@ -6348,3 +6537,431 @@ issue_3526_2: {
     }
     expect_stdout: "PASS"
 }
+
+issue_3562: {
+    options = {
+        collapse_vars: true,
+        conditionals: true,
+        sequences: true,
+    }
+    input: {
+        function f(a) {
+            console.log("PASS", a);
+        }
+        function g(b) {
+            console.log("FAIL", b);
+        }
+        var h;
+        var c;
+        if (console) {
+            h = f;
+            c = "PASS";
+        } else {
+            h = g;
+            c = "FAIL";
+        }
+        h(c);
+    }
+    expect: {
+        function f(a) {
+            console.log("PASS", a);
+        }
+        function g(b) {
+            console.log("FAIL", b);
+        }
+        var h;
+        var c;
+        c = console ? (h = f, "PASS") : (h = g, "FAIL"),
+        h(c);
+    }
+    expect_stdout: "PASS PASS"
+}
+
+dot_throw_assign_sequence: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var a = "FAIL";
+        try {
+            var b;
+            b[0] = (a = "PASS", 0);
+            a = 1 + a;
+        } catch (c) {
+        }
+        console.log(a);
+    }
+    expect: {
+        var a = "FAIL";
+        try {
+            var b;
+            b[0] = (a = "PASS", 0);
+            a = 1 + a;
+        } catch (c) {
+        }
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+}
+
+call_assign_order: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var a, b = 1, c = 0, log = console.log;
+        (function() {
+            a = b = "PASS";
+        })((b = "FAIL", c++));
+        log(a, b);
+    }
+    expect: {
+        var a, b = 1, c = 0, log = console.log;
+        (function() {
+            a = b = "PASS";
+        })((b = "FAIL", c++));
+        log(a, b);
+    }
+    expect_stdout: "PASS PASS"
+}
+
+issue_3573: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var c = 0;
+        (function(b) {
+            while (--b) {
+                b = NaN;
+                switch (0 / this < 0) {
+                  case c++, false:
+                  case c++, NaN:
+                }
+            }
+        })(3);
+        console.log(c);
+    }
+    expect: {
+        var c = 0;
+        (function(b) {
+            while (--b) {
+                b = NaN;
+                switch (0 / this < 0) {
+                  case c++, false:
+                  case c++, NaN:
+                }
+            }
+        })(3);
+        console.log(c);
+    }
+    expect_stdout: "1"
+}
+
+issue_3581_1: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var a = "PASS", b = "FAIL";
+        try {
+            b = "PASS";
+            if (a) throw 0;
+            b = 1 + b;
+            a = "FAIL";
+        } catch (e) {}
+        console.log(a, b);
+    }
+    expect: {
+        var a = "PASS", b = "FAIL";
+        try {
+            b = "PASS";
+            if (a) throw 0;
+            b = 1 + b;
+            a = "FAIL";
+        } catch (e) {}
+        console.log(a, b);
+    }
+    expect_stdout: "PASS PASS"
+}
+
+issue_3581_2: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        (function() {
+            var a = "PASS", b = "FAIL";
+            try {
+                b = "PASS";
+                if (a) return;
+                b = 1 + b;
+                a = "FAIL";
+            } finally {
+                console.log(a, b);
+            }
+        })();
+    }
+    expect: {
+        (function() {
+            var a = "PASS", b = "FAIL";
+            try {
+                b = "PASS";
+                if (a) return;
+                b = 1 + b;
+                a = "FAIL";
+            } finally {
+                console.log(a, b);
+            }
+        })();
+    }
+    expect_stdout: "PASS PASS"
+}
+
+issue_3596: {
+    options = {
+        collapse_vars: true,
+        pure_getters: "strict",
+    }
+    input: {
+        console.log(function f() {
+            return f[[ ][f.undefined = 42, 0]] += !1;
+        }());
+    }
+    expect: {
+        console.log(function f() {
+            return f[[ ][f.undefined = 42, 0]] += !1;
+        }());
+    }
+    expect_stdout: "42"
+}
+
+local_value_replacement: {
+    options = {
+        collapse_vars: true,
+        unused: true,
+    }
+    input: {
+        function f(a, b) {
+            (a = b) && g(a);
+        }
+        function g(c) {
+            console.log(c);
+        }
+        f("FAIL", "PASS");
+    }
+    expect: {
+        function f(a, b) {
+            b && g(b);
+        }
+        function g(c) {
+            console.log(c);
+        }
+        f("FAIL", "PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+array_in_object_1: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var a = 2;
+        console.log({
+            p: [ a, a-- ],
+            q: a,
+        }.q, a);
+    }
+    expect: {
+        var a = 2;
+        console.log({
+            p: [ a, a-- ],
+            q: a,
+        }.q, a);
+    }
+    expect_stdout: "1 1"
+}
+
+array_in_object_2: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var a = 2;
+        console.log({
+            p: [ a, (a--, 42) ],
+            q: a,
+        }.q, a);
+    }
+    expect: {
+        var a = 2;
+        console.log({
+            p: [ a, 42 ],
+            q: --a,
+        }.q, a);
+    }
+    expect_stdout: "1 1"
+}
+
+array_in_conditional: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var a = 1, b = 2, c;
+        console.log(c && [ b = a ], a, b);
+    }
+    expect: {
+        var a = 1, b = 2, c;
+        console.log(c && [ b = a ], a, b);
+    }
+    expect_stdout: "undefined 1 2"
+}
+
+object_in_conditional: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var a = 1, b = 2, c;
+        console.log(c && {
+            p: b = a
+        }, a, b);
+    }
+    expect: {
+        var a = 1, b = 2, c;
+        console.log(c && {
+            p: b = a
+        }, a, b);
+    }
+    expect_stdout: "undefined 1 2"
+}
+
+sequence_in_iife_1: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var a = "foo", b = 42;
+        (function() {
+            var c = (b = a, b);
+        })();
+        console.log(a, b);
+    }
+    expect: {
+        var a = "foo", b = 42;
+        (function() {
+            var c = b = a;
+        })();
+        console.log(a, b);
+    }
+    expect_stdout: "foo foo"
+}
+
+sequence_in_iife_2: {
+    options = {
+        collapse_vars: true,
+        inline: true,
+        passes: 2,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        var a = "foo", b = 42;
+        (function() {
+            var c = (b = a, b);
+        })();
+        console.log(a, b);
+    }
+    expect: {
+        var a = "foo", b = 42;
+        console.log(a, a);
+    }
+    expect_stdout: "foo foo"
+}
+
+retain_assign: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var a = 42, b, c = "FAIL";
+        b = a;
+        b++ && (c = "PASS");
+        console.log(c);
+    }
+    expect: {
+        var a = 42, b, c = "FAIL";
+        b = a;
+        b++ && (c = "PASS");
+        console.log(c);
+    }
+    expect_stdout: "PASS"
+}
+
+getter_side_effect: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var c = "FAIL";
+        (function(a) {
+            var b;
+            (b = a) && {
+                get foo() {
+                    a = 0;
+                }
+            }.foo;
+            b && (c = "PASS");
+        })(42);
+        console.log(c);
+    }
+    expect: {
+        var c = "FAIL";
+        (function(a) {
+            var b;
+            (b = a) && {
+                get foo() {
+                    a = 0;
+                }
+            }.foo;
+            b && (c = "PASS");
+        })(42);
+        console.log(c);
+    }
+    expect_stdout: "PASS"
+}
+
+setter_side_effect: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var c = "FAIL";
+        (function(a) {
+            var b;
+            (b = a) && ({
+                set foo(v) {
+                    a = v;
+                }
+            }.foo = 0);
+            b && (c = "PASS");
+        })(42);
+        console.log(c);
+    }
+    expect: {
+        var c = "FAIL";
+        (function(a) {
+            var b;
+            (b = a) && ({
+                set foo(v) {
+                    a = v;
+                }
+            }.foo = 0);
+            b && (c = "PASS");
+        })(42);
+        console.log(c);
+    }
+    expect_stdout: "PASS"
+}

test/compress/conditionals.js

@@ -161,6 +161,24 @@ ifs_6: {
     }
 }
 
+ifs_7: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        if (A); else;
+        if (A) while (B); else;
+        if (A); else while (C);
+        if (A) while (B); else while (C);
+    }
+    expect: {
+        A;
+        if (A) while (B);
+        if (!A) while (C);
+        if (A) while (B); else while (C);
+    }
+}
+
 cond_1: {
     options = {
         conditionals: true,
@@ -1471,3 +1489,29 @@ angularjs_chain: {
         }
     }
 }
+
+issue_3576: {
+    options = {
+        conditionals: true,
+        evaluate: true,
+        pure_getters: "strict",
+        reduce_vars: true,
+    }
+    input: {
+        var c = "FAIL";
+        (function(a) {
+            (a = -1) ? (a && (a.a = 0)) : (a && (a.a = 0));
+            a && a[c = "PASS"]++;
+        })();
+        console.log(c);
+    }
+    expect: {
+        var c = "FAIL";
+        (function(a) {
+            a = -1, a, a.a = 0;
+            a, a[c = "PASS"]++;
+        })();
+        console.log(c);
+    }
+    expect_stdout: "PASS"
+}

test/compress/dead-code.js

@@ -892,9 +892,7 @@ issue_2860_1: {
         }());
     }
     expect: {
-        console.log(function(a) {
-            return 1 ^ a;
-        }());
+        console.log(1);
     }
     expect_stdout: "1"
 }
@@ -1013,3 +1011,119 @@ issue_3406: {
     }
     expect_stdout: "true"
 }
+
+function_assign: {
+    options = {
+        dead_code: true,
+    }
+    input: {
+        console.log(function() {
+            var a = "PASS";
+            function h(c) {
+                return c;
+            }
+            h.p = function(b) {
+                return b;
+            }.p = a;
+            return h;
+        }().p);
+    }
+    expect: {
+        console.log(function() {
+            var a = "PASS";
+            function h(c) {
+                return c;
+            }
+            h.p = a;
+            return h;
+        }().p);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_3552: {
+    options = {
+        dead_code: true,
+        pure_getters: "strict",
+    }
+    input: {
+        var a = "PASS";
+        (function() {
+            (1..p += 42) && (a = "FAIL");
+        })();
+        console.log(a);
+    }
+    expect: {
+        var a = "PASS";
+        (function() {
+            (1..p += 42) && (a = "FAIL");
+        })();
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+}
+
+unreachable_assign: {
+    options = {
+        dead_code: true,
+    }
+    input: {
+        console.log(A = "P" + (A = "A" + (B = "S" + (A = B = "S"))), A, B);
+    }
+    expect: {
+        console.log(A = "P" + "A" + (B = "S" + "S"), A, B);
+    }
+    expect_stdout: "PASS PASS SS"
+}
+
+catch_return_assign: {
+    options = {
+        dead_code: true,
+    }
+    input: {
+        console.log(function() {
+            try {
+                throw "FAIL";
+            } catch (e) {
+                return e = "PASS";
+            }
+        }());
+    }
+    expect: {
+        console.log(function() {
+            try {
+                throw "FAIL";
+            } catch (e) {
+                return "PASS";
+            }
+        }());
+    }
+    expect_stdout: "PASS"
+}
+
+issue_3578: {
+    options = {
+        dead_code: true,
+    }
+    input: {
+        var a = "FAIL", b, c;
+        try {
+            b = c.p = b = 0;
+        } catch (e) {
+            b += 42;
+            b && (a = "PASS");
+        }
+        console.log(a);
+    }
+    expect: {
+        var a = "FAIL", b, c;
+        try {
+            b = c.p = b = 0;
+        } catch (e) {
+            b += 42;
+            b && (a = "PASS");
+        }
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+}

test/compress/directives.js

@@ -0,0 +1,95 @@
+simple_statement_is_not_a_directive: {
+    input: {
+        "use strict"
+            .split(" ")
+            .forEach(function(s) {
+                console.log(s);
+            });
+        console.log(!this); // is strict mode?
+        (function() {
+            "directive"
+            ""
+            "use strict"
+            "hello world"
+                .split(" ")
+                .forEach(function(s) {
+                    console.log(s);
+                });
+            console.log(!this); // is strict mode?
+        })();
+    }
+    expect: {
+        "use strict".split(" ").forEach(function(s) {
+            console.log(s);
+        });
+        console.log(!this);
+        (function() {
+            "directive";
+            "";
+            "use strict";
+            "hello world".split(" ").forEach(function(s) {
+                console.log(s);
+            });
+            console.log(!this);
+        })();
+    }
+    expect_stdout: [
+        "use",
+        "strict",
+        "false",
+        "hello",
+        "world",
+        "true",
+    ]
+}
+
+drop_lone_use_strict: {
+    options = {
+        directives: true,
+        side_effects: true,
+    }
+    input: {
+        function f1() {
+            "use strict";
+        }
+        function f2() {
+            "use strict";
+            function f3() {
+                "use strict";
+            }
+        }
+        (function f4() {
+            "use strict";
+        })();
+    }
+    expect: {
+        function f1() {
+        }
+        function f2() {
+            "use strict";
+            function f3() {
+            }
+        }
+    }
+}
+
+issue_3166: {
+    options = {
+        directives: true,
+    }
+    input: {
+        "foo";
+        "use strict";
+        function f() {
+            "use strict";
+            "bar";
+            "use asm";
+        }
+    }
+    expect: {
+        "use strict";
+        function f() {
+            "use asm";
+        }
+    }
+}

test/compress/drop-unused.js

@@ -1019,14 +1019,21 @@ delete_assign_1: {
         console.log(delete (a = 0 / 0));
     }
     expect: {
-        console.log((void 0, !0));
-        console.log((void 0, !0));
-        console.log((1 / 0, !0));
-        console.log((1 / 0, !0));
-        console.log((NaN, !0));
-        console.log((NaN, !0));
+        console.log(!0);
+        console.log(!0);
+        console.log(!0);
+        console.log(!0);
+        console.log(!0);
+        console.log(!0);
     }
-    expect_stdout: true
+    expect_stdout: [
+        "true",
+        "true",
+        "true",
+        "true",
+        "true",
+        "true",
+    ]
 }
 
 delete_assign_2: {
@@ -1047,14 +1054,21 @@ delete_assign_2: {
         console.log(delete (a = 0 / 0));
     }
     expect: {
-        console.log((void 0, !0));
-        console.log((void 0, !0));
-        console.log((Infinity, !0));
-        console.log((1 / 0, !0));
-        console.log((NaN, !0));
-        console.log((NaN, !0));
+        console.log(!0);
+        console.log(!0);
+        console.log(!0);
+        console.log(!0);
+        console.log(!0);
+        console.log(!0);
     }
-    expect_stdout: true
+    expect_stdout: [
+        "true",
+        "true",
+        "true",
+        "true",
+        "true",
+        "true",
+    ]
 }
 
 drop_var: {
@@ -1635,7 +1649,7 @@ double_assign_2: {
     }
     expect: {
         for (var i = 0; i < 2; i++)
-            void 0, a = {}, console.log(a);
+            a = {}, console.log(a);
         var a;
     }
 }
@@ -1716,7 +1730,7 @@ issue_2768: {
     }
     expect: {
         var a = "FAIL";
-        var c = (d = a, 0, void (d && (a = "PASS")));
+        var c = (d = a, void (d && (a = "PASS")));
         var d;
         console.log(a, typeof c);
     }
@@ -2187,3 +2201,68 @@ issue_3515_3: {
     }
     expect_stdout: "PASS"
 }
+
+function_assign: {
+    options = {
+        pure_getters: "strict",
+        reduce_vars: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        console.log(function() {
+            var a = "PASS";
+            function g(b) {
+                return b;
+            }
+            g.p = a;
+            function h(c) {
+                return c;
+            }
+            h.p = a;
+            return h;
+        }().p);
+    }
+    expect: {
+        console.log(function() {
+            var a = "PASS";
+            function h(c) {
+                return c;
+            }
+            h.p = a;
+            return h;
+        }().p);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_3598: {
+    options = {
+        collapse_vars: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        var a = "FAIL";
+        try {
+            (function() {
+                var b = void 0;
+                a = "PASS";
+                c.p = 0;
+                var c = b[!1];
+            })();
+        } catch (e) {}
+        console.log(a);
+    }
+    expect: {
+        var a = "FAIL";
+        try {
+            (function() {
+                a = "PASS";
+                var c = (void (c.p = 0))[!1];
+            })();
+        } catch (e) {}
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+}

test/compress/evaluate.js

@@ -237,22 +237,39 @@ unsafe_constant: {
         unsafe: true,
     }
     input: {
-        console.log(
-            true.a,
-            false.a,
-            null.a,
-            undefined.a
-        );
+        console.log(true.a, false.a);
+        console.log(true.valueOf(), false.valueOf());
+        try {
+            console.log(null.a);
+        } catch (e) {
+            console.log("PASS");
+        }
+        try {
+            console.log(undefined.a);
+        } catch (e) {
+            console.log("PASS");
+        }
     }
     expect: {
-        console.log(
-            void 0,
-            false.a,
-            null.a,
-            (void 0).a
-        );
+        console.log(void 0, void 0);
+        console.log(true, false);
+        try {
+            console.log(null.a);
+        } catch (e) {
+            console.log("PASS");
         }
-    expect_stdout: true
+        try {
+            console.log((void 0).a);
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect_stdout: [
+        "undefined undefined",
+        "true false",
+        "PASS",
+        "PASS",
+    ]
 }
 
 unsafe_object: {
@@ -1757,3 +1774,390 @@ issue_3387_2: {
     }
     expect_stdout: "NaN"
 }
+
+simple_function_1: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function sum(a, b) {
+            return a + b;
+        }
+        console.log(sum(1, 2) * sum(3, 4));
+    }
+    expect: {
+        console.log(21);
+    }
+    expect_stdout: "21"
+}
+
+simple_function_2: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var sum = function(a, b) {
+            return a + b;
+        }
+        console.log(sum(1, 2) * sum(3, 4));
+    }
+    expect: {
+        console.log(21);
+    }
+    expect_stdout: "21"
+}
+
+recursive_function_1: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function factorial(a) {
+            return a > 0 ? a * factorial(a - 1) : 1;
+        }
+        console.log(factorial(5));
+    }
+    expect: {
+        console.log(function factorial(a) {
+            return a > 0 ? a * factorial(a - 1) : 1;
+        }(5));
+    }
+    expect_stdout: "120"
+}
+
+recursive_function_2: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var factorial = function(a) {
+            return a > 0 ? a * factorial(a - 1) : 1;
+        }
+        console.log(factorial(5));
+    }
+    expect: {
+        var factorial = function(a) {
+            return a > 0 ? a * factorial(a - 1) : 1;
+        }
+        console.log(factorial(5));
+    }
+    expect_stdout: "120"
+}
+
+issue_3558: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+    }
+    input: {
+        function f(a) {
+            return 1 + --a;
+        }
+        console.log(f(true), f(false));
+    }
+    expect: {
+        function f(a) {
+            return 1 + --a;
+        }
+        console.log(1, 0);
+    }
+    expect_stdout: "1 0"
+}
+
+issue_3568: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unsafe: true,
+    }
+    input: {
+        var a = 0;
+        function f(b) {
+            return b && b.p;
+        }
+        console.log(f(++a + f()));
+    }
+    expect: {
+        var a = 0;
+        function f(b) {
+            return b && b.p;
+        }
+        console.log(NaN);
+    }
+    expect_stdout: "NaN"
+}
+
+conditional_function: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+    }
+    input: {
+        function f(a) {
+            return a && "undefined" != typeof A ? A : 42;
+        }
+        console.log(f(0), f(1));
+    }
+    expect: {
+        function f(a) {
+            return a && "undefined" != typeof A ? A : 42;
+        }
+        console.log(42, f(1));
+    }
+    expect_stdout: "42 42"
+}
+
+best_of_evaluate: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function d(x, y) {
+            return x / y;
+        }
+        console.log(0 / 3, 1 / 64, 4 / 7, 7 / 7);
+        console.log(d(0, 3), d(1, 64), d(4, 7), d(7, 7));
+    }
+    expect: {
+        function d(x, y) {
+            return x / y;
+        }
+        console.log(0, 1 / 64, 4 / 7, 1);
+        console.log(0, .015625, d(4, 7), 1);
+    }
+    expect_stdout: [
+        "0 0.015625 0.5714285714285714 1",
+        "0 0.015625 0.5714285714285714 1",
+    ]
+}
+
+eager_evaluate: {
+    options = {
+        evaluate: "eager",
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function d(x, y) {
+            return x / y;
+        }
+        console.log(0 / 3, 1 / 64, 4 / 7, 7 / 7);
+        console.log(d(0, 3), d(1, 64), d(4, 7), d(7, 7));
+    }
+    expect: {
+        console.log(0, .015625, .5714285714285714, 1);
+        console.log(0, .015625, .5714285714285714, 1);
+    }
+    expect_stdout: [
+        "0 0.015625 0.5714285714285714 1",
+        "0 0.015625 0.5714285714285714 1",
+    ]
+}
+
+threshold_evaluate_default: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function b(x) {
+            return x + x + x;
+        }
+        console.log(b("1"), b(2), b(b(b("ABCDEFGHIJK"))));
+    }
+    expect: {
+        function b(x) {
+            return x + x + x;
+        }
+        console.log("111", 6, b(b(b("ABCDEFGHIJK"))));
+    }
+    expect_stdout: "111 6 ABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJK"
+}
+
+threshold_evaluate_30: {
+    options = {
+        evaluate: 30,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function b(x) {
+            return x + x + x;
+        }
+        console.log(b("1"), b(2), b(b(b("ABCDEFGHIJK"))));
+    }
+    expect: {
+        function b(x) {
+            return x + x + x;
+        }
+        console.log("111", 6, b(b("ABCDEFGHIJKABCDEFGHIJKABCDEFGHIJK")));
+    }
+    expect_stdout: "111 6 ABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJK"
+}
+
+threshold_evaluate_100: {
+    options = {
+        evaluate: 100,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function b(x) {
+            return x + x + x;
+        }
+        console.log(b("1"), b(2), b(b(b("ABCDEFGHIJK"))));
+    }
+    expect: {
+        function b(x) {
+            return x + x + x;
+        }
+        console.log("111", 6, b("ABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJK"));
+    }
+    expect_stdout: "111 6 ABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJK"
+}
+
+threshold_evaluate_999: {
+    options = {
+        evaluate: 999,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function b(x) {
+            return x + x + x;
+        }
+        console.log(b("1"), b(2), b(b(b("ABCDEFGHIJK"))));
+    }
+    expect: {
+        console.log("111", 6, "ABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJK");
+    }
+    expect_stdout: "111 6 ABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJKABCDEFGHIJK"
+}
+
+collapse_vars_regexp: {
+    options = {
+        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,
+        reduce_funcs: true,
+        reduce_vars: true,
+        side_effects: true,
+        unsafe_regexp: true,
+        unused: true,
+    }
+    input: {
+        function f1() {
+            var k = 9;
+            var rx = /[A-Z]+/;
+            return [rx, k];
+        }
+        function f2() {
+            var rx = /ab*/g;
+            return function(s) {
+                return rx.exec(s);
+            };
+        }
+        function f3() {
+            var rx = /ab*/g;
+            return function() {
+                return rx;
+            };
+        }
+        (function() {
+            var result;
+            var s = "acdabcdeabbb";
+            var rx = /ab*/g;
+            while (result = rx.exec(s))
+                console.log(result[0]);
+        })();
+        (function() {
+            var result;
+            var s = "acdabcdeabbb";
+            var rx = f2();
+            while (result = rx(s))
+                console.log(result[0]);
+        })();
+        (function() {
+            var result;
+            var s = "acdabcdeabbb";
+            var rx = f3();
+            while (result = rx().exec(s))
+                console.log(result[0]);
+        })();
+    }
+    expect: {
+        function f1() {
+            return [/[A-Z]+/, 9];
+        }
+        function f2() {
+            var rx = /ab*/g;
+            return function(s) {
+                return rx.exec(s);
+            };
+        }
+        function f3() {
+            var rx = /ab*/g;
+            return function() {
+                return rx;
+            };
+        }
+        (function() {
+            var result, rx = /ab*/g;
+            while (result = rx.exec("acdabcdeabbb"))
+                console.log(result[0]);
+        })();
+        (function() {
+            var result, rx = f2();
+            while (result = rx("acdabcdeabbb"))
+                console.log(result[0]);
+        })();
+        (function() {
+            var result, rx = f3();
+            while (result = rx().exec("acdabcdeabbb"))
+                console.log(result[0]);
+        })();
+    }
+    expect_stdout: [
+        "a",
+        "ab",
+        "abbb",
+        "a",
+        "ab",
+        "abbb",
+        "a",
+        "ab",
+        "abbb",
+    ]
+}

test/compress/functions.js

@@ -2004,57 +2004,6 @@ deduplicate_parenthesis: {
     expect_exact: "({}).a=b;({}.a=b)();(function(){}).a=b;(function(){}.a=b)();"
 }
 
-drop_lone_use_strict: {
-    options = {
-        directives: true,
-        side_effects: true,
-    }
-    input: {
-        function f1() {
-            "use strict";
-        }
-        function f2() {
-            "use strict";
-            function f3() {
-                "use strict";
-            }
-        }
-        (function f4() {
-            "use strict";
-        })();
-    }
-    expect: {
-        function f1() {
-        }
-        function f2() {
-            "use strict";
-            function f3() {
-            }
-        }
-    }
-}
-
-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,
@@ -2265,7 +2214,8 @@ issue_3054: {
             return { a: !0 };
         }
         console.log(function(b) {
-            return { a: !(b = !1) };
+            b = !1;
+            return f();
         }().a, f.call().a);
     }
     expect_stdout: "true true"
@@ -2345,7 +2295,7 @@ issue_3274: {
     }
     expect: {
         (function() {
-            for (var c; void 0, (c = 1..p) != c;)
+            for (var c; (c = 1..p) != c;)
                 console.log("FAIL");
             console.log("PASS");
         })();
@@ -2513,18 +2463,21 @@ issue_3297_3: {
         }).processBulk([1, 2, 3]);
     }
     expect: {
-        function function1(u) {
+        function function1(c) {
             return {
-                processBulk: function n(r) {
-                    var o, t = u();
-                    r && 0 < r.length && (o = {
-                        param1: r.shift(),
+                processBulk: function n(o) {
+                    var r, t, u = c();
+                    o && 0 < o.length && (r = {
+                        param1: o.shift(),
                         param2: {
-                            subparam1: t
+                            subparam1: u
                         }
                     },
-                    console.log(JSON.stringify(o)),
-                    n(r));
+                    t = function() {
+                        n(o);
+                    },
+                    console.log(JSON.stringify(r)),
+                    t());
                 }
             };
         }
@@ -3096,8 +3049,7 @@ issue_3400_1: {
         });
     }
     expect: {
-        void console.log(function() {
-            function g() {
+        void console.log(function g() {
             function h(u) {
                 var o = {
                     p: u
@@ -3110,9 +3062,7 @@ issue_3400_1: {
                 });
             }
             return e();
-            }
-            return g;
-        }()()[0].p);
+        }()[0].p);
     }
     expect_stdout: [
         "undefined",
@@ -3153,12 +3103,10 @@ issue_3400_2: {
     expect: {
         void console.log(function g() {
             return [ 42 ].map(function(v) {
-                return function(u) {
-                    var o = {
-                        p: u
-                    };
-                    return console.log(o[g]), o;
-                }(v);
+                return o = {
+                    p: v
+                }, console.log(o[g]), o;
+                var o;
             });
         }()[0].p);
     }
@@ -3370,3 +3318,390 @@ issue_3512: {
     }
     expect_stdout: "PASS"
 }
+
+issue_3562: {
+    options = {
+        collapse_vars: true,
+        reduce_vars: true,
+    }
+    input: {
+        var a = "PASS";
+        function f(b) {
+            f = function() {
+                console.log(b);
+            };
+            return "FAIL";
+        }
+        a = f(a);
+        f(a);
+    }
+    expect: {
+        var a = "PASS";
+        function f(b) {
+            f = function() {
+                console.log(b);
+            };
+            return "FAIL";
+        }
+        a = f(a);
+        f(a);
+    }
+    expect_stdout: "PASS"
+}
+
+hoisted_inline: {
+    options = {
+        inline: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            console.log("PASS");
+        }
+        function g() {
+            for (var console in [ 0 ])
+                h();
+        }
+        function h() {
+            f();
+        }
+        g();
+    }
+    expect: {
+        function f() {
+            console.log("PASS");
+        }
+        (function() {
+            for (var console in [ 0 ])
+                void f();
+        })();
+    }
+    expect_stdout: "PASS"
+}
+
+hoisted_single_use: {
+    options = {
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f(a) {
+            for (var r in a) g(r);
+        }
+        function g(a) {
+            console.log(a);
+        }
+        function h(a) {
+            var g = a.bar;
+            g();
+            g();
+            i(a);
+        }
+        function i(b) {
+            f(b);
+        }
+        h({
+            bar: function() {
+                console.log("foo");
+            }
+        });
+    }
+    expect: {
+        function f(a) {
+            for (var r in a) g(r);
+        }
+        function g(a) {
+            console.log(a);
+        }
+        (function(a) {
+            var g = a.bar;
+            g();
+            g();
+            (function(b) {
+                f(b);
+            })(a);
+        })({
+            bar: function() {
+                console.log("foo");
+            }
+        });
+    }
+    expect_stdout: [
+        "foo",
+        "foo",
+        "bar",
+    ]
+}
+
+pr_3592_1: {
+    options = {
+        inline: true,
+        reduce_funcs: false,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function problem(w) {
+            return g.indexOf(w);
+        }
+        function unused(x) {
+            return problem(x);
+        }
+        function B(problem) {
+            return g[problem];
+        }
+        function A(y) {
+            return problem(y);
+        }
+        function main(z) {
+            return B(A(z));
+        }
+        var g = [ "PASS" ];
+        console.log(main("PASS"));
+    }
+    expect: {
+        function problem(w) {
+            return g.indexOf(w);
+        }
+        function B(problem) {
+            return g[problem];
+        }
+        var g = [ "PASS" ];
+        console.log((z = "PASS", B((y = z, problem(y)))));
+        var z, y;
+    }
+    expect_stdout: "PASS"
+}
+
+pr_3592_2: {
+    options = {
+        inline: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function problem(w) {
+            return g.indexOf(w);
+        }
+        function unused(x) {
+            return problem(x);
+        }
+        function B(problem) {
+            return g[problem];
+        }
+        function A(y) {
+            return problem(y);
+        }
+        function main(z) {
+            return B(A(z));
+        }
+        var g = [ "PASS" ];
+        console.log(main("PASS"));
+    }
+    expect: {
+        function problem(w) {
+            return g.indexOf(w);
+        }
+        var g = [ "PASS" ];
+        console.log((z = "PASS", function(problem) {
+            return g[problem];
+        }((y = z, problem(y)))));
+        var z, y;
+    }
+    expect_stdout: "PASS"
+}
+
+inline_use_strict: {
+    options = {
+        evaluate: true,
+        inline: true,
+        reduce_vars: true,
+        sequences: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        console.log(function() {
+            "use strict";
+            return function() {
+                "use strict";
+                var a = "foo";
+                a += "bar";
+                return a;
+            };
+        }()());
+    }
+    expect: {
+        console.log("foobar");
+    }
+    expect_stdout: "foobar"
+}
+
+pr_3595_1: {
+    options = {
+        collapse_vars: false,
+        inline: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var g = [ "PASS" ];
+        function problem(arg) {
+            return g.indexOf(arg);
+        }
+        function unused(arg) {
+            return problem(arg);
+        }
+        function a(arg) {
+            return problem(arg);
+        }
+        function b(problem) {
+            return g[problem];
+        }
+        function c(arg) {
+            return b(a(arg));
+        }
+        console.log(c("PASS"));
+    }
+    expect: {
+        var g = [ "PASS" ];
+        function problem(arg) {
+            return g.indexOf(arg);
+        }
+        console.log((arg = "PASS", function(problem) {
+            return g[problem];
+        }(function(arg) {
+            return problem(arg);
+        }(arg))));
+        var arg;
+    }
+    expect_stdout: "PASS"
+}
+
+pr_3595_2: {
+    options = {
+        collapse_vars: true,
+        inline: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var g = [ "PASS" ];
+        function problem(arg) {
+            return g.indexOf(arg);
+        }
+        function unused(arg) {
+            return problem(arg);
+        }
+        function a(arg) {
+            return problem(arg);
+        }
+        function b(problem) {
+            return g[problem];
+        }
+        function c(arg) {
+            return b(a(arg));
+        }
+        console.log(c("PASS"));
+    }
+    expect: {
+        var g = [ "PASS" ];
+        function problem(arg) {
+            return g.indexOf(arg);
+        }
+        console.log(function(problem) {
+            return g[problem];
+        }(function(arg) {
+            return problem(arg);
+        }("PASS")));
+    }
+    expect_stdout: "PASS"
+}
+
+pr_3595_3: {
+    options = {
+        collapse_vars: true,
+        inline: true,
+        passes: 2,
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var g = [ "PASS" ];
+        function problem(arg) {
+            return g.indexOf(arg);
+        }
+        function unused(arg) {
+            return problem(arg);
+        }
+        function a(arg) {
+            return problem(arg);
+        }
+        function b(problem) {
+            return g[problem];
+        }
+        function c(arg) {
+            return b(a(arg));
+        }
+        console.log(c("PASS"));
+    }
+    expect: {
+        var g = [ "PASS" ];
+        console.log(function(problem) {
+            return g[problem];
+        }(function(arg) {
+            return g.indexOf(arg);
+        }("PASS")));
+    }
+    expect_stdout: "PASS"
+}
+
+pr_3595_4: {
+    options = {
+        collapse_vars: true,
+        inline: true,
+        passes: 3,
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var g = [ "PASS" ];
+        function problem(arg) {
+            return g.indexOf(arg);
+        }
+        function unused(arg) {
+            return problem(arg);
+        }
+        function a(arg) {
+            return problem(arg);
+        }
+        function b(problem) {
+            return g[problem];
+        }
+        function c(arg) {
+            return b(a(arg));
+        }
+        console.log(c("PASS"));
+    }
+    expect: {
+        var g = [ "PASS" ];
+        console.log((problem = g.indexOf("PASS"), g[problem]));
+        var problem;
+    }
+    expect_stdout: "PASS"
+}

test/compress/if_return.js

@@ -544,3 +544,32 @@ if_body_return_3: {
         "PASS",
     ]
 }
+
+issue_3600: {
+    options = {
+        if_return: true,
+        inline: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        var c = 0;
+        (function() {
+            if ([ ][c++]); else return;
+            return void function() {
+                var b = --b, a = c = 42;
+                return c;
+            }();
+        })();
+        console.log(c);
+    }
+    expect: {
+        var c = 0;
+        (function() {
+            if ([][c++]) b = --b, c = 42;
+            var b;
+        })();
+        console.log(c);
+    }
+    expect_stdout: "1"
+}

test/compress/issue-1609.js

@@ -52,3 +52,30 @@ chained_evaluation_2: {
         })();
     }
 }
+
+chained_evaluation_3: {
+    options = {
+        collapse_vars: true,
+        evaluate: 10,
+        reduce_funcs: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        (function() {
+            var a = "long piece of string";
+            (function() {
+                var b = a, c;
+                c = f(b);
+                c.bar = b;
+            })();
+        })();
+    }
+    expect: {
+        (function() {
+            (function() {
+                f("long piece of string").bar = "long piece of string";
+            })();
+        })();
+    }
+}

test/compress/loops.js

@@ -689,3 +689,67 @@ step: {
     }
     expect_stdout: "42"
 }
+
+empty_for_in: {
+    options = {
+        loops: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        for (var a in [ 1, 2, 3 ]) {
+            var b = a + 1;
+        }
+    }
+    expect: {}
+    expect_warnings: [
+        "WARN: Dropping unused variable b [test/compress/loops.js:2,16]",
+        "INFO: Dropping unused loop variable a [test/compress/loops.js:1,17]",
+    ]
+}
+
+empty_for_in_used: {
+    options = {
+        loops: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        for (var a in [ 1, 2, 3 ]) {
+            var b = a + 1;
+        }
+        console.log(a);
+    }
+    expect: {
+        for (var a in [ 1, 2, 3 ]);
+        console.log(a);
+    }
+    expect_stdout: "2"
+    expect_warnings: [
+        "WARN: Dropping unused variable b [test/compress/loops.js:2,16]",
+    ]
+}
+
+empty_for_in_side_effects: {
+    options = {
+        loops: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        for (var a in {
+            foo: console.log("PASS")
+        }) {
+            var b = a + "bar";
+        }
+    }
+    expect: {
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+    expect_warnings: [
+        "WARN: Dropping unused variable b [test/compress/loops.js:4,16]",
+        "INFO: Dropping unused loop variable a [test/compress/loops.js:1,17]",
+        "WARN: Side effects in object of for-in loop [test/compress/loops.js:1,17]",
+    ]
+}

test/compress/numbers.js

@@ -781,3 +781,201 @@ issue_3539: {
     }
     expect_stdout: "NaN -Infinity Infinity"
 }
+
+issue_3547_1: {
+    options = {
+        evaluate: true,
+        unsafe_math: true,
+    }
+    input: {
+        [
+            1/0 + "1" + 0,
+            1/0 + "1" - 0,
+            1/0 - "1" + 0,
+            1/0 - "1" - 0,
+        ].forEach(function(n) {
+            console.log(typeof n, n);
+        });
+    }
+    expect: {
+        [
+            1/0 + "10",
+            NaN,
+            1/0,
+            1/0,
+        ].forEach(function(n) {
+            console.log(typeof n, n);
+        });
+    }
+    expect_stdout: [
+        "string Infinity10",
+        "number NaN",
+        "number Infinity",
+        "number Infinity",
+    ]
+}
+
+issue_3547_2: {
+    options = {
+        evaluate: true,
+        unsafe_math: true,
+    }
+    input: {
+        [
+            "1" + 1/0 + 0,
+            "1" + 1/0 - 0,
+            "1" - 1/0 + 0,
+            "1" - 1/0 - 0,
+        ].forEach(function(n) {
+            console.log(typeof n, n);
+        });
+    }
+    expect: {
+        [
+            "1" + 1/0 + 0,
+            NaN,
+            -1/0,
+            -1/0,
+        ].forEach(function(n) {
+            console.log(typeof n, n);
+        });
+    }
+    expect_stdout: [
+        "string 1Infinity0",
+        "number NaN",
+        "number -Infinity",
+        "number -Infinity",
+    ]
+}
+
+issue_3547_3: {
+    options = {
+        evaluate: true,
+        unsafe_math: true,
+    }
+    input: {
+        var a = "3";
+        [
+            a + "2" + 1,
+            a + "2" - 1,
+            a - "2" + 1,
+            a - "2" - 1,
+        ].forEach(function(n) {
+            console.log(typeof n, n);
+        });
+    }
+    expect: {
+        var a = "3";
+        [
+            a + "21",
+            a + "2" - 1,
+            a - 1,
+            a - 3,
+        ].forEach(function(n) {
+            console.log(typeof n, n);
+        });
+    }
+    expect_stdout: [
+        "string 321",
+        "number 31",
+        "number 2",
+        "number 0",
+    ]
+}
+
+issue_3547_4: {
+    options = {
+        evaluate: true,
+        unsafe_math: true,
+    }
+    input: {
+        var a = "2";
+        [
+            "3" + a + 1,
+            "3" + a - 1,
+            "3" - a + 1,
+            "3" - a - 1,
+        ].forEach(function(n) {
+            console.log(typeof n, n);
+        });
+    }
+    expect: {
+        var a = "2";
+        [
+            "3" + a + 1,
+            "3" + a - 1,
+            4 - a,
+            2 - a,
+        ].forEach(function(n) {
+            console.log(typeof n, n);
+        });
+    }
+    expect_stdout: [
+        "string 321",
+        "number 31",
+        "number 2",
+        "number 0",
+    ]
+}
+
+unsafe_math_rounding: {
+    options = {
+        evaluate: true,
+        unsafe_math: true,
+    }
+    input: {
+        console.log(4 / -3 + 1 === 1 / -3);
+    }
+    expect: {
+        console.log(false);
+    }
+    expect_stdout: "false"
+}
+
+issue_3593: {
+    options = {
+        evaluate: true,
+        unsafe_math: true,
+    }
+    input: {
+        console.log((0 === this) - 1 - "1");
+    }
+    expect: {
+        console.log((0 === this) - 2);
+    }
+    expect_stdout: "-2"
+}
+
+unsafe_math_swap_constant: {
+    options = {
+        evaluate: true,
+        unsafe_math: true,
+    }
+    input: {
+        var a = 1, b = 2;
+        console.log(
+            a++ + b-- + 3,
+            a++ + b + 3,
+            a + b-- + 3,
+            a + b + 3,
+            a++ - b-- + 3,
+            a++ - b + 3,
+            a - b-- + 3,
+            a - b + 3
+        );
+    }
+    expect: {
+        var a = 1, b = 2;
+        console.log(
+            3 + a++ + b--,
+            a++ + b + 3,
+            a + b-- + 3,
+            a + b + 3,
+            3 + a++ - b--,
+            3 + a++ - b,
+            a - b-- + 3,
+            a - b + 3
+        );
+    }
+    expect_stdout: "6 6 7 6 6 8 9 10"
+}

test/compress/objects.js

@@ -0,0 +1,223 @@
+duplicate_key: {
+    options = {
+        objects: true,
+        side_effects: true,
+    }
+    input: {
+        var o = {
+            a: 1,
+            b: 2,
+            a: 3,
+        };
+        for (var k in o)
+            console.log(k, o[k]);
+    }
+    expect: {
+        var o = {
+            a: 3,
+            b: 2,
+        };
+        for (var k in o)
+            console.log(k, o[k]);
+    }
+    expect_stdout: [
+        "a 3",
+        "b 2",
+    ]
+}
+
+duplicate_key_strict: {
+    options = {
+        objects: true,
+        side_effects: true,
+    }
+    input: {
+        "use strict";
+        var o = {
+            a: 1,
+            b: 2,
+            a: 3,
+        };
+        for (var k in o)
+            console.log(k, o[k]);
+    }
+    expect: {
+        "use strict";
+        var o = {
+            a: 1,
+            b: 2,
+            a: 3,
+        };
+        for (var k in o)
+            console.log(k, o[k]);
+    }
+    expect_stdout: true
+}
+
+duplicate_key_side_effect: {
+    options = {
+        objects: true,
+        side_effects: true,
+    }
+    input: {
+        var o = {
+            a: 1,
+            b: o = 2,
+            a: 3,
+        };
+        for (var k in o)
+            console.log(k, o[k]);
+    }
+    expect: {
+        var o = {
+            a: 1,
+            b: o = 2,
+            a: 3,
+        };
+        for (var k in o)
+            console.log(k, o[k]);
+    }
+    expect_stdout: [
+        "a 3",
+        "b 2",
+    ]
+}
+
+duplicate_key_with_accessor: {
+    options = {
+        objects: true,
+        side_effects: true,
+    }
+    input: {
+        [
+            {
+                a: 0,
+                b: 1,
+                a: 2,
+                set b(v) {},
+            },
+            {
+                a: 3,
+                b: 4,
+                get a() {
+                    return 5;
+                },
+                a: 6,
+                b: 7,
+                a: 8,
+                b: 9,
+            },
+        ].forEach(function(o) {
+            for (var k in o)
+                console.log(k, o[k]);
+        });
+    }
+    expect: {
+        [
+            {
+                a: 2,
+                b: 1,
+                set b(v) {},
+            },
+            {
+                a: 3,
+                b: 4,
+                get a() {
+                    return 5;
+                },
+                a: 8,
+                b: 9,
+            },
+        ].forEach(function(o) {
+            for (var k in o)
+                console.log(k, o[k]);
+        });
+    }
+    expect_stdout: true
+}
+
+unsafe_object_repeated: {
+    options = {
+        evaluate: true,
+        objects: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unsafe: true,
+    }
+    input: {
+        var o = { a: { b: 1 }, a: 1 };
+        console.log(
+            o + 1,
+            o.a + 1,
+            o.b + 1,
+            o.a.b + 1
+        );
+    }
+    expect: {
+        var o = { a: 1 };
+        console.log(
+            o + 1,
+            2,
+            o.b + 1,
+            NaN
+        );
+    }
+    expect_stdout: true
+}
+
+numeric_literal: {
+    options = {
+        objects: true,
+        side_effects: true,
+    }
+    mangle = {
+        properties: true,
+    }
+    beautify = {
+        beautify: true,
+    }
+    input: {
+        var obj = {
+            0: 0,
+            "-0": 1,
+            42: 2,
+            "42": 3,
+            0x25: 4,
+            "0x25": 5,
+            1E42: 6,
+            "1E42": 7,
+            "1e+42": 8,
+        };
+        console.log(obj[-0], obj[-""], obj["-0"]);
+        console.log(obj[42], obj["42"]);
+        console.log(obj[0x25], obj["0x25"], obj[37], obj["37"]);
+        console.log(obj[1E42], obj["1E42"], obj["1e+42"]);
+    }
+    expect_exact: [
+        'var obj = {',
+        '    0: 0,',
+        '    "-0": 1,',
+        '    42: 3,',
+        '    37: 4,',
+        '    o: 5,',
+        '    1e42: 8,',
+        '    b: 7',
+        '};',
+        '',
+        'console.log(obj[-0], obj[-""], obj["-0"]);',
+        '',
+        'console.log(obj[42], obj["42"]);',
+        '',
+        'console.log(obj[37], obj["o"], obj[37], obj["37"]);',
+        '',
+        'console.log(obj[1e42], obj["b"], obj["1e+42"]);',
+    ]
+    expect_stdout: [
+        "0 0 1",
+        "3 3",
+        "4 5 4 4",
+        "8 7 8",
+    ]
+}

test/compress/reduce_vars.js

@@ -1427,13 +1427,13 @@ defun_inline_3: {
 
 defun_call: {
     options = {
-        inline: true,
+        evaluate: true,
         reduce_funcs: true,
         reduce_vars: true,
         unused: true,
     }
     input: {
-        function f() {
+        console.log(function f() {
             return g() + h(1) - h(g(), 2, 3);
             function g() {
                 return 4;
@@ -1441,21 +1441,17 @@ defun_call: {
             function h(a) {
                 return a;
             }
-        }
+        }());
     }
     expect: {
-        function f() {
-            return 4 + h(1) - h(4);
-            function h(a) {
-                return a;
-            }
-        }
+        console.log(1);
     }
+    expect_stdout: "1"
 }
 
 defun_redefine: {
     options = {
-        inline: true,
+        evaluate: true,
         reduce_funcs: true,
         reduce_vars: true,
         unused: true,
@@ -1480,7 +1476,7 @@ defun_redefine: {
             (function() {
                 return 3;
             });
-            return 3 + 2;
+            return 5;
         }
         console.log(f());
     }
@@ -1517,7 +1513,7 @@ func_inline: {
 
 func_modified: {
     options = {
-        inline: true,
+        evaluate: true,
         reduce_funcs: true,
         reduce_vars: true,
         unused: true,
@@ -1550,7 +1546,7 @@ func_modified: {
             (function() {
                 return 4;
             });
-            return 1 + 2 + 4;
+            return 7;
         }
         console.log(f());
     }
@@ -5516,9 +5512,7 @@ issue_2860_1: {
         }());
     }
     expect: {
-        console.log(function(a) {
-            return 1 ^ a;
-        }());
+        console.log(1);
     }
     expect_stdout: "1"
 }

test/compress/regexp.js

@@ -36,6 +36,20 @@ regexp_2: {
     expect_stdout: '["PASS","pass"]'
 }
 
+regexp_properties: {
+    options = {
+        evaluate: true,
+        unsafe: true,
+    }
+    input: {
+        console.log(/abc/g.source, /abc/g.global, /abc/g.ignoreCase, /abc/g.lastIndex, /abc/g.multiline);
+    }
+    expect: {
+        console.log("abc", true, false, /abc/g.lastIndex, false);
+    }
+    expect_stdout: "abc true false 0 false"
+}
+
 issue_3434_1: {
     options = {
         evaluate: true,

test/compress/switch.js

@@ -261,13 +261,13 @@ drop_default_1: {
     }
     input: {
         switch (foo) {
-          case 'bar': baz();
+          case "bar": baz();
           default:
         }
     }
     expect: {
         switch (foo) {
-          case 'bar': baz();
+          case "bar": baz();
         }
     }
 }
@@ -279,14 +279,14 @@ drop_default_2: {
     }
     input: {
         switch (foo) {
-          case 'bar': baz(); break;
+          case "bar": baz(); break;
           default:
             break;
         }
     }
     expect: {
         switch (foo) {
-          case 'bar': baz();
+          case "bar": baz();
         }
     }
 }
@@ -298,7 +298,7 @@ keep_default: {
     }
     input: {
         switch (foo) {
-          case 'bar': baz();
+          case "bar": baz();
           default:
             something();
             break;
@@ -306,7 +306,7 @@ keep_default: {
     }
     expect: {
         switch (foo) {
-          case 'bar': baz();
+          case "bar": baz();
           default:
             something();
         }
@@ -347,25 +347,103 @@ issue_1663: {
     expect_stdout: true
 }
 
-drop_case: {
+drop_case_1: {
     options = {
         dead_code: true,
         switches: true,
     }
     input: {
         switch (foo) {
-          case 'bar': baz(); break;
-          case 'moo':
+          case "bar": baz(); break;
+          case "moo":
             break;
         }
     }
     expect: {
         switch (foo) {
-          case 'bar': baz();
+          case "bar": baz();
         }
     }
 }
 
+drop_case_2: {
+    options = {
+        dead_code: true,
+        switches: true,
+    }
+    input: {
+        switch (foo) {
+          case "bar":
+            bar();
+            break;
+          default:
+          case "moo":
+            moo();
+            break;
+        }
+    }
+    expect: {
+        switch (foo) {
+          case "bar":
+            bar();
+            break;
+          default:
+            moo();
+        }
+    }
+}
+
+drop_case_3: {
+    options = {
+        dead_code: true,
+        switches: true,
+    }
+    input: {
+        var c = "PASS";
+        switch ({}.p) {
+          default:
+          case void 0:
+            break;
+          case c = "FAIL":
+        }
+        console.log(c);
+    }
+    expect: {
+        var c = "PASS";
+        switch ({}.p) {
+          default:
+          case void 0:
+            break;
+          case c = "FAIL":
+        }
+        console.log(c);
+    }
+    expect_stdout: "PASS"
+}
+
+drop_case_4: {
+    options = {
+        dead_code: true,
+        switches: true,
+    }
+    input: {
+        switch (0) {
+          case [ a, typeof b ]:
+          default:
+            var a;
+        }
+        console.log("PASS");
+    }
+    expect: {
+        switch (0) {
+          case [ a, typeof b ]:
+            var a;
+        }
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+}
+
 keep_case: {
     options = {
         dead_code: true,
@@ -373,14 +451,14 @@ keep_case: {
     }
     input: {
         switch (foo) {
-          case 'bar': baz(); break;
+          case "bar": baz(); break;
           case moo:
             break;
         }
     }
     expect: {
         switch (foo) {
-          case 'bar': baz(); break;
+          case "bar": baz(); break;
           case moo:
         }
     }
@@ -539,7 +617,7 @@ issue_1679: {
         f();
         console.log(a, b);
     }
-    expect_stdout: true
+    expect_stdout: "99 8"
 }
 
 issue_1680_1: {
@@ -864,3 +942,89 @@ issue_1750: {
     }
     expect_stdout: "0 2"
 }
+
+drop_switch_1: {
+    options = {
+        dead_code: true,
+        switches: true,
+    }
+    input: {
+        switch (foo) {
+          default:
+            break;
+          case "bar":
+            break;
+        }
+    }
+    expect: {
+        foo;
+    }
+}
+
+drop_switch_2: {
+    options = {
+        dead_code: true,
+        switches: true,
+    }
+    input: {
+        switch (foo) {
+          default:
+          case "bar":
+            baz();
+        }
+    }
+    expect: {
+        foo;
+        baz();
+    }
+}
+
+drop_switch_3: {
+    options = {
+        dead_code: true,
+        switches: true,
+    }
+    input: {
+        console.log(function() {
+            switch (0) {
+              default:
+                return "PASS";
+              case 1:
+            }
+        }());
+    }
+    expect: {
+        console.log(function() {
+            switch (0) {
+              default:
+                return "PASS";
+              case 1:
+            }
+        }());
+    }
+    expect_stdout: "PASS"
+}
+
+drop_switch_4: {
+    options = {
+        dead_code: true,
+        switches: true,
+    }
+    input: {
+        var a = "FAIL";
+        switch (0) {
+          default:
+          case a:
+            var b = a = "PASS";
+            break;
+        }
+        console.log(a);
+    }
+    expect: {
+        var a = "FAIL";
+        0;
+        var b = a = "PASS";
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+}

test/compress/typeof.js

@@ -166,9 +166,7 @@ duplicate_lambda_arg_name: {
         }());
     }
     expect: {
-        console.log(function long_name(long_name) {
-            return typeof long_name;
-        }());
+        console.log("undefined");
     }
     expect_stdout: "undefined"
 }
@@ -295,3 +293,145 @@ issue_2728_6: {
     }
     expect_stdout: "function undefined"
 }
+
+typeof_defined_1: {
+    options = {
+        side_effects: true,
+        typeofs: true,
+    }
+    input: {
+        "undefined" == typeof A && A;
+        "undefined" != typeof A && A;
+        "undefined" == typeof A || A;
+        "undefined" != typeof A || A;
+    }
+    expect: {
+        "undefined" == typeof A && A;
+        "undefined" != typeof A || A;
+    }
+}
+
+typeof_defined_2: {
+    options = {
+        side_effects: true,
+        typeofs: true,
+    }
+    input: {
+        "function" == typeof A && A;
+        "function" != typeof A && A;
+        "function" == typeof A || A;
+        "function" != typeof A || A;
+    }
+    expect: {
+        "function" != typeof A && A;
+        "function" == typeof A || A;
+    }
+}
+
+typeof_defined_3: {
+    options = {
+        side_effects: true,
+        typeofs: true,
+    }
+    input: {
+        "undefined" == typeof A && "undefined" == typeof B && (A, B);
+        "undefined" == typeof A && "undefined" != typeof B && (A, B);
+        "undefined" != typeof A && "undefined" == typeof B && (A, B);
+        "undefined" != typeof A && "undefined" != typeof B && (A, B);
+        "undefined" == typeof A && "undefined" == typeof B || (A, B);
+        "undefined" == typeof A && "undefined" != typeof B || (A, B);
+        "undefined" != typeof A && "undefined" == typeof B || (A, B);
+        "undefined" != typeof A && "undefined" != typeof B || (A, B);
+        "undefined" == typeof A || "undefined" == typeof B && (A, B);
+        "undefined" == typeof A || "undefined" != typeof B && (A, B);
+        "undefined" != typeof A || "undefined" == typeof B && (A, B);
+        "undefined" != typeof A || "undefined" != typeof B && (A, B);
+        "undefined" == typeof A || "undefined" == typeof B || (A, B);
+        "undefined" == typeof A || "undefined" != typeof B || (A, B);
+        "undefined" != typeof A || "undefined" == typeof B || (A, B);
+        "undefined" != typeof A || "undefined" != typeof B || (A, B);
+    }
+    expect: {
+        "undefined" == typeof A && "undefined" == typeof B && (A, B);
+        "undefined" == typeof A && "undefined" != typeof B && A;
+        "undefined" != typeof A && "undefined" == typeof B && B;
+        "undefined" == typeof A && "undefined" == typeof B || (A, B);
+        "undefined" == typeof A && "undefined" != typeof B || (A, B);
+        "undefined" != typeof A && "undefined" == typeof B || (A, B);
+        "undefined" != typeof A && "undefined" != typeof B || (A, B);
+        "undefined" == typeof A || "undefined" == typeof B && B;
+        "undefined" != typeof A || "undefined" == typeof B && (A, B);
+        "undefined" != typeof A || "undefined" != typeof B && A;
+        "undefined" == typeof A || "undefined" != typeof B || B;
+        "undefined" != typeof A || "undefined" == typeof B || A;
+        "undefined" != typeof A || "undefined" != typeof B || (A, B);
+    }
+}
+
+typeof_defined_4: {
+    options = {
+        side_effects: true,
+        typeofs: true,
+    }
+    input: {
+        "object" == typeof A && "object" == typeof B && (A, B);
+        "object" == typeof A && "object" != typeof B && (A, B);
+        "object" != typeof A && "object" == typeof B && (A, B);
+        "object" != typeof A && "object" != typeof B && (A, B);
+        "object" == typeof A && "object" == typeof B || (A, B);
+        "object" == typeof A && "object" != typeof B || (A, B);
+        "object" != typeof A && "object" == typeof B || (A, B);
+        "object" != typeof A && "object" != typeof B || (A, B);
+        "object" == typeof A || "object" == typeof B && (A, B);
+        "object" == typeof A || "object" != typeof B && (A, B);
+        "object" != typeof A || "object" == typeof B && (A, B);
+        "object" != typeof A || "object" != typeof B && (A, B);
+        "object" == typeof A || "object" == typeof B || (A, B);
+        "object" == typeof A || "object" != typeof B || (A, B);
+        "object" != typeof A || "object" == typeof B || (A, B);
+        "object" != typeof A || "object" != typeof B || (A, B);
+    }
+    expect: {
+        "object" == typeof A && "object" != typeof B && B;
+        "object" != typeof A && "object" == typeof B && A;
+        "object" != typeof A && "object" != typeof B && (A, B);
+        "object" == typeof A && "object" == typeof B || (A, B);
+        "object" == typeof A && "object" != typeof B || (A, B);
+        "object" != typeof A && "object" == typeof B || (A, B);
+        "object" != typeof A && "object" != typeof B || (A, B);
+        "object" == typeof A || "object" == typeof B && A;
+        "object" == typeof A || "object" != typeof B && (A, B);
+        "object" != typeof A || "object" != typeof B && B;
+        "object" == typeof A || "object" == typeof B || (A, B);
+        "object" == typeof A || "object" != typeof B || A;
+        "object" != typeof A || "object" == typeof B || B;
+    }
+}
+
+emberjs_global: {
+    options = {
+        comparisons: true,
+        conditionals: true,
+        if_return: true,
+        passes: 2,
+        side_effects: true,
+        toplevel: true,
+        typeofs: true,
+        unused: true,
+    }
+    input: {
+        var a;
+        if (typeof A === "object") {
+            a = A;
+        } else if (typeof B === "object") {
+            a = B;
+        } else {
+            throw new Error("PASS");
+        }
+    }
+    expect: {
+        if ("object" != typeof A && "object" != typeof B)
+            throw new Error("PASS");
+    }
+    expect_stdout: Error("PASS")
+}

test/mocha/cli.js

@@ -12,7 +12,9 @@ describe("bin/uglifyjs", function() {
     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) {
+        exec(command, {
+            maxBuffer: 1048576
+        }, function(err, stdout) {
             if (err) throw err;
             eval(stdout);
             assert.strictEqual(typeof WrappedUglifyJS, "object");

test/mocha/comments.js

@@ -259,6 +259,30 @@ describe("comments", function() {
         assert.strictEqual(result.code, code);
     });
 
+    it("Should handle comments around parenthesis correctly", function() {
+        var code = [
+            "a();",
+            "/* foo */",
+            "(b())",
+            "/* bar */",
+            "c();",
+        ].join("\n");
+        var result = UglifyJS.minify(code, {
+            compress: false,
+            mangle: false,
+            output: {
+                comments: "all",
+            },
+        });
+        if (result.error) throw result.error;
+        assert.strictEqual(result.code, [
+            "a();",
+            "/* foo */",
+            "b()",
+            "/* bar */;c();",
+        ].join("\n"));
+    });
+
     it("Should preserve comments around IIFE", function() {
         var result = UglifyJS.minify("/*a*/(/*b*/function(){/*c*/}/*d*/)/*e*/();", {
             compress: false,

test/mocha/directives.js

@@ -80,8 +80,8 @@ describe("Directives", function() {
             [
                 // no ; or newline
                 '"use strict"',
-                [],
-                [ "use strict", "use\nstrict", "use \nstrict", "use asm" ]
+                [ "use strict" ],
+                [ "use\nstrict", "use \nstrict", "use asm" ]
             ],
             [
                 ';"use strict"',
@@ -116,8 +116,8 @@ describe("Directives", function() {
             ],
             [
                 'var foo = function() {"use strict"', // no ; or newline
-                [],
-                [ "use strict", "use\nstrict", "use \nstrict", "use asm" ]
+                [ "use strict" ],
+                [ "use\nstrict", "use \nstrict", "use asm" ]
             ],
             [
                 'var foo = function() {;"use strict"',

test/mocha/number-literal.js

@@ -2,10 +2,18 @@ var assert = require("assert");
 var UglifyJS = require("../node");
 
 describe("Number literals", function() {
+    it("Should allow legacy octal literals in non-strict mode", function() {
+        [
+            "'use strict'\n.slice()\n00",
+            '"use strict"\n.slice()\nvar foo = 00',
+        ].forEach(function(input) {
+            UglifyJS.parse(input);
+        });
+    });
     it("Should not allow legacy octal literals in strict mode", function() {
         var inputs = [
             '"use strict";00;',
-            '"use strict"; var foo = 00;'
+            '"use strict"; var foo = 00;',
         ];
         var test = function(input) {
             return function() {

test/mocha/spidermonkey.js

@@ -10,7 +10,9 @@ describe("spidermonkey export/import sanity test", function() {
         var command = uglifyjs + " --self -cm --wrap SpiderUglify -o spidermonkey | " +
             uglifyjs + " -p spidermonkey -cm";
 
-        exec(command, function(err, stdout) {
+        exec(command, {
+            maxBuffer: 1048576
+        }, function(err, stdout) {
             if (err) throw err;
 
             eval(stdout);

test/ufuzz/travis.js

@@ -1,44 +0,0 @@
-"use strict";
-
-var child_process = require("child_process");
-var https = require("https");
-var url = require("url");
-
-var period = 45 * 60 * 1000;
-var wait = 2 * 60 * 1000;
-if (process.argv.length > 2) {
-    var token = process.argv[2];
-    var branch = process.argv[3] || "v" + require("../../package.json").version;
-    var repository = encodeURIComponent(process.argv[4] || "mishoo/UglifyJS2");
-    var concurrency = process.argv[5] || 1;
-    var platform = process.argv[6] || "latest";
-    (function request() {
-        setTimeout(request, (period + wait) / concurrency);
-        var options = url.parse("https://api.travis-ci.org/repo/" + repository + "/requests");
-        options.method = "POST";
-        options.headers = {
-            "Content-Type": "application/json",
-            "Travis-API-Version": 3,
-            "Authorization": "token " + token
-        };
-        https.request(options, function(res) {
-            console.log("HTTP", res.statusCode);
-            console.log(JSON.stringify(res.headers, null, 2));
-            console.log();
-            res.setEncoding("utf8");
-            res.on("data", console.log);
-        }).on("error", console.error).end(JSON.stringify({
-            request: {
-                message: "ufuzz testing",
-                branch: branch,
-                config: {
-                    cache: false,
-                    env: "NODE=" + platform,
-                    script: "node test/ufuzz/job " + period
-                }
-            }
-        }));
-    })();
-} else {
-    console.log("Usage: test/ufuzz/travis.js <token> [branch] [repository] [concurrency] [platform]");
-}