diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 56546f12432..8a7cb5d1761 100644
--- a/src/compiler/checker.ts
+++ b/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[]{
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index 4b881c9f8d6..e8cda8b0c98 100644
--- a/src/compiler/types.ts
+++ b/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[];
diff --git a/src/harness/typeWriter.ts b/src/harness/typeWriter.ts
index c5f57dfa8ac..6ca49fdf486 100644
--- a/src/harness/typeWriter.ts
+++ b/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;
     }
diff --git a/src/services/services.ts b/src/services/services.ts
index f63cb5c7ed0..c1f86f89b24 100644
--- a/src/services/services.ts
+++ b/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;
                 }