Merge pull request #7226 from Microsoft/bindingPatternsInTypes

Correctly serialize types with signatures containing binding patterns

src/compiler/checker.ts

@@ -2176,7 +2176,12 @@ namespace ts {
                 if (isRestParameter(parameterNode)) {
                     writePunctuation(writer, SyntaxKind.DotDotDotToken);
                 }
-                appendSymbolNameOnly(p, writer);
+                if (isBindingPattern(parameterNode.name)) {
+                    buildBindingPatternDisplay(<BindingPattern>parameterNode.name, writer, enclosingDeclaration, flags, symbolStack);
+                }
+                else {
+                    appendSymbolNameOnly(p, writer);
+                }
                 if (isOptionalParameter(parameterNode)) {
                     writePunctuation(writer, SyntaxKind.QuestionToken);
                 }
@@ -2186,20 +2191,63 @@ namespace ts {
                 buildTypeDisplay(getTypeOfSymbol(p), writer, enclosingDeclaration, flags, symbolStack);
             }
 
+            function buildBindingPatternDisplay(bindingPattern: BindingPattern, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags, symbolStack?: Symbol[]) {
+                // We have to explicitly emit square bracket and bracket because these tokens are not stored inside the node.
+                if (bindingPattern.kind === SyntaxKind.ObjectBindingPattern) {
+                    writePunctuation(writer, SyntaxKind.OpenBraceToken);
+                    buildDisplayForCommaSeparatedList(bindingPattern.elements, writer, e => buildBindingElementDisplay(e, writer, enclosingDeclaration, flags, symbolStack));
+                    writePunctuation(writer, SyntaxKind.CloseBraceToken);
+                }
+                else if (bindingPattern.kind === SyntaxKind.ArrayBindingPattern) {
+                    writePunctuation(writer, SyntaxKind.OpenBracketToken);
+                    const elements = bindingPattern.elements;
+                    buildDisplayForCommaSeparatedList(elements, writer, e => buildBindingElementDisplay(e, writer, enclosingDeclaration, flags, symbolStack));
+                    if (elements && elements.hasTrailingComma) {
+                        writePunctuation(writer, SyntaxKind.CommaToken);
+                    }
+                    writePunctuation(writer, SyntaxKind.CloseBracketToken);
+                }
+            }
+
+            function buildBindingElementDisplay(bindingElement: BindingElement, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags, symbolStack?: Symbol[]) {
+                if (bindingElement.kind === SyntaxKind.OmittedExpression) {
+                    return;
+                }
+                Debug.assert(bindingElement.kind === SyntaxKind.BindingElement);
+                if (bindingElement.propertyName) {
+                    writer.writeSymbol(getTextOfNode(bindingElement.propertyName), bindingElement.symbol);
+                    writePunctuation(writer, SyntaxKind.ColonToken);
+                    writeSpace(writer);
+                }
+                if (isBindingPattern(bindingElement.name)) {
+                    buildBindingPatternDisplay(<BindingPattern>bindingElement.name, writer, enclosingDeclaration, flags, symbolStack);
+                }
+                else {
+                    if (bindingElement.dotDotDotToken) {
+                        writePunctuation(writer, SyntaxKind.DotDotDotToken);
+                    }
+                    appendSymbolNameOnly(bindingElement.symbol, writer);
+                }
+            }
+
             function buildDisplayForTypeParametersAndDelimiters(typeParameters: TypeParameter[], writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags, symbolStack?: Symbol[]) {
                 if (typeParameters && typeParameters.length) {
                     writePunctuation(writer, SyntaxKind.LessThanToken);
-                    for (let i = 0; i < typeParameters.length; i++) {
-                        if (i > 0) {
-                            writePunctuation(writer, SyntaxKind.CommaToken);
-                            writeSpace(writer);
-                        }
-                        buildTypeParameterDisplay(typeParameters[i], writer, enclosingDeclaration, flags, symbolStack);
-                    }
+                    buildDisplayForCommaSeparatedList(typeParameters, writer, p => buildTypeParameterDisplay(p, writer, enclosingDeclaration, flags, symbolStack));
                     writePunctuation(writer, SyntaxKind.GreaterThanToken);
                 }
             }
 
+            function buildDisplayForCommaSeparatedList<T>(list: T[], writer: SymbolWriter, action: (item: T) => void) {
+                for (let i = 0; i < list.length; i++) {
+                    if (i > 0) {
+                        writePunctuation(writer, SyntaxKind.CommaToken);
+                        writeSpace(writer);
+                    }
+                    action(list[i]);
+                }
+            }
+
             function buildDisplayForTypeArgumentsAndDelimiters(typeParameters: TypeParameter[], mapper: TypeMapper, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags, symbolStack?: Symbol[]) {
                 if (typeParameters && typeParameters.length) {
                     writePunctuation(writer, SyntaxKind.LessThanToken);

tests/baselines/reference/arrayBindingPatternOmittedExpressions.types

@@ -25,7 +25,7 @@ var results: string[];
 
 
 function f([, a, , b, , , , s, , , ] = results) {
->f : ([, a, , b, , , , s, , , ]?: string[]) => void
+>f : ([, a, , b, , , , s, , ,]?: string[]) => void
 > : undefined
 >a : string
 > : undefined

tests/baselines/reference/arrowFunctionExpressions.types

@@ -77,31 +77,31 @@ var p4 = ([, ...a]) => { };
 >a : any[]
 
 var p5 = ([a = 1]) => { };
->p5 : ([a = 1]: [number]) => void
->([a = 1]) => { } : ([a = 1]: [number]) => void
+>p5 : ([a]: [number]) => void
+>([a = 1]) => { } : ([a]: [number]) => void
 >a : number
 >1 : number
 
 var p6 = ({ a }) => { };
->p6 : ({ a }: { a: any; }) => void
->({ a }) => { } : ({ a }: { a: any; }) => void
+>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
+>p7 : ({a: {b}}: { a: { b: any; }; }) => void
+>({ a: { b } }) => { } : ({a: {b}}: { a: { b: any; }; }) => void
 >a : any
 >b : any
 
 var p8 = ({ a = 1 }) => { };
->p8 : ({ a = 1 }: { a?: number; }) => void
->({ a = 1 }) => { } : ({ a = 1 }: { a?: number; }) => void
+>p8 : ({a}: { a?: number; }) => void
+>({ a = 1 }) => { } : ({a}: { a?: number; }) => void
 >a : number
 >1 : 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
+>p9 : ({a: {b}}: { a?: { b?: number; }; }) => void
+>({ a: { b = 1 } = { b: 1 } }) => { } : ({a: {b}}: { a?: { b?: number; }; }) => void
 >a : any
 >b : number
 >1 : number
@@ -110,8 +110,8 @@ var p9 = ({ a: { b = 1 } = { b: 1 } }) => { };
 >1 : number
 
 var p10 = ([{ value, done }]) => { };
->p10 : ([{ value, done }]: [{ value: any; done: any; }]) => void
->([{ value, done }]) => { } : ([{ value, done }]: [{ value: any; done: any; }]) => void
+>p10 : ([{value, done}]: [{ value: any; done: any; }]) => void
+>([{ value, done }]) => { } : ([{value, done}]: [{ value: any; done: any; }]) => void
 >value : any
 >done : any
 

tests/baselines/reference/declarationEmitDestructuring5.types

@@ -1,23 +1,23 @@
 === tests/cases/compiler/declarationEmitDestructuring5.ts ===
 function baz([, z, , ]) { }
->baz : ([, z, , ]: [any, any, any]) => void
+>baz : ([, z, ,]: [any, any, any]) => void
 > : undefined
 >z : any
 > : undefined
 
 function foo([, b, ]: [any, any]): void { }
->foo : ([, b, ]: [any, any]) => void
+>foo : ([, b,]: [any, any]) => void
 > : undefined
 >b : any
 
 function bar([z, , , ]) { }
->bar : ([z, , , ]: [any, any, any]) => void
+>bar : ([z, , ,]: [any, any, any]) => void
 >z : any
 > : undefined
 > : undefined
 
 function bar1([z, , , ] = [1, 3, 4, 6, 7]) { }
->bar1 : ([z, , , ]?: [number, number, number, number, number]) => void
+>bar1 : ([z, , ,]?: [number, number, number, number, number]) => void
 >z : number
 > : undefined
 > : undefined
@@ -29,7 +29,7 @@ function bar1([z, , , ] = [1, 3, 4, 6, 7]) { }
 >7 : number
 
 function bar2([,,z, , , ]) { }
->bar2 : ([,,z, , , ]: [any, any, any, any, any]) => void
+>bar2 : ([, , z, , ,]: [any, any, any, any, any]) => void
 > : undefined
 > : undefined
 >z : any

tests/baselines/reference/declarationEmitDestructuringOptionalBindingParametersInOverloads.types

@@ -12,7 +12,7 @@ function foo(...rest: any[]) {
 }
 
 function foo2( { x, y, z }?: { x: string; y: number; z: boolean });
->foo2 : ({ x, y, z }?: { x: string; y: number; z: boolean; }) => any
+>foo2 : ({x, y, z}?: { x: string; y: number; z: boolean; }) => any
 >x : string
 >y : number
 >z : boolean
@@ -21,7 +21,7 @@ function foo2( { x, y, z }?: { x: string; y: number; z: boolean });
 >z : boolean
 
 function foo2(...rest: any[]) {
->foo2 : ({ x, y, z }?: { x: string; y: number; z: boolean; }) => any
+>foo2 : ({x, y, z}?: { x: string; y: number; z: boolean; }) => any
 >rest : any[]
 
 }

tests/baselines/reference/declarationEmit_bindingPatterns.js

@@ -0,0 +1,26 @@
+//// [declarationEmit_bindingPatterns.ts]
+
+const k = ({x: z = 'y'}) => { }
+
+var a;
+function f({} = a, [] = a, { p: {} = a} = a) {
+}
+
+//// [declarationEmit_bindingPatterns.js]
+var k = function (_a) {
+    var _b = _a.x, z = _b === void 0 ? 'y' : _b;
+};
+var a;
+function f(_a, _b, _c) {
+    var _a = a;
+    var _b = a;
+    var _d = (_c === void 0 ? a : _c).p, _e = _d === void 0 ? a : _d;
+}
+
+
+//// [declarationEmit_bindingPatterns.d.ts]
+declare const k: ({x: z}: {
+    x?: string;
+}) => void;
+declare var a: any;
+declare function f({}?: any, []?: any, {p: {}}?: any): void;

tests/baselines/reference/declarationEmit_bindingPatterns.symbols

@@ -0,0 +1,17 @@
+=== tests/cases/compiler/declarationEmit_bindingPatterns.ts ===
+
+const k = ({x: z = 'y'}) => { }
+>k : Symbol(k, Decl(declarationEmit_bindingPatterns.ts, 1, 5))
+>x : Symbol(x)
+>z : Symbol(z, Decl(declarationEmit_bindingPatterns.ts, 1, 12))
+
+var a;
+>a : Symbol(a, Decl(declarationEmit_bindingPatterns.ts, 3, 3))
+
+function f({} = a, [] = a, { p: {} = a} = a) {
+>f : Symbol(f, Decl(declarationEmit_bindingPatterns.ts, 3, 6))
+>a : Symbol(a, Decl(declarationEmit_bindingPatterns.ts, 3, 3))
+>a : Symbol(a, Decl(declarationEmit_bindingPatterns.ts, 3, 3))
+>a : Symbol(a, Decl(declarationEmit_bindingPatterns.ts, 3, 3))
+>a : Symbol(a, Decl(declarationEmit_bindingPatterns.ts, 3, 3))
+}

tests/baselines/reference/declarationEmit_bindingPatterns.types

@@ -0,0 +1,20 @@
+=== tests/cases/compiler/declarationEmit_bindingPatterns.ts ===
+
+const k = ({x: z = 'y'}) => { }
+>k : ({x: z}: { x?: string; }) => void
+>({x: z = 'y'}) => { } : ({x: z}: { x?: string; }) => void
+>x : any
+>z : string
+>'y' : string
+
+var a;
+>a : any
+
+function f({} = a, [] = a, { p: {} = a} = a) {
+>f : ({}?: any, []?: any, {p: {}}?: any) => void
+>a : any
+>a : any
+>p : any
+>a : any
+>a : any
+}

tests/baselines/reference/destructuringInFunctionType.types

@@ -29,7 +29,7 @@ type T2 = ({ a });
 >a : any
 
 type F2 = ({ a }) => void;
->F2 : ({ a }: { a: any; }) => void
+>F2 : ({a}: { a: any; }) => void
 >a : any
 
 type T3 = ([{ a: b }, { b: a }]);
@@ -40,7 +40,7 @@ type T3 = ([{ a: b }, { b: a }]);
 >a : a
 
 type F3 = ([{ a: b }, { b: a }]) => void;
->F3 : ([{ a: b }, { b: a }]: [{ a: any; }, { b: any; }]) => void
+>F3 : ([{a: b}, {b: a}]: [{ a: any; }, { b: any; }]) => void
 >a : any
 >b : any
 >b : any
@@ -53,13 +53,13 @@ type T4 = ([{ a: [b, c] }]);
 >c : c
 
 type F4 = ([{ a: [b, c] }]) => void;
->F4 : ([{ a: [b, c] }]: [{ a: [any, any]; }]) => void
+>F4 : ([{a: [b, c]}]: [{ a: [any, any]; }]) => void
 >a : any
 >b : any
 >c : any
 
 type C1 = new ([{ a: [b, c] }]) => void;
->C1 : new ([{ a: [b, c] }]: [{ a: [any, any]; }]) => void
+>C1 : new ([{a: [b, c]}]: [{ a: [any, any]; }]) => void
 >a : any
 >b : any
 >c : any

tests/baselines/reference/destructuringWithLiteralInitializers.types

@@ -1,13 +1,13 @@
 === tests/cases/conformance/es6/destructuring/destructuringWithLiteralInitializers.ts ===
 // (arg: { x: any, y: any }) => void
 function f1({ x, y }) { }
->f1 : ({ x, y }: { x: any; y: any; }) => void
+>f1 : ({x, y}: { x: any; y: any; }) => void
 >x : any
 >y : any
 
 f1({ x: 1, y: 1 });
 >f1({ x: 1, y: 1 }) : void
->f1 : ({ x, y }: { x: any; y: any; }) => void
+>f1 : ({x, y}: { x: any; y: any; }) => void
 >{ x: 1, y: 1 } : { x: number; y: number; }
 >x : number
 >1 : number
@@ -16,21 +16,21 @@ f1({ x: 1, y: 1 });
 
 // (arg: { x: any, y?: number }) => void
 function f2({ x, y = 0 }) { }
->f2 : ({ x, y = 0 }: { x: any; y?: number; }) => void
+>f2 : ({x, y}: { x: any; y?: number; }) => void
 >x : any
 >y : number
 >0 : number
 
 f2({ x: 1 });
 >f2({ x: 1 }) : void
->f2 : ({ x, y = 0 }: { x: any; y?: number; }) => void
+>f2 : ({x, y}: { x: any; y?: number; }) => void
 >{ x: 1 } : { x: number; }
 >x : number
 >1 : number
 
 f2({ x: 1, y: 1 });
 >f2({ x: 1, y: 1 }) : void
->f2 : ({ x, y = 0 }: { x: any; y?: number; }) => void
+>f2 : ({x, y}: { x: any; y?: number; }) => void
 >{ x: 1, y: 1 } : { x: number; y: number; }
 >x : number
 >1 : number
@@ -39,7 +39,7 @@ f2({ x: 1, y: 1 });
 
 // (arg: { x?: number, y?: number }) => void
 function f3({ x = 0, y = 0 }) { }
->f3 : ({ x = 0, y = 0 }: { x?: number; y?: number; }) => void
+>f3 : ({x, y}: { x?: number; y?: number; }) => void
 >x : number
 >0 : number
 >y : number
@@ -47,26 +47,26 @@ function f3({ x = 0, y = 0 }) { }
 
 f3({});
 >f3({}) : void
->f3 : ({ x = 0, y = 0 }: { x?: number; y?: number; }) => void
+>f3 : ({x, y}: { x?: number; y?: number; }) => void
 >{} : {}
 
 f3({ x: 1 });
 >f3({ x: 1 }) : void
->f3 : ({ x = 0, y = 0 }: { x?: number; y?: number; }) => void
+>f3 : ({x, y}: { x?: number; y?: number; }) => void
 >{ x: 1 } : { x: number; }
 >x : number
 >1 : number
 
 f3({ y: 1 });
 >f3({ y: 1 }) : void
->f3 : ({ x = 0, y = 0 }: { x?: number; y?: number; }) => void
+>f3 : ({x, y}: { x?: number; y?: number; }) => void
 >{ y: 1 } : { y: number; }
 >y : number
 >1 : number
 
 f3({ x: 1, y: 1 });
 >f3({ x: 1, y: 1 }) : void
->f3 : ({ x = 0, y = 0 }: { x?: number; y?: number; }) => void
+>f3 : ({x, y}: { x?: number; y?: number; }) => void
 >{ x: 1, y: 1 } : { x: number; y: number; }
 >x : number
 >1 : number
@@ -75,7 +75,7 @@ f3({ x: 1, y: 1 });
 
 // (arg?: { x: number, y: number }) => void
 function f4({ x, y } = { x: 0, y: 0 }) { }
->f4 : ({ x, y }?: { x: number; y: number; }) => void
+>f4 : ({x, y}?: { x: number; y: number; }) => void
 >x : number
 >y : number
 >{ x: 0, y: 0 } : { x: number; y: number; }
@@ -86,11 +86,11 @@ function f4({ x, y } = { x: 0, y: 0 }) { }
 
 f4();
 >f4() : void
->f4 : ({ x, y }?: { x: number; y: number; }) => void
+>f4 : ({x, y}?: { x: number; y: number; }) => void
 
 f4({ x: 1, y: 1 });
 >f4({ x: 1, y: 1 }) : void
->f4 : ({ x, y }?: { x: number; y: number; }) => void
+>f4 : ({x, y}?: { x: number; y: number; }) => void
 >{ x: 1, y: 1 } : { x: number; y: number; }
 >x : number
 >1 : number
@@ -99,7 +99,7 @@ f4({ x: 1, y: 1 });
 
 // (arg?: { x: number, y?: number }) => void
 function f5({ x, y = 0 } = { x: 0 }) { }
->f5 : ({ x, y = 0 }?: { x: number; y?: number; }) => void
+>f5 : ({x, y}?: { x: number; y?: number; }) => void
 >x : number
 >y : number
 >0 : number
@@ -109,18 +109,18 @@ function f5({ x, y = 0 } = { x: 0 }) { }
 
 f5();
 >f5() : void
->f5 : ({ x, y = 0 }?: { x: number; y?: number; }) => void
+>f5 : ({x, y}?: { x: number; y?: number; }) => void
 
 f5({ x: 1 });
 >f5({ x: 1 }) : void
->f5 : ({ x, y = 0 }?: { x: number; y?: number; }) => void
+>f5 : ({x, y}?: { x: number; y?: number; }) => void
 >{ x: 1 } : { x: number; }
 >x : number
 >1 : number
 
 f5({ x: 1, y: 1 });
 >f5({ x: 1, y: 1 }) : void
->f5 : ({ x, y = 0 }?: { x: number; y?: number; }) => void
+>f5 : ({x, y}?: { x: number; y?: number; }) => void
 >{ x: 1, y: 1 } : { x: number; y: number; }
 >x : number
 >1 : number
@@ -129,7 +129,7 @@ f5({ x: 1, y: 1 });
 
 // (arg?: { x?: number, y?: number }) => void
 function f6({ x = 0, y = 0 } = {}) { }
->f6 : ({ x = 0, y = 0 }?: { x?: number; y?: number; }) => void
+>f6 : ({x, y}?: { x?: number; y?: number; }) => void
 >x : number
 >0 : number
 >y : number
@@ -138,30 +138,30 @@ function f6({ x = 0, y = 0 } = {}) { }
 
 f6();
 >f6() : void
->f6 : ({ x = 0, y = 0 }?: { x?: number; y?: number; }) => void
+>f6 : ({x, y}?: { x?: number; y?: number; }) => void
 
 f6({});
 >f6({}) : void
->f6 : ({ x = 0, y = 0 }?: { x?: number; y?: number; }) => void
+>f6 : ({x, y}?: { x?: number; y?: number; }) => void
 >{} : {}
 
 f6({ x: 1 });
 >f6({ x: 1 }) : void
->f6 : ({ x = 0, y = 0 }?: { x?: number; y?: number; }) => void
+>f6 : ({x, y}?: { x?: number; y?: number; }) => void
 >{ x: 1 } : { x: number; }
 >x : number
 >1 : number
 
 f6({ y: 1 });
 >f6({ y: 1 }) : void
->f6 : ({ x = 0, y = 0 }?: { x?: number; y?: number; }) => void
+>f6 : ({x, y}?: { x?: number; y?: number; }) => void
 >{ y: 1 } : { y: number; }
 >y : number
 >1 : number
 
 f6({ x: 1, y: 1 });
 >f6({ x: 1, y: 1 }) : void
->f6 : ({ x = 0, y = 0 }?: { x?: number; y?: number; }) => void
+>f6 : ({x, y}?: { x?: number; y?: number; }) => void
 >{ x: 1, y: 1 } : { x: number; y: number; }
 >x : number
 >1 : number
@@ -170,7 +170,7 @@ f6({ x: 1, y: 1 });
 
 // (arg?: { a: { x?: number, y?: number } }) => void
 function f7({ a: { x = 0, y = 0 } } = { a: {} }) { }
->f7 : ({ a: { x = 0, y = 0 } }?: { a: { x?: number; y?: number; }; }) => void
+>f7 : ({a: {x, y}}?: { a: { x?: number; y?: number; }; }) => void
 >a : any
 >x : number
 >0 : number
@@ -182,18 +182,18 @@ function f7({ a: { x = 0, y = 0 } } = { a: {} }) { }
 
 f7();
 >f7() : void
->f7 : ({ a: { x = 0, y = 0 } }?: { a: { x?: number; y?: number; }; }) => void
+>f7 : ({a: {x, y}}?: { a: { x?: number; y?: number; }; }) => void
 
 f7({ a: {} });
 >f7({ a: {} }) : void
->f7 : ({ a: { x = 0, y = 0 } }?: { a: { x?: number; y?: number; }; }) => void
+>f7 : ({a: {x, y}}?: { a: { x?: number; y?: number; }; }) => void
 >{ a: {} } : { a: {}; }
 >a : {}
 >{} : {}
 
 f7({ a: { x: 1 } });
 >f7({ a: { x: 1 } }) : void
->f7 : ({ a: { x = 0, y = 0 } }?: { a: { x?: number; y?: number; }; }) => void
+>f7 : ({a: {x, y}}?: { a: { x?: number; y?: number; }; }) => void
 >{ a: { x: 1 } } : { a: { x: number; }; }
 >a : { x: number; }
 >{ x: 1 } : { x: number; }
@@ -202,7 +202,7 @@ f7({ a: { x: 1 } });
 
 f7({ a: { y: 1 } });
 >f7({ a: { y: 1 } }) : void
->f7 : ({ a: { x = 0, y = 0 } }?: { a: { x?: number; y?: number; }; }) => void
+>f7 : ({a: {x, y}}?: { a: { x?: number; y?: number; }; }) => void
 >{ a: { y: 1 } } : { a: { y: number; }; }
 >a : { y: number; }
 >{ y: 1 } : { y: number; }
@@ -211,7 +211,7 @@ f7({ a: { y: 1 } });
 
 f7({ a: { x: 1, y: 1 } });
 >f7({ a: { x: 1, y: 1 } }) : void
->f7 : ({ a: { x = 0, y = 0 } }?: { a: { x?: number; y?: number; }; }) => void
+>f7 : ({a: {x, y}}?: { a: { x?: number; y?: number; }; }) => void
 >{ a: { x: 1, y: 1 } } : { a: { x: number; y: number; }; }
 >a : { x: number; y: number; }
 >{ x: 1, y: 1 } : { x: number; y: number; }
@@ -235,7 +235,7 @@ g1([1, 1]);
 
 // (arg: [number, number]) => void
 function g2([x = 0, y = 0]) { }
->g2 : ([x = 0, y = 0]: [number, number]) => void
+>g2 : ([x, y]: [number, number]) => void
 >x : number
 >0 : number
 >y : number
@@ -243,7 +243,7 @@ function g2([x = 0, y = 0]) { }
 
 g2([1, 1]);
 >g2([1, 1]) : void
->g2 : ([x = 0, y = 0]: [number, number]) => void
+>g2 : ([x, y]: [number, number]) => void
 >[1, 1] : [number, number]
 >1 : number
 >1 : number
@@ -270,7 +270,7 @@ g3([1, 1]);
 
 // (arg?: [number, number]) => void
 function g4([x, y = 0] = [0]) { }
->g4 : ([x, y = 0]?: [number, number]) => void
+>g4 : ([x, y]?: [number, number]) => void
 >x : number
 >y : number
 >0 : number
@@ -279,18 +279,18 @@ function g4([x, y = 0] = [0]) { }
 
 g4();
 >g4() : void
->g4 : ([x, y = 0]?: [number, number]) => void
+>g4 : ([x, y]?: [number, number]) => void
 
 g4([1, 1]);
 >g4([1, 1]) : void
->g4 : ([x, y = 0]?: [number, number]) => void
+>g4 : ([x, y]?: [number, number]) => void
 >[1, 1] : [number, number]
 >1 : number
 >1 : number
 
 // (arg?: [number, number]) => void
 function g5([x = 0, y = 0] = []) { }
->g5 : ([x = 0, y = 0]?: [number, number]) => void
+>g5 : ([x, y]?: [number, number]) => void
 >x : number
 >0 : number
 >y : number
@@ -299,11 +299,11 @@ function g5([x = 0, y = 0] = []) { }
 
 g5();
 >g5() : void
->g5 : ([x = 0, y = 0]?: [number, number]) => void
+>g5 : ([x, y]?: [number, number]) => void
 
 g5([1, 1]);
 >g5([1, 1]) : void
->g5 : ([x = 0, y = 0]?: [number, number]) => void
+>g5 : ([x, y]?: [number, number]) => void
 >[1, 1] : [number, number]
 >1 : number
 >1 : number

tests/baselines/reference/emitArrowFunctionES6.types

@@ -64,31 +64,31 @@ var p4 = ([, ...a]) => { };
 >a : any[]
 
 var p5 = ([a = 1]) => { };
->p5 : ([a = 1]: [number]) => void
->([a = 1]) => { } : ([a = 1]: [number]) => void
+>p5 : ([a]: [number]) => void
+>([a = 1]) => { } : ([a]: [number]) => void
 >a : number
 >1 : number
 
 var p6 = ({ a }) => { };
->p6 : ({ a }: { a: any; }) => void
->({ a }) => { } : ({ a }: { a: any; }) => void
+>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
+>p7 : ({a: {b}}: { a: { b: any; }; }) => void
+>({ a: { b } }) => { } : ({a: {b}}: { a: { b: any; }; }) => void
 >a : any
 >b : any
 
 var p8 = ({ a = 1 }) => { };
->p8 : ({ a = 1 }: { a?: number; }) => void
->({ a = 1 }) => { } : ({ a = 1 }: { a?: number; }) => void
+>p8 : ({a}: { a?: number; }) => void
+>({ a = 1 }) => { } : ({a}: { a?: number; }) => void
 >a : number
 >1 : 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
+>p9 : ({a: {b}}: { a?: { b?: number; }; }) => void
+>({ a: { b = 1 } = { b: 1 } }) => { } : ({a: {b}}: { a?: { b?: number; }; }) => void
 >a : any
 >b : number
 >1 : number
@@ -97,8 +97,8 @@ var p9 = ({ a: { b = 1 } = { b: 1 } }) => { };
 >1 : number
 
 var p10 = ([{ value, done }]) => { };
->p10 : ([{ value, done }]: [{ value: any; done: any; }]) => void
->([{ value, done }]) => { } : ([{ value, done }]: [{ value: any; done: any; }]) => void
+>p10 : ([{value, done}]: [{ value: any; done: any; }]) => void
+>([{ value, done }]) => { } : ([{value, done}]: [{ value: any; done: any; }]) => void
 >value : any
 >done : any
 

tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES5.types

@@ -62,7 +62,7 @@
     }
 
     function f({} = a, [] = a, { p: {} = a} = a) {
->f : ({}?: any, []?: any, { p: {} = a}?: any) => ({}?: any, []?: any, { p: {} = a }?: any) => any
+>f : ({}?: any, []?: any, {p: {}}?: any) => ({}?: any, []?: any, {p: {}}?: any) => any
 >a : any
 >a : any
 >p : any
@@ -70,7 +70,7 @@
 >a : any
 
         return ({} = a, [] = a, { p: {} = a } = a) => a;
->({} = a, [] = a, { p: {} = a } = a) => a : ({}?: any, []?: any, { p: {} = a }?: any) => any
+>({} = a, [] = a, { p: {} = a } = a) => a : ({}?: any, []?: any, {p: {}}?: any) => any
 >a : any
 >a : any
 >p : any

tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES6.types

@@ -62,7 +62,7 @@
     }
 
     function f({} = a, [] = a, { p: {} = a} = a) {
->f : ({}?: any, []?: any, { p: {} = a}?: any) => ({}?: any, []?: any, { p: {} = a }?: any) => any
+>f : ({}?: any, []?: any, {p: {}}?: any) => ({}?: any, []?: any, {p: {}}?: any) => any
 >a : any
 >a : any
 >p : any
@@ -70,7 +70,7 @@
 >a : any
 
         return ({} = a, [] = a, { p: {} = a } = a) => a;
->({} = a, [] = a, { p: {} = a } = a) => a : ({}?: any, []?: any, { p: {} = a }?: any) => any
+>({} = a, [] = a, { p: {} = a } = a) => a : ({}?: any, []?: any, {p: {}}?: any) => any
 >a : any
 >a : any
 >p : any

tests/baselines/reference/sourceMapValidationDestructuringParameterNestedObjectBindingPattern.types

@@ -37,7 +37,7 @@ var robotA: Robot = { name: "mower", skills: { primary: "mowing", secondary: "no
 >"none" : string
 
 function foo1({ skills: { primary: primaryA, secondary: secondaryA } }: Robot) {
->foo1 : ({ skills: { primary: primaryA, secondary: secondaryA } }: Robot) => void
+>foo1 : ({skills: {primary: primaryA, secondary: secondaryA}}: Robot) => void
 >skills : any
 >primary : any
 >primaryA : string
@@ -53,7 +53,7 @@ function foo1({ skills: { primary: primaryA, secondary: secondaryA } }: Robot) {
 >primaryA : string
 }
 function foo2({ name: nameC, skills: { primary: primaryB, secondary: secondaryB } }: Robot) {
->foo2 : ({ name: nameC, skills: { primary: primaryB, secondary: secondaryB } }: Robot) => void
+>foo2 : ({name: nameC, skills: {primary: primaryB, secondary: secondaryB}}: Robot) => void
 >name : any
 >nameC : string
 >skills : any
@@ -71,7 +71,7 @@ function foo2({ name: nameC, skills: { primary: primaryB, secondary: secondaryB
 >secondaryB : string
 }
 function foo3({ skills }: Robot) {
->foo3 : ({ skills }: Robot) => void
+>foo3 : ({skills}: Robot) => void
 >skills : { primary: string; secondary: string; }
 >Robot : Robot
 
@@ -87,12 +87,12 @@ function foo3({ skills }: Robot) {
 
 foo1(robotA);
 >foo1(robotA) : void
->foo1 : ({ skills: { primary: primaryA, secondary: secondaryA } }: Robot) => void
+>foo1 : ({skills: {primary: primaryA, secondary: secondaryA}}: Robot) => void
 >robotA : Robot
 
 foo1({ name: "Edger", skills: { primary: "edging", secondary: "branch trimming" } });
 >foo1({ name: "Edger", skills: { primary: "edging", secondary: "branch trimming" } }) : void
->foo1 : ({ skills: { primary: primaryA, secondary: secondaryA } }: Robot) => void
+>foo1 : ({skills: {primary: primaryA, secondary: secondaryA}}: Robot) => void
 >{ name: "Edger", skills: { primary: "edging", secondary: "branch trimming" } } : { name: string; skills: { primary: string; secondary: string; }; }
 >name : string
 >"Edger" : string
@@ -105,12 +105,12 @@ foo1({ name: "Edger", skills: { primary: "edging", secondary: "branch trimming"
 
 foo2(robotA);
 >foo2(robotA) : void
->foo2 : ({ name: nameC, skills: { primary: primaryB, secondary: secondaryB } }: Robot) => void
+>foo2 : ({name: nameC, skills: {primary: primaryB, secondary: secondaryB}}: Robot) => void
 >robotA : Robot
 
 foo2({ name: "Edger", skills: { primary: "edging", secondary: "branch trimming" } });
 >foo2({ name: "Edger", skills: { primary: "edging", secondary: "branch trimming" } }) : void
->foo2 : ({ name: nameC, skills: { primary: primaryB, secondary: secondaryB } }: Robot) => void
+>foo2 : ({name: nameC, skills: {primary: primaryB, secondary: secondaryB}}: Robot) => void
 >{ name: "Edger", skills: { primary: "edging", secondary: "branch trimming" } } : { name: string; skills: { primary: string; secondary: string; }; }
 >name : string
 >"Edger" : string
@@ -123,12 +123,12 @@ foo2({ name: "Edger", skills: { primary: "edging", secondary: "branch trimming"
 
 foo3(robotA);
 >foo3(robotA) : void
->foo3 : ({ skills }: Robot) => void
+>foo3 : ({skills}: Robot) => void
 >robotA : Robot
 
 foo3({ name: "Edger", skills: { primary: "edging", secondary: "branch trimming" } });
 >foo3({ name: "Edger", skills: { primary: "edging", secondary: "branch trimming" } }) : void
->foo3 : ({ skills }: Robot) => void
+>foo3 : ({skills}: Robot) => void
 >{ name: "Edger", skills: { primary: "edging", secondary: "branch trimming" } } : { name: string; skills: { primary: string; secondary: string; }; }
 >name : string
 >"Edger" : string

tests/baselines/reference/sourceMapValidationDestructuringParameterNestedObjectBindingPatternDefaultValues.types

@@ -37,12 +37,7 @@ var robotA: Robot = { name: "mower", skills: { primary: "mowing", secondary: "no
 >"none" : string
 
 function foo1(
->foo1 : ({
-        skills: {
-            primary: primaryA = "primary",
-            secondary: secondaryA = "secondary"
-        } = { primary: "SomeSkill", secondary: "someSkill" }
-    }?: Robot) => void
+>foo1 : ({skills: {primary: primaryA, secondary: secondaryA}}?: Robot) => void
     {
         skills: {
 >skills : any
@@ -76,13 +71,7 @@ function foo1(
 >primaryA : string
 }
 function foo2(
->foo2 : ({
-        name: nameC = "name",
-        skills: {
-            primary: primaryB = "primary",
-            secondary: secondaryB = "secondary"
-        } = { primary: "SomeSkill", secondary: "someSkill" }
-    }?: Robot) => void
+>foo2 : ({name: nameC, skills: {primary: primaryB, secondary: secondaryB}}?: Robot) => void
     {
         name: nameC = "name",
 >name : any
@@ -121,7 +110,7 @@ function foo2(
 >secondaryB : string
 }
 function foo3({ skills = { primary: "SomeSkill", secondary: "someSkill" }  }: Robot = robotA) {
->foo3 : ({ skills = { primary: "SomeSkill", secondary: "someSkill" }  }?: Robot) => void
+>foo3 : ({skills}?: Robot) => void
 >skills : { primary?: string; secondary?: string; }
 >{ primary: "SomeSkill", secondary: "someSkill" } : { primary: string; secondary: string; }
 >primary : string
@@ -143,22 +132,12 @@ function foo3({ skills = { primary: "SomeSkill", secondary: "someSkill" }  }: Ro
 
 foo1(robotA);
 >foo1(robotA) : void
->foo1 : ({
-        skills: {
-            primary: primaryA = "primary",
-            secondary: secondaryA = "secondary"
-        } = { primary: "SomeSkill", secondary: "someSkill" }
-    }?: Robot) => void
+>foo1 : ({skills: {primary: primaryA, secondary: secondaryA}}?: Robot) => void
 >robotA : Robot
 
 foo1({ name: "Edger", skills: { primary: "edging", secondary: "branch trimming" } });
 >foo1({ name: "Edger", skills: { primary: "edging", secondary: "branch trimming" } }) : void
->foo1 : ({
-        skills: {
-            primary: primaryA = "primary",
-            secondary: secondaryA = "secondary"
-        } = { primary: "SomeSkill", secondary: "someSkill" }
-    }?: Robot) => void
+>foo1 : ({skills: {primary: primaryA, secondary: secondaryA}}?: Robot) => void
 >{ name: "Edger", skills: { primary: "edging", secondary: "branch trimming" } } : { name: string; skills: { primary: string; secondary: string; }; }
 >name : string
 >"Edger" : string
@@ -171,24 +150,12 @@ foo1({ name: "Edger", skills: { primary: "edging", secondary: "branch trimming"
 
 foo2(robotA);
 >foo2(robotA) : void
->foo2 : ({
-        name: nameC = "name",
-        skills: {
-            primary: primaryB = "primary",
-            secondary: secondaryB = "secondary"
-        } = { primary: "SomeSkill", secondary: "someSkill" }
-    }?: Robot) => void
+>foo2 : ({name: nameC, skills: {primary: primaryB, secondary: secondaryB}}?: Robot) => void
 >robotA : Robot
 
 foo2({ name: "Edger", skills: { primary: "edging", secondary: "branch trimming" } });
 >foo2({ name: "Edger", skills: { primary: "edging", secondary: "branch trimming" } }) : void
->foo2 : ({
-        name: nameC = "name",
-        skills: {
-            primary: primaryB = "primary",
-            secondary: secondaryB = "secondary"
-        } = { primary: "SomeSkill", secondary: "someSkill" }
-    }?: Robot) => void
+>foo2 : ({name: nameC, skills: {primary: primaryB, secondary: secondaryB}}?: Robot) => void
 >{ name: "Edger", skills: { primary: "edging", secondary: "branch trimming" } } : { name: string; skills: { primary: string; secondary: string; }; }
 >name : string
 >"Edger" : string
@@ -201,12 +168,12 @@ foo2({ name: "Edger", skills: { primary: "edging", secondary: "branch trimming"
 
 foo3(robotA);
 >foo3(robotA) : void
->foo3 : ({ skills = { primary: "SomeSkill", secondary: "someSkill" }  }?: Robot) => void
+>foo3 : ({skills}?: Robot) => void
 >robotA : Robot
 
 foo3({ name: "Edger", skills: { primary: "edging", secondary: "branch trimming" } });
 >foo3({ name: "Edger", skills: { primary: "edging", secondary: "branch trimming" } }) : void
->foo3 : ({ skills = { primary: "SomeSkill", secondary: "someSkill" }  }?: Robot) => void
+>foo3 : ({skills}?: Robot) => void
 >{ name: "Edger", skills: { primary: "edging", secondary: "branch trimming" } } : { name: string; skills: { primary: string; secondary: string; }; }
 >name : string
 >"Edger" : string

tests/baselines/reference/sourceMapValidationDestructuringParameterObjectBindingPattern.types

@@ -29,7 +29,7 @@ var robotA: Robot = { name: "mower", skill: "mowing" };
 >"mowing" : string
 
 function foo1({ name: nameA }: Robot) {
->foo1 : ({ name: nameA }: Robot) => void
+>foo1 : ({name: nameA}: Robot) => void
 >name : any
 >nameA : string
 >Robot : Robot
@@ -42,7 +42,7 @@ function foo1({ name: nameA }: Robot) {
 >nameA : string
 }
 function foo2({ name: nameB, skill: skillB }: Robot) {
->foo2 : ({ name: nameB, skill: skillB }: Robot) => void
+>foo2 : ({name: nameB, skill: skillB}: Robot) => void
 >name : any
 >nameB : string
 >skill : any
@@ -57,7 +57,7 @@ function foo2({ name: nameB, skill: skillB }: Robot) {
 >nameB : string
 }
 function foo3({ name }: Robot) {
->foo3 : ({ name }: Robot) => void
+>foo3 : ({name}: Robot) => void
 >name : string
 >Robot : Robot
 
@@ -71,12 +71,12 @@ function foo3({ name }: Robot) {
 
 foo1(robotA);
 >foo1(robotA) : void
->foo1 : ({ name: nameA }: Robot) => void
+>foo1 : ({name: nameA}: Robot) => void
 >robotA : Robot
 
 foo1({ name: "Edger", skill: "cutting edges" });
 >foo1({ name: "Edger", skill: "cutting edges" }) : void
->foo1 : ({ name: nameA }: Robot) => void
+>foo1 : ({name: nameA}: Robot) => void
 >{ name: "Edger", skill: "cutting edges" } : { name: string; skill: string; }
 >name : string
 >"Edger" : string
@@ -85,12 +85,12 @@ foo1({ name: "Edger", skill: "cutting edges" });
 
 foo2(robotA);
 >foo2(robotA) : void
->foo2 : ({ name: nameB, skill: skillB }: Robot) => void
+>foo2 : ({name: nameB, skill: skillB}: Robot) => void
 >robotA : Robot
 
 foo2({ name: "Edger", skill: "cutting edges" });
 >foo2({ name: "Edger", skill: "cutting edges" }) : void
->foo2 : ({ name: nameB, skill: skillB }: Robot) => void
+>foo2 : ({name: nameB, skill: skillB}: Robot) => void
 >{ name: "Edger", skill: "cutting edges" } : { name: string; skill: string; }
 >name : string
 >"Edger" : string
@@ -99,12 +99,12 @@ foo2({ name: "Edger", skill: "cutting edges" });
 
 foo3(robotA);
 >foo3(robotA) : void
->foo3 : ({ name }: Robot) => void
+>foo3 : ({name}: Robot) => void
 >robotA : Robot
 
 foo3({ name: "Edger", skill: "cutting edges" });
 >foo3({ name: "Edger", skill: "cutting edges" }) : void
->foo3 : ({ name }: Robot) => void
+>foo3 : ({name}: Robot) => void
 >{ name: "Edger", skill: "cutting edges" } : { name: string; skill: string; }
 >name : string
 >"Edger" : string

tests/baselines/reference/sourceMapValidationDestructuringParameterObjectBindingPatternDefaultValues.types

@@ -29,7 +29,7 @@ var robotA: Robot = { name: "mower", skill: "mowing" };
 >"mowing" : string
 
 function foo1({ name: nameA = "<NoName>" }: Robot = { }) {
->foo1 : ({ name: nameA = "<NoName>" }?: Robot) => void
+>foo1 : ({name: nameA}?: Robot) => void
 >name : any
 >nameA : string
 >"<NoName>" : string
@@ -44,7 +44,7 @@ function foo1({ name: nameA = "<NoName>" }: Robot = { }) {
 >nameA : string
 }
 function foo2({ name: nameB = "<NoName>", skill: skillB = "noSkill" }: Robot = {}) {
->foo2 : ({ name: nameB = "<NoName>", skill: skillB = "noSkill" }?: Robot) => void
+>foo2 : ({name: nameB, skill: skillB}?: Robot) => void
 >name : any
 >nameB : string
 >"<NoName>" : string
@@ -62,7 +62,7 @@ function foo2({ name: nameB = "<NoName>", skill: skillB = "noSkill" }: Robot = {
 >nameB : string
 }
 function foo3({ name = "<NoName>" }: Robot = {}) {
->foo3 : ({ name = "<NoName>" }?: Robot) => void
+>foo3 : ({name}?: Robot) => void
 >name : string
 >"<NoName>" : string
 >Robot : Robot
@@ -78,12 +78,12 @@ function foo3({ name = "<NoName>" }: Robot = {}) {
 
 foo1(robotA);
 >foo1(robotA) : void
->foo1 : ({ name: nameA = "<NoName>" }?: Robot) => void
+>foo1 : ({name: nameA}?: Robot) => void
 >robotA : Robot
 
 foo1({ name: "Edger", skill: "cutting edges" });
 >foo1({ name: "Edger", skill: "cutting edges" }) : void
->foo1 : ({ name: nameA = "<NoName>" }?: Robot) => void
+>foo1 : ({name: nameA}?: Robot) => void
 >{ name: "Edger", skill: "cutting edges" } : { name: string; skill: string; }
 >name : string
 >"Edger" : string
@@ -92,12 +92,12 @@ foo1({ name: "Edger", skill: "cutting edges" });
 
 foo2(robotA);
 >foo2(robotA) : void
->foo2 : ({ name: nameB = "<NoName>", skill: skillB = "noSkill" }?: Robot) => void
+>foo2 : ({name: nameB, skill: skillB}?: Robot) => void
 >robotA : Robot
 
 foo2({ name: "Edger", skill: "cutting edges" });
 >foo2({ name: "Edger", skill: "cutting edges" }) : void
->foo2 : ({ name: nameB = "<NoName>", skill: skillB = "noSkill" }?: Robot) => void
+>foo2 : ({name: nameB, skill: skillB}?: Robot) => void
 >{ name: "Edger", skill: "cutting edges" } : { name: string; skill: string; }
 >name : string
 >"Edger" : string
@@ -106,12 +106,12 @@ foo2({ name: "Edger", skill: "cutting edges" });
 
 foo3(robotA);
 >foo3(robotA) : void
->foo3 : ({ name = "<NoName>" }?: Robot) => void
+>foo3 : ({name}?: Robot) => void
 >robotA : Robot
 
 foo3({ name: "Edger", skill: "cutting edges" });
 >foo3({ name: "Edger", skill: "cutting edges" }) : void
->foo3 : ({ name = "<NoName>" }?: Robot) => void
+>foo3 : ({name}?: Robot) => void
 >{ name: "Edger", skill: "cutting edges" } : { name: string; skill: string; }
 >name : string
 >"Edger" : string

tests/baselines/reference/sourceMapValidationDestructuringParametertArrayBindingPatternDefaultValues.types

@@ -18,7 +18,7 @@ var robotA: Robot = [1, "mower", "mowing"];
 >"mowing" : string
 
 function foo1([, nameA = "noName"]: Robot = [-1, "name", "skill"]) {
->foo1 : ([, nameA = "noName"]?: [number, string, string]) => void
+>foo1 : ([, nameA]?: [number, string, string]) => void
 > : undefined
 >nameA : string
 >"noName" : string
@@ -38,7 +38,7 @@ function foo1([, nameA = "noName"]: Robot = [-1, "name", "skill"]) {
 }
 
 function foo2([numberB = -1]: Robot = [-1, "name", "skill"]) {
->foo2 : ([numberB = -1]?: [number, string, string]) => void
+>foo2 : ([numberB]?: [number, string, string]) => void
 >numberB : number
 >-1 : number
 >1 : number
@@ -58,7 +58,7 @@ function foo2([numberB = -1]: Robot = [-1, "name", "skill"]) {
 }
 
 function foo3([numberA2 = -1, nameA2 = "name", skillA2 = "skill"]: Robot = [-1, "name", "skill"]) {
->foo3 : ([numberA2 = -1, nameA2 = "name", skillA2 = "skill"]?: [number, string, string]) => void
+>foo3 : ([numberA2, nameA2, skillA2]?: [number, string, string]) => void
 >numberA2 : number
 >-1 : number
 >1 : number
@@ -82,7 +82,7 @@ function foo3([numberA2 = -1, nameA2 = "name", skillA2 = "skill"]: Robot = [-1,
 }
 
 function foo4([numberA3 = -1, ...robotAInfo]: Robot = [-1, "name", "skill"]) {
->foo4 : ([numberA3 = -1, ...robotAInfo]?: [number, string, string]) => void
+>foo4 : ([numberA3, ...robotAInfo]?: [number, string, string]) => void
 >numberA3 : number
 >-1 : number
 >1 : number
@@ -104,12 +104,12 @@ function foo4([numberA3 = -1, ...robotAInfo]: Robot = [-1, "name", "skill"]) {
 
 foo1(robotA);
 >foo1(robotA) : void
->foo1 : ([, nameA = "noName"]?: [number, string, string]) => void
+>foo1 : ([, nameA]?: [number, string, string]) => void
 >robotA : [number, string, string]
 
 foo1([2, "trimmer", "trimming"]);
 >foo1([2, "trimmer", "trimming"]) : void
->foo1 : ([, nameA = "noName"]?: [number, string, string]) => void
+>foo1 : ([, nameA]?: [number, string, string]) => void
 >[2, "trimmer", "trimming"] : [number, string, string]
 >2 : number
 >"trimmer" : string
@@ -117,12 +117,12 @@ foo1([2, "trimmer", "trimming"]);
 
 foo2(robotA);
 >foo2(robotA) : void
->foo2 : ([numberB = -1]?: [number, string, string]) => void
+>foo2 : ([numberB]?: [number, string, string]) => void
 >robotA : [number, string, string]
 
 foo2([2, "trimmer", "trimming"]);
 >foo2([2, "trimmer", "trimming"]) : void
->foo2 : ([numberB = -1]?: [number, string, string]) => void
+>foo2 : ([numberB]?: [number, string, string]) => void
 >[2, "trimmer", "trimming"] : [number, string, string]
 >2 : number
 >"trimmer" : string
@@ -130,12 +130,12 @@ foo2([2, "trimmer", "trimming"]);
 
 foo3(robotA);
 >foo3(robotA) : void
->foo3 : ([numberA2 = -1, nameA2 = "name", skillA2 = "skill"]?: [number, string, string]) => void
+>foo3 : ([numberA2, nameA2, skillA2]?: [number, string, string]) => void
 >robotA : [number, string, string]
 
 foo3([2, "trimmer", "trimming"]);
 >foo3([2, "trimmer", "trimming"]) : void
->foo3 : ([numberA2 = -1, nameA2 = "name", skillA2 = "skill"]?: [number, string, string]) => void
+>foo3 : ([numberA2, nameA2, skillA2]?: [number, string, string]) => void
 >[2, "trimmer", "trimming"] : [number, string, string]
 >2 : number
 >"trimmer" : string
@@ -143,12 +143,12 @@ foo3([2, "trimmer", "trimming"]);
 
 foo4(robotA);
 >foo4(robotA) : void
->foo4 : ([numberA3 = -1, ...robotAInfo]?: [number, string, string]) => void
+>foo4 : ([numberA3, ...robotAInfo]?: [number, string, string]) => void
 >robotA : [number, string, string]
 
 foo4([2, "trimmer", "trimming"]);
 >foo4([2, "trimmer", "trimming"]) : void
->foo4 : ([numberA3 = -1, ...robotAInfo]?: [number, string, string]) => void
+>foo4 : ([numberA3, ...robotAInfo]?: [number, string, string]) => void
 >[2, "trimmer", "trimming"] : [number, string, string]
 >2 : number
 >"trimmer" : string

tests/baselines/reference/sourceMapValidationDestructuringParametertArrayBindingPatternDefaultValues2.types

@@ -19,7 +19,7 @@ var robotA: Robot = ["trimmer", ["trimming", "edging"]];
 >"edging" : string
 
 function foo1([, skillA = ["noSkill", "noSkill"]]: Robot= ["name", ["skill1", "skill2"]]) {
->foo1 : ([, skillA = ["noSkill", "noSkill"]]?: [string, string[]]) => void
+>foo1 : ([, skillA]?: [string, string[]]) => void
 > : undefined
 >skillA : string[]
 >["noSkill", "noSkill"] : string[]
@@ -41,7 +41,7 @@ function foo1([, skillA = ["noSkill", "noSkill"]]: Robot= ["name", ["skill1", "s
 }
 
 function foo2([nameMB = "noName"]: Robot = ["name", ["skill1", "skill2"]]) {
->foo2 : ([nameMB = "noName"]?: [string, string[]]) => void
+>foo2 : ([nameMB]?: [string, string[]]) => void
 >nameMB : string
 >"noName" : string
 >Robot : [string, string[]]
@@ -60,10 +60,7 @@ function foo2([nameMB = "noName"]: Robot = ["name", ["skill1", "skill2"]]) {
 }
 
 function foo3([nameMA = "noName", [
->foo3 : ([nameMA = "noName", [
-    primarySkillA = "primary",
-    secondarySkillA = "secondary"
-] = ["noSkill", "noSkill"]]: [string, string[]]) => void
+>foo3 : ([nameMA, [primarySkillA, secondarySkillA]]: [string, string[]]) => void
 >nameMA : string
 >"noName" : string
 
@@ -91,12 +88,12 @@ function foo3([nameMA = "noName", [
 
 foo1(robotA);
 >foo1(robotA) : void
->foo1 : ([, skillA = ["noSkill", "noSkill"]]?: [string, string[]]) => void
+>foo1 : ([, skillA]?: [string, string[]]) => void
 >robotA : [string, string[]]
 
 foo1(["roomba", ["vaccum", "mopping"]]);
 >foo1(["roomba", ["vaccum", "mopping"]]) : void
->foo1 : ([, skillA = ["noSkill", "noSkill"]]?: [string, string[]]) => void
+>foo1 : ([, skillA]?: [string, string[]]) => void
 >["roomba", ["vaccum", "mopping"]] : [string, string[]]
 >"roomba" : string
 >["vaccum", "mopping"] : string[]
@@ -105,12 +102,12 @@ foo1(["roomba", ["vaccum", "mopping"]]);
 
 foo2(robotA);
 >foo2(robotA) : void
->foo2 : ([nameMB = "noName"]?: [string, string[]]) => void
+>foo2 : ([nameMB]?: [string, string[]]) => void
 >robotA : [string, string[]]
 
 foo2(["roomba", ["vaccum", "mopping"]]);
 >foo2(["roomba", ["vaccum", "mopping"]]) : void
->foo2 : ([nameMB = "noName"]?: [string, string[]]) => void
+>foo2 : ([nameMB]?: [string, string[]]) => void
 >["roomba", ["vaccum", "mopping"]] : [string, string[]]
 >"roomba" : string
 >["vaccum", "mopping"] : string[]
@@ -119,18 +116,12 @@ foo2(["roomba", ["vaccum", "mopping"]]);
 
 foo3(robotA);
 >foo3(robotA) : void
->foo3 : ([nameMA = "noName", [
-    primarySkillA = "primary",
-    secondarySkillA = "secondary"
-] = ["noSkill", "noSkill"]]: [string, string[]]) => void
+>foo3 : ([nameMA, [primarySkillA, secondarySkillA]]: [string, string[]]) => void
 >robotA : [string, string[]]
 
 foo3(["roomba", ["vaccum", "mopping"]]);
 >foo3(["roomba", ["vaccum", "mopping"]]) : void
->foo3 : ([nameMA = "noName", [
-    primarySkillA = "primary",
-    secondarySkillA = "secondary"
-] = ["noSkill", "noSkill"]]: [string, string[]]) => void
+>foo3 : ([nameMA, [primarySkillA, secondarySkillA]]: [string, string[]]) => void
 >["roomba", ["vaccum", "mopping"]] : [string, string[]]
 >"roomba" : string
 >["vaccum", "mopping"] : string[]

tests/cases/compiler/declarationEmit_bindingPatterns.ts

@@ -0,0 +1,7 @@
+// @declaration: true
+
+const k = ({x: z = 'y'}) => { }
+
+var a;
+function f({} = a, [] = a, { p: {} = a} = a) {
+}