• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1/*
2* Copyright (c) Microsoft Corporation. All rights reserved.
3* Copyright (c) 2023 Huawei Device Co., Ltd.
4* Licensed under the Apache License, Version 2.0 (the "License");
5* you may not use this file except in compliance with the License.
6* You may obtain a copy of the License at
7*
8*     http://www.apache.org/licenses/LICENSE-2.0
9*
10* Unless required by applicable law or agreed to in writing, software
11* distributed under the License is distributed on an "AS IS" BASIS,
12* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13* See the License for the specific language governing permissions and
14* limitations under the License.
15*
16* This file has been modified by Huawei to verify type inference by adding verification statements.
17*/
18
19// === tests/cases/compiler/constEnums.ts ===
20declare function AssertType(value:any, type:string):void;
21const enum Enum1 {
22   A0 = 100,
23}
24
25const enum Enum1 {
26    // correct cases
27    A,
28    B,
29    C = 10,
30    D = A | B,
31    E = A | 1,
32    F = 1 | A,
33    G = (1 & 1),
34    H = ~(A | B),
35    I = A >>> 1,
36    J = 1 & A,
37    K = ~(1 | 5),
38    L = ~D,
39    M = E << B,
40    N = E << 1,
41    O = E >> B,
42    P = E >> 1,
43    PQ = E ** 2,
44    Q = -D,
45    R = C & 5,
46    S = 5 & C,
47    T = C | D,
48    U = C | 1,
49    V = 10 | D,
50    W = Enum1.V,
51
52    // correct cases: reference to the enum member from different enum declaration
53    W1 = A0,
54    W2 = Enum1.A0,
55    W3 = Enum1["A0"],
56    W4 = Enum1["W"],
57    W5 = Enum1[`V`],
58}
59
60const enum Comments {
61    "//",
62    "/*",
63    "*/",
64    "///",
65    "#",
66    "<!--",
67    "-->",
68}
69
70module A {
71    export module B {
72        export module C {
73            export const enum E {
74                V1 = 1,
75                V2 = A.B.C.E.V1 | 100
76            }
77        }
78    }
79}
80
81module A {
82    export module B {
83        export module C {
84            export const enum E {
85                V3 = A.B.C.E["V2"] & 200,
86                V4 = A.B.C.E[`V1`] << 1,
87            }
88        }
89    }
90}
91
92module A1 {
93    export module B {
94        export module C {
95            export const enum E {
96                V1 = 10,
97                V2 = 110,
98            }
99        }
100    }
101}
102
103module A2 {
104    export module B {
105        export module C {
106            export const enum E {
107                V1 = 10,
108                V2 = 110,
109            }
110        }
111        // module C will be classified as value
112        export module C {
113            let x = 1
114        }
115    }
116}
117
118import I = A.B.C.E;
119import I1 = A1.B;
120import I2 = A2.B;
121
122function foo0(e: I): void {
123    if (e === I.V1) {
124AssertType(e === I.V1, "boolean");
125AssertType(e, "I");
126AssertType(I.V1, "I.V1");
127    }
128    else if (e === I.V2) {
129AssertType(e === I.V2, "boolean");
130AssertType(e, "union");
131AssertType(I.V2, "I.V2");
132    }
133}
134
135function foo1(e: I1.C.E): void {
136    if (e === I1.C.E.V1) {
137AssertType(e === I1.C.E.V1, "boolean");
138AssertType(e, "I1.C.E");
139AssertType(I1.C.E.V1, "I1.C.E.V1");
140AssertType(I1.C.E, "typeof I1.C.E");
141AssertType(I1.C, "typeof I1.C");
142    }
143    else if (e === I1.C.E.V2) {
144AssertType(e === I1.C.E.V2, "boolean");
145AssertType(e, "I1.C.E.V2");
146AssertType(I1.C.E.V2, "I1.C.E.V2");
147AssertType(I1.C.E, "typeof I1.C.E");
148AssertType(I1.C, "typeof I1.C");
149    }
150}
151
152function foo2(e: I2.C.E): void {
153    if (e === I2.C.E.V1) {
154AssertType(e === I2.C.E.V1, "boolean");
155AssertType(e, "I2.C.E");
156AssertType(I2.C.E.V1, "I2.C.E.V1");
157AssertType(I2.C.E, "typeof I2.C.E");
158AssertType(I2.C, "typeof I2.C");
159    }
160    else if (e === I2.C.E.V2) {
161AssertType(e === I2.C.E.V2, "boolean");
162AssertType(e, "I2.C.E.V2");
163AssertType(I2.C.E.V2, "I2.C.E.V2");
164AssertType(I2.C.E, "typeof I2.C.E");
165AssertType(I2.C, "typeof I2.C");
166    }
167}
168
169
170function foo(x: Enum1) {
171    switch (x) {
172AssertType(x, "Enum1");
173
174        case Enum1.A:
175AssertType(Enum1.A, "Enum1.A");
176
177        case Enum1.B:
178AssertType(Enum1.B, "Enum1.B");
179
180        case Enum1.C:
181AssertType(Enum1.C, "Enum1.C");
182
183        case Enum1.D:
184AssertType(Enum1.D, "Enum1.B");
185
186        case Enum1.E:
187AssertType(Enum1.E, "Enum1.B");
188
189        case Enum1.F:
190AssertType(Enum1.F, "Enum1.B");
191
192        case Enum1.G:
193AssertType(Enum1.G, "Enum1.B");
194
195        case Enum1.H:
196AssertType(Enum1.H, "Enum1.H");
197
198        case Enum1.I:
199AssertType(Enum1.I, "Enum1.A");
200
201        case Enum1.J:
202AssertType(Enum1.J, "Enum1.A");
203
204        case Enum1.K:
205AssertType(Enum1.K, "Enum1.K");
206
207        case Enum1.L:
208AssertType(Enum1.L, "Enum1.H");
209
210        case Enum1.M:
211AssertType(Enum1.M, "Enum1.M");
212
213        case Enum1.N:
214AssertType(Enum1.N, "Enum1.M");
215
216        case Enum1.O:
217AssertType(Enum1.O, "Enum1.A");
218
219        case Enum1.P:
220AssertType(Enum1.P, "Enum1.A");
221
222        case Enum1.PQ:
223AssertType(Enum1.PQ, "Enum1.B");
224
225        case Enum1.Q:
226AssertType(Enum1.Q, "Enum1.Q");
227
228        case Enum1.R:
229AssertType(Enum1.R, "Enum1.A");
230
231        case Enum1.S:
232AssertType(Enum1.S, "Enum1.A");
233
234        case Enum1["T"]:
235AssertType(Enum1["T"], "Enum1.T");
236AssertType(Enum1, "typeof Enum1");
237AssertType("T", "string");
238
239        case Enum1[`U`]:
240AssertType(Enum1[`U`], "Enum1.T");
241AssertType(Enum1, "typeof Enum1");
242AssertType(`U`, "string");
243
244        case Enum1.V:
245AssertType(Enum1.V, "Enum1.T");
246
247        case Enum1.W:
248AssertType(Enum1.W, "Enum1.T");
249
250        case Enum1.W1:
251AssertType(Enum1.W1, "Enum1.A0");
252
253        case Enum1.W2:
254AssertType(Enum1.W2, "Enum1.A0");
255
256        case Enum1.W3:
257AssertType(Enum1.W3, "Enum1.A0");
258
259        case Enum1.W4:
260AssertType(Enum1.W4, "Enum1.T");
261
262            break;
263    }
264}
265
266function bar(e: A.B.C.E): number {
267    switch (e) {
268AssertType(e, "I");
269
270        case A.B.C.E.V1:
271AssertType(A.B.C.E.V1, "I.V1");
272AssertType(A.B.C.E, "typeof I");
273AssertType(A.B.C, "typeof A.B.C");
274AssertType(A.B, "typeof A.B");
275AssertType(1, "int");
276return 1;
277
278        case A.B.C.E.V2:
279AssertType(A.B.C.E.V2, "I.V2");
280AssertType(A.B.C.E, "typeof I");
281AssertType(A.B.C, "typeof A.B.C");
282AssertType(A.B, "typeof A.B");
283AssertType(1, "int");
284return 1;
285
286        case A.B.C.E.V3:
287AssertType(A.B.C.E.V3, "I.V3");
288AssertType(A.B.C.E, "typeof I");
289AssertType(A.B.C, "typeof A.B.C");
290AssertType(A.B, "typeof A.B");
291AssertType(1, "int");
292return 1;
293    }
294}
295
296function baz(c: Comments) {
297    switch (c) {
298AssertType(c, "Comments");
299
300        case Comments["//"]:
301AssertType(Comments["//"], "(typeof Comments)["//"]");
302AssertType(Comments, "typeof Comments");
303AssertType("//", "string");
304
305        case Comments["/*"]:
306AssertType(Comments["/*"], "(typeof Comments)["/*"]");
307AssertType(Comments, "typeof Comments");
308AssertType("/*", "string");
309
310        case Comments["*/"]:
311AssertType(Comments["*/"], "(typeof Comments)["*/"]");
312AssertType(Comments, "typeof Comments");
313AssertType("*/", "string");
314
315        case Comments["///"]:
316AssertType(Comments["///"], "(typeof Comments)["///"]");
317AssertType(Comments, "typeof Comments");
318AssertType("///", "string");
319
320        case Comments["#"]:
321AssertType(Comments["#"], "(typeof Comments)["#"]");
322AssertType(Comments, "typeof Comments");
323AssertType("#", "string");
324
325        case Comments["<!--"]:
326AssertType(Comments["<!--"], "(typeof Comments)["<!--"]");
327AssertType(Comments, "typeof Comments");
328AssertType("<!--", "string");
329
330        case Comments["-->"]:
331AssertType(Comments["-->"], "(typeof Comments)["-->"]");
332AssertType(Comments, "typeof Comments");
333AssertType("-->", "string");
334
335        break;
336    }
337}
338
339
340