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
|
=== tests/cases/conformance/controlFlow/typeGuardsTypeParameters.ts ===
// Type guards involving type parameters produce intersection types
class C {
>C : C
prop: string;
>prop : string
}
function f1<T>(x: T) {
>f1 : <T>(x: T) => void
>x : T
if (x instanceof C) {
>x instanceof C : boolean
>x : T
>C : typeof C
let v1: T = x;
>v1 : T
>x : T & C
let v2: C = x;
>v2 : C
>x : T & C
x.prop;
>x.prop : string
>x : T & C
>prop : string
}
}
function f2<T>(x: T) {
>f2 : <T>(x: T) => void
>x : T
if (typeof x === "string") {
>typeof x === "string" : boolean
>typeof x : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"
>x : T
>"string" : "string"
let v1: T = x;
>v1 : T
>x : T & string
let v2: string = x;
>v2 : string
>x : T & string
x.length;
>x.length : number
>x : T & string
>length : number
}
}
// Repro from #13872
function fun<T>(item: { [P in keyof T]: T[P] }) {
>fun : <T>(item: { [P in keyof T]: T[P]; }) => void
>item : { [P in keyof T]: T[P]; }
const strings: string[] = [];
>strings : string[]
>[] : never[]
for (const key in item) {
>key : Extract<keyof T, string>
>item : { [P in keyof T]: T[P]; }
const value = item[key];
>value : { [P in keyof T]: T[P]; }[Extract<keyof T, string>]
>item[key] : { [P in keyof T]: T[P]; }[Extract<keyof T, string>]
>item : { [P in keyof T]: T[P]; }
>key : Extract<keyof T, string>
if (typeof value === "string") {
>typeof value === "string" : boolean
>typeof value : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"
>value : { [P in keyof T]: T[P]; }[Extract<keyof T, string>]
>"string" : "string"
strings.push(value);
>strings.push(value) : number
>strings.push : (...items: string[]) => number
>strings : string[]
>push : (...items: string[]) => number
>value : { [P in keyof T]: T[P]; }[Extract<keyof T, string>] & string
}
}
}
|
