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
|
=== tests/cases/conformance/types/typeRelationships/bestCommonType/bestCommonTypeOfConditionalExpressions.ts ===
// conditional expressions return the best common type of the branches plus contextual type (using the first candidate if multiple BCTs exist)
// no errors expected here
var a: { x: number; y?: number };
>a : { x: number; y?: number; }
>x : number
>y : number
var b: { x: number; z?: number };
>b : { x: number; z?: number; }
>x : number
>z : number
class Base { foo: string; }
>Base : Base
>foo : string
class Derived extends Base { bar: string; }
>Derived : Derived
>Base : Base
>bar : string
class Derived2 extends Base { baz: string; }
>Derived2 : Derived2
>Base : Base
>baz : string
var base: Base;
>base : Base
var derived: Derived;
>derived : Derived
var derived2: Derived2;
>derived2 : Derived2
var r = true ? 1 : 2;
>r : number
>true ? 1 : 2 : 1 | 2
>true : true
>1 : 1
>2 : 2
var r3 = true ? 1 : {};
>r3 : {}
>true ? 1 : {} : 1 | {}
>true : true
>1 : 1
>{} : {}
var r4 = true ? a : b; // typeof a
>r4 : { x: number; y?: number; } | { x: number; z?: number; }
>true ? a : b : { x: number; y?: number; } | { x: number; z?: number; }
>true : true
>a : { x: number; y?: number; }
>b : { x: number; z?: number; }
var r5 = true ? b : a; // typeof b
>r5 : { x: number; y?: number; } | { x: number; z?: number; }
>true ? b : a : { x: number; y?: number; } | { x: number; z?: number; }
>true : true
>b : { x: number; z?: number; }
>a : { x: number; y?: number; }
var r6 = true ? (x: number) => { } : (x: Object) => { }; // returns number => void
>r6 : (x: number) => void
>true ? (x: number) => { } : (x: Object) => { } : (x: number) => void
>true : true
>(x: number) => { } : (x: number) => void
>x : number
>(x: Object) => { } : (x: Object) => void
>x : Object
var r7: (x: Object) => void = true ? (x: number) => { } : (x: Object) => { };
>r7 : (x: Object) => void
>x : Object
>true ? (x: number) => { } : (x: Object) => { } : (x: number) => void
>true : true
>(x: number) => { } : (x: number) => void
>x : number
>(x: Object) => { } : (x: Object) => void
>x : Object
var r8 = true ? (x: Object) => { } : (x: number) => { }; // returns Object => void
>r8 : (x: Object) => void
>true ? (x: Object) => { } : (x: number) => { } : (x: Object) => void
>true : true
>(x: Object) => { } : (x: Object) => void
>x : Object
>(x: number) => { } : (x: number) => void
>x : number
var r10: Base = true ? derived : derived2; // no error since we use the contextual type in BCT
>r10 : Base
>true ? derived : derived2 : Derived | Derived2
>true : true
>derived : Derived
>derived2 : Derived2
var r11 = true ? base : derived2;
>r11 : Base
>true ? base : derived2 : Base
>true : true
>base : Base
>derived2 : Derived2
function foo5<T, U>(t: T, u: U): Object {
>foo5 : <T, U>(t: T, u: U) => Object
>t : T
>u : U
return true ? t : u; // BCT is Object
>true ? t : u : T | U
>true : true
>t : T
>u : U
}
|
