microsoft/TypeScript
1
0
Fork 0
mirror of https://github.com/microsoft/TypeScript.git synced 2026-02-10 15:25:54 -06:00
Code Issues Packages Projects Releases 212 Wiki Activity

Correctelly serialize types with signatures containing binding patterns

Browse Source
This commit is contained in:
Mohamed Hegazy 2016-02-24 12:54:20 -08:00
parent 0f67f4b6f1
commit 217f5583c6
19 changed files with 207 additions and 199 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

66
src/compiler/checker.ts
View File

@ -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,65 @@ 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 store inside the node.
if (bindingPattern.kind === SyntaxKind.ObjectBindingPattern) {
writePunctuation(writer, SyntaxKind.OpenBraceToken);
buildDisplatForCommaSeparatedList(bindingPattern.elements, writer, enclosingDeclaration, flags, symbolStack, buildBindingElementDisplay);
writePunctuation(writer, SyntaxKind.CloseBraceToken);
}
else if (bindingPattern.kind === SyntaxKind.ArrayBindingPattern) {
writePunctuation(writer, SyntaxKind.OpenBracketToken);
const elements = bindingPattern.elements;
buildDisplatForCommaSeparatedList(bindingPattern.elements, writer, enclosingDeclaration, flags, symbolStack, buildBindingElementDisplay);
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) {
writeSpace(writer);
}
else if (bindingElement.kind === SyntaxKind.BindingElement) {
if (bindingElement.propertyName) {
writer.writeSymbol(getTextOfNode(bindingElement.propertyName), bindingElement.symbol);
writePunctuation(writer, SyntaxKind.ColonToken);
}
if (bindingElement.name) {
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);
}
buildDisplatForCommaSeparatedList(typeParameters, writer, enclosingDeclaration, flags, symbolStack, buildTypeParameterDisplay);
writePunctuation(writer, SyntaxKind.GreaterThanToken);
}
}
function buildDisplatForCommaSeparatedList<T>(list: T[], writer: SymbolWriter, enclosingDeclaration: Node, flags: TypeFormatFlags, symbolStack: Symbol[], action: (item: T, writer: SymbolWriter, enclosingDeclaration: Node, flags: TypeFormatFlags, symbolStack: Symbol[]) => void) {
for (let i = 0; i < list.length; i++) {
if (i > 0) {
writePunctuation(writer, SyntaxKind.CommaToken);
writeSpace(writer);
}
action(list[i], writer, enclosingDeclaration, flags, symbolStack);
}
}
function buildDisplayForTypeArgumentsAndDelimiters(typeParameters: TypeParameter[], mapper: TypeMapper, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags, symbolStack?: Symbol[]) {
if (typeParameters && typeParameters.length) {
writePunctuation(writer, SyntaxKind.LessThanToken);

2
tests/baselines/reference/arrayBindingPatternOmittedExpressions.types
View File

@ -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

32
tests/baselines/reference/arrowFunctionExpressions.types
View File

@ -65,43 +65,43 @@ var p2 = ([...a]) => { };
>a : any[]
var p3 = ([, a]) => { };
>p3 : ([, a]: [any, any]) => void
>([, a]) => { } : ([, a]: [any, any]) => void
>p3 : ([ , a]: [any, any]) => void
>([, a]) => { } : ([ , a]: [any, any]) => void
> : undefined
>a : any
var p4 = ([, ...a]) => { };
>p4 : ([, ...a]: any[]) => void
>([, ...a]) => { } : ([, ...a]: any[]) => void
>p4 : ([ , ...a]: any[]) => void
>([, ...a]) => { } : ([ , ...a]: any[]) => void
> : undefined
>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

2
tests/baselines/reference/declarationEmitDestructuring1.types
View File

@ -21,7 +21,7 @@ function bar({a1, b1, c1}: { a1: number, b1: boolean, c1: string }): void { }
>c1 : string
function baz({a2, b2: {b1, c1}}: { a2: number, b2: { b1: boolean, c1: string } }): void { }
>baz : ({a2, b2: {b1, c1}}: { a2: number; b2: { b1: boolean; c1: string; }; }) => void
>baz : ({a2, b2:{b1, c1}}: { a2: number; b2: { b1: boolean; c1: string; }; }) => void
>a2 : number
>b2 : any
>b1 : boolean

10
tests/baselines/reference/declarationEmitDestructuring5.types
View File

@ -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

4
tests/baselines/reference/declarationEmitDestructuringOptionalBindingParametersInOverloads.types
View File

@ -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[]
}

8
tests/baselines/reference/destructuringInFunctionType.types
View File

@ -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

74
tests/baselines/reference/destructuringWithLiteralInitializers.types
View File

@ -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

32
tests/baselines/reference/emitArrowFunctionES6.types
View File

@ -52,43 +52,43 @@ var p2 = ([...a]) => { };
>a : any[]
var p3 = ([, a]) => { };
>p3 : ([, a]: [any, any]) => void
>([, a]) => { } : ([, a]: [any, any]) => void
>p3 : ([ , a]: [any, any]) => void
>([, a]) => { } : ([ , a]: [any, any]) => void
> : undefined
>a : any
var p4 = ([, ...a]) => { };
>p4 : ([, ...a]: Iterable<any>) => void
>([, ...a]) => { } : ([, ...a]: Iterable<any>) => void
>p4 : ([ , ...a]: Iterable<any>) => void
>([, ...a]) => { } : ([ , ...a]: Iterable<any>) => void
> : undefined
>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

4
tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES5.types
View File

@ -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

4
tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES6.types
View File

@ -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

18
tests/baselines/reference/sourceMapValidationDestructuringParameterNestedObjectBindingPattern.types
View File

@ -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

51
tests/baselines/reference/sourceMapValidationDestructuringParameterNestedObjectBindingPatternDefaultValues.types
View File

@ -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

18
tests/baselines/reference/sourceMapValidationDestructuringParameterObjectBindingPattern.types
View File

@ -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

18
tests/baselines/reference/sourceMapValidationDestructuringParameterObjectBindingPatternDefaultValues.types
View File

@ -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

6
tests/baselines/reference/sourceMapValidationDestructuringParametertArrayBindingPattern.types
View File

@ -18,7 +18,7 @@ var robotA: Robot = [1, "mower", "mowing"];
>"mowing" : string
function foo1([, nameA]: Robot) {
>foo1 : ([, nameA]: [number, string, string]) => void
>foo1 : ([ , nameA]: [number, string, string]) => void
> : undefined
>nameA : string
>Robot : [number, string, string]
@ -75,12 +75,12 @@ function foo4([numberA3, ...robotAInfo]: Robot) {
foo1(robotA);
>foo1(robotA) : void
>foo1 : ([, nameA]: [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]: [number, string, string]) => void
>foo1 : ([ , nameA]: [number, string, string]) => void
>[2, "trimmer", "trimming"] : [number, string, string]
>2 : number
>"trimmer" : string

6
tests/baselines/reference/sourceMapValidationDestructuringParametertArrayBindingPattern2.types
View File

@ -19,7 +19,7 @@ var robotA: Robot = ["trimmer", ["trimming", "edging"]];
>"edging" : string
function foo1([, skillA]: Robot) {
>foo1 : ([, skillA]: [string, [string, string]]) => void
>foo1 : ([ , skillA]: [string, [string, string]]) => void
> : undefined
>skillA : [string, string]
>Robot : [string, [string, string]]
@ -75,12 +75,12 @@ function foo4([...multiRobotAInfo]: Robot) {
foo1(robotA);
>foo1(robotA) : void
>foo1 : ([, skillA]: [string, [string, string]]) => void
>foo1 : ([ , skillA]: [string, [string, string]]) => void
>robotA : [string, [string, string]]
foo1(["roomba", ["vaccum", "mopping"]]);
>foo1(["roomba", ["vaccum", "mopping"]]) : void
>foo1 : ([, skillA]: [string, [string, string]]) => void
>foo1 : ([ , skillA]: [string, [string, string]]) => void
>["roomba", ["vaccum", "mopping"]] : [string, [string, string]]
>"roomba" : string
>["vaccum", "mopping"] : [string, string]

24
tests/baselines/reference/sourceMapValidationDestructuringParametertArrayBindingPatternDefaultValues.types
View File

@ -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

27
tests/baselines/reference/sourceMapValidationDestructuringParametertArrayBindingPatternDefaultValues2.types
View File

@ -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[]