Adjust TypeChecker to have separate method for getApparentType

Author: JsonFreeman

src/compiler/checker.ts

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

src/compiler/types.ts

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

src/harness/typeWriter.ts

@@ -88,7 +88,7 @@ class TypeWriterWalker {
     }
 
     private getTypeOfNode(node: ts.Node): ts.Type {
-        var type = this.checker.getTypeOfNode(node, /*apparentType*/ false);
+        var type = this.checker.getTypeOfNode(node);
         ts.Debug.assert(type, "type doesn't exist");
         return type;
     }

src/services/services.ts

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