Accept new baselines

tests/baselines/reference/amdImportAsPrimaryExpression.types

@@ -4,11 +4,11 @@ import foo = require("./foo_0");
 
 if(foo.E1.A === 0){
 >foo.E1.A === 0 : boolean
->foo.E1.A : foo.E1
+>foo.E1.A : foo.E1.A
 >foo.E1 : typeof foo.E1
 >foo : typeof foo
 >E1 : typeof foo.E1
->A : foo.E1
+>A : foo.E1.A
 >0 : 0
 
 	// Should cause runtime import - interesting optimization possibility, as gets inlined to 0.

tests/baselines/reference/amdImportNotAsPrimaryExpression.types

@@ -41,7 +41,7 @@ var e: number = <foo.E1>0;
 ><foo.E1>0 : foo.E1
 >foo : any
 >E1 : foo.E1
->0 : number
+>0 : 0
 
 === tests/cases/conformance/externalModules/foo_0.ts ===
 export class C1 {

tests/baselines/reference/assignmentNonObjectTypeConstraints.types

@@ -24,9 +24,9 @@ foo(5);
 foo(E.A);
 >foo(E.A) : void
 >foo : <T extends number>(x: T) => void
->E.A : E
+>E.A : E.A
 >E : typeof E
->A : E
+>A : E.A
 
 class A { a }
 >A : A

tests/baselines/reference/commentsEnums.types

@@ -20,10 +20,10 @@ var x = Colors.Cornflower;
 >Cornflower : Colors
 
 x = Colors.FancyPink;
->x = Colors.FancyPink : Colors
+>x = Colors.FancyPink : Colors.FancyPink
 >x : Colors
->Colors.FancyPink : Colors
+>Colors.FancyPink : Colors.FancyPink
 >Colors : typeof Colors
->FancyPink : Colors
+>FancyPink : Colors.FancyPink
 
 

tests/baselines/reference/commentsdoNotEmitComments.types

@@ -165,7 +165,7 @@ const enum color { red, green, blue }
 var shade: color = color.green;
 >shade : color
 >color : color
->color.green : color
+>color.green : color.green
 >color : typeof color
->green : color
+>green : color.green
 

tests/baselines/reference/commonJSImportNotAsPrimaryExpression.types

@@ -41,7 +41,7 @@ var e: number = <foo.E1>0;
 ><foo.E1>0 : foo.E1
 >foo : any
 >E1 : foo.E1
->0 : number
+>0 : 0
 
 === tests/cases/conformance/externalModules/foo_0.ts ===
 export class C1 {

tests/baselines/reference/comparisonOperatorWithSubtypeEnumAndNumber.types

@@ -208,34 +208,34 @@ var re2 = b == a;
 var re3 = E.a == b;
 >re3 : boolean
 >E.a == b : boolean
->E.a : E
+>E.a : E.a
 >E : typeof E
->a : E
+>a : E.a
 >b : number
 
 var re4 = b == E.a;
 >re4 : boolean
 >b == E.a : boolean
 >b : number
->E.a : E
+>E.a : E.a
 >E : typeof E
->a : E
+>a : E.a
 
 var re5 = E.a == 0;
 >re5 : boolean
 >E.a == 0 : boolean
->E.a : E
+>E.a : E.a
 >E : typeof E
->a : E
+>a : E.a
 >0 : 0
 
 var re6 = 0 == E.a;
 >re6 : boolean
 >0 == E.a : boolean
 >0 : 0
->E.a : E
+>E.a : E.a
 >E : typeof E
->a : E
+>a : E.a
 
 // operator !=
 var rf1 = a != b;
@@ -253,34 +253,34 @@ var rf2 = b != a;
 var rf3 = E.a != b;
 >rf3 : boolean
 >E.a != b : boolean
->E.a : E
+>E.a : E.a
 >E : typeof E
->a : E
+>a : E.a
 >b : number
 
 var rf4 = b != E.a;
 >rf4 : boolean
 >b != E.a : boolean
 >b : number
->E.a : E
+>E.a : E.a
 >E : typeof E
->a : E
+>a : E.a
 
 var rf5 = E.a != 0;
 >rf5 : boolean
 >E.a != 0 : boolean
->E.a : E
+>E.a : E.a
 >E : typeof E
->a : E
+>a : E.a
 >0 : 0
 
 var rf6 = 0 != E.a;
 >rf6 : boolean
 >0 != E.a : boolean
 >0 : 0
->E.a : E
+>E.a : E.a
 >E : typeof E
->a : E
+>a : E.a
 
 // operator ===
 var rg1 = a === b;
@@ -298,34 +298,34 @@ var rg2 = b === a;
 var rg3 = E.a === b;
 >rg3 : boolean
 >E.a === b : boolean
->E.a : E
+>E.a : E.a
 >E : typeof E
->a : E
+>a : E.a
 >b : number
 
 var rg4 = b === E.a;
 >rg4 : boolean
 >b === E.a : boolean
 >b : number
->E.a : E
+>E.a : E.a
 >E : typeof E
->a : E
+>a : E.a
 
 var rg5 = E.a === 0;
 >rg5 : boolean
 >E.a === 0 : boolean
->E.a : E
+>E.a : E.a
 >E : typeof E
->a : E
+>a : E.a
 >0 : 0
 
 var rg6 = 0 === E.a;
 >rg6 : boolean
 >0 === E.a : boolean
 >0 : 0
->E.a : E
+>E.a : E.a
 >E : typeof E
->a : E
+>a : E.a
 
 // operator !==
 var rh1 = a !== b;
@@ -343,32 +343,32 @@ var rh2 = b !== a;
 var rh3 = E.a !== b;
 >rh3 : boolean
 >E.a !== b : boolean
->E.a : E
+>E.a : E.a
 >E : typeof E
->a : E
+>a : E.a
 >b : number
 
 var rh4 = b !== E.a;
 >rh4 : boolean
 >b !== E.a : boolean
 >b : number
->E.a : E
+>E.a : E.a
 >E : typeof E
->a : E
+>a : E.a
 
 var rh5 = E.a !== 0;
 >rh5 : boolean
 >E.a !== 0 : boolean
->E.a : E
+>E.a : E.a
 >E : typeof E
->a : E
+>a : E.a
 >0 : 0
 
 var rh6 = 0 !== E.a;
 >rh6 : boolean
 >0 !== E.a : boolean
 >0 : 0
->E.a : E
+>E.a : E.a
 >E : typeof E
->a : E
+>a : E.a
 

tests/baselines/reference/compoundAdditionAssignmentLHSCanBeAssigned.types

@@ -152,14 +152,14 @@ x4 += a;
 x4 += 0;
 >x4 += 0 : number
 >x4 : E
->0 : number
+>0 : 0
 
 x4 += E.a;
 >x4 += E.a : number
 >x4 : E
->E.a : E
+>E.a : E.a
 >E : typeof E
->a : E
+>a : E.a
 
 x4 += null;
 >x4 += null : number

tests/baselines/reference/constEnums.types

@@ -314,16 +314,16 @@ function foo0(e: I): void {
     if (e === I.V1) {
 >e === I.V1 : boolean
 >e : I
->I.V1 : I.V1
+>I.V1 : I
 >I : typeof I
->V1 : I.V1
+>V1 : I
     }
     else if (e === I.V2) {
 >e === I.V2 : boolean
 >e : I
->I.V2 : I.V2
+>I.V2 : I
 >I : typeof I
->V2 : I.V2
+>V2 : I
     }
 }
 
@@ -347,7 +347,7 @@ function foo1(e: I1.C.E): void {
     }
     else if (e === I1.C.E.V2) {
 >e === I1.C.E.V2 : boolean
->e : I1.C.E
+>e : I1.C.E.V2
 >I1.C.E.V2 : I1.C.E.V2
 >I1.C.E : typeof I1.C.E
 >I1.C : typeof I1.C
@@ -378,7 +378,7 @@ function foo2(e: I2.C.E): void {
     }
     else if (e === I2.C.E.V2) {
 >e === I2.C.E.V2 : boolean
->e : I2.C.E
+>e : I2.C.E.V2
 >I2.C.E.V2 : I2.C.E.V2
 >I2.C.E : typeof I2.C.E
 >I2.C : typeof I2.C
@@ -399,99 +399,99 @@ function foo(x: Enum1) {
 >x : Enum1
 
         case Enum1.A:
->Enum1.A : Enum1.A
+>Enum1.A : Enum1
 >Enum1 : typeof Enum1
->A : Enum1.A
+>A : Enum1
 
         case Enum1.B:
->Enum1.B : Enum1.B
+>Enum1.B : Enum1
 >Enum1 : typeof Enum1
->B : Enum1.B
+>B : Enum1
 
         case Enum1.C:
->Enum1.C : Enum1.C
+>Enum1.C : Enum1
 >Enum1 : typeof Enum1
->C : Enum1.C
+>C : Enum1
 
         case Enum1.D:
->Enum1.D : Enum1.B
+>Enum1.D : Enum1
 >Enum1 : typeof Enum1
->D : Enum1.B
+>D : Enum1
 
         case Enum1.E:
->Enum1.E : Enum1.B
+>Enum1.E : Enum1
 >Enum1 : typeof Enum1
->E : Enum1.B
+>E : Enum1
 
         case Enum1.F:
->Enum1.F : Enum1.B
+>Enum1.F : Enum1
 >Enum1 : typeof Enum1
->F : Enum1.B
+>F : Enum1
 
         case Enum1.G:
->Enum1.G : Enum1.B
+>Enum1.G : Enum1
 >Enum1 : typeof Enum1
->G : Enum1.B
+>G : Enum1
 
         case Enum1.H:
->Enum1.H : Enum1.H
+>Enum1.H : Enum1
 >Enum1 : typeof Enum1
->H : Enum1.H
+>H : Enum1
 
         case Enum1.I:
->Enum1.I : Enum1.A
+>Enum1.I : Enum1
 >Enum1 : typeof Enum1
->I : Enum1.A
+>I : Enum1
 
         case Enum1.J:
->Enum1.J : Enum1.A
+>Enum1.J : Enum1
 >Enum1 : typeof Enum1
->J : Enum1.A
+>J : Enum1
 
         case Enum1.K:
->Enum1.K : Enum1.K
+>Enum1.K : Enum1
 >Enum1 : typeof Enum1
->K : Enum1.K
+>K : Enum1
 
         case Enum1.L:
->Enum1.L : Enum1.H
+>Enum1.L : Enum1
 >Enum1 : typeof Enum1
->L : Enum1.H
+>L : Enum1
 
         case Enum1.M:
->Enum1.M : Enum1.M
+>Enum1.M : Enum1
 >Enum1 : typeof Enum1
->M : Enum1.M
+>M : Enum1
 
         case Enum1.N:
->Enum1.N : Enum1.M
+>Enum1.N : Enum1
 >Enum1 : typeof Enum1
->N : Enum1.M
+>N : Enum1
 
         case Enum1.O:
->Enum1.O : Enum1.A
+>Enum1.O : Enum1
 >Enum1 : typeof Enum1
->O : Enum1.A
+>O : Enum1
 
         case Enum1.P:
->Enum1.P : Enum1.A
+>Enum1.P : Enum1
 >Enum1 : typeof Enum1
->P : Enum1.A
+>P : Enum1
 
         case Enum1.Q:
->Enum1.Q : Enum1.Q
+>Enum1.Q : Enum1
 >Enum1 : typeof Enum1
->Q : Enum1.Q
+>Q : Enum1
 
         case Enum1.R:
->Enum1.R : Enum1.A
+>Enum1.R : Enum1
 >Enum1 : typeof Enum1
->R : Enum1.A
+>R : Enum1
 
         case Enum1.S:
->Enum1.S : Enum1.A
+>Enum1.S : Enum1
 >Enum1 : typeof Enum1
->S : Enum1.A
+>S : Enum1
 
         case Enum1["T"]:
 >Enum1["T"] : Enum1
@@ -499,39 +499,39 @@ function foo(x: Enum1) {
 >"T" : string
 
         case Enum1.U:
->Enum1.U : Enum1.U
+>Enum1.U : Enum1
 >Enum1 : typeof Enum1
->U : Enum1.U
+>U : Enum1
 
         case Enum1.V:
->Enum1.V : Enum1.U
+>Enum1.V : Enum1
 >Enum1 : typeof Enum1
->V : Enum1.U
+>V : Enum1
 
         case Enum1.W:
->Enum1.W : Enum1.U
+>Enum1.W : Enum1
 >Enum1 : typeof Enum1
->W : Enum1.U
+>W : Enum1
 
         case Enum1.W1:
->Enum1.W1 : Enum1.W1
+>Enum1.W1 : Enum1
 >Enum1 : typeof Enum1
->W1 : Enum1.W1
+>W1 : Enum1
 
         case Enum1.W2:
->Enum1.W2 : Enum1.W1
+>Enum1.W2 : Enum1
 >Enum1 : typeof Enum1
->W2 : Enum1.W1
+>W2 : Enum1
 
         case Enum1.W3:
->Enum1.W3 : Enum1.W1
+>Enum1.W3 : Enum1
 >Enum1 : typeof Enum1
->W3 : Enum1.W1
+>W3 : Enum1
 
         case Enum1.W4:
->Enum1.W4 : Enum1.U
+>Enum1.W4 : Enum1
 >Enum1 : typeof Enum1
->W4 : Enum1.U
+>W4 : Enum1
 
             break;
     }
@@ -549,7 +549,7 @@ function bar(e: A.B.C.E): number {
 >e : I
 
         case A.B.C.E.V1: return 1;
->A.B.C.E.V1 : I.V1
+>A.B.C.E.V1 : I
 >A.B.C.E : typeof I
 >A.B.C : typeof A.B.C
 >A.B : typeof A.B
@@ -557,11 +557,11 @@ function bar(e: A.B.C.E): number {
 >B : typeof A.B
 >C : typeof A.B.C
 >E : typeof I
->V1 : I.V1
+>V1 : I
 >1 : number
 
         case A.B.C.E.V2: return 1;
->A.B.C.E.V2 : I.V2
+>A.B.C.E.V2 : I
 >A.B.C.E : typeof I
 >A.B.C : typeof A.B.C
 >A.B : typeof A.B
@@ -569,11 +569,11 @@ function bar(e: A.B.C.E): number {
 >B : typeof A.B
 >C : typeof A.B.C
 >E : typeof I
->V2 : I.V2
+>V2 : I
 >1 : number
 
         case A.B.C.E.V3: return 1;
->A.B.C.E.V3 : I.V3
+>A.B.C.E.V3 : I
 >A.B.C.E : typeof I
 >A.B.C : typeof A.B.C
 >A.B : typeof A.B
@@ -581,7 +581,7 @@ function bar(e: A.B.C.E): number {
 >B : typeof A.B
 >C : typeof A.B.C
 >E : typeof I
->V3 : I.V3
+>V3 : I
 >1 : number
     }
 }

tests/baselines/reference/declarationEmit_nameConflicts3.symbols

@@ -52,11 +52,11 @@ module M.P {
 
     export var w = M.D.f; // error, should be typeof M.D.f
 >w : Symbol(w, Decl(declarationEmit_nameConflicts3.ts, 22, 14))
->M.D.f : Symbol(D.f, Decl(declarationEmit_nameConflicts3.ts, 2, 21))
+>M.D.f : Symbol(M.D.f, Decl(declarationEmit_nameConflicts3.ts, 2, 21))
 >M.D : Symbol(D, Decl(declarationEmit_nameConflicts3.ts, 0, 10), Decl(declarationEmit_nameConflicts3.ts, 1, 26))
 >M : Symbol(M, Decl(declarationEmit_nameConflicts3.ts, 0, 0), Decl(declarationEmit_nameConflicts3.ts, 11, 1))
 >D : Symbol(D, Decl(declarationEmit_nameConflicts3.ts, 0, 10), Decl(declarationEmit_nameConflicts3.ts, 1, 26))
->f : Symbol(D.f, Decl(declarationEmit_nameConflicts3.ts, 2, 21))
+>f : Symbol(M.D.f, Decl(declarationEmit_nameConflicts3.ts, 2, 21))
 
     export var x = M.C.f; // error, should be typeof M.C.f
 >x : Symbol(x, Decl(declarationEmit_nameConflicts3.ts, 23, 14), Decl(declarationEmit_nameConflicts3.ts, 24, 14))

tests/baselines/reference/enumLiteralTypes1.types

@@ -20,7 +20,7 @@ type NoYes = Choice.No | Choice.Yes;
 >Yes : Choice.Yes
 
 type UnknownYesNo = Choice.Unknown | Choice.Yes | Choice.No;
->UnknownYesNo : UnknownYesNo
+>UnknownYesNo : Choice
 >Choice : any
 >Unknown : Choice.Unknown
 >Choice : any
@@ -55,17 +55,17 @@ function f1() {
 }
 
 function f2(a: YesNo, b: UnknownYesNo, c: Choice) {
->f2 : (a: YesNo, b: UnknownYesNo, c: Choice) => void
+>f2 : (a: YesNo, b: Choice, c: Choice) => void
 >a : YesNo
 >YesNo : YesNo
->b : UnknownYesNo
->UnknownYesNo : UnknownYesNo
+>b : Choice
+>UnknownYesNo : Choice
 >c : Choice
 >Choice : Choice
 
     b = a;
 >b = a : YesNo
->b : UnknownYesNo
+>b : Choice
 >a : YesNo
 
     c = a;
@@ -234,11 +234,11 @@ declare function g(x: Choice): number;
 >Choice : Choice
 
 function f5(a: YesNo, b: UnknownYesNo, c: Choice) {
->f5 : (a: YesNo, b: UnknownYesNo, c: Choice) => void
+>f5 : (a: YesNo, b: Choice, c: Choice) => void
 >a : YesNo
 >YesNo : YesNo
->b : UnknownYesNo
->UnknownYesNo : UnknownYesNo
+>b : Choice
+>UnknownYesNo : Choice
 >c : Choice
 >Choice : Choice
 
@@ -268,7 +268,7 @@ function f5(a: YesNo, b: UnknownYesNo, c: Choice) {
 >z4 : number
 >g(b) : number
 >g : { (x: Choice.Yes): string; (x: Choice.No): boolean; (x: Choice): number; }
->b : UnknownYesNo
+>b : Choice
 
     var z5 = g(c);
 >z5 : number
@@ -336,30 +336,30 @@ function f11(x: YesNo) {
 }
 
 function f12(x: UnknownYesNo) {
->f12 : (x: UnknownYesNo) => void
->x : UnknownYesNo
->UnknownYesNo : UnknownYesNo
+>f12 : (x: Choice) => void
+>x : Choice
+>UnknownYesNo : Choice
 
     if (x) {
->x : UnknownYesNo
+>x : Choice
 
         x;
 >x : YesNo
     }
     else {
         x;
->x : UnknownYesNo
+>x : Choice
     }
 }
 
 function f13(x: UnknownYesNo) {
->f13 : (x: UnknownYesNo) => void
->x : UnknownYesNo
->UnknownYesNo : UnknownYesNo
+>f13 : (x: Choice) => void
+>x : Choice
+>UnknownYesNo : Choice
 
     if (x === Choice.Yes) {
 >x === Choice.Yes : boolean
->x : UnknownYesNo
+>x : Choice
 >Choice.Yes : Choice.Yes
 >Choice : typeof Choice
 >Yes : Choice.Yes
@@ -369,7 +369,7 @@ function f13(x: UnknownYesNo) {
     }
     else {
         x;
->x : Choice.No | Choice.Unknown
+>x : Choice.Unknown | Choice.No
     }
 }
 

tests/baselines/reference/enumLiteralTypes2.types

@@ -21,7 +21,7 @@ type NoYes = Choice.No | Choice.Yes;
 >Yes : Choice.Yes
 
 type UnknownYesNo = Choice.Unknown | Choice.Yes | Choice.No;
->UnknownYesNo : UnknownYesNo
+>UnknownYesNo : Choice
 >Choice : any
 >Unknown : Choice.Unknown
 >Choice : any
@@ -56,17 +56,17 @@ function f1() {
 }
 
 function f2(a: YesNo, b: UnknownYesNo, c: Choice) {
->f2 : (a: YesNo, b: UnknownYesNo, c: Choice) => void
+>f2 : (a: YesNo, b: Choice, c: Choice) => void
 >a : YesNo
 >YesNo : YesNo
->b : UnknownYesNo
->UnknownYesNo : UnknownYesNo
+>b : Choice
+>UnknownYesNo : Choice
 >c : Choice
 >Choice : Choice
 
     b = a;
 >b = a : YesNo
->b : UnknownYesNo
+>b : Choice
 >a : YesNo
 
     c = a;
@@ -81,132 +81,132 @@ function f2(a: YesNo, b: UnknownYesNo, c: Choice) {
 }
 
 function f3(a: Choice.Yes, b: UnknownYesNo) {
->f3 : (a: Choice.Yes, b: UnknownYesNo) => void
+>f3 : (a: Choice.Yes, b: Choice) => void
 >a : Choice.Yes
 >Choice : any
 >Yes : Choice.Yes
->b : UnknownYesNo
->UnknownYesNo : UnknownYesNo
+>b : Choice
+>UnknownYesNo : Choice
 
     var x = a + b;
 >x : number
 >a + b : number
 >a : Choice.Yes
->b : UnknownYesNo
+>b : Choice
 
     var x = a - b;
 >x : number
 >a - b : number
 >a : Choice.Yes
->b : UnknownYesNo
+>b : Choice
 
     var x = a * b;
 >x : number
 >a * b : number
 >a : Choice.Yes
->b : UnknownYesNo
+>b : Choice
 
     var x = a / b;
 >x : number
 >a / b : number
 >a : Choice.Yes
->b : UnknownYesNo
+>b : Choice
 
     var x = a % b;
 >x : number
 >a % b : number
 >a : Choice.Yes
->b : UnknownYesNo
+>b : Choice
 
     var x = a | b;
 >x : number
 >a | b : number
 >a : Choice.Yes
->b : UnknownYesNo
+>b : Choice
 
     var x = a & b;
 >x : number
 >a & b : number
 >a : Choice.Yes
->b : UnknownYesNo
+>b : Choice
 
     var x = a ^ b;
 >x : number
 >a ^ b : number
 >a : Choice.Yes
->b : UnknownYesNo
+>b : Choice
 
     var x = -b;
 >x : number
 >-b : number
->b : UnknownYesNo
+>b : Choice
 
     var x = ~b;
 >x : number
 >~b : number
->b : UnknownYesNo
+>b : Choice
 
     var y = a == b;
 >y : boolean
 >a == b : boolean
 >a : Choice.Yes
->b : UnknownYesNo
+>b : Choice
 
     var y = a != b;
 >y : boolean
 >a != b : boolean
 >a : Choice.Yes
->b : UnknownYesNo
+>b : Choice
 
     var y = a === b;
 >y : boolean
 >a === b : boolean
 >a : Choice.Yes
->b : UnknownYesNo
+>b : Choice
 
     var y = a !== b;
 >y : boolean
 >a !== b : boolean
 >a : Choice.Yes
->b : UnknownYesNo
+>b : Choice
 
     var y = a > b;
 >y : boolean
 >a > b : boolean
 >a : Choice.Yes
->b : UnknownYesNo
+>b : Choice
 
     var y = a < b;
 >y : boolean
 >a < b : boolean
 >a : Choice.Yes
->b : UnknownYesNo
+>b : Choice
 
     var y = a >= b;
 >y : boolean
 >a >= b : boolean
 >a : Choice.Yes
->b : UnknownYesNo
+>b : Choice
 
     var y = a <= b;
 >y : boolean
 >a <= b : boolean
 >a : Choice.Yes
->b : UnknownYesNo
+>b : Choice
 
     var y = !b;
 >y : boolean
 >!b : boolean
->b : UnknownYesNo
+>b : Choice
 }
 
 function f4(a: Choice.Yes, b: UnknownYesNo) {
->f4 : (a: Choice.Yes, b: UnknownYesNo) => void
+>f4 : (a: Choice.Yes, b: Choice) => void
 >a : Choice.Yes
 >Choice : any
 >Yes : Choice.Yes
->b : UnknownYesNo
->UnknownYesNo : UnknownYesNo
+>b : Choice
+>UnknownYesNo : Choice
 
     a++;
 >a++ : number
@@ -214,7 +214,7 @@ function f4(a: Choice.Yes, b: UnknownYesNo) {
 
     b++;
 >b++ : number
->b : UnknownYesNo
+>b : Choice
 }
 
 declare function g(x: Choice.Yes): string;
@@ -235,11 +235,11 @@ declare function g(x: Choice): number;
 >Choice : Choice
 
 function f5(a: YesNo, b: UnknownYesNo, c: Choice) {
->f5 : (a: YesNo, b: UnknownYesNo, c: Choice) => void
+>f5 : (a: YesNo, b: Choice, c: Choice) => void
 >a : YesNo
 >YesNo : YesNo
->b : UnknownYesNo
->UnknownYesNo : UnknownYesNo
+>b : Choice
+>UnknownYesNo : Choice
 >c : Choice
 >Choice : Choice
 
@@ -269,7 +269,7 @@ function f5(a: YesNo, b: UnknownYesNo, c: Choice) {
 >z4 : number
 >g(b) : number
 >g : { (x: Choice.Yes): string; (x: Choice.No): boolean; (x: Choice): number; }
->b : UnknownYesNo
+>b : Choice
 
     var z5 = g(c);
 >z5 : number
@@ -337,12 +337,12 @@ function f11(x: YesNo) {
 }
 
 function f12(x: UnknownYesNo) {
->f12 : (x: UnknownYesNo) => void
->x : UnknownYesNo
->UnknownYesNo : UnknownYesNo
+>f12 : (x: Choice) => void
+>x : Choice
+>UnknownYesNo : Choice
 
     if (x) {
->x : UnknownYesNo
+>x : Choice
 
         x;
 >x : YesNo
@@ -354,13 +354,13 @@ function f12(x: UnknownYesNo) {
 }
 
 function f13(x: UnknownYesNo) {
->f13 : (x: UnknownYesNo) => void
->x : UnknownYesNo
->UnknownYesNo : UnknownYesNo
+>f13 : (x: Choice) => void
+>x : Choice
+>UnknownYesNo : Choice
 
     if (x === Choice.Yes) {
 >x === Choice.Yes : boolean
->x : UnknownYesNo
+>x : Choice
 >Choice.Yes : Choice.Yes
 >Choice : typeof Choice
 >Yes : Choice.Yes
@@ -370,7 +370,7 @@ function f13(x: UnknownYesNo) {
     }
     else {
         x;
->x : Choice.No | Choice.Unknown
+>x : Choice.Unknown | Choice.No
     }
 }
 

tests/baselines/reference/enumLiteralTypes3.errors.txt

@@ -1,12 +1,9 @@
 tests/cases/conformance/types/literal/enumLiteralTypes3.ts(10,5): error TS2322: Type 'YesNo' is not assignable to type 'Yes'.
   Type 'No' is not assignable to type 'Yes'.
-tests/cases/conformance/types/literal/enumLiteralTypes3.ts(11,5): error TS2322: Type 'UnknownYesNo' is not assignable to type 'Yes'.
-  Type 'No' is not assignable to type 'Yes'.
+tests/cases/conformance/types/literal/enumLiteralTypes3.ts(11,5): error TS2322: Type 'Choice' is not assignable to type 'Yes'.
 tests/cases/conformance/types/literal/enumLiteralTypes3.ts(12,5): error TS2322: Type 'Choice' is not assignable to type 'Yes'.
-tests/cases/conformance/types/literal/enumLiteralTypes3.ts(18,5): error TS2322: Type 'UnknownYesNo' is not assignable to type 'YesNo'.
-  Type 'Unknown' is not assignable to type 'YesNo'.
+tests/cases/conformance/types/literal/enumLiteralTypes3.ts(18,5): error TS2322: Type 'Choice' is not assignable to type 'YesNo'.
 tests/cases/conformance/types/literal/enumLiteralTypes3.ts(19,5): error TS2322: Type 'Choice' is not assignable to type 'YesNo'.
-tests/cases/conformance/types/literal/enumLiteralTypes3.ts(26,5): error TS2322: Type 'Choice' is not assignable to type 'UnknownYesNo'.
 tests/cases/conformance/types/literal/enumLiteralTypes3.ts(37,5): error TS2322: Type 'Unknown' is not assignable to type 'Yes'.
 tests/cases/conformance/types/literal/enumLiteralTypes3.ts(39,5): error TS2322: Type 'No' is not assignable to type 'Yes'.
 tests/cases/conformance/types/literal/enumLiteralTypes3.ts(40,5): error TS2322: Type 'Unknown' is not assignable to type 'YesNo'.
@@ -18,7 +15,7 @@ tests/cases/conformance/types/literal/enumLiteralTypes3.ts(89,14): error TS2678:
 tests/cases/conformance/types/literal/enumLiteralTypes3.ts(96,14): error TS2678: Type 'Unknown' is not comparable to type 'YesNo'.
 
 
-==== tests/cases/conformance/types/literal/enumLiteralTypes3.ts (15 errors) ====
+==== tests/cases/conformance/types/literal/enumLiteralTypes3.ts (14 errors) ====
     const enum Choice { Unknown, Yes, No };
     
     type Yes = Choice.Yes;
@@ -34,8 +31,7 @@ tests/cases/conformance/types/literal/enumLiteralTypes3.ts(96,14): error TS2678:
 !!! error TS2322:   Type 'No' is not assignable to type 'Yes'.
         a = c;
         ~
-!!! error TS2322: Type 'UnknownYesNo' is not assignable to type 'Yes'.
-!!! error TS2322:   Type 'No' is not assignable to type 'Yes'.
+!!! error TS2322: Type 'Choice' is not assignable to type 'Yes'.
         a = d;
         ~
 !!! error TS2322: Type 'Choice' is not assignable to type 'Yes'.
@@ -46,8 +42,7 @@ tests/cases/conformance/types/literal/enumLiteralTypes3.ts(96,14): error TS2678:
         b = b;
         b = c;
         ~
-!!! error TS2322: Type 'UnknownYesNo' is not assignable to type 'YesNo'.
-!!! error TS2322:   Type 'Unknown' is not assignable to type 'YesNo'.
+!!! error TS2322: Type 'Choice' is not assignable to type 'YesNo'.
         b = d;
         ~
 !!! error TS2322: Type 'Choice' is not assignable to type 'YesNo'.
@@ -58,8 +53,6 @@ tests/cases/conformance/types/literal/enumLiteralTypes3.ts(96,14): error TS2678:
         c = b;
         c = c;
         c = d;
-        ~
-!!! error TS2322: Type 'Choice' is not assignable to type 'UnknownYesNo'.
     }
     
     function f4(a: Yes, b: YesNo, c: UnknownYesNo, d: Choice) {

tests/baselines/reference/enumMerging.types

@@ -208,12 +208,12 @@ module M6 {
 >Yellow : A.Color
 
     t = A.Color.Red;
->t = A.Color.Red : A.Color
+>t = A.Color.Red : A.Color.Red
 >t : A.Color
->A.Color.Red : A.Color
+>A.Color.Red : A.Color.Red
 >A.Color : typeof A.Color
 >A : typeof A
 >Color : typeof A.Color
->Red : A.Color
+>Red : A.Color.Red
 }
 

tests/baselines/reference/exportAssignmentTopLevelEnumdule.types

@@ -9,9 +9,9 @@ var color: foo;
 if(color === foo.green){
 >color === foo.green : boolean
 >color : foo
->foo.green : foo
+>foo.green : foo.green
 >foo : typeof foo
->green : foo
+>green : foo.green
 
 	color = foo.answer;
 >color = foo.answer : number

tests/baselines/reference/functionExpressionContextualTyping1.types

@@ -116,7 +116,7 @@ var b4: (n: E) => string = (number = 1) => { return "hello"; };
 >E : E
 >(number = 1) => { return "hello"; } : (number?: E) => string
 >number : E
->1 : number
+>1 : 1
 >"hello" : string
 
 var b5: (n: {}) => string = (number = "string") => { return "hello"; };

tests/baselines/reference/instantiatedModule.types

@@ -175,9 +175,9 @@ var blue: M3.Color = a3.Blue;
 >blue : M3.Color
 >M3 : any
 >Color : M3.Color
->a3.Blue : M3.Color
+>a3.Blue : M3.Color.Blue
 >a3 : typeof M3.Color
->Blue : M3.Color
+>Blue : M3.Color.Blue
 
 var p3: M3.Color;
 >p3 : M3.Color

tests/baselines/reference/internalAliasEnum.types

@@ -27,8 +27,8 @@ module c {
     export var bVal: b = b.Sunday;
 >bVal : b
 >b : b
->b.Sunday : b
+>b.Sunday : b.Sunday
 >b : typeof b
->Sunday : b
+>Sunday : b.Sunday
 }
 

tests/baselines/reference/internalAliasEnumInsideLocalModuleWithExport.types

@@ -27,8 +27,8 @@ export module c {
     export var bVal: b = b.Sunday;
 >bVal : b
 >b : b
->b.Sunday : b
+>b.Sunday : b.Sunday
 >b : typeof b
->Sunday : b
+>Sunday : b.Sunday
 }
 

tests/baselines/reference/internalAliasEnumInsideLocalModuleWithoutExport.types

@@ -27,8 +27,8 @@ export module c {
     export var bVal: b = b.Sunday;
 >bVal : b
 >b : b
->b.Sunday : b
+>b.Sunday : b.Sunday
 >b : typeof b
->Sunday : b
+>Sunday : b.Sunday
 }
 

tests/baselines/reference/internalAliasEnumInsideTopLevelModuleWithExport.types

@@ -24,7 +24,7 @@ export import b = a.weekend;
 export var bVal: b = b.Sunday;
 >bVal : b
 >b : b
->b.Sunday : b
+>b.Sunday : b.Sunday
 >b : typeof b
->Sunday : b
+>Sunday : b.Sunday
 

tests/baselines/reference/internalAliasEnumInsideTopLevelModuleWithoutExport.types

@@ -24,7 +24,7 @@ import b = a.weekend;
 export var bVal: b = b.Sunday;
 >bVal : b
 >b : b
->b.Sunday : b
+>b.Sunday : b.Sunday
 >b : typeof b
->Sunday : b
+>Sunday : b.Sunday
 

tests/baselines/reference/invalidImportAliasIdentifiers.errors.txt

@@ -1,10 +1,9 @@
 tests/cases/conformance/internalModules/importDeclarations/invalidImportAliasIdentifiers.ts(5,12): error TS2503: Cannot find namespace 'V'.
 tests/cases/conformance/internalModules/importDeclarations/invalidImportAliasIdentifiers.ts(11,12): error TS2503: Cannot find namespace 'C'.
-tests/cases/conformance/internalModules/importDeclarations/invalidImportAliasIdentifiers.ts(17,12): error TS2503: Cannot find namespace 'E'.
 tests/cases/conformance/internalModules/importDeclarations/invalidImportAliasIdentifiers.ts(23,12): error TS2503: Cannot find namespace 'I'.
 
 
-==== tests/cases/conformance/internalModules/importDeclarations/invalidImportAliasIdentifiers.ts (4 errors) ====
+==== tests/cases/conformance/internalModules/importDeclarations/invalidImportAliasIdentifiers.ts (3 errors) ====
     // none of these should work, since non are actually modules
     
     var V = 12;
@@ -26,8 +25,6 @@ tests/cases/conformance/internalModules/importDeclarations/invalidImportAliasIde
     }
     
     import e = E;
-               ~
-!!! error TS2503: Cannot find namespace 'E'.
     
     interface I {
         id: number;

tests/baselines/reference/localImportNameVsGlobalName.types

@@ -26,21 +26,21 @@ module App {
   foo(Key.UP);
 >foo(Key.UP) : void
 >foo : (key: Key) => void
->Key.UP : Key
+>Key.UP : Key.UP
 >Key : typeof Key
->UP : Key
+>UP : Key.UP
 
   foo(Key.DOWN);
 >foo(Key.DOWN) : void
 >foo : (key: Key) => void
->Key.DOWN : Key
+>Key.DOWN : Key.DOWN
 >Key : typeof Key
->DOWN : Key
+>DOWN : Key.DOWN
 
   foo(Key.LEFT);
 >foo(Key.LEFT) : void
 >foo : (key: Key) => void
->Key.LEFT : Key
+>Key.LEFT : Key.LEFT
 >Key : typeof Key
->LEFT : Key
+>LEFT : Key.LEFT
 }

tests/baselines/reference/localTypes1.types

@@ -37,15 +37,15 @@ function f1() {
 >C : typeof C
 
     a[0].x = E.B;
->a[0].x = E.B : E
+>a[0].x = E.B : E.B
 >a[0].x : E
 >a[0] : I
 >a : I[]
 >0 : number
 >x : E
->E.B : E
+>E.B : E.B
 >E : typeof E
->B : E
+>B : E.B
 
     return a;
 >a : I[]
@@ -91,15 +91,15 @@ function f2() {
 >C : typeof C
 
         a[0].x = E.B;
->a[0].x = E.B : E
+>a[0].x = E.B : E.B
 >a[0].x : E
 >a[0] : I
 >a : I[]
 >0 : number
 >x : E
->E.B : E
+>E.B : E.B
 >E : typeof E
->B : E
+>B : E.B
 
         return a;
 >a : I[]
@@ -153,15 +153,15 @@ function f3(b: boolean) {
 >C : typeof C
 
             a[0].x = E.B;
->a[0].x = E.B : E
+>a[0].x = E.B : E.B
 >a[0].x : E
 >a[0] : I
 >a : I[]
 >0 : number
 >x : E
->E.B : E
+>E.B : E.B
 >E : typeof E
->B : E
+>B : E.B
 
             return a;
 >a : I[]
@@ -193,15 +193,15 @@ function f3(b: boolean) {
 >A : typeof A
 
             c[0].x = E.B;
->c[0].x = E.B : E
+>c[0].x = E.B : E.B
 >c[0].x : E
 >c[0] : J
 >c : J[]
 >0 : number
 >x : E
->E.B : E
+>E.B : E.B
 >E : typeof E
->B : E
+>B : E.B
 
             return c;
 >c : J[]

tests/baselines/reference/logicalAndOperatorWithEveryType.types

@@ -364,10 +364,10 @@ var rf5 = a5 && a6;
 >a6 : E
 
 var rf6 = a6 && a6;
->rf6 : E
->a6 && a6 : E
->a6 : E
+>rf6 : E.b | E.c
+>a6 && a6 : E.b | E.c
 >a6 : E
+>a6 : E.b | E.c
 
 var rf7 = a7 && a6;
 >rf7 : E

tests/baselines/reference/validEnumAssignments.types

@@ -54,18 +54,18 @@ e = e;
 >e : E
 
 e = E.A;
->e = E.A : E
+>e = E.A : E.A
 >e : E
->E.A : E
+>E.A : E.A
 >E : typeof E
->A : E
+>A : E.A
 
 e = E.B;
->e = E.B : E
+>e = E.B : E.B
 >e : E
->E.B : E
+>E.B : E.B
 >E : typeof E
->B : E
+>B : E.B
 
 e = n;
 >e = n : number
@@ -83,23 +83,23 @@ e = undefined;
 >undefined : undefined
 
 e = 1;
->e = 1 : number
+>e = 1 : 1
 >e : E
->1 : number
+>1 : 1
 
 e = 1.;
->e = 1. : number
+>e = 1. : 1
 >e : E
->1. : number
+>1. : 1
 
 e = 1.0;
->e = 1.0 : number
+>e = 1.0 : 1
 >e : E
->1.0 : number
+>1.0 : 1
 
 e = -1;
->e = -1 : number
+>e = -1 : -1
 >e : E
->-1 : number
+>-1 : -1
 >1 : number