@zzzen/pyright-internal 1.1.254

package/dist/analyzer/codeFlowEngine.js

@@ -0,0 +1,1132 @@
+"use strict";
+/*
+ * codeFlowEngine.ts
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT license.
+ * Author: Eric Traut
+ *
+ * Code that traverses the code flow graph to determine the (narrowed)
+ * type of a variable or expression or the reachability of a statement.
+ *
+ * This is largely based on the code flow engine in the
+ * TypeScript compiler.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCodeFlowEngine = void 0;
+const debug_1 = require("../common/debug");
+const positionUtils_1 = require("../common/positionUtils");
+const analyzerNodeInfo_1 = require("./analyzerNodeInfo");
+const codeFlowTypes_1 = require("./codeFlowTypes");
+const codeFlowUtils_1 = require("./codeFlowUtils");
+const parseTreeUtils_1 = require("./parseTreeUtils");
+const typeCache_1 = require("./typeCache");
+const typeGuards_1 = require("./typeGuards");
+const types_1 = require("./types");
+const typeUtils_1 = require("./typeUtils");
+// This debugging option prints the control flow graph when getTypeFromCodeFlow is called.
+const isPrintControlFlowGraphEnabled = false;
+// This debugging option prints the results of calls to isCallNoReturn.
+const isPrintCallNoReturnEnabled = false;
+function getCodeFlowEngine(evaluator, speculativeTypeTracker) {
+    const isReachableRecursionMap = new Map();
+    const callIsNoReturnCache = new Map();
+    const isExceptionContextManagerCache = new Map();
+    let flowIncompleteGeneration = 1;
+    let noReturnAnalysisDepth = 0;
+    let contextManagerAnalysisDepth = 0;
+    // Creates a new code flow analyzer that can be used to narrow the types
+    // of the expressions within an execution context. Each code flow analyzer
+    // instance maintains a cache of types it has already determined.
+    function createCodeFlowAnalyzer() {
+        const flowNodeTypeCacheSet = new Map();
+        function getFlowNodeTypeCacheForReference(referenceKey) {
+            let flowNodeTypeCache = flowNodeTypeCacheSet.get(referenceKey);
+            if (!flowNodeTypeCache) {
+                flowNodeTypeCache = new Map();
+                flowNodeTypeCacheSet.set(referenceKey, flowNodeTypeCache);
+            }
+            return flowNodeTypeCache;
+        }
+        function getTypeFromCodeFlow(flowNode, reference, targetSymbolId, initialType, isInitialTypeIncomplete, ignoreNoReturn) {
+            if (isPrintControlFlowGraphEnabled) {
+                printControlFlowGraph(flowNode, reference, 'getTypeFromCodeFlow');
+            }
+            const referenceKey = reference !== undefined ? (0, codeFlowTypes_1.createKeyForReference)(reference) : undefined;
+            let subexpressionReferenceKeys;
+            const referenceKeyWithSymbolId = referenceKey !== undefined && targetSymbolId !== undefined
+                ? referenceKey + `.${targetSymbolId.toString()}`
+                : '.';
+            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) {
+                if (!isIncomplete) {
+                    flowIncompleteGeneration++;
+                }
+                else if (type) {
+                    const prevEntry = flowNodeTypeCache.get(flowNode.id);
+                    if (prevEntry === undefined) {
+                        flowIncompleteGeneration++;
+                    }
+                    else if (prevEntry.isIncompleteType) {
+                        const prevIncompleteType = prevEntry;
+                        if (prevIncompleteType.type && !(0, types_1.isTypeSame)(prevIncompleteType.type, type)) {
+                            flowIncompleteGeneration++;
+                        }
+                    }
+                }
+                // For speculative or incomplete types, we'll create a separate
+                // object. For non-speculative and complete types, we'll store
+                // the type directly.
+                const entry = isIncomplete
+                    ? {
+                        isIncompleteType: true,
+                        type,
+                        incompleteSubtypes: [],
+                        generationCount: flowIncompleteGeneration,
+                        isRecursionSentinel,
+                    }
+                    : type;
+                flowNodeTypeCache.set(flowNode.id, entry);
+                speculativeTypeTracker.trackEntry(flowNodeTypeCache, 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);
+                if (cachedEntry === undefined || !(0, typeCache_1.isIncompleteType)(cachedEntry)) {
+                    (0, debug_1.fail)('setIncompleteSubtype can be called only on a valid incomplete cache entry');
+                }
+                const incompleteEntries = cachedEntry.incompleteSubtypes;
+                if (index < incompleteEntries.length) {
+                    const oldEntry = incompleteEntries[index];
+                    if (oldEntry.isIncomplete !== isIncomplete ||
+                        oldEntry.type === undefined ||
+                        type === undefined ||
+                        !(0, types_1.isTypeSame)(oldEntry.type, type)) {
+                        incompleteEntries[index] = { type, isIncomplete, isPending, evaluationCount };
+                        flowIncompleteGeneration++;
+                    }
+                    else if (oldEntry.isPending !== isPending) {
+                        incompleteEntries[index] = { type, isIncomplete, isPending, evaluationCount };
+                    }
+                }
+                else {
+                    (0, debug_1.assert)(incompleteEntries.length === index);
+                    incompleteEntries.push({ type, isIncomplete, isPending, evaluationCount });
+                    flowIncompleteGeneration++;
+                }
+                return getCacheEntry(flowNode);
+            }
+            function getCacheEntry(flowNode) {
+                if (!flowNodeTypeCache.has(flowNode.id)) {
+                    return undefined;
+                }
+                const cachedEntry = flowNodeTypeCache.get(flowNode.id);
+                if (cachedEntry === undefined) {
+                    return {
+                        type: cachedEntry,
+                        isIncomplete: false,
+                    };
+                }
+                if (!(0, typeCache_1.isIncompleteType)(cachedEntry)) {
+                    return {
+                        type: cachedEntry,
+                        isIncomplete: false,
+                    };
+                }
+                let type = cachedEntry.type;
+                if (cachedEntry.incompleteSubtypes.length > 0) {
+                    // Recompute the effective type based on all of the incomplete
+                    // types we've accumulated so far.
+                    const typesToCombine = [];
+                    cachedEntry.incompleteSubtypes.forEach((t) => {
+                        if (t.type) {
+                            typesToCombine.push(t.type);
+                        }
+                    });
+                    type = typesToCombine.length > 0 ? (0, types_1.combineTypes)(typesToCombine) : undefined;
+                }
+                return {
+                    type,
+                    isIncomplete: true,
+                    incompleteSubtypes: cachedEntry.incompleteSubtypes,
+                    generationCount: cachedEntry.generationCount,
+                    isRecursionSentinel: cachedEntry.isRecursionSentinel,
+                };
+            }
+            function deleteCacheEntry(flowNode) {
+                flowNodeTypeCache.delete(flowNode.id);
+            }
+            function evaluateAssignmentFlowNode(flowNode) {
+                // For function and class nodes, the reference node is the name
+                // node, but we need to use the parent node (the FunctionNode or ClassNode)
+                // to access the decorated type in the type cache.
+                let nodeForCacheLookup = flowNode.node;
+                const parentNode = flowNode.node.parent;
+                if (parentNode) {
+                    if (parentNode.nodeType === 28 /* Function */ || parentNode.nodeType === 10 /* Class */) {
+                        nodeForCacheLookup = parentNode;
+                    }
+                }
+                return evaluator.evaluateTypeForSubnode(nodeForCacheLookup, () => {
+                    evaluator.evaluateTypesForStatement(flowNode.node);
+                });
+            }
+            // 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) {
+                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
+                // will be thrown at this point.
+                evaluator.checkForCancellation();
+                while (true) {
+                    // Have we already been here? If so, use the cached value.
+                    const cachedEntry = getCacheEntry(curFlowNode);
+                    if (cachedEntry) {
+                        if (!cachedEntry.isIncomplete) {
+                            return cachedEntry;
+                        }
+                        // If the cached entry is incomplete, we can use it only if nothing
+                        // has changed that may cause the previously-reported incomplete type to change.
+                        if (cachedEntry.generationCount === flowIncompleteGeneration) {
+                            return { type: 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.
+                        return setCacheEntry(curFlowNode, types_1.NeverType.createNever(), /* isIncomplete */ false);
+                    }
+                    if (curFlowNode.flags & codeFlowTypes_1.FlowFlags.VariableAnnotation) {
+                        const varAnnotationNode = curFlowNode;
+                        curFlowNode = varAnnotationNode.antecedent;
+                        continue;
+                    }
+                    if (curFlowNode.flags & codeFlowTypes_1.FlowFlags.Call) {
+                        const callFlowNode = curFlowNode;
+                        // If this function returns a "NoReturn" type, that means
+                        // it always raises an exception or otherwise doesn't return,
+                        // so we can assume that the code before this is unreachable.
+                        if (!ignoreNoReturn && isCallNoReturn(evaluator, callFlowNode)) {
+                            return setCacheEntry(curFlowNode, /* type */ undefined, /* isIncomplete */ false);
+                        }
+                        curFlowNode = callFlowNode.antecedent;
+                        continue;
+                    }
+                    if (curFlowNode.flags & codeFlowTypes_1.FlowFlags.Assignment) {
+                        const assignmentFlowNode = curFlowNode;
+                        // 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)) {
+                                // 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);
+                                if (flowTypeResult) {
+                                    if ((0, typeUtils_1.isTypeAliasPlaceholder)(flowTypeResult.type)) {
+                                        flowTypeResult = undefined;
+                                    }
+                                    else if (reference.nodeType === 35 /* MemberAccess */ &&
+                                        evaluator.isAsymmetricDescriptorAssignment(assignmentFlowNode.node)) {
+                                        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,
+                                };
+                            }
+                        }
+                        curFlowNode = assignmentFlowNode.antecedent;
+                        continue;
+                    }
+                    if (curFlowNode.flags & codeFlowTypes_1.FlowFlags.BranchLabel) {
+                        const branchFlowNode = curFlowNode;
+                        if (curFlowNode.flags & codeFlowTypes_1.FlowFlags.PostContextManager) {
+                            // Determine whether any of the context managers support exception
+                            // suppression. If not, none of its antecedents are reachable.
+                            const contextMgrNode = curFlowNode;
+                            const contextManagerSwallowsExceptions = contextMgrNode.expressions.some((expr) => isExceptionContextManager(evaluator, expr, contextMgrNode.isAsync));
+                            if (contextManagerSwallowsExceptions === contextMgrNode.blockIfSwallowsExceptions) {
+                                // Do not explore any further along this code flow path.
+                                return setCacheEntry(curFlowNode, /* type */ undefined, /* isIncomplete */ false);
+                            }
+                        }
+                        // Is the current symbol modified in any way within the scope of the branch?
+                        // If not, we can skip all processing within the branch scope.
+                        if (reference && branchFlowNode.preBranchAntecedent && branchFlowNode.affectedExpressions) {
+                            if (!subexpressionReferenceKeys) {
+                                subexpressionReferenceKeys = (0, codeFlowTypes_1.createKeysForReferenceSubexpressions)(reference);
+                            }
+                            if (!subexpressionReferenceKeys.some((key) => branchFlowNode.affectedExpressions.has(key)) &&
+                                isFlowNodeReachable(curFlowNode, branchFlowNode.preBranchAntecedent)) {
+                                curFlowNode = branchFlowNode.preBranchAntecedent;
+                                continue;
+                            }
+                        }
+                        return getTypeFromBranchFlowNode(curFlowNode);
+                    }
+                    if (curFlowNode.flags & codeFlowTypes_1.FlowFlags.LoopLabel) {
+                        const loopNode = curFlowNode;
+                        // Is the current symbol modified in any way within the loop? If not, we can skip all
+                        // processing within the loop and assume that the type comes from the first antecedent,
+                        // which feeds the loop.
+                        if (reference) {
+                            if (!subexpressionReferenceKeys) {
+                                subexpressionReferenceKeys = (0, codeFlowTypes_1.createKeysForReferenceSubexpressions)(reference);
+                            }
+                            if (!subexpressionReferenceKeys.some((key) => loopNode.affectedExpressions.has(key))) {
+                                curFlowNode = loopNode.antecedents[0];
+                                continue;
+                            }
+                        }
+                        return getTypeFromLoopFlowNode(loopNode);
+                    }
+                    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 typeNarrowingCallback = (0, typeGuards_1.getTypeNarrowingCallback)(evaluator, reference, conditionalFlowNode.expression, !!(conditionalFlowNode.flags &
+                                    (codeFlowTypes_1.FlowFlags.TrueCondition | codeFlowTypes_1.FlowFlags.TrueNeverCondition)));
+                                if (typeNarrowingCallback) {
+                                    const flowTypeResult = getTypeFromFlowNode(conditionalFlowNode.antecedent);
+                                    let flowType = flowTypeResult.type;
+                                    if (flowType) {
+                                        flowType = typeNarrowingCallback(flowType);
+                                    }
+                                    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;
+                            }
+                        }
+                        curFlowNode = conditionalFlowNode.antecedent;
+                        continue;
+                    }
+                    if (curFlowNode.flags & (codeFlowTypes_1.FlowFlags.TrueNeverCondition | codeFlowTypes_1.FlowFlags.FalseNeverCondition)) {
+                        const conditionalFlowNode = curFlowNode;
+                        if (conditionalFlowNode.reference) {
+                            // Don't allow apply if the conditional expression references the expression
+                            // we're already narrowing. This case will be handled by the TrueCondition
+                            // or FalseCondition node.
+                            if ((0, codeFlowTypes_1.createKeyForReference)(conditionalFlowNode.reference) !== referenceKey) {
+                                // Make sure the reference type has a declared type. If not,
+                                // don't bother trying to infer its type because that would be
+                                // too expensive.
+                                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 typeNarrowingCallback = (0, typeGuards_1.getTypeNarrowingCallback)(evaluator, conditionalFlowNode.reference, conditionalFlowNode.expression, !!(conditionalFlowNode.flags &
+                                            (codeFlowTypes_1.FlowFlags.TrueCondition | codeFlowTypes_1.FlowFlags.TrueNeverCondition)));
+                                        if (typeNarrowingCallback) {
+                                            const refTypeInfo = evaluator.getTypeOfExpression(conditionalFlowNode.reference);
+                                            const narrowedType = typeNarrowingCallback(refTypeInfo.type) || refTypeInfo.type;
+                                            // If the narrowed type is "never", don't allow further exploration.
+                                            if ((0, types_1.isNever)(narrowedType)) {
+                                                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;
+                                    }
+                                }
+                            }
+                        }
+                        curFlowNode = conditionalFlowNode.antecedent;
+                        continue;
+                    }
+                    if (curFlowNode.flags & codeFlowTypes_1.FlowFlags.ExhaustedMatch) {
+                        const exhaustedMatchFlowNode = curFlowNode;
+                        const narrowedTypeResult = evaluator.evaluateTypeForSubnode(exhaustedMatchFlowNode.node, () => {
+                            evaluator.evaluateTypesForMatchStatement(exhaustedMatchFlowNode.node);
+                        });
+                        // If the narrowed type is "never", don't allow further exploration.
+                        if (narrowedTypeResult && (0, types_1.isNever)(narrowedTypeResult.type)) {
+                            return setCacheEntry(curFlowNode, /* type */ undefined, !!narrowedTypeResult.isIncomplete);
+                        }
+                        curFlowNode = exhaustedMatchFlowNode.antecedent;
+                        continue;
+                    }
+                    if (curFlowNode.flags & codeFlowTypes_1.FlowFlags.NarrowForPattern) {
+                        const patternFlowNode = curFlowNode;
+                        if (!reference || (0, parseTreeUtils_1.isMatchingExpression)(reference, patternFlowNode.subjectExpression)) {
+                            const typeResult = evaluator.evaluateTypeForSubnode(patternFlowNode.statement, () => {
+                                if (patternFlowNode.statement.nodeType === 64 /* Case */) {
+                                    evaluator.evaluateTypesForCaseStatement(patternFlowNode.statement);
+                                }
+                                else {
+                                    evaluator.evaluateTypesForMatchStatement(patternFlowNode.statement);
+                                }
+                            });
+                            if (typeResult) {
+                                if (!reference) {
+                                    if ((0, types_1.isNever)(typeResult.type)) {
+                                        return setCacheEntry(curFlowNode, 
+                                        /* type */ undefined, !!typeResult.isIncomplete);
+                                    }
+                                }
+                                else {
+                                    return setCacheEntry(curFlowNode, typeResult.type, !!typeResult.isIncomplete);
+                                }
+                            }
+                        }
+                        curFlowNode = patternFlowNode.antecedent;
+                        continue;
+                    }
+                    if (curFlowNode.flags & codeFlowTypes_1.FlowFlags.PreFinallyGate) {
+                        return getTypeFromPreFinallyGateFlowNode(curFlowNode);
+                    }
+                    if (curFlowNode.flags & codeFlowTypes_1.FlowFlags.PostFinally) {
+                        return getTypeFromPostFinallyFlowNode(curFlowNode);
+                    }
+                    if (curFlowNode.flags & codeFlowTypes_1.FlowFlags.Start) {
+                        return setCacheEntry(curFlowNode, initialType, isInitialTypeIncomplete);
+                    }
+                    if (curFlowNode.flags & codeFlowTypes_1.FlowFlags.WildcardImport) {
+                        const wildcardImportFlowNode = curFlowNode;
+                        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 {
+                                    const type = getTypeFromWildcardImport(wildcardImportFlowNode, nameValue);
+                                    return setCacheEntry(curFlowNode, type, /* isIncomplete */ false);
+                                }
+                                catch (e) {
+                                    deleteCacheEntry(curFlowNode);
+                                    throw e;
+                                }
+                            }
+                        }
+                        curFlowNode = wildcardImportFlowNode.antecedent;
+                        continue;
+                    }
+                    // We shouldn't get here.
+                    (0, debug_1.fail)('Unexpected flow node flags');
+                    return setCacheEntry(curFlowNode, /* type */ undefined, /* isIncomplete */ false);
+                }
+            }
+            function getTypeFromBranchFlowNode(branchNode) {
+                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);
+                    }
+                });
+                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);
+                // 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);
+                            }
+                            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);
+                    }
+                    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++;
+                }
+            }
+            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 {
+                    const flowTypeResult = getTypeFromFlowNode(preFinallyFlowNode.antecedent);
+                    // We want to cache the type only if we're evaluating the "gate closed" path.
+                    deleteCacheEntry(preFinallyFlowNode);
+                    return {
+                        type: flowTypeResult.type,
+                        isIncomplete: flowTypeResult.isIncomplete,
+                    };
+                }
+                catch (e) {
+                    deleteCacheEntry(preFinallyFlowNode);
+                    throw e;
+                }
+            }
+            function getTypeFromPostFinallyFlowNode(postFinallyFlowNode) {
+                const wasGateClosed = postFinallyFlowNode.preFinallyGate.isGateClosed;
+                try {
+                    postFinallyFlowNode.preFinallyGate.isGateClosed = true;
+                    let flowTypeResult;
+                    // Use speculative mode for the remainder of the finally suite
+                    // because the final types within this parse node block should be
+                    // evaluated when the gate is open.
+                    evaluator.useSpeculativeMode(postFinallyFlowNode.finallyNode, () => {
+                        flowTypeResult = getTypeFromFlowNode(postFinallyFlowNode.antecedent);
+                    });
+                    // If the type is incomplete, don't write back to the cache.
+                    return flowTypeResult.isIncomplete
+                        ? flowTypeResult
+                        : setCacheEntry(postFinallyFlowNode, flowTypeResult.type, /* isIncomplete */ false);
+                }
+                finally {
+                    postFinallyFlowNode.preFinallyGate.isGateClosed = wasGateClosed;
+                }
+            }
+            if (!flowNode) {
+                // This should happen only in cases where we're evaluating
+                // parse nodes that are created after the initial parse
+                // (namely, string literals that are used for forward
+                // referenced types).
+                return {
+                    type: initialType,
+                    isIncomplete: isInitialTypeIncomplete,
+                };
+            }
+            return getTypeFromFlowNode(flowNode);
+        }
+        return {
+            getTypeFromCodeFlow,
+        };
+    }
+    // Determines whether the specified flowNode can be reached by any
+    // control flow path within the execution context. If sourceFlowNode
+    // is specified, it returns true only if at least one control flow
+    // path passes through sourceFlowNode.
+    function isFlowNodeReachable(flowNode, sourceFlowNode, ignoreNoReturn = false) {
+        const visitedFlowNodeMap = new Set();
+        if (isPrintControlFlowGraphEnabled) {
+            printControlFlowGraph(flowNode, /* reference */ undefined, 'isFlowNodeReachable');
+        }
+        function isFlowNodeReachableRecursive(flowNode, sourceFlowNode, recursionCount = 0) {
+            // Cut off the recursion at some point to prevent a stack overflow.
+            const maxFlowNodeReachableRecursionCount = 64;
+            if (recursionCount > maxFlowNodeReachableRecursionCount) {
+                return true;
+            }
+            recursionCount++;
+            let curFlowNode = flowNode;
+            while (true) {
+                // If we've already visited this node, we can assume
+                // it wasn't reachable.
+                if (visitedFlowNodeMap.has(curFlowNode.id)) {
+                    return false;
+                }
+                // Note that we've been here before.
+                visitedFlowNodeMap.add(curFlowNode.id);
+                if (curFlowNode.flags & codeFlowTypes_1.FlowFlags.Unreachable) {
+                    return false;
+                }
+                if (curFlowNode === sourceFlowNode) {
+                    return true;
+                }
+                if (curFlowNode.flags &
+                    (codeFlowTypes_1.FlowFlags.VariableAnnotation |
+                        codeFlowTypes_1.FlowFlags.Assignment |
+                        codeFlowTypes_1.FlowFlags.TrueCondition |
+                        codeFlowTypes_1.FlowFlags.FalseCondition |
+                        codeFlowTypes_1.FlowFlags.WildcardImport |
+                        codeFlowTypes_1.FlowFlags.TrueNeverCondition |
+                        codeFlowTypes_1.FlowFlags.FalseNeverCondition |
+                        codeFlowTypes_1.FlowFlags.NarrowForPattern |
+                        codeFlowTypes_1.FlowFlags.ExhaustedMatch)) {
+                    const typedFlowNode = curFlowNode;
+                    curFlowNode = typedFlowNode.antecedent;
+                    continue;
+                }
+                if (curFlowNode.flags & codeFlowTypes_1.FlowFlags.Call) {
+                    const callFlowNode = curFlowNode;
+                    // If this function returns a "NoReturn" type, that means
+                    // it always raises an exception or otherwise doesn't return,
+                    // so we can assume that the code before this is unreachable.
+                    if (!ignoreNoReturn && isCallNoReturn(evaluator, callFlowNode)) {
+                        return false;
+                    }
+                    curFlowNode = callFlowNode.antecedent;
+                    continue;
+                }
+                if (curFlowNode.flags & (codeFlowTypes_1.FlowFlags.BranchLabel | codeFlowTypes_1.FlowFlags.LoopLabel)) {
+                    if (curFlowNode.flags & codeFlowTypes_1.FlowFlags.PostContextManager) {
+                        // Determine whether any of the context managers support exception
+                        // suppression. If not, none of its antecedents are reachable.
+                        const contextMgrNode = curFlowNode;
+                        if (!contextMgrNode.expressions.some((expr) => isExceptionContextManager(evaluator, expr, contextMgrNode.isAsync))) {
+                            return false;
+                        }
+                    }
+                    const labelNode = curFlowNode;
+                    for (const antecedent of labelNode.antecedents) {
+                        if (isFlowNodeReachableRecursive(antecedent, sourceFlowNode, recursionCount)) {
+                            return true;
+                        }
+                    }
+                    return false;
+                }
+                if (curFlowNode.flags & codeFlowTypes_1.FlowFlags.Start) {
+                    // If we hit the start but were looking for a particular source flow
+                    // node, return false. Otherwise, the start is what we're looking for.
+                    return sourceFlowNode ? false : true;
+                }
+                if (curFlowNode.flags & codeFlowTypes_1.FlowFlags.PreFinallyGate) {
+                    const preFinallyFlowNode = curFlowNode;
+                    if (preFinallyFlowNode.isGateClosed) {
+                        return false;
+                    }
+                    curFlowNode = preFinallyFlowNode.antecedent;
+                    continue;
+                }
+                if (curFlowNode.flags & codeFlowTypes_1.FlowFlags.PostFinally) {
+                    const postFinallyFlowNode = curFlowNode;
+                    const wasGateClosed = postFinallyFlowNode.preFinallyGate.isGateClosed;
+                    try {
+                        postFinallyFlowNode.preFinallyGate.isGateClosed = true;
+                        return isFlowNodeReachableRecursive(postFinallyFlowNode.antecedent, sourceFlowNode, recursionCount);
+                    }
+                    finally {
+                        postFinallyFlowNode.preFinallyGate.isGateClosed = wasGateClosed;
+                    }
+                }
+                // We shouldn't get here.
+                (0, debug_1.fail)('Unexpected flow node flags');
+                return false;
+            }
+        }
+        // Protect against infinite recursion.
+        if (isReachableRecursionMap.has(flowNode.id)) {
+            return true;
+        }
+        isReachableRecursionMap.set(flowNode.id, true);
+        try {
+            return isFlowNodeReachableRecursive(flowNode, sourceFlowNode);
+        }
+        finally {
+            isReachableRecursionMap.delete(flowNode.id);
+        }
+    }
+    // Determines whether the specified typeVar, which is assumed to be constrained,
+    // can be narrowed to one of its constrained types based on isinstance type
+    // guard checks.
+    function narrowConstrainedTypeVar(flowNode, typeVar) {
+        (0, debug_1.assert)(!typeVar.details.isParamSpec);
+        (0, debug_1.assert)(!typeVar.details.isVariadic);
+        (0, debug_1.assert)(!typeVar.details.boundType);
+        (0, debug_1.assert)(typeVar.details.constraints.length > 0);
+        const visitedFlowNodeMap = new Set();
+        const startingConstraints = [];
+        for (const constraint of typeVar.details.constraints) {
+            if ((0, types_1.isClassInstance)(constraint)) {
+                startingConstraints.push(constraint);
+            }
+            else {
+                // If one or more constraints are Unknown, Any, union types, etc.,
+                // we can't narrow them.
+                return undefined;
+            }
+        }
+        function narrowConstrainedTypeVarRecursive(flowNode, typeVar) {
+            let curFlowNode = flowNode;
+            while (true) {
+                if (visitedFlowNodeMap.has(curFlowNode.id)) {
+                    return startingConstraints;
+                }
+                if (curFlowNode.flags & (codeFlowTypes_1.FlowFlags.Unreachable | codeFlowTypes_1.FlowFlags.Start)) {
+                    return startingConstraints;
+                }
+                if (curFlowNode.flags &
+                    (codeFlowTypes_1.FlowFlags.VariableAnnotation |
+                        codeFlowTypes_1.FlowFlags.Assignment |
+                        codeFlowTypes_1.FlowFlags.WildcardImport |
+                        codeFlowTypes_1.FlowFlags.TrueNeverCondition |
+                        codeFlowTypes_1.FlowFlags.FalseNeverCondition |
+                        codeFlowTypes_1.FlowFlags.NarrowForPattern |
+                        codeFlowTypes_1.FlowFlags.ExhaustedMatch |
+                        codeFlowTypes_1.FlowFlags.PostFinally |
+                        codeFlowTypes_1.FlowFlags.PreFinallyGate |
+                        codeFlowTypes_1.FlowFlags.Call)) {
+                    const typedFlowNode = curFlowNode;
+                    curFlowNode = typedFlowNode.antecedent;
+                    continue;
+                }
+                if (curFlowNode.flags & (codeFlowTypes_1.FlowFlags.TrueCondition | codeFlowTypes_1.FlowFlags.FalseCondition)) {
+                    const conditionFlowNode = curFlowNode;
+                    const testExpression = conditionFlowNode.expression;
+                    const isPositiveTest = (curFlowNode.flags & codeFlowTypes_1.FlowFlags.TrueCondition) !== 0;
+                    if (testExpression.nodeType === 9 /* Call */ &&
+                        testExpression.leftExpression.nodeType === 38 /* Name */ &&
+                        testExpression.leftExpression.value === 'isinstance' &&
+                        testExpression.arguments.length === 2) {
+                        const arg0Expr = testExpression.arguments[0].valueExpression;
+                        const arg0Type = evaluator.getTypeOfExpression(arg0Expr).type;
+                        if (isCompatibleWithConstrainedTypeVar(arg0Type, typeVar)) {
+                            // Prevent infinite recursion by noting that we've been here before.
+                            visitedFlowNodeMap.add(curFlowNode.id);
+                            const priorRemainingConstraints = narrowConstrainedTypeVarRecursive(conditionFlowNode.antecedent, typeVar);
+                            visitedFlowNodeMap.delete(curFlowNode.id);
+                            const arg1Expr = testExpression.arguments[1].valueExpression;
+                            const arg1Type = evaluator.getTypeOfExpression(arg1Expr, 8 /* EvaluateStringLiteralAsType */ |
+                                32 /* ParamSpecDisallowed */ |
+                                128 /* TypeVarTupleDisallowed */).type;
+                            if ((0, types_1.isInstantiableClass)(arg1Type)) {
+                                return priorRemainingConstraints.filter((subtype) => {
+                                    if (types_1.ClassType.isSameGenericClass(subtype, arg1Type)) {
+                                        return isPositiveTest;
+                                    }
+                                    else {
+                                        return !isPositiveTest;
+                                    }
+                                });
+                            }
+                        }
+                    }
+                    curFlowNode = conditionFlowNode.antecedent;
+                    continue;
+                }
+                if (curFlowNode.flags & (codeFlowTypes_1.FlowFlags.BranchLabel | codeFlowTypes_1.FlowFlags.LoopLabel)) {
+                    const labelNode = curFlowNode;
+                    const newConstraints = [];
+                    // Prevent infinite recursion by noting that we've been here before.
+                    visitedFlowNodeMap.add(curFlowNode.id);
+                    for (const antecedent of labelNode.antecedents) {
+                        const constraintsToAdd = narrowConstrainedTypeVarRecursive(antecedent, typeVar);
+                        for (const constraint of constraintsToAdd) {
+                            if (!newConstraints.some((t) => (0, types_1.isTypeSame)(t, constraint))) {
+                                newConstraints.push(constraint);
+                            }
+                        }
+                    }
+                    visitedFlowNodeMap.delete(curFlowNode.id);
+                    return newConstraints;
+                }
+                // We shouldn't get here.
+                (0, debug_1.fail)('Unexpected flow node flags');
+                return startingConstraints;
+            }
+        }
+        const narrowedConstrainedType = narrowConstrainedTypeVarRecursive(flowNode, typeVar);
+        // Have we narrowed the typeVar to a single constraint?
+        return narrowedConstrainedType.length === 1 ? narrowedConstrainedType[0] : undefined;
+    }
+    // Determines whether a specified type is the same as a constrained
+    // TypeVar or is conditioned on that same TypeVar or is some union of
+    // the above.
+    function isCompatibleWithConstrainedTypeVar(type, typeVar) {
+        let isCompatible = true;
+        (0, typeUtils_1.doForEachSubtype)(type, (subtype) => {
+            if ((0, types_1.isTypeVar)(subtype)) {
+                if (!(0, types_1.isTypeSame)(subtype, typeVar)) {
+                    isCompatible = false;
+                }
+            }
+            else if (subtype.condition) {
+                if (!subtype.condition.some((condition) => condition.isConstrainedTypeVar && condition.typeVarName === typeVar.nameWithScope)) {
+                    isCompatible = false;
+                }
+            }
+            else {
+                isCompatible = false;
+            }
+        });
+        return isCompatible;
+    }
+    // Determines whether a call associated with this flow node returns a NoReturn
+    // type, thus preventing further traversal of the code flow graph.
+    function isCallNoReturn(evaluator, flowNode) {
+        const node = flowNode.node;
+        if (isPrintCallNoReturnEnabled) {
+            console.log(`isCallNoReturn@${flowNode.id} Pre depth ${noReturnAnalysisDepth}`);
+        }
+        // See if this information is cached already.
+        if (callIsNoReturnCache.has(node.id)) {
+            const result = callIsNoReturnCache.get(node.id);
+            if (isPrintCallNoReturnEnabled) {
+                console.log(`isCallNoReturn@${flowNode.id} Post: ${result ? 'true' : 'false'} (cached)`);
+            }
+            return result;
+        }
+        // See if we've exceeded the max recursion depth.
+        if (noReturnAnalysisDepth > types_1.maxTypeRecursionCount) {
+            return false;
+        }
+        // Initially set to false to avoid recursion.
+        callIsNoReturnCache.set(node.id, false);
+        noReturnAnalysisDepth++;
+        try {
+            let noReturnTypeCount = 0;
+            let subtypeCount = 0;
+            // Evaluate the call base type.
+            const callType = evaluator.getTypeOfExpression(node.leftExpression, 2 /* DoNotSpecialize */).type;
+            (0, typeUtils_1.doForEachSubtype)(callType, (callSubtype) => {
+                var _a;
+                // Track the number of subtypes we've examined.
+                subtypeCount++;
+                if ((0, types_1.isInstantiableClass)(callSubtype)) {
+                    // Does the class have a custom metaclass that implements a `__call__` method?
+                    // If so, it will be called instead of `__init__` or `__new__`. We'll assume
+                    // in this case that the __call__ method is not a NoReturn type.
+                    if (callSubtype.details.effectiveMetaclass &&
+                        (0, types_1.isClass)(callSubtype.details.effectiveMetaclass) &&
+                        !types_1.ClassType.isBuiltIn(callSubtype.details.effectiveMetaclass, 'type')) {
+                        const metaclassCallMember = (0, typeUtils_1.lookUpClassMember)(callSubtype.details.effectiveMetaclass, '__call__', 8 /* SkipInstanceVariables */ | 4 /* SkipObjectBaseClass */);
+                        if (metaclassCallMember) {
+                            return;
+                        }
+                    }
+                    let constructorMember = (0, typeUtils_1.lookUpClassMember)(callSubtype, '__init__', 8 /* SkipInstanceVariables */ | 4 /* SkipObjectBaseClass */);
+                    if (constructorMember === undefined) {
+                        constructorMember = (0, typeUtils_1.lookUpClassMember)(callSubtype, '__new__', 8 /* SkipInstanceVariables */ | 4 /* SkipObjectBaseClass */);
+                    }
+                    if (constructorMember) {
+                        const constructorType = evaluator.getTypeOfMember(constructorMember);
+                        if (constructorType) {
+                            if ((0, types_1.isFunction)(constructorType) || (0, types_1.isOverloadedFunction)(constructorType)) {
+                                const boundConstructorType = evaluator.bindFunctionToClassOrObject(undefined, constructorType);
+                                if (boundConstructorType) {
+                                    callSubtype = boundConstructorType;
+                                }
+                            }
+                        }
+                    }
+                }
+                else if ((0, types_1.isClassInstance)(callSubtype)) {
+                    const callMember = (0, typeUtils_1.lookUpClassMember)(callSubtype, '__call__', 8 /* SkipInstanceVariables */);
+                    if (callMember) {
+                        const callMemberType = evaluator.getTypeOfMember(callMember);
+                        if (callMemberType) {
+                            if ((0, types_1.isFunction)(callMemberType) || (0, types_1.isOverloadedFunction)(callMemberType)) {
+                                const boundCallType = evaluator.bindFunctionToClassOrObject(undefined, callMemberType);
+                                if (boundCallType) {
+                                    callSubtype = boundCallType;
+                                }
+                            }
+                        }
+                    }
+                }
+                const isCallAwaited = ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 6 /* Await */;
+                if ((0, types_1.isFunction)(callSubtype)) {
+                    if (isFunctionNoReturn(callSubtype, isCallAwaited)) {
+                        noReturnTypeCount++;
+                    }
+                }
+                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++;
+                            }
+                        }
+                    });
+                    // Was at least one of the overloaded return types NoReturn?
+                    if (noReturnOverloadCount > 0) {
+                        if (noReturnOverloadCount === overloadCount) {
+                            noReturnTypeCount++;
+                        }
+                        // For now, assume that if some (but not all) overloads return
+                        // NoReturn that the call is not a NoReturn.
+                    }
+                }
+            });
+            // The call is considered NoReturn if all subtypes evaluate to NoReturn.
+            const callIsNoReturn = subtypeCount > 0 && noReturnTypeCount === subtypeCount;
+            // Cache the value for next time.
+            callIsNoReturnCache.set(node.id, callIsNoReturn);
+            if (isPrintCallNoReturnEnabled) {
+                console.log(`isCallNoReturn@${flowNode.id} Post: ${callIsNoReturn ? 'true' : 'false'}`);
+            }
+            return callIsNoReturn;
+        }
+        finally {
+            noReturnAnalysisDepth--;
+        }
+    }
+    function isFunctionNoReturn(functionType, isCallAwaited) {
+        const returnType = functionType.details.declaredReturnType;
+        if (types_1.FunctionType.isAsync(functionType)) {
+            if (returnType &&
+                (0, types_1.isClassInstance)(returnType) &&
+                types_1.ClassType.isBuiltIn(returnType, 'Coroutine') &&
+                returnType.typeArguments &&
+                returnType.typeArguments.length >= 3) {
+                if ((0, types_1.isNever)(returnType.typeArguments[2]) && isCallAwaited) {
+                    return true;
+                }
+            }
+        }
+        else if (returnType) {
+            return (0, types_1.isNever)(returnType);
+        }
+        else if (functionType.details.declaration) {
+            // If the function has yield expressions, it's a generator, and
+            // we'll assume the yield statements are reachable. Also, don't
+            // infer a "no return" type for abstract methods.
+            if (!functionType.details.declaration.yieldStatements &&
+                !types_1.FunctionType.isAbstractMethod(functionType) &&
+                !types_1.FunctionType.isStubDefinition(functionType) &&
+                !types_1.FunctionType.isPyTypedDefinition(functionType)) {
+                // Check specifically for a common idiom where the only statement
+                // (other than a possible docstring) is a "raise NotImplementedError".
+                const functionStatements = functionType.details.declaration.node.suite.statements;
+                let foundRaiseNotImplemented = false;
+                for (const statement of functionStatements) {
+                    if (statement.nodeType !== 47 /* StatementList */ || statement.statements.length !== 1) {
+                        break;
+                    }
+                    const simpleStatement = statement.statements[0];
+                    if (simpleStatement.nodeType === 48 /* StringList */) {
+                        continue;
+                    }
+                    if (simpleStatement.nodeType === 43 /* Raise */ && simpleStatement.typeExpression) {
+                        // Check for "raise NotImplementedError" or "raise NotImplementedError()"
+                        const isNotImplementedName = (node) => {
+                            return (node === null || node === void 0 ? void 0 : node.nodeType) === 38 /* Name */ && node.value === 'NotImplementedError';
+                        };
+                        if (isNotImplementedName(simpleStatement.typeExpression)) {
+                            foundRaiseNotImplemented = true;
+                        }
+                        else if (simpleStatement.typeExpression.nodeType === 9 /* Call */ &&
+                            isNotImplementedName(simpleStatement.typeExpression.leftExpression)) {
+                            foundRaiseNotImplemented = true;
+                        }
+                    }
+                    break;
+                }
+                if (!foundRaiseNotImplemented && !isAfterNodeReachable(evaluator, functionType)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    function isAfterNodeReachable(evaluator, functionType) {
+        if (!functionType.details.declaration) {
+            return true;
+        }
+        return evaluator.isAfterNodeReachable(functionType.details.declaration.node);
+    }
+    // Performs a cursory analysis to determine whether the expression
+    // corresponds to a context manager object that supports the swallowing
+    // of exceptions. By convention, these objects have an "__exit__" method
+    // that returns a bool response (as opposed to a None). This function is
+    // called during code flow, so it can't rely on full type evaluation. It
+    // makes some simplifying assumptions that work in most cases.
+    function isExceptionContextManager(evaluator, node, isAsync) {
+        var _a;
+        // See if this information is cached already.
+        if (isExceptionContextManagerCache.has(node.id)) {
+            return isExceptionContextManagerCache.get(node.id);
+        }
+        // Initially set to false to avoid infinite recursion.
+        isExceptionContextManagerCache.set(node.id, false);
+        // See if we've exceeded the max recursion depth.
+        if (contextManagerAnalysisDepth > types_1.maxTypeRecursionCount) {
+            return false;
+        }
+        contextManagerAnalysisDepth++;
+        let cmSwallowsExceptions = false;
+        try {
+            const cmType = evaluator.getTypeOfExpression(node).type;
+            if (cmType && (0, types_1.isClassInstance)(cmType)) {
+                const exitMethodName = isAsync ? '__aexit__' : '__exit__';
+                const exitType = (_a = evaluator.getTypeOfObjectMember(node, cmType, exitMethodName)) === null || _a === void 0 ? void 0 : _a.type;
+                if (exitType && (0, types_1.isFunction)(exitType) && exitType.details.declaredReturnType) {
+                    const returnType = exitType.details.declaredReturnType;
+                    cmSwallowsExceptions = (0, types_1.isClassInstance)(returnType) && types_1.ClassType.isBuiltIn(returnType, 'bool');
+                }
+            }
+        }
+        finally {
+            contextManagerAnalysisDepth--;
+        }
+        // Cache the value for next time.
+        isExceptionContextManagerCache.set(node.id, cmSwallowsExceptions);
+        return cmSwallowsExceptions;
+    }
+    function getTypeFromWildcardImport(flowNode, name) {
+        const importInfo = (0, analyzerNodeInfo_1.getImportInfo)(flowNode.node.module);
+        (0, debug_1.assert)(importInfo !== undefined && importInfo.isImportFound);
+        (0, debug_1.assert)(flowNode.node.isWildcardImport);
+        const symbolWithScope = evaluator.lookUpSymbolRecursive(flowNode.node, name, /* honorCodeFlow */ false);
+        (0, debug_1.assert)(symbolWithScope !== undefined);
+        const decls = symbolWithScope.symbol.getDeclarations();
+        const wildcardDecl = decls.find((decl) => decl.node === flowNode.node);
+        if (!wildcardDecl) {
+            return types_1.UnknownType.create();
+        }
+        return evaluator.getInferredTypeOfDeclaration(symbolWithScope.symbol, wildcardDecl) || types_1.UnknownType.create();
+    }
+    function printControlFlowGraph(flowNode, reference, callName) {
+        let referenceText = '';
+        if (reference) {
+            const fileInfo = (0, analyzerNodeInfo_1.getFileInfo)(reference);
+            const pos = (0, positionUtils_1.convertOffsetToPosition)(reference.start, fileInfo.lines);
+            referenceText = `${(0, parseTreeUtils_1.printExpression)(reference)}[${pos.line + 1}:${pos.character + 1}]`;
+        }
+        console.log(`${callName}@${flowNode.id}: ${referenceText || '(none)'}`);
+        console.log((0, codeFlowUtils_1.formatControlFlowGraph)(flowNode));
+    }
+    return {
+        createCodeFlowAnalyzer,
+        isFlowNodeReachable,
+        narrowConstrainedTypeVar,
+    };
+}
+exports.getCodeFlowEngine = getCodeFlowEngine;
+//# sourceMappingURL=codeFlowEngine.js.map