Temporary fix for import case in getTypeOfNode

src/compiler/checker.ts

@@ -6773,19 +6773,19 @@ module ts {
                 (<QualifiedName>node.parent).right === node;
         }
 
-        function getSymbolOfIdentifier(identifier: Identifier) {
-            if (isDeclarationOrFunctionExpressionOrCatchVariableName(identifier)) {
-                return getSymbolOfNode(identifier.parent);
+        function getSymbolOfEntityName(entityName: EntityName): Symbol {
+            if (isDeclarationOrFunctionExpressionOrCatchVariableName(entityName)) {
+                return getSymbolOfNode(entityName.parent);
             }
 
-            if (identifier.parent.kind === SyntaxKind.ExportAssignment) {
-                return resolveEntityName(/*location*/ identifier.parent.parent, identifier,
+            if (entityName.parent.kind === SyntaxKind.ExportAssignment) {
+                return resolveEntityName(/*location*/ entityName.parent.parent, entityName,
                     /*all meanings*/ SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace | SymbolFlags.Import);
             }
 
-            var entityName: Node = identifier;
-            while (isRightSideOfQualifiedNameOrPropertyAccess(entityName))
+            if (isRightSideOfQualifiedNameOrPropertyAccess(entityName)) {
                 entityName = entityName.parent;
+            }
 
             if (isExpression(entityName)) {
                 if (entityName.kind === SyntaxKind.Identifier) {
@@ -6813,12 +6813,17 @@ module ts {
                 meaning |= SymbolFlags.Import;
                 return resolveEntityName(entityName, entityName, meaning);
             }
+
+            // Do we want to return undefined here?
+            return undefined;
         }
 
         function getSymbolInfo(node: Node) {
             switch (node.kind) {
                 case SyntaxKind.Identifier:
-                    return getSymbolOfIdentifier(<Identifier>node);
+                case SyntaxKind.PropertyAccess:
+                case SyntaxKind.QualifiedName:
+                    return getSymbolOfEntityName(<Identifier>node);
 
                 case SyntaxKind.ThisKeyword:
                 case SyntaxKind.SuperKeyword:
@@ -6894,10 +6899,12 @@ module ts {
                 }
                 else {
                     // It is an import statement
-                    while (node.kind !== SyntaxKind.ImportDeclaration) {
+                    if (isRightSideOfQualifiedNameOrPropertyAccess(node)) {
                         node = node.parent;
                     }
-                    symbol = getSymbolOfNode(node);
+                    // We include all declaration spaces for aliases. This is likely too inclusive, as the rules
+                    // for resolving aliases are quite particular. Ideally this should reuse the logic in resolveAlias.
+                    symbol = resolveEntityName(node, node, SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace | SymbolFlags.Import);
                 }
                 var declaredType = getDeclaredTypeOfSymbol(symbol);
                 return declaredType !== unknownType ? declaredType : getTypeOfSymbol(symbol);

tests/baselines/reference/ExportClassWithInaccessibleTypeInTypeParameterConstraint.types

@@ -50,7 +50,7 @@ module A {
 >fromorigin2d : (p: Point) => Line<Point>
 >p : Point
 >Point : Point
->Line : Line
+>Line : Line<TPoint>
 >Point : Point
 
             return null;

tests/baselines/reference/ExportVariableOfGenericTypeWithInaccessibleTypeAsTypeArgument.types

@@ -11,7 +11,7 @@ module A {
 
     export var beez: Array<B>;
 >beez : B[]
->Array : Array
+>Array : T[]
 >B : B
 
     export var beez2 = new Array<B>();

tests/baselines/reference/acceptableAlias1.types

@@ -12,6 +12,6 @@ module M {
 
 import r = M.X;
 >r : r
->M : M
+>M : typeof M
 >X : X
 

tests/baselines/reference/aliasUsageInTypeArgumentOfExtendsClause.types

@@ -24,7 +24,7 @@ class C<T extends IHasVisualizationModel> {
 }
 class D extends C<IHasVisualizationModel> {
 >D : D
->C : C
+>C : C<T>
 >IHasVisualizationModel : IHasVisualizationModel
 
     x = moduleA;

tests/baselines/reference/amdImportNotAsPrimaryExpression.types

@@ -5,7 +5,7 @@ import foo = require("./foo_0");
 // None of the below should cause a runtime dependency on foo_0
 import f = foo.M1;
 >f : f
->foo : foo
+>foo : typeof "tests/cases/conformance/externalModules/foo_0"
 >M1 : M1
 
 var i: f.I2;

tests/baselines/reference/anyAssignabilityInInheritance.types

@@ -167,8 +167,8 @@ class A2<T> { foo: T; }
 declare function foo11(x: A2<string>): A2<string>;
 >foo11 : { (x: A2<string>): A2<string>; (x: any): any; }
 >x : A2<string>
->A2 : A2
->A2 : A2
+>A2 : A2<T>
+>A2 : A2<T>
 
 declare function foo11(x: any): any;
 >foo11 : { (x: A2<string>): A2<string>; (x: any): any; }

tests/baselines/reference/arrayLiterals.types

@@ -78,7 +78,7 @@ var classTypeArray = [C, C, C];
 
 var classTypeArray: Array<typeof C>; // Should OK, not be a parse error
 >classTypeArray : typeof C[]
->Array : Array
+>Array : T[]
 >C : typeof C
 
 // Contextual type C with numeric index signature makes array literal of EveryType E of type BCT(E,C)[]
@@ -111,7 +111,7 @@ var context2 = [{ a: '', b: 0, c: '' }, { a: "", b: 3, c: 0 }];
 
 var context2: Array<{}>; // Should be OK
 >context2 : {}[]
->Array : Array
+>Array : T[]
 
 // Contextual type C with numeric index signature of type Base makes array literal of Derived have type Base[]
 class Base { private p; }

tests/baselines/reference/arrayLiteralsWithRecursiveGenerics.types

@@ -9,15 +9,15 @@ class List<T> {
 
     next: List<List<T>>;
 >next : List<List<T>>
->List : List
->List : List
+>List : List<T>
+>List : List<T>
 >T : T
 }
 
 class DerivedList<U> extends List<U> {
 >DerivedList : DerivedList<U>
 >U : U
->List : List
+>List : List<T>
 >U : U
 
     foo: U;
@@ -37,22 +37,22 @@ class MyList<T> {
 
     next: MyList<MyList<T>>;
 >next : MyList<MyList<T>>
->MyList : MyList
->MyList : MyList
+>MyList : MyList<T>
+>MyList : MyList<T>
 >T : T
 }
 
 var list: List<number>;
 >list : List<number>
->List : List
+>List : List<T>
 
 var list2: List<string>;
 >list2 : List<string>
->List : List
+>List : List<T>
 
 var myList: MyList<number>;
 >myList : MyList<number>
->MyList : MyList
+>MyList : MyList<T>
 
 var xs = [list, myList]; // {}[]
 >xs : List<number>[]
@@ -73,7 +73,7 @@ var zs = [list, null]; // List<number>[]
 
 var myDerivedList: DerivedList<number>;
 >myDerivedList : DerivedList<number>
->DerivedList : DerivedList
+>DerivedList : DerivedList<U>
 
 var as = [list, myDerivedList]; // List<number>[]
 >as : List<number>[]

tests/baselines/reference/arrayTypeInSignatureOfInterfaceAndClass.types

@@ -12,15 +12,15 @@ declare module WinJS {
 >success : (value: T) => Promise<U>
 >value : T
 >T : T
->Promise : Promise
+>Promise : Promise<T>
 >U : U
 >error : (error: any) => Promise<U>
 >error : any
->Promise : Promise
+>Promise : Promise<T>
 >U : U
 >progress : (progress: any) => void
 >progress : any
->Promise : Promise
+>Promise : Promise<T>
 >U : U
     }
 }
@@ -66,14 +66,14 @@ declare module Data {
 >indices : number[]
 >options : any
 >WinJS : WinJS
->Promise : Promise
->IListItem : IListItem
+>Promise : Promise<T>
+>IListItem : IListItem<T>
 >T : T
     }
     export class VirtualList<T> implements IVirtualList<T> {
 >VirtualList : VirtualList<T>
 >T : T
->IVirtualList : IVirtualList
+>IVirtualList : IVirtualList<T>
 >T : T
 
         //removeIndices: WinJS.Promise<IListItem<T>[]>;
@@ -82,8 +82,8 @@ declare module Data {
 >indices : number[]
 >options : any
 >WinJS : WinJS
->Promise : Promise
->IListItem : IListItem
+>Promise : Promise<T>
+>IListItem : IListItem<T>
 >T : T
     }
 }

tests/baselines/reference/assignmentCompatWithCallSignatures3.types

@@ -106,23 +106,23 @@ var a11: (x: { foo: string }, y: { foo: string; bar: string }) => Base;
 var a12: (x: Array<Base>, y: Array<Derived2>) => Array<Derived>;
 >a12 : (x: Base[], y: Derived2[]) => Derived[]
 >x : Base[]
->Array : Array
+>Array : T[]
 >Base : Base
 >y : Derived2[]
->Array : Array
+>Array : T[]
 >Derived2 : Derived2
->Array : Array
+>Array : T[]
 >Derived : Derived
 
 var a13: (x: Array<Base>, y: Array<Derived>) => Array<Derived>;
 >a13 : (x: Base[], y: Derived[]) => Derived[]
 >x : Base[]
->Array : Array
+>Array : T[]
 >Base : Base
 >y : Derived[]
->Array : Array
+>Array : T[]
 >Derived : Derived
->Array : Array
+>Array : T[]
 >Derived : Derived
 
 var a14: (x: { a: string; b: number }) => Object;
@@ -429,14 +429,14 @@ b11 = a11; // ok
 var b12: <T extends Array<Base>>(x: Array<Base>, y: T) => Array<Derived>; 
 >b12 : <T extends Base[]>(x: Base[], y: T) => Derived[]
 >T : T
->Array : Array
+>Array : T[]
 >Base : Base
 >x : Base[]
->Array : Array
+>Array : T[]
 >Base : Base
 >y : T
 >T : T
->Array : Array
+>Array : T[]
 >Derived : Derived
 
 a12 = b12; // ok
@@ -452,10 +452,10 @@ b12 = a12; // ok
 var b13: <T extends Array<Derived>>(x: Array<Base>, y: T) => T; 
 >b13 : <T extends Derived[]>(x: Base[], y: T) => T
 >T : T
->Array : Array
+>Array : T[]
 >Derived : Derived
 >x : Base[]
->Array : Array
+>Array : T[]
 >Base : Base
 >y : T
 >T : T

tests/baselines/reference/assignmentCompatWithConstructSignatures3.types

@@ -106,23 +106,23 @@ var a11: new (x: { foo: string }, y: { foo: string; bar: string }) => Base;
 var a12: new (x: Array<Base>, y: Array<Derived2>) => Array<Derived>;
 >a12 : new (x: Base[], y: Derived2[]) => Derived[]
 >x : Base[]
->Array : Array
+>Array : T[]
 >Base : Base
 >y : Derived2[]
->Array : Array
+>Array : T[]
 >Derived2 : Derived2
->Array : Array
+>Array : T[]
 >Derived : Derived
 
 var a13: new (x: Array<Base>, y: Array<Derived>) => Array<Derived>;
 >a13 : new (x: Base[], y: Derived[]) => Derived[]
 >x : Base[]
->Array : Array
+>Array : T[]
 >Base : Base
 >y : Derived[]
->Array : Array
+>Array : T[]
 >Derived : Derived
->Array : Array
+>Array : T[]
 >Derived : Derived
 
 var a14: new (x: { a: string; b: number }) => Object;
@@ -429,14 +429,14 @@ b11 = a11; // ok
 var b12: new <T extends Array<Base>>(x: Array<Base>, y: T) => Array<Derived>; 
 >b12 : new <T extends Base[]>(x: Base[], y: T) => Derived[]
 >T : T
->Array : Array
+>Array : T[]
 >Base : Base
 >x : Base[]
->Array : Array
+>Array : T[]
 >Base : Base
 >y : T
 >T : T
->Array : Array
+>Array : T[]
 >Derived : Derived
 
 a12 = b12; // ok
@@ -452,10 +452,10 @@ b12 = a12; // ok
 var b13: new <T extends Array<Derived>>(x: Array<Base>, y: T) => T; 
 >b13 : new <T extends Derived[]>(x: Base[], y: T) => T
 >T : T
->Array : Array
+>Array : T[]
 >Derived : Derived
 >x : Base[]
->Array : Array
+>Array : T[]
 >Base : Base
 >y : T
 >T : T

tests/baselines/reference/assignmentCompatWithGenericCallSignatures3.types

@@ -25,7 +25,7 @@ var g: <T>(x: T) => <S>(y: S) => I<T, S>
 >S : S
 >y : S
 >S : S
->I : I
+>I : I<T, S>
 >T : T
 >S : S
 

tests/baselines/reference/assignmentCompatability1.types

@@ -11,7 +11,7 @@ module __test1__ {
 >two : U
 >U : U
 >obj4 : interfaceWithPublicAndOptional<number, string>
->interfaceWithPublicAndOptional : interfaceWithPublicAndOptional
+>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional<T, U>
 >{ one: 1 } : { one: number; }
 >one : number
 

tests/baselines/reference/assignmentCompatability2.types

@@ -11,7 +11,7 @@ module __test1__ {
 >two : U
 >U : U
 >obj4 : interfaceWithPublicAndOptional<number, string>
->interfaceWithPublicAndOptional : interfaceWithPublicAndOptional
+>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional<T, U>
 >{ one: 1 } : { one: number; }
 >one : number
 

tests/baselines/reference/assignmentCompatability3.types

@@ -11,7 +11,7 @@ module __test1__ {
 >two : U
 >U : U
 >obj4 : interfaceWithPublicAndOptional<number, string>
->interfaceWithPublicAndOptional : interfaceWithPublicAndOptional
+>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional<T, U>
 >{ one: 1 } : { one: number; }
 >one : number
 

tests/baselines/reference/assignmentCompatability4.types

@@ -11,7 +11,7 @@ module __test1__ {
 >two : U
 >U : U
 >obj4 : interfaceWithPublicAndOptional<number, string>
->interfaceWithPublicAndOptional : interfaceWithPublicAndOptional
+>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional<T, U>
 >{ one: 1 } : { one: number; }
 >one : number
 

tests/baselines/reference/assignmentCompatability5.types

@@ -11,7 +11,7 @@ module __test1__ {
 >two : U
 >U : U
 >obj4 : interfaceWithPublicAndOptional<number, string>
->interfaceWithPublicAndOptional : interfaceWithPublicAndOptional
+>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional<T, U>
 >{ one: 1 } : { one: number; }
 >one : number
 
@@ -28,7 +28,7 @@ module __test2__ {
 >one : T
 >T : T
 >obj1 : interfaceOne<number>
->interfaceOne : interfaceOne
+>interfaceOne : interfaceOne<T>
 >{ one: 1 } : { one: number; }
 >one : number
 

tests/baselines/reference/assignmentCompatability6.types

@@ -11,7 +11,7 @@ module __test1__ {
 >two : U
 >U : U
 >obj4 : interfaceWithPublicAndOptional<number, string>
->interfaceWithPublicAndOptional : interfaceWithPublicAndOptional
+>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional<T, U>
 >{ one: 1 } : { one: number; }
 >one : number
 
@@ -28,7 +28,7 @@ module __test2__ {
 >one : T
 >T : T
 >obj3 : interfaceWithOptional<number>
->interfaceWithOptional : interfaceWithOptional
+>interfaceWithOptional : interfaceWithOptional<T>
 >{ } : {}
 
     export var __val__obj3 = obj3;

tests/baselines/reference/assignmentCompatability7.types

@@ -11,7 +11,7 @@ module __test1__ {
 >two : U
 >U : U
 >obj4 : interfaceWithPublicAndOptional<number, string>
->interfaceWithPublicAndOptional : interfaceWithPublicAndOptional
+>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional<T, U>
 >{ one: 1 } : { one: number; }
 >one : number
 
@@ -31,7 +31,7 @@ module __test2__ {
 >two : U
 >U : U
 >obj4 : interfaceWithPublicAndOptional<number, string>
->interfaceWithPublicAndOptional : interfaceWithPublicAndOptional
+>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional<T, U>
 >{ one: 1 } : { one: number; }
 >one : number
 

tests/baselines/reference/assignmentCompatability8.types

@@ -11,7 +11,7 @@ module __test1__ {
 >two : U
 >U : U
 >obj4 : interfaceWithPublicAndOptional<number, string>
->interfaceWithPublicAndOptional : interfaceWithPublicAndOptional
+>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional<T, U>
 >{ one: 1 } : { one: number; }
 >one : number
 

tests/baselines/reference/assignmentCompatability9.types

@@ -11,7 +11,7 @@ module __test1__ {
 >two : U
 >U : U
 >obj4 : interfaceWithPublicAndOptional<number, string>
->interfaceWithPublicAndOptional : interfaceWithPublicAndOptional
+>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional<T, U>
 >{ one: 1 } : { one: number; }
 >one : number
 

tests/baselines/reference/baseIndexSignatureResolution.types

@@ -28,7 +28,7 @@ interface FooOf<TBase extends Base> extends Foo {
 }
 var x: FooOf<Derived> = null;
 >x : FooOf<Derived>
->FooOf : FooOf
+>FooOf : FooOf<TBase>
 >Derived : Derived
 
 var y: Derived = x[0];

tests/baselines/reference/baseTypeOrderChecking.types

@@ -1,7 +1,7 @@
 === tests/cases/compiler/baseTypeOrderChecking.ts ===
 var someVariable: Class4<Class2>;
 >someVariable : Class4<Class2>
->Class4 : Class4
+>Class4 : Class4<T>
 >Class2 : Class2
 
  
@@ -42,7 +42,7 @@ class Class3<T>
 class Class4<T> extends Class3<T>
 >Class4 : Class4<T>
 >T : T
->Class3 : Class3
+>Class3 : Class3<T>
 >T : T
 
 {

tests/baselines/reference/bestCommonTypeReturnStatement.types

@@ -10,7 +10,7 @@ interface IPromise<T> {
 >T : T
 >errorCallback : (reason: any) => any
 >reason : any
->IPromise : IPromise
+>IPromise : IPromise<T>
 }
 
 function f() {
@@ -28,9 +28,9 @@ function f() {
 
 function b(): IPromise<void> { return null; }
 >b : () => IPromise<void>
->IPromise : IPromise
+>IPromise : IPromise<T>
 
 function d(): IPromise<any> { return null; }
 >d : () => IPromise<any>
->IPromise : IPromise
+>IPromise : IPromise<T>
 

tests/baselines/reference/callExpressionWithTypeParameterConstrainedToOuterTypeParameter.types

@@ -12,7 +12,7 @@ interface I<T> {
 }
 var i: I<string>;
 >i : I<string>
->I : I
+>I : I<T>
 
 var y = i(""); // y should be string
 >y : string

tests/baselines/reference/callGenericFunctionWithZeroTypeArguments.types

@@ -115,7 +115,7 @@ interface I2<T> {
 }
 var i2: I2<number>;
 >i2 : I2<number>
->I2 : I2
+>I2 : I2<T>
 
 var r7 = i2.f(1);
 >r7 : number

tests/baselines/reference/callSignatureAssignabilityInInheritance2.types

@@ -110,23 +110,23 @@ interface A { // T
     a12: (x: Array<Base>, y: Array<Derived2>) => Array<Derived>;
 >a12 : (x: Base[], y: Derived2[]) => Derived[]
 >x : Base[]
->Array : Array
+>Array : T[]
 >Base : Base
 >y : Derived2[]
->Array : Array
+>Array : T[]
 >Derived2 : Derived2
->Array : Array
+>Array : T[]
 >Derived : Derived
 
     a13: (x: Array<Base>, y: Array<Derived>) => Array<Derived>;
 >a13 : (x: Base[], y: Derived[]) => Derived[]
 >x : Base[]
->Array : Array
+>Array : T[]
 >Base : Base
 >y : Derived[]
->Array : Array
+>Array : T[]
 >Derived : Derived
->Array : Array
+>Array : T[]
 >Derived : Derived
 
     a14: (x: { a: string; b: number }) => Object;
@@ -332,23 +332,23 @@ interface I extends A {
     a12: <T extends Array<Base>>(x: Array<Base>, y: T) => Array<Derived>; // ok, less specific parameter type
 >a12 : <T extends Base[]>(x: Base[], y: T) => Derived[]
 >T : T
->Array : Array
+>Array : T[]
 >Base : Base
 >x : Base[]
->Array : Array
+>Array : T[]
 >Base : Base
 >y : T
 >T : T
->Array : Array
+>Array : T[]
 >Derived : Derived
 
     a13: <T extends Array<Derived>>(x: Array<Base>, y: T) => T; // ok, T = Array<Derived>, satisfies constraint, contextual signature instantiation succeeds
 >a13 : <T extends Derived[]>(x: Base[], y: T) => T
 >T : T
->Array : Array
+>Array : T[]
 >Derived : Derived
 >x : Base[]
->Array : Array
+>Array : T[]
 >Base : Base
 >y : T
 >T : T

tests/baselines/reference/callSignatureAssignabilityInInheritance5.types

@@ -111,23 +111,23 @@ interface A { // T
     a12: (x: Array<Base>, y: Array<Derived2>) => Array<Derived>;
 >a12 : (x: Base[], y: Derived2[]) => Derived[]
 >x : Base[]
->Array : Array
+>Array : T[]
 >Base : Base
 >y : Derived2[]
->Array : Array
+>Array : T[]
 >Derived2 : Derived2
->Array : Array
+>Array : T[]
 >Derived : Derived
 
     a13: (x: Array<Base>, y: Array<Derived>) => Array<Derived>;
 >a13 : (x: Base[], y: Derived[]) => Derived[]
 >x : Base[]
->Array : Array
+>Array : T[]
 >Base : Base
 >y : Derived[]
->Array : Array
+>Array : T[]
 >Derived : Derived
->Array : Array
+>Array : T[]
 >Derived : Derived
 
     a14: (x: { a: string; b: number }) => Object;
@@ -280,23 +280,23 @@ interface I extends B {
     a12: <T extends Array<Base>>(x: Array<Base>, y: T) => Array<Derived>; // ok, less specific parameter type
 >a12 : <T extends Base[]>(x: Base[], y: T) => Derived[]
 >T : T
->Array : Array
+>Array : T[]
 >Base : Base
 >x : Base[]
->Array : Array
+>Array : T[]
 >Base : Base
 >y : T
 >T : T
->Array : Array
+>Array : T[]
 >Derived : Derived
 
     a13: <T extends Array<Derived>>(x: Array<Base>, y: T) => T; // ok, T = Array<Derived>, satisfies constraint, contextual signature instantiation succeeds
 >a13 : <T extends Derived[]>(x: Base[], y: T) => T
 >T : T
->Array : Array
+>Array : T[]
 >Derived : Derived
 >x : Base[]
->Array : Array
+>Array : T[]
 >Base : Base
 >y : T
 >T : T

tests/baselines/reference/callbacksDontShareTypes.types

@@ -24,25 +24,25 @@ interface Combinators {
 >T : T
 >U : U
 >c : Collection<T>
->Collection : Collection
+>Collection : Collection<T>
 >T : T
 >f : (x: T) => U
 >x : T
 >T : T
 >U : U
->Collection : Collection
+>Collection : Collection<T>
 >U : U
 
     map<T>(c: Collection<T>, f: (x: T) => any): Collection<any>;
 >map : { <T, U>(c: Collection<T>, f: (x: T) => U): Collection<U>; <T>(c: Collection<T>, f: (x: T) => any): Collection<any>; }
 >T : T
 >c : Collection<T>
->Collection : Collection
+>Collection : Collection<T>
 >T : T
 >f : (x: T) => any
 >x : T
 >T : T
->Collection : Collection
+>Collection : Collection<T>
 }
 
 var _: Combinators;
@@ -51,7 +51,7 @@ var _: Combinators;
 
 var c2: Collection<number>;
 >c2 : Collection<number>
->Collection : Collection
+>Collection : Collection<T>
 
 var rf1 = (x: number) => { return x.toFixed() };
 >rf1 : (x: number) => string

tests/baselines/reference/chainedSpecializationToObjectTypeLiteral.types

@@ -16,7 +16,7 @@ interface Sequence<T> {
 >value : T
 >T : T
 >U : U
->Sequence : Sequence
+>Sequence : Sequence<T>
 >U : U
 
     filter(iterator: (value: T) => boolean): Sequence<T>;
@@ -24,7 +24,7 @@ interface Sequence<T> {
 >iterator : (value: T) => boolean
 >value : T
 >T : T
->Sequence : Sequence
+>Sequence : Sequence<T>
 >T : T
 
     groupBy<K>(keySelector: (value: T) => K): Sequence<{ key: K; items: T[]; }>;
@@ -34,7 +34,7 @@ interface Sequence<T> {
 >value : T
 >T : T
 >K : K
->Sequence : Sequence
+>Sequence : Sequence<T>
 >key : K
 >K : K
 >items : T[]
@@ -43,7 +43,7 @@ interface Sequence<T> {
 
 var s: Sequence<string>;
 >s : Sequence<string>
->Sequence : Sequence
+>Sequence : Sequence<T>
 
 var s2 = s.groupBy(s => s.length);
 >s2 : Sequence<{ key: number; items: string[]; }>

tests/baselines/reference/classExtendingClass.types

@@ -73,7 +73,7 @@ class C2<T> {
 class D2<T> extends C2<T> {
 >D2 : D2<T>
 >T : T
->C2 : C2
+>C2 : C2<T>
 >T : T
 
     bar: string;
@@ -82,7 +82,7 @@ class D2<T> extends C2<T> {
 
 var d2: D2<string>;
 >d2 : D2<string>
->D2 : D2
+>D2 : D2<T>
 
 var r5 = d2.foo;
 >r5 : string

tests/baselines/reference/classImplementsImportedInterface.types

@@ -15,12 +15,12 @@ module M2 {
 
     import T = M1.I;
 >T : T
->M1 : I
+>M1 : M1
 >I : I
 
     class C implements T {
 >C : C
->T : T
+>T : I
 
         foo() {}
 >foo : () => void

tests/baselines/reference/cloduleAndTypeParameters.types

@@ -2,7 +2,7 @@
 class Foo<T extends Foo.Bar> {
 >Foo : Foo<T>
 >T : T
->Foo : Foo
+>Foo : Foo<T>
 >Bar : Bar
 
   constructor() {

tests/baselines/reference/commonJSImportNotAsPrimaryExpression.types

@@ -5,7 +5,7 @@ import foo = require("./foo_0");
 // None of the below should cause a runtime dependency on foo_0
 import f = foo.M1;
 >f : f
->foo : foo
+>foo : typeof "tests/cases/conformance/externalModules/foo_0"
 >M1 : M1
 
 var i: f.I2;

tests/baselines/reference/complexClassRelationships.types

@@ -41,7 +41,7 @@ class Base {
 
     ownerCollection: BaseCollection<Base>;
 >ownerCollection : BaseCollection<Base>
->BaseCollection : BaseCollection
+>BaseCollection : BaseCollection<T>
 >Base : Base
 }
 
@@ -50,7 +50,7 @@ class Thing {
 
     public get Components(): ComponentCollection<any> { return null }
 >Components : ComponentCollection<any>
->ComponentCollection : ComponentCollection
+>ComponentCollection : ComponentCollection<T>
 }
 
 class ComponentCollection<T> {
@@ -90,7 +90,7 @@ class Foo {
     }
     public get prop2(): BaseCollection<Derived> {
 >prop2 : BaseCollection<Derived>
->BaseCollection : BaseCollection
+>BaseCollection : BaseCollection<T>
 >Derived : Derived
 
         return new BaseCollection<Derived>(Derived.createEmpty);

tests/baselines/reference/constraintCheckInGenericBaseTypeReference.types

@@ -16,7 +16,7 @@ class GenericBase<T extends Constraint> {
 }
 class Derived extends GenericBase<TypeArg> {
 >Derived : Derived
->GenericBase : GenericBase
+>GenericBase : GenericBase<T>
 >TypeArg : TypeArg
 
 }

tests/baselines/reference/constraintSatisfactionWithEmptyObject.types

@@ -52,7 +52,7 @@ interface I<T extends Object> {
 }
 var i: I<{}>;
 >i : I<{}>
->I : I
+>I : I<T>
 
 // {} constraint
 function foo2<T extends {}>(x: T) { }
@@ -102,6 +102,6 @@ interface I2<T extends {}> {
 }
 var i2: I2<{}>;
 >i2 : I2<{}>
->I2 : I2
+>I2 : I2<T>
 
 

tests/baselines/reference/constructSignatureAssignabilityInInheritance2.types

@@ -110,23 +110,23 @@ interface A { // T
     a12: new (x: Array<Base>, y: Array<Derived2>) => Array<Derived>;
 >a12 : new (x: Base[], y: Derived2[]) => Derived[]
 >x : Base[]
->Array : Array
+>Array : T[]
 >Base : Base
 >y : Derived2[]
->Array : Array
+>Array : T[]
 >Derived2 : Derived2
->Array : Array
+>Array : T[]
 >Derived : Derived
 
     a13: new (x: Array<Base>, y: Array<Derived>) => Array<Derived>;
 >a13 : new (x: Base[], y: Derived[]) => Derived[]
 >x : Base[]
->Array : Array
+>Array : T[]
 >Base : Base
 >y : Derived[]
->Array : Array
+>Array : T[]
 >Derived : Derived
->Array : Array
+>Array : T[]
 >Derived : Derived
 
     a14: new (x: { a: string; b: number }) => Object;
@@ -332,23 +332,23 @@ interface I extends A {
     a12: new <T extends Array<Base>>(x: Array<Base>, y: T) => Array<Derived>; // ok, less specific parameter type
 >a12 : new <T extends Base[]>(x: Base[], y: T) => Derived[]
 >T : T
->Array : Array
+>Array : T[]
 >Base : Base
 >x : Base[]
->Array : Array
+>Array : T[]
 >Base : Base
 >y : T
 >T : T
->Array : Array
+>Array : T[]
 >Derived : Derived
 
     a13: new <T extends Array<Derived>>(x: Array<Base>, y: T) => T; // ok, T = Array<Derived>, satisfies constraint, contextual signature instantiation succeeds
 >a13 : new <T extends Derived[]>(x: Base[], y: T) => T
 >T : T
->Array : Array
+>Array : T[]
 >Derived : Derived
 >x : Base[]
->Array : Array
+>Array : T[]
 >Base : Base
 >y : T
 >T : T

tests/baselines/reference/constructSignatureAssignabilityInInheritance5.types

@@ -111,23 +111,23 @@ interface A { // T
     a12: new (x: Array<Base>, y: Array<Derived2>) => Array<Derived>;
 >a12 : new (x: Base[], y: Derived2[]) => Derived[]
 >x : Base[]
->Array : Array
+>Array : T[]
 >Base : Base
 >y : Derived2[]
->Array : Array
+>Array : T[]
 >Derived2 : Derived2
->Array : Array
+>Array : T[]
 >Derived : Derived
 
     a13: new (x: Array<Base>, y: Array<Derived>) => Array<Derived>;
 >a13 : new (x: Base[], y: Derived[]) => Derived[]
 >x : Base[]
->Array : Array
+>Array : T[]
 >Base : Base
 >y : Derived[]
->Array : Array
+>Array : T[]
 >Derived : Derived
->Array : Array
+>Array : T[]
 >Derived : Derived
 
     a14: new (x: { a: string; b: number }) => Object;
@@ -280,23 +280,23 @@ interface I extends B {
     a12: new <T extends Array<Base>>(x: Array<Base>, y: T) => Array<Derived>; // ok, less specific parameter type
 >a12 : new <T extends Base[]>(x: Base[], y: T) => Derived[]
 >T : T
->Array : Array
+>Array : T[]
 >Base : Base
 >x : Base[]
->Array : Array
+>Array : T[]
 >Base : Base
 >y : T
 >T : T
->Array : Array
+>Array : T[]
 >Derived : Derived
 
     a13: new <T extends Array<Derived>>(x: Array<Base>, y: T) => T; // ok, T = Array<Derived>, satisfies constraint, contextual signature instantiation succeeds
 >a13 : new <T extends Derived[]>(x: Base[], y: T) => T
 >T : T
->Array : Array
+>Array : T[]
 >Derived : Derived
 >x : Base[]
->Array : Array
+>Array : T[]
 >Base : Base
 >y : T
 >T : T

tests/baselines/reference/constructSignaturesWithIdenticalOverloads.types

@@ -76,14 +76,14 @@ interface I2<T> {
 >x : T
 >T : T
 >y : string
->C2 : C2
+>C2 : C2<T>
 >T : T
 
     new (x: T, y: string): C2<T>; // error
 >x : T
 >T : T
 >y : string
->C2 : C2
+>C2 : C2<T>
 >T : T
 
     new <T>(x: T, y: string): C2<T>;
@@ -91,7 +91,7 @@ interface I2<T> {
 >x : T
 >T : T
 >y : string
->C2 : C2
+>C2 : C2<T>
 >T : T
 
     new <T>(x: T, y: string): C2<T>; // error
@@ -99,13 +99,13 @@ interface I2<T> {
 >x : T
 >T : T
 >y : string
->C2 : C2
+>C2 : C2<T>
 >T : T
 }
 
 var i2: I2<number>;
 >i2 : I2<number>
->I2 : I2
+>I2 : I2<T>
 
 var r4 = new i2(1, '');
 >r4 : C2<number>
@@ -139,7 +139,7 @@ var b: {
 >x : T
 >T : T
 >y : string
->C2 : C2
+>C2 : C2<T>
 >T : T
 
     new <T>(x: T, y: string): C2<T>; // error
@@ -147,7 +147,7 @@ var b: {
 >x : T
 >T : T
 >y : string
->C2 : C2
+>C2 : C2<T>
 >T : T
 }
 

tests/baselines/reference/constructSignaturesWithOverloads.types

@@ -76,14 +76,14 @@ interface I2<T> {
 >x : T
 >T : T
 >y : string
->C2 : C2
+>C2 : C2<T>
 >T : T
 
     new (x: T, y: string): C2<T>;
 >x : T
 >T : T
 >y : string
->C2 : C2
+>C2 : C2<T>
 >T : T
 
     new <T>(x: T, y?: string): C2<T>;
@@ -91,7 +91,7 @@ interface I2<T> {
 >x : T
 >T : T
 >y : string
->C2 : C2
+>C2 : C2<T>
 >T : T
 
     new <T>(x: T, y: string): C2<T>;
@@ -99,14 +99,14 @@ interface I2<T> {
 >x : T
 >T : T
 >y : string
->C2 : C2
+>C2 : C2<T>
 >T : T
 
 }
 
 var i2: I2<number>;
 >i2 : I2<number>
->I2 : I2
+>I2 : I2<T>
 
 var r4 = new i2(1, '');
 >r4 : C2<number>
@@ -140,7 +140,7 @@ var b: {
 >x : T
 >T : T
 >y : string
->C2 : C2
+>C2 : C2<T>
 >T : T
 
     new<T>(x: T, y: string): C2<T>;
@@ -148,7 +148,7 @@ var b: {
 >x : T
 >T : T
 >y : string
->C2 : C2
+>C2 : C2<T>
 >T : T
 }
 

tests/baselines/reference/constructSignaturesWithOverloadsThatDifferOnlyByReturnType.types

@@ -29,7 +29,7 @@ interface I {
     new(x: number, y: string): C2<number>; // error
 >x : number
 >y : string
->C2 : C2
+>C2 : C2<T>
 }
 
 interface I2<T> {
@@ -40,7 +40,7 @@ interface I2<T> {
 >x : T
 >T : T
 >y : string
->C2 : C2
+>C2 : C2<T>
 
     new (x: T, y: string): C; // error
 >x : T
@@ -53,7 +53,7 @@ interface I2<T> {
 >x : T
 >T : T
 >y : string
->C2 : C2
+>C2 : C2<T>
 >T : T
 
     new <T>(x: T, y: string): C; // error
@@ -71,7 +71,7 @@ var a: {
     new (x: number, y: string): C2<number>;
 >x : number
 >y : string
->C2 : C2
+>C2 : C2<T>
 
     new (x: number, y: string): C; // error
 >x : number
@@ -87,7 +87,7 @@ var b: {
 >x : T
 >T : T
 >y : string
->C2 : C2
+>C2 : C2<T>
 >T : T
 
     new <T>(x: T, y: string): C; // error

tests/baselines/reference/constructorHasPrototypeProperty.types

@@ -61,7 +61,7 @@ module Generic {
 >D : D<T, U>
 >T : T
 >U : U
->C : C
+>C : C<T, U>
 >T : T
 >U : U
 

tests/baselines/reference/crashInResolveInterface.types

@@ -34,7 +34,7 @@ interface Q<T> {
 }
 var q1: Q<{ a: number; }>;
 >q1 : Q<{ a: number; }>
->Q : Q
+>Q : Q<T>
 >a : number
 
 var x = q1.each(x => c.log(x));

tests/baselines/reference/declFileExportAssignmentOfGenericInterface.types

@@ -4,8 +4,8 @@ import a = require('declFileExportAssignmentOfGenericInterface_0');
 
 export var x: a<a<string>>;
 >x : Foo<Foo<string>>
->a : a
->a : a
+>a : Foo<T>
+>a : Foo<T>
 
 x.a;
 >x.a : string

tests/baselines/reference/declFileForFunctionTypeAsTypeParameter.types

@@ -6,11 +6,11 @@ class X<T> {
 }
 class C extends X<() => number> {
 >C : C
->X : X
+>X : X<T>
 }
 interface I extends X<() => number> {
 >I : I
->X : X
+>X : X<T>
 }
 
 

tests/baselines/reference/declFileGenericClassWithGenericExtendedClass.types

@@ -13,7 +13,7 @@ class Base<T> { }
 class Derived<T> extends Base<T> { }
 >Derived : Derived<T>
 >T : T
->Base : Base
+>Base : Base<T>
 >T : T
 
 interface IBar<T> {
@@ -22,17 +22,17 @@ interface IBar<T> {
 
     derived: Derived<T>;
 >derived : Derived<T>
->Derived : Derived
+>Derived : Derived<T>
 >T : T
 }
 class Baz implements IBar<Baz> {
 >Baz : Baz
->IBar : IBar
+>IBar : IBar<T>
 >Baz : Baz
 
     derived: Derived<Baz>;
 >derived : Derived<Baz>
->Derived : Derived
+>Derived : Derived<T>
 >Baz : Baz
 }
 

tests/baselines/reference/declFileGenericType.types

@@ -14,7 +14,7 @@ export module C {
 >T : T
 >x : T
 >T : T
->A : A
+>A : A<T>
 >B : B
 
     export function F2<T>(x: T): C.A<C.B> { return null; }
@@ -23,7 +23,7 @@ export module C {
 >x : T
 >T : T
 >C : C
->A : A
+>A : A<T>
 >C : C
 >B : B
 
@@ -33,20 +33,20 @@ export module C {
 >x : T
 >T : T
 >C : C
->A : A
+>A : A<T>
 >C : C
 >B : B
 
     export function F4<T extends A<B>>(x: T): Array<C.A<C.B>> { return null; }
 >F4 : <T extends A<B>>(x: T) => A<B>[]
 >T : T
->A : A
+>A : A<T>
 >B : B
 >x : T
 >T : T
->Array : Array
+>Array : T[]
 >C : C
->A : A
+>A : A<T>
 >C : C
 >B : B
 
@@ -58,7 +58,7 @@ export module C {
     export function F6<T extends A<B>>(x: T): T { return null; }
 >F6 : <T extends A<B>>(x: T) => T
 >T : T
->A : A
+>A : A<T>
 >B : B
 >x : T
 >T : T
@@ -78,7 +78,7 @@ export module C {
 export var a: C.A<C.B>;
 >a : A<B>
 >C : C
->A : A
+>A : A<T>
 >C : C
 >B : B
 
@@ -115,7 +115,7 @@ export var x = (new C.D<C.A<C.B>>(new C.A<C.B>())).val;
 >C : typeof C
 >D : typeof D
 >C : C
->A : A
+>A : A<T>
 >C : C
 >B : B
 >new C.A<C.B>() : A<B>
@@ -130,7 +130,7 @@ export function f<T extends C.A<C.B>>() { }
 >f : <T extends A<B>>() => void
 >T : T
 >C : C
->A : A
+>A : A<T>
 >C : C
 >B : B
 
@@ -141,21 +141,21 @@ export var g = C.F5<C.A<C.B>>();
 >C : typeof C
 >F5 : <T>() => T
 >C : C
->A : A
+>A : A<T>
 >C : C
 >B : B
 
 export class h extends C.A<C.B>{ }
 >h : h
 >C : C
->A : A
+>A : A<T>
 >C : C
 >B : B
 
 export interface i extends C.A<C.B> { }
 >i : i
 >C : C
->A : A
+>A : A<T>
 >C : C
 >B : B
 

tests/baselines/reference/declFileGenericType2.types

@@ -31,7 +31,7 @@ declare module templa.mvc {
 >mvc : mvc
 >IModel : IModel
 >mvc : mvc
->IController : IController
+>IController : IController<ModelType>
 >ModelType : ModelType
     }
 }
@@ -48,7 +48,7 @@ declare module templa.mvc.composite {
         getControllers(): mvc.IController<mvc.IModel>[];
 >getControllers : () => IController<IModel>[]
 >mvc : mvc
->IController : IController
+>IController : IController<ModelType>
 >mvc : mvc
 >IModel : IModel
     }
@@ -66,7 +66,7 @@ module templa.dom.mvc {
 >IModel : IModel
 >templa : templa
 >mvc : mvc
->IController : IController
+>IController : IController<ModelType>
 >ModelType : ModelType
     }
 }
@@ -84,9 +84,9 @@ module templa.dom.mvc {
 >IModel : IModel
 >templa : templa
 >mvc : mvc
->AbstractController : AbstractController
+>AbstractController : AbstractController<ModelType>
 >ModelType : ModelType
->IElementController : IElementController
+>IElementController : IElementController<ModelType>
 >ModelType : ModelType
 
         constructor() {
@@ -112,14 +112,14 @@ module templa.dom.mvc.composite {
 >templa : templa
 >dom : dom
 >mvc : mvc
->AbstractElementController : AbstractElementController
+>AbstractElementController : AbstractElementController<ModelType>
 >ModelType : ModelType
 
         public _controllers: templa.mvc.IController<templa.mvc.IModel>[];
 >_controllers : IController<IModel>[]
 >templa : templa
 >mvc : mvc
->IController : IController
+>IController : IController<ModelType>
 >templa : templa
 >mvc : mvc
 >IModel : IModel

tests/baselines/reference/declFileImportChainInExportAssignment.types

@@ -12,7 +12,7 @@ module m {
 }
 import a = m.c;
 >a : typeof c
->m : typeof c
+>m : typeof m
 >c : typeof c
 
 import b = a;

tests/baselines/reference/declFileImportedTypeUseInTypeArgPosition.types

@@ -15,7 +15,7 @@ declare module 'moo' {
 
     export var p: List<x.Foo>;
 >p : List<Foo>
->List : List
+>List : List<T>
 >x : x
 >Foo : Foo
 }

tests/baselines/reference/declFileInternalAliases.types

@@ -11,7 +11,7 @@ module m1 {
 
     import x = m.c;
 >x : typeof c
->m : c
+>m : typeof m
 >c : c
 
     export var d = new x(); // emit the type as m.c
@@ -24,7 +24,7 @@ module m2 {
 
     export import x = m.c;
 >x : typeof c
->m : c
+>m : typeof m
 >c : c
 
     export var d = new x(); // emit the type as x

tests/baselines/reference/declarationEmit_array-types-from-generic-array-usage.types

@@ -1,5 +1,5 @@
 === tests/cases/compiler/declarationEmit_array-types-from-generic-array-usage.ts ===
 interface A extends Array<string> { }
 >A : A
->Array : Array
+>Array : T[]
 

tests/baselines/reference/declarationEmit_nameConflicts.types

@@ -23,12 +23,12 @@ export module M {
 
     export import a = M.f;
 >a : () => void
->M : () => void
+>M : typeof M
 >f : () => void
 
     export import b = M.C;
 >b : typeof C
->M : C
+>M : typeof M
 >C : C
 
     export import c = N;
@@ -61,8 +61,8 @@ export module M.P {
     }
     export import im = M.P.f;
 >im : () => void
->M : () => void
->P : () => void
+>M : typeof M
+>P : typeof P
 >f : () => void
 
     export var a = M.a; // emitted incorrectly as typeof f
@@ -120,7 +120,7 @@ export module M.Q {
     export interface b extends M.b { } // ok
 >b : b
 >M : M
->b : b
+>b : C
 
     export interface I extends M.c.I { } // ok
 >I : I

tests/baselines/reference/declareDottedExtend.types

@@ -9,7 +9,7 @@ declare module A.B
 
 import ab = A.B;
 >ab : typeof B
->A : typeof B
+>A : typeof A
 >B : typeof B
 
 class D extends ab.C{ }

tests/baselines/reference/dependencyViaImportAlias.types

@@ -4,7 +4,7 @@ import a = require('A');
 
 import A = a.A;
 >A : typeof A
->a : A
+>a : typeof "tests/cases/compiler/A"
 >A : A
 
 export = A;

tests/baselines/reference/dottedModuleName2.types

@@ -63,13 +63,13 @@ module M
  
     import X2 = A.B;
 >X2 : typeof B
->A : typeof B
+>A : typeof A
 >B : typeof B
  
     import X3 = A.B.C;
 >X3 : typeof C
->A : typeof C
->B : typeof C
+>A : typeof A
+>B : typeof B
 >C : typeof C
  
 }

tests/baselines/reference/duplicateOverloadInTypeAugmentation1.types

@@ -40,7 +40,7 @@ interface Array<T> {
 }
 var a: Array<string>;
 >a : string[]
->Array : Array
+>Array : T[]
 
 var r5 = a.reduce((x, y) => x + y);
 >r5 : string

tests/baselines/reference/duplicateVarAndImport.types

@@ -9,5 +9,5 @@ module M { }
 
 import a = M;
 >a : any
->M : any
+>M : M
 

tests/baselines/reference/escapedIdentifiers.types

@@ -160,7 +160,7 @@ interfaceType1Object1.bar1 = 2;
 var interfaceType1Object2 = <interfaceType\u0031>{ bar1: 0 };
 >interfaceType1Object2 : interfaceType1
 ><interfaceType\u0031>{ bar1: 0 } : interfaceType1
->interfaceType\u0031 : interfaceType\u0031
+>interfaceType\u0031 : interfaceType1
 >{ bar1: 0 } : { bar1: number; }
 >bar1 : number
 
@@ -173,7 +173,7 @@ interfaceType1Object2.bar1 = 2;
 var interfaceType2Object1 = <interfaceType2>{ bar2: 0 };
 >interfaceType2Object1 : interfaceType\u0032
 ><interfaceType2>{ bar2: 0 } : interfaceType\u0032
->interfaceType2 : interfaceType2
+>interfaceType2 : interfaceType\u0032
 >{ bar2: 0 } : { bar2: number; }
 >bar2 : number
 

tests/baselines/reference/everyTypeWithAnnotationAndInitializer.types

@@ -24,13 +24,13 @@ class D<T>{
 
     recurse: D<T>;
 >recurse : D<T>
->D : D
+>D : D<T>
 >T : T
 
     wrapped: D<D<T>>
 >wrapped : D<D<T>>
->D : D
->D : D
+>D : D<T>
+>D : D<T>
 >T : T
 }
 
@@ -100,7 +100,7 @@ var aClass: C = new C();
 
 var aGenericClass: D<string> = new D<string>();
 >aGenericClass : D<string>
->D : D
+>D : D<T>
 >new D<string>() : D<string>
 >D : typeof D
 

tests/baselines/reference/everyTypeWithInitializer.types

@@ -24,13 +24,13 @@ class D<T>{
 
     recurse: D<T>;
 >recurse : D<T>
->D : D
+>D : D<T>
 >T : T
 
     wrapped: D<D<T>>
 >wrapped : D<D<T>>
->D : D
->D : D
+>D : D<T>
+>D : D<T>
 >T : T
 }
 

tests/baselines/reference/exportAssignedTypeAsTypeAnnotation.types

@@ -5,7 +5,7 @@ import test = require('exportAssignedTypeAsTypeAnnotation_0');
 
 var t2: test; // should not raise a 'container type' error
 >t2 : x
->test : test
+>test : x
 
 === tests/cases/compiler/exportAssignedTypeAsTypeAnnotation_0.ts ===
 

tests/baselines/reference/exportAssignmentInterface.types

@@ -4,7 +4,7 @@ import I1 = require("exportAssignmentInterface_A");
 
 var i: I1;
 >i : A
->I1 : I1
+>I1 : A
 
 var n: number = i.p1;
 >n : number

tests/baselines/reference/exportAssignmentMergedInterface.types

@@ -4,7 +4,7 @@ import foo = require("./foo_0");
 
 var x: foo;
 >x : Foo
->foo : foo
+>foo : Foo
 
 x("test");
 >x("test") : void

tests/baselines/reference/exportAssignmentOfGenericType1.types

@@ -5,7 +5,7 @@ import q = require("exportAssignmentOfGenericType1_0");
 
 class M extends q<string> { }
 >M : M
->q : q
+>q : T<X>
 
 var m: M;
 >m : M

tests/baselines/reference/exportImport.types

@@ -5,7 +5,7 @@ import e = require('./exporter');
 export function w(): e.w { // Should be OK
 >w : () => Widget1
 >e : e
->w : w
+>w : Widget1
 
     return new e.w();
 >new e.w() : Widget1

tests/baselines/reference/exportImportAlias.types

@@ -92,7 +92,7 @@ module Z {
     // 'y' should be a fundule here
     export import y = X.Y;
 >y : typeof Y
->X : typeof Y
+>X : typeof X
 >Y : typeof Y
 }
 
@@ -147,7 +147,7 @@ module M {
 
     export import D = K.L;
 >D : typeof L
->K : L
+>K : typeof K
 >L : L
 }
 

tests/baselines/reference/exportImportAndClodule.types

@@ -30,7 +30,7 @@ module M {
 
     export import D = K.L;
 >D : typeof L
->K : L
+>K : typeof K
 >L : L
 }
 var o: { name: string };

tests/baselines/reference/exportImportNonInstantiatedModule2.types

@@ -5,7 +5,7 @@ import e = require('./exporter');
 export function w(): e.w { // Should be OK
 >w : () => Widget1
 >e : e
->w : w
+>w : Widget1
 
     return {name: 'value' };
 >{name: 'value' } : { name: string; }

tests/baselines/reference/exportedInterfaceInaccessibleInCallbackInModule.types

@@ -29,14 +29,14 @@ export declare class TPromise<V> {
 >success : (value: V) => TPromise<U>
 >value : V
 >V : V
->TPromise : TPromise
+>TPromise : TPromise<V>
 >U : U
 >error : (err: any) => TPromise<U>
 >err : any
->TPromise : TPromise
+>TPromise : TPromise<V>
 >U : U
 >progress : ProgressCallback
 >ProgressCallback : ProgressCallback
->TPromise : TPromise
+>TPromise : TPromise<V>
 >U : U
 }

tests/baselines/reference/extendedInterfaceGenericType.types

@@ -7,23 +7,23 @@ interface Alpha<T> {
 >takesArgOfT : (arg: T) => Alpha<T>
 >arg : T
 >T : T
->Alpha : Alpha
+>Alpha : Alpha<T>
 >T : T
 
     makeBetaOfNumber(): Beta<number>;
 >makeBetaOfNumber : () => Beta<number>
->Beta : Beta
+>Beta : Beta<T>
 }
 interface Beta<T> extends Alpha<T> {
 >Beta : Beta<T>
 >T : T
->Alpha : Alpha
+>Alpha : Alpha<T>
 >T : T
 }
 
 var alpha: Alpha<number>;
 >alpha : Alpha<number>
->Alpha : Alpha
+>Alpha : Alpha<T>
 
 var betaOfNumber = alpha.makeBetaOfNumber();
 >betaOfNumber : Beta<number>

tests/baselines/reference/externalModuleAssignToVar.types

@@ -20,7 +20,7 @@ import ext2 = require('externalModuleAssignToVar_core_require2');
 
 var y2: new() => ext2 = ext2;
 >y2 : new () => C
->ext2 : ext2
+>ext2 : C
 >ext2 : typeof C
 
 y2 = ext2; // ok
@@ -33,7 +33,7 @@ import ext3 = require('externalModuleAssignToVar_ext');
 
 var y3: new () => ext3 = ext3;
 >y3 : new () => D
->ext3 : ext3
+>ext3 : D
 >ext3 : typeof D
 
 y3 = ext3; // ok

tests/baselines/reference/externalModuleQualification.types

@@ -23,7 +23,7 @@ class NavigateAction {
     f(editor: DiffEditor<any, any, any>) {
 >f : (editor: DiffEditor<any, any, any>) => void
 >editor : DiffEditor<any, any, any>
->DiffEditor : DiffEditor
+>DiffEditor : DiffEditor<A, B, C>
     }
 }
 

tests/baselines/reference/forStatements.types

@@ -24,13 +24,13 @@ class D<T>{
 
     recurse: D<T>;
 >recurse : D<T>
->D : D
+>D : D<T>
 >T : T
 
     wrapped: D<D<T>>
 >wrapped : D<D<T>>
->D : D
->D : D
+>D : D<T>
+>D : D<T>
 >T : T
 }
 
@@ -100,7 +100,7 @@ for(var aClass: C = new C();;){}
 
 for(var aGenericClass: D<string> = new D<string>();;){}
 >aGenericClass : D<string>
->D : D
+>D : D<T>
 >new D<string>() : D<string>
 >D : typeof D
 

tests/baselines/reference/functionConstraintSatisfaction.types

@@ -110,7 +110,7 @@ interface I2<T> {
 }
 var i2: I2<string>;
 >i2 : I2<string>
->I2 : I2
+>I2 : I2<T>
 
 class C2<T> {
 >C2 : C2<T>

tests/baselines/reference/functionConstraintSatisfaction3.types

@@ -91,7 +91,7 @@ interface I2<T> {
 }
 var i2: I2<string>;
 >i2 : I2<string>
->I2 : I2
+>I2 : I2<T>
 
 class C2<T> {
 >C2 : C2<T>

tests/baselines/reference/functionLiteralForOverloads2.types

@@ -64,13 +64,13 @@ var f3: {
     new<T>(x: string): D<T>;
 >T : T
 >x : string
->D : D
+>D : D<T>
 >T : T
 
     new<T>(x: number): D<T>;
 >T : T
 >x : number
->D : D
+>D : D<T>
 >T : T
 
 } = D;

tests/baselines/reference/functionOverloadsRecursiveGenericReturnType.types

@@ -14,7 +14,7 @@ class A<U>{
 
     GetEnumerator: () => B<U>;
 >GetEnumerator : () => B<U>
->B : B
+>B : B<V>
 >U : U
 }
 
@@ -23,7 +23,7 @@ function Choice<T>(args: T[]): A<T>;
 >T : T
 >args : T[]
 >T : T
->A : A
+>A : A<U>
 >T : T
 
 function Choice<T>(...v_args: T[]): A<T>;
@@ -31,14 +31,14 @@ function Choice<T>(...v_args: T[]): A<T>;
 >T : T
 >v_args : T[]
 >T : T
->A : A
+>A : A<U>
 >T : T
 
 function Choice<T>(...v_args: any[]): A<T>{
 >Choice : { <T>(args: T[]): A<T>; <T>(...v_args: T[]): A<T>; }
 >T : T
 >v_args : any[]
->A : A
+>A : A<U>
 >T : T
 
     return new A<T>();

tests/baselines/reference/funduleUsedAcrossFileBoundary.types

@@ -26,7 +26,7 @@ function promiseWithCancellation<T>(promise: Q.Promise<T>) {
 >T : T
 >promise : Promise<T>
 >Q : Q
->Promise : Promise
+>Promise : Promise<T>
 >T : T
 
     var deferred = Q.defer<T>(); // used to be an error

tests/baselines/reference/generatedContextualTyping.types

@@ -90,7 +90,7 @@ var x7: Base[] = [d1, d2];
 
 var x8: Array<Base> = [d1, d2];
 >x8 : Base[]
->Array : Array
+>Array : T[]
 >Base : Base
 >[d1, d2] : Base[]
 >d1 : Derived1
@@ -125,7 +125,7 @@ var x11: (s: Base[]) => any = n => { var n: Base[]; return null; };
 
 var x12: Genric<Base> = { func: n => { return [d1, d2]; } };
 >x12 : Genric<Base>
->Genric : Genric
+>Genric : Genric<T>
 >Base : Base
 >{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => {}[]; }
 >func : (n: Base[]) => {}[]
@@ -202,7 +202,7 @@ class x19 { member: Base[] = [d1, d2] }
 class x20 { member: Array<Base> = [d1, d2] }
 >x20 : x20
 >member : Base[]
->Array : Array
+>Array : T[]
 >Base : Base
 >[d1, d2] : Base[]
 >d1 : Derived1
@@ -241,7 +241,7 @@ class x23 { member: (s: Base[]) => any = n => { var n: Base[]; return null; } }
 class x24 { member: Genric<Base> = { func: n => { return [d1, d2]; } } }
 >x24 : x24
 >member : Genric<Base>
->Genric : Genric
+>Genric : Genric<T>
 >Base : Base
 >{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => {}[]; }
 >func : (n: Base[]) => {}[]
@@ -318,7 +318,7 @@ class x31 { private member: Base[] = [d1, d2] }
 class x32 { private member: Array<Base> = [d1, d2] }
 >x32 : x32
 >member : Base[]
->Array : Array
+>Array : T[]
 >Base : Base
 >[d1, d2] : Base[]
 >d1 : Derived1
@@ -357,7 +357,7 @@ class x35 { private member: (s: Base[]) => any = n => { var n: Base[]; return nu
 class x36 { private member: Genric<Base> = { func: n => { return [d1, d2]; } } }
 >x36 : x36
 >member : Genric<Base>
->Genric : Genric
+>Genric : Genric<T>
 >Base : Base
 >{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => {}[]; }
 >func : (n: Base[]) => {}[]
@@ -434,7 +434,7 @@ class x43 { public member: Base[] = [d1, d2] }
 class x44 { public member: Array<Base> = [d1, d2] }
 >x44 : x44
 >member : Base[]
->Array : Array
+>Array : T[]
 >Base : Base
 >[d1, d2] : Base[]
 >d1 : Derived1
@@ -473,7 +473,7 @@ class x47 { public member: (s: Base[]) => any = n => { var n: Base[]; return nul
 class x48 { public member: Genric<Base> = { func: n => { return [d1, d2]; } } }
 >x48 : x48
 >member : Genric<Base>
->Genric : Genric
+>Genric : Genric<T>
 >Base : Base
 >{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => {}[]; }
 >func : (n: Base[]) => {}[]
@@ -550,7 +550,7 @@ class x55 { static member: Base[] = [d1, d2] }
 class x56 { static member: Array<Base> = [d1, d2] }
 >x56 : x56
 >member : Base[]
->Array : Array
+>Array : T[]
 >Base : Base
 >[d1, d2] : Base[]
 >d1 : Derived1
@@ -589,7 +589,7 @@ class x59 { static member: (s: Base[]) => any = n => { var n: Base[]; return nul
 class x60 { static member: Genric<Base> = { func: n => { return [d1, d2]; } } }
 >x60 : x60
 >member : Genric<Base>
->Genric : Genric
+>Genric : Genric<T>
 >Base : Base
 >{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => {}[]; }
 >func : (n: Base[]) => {}[]
@@ -666,7 +666,7 @@ class x67 { private static member: Base[] = [d1, d2] }
 class x68 { private static member: Array<Base> = [d1, d2] }
 >x68 : x68
 >member : Base[]
->Array : Array
+>Array : T[]
 >Base : Base
 >[d1, d2] : Base[]
 >d1 : Derived1
@@ -705,7 +705,7 @@ class x71 { private static member: (s: Base[]) => any = n => { var n: Base[]; re
 class x72 { private static member: Genric<Base> = { func: n => { return [d1, d2]; } } }
 >x72 : x72
 >member : Genric<Base>
->Genric : Genric
+>Genric : Genric<T>
 >Base : Base
 >{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => {}[]; }
 >func : (n: Base[]) => {}[]
@@ -782,7 +782,7 @@ class x79 { public static member: Base[] = [d1, d2] }
 class x80 { public static member: Array<Base> = [d1, d2] }
 >x80 : x80
 >member : Base[]
->Array : Array
+>Array : T[]
 >Base : Base
 >[d1, d2] : Base[]
 >d1 : Derived1
@@ -821,7 +821,7 @@ class x83 { public static member: (s: Base[]) => any = n => { var n: Base[]; ret
 class x84 { public static member: Genric<Base> = { func: n => { return [d1, d2]; } } }
 >x84 : x84
 >member : Genric<Base>
->Genric : Genric
+>Genric : Genric<T>
 >Base : Base
 >{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => {}[]; }
 >func : (n: Base[]) => {}[]
@@ -898,7 +898,7 @@ class x91 { constructor(parm: Base[] = [d1, d2]) { } }
 class x92 { constructor(parm: Array<Base> = [d1, d2]) { } }
 >x92 : x92
 >parm : Base[]
->Array : Array
+>Array : T[]
 >Base : Base
 >[d1, d2] : Base[]
 >d1 : Derived1
@@ -937,7 +937,7 @@ class x95 { constructor(parm: (s: Base[]) => any = n => { var n: Base[]; return
 class x96 { constructor(parm: Genric<Base> = { func: n => { return [d1, d2]; } }) { } }
 >x96 : x96
 >parm : Genric<Base>
->Genric : Genric
+>Genric : Genric<T>
 >Base : Base
 >{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => {}[]; }
 >func : (n: Base[]) => {}[]
@@ -1014,7 +1014,7 @@ class x103 { constructor(public parm: Base[] = [d1, d2]) { } }
 class x104 { constructor(public parm: Array<Base> = [d1, d2]) { } }
 >x104 : x104
 >parm : Base[]
->Array : Array
+>Array : T[]
 >Base : Base
 >[d1, d2] : Base[]
 >d1 : Derived1
@@ -1053,7 +1053,7 @@ class x107 { constructor(public parm: (s: Base[]) => any = n => { var n: Base[];
 class x108 { constructor(public parm: Genric<Base> = { func: n => { return [d1, d2]; } }) { } }
 >x108 : x108
 >parm : Genric<Base>
->Genric : Genric
+>Genric : Genric<T>
 >Base : Base
 >{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => {}[]; }
 >func : (n: Base[]) => {}[]
@@ -1130,7 +1130,7 @@ class x115 { constructor(private parm: Base[] = [d1, d2]) { } }
 class x116 { constructor(private parm: Array<Base> = [d1, d2]) { } }
 >x116 : x116
 >parm : Base[]
->Array : Array
+>Array : T[]
 >Base : Base
 >[d1, d2] : Base[]
 >d1 : Derived1
@@ -1169,7 +1169,7 @@ class x119 { constructor(private parm: (s: Base[]) => any = n => { var n: Base[]
 class x120 { constructor(private parm: Genric<Base> = { func: n => { return [d1, d2]; } }) { } }
 >x120 : x120
 >parm : Genric<Base>
->Genric : Genric
+>Genric : Genric<T>
 >Base : Base
 >{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => {}[]; }
 >func : (n: Base[]) => {}[]
@@ -1246,7 +1246,7 @@ function x127(parm: Base[] = [d1, d2]) { }
 function x128(parm: Array<Base> = [d1, d2]) { }
 >x128 : (parm?: Base[]) => void
 >parm : Base[]
->Array : Array
+>Array : T[]
 >Base : Base
 >[d1, d2] : Base[]
 >d1 : Derived1
@@ -1285,7 +1285,7 @@ function x131(parm: (s: Base[]) => any = n => { var n: Base[]; return null; }) {
 function x132(parm: Genric<Base> = { func: n => { return [d1, d2]; } }) { }
 >x132 : (parm?: Genric<Base>) => void
 >parm : Genric<Base>
->Genric : Genric
+>Genric : Genric<T>
 >Base : Base
 >{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => {}[]; }
 >func : (n: Base[]) => {}[]
@@ -1354,7 +1354,7 @@ function x139(): Base[] { return [d1, d2]; }
 
 function x140(): Array<Base> { return [d1, d2]; }
 >x140 : () => Base[]
->Array : Array
+>Array : T[]
 >Base : Base
 >[d1, d2] : Base[]
 >d1 : Derived1
@@ -1389,7 +1389,7 @@ function x143(): (s: Base[]) => any { return n => { var n: Base[]; return null;
 
 function x144(): Genric<Base> { return { func: n => { return [d1, d2]; } }; }
 >x144 : () => Genric<Base>
->Genric : Genric
+>Genric : Genric<T>
 >Base : Base
 >{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => {}[]; }
 >func : (n: Base[]) => {}[]
@@ -1487,7 +1487,7 @@ function x151(): Base[] { return [d1, d2]; return [d1, d2]; }
 
 function x152(): Array<Base> { return [d1, d2]; return [d1, d2]; }
 >x152 : () => Base[]
->Array : Array
+>Array : T[]
 >Base : Base
 >[d1, d2] : Base[]
 >d1 : Derived1
@@ -1537,7 +1537,7 @@ function x155(): (s: Base[]) => any { return n => { var n: Base[]; return null;
 
 function x156(): Genric<Base> { return { func: n => { return [d1, d2]; } }; return { func: n => { return [d1, d2]; } }; }
 >x156 : () => Genric<Base>
->Genric : Genric
+>Genric : Genric<T>
 >Base : Base
 >{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => {}[]; }
 >func : (n: Base[]) => {}[]
@@ -1620,7 +1620,7 @@ var x163: () => Base[] = () => { return [d1, d2]; };
 
 var x164: () => Array<Base> = () => { return [d1, d2]; };
 >x164 : () => Base[]
->Array : Array
+>Array : T[]
 >Base : Base
 >() => { return [d1, d2]; } : () => Base[]
 >[d1, d2] : Base[]
@@ -1659,7 +1659,7 @@ var x167: () => (s: Base[]) => any = () => { return n => { var n: Base[]; return
 
 var x168: () => Genric<Base> = () => { return { func: n => { return [d1, d2]; } }; };
 >x168 : () => Genric<Base>
->Genric : Genric
+>Genric : Genric<T>
 >Base : Base
 >() => { return { func: n => { return [d1, d2]; } }; } : () => { func: (n: Base[]) => {}[]; }
 >{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => {}[]; }
@@ -1736,7 +1736,7 @@ var x175: () => Base[] = function() { return [d1, d2]; };
 
 var x176: () => Array<Base> = function() { return [d1, d2]; };
 >x176 : () => Base[]
->Array : Array
+>Array : T[]
 >Base : Base
 >function() { return [d1, d2]; } : () => Base[]
 >[d1, d2] : Base[]
@@ -1775,7 +1775,7 @@ var x179: () => (s: Base[]) => any = function() { return n => { var n: Base[]; r
 
 var x180: () => Genric<Base> = function() { return { func: n => { return [d1, d2]; } }; };
 >x180 : () => Genric<Base>
->Genric : Genric
+>Genric : Genric<T>
 >Base : Base
 >function() { return { func: n => { return [d1, d2]; } }; } : () => { func: (n: Base[]) => {}[]; }
 >{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => {}[]; }
@@ -1853,7 +1853,7 @@ module x187 { var t: Base[] = [d1, d2]; }
 module x188 { var t: Array<Base> = [d1, d2]; }
 >x188 : typeof x188
 >t : Base[]
->Array : Array
+>Array : T[]
 >Base : Base
 >[d1, d2] : Base[]
 >d1 : Derived1
@@ -1892,7 +1892,7 @@ module x191 { var t: (s: Base[]) => any = n => { var n: Base[]; return null; };
 module x192 { var t: Genric<Base> = { func: n => { return [d1, d2]; } }; }
 >x192 : typeof x192
 >t : Genric<Base>
->Genric : Genric
+>Genric : Genric<T>
 >Base : Base
 >{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => {}[]; }
 >func : (n: Base[]) => {}[]
@@ -1969,7 +1969,7 @@ module x199 { export var t: Base[] = [d1, d2]; }
 module x200 { export var t: Array<Base> = [d1, d2]; }
 >x200 : typeof x200
 >t : Base[]
->Array : Array
+>Array : T[]
 >Base : Base
 >[d1, d2] : Base[]
 >d1 : Derived1
@@ -2008,7 +2008,7 @@ module x203 { export var t: (s: Base[]) => any = n => { var n: Base[]; return nu
 module x204 { export var t: Genric<Base> = { func: n => { return [d1, d2]; } }; }
 >x204 : typeof x204
 >t : Genric<Base>
->Genric : Genric
+>Genric : Genric<T>
 >Base : Base
 >{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => {}[]; }
 >func : (n: Base[]) => {}[]
@@ -2067,7 +2067,7 @@ var x211 = <Base[]>[d1, d2];
 var x212 = <Array<Base>>[d1, d2];
 >x212 : Base[]
 ><Array<Base>>[d1, d2] : Base[]
->Array : Array
+>Array : T[]
 >Base : Base
 >[d1, d2] : Base[]
 >d1 : Derived1
@@ -2096,7 +2096,7 @@ var x214 = <{n: Base[]; } >{ n: [d1, d2] };
 var x216 = <Genric<Base>>{ func: n => { return [d1, d2]; } };
 >x216 : Genric<Base>
 ><Genric<Base>>{ func: n => { return [d1, d2]; } } : Genric<Base>
->Genric : Genric
+>Genric : Genric<T>
 >Base : Base
 >{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => {}[]; }
 >func : (n: Base[]) => {}[]
@@ -2172,7 +2172,7 @@ var x222 = (<Array<Base>>undefined) || [d1, d2];
 >(<Array<Base>>undefined) || [d1, d2] : Base[]
 >(<Array<Base>>undefined) : Base[]
 ><Array<Base>>undefined : Base[]
->Array : Array
+>Array : T[]
 >Base : Base
 >undefined : undefined
 >[d1, d2] : Base[]
@@ -2278,7 +2278,7 @@ var x231: Base[]; x231 = [d1, d2];
 
 var x232: Array<Base>; x232 = [d1, d2];
 >x232 : Base[]
->Array : Array
+>Array : T[]
 >Base : Base
 >x232 = [d1, d2] : Base[]
 >x232 : Base[]
@@ -2321,7 +2321,7 @@ var x235: (s: Base[]) => any; x235 = n => { var n: Base[]; return null; };
 
 var x236: Genric<Base>; x236 = { func: n => { return [d1, d2]; } };
 >x236 : Genric<Base>
->Genric : Genric
+>Genric : Genric<T>
 >Base : Base
 >x236 = { func: n => { return [d1, d2]; } } : { func: (n: Base[]) => {}[]; }
 >x236 : Genric<Base>
@@ -2414,7 +2414,7 @@ var x243: { n: Base[]; } = { n: [d1, d2] };
 var x244: { n: Array<Base>; } = { n: [d1, d2] };
 >x244 : { n: Base[]; }
 >n : Base[]
->Array : Array
+>Array : T[]
 >Base : Base
 >{ n: [d1, d2] } : { n: Base[]; }
 >n : Base[]
@@ -2461,7 +2461,7 @@ var x247: { n: (s: Base[]) => any; } = { n: n => { var n: Base[]; return null; }
 var x248: { n: Genric<Base>; } = { n: { func: n => { return [d1, d2]; } } };
 >x248 : { n: Genric<Base>; }
 >n : Genric<Base>
->Genric : Genric
+>Genric : Genric<T>
 >Base : Base
 >{ n: { func: n => { return [d1, d2]; } } } : { n: { func: (n: Base[]) => {}[]; }; }
 >n : { func: (n: Base[]) => {}[]; }
@@ -2511,7 +2511,7 @@ var x255: Base[][] = [[d1, d2]];
 
 var x256: Array<Base>[] = [[d1, d2]];
 >x256 : Base[][]
->Array : Array
+>Array : T[]
 >Base : Base
 >[[d1, d2]] : Base[][]
 >[d1, d2] : Base[]
@@ -2540,7 +2540,7 @@ var x258: {n: Base[]; } [] = [{ n: [d1, d2] }];
 
 var x260: Genric<Base>[] = [{ func: n => { return [d1, d2]; } }];
 >x260 : Genric<Base>[]
->Genric : Genric
+>Genric : Genric<T>
 >Base : Base
 >[{ func: n => { return [d1, d2]; } }] : Genric<Base>[]
 >{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => {}[]; }
@@ -2604,7 +2604,7 @@ var x265: Base[] = [d1, d2] || undefined;
 
 var x266: Array<Base> = [d1, d2] || undefined;
 >x266 : Base[]
->Array : Array
+>Array : T[]
 >Base : Base
 >[d1, d2] || undefined : Base[]
 >[d1, d2] : Base[]
@@ -2687,7 +2687,7 @@ var x273: Base[] = undefined || [d1, d2];
 
 var x274: Array<Base> = undefined || [d1, d2];
 >x274 : Base[]
->Array : Array
+>Array : T[]
 >Base : Base
 >undefined || [d1, d2] : Base[]
 >undefined : undefined
@@ -2786,7 +2786,7 @@ var x281: Base[] = [d1, d2] || [d1, d2];
 
 var x282: Array<Base> = [d1, d2] || [d1, d2];
 >x282 : Base[]
->Array : Array
+>Array : T[]
 >Base : Base
 >[d1, d2] || [d1, d2] : Base[]
 >[d1, d2] : Base[]
@@ -2919,7 +2919,7 @@ var x291: Base[] = true ? [d1, d2] : [d1, d2];
 
 var x292: Array<Base> = true ? [d1, d2] : [d1, d2];
 >x292 : Base[]
->Array : Array
+>Array : T[]
 >Base : Base
 >true ? [d1, d2] : [d1, d2] : Base[]
 >[d1, d2] : Base[]
@@ -2973,7 +2973,7 @@ var x295: (s: Base[]) => any = true ? n => { var n: Base[]; return null; } : n =
 
 var x296: Genric<Base> = true ? { func: n => { return [d1, d2]; } } : { func: n => { return [d1, d2]; } };
 >x296 : Genric<Base>
->Genric : Genric
+>Genric : Genric<T>
 >Base : Base
 >true ? { func: n => { return [d1, d2]; } } : { func: n => { return [d1, d2]; } } : Genric<Base>
 >{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => {}[]; }
@@ -3064,7 +3064,7 @@ var x303: Base[] = true ? undefined : [d1, d2];
 
 var x304: Array<Base> = true ? undefined : [d1, d2];
 >x304 : Base[]
->Array : Array
+>Array : T[]
 >Base : Base
 >true ? undefined : [d1, d2] : Base[]
 >undefined : undefined
@@ -3107,7 +3107,7 @@ var x307: (s: Base[]) => any = true ? undefined : n => { var n: Base[]; return n
 
 var x308: Genric<Base> = true ? undefined : { func: n => { return [d1, d2]; } };
 >x308 : Genric<Base>
->Genric : Genric
+>Genric : Genric<T>
 >Base : Base
 >true ? undefined : { func: n => { return [d1, d2]; } } : Genric<Base>
 >undefined : undefined
@@ -3192,7 +3192,7 @@ var x315: Base[] = true ? [d1, d2] : undefined;
 
 var x316: Array<Base> = true ? [d1, d2] : undefined;
 >x316 : Base[]
->Array : Array
+>Array : T[]
 >Base : Base
 >true ? [d1, d2] : undefined : Base[]
 >[d1, d2] : Base[]
@@ -3235,7 +3235,7 @@ var x319: (s: Base[]) => any = true ? n => { var n: Base[]; return null; } : und
 
 var x320: Genric<Base> = true ? { func: n => { return [d1, d2]; } } : undefined;
 >x320 : Genric<Base>
->Genric : Genric
+>Genric : Genric<T>
 >Base : Base
 >true ? { func: n => { return [d1, d2]; } } : undefined : Genric<Base>
 >{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => {}[]; }
@@ -3328,7 +3328,7 @@ function x327(n: Base[]) { }; x327([d1, d2]);
 function x328(n: Array<Base>) { }; x328([d1, d2]);
 >x328 : (n: Base[]) => void
 >n : Base[]
->Array : Array
+>Array : T[]
 >Base : Base
 >x328([d1, d2]) : void
 >x328 : (n: Base[]) => void
@@ -3375,7 +3375,7 @@ function x331(n: (s: Base[]) => any) { }; x331(n => { var n: Base[]; return null
 function x332(n: Genric<Base>) { }; x332({ func: n => { return [d1, d2]; } });
 >x332 : (n: Genric<Base>) => void
 >n : Genric<Base>
->Genric : Genric
+>Genric : Genric<T>
 >Base : Base
 >x332({ func: n => { return [d1, d2]; } }) : void
 >x332 : (n: Genric<Base>) => void
@@ -3483,7 +3483,7 @@ var x340 = (n: Array<Base>) => n; x340([d1, d2]);
 >x340 : (n: Base[]) => Base[]
 >(n: Array<Base>) => n : (n: Base[]) => Base[]
 >n : Base[]
->Array : Array
+>Array : T[]
 >Base : Base
 >n : Base[]
 >x340([d1, d2]) : Base[]
@@ -3538,7 +3538,7 @@ var x344 = (n: Genric<Base>) => n; x344({ func: n => { return [d1, d2]; } });
 >x344 : (n: Genric<Base>) => Genric<Base>
 >(n: Genric<Base>) => n : (n: Genric<Base>) => Genric<Base>
 >n : Genric<Base>
->Genric : Genric
+>Genric : Genric<T>
 >Base : Base
 >n : Genric<Base>
 >x344({ func: n => { return [d1, d2]; } }) : Genric<Base>
@@ -3640,7 +3640,7 @@ var x352 = function(n: Array<Base>) { }; x352([d1, d2]);
 >x352 : (n: Base[]) => void
 >function(n: Array<Base>) { } : (n: Base[]) => void
 >n : Base[]
->Array : Array
+>Array : T[]
 >Base : Base
 >x352([d1, d2]) : void
 >x352 : (n: Base[]) => void
@@ -3691,7 +3691,7 @@ var x356 = function(n: Genric<Base>) { }; x356({ func: n => { return [d1, d2]; }
 >x356 : (n: Genric<Base>) => void
 >function(n: Genric<Base>) { } : (n: Genric<Base>) => void
 >n : Genric<Base>
->Genric : Genric
+>Genric : Genric<T>
 >Base : Base
 >x356({ func: n => { return [d1, d2]; } }) : void
 >x356 : (n: Genric<Base>) => void

tests/baselines/reference/genericAndNonGenericOverload1.types

@@ -16,7 +16,7 @@ interface callable2<T> {
 }
 var c2: callable2<number>;
 >c2 : callable2<number>
->callable2 : callable2
+>callable2 : callable2<T>
 
 c2<string>(1);
 >c2<string>(1) : string

tests/baselines/reference/genericArgumentCallSigAssignmentCompat.types

@@ -24,7 +24,7 @@ module Underscore {
 >list : T[]
 >T : T
 >iterator : Iterator<T, boolean>
->Iterator : Iterator
+>Iterator : Iterator<T, U>
 >T : T
 >context : any
 

tests/baselines/reference/genericBaseClassLiteralProperty.types

@@ -14,7 +14,7 @@ class BaseClass<T> {
 
 class SubClass extends BaseClass<number> {
 >SubClass : SubClass
->BaseClass : BaseClass
+>BaseClass : BaseClass<T>
 
     public Error(): void {
 >Error : () => void

tests/baselines/reference/genericBaseClassLiteralProperty2.types

@@ -24,7 +24,7 @@ class BaseCollection2<TItem extends CollectionItem2> {
 
 class DataView2 extends BaseCollection2<CollectionItem2> {
 >DataView2 : DataView2
->BaseCollection2 : BaseCollection2
+>BaseCollection2 : BaseCollection2<TItem>
 >CollectionItem2 : CollectionItem2
 
     fillItems(item: CollectionItem2) {

tests/baselines/reference/genericCallTypeArgumentInference.types

@@ -306,7 +306,7 @@ interface I<T, U> {
 
 var i: I<string, number>;
 >i : I<string, number>
->I : I
+>I : I<T, U>
 
 var r4 = i.foo('', 1); // string
 >r4 : string

tests/baselines/reference/genericCallWithConstraintsTypeArgumentInference.types

@@ -406,7 +406,7 @@ interface I<T extends Base, U extends Derived> {
 
 var i: I<Base, Derived>;
 >i : I<Base, Derived>
->I : I
+>I : I<T, U>
 >Base : Base
 >Derived : Derived
 

tests/baselines/reference/genericCallWithFunctionTypedArguments2.types

@@ -39,7 +39,7 @@ var i: I;
 
 var i2: I2<string>;
 >i2 : I2<string>
->I2 : I2
+>I2 : I2<T>
 
 var a: {
 >a : new <T>(x: T) => T

tests/baselines/reference/genericCallWithObjectTypeArgs.types

@@ -26,10 +26,10 @@ function foo<T>(t: X<T>, t2: X<T>) {
 >foo : <T>(t: X<T>, t2: X<T>) => T
 >T : T
 >t : X<T>
->X : X
+>X : X<T>
 >T : T
 >t2 : X<T>
->X : X
+>X : X<T>
 >T : T
 
     var x: T;

tests/baselines/reference/genericCallWithObjectTypeArgs2.types

@@ -117,7 +117,7 @@ interface I<T, U> {
 
 var i: I<Base, Derived>;
 >i : I<Base, Derived>
->I : I
+>I : I<T, U>
 >Base : Base
 >Derived : Derived
 

tests/baselines/reference/genericCallWithObjectTypeArgsAndConstraints.types

@@ -33,10 +33,10 @@ function foo<T extends { x: string }>(t: X<T>, t2: X<T>) {
 >T : T
 >x : string
 >t : X<T>
->X : X
+>X : X<T>
 >T : T
 >t2 : X<T>
->X : X
+>X : X<T>
 >T : T
 
     var x: T;
@@ -78,10 +78,10 @@ function foo2<T extends C>(t: X<T>, t2: X<T>) {
 >T : T
 >C : C
 >t : X<T>
->X : X
+>X : X<T>
 >T : T
 >t2 : X<T>
->X : X
+>X : X<T>
 >T : T
 
     var x: T;

tests/baselines/reference/genericCallWithObjectTypeArgsAndConstraints2.types

@@ -71,7 +71,7 @@ function f2<T extends Base>(x: I<T>) {
 >T : T
 >Base : Base
 >x : I<T>
->I : I
+>I : I<T>
 >T : T
 
     var r: T;
@@ -83,7 +83,7 @@ function f2<T extends Base>(x: I<T>) {
 }
 var i: I<Derived>;
 >i : I<Derived>
->I : I
+>I : I<T>
 >Derived : Derived
 
 var r3 = f2(i);

tests/baselines/reference/genericCallbacksAndClassHierarchy.types

@@ -18,7 +18,7 @@ module M {
 
         public value: I<T>;
 >value : I<T>
->I : I
+>I : I<T>
 >T : T
     }
     export class A<T> {
@@ -31,8 +31,8 @@ module M {
     export class B<T> extends C1<A<T>> { }
 >B : B<T>
 >T : T
->C1 : C1
->A : A
+>C1 : C1<T>
+>A : A<T>
 >T : T
 
     export class D<T> {
@@ -42,20 +42,20 @@ module M {
         _subscribe(viewModel: B<T>): void {
 >_subscribe : (viewModel: B<T>) => void
 >viewModel : B<T>
->B : B
+>B : B<T>
 >T : T
 
             var f = (newValue: A<T>) => { };
 >f : (newValue: A<T>) => void
 >(newValue: A<T>) => { } : (newValue: A<T>) => void
 >newValue : A<T>
->A : A
+>A : A<T>
 >T : T
 
             var v: I<A<T>> = viewModel.value;
 >v : I<A<T>>
->I : I
->A : A
+>I : I<T>
+>A : A<T>
 >T : T
 >viewModel.value : I<A<T>>
 >viewModel : B<T>
@@ -76,7 +76,7 @@ module M {
 >subscribe : (callback: (newValue: A<T>) => void) => any
 >(newValue: A<T>) => { } : (newValue: A<T>) => void
 >newValue : A<T>
->A : A
+>A : A<T>
 >T : T
         }
     }

tests/baselines/reference/genericClassImplementingGenericInterfaceFromAnotherModule.types

@@ -13,7 +13,7 @@ module bar {
 >Foo : Foo<T>
 >T : T
 >foo : foo
->IFoo : IFoo
+>IFoo : IFoo<T>
 >T : T
 }
 

tests/baselines/reference/genericClassInheritsConstructorFromNonGenericClass.types

@@ -1,7 +1,7 @@
 === tests/cases/compiler/genericClassInheritsConstructorFromNonGenericClass.ts ===
 class A extends B<string> { }
 >A : A
->B : B
+>B : B<U>
 
 class B<U> extends C { }
 >B : B<U>

tests/baselines/reference/genericClassPropertyInheritanceSpecialization.types

@@ -18,7 +18,7 @@ interface KnockoutObservableBase<T> {
 interface KnockoutObservable<T> extends KnockoutObservableBase<T> {
 >KnockoutObservable : KnockoutObservable<T>
 >T : T
->KnockoutObservableBase : KnockoutObservableBase
+>KnockoutObservableBase : KnockoutObservableBase<T>
 >T : T
 
     equalityComparer(a: T, b: T): boolean;
@@ -38,7 +38,7 @@ interface KnockoutObservable<T> extends KnockoutObservableBase<T> {
 interface KnockoutObservableArray<T> extends KnockoutObservable<T[]> {
 >KnockoutObservableArray : KnockoutObservableArray<T>
 >T : T
->KnockoutObservable : KnockoutObservable
+>KnockoutObservable : KnockoutObservable<T>
 >T : T
 
     indexOf(searchElement: T, fromIndex?: number): number;
@@ -126,13 +126,13 @@ interface KnockoutObservableArrayStatic {
 
     fn: KnockoutObservableArray<any>;
 >fn : KnockoutObservableArray<any>
->KnockoutObservableArray : KnockoutObservableArray
+>KnockoutObservableArray : KnockoutObservableArray<T>
 
     <T>(value?: T[]): KnockoutObservableArray<T>;
 >T : T
 >value : T[]
 >T : T
->KnockoutObservableArray : KnockoutObservableArray
+>KnockoutObservableArray : KnockoutObservableArray<T>
 >T : T
 }
 
@@ -158,15 +158,15 @@ module Portal.Controls.Validators {
 
         public message: KnockoutObservable<string>;
 >message : KnockoutObservable<string>
->KnockoutObservable : KnockoutObservable
+>KnockoutObservable : KnockoutObservable<T>
 
         public validationState: KnockoutObservable<number>;
 >validationState : KnockoutObservable<number>
->KnockoutObservable : KnockoutObservable
+>KnockoutObservable : KnockoutObservable<T>
 
         public validate: KnockoutObservable<TValue>;
 >validate : KnockoutObservable<TValue>
->KnockoutObservable : KnockoutObservable
+>KnockoutObservable : KnockoutObservable<T>
 >TValue : TValue
 
         constructor(message?: string) { }
@@ -194,7 +194,7 @@ module PortalFx.ViewModels.Controls.Validators {
 >Portal : Portal
 >Controls : Controls
 >Validators : Validators
->Validator : Validator
+>Validator : Validator<TValue>
 >TValue : TValue
 
         constructor(message?: string) {
@@ -214,12 +214,12 @@ interface Contract<TValue> {
 
     validators: KnockoutObservableArray<PortalFx.ViewModels.Controls.Validators.Validator<TValue>>;
 >validators : KnockoutObservableArray<Validator<TValue>>
->KnockoutObservableArray : KnockoutObservableArray
+>KnockoutObservableArray : KnockoutObservableArray<T>
 >PortalFx : PortalFx
 >ViewModels : ViewModels
 >Controls : Controls
 >Validators : Validators
->Validator : Validator
+>Validator : Validator<TValue>
 >TValue : TValue
 }
 
@@ -227,17 +227,17 @@ interface Contract<TValue> {
 class ViewModel<TValue> implements Contract<TValue> {
 >ViewModel : ViewModel<TValue>
 >TValue : TValue
->Contract : Contract
+>Contract : Contract<TValue>
 >TValue : TValue
 
     public validators: KnockoutObservableArray<PortalFx.ViewModels.Controls.Validators.Validator<TValue>> = ko.observableArray<PortalFx.ViewModels.Controls.Validators.Validator<TValue>>();
 >validators : KnockoutObservableArray<Validator<TValue>>
->KnockoutObservableArray : KnockoutObservableArray
+>KnockoutObservableArray : KnockoutObservableArray<T>
 >PortalFx : PortalFx
 >ViewModels : ViewModels
 >Controls : Controls
 >Validators : Validators
->Validator : Validator
+>Validator : Validator<TValue>
 >TValue : TValue
 >ko.observableArray<PortalFx.ViewModels.Controls.Validators.Validator<TValue>>() : KnockoutObservableArray<Validator<TValue>>
 >ko.observableArray : KnockoutObservableArrayStatic
@@ -247,7 +247,7 @@ class ViewModel<TValue> implements Contract<TValue> {
 >ViewModels : ViewModels
 >Controls : Controls
 >Validators : Validators
->Validator : Validator
+>Validator : Validator<TValue>
 >TValue : TValue
 }
 

tests/baselines/reference/genericClassStaticMethod.types

@@ -11,7 +11,7 @@ class Foo<T> {
 class Bar<T> extends Foo<T> {
 >Bar : Bar<T>
 >T : T
->Foo : Foo
+>Foo : Foo<T>
 >T : T
 
     static getFoo() {

tests/baselines/reference/genericClassWithFunctionTypedMemberArguments.types

@@ -129,7 +129,7 @@ module WithCandidates {
 
     var c: C<number>;
 >c : C<number>
->C : C
+>C : C<T>
 
     var r4 = c.foo2(1, function <Z>(a: Z) { return '' }); // string, contextual signature instantiation is applied to generic functions
 >r4 : string
@@ -187,7 +187,7 @@ module WithCandidates {
 
     var c2: C2<number, string>;
 >c2 : C2<number, string>
->C2 : C2
+>C2 : C2<T, U>
 
     var r7 = c2.foo3(1, <Z>(a: Z) => '', ''); // string
 >r7 : string
@@ -235,7 +235,7 @@ module WithCandidates {
     }
     var c3: C3<number, string>;
 >c3 : C3<number, string>
->C3 : C3
+>C3 : C3<T, U>
 
     function other<T, U>(t: T, u: U) {
 >other : <T, U>(t: T, u: U) => void

tests/baselines/reference/genericClassWithObjectTypeArgsAndConstraints.types

@@ -41,10 +41,10 @@ module Class {
 >T : T
 >x : string
 >t : X<T>
->X : X
+>X : X<T>
 >T : T
 >t2 : X<T>
->X : X
+>X : X<T>
 >T : T
 
             var x: T;
@@ -70,7 +70,7 @@ module Class {
 
     var g: G<{ x: string; y: string }>;
 >g : G<{ x: string; y: string; }>
->G : G
+>G : G<T>
 >x : string
 >y : string
 
@@ -102,10 +102,10 @@ module Class {
 >T : T
 >C : C
 >t : X<T>
->X : X
+>X : X<T>
 >T : T
 >t2 : X<T>
->X : X
+>X : X<T>
 >T : T
 
             var x: T;
@@ -118,7 +118,7 @@ module Class {
     }
     var g2: G2<D>;
 >g2 : G2<D>
->G2 : G2
+>G2 : G2<T>
 >D : D
 
     var r = g2.foo2(c1, d1);
@@ -153,10 +153,10 @@ module Interface {
 >T : T
 >x : string
 >t : X<T>
->X : X
+>X : X<T>
 >T : T
 >t2 : X<T>
->X : X
+>X : X<T>
 >T : T
 >T : T
     }
@@ -175,7 +175,7 @@ module Interface {
 
     var g: G<{ x: string; y: string }>;
 >g : G<{ x: string; y: string; }>
->G : G
+>G : G<T>
 >x : string
 >y : string
 
@@ -207,17 +207,17 @@ module Interface {
 >T : T
 >C : C
 >t : X<T>
->X : X
+>X : X<T>
 >T : T
 >t2 : X<T>
->X : X
+>X : X<T>
 >T : T
 >T : T
     }
 
     var g2: G2<D>;
 >g2 : G2<D>
->G2 : G2
+>G2 : G2<T>
 >D : D
 
     var r = g2.foo2(c1, d1);