@zzzen/pyright-internal 1.2.0-dev.20240707 → 1.2.0-dev.20240721

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;
@@ -39,6 +51,19 @@ const enablePrintCallNoReturn = false;
 // to determine whether it is `NoReturn`? Enabling this produces more consistent
 // and complete results, but it can be very expensive.
 const inferNoReturnForUnannotatedFunctions = false;
+// In rare circumstances, it's possible for types in a loop not to converge. This
+// can happen, for example, if there are many symbols that depend on each other
+// and their types depend on complex overloads that can resolve to Any under
+// certain circumstances. This defines the max number of times we'll attempt to
+// evaluate an antecedent in a loop before we give up and "pin" the evaluated
+// type for that antecedent. The number is somewhat arbitrary. Too low and
+// it will cause incorrect types to be evaluated even when types could converge.
+// Too high, and it will cause long hangs before giving up.
+const maxConvergenceAttemptLimit = 256;
+// Should a message be logged when the convergence limit is hit? This is useful
+// for debugging but not something that is actionable for users, so disable by
+// default.
+const enablePrintConvergenceLimitHit = false;
 function getCodeFlowEngine(evaluator, speculativeTypeTracker) {
     const isReachableRecursionSet = new Set();
     const reachabilityCache = new Map();
@@ -47,6 +72,7 @@ function getCodeFlowEngine(evaluator, speculativeTypeTracker) {
     let flowIncompleteGeneration = 1;
     let noReturnAnalysisDepth = 0;
     let contextManagerAnalysisDepth = 0;
+    let maxConvergenceLimitHit = false;
     // 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.
@@ -125,12 +151,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);
@@ -182,17 +203,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);
@@ -246,18 +263,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
@@ -312,10 +325,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)) {
@@ -328,16 +338,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) {
@@ -360,10 +370,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;
@@ -451,7 +458,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, () => {
@@ -562,7 +569,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);
@@ -615,10 +622,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) {
@@ -671,6 +676,16 @@ function getCodeFlowEngine(evaluator, speculativeTypeTracker) {
                             : 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;
+                            // Does it look like this will never converge? If so, stick with the
+                            // previously-computed type for this entry.
+                            if (entryEvaluationCount >= maxConvergenceAttemptLimit) {
+                                // Log this only once.
+                                if (!maxConvergenceLimitHit && enablePrintConvergenceLimitHit) {
+                                    console.log('Types failed to converge during code flow analysis');
+                                }
+                                maxConvergenceLimitHit = true;
+                                return;
+                            }
                             // 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 : types_1.UnknownType.create(/* isIncomplete */ true), 
@@ -705,7 +720,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;
@@ -742,12 +757,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);
                     }
@@ -757,15 +772,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);
@@ -794,10 +806,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);
         }
@@ -892,7 +901,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;
@@ -988,13 +997,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);
             }
@@ -1033,12 +1042,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 /* EvalFlags.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));
@@ -1055,17 +1064,17 @@ 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 arg1Expr = testExpression.d.args[1].d.valueExpr;
                             const arg1Type = evaluator.getTypeOfExpression(arg1Expr, 512 /* EvalFlags.AllowMissingTypeArgs */ |
                                 8 /* EvalFlags.StrLiteralAsType */ |
                                 32 /* EvalFlags.NoParamSpec */ |
@@ -1118,14 +1127,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;
                 }
             }
@@ -1156,7 +1166,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.
@@ -1166,7 +1176,7 @@ function getCodeFlowEngine(evaluator, speculativeTypeTracker) {
             let noReturnTypeCount = 0;
             let subtypeCount = 0;
             // Evaluate the call base type.
-            const callTypeResult = evaluator.getTypeOfExpression(node.leftExpression, 2 /* EvalFlags.CallBaseDefaults */);
+            const callTypeResult = evaluator.getTypeOfExpression(node.d.leftExpr, 2 /* EvalFlags.CallBaseDefaults */);
             const callType = callTypeResult.type;
             (0, typeUtils_1.doForEachSubtype)(callType, (callSubtype) => {
                 var _a;
@@ -1217,11 +1227,10 @@ 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.validateOverloadedArgTypes(node, node.d.args.map((arg) => (0, typeUtils_1.convertArgumentNodeToFunctionArgument)(arg)), { type: callSubtype, isIncomplete: callTypeResult.isIncomplete }, 
                             /* typeVarContext */ undefined, 
                             /* skipUnknownArgCheck */ false, 
-                            /* inferenceContext */ undefined, 
-                            /* signatureTracker */ undefined);
+                            /* inferenceContext */ undefined);
                             if (callResult.returnType && (0, types_1.isNever)(callResult.returnType)) {
                                 noReturnTypeCount++;
                             }
@@ -1243,13 +1252,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;
                 }
             }
@@ -1258,29 +1267,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')) {
@@ -1297,10 +1306,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
@@ -1326,22 +1335,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;
                         }
                     }
@@ -1356,9 +1365,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();