diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 21633d97a3ec4..843904dd01826 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -4590,8 +4590,8 @@ module ts {
         // Get the narrowed type of a given symbol at a given location
         function getNarrowedTypeOfSymbol(symbol: Symbol, node: Node) {
             var type = getTypeOfSymbol(symbol);
-            // Only narrow when symbol is variable of an object, union, or type parameter type
-            if (node && symbol.flags & SymbolFlags.Variable && type.flags & (TypeFlags.ObjectType | TypeFlags.Union | TypeFlags.TypeParameter)) {
+            // Only narrow when symbol is variable of type any or an object, union, or type parameter type
+            if (node && symbol.flags & SymbolFlags.Variable && type.flags & (TypeFlags.Any | TypeFlags.ObjectType | TypeFlags.Union | TypeFlags.TypeParameter)) {
                 loop: while (node.parent) {
                     var child = node;
                     node = node.parent;
@@ -4647,21 +4647,16 @@ module ts {
                 if (expr.left.kind !== SyntaxKind.TypeOfExpression || expr.right.kind !== SyntaxKind.StringLiteral) {
                     return type;
                 }
-
                 var left = <TypeOfExpression>expr.left;
                 var right = <LiteralExpression>expr.right;
-                if (left.expression.kind !== SyntaxKind.Identifier ||
-                    getResolvedSymbol(<Identifier>left.expression) !== symbol) {
-
+                if (left.expression.kind !== SyntaxKind.Identifier || getResolvedSymbol(<Identifier>left.expression) !== symbol) {
                     return type;
                 }
-
                 var t = right.text;
                 var checkType: Type = t === "string" ? stringType : t === "number" ? numberType : t === "boolean" ? booleanType : emptyObjectType;
                 if (expr.operator === SyntaxKind.ExclamationEqualsEqualsToken) {
                     assumeTrue = !assumeTrue;
                 }
-
                 if (assumeTrue) {
                     // The assumed result is true. If check was for a primitive type, that type is the narrowed type. Otherwise we can
                     // remove the primitive types from the narrowed type.
@@ -4705,8 +4700,8 @@ module ts {
             }
 
             function narrowTypeByInstanceof(type: Type, expr: BinaryExpression, assumeTrue: boolean): Type {
-                // Check that assumed result is true and we have variable symbol on the left
-                if (!assumeTrue || expr.left.kind !== SyntaxKind.Identifier || getResolvedSymbol(<Identifier>expr.left) !== symbol) {
+                // Check that type is not any, assumed result is true, and we have variable symbol on the left
+                if (type.flags & TypeFlags.Any || !assumeTrue || expr.left.kind !== SyntaxKind.Identifier || getResolvedSymbol(<Identifier>expr.left) !== symbol) {
                     return type;
                 }
                 // Check that right operand is a function type with a prototype property
diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
index 00cd54b94ebcb..b70c4a7a1d5cb 100644
--- a/src/compiler/parser.ts
+++ b/src/compiler/parser.ts
@@ -12,43 +12,50 @@ module ts {
         return new (getNodeConstructor(kind))();
     }
 
-    // Invokes a callback for each child of the given node. The 'cbNode' callback is invoked for all child nodes
-    // stored in properties. If a 'cbNodes' callback is specified, it is invoked for embedded arrays; otherwise,
-    // embedded arrays are flattened and the 'cbNode' callback is invoked for each element. If a callback returns
-    // a truthy value, iteration stops and that value is returned. Otherwise, undefined is returned.
-    export function forEachChild<T>(node: Node, cbNode: (node: Node) => T, cbNodes?: (nodes: Node[]) => T): T {
-        function child(node: Node): T {
-            if (node) {
-                return cbNode(node);
-            }
+    function visitNode<T>(cbNode: (node: Node) => T, node: Node): T {
+        if (node) {
+            return cbNode(node);
         }
-        function children(nodes: Node[]) {
-            if (nodes) {
-                if (cbNodes) {
-                    return cbNodes(nodes);
-                }
+    }
 
-                for (var i = 0, len = nodes.length; i < len; i++) {
-                    var result = cbNode(nodes[i])
-                    if (result) {
-                        return result;
-                    }
-                }
+    function visitNodeArray<T>(cbNodes: (nodes: Node[]) => T, nodes: Node[]) {
+        if (nodes) {
+            return cbNodes(nodes);
+        }
+    }
 
-                return undefined;
+    function visitEachNode<T>(cbNode: (node: Node) => T, nodes: Node[]) {
+        if (nodes) {
+            for (var i = 0, len = nodes.length; i < len; i++) {
+                var result = cbNode(nodes[i]);
+                if (result) {
+                    return result;
+                }
             }
         }
+    }
+
+    // Invokes a callback for each child of the given node. The 'cbNode' callback is invoked for all child nodes
+    // stored in properties. If a 'cbNodes' callback is specified, it is invoked for embedded arrays; otherwise,
+    // embedded arrays are flattened and the 'cbNode' callback is invoked for each element. If a callback returns
+    // a truthy value, iteration stops and that value is returned. Otherwise, undefined is returned.
+    export function forEachChild<T>(node: Node, cbNode: (node: Node) => T, cbNodeArray?: (nodes: Node[]) => T): T {
         if (!node) {
             return;
         }
+        // The visitXXX functions could be written as local functions that close over the cbNode and cbNodeArray
+        // callback parameters, but that causes a closure allocation for each invocation with noticeable effects
+        // on performance.
+        var visitNodes: (cb: (node: Node | Node[]) => T, nodes: Node[]) => T = cbNodeArray ? visitNodeArray : visitEachNode;
+        var cbNodes = cbNodeArray || cbNode;
         switch (node.kind) {
             case SyntaxKind.QualifiedName:
-                return child((<QualifiedName>node).left) ||
-                    child((<QualifiedName>node).right);
+                return visitNode(cbNode, (<QualifiedName>node).left) ||
+                    visitNode(cbNode, (<QualifiedName>node).right);
             case SyntaxKind.TypeParameter:
-                return child((<TypeParameterDeclaration>node).name) ||
-                    child((<TypeParameterDeclaration>node).constraint) ||
-                    child((<TypeParameterDeclaration>node).expression);
+                return visitNode(cbNode, (<TypeParameterDeclaration>node).name) ||
+                    visitNode(cbNode, (<TypeParameterDeclaration>node).constraint) ||
+                    visitNode(cbNode, (<TypeParameterDeclaration>node).expression);
             case SyntaxKind.Parameter:
             case SyntaxKind.PropertyDeclaration:
             case SyntaxKind.PropertySignature:
@@ -56,22 +63,22 @@ module ts {
             case SyntaxKind.ShorthandPropertyAssignment:
             case SyntaxKind.VariableDeclaration:
             case SyntaxKind.BindingElement:
-                return children(node.modifiers) ||
-                    child((<VariableLikeDeclaration>node).propertyName) ||
-                    child((<VariableLikeDeclaration>node).dotDotDotToken) ||
-                    child((<VariableLikeDeclaration>node).name) ||
-                    child((<VariableLikeDeclaration>node).questionToken) ||
-                    child((<VariableLikeDeclaration>node).type) ||
-                    child((<VariableLikeDeclaration>node).initializer);
+                return visitNodes(cbNodes, node.modifiers) ||
+                    visitNode(cbNode, (<VariableLikeDeclaration>node).propertyName) ||
+                    visitNode(cbNode, (<VariableLikeDeclaration>node).dotDotDotToken) ||
+                    visitNode(cbNode, (<VariableLikeDeclaration>node).name) ||
+                    visitNode(cbNode, (<VariableLikeDeclaration>node).questionToken) ||
+                    visitNode(cbNode, (<VariableLikeDeclaration>node).type) ||
+                    visitNode(cbNode, (<VariableLikeDeclaration>node).initializer);
             case SyntaxKind.FunctionType:
             case SyntaxKind.ConstructorType:
             case SyntaxKind.CallSignature:
             case SyntaxKind.ConstructSignature:
             case SyntaxKind.IndexSignature:
-                return children(node.modifiers) ||
-                    children((<SignatureDeclaration>node).typeParameters) ||
-                    children((<SignatureDeclaration>node).parameters) ||
-                    child((<SignatureDeclaration>node).type);
+                return visitNodes(cbNodes, node.modifiers) ||
+                    visitNodes(cbNodes, (<SignatureDeclaration>node).typeParameters) ||
+                    visitNodes(cbNodes, (<SignatureDeclaration>node).parameters) ||
+                    visitNode(cbNode, (<SignatureDeclaration>node).type);
             case SyntaxKind.MethodDeclaration:
             case SyntaxKind.MethodSignature:
             case SyntaxKind.Constructor:
@@ -80,182 +87,182 @@ module ts {
             case SyntaxKind.FunctionExpression:
             case SyntaxKind.FunctionDeclaration:
             case SyntaxKind.ArrowFunction:
-                return children(node.modifiers) ||
-                    child((<FunctionLikeDeclaration>node).asteriskToken) ||
-                    child((<FunctionLikeDeclaration>node).name) ||
-                    child((<FunctionLikeDeclaration>node).questionToken) ||
-                    children((<FunctionLikeDeclaration>node).typeParameters) ||
-                    children((<FunctionLikeDeclaration>node).parameters) ||
-                    child((<FunctionLikeDeclaration>node).type) ||
-                    child((<FunctionLikeDeclaration>node).body);
+                return visitNodes(cbNodes, node.modifiers) ||
+                    visitNode(cbNode, (<FunctionLikeDeclaration>node).asteriskToken) ||
+                    visitNode(cbNode, (<FunctionLikeDeclaration>node).name) ||
+                    visitNode(cbNode, (<FunctionLikeDeclaration>node).questionToken) ||
+                    visitNodes(cbNodes, (<FunctionLikeDeclaration>node).typeParameters) ||
+                    visitNodes(cbNodes, (<FunctionLikeDeclaration>node).parameters) ||
+                    visitNode(cbNode, (<FunctionLikeDeclaration>node).type) ||
+                    visitNode(cbNode, (<FunctionLikeDeclaration>node).body);
             case SyntaxKind.TypeReference:
-                return child((<TypeReferenceNode>node).typeName) ||
-                    children((<TypeReferenceNode>node).typeArguments);
+                return visitNode(cbNode, (<TypeReferenceNode>node).typeName) ||
+                    visitNodes(cbNodes, (<TypeReferenceNode>node).typeArguments);
             case SyntaxKind.TypeQuery:
-                return child((<TypeQueryNode>node).exprName);
+                return visitNode(cbNode, (<TypeQueryNode>node).exprName);
             case SyntaxKind.TypeLiteral:
-                return children((<TypeLiteralNode>node).members);
+                return visitNodes(cbNodes, (<TypeLiteralNode>node).members);
             case SyntaxKind.ArrayType:
-                return child((<ArrayTypeNode>node).elementType);
+                return visitNode(cbNode, (<ArrayTypeNode>node).elementType);
             case SyntaxKind.TupleType:
-                return children((<TupleTypeNode>node).elementTypes);
+                return visitNodes(cbNodes, (<TupleTypeNode>node).elementTypes);
             case SyntaxKind.UnionType:
-                return children((<UnionTypeNode>node).types);
+                return visitNodes(cbNodes, (<UnionTypeNode>node).types);
             case SyntaxKind.ParenthesizedType:
-                return child((<ParenthesizedTypeNode>node).type);
+                return visitNode(cbNode, (<ParenthesizedTypeNode>node).type);
             case SyntaxKind.ObjectBindingPattern:
             case SyntaxKind.ArrayBindingPattern:
-                return children((<BindingPattern>node).elements);
+                return visitNodes(cbNodes, (<BindingPattern>node).elements);
             case SyntaxKind.ArrayLiteralExpression:
-                return children((<ArrayLiteralExpression>node).elements);
+                return visitNodes(cbNodes, (<ArrayLiteralExpression>node).elements);
             case SyntaxKind.ObjectLiteralExpression:
-                return children((<ObjectLiteralExpression>node).properties);
+                return visitNodes(cbNodes, (<ObjectLiteralExpression>node).properties);
             case SyntaxKind.PropertyAccessExpression:
-                return child((<PropertyAccessExpression>node).expression) ||
-                    child((<PropertyAccessExpression>node).name);
+                return visitNode(cbNode, (<PropertyAccessExpression>node).expression) ||
+                    visitNode(cbNode, (<PropertyAccessExpression>node).name);
             case SyntaxKind.ElementAccessExpression:
-                return child((<ElementAccessExpression>node).expression) ||
-                    child((<ElementAccessExpression>node).argumentExpression);
+                return visitNode(cbNode, (<ElementAccessExpression>node).expression) ||
+                    visitNode(cbNode, (<ElementAccessExpression>node).argumentExpression);
             case SyntaxKind.CallExpression:
             case SyntaxKind.NewExpression:
-                return child((<CallExpression>node).expression) ||
-                    children((<CallExpression>node).typeArguments) ||
-                    children((<CallExpression>node).arguments);
+                return visitNode(cbNode, (<CallExpression>node).expression) ||
+                    visitNodes(cbNodes, (<CallExpression>node).typeArguments) ||
+                    visitNodes(cbNodes, (<CallExpression>node).arguments);
             case SyntaxKind.TaggedTemplateExpression:
-                return child((<TaggedTemplateExpression>node).tag) ||
-                    child((<TaggedTemplateExpression>node).template);
+                return visitNode(cbNode, (<TaggedTemplateExpression>node).tag) ||
+                    visitNode(cbNode, (<TaggedTemplateExpression>node).template);
             case SyntaxKind.TypeAssertionExpression:
-                return child((<TypeAssertion>node).type) ||
-                    child((<TypeAssertion>node).expression);
+                return visitNode(cbNode, (<TypeAssertion>node).type) ||
+                    visitNode(cbNode, (<TypeAssertion>node).expression);
             case SyntaxKind.ParenthesizedExpression:
-                return child((<ParenthesizedExpression>node).expression);
+                return visitNode(cbNode, (<ParenthesizedExpression>node).expression);
             case SyntaxKind.DeleteExpression:
-                return child((<DeleteExpression>node).expression);
+                return visitNode(cbNode, (<DeleteExpression>node).expression);
             case SyntaxKind.TypeOfExpression:
-                return child((<TypeOfExpression>node).expression);
+                return visitNode(cbNode, (<TypeOfExpression>node).expression);
             case SyntaxKind.VoidExpression:
-                return child((<VoidExpression>node).expression);
+                return visitNode(cbNode, (<VoidExpression>node).expression);
             case SyntaxKind.PrefixUnaryExpression:
-                return child((<PrefixUnaryExpression>node).operand);
+                return visitNode(cbNode, (<PrefixUnaryExpression>node).operand);
             case SyntaxKind.YieldExpression:
-                return child((<YieldExpression>node).asteriskToken) ||
-                    child((<YieldExpression>node).expression);
+                return visitNode(cbNode, (<YieldExpression>node).asteriskToken) ||
+                    visitNode(cbNode, (<YieldExpression>node).expression);
             case SyntaxKind.PostfixUnaryExpression:
-                return child((<PostfixUnaryExpression>node).operand);
+                return visitNode(cbNode, (<PostfixUnaryExpression>node).operand);
             case SyntaxKind.BinaryExpression:
-                return child((<BinaryExpression>node).left) ||
-                    child((<BinaryExpression>node).right);
+                return visitNode(cbNode, (<BinaryExpression>node).left) ||
+                    visitNode(cbNode, (<BinaryExpression>node).right);
             case SyntaxKind.ConditionalExpression:
-                return child((<ConditionalExpression>node).condition) ||
-                    child((<ConditionalExpression>node).whenTrue) ||
-                    child((<ConditionalExpression>node).whenFalse);
+                return visitNode(cbNode, (<ConditionalExpression>node).condition) ||
+                    visitNode(cbNode, (<ConditionalExpression>node).whenTrue) ||
+                    visitNode(cbNode, (<ConditionalExpression>node).whenFalse);
             case SyntaxKind.SpreadElementExpression:
-                return child((<SpreadElementExpression>node).expression);
+                return visitNode(cbNode, (<SpreadElementExpression>node).expression);
             case SyntaxKind.Block:
             case SyntaxKind.ModuleBlock:
-                return children((<Block>node).statements);
+                return visitNodes(cbNodes, (<Block>node).statements);
             case SyntaxKind.SourceFile:
-                return children((<SourceFile>node).statements) ||
-                    child((<SourceFile>node).endOfFileToken);
+                return visitNodes(cbNodes, (<SourceFile>node).statements) ||
+                    visitNode(cbNode, (<SourceFile>node).endOfFileToken);
             case SyntaxKind.VariableStatement:
-                return children(node.modifiers) ||
-                    child((<VariableStatement>node).declarationList);
+                return visitNodes(cbNodes, node.modifiers) ||
+                    visitNode(cbNode, (<VariableStatement>node).declarationList);
             case SyntaxKind.VariableDeclarationList:
-                return children((<VariableDeclarationList>node).declarations);
+                return visitNodes(cbNodes, (<VariableDeclarationList>node).declarations);
             case SyntaxKind.ExpressionStatement:
-                return child((<ExpressionStatement>node).expression);
+                return visitNode(cbNode, (<ExpressionStatement>node).expression);
             case SyntaxKind.IfStatement:
-                return child((<IfStatement>node).expression) ||
-                    child((<IfStatement>node).thenStatement) ||
-                    child((<IfStatement>node).elseStatement);
+                return visitNode(cbNode, (<IfStatement>node).expression) ||
+                    visitNode(cbNode, (<IfStatement>node).thenStatement) ||
+                    visitNode(cbNode, (<IfStatement>node).elseStatement);
             case SyntaxKind.DoStatement:
-                return child((<DoStatement>node).statement) ||
-                    child((<DoStatement>node).expression);
+                return visitNode(cbNode, (<DoStatement>node).statement) ||
+                    visitNode(cbNode, (<DoStatement>node).expression);
             case SyntaxKind.WhileStatement:
-                return child((<WhileStatement>node).expression) ||
-                    child((<WhileStatement>node).statement);
+                return visitNode(cbNode, (<WhileStatement>node).expression) ||
+                    visitNode(cbNode, (<WhileStatement>node).statement);
             case SyntaxKind.ForStatement:
-                return child((<ForStatement>node).initializer) ||
-                    child((<ForStatement>node).condition) ||
-                    child((<ForStatement>node).iterator) ||
-                    child((<ForStatement>node).statement);
+                return visitNode(cbNode, (<ForStatement>node).initializer) ||
+                    visitNode(cbNode, (<ForStatement>node).condition) ||
+                    visitNode(cbNode, (<ForStatement>node).iterator) ||
+                    visitNode(cbNode, (<ForStatement>node).statement);
             case SyntaxKind.ForInStatement:
-                return child((<ForInStatement>node).initializer) ||
-                    child((<ForInStatement>node).expression) ||
-                    child((<ForInStatement>node).statement);
+                return visitNode(cbNode, (<ForInStatement>node).initializer) ||
+                    visitNode(cbNode, (<ForInStatement>node).expression) ||
+                    visitNode(cbNode, (<ForInStatement>node).statement);
             case SyntaxKind.ContinueStatement:
             case SyntaxKind.BreakStatement:
-                return child((<BreakOrContinueStatement>node).label);
+                return visitNode(cbNode, (<BreakOrContinueStatement>node).label);
             case SyntaxKind.ReturnStatement:
-                return child((<ReturnStatement>node).expression);
+                return visitNode(cbNode, (<ReturnStatement>node).expression);
             case SyntaxKind.WithStatement:
-                return child((<WithStatement>node).expression) ||
-                    child((<WithStatement>node).statement);
+                return visitNode(cbNode, (<WithStatement>node).expression) ||
+                    visitNode(cbNode, (<WithStatement>node).statement);
             case SyntaxKind.SwitchStatement:
-                return child((<SwitchStatement>node).expression) ||
-                    children((<SwitchStatement>node).clauses);
+                return visitNode(cbNode, (<SwitchStatement>node).expression) ||
+                    visitNodes(cbNodes, (<SwitchStatement>node).clauses);
             case SyntaxKind.CaseClause:
-                return child((<CaseClause>node).expression) ||
-                    children((<CaseClause>node).statements);
+                return visitNode(cbNode, (<CaseClause>node).expression) ||
+                    visitNodes(cbNodes, (<CaseClause>node).statements);
             case SyntaxKind.DefaultClause:
-                return children((<DefaultClause>node).statements);
+                return visitNodes(cbNodes, (<DefaultClause>node).statements);
             case SyntaxKind.LabeledStatement:
-                return child((<LabeledStatement>node).label) ||
-                    child((<LabeledStatement>node).statement);
+                return visitNode(cbNode, (<LabeledStatement>node).label) ||
+                    visitNode(cbNode, (<LabeledStatement>node).statement);
             case SyntaxKind.ThrowStatement:
-                return child((<ThrowStatement>node).expression);
+                return visitNode(cbNode, (<ThrowStatement>node).expression);
             case SyntaxKind.TryStatement:
-                return child((<TryStatement>node).tryBlock) ||
-                    child((<TryStatement>node).catchClause) ||
-                    child((<TryStatement>node).finallyBlock);
+                return visitNode(cbNode, (<TryStatement>node).tryBlock) ||
+                    visitNode(cbNode, (<TryStatement>node).catchClause) ||
+                    visitNode(cbNode, (<TryStatement>node).finallyBlock);
             case SyntaxKind.CatchClause:
-                return child((<CatchClause>node).name) ||
-                    child((<CatchClause>node).type) ||
-                    child((<CatchClause>node).block);
+                return visitNode(cbNode, (<CatchClause>node).name) ||
+                    visitNode(cbNode, (<CatchClause>node).type) ||
+                    visitNode(cbNode, (<CatchClause>node).block);
             case SyntaxKind.ClassDeclaration:
-                return children(node.modifiers) ||
-                    child((<ClassDeclaration>node).name) ||
-                    children((<ClassDeclaration>node).typeParameters) ||
-                    children((<ClassDeclaration>node).heritageClauses) ||
-                    children((<ClassDeclaration>node).members);
+                return visitNodes(cbNodes, node.modifiers) ||
+                    visitNode(cbNode, (<ClassDeclaration>node).name) ||
+                    visitNodes(cbNodes, (<ClassDeclaration>node).typeParameters) ||
+                    visitNodes(cbNodes, (<ClassDeclaration>node).heritageClauses) ||
+                    visitNodes(cbNodes, (<ClassDeclaration>node).members);
             case SyntaxKind.InterfaceDeclaration:
-                return children(node.modifiers) ||
-                    child((<InterfaceDeclaration>node).name) ||
-                    children((<InterfaceDeclaration>node).typeParameters) ||
-                    children((<ClassDeclaration>node).heritageClauses) ||
-                    children((<InterfaceDeclaration>node).members);
+                return visitNodes(cbNodes, node.modifiers) ||
+                    visitNode(cbNode, (<InterfaceDeclaration>node).name) ||
+                    visitNodes(cbNodes, (<InterfaceDeclaration>node).typeParameters) ||
+                    visitNodes(cbNodes, (<ClassDeclaration>node).heritageClauses) ||
+                    visitNodes(cbNodes, (<InterfaceDeclaration>node).members);
             case SyntaxKind.TypeAliasDeclaration:
-                return children(node.modifiers) ||
-                    child((<TypeAliasDeclaration>node).name) ||
-                    child((<TypeAliasDeclaration>node).type);
+                return visitNodes(cbNodes, node.modifiers) ||
+                    visitNode(cbNode, (<TypeAliasDeclaration>node).name) ||
+                    visitNode(cbNode, (<TypeAliasDeclaration>node).type);
             case SyntaxKind.EnumDeclaration:
-                return children(node.modifiers) ||
-                    child((<EnumDeclaration>node).name) ||
-                    children((<EnumDeclaration>node).members);
+                return visitNodes(cbNodes, node.modifiers) ||
+                    visitNode(cbNode, (<EnumDeclaration>node).name) ||
+                    visitNodes(cbNodes, (<EnumDeclaration>node).members);
             case SyntaxKind.EnumMember:
-                return child((<EnumMember>node).name) ||
-                    child((<EnumMember>node).initializer);
+                return visitNode(cbNode, (<EnumMember>node).name) ||
+                    visitNode(cbNode, (<EnumMember>node).initializer);
             case SyntaxKind.ModuleDeclaration:
-                return children(node.modifiers) ||
-                    child((<ModuleDeclaration>node).name) ||
-                    child((<ModuleDeclaration>node).body);
+                return visitNodes(cbNodes, node.modifiers) ||
+                    visitNode(cbNode, (<ModuleDeclaration>node).name) ||
+                    visitNode(cbNode, (<ModuleDeclaration>node).body);
             case SyntaxKind.ImportDeclaration:
-                return children(node.modifiers) ||
-                    child((<ImportDeclaration>node).name) ||
-                    child((<ImportDeclaration>node).moduleReference);
+                return visitNodes(cbNodes, node.modifiers) ||
+                    visitNode(cbNode, (<ImportDeclaration>node).name) ||
+                    visitNode(cbNode, (<ImportDeclaration>node).moduleReference);
             case SyntaxKind.ExportAssignment:
-                return children(node.modifiers) ||
-                    child((<ExportAssignment>node).exportName);
+                return visitNodes(cbNodes, node.modifiers) ||
+                    visitNode(cbNode, (<ExportAssignment>node).exportName);
             case SyntaxKind.TemplateExpression:
-                return child((<TemplateExpression>node).head) || children((<TemplateExpression>node).templateSpans);
+                return visitNode(cbNode, (<TemplateExpression>node).head) || visitNodes(cbNodes, (<TemplateExpression>node).templateSpans);
             case SyntaxKind.TemplateSpan:
-                return child((<TemplateSpan>node).expression) || child((<TemplateSpan>node).literal);
+                return visitNode(cbNode, (<TemplateSpan>node).expression) || visitNode(cbNode, (<TemplateSpan>node).literal);
             case SyntaxKind.ComputedPropertyName:
-                return child((<ComputedPropertyName>node).expression);
+                return visitNode(cbNode, (<ComputedPropertyName>node).expression);
             case SyntaxKind.HeritageClause:
-                return children((<HeritageClause>node).types);
+                return visitNodes(cbNodes, (<HeritageClause>node).types);
             case SyntaxKind.ExternalModuleReference:
-                return child((<ExternalModuleReference>node).expression);
+                return visitNode(cbNode, (<ExternalModuleReference>node).expression);
         }
     }
 
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index 60ed8352b9a3d..9ebab8dc2207c 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -1331,8 +1331,6 @@ module ts {
     // Generic class and interface types
     export interface GenericType extends InterfaceType, TypeReference {
         instantiations: Map<TypeReference>;   // Generic instantiation cache
-        openReferenceTargets: GenericType[];  // Open type reference targets
-        openReferenceChecks: Map<boolean>;    // Open type reference check cache
     }
 
     export interface TupleType extends ObjectType {
diff --git a/tests/baselines/reference/typeGuardsWithAny.errors.txt b/tests/baselines/reference/typeGuardsWithAny.errors.txt
new file mode 100644
index 0000000000000..653c89c7554ad
--- /dev/null
+++ b/tests/baselines/reference/typeGuardsWithAny.errors.txt
@@ -0,0 +1,49 @@
+tests/cases/conformance/expressions/typeGuards/typeGuardsWithAny.ts(11,7): error TS2339: Property 'p' does not exist on type 'string'.
+tests/cases/conformance/expressions/typeGuards/typeGuardsWithAny.ts(18,7): error TS2339: Property 'p' does not exist on type 'number'.
+tests/cases/conformance/expressions/typeGuards/typeGuardsWithAny.ts(25,7): error TS2339: Property 'p' does not exist on type 'boolean'.
+
+
+==== tests/cases/conformance/expressions/typeGuards/typeGuardsWithAny.ts (3 errors) ====
+    var x: any = { p: 0 };
+    
+    if (x instanceof Object) {
+        x.p; // No error, type any unaffected by instanceof type guard
+    }
+    else {
+        x.p; // No error, type any unaffected by instanceof type guard
+    }
+    
+    if (typeof x === "string") {
+        x.p; // Error, type any narrowed by primitive type check
+          ~
+!!! error TS2339: Property 'p' does not exist on type 'string'.
+    }
+    else {
+        x.p; // No error, type unaffected in this branch
+    }
+    
+    if (typeof x === "number") {
+        x.p; // Error, type any narrowed by primitive type check
+          ~
+!!! error TS2339: Property 'p' does not exist on type 'number'.
+    }
+    else {
+        x.p; // No error, type unaffected in this branch
+    }
+    
+    if (typeof x === "boolean") {
+        x.p; // Error, type any narrowed by primitive type check
+          ~
+!!! error TS2339: Property 'p' does not exist on type 'boolean'.
+    }
+    else {
+        x.p; // No error, type unaffected in this branch
+    }
+    
+    if (typeof x === "object") {
+        x.p; // No error, type any only affected by primitive type check
+    }
+    else {
+        x.p; // No error, type unaffected in this branch
+    }
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/typeGuardsWithAny.js b/tests/baselines/reference/typeGuardsWithAny.js
index 56676fb6d6884..be3d64b806fc1 100644
--- a/tests/baselines/reference/typeGuardsWithAny.js
+++ b/tests/baselines/reference/typeGuardsWithAny.js
@@ -1,18 +1,71 @@
 //// [typeGuardsWithAny.ts]
 var x: any = { p: 0 };
+
 if (x instanceof Object) {
-    x.p; // No error, type any unaffected by type guard
+    x.p; // No error, type any unaffected by instanceof type guard
 }
 else {
-    x.p; // No error, type any unaffected by type guard
+    x.p; // No error, type any unaffected by instanceof type guard
+}
+
+if (typeof x === "string") {
+    x.p; // Error, type any narrowed by primitive type check
+}
+else {
+    x.p; // No error, type unaffected in this branch
+}
+
+if (typeof x === "number") {
+    x.p; // Error, type any narrowed by primitive type check
+}
+else {
+    x.p; // No error, type unaffected in this branch
+}
+
+if (typeof x === "boolean") {
+    x.p; // Error, type any narrowed by primitive type check
+}
+else {
+    x.p; // No error, type unaffected in this branch
+}
+
+if (typeof x === "object") {
+    x.p; // No error, type any only affected by primitive type check
+}
+else {
+    x.p; // No error, type unaffected in this branch
 }
 
 
 //// [typeGuardsWithAny.js]
 var x = { p: 0 };
 if (x instanceof Object) {
-    x.p; // No error, type any unaffected by type guard
+    x.p; // No error, type any unaffected by instanceof type guard
+}
+else {
+    x.p; // No error, type any unaffected by instanceof type guard
+}
+if (typeof x === "string") {
+    x.p; // Error, type any narrowed by primitive type check
+}
+else {
+    x.p; // No error, type unaffected in this branch
+}
+if (typeof x === "number") {
+    x.p; // Error, type any narrowed by primitive type check
+}
+else {
+    x.p; // No error, type unaffected in this branch
+}
+if (typeof x === "boolean") {
+    x.p; // Error, type any narrowed by primitive type check
+}
+else {
+    x.p; // No error, type unaffected in this branch
+}
+if (typeof x === "object") {
+    x.p; // No error, type any only affected by primitive type check
 }
 else {
-    x.p; // No error, type any unaffected by type guard
+    x.p; // No error, type unaffected in this branch
 }
diff --git a/tests/baselines/reference/typeGuardsWithAny.types b/tests/baselines/reference/typeGuardsWithAny.types
deleted file mode 100644
index ee628c9c2497d..0000000000000
--- a/tests/baselines/reference/typeGuardsWithAny.types
+++ /dev/null
@@ -1,23 +0,0 @@
-=== tests/cases/conformance/expressions/typeGuards/typeGuardsWithAny.ts ===
-var x: any = { p: 0 };
->x : any
->{ p: 0 } : { p: number; }
->p : number
-
-if (x instanceof Object) {
->x instanceof Object : boolean
->x : any
->Object : ObjectConstructor
-
-    x.p; // No error, type any unaffected by type guard
->x.p : any
->x : any
->p : any
-}
-else {
-    x.p; // No error, type any unaffected by type guard
->x.p : any
->x : any
->p : any
-}
-
diff --git a/tests/cases/conformance/expressions/typeGuards/typeGuardsWithAny.ts b/tests/cases/conformance/expressions/typeGuards/typeGuardsWithAny.ts
index e7e756ea8e041..a6379bf95b082 100644
--- a/tests/cases/conformance/expressions/typeGuards/typeGuardsWithAny.ts
+++ b/tests/cases/conformance/expressions/typeGuards/typeGuardsWithAny.ts
@@ -1,7 +1,36 @@
 var x: any = { p: 0 };
+
 if (x instanceof Object) {
-    x.p; // No error, type any unaffected by type guard
+    x.p; // No error, type any unaffected by instanceof type guard
 }
 else {
-    x.p; // No error, type any unaffected by type guard
+    x.p; // No error, type any unaffected by instanceof type guard
+}
+
+if (typeof x === "string") {
+    x.p; // Error, type any narrowed by primitive type check
+}
+else {
+    x.p; // No error, type unaffected in this branch
+}
+
+if (typeof x === "number") {
+    x.p; // Error, type any narrowed by primitive type check
+}
+else {
+    x.p; // No error, type unaffected in this branch
+}
+
+if (typeof x === "boolean") {
+    x.p; // Error, type any narrowed by primitive type check
+}
+else {
+    x.p; // No error, type unaffected in this branch
+}
+
+if (typeof x === "object") {
+    x.p; // No error, type any only affected by primitive type check
+}
+else {
+    x.p; // No error, type unaffected in this branch
 }