Change getTypeOfNode to take an apparentType flag

Author: JsonFreeman

src/compiler/checker.ts

@@ -6820,9 +6820,9 @@ module ts {
             return undefined;
         }
 
-        function getTypeOfNode(node: Node): Type {
+        function getTypeOfNode(node: Node, apparentType: boolean): Type {
             if (isExpression(node)) {
-                return getTypeOfExpression(<Expression>node);
+                return getTypeOfExpression(<Expression>node, apparentType);
             }
             if (isTypeNode(node)) {
                 if (node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.QualifiedName) {
@@ -6863,11 +6863,12 @@ module ts {
             Debug.fail("Unhandled case in getTypeOfNode");
         }
 
-        function getTypeOfExpression(expr: Expression): Type {
+        function getTypeOfExpression(expr: Expression, apparentType: boolean): Type {
             if (isRightSideOfQualifiedNameOrPropertyAccess(expr)) {
                 expr = expr.parent;
             }
-            return <Type>getApparentType(checkExpression(expr));
+            var type = checkExpression(expr);
+            return apparentType ? getApparentType(type) : type;
         }
 
         function getAugmentedPropertiesOfApparentType(type: Type): Symbol[]{

src/compiler/types.ts

@@ -604,7 +604,7 @@ module ts {
         getReturnTypeOfSignature(signature: Signature): Type;
         getSymbolsInScope(location: Node, meaning: SymbolFlags): Symbol[];
         getSymbolInfo(node: Node): Symbol;
-        getTypeOfNode(node: Node): Type;
+        getTypeOfNode(node: Node, apparentType: boolean): Type;
         typeToString(type: Type, enclosingDeclaration?: Node, flags?: TypeFormatFlags): string;
         symbolToString(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags): string;
         getAugmentedPropertiesOfApparentType(type: Type): Symbol[];

src/services/services.ts

@@ -1693,7 +1693,7 @@ module ts {
 
             // Right of dot member completion list
             if (isRightOfDot) {
-                var type: Type = typeInfoResolver.getTypeOfNode(mappedNode);
+                var type: Type = typeInfoResolver.getTypeOfNode(mappedNode, /*apparentType*/ true);
                 if (!type) {
                     return undefined;
                 }