207 lines
4.5 KiB
Plaintext
207 lines
4.5 KiB
Plaintext
=== tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration3ES5.ts ===
|
|
|
|
// If the parameter is a rest parameter, the parameter type is any[]
|
|
// A type annotation for a rest parameter must denote an array type.
|
|
|
|
// RestParameter:
|
|
// ... Identifier TypeAnnotation(opt)
|
|
|
|
type arrayString = Array<String>
|
|
>arrayString : String[]
|
|
>Array : T[]
|
|
>String : String
|
|
|
|
type someArray = Array<String> | number[];
|
|
>someArray : number[] | String[]
|
|
>Array : T[]
|
|
>String : String
|
|
|
|
type stringOrNumArray = Array<String|Number>;
|
|
>stringOrNumArray : (String | Number)[]
|
|
>Array : T[]
|
|
>String : String
|
|
>Number : Number
|
|
|
|
function a1(...x: (number|string)[]) { }
|
|
>a1 : (...x: (string | number)[]) => void
|
|
>x : (string | number)[]
|
|
|
|
function a2(...a) { }
|
|
>a2 : (...a: any[]) => void
|
|
>a : any[]
|
|
|
|
function a3(...a: Array<String>) { }
|
|
>a3 : (...a: String[]) => void
|
|
>a : String[]
|
|
>Array : T[]
|
|
>String : String
|
|
|
|
function a4(...a: arrayString) { }
|
|
>a4 : (...a: String[]) => void
|
|
>a : String[]
|
|
>arrayString : String[]
|
|
|
|
function a5(...a: stringOrNumArray) { }
|
|
>a5 : (...a: (String | Number)[]) => void
|
|
>a : (String | Number)[]
|
|
>stringOrNumArray : (String | Number)[]
|
|
|
|
function a9([a, b, [[c]]]) { }
|
|
>a9 : ([a, b, [[c]]]: [any, any, [[any]]]) => void
|
|
>a : any
|
|
>b : any
|
|
>c : any
|
|
|
|
function a10([a, b, [[c]], ...x]) { }
|
|
>a10 : ([a, b, [[c]], ...x]: Iterable<any>) => void
|
|
>a : any
|
|
>b : any
|
|
>c : any
|
|
>x : any[]
|
|
|
|
function a11([a, b, c, ...x]: number[]) { }
|
|
>a11 : ([a, b, c, ...x]: number[]) => void
|
|
>a : number
|
|
>b : number
|
|
>c : number
|
|
>x : number[]
|
|
|
|
|
|
var array = [1, 2, 3];
|
|
>array : number[]
|
|
>[1, 2, 3] : number[]
|
|
>1 : number
|
|
>2 : number
|
|
>3 : number
|
|
|
|
var array2 = [true, false, "hello"];
|
|
>array2 : (string | boolean)[]
|
|
>[true, false, "hello"] : (string | boolean)[]
|
|
>true : boolean
|
|
>false : boolean
|
|
>"hello" : string
|
|
|
|
a2([...array]);
|
|
>a2([...array]) : void
|
|
>a2 : (...a: any[]) => void
|
|
>[...array] : number[]
|
|
>...array : number
|
|
>array : number[]
|
|
|
|
a1(...array);
|
|
>a1(...array) : void
|
|
>a1 : (...x: (string | number)[]) => void
|
|
>...array : number
|
|
>array : number[]
|
|
|
|
a9([1, 2, [["string"]], false, true]); // Parameter type is [any, any, [[any]]]
|
|
>a9([1, 2, [["string"]], false, true]) : void
|
|
>a9 : ([a, b, [[c]]]: [any, any, [[any]]]) => void
|
|
>[1, 2, [["string"]], false, true] : [number, number, [[string]], boolean, boolean]
|
|
>1 : number
|
|
>2 : number
|
|
>[["string"]] : [[string]]
|
|
>["string"] : [string]
|
|
>"string" : string
|
|
>false : boolean
|
|
>true : boolean
|
|
|
|
a10([1, 2, [["string"]], false, true]); // Parameter type is any[]
|
|
>a10([1, 2, [["string"]], false, true]) : void
|
|
>a10 : ([a, b, [[c]], ...x]: Iterable<any>) => void
|
|
>[1, 2, [["string"]], false, true] : (number | boolean | string[][])[]
|
|
>1 : number
|
|
>2 : number
|
|
>[["string"]] : string[][]
|
|
>["string"] : string[]
|
|
>"string" : string
|
|
>false : boolean
|
|
>true : boolean
|
|
|
|
a10([1, 2, 3, false, true]); // Parameter type is any[]
|
|
>a10([1, 2, 3, false, true]) : void
|
|
>a10 : ([a, b, [[c]], ...x]: Iterable<any>) => void
|
|
>[1, 2, 3, false, true] : (number | boolean)[]
|
|
>1 : number
|
|
>2 : number
|
|
>3 : number
|
|
>false : boolean
|
|
>true : boolean
|
|
|
|
a10([1, 2]); // Parameter type is any[]
|
|
>a10([1, 2]) : void
|
|
>a10 : ([a, b, [[c]], ...x]: Iterable<any>) => void
|
|
>[1, 2] : number[]
|
|
>1 : number
|
|
>2 : number
|
|
|
|
a11([1, 2]); // Parameter type is number[]
|
|
>a11([1, 2]) : void
|
|
>a11 : ([a, b, c, ...x]: number[]) => void
|
|
>[1, 2] : number[]
|
|
>1 : number
|
|
>2 : number
|
|
|
|
// Rest parameter with generic
|
|
function foo<T>(...a: T[]) { }
|
|
>foo : <T>(...a: T[]) => void
|
|
>T : T
|
|
>a : T[]
|
|
>T : T
|
|
|
|
foo<number|string>("hello", 1, 2);
|
|
>foo<number|string>("hello", 1, 2) : void
|
|
>foo : <T>(...a: T[]) => void
|
|
>"hello" : string
|
|
>1 : number
|
|
>2 : number
|
|
|
|
foo("hello", "world");
|
|
>foo("hello", "world") : void
|
|
>foo : <T>(...a: T[]) => void
|
|
>"hello" : string
|
|
>"world" : string
|
|
|
|
enum E { a, b }
|
|
>E : E
|
|
>a : E
|
|
>b : E
|
|
|
|
const enum E1 { a, b }
|
|
>E1 : E1
|
|
>a : E1
|
|
>b : E1
|
|
|
|
function foo1<T extends Number>(...a: T[]) { }
|
|
>foo1 : <T extends Number>(...a: T[]) => void
|
|
>T : T
|
|
>Number : Number
|
|
>a : T[]
|
|
>T : T
|
|
|
|
foo1(1, 2, 3, E.a);
|
|
>foo1(1, 2, 3, E.a) : void
|
|
>foo1 : <T extends Number>(...a: T[]) => void
|
|
>1 : number
|
|
>2 : number
|
|
>3 : number
|
|
>E.a : E
|
|
>E : typeof E
|
|
>a : E
|
|
|
|
foo1(1, 2, 3, E1.a, E.b);
|
|
>foo1(1, 2, 3, E1.a, E.b) : void
|
|
>foo1 : <T extends Number>(...a: T[]) => void
|
|
>1 : number
|
|
>2 : number
|
|
>3 : number
|
|
>E1.a : E1
|
|
>E1 : typeof E1
|
|
>a : E1
|
|
>E.b : E
|
|
>E : typeof E
|
|
>b : E
|
|
|
|
|
|
|