TypeScript/tests/baselines/reference/discriminantPropertyInference.types at 8b3588d749c4821f6ace5d5f081754fcae039a0f · microsoft/TypeScript · GitHub

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
131
132
133
134
135
136
137
138
139
=== tests/cases/compiler/discriminantPropertyInference.ts ===
// Repro from #41759

type DiscriminatorTrue = {
>DiscriminatorTrue : DiscriminatorTrue

    disc: true;
>disc : true
>true : true

    cb: (x: string) => void;
>cb : (x: string) => void
>x : string
}

type DiscriminatorFalse = {
>DiscriminatorFalse : DiscriminatorFalse

    disc?: false;
>disc : false | undefined
>false : false

    cb: (x: number) => void;
>cb : (x: number) => void
>x : number
}

type Unrelated = {
>Unrelated : Unrelated

    val: number;
>val : number
}

declare function f(options: DiscriminatorTrue | DiscriminatorFalse): any;
>f : (options: DiscriminatorTrue | DiscriminatorFalse) => any
>options : DiscriminatorTrue | DiscriminatorFalse

// simple inference
f({
>f({    disc: true,    cb: s => parseInt(s)}) : any
>f : (options: DiscriminatorTrue | DiscriminatorFalse) => any
>{    disc: true,    cb: s => parseInt(s)} : { disc: true; cb: (s: string) => number; }

    disc: true,
>disc : true
>true : true

    cb: s => parseInt(s)
>cb : (s: string) => number
>s => parseInt(s) : (s: string) => number
>s : string
>parseInt(s) : number
>parseInt : (string: string, radix?: number | undefined) => number
>s : string

});

// simple inference
f({
>f({    disc: false,    cb: n => n.toFixed()}) : any
>f : (options: DiscriminatorTrue | DiscriminatorFalse) => any
>{    disc: false,    cb: n => n.toFixed()} : { disc: false; cb: (n: number) => string; }

    disc: false,
>disc : false
>false : false

    cb: n => n.toFixed()
>cb : (n: number) => string
>n => n.toFixed() : (n: number) => string
>n : number
>n.toFixed() : string
>n.toFixed : (fractionDigits?: number | undefined) => string
>n : number
>toFixed : (fractionDigits?: number | undefined) => string

});

// simple inference when strict-null-checks are enabled
f({
>f({    disc: undefined,    cb: n => n.toFixed()}) : any
>f : (options: DiscriminatorTrue | DiscriminatorFalse) => any
>{    disc: undefined,    cb: n => n.toFixed()} : { disc: undefined; cb: (n: number) => string; }

    disc: undefined,
>disc : undefined
>undefined : undefined

    cb: n => n.toFixed()
>cb : (n: number) => string
>n => n.toFixed() : (n: number) => string
>n : number
>n.toFixed() : string
>n.toFixed : (fractionDigits?: number | undefined) => string
>n : number
>toFixed : (fractionDigits?: number | undefined) => string

});

// requires checking type information since discriminator is missing from object
f({
>f({    cb: n => n.toFixed()}) : any
>f : (options: DiscriminatorTrue | DiscriminatorFalse) => any
>{    cb: n => n.toFixed()} : { cb: (n: number) => string; }

    cb: n => n.toFixed()
>cb : (n: number) => string
>n => n.toFixed() : (n: number) => string
>n : number
>n.toFixed() : string
>n.toFixed : (fractionDigits?: number | undefined) => string
>n : number
>toFixed : (fractionDigits?: number | undefined) => string

});


declare function g(options: DiscriminatorTrue | DiscriminatorFalse | Unrelated): any;
>g : (options: DiscriminatorTrue | DiscriminatorFalse | Unrelated) => any
>options : DiscriminatorTrue | DiscriminatorFalse | Unrelated

// requires checking properties of all types, rather than properties of just the union type (e.g. only intersection)
g({
>g({    cb: n => n.toFixed()}) : any
>g : (options: DiscriminatorTrue | DiscriminatorFalse | Unrelated) => any
>{    cb: n => n.toFixed()} : { cb: (n: number) => string; }

    cb: n => n.toFixed()
>cb : (n: number) => string
>n => n.toFixed() : (n: number) => string
>n : number
>n.toFixed() : string
>n.toFixed : (fractionDigits?: number | undefined) => string
>n : number
>toFixed : (fractionDigits?: number | undefined) => string

});