=== tests/cases/conformance/statements/switchStatements/switchStatements.ts ===
module M {
>M : typeof M

    export function fn(x: number) {
>fn : (x: number) => string
>x : number

        return '';
>'' : string
    }
}

var x: any;
>x : any

switch (x) {
>x : any

    case '':
>'' : string

    case 12:
>12 : number

    case true:
>true : boolean

    case null:
>null : null

    case undefined:
>undefined : undefined

    case new Date(12):
>new Date(12) : Date
>Date : DateConstructor
>12 : number

    case new Object():
>new Object() : Object
>Object : ObjectConstructor

    case /[a-z]/:
>/[a-z]/ : RegExp

    case[]:
>[] : undefined[]

    case {}:
>{} : {}

    case { id: 12 }:
>{ id: 12 } : { id: number; }
>id : number
>12 : number

    case['a']:
>['a'] : string[]
>'a' : string

    case typeof x:
>typeof x : string
>x : any

    case typeof M:
>typeof M : string
>M : typeof M

    case M.fn(1):
>M.fn(1) : string
>M.fn : (x: number) => string
>M : typeof M
>fn : (x: number) => string
>1 : number

    case <T>(x: number) => '':
><T>(x: number) => '' : <T>(x: number) => string
>T : T
>x : number
>'' : string

    case (<T>(x: number) => '')(2):
>(<T>(x: number) => '')(2) : string
>(<T>(x: number) => '') : <T>(x: number) => string
><T>(x: number) => '' : <T>(x: number) => string
>T : T
>x : number
>'' : string
>2 : number

    default:
}

// basic assignable check, rest covered in tests for 'assignement compatibility'
class C { id: number; }
>C : C
>id : number

class D extends C { name: string }
>D : D
>C : C
>name : string

switch (new C()) {
>new C() : C
>C : typeof C

    case new D():
>new D() : D
>D : typeof D

    case { id: 12, name: '' }:
>{ id: 12, name: '' } : { id: number; name: string; }
>id : number
>12 : number
>name : string
>'' : string

    case new C():
>new C() : C
>C : typeof C
}

switch ('') { }
>'' : string

switch (12) { }
>12 : number

switch (true) { }
>true : boolean

switch (null) { }
>null : null

switch (undefined) { }
>undefined : undefined

switch (new Date(12)) { }
>new Date(12) : Date
>Date : DateConstructor
>12 : number

switch (new Object()) { }
>new Object() : Object
>Object : ObjectConstructor

switch (/[a-z]/) { }
>/[a-z]/ : RegExp

switch ([]) { }
>[] : undefined[]

switch ({}) { }
>{} : {}

switch ({ id: 12 }) { }
>{ id: 12 } : { id: number; }
>id : number
>12 : number

switch (['a']) { }
>['a'] : string[]
>'a' : string

switch (<T>(x: number) => '') { }
><T>(x: number) => '' : <T>(x: number) => string
>T : T
>x : number
>'' : string

switch ((<T>(x: T) => '')(1)) { }
>(<T>(x: T) => '')(1) : string
>(<T>(x: T) => '') : <T>(x: T) => string
><T>(x: T) => '' : <T>(x: T) => string
>T : T
>x : T
>T : T
>'' : string
>1 : number