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