@zzzen/pyright-internal 1.2.0-dev.20240630 → 1.2.0-dev.20240714

package/dist/analyzer/codeFlowEngine.d.ts

@@ -6,9 +6,11 @@ import { Type, TypeVarType } from './types';
 export interface FlowNodeTypeResult {
     type: Type | undefined;
     isIncomplete: boolean;
-    generationCount?: number | undefined;
-    incompleteType?: Type | undefined;
-    incompleteSubtypes?: IncompleteSubtypeInfo[] | undefined;
+    generationCount: number | undefined;
+    incompleteSubtypes: IncompleteSubtypeInfo[] | undefined;
+}
+export declare namespace FlowNodeTypeResult {
+    function create(type: Type | undefined, isIncomplete: boolean, generationCount?: number, incompleteSubtypes?: IncompleteSubtypeInfo[]): FlowNodeTypeResult;
 }
 export interface FlowNodeTypeOptions {
     targetSymbolId?: number;

package/dist/analyzer/codeFlowEngine.js

@@ -12,7 +12,7 @@
  * TypeScript compiler.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getCodeFlowEngine = exports.isIncompleteType = void 0;
+exports.getCodeFlowEngine = exports.isIncompleteType = exports.FlowNodeTypeResult = void 0;
 const debug_1 = require("../common/debug");
 const positionUtils_1 = require("../common/positionUtils");
 const analyzerNodeInfo_1 = require("./analyzerNodeInfo");
@@ -25,6 +25,18 @@ const typedDicts_1 = require("./typedDicts");
 const typeGuards_1 = require("./typeGuards");
 const types_1 = require("./types");
 const typeUtils_1 = require("./typeUtils");
+var FlowNodeTypeResult;
+(function (FlowNodeTypeResult) {
+    function create(type, isIncomplete, generationCount, incompleteSubtypes) {
+        return {
+            type,
+            isIncomplete,
+            generationCount,
+            incompleteSubtypes,
+        };
+    }
+    FlowNodeTypeResult.create = create;
+})(FlowNodeTypeResult || (exports.FlowNodeTypeResult = FlowNodeTypeResult = {}));
 // Define a user type guard function for IncompleteType.
 function isIncompleteType(cachedType) {
     return !!cachedType.isIncompleteType;
@@ -41,6 +53,7 @@ const enablePrintCallNoReturn = false;
 const inferNoReturnForUnannotatedFunctions = false;
 function getCodeFlowEngine(evaluator, speculativeTypeTracker) {
     const isReachableRecursionSet = new Set();
+    const reachabilityCache = new Map();
     const callIsNoReturnCache = new Map();
     const isExceptionContextManagerCache = new Map();
     let flowIncompleteGeneration = 1;
@@ -124,12 +137,7 @@ function getCodeFlowEngine(evaluator, speculativeTypeTracker) {
                     : type;
                 flowNodeTypeCache.cache.set(flowNode.id, entry);
                 speculativeTypeTracker.trackEntry(flowNodeTypeCache.cache, flowNode.id);
-                return {
-                    type,
-                    isIncomplete,
-                    generationCount: flowIncompleteGeneration,
-                    incompleteSubtypes: isIncomplete ? [] : undefined,
-                };
+                return FlowNodeTypeResult.create(type, isIncomplete, flowIncompleteGeneration, isIncomplete ? [] : undefined);
             }
             function setIncompleteSubtype(flowNode, index, type, isIncomplete, isPending, evaluationCount) {
                 const cachedEntry = flowNodeTypeCache.cache.get(flowNode.id);
@@ -181,17 +189,13 @@ function getCodeFlowEngine(evaluator, speculativeTypeTracker) {
                 }
                 const cachedEntry = flowNodeTypeCache.cache.get(flowNode.id);
                 if (cachedEntry === undefined) {
-                    return { type: undefined, isIncomplete: false };
+                    return FlowNodeTypeResult.create(/* type */ undefined, /* isIncomplete */ false);
                 }
                 if (!isIncompleteType(cachedEntry)) {
-                    return { type: cachedEntry, isIncomplete: false };
+                    return FlowNodeTypeResult.create(cachedEntry, /* isIncomplete */ false);
                 }
-                return {
-                    type: cachedEntry.type,
-                    isIncomplete: true,
-                    incompleteSubtypes: cachedEntry.incompleteSubtypes,
-                    generationCount: cachedEntry.generationCount,
-                };
+                return FlowNodeTypeResult.create(cachedEntry.type, 
+                /* isIncomplete */ true, cachedEntry.generationCount, cachedEntry.incompleteSubtypes);
             }
             function deleteCacheEntry(flowNode) {
                 flowNodeTypeCache.cache.delete(flowNode.id);
@@ -245,18 +249,14 @@ function getCodeFlowEngine(evaluator, speculativeTypeTracker) {
                         // 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 ? (0, typeUtils_1.cleanIncompleteUnknown)(cachedEntry.type) : undefined,
-                                isIncomplete: true,
-                            };
+                            return FlowNodeTypeResult.create(cachedEntry.type ? (0, typeUtils_1.cleanIncompleteUnknown)(cachedEntry.type) : undefined, 
+                            /* isIncomplete */ true);
                         }
                     }
                     // Check for recursion.
                     if (flowNodeTypeCache.pendingNodes.has(curFlowNode.id)) {
-                        return {
-                            type: (_a = cachedEntry === null || cachedEntry === void 0 ? void 0 : cachedEntry.type) !== null && _a !== void 0 ? _a : types_1.UnknownType.create(/* isIncomplete */ true),
-                            isIncomplete: true,
-                        };
+                        return FlowNodeTypeResult.create((_a = cachedEntry === null || cachedEntry === void 0 ? void 0 : cachedEntry.type) !== null && _a !== void 0 ? _a : types_1.UnknownType.create(/* isIncomplete */ true), 
+                        /* isIncomplete */ true);
                     }
                     if (curFlowNode.flags & codeFlowTypes_1.FlowFlags.Unreachable) {
                         // We can get here if there are nodes in a compound logical expression
@@ -311,10 +311,7 @@ function getCodeFlowEngine(evaluator, speculativeTypeTracker) {
                                 if (flowTypeResult) {
                                     if ((0, typeUtils_1.isTypeAliasPlaceholder)(flowTypeResult.type)) {
                                         // Don't cache a recursive type alias placeholder.
-                                        return {
-                                            type: flowTypeResult.type,
-                                            isIncomplete: true,
-                                        };
+                                        return FlowNodeTypeResult.create(flowTypeResult.type, /* isIncomplete */ true);
                                     }
                                     else if (reference.nodeType === 35 /* ParseNodeType.MemberAccess */ &&
                                         evaluator.isAsymmetricAccessorAssignment(targetNode)) {
@@ -327,16 +324,16 @@ function getCodeFlowEngine(evaluator, speculativeTypeTracker) {
                             // be assigning to a TypedDict, which requires narrowing of the expression's
                             // base type.
                             if (targetNode.nodeType === 27 /* ParseNodeType.Index */ &&
-                                (0, parseTreeUtils_1.isMatchingExpression)(reference, targetNode.baseExpression)) {
+                                (0, parseTreeUtils_1.isMatchingExpression)(reference, targetNode.d.leftExpr)) {
                                 if (((_b = targetNode.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 3 /* ParseNodeType.Assignment */ &&
-                                    targetNode.items.length === 1 &&
-                                    !targetNode.trailingComma &&
-                                    !targetNode.items[0].name &&
-                                    targetNode.items[0].argumentCategory === 0 /* ArgumentCategory.Simple */ &&
-                                    targetNode.items[0].valueExpression.nodeType === 48 /* ParseNodeType.StringList */ &&
-                                    targetNode.items[0].valueExpression.strings.length === 1 &&
-                                    targetNode.items[0].valueExpression.strings[0].nodeType === 49 /* ParseNodeType.String */) {
-                                    const keyValue = targetNode.items[0].valueExpression.strings[0].value;
+                                    targetNode.d.items.length === 1 &&
+                                    !targetNode.d.trailingComma &&
+                                    !targetNode.d.items[0].d.name &&
+                                    targetNode.d.items[0].d.argCategory === 0 /* ArgumentCategory.Simple */ &&
+                                    targetNode.d.items[0].d.valueExpr.nodeType === 48 /* ParseNodeType.StringList */ &&
+                                    targetNode.d.items[0].d.valueExpr.d.strings.length === 1 &&
+                                    targetNode.d.items[0].d.valueExpr.d.strings[0].nodeType === 49 /* ParseNodeType.String */) {
+                                    const keyValue = targetNode.d.items[0].d.valueExpr.d.strings[0].d.value;
                                     const narrowedResult = preventRecursion(assignmentFlowNode, () => {
                                         const flowTypeResult = getTypeFromFlowNode(assignmentFlowNode.antecedent);
                                         if (flowTypeResult.type) {
@@ -359,10 +356,7 @@ function getCodeFlowEngine(evaluator, speculativeTypeTracker) {
                                 //    a = Foo()
                                 //    x = a.b
                                 // The type of "a.b" can no longer be assumed to be Literal[3].
-                                return {
-                                    type: (_c = options === null || options === void 0 ? void 0 : options.typeAtStart) === null || _c === void 0 ? void 0 : _c.type,
-                                    isIncomplete: !!((_d = options === null || options === void 0 ? void 0 : options.typeAtStart) === null || _d === void 0 ? void 0 : _d.isIncomplete),
-                                };
+                                return FlowNodeTypeResult.create((_c = options === null || options === void 0 ? void 0 : options.typeAtStart) === null || _c === void 0 ? void 0 : _c.type, !!((_d = options === null || options === void 0 ? void 0 : options.typeAtStart) === null || _d === void 0 ? void 0 : _d.isIncomplete));
                             }
                         }
                         curFlowNode = assignmentFlowNode.antecedent;
@@ -450,7 +444,7 @@ function getCodeFlowEngine(evaluator, speculativeTypeTracker) {
                                 // 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, 
+                                const symbolWithScope = evaluator.lookUpSymbolRecursive(conditionalFlowNode.reference, conditionalFlowNode.reference.d.value, 
                                 /* honorCodeFlow */ false);
                                 if (symbolWithScope && symbolWithScope.symbol.hasTypedDeclarations()) {
                                     const result = preventRecursion(curFlowNode, () => {
@@ -561,7 +555,7 @@ function getCodeFlowEngine(evaluator, speculativeTypeTracker) {
                     if (curFlowNode.flags & codeFlowTypes_1.FlowFlags.WildcardImport) {
                         const wildcardImportFlowNode = curFlowNode;
                         if (reference && reference.nodeType === 38 /* ParseNodeType.Name */) {
-                            const nameValue = reference.value;
+                            const nameValue = reference.d.value;
                             if (wildcardImportFlowNode.names.some((name) => name === nameValue)) {
                                 return preventRecursion(curFlowNode, () => {
                                     const type = getTypeFromWildcardImport(wildcardImportFlowNode, nameValue);
@@ -614,10 +608,8 @@ function getCodeFlowEngine(evaluator, speculativeTypeTracker) {
                     // If entries have been added for all antecedents and there are pending entries
                     // that have not been evaluated even once, treat it as incomplete. We clean
                     // any incomplete unknowns from the type here to assist with type convergence.
-                    return {
-                        type: cacheEntry.type ? (0, typeUtils_1.cleanIncompleteUnknown)(cacheEntry.type) : undefined,
-                        isIncomplete: true,
-                    };
+                    return FlowNodeTypeResult.create(cacheEntry.type ? (0, typeUtils_1.cleanIncompleteUnknown)(cacheEntry.type) : undefined, 
+                    /* isIncomplete */ true);
                 }
                 let attemptCount = 0;
                 while (true) {
@@ -704,7 +696,7 @@ function getCodeFlowEngine(evaluator, speculativeTypeTracker) {
                         // entry because we'll overwrite a pending evaluation. The type that
                         // we return here doesn't matter as long as it's not undefined.
                         return sawPending
-                            ? { type: types_1.UnknownType.create(), isIncomplete: false }
+                            ? FlowNodeTypeResult.create(types_1.UnknownType.create(), /* isIncomplete */ false)
                             : setCacheEntry(loopNode, types_1.UnknownType.create(), /* isIncomplete */ false);
                     }
                     let effectiveType = cacheEntry.type;
@@ -741,12 +733,12 @@ function getCodeFlowEngine(evaluator, speculativeTypeTracker) {
                                 // other incomplete types based on this now-complete type.
                                 flowIncompleteGeneration++;
                             }
-                            return { type: effectiveType, isIncomplete: reportIncomplete };
+                            return FlowNodeTypeResult.create(effectiveType, reportIncomplete);
                         }
                         // If the first antecedent was pending, we skipped all of the other
                         // antecedents, so the type is incomplete.
                         if (firstAntecedentTypeIsPending) {
-                            return { type: effectiveType, isIncomplete: true };
+                            return FlowNodeTypeResult.create(effectiveType, /* isIncomplete */ true);
                         }
                         return setCacheEntry(loopNode, effectiveType, /* isIncomplete */ false);
                     }
@@ -756,15 +748,12 @@ function getCodeFlowEngine(evaluator, speculativeTypeTracker) {
             function getTypeFromPreFinallyGateFlowNode(preFinallyFlowNode) {
                 // Is the finally gate closed?
                 if (flowNodeTypeCache.closedFinallyGateNodes.has(preFinallyFlowNode.id)) {
-                    return { type: undefined, isIncomplete: false };
+                    return FlowNodeTypeResult.create(/* type */ undefined, /* isIncomplete */ false);
                 }
                 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,
-                };
+                return FlowNodeTypeResult.create(flowTypeResult.type, flowTypeResult.isIncomplete);
             }
             function getTypeFromPostFinallyFlowNode(postFinallyFlowNode) {
                 const wasGateClosed = flowNodeTypeCache.closedFinallyGateNodes.has(postFinallyFlowNode.preFinallyGate.id);
@@ -793,10 +782,7 @@ function getCodeFlowEngine(evaluator, speculativeTypeTracker) {
                 // parse nodes that are created after the initial parse
                 // (namely, string literals that are used for forward
                 // referenced types).
-                return {
-                    type: (_a = options === null || options === void 0 ? void 0 : options.typeAtStart) === null || _a === void 0 ? void 0 : _a.type,
-                    isIncomplete: !!((_b = options === null || options === void 0 ? void 0 : options.typeAtStart) === null || _b === void 0 ? void 0 : _b.isIncomplete),
-                };
+                return FlowNodeTypeResult.create((_a = options === null || options === void 0 ? void 0 : options.typeAtStart) === null || _a === void 0 ? void 0 : _a.type, !!((_b = options === null || options === void 0 ? void 0 : options.typeAtStart) === null || _b === void 0 ? void 0 : _b.isIncomplete));
             }
             return getTypeFromFlowNode(flowNode);
         }
@@ -814,7 +800,26 @@ function getCodeFlowEngine(evaluator, speculativeTypeTracker) {
         if (enablePrintControlFlowGraph) {
             printControlFlowGraph(flowNode, /* reference */ undefined, 'isFlowNodeReachable');
         }
-        function isFlowNodeReachableRecursive(flowNode, sourceFlowNode, recursionCount = 0) {
+        function cacheReachabilityResult(isReachable) {
+            // If there is a finally gate set, we will not cache the results
+            // because this can affect the reachability.
+            if (closedFinallyGateSet.size > 0) {
+                return isReachable;
+            }
+            let cacheEntry = reachabilityCache.get(flowNode.id);
+            if (!cacheEntry) {
+                cacheEntry = { isReachable: undefined, isReachableFrom: new Map() };
+                reachabilityCache.set(flowNode.id, cacheEntry);
+            }
+            if (!sourceFlowNode) {
+                cacheEntry.isReachable = isReachable;
+            }
+            else {
+                cacheEntry.isReachableFrom.set(sourceFlowNode.id, isReachable);
+            }
+            return isReachable;
+        }
+        function isFlowNodeReachableRecursive(flowNode, recursionCount = 0) {
             var _a;
             // Cut off the recursion at some point to prevent a stack overflow.
             const maxFlowNodeReachableRecursionCount = 64;
@@ -824,18 +829,33 @@ function getCodeFlowEngine(evaluator, speculativeTypeTracker) {
             recursionCount++;
             let curFlowNode = flowNode;
             while (true) {
+                // See if we've already cached this result.
+                const cacheEntry = reachabilityCache.get(flowNode.id);
+                if (cacheEntry !== undefined && closedFinallyGateSet.size === 0) {
+                    if (!sourceFlowNode) {
+                        if (cacheEntry.isReachable !== undefined) {
+                            return cacheEntry.isReachable;
+                        }
+                    }
+                    else {
+                        const isReachableFrom = cacheEntry.isReachableFrom.get(sourceFlowNode.id);
+                        if (isReachableFrom !== undefined) {
+                            return isReachableFrom;
+                        }
+                    }
+                }
                 // If we've already visited this node, we can assume
                 // it wasn't reachable.
                 if (visitedFlowNodeSet.has(curFlowNode.id)) {
-                    return false;
+                    return cacheReachabilityResult(false);
                 }
                 // Note that we've been here before.
                 visitedFlowNodeSet.add(curFlowNode.id);
                 if (curFlowNode.flags & codeFlowTypes_1.FlowFlags.Unreachable) {
-                    return false;
+                    return cacheReachabilityResult(false);
                 }
                 if (curFlowNode === sourceFlowNode) {
-                    return true;
+                    return cacheReachabilityResult(true);
                 }
                 if (curFlowNode.flags &
                     (codeFlowTypes_1.FlowFlags.VariableAnnotation |
@@ -857,7 +877,7 @@ function getCodeFlowEngine(evaluator, speculativeTypeTracker) {
                         // 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, 
+                        const symbolWithScope = evaluator.lookUpSymbolRecursive(conditionalFlowNode.reference, conditionalFlowNode.reference.d.value, 
                         /* honorCodeFlow */ false);
                         if (symbolWithScope && symbolWithScope.symbol.hasTypedDeclarations()) {
                             let isUnreachable = false;
@@ -871,7 +891,7 @@ function getCodeFlowEngine(evaluator, speculativeTypeTracker) {
                                 }
                             }
                             if (isUnreachable) {
-                                return false;
+                                return cacheReachabilityResult(false);
                             }
                         }
                     }
@@ -884,7 +904,7 @@ function getCodeFlowEngine(evaluator, speculativeTypeTracker) {
                     // 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;
+                        return cacheReachabilityResult(false);
                     }
                     curFlowNode = callFlowNode.antecedent;
                     continue;
@@ -895,26 +915,26 @@ function getCodeFlowEngine(evaluator, speculativeTypeTracker) {
                         // suppression. If not, none of its antecedents are reachable.
                         const contextMgrNode = curFlowNode;
                         if (!contextMgrNode.expressions.some((expr) => isExceptionContextManager(evaluator, expr, contextMgrNode.isAsync))) {
-                            return false;
+                            return cacheReachabilityResult(false);
                         }
                     }
                     const labelNode = curFlowNode;
                     for (const antecedent of labelNode.antecedents) {
-                        if (isFlowNodeReachableRecursive(antecedent, sourceFlowNode, recursionCount)) {
-                            return true;
+                        if (isFlowNodeReachableRecursive(antecedent, recursionCount)) {
+                            return cacheReachabilityResult(true);
                         }
                     }
-                    return false;
+                    return cacheReachabilityResult(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;
+                    return cacheReachabilityResult(sourceFlowNode ? false : true);
                 }
                 if (curFlowNode.flags & codeFlowTypes_1.FlowFlags.PreFinallyGate) {
                     const preFinallyFlowNode = curFlowNode;
                     if (closedFinallyGateSet.has(preFinallyFlowNode.id)) {
-                        return false;
+                        return cacheReachabilityResult(false);
                     }
                     curFlowNode = preFinallyFlowNode.antecedent;
                     continue;
@@ -924,7 +944,7 @@ function getCodeFlowEngine(evaluator, speculativeTypeTracker) {
                     const wasGateClosed = closedFinallyGateSet.has(postFinallyFlowNode.preFinallyGate.id);
                     try {
                         closedFinallyGateSet.add(postFinallyFlowNode.preFinallyGate.id);
-                        return isFlowNodeReachableRecursive(postFinallyFlowNode.antecedent, sourceFlowNode, recursionCount);
+                        return cacheReachabilityResult(isFlowNodeReachableRecursive(postFinallyFlowNode.antecedent, recursionCount));
                     }
                     finally {
                         if (!wasGateClosed) {
@@ -934,7 +954,7 @@ function getCodeFlowEngine(evaluator, speculativeTypeTracker) {
                 }
                 // We shouldn't get here.
                 (0, debug_1.fail)('Unexpected flow node flags');
-                return false;
+                return cacheReachabilityResult(false);
             }
         }
         // Protect against infinite recursion.
@@ -943,7 +963,7 @@ function getCodeFlowEngine(evaluator, speculativeTypeTracker) {
         }
         isReachableRecursionSet.add(flowNode.id);
         try {
-            return isFlowNodeReachableRecursive(flowNode, sourceFlowNode);
+            return isFlowNodeReachableRecursive(flowNode);
         }
         finally {
             isReachableRecursionSet.delete(flowNode.id);
@@ -953,13 +973,13 @@ function getCodeFlowEngine(evaluator, speculativeTypeTracker) {
     // 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);
+        (0, debug_1.assert)(!typeVar.shared.isParamSpec);
+        (0, debug_1.assert)(!typeVar.shared.isVariadic);
+        (0, debug_1.assert)(!typeVar.shared.boundType);
+        (0, debug_1.assert)(typeVar.shared.constraints.length > 0);
         const visitedFlowNodeMap = new Set();
         const startingConstraints = [];
-        for (const constraint of typeVar.details.constraints) {
+        for (const constraint of typeVar.shared.constraints) {
             if ((0, types_1.isClassInstance)(constraint)) {
                 startingConstraints.push(constraint);
             }
@@ -998,12 +1018,12 @@ function getCodeFlowEngine(evaluator, speculativeTypeTracker) {
                     if (narrowForPatternFlowNode.statement.nodeType === 64 /* ParseNodeType.Case */) {
                         const subjectType = evaluator.getTypeOfExpression(narrowForPatternFlowNode.subjectExpression).type;
                         if (isCompatibleWithConstrainedTypeVar(subjectType, typeVar)) {
-                            const patternNode = narrowForPatternFlowNode.statement.pattern;
+                            const patternNode = narrowForPatternFlowNode.statement.d.pattern;
                             if (patternNode.nodeType === 66 /* ParseNodeType.PatternAs */ &&
-                                patternNode.orPatterns.length === 1 &&
-                                patternNode.orPatterns[0].nodeType === 68 /* ParseNodeType.PatternClass */) {
-                                const classPatternNode = patternNode.orPatterns[0];
-                                const classType = evaluator.getTypeOfExpression(classPatternNode.className, 2 /* EvaluatorFlags.CallBaseDefaults */).type;
+                                patternNode.d.orPatterns.length === 1 &&
+                                patternNode.d.orPatterns[0].nodeType === 68 /* ParseNodeType.PatternClass */) {
+                                const classPatternNode = patternNode.d.orPatterns[0];
+                                const classType = evaluator.getTypeOfExpression(classPatternNode.d.className, 2 /* EvalFlags.CallBaseDefaults */).type;
                                 if ((0, types_1.isInstantiableClass)(classType)) {
                                     const priorRemainingConstraints = narrowConstrainedTypeVarRecursive(narrowForPatternFlowNode.antecedent, typeVar);
                                     return priorRemainingConstraints.filter((subtype) => types_1.ClassType.isSameGenericClass(subtype, classType));
@@ -1020,23 +1040,23 @@ function getCodeFlowEngine(evaluator, speculativeTypeTracker) {
                     const testExpression = conditionFlowNode.expression;
                     const isPositiveTest = (curFlowNode.flags & codeFlowTypes_1.FlowFlags.TrueCondition) !== 0;
                     if (testExpression.nodeType === 9 /* ParseNodeType.Call */ &&
-                        testExpression.leftExpression.nodeType === 38 /* ParseNodeType.Name */ &&
-                        testExpression.leftExpression.value === 'isinstance' &&
-                        testExpression.arguments.length === 2) {
-                        const arg0Expr = testExpression.arguments[0].valueExpression;
+                        testExpression.d.leftExpr.nodeType === 38 /* ParseNodeType.Name */ &&
+                        testExpression.d.leftExpr.d.value === 'isinstance' &&
+                        testExpression.d.args.length === 2) {
+                        const arg0Expr = testExpression.d.args[0].d.valueExpr;
                         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, 512 /* EvaluatorFlags.AllowMissingTypeArgs */ |
-                                8 /* EvaluatorFlags.EvaluateStringLiteralAsType */ |
-                                32 /* EvaluatorFlags.DisallowParamSpec */ |
-                                64 /* EvaluatorFlags.DisallowTypeVarTuple */ |
-                                16 /* EvaluatorFlags.DisallowFinal */ |
-                                2 /* EvaluatorFlags.DoNotSpecialize */).type;
+                            const arg1Expr = testExpression.d.args[1].d.valueExpr;
+                            const arg1Type = evaluator.getTypeOfExpression(arg1Expr, 512 /* EvalFlags.AllowMissingTypeArgs */ |
+                                8 /* EvalFlags.StrLiteralAsType */ |
+                                32 /* EvalFlags.NoParamSpec */ |
+                                64 /* EvalFlags.NoTypeVarTuple */ |
+                                16 /* EvalFlags.NoFinal */ |
+                                2 /* EvalFlags.NoSpecialize */).type;
                             if ((0, types_1.isInstantiableClass)(arg1Type)) {
                                 return priorRemainingConstraints.filter((subtype) => {
                                     if (types_1.ClassType.isSameGenericClass(subtype, arg1Type)) {
@@ -1083,14 +1103,15 @@ function getCodeFlowEngine(evaluator, speculativeTypeTracker) {
     function isCompatibleWithConstrainedTypeVar(type, typeVar) {
         let isCompatible = true;
         (0, typeUtils_1.doForEachSubtype)(type, (subtype) => {
+            var _a;
             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.typeVar.details.constraints.length > 0 &&
-                    condition.typeVar.nameWithScope === typeVar.nameWithScope)) {
+            else if ((_a = subtype.props) === null || _a === void 0 ? void 0 : _a.condition) {
+                if (!subtype.props.condition.some((condition) => condition.typeVar.shared.constraints.length > 0 &&
+                    condition.typeVar.priv.nameWithScope === typeVar.priv.nameWithScope)) {
                     isCompatible = false;
                 }
             }
@@ -1121,7 +1142,7 @@ function getCodeFlowEngine(evaluator, speculativeTypeTracker) {
         }
         // Don't attempt to evaluate a lambda call. We need to evaluate these in the
         // context of its arguments.
-        if (node.leftExpression.nodeType === 33 /* ParseNodeType.Lambda */) {
+        if (node.d.leftExpr.nodeType === 33 /* ParseNodeType.Lambda */) {
             return false;
         }
         // Initially set to false to avoid recursion.
@@ -1131,7 +1152,7 @@ function getCodeFlowEngine(evaluator, speculativeTypeTracker) {
             let noReturnTypeCount = 0;
             let subtypeCount = 0;
             // Evaluate the call base type.
-            const callTypeResult = evaluator.getTypeOfExpression(node.leftExpression, 2 /* EvaluatorFlags.CallBaseDefaults */);
+            const callTypeResult = evaluator.getTypeOfExpression(node.d.leftExpr, 2 /* EvalFlags.CallBaseDefaults */);
             const callType = callTypeResult.type;
             (0, typeUtils_1.doForEachSubtype)(callType, (callSubtype) => {
                 var _a;
@@ -1182,7 +1203,7 @@ function getCodeFlowEngine(evaluator, speculativeTypeTracker) {
                         else {
                             // Perform a more complete evaluation to determine whether
                             // the applicable overload returns a NoReturn.
-                            const callResult = evaluator.validateOverloadedFunctionArguments(node, node.arguments, { type: callSubtype, isIncomplete: callTypeResult.isIncomplete }, 
+                            const callResult = evaluator.validateOverloadedFunctionArguments(node, node.d.args.map((arg) => (0, typeUtils_1.convertArgumentNodeToFunctionArgument)(arg)), { type: callSubtype, isIncomplete: callTypeResult.isIncomplete }, 
                             /* typeVarContext */ undefined, 
                             /* skipUnknownArgCheck */ false, 
                             /* inferenceContext */ undefined, 
@@ -1208,13 +1229,13 @@ function getCodeFlowEngine(evaluator, speculativeTypeTracker) {
         }
     }
     function isFunctionNoReturn(functionType, isCallAwaited) {
-        const returnType = functionType.details.declaredReturnType;
+        const returnType = functionType.shared.declaredReturnType;
         if (returnType) {
             if ((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) {
+                returnType.priv.typeArguments &&
+                returnType.priv.typeArguments.length >= 3) {
+                if ((0, types_1.isNever)(returnType.priv.typeArguments[2]) && isCallAwaited) {
                     return true;
                 }
             }
@@ -1223,29 +1244,29 @@ function getCodeFlowEngine(evaluator, speculativeTypeTracker) {
         else if (!inferNoReturnForUnannotatedFunctions) {
             return false;
         }
-        else if (functionType.details.declaration) {
+        else if (functionType.shared.declaration) {
             // If the function is a generator (i.e. it has yield statements)
             // then it is not a "no return" call. Also, don't infer a "no
             // return" type for abstract methods.
-            if (!functionType.details.declaration.isGenerator &&
+            if (!functionType.shared.declaration.isGenerator &&
                 !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;
+                const functionStatements = functionType.shared.declaration.node.d.suite.d.statements;
                 let foundRaiseNotImplemented = false;
                 for (const statement of functionStatements) {
-                    if (statement.nodeType !== 47 /* ParseNodeType.StatementList */ || statement.statements.length !== 1) {
+                    if (statement.nodeType !== 47 /* ParseNodeType.StatementList */ || statement.d.statements.length !== 1) {
                         break;
                     }
-                    const simpleStatement = statement.statements[0];
+                    const simpleStatement = statement.d.statements[0];
                     if (simpleStatement.nodeType === 48 /* ParseNodeType.StringList */) {
                         continue;
                     }
-                    if (simpleStatement.nodeType === 43 /* ParseNodeType.Raise */ && simpleStatement.typeExpression) {
+                    if (simpleStatement.nodeType === 43 /* ParseNodeType.Raise */ && simpleStatement.d.typeExpression) {
                         // Check for a raising about 'NotImplementedError' or a subtype thereof.
-                        const exceptionType = evaluator.getType(simpleStatement.typeExpression);
+                        const exceptionType = evaluator.getType(simpleStatement.d.typeExpression);
                         if (exceptionType &&
                             (0, types_1.isClass)(exceptionType) &&
                             (0, typeUtils_1.derivesFromStdlibClass)(exceptionType, 'NotImplementedError')) {
@@ -1262,10 +1283,10 @@ function getCodeFlowEngine(evaluator, speculativeTypeTracker) {
         return false;
     }
     function isAfterNodeReachable(evaluator, functionType) {
-        if (!functionType.details.declaration) {
+        if (!functionType.shared.declaration) {
             return true;
         }
-        return evaluator.isAfterNodeReachable(functionType.details.declaration.node);
+        return evaluator.isAfterNodeReachable(functionType.shared.declaration.node);
     }
     // Performs a cursory analysis to determine whether the expression
     // corresponds to a context manager object that supports the swallowing
@@ -1291,22 +1312,22 @@ function getCodeFlowEngine(evaluator, speculativeTypeTracker) {
             if (cmType && (0, types_1.isClassInstance)(cmType)) {
                 const exitMethodName = isAsync ? '__aexit__' : '__exit__';
                 const exitType = evaluator.getBoundMagicMethod(cmType, exitMethodName);
-                if (exitType && (0, types_1.isFunction)(exitType) && exitType.details.declaredReturnType) {
-                    let returnType = exitType.details.declaredReturnType;
+                if (exitType && (0, types_1.isFunction)(exitType) && exitType.shared.declaredReturnType) {
+                    let returnType = exitType.shared.declaredReturnType;
                     // If it's an __aexit__ method, its return type will typically be wrapped
                     // in a Coroutine, so we need to extract the return type from the third
                     // type argument.
                     if (isAsync) {
                         if ((0, types_1.isClassInstance)(returnType) &&
                             types_1.ClassType.isBuiltIn(returnType, 'Coroutine') &&
-                            returnType.typeArguments &&
-                            returnType.typeArguments.length >= 3) {
-                            returnType = returnType.typeArguments[2];
+                            returnType.priv.typeArguments &&
+                            returnType.priv.typeArguments.length >= 3) {
+                            returnType = returnType.priv.typeArguments[2];
                         }
                     }
                     cmSwallowsExceptions = false;
                     if ((0, types_1.isClassInstance)(returnType) && types_1.ClassType.isBuiltIn(returnType, 'bool')) {
-                        if (returnType.literalValue === undefined || returnType.literalValue === true) {
+                        if (returnType.priv.literalValue === undefined || returnType.priv.literalValue === true) {
                             cmSwallowsExceptions = true;
                         }
                     }
@@ -1321,9 +1342,9 @@ function getCodeFlowEngine(evaluator, speculativeTypeTracker) {
         return cmSwallowsExceptions;
     }
     function getTypeFromWildcardImport(flowNode, name) {
-        const importInfo = (0, analyzerNodeInfo_1.getImportInfo)(flowNode.node.module);
+        const importInfo = (0, analyzerNodeInfo_1.getImportInfo)(flowNode.node.d.module);
         (0, debug_1.assert)(importInfo !== undefined && importInfo.isImportFound);
-        (0, debug_1.assert)(flowNode.node.isWildcardImport);
+        (0, debug_1.assert)(flowNode.node.d.isWildcardImport);
         const symbolWithScope = evaluator.lookUpSymbolRecursive(flowNode.node, name, /* honorCodeFlow */ false);
         (0, debug_1.assert)(symbolWithScope !== undefined);
         const decls = symbolWithScope.symbol.getDeclarations();