• 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/main.ts ===
20declare function AssertType(value:any, type:string):void;
21import { c0, c1, s0, T0, T1, T2, T3 } from "./module";
22import * as M from "./module";
23
24namespace N {
25    export const c2 = "a";
26    export const c3 = 1;
27    export const s1: typeof s0 = s0;
28
29    export interface T4 {
30        [N.c2]: number;
31        [N.c3]: string;
32        [N.s1]: boolean;
33    }
34    export declare class T5 implements T4 {
35        [N.c2]: number;
36        [N.c3]: string;
37        [N.s1]: boolean;
38    }
39    export declare class T6 extends T5 {
40    }
41    export declare type T7 = {
42        [N.c2]: number;
43        [N.c3]: string;
44        [N.s1]: boolean;
45    };
46}
47
48export const c4 = "a";
49AssertType(c4, "string");
50AssertType("a", "string");
51
52export const c5 = 1;
53AssertType(c5, "int");
54AssertType(1, "int");
55
56export const s2: typeof s0 = s0;
57AssertType(s2, "unique symbol");
58AssertType(s0, "unique symbol");
59AssertType(s0, "unique symbol");
60
61interface T8 {
62    [c4]: number;
63    [c5]: string;
64    [s2]: boolean;
65}
66declare class T9 implements T8 {
67    [c4]: number;
68    [c5]: string;
69    [s2]: boolean;
70}
71declare class T10 extends T9 {
72}
73declare type T11 = {
74    [c4]: number;
75    [c5]: string;
76    [s2]: boolean;
77};
78
79interface T12 {
80    a: number;
81    1: string;
82    [s2]: boolean;
83}
84declare class T13 implements T2 {
85    a: number;
86    1: string;
87    [s2]: boolean;
88}
89declare class T14 extends T13 {
90}
91declare type T15 = {
92    a: number;
93    1: string;
94    [s2]: boolean;
95};
96
97declare class C {
98    static a: number;
99    static 1: string;
100    static [s2]: boolean;
101}
102
103let t0: T0;
104AssertType(t0, "T0");
105
106let t1: T1;
107AssertType(t1, "T1");
108
109let t2: T2;
110AssertType(t2, "T2");
111
112let t3: T3;
113AssertType(t3, "T3");
114
115let t0_1: M.T0;
116AssertType(t0_1, "T0");
117AssertType(M, "any");
118
119let t1_1: M.T1;
120AssertType(t1_1, "T1");
121AssertType(M, "any");
122
123let t2_1: M.T2;
124AssertType(t2_1, "T2");
125AssertType(M, "any");
126
127let t3_1: M.T3;
128AssertType(t3_1, "T3");
129AssertType(M, "any");
130
131let t4: N.T4;
132AssertType(t4, "N.T4");
133AssertType(N, "any");
134
135let t5: N.T5;
136AssertType(t5, "N.T5");
137AssertType(N, "any");
138
139let t6: N.T6;
140AssertType(t6, "N.T6");
141AssertType(N, "any");
142
143let t7: N.T7;
144AssertType(t7, "N.T7");
145AssertType(N, "any");
146
147let t8: T8;
148AssertType(t8, "T8");
149
150let t9: T9;
151AssertType(t9, "T9");
152
153let t10: T10;
154AssertType(t10, "T10");
155
156let t11: T11;
157AssertType(t11, "T11");
158
159let t12: T12;
160AssertType(t12, "T12");
161
162let t13: T13;
163AssertType(t13, "T13");
164
165let t14: T14;
166AssertType(t14, "T14");
167
168let t15: T15;
169AssertType(t15, "T15");
170
171// assignability
172t0 = t1, t0 = t2, t0 = t3, t1 = t0, t1 = t2, t1 = t3, t2 = t0, t2 = t1, t2 = t3, t3 = t0, t3 = t1, t3 = t2;
173AssertType(t0 = t1, t0 = t2, t0 = t3, t1 = t0, t1 = t2, t1 = t3, t2 = t0, t2 = t1, t2 = t3, t3 = t0, t3 = t1, t3 = t2, "T2");
174AssertType(t0 = t1, t0 = t2, t0 = t3, t1 = t0, t1 = t2, t1 = t3, t2 = t0, t2 = t1, t2 = t3, t3 = t0, t3 = t1, "T1");
175AssertType(t0 = t1, t0 = t2, t0 = t3, t1 = t0, t1 = t2, t1 = t3, t2 = t0, t2 = t1, t2 = t3, t3 = t0, "T0");
176AssertType(t0 = t1, t0 = t2, t0 = t3, t1 = t0, t1 = t2, t1 = t3, t2 = t0, t2 = t1, t2 = t3, "T3");
177AssertType(t0 = t1, t0 = t2, t0 = t3, t1 = t0, t1 = t2, t1 = t3, t2 = t0, t2 = t1, "T1");
178AssertType(t0 = t1, t0 = t2, t0 = t3, t1 = t0, t1 = t2, t1 = t3, t2 = t0, "T0");
179AssertType(t0 = t1, t0 = t2, t0 = t3, t1 = t0, t1 = t2, t1 = t3, "T3");
180AssertType(t0 = t1, t0 = t2, t0 = t3, t1 = t0, t1 = t2, "T2");
181AssertType(t0 = t1, t0 = t2, t0 = t3, t1 = t0, "T0");
182AssertType(t0 = t1, t0 = t2, t0 = t3, "T3");
183AssertType(t0 = t1, t0 = t2, "T2");
184AssertType(t0 = t1, "T1");
185AssertType(t0, "T0");
186AssertType(t1, "T1");
187AssertType(t0 = t2, "T2");
188AssertType(t0, "T0");
189AssertType(t2, "T2");
190AssertType(t0 = t3, "T3");
191AssertType(t0, "T0");
192AssertType(t3, "T3");
193AssertType(t1 = t0, "T0");
194AssertType(t1, "T1");
195AssertType(t0, "T0");
196AssertType(t1 = t2, "T2");
197AssertType(t1, "T1");
198AssertType(t2, "T2");
199AssertType(t1 = t3, "T3");
200AssertType(t1, "T1");
201AssertType(t3, "T3");
202AssertType(t2 = t0, "T0");
203AssertType(t2, "T2");
204AssertType(t0, "T0");
205AssertType(t2 = t1, "T1");
206AssertType(t2, "T2");
207AssertType(t1, "T1");
208AssertType(t2 = t3, "T3");
209AssertType(t2, "T2");
210AssertType(t3, "T3");
211AssertType(t3 = t0, "T0");
212AssertType(t3, "T3");
213AssertType(t0, "T0");
214AssertType(t3 = t1, "T1");
215AssertType(t3, "T3");
216AssertType(t1, "T1");
217AssertType(t3 = t2, "T2");
218AssertType(t3, "T3");
219AssertType(t2, "T2");
220
221t4 = t5, t4 = t6, t4 = t7, t5 = t4, t5 = t6, t5 = t7, t6 = t4, t6 = t5, t6 = t7, t7 = t4, t7 = t5, t7 = t6;
222AssertType(t4 = t5, t4 = t6, t4 = t7, t5 = t4, t5 = t6, t5 = t7, t6 = t4, t6 = t5, t6 = t7, t7 = t4, t7 = t5, t7 = t6, "N.T6");
223AssertType(t4 = t5, t4 = t6, t4 = t7, t5 = t4, t5 = t6, t5 = t7, t6 = t4, t6 = t5, t6 = t7, t7 = t4, t7 = t5, "N.T5");
224AssertType(t4 = t5, t4 = t6, t4 = t7, t5 = t4, t5 = t6, t5 = t7, t6 = t4, t6 = t5, t6 = t7, t7 = t4, "N.T4");
225AssertType(t4 = t5, t4 = t6, t4 = t7, t5 = t4, t5 = t6, t5 = t7, t6 = t4, t6 = t5, t6 = t7, "N.T7");
226AssertType(t4 = t5, t4 = t6, t4 = t7, t5 = t4, t5 = t6, t5 = t7, t6 = t4, t6 = t5, "N.T5");
227AssertType(t4 = t5, t4 = t6, t4 = t7, t5 = t4, t5 = t6, t5 = t7, t6 = t4, "N.T4");
228AssertType(t4 = t5, t4 = t6, t4 = t7, t5 = t4, t5 = t6, t5 = t7, "N.T7");
229AssertType(t4 = t5, t4 = t6, t4 = t7, t5 = t4, t5 = t6, "N.T6");
230AssertType(t4 = t5, t4 = t6, t4 = t7, t5 = t4, "N.T4");
231AssertType(t4 = t5, t4 = t6, t4 = t7, "N.T7");
232AssertType(t4 = t5, t4 = t6, "N.T6");
233AssertType(t4 = t5, "N.T5");
234AssertType(t4, "N.T4");
235AssertType(t5, "N.T5");
236AssertType(t4 = t6, "N.T6");
237AssertType(t4, "N.T4");
238AssertType(t6, "N.T6");
239AssertType(t4 = t7, "N.T7");
240AssertType(t4, "N.T4");
241AssertType(t7, "N.T7");
242AssertType(t5 = t4, "N.T4");
243AssertType(t5, "N.T5");
244AssertType(t4, "N.T4");
245AssertType(t5 = t6, "N.T6");
246AssertType(t5, "N.T5");
247AssertType(t6, "N.T6");
248AssertType(t5 = t7, "N.T7");
249AssertType(t5, "N.T5");
250AssertType(t7, "N.T7");
251AssertType(t6 = t4, "N.T4");
252AssertType(t6, "N.T6");
253AssertType(t4, "N.T4");
254AssertType(t6 = t5, "N.T5");
255AssertType(t6, "N.T6");
256AssertType(t5, "N.T5");
257AssertType(t6 = t7, "N.T7");
258AssertType(t6, "N.T6");
259AssertType(t7, "N.T7");
260AssertType(t7 = t4, "N.T4");
261AssertType(t7, "N.T7");
262AssertType(t4, "N.T4");
263AssertType(t7 = t5, "N.T5");
264AssertType(t7, "N.T7");
265AssertType(t5, "N.T5");
266AssertType(t7 = t6, "N.T6");
267AssertType(t7, "N.T7");
268AssertType(t6, "N.T6");
269
270t0 = t12, t0 = t13, t0 = t14, t0 = t15, t12 = t0, t13 = t0, t14 = t0, t15 = t0;
271AssertType(t0 = t12, t0 = t13, t0 = t14, t0 = t15, t12 = t0, t13 = t0, t14 = t0, t15 = t0, "T0");
272AssertType(t0 = t12, t0 = t13, t0 = t14, t0 = t15, t12 = t0, t13 = t0, t14 = t0, "T0");
273AssertType(t0 = t12, t0 = t13, t0 = t14, t0 = t15, t12 = t0, t13 = t0, "T0");
274AssertType(t0 = t12, t0 = t13, t0 = t14, t0 = t15, t12 = t0, "T0");
275AssertType(t0 = t12, t0 = t13, t0 = t14, t0 = t15, "T15");
276AssertType(t0 = t12, t0 = t13, t0 = t14, "T14");
277AssertType(t0 = t12, t0 = t13, "T13");
278AssertType(t0 = t12, "T12");
279AssertType(t0, "T0");
280AssertType(t12, "T12");
281AssertType(t0 = t13, "T13");
282AssertType(t0, "T0");
283AssertType(t13, "T13");
284AssertType(t0 = t14, "T14");
285AssertType(t0, "T0");
286AssertType(t14, "T14");
287AssertType(t0 = t15, "T15");
288AssertType(t0, "T0");
289AssertType(t15, "T15");
290AssertType(t12 = t0, "T0");
291AssertType(t12, "T12");
292AssertType(t0, "T0");
293AssertType(t13 = t0, "T0");
294AssertType(t13, "T13");
295AssertType(t0, "T0");
296AssertType(t14 = t0, "T0");
297AssertType(t14, "T14");
298AssertType(t0, "T0");
299AssertType(t15 = t0, "T0");
300AssertType(t15, "T15");
301AssertType(t0, "T0");
302
303t0 = C; // static side
304AssertType(t0 = C, "typeof C");
305AssertType(t0, "T0");
306AssertType(C, "typeof C");
307
308// object literals
309export const o1 = {
310AssertType(o1, "{ a: number; 1: string; [s0]: boolean; }");
311AssertType({    [c4]: 1,    [c5]: "a",    [s2]: true}, "{ a: number; 1: string; [s0]: boolean; }");
312
313    [c4]: 1,
314AssertType([c4], "number");
315AssertType(c4, "string");
316AssertType(1, "int");
317
318    [c5]: "a",
319AssertType([c5], "string");
320AssertType(c5, "int");
321AssertType("a", "string");
322
323    [s2]: true
324AssertType([s2], "boolean");
325AssertType(s2, "unique symbol");
326AssertType(true, "boolean");
327
328};
329
330// check element access types
331export const o1_c4 = o1[c4];
332AssertType(o1_c4, "number");
333AssertType(o1[c4], "number");
334AssertType(o1, "{ a: number; 1: string; [s0]: boolean; }");
335AssertType(c4, "string");
336
337export const o1_c5 = o1[c5];
338AssertType(o1_c5, "string");
339AssertType(o1[c5], "string");
340AssertType(o1, "{ a: number; 1: string; [s0]: boolean; }");
341AssertType(c5, "int");
342
343export const o1_s2 = o1[s2];
344AssertType(o1_s2, "boolean");
345AssertType(o1[s2], "boolean");
346AssertType(o1, "{ a: number; 1: string; [s0]: boolean; }");
347AssertType(s2, "unique symbol");
348
349export const o2: T0 = o1;
350AssertType(o2, "T0");
351AssertType(o1, "{ a: number; 1: string; [s0]: boolean; }");
352
353// recursive declarations
354// (type parameter indirection courtesy of #20400)
355declare const rI: RI<"a">;
356AssertType(rI, "RI<"a">");
357
358rI.x
359AssertType(rI.x, "string");
360
361interface RI<T extends "a" | "b"> {
362    x: T;
363    [rI.x]: "b";
364}
365
366declare const rC: RC<"a">;
367AssertType(rC, "RC<"a">");
368
369rC.x
370AssertType(rC.x, "string");
371
372declare class RC<T extends "a" | "b"> {
373    x: T;
374    [rC.x]: "b";
375}
376
377
378