Add support for parsing destructuring patterns in arrow function parameter lists

Author: rbuckton

src/compiler/parser.ts

@@ -3221,10 +3221,27 @@ module ts {
                     }
                 }
 
-                // Simple case: "(..."
+                // If we had "(" followed by "{" or "[", this could be the start of a binding pattern.
+                let possiblyInArrayBindingPattern = false;
+                let possiblyInObjectBindingPattern = false;
+                while (second === SyntaxKind.OpenBraceToken || second === SyntaxKind.OpenBracketToken) {
+                    possiblyInObjectBindingPattern = second === SyntaxKind.OpenBraceToken;
+                    possiblyInArrayBindingPattern = second === SyntaxKind.OpenBracketToken;
+                    second = nextToken();
+                }
+
+                if (possiblyInArrayBindingPattern) {
+                    // If we are possibly in an array binding pattern, skip empty elements
+                    while (second === SyntaxKind.CommaToken) {
+                        second = nextToken();
+                    }
+                }
+
+                // Simple case: "(..." or "([...", but not "({..."
                 // This is an arrow function with a rest parameter.
-                if (second === SyntaxKind.DotDotDotToken) {
-                    return Tristate.True;
+                if (second === SyntaxKind.DotDotDotToken && !possiblyInObjectBindingPattern) {
+                    // if we are possibly in an array binding pattern, then this may be a lambda, otherwise it must be a lambda.
+                    return possiblyInArrayBindingPattern ? Tristate.Unknown : Tristate.True;
                 }
 
                 // If we had "(" followed by something that's not an identifier,
@@ -3236,9 +3253,9 @@ module ts {
                     return Tristate.False;
                 }
 
-                // If we have something like "(a:", then we must have a
+                // If we have something like "(a:", but not "({ a:", then we must have a
                 // type-annotated parameter in an arrow function expression.
-                if (nextToken() === SyntaxKind.ColonToken) {
+                if (nextToken() === SyntaxKind.ColonToken && !possiblyInObjectBindingPattern) {
                     return Tristate.True;
                 }
 

tests/baselines/reference/arrowFunctionExpressions.js

@@ -13,6 +13,17 @@ var d = n => c = n;
 var d = (n) => c = n;
 var d: (n: any) => any;
 
+// Binding patterns in arrow functions
+var p1 = ([a]) => { };
+var p2 = ([...a]) => { };
+var p3 = ([, a]) => { };
+var p4 = ([, ...a]) => { };
+var p5 = ([a = 1]) => { };
+var p6 = ({ a }) => { };
+var p7 = ({ a: { b } }) => { };
+var p8 = ({ a = 1 }) => { };
+var p9 = ({ a: { b = 1 } = { b: 1 } }) => { };
+var p10 = ([{ value, done }]) => { };
 
 // Arrow function used in class member initializer
 // Arrow function used in class member function
@@ -100,6 +111,37 @@ var c;
 var d = function (n) { return c = n; };
 var d = function (n) { return c = n; };
 var d;
+// Binding patterns in arrow functions
+var p1 = function (_a) {
+    var a = _a[0];
+};
+var p2 = function (_a) {
+    var a = _a.slice(0);
+};
+var p3 = function (_a) {
+    var a = _a[1];
+};
+var p4 = function (_a) {
+    var a = _a.slice(1);
+};
+var p5 = function (_a) {
+    var _b = _a[0], a = _b === void 0 ? 1 : _b;
+};
+var p6 = function (_a) {
+    var a = _a.a;
+};
+var p7 = function (_a) {
+    var b = _a.a.b;
+};
+var p8 = function (_a) {
+    var _b = _a.a, a = _b === void 0 ? 1 : _b;
+};
+var p9 = function (_a) {
+    var _b = _a.a, _c = (_b === void 0 ? { b: 1 } : _b).b, b = _c === void 0 ? 1 : _c;
+};
+var p10 = function (_a) {
+    var _b = _a[0], value = _b.value, done = _b.done;
+};
 // Arrow function used in class member initializer
 // Arrow function used in class member function
 var MyClass = (function () {

tests/baselines/reference/arrowFunctionExpressions.types

@@ -51,6 +51,61 @@ var d: (n: any) => any;
 >d : (n: any) => any
 >n : any
 
+// Binding patterns in arrow functions
+var p1 = ([a]) => { };
+>p1 : ([a]: [any]) => void
+>([a]) => { } : ([a]: [any]) => void
+>a : any
+
+var p2 = ([...a]) => { };
+>p2 : ([...a]: any[]) => void
+>([...a]) => { } : ([...a]: any[]) => void
+>a : any[]
+
+var p3 = ([, a]) => { };
+>p3 : ([, a]: [any, any]) => void
+>([, a]) => { } : ([, a]: [any, any]) => void
+>a : any
+
+var p4 = ([, ...a]) => { };
+>p4 : ([, ...a]: any[]) => void
+>([, ...a]) => { } : ([, ...a]: any[]) => void
+>a : any[]
+
+var p5 = ([a = 1]) => { };
+>p5 : ([a = 1]: [number]) => void
+>([a = 1]) => { } : ([a = 1]: [number]) => void
+>a : number
+
+var p6 = ({ a }) => { };
+>p6 : ({ a }: { a: any; }) => void
+>({ a }) => { } : ({ a }: { a: any; }) => void
+>a : any
+
+var p7 = ({ a: { b } }) => { };
+>p7 : ({ a: { b } }: { a: { b: any; }; }) => void
+>({ a: { b } }) => { } : ({ a: { b } }: { a: { b: any; }; }) => void
+>a : unknown
+>b : any
+
+var p8 = ({ a = 1 }) => { };
+>p8 : ({ a = 1 }: { a?: number; }) => void
+>({ a = 1 }) => { } : ({ a = 1 }: { a?: number; }) => void
+>a : number
+
+var p9 = ({ a: { b = 1 } = { b: 1 } }) => { };
+>p9 : ({ a: { b = 1 } = { b: 1 } }: { a?: { b: number; }; }) => void
+>({ a: { b = 1 } = { b: 1 } }) => { } : ({ a: { b = 1 } = { b: 1 } }: { a?: { b: number; }; }) => void
+>a : unknown
+>b : number
+>{ b: 1 } : { b: number; }
+>b : number
+
+var p10 = ([{ value, done }]) => { };
+>p10 : ([{ value, done }]: [{ value: any; done: any; }]) => void
+>([{ value, done }]) => { } : ([{ value, done }]: [{ value: any; done: any; }]) => void
+>value : any
+>done : any
 
 // Arrow function used in class member initializer
 // Arrow function used in class member function

tests/cases/conformance/expressions/functions/arrowFunctionExpressions.ts

@@ -12,6 +12,17 @@ var d = n => c = n;
 var d = (n) => c = n;
 var d: (n: any) => any;
 
+// Binding patterns in arrow functions
+var p1 = ([a]) => { };
+var p2 = ([...a]) => { };
+var p3 = ([, a]) => { };
+var p4 = ([, ...a]) => { };
+var p5 = ([a = 1]) => { };
+var p6 = ({ a }) => { };
+var p7 = ({ a: { b } }) => { };
+var p8 = ({ a = 1 }) => { };
+var p9 = ({ a: { b = 1 } = { b: 1 } }) => { };
+var p10 = ([{ value, done }]) => { };
 
 // Arrow function used in class member initializer
 // Arrow function used in class member function