Skip to content

Commit fb8216b

Browse files
ahejlsbergahejlsberg
committed
Accept new baselines
1 parent f8aaccd commit fb8216b

File tree

3 files changed

+296
-0
lines changed

3 files changed

+296
-0
lines changed

‎tests/baselines/reference/numericEnumMappedType.js

Lines changed: 68 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,68 @@
1+
//// [numericEnumMappedType.ts]
2+
// Repro from #31771
3+
4+
enum E1 { ONE, TWO, THREE }
5+
declare enum E2 { ONE, TWO, THREE }
6+
7+
type Bins1 = { [k in E1]?: string; }
8+
type Bins2 = { [k in E2]?: string; }
9+
10+
const b1: Bins1 = {};
11+
const b2: Bins2 = {};
12+
13+
const e1: E1 = E1.ONE;
14+
const e2: E2 = E2.ONE;
15+
16+
b1[1] = "a";
17+
b1[e1] = "b";
18+
19+
b2[1] = "a";
20+
b2[e2] = "b";
21+
22+
// Multiple numeric enum types accrue to the same numeric index signature in a mapped type
23+
24+
declare function val(): number;
25+
26+
enum N1 { A = val(), B = val() }
27+
enum N2 { C = val(), D = val() }
28+
29+
type T1 = { [K in N1 | N2]: K };
30+
31+
// Enum types with string valued members are always literal enum types and therefore
32+
// ONE and TWO below are not computed members but rather just numerically valued members
33+
// with auto-incremented values.
34+
35+
declare enum E { ONE, TWO, THREE = 'x' }
36+
const e: E = E.ONE;
37+
const x: E.ONE = e;
38+
39+
40+
//// [numericEnumMappedType.js]
41+
"use strict";
42+
// Repro from #31771
43+
var E1;
44+
(function (E1) {
45+
E1[E1["ONE"] = 0] = "ONE";
46+
E1[E1["TWO"] = 1] = "TWO";
47+
E1[E1["THREE"] = 2] = "THREE";
48+
})(E1 || (E1 = {}));
49+
var b1 = {};
50+
var b2 = {};
51+
var e1 = E1.ONE;
52+
var e2 = E2.ONE;
53+
b1[1] = "a";
54+
b1[e1] = "b";
55+
b2[1] = "a";
56+
b2[e2] = "b";
57+
var N1;
58+
(function (N1) {
59+
N1[N1["A"] = val()] = "A";
60+
N1[N1["B"] = val()] = "B";
61+
})(N1 || (N1 = {}));
62+
var N2;
63+
(function (N2) {
64+
N2[N2["C"] = val()] = "C";
65+
N2[N2["D"] = val()] = "D";
66+
})(N2 || (N2 = {}));
67+
var e = E.ONE;
68+
var x = e;

‎tests/baselines/reference/numericEnumMappedType.symbols

Lines changed: 111 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,111 @@
1+
=== tests/cases/compiler/numericEnumMappedType.ts ===
2+
// Repro from #31771
3+
4+
enum E1 { ONE, TWO, THREE }
5+
>E1 : Symbol(E1, Decl(numericEnumMappedType.ts, 0, 0))
6+
>ONE : Symbol(E1.ONE, Decl(numericEnumMappedType.ts, 2, 9))
7+
>TWO : Symbol(E1.TWO, Decl(numericEnumMappedType.ts, 2, 14))
8+
>THREE : Symbol(E1.THREE, Decl(numericEnumMappedType.ts, 2, 19))
9+
10+
declare enum E2 { ONE, TWO, THREE }
11+
>E2 : Symbol(E2, Decl(numericEnumMappedType.ts, 2, 27))
12+
>ONE : Symbol(E2.ONE, Decl(numericEnumMappedType.ts, 3, 17))
13+
>TWO : Symbol(E2.TWO, Decl(numericEnumMappedType.ts, 3, 22))
14+
>THREE : Symbol(E2.THREE, Decl(numericEnumMappedType.ts, 3, 27))
15+
16+
type Bins1 = { [k in E1]?: string; }
17+
>Bins1 : Symbol(Bins1, Decl(numericEnumMappedType.ts, 3, 35))
18+
>k : Symbol(k, Decl(numericEnumMappedType.ts, 5, 16))
19+
>E1 : Symbol(E1, Decl(numericEnumMappedType.ts, 0, 0))
20+
21+
type Bins2 = { [k in E2]?: string; }
22+
>Bins2 : Symbol(Bins2, Decl(numericEnumMappedType.ts, 5, 36))
23+
>k : Symbol(k, Decl(numericEnumMappedType.ts, 6, 16))
24+
>E2 : Symbol(E2, Decl(numericEnumMappedType.ts, 2, 27))
25+
26+
const b1: Bins1 = {};
27+
>b1 : Symbol(b1, Decl(numericEnumMappedType.ts, 8, 5))
28+
>Bins1 : Symbol(Bins1, Decl(numericEnumMappedType.ts, 3, 35))
29+
30+
const b2: Bins2 = {};
31+
>b2 : Symbol(b2, Decl(numericEnumMappedType.ts, 9, 5))
32+
>Bins2 : Symbol(Bins2, Decl(numericEnumMappedType.ts, 5, 36))
33+
34+
const e1: E1 = E1.ONE;
35+
>e1 : Symbol(e1, Decl(numericEnumMappedType.ts, 11, 5))
36+
>E1 : Symbol(E1, Decl(numericEnumMappedType.ts, 0, 0))
37+
>E1.ONE : Symbol(E1.ONE, Decl(numericEnumMappedType.ts, 2, 9))
38+
>E1 : Symbol(E1, Decl(numericEnumMappedType.ts, 0, 0))
39+
>ONE : Symbol(E1.ONE, Decl(numericEnumMappedType.ts, 2, 9))
40+
41+
const e2: E2 = E2.ONE;
42+
>e2 : Symbol(e2, Decl(numericEnumMappedType.ts, 12, 5))
43+
>E2 : Symbol(E2, Decl(numericEnumMappedType.ts, 2, 27))
44+
>E2.ONE : Symbol(E2.ONE, Decl(numericEnumMappedType.ts, 3, 17))
45+
>E2 : Symbol(E2, Decl(numericEnumMappedType.ts, 2, 27))
46+
>ONE : Symbol(E2.ONE, Decl(numericEnumMappedType.ts, 3, 17))
47+
48+
b1[1] = "a";
49+
>b1 : Symbol(b1, Decl(numericEnumMappedType.ts, 8, 5))
50+
>1 : Symbol(1)
51+
52+
b1[e1] = "b";
53+
>b1 : Symbol(b1, Decl(numericEnumMappedType.ts, 8, 5))
54+
>e1 : Symbol(e1, Decl(numericEnumMappedType.ts, 11, 5))
55+
56+
b2[1] = "a";
57+
>b2 : Symbol(b2, Decl(numericEnumMappedType.ts, 9, 5))
58+
59+
b2[e2] = "b";
60+
>b2 : Symbol(b2, Decl(numericEnumMappedType.ts, 9, 5))
61+
>e2 : Symbol(e2, Decl(numericEnumMappedType.ts, 12, 5))
62+
63+
// Multiple numeric enum types accrue to the same numeric index signature in a mapped type
64+
65+
declare function val(): number;
66+
>val : Symbol(val, Decl(numericEnumMappedType.ts, 18, 13))
67+
68+
enum N1 { A = val(), B = val() }
69+
>N1 : Symbol(N1, Decl(numericEnumMappedType.ts, 22, 31))
70+
>A : Symbol(N1.A, Decl(numericEnumMappedType.ts, 24, 9))
71+
>val : Symbol(val, Decl(numericEnumMappedType.ts, 18, 13))
72+
>B : Symbol(N1.B, Decl(numericEnumMappedType.ts, 24, 20))
73+
>val : Symbol(val, Decl(numericEnumMappedType.ts, 18, 13))
74+
75+
enum N2 { C = val(), D = val() }
76+
>N2 : Symbol(N2, Decl(numericEnumMappedType.ts, 24, 32))
77+
>C : Symbol(N2.C, Decl(numericEnumMappedType.ts, 25, 9))
78+
>val : Symbol(val, Decl(numericEnumMappedType.ts, 18, 13))
79+
>D : Symbol(N2.D, Decl(numericEnumMappedType.ts, 25, 20))
80+
>val : Symbol(val, Decl(numericEnumMappedType.ts, 18, 13))
81+
82+
type T1 = { [K in N1 | N2]: K };
83+
>T1 : Symbol(T1, Decl(numericEnumMappedType.ts, 25, 32))
84+
>K : Symbol(K, Decl(numericEnumMappedType.ts, 27, 13))
85+
>N1 : Symbol(N1, Decl(numericEnumMappedType.ts, 22, 31))
86+
>N2 : Symbol(N2, Decl(numericEnumMappedType.ts, 24, 32))
87+
>K : Symbol(K, Decl(numericEnumMappedType.ts, 27, 13))
88+
89+
// Enum types with string valued members are always literal enum types and therefore
90+
// ONE and TWO below are not computed members but rather just numerically valued members
91+
// with auto-incremented values.
92+
93+
declare enum E { ONE, TWO, THREE = 'x' }
94+
>E : Symbol(E, Decl(numericEnumMappedType.ts, 27, 32))
95+
>ONE : Symbol(E.ONE, Decl(numericEnumMappedType.ts, 33, 16))
96+
>TWO : Symbol(E.TWO, Decl(numericEnumMappedType.ts, 33, 21))
97+
>THREE : Symbol(E.THREE, Decl(numericEnumMappedType.ts, 33, 26))
98+
99+
const e: E = E.ONE;
100+
>e : Symbol(e, Decl(numericEnumMappedType.ts, 34, 5))
101+
>E : Symbol(E, Decl(numericEnumMappedType.ts, 27, 32))
102+
>E.ONE : Symbol(E.ONE, Decl(numericEnumMappedType.ts, 33, 16))
103+
>E : Symbol(E, Decl(numericEnumMappedType.ts, 27, 32))
104+
>ONE : Symbol(E.ONE, Decl(numericEnumMappedType.ts, 33, 16))
105+
106+
const x: E.ONE = e;
107+
>x : Symbol(x, Decl(numericEnumMappedType.ts, 35, 5))
108+
>E : Symbol(E, Decl(numericEnumMappedType.ts, 27, 32))
109+
>ONE : Symbol(E.ONE, Decl(numericEnumMappedType.ts, 33, 16))
110+
>e : Symbol(e, Decl(numericEnumMappedType.ts, 34, 5))
111+

‎tests/baselines/reference/numericEnumMappedType.types

Lines changed: 117 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,117 @@
1+
=== tests/cases/compiler/numericEnumMappedType.ts ===
2+
// Repro from #31771
3+
4+
enum E1 { ONE, TWO, THREE }
5+
>E1 : E1
6+
>ONE : E1.ONE
7+
>TWO : E1.TWO
8+
>THREE : E1.THREE
9+
10+
declare enum E2 { ONE, TWO, THREE }
11+
>E2 : E2
12+
>ONE : E2
13+
>TWO : E2
14+
>THREE : E2
15+
16+
type Bins1 = { [k in E1]?: string; }
17+
>Bins1 : Bins1
18+
19+
type Bins2 = { [k in E2]?: string; }
20+
>Bins2 : Bins2
21+
22+
const b1: Bins1 = {};
23+
>b1 : Bins1
24+
>{} : {}
25+
26+
const b2: Bins2 = {};
27+
>b2 : Bins2
28+
>{} : {}
29+
30+
const e1: E1 = E1.ONE;
31+
>e1 : E1
32+
>E1.ONE : E1.ONE
33+
>E1 : typeof E1
34+
>ONE : E1.ONE
35+
36+
const e2: E2 = E2.ONE;
37+
>e2 : E2
38+
>E2.ONE : E2
39+
>E2 : typeof E2
40+
>ONE : E2
41+
42+
b1[1] = "a";
43+
>b1[1] = "a" : "a"
44+
>b1[1] : string | undefined
45+
>b1 : Bins1
46+
>1 : 1
47+
>"a" : "a"
48+
49+
b1[e1] = "b";
50+
>b1[e1] = "b" : "b"
51+
>b1[e1] : string | undefined
52+
>b1 : Bins1
53+
>e1 : E1.ONE
54+
>"b" : "b"
55+
56+
b2[1] = "a";
57+
>b2[1] = "a" : "a"
58+
>b2[1] : string | undefined
59+
>b2 : Bins2
60+
>1 : 1
61+
>"a" : "a"
62+
63+
b2[e2] = "b";
64+
>b2[e2] = "b" : "b"
65+
>b2[e2] : string | undefined
66+
>b2 : Bins2
67+
>e2 : E2
68+
>"b" : "b"
69+
70+
// Multiple numeric enum types accrue to the same numeric index signature in a mapped type
71+
72+
declare function val(): number;
73+
>val : () => number
74+
75+
enum N1 { A = val(), B = val() }
76+
>N1 : N1
77+
>A : N1
78+
>val() : number
79+
>val : () => number
80+
>B : N1
81+
>val() : number
82+
>val : () => number
83+
84+
enum N2 { C = val(), D = val() }
85+
>N2 : N2
86+
>C : N2
87+
>val() : number
88+
>val : () => number
89+
>D : N2
90+
>val() : number
91+
>val : () => number
92+
93+
type T1 = { [K in N1 | N2]: K };
94+
>T1 : T1
95+
96+
// Enum types with string valued members are always literal enum types and therefore
97+
// ONE and TWO below are not computed members but rather just numerically valued members
98+
// with auto-incremented values.
99+
100+
declare enum E { ONE, TWO, THREE = 'x' }
101+
>E : E
102+
>ONE : E.ONE
103+
>TWO : E.TWO
104+
>THREE : E.THREE
105+
>'x' : "x"
106+
107+
const e: E = E.ONE;
108+
>e : E
109+
>E.ONE : E.ONE
110+
>E : typeof E
111+
>ONE : E.ONE
112+
113+
const x: E.ONE = e;
114+
>x : E.ONE
115+
>E : any
116+
>e : E.ONE
117+

0 commit comments

Comments
 (0)