harmony-v3.0.28

* Not always safe to convert a function expression to an arrow
  function when code depends on the function prototype existing.

Fixes #2271

README.md

@@ -646,9 +646,16 @@ If you're using the `X-SourceMap` header instead, you can just omit `sourceMap.u
 
 - `evaluate` -- attempt to evaluate constant expressions
 
-- `arrows` (default `true`) -- convert ES5 style anonymous function expressions
-  to arrow functions if permissible by language semantics.
-  Note: `arrows` requires that the `ecma` compress option is set to `6` or greater.
+- `arrows` (default `true`) -- Converts `()=>{return x}` to `()=>x`. Class
+  and object literal methods will also be converted to arrow expressions if
+  the resultant code is shorter: `m(){return x}` becomes `m:()=>x`.
+  This transform requires that the `ecma` compress option is set to `6` or greater.
+
+- `unsafe_arrows` (default `false`) -- Convert ES5 style anonymous function
+  expressions to arrow functions if the function body does not reference `this`.
+  Note: it is not always safe to perform this conversion if code relies on the
+  the function having a `prototype`, which arrow functions lack.
+  This transform requires that the `ecma` compress option is set to `6` or greater.
 
 - `booleans` -- various optimizations for boolean context, for example `!!a
   ? b : c → a ? b : c`

lib/compress.js

@@ -84,6 +84,7 @@ function Compressor(options, false_by_default) {
         toplevel      : !!(options && options["top_retain"]),
         typeofs       : !false_by_default,
         unsafe        : false,
+        unsafe_arrows : false,
         unsafe_comps  : false,
         unsafe_Func   : false,
         unsafe_math   : false,
@@ -1427,9 +1428,14 @@ merge(Compressor.prototype, {
         def(AST_Object, function(compressor) {
             if (!is_strict(compressor)) return false;
             for (var i = this.properties.length; --i >=0;)
-                if (this.properties[i].value instanceof AST_Accessor) return true;
+                if (this.properties[i]._dot_throw(compressor)) return true;
             return false;
         });
+        def(AST_ObjectProperty, return_false);
+        def(AST_ObjectGetter, return_true);
+        def(AST_Expansion, function(compressor) {
+            return this.expression._dot_throw(compressor);
+        });
         def(AST_Function, return_false);
         def(AST_Arrow, return_false);
         def(AST_UnaryPostfix, return_false);
@@ -1731,6 +1737,7 @@ merge(Compressor.prototype, {
                 var val = {};
                 for (var i = 0, len = this.properties.length; i < len; i++) {
                     var prop = this.properties[i];
+                    if (prop instanceof AST_Expansion) return this;
                     var key = prop.key;
                     if (key instanceof AST_Symbol) {
                         key = key.name;
@@ -4742,7 +4749,7 @@ merge(Compressor.prototype, {
 
     OPT(AST_Function, function(self, compressor){
         tighten_body(self.body, compressor);
-        if (compressor.option("arrows")
+        if (compressor.option("unsafe_arrows")
             && compressor.option("ecma") >= 6
             && !self.name
             && !self.is_generator

lib/output.js

@@ -157,7 +157,7 @@ function OutputStream(options) {
               case "\u2029": return "\\u2029";
               case "\ufeff": return "\\ufeff";
               case "\0":
-                  return /[0-7]/.test(get_full_char(str, i+1)) ? "\\x00" : "\\0";
+                  return /[0-9]/.test(get_full_char(str, i+1)) ? "\\x00" : "\\0";
             }
             return s;
         });
@@ -689,6 +689,7 @@ function OutputStream(options) {
                                                                * ==> 20 (side effect, set a := 10 and b := 20) */
             || p instanceof AST_Arrow                         // x => (x, x)
             || p instanceof AST_DefaultAssign                 // x => (x = (0, function(){}))
+            || p instanceof AST_Expansion                     // [...(a, b)]
         ;
     });
 

lib/parse.js

@@ -1522,7 +1522,7 @@ function parse($TEXT, options) {
                 }
                 if (is_expand) {
                     if (!is("punc", "]")) {
-                        unexpected(); // Must be last element
+                        croak("Rest element must be last element");
                     }
                     elements[elements.length - 1] = new AST_Expansion({
                         start: expand_token,
@@ -1547,18 +1547,33 @@ function parse($TEXT, options) {
                 } else {
                     expect(",");
                 }
+                if (is("expand", "...")) {
+                    is_expand = true;
+                    expand_token = S.token;
+                    used_parameters.mark_spread(S.token);
+                    next();
+                }
                 if (is("name") && (is_token(peek(), "punc") || is_token(peek(), "operator")) && [",", "}", "="].indexOf(peek().value) !== -1) {
                     used_parameters.add_parameter(S.token);
-                    elements.push(new AST_ObjectKeyVal({
-                        start: prev(),
-                        key: S.token.value,
-                        value: new symbol_type({
-                            start: S.token,
-                            name: S.token.value,
-                            end: S.token
-                        }),
-                        end: prev()
-                    }));
+                    var value = new symbol_type({
+                        start: S.token,
+                        name: S.token.value,
+                        end: S.token,
+                    });
+                    if (is_expand) {
+                        elements.push(new AST_Expansion({
+                            start: expand_token,
+                            expression: value,
+                            end: value.end,
+                        }));
+                    } else {
+                        elements.push(new AST_ObjectKeyVal({
+                            start: prev(),
+                            key: S.token.value,
+                            value: value,
+                            end: value.end,
+                        }));
+                    }
                     next();
                 } else if (is("punc", "}")) {
                     continue; // Allow trailing hole
@@ -1589,7 +1604,12 @@ function parse($TEXT, options) {
                         }));
                     }
                 }
-                if (is("operator", "=")) {
+                if (is_expand) {
+                    if (!is("punc", "}")) {
+                        croak("Rest element must be last element");
+                    }
+                }
+                else if (is("operator", "=")) {
                     used_parameters.mark_default_assignment(S.token);
                     next();
                     elements[elements.length - 1].value = new AST_DefaultAssign({
@@ -2143,7 +2163,18 @@ function parse($TEXT, options) {
             if (!options.strict && is("punc", "}"))
                 // allow trailing comma
                 break;
+
             start = S.token;
+            if (start.type == "expand") {
+                next();
+                a.push(new AST_Expansion({
+                    start: start,
+                    expression: expression(false),
+                    end: prev(),
+                }));
+                continue;
+            }
+
             var name = as_property_name();
             var value;
 

lib/scope.js

@@ -203,6 +203,21 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
             || node instanceof AST_SymbolLet
             || node instanceof AST_SymbolConst) {
             var def = ((node instanceof AST_SymbolBlockDeclaration) ? scope : defun).def_variable(node);
+            if (!all(def.orig, function(sym) {
+                if (sym === node) return true;
+                if (node instanceof AST_SymbolBlockDeclaration) {
+                    return sym instanceof AST_SymbolLambda;
+                }
+                return !(sym instanceof AST_SymbolLet || sym instanceof AST_SymbolConst);
+            })) {
+                js_error(
+                    node.name + " redeclared",
+                    node.start.file,
+                    node.start.line,
+                    node.start.col,
+                    node.start.pos
+                );
+            }
             if (!(node instanceof AST_SymbolFunarg)) mark_export(def, 2);
             def.destructuring = in_destructuring;
             if (defun !== scope) {
@@ -300,6 +315,7 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
                     ref.reference(options);
                 });
                 node.thedef = def;
+                node.reference(options);
                 return true;
             }
         }));
@@ -357,7 +373,7 @@ AST_IterationStatement.DEFMETHOD("is_block_scope", return_true);
 AST_Lambda.DEFMETHOD("init_scope_vars", function(){
     AST_Scope.prototype.init_scope_vars.apply(this, arguments);
     this.uses_arguments = false;
-    this.def_variable(new AST_SymbolConst({
+    this.def_variable(new AST_SymbolFunarg({
         name: "arguments",
         start: this.start,
         end: this.end

package.json

@@ -4,7 +4,7 @@
   "homepage": "https://github.com/mishoo/UglifyJS2/tree/harmony",
   "author": "Mihai Bazon <mihai.bazon@gmail.com> (http://lisperator.net/)",
   "license": "BSD-2-Clause",
-  "version": "3.0.27",
+  "version": "3.0.28",
   "engines": {
     "node": ">=0.8.0"
   },

test/compress/arrow.js

@@ -213,7 +213,7 @@ no_leading_parentheses: {
 
 async_identifiers: {
     options = {
-        arrows: true,
+        unsafe_arrows: true,
         ecma: 6,
     }
     input: {
@@ -237,7 +237,7 @@ async_identifiers: {
 
 async_function_expression: {
     options = {
-        arrows: true,
+        unsafe_arrows: true,
         ecma: 6,
         evaluate: true,
         side_effects: true,
@@ -262,7 +262,7 @@ async_function_expression: {
 
 issue_27: {
     options = {
-        arrows: true,
+        unsafe_arrows: true,
         collapse_vars: true,
         ecma: 6,
         unused: true,
@@ -283,7 +283,7 @@ issue_27: {
 
 issue_2105_1: {
     options = {
-        arrows: true,
+        unsafe_arrows: true,
         collapse_vars: true,
         ecma: 6,
         inline: true,
@@ -501,7 +501,7 @@ issue_485_crashing_1530: {
 
 issue_2084: {
     options = {
-        arrows: true,
+        unsafe_arrows: true,
         collapse_vars: true,
         conditionals: true,
         ecma: 6,
@@ -577,6 +577,7 @@ concise_methods_with_computed_property2: {
 async_object_literal: {
     options = {
         arrows: true,
+        unsafe_arrows: true,
         ecma: 6,
         evaluate: true,
     }
@@ -597,3 +598,35 @@ async_object_literal: {
         };
     }
 }
+
+issue_2271: {
+    options = {
+        arrows: true,
+        ecma: 6,
+        evaluate: true,
+        unsafe_arrows: false,
+    }
+    input: {
+        var Foo = function() {};
+        Foo.prototype.set = function(value) {
+            this.value = value;
+            return this;
+        }
+        Foo.prototype.print = function() {
+            console.log(this.value);
+        }
+        new Foo().set("PASS").print();
+    }
+    expect: {
+        var Foo = function() {};
+        Foo.prototype.set = function(value) {
+            this.value = value;
+            return this;
+        }
+        Foo.prototype.print = function() {
+            console.log(this.value);
+        }
+        new Foo().set("PASS").print();
+    }
+    expect_stdout: "PASS"
+}

test/compress/ascii.js

@@ -13,7 +13,7 @@ ascii_only_true: {
                    "\x20\x21\x22\x23 ... \x7d\x7e\x7f\x80\x81 ... \xfe\xff\u0fff\uffff";
         }
     }
-    expect_exact: 'function f(){return"\\x000\\x001\\x007\\08\\0"+"\\0\\x01\\x02\\x03\\x04\\x05\\x06\\x07\\b\\t\\n\\v\\f\\r\\x0e\\x0f"+"\\x10\\x11\\x12\\x13\\x14\\x15\\x16\\x17\\x18\\x19\\x1a\\x1b\\x1c\\x1d\\x1e\\x1f"+\' !"# ... }~\\x7f\\x80\\x81 ... \\xfe\\xff\\u0fff\\uffff\'}'
+    expect_exact: 'function f(){return"\\x000\\x001\\x007\\x008\\0"+"\\0\\x01\\x02\\x03\\x04\\x05\\x06\\x07\\b\\t\\n\\v\\f\\r\\x0e\\x0f"+"\\x10\\x11\\x12\\x13\\x14\\x15\\x16\\x17\\x18\\x19\\x1a\\x1b\\x1c\\x1d\\x1e\\x1f"+\' !"# ... }~\\x7f\\x80\\x81 ... \\xfe\\xff\\u0fff\\uffff\'}'
 }
 
 ascii_only_false: {
@@ -31,5 +31,5 @@ ascii_only_false: {
                    "\x20\x21\x22\x23 ... \x7d\x7e\x7f\x80\x81 ... \xfe\xff\u0fff\uffff";
         }
     }
-    expect_exact: 'function f(){return"\\x000\\x001\\x007\\08\\0"+"\\0\x01\x02\x03\x04\x05\x06\x07\\b\\t\\n\\v\\f\\r\x0e\x0f"+"\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f"+\' !"# ... }~\x7f\x80\x81 ... \xfe\xff\u0fff\uffff\'}'
+    expect_exact: 'function f(){return"\\x000\\x001\\x007\\x008\\0"+"\\0\x01\x02\x03\x04\x05\x06\x07\\b\\t\\n\\v\\f\\r\x0e\x0f"+"\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f"+\' !"# ... }~\x7f\x80\x81 ... \xfe\xff\u0fff\uffff\'}'
 }

test/compress/concat-strings.js

@@ -21,7 +21,7 @@ concat_1: {
         var c = 1 + x() + 2 + "boo";
         var d = 1 + x() + 2 + 3 + "boo";
         var e = 1 + x() + 2 + "X3boo";
-        var f = "\x00360\08\0";
+        var f = "\x00360\x008\0";
     }
 }
 

test/compress/destructuring.js

@@ -65,10 +65,10 @@ nested_destructuring_objects: {
     }
     input: {
         const [{a},b] = c;
-        let [{a},b] = c;
-        var [{a},b] = c;
+        let [{d},e] = f;
+        var [{g},h] = i;
     }
-    expect_exact: 'const[{a},b]=c;let[{a},b]=c;var[{a},b]=c;';
+    expect_exact: 'const[{a},b]=c;let[{d},e]=f;var[{g},h]=i;';
 }
 
 destructuring_constdef_in_loops: {
@@ -274,8 +274,8 @@ reduce_vars: {
         var {aa, bb: {cc, dd}} = {aa:1, bb: {cc:2, dd: 3}};
         ({aa, bb: {cc, dd}} = {aa:1, bb: {cc:2, dd: 3}});
         const [{a},b] = c;
-        let [{a},b] = c;
-        var [{a},b] = c;
+        let [{d},e] = f;
+        var [{g},h] = i;
         [{a},b] = c;
         for (const [x,y] in pairs);
         for (let [x,y] in pairs);
@@ -292,8 +292,8 @@ reduce_vars: {
         var {aa, bb: {cc, dd}} = {aa:1, bb: {cc:2, dd: 3}};
         ({aa, bb: {cc, dd}} = {aa:1, bb: {cc:2, dd: 3}});
         const [{a},b] = c;
-        let [{a},b] = c;
-        var [{a},b] = c;
+        let [{d},e] = f;
+        var [{g},h] = i;
         [{a},b] = c;
         for (const [x,y] in pairs);
         for (let [x,y] in pairs);

test/compress/harmony.js

@@ -211,13 +211,13 @@ export_statement: {
     }
     input: {
         export default 1 + 2;
-        export var foo = 4;
-        export let foo = 6;
-        export const foo = 6;
-        export function foo() {};
-        export class foo { };
+        export var a = 4;
+        export let b = 6;
+        export const c = 6;
+        export function d() {};
+        export class e {};
     }
-    expect_exact: "export default 3;export var foo=4;export let foo=6;export const foo=6;export function foo(){};export class foo{};"
+    expect_exact: "export default 3;export var a=4;export let b=6;export const c=6;export function d(){};export class e{};"
 }
 
 export_default_object_expression: {
@@ -695,3 +695,112 @@ export_default_class_decl: {
     }
     expect_exact: "export default class Car{};export class Cab{};"
 }
+
+object_rest_spread: {
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        var   { w: w1, ...V } = { w: 7, x: 1, y: 2 }; console.log(w1, V);
+        let   { w: w2, ...L } = { w: 8, x: 3, y: 4 }; console.log(w2, L);
+        const { w: w3, ...C } = { w: 9, x: 5, y: 6 }; console.log(w3, C);
+
+        let b;
+        ({ b, ...V } = { a: 1, b: 2, c: 3 }); console.log(V);
+        ({ b, ...L } = { a: 4, b: 5, c: 6 }); console.log(L);
+
+        (function({ y, ...p }){ console.log(p); })({ x: 1, y: 2, z: 3 });
+        (({ y, ...p }) =>     { console.log(p); })({ x: 4, y: 5, z: 6 });
+
+        const T = { a: 1, b: 2 }; console.log({ ...T, w: 0, ...{}, ...L, ...{K: 9} });
+    }
+    expect: {
+        var   { w: o, ...l } = { w: 7, x: 1, y: 2 }; console.log(o, l);
+        let   { w: c, ...n } = { w: 8, x: 3, y: 4 }; console.log(c, n);
+        const { w: e, ...s } = { w: 9, x: 5, y: 6 }; console.log(e, s);
+
+        let g;
+        ({ b: g, ...l } = { a: 1, b: 2, c: 3 }); console.log(l);
+        ({ b: g, ...n } = { a: 4, b: 5, c: 6 }); console.log(n);
+
+        (function({ y: o, ...l }) { console.log(l); })({ x: 1, y: 2, z: 3 });
+        (({ y: o, ...l }) =>      { console.log(l); })({ x: 4, y: 5, z: 6 });
+
+        const w = { a: 1, b: 2 }; console.log({ ...w, w: 0, ...{}, ...n, ...{ K: 9 } });
+    }
+}
+
+object_spread_unsafe: {
+    options = {
+        collapse_vars: true,
+        evaluate: true,
+        join_vars: true,
+        passes: 3,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unsafe: true,
+        unused: true,
+    }
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        var o1 = { x: 1, y: 2 };
+        var o2 = { x: 3, z: 4 };
+        var cloned = { ...o1 };
+        var merged = { ...o1, ...o2 };
+        console.log(cloned, merged);
+    }
+    expect: {
+        var o = { x: 1, y: 2 }, l = { ...o }, x = { ...o, ...{ x: 3, z: 4 } };
+        console.log(l, x);
+    }
+}
+
+array_spread_of_sequence: {
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        var a = [1];
+        console.log([...(a, a)]);
+        console.log([...a, a]);
+        console.log([...(a || a)]);
+        console.log([...a || a]);
+    }
+    expect: {
+        var o = [1];
+        console.log([...(o, o)]);
+        console.log([...o, o]);
+        console.log([...o || o]);
+        console.log([...o || o]);
+    }
+    expect_stdout: [
+        "[ 1 ]",
+        "[ 1, [ 1 ] ]",
+        "[ 1 ]",
+        "[ 1 ]",
+    ]
+    node_version: ">=6"
+}
+
+object_spread_of_sequence: {
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        var a = {x: 1};
+        console.log({ ...(a, a) });
+        console.log({ ...a, a });
+        console.log({ ...(a || a) });
+        console.log({ ...a || a });
+    }
+    expect: {
+        var o = { x: 1 };
+        console.log({ ...(o, o) });
+        console.log({ ...o, a: o });
+        console.log({ ...o || o });
+        console.log({ ...o || o });
+    }
+}

test/compress/issue-203.js

@@ -36,9 +36,10 @@ compress_new_function_with_destruct: {
 compress_new_function_with_destruct_arrows: {
     options = {
         arrows: true,
+        unsafe_arrows: true,
         unsafe: true,
         unsafe_Func: true,
-        ecma: 6
+        ecma: 6,
     }
     beautify = {
         ecma: 6

test/compress/parameters.js

@@ -142,11 +142,11 @@ destructuring_arguments_3: {
     }
     input: {
         function fn3({x: {y: {z: {} = 42}}}) {}
-        const { cover = (function () {}), xCover = (0, function() {})  } = {};
-        let { cover = (function () {}), xCover = (0, function() {})  } = {};
-        var { cover = (function () {}), xCover = (0, function() {})  } = {};
+        const { a = (function () {}), b = (0, function() {})  } = {};
+        let { c = (function () {}), d = (0, function() {})  } = {};
+        var { e = (function () {}), f = (0, function() {})  } = {};
     }
-    expect_exact: "function fn3({x:{y:{z:{}=42}}}){}const{cover=function(){},xCover=(0,function(){})}={};let{cover=function(){},xCover=(0,function(){})}={};var{cover=function(){},xCover=(0,function(){})}={};"
+    expect_exact: "function fn3({x:{y:{z:{}=42}}}){}const{a=function(){},b=(0,function(){})}={};let{c=function(){},d=(0,function(){})}={};var{e=function(){},f=(0,function(){})}={};"
 }
 
 default_arguments: {

test/compress/pure_getters.js

@@ -385,3 +385,76 @@ set_mutable_2: {
     }
     expect_stdout: "PASS"
 }
+
+issue_2265_1: {
+    options = {
+        pure_getters: "strict",
+        side_effects: true,
+    }
+    input: {
+        ({ ...{} }).p;
+        ({ ...g }).p;
+    }
+    expect: {
+        ({ ...g }).p;
+    }
+}
+
+issue_2265_2: {
+    options = {
+        pure_getters: "strict",
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+    }
+    input: {
+        var a = {
+            get b() {
+                throw 0;
+            }
+        };
+        ({...a}).b;
+    }
+    expect: {
+        var a = {
+            get b() {
+                throw 0;
+            }
+        };
+        ({...a}).b;
+    }
+}
+
+issue_2265_3: {
+    options = {
+        pure_getters: "strict",
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = {
+            set b() {
+                throw 0;
+            }
+        };
+        ({...a}).b;
+    }
+    expect: {}
+}
+
+issue_2265_4: {
+    options = {
+        pure_getters: "strict",
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = { b: 1 };
+        ({...a}).b;
+    }
+    expect: {}
+}

test/compress/screw-ie8.js

@@ -325,3 +325,69 @@ issue_2120_2: {
     }
     expect_stdout: "PASS"
 }
+
+issue_2254_1: {
+    mangle = {
+        ie8: false,
+    }
+    input: {
+        "eeeeee";
+        try {
+            console.log(f("PASS"));
+        } catch (e) {}
+        function f(s) {
+            try {
+                throw "FAIL";
+            } catch (e) {
+                return s;
+            }
+        }
+    }
+    expect: {
+        "eeeeee";
+        try {
+            console.log(f("PASS"));
+        } catch (e) {}
+        function f(e) {
+            try {
+                throw "FAIL";
+            } catch (t) {
+                return e;
+            }
+        }
+    }
+    expect_stdout: "PASS"
+}
+
+issue_2254_2: {
+    mangle = {
+        ie8: true,
+    }
+    input: {
+        "eeeeee";
+        try {
+            console.log(f("PASS"));
+        } catch (e) {}
+        function f(s) {
+            try {
+                throw "FAIL";
+            } catch (e) {
+                return s;
+            }
+        }
+    }
+    expect: {
+        "eeeeee";
+        try {
+            console.log(f("PASS"));
+        } catch (e) {}
+        function f(t) {
+            try {
+                throw "FAIL";
+            } catch (e) {
+                return t;
+            }
+        }
+    }
+    expect_stdout: "PASS"
+}

test/mocha/lhs-expressions.js

@@ -253,13 +253,19 @@ describe("Left-hand side expressions", function () {
         // Multiple spreads are not allowed in destructuring array
         expect("[...a, ...b] = [1, 2, 3, 4]", "Spread must the be last element in destructuring array");
 
-        // Spread in obvious object pattern
-        expect("({...a} = foo)", "Unexpected token: expand (...)");
+        // Array spread must be last in destructuring declaration
+        expect("let [ ...x, a ] = o;", "Rest element must be last element");
+
+        // Only one spread per destructuring array declaration
+        expect("let [ a, ...x, ...y ] = o;", "Rest element must be last element");
 
         // Spread in block should not be allowed
         expect("{...a} = foo", "Unexpected token: expand (...)");
 
-        // Not in standard yet
-        expect("let foo = {bar: 42}, bar; bar = {...foo}", "Unexpected token: expand (...)");
+        // Object spread must be last in destructuring declaration
+        expect("let { ...x, a } = o;", "Rest element must be last element");
+
+        // Only one spread per destructuring declaration
+        expect("let { a, ...x, ...y } = o;", "Rest element must be last element");
     });
 });

test/mocha/minify.js

@@ -291,4 +291,34 @@ describe("minify", function() {
             assert.strictEqual(result.code, "alert({bar:42});");
         });
     });
+
+    describe("duplicated block-scoped declarations", function() {
+        [
+            "let a=1;let a=2;",
+            "let a=1;var a=2;",
+            "var a=1;let a=2;",
+            "let[a]=[1];var a=2;",
+            "let a=1;var[a]=[2];",
+            "let[a]=[1];var[a]=[2];",
+            "const a=1;const a=2;",
+            "const a=1;var a=2;",
+            "var a=1;const a=2;",
+            "const[a]=[1];var a=2;",
+            "const a=1;var[a]=[2];",
+            "const[a]=[1];var[a]=[2];",
+        ].forEach(function(code) {
+            it(code, function() {
+                var result = Uglify.minify(code, {
+                    compress: false,
+                    mangle: false
+                });
+                assert.strictEqual(result.error, undefined);
+                assert.strictEqual(result.code, code);
+                result = Uglify.minify(code);
+                var err = result.error;
+                assert.ok(err instanceof Error);
+                assert.strictEqual(err.stack.split(/\n/)[0], "SyntaxError: a redeclared");
+            });
+        });
+    });
 });

test/mocha/string-literal.js

@@ -61,9 +61,9 @@ describe("String literals", function() {
         var tests = [
             ['"\\76";', ';">";'],
             ['"\\0"', '"\\0";'],
-            ['"\\08"', '"\\08";'],
-            ['"\\008"', '"\\08";'],
-            ['"\\0008"', '"\\08";'],
+            ['"\\08"', '"\\x008";'],
+            ['"\\008"', '"\\x008";'],
+            ['"\\0008"', '"\\x008";'],
             ['"use strict" === "use strict";\n"\\76";', '"use strict"==="use strict";">";'],
             ['"use\\\n strict";\n"\\07";', ';"use strict";"\07";']
         ];
@@ -75,8 +75,8 @@ describe("String literals", function() {
     });
 
     it("Should not throw error when digit is 8 or 9", function() {
-        assert.equal(UglifyJS.parse('"use strict";"\\08"').print_to_string(), '"use strict";"\\08";');
-        assert.equal(UglifyJS.parse('"use strict";"\\09"').print_to_string(), '"use strict";"\\09";');
+        assert.equal(UglifyJS.parse('"use strict";"\\08"').print_to_string(), '"use strict";"\\x008";');
+        assert.equal(UglifyJS.parse('"use strict";"\\09"').print_to_string(), '"use strict";"\\x009";');
     });
 
     it("Should not unescape unpaired surrogates", function() {

test/mocha/unicode.js

@@ -146,6 +146,7 @@ describe("Unicode", function() {
 
     if (semver.satisfies(process.version, ">=4")) {
         it("Should not unescape unpaired surrogates", function() {
+            this.timeout(5000);
             var code = [];
             for (var i = 0; i <= 0x20001; i++) {
                 code.push("\\u{" + i.toString(16) + "}");