1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
|
//// [genericTypeAliases.ts]
type Tree<T> = T | { left: Tree<T>, right: Tree<T> };
var tree: Tree<number> = {
left: {
left: 0,
right: {
left: 1,
right: 2
},
},
right: 3
};
type Lazy<T> = T | (() => T);
var ls: Lazy<string>;
ls = "eager";
ls = () => "lazy";
type Foo<T> = T | { x: Foo<T> };
type Bar<U> = U | { x: Bar<U> };
// Deeply instantiated generics
var x: Foo<string>;
var y: Bar<string>;
x = y;
y = x;
x = "string";
x = { x: "hello" };
x = { x: { x: "world" } };
var z: Foo<number>;
z = 42;
z = { x: 42 };
z = { x: { x: 42 } };
type Strange<T> = string; // Type parameter not used
var s: Strange<number>;
s = "hello";
interface AB<A, B> {
a: A;
b: B;
}
type Pair<T> = AB<T, T>;
interface TaggedPair<T> extends Pair<T> {
tag: string;
}
var p: TaggedPair<number>;
p.a = 1;
p.b = 2;
p.tag = "test";
function f<A>() {
type Foo<T> = T | { x: Foo<T> };
var x: Foo<A[]>;
return x;
}
function g<B>() {
type Bar<U> = U | { x: Bar<U> };
var x: Bar<B[]>;
return x;
}
// Deeply instantiated generics
var a = f<string>();
var b = g<string>();
a = b;
//// [genericTypeAliases.js]
var tree = {
left: {
left: 0,
right: {
left: 1,
right: 2
}
},
right: 3
};
var ls;
ls = "eager";
ls = function () { return "lazy"; };
// Deeply instantiated generics
var x;
var y;
x = y;
y = x;
x = "string";
x = { x: "hello" };
x = { x: { x: "world" } };
var z;
z = 42;
z = { x: 42 };
z = { x: { x: 42 } };
var s;
s = "hello";
var p;
p.a = 1;
p.b = 2;
p.tag = "test";
function f() {
var x;
return x;
}
function g() {
var x;
return x;
}
// Deeply instantiated generics
var a = f();
var b = g();
a = b;
|
