Don't check an expression if it was checked cached

Author: Andy Hanson

src/compiler/checker.ts

@@ -421,8 +421,8 @@ namespace ts {
         let deferredGlobalTemplateStringsArrayType: ObjectType;
 
         let deferredNodes: Node[];
+        const seenDeferredNodes = createMap<true>(); // For assertion that we don't defer the same node twice
         let deferredUnusedIdentifierNodes: Node[];
-        const seenDeferredUnusedIdentifiers = createMap<true>(); // For assertion that we don't defer the same identifier twice
 
         let flowLoopStart = 0;
         let flowLoopCount = 0;
@@ -19573,14 +19573,14 @@ namespace ts {
             const links = getNodeLinks(node);
             if (!links.resolvedType) {
                 if (checkMode) {
-                    return checkExpression(node, checkMode);
+                    return checkExpressionNoCache(node, checkMode);
                 }
                 // When computing a type that we're going to cache, we need to ignore any ongoing control flow
                 // analysis because variables may have transient types in indeterminable states. Moving flowLoopStart
                 // to the top of the stack ensures all transient types are computed from a known point.
                 const saveFlowLoopStart = flowLoopStart;
                 flowLoopStart = flowLoopCount;
-                links.resolvedType = checkExpression(node, checkMode);
+                links.resolvedType = checkExpressionNoCache(node, checkMode);
                 flowLoopStart = saveFlowLoopStart;
             }
             return links.resolvedType;
@@ -19715,14 +19715,19 @@ namespace ts {
             return type;
         }
 
+        function checkExpression(node: Expression | QualifiedName, checkMode?: CheckMode): Type {
+            // Do nothing if this was already checked by a `checkExpressionCached` call
+            return getNodeLinks(node).resolvedType || checkExpressionNoCache(node, checkMode);
+        }
+
         // Checks an expression and returns its type. The contextualMapper parameter serves two purposes: When
         // contextualMapper is not undefined and not equal to the identityMapper function object it indicates that the
         // expression is being inferentially typed (section 4.15.2 in spec) and provides the type mapper to use in
         // conjunction with the generic contextual type. When contextualMapper is equal to the identityMapper function
         // object, it serves as an indicator that all contained function and arrow expressions should be considered to
         // have the wildcard function type; this form of type check is used during overload resolution to exclude
         // contextually typed function and arrow expressions in the initial phase.
-        function checkExpression(node: Expression | QualifiedName, checkMode?: CheckMode): Type {
+        function checkExpressionNoCache(node: Expression | QualifiedName, checkMode: CheckMode | undefined): Type {
             let type: Type;
             if (node.kind === SyntaxKind.QualifiedName) {
                 type = checkQualifiedName(<QualifiedName>node);
@@ -19802,7 +19807,7 @@ namespace ts {
                 case SyntaxKind.ParenthesizedExpression:
                     return checkParenthesizedExpression(<ParenthesizedExpression>node, checkMode);
                 case SyntaxKind.ClassExpression:
-                    return checkClassExpression(<ClassExpression>node);
+                    return checkClassExpression(<ClassExpression>node, checkMode);
                 case SyntaxKind.FunctionExpression:
                 case SyntaxKind.ArrowFunction:
                     return checkFunctionExpressionOrObjectLiteralMethod(<FunctionExpression>node, checkMode);
@@ -21573,7 +21578,6 @@ namespace ts {
 
         function registerForUnusedIdentifiersCheck(node: Node) {
             if (deferredUnusedIdentifierNodes) {
-                Debug.assert(addToSeen(seenDeferredUnusedIdentifiers, getNodeId(node)), "Deferring unused identifier check twice");
                 deferredUnusedIdentifierNodes.push(node);
             }
         }
@@ -23175,9 +23179,11 @@ namespace ts {
             return true;
         }
 
-        function checkClassExpression(node: ClassExpression): Type {
-            checkClassLikeDeclaration(node);
-            checkNodeDeferred(node);
+        function checkClassExpression(node: ClassExpression, checkMode: CheckMode | undefined): Type {
+            if (!checkMode) {
+                checkClassLikeDeclaration(node);
+                checkNodeDeferred(node);
+            }
             return getTypeOfSymbol(getSymbolOfNode(node));
         }
 
@@ -24519,6 +24525,7 @@ namespace ts {
         // Delaying the type check of the body ensures foo has been assigned a type.
         function checkNodeDeferred(node: Node) {
             if (deferredNodes) {
+                Debug.assert(addToSeen(seenDeferredNodes, getNodeId(node)));
                 deferredNodes.push(node);
             }
         }
@@ -24584,7 +24591,7 @@ namespace ts {
                 }
 
                 deferredNodes = undefined;
-                seenDeferredUnusedIdentifiers.clear();
+                seenDeferredNodes.clear();
                 deferredUnusedIdentifierNodes = undefined;
 
                 if (isExternalOrCommonJsModule(node)) {

src/harness/harness.ts

@@ -73,6 +73,8 @@ interface XMLHttpRequest {
 }
 /* tslint:enable:no-var-keyword */
 
+ts.Debug.currentAssertionLevel = ts.AssertionLevel.Normal;
+
 namespace Utils {
     // Setup some globals based on the current environment
     export const enum ExecutionEnvironment {