Temporary fix for import case in getTypeOfNode

Author: JsonFreeman

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
     }
 }