Improve binding patterns for arrow functions

test/mocha/arrow.js

@@ -18,6 +18,45 @@ describe("Arrow functions", function() {
                 e.message === "SyntaxError: Unexpected token: expand (...)";
         }
 
+        for (var i = 0; i < tests.length; i++) {
+            assert.throws(test(tests[i]), error);
+        }
+    });
+    it("Should not accept holes in object binding patterns, while still allowing a trailing elision", function() {
+        var tests = [
+            "f = ({, , ...x} = [1, 2]) => {};"
+        ];
+        var test = function(code) {
+            return function() {
+                uglify.parse(code, {fromString: true});
+            }
+        }
+        var error = function(e) {
+            return e instanceof uglify.JS_Parse_Error &&
+                e.message === "SyntaxError: Unexpected token: punc (,)";
+        }
+
+        for (var i = 0; i < tests.length; i++) {
+            assert.throws(test(tests[i]), error);
+        }
+    });
+    it("Should not accept newlines before arrow token", function() {
+        var tests = [
+            "f = foo\n=> 'foo';",
+            "f = (foo, bar)\n=> 'foo';",
+            "f = ()\n=> 'foo';",
+            "foo((bar)\n=>'baz';);"
+        ];
+        var test = function(code) {
+            return function() {
+                uglify.parse(code, {fromString: true});
+            }
+        }
+        var error = function(e) {
+            return e instanceof uglify.JS_Parse_Error &&
+                e.message === "SyntaxError: Unexpected newline before arrow (=>)";
+        }
+
         for (var i = 0; i < tests.length; i++) {
             assert.throws(test(tests[i]), error);
         }

test/mocha/function.js

@@ -13,30 +13,39 @@ describe("Function", function() {
         // Destructurings as arguments
         var destr_fun1 = uglify.parse('(function ({a, b}) {})').body[0].body;
         var destr_fun2 = uglify.parse('(function ([a, [b]]) {})').body[0].body;
+        var destr_fun3 = uglify.parse('({a, b}) => null').body[0].body;
+        var destr_fun4 = uglify.parse('([a, [b]]) => null').body[0].body;
 
         assert.equal(destr_fun1.argnames.length, 1);
         assert.equal(destr_fun2.argnames.length, 1);
-
-        var destr_fun1 = uglify.parse('({a, b}) => null').body[0].body;
-        var destr_fun2 = uglify.parse('([a, [b]]) => null').body[0].body;
-
-        assert.equal(destr_fun1.argnames.length, 1);
-        assert.equal(destr_fun2.argnames.length, 1);
+        assert.equal(destr_fun3.argnames.length, 1);
+        assert.equal(destr_fun4.argnames.length, 1);
 
         var destruct1 = destr_fun1.argnames[0];
         var destruct2 = destr_fun2.argnames[0];
+        var destruct3 = destr_fun3.argnames[0];
+        var destruct4 = destr_fun4.argnames[0];
 
         assert(destruct1 instanceof uglify.AST_Destructuring);
         assert(destruct2 instanceof uglify.AST_Destructuring);
+        assert(destruct3 instanceof uglify.AST_Destructuring);
+        assert(destruct4 instanceof uglify.AST_Destructuring);
         assert(destruct2.names[1] instanceof uglify.AST_Destructuring);
+        assert(destruct4.names[1] instanceof uglify.AST_Destructuring);
 
         assert.equal(destruct1.start.value, '{');
         assert.equal(destruct1.end.value, '}');
         assert.equal(destruct2.start.value, '[');
         assert.equal(destruct2.end.value, ']');
+        assert.equal(destruct3.start.value, '{');
+        assert.equal(destruct3.end.value, '}');
+        assert.equal(destruct4.start.value, '[');
+        assert.equal(destruct4.end.value, ']');
 
         assert.equal(destruct1.is_array, false);
         assert.equal(destruct2.is_array, true);
+        assert.equal(destruct3.is_array, false);
+        assert.equal(destruct4.is_array, true);
 
         var aAndB = [
             ['SymbolFunarg', 'a'],
@@ -46,15 +55,43 @@ describe("Function", function() {
         assert.deepEqual(
             [
                 destruct1.names[0].TYPE,
-                destruct1.names[0].name],
+                destruct1.names[0].name
+            ],
+            aAndB[0]);
+        assert.deepEqual(
+            [
+                destruct1.names[1].TYPE,
+                destruct1.names[1].name
+            ],
+            aAndB[1]);
+        assert.deepEqual(
+            [
+                destruct2.names[0].TYPE,
+                destruct2.names[0].name
+            ],
             aAndB[0]);
-
         assert.deepEqual(
             [
                 destruct2.names[1].names[0].TYPE,
                 destruct2.names[1].names[0].name
             ],
             aAndB[1]);
+        assert.strictEqual(typeof destruct3.names[0].key, "string");
+        assert.strictEqual(destruct3.names[0].key, "a");
+        assert.strictEqual(typeof destruct3.names[1].key, "string");
+        assert.strictEqual(destruct3.names[1].key, "b");
+        assert.deepEqual(
+            [
+                destruct4.names[0].TYPE,
+                destruct4.names[0].name
+            ],
+            aAndB[0]);
+        assert.deepEqual(
+            [
+                destruct4.names[1].names[0].TYPE,
+                destruct4.names[1].names[0].name
+            ],
+            aAndB[1]);
 
         assert.deepEqual(
             get_args(destr_fun1.args_as_names()),
@@ -62,6 +99,12 @@ describe("Function", function() {
         assert.deepEqual(
             get_args(destr_fun2.args_as_names()),
             aAndB);
+        assert.deepEqual(
+            get_args(destr_fun3.args_as_names()),
+            aAndB);
+        assert.deepEqual(
+            get_args(destr_fun4.args_as_names()),
+            aAndB);
 
         // Making sure we don't accidentally accept things which
         // Aren't argument destructurings

test/mocha/object.js

@@ -124,4 +124,8 @@ describe("Object", function() {
             assert.throws(testCase(test), fail(test), errorMessage(test));
         }
     });
+    it("Should be able to use shorthand properties", function() {
+        var ast = Uglify.parse("var foo = 123\nvar obj = {foo: foo}");
+        assert.strictEqual(ast.print_to_string({ecma: 6}), "var foo=123;var obj={foo};");
+    })
 });