Skip to content

Commit 3c2f556

Browse files
vladimavladima
committed
Merge pull request #1033 from Microsoft/type_aliases_conformance
Type aliases conformance tests, fixed #1004
2 parents 23c9b01 + cba9b7f commit 3c2f556

10 files changed

+709
-0
lines changed

‎tests/baselines/reference/directDependenceBetweenTypeAliases.errors.txt

+72
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,72 @@
1+
tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts(4,6): error TS2456: Type alias 'T0' circularly references itself.
2+
tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts(6,6): error TS2456: Type alias 'T0_2' circularly references itself.
3+
tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts(11,6): error TS2456: Type alias 'T1' circularly references itself.
4+
tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts(14,6): error TS2456: Type alias 'T2' circularly references itself.
5+
tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts(16,6): error TS2456: Type alias 'T2_1' circularly references itself.
6+
tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts(19,6): error TS2456: Type alias 'T3' circularly references itself.
7+
tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts(22,6): error TS2456: Type alias 'T4' circularly references itself.
8+
tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts(26,6): error TS2456: Type alias 'T5' circularly references itself.
9+
tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts(30,6): error TS2456: Type alias 'T7' circularly references itself.
10+
11+
12+
==== tests/cases/conformance/types/typeAliases/directDependenceBetweenTypeAliases.ts (9 errors) ====
13+
// It is an error for the type specified in a type alias to depend on that type alias
14+
15+
// A type alias directly depends on the type it aliases.
16+
type T0 = T0
17+
~~
18+
!!! error TS2456: Type alias 'T0' circularly references itself.
19+
type T0_1 = T0_2
20+
type T0_2 = T0_3
21+
~~~~
22+
!!! error TS2456: Type alias 'T0_2' circularly references itself.
23+
type T0_3 = T0_1
24+
25+
// A type reference directly depends on the referenced type and each of the type arguments, if any.
26+
interface I<T> {}
27+
type T1 = I<T1>
28+
~~
29+
!!! error TS2456: Type alias 'T1' circularly references itself.
30+
31+
// A union type directly depends on each of the constituent types.
32+
type T2 = T2 | string
33+
~~
34+
!!! error TS2456: Type alias 'T2' circularly references itself.
35+
class C<T> {}
36+
type T2_1 = T2_1[] | number
37+
~~~~
38+
!!! error TS2456: Type alias 'T2_1' circularly references itself.
39+
40+
// An array type directly depends on its element type.
41+
type T3 = T3[]
42+
~~
43+
!!! error TS2456: Type alias 'T3' circularly references itself.
44+
45+
// A tuple type directly depends on each of its element types.
46+
type T4 = [number, T4]
47+
~~
48+
!!! error TS2456: Type alias 'T4' circularly references itself.
49+
50+
// A type query directly depends on the type of the referenced entity.
51+
var x: T5[] = []
52+
type T5 = typeof x
53+
~~
54+
!!! error TS2456: Type alias 'T5' circularly references itself.
55+
56+
class C1<T> {}
57+
type T6 = T7 | number
58+
type T7 = typeof yy
59+
~~
60+
!!! error TS2456: Type alias 'T7' circularly references itself.
61+
var yy: [string, T8[]];
62+
type T8 = C<T6>
63+
64+
// legal cases
65+
type T9 = () => T9
66+
type T10 = { x: T10 } | { new(v: T10): string }
67+
type T11 = T12[]
68+
type T12 = [T13, string]
69+
type T13 = typeof zz
70+
var zz: { x: T11 }
71+
72+

‎tests/baselines/reference/directDependenceBetweenTypeAliases.js

+60
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,60 @@
1+
//// [directDependenceBetweenTypeAliases.ts]
2+
// It is an error for the type specified in a type alias to depend on that type alias
3+
4+
// A type alias directly depends on the type it aliases.
5+
type T0 = T0
6+
type T0_1 = T0_2
7+
type T0_2 = T0_3
8+
type T0_3 = T0_1
9+
10+
// A type reference directly depends on the referenced type and each of the type arguments, if any.
11+
interface I<T> {}
12+
type T1 = I<T1>
13+
14+
// A union type directly depends on each of the constituent types.
15+
type T2 = T2 | string
16+
class C<T> {}
17+
type T2_1 = T2_1[] | number
18+
19+
// An array type directly depends on its element type.
20+
type T3 = T3[]
21+
22+
// A tuple type directly depends on each of its element types.
23+
type T4 = [number, T4]
24+
25+
// A type query directly depends on the type of the referenced entity.
26+
var x: T5[] = []
27+
type T5 = typeof x
28+
29+
class C1<T> {}
30+
type T6 = T7 | number
31+
type T7 = typeof yy
32+
var yy: [string, T8[]];
33+
type T8 = C<T6>
34+
35+
// legal cases
36+
type T9 = () => T9
37+
type T10 = { x: T10 } | { new(v: T10): string }
38+
type T11 = T12[]
39+
type T12 = [T13, string]
40+
type T13 = typeof zz
41+
var zz: { x: T11 }
42+
43+
44+
45+
//// [directDependenceBetweenTypeAliases.js]
46+
// It is an error for the type specified in a type alias to depend on that type alias
47+
var C = (function () {
48+
function C() {
49+
}
50+
return C;
51+
})();
52+
// A type query directly depends on the type of the referenced entity.
53+
var x = [];
54+
var C1 = (function () {
55+
function C1() {
56+
}
57+
return C1;
58+
})();
59+
var yy;
60+
var zz;

‎tests/baselines/reference/reservedNamesInAliases.errors.txt

+30
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,30 @@
1+
tests/cases/conformance/types/typeAliases/reservedNamesInAliases.ts(6,6): error TS1003: Identifier expected.
2+
tests/cases/conformance/types/typeAliases/reservedNamesInAliases.ts(6,11): error TS1005: ';' expected.
3+
tests/cases/conformance/types/typeAliases/reservedNamesInAliases.ts(2,6): error TS2457: Type alias name cannot be 'any'
4+
tests/cases/conformance/types/typeAliases/reservedNamesInAliases.ts(3,6): error TS2457: Type alias name cannot be 'number'
5+
tests/cases/conformance/types/typeAliases/reservedNamesInAliases.ts(4,6): error TS2457: Type alias name cannot be 'boolean'
6+
tests/cases/conformance/types/typeAliases/reservedNamesInAliases.ts(5,6): error TS2457: Type alias name cannot be 'string'
7+
tests/cases/conformance/types/typeAliases/reservedNamesInAliases.ts(6,13): error TS2304: Cannot find name 'I'.
8+
9+
10+
==== tests/cases/conformance/types/typeAliases/reservedNamesInAliases.ts (7 errors) ====
11+
interface I {}
12+
type any = I;
13+
~~~
14+
!!! error TS2457: Type alias name cannot be 'any'
15+
type number = I;
16+
~~~~~~
17+
!!! error TS2457: Type alias name cannot be 'number'
18+
type boolean = I;
19+
~~~~~~~
20+
!!! error TS2457: Type alias name cannot be 'boolean'
21+
type string = I;
22+
~~~~~~
23+
!!! error TS2457: Type alias name cannot be 'string'
24+
type void = I;
25+
~~~~
26+
!!! error TS1003: Identifier expected.
27+
~
28+
!!! error TS1005: ';' expected.
29+
~
30+
!!! error TS2304: Cannot find name 'I'.

‎tests/baselines/reference/typeAliases.js

+126
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,126 @@
1+
//// [typeAliases.ts]
2+
// Writing a reference to a type alias has exactly the same effect as writing the aliased type itself.
3+
4+
type T1 = number;
5+
var x1: number;
6+
var x1: T1;
7+
8+
type T2 = string;
9+
var x2: string;
10+
var x2: T2;
11+
12+
type T3 = boolean;
13+
var x3: boolean;
14+
var x3: T3;
15+
16+
type T4 = void;
17+
var x4: void;
18+
var x4: T4;
19+
20+
type T5 = any;
21+
var x5: any;
22+
var x5: T5;
23+
24+
interface I6 { x : string }
25+
type T6 = I6;
26+
var x6: I6;
27+
var x6: T6;
28+
29+
class C7 { x: boolean }
30+
type T7 = C7;
31+
var x7: C7;
32+
var x7: T7;
33+
34+
type T8 = string | boolean;
35+
var x8: string | boolean;
36+
var x8: T8;
37+
38+
type T9 = () => string;
39+
var x9: () => string;
40+
var x9: T9;
41+
42+
type T10 = { x: number };
43+
var x10: { x: number };
44+
var x10: T10;
45+
46+
type T11 = { new(): boolean };
47+
var x11: { new(): boolean };
48+
var x11: T11;
49+
50+
interface I13 { x: string };
51+
type T13 = I13;
52+
var x13_1: I13;
53+
var x13_2: T13
54+
55+
declare function foo13<T1 extends I13, T2 extends T13>(t1: T1, t2: T13): void;
56+
foo13(x13_1, x13_2);
57+
foo13(x13_2, x13_1);
58+
59+
type T14 = string;
60+
var x14: T14;
61+
62+
declare function foo14_1(x: T14): void;
63+
64+
declare function foo14_2(x: "click"): void;
65+
declare function foo14_2(x: T14): void;
66+
67+
type Meters = number
68+
69+
enum E { x = 10 }
70+
71+
declare function f15(a: string): boolean;
72+
declare function f15(a: Meters): string;
73+
f15(E.x).toLowerCase();
74+
75+
type StringAndBoolean = [string, boolean]
76+
declare function f16(s: StringAndBoolean): string;
77+
var x: [string, boolean];
78+
f16(x);
79+
80+
var y: StringAndBoolean = ["1", false];
81+
y[0].toLowerCase();
82+
83+
//// [typeAliases.js]
84+
// Writing a reference to a type alias has exactly the same effect as writing the aliased type itself.
85+
var x1;
86+
var x1;
87+
var x2;
88+
var x2;
89+
var x3;
90+
var x3;
91+
var x4;
92+
var x4;
93+
var x5;
94+
var x5;
95+
var x6;
96+
var x6;
97+
var C7 = (function () {
98+
function C7() {
99+
}
100+
return C7;
101+
})();
102+
var x7;
103+
var x7;
104+
var x8;
105+
var x8;
106+
var x9;
107+
var x9;
108+
var x10;
109+
var x10;
110+
var x11;
111+
var x11;
112+
;
113+
var x13_1;
114+
var x13_2;
115+
foo13(x13_1, x13_2);
116+
foo13(x13_2, x13_1);
117+
var x14;
118+
var E;
119+
(function (E) {
120+
E[E["x"] = 10] = "x";
121+
})(E || (E = {}));
122+
f15(10 /* x */).toLowerCase();
123+
var x;
124+
f16(x);
125+
var y = ["1", false];
126+
y[0].toLowerCase();

0 commit comments

Comments
 (0)