1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
|
//// [tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration4.ts] ////
=== destructuringParameterDeclaration4.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[]
type someArray = Array<String> | number[];
>someArray : String[] | number[]
type stringOrNumArray = Array<String|Number>;
>stringOrNumArray : (String | Number)[]
function a0(...x: [number, number, string]) { } // Error, rest parameter must be array type
>a0 : (x_0: number, x_1: number, x_2: string) => void
>x : [number, number, string]
function a1(...x: (number|string)[]) { }
>a1 : (...x: (number | string)[]) => void
>x : (string | number)[]
function a2(...a: someArray) { } // Error, rest parameter must be array type
>a2 : (...a: someArray) => void
>a : someArray
function a3(...b?) { } // Error, can't be optional
>a3 : (...b?: any[]) => void
>b : any[]
function a4(...b = [1,2,3]) { } // Error, can't have initializer
>a4 : (...b?: number[]) => void
>b : number[]
>[1,2,3] : number[]
>1 : 1
>2 : 2
>3 : 3
function a5([a, b, [[c]]]) { }
>a5 : ([a, b, [[c]]]: [any, any, [[any]]]) => void
>a : any
>b : any
>c : any
function a6([a, b, c, ...x]: number[]) { }
>a6 : ([a, b, c, ...x]: number[]) => void
>a : number
>b : number
>c : number
>x : number[]
a1(1, 2, "hello", true); // Error, parameter type is (number|string)[]
>a1(1, 2, "hello", true) : void
>a1 : (...x: (string | number)[]) => void
>1 : 1
>2 : 2
>"hello" : "hello"
>true : true
a1(...array2); // Error parameter type is (number|string)[]
>a1(...array2) : void
>a1 : (...x: (string | number)[]) => void
>...array2 : any
>array2 : any
a5([1, 2, "string", false, true]); // Error, parameter type is [any, any, [[any]]]
>a5([1, 2, "string", false, true]) : void
>a5 : ([a, b, [[c]]]: [any, any, [[any]]]) => void
>[1, 2, "string", false, true] : [number, number, string, boolean, boolean]
>1 : 1
>2 : 2
>"string" : "string"
>false : false
>true : true
a5([1, 2]); // Error, parameter type is [any, any, [[any]]]
>a5([1, 2]) : void
>a5 : ([a, b, [[c]]]: [any, any, [[any]]]) => void
>[1, 2] : [number, number]
>1 : 1
>2 : 2
a6([1, 2, "string"]); // Error, parameter type is number[]
>a6([1, 2, "string"]) : void
>a6 : ([a, b, c, ...x]: number[]) => void
>[1, 2, "string"] : (string | number)[]
>1 : 1
>2 : 2
>"string" : "string"
var temp = [1, 2, 3];
>temp : number[]
>[1, 2, 3] : number[]
>1 : 1
>2 : 2
>3 : 3
class C {
>C : C
constructor(public ...temp) { } // Error, rest parameter can't have properties
>temp : any[]
}
// Rest parameter with generic
function foo1<T extends Number>(...a: T[]) { }
>foo1 : <T extends Number>(...a: T[]) => void
>a : T[]
foo1(1, 2, "string", E1.a, E.b); // Error
>foo1(1, 2, "string", E1.a, E.b) : void
>foo1 : <T extends Number>(...a: T[]) => void
>1 : 1
>2 : 2
>"string" : "string"
>E1.a : any
>E1 : any
>a : any
>E.b : any
>E : any
>b : any
|
