• 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/conformance/types/typeRelationships/bestCommonType/heterogeneousArrayLiterals.ts ===
20declare function AssertType(value:any, type:string):void;
21// type of an array is the best common type of its elements (plus its contextual type if it exists)
22
23let a = [1, '']; // {}[]
24AssertType(a, "(union)[]");
25AssertType([1, ''], "(union)[]");
26AssertType(1, "int");
27AssertType('', "string");
28
29let b = [1, null]; // number[]
30AssertType(b, "number[]");
31AssertType([1, null], "number[]");
32AssertType(1, "int");
33AssertType(null, "null");
34
35let c = [1, '', null]; // {}[]
36AssertType(c, "(union)[]");
37AssertType([1, '', null], "(union)[]");
38AssertType(1, "int");
39AssertType('', "string");
40AssertType(null, "null");
41
42let d = [{}, 1]; // {}[]
43AssertType(d, "{}[]");
44AssertType([{}, 1], "(union)[]");
45AssertType({}, "{}");
46AssertType(1, "int");
47
48let e = [{}, Object]; // {}[]
49AssertType(e, "{}[]");
50AssertType([{}, Object], "(union)[]");
51AssertType({}, "{}");
52AssertType(Object, "ObjectConstructor");
53
54let f = [[], [1]]; // number[][]
55AssertType(f, "number[][]");
56AssertType([[], [1]], "number[][]");
57AssertType([], "undefined[]");
58AssertType([1], "number[]");
59AssertType(1, "int");
60
61let g = [[1], ['']]; // {}[]
62AssertType(g, "(union)[]");
63AssertType([[1], ['']], "(union)[]");
64AssertType([1], "number[]");
65AssertType(1, "int");
66AssertType([''], "string[]");
67AssertType('', "string");
68
69let h = [{ foo: 1, bar: '' }, { foo: 2 }]; // {foo: number}[]
70AssertType(h, "(union)[]");
71AssertType([{ foo: 1, bar: '' }, { foo: 2 }], "(union)[]");
72AssertType({ foo: 1, bar: '' }, "{ foo: number; bar: string; }");
73AssertType(foo, "number");
74AssertType(1, "int");
75AssertType(bar, "string");
76AssertType('', "string");
77AssertType({ foo: 2 }, "{ foo: number; }");
78AssertType(foo, "number");
79AssertType(2, "int");
80
81let i = [{ foo: 1, bar: '' }, { foo: '' }]; // {}[]
82AssertType(i, "(union)[]");
83AssertType([{ foo: 1, bar: '' }, { foo: '' }], "(union)[]");
84AssertType({ foo: 1, bar: '' }, "{ foo: number; bar: string; }");
85AssertType(foo, "number");
86AssertType(1, "int");
87AssertType(bar, "string");
88AssertType('', "string");
89AssertType({ foo: '' }, "{ foo: string; }");
90AssertType(foo, "string");
91AssertType('', "string");
92
93let j = [() => 1, () => '']; // {}[]
94AssertType(j, "(union)[]");
95AssertType([() => 1, () => ''], "(union)[]");
96AssertType(() => 1, "() => number");
97AssertType(1, "int");
98AssertType(() => '', "() => string");
99AssertType('', "string");
100
101let k = [() => 1, () => 1]; // { (): number }[]
102AssertType(k, "(() => number)[]");
103AssertType([() => 1, () => 1], "(() => number)[]");
104AssertType(() => 1, "() => number");
105AssertType(1, "int");
106AssertType(() => 1, "() => number");
107AssertType(1, "int");
108
109let l = [() => 1, () => null]; // { (): any }[]
110AssertType(l, "(() => any)[]");
111AssertType([() => 1, () => null], "(() => any)[]");
112AssertType(() => 1, "() => number");
113AssertType(1, "int");
114AssertType(() => null, "() => any");
115AssertType(null, "null");
116
117let m = [() => 1, () => '', () => null]; // { (): any }[]
118AssertType(m, "(() => any)[]");
119AssertType([() => 1, () => '', () => null], "(() => any)[]");
120AssertType(() => 1, "() => number");
121AssertType(1, "int");
122AssertType(() => '', "() => string");
123AssertType('', "string");
124AssertType(() => null, "() => any");
125AssertType(null, "null");
126
127let n = [[() => 1], [() => '']]; // {}[]
128AssertType(n, "(union)[]");
129AssertType([[() => 1], [() => '']], "(union)[]");
130AssertType([() => 1], "(() => number)[]");
131AssertType(() => 1, "() => number");
132AssertType(1, "int");
133AssertType([() => ''], "(() => string)[]");
134AssertType(() => '', "() => string");
135AssertType('', "string");
136
137class Base { foo: string; }
138class Derived extends Base { bar: string; }
139class Derived2 extends Base { baz: string; }
140let base: Base;
141AssertType(base, "Base");
142
143let derived: Derived;
144AssertType(derived, "Derived");
145
146let derived2: Derived2;
147AssertType(derived2, "Derived2");
148
149module Derived {
150    let h = [{ foo: base, basear: derived }, { foo: base }]; // {foo: Base}[]
151    let i = [{ foo: base, basear: derived }, { foo: derived }]; // {foo: Derived}[]
152
153    let j = [() => base, () => derived]; // { {}: Base }
154    let k = [() => base, () => 1]; // {}[]~
155    let l = [() => base, () => null]; // { (): any }[]
156    let m = [() => base, () => derived, () => null]; // { (): any }[]
157    let n = [[() => base], [() => derived]]; // { (): Base }[]
158    let o = [derived, derived2]; // {}[]
159    let p = [derived, derived2, base]; // Base[]
160    let q = [[() => derived2], [() => derived]]; // {}[]
161}
162
163module WithContextualType {
164    // no errors
165    let a: Base[] = [derived, derived2];
166    let b: Derived[] = [null];
167    let c: Derived[] = [];
168    let d: { (): Base }[] = [() => derived, () => derived2];
169}
170
171function foo<T, U>(t: T, u: U) {
172    let a = [t, t]; // T[]
173AssertType(a, "T[]");
174AssertType([t, t], "T[]");
175AssertType(t, "T");
176AssertType(t, "T");
177
178    let b = [t, null]; // T[]
179AssertType(b, "T[]");
180AssertType([t, null], "T[]");
181AssertType(t, "T");
182AssertType(null, "null");
183
184    let c = [t, u]; // {}[]
185AssertType(c, "(union)[]");
186AssertType([t, u], "(union)[]");
187AssertType(t, "T");
188AssertType(u, "U");
189
190    let d = [t, 1]; // {}[]
191AssertType(d, "(union)[]");
192AssertType([t, 1], "(union)[]");
193AssertType(t, "T");
194AssertType(1, "int");
195
196    let e = [() => t, () => u]; // {}[]
197AssertType(e, "(union)[]");
198AssertType([() => t, () => u], "(union)[]");
199AssertType(() => t, "() => T");
200AssertType(t, "T");
201AssertType(() => u, "() => U");
202AssertType(u, "U");
203
204    let f = [() => t, () => u, () => null]; // { (): any }[]
205AssertType(f, "(() => any)[]");
206AssertType([() => t, () => u, () => null], "(() => any)[]");
207AssertType(() => t, "() => T");
208AssertType(t, "T");
209AssertType(() => u, "() => U");
210AssertType(u, "U");
211AssertType(() => null, "() => any");
212AssertType(null, "null");
213}
214
215function foo2<T extends Base, U extends Derived>(t: T, u: U) {
216    let a = [t, t]; // T[]
217AssertType(a, "T[]");
218AssertType([t, t], "T[]");
219AssertType(t, "T");
220AssertType(t, "T");
221
222    let b = [t, null]; // T[]
223AssertType(b, "T[]");
224AssertType([t, null], "T[]");
225AssertType(t, "T");
226AssertType(null, "null");
227
228    let c = [t, u]; // {}[]
229AssertType(c, "(union)[]");
230AssertType([t, u], "(union)[]");
231AssertType(t, "T");
232AssertType(u, "U");
233
234    let d = [t, 1]; // {}[]
235AssertType(d, "(union)[]");
236AssertType([t, 1], "(union)[]");
237AssertType(t, "T");
238AssertType(1, "int");
239
240    let e = [() => t, () => u]; // {}[]
241AssertType(e, "(union)[]");
242AssertType([() => t, () => u], "(union)[]");
243AssertType(() => t, "() => T");
244AssertType(t, "T");
245AssertType(() => u, "() => U");
246AssertType(u, "U");
247
248    let f = [() => t, () => u, () => null]; // { (): any }[]
249AssertType(f, "(() => any)[]");
250AssertType([() => t, () => u, () => null], "(() => any)[]");
251AssertType(() => t, "() => T");
252AssertType(t, "T");
253AssertType(() => u, "() => U");
254AssertType(u, "U");
255AssertType(() => null, "() => any");
256AssertType(null, "null");
257
258    let g = [t, base]; // Base[]
259AssertType(g, "Base[]");
260AssertType([t, base], "Base[]");
261AssertType(t, "T");
262AssertType(base, "Base");
263
264    let h = [t, derived]; // Derived[]
265AssertType(h, "(union)[]");
266AssertType([t, derived], "(union)[]");
267AssertType(t, "T");
268AssertType(derived, "Derived");
269
270    let i = [u, base]; // Base[]
271AssertType(i, "Base[]");
272AssertType([u, base], "Base[]");
273AssertType(u, "U");
274AssertType(base, "Base");
275
276    let j = [u, derived]; // Derived[]
277AssertType(j, "Derived[]");
278AssertType([u, derived], "Derived[]");
279AssertType(u, "U");
280AssertType(derived, "Derived");
281}
282
283function foo3<T extends Derived, U extends Derived>(t: T, u: U) {
284    let a = [t, t]; // T[]
285AssertType(a, "T[]");
286AssertType([t, t], "T[]");
287AssertType(t, "T");
288AssertType(t, "T");
289
290    let b = [t, null]; // T[]
291AssertType(b, "T[]");
292AssertType([t, null], "T[]");
293AssertType(t, "T");
294AssertType(null, "null");
295
296    let c = [t, u]; // {}[]
297AssertType(c, "(union)[]");
298AssertType([t, u], "(union)[]");
299AssertType(t, "T");
300AssertType(u, "U");
301
302    let d = [t, 1]; // {}[]
303AssertType(d, "(union)[]");
304AssertType([t, 1], "(union)[]");
305AssertType(t, "T");
306AssertType(1, "int");
307
308    let e = [() => t, () => u]; // {}[]
309AssertType(e, "(union)[]");
310AssertType([() => t, () => u], "(union)[]");
311AssertType(() => t, "() => T");
312AssertType(t, "T");
313AssertType(() => u, "() => U");
314AssertType(u, "U");
315
316    let f = [() => t, () => u, () => null]; // { (): any }[]
317AssertType(f, "(() => any)[]");
318AssertType([() => t, () => u, () => null], "(() => any)[]");
319AssertType(() => t, "() => T");
320AssertType(t, "T");
321AssertType(() => u, "() => U");
322AssertType(u, "U");
323AssertType(() => null, "() => any");
324AssertType(null, "null");
325
326    let g = [t, base]; // Base[]
327AssertType(g, "Base[]");
328AssertType([t, base], "Base[]");
329AssertType(t, "T");
330AssertType(base, "Base");
331
332    let h = [t, derived]; // Derived[]
333AssertType(h, "Derived[]");
334AssertType([t, derived], "Derived[]");
335AssertType(t, "T");
336AssertType(derived, "Derived");
337
338    let i = [u, base]; // Base[]
339AssertType(i, "Base[]");
340AssertType([u, base], "Base[]");
341AssertType(u, "U");
342AssertType(base, "Base");
343
344    let j = [u, derived]; // Derived[]
345AssertType(j, "Derived[]");
346AssertType([u, derived], "Derived[]");
347AssertType(u, "U");
348AssertType(derived, "Derived");
349}
350
351function foo4<T extends Base, U extends Base>(t: T, u: U) {
352    let a = [t, t]; // T[]
353AssertType(a, "T[]");
354AssertType([t, t], "T[]");
355AssertType(t, "T");
356AssertType(t, "T");
357
358    let b = [t, null]; // T[]
359AssertType(b, "T[]");
360AssertType([t, null], "T[]");
361AssertType(t, "T");
362AssertType(null, "null");
363
364    let c = [t, u]; // BUG 821629
365AssertType(c, "(union)[]");
366AssertType([t, u], "(union)[]");
367AssertType(t, "T");
368AssertType(u, "U");
369
370    let d = [t, 1]; // {}[]
371AssertType(d, "(union)[]");
372AssertType([t, 1], "(union)[]");
373AssertType(t, "T");
374AssertType(1, "int");
375
376    let e = [() => t, () => u]; // {}[]
377AssertType(e, "(union)[]");
378AssertType([() => t, () => u], "(union)[]");
379AssertType(() => t, "() => T");
380AssertType(t, "T");
381AssertType(() => u, "() => U");
382AssertType(u, "U");
383
384    let f = [() => t, () => u, () => null]; // { (): any }[]
385AssertType(f, "(() => any)[]");
386AssertType([() => t, () => u, () => null], "(() => any)[]");
387AssertType(() => t, "() => T");
388AssertType(t, "T");
389AssertType(() => u, "() => U");
390AssertType(u, "U");
391AssertType(() => null, "() => any");
392AssertType(null, "null");
393
394    let g = [t, base]; // Base[]
395AssertType(g, "Base[]");
396AssertType([t, base], "Base[]");
397AssertType(t, "T");
398AssertType(base, "Base");
399
400    let h = [t, derived]; // Derived[]
401AssertType(h, "(union)[]");
402AssertType([t, derived], "(union)[]");
403AssertType(t, "T");
404AssertType(derived, "Derived");
405
406    let i = [u, base]; // Base[]
407AssertType(i, "Base[]");
408AssertType([u, base], "Base[]");
409AssertType(u, "U");
410AssertType(base, "Base");
411
412    let j = [u, derived]; // Derived[]
413AssertType(j, "(union)[]");
414AssertType([u, derived], "(union)[]");
415AssertType(u, "U");
416AssertType(derived, "Derived");
417
418    let k: Base[] = [t, u];
419AssertType(k, "Base[]");
420AssertType([t, u], "(union)[]");
421AssertType(t, "T");
422AssertType(u, "U");
423}
424
425//function foo3<T extends U, U extends Derived>(t: T, u: U) {
426//    let a = [t, t]; // T[]
427//    let b = [t, null]; // T[]
428//    let c = [t, u]; // {}[]
429//    let d = [t, 1]; // {}[]
430//    let e = [() => t, () => u]; // {}[]
431//    let f = [() => t, () => u, () => null]; // { (): any }[]
432
433//    let g = [t, base]; // Base[]
434//    let h = [t, derived]; // Derived[]
435//    let i = [u, base]; // Base[]
436//    let j = [u, derived]; // Derived[]
437//}
438
439//function foo4<T extends U, U extends Base>(t: T, u: U) {
440//    let a = [t, t]; // T[]
441//    let b = [t, null]; // T[]
442//    let c = [t, u]; // BUG 821629
443//    let d = [t, 1]; // {}[]
444//    let e = [() => t, () => u]; // {}[]
445//    let f = [() => t, () => u, () => null]; // { (): any }[]
446
447//    let g = [t, base]; // Base[]
448//    let h = [t, derived]; // Derived[]
449//    let i = [u, base]; // Base[]
450//    let j = [u, derived]; // Derived[]
451
452//    let k: Base[] = [t, u];
453//}
454
455