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
142
143
144
145
146
147
148
149
150
151
152
153
154
155
|
tests/cases/conformance/types/intersection/intersectionReduction.ts(38,4): error TS2339: Property 'kind' does not exist on type 'never'.
The intersection 'A & B' was reduced to 'never' because property 'kind' has conflicting types in some constituents.
tests/cases/conformance/types/intersection/intersectionReduction.ts(80,1): error TS2322: Type 'any' is not assignable to type 'never'.
tests/cases/conformance/types/intersection/intersectionReduction.ts(81,1): error TS2322: Type 'any' is not assignable to type 'never'.
==== tests/cases/conformance/types/intersection/intersectionReduction.ts (3 errors) ====
declare const sym1: unique symbol;
declare const sym2: unique symbol;
type T1 = string & 'a'; // 'a'
type T2 = 'a' & string & 'b'; // never
type T3 = number & 10; // 10
type T4 = 10 & number & 20; // never
type T5 = symbol & typeof sym1; // typeof sym1
type T6 = typeof sym1 & symbol & typeof sym2; // never
type T7 = string & 'a' & number & 10 & symbol & typeof sym1; // never
type T10 = string & ('a' | 'b'); // 'a' | 'b'
type T11 = (string | number) & ('a' | 10); // 'a' | 10
type N1 = 'a' & 'b';
type N2 = { a: string } & null;
type N3 = { a: string } & undefined;
type N4 = string & number;
type N5 = number & object;
type N6 = symbol & string;
type N7 = void & string;
type X = { x: string };
type X1 = X | 'a' & 'b';
type X2 = X | { a: string } & null;
type X3 = X | { a: string } & undefined;
type X4 = X | string & number;
type X5 = X | number & object;
type X6 = X | symbol & string;
type X7 = X | void & string;
type A = { kind: 'a', foo: string };
type B = { kind: 'b', foo: number };
type C = { kind: 'c', foo: number };
declare let ab: A & B;
ab.kind; // Error
~~~~
!!! error TS2339: Property 'kind' does not exist on type 'never'.
!!! error TS2339: The intersection 'A & B' was reduced to 'never' because property 'kind' has conflicting types in some constituents.
declare let x: A | (B & C); // A
let a: A = x;
type AB = A & B; // never
type BC = B & C; // never
type U1 = Partial<A & B>; // never
type U2 = Readonly<A & B>; // never
type U3 = (A & B)['kind']; // never
type U4 = A & B | B & C; // never
type U5 = A | B & C; // A
type K1 = keyof (A & B); // string | number | symbol
type K2 = keyof A | keyof B; // 'kind' | 'foo'
type Merge1<T, U> = { [P in keyof (T & U)]: P extends keyof T ? T[P] : U[P & keyof U] }
type Merge2<T, U> = { [P in keyof T | keyof U]: P extends keyof T ? T[P] : U[P & keyof U] }
type M1 = { a: 1, b: 2 } & { a: 2, c: 3 }; // never
type M2 = Merge1<{ a: 1, b: 2 }, { a: 2, c: 3 }>; // {}
type M3 = Merge2<{ a: 1, b: 2 }, { a: 2, c: 3 }>; // { a: 1, b: 2, c: 3 }
type D = { kind: 'd', foo: unknown };
type E = { kind: 'e', foo: unknown };
declare function f10<T>(x: { foo: T }): T;
declare let a1: A | D;
declare let a2: A | D & E;
let r1 = f10(a1); // unknown
let r2 = f10(a2); // string
// Repro from #31663
const x1 = { a: 'foo', b: 42 };
const x2 = { a: 'foo', b: true };
declare let k: 'a' | 'b';
x1[k] = 'bar' as any; // Error
~~~~~
!!! error TS2322: Type 'any' is not assignable to type 'never'.
x2[k] = 'bar' as any; // Error
~~~~~
!!! error TS2322: Type 'any' is not assignable to type 'never'.
const enum Tag1 {}
const enum Tag2 {}
declare let s1: string & Tag1;
declare let s2: string & Tag2;
declare let t1: string & Tag1 | undefined;
declare let t2: string & Tag2 | undefined;
s1 = s2;
s2 = s1;
t1 = t2;
t2 = t1;
// Repro from #36736
const f1 = (t: "a" | ("b" & "c")): "a" => t;
type Container<Type extends string> = {
type: Type;
}
const f2 = (t: Container<"a"> | (Container<"b"> & Container<"c">)): Container<"a"> => t;
const f3 = (t: Container<"a"> | (Container<"b"> & { dataB: boolean } & Container<"a">)): Container<"a"> => t;
const f4 = (t: number | (Container<"b"> & { dataB: boolean } & Container<"a">)): number => t;
// Repro from #38549
interface A2 {
kind: "A";
a: number;
}
interface B2 {
kind: "B";
b: number;
}
declare const shouldBeB: (A2 | B2) & B2;
const b: B2 = shouldBeB; // works
function inGeneric<T extends A2 | B2>(alsoShouldBeB: T & B2) {
const b: B2 = alsoShouldBeB;
}
// Repro from #38542
interface ABI {
kind: 'a' | 'b';
}
declare class CA { kind: 'a'; a: string; x: number };
declare class CB { kind: 'b'; b: string; y: number };
function bar<T extends CA | CB>(x: T & CA) {
let ab: ABI = x;
}
|
