@zzzen/pyright-internal 1.2.0-dev.20220710 → 1.2.0-dev.20220717

package/dist/analyzer/codeFlowEngine.d.ts

@@ -5,7 +5,6 @@ import { Type, TypeVarType } from './types';
 export interface FlowNodeTypeResult {
     type: Type | undefined;
     isIncomplete: boolean;
-    isRecursionSentinel?: boolean;
     generationCount?: number | undefined;
     incompleteType?: Type | undefined;
     incompleteSubtypes?: IncompleteSubtypeInfo[] | undefined;

package/dist/analyzer/codeFlowEngine.js

@@ -20,6 +20,7 @@ const codeFlowTypes_1 = require("./codeFlowTypes");
 const codeFlowUtils_1 = require("./codeFlowUtils");
 const parseTreeUtils_1 = require("./parseTreeUtils");
 const typeCache_1 = require("./typeCache");
+const typedDicts_1 = require("./typedDicts");
 const typeGuards_1 = require("./typeGuards");
 const types_1 = require("./types");
 const typeUtils_1 = require("./typeUtils");
@@ -42,7 +43,10 @@ function getCodeFlowEngine(evaluator, speculativeTypeTracker) {
         function getFlowNodeTypeCacheForReference(referenceKey) {
             let flowNodeTypeCache = flowNodeTypeCacheSet.get(referenceKey);
             if (!flowNodeTypeCache) {
-                flowNodeTypeCache = new Map();
+                flowNodeTypeCache = {
+                    cache: new Map(),
+                    pendingNodes: new Set(),
+                };
                 flowNodeTypeCacheSet.set(referenceKey, flowNodeTypeCache);
             }
             return flowNodeTypeCache;
@@ -58,12 +62,12 @@ function getCodeFlowEngine(evaluator, speculativeTypeTracker) {
                 : '.';
             const flowNodeTypeCache = getFlowNodeTypeCacheForReference(referenceKeyWithSymbolId);
             // Caches the type of the flow node in our local cache, keyed by the flow node ID.
-            function setCacheEntry(flowNode, type, isIncomplete, isRecursionSentinel) {
+            function setCacheEntry(flowNode, type, isIncomplete) {
                 if (!isIncomplete) {
                     flowIncompleteGeneration++;
                 }
                 else if (type) {
-                    const prevEntry = flowNodeTypeCache.get(flowNode.id);
+                    const prevEntry = flowNodeTypeCache.cache.get(flowNode.id);
                     if (prevEntry === undefined) {
                         flowIncompleteGeneration++;
                     }
@@ -83,21 +87,19 @@ function getCodeFlowEngine(evaluator, speculativeTypeTracker) {
                         type,
                         incompleteSubtypes: [],
                         generationCount: flowIncompleteGeneration,
-                        isRecursionSentinel,
                     }
                     : type;
-                flowNodeTypeCache.set(flowNode.id, entry);
-                speculativeTypeTracker.trackEntry(flowNodeTypeCache, flowNode.id);
+                flowNodeTypeCache.cache.set(flowNode.id, entry);
+                speculativeTypeTracker.trackEntry(flowNodeTypeCache.cache, flowNode.id);
                 return {
                     type,
                     isIncomplete,
-                    isRecursionSentinel,
                     generationCount: flowIncompleteGeneration,
                     incompleteSubtypes: isIncomplete ? [] : undefined,
                 };
             }
             function setIncompleteSubtype(flowNode, index, type, isIncomplete, isPending, evaluationCount) {
-                const cachedEntry = flowNodeTypeCache.get(flowNode.id);
+                const cachedEntry = flowNodeTypeCache.cache.get(flowNode.id);
                 if (cachedEntry === undefined || !(0, typeCache_1.isIncompleteType)(cachedEntry)) {
                     (0, debug_1.fail)('setIncompleteSubtype can be called only on a valid incomplete cache entry');
                 }
@@ -123,10 +125,10 @@ function getCodeFlowEngine(evaluator, speculativeTypeTracker) {
                 return getCacheEntry(flowNode);
             }
             function getCacheEntry(flowNode) {
-                if (!flowNodeTypeCache.has(flowNode.id)) {
+                if (!flowNodeTypeCache.cache.has(flowNode.id)) {
                     return undefined;
                 }
-                const cachedEntry = flowNodeTypeCache.get(flowNode.id);
+                const cachedEntry = flowNodeTypeCache.cache.get(flowNode.id);
                 if (cachedEntry === undefined) {
                     return {
                         type: cachedEntry,
@@ -156,11 +158,10 @@ function getCodeFlowEngine(evaluator, speculativeTypeTracker) {
                     isIncomplete: true,
                     incompleteSubtypes: cachedEntry.incompleteSubtypes,
                     generationCount: cachedEntry.generationCount,
-                    isRecursionSentinel: cachedEntry.isRecursionSentinel,
                 };
             }
             function deleteCacheEntry(flowNode) {
-                flowNodeTypeCache.delete(flowNode.id);
+                flowNodeTypeCache.cache.delete(flowNode.id);
             }
             function evaluateAssignmentFlowNode(flowNode) {
                 // For function and class nodes, the reference node is the name
@@ -177,10 +178,20 @@ function getCodeFlowEngine(evaluator, speculativeTypeTracker) {
                     evaluator.evaluateTypesForStatement(flowNode.node);
                 });
             }
+            function preventRecursion(flowNode, callback) {
+                flowNodeTypeCache.pendingNodes.add(flowNode.id);
+                try {
+                    return callback();
+                }
+                finally {
+                    flowNodeTypeCache.pendingNodes.delete(flowNode.id);
+                }
+            }
             // If this flow has no knowledge of the target expression, it returns undefined.
             // If the start flow node for this scope is reachable, the typeAtStart value is
             // returned.
             function getTypeFromFlowNode(flowNode) {
+                var _a;
                 let curFlowNode = flowNode;
                 // This is a frequently-called routine, so it's a good place to call
                 // the cancellation check. If the operation is canceled, an exception
@@ -199,6 +210,10 @@ function getCodeFlowEngine(evaluator, speculativeTypeTracker) {
                             return { type: cachedEntry.type, isIncomplete: true };
                         }
                     }
+                    // Check for recursion.
+                    if (flowNodeTypeCache.pendingNodes.has(curFlowNode.id)) {
+                        return { type: cachedEntry === null || cachedEntry === void 0 ? void 0 : cachedEntry.type, isIncomplete: true };
+                    }
                     if (curFlowNode.flags & codeFlowTypes_1.FlowFlags.Unreachable) {
                         // We can get here if there are nodes in a compound logical expression
                         // (e.g. "False and x") that are never executed but are evaluated.
@@ -222,51 +237,72 @@ function getCodeFlowEngine(evaluator, speculativeTypeTracker) {
                     }
                     if (curFlowNode.flags & codeFlowTypes_1.FlowFlags.Assignment) {
                         const assignmentFlowNode = curFlowNode;
+                        const targetNode = assignmentFlowNode.node;
                         // Are we targeting the same symbol? We need to do this extra check because the same
                         // symbol name might refer to different symbols in different scopes (e.g. a list
                         // comprehension introduces a new scope).
                         if (reference) {
                             if (targetSymbolId === assignmentFlowNode.targetSymbolId &&
-                                (0, parseTreeUtils_1.isMatchingExpression)(reference, assignmentFlowNode.node)) {
+                                (0, parseTreeUtils_1.isMatchingExpression)(reference, targetNode)) {
                                 // Is this a special "unbind" assignment? If so,
                                 // we can handle it immediately without any further evaluation.
                                 if (curFlowNode.flags & codeFlowTypes_1.FlowFlags.Unbind) {
                                     return setCacheEntry(curFlowNode, types_1.UnboundType.create(), /* isIncomplete */ false);
                                 }
-                                // If there was a cache entry already, that means we hit a recursive
-                                // case (something like "int: int = 4"). Avoid infinite recursion
-                                // by returning an undefined type.
-                                if (cachedEntry === null || cachedEntry === void 0 ? void 0 : cachedEntry.isRecursionSentinel) {
-                                    return { type: undefined, isIncomplete: true };
-                                }
-                                // Set the cache entry to undefined before evaluating the
-                                // expression in case it depends on itself.
-                                setCacheEntry(curFlowNode, reference ? undefined : initialType, 
-                                /* isIncomplete */ true, 
-                                /* isRecursionSentinel */ true);
-                                let flowTypeResult = evaluateAssignmentFlowNode(assignmentFlowNode);
+                                let flowTypeResult = preventRecursion(curFlowNode, () => evaluateAssignmentFlowNode(assignmentFlowNode));
                                 if (flowTypeResult) {
                                     if ((0, typeUtils_1.isTypeAliasPlaceholder)(flowTypeResult.type)) {
                                         flowTypeResult = undefined;
                                     }
                                     else if (reference.nodeType === 35 /* MemberAccess */ &&
-                                        evaluator.isAsymmetricDescriptorAssignment(assignmentFlowNode.node)) {
+                                        evaluator.isAsymmetricDescriptorAssignment(targetNode)) {
                                         flowTypeResult = undefined;
                                     }
                                 }
                                 return setCacheEntry(curFlowNode, flowTypeResult === null || flowTypeResult === void 0 ? void 0 : flowTypeResult.type, !!(flowTypeResult === null || flowTypeResult === void 0 ? void 0 : flowTypeResult.isIncomplete));
                             }
-                            else if ((0, parseTreeUtils_1.isPartialMatchingExpression)(reference, assignmentFlowNode.node)) {
-                                // If the node partially matches the reference, we need to "kill" any narrowed
-                                // types further above this point. For example, if we see the sequence
-                                //    a.b = 3
-                                //    a = Foo()
-                                //    x = a.b
-                                // The type of "a.b" can no longer be assumed to be Literal[3].
-                                return {
-                                    type: initialType,
-                                    isIncomplete: isInitialTypeIncomplete,
-                                };
+                            else {
+                                // Is this a simple assignment to an index expression? If so, it could
+                                // be assigning to a TypedDict, which requires narrowing of the expression's
+                                // base type.
+                                if (targetNode.nodeType === 24 /* Index */ &&
+                                    (0, parseTreeUtils_1.isMatchingExpression)(reference, targetNode.baseExpression)) {
+                                    if (((_a = targetNode.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 3 /* Assignment */ &&
+                                        targetNode.items.length === 1 &&
+                                        !targetNode.trailingComma &&
+                                        !targetNode.items[0].name &&
+                                        targetNode.items[0].argumentCategory === 0 /* Simple */ &&
+                                        targetNode.items[0].valueExpression.nodeType === 48 /* StringList */ &&
+                                        targetNode.items[0].valueExpression.strings.length === 1 &&
+                                        targetNode.items[0].valueExpression.strings[0].nodeType === 49 /* String */) {
+                                        const keyValue = targetNode.items[0].valueExpression.strings[0].value;
+                                        const narrowedResult = preventRecursion(assignmentFlowNode, () => {
+                                            const flowTypeResult = getTypeFromFlowNode(assignmentFlowNode.antecedent);
+                                            if (flowTypeResult.type) {
+                                                flowTypeResult.type = (0, typeUtils_1.mapSubtypes)(flowTypeResult.type, (subtype) => {
+                                                    if ((0, types_1.isClass)(subtype) && types_1.ClassType.isTypedDictClass(subtype)) {
+                                                        return (0, typedDicts_1.narrowForKeyAssignment)(subtype, keyValue);
+                                                    }
+                                                    return subtype;
+                                                });
+                                            }
+                                            return flowTypeResult;
+                                        });
+                                        return setCacheEntry(curFlowNode, narrowedResult === null || narrowedResult === void 0 ? void 0 : narrowedResult.type, !!(narrowedResult === null || narrowedResult === void 0 ? void 0 : narrowedResult.isIncomplete));
+                                    }
+                                }
+                                if ((0, parseTreeUtils_1.isPartialMatchingExpression)(reference, targetNode)) {
+                                    // If the node partially matches the reference, we need to "kill" any narrowed
+                                    // types further above this point. For example, if we see the sequence
+                                    //    a.b = 3
+                                    //    a = Foo()
+                                    //    x = a.b
+                                    // The type of "a.b" can no longer be assumed to be Literal[3].
+                                    return {
+                                        type: initialType,
+                                        isIncomplete: isInitialTypeIncomplete,
+                                    };
+                                }
                             }
                         }
                         curFlowNode = assignmentFlowNode.antecedent;
@@ -312,22 +348,12 @@ function getCodeFlowEngine(evaluator, speculativeTypeTracker) {
                                 continue;
                             }
                         }
-                        return getTypeFromLoopFlowNode(loopNode);
+                        return getTypeFromLoopFlowNode(loopNode, cachedEntry);
                     }
                     if (curFlowNode.flags & (codeFlowTypes_1.FlowFlags.TrueCondition | codeFlowTypes_1.FlowFlags.FalseCondition)) {
                         const conditionalFlowNode = curFlowNode;
                         if (reference) {
-                            // Was an incomplete entry added to prevent recursion?
-                            if (cachedEntry === null || cachedEntry === void 0 ? void 0 : cachedEntry.isRecursionSentinel) {
-                                return cachedEntry;
-                            }
-                            // Before calling getTypeNarrowingCallback, set the type
-                            // of this flow node in the cache to prevent recursion.
-                            setCacheEntry(curFlowNode, 
-                            /* type */ undefined, 
-                            /* isIncomplete */ true, 
-                            /* isRecursionSentinel */ true);
-                            try {
+                            const narrowedResult = preventRecursion(curFlowNode, () => {
                                 const typeNarrowingCallback = (0, typeGuards_1.getTypeNarrowingCallback)(evaluator, reference, conditionalFlowNode.expression, !!(conditionalFlowNode.flags &
                                     (codeFlowTypes_1.FlowFlags.TrueCondition | codeFlowTypes_1.FlowFlags.TrueNeverCondition)));
                                 if (typeNarrowingCallback) {
@@ -338,13 +364,10 @@ function getCodeFlowEngine(evaluator, speculativeTypeTracker) {
                                     }
                                     return setCacheEntry(curFlowNode, flowType, flowTypeResult.isIncomplete);
                                 }
-                                deleteCacheEntry(curFlowNode);
-                            }
-                            catch (e) {
-                                // We don't use finally here because the debugger
-                                // doesn't handle it well during single stepping.
-                                deleteCacheEntry(curFlowNode);
-                                throw e;
+                                return undefined;
+                            });
+                            if (narrowedResult) {
+                                return narrowedResult;
                             }
                         }
                         curFlowNode = conditionalFlowNode.antecedent;
@@ -363,12 +386,7 @@ function getCodeFlowEngine(evaluator, speculativeTypeTracker) {
                                 const symbolWithScope = evaluator.lookUpSymbolRecursive(conditionalFlowNode.reference, conditionalFlowNode.reference.value, 
                                 /* honorCodeFlow */ false);
                                 if (symbolWithScope && symbolWithScope.symbol.getTypedDeclarations().length > 0) {
-                                    // Before calling getTypeNarrowingCallback, set the type
-                                    // of this flow node in the cache to prevent recursion.
-                                    setCacheEntry(curFlowNode, reference ? undefined : initialType, 
-                                    /* isIncomplete */ true, 
-                                    /* isRecursionSentinel */ true);
-                                    try {
+                                    const result = preventRecursion(curFlowNode, () => {
                                         const typeNarrowingCallback = (0, typeGuards_1.getTypeNarrowingCallback)(evaluator, conditionalFlowNode.reference, conditionalFlowNode.expression, !!(conditionalFlowNode.flags &
                                             (codeFlowTypes_1.FlowFlags.TrueCondition | codeFlowTypes_1.FlowFlags.TrueNeverCondition)));
                                         if (typeNarrowingCallback) {
@@ -379,13 +397,10 @@ function getCodeFlowEngine(evaluator, speculativeTypeTracker) {
                                                 return setCacheEntry(curFlowNode, undefined, !!refTypeInfo.isIncomplete);
                                             }
                                         }
-                                        deleteCacheEntry(curFlowNode);
-                                    }
-                                    catch (e) {
-                                        // We don't use finally here because the debugger
-                                        // doesn't handle it well during single stepping.
-                                        deleteCacheEntry(curFlowNode);
-                                        throw e;
+                                        return undefined;
+                                    });
+                                    if (result) {
+                                        return result;
                                     }
                                 }
                             }
@@ -445,19 +460,10 @@ function getCodeFlowEngine(evaluator, speculativeTypeTracker) {
                         if (reference && reference.nodeType === 38 /* Name */) {
                             const nameValue = reference.value;
                             if (wildcardImportFlowNode.names.some((name) => name === nameValue)) {
-                                // Before calling getTypeFromWildcardImport, set the cache entry to prevent infinite recursion.
-                                setCacheEntry(curFlowNode, 
-                                /* type */ undefined, 
-                                /* isIncomplete */ true, 
-                                /* isRecursionSentinel */ true);
-                                try {
+                                return preventRecursion(curFlowNode, () => {
                                     const type = getTypeFromWildcardImport(wildcardImportFlowNode, nameValue);
                                     return setCacheEntry(curFlowNode, type, /* isIncomplete */ false);
-                                }
-                                catch (e) {
-                                    deleteCacheEntry(curFlowNode);
-                                    throw e;
-                                }
+                                });
                             }
                         }
                         curFlowNode = wildcardImportFlowNode.antecedent;
@@ -472,130 +478,124 @@ function getCodeFlowEngine(evaluator, speculativeTypeTracker) {
                 const typesToCombine = [];
                 let sawIncomplete = false;
                 let isProvenReachable = false;
-                // Set the cache entry to undefined before evaluating the
-                // expression in case it depends on itself.
-                setCacheEntry(branchNode, reference ? undefined : initialType, 
-                /* isIncomplete */ true, 
-                /* isRecursionSentinel */ true);
-                branchNode.antecedents.forEach((antecedent) => {
-                    // If we're solving for "reachability", and we have now proven
-                    // reachability, there's no reason to do more work.
-                    if (reference === undefined && isProvenReachable) {
-                        return;
-                    }
-                    const flowTypeResult = getTypeFromFlowNode(antecedent);
-                    if (flowTypeResult.isIncomplete) {
-                        sawIncomplete = true;
-                    }
-                    if (reference === undefined && flowTypeResult.type !== undefined) {
-                        isProvenReachable = true;
-                    }
-                    if (flowTypeResult.type) {
-                        typesToCombine.push(flowTypeResult.type);
+                return preventRecursion(branchNode, () => {
+                    branchNode.antecedents.forEach((antecedent) => {
+                        // If we're solving for "reachability", and we have now proven
+                        // reachability, there's no reason to do more work.
+                        if (reference === undefined && isProvenReachable) {
+                            return;
+                        }
+                        const flowTypeResult = getTypeFromFlowNode(antecedent);
+                        if (flowTypeResult.isIncomplete) {
+                            sawIncomplete = true;
+                        }
+                        if (reference === undefined && flowTypeResult.type !== undefined) {
+                            isProvenReachable = true;
+                        }
+                        if (flowTypeResult.type) {
+                            typesToCombine.push(flowTypeResult.type);
+                        }
+                    });
+                    if (isProvenReachable) {
+                        return setCacheEntry(branchNode, initialType, /* isIncomplete */ false);
                     }
+                    const effectiveType = typesToCombine.length > 0 ? (0, types_1.combineTypes)(typesToCombine) : undefined;
+                    return setCacheEntry(branchNode, effectiveType, sawIncomplete);
                 });
-                if (isProvenReachable) {
-                    return setCacheEntry(branchNode, initialType, /* isIncomplete */ false);
-                }
-                const effectiveType = typesToCombine.length > 0 ? (0, types_1.combineTypes)(typesToCombine) : undefined;
-                return setCacheEntry(branchNode, effectiveType, sawIncomplete);
             }
-            function getTypeFromLoopFlowNode(loopNode) {
-                var _a, _b;
-                // See if we've been here before. If so, there will be an incomplete cache entry.
-                let cacheEntry = getCacheEntry(loopNode);
+            function getTypeFromLoopFlowNode(loopNode, cacheEntry) {
                 // The type result from one antecedent may depend on the type
                 // result from another, so loop up to one time for each
                 // antecedent in the loop.
                 const maxAttemptCount = loopNode.antecedents.length;
-                if (cacheEntry === undefined) {
-                    // We haven't been here before, so create a new incomplete cache entry.
-                    cacheEntry = setCacheEntry(loopNode, reference ? undefined : initialType, 
-                    /* isIncomplete */ true, 
-                    /* isRecursionSentinel */ true);
-                }
-                else if ((_a = cacheEntry.incompleteSubtypes) === null || _a === void 0 ? void 0 : _a.some((subtype) => subtype.isPending)) {
-                    // If there are pending entries that have not been evaluated even once,
-                    // treat it as incomplete.
-                    const isIncomplete = cacheEntry.incompleteSubtypes.length < loopNode.antecedents.length ||
-                        cacheEntry.incompleteSubtypes.some((subtype) => subtype.isPending && subtype.evaluationCount < maxAttemptCount);
-                    return { type: cacheEntry.type, isIncomplete };
-                }
-                let attemptCount = 0;
-                while (true) {
-                    let sawIncomplete = false;
-                    let isProvenReachable = reference === undefined &&
-                        ((_b = cacheEntry.incompleteSubtypes) === null || _b === void 0 ? void 0 : _b.some((subtype) => subtype.type !== undefined));
-                    loopNode.antecedents.forEach((antecedent, index) => {
-                        var _a;
-                        // If we've trying to determine reachability and we've already proven
-                        // reachability, then we're done.
-                        if (reference === undefined && isProvenReachable) {
-                            return;
-                        }
-                        cacheEntry = getCacheEntry(loopNode);
-                        // Have we already been here (i.e. does the entry exist and is
-                        // not marked "pending")? If so, we can use the type that was already
-                        // computed if it is complete.
-                        const subtypeEntry = cacheEntry.incompleteSubtypes !== undefined && index < cacheEntry.incompleteSubtypes.length
-                            ? cacheEntry.incompleteSubtypes[index]
-                            : undefined;
-                        if (subtypeEntry === undefined || (!(subtypeEntry === null || subtypeEntry === void 0 ? void 0 : subtypeEntry.isPending) && (subtypeEntry === null || subtypeEntry === void 0 ? void 0 : subtypeEntry.isIncomplete))) {
-                            const entryEvaluationCount = subtypeEntry === undefined ? 0 : subtypeEntry.evaluationCount;
-                            // Set this entry to "pending" to prevent infinite recursion.
-                            // We'll mark it "not pending" below.
-                            cacheEntry = setIncompleteSubtype(loopNode, index, (_a = subtypeEntry === null || subtypeEntry === void 0 ? void 0 : subtypeEntry.type) !== null && _a !== void 0 ? _a : (reference ? undefined : initialType), 
-                            /* isIncomplete */ true, 
-                            /* isPending */ true, entryEvaluationCount);
-                            try {
-                                const flowTypeResult = getTypeFromFlowNode(antecedent);
-                                if (flowTypeResult.isIncomplete) {
-                                    sawIncomplete = true;
-                                }
-                                cacheEntry = setIncompleteSubtype(loopNode, index, flowTypeResult.type, flowTypeResult.isIncomplete, 
-                                /* isPending */ false, entryEvaluationCount + 1);
+                return preventRecursion(loopNode, () => {
+                    var _a, _b;
+                    if (cacheEntry === undefined) {
+                        // We haven't been here before, so create a new incomplete cache entry.
+                        cacheEntry = setCacheEntry(loopNode, reference ? undefined : initialType, 
+                        /* isIncomplete */ true);
+                    }
+                    else if ((_a = cacheEntry.incompleteSubtypes) === null || _a === void 0 ? void 0 : _a.some((subtype) => subtype.isPending)) {
+                        // If there are pending entries that have not been evaluated even once,
+                        // treat it as incomplete.
+                        const isIncomplete = cacheEntry.incompleteSubtypes.length < loopNode.antecedents.length ||
+                            cacheEntry.incompleteSubtypes.some((subtype) => subtype.isPending && subtype.evaluationCount < maxAttemptCount);
+                        return { type: cacheEntry.type, isIncomplete };
+                    }
+                    let attemptCount = 0;
+                    while (true) {
+                        let sawIncomplete = false;
+                        let isProvenReachable = reference === undefined &&
+                            ((_b = cacheEntry.incompleteSubtypes) === null || _b === void 0 ? void 0 : _b.some((subtype) => subtype.type !== undefined));
+                        loopNode.antecedents.forEach((antecedent, index) => {
+                            var _a;
+                            // If we've trying to determine reachability and we've already proven
+                            // reachability, then we're done.
+                            if (reference === undefined && isProvenReachable) {
+                                return;
                             }
-                            catch (e) {
-                                setIncompleteSubtype(loopNode, index, undefined, 
+                            cacheEntry = getCacheEntry(loopNode);
+                            // Have we already been here (i.e. does the entry exist and is
+                            // not marked "pending")? If so, we can use the type that was already
+                            // computed if it is complete.
+                            const subtypeEntry = cacheEntry.incompleteSubtypes !== undefined &&
+                                index < cacheEntry.incompleteSubtypes.length
+                                ? cacheEntry.incompleteSubtypes[index]
+                                : undefined;
+                            if (subtypeEntry === undefined ||
+                                (!(subtypeEntry === null || subtypeEntry === void 0 ? void 0 : subtypeEntry.isPending) && (subtypeEntry === null || subtypeEntry === void 0 ? void 0 : subtypeEntry.isIncomplete))) {
+                                const entryEvaluationCount = subtypeEntry === undefined ? 0 : subtypeEntry.evaluationCount;
+                                // Set this entry to "pending" to prevent infinite recursion.
+                                // We'll mark it "not pending" below.
+                                cacheEntry = setIncompleteSubtype(loopNode, index, (_a = subtypeEntry === null || subtypeEntry === void 0 ? void 0 : subtypeEntry.type) !== null && _a !== void 0 ? _a : (reference ? undefined : initialType), 
                                 /* isIncomplete */ true, 
-                                /* isPending */ false, entryEvaluationCount + 1);
-                                throw e;
+                                /* isPending */ true, entryEvaluationCount);
+                                try {
+                                    const flowTypeResult = getTypeFromFlowNode(antecedent);
+                                    if (flowTypeResult.isIncomplete) {
+                                        sawIncomplete = true;
+                                    }
+                                    cacheEntry = setIncompleteSubtype(loopNode, index, flowTypeResult.type, flowTypeResult.isIncomplete, 
+                                    /* isPending */ false, entryEvaluationCount + 1);
+                                }
+                                catch (e) {
+                                    setIncompleteSubtype(loopNode, index, undefined, 
+                                    /* isIncomplete */ true, 
+                                    /* isPending */ false, entryEvaluationCount + 1);
+                                    throw e;
+                                }
                             }
+                            if (reference === undefined && (cacheEntry === null || cacheEntry === void 0 ? void 0 : cacheEntry.type) !== undefined) {
+                                isProvenReachable = true;
+                            }
+                        });
+                        if (isProvenReachable) {
+                            return setCacheEntry(loopNode, initialType, /* isIncomplete */ false);
                         }
-                        if (reference === undefined && (cacheEntry === null || cacheEntry === void 0 ? void 0 : cacheEntry.type) !== undefined) {
-                            isProvenReachable = true;
-                        }
-                    });
-                    if (isProvenReachable) {
-                        return setCacheEntry(loopNode, initialType, /* isIncomplete */ false);
-                    }
-                    let effectiveType = cacheEntry.type;
-                    if (sawIncomplete) {
-                        // If there is an incomplete "Unknown" type within a union type, remove
-                        // it. Otherwise we might end up resolving the cycle with a type
-                        // that includes an undesirable unknown.
-                        if (effectiveType) {
-                            const typeWithoutUnknown = (0, types_1.removeIncompleteUnknownFromUnion)(effectiveType);
-                            if (!(0, types_1.isNever)(typeWithoutUnknown)) {
-                                effectiveType = typeWithoutUnknown;
+                        let effectiveType = cacheEntry.type;
+                        if (sawIncomplete) {
+                            // If there is an incomplete "Unknown" type within a union type, remove
+                            // it. Otherwise we might end up resolving the cycle with a type
+                            // that includes an undesirable unknown.
+                            if (effectiveType) {
+                                const typeWithoutUnknown = (0, types_1.removeIncompleteUnknownFromUnion)(effectiveType);
+                                if (!(0, types_1.isNever)(typeWithoutUnknown)) {
+                                    effectiveType = typeWithoutUnknown;
+                                }
                             }
                         }
+                        if (!sawIncomplete || attemptCount >= maxAttemptCount) {
+                            return setCacheEntry(loopNode, effectiveType, /* isIncomplete */ false);
+                        }
+                        attemptCount++;
                     }
-                    if (!sawIncomplete || attemptCount >= maxAttemptCount) {
-                        return setCacheEntry(loopNode, effectiveType, /* isIncomplete */ false);
-                    }
-                    attemptCount++;
-                }
+                });
             }
             function getTypeFromPreFinallyGateFlowNode(preFinallyFlowNode) {
                 if (preFinallyFlowNode.isGateClosed) {
                     return { type: undefined, isIncomplete: false };
                 }
-                // Before recursively calling, set the cache entry to prevent infinite recursion.
-                setCacheEntry(preFinallyFlowNode, reference ? undefined : initialType, 
-                /* isIncomplete */ true, 
-                /* isRecursionSentinel */ true);
-                try {
+                return preventRecursion(preFinallyFlowNode, () => {
                     const flowTypeResult = getTypeFromFlowNode(preFinallyFlowNode.antecedent);
                     // We want to cache the type only if we're evaluating the "gate closed" path.
                     deleteCacheEntry(preFinallyFlowNode);
@@ -603,11 +603,7 @@ function getCodeFlowEngine(evaluator, speculativeTypeTracker) {
                         type: flowTypeResult.type,
                         isIncomplete: flowTypeResult.isIncomplete,
                     };
-                }
-                catch (e) {
-                    deleteCacheEntry(preFinallyFlowNode);
-                    throw e;
-                }
+                });
             }
             function getTypeFromPostFinallyFlowNode(postFinallyFlowNode) {
                 const wasGateClosed = postFinallyFlowNode.preFinallyGate.isGateClosed;
@@ -966,12 +962,10 @@ function getCodeFlowEngine(evaluator, speculativeTypeTracker) {
                 else if ((0, types_1.isOverloadedFunction)(callSubtype)) {
                     let overloadCount = 0;
                     let noReturnOverloadCount = 0;
-                    callSubtype.overloads.forEach((overload) => {
-                        if (types_1.FunctionType.isOverloaded(overload)) {
-                            overloadCount++;
-                            if (isFunctionNoReturn(overload, isCallAwaited)) {
-                                noReturnOverloadCount++;
-                            }
+                    types_1.OverloadedFunctionType.getOverloads(callSubtype).forEach((overload) => {
+                        overloadCount++;
+                        if (isFunctionNoReturn(overload, isCallAwaited)) {
+                            noReturnOverloadCount++;
                         }
                     });
                     // Was at least one of the overloaded return types NoReturn?