diff --git a/tests/baselines/reference/genericTypeAliases.js b/tests/baselines/reference/genericTypeAliases.js
new file mode 100644
index 00000000000..8218f5c886c
--- /dev/null
+++ b/tests/baselines/reference/genericTypeAliases.js
@@ -0,0 +1,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 Tuple<A, B> {
+    a: A;
+    b: B;
+}
+
+type Pair<T> = Tuple<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;
diff --git a/tests/baselines/reference/genericTypeAliases.symbols b/tests/baselines/reference/genericTypeAliases.symbols
new file mode 100644
index 00000000000..1a1d0e51487
--- /dev/null
+++ b/tests/baselines/reference/genericTypeAliases.symbols
@@ -0,0 +1,231 @@
+=== tests/cases/conformance/types/typeAliases/genericTypeAliases.ts ===
+type Tree<T> = T | { left: Tree<T>, right: Tree<T> };
+>Tree : Symbol(Tree, Decl(genericTypeAliases.ts, 0, 0))
+>T : Symbol(T, Decl(genericTypeAliases.ts, 0, 10))
+>T : Symbol(T, Decl(genericTypeAliases.ts, 0, 10))
+>left : Symbol(left, Decl(genericTypeAliases.ts, 0, 20))
+>Tree : Symbol(Tree, Decl(genericTypeAliases.ts, 0, 0))
+>T : Symbol(T, Decl(genericTypeAliases.ts, 0, 10))
+>right : Symbol(right, Decl(genericTypeAliases.ts, 0, 35))
+>Tree : Symbol(Tree, Decl(genericTypeAliases.ts, 0, 0))
+>T : Symbol(T, Decl(genericTypeAliases.ts, 0, 10))
+
+var tree: Tree<number> = {
+>tree : Symbol(tree, Decl(genericTypeAliases.ts, 2, 3))
+>Tree : Symbol(Tree, Decl(genericTypeAliases.ts, 0, 0))
+
+    left: {
+>left : Symbol(left, Decl(genericTypeAliases.ts, 2, 26))
+
+        left: 0,
+>left : Symbol(left, Decl(genericTypeAliases.ts, 3, 11))
+
+        right: {
+>right : Symbol(right, Decl(genericTypeAliases.ts, 4, 16))
+
+            left: 1,
+>left : Symbol(left, Decl(genericTypeAliases.ts, 5, 16))
+
+            right: 2
+>right : Symbol(right, Decl(genericTypeAliases.ts, 6, 20))
+
+        },
+    },
+    right: 3
+>right : Symbol(right, Decl(genericTypeAliases.ts, 9, 6))
+
+};
+
+type Lazy<T> = T | (() => T);
+>Lazy : Symbol(Lazy, Decl(genericTypeAliases.ts, 11, 2))
+>T : Symbol(T, Decl(genericTypeAliases.ts, 13, 10))
+>T : Symbol(T, Decl(genericTypeAliases.ts, 13, 10))
+>T : Symbol(T, Decl(genericTypeAliases.ts, 13, 10))
+
+var ls: Lazy<string>;
+>ls : Symbol(ls, Decl(genericTypeAliases.ts, 15, 3))
+>Lazy : Symbol(Lazy, Decl(genericTypeAliases.ts, 11, 2))
+
+ls = "eager";
+>ls : Symbol(ls, Decl(genericTypeAliases.ts, 15, 3))
+
+ls = () => "lazy";
+>ls : Symbol(ls, Decl(genericTypeAliases.ts, 15, 3))
+
+type Foo<T> = T | { x: Foo<T> };
+>Foo : Symbol(Foo, Decl(genericTypeAliases.ts, 17, 18))
+>T : Symbol(T, Decl(genericTypeAliases.ts, 19, 9))
+>T : Symbol(T, Decl(genericTypeAliases.ts, 19, 9))
+>x : Symbol(x, Decl(genericTypeAliases.ts, 19, 19))
+>Foo : Symbol(Foo, Decl(genericTypeAliases.ts, 17, 18))
+>T : Symbol(T, Decl(genericTypeAliases.ts, 19, 9))
+
+type Bar<U> = U | { x: Bar<U> };
+>Bar : Symbol(Bar, Decl(genericTypeAliases.ts, 19, 32))
+>U : Symbol(U, Decl(genericTypeAliases.ts, 20, 9))
+>U : Symbol(U, Decl(genericTypeAliases.ts, 20, 9))
+>x : Symbol(x, Decl(genericTypeAliases.ts, 20, 19))
+>Bar : Symbol(Bar, Decl(genericTypeAliases.ts, 19, 32))
+>U : Symbol(U, Decl(genericTypeAliases.ts, 20, 9))
+
+// Deeply instantiated generics
+var x: Foo<string>;
+>x : Symbol(x, Decl(genericTypeAliases.ts, 23, 3))
+>Foo : Symbol(Foo, Decl(genericTypeAliases.ts, 17, 18))
+
+var y: Bar<string>;
+>y : Symbol(y, Decl(genericTypeAliases.ts, 24, 3))
+>Bar : Symbol(Bar, Decl(genericTypeAliases.ts, 19, 32))
+
+x = y;
+>x : Symbol(x, Decl(genericTypeAliases.ts, 23, 3))
+>y : Symbol(y, Decl(genericTypeAliases.ts, 24, 3))
+
+y = x;
+>y : Symbol(y, Decl(genericTypeAliases.ts, 24, 3))
+>x : Symbol(x, Decl(genericTypeAliases.ts, 23, 3))
+
+x = "string";
+>x : Symbol(x, Decl(genericTypeAliases.ts, 23, 3))
+
+x = { x: "hello" };
+>x : Symbol(x, Decl(genericTypeAliases.ts, 23, 3))
+>x : Symbol(x, Decl(genericTypeAliases.ts, 29, 5))
+
+x = { x: { x: "world" } };
+>x : Symbol(x, Decl(genericTypeAliases.ts, 23, 3))
+>x : Symbol(x, Decl(genericTypeAliases.ts, 30, 5))
+>x : Symbol(x, Decl(genericTypeAliases.ts, 30, 10))
+
+var z: Foo<number>;
+>z : Symbol(z, Decl(genericTypeAliases.ts, 32, 3))
+>Foo : Symbol(Foo, Decl(genericTypeAliases.ts, 17, 18))
+
+z = 42;
+>z : Symbol(z, Decl(genericTypeAliases.ts, 32, 3))
+
+z = { x: 42 };
+>z : Symbol(z, Decl(genericTypeAliases.ts, 32, 3))
+>x : Symbol(x, Decl(genericTypeAliases.ts, 34, 5))
+
+z = { x: { x: 42 } };
+>z : Symbol(z, Decl(genericTypeAliases.ts, 32, 3))
+>x : Symbol(x, Decl(genericTypeAliases.ts, 35, 5))
+>x : Symbol(x, Decl(genericTypeAliases.ts, 35, 10))
+
+type Strange<T> = string;  // Type parameter not used
+>Strange : Symbol(Strange, Decl(genericTypeAliases.ts, 35, 21))
+>T : Symbol(T, Decl(genericTypeAliases.ts, 37, 13))
+
+var s: Strange<number>;
+>s : Symbol(s, Decl(genericTypeAliases.ts, 38, 3))
+>Strange : Symbol(Strange, Decl(genericTypeAliases.ts, 35, 21))
+
+s = "hello";
+>s : Symbol(s, Decl(genericTypeAliases.ts, 38, 3))
+
+interface Tuple<A, B> {
+>Tuple : Symbol(Tuple, Decl(genericTypeAliases.ts, 39, 12))
+>A : Symbol(A, Decl(genericTypeAliases.ts, 41, 16))
+>B : Symbol(B, Decl(genericTypeAliases.ts, 41, 18))
+
+    a: A;
+>a : Symbol(a, Decl(genericTypeAliases.ts, 41, 23))
+>A : Symbol(A, Decl(genericTypeAliases.ts, 41, 16))
+
+    b: B;
+>b : Symbol(b, Decl(genericTypeAliases.ts, 42, 9))
+>B : Symbol(B, Decl(genericTypeAliases.ts, 41, 18))
+}
+
+type Pair<T> = Tuple<T, T>;
+>Pair : Symbol(Pair, Decl(genericTypeAliases.ts, 44, 1))
+>T : Symbol(T, Decl(genericTypeAliases.ts, 46, 10))
+>Tuple : Symbol(Tuple, Decl(genericTypeAliases.ts, 39, 12))
+>T : Symbol(T, Decl(genericTypeAliases.ts, 46, 10))
+>T : Symbol(T, Decl(genericTypeAliases.ts, 46, 10))
+
+interface TaggedPair<T> extends Pair<T> {
+>TaggedPair : Symbol(TaggedPair, Decl(genericTypeAliases.ts, 46, 27))
+>T : Symbol(T, Decl(genericTypeAliases.ts, 48, 21))
+>Pair : Symbol(Pair, Decl(genericTypeAliases.ts, 44, 1))
+>T : Symbol(T, Decl(genericTypeAliases.ts, 48, 21))
+
+    tag: string;
+>tag : Symbol(tag, Decl(genericTypeAliases.ts, 48, 41))
+}
+
+var p: TaggedPair<number>;
+>p : Symbol(p, Decl(genericTypeAliases.ts, 52, 3))
+>TaggedPair : Symbol(TaggedPair, Decl(genericTypeAliases.ts, 46, 27))
+
+p.a = 1;
+>p.a : Symbol(Tuple.a, Decl(genericTypeAliases.ts, 41, 23))
+>p : Symbol(p, Decl(genericTypeAliases.ts, 52, 3))
+>a : Symbol(Tuple.a, Decl(genericTypeAliases.ts, 41, 23))
+
+p.b = 2;
+>p.b : Symbol(Tuple.b, Decl(genericTypeAliases.ts, 42, 9))
+>p : Symbol(p, Decl(genericTypeAliases.ts, 52, 3))
+>b : Symbol(Tuple.b, Decl(genericTypeAliases.ts, 42, 9))
+
+p.tag = "test";
+>p.tag : Symbol(TaggedPair.tag, Decl(genericTypeAliases.ts, 48, 41))
+>p : Symbol(p, Decl(genericTypeAliases.ts, 52, 3))
+>tag : Symbol(TaggedPair.tag, Decl(genericTypeAliases.ts, 48, 41))
+
+function f<A>() {
+>f : Symbol(f, Decl(genericTypeAliases.ts, 55, 15))
+>A : Symbol(A, Decl(genericTypeAliases.ts, 57, 11))
+
+    type Foo<T> = T | { x: Foo<T> };
+>Foo : Symbol(Foo, Decl(genericTypeAliases.ts, 57, 17))
+>T : Symbol(T, Decl(genericTypeAliases.ts, 58, 13))
+>T : Symbol(T, Decl(genericTypeAliases.ts, 58, 13))
+>x : Symbol(x, Decl(genericTypeAliases.ts, 58, 23))
+>Foo : Symbol(Foo, Decl(genericTypeAliases.ts, 57, 17))
+>T : Symbol(T, Decl(genericTypeAliases.ts, 58, 13))
+
+    var x: Foo<A[]>;
+>x : Symbol(x, Decl(genericTypeAliases.ts, 59, 7))
+>Foo : Symbol(Foo, Decl(genericTypeAliases.ts, 57, 17))
+>A : Symbol(A, Decl(genericTypeAliases.ts, 57, 11))
+
+    return x;
+>x : Symbol(x, Decl(genericTypeAliases.ts, 59, 7))
+}
+
+function g<B>() {
+>g : Symbol(g, Decl(genericTypeAliases.ts, 61, 1))
+>B : Symbol(B, Decl(genericTypeAliases.ts, 63, 11))
+
+    type Bar<U> = U | { x: Bar<U> };
+>Bar : Symbol(Bar, Decl(genericTypeAliases.ts, 63, 17))
+>U : Symbol(U, Decl(genericTypeAliases.ts, 64, 13))
+>U : Symbol(U, Decl(genericTypeAliases.ts, 64, 13))
+>x : Symbol(x, Decl(genericTypeAliases.ts, 64, 23))
+>Bar : Symbol(Bar, Decl(genericTypeAliases.ts, 63, 17))
+>U : Symbol(U, Decl(genericTypeAliases.ts, 64, 13))
+
+    var x: Bar<B[]>;
+>x : Symbol(x, Decl(genericTypeAliases.ts, 65, 7))
+>Bar : Symbol(Bar, Decl(genericTypeAliases.ts, 63, 17))
+>B : Symbol(B, Decl(genericTypeAliases.ts, 63, 11))
+
+    return x;
+>x : Symbol(x, Decl(genericTypeAliases.ts, 65, 7))
+}
+
+// Deeply instantiated generics
+var a = f<string>();
+>a : Symbol(a, Decl(genericTypeAliases.ts, 70, 3))
+>f : Symbol(f, Decl(genericTypeAliases.ts, 55, 15))
+
+var b = g<string>();
+>b : Symbol(b, Decl(genericTypeAliases.ts, 71, 3))
+>g : Symbol(g, Decl(genericTypeAliases.ts, 61, 1))
+
+a = b;
+>a : Symbol(a, Decl(genericTypeAliases.ts, 70, 3))
+>b : Symbol(b, Decl(genericTypeAliases.ts, 71, 3))
+
diff --git a/tests/baselines/reference/genericTypeAliases.types b/tests/baselines/reference/genericTypeAliases.types
new file mode 100644
index 00000000000..b43e2610725
--- /dev/null
+++ b/tests/baselines/reference/genericTypeAliases.types
@@ -0,0 +1,274 @@
+=== tests/cases/conformance/types/typeAliases/genericTypeAliases.ts ===
+type Tree<T> = T | { left: Tree<T>, right: Tree<T> };
+>Tree : T | { left: T | any; right: T | any; }
+>T : T
+>T : T
+>left : T | { left: T | any; right: T | any; }
+>Tree : T | { left: T | any; right: T | any; }
+>T : T
+>right : T | { left: T | any; right: T | any; }
+>Tree : T | { left: T | any; right: T | any; }
+>T : T
+
+var tree: Tree<number> = {
+>tree : number | { left: number | any; right: number | any; }
+>Tree : T | { left: T | any; right: T | any; }
+>{    left: {        left: 0,        right: {            left: 1,            right: 2        },    },    right: 3} : { left: { left: number; right: { left: number; right: number; }; }; right: number; }
+
+    left: {
+>left : { left: number; right: { left: number; right: number; }; }
+>{        left: 0,        right: {            left: 1,            right: 2        },    } : { left: number; right: { left: number; right: number; }; }
+
+        left: 0,
+>left : number
+>0 : number
+
+        right: {
+>right : { left: number; right: number; }
+>{            left: 1,            right: 2        } : { left: number; right: number; }
+
+            left: 1,
+>left : number
+>1 : number
+
+            right: 2
+>right : number
+>2 : number
+
+        },
+    },
+    right: 3
+>right : number
+>3 : number
+
+};
+
+type Lazy<T> = T | (() => T);
+>Lazy : T | (() => T)
+>T : T
+>T : T
+>T : T
+
+var ls: Lazy<string>;
+>ls : string | (() => string)
+>Lazy : T | (() => T)
+
+ls = "eager";
+>ls = "eager" : string
+>ls : string | (() => string)
+>"eager" : string
+
+ls = () => "lazy";
+>ls = () => "lazy" : () => string
+>ls : string | (() => string)
+>() => "lazy" : () => string
+>"lazy" : string
+
+type Foo<T> = T | { x: Foo<T> };
+>Foo : T | { x: T | any; }
+>T : T
+>T : T
+>x : T | { x: T | any; }
+>Foo : T | { x: T | any; }
+>T : T
+
+type Bar<U> = U | { x: Bar<U> };
+>Bar : U | { x: U | any; }
+>U : U
+>U : U
+>x : U | { x: U | any; }
+>Bar : U | { x: U | any; }
+>U : U
+
+// Deeply instantiated generics
+var x: Foo<string>;
+>x : string | { x: string | any; }
+>Foo : T | { x: T | any; }
+
+var y: Bar<string>;
+>y : string | { x: string | any; }
+>Bar : U | { x: U | any; }
+
+x = y;
+>x = y : string | { x: string | any; }
+>x : string | { x: string | any; }
+>y : string | { x: string | any; }
+
+y = x;
+>y = x : string | { x: string | any; }
+>y : string | { x: string | any; }
+>x : string | { x: string | any; }
+
+x = "string";
+>x = "string" : string
+>x : string | { x: string | any; }
+>"string" : string
+
+x = { x: "hello" };
+>x = { x: "hello" } : { x: string; }
+>x : string | { x: string | any; }
+>{ x: "hello" } : { x: string; }
+>x : string
+>"hello" : string
+
+x = { x: { x: "world" } };
+>x = { x: { x: "world" } } : { x: { x: string; }; }
+>x : string | { x: string | any; }
+>{ x: { x: "world" } } : { x: { x: string; }; }
+>x : { x: string; }
+>{ x: "world" } : { x: string; }
+>x : string
+>"world" : string
+
+var z: Foo<number>;
+>z : number | { x: number | any; }
+>Foo : T | { x: T | any; }
+
+z = 42;
+>z = 42 : number
+>z : number | { x: number | any; }
+>42 : number
+
+z = { x: 42 };
+>z = { x: 42 } : { x: number; }
+>z : number | { x: number | any; }
+>{ x: 42 } : { x: number; }
+>x : number
+>42 : number
+
+z = { x: { x: 42 } };
+>z = { x: { x: 42 } } : { x: { x: number; }; }
+>z : number | { x: number | any; }
+>{ x: { x: 42 } } : { x: { x: number; }; }
+>x : { x: number; }
+>{ x: 42 } : { x: number; }
+>x : number
+>42 : number
+
+type Strange<T> = string;  // Type parameter not used
+>Strange : string
+>T : T
+
+var s: Strange<number>;
+>s : string
+>Strange : string
+
+s = "hello";
+>s = "hello" : string
+>s : string
+>"hello" : string
+
+interface Tuple<A, B> {
+>Tuple : Tuple<A, B>
+>A : A
+>B : B
+
+    a: A;
+>a : A
+>A : A
+
+    b: B;
+>b : B
+>B : B
+}
+
+type Pair<T> = Tuple<T, T>;
+>Pair : Tuple<T, T>
+>T : T
+>Tuple : Tuple<A, B>
+>T : T
+>T : T
+
+interface TaggedPair<T> extends Pair<T> {
+>TaggedPair : TaggedPair<T>
+>T : T
+>Pair : Tuple<T, T>
+>T : T
+
+    tag: string;
+>tag : string
+}
+
+var p: TaggedPair<number>;
+>p : TaggedPair<number>
+>TaggedPair : TaggedPair<T>
+
+p.a = 1;
+>p.a = 1 : number
+>p.a : number
+>p : TaggedPair<number>
+>a : number
+>1 : number
+
+p.b = 2;
+>p.b = 2 : number
+>p.b : number
+>p : TaggedPair<number>
+>b : number
+>2 : number
+
+p.tag = "test";
+>p.tag = "test" : string
+>p.tag : string
+>p : TaggedPair<number>
+>tag : string
+>"test" : string
+
+function f<A>() {
+>f : <A>() => A[] | { x: A[] | any; }
+>A : A
+
+    type Foo<T> = T | { x: Foo<T> };
+>Foo : T | { x: T | any; }
+>T : T
+>T : T
+>x : T | { x: T | any; }
+>Foo : T | { x: T | any; }
+>T : T
+
+    var x: Foo<A[]>;
+>x : A[] | { x: A[] | any; }
+>Foo : T | { x: T | any; }
+>A : A
+
+    return x;
+>x : A[] | { x: A[] | any; }
+}
+
+function g<B>() {
+>g : <B>() => B[] | { x: B[] | any; }
+>B : B
+
+    type Bar<U> = U | { x: Bar<U> };
+>Bar : U | { x: U | any; }
+>U : U
+>U : U
+>x : U | { x: U | any; }
+>Bar : U | { x: U | any; }
+>U : U
+
+    var x: Bar<B[]>;
+>x : B[] | { x: B[] | any; }
+>Bar : U | { x: U | any; }
+>B : B
+
+    return x;
+>x : B[] | { x: B[] | any; }
+}
+
+// Deeply instantiated generics
+var a = f<string>();
+>a : string[] | { x: string[] | any; }
+>f<string>() : string[] | { x: string[] | any; }
+>f : <A>() => A[] | { x: A[] | any; }
+
+var b = g<string>();
+>b : string[] | { x: string[] | any; }
+>g<string>() : string[] | { x: string[] | any; }
+>g : <B>() => B[] | { x: B[] | any; }
+
+a = b;
+>a = b : string[] | { x: string[] | any; }
+>a : string[] | { x: string[] | any; }
+>b : string[] | { x: string[] | any; }
+
diff --git a/tests/cases/conformance/types/typeAliases/genericTypeAliases.ts b/tests/cases/conformance/types/typeAliases/genericTypeAliases.ts
new file mode 100644
index 00000000000..e26279a8a41
--- /dev/null
+++ b/tests/cases/conformance/types/typeAliases/genericTypeAliases.ts
@@ -0,0 +1,73 @@
+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 Tuple<A, B> {
+    a: A;
+    b: B;
+}
+
+type Pair<T> = Tuple<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;