From e60e72ee7312e37cc92b0c9d909b8e6031b9a118 Mon Sep 17 00:00:00 2001
From: Kanchalai Tanglertsampan <yuisu@microsoft.com>
Date: Fri, 16 Sep 2016 09:25:56 -0700
Subject: [PATCH] Update baselines

---
 .../controlFlowBinaryOrExpression.types       | 12 ++---
 .../declarationEmitInferedTypeAlias1.js       | 30 ++++++++++++
 .../declarationEmitInferedTypeAlias1.symbols  | 19 ++++++++
 .../declarationEmitInferedTypeAlias1.types    | 23 ++++++++++
 .../declarationEmitInferedTypeAlias2.js       | 38 +++++++++++++++
 .../declarationEmitInferedTypeAlias2.symbols  | 26 +++++++++++
 .../declarationEmitInferedTypeAlias2.types    | 30 ++++++++++++
 .../declarationEmitInferedTypeAlias3.js       | 31 +++++++++++++
 .../declarationEmitInferedTypeAlias3.symbols  | 19 ++++++++
 .../declarationEmitInferedTypeAlias3.types    | 23 ++++++++++
 .../declarationEmitInferedTypeAlias4.js       | 19 ++++++++
 .../declarationEmitInferedTypeAlias4.symbols  | 22 +++++++++
 .../declarationEmitInferedTypeAlias4.types    | 22 +++++++++
 .../declarationEmitInferedTypeAlias5.js       | 29 ++++++++++++
 .../declarationEmitInferedTypeAlias5.symbols  | 20 ++++++++
 .../declarationEmitInferedTypeAlias5.types    | 24 ++++++++++
 .../declarationEmitInferedTypeAlias6.js       | 30 ++++++++++++
 .../declarationEmitInferedTypeAlias6.symbols  | 19 ++++++++
 .../declarationEmitInferedTypeAlias6.types    | 23 ++++++++++
 .../declarationEmitInferedTypeAlias7.js       | 25 ++++++++++
 .../declarationEmitInferedTypeAlias7.symbols  | 16 +++++++
 .../declarationEmitInferedTypeAlias7.types    | 20 ++++++++
 .../declarationEmitInferedTypeAlias8.js       | 22 +++++++++
 .../declarationEmitInferedTypeAlias8.symbols  | 20 ++++++++
 .../declarationEmitInferedTypeAlias8.types    | 20 ++++++++
 .../declarationEmitInferedTypeAlias9.js       | 22 +++++++++
 .../declarationEmitInferedTypeAlias9.symbols  | 20 ++++++++
 .../declarationEmitInferedTypeAlias9.types    | 20 ++++++++
 .../reference/genericTypeAliases.types        | 46 +++++++++----------
 ...unusedLocalsAndParametersTypeAliases.types | 32 ++++++-------
 30 files changed, 677 insertions(+), 45 deletions(-)
 create mode 100644 tests/baselines/reference/declarationEmitInferedTypeAlias1.js
 create mode 100644 tests/baselines/reference/declarationEmitInferedTypeAlias1.symbols
 create mode 100644 tests/baselines/reference/declarationEmitInferedTypeAlias1.types
 create mode 100644 tests/baselines/reference/declarationEmitInferedTypeAlias2.js
 create mode 100644 tests/baselines/reference/declarationEmitInferedTypeAlias2.symbols
 create mode 100644 tests/baselines/reference/declarationEmitInferedTypeAlias2.types
 create mode 100644 tests/baselines/reference/declarationEmitInferedTypeAlias3.js
 create mode 100644 tests/baselines/reference/declarationEmitInferedTypeAlias3.symbols
 create mode 100644 tests/baselines/reference/declarationEmitInferedTypeAlias3.types
 create mode 100644 tests/baselines/reference/declarationEmitInferedTypeAlias4.js
 create mode 100644 tests/baselines/reference/declarationEmitInferedTypeAlias4.symbols
 create mode 100644 tests/baselines/reference/declarationEmitInferedTypeAlias4.types
 create mode 100644 tests/baselines/reference/declarationEmitInferedTypeAlias5.js
 create mode 100644 tests/baselines/reference/declarationEmitInferedTypeAlias5.symbols
 create mode 100644 tests/baselines/reference/declarationEmitInferedTypeAlias5.types
 create mode 100644 tests/baselines/reference/declarationEmitInferedTypeAlias6.js
 create mode 100644 tests/baselines/reference/declarationEmitInferedTypeAlias6.symbols
 create mode 100644 tests/baselines/reference/declarationEmitInferedTypeAlias6.types
 create mode 100644 tests/baselines/reference/declarationEmitInferedTypeAlias7.js
 create mode 100644 tests/baselines/reference/declarationEmitInferedTypeAlias7.symbols
 create mode 100644 tests/baselines/reference/declarationEmitInferedTypeAlias7.types
 create mode 100644 tests/baselines/reference/declarationEmitInferedTypeAlias8.js
 create mode 100644 tests/baselines/reference/declarationEmitInferedTypeAlias8.symbols
 create mode 100644 tests/baselines/reference/declarationEmitInferedTypeAlias8.types
 create mode 100644 tests/baselines/reference/declarationEmitInferedTypeAlias9.js
 create mode 100644 tests/baselines/reference/declarationEmitInferedTypeAlias9.symbols
 create mode 100644 tests/baselines/reference/declarationEmitInferedTypeAlias9.types

diff --git a/tests/baselines/reference/controlFlowBinaryOrExpression.types b/tests/baselines/reference/controlFlowBinaryOrExpression.types
index 166718b9266..3634a322396 100644
--- a/tests/baselines/reference/controlFlowBinaryOrExpression.types
+++ b/tests/baselines/reference/controlFlowBinaryOrExpression.types
@@ -62,21 +62,21 @@ declare function isHTMLCollection(sourceObj: any): sourceObj is HTMLCollection;
 >HTMLCollection : HTMLCollection
 
 type EventTargetLike = {a: string} | HTMLCollection | NodeList;
->EventTargetLike : EventTargetLike
+>EventTargetLike : NodeList | HTMLCollection | { a: string; }
 >a : string
 >HTMLCollection : HTMLCollection
 >NodeList : NodeList
 
 var sourceObj: EventTargetLike = <any>undefined;
->sourceObj : EventTargetLike
->EventTargetLike : EventTargetLike
+>sourceObj : NodeList | HTMLCollection | { a: string; }
+>EventTargetLike : NodeList | HTMLCollection | { a: string; }
 ><any>undefined : any
 >undefined : undefined
 
 if (isNodeList(sourceObj)) {
 >isNodeList(sourceObj) : boolean
 >isNodeList : (sourceObj: any) => sourceObj is NodeList
->sourceObj : EventTargetLike
+>sourceObj : NodeList | HTMLCollection | { a: string; }
 
     sourceObj.length;
 >sourceObj.length : number
@@ -87,7 +87,7 @@ if (isNodeList(sourceObj)) {
 if (isHTMLCollection(sourceObj)) {
 >isHTMLCollection(sourceObj) : boolean
 >isHTMLCollection : (sourceObj: any) => sourceObj is HTMLCollection
->sourceObj : EventTargetLike
+>sourceObj : NodeList | HTMLCollection | { a: string; }
 
     sourceObj.length;
 >sourceObj.length : number
@@ -99,7 +99,7 @@ if (isNodeList(sourceObj) || isHTMLCollection(sourceObj)) {
 >isNodeList(sourceObj) || isHTMLCollection(sourceObj) : boolean
 >isNodeList(sourceObj) : boolean
 >isNodeList : (sourceObj: any) => sourceObj is NodeList
->sourceObj : EventTargetLike
+>sourceObj : NodeList | HTMLCollection | { a: string; }
 >isHTMLCollection(sourceObj) : boolean
 >isHTMLCollection : (sourceObj: any) => sourceObj is HTMLCollection
 >sourceObj : HTMLCollection | { a: string; }
diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias1.js b/tests/baselines/reference/declarationEmitInferedTypeAlias1.js
new file mode 100644
index 00000000000..05ce74e3bad
--- /dev/null
+++ b/tests/baselines/reference/declarationEmitInferedTypeAlias1.js
@@ -0,0 +1,30 @@
+//// [tests/cases/compiler/declarationEmitInferedTypeAlias1.ts] ////
+
+//// [0.ts]
+
+{
+    type Data = string | boolean;
+    let obj: Data = true;
+}
+export { }
+
+//// [1.ts]
+let v = "str" || true;
+export { v }
+
+//// [0.js]
+"use strict";
+{
+    var obj = true;
+}
+//// [1.js]
+"use strict";
+var v = "str" || true;
+exports.v = v;
+
+
+//// [0.d.ts]
+export {  };
+//// [1.d.ts]
+declare let v: string | boolean;
+export { v };
diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias1.symbols b/tests/baselines/reference/declarationEmitInferedTypeAlias1.symbols
new file mode 100644
index 00000000000..94599418c5d
--- /dev/null
+++ b/tests/baselines/reference/declarationEmitInferedTypeAlias1.symbols
@@ -0,0 +1,19 @@
+=== tests/cases/compiler/0.ts ===
+
+{
+    type Data = string | boolean;
+>Data : Symbol(Data, Decl(0.ts, 1, 1))
+
+    let obj: Data = true;
+>obj : Symbol(obj, Decl(0.ts, 3, 7))
+>Data : Symbol(Data, Decl(0.ts, 1, 1))
+}
+export { }
+
+=== tests/cases/compiler/1.ts ===
+let v = "str" || true;
+>v : Symbol(v, Decl(1.ts, 0, 3))
+
+export { v }
+>v : Symbol(v, Decl(1.ts, 1, 8))
+
diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias1.types b/tests/baselines/reference/declarationEmitInferedTypeAlias1.types
new file mode 100644
index 00000000000..922eb9ccf44
--- /dev/null
+++ b/tests/baselines/reference/declarationEmitInferedTypeAlias1.types
@@ -0,0 +1,23 @@
+=== tests/cases/compiler/0.ts ===
+
+{
+    type Data = string | boolean;
+>Data : string | boolean
+
+    let obj: Data = true;
+>obj : string | boolean
+>Data : string | boolean
+>true : true
+}
+export { }
+
+=== tests/cases/compiler/1.ts ===
+let v = "str" || true;
+>v : string | boolean
+>"str" || true : true | "str"
+>"str" : "str"
+>true : true
+
+export { v }
+>v : string | boolean
+
diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias2.js b/tests/baselines/reference/declarationEmitInferedTypeAlias2.js
new file mode 100644
index 00000000000..307a9b82d67
--- /dev/null
+++ b/tests/baselines/reference/declarationEmitInferedTypeAlias2.js
@@ -0,0 +1,38 @@
+//// [tests/cases/compiler/declarationEmitInferedTypeAlias2.ts] ////
+
+//// [0.ts]
+
+{
+    type Data = string | boolean;
+    let obj: Data = true;
+}
+export { }
+
+//// [1.ts]
+let v = "str" || true;
+function bar () {
+    return v;
+}
+export { v, bar }
+
+//// [0.js]
+"use strict";
+{
+    var obj = true;
+}
+//// [1.js]
+"use strict";
+var v = "str" || true;
+exports.v = v;
+function bar() {
+    return v;
+}
+exports.bar = bar;
+
+
+//// [0.d.ts]
+export {  };
+//// [1.d.ts]
+declare let v: string | boolean;
+declare function bar(): string | boolean;
+export { v, bar };
diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias2.symbols b/tests/baselines/reference/declarationEmitInferedTypeAlias2.symbols
new file mode 100644
index 00000000000..c8027397869
--- /dev/null
+++ b/tests/baselines/reference/declarationEmitInferedTypeAlias2.symbols
@@ -0,0 +1,26 @@
+=== tests/cases/compiler/0.ts ===
+
+{
+    type Data = string | boolean;
+>Data : Symbol(Data, Decl(0.ts, 1, 1))
+
+    let obj: Data = true;
+>obj : Symbol(obj, Decl(0.ts, 3, 7))
+>Data : Symbol(Data, Decl(0.ts, 1, 1))
+}
+export { }
+
+=== tests/cases/compiler/1.ts ===
+let v = "str" || true;
+>v : Symbol(v, Decl(1.ts, 0, 3))
+
+function bar () {
+>bar : Symbol(bar, Decl(1.ts, 0, 22))
+
+    return v;
+>v : Symbol(v, Decl(1.ts, 0, 3))
+}
+export { v, bar }
+>v : Symbol(v, Decl(1.ts, 4, 8))
+>bar : Symbol(bar, Decl(1.ts, 4, 11))
+
diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias2.types b/tests/baselines/reference/declarationEmitInferedTypeAlias2.types
new file mode 100644
index 00000000000..6a9ace4eb86
--- /dev/null
+++ b/tests/baselines/reference/declarationEmitInferedTypeAlias2.types
@@ -0,0 +1,30 @@
+=== tests/cases/compiler/0.ts ===
+
+{
+    type Data = string | boolean;
+>Data : string | boolean
+
+    let obj: Data = true;
+>obj : string | boolean
+>Data : string | boolean
+>true : true
+}
+export { }
+
+=== tests/cases/compiler/1.ts ===
+let v = "str" || true;
+>v : string | boolean
+>"str" || true : true | "str"
+>"str" : "str"
+>true : true
+
+function bar () {
+>bar : () => string | boolean
+
+    return v;
+>v : string | boolean
+}
+export { v, bar }
+>v : string | boolean
+>bar : () => string | boolean
+
diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias3.js b/tests/baselines/reference/declarationEmitInferedTypeAlias3.js
new file mode 100644
index 00000000000..c99e5c429dd
--- /dev/null
+++ b/tests/baselines/reference/declarationEmitInferedTypeAlias3.js
@@ -0,0 +1,31 @@
+//// [tests/cases/compiler/declarationEmitInferedTypeAlias3.ts] ////
+
+//// [0.ts]
+
+{
+    type Data = string | boolean;
+    let obj: Data = true;
+}
+export { }
+
+//// [1.ts]
+var x = "hi" || 5;
+export default x;
+
+//// [0.js]
+"use strict";
+{
+    var obj = true;
+}
+//// [1.js]
+"use strict";
+var x = "hi" || 5;
+exports.__esModule = true;
+exports["default"] = x;
+
+
+//// [0.d.ts]
+export {  };
+//// [1.d.ts]
+declare var x: string | number;
+export default x;
diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias3.symbols b/tests/baselines/reference/declarationEmitInferedTypeAlias3.symbols
new file mode 100644
index 00000000000..8a9f7b35d18
--- /dev/null
+++ b/tests/baselines/reference/declarationEmitInferedTypeAlias3.symbols
@@ -0,0 +1,19 @@
+=== tests/cases/compiler/0.ts ===
+
+{
+    type Data = string | boolean;
+>Data : Symbol(Data, Decl(0.ts, 1, 1))
+
+    let obj: Data = true;
+>obj : Symbol(obj, Decl(0.ts, 3, 7))
+>Data : Symbol(Data, Decl(0.ts, 1, 1))
+}
+export { }
+
+=== tests/cases/compiler/1.ts ===
+var x = "hi" || 5;
+>x : Symbol(x, Decl(1.ts, 0, 3))
+
+export default x;
+>x : Symbol(x, Decl(1.ts, 0, 3))
+
diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias3.types b/tests/baselines/reference/declarationEmitInferedTypeAlias3.types
new file mode 100644
index 00000000000..565a484a094
--- /dev/null
+++ b/tests/baselines/reference/declarationEmitInferedTypeAlias3.types
@@ -0,0 +1,23 @@
+=== tests/cases/compiler/0.ts ===
+
+{
+    type Data = string | boolean;
+>Data : string | boolean
+
+    let obj: Data = true;
+>obj : string | boolean
+>Data : string | boolean
+>true : true
+}
+export { }
+
+=== tests/cases/compiler/1.ts ===
+var x = "hi" || 5;
+>x : string | number
+>"hi" || 5 : "hi" | 5
+>"hi" : "hi"
+>5 : 5
+
+export default x;
+>x : string | number
+
diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias4.js b/tests/baselines/reference/declarationEmitInferedTypeAlias4.js
new file mode 100644
index 00000000000..8d7ef72012c
--- /dev/null
+++ b/tests/baselines/reference/declarationEmitInferedTypeAlias4.js
@@ -0,0 +1,19 @@
+//// [declarationEmitInferedTypeAlias4.ts]
+
+function f<A>() {
+    type Foo<T> = T | { x: Foo<T> };
+    var x: Foo<A[]>;
+    return x;
+}
+
+//// [declarationEmitInferedTypeAlias4.js]
+function f() {
+    var x;
+    return x;
+}
+
+
+//// [declarationEmitInferedTypeAlias4.d.ts]
+declare function f<A>(): A[] | {
+    x: A[] | any;
+};
diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias4.symbols b/tests/baselines/reference/declarationEmitInferedTypeAlias4.symbols
new file mode 100644
index 00000000000..f522eca7d0b
--- /dev/null
+++ b/tests/baselines/reference/declarationEmitInferedTypeAlias4.symbols
@@ -0,0 +1,22 @@
+=== tests/cases/compiler/declarationEmitInferedTypeAlias4.ts ===
+
+function f<A>() {
+>f : Symbol(f, Decl(declarationEmitInferedTypeAlias4.ts, 0, 0))
+>A : Symbol(A, Decl(declarationEmitInferedTypeAlias4.ts, 1, 11))
+
+    type Foo<T> = T | { x: Foo<T> };
+>Foo : Symbol(Foo, Decl(declarationEmitInferedTypeAlias4.ts, 1, 17))
+>T : Symbol(T, Decl(declarationEmitInferedTypeAlias4.ts, 2, 13))
+>T : Symbol(T, Decl(declarationEmitInferedTypeAlias4.ts, 2, 13))
+>x : Symbol(x, Decl(declarationEmitInferedTypeAlias4.ts, 2, 23))
+>Foo : Symbol(Foo, Decl(declarationEmitInferedTypeAlias4.ts, 1, 17))
+>T : Symbol(T, Decl(declarationEmitInferedTypeAlias4.ts, 2, 13))
+
+    var x: Foo<A[]>;
+>x : Symbol(x, Decl(declarationEmitInferedTypeAlias4.ts, 3, 7))
+>Foo : Symbol(Foo, Decl(declarationEmitInferedTypeAlias4.ts, 1, 17))
+>A : Symbol(A, Decl(declarationEmitInferedTypeAlias4.ts, 1, 11))
+
+    return x;
+>x : Symbol(x, Decl(declarationEmitInferedTypeAlias4.ts, 3, 7))
+}
diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias4.types b/tests/baselines/reference/declarationEmitInferedTypeAlias4.types
new file mode 100644
index 00000000000..f4cc0789f45
--- /dev/null
+++ b/tests/baselines/reference/declarationEmitInferedTypeAlias4.types
@@ -0,0 +1,22 @@
+=== tests/cases/compiler/declarationEmitInferedTypeAlias4.ts ===
+
+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; }
+}
diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias5.js b/tests/baselines/reference/declarationEmitInferedTypeAlias5.js
new file mode 100644
index 00000000000..79d28d3d181
--- /dev/null
+++ b/tests/baselines/reference/declarationEmitInferedTypeAlias5.js
@@ -0,0 +1,29 @@
+//// [tests/cases/compiler/declarationEmitInferedTypeAlias5.ts] ////
+
+//// [0.ts]
+
+export type Data = string | boolean;
+let obj: Data = true;
+
+//// [1.ts]
+import * as Z from "./0"
+//let v2: Z.Data;
+let v = "str" || true;
+export { v }
+
+//// [0.js]
+"use strict";
+var obj = true;
+//// [1.js]
+"use strict";
+//let v2: Z.Data;
+var v = "str" || true;
+exports.v = v;
+
+
+//// [0.d.ts]
+export declare type Data = string | boolean;
+//// [1.d.ts]
+import * as Z from "./0";
+declare let v: Z.Data;
+export { v };
diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias5.symbols b/tests/baselines/reference/declarationEmitInferedTypeAlias5.symbols
new file mode 100644
index 00000000000..6c06697cfdc
--- /dev/null
+++ b/tests/baselines/reference/declarationEmitInferedTypeAlias5.symbols
@@ -0,0 +1,20 @@
+=== tests/cases/compiler/0.ts ===
+
+export type Data = string | boolean;
+>Data : Symbol(Data, Decl(0.ts, 0, 0))
+
+let obj: Data = true;
+>obj : Symbol(obj, Decl(0.ts, 2, 3))
+>Data : Symbol(Data, Decl(0.ts, 0, 0))
+
+=== tests/cases/compiler/1.ts ===
+import * as Z from "./0"
+>Z : Symbol(Z, Decl(1.ts, 0, 6))
+
+//let v2: Z.Data;
+let v = "str" || true;
+>v : Symbol(v, Decl(1.ts, 2, 3))
+
+export { v }
+>v : Symbol(v, Decl(1.ts, 3, 8))
+
diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias5.types b/tests/baselines/reference/declarationEmitInferedTypeAlias5.types
new file mode 100644
index 00000000000..21e6b415d2e
--- /dev/null
+++ b/tests/baselines/reference/declarationEmitInferedTypeAlias5.types
@@ -0,0 +1,24 @@
+=== tests/cases/compiler/0.ts ===
+
+export type Data = string | boolean;
+>Data : Data
+
+let obj: Data = true;
+>obj : Data
+>Data : Data
+>true : true
+
+=== tests/cases/compiler/1.ts ===
+import * as Z from "./0"
+>Z : typeof Z
+
+//let v2: Z.Data;
+let v = "str" || true;
+>v : Z.Data
+>"str" || true : true | "str"
+>"str" : "str"
+>true : true
+
+export { v }
+>v : Z.Data
+
diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias6.js b/tests/baselines/reference/declarationEmitInferedTypeAlias6.js
new file mode 100644
index 00000000000..924f73d0ed9
--- /dev/null
+++ b/tests/baselines/reference/declarationEmitInferedTypeAlias6.js
@@ -0,0 +1,30 @@
+//// [tests/cases/compiler/declarationEmitInferedTypeAlias6.ts] ////
+
+//// [0.ts]
+
+{
+    type Data = string | boolean;
+    let obj: Data = true;
+}
+export { }
+
+//// [1.ts]
+let v = "str" || true;
+export { v }
+
+//// [0.js]
+"use strict";
+{
+    var obj = true;
+}
+//// [1.js]
+"use strict";
+var v = "str" || true;
+exports.v = v;
+
+
+//// [0.d.ts]
+export {  };
+//// [1.d.ts]
+declare let v: string | boolean;
+export { v };
diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias6.symbols b/tests/baselines/reference/declarationEmitInferedTypeAlias6.symbols
new file mode 100644
index 00000000000..94599418c5d
--- /dev/null
+++ b/tests/baselines/reference/declarationEmitInferedTypeAlias6.symbols
@@ -0,0 +1,19 @@
+=== tests/cases/compiler/0.ts ===
+
+{
+    type Data = string | boolean;
+>Data : Symbol(Data, Decl(0.ts, 1, 1))
+
+    let obj: Data = true;
+>obj : Symbol(obj, Decl(0.ts, 3, 7))
+>Data : Symbol(Data, Decl(0.ts, 1, 1))
+}
+export { }
+
+=== tests/cases/compiler/1.ts ===
+let v = "str" || true;
+>v : Symbol(v, Decl(1.ts, 0, 3))
+
+export { v }
+>v : Symbol(v, Decl(1.ts, 1, 8))
+
diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias6.types b/tests/baselines/reference/declarationEmitInferedTypeAlias6.types
new file mode 100644
index 00000000000..922eb9ccf44
--- /dev/null
+++ b/tests/baselines/reference/declarationEmitInferedTypeAlias6.types
@@ -0,0 +1,23 @@
+=== tests/cases/compiler/0.ts ===
+
+{
+    type Data = string | boolean;
+>Data : string | boolean
+
+    let obj: Data = true;
+>obj : string | boolean
+>Data : string | boolean
+>true : true
+}
+export { }
+
+=== tests/cases/compiler/1.ts ===
+let v = "str" || true;
+>v : string | boolean
+>"str" || true : true | "str"
+>"str" : "str"
+>true : true
+
+export { v }
+>v : string | boolean
+
diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias7.js b/tests/baselines/reference/declarationEmitInferedTypeAlias7.js
new file mode 100644
index 00000000000..2fba057fc91
--- /dev/null
+++ b/tests/baselines/reference/declarationEmitInferedTypeAlias7.js
@@ -0,0 +1,25 @@
+//// [tests/cases/compiler/declarationEmitInferedTypeAlias7.ts] ////
+
+//// [0.ts]
+
+export type Data = string | boolean;
+let obj: Data = true;
+
+//// [1.ts]
+let v = "str" || true;
+export { v }
+
+//// [0.js]
+"use strict";
+var obj = true;
+//// [1.js]
+"use strict";
+var v = "str" || true;
+exports.v = v;
+
+
+//// [0.d.ts]
+export declare type Data = string | boolean;
+//// [1.d.ts]
+declare let v: string | boolean;
+export { v };
diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias7.symbols b/tests/baselines/reference/declarationEmitInferedTypeAlias7.symbols
new file mode 100644
index 00000000000..8923fd72692
--- /dev/null
+++ b/tests/baselines/reference/declarationEmitInferedTypeAlias7.symbols
@@ -0,0 +1,16 @@
+=== tests/cases/compiler/0.ts ===
+
+export type Data = string | boolean;
+>Data : Symbol(Data, Decl(0.ts, 0, 0))
+
+let obj: Data = true;
+>obj : Symbol(obj, Decl(0.ts, 2, 3))
+>Data : Symbol(Data, Decl(0.ts, 0, 0))
+
+=== tests/cases/compiler/1.ts ===
+let v = "str" || true;
+>v : Symbol(v, Decl(1.ts, 0, 3))
+
+export { v }
+>v : Symbol(v, Decl(1.ts, 1, 8))
+
diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias7.types b/tests/baselines/reference/declarationEmitInferedTypeAlias7.types
new file mode 100644
index 00000000000..f4bcaaf5105
--- /dev/null
+++ b/tests/baselines/reference/declarationEmitInferedTypeAlias7.types
@@ -0,0 +1,20 @@
+=== tests/cases/compiler/0.ts ===
+
+export type Data = string | boolean;
+>Data : Data
+
+let obj: Data = true;
+>obj : Data
+>Data : Data
+>true : true
+
+=== tests/cases/compiler/1.ts ===
+let v = "str" || true;
+>v : string | boolean
+>"str" || true : true | "str"
+>"str" : "str"
+>true : true
+
+export { v }
+>v : string | boolean
+
diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias8.js b/tests/baselines/reference/declarationEmitInferedTypeAlias8.js
new file mode 100644
index 00000000000..54a8ba37af1
--- /dev/null
+++ b/tests/baselines/reference/declarationEmitInferedTypeAlias8.js
@@ -0,0 +1,22 @@
+//// [declarationEmitInferedTypeAlias8.ts]
+
+type Foo<T> = T | { x: Foo<T> };
+var x: Foo<number[]>;
+
+function returnSomeGlobalValue() {
+    return x;
+}
+
+//// [declarationEmitInferedTypeAlias8.js]
+var x;
+function returnSomeGlobalValue() {
+    return x;
+}
+
+
+//// [declarationEmitInferedTypeAlias8.d.ts]
+declare type Foo<T> = T | {
+    x: Foo<T>;
+};
+declare var x: Foo<number[]>;
+declare function returnSomeGlobalValue(): Foo<number[]>;
diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias8.symbols b/tests/baselines/reference/declarationEmitInferedTypeAlias8.symbols
new file mode 100644
index 00000000000..9a0c0974e79
--- /dev/null
+++ b/tests/baselines/reference/declarationEmitInferedTypeAlias8.symbols
@@ -0,0 +1,20 @@
+=== tests/cases/compiler/declarationEmitInferedTypeAlias8.ts ===
+
+type Foo<T> = T | { x: Foo<T> };
+>Foo : Symbol(Foo, Decl(declarationEmitInferedTypeAlias8.ts, 0, 0))
+>T : Symbol(T, Decl(declarationEmitInferedTypeAlias8.ts, 1, 9))
+>T : Symbol(T, Decl(declarationEmitInferedTypeAlias8.ts, 1, 9))
+>x : Symbol(x, Decl(declarationEmitInferedTypeAlias8.ts, 1, 19))
+>Foo : Symbol(Foo, Decl(declarationEmitInferedTypeAlias8.ts, 0, 0))
+>T : Symbol(T, Decl(declarationEmitInferedTypeAlias8.ts, 1, 9))
+
+var x: Foo<number[]>;
+>x : Symbol(x, Decl(declarationEmitInferedTypeAlias8.ts, 2, 3))
+>Foo : Symbol(Foo, Decl(declarationEmitInferedTypeAlias8.ts, 0, 0))
+
+function returnSomeGlobalValue() {
+>returnSomeGlobalValue : Symbol(returnSomeGlobalValue, Decl(declarationEmitInferedTypeAlias8.ts, 2, 21))
+
+    return x;
+>x : Symbol(x, Decl(declarationEmitInferedTypeAlias8.ts, 2, 3))
+}
diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias8.types b/tests/baselines/reference/declarationEmitInferedTypeAlias8.types
new file mode 100644
index 00000000000..9fc0aaf7016
--- /dev/null
+++ b/tests/baselines/reference/declarationEmitInferedTypeAlias8.types
@@ -0,0 +1,20 @@
+=== tests/cases/compiler/declarationEmitInferedTypeAlias8.ts ===
+
+type Foo<T> = T | { x: Foo<T> };
+>Foo : Foo<T>
+>T : T
+>T : T
+>x : Foo<T>
+>Foo : Foo<T>
+>T : T
+
+var x: Foo<number[]>;
+>x : Foo<number[]>
+>Foo : Foo<T>
+
+function returnSomeGlobalValue() {
+>returnSomeGlobalValue : () => Foo<number[]>
+
+    return x;
+>x : Foo<number[]>
+}
diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias9.js b/tests/baselines/reference/declarationEmitInferedTypeAlias9.js
new file mode 100644
index 00000000000..667acdff49c
--- /dev/null
+++ b/tests/baselines/reference/declarationEmitInferedTypeAlias9.js
@@ -0,0 +1,22 @@
+//// [declarationEmitInferedTypeAlias9.ts]
+
+type Foo<T> = T | { x: Foo<T> };
+var x: Foo<number[]>;
+
+export function returnSomeGlobalValue() {
+    return x;
+}
+
+//// [declarationEmitInferedTypeAlias9.js]
+"use strict";
+var x;
+function returnSomeGlobalValue() {
+    return x;
+}
+exports.returnSomeGlobalValue = returnSomeGlobalValue;
+
+
+//// [declarationEmitInferedTypeAlias9.d.ts]
+export declare function returnSomeGlobalValue(): number[] | {
+    x: number[] | any;
+};
diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias9.symbols b/tests/baselines/reference/declarationEmitInferedTypeAlias9.symbols
new file mode 100644
index 00000000000..5057ef22c0b
--- /dev/null
+++ b/tests/baselines/reference/declarationEmitInferedTypeAlias9.symbols
@@ -0,0 +1,20 @@
+=== tests/cases/compiler/declarationEmitInferedTypeAlias9.ts ===
+
+type Foo<T> = T | { x: Foo<T> };
+>Foo : Symbol(Foo, Decl(declarationEmitInferedTypeAlias9.ts, 0, 0))
+>T : Symbol(T, Decl(declarationEmitInferedTypeAlias9.ts, 1, 9))
+>T : Symbol(T, Decl(declarationEmitInferedTypeAlias9.ts, 1, 9))
+>x : Symbol(x, Decl(declarationEmitInferedTypeAlias9.ts, 1, 19))
+>Foo : Symbol(Foo, Decl(declarationEmitInferedTypeAlias9.ts, 0, 0))
+>T : Symbol(T, Decl(declarationEmitInferedTypeAlias9.ts, 1, 9))
+
+var x: Foo<number[]>;
+>x : Symbol(x, Decl(declarationEmitInferedTypeAlias9.ts, 2, 3))
+>Foo : Symbol(Foo, Decl(declarationEmitInferedTypeAlias9.ts, 0, 0))
+
+export function returnSomeGlobalValue() {
+>returnSomeGlobalValue : Symbol(returnSomeGlobalValue, Decl(declarationEmitInferedTypeAlias9.ts, 2, 21))
+
+    return x;
+>x : Symbol(x, Decl(declarationEmitInferedTypeAlias9.ts, 2, 3))
+}
diff --git a/tests/baselines/reference/declarationEmitInferedTypeAlias9.types b/tests/baselines/reference/declarationEmitInferedTypeAlias9.types
new file mode 100644
index 00000000000..d4f61bf927a
--- /dev/null
+++ b/tests/baselines/reference/declarationEmitInferedTypeAlias9.types
@@ -0,0 +1,20 @@
+=== tests/cases/compiler/declarationEmitInferedTypeAlias9.ts ===
+
+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<number[]>;
+>x : number[] | { x: number[] | any; }
+>Foo : T | { x: T | any; }
+
+export function returnSomeGlobalValue() {
+>returnSomeGlobalValue : () => number[] | { x: number[] | any; }
+
+    return x;
+>x : number[] | { x: number[] | any; }
+}
diff --git a/tests/baselines/reference/genericTypeAliases.types b/tests/baselines/reference/genericTypeAliases.types
index 1cabaa8caa0..b4c75841245 100644
--- a/tests/baselines/reference/genericTypeAliases.types
+++ b/tests/baselines/reference/genericTypeAliases.types
@@ -215,60 +215,60 @@ p.tag = "test";
 >"test" : "test"
 
 function f<A>() {
->f : <A>() => Foo<A[]>
+>f : <A>() => A[] | { x: A[] | any; }
 >A : A
 
     type Foo<T> = T | { x: Foo<T> };
->Foo : Foo<T>
+>Foo : T | { x: T | any; }
 >T : T
 >T : T
->x : Foo<T>
->Foo : Foo<T>
+>x : T | { x: T | any; }
+>Foo : T | { x: T | any; }
 >T : T
 
     var x: Foo<A[]>;
->x : Foo<A[]>
->Foo : Foo<T>
+>x : A[] | { x: A[] | any; }
+>Foo : T | { x: T | any; }
 >A : A
 
     return x;
->x : Foo<A[]>
+>x : A[] | { x: A[] | any; }
 }
 
 function g<B>() {
->g : <B>() => Bar<B[]>
+>g : <B>() => B[] | { x: B[] | any; }
 >B : B
 
     type Bar<U> = U | { x: Bar<U> };
->Bar : Bar<U>
+>Bar : U | { x: U | any; }
 >U : U
 >U : U
->x : Bar<U>
->Bar : Bar<U>
+>x : U | { x: U | any; }
+>Bar : U | { x: U | any; }
 >U : U
 
     var x: Bar<B[]>;
->x : Bar<B[]>
->Bar : Bar<U>
+>x : B[] | { x: B[] | any; }
+>Bar : U | { x: U | any; }
 >B : B
 
     return x;
->x : Bar<B[]>
+>x : B[] | { x: B[] | any; }
 }
 
 // Deeply instantiated generics
 var a = f<string>();
->a : Foo<string>
->f<string>() : Foo<string>
->f : <A>() => Foo<A[]>
+>a : string[] | { x: string[] | any; }
+>f<string>() : string[] | { x: string[] | any; }
+>f : <A>() => A[] | { x: A[] | any; }
 
 var b = g<string>();
->b : Bar<string>
->g<string>() : Bar<string>
->g : <B>() => Bar<B[]>
+>b : string[] | { x: string[] | any; }
+>g<string>() : string[] | { x: string[] | any; }
+>g : <B>() => B[] | { x: B[] | any; }
 
 a = b;
->a = b : Bar<string>
->a : Foo<string>
->b : Bar<string>
+>a = b : string[] | { x: string[] | any; }
+>a : string[] | { x: string[] | any; }
+>b : string[] | { x: string[] | any; }
 
diff --git a/tests/baselines/reference/unusedLocalsAndParametersTypeAliases.types b/tests/baselines/reference/unusedLocalsAndParametersTypeAliases.types
index 6090d300056..e927b011e53 100644
--- a/tests/baselines/reference/unusedLocalsAndParametersTypeAliases.types
+++ b/tests/baselines/reference/unusedLocalsAndParametersTypeAliases.types
@@ -2,14 +2,14 @@
 
 // used in a declaration
 type handler1 = () => void;
->handler1 : handler1
+>handler1 : () => void
 
 export interface I1 {
 >I1 : I1
 
     getHandler: handler1;
->getHandler : handler1
->handler1 : handler1
+>getHandler : () => void
+>handler1 : () => void
 }
 
 // exported
@@ -18,12 +18,12 @@ export type handler2 = () => void;
 
 // used in extends clause
 type handler3 = () => void;
->handler3 : handler3
+>handler3 : () => void
 
 export interface I3<T extends handler3> {
 >I3 : I3<T>
 >T : T
->handler3 : handler3
+>handler3 : () => void
 
     getHandler: T;
 >getHandler : T
@@ -32,32 +32,32 @@ export interface I3<T extends handler3> {
 
 // used in another type alias declaration
 type handler4 = () => void;
->handler4 : handler4
+>handler4 : () => void
 
 type handler5 = handler4 | (()=>number);
->handler5 : handler5
->handler4 : handler4
+>handler5 : (() => void) | (() => number)
+>handler4 : () => void
 
 var x: handler5;
->x : handler5
->handler5 : handler5
+>x : (() => void) | (() => number)
+>handler5 : (() => void) | (() => number)
 
 x();
 >x() : number | void
->x : handler5
+>x : (() => void) | (() => number)
 
 // used as type argument
 type handler6 = () => void;
->handler6 : handler6
+>handler6 : () => void
 
 var y: Array<handler6>;
->y : handler6[]
+>y : (() => void)[]
 >Array : T[]
->handler6 : handler6
+>handler6 : () => void
 
 y[0]();
 >y[0]() : void
->y[0] : handler6
->y : handler6[]
+>y[0] : () => void
+>y : (() => void)[]
 >0 : 0