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
140
141
|
=== tests/cases/compiler/typePredicatesInUnion3.ts ===
// A union of function types is considered a type predicate if at least one constituent is a type
// predicate and the other constituents are matching type predicates or functions returning `false`.
type P1 = (x: unknown) => x is string;
>P1 : (x: unknown) => x is string
>x : unknown
type P2 = (x: unknown) => x is number;
>P2 : (x: unknown) => x is number
>x : unknown
type F1 = (x: unknown) => false;
>F1 : (x: unknown) => false
>x : unknown
>false : false
type F2 = (x: unknown) => boolean;
>F2 : (x: unknown) => boolean
>x : unknown
type F3 = (x: unknown) => string;
>F3 : (x: unknown) => string
>x : unknown
function f1(x: unknown, p: P1 | P2) {
>f1 : (x: unknown, p: P1 | P2) => void
>x : unknown
>p : P1 | P2
if (p(x)) {
>p(x) : boolean
>p : P1 | P2
>x : unknown
x; // string | number
>x : string | number
}
}
function f2(x: unknown, p: P1 | P2 | F1) {
>f2 : (x: unknown, p: P1 | P2 | F1) => void
>x : unknown
>p : P1 | P2 | F1
if (p(x)) {
>p(x) : boolean
>p : P1 | P2 | F1
>x : unknown
x; // string | number
>x : string | number
}
}
function f3(x: unknown, p: P1 | P2 | F2) {
>f3 : (x: unknown, p: P1 | P2 | F2) => void
>x : unknown
>p : P1 | P2 | F2
if (p(x)) {
>p(x) : boolean
>p : P1 | P2 | F2
>x : unknown
x; // unknown
>x : unknown
}
}
function f4(x: unknown, p: P1 | P2 | F3) {
>f4 : (x: unknown, p: P1 | P2 | F3) => void
>x : unknown
>p : P1 | P2 | F3
if (p(x)) {
>p(x) : string | boolean
>p : P1 | P2 | F3
>x : unknown
x; // unknown
>x : unknown
}
}
// Repro from #54143
type HasAttribute<T> = T & { attribute: number };
>HasAttribute : HasAttribute<T>
>attribute : number
class Type1 {
>Type1 : Type1
attribute: number | null = null;
>attribute : number | null
predicate(): this is HasAttribute<Type1> {
>predicate : () => this is HasAttribute<Type1>
return true;
>true : true
}
}
class Type2 {
>Type2 : Type2
attribute: number | null = null;
>attribute : number | null
predicate(): boolean {
>predicate : () => boolean
return true;
>true : true
}
}
function assertType<T>(_val: T) {
>assertType : <T>(_val: T) => void
>_val : T
}
declare const val: Type1 | Type2;
>val : Type1 | Type2
if (val.predicate()) {
>val.predicate() : boolean
>val.predicate : (() => this is HasAttribute<Type1>) | (() => boolean)
>val : Type1 | Type2
>predicate : (() => this is HasAttribute<Type1>) | (() => boolean)
assertType<number>(val.attribute); // Error
>assertType<number>(val.attribute) : void
>assertType : <T>(_val: T) => void
>val.attribute : number | null
>val : Type1 | Type2
>attribute : number | null
}
|
