@zzzen/pyright-internal 1.2.0-dev.20260816 → 1.2.0-dev.20260830

package/dist/analyzer/typeEvaluator.js

@@ -196,6 +196,7 @@ const printExpressionTypes = false;
 // long analysis times. This number has been tuned empirically.
 exports.maxCodeComplexity = 768;
 function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
+    const nodeInfo = AnalyzerNodeInfo.createAnalyzerNodeInfoAccessor(evaluatorOptions.nodeInfoReader);
     const symbolResolutionStack = [];
     const speculativeTypeTracker = new typeCacheUtils_1.SpeculativeTypeTracker();
     const suppressedNodeStack = [];
@@ -216,6 +217,21 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     let returnTypeInferenceTypeFormTypeCache;
     const signatureTrackerStack = [];
     let prefetched;
+    function getScopeForNode(node) {
+        return ScopeUtils.getScopeForNode(node, nodeInfo);
+    }
+    function getScopeHierarchy(node, stopScope) {
+        return ScopeUtils.getScopeHierarchy(node, stopScope, nodeInfo);
+    }
+    function findTopNodeInScope(node, scope) {
+        return ScopeUtils.findTopNodeInScope(node, scope, nodeInfo);
+    }
+    function getScopeIdForNode(node) {
+        return ParseTreeUtils.getScopeIdForNode(node, nodeInfo);
+    }
+    function getTypeVarScopesForNode(node) {
+        return ParseTreeUtils.getTypeVarScopesForNode(node, nodeInfo);
+    }
     function runWithCancellationToken(token, callback) {
         // Save the current token and restore it after the callback to support nested calls
         const oldToken = cancellationToken;
@@ -328,7 +344,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (flags !== undefined) {
                 const expectedFlags = cacheEntry.flags;
                 if (expectedFlags !== undefined && flags !== expectedFlags) {
-                    const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
+                    const fileInfo = nodeInfo.getFileInfo(node);
                     const position = (0, positionUtils_1.convertOffsetToPosition)(node.start, fileInfo.lines);
                     const message = `Type cache flag mismatch for node type ${node.nodeType} ` +
                         `(parent ${node.parent?.nodeType ?? 'none'}): ` +
@@ -573,7 +589,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // Some of these types have cyclical dependencies on each other,
             // so don't re-enter this block once we start executing it.
             prefetched = {};
-            const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
+            const fileInfo = nodeInfo.getFileInfo(node);
             prefetched.objectClass = getBuiltInType(node, 'object');
             prefetched.typeClass = getBuiltInType(node, 'type');
             prefetched.functionClass = getTypesType(node, 'FunctionType') ?? getBuiltInType(node, 'function');
@@ -686,7 +702,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             typeResult.type.priv.includePromotions &&
             !typeResult.type.priv.includeSubclasses &&
             types_1.ClassType.isBuiltIn(typeResult.type, 'bytes')) {
-            if (AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.disableBytesTypePromotions) {
+            if (nodeInfo.getFileInfo(node).diagnosticRuleSet.disableBytesTypePromotions) {
                 typeResult = {
                     ...typeResult,
                     type: types_1.ClassType.cloneRemoveTypePromotions(typeResult.type),
@@ -753,7 +769,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 break;
             }
             case 52 /* ParseNodeType.Tuple */: {
-                typeResult = (0, tuples_1.getTypeOfTuple)(evaluatorInterface, node, flags, inferenceContext);
+                typeResult = (0, tuples_1.getTypeOfTuple)(evaluatorInterface, node, flags, inferenceContext, nodeInfo);
                 break;
             }
             case 14 /* ParseNodeType.Constant */: {
@@ -788,7 +804,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 if (expectingInstantiable && node.d.operator !== 6 /* OperatorType.BitwiseOr */) {
                     effectiveFlags &= ~128 /* EvalFlags.InstantiableType */;
                 }
-                typeResult = (0, operations_1.getTypeOfBinaryOperation)(evaluatorInterface, node, effectiveFlags, inferenceContext);
+                typeResult = (0, operations_1.getTypeOfBinaryOperation)(evaluatorInterface, node, effectiveFlags, inferenceContext, nodeInfo);
                 break;
             }
             case 5 /* ParseNodeType.AugmentedAssignment */: {
@@ -809,7 +825,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 break;
             }
             case 51 /* ParseNodeType.Ternary */: {
-                typeResult = (0, operations_1.getTypeOfTernaryOperation)(evaluatorInterface, node, flags, inferenceContext);
+                typeResult = (0, operations_1.getTypeOfTernaryOperation)(evaluatorInterface, node, flags, inferenceContext, nodeInfo);
                 break;
             }
             case 11 /* ParseNodeType.Comprehension */: {
@@ -911,7 +927,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             name = type.shared.name;
         }
         if (isTypeCheckingOnly) {
-            const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
+            const fileInfo = nodeInfo.getFileInfo(node);
             if (!fileInfo.isStubFile) {
                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeCheckOnly().format({ name }), node);
             }
@@ -1145,8 +1161,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if ((flags & 16777216 /* EvalFlags.ParsesStringLiteral */) === 0) {
             updatedFlags |= 524288 /* EvalFlags.NotParsed */;
         }
-        if (node.d.annotation && (flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
-            return getTypeOfExpression(node.d.annotation, updatedFlags);
+        const annotation = nodeInfo.getStringAnnotation(node);
+        if (annotation && (flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
+            return getTypeOfExpression(annotation, updatedFlags);
         }
         if (node.d.strings.length === 1) {
             const tokenFlags = node.d.strings[0].d.token.flags;
@@ -1286,7 +1303,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         });
     }
     function getTypeOfAnnotation(node, options) {
-        const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
+        const fileInfo = nodeInfo.getFileInfo(node);
         // Special-case the typing.pyi file, which contains some special
         // types that the type analyzer needs to interpret differently.
         if (fileInfo.isTypingStubFile || fileInfo.isTypingExtensionsStubFile) {
@@ -2243,9 +2260,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
                 const iterReturnType = getTypeOfMagicMethodCall(subtype, iterMethodName, [], errorNode)?.type;
                 if (!iterReturnType) {
-                    // There was no __iter__. See if we can fall back to
-                    // the __getitem__ method instead.
+                    // There was no callable __iter__. The legacy sequence protocol
+                    // falls back to __getitem__, but CPython does that only when
+                    // __iter__ is missing. An explicit `__iter__ = None` (or any
+                    // non-callable __iter__) makes the object not iterable.
+                    let hasExplicitIterMember = false;
                     if (!isAsync && (0, types_1.isClassInstance)(subtype)) {
+                        hasExplicitIterMember = !!(0, typeUtils_1.lookUpObjectMember)(subtype, iterMethodName, 16 /* MemberAccessFlags.SkipInstanceMembers */ |
+                            512 /* MemberAccessFlags.SkipAttributeAccessOverride */ |
+                            4 /* MemberAccessFlags.SkipObjectBaseClass */);
+                    }
+                    if (!isAsync && (0, types_1.isClassInstance)(subtype) && !hasExplicitIterMember) {
                         const getItemReturnType = getTypeOfMagicMethodCall(subtype, '__getitem__', [
                             {
                                 type: prefetched?.intClass && (0, types_1.isInstantiableClass)(prefetched.intClass)
@@ -2419,7 +2444,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         return getTypeOfModule(node, symbolName, ['_typeshed']);
     }
     function getTypeOfModule(node, symbolName, nameParts) {
-        const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
+        const fileInfo = nodeInfo.getFileInfo(node);
         const lookupResult = importLookup({ nameParts, importingFileUri: fileInfo.fileUri });
         if (!lookupResult) {
             return undefined;
@@ -2431,8 +2456,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         return getEffectiveTypeOfSymbol(symbol);
     }
     function checkCodeFlowTooComplex(node) {
-        const scopeNode = node.nodeType === 31 /* ParseNodeType.Function */ ? node : ParseTreeUtils.getExecutionScopeNode(node);
-        const codeComplexity = AnalyzerNodeInfo.getCodeFlowComplexity(scopeNode);
+        const scopeNode = node.nodeType === 31 /* ParseNodeType.Function */ ? node : ParseTreeUtils.getExecutionScopeNode(node, nodeInfo);
+        const codeComplexity = nodeInfo.getCodeFlowComplexity(scopeNode);
         if (codeComplexity > exports.maxCodeComplexity) {
             let errorRange = scopeNode;
             if (scopeNode.nodeType === 31 /* ParseNodeType.Function */) {
@@ -2441,7 +2466,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             else if (scopeNode.nodeType === 36 /* ParseNodeType.Module */) {
                 errorRange = { start: 0, length: 0 };
             }
-            const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
+            const fileInfo = nodeInfo.getFileInfo(node);
             addDiagnosticForTextRange(fileInfo, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.codeTooComplexToAnalyze(), errorRange);
             return true;
         }
@@ -2457,18 +2482,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (checkCodeFlowTooComplex(node)) {
             return typeEvaluatorTypes_1.Reachability.Reachable;
         }
-        const flowNode = AnalyzerNodeInfo.getFlowNode(node);
+        const flowNode = nodeInfo.getFlowNode(node);
         if (!flowNode) {
             if (node.parent) {
                 return getNodeReachability(node.parent, sourceNode);
             }
             return typeEvaluatorTypes_1.Reachability.UnreachableStructural;
         }
-        const sourceFlowNode = sourceNode ? AnalyzerNodeInfo.getFlowNode(sourceNode) : undefined;
+        const sourceFlowNode = sourceNode ? nodeInfo.getFlowNode(sourceNode) : undefined;
         return codeFlowEngine.getFlowNodeReachability(flowNode, sourceFlowNode);
     }
     function getAfterNodeReachability(node) {
-        const returnFlowNode = AnalyzerNodeInfo.getAfterFlowNode(node);
+        const returnFlowNode = nodeInfo.getAfterFlowNode(node);
         if (!returnFlowNode) {
             return typeEvaluatorTypes_1.Reachability.UnreachableStructural;
         }
@@ -2479,7 +2504,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (reachability !== typeEvaluatorTypes_1.Reachability.Reachable) {
             return reachability;
         }
-        const executionScopeNode = ParseTreeUtils.getExecutionScopeNode(node);
+        const executionScopeNode = ParseTreeUtils.getExecutionScopeNode(node, nodeInfo);
         if (!isFlowNodeReachableUsingNeverNarrowing(executionScopeNode, returnFlowNode)) {
             return typeEvaluatorTypes_1.Reachability.UnreachableByAnalysis;
         }
@@ -2502,8 +2527,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (checkCodeFlowTooComplex(sourceNode)) {
             return true;
         }
-        const sourceFlowNode = AnalyzerNodeInfo.getFlowNode(sourceNode);
-        const sinkFlowNode = AnalyzerNodeInfo.getFlowNode(sinkNode);
+        const sourceFlowNode = nodeInfo.getFlowNode(sourceNode);
+        const sinkFlowNode = nodeInfo.getFlowNode(sinkNode);
         if (!sourceFlowNode || !sinkFlowNode) {
             return false;
         }
@@ -2521,7 +2546,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             return;
         }
         if (!isDiagnosticSuppressedForNode(node)) {
-            const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
+            const fileInfo = nodeInfo.getFileInfo(node);
             const reportTypeReachability = fileInfo.diagnosticRuleSet.enableReachabilityAnalysis;
             if (reachability === typeEvaluatorTypes_1.Reachability.UnreachableStructural ||
                 reachability === typeEvaluatorTypes_1.Reachability.UnreachableStaticCondition ||
@@ -2536,7 +2561,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     }
     function addDeprecated(message, node) {
         if (!isDiagnosticSuppressedForNode(node)) {
-            const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
+            const fileInfo = nodeInfo.getFileInfo(node);
             fileInfo.diagnosticSink.addDeprecatedWithTextRange(message, node);
         }
     }
@@ -2549,7 +2574,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             return undefined;
         }
         if (isNodeReachable(node)) {
-            const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
+            const fileInfo = nodeInfo.getFileInfo(node);
             return fileInfo.diagnosticSink.addDiagnosticWithTextRange(diagLevel, message, range ?? node);
         }
         return undefined;
@@ -2574,7 +2599,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         return suppressedEntries.every((entry) => !entry.suppressedDiags);
     }
     function addDiagnostic(rule, message, node, range) {
-        const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
+        const fileInfo = nodeInfo.getFileInfo(node);
         const diagLevel = fileInfo.diagnosticRuleSet[rule];
         if (diagLevel === 'none') {
             return undefined;
@@ -2582,7 +2607,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         const containingFunction = ParseTreeUtils.getEnclosingFunction(node);
         if (containingFunction) {
             // Should we suppress this diagnostic because it's within an unannotated function?
-            const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
+            const fileInfo = nodeInfo.getFileInfo(node);
             if (!fileInfo.diagnosticRuleSet.analyzeUnannotatedFunctions) {
                 // Is the target node within the body of the function? If so, suppress the diagnostic.
                 if (ParseTreeUtils.isUnannotatedFunction(containingFunction) &&
@@ -2592,7 +2617,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             // Should we suppress this diagnostic because it's within a no_type_check function?
             const containingClassNode = ParseTreeUtils.getEnclosingClass(containingFunction, /* stopAtFunction */ true);
-            const functionInfo = (0, decorators_1.getFunctionInfoFromDecorators)(evaluatorInterface, containingFunction, !!containingClassNode);
+            const functionInfo = (0, decorators_1.getFunctionInfoFromDecorators)(evaluatorInterface, containingFunction, !!containingClassNode, nodeInfo);
             if ((functionInfo.flags & 524288 /* FunctionTypeFlags.NoTypeCheck */) !== 0) {
                 return undefined;
             }
@@ -2624,7 +2649,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         const declarations = symbolWithScope.symbol.getDeclarations();
         let declaredType = getDeclaredTypeOfSymbol(symbolWithScope.symbol)?.type;
-        const fileInfo = AnalyzerNodeInfo.getFileInfo(nameNode);
+        const fileInfo = nodeInfo.getFileInfo(nameNode);
         // If this is a class scope and there is no type declared for this class variable,
         // see if a parent class has a type declared.
         if (declaredType === undefined && symbolWithScope.scope.type === 3 /* ScopeType.Class */) {
@@ -2644,7 +2669,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         const isTypeAlias = !!declaredType && (0, types_1.isClassInstance)(declaredType) && types_1.ClassType.isBuiltIn(declaredType, 'TypeAlias');
         if (declaredType && !isTypeAlias) {
             let diagAddendum = new diagnostic_1.DiagnosticAddendum();
-            const liveScopeIds = ParseTreeUtils.getTypeVarScopesForNode(nameNode);
+            const liveScopeIds = getTypeVarScopesForNode(nameNode);
             const boundDeclaredType = (0, typeUtils_1.makeTypeVarsBound)(declaredType, liveScopeIds);
             const srcType = (0, typeUtils_1.makeTypeVarsBound)(typeResult.type, liveScopeIds);
             if (!assignType(boundDeclaredType, srcType, diagAddendum)) {
@@ -2670,7 +2695,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // appears to be a constant, use the strict source type. If it's a member
             // variable that can be overridden by a child class, use the more general
             // version by stripping off the literal and TypeForm.
-            const scope = ScopeUtils.getScopeForNode(nameNode);
+            const scope = getScopeForNode(nameNode);
             if (scope?.type === 3 /* ScopeType.Class */) {
                 if (types_1.TypeBase.isInstance(destType) &&
                     !(0, symbolNameUtils_1.isConstantName)(nameValue) &&
@@ -2768,7 +2793,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     }
     function assignTypeToMemberVariable(node, typeResult, isInstanceMember, srcExprNode) {
         const memberName = node.d.member.d.value;
-        const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
+        const fileInfo = nodeInfo.getFileInfo(node);
         const classDef = ParseTreeUtils.getEnclosingClass(node);
         if (!classDef) {
             return;
@@ -3174,8 +3199,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         return type;
     }
     function markNamesAccessed(node, names) {
-        const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
-        const scope = ScopeUtils.getScopeForNode(node);
+        const fileInfo = nodeInfo.getFileInfo(node);
+        const scope = getScopeForNode(node);
         if (scope) {
             names.forEach((symbolName) => {
                 const symbolInScope = scope.lookUpSymbolRecursive(symbolName);
@@ -3400,7 +3425,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
     }
     function getTypeOfName(node, flags) {
-        const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
+        const fileInfo = nodeInfo.getFileInfo(node);
         const name = node.d.value;
         let symbol;
         let type;
@@ -3611,7 +3636,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         if ((0, types_1.isTypeVar)(type) && type.priv.scopeId && !type.shared.isSynthesized) {
             if (!(0, types_1.isTypeVarTuple)(type) || !type.priv.isInUnion) {
-                const liveScopeIds = ParseTreeUtils.getTypeVarScopesForNode(node);
+                const liveScopeIds = getTypeVarScopesForNode(node);
                 type = types_1.TypeBase.cloneWithTypeForm(type, (0, typeUtils_1.convertToInstance)((0, typeUtils_1.makeTypeVarsBound)(type, liveScopeIds)));
             }
         }
@@ -3660,7 +3685,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             return type;
         }
         // Disable for assignments in the typings.pyi file, since it defines special forms.
-        const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
+        const fileInfo = nodeInfo.getFileInfo(node);
         if (fileInfo.isTypingStubFile) {
             return type;
         }
@@ -3723,28 +3748,27 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // If the symbol is modified in scopes other than the one in which it is
         // declared (e.g. through a nonlocal or global binding), it is not eligible
         // for code flow analysis.
-        if (!decls.every((decl) => decl.type === 2 /* DeclarationType.Param */ ||
-            ScopeUtils.getScopeForNode(decl.node) === symbolWithScope.scope)) {
+        if (!decls.every((decl) => decl.type === 2 /* DeclarationType.Param */ || getScopeForNode(decl.node) === symbolWithScope.scope)) {
             return undefined;
         }
         // If the symbol is a non-final variable in the global scope, it is not
         // eligible because it could be modified by other modules.
         if (!decls.every((decl) => decl.type !== 1 /* DeclarationType.Variable */ ||
             decl.isFinal ||
-            ScopeUtils.getScopeForNode(decl.node)?.type !== 4 /* ScopeType.Module */)) {
+            getScopeForNode(decl.node)?.type !== 4 /* ScopeType.Module */)) {
             return undefined;
         }
         // If the symbol is a variable captured by an inner function
         // or lambda, see if we can infer the type from the outer scope.
-        const scopeHierarchy = ScopeUtils.getScopeHierarchy(node, symbolWithScope.scope);
+        const scopeHierarchy = getScopeHierarchy(node, symbolWithScope.scope);
         if (scopeHierarchy && scopeHierarchy.length >= 2) {
             // Find the parse node associated with the scope that is just inside of the
             // scope that declares the captured variable.
-            const innerScopeNode = ScopeUtils.findTopNodeInScope(node, scopeHierarchy[scopeHierarchy.length - 2]);
+            const innerScopeNode = findTopNodeInScope(node, scopeHierarchy[scopeHierarchy.length - 2]);
             if (innerScopeNode?.nodeType === 31 /* ParseNodeType.Function */ ||
                 innerScopeNode?.nodeType === 33 /* ParseNodeType.Lambda */ ||
                 innerScopeNode?.nodeType === 10 /* ParseNodeType.Class */) {
-                const innerScopeCodeFlowNode = AnalyzerNodeInfo.getFlowNode(innerScopeNode);
+                const innerScopeCodeFlowNode = nodeInfo.getFlowNode(innerScopeNode);
                 if (innerScopeCodeFlowNode) {
                     // See if any of the assignments of the symbol are reachable
                     // from this node. If so, we cannot apply any narrowing because
@@ -3755,7 +3779,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         if (decl.type === 2 /* DeclarationType.Param */) {
                             return true;
                         }
-                        const declCodeFlowNode = AnalyzerNodeInfo.getFlowNode(decl.node);
+                        const declCodeFlowNode = nodeInfo.getFlowNode(decl.node);
                         if (!declCodeFlowNode) {
                             return false;
                         }
@@ -3874,7 +3898,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     container: enclosingScope.d.name.d.value,
                 }), node);
             }
-            const scopeIdToAssign = ParseTreeUtils.getScopeIdForNode(enclosingScope);
+            const scopeIdToAssign = getScopeIdForNode(enclosingScope);
             return types_1.TypeVarType.cloneForScopeId(type, scopeIdToAssign, enclosingScope.d.name.d.value, enclosingScope.nodeType === 31 /* ParseNodeType.Function */ ? 1 /* TypeVarScopeType.Function */ : 0 /* TypeVarScopeType.Class */);
         }
         if ((flags & 4096 /* EvalFlags.AllowTypeVarWithoutScopeId */) === 0) {
@@ -3899,7 +3923,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         const enclosingClass = ParseTreeUtils.getEnclosingClass(node);
         if (enclosingClass) {
-            const liveTypeVarScopeIds = ParseTreeUtils.getTypeVarScopesForNode(enclosingClass);
+            const liveTypeVarScopeIds = getTypeVarScopesForNode(enclosingClass);
             if (!liveTypeVarScopeIds.includes(scopeId)) {
                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarInvalidForMemberVariable().format({
                     name: types_1.TypeVarType.getReadableName(type),
@@ -4120,7 +4144,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
         }
         if (!skipPartialUnknownCheck) {
-            reportPossibleUnknownAssignment(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportUnknownMemberType, diagnosticRules_1.DiagnosticRule.reportUnknownMemberType, node.d.member, typeResult.type, node, 
+            reportPossibleUnknownAssignment(nodeInfo.getFileInfo(node).diagnosticRuleSet.reportUnknownMemberType, diagnosticRules_1.DiagnosticRule.reportUnknownMemberType, node.d.member, typeResult.type, node, 
             /* ignoreEmptyContainers */ false);
         }
         // Cache the type information in the member name node.
@@ -4131,7 +4155,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         let baseType = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(baseTypeResult.type);
         const memberName = node.d.member.d.value;
         let diag = new diagnostic_1.DiagnosticAddendum();
-        const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
+        const fileInfo = nodeInfo.getFileInfo(node);
         let type;
         let narrowedTypeForSet;
         let typeErrors = false;
@@ -4223,7 +4247,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     (0, types_1.isClass)(prefetched.functionClass)) {
                     baseType = types_1.ClassType.cloneAsInstance(prefetched.functionClass);
                 }
-                const enumMemberResult = (0, enums_1.getTypeOfEnumMember)(evaluatorInterface, node, baseType, memberName, isIncomplete);
+                const enumMemberResult = (0, enums_1.getTypeOfEnumMember)(evaluatorInterface, node, baseType, memberName, isIncomplete, nodeInfo);
                 if (enumMemberResult) {
                     if (usage.method === 'get') {
                         typeResult = enumMemberResult;
@@ -4573,7 +4597,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (errorNode &&
                 (0, types_1.isInstantiableClass)(memberInfo.classType) &&
                 types_1.ClassType.isSameGenericClass(memberInfo.classType, isAccessedThroughObject ? types_1.ClassType.cloneAsInstantiable(classType) : classType)) {
-                setSymbolAccessed(AnalyzerNodeInfo.getFileInfo(errorNode), memberInfo.symbol, errorNode);
+                setSymbolAccessed(nodeInfo.getFileInfo(errorNode), memberInfo.symbol, errorNode);
             }
             // Special-case `__init_subclass` and `__class_getitem__` because
             // these are always treated as class methods even if they're not
@@ -5081,13 +5105,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // they don't result in runtime exceptions when used in this manner.
             let skipSubscriptCheck = (flags & 32768 /* EvalFlags.VarTypeAnnotation */) !== 0;
             if (skipSubscriptCheck) {
-                const scopeNode = ParseTreeUtils.getExecutionScopeNode(node);
+                const scopeNode = ParseTreeUtils.getExecutionScopeNode(node, nodeInfo);
                 if (scopeNode?.nodeType === 36 /* ParseNodeType.Module */) {
                     skipSubscriptCheck = false;
                 }
             }
             if (!skipSubscriptCheck) {
-                const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
+                const fileInfo = nodeInfo.getFileInfo(node);
                 if ((0, types_1.isInstantiableClass)(baseTypeResult.type) &&
                     types_1.ClassType.isBuiltIn(baseTypeResult.type) &&
                     !baseTypeResult.type.priv.aliasName) {
@@ -5636,7 +5660,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 const isFinalAnnotation = (0, types_1.isInstantiableClass)(concreteSubtype) && types_1.ClassType.isBuiltIn(concreteSubtype, 'Final');
                 const isClassVarAnnotation = (0, types_1.isInstantiableClass)(concreteSubtype) && types_1.ClassType.isBuiltIn(concreteSubtype, 'ClassVar');
                 // This feature is currently experimental.
-                const supportsTypedDictTypeArg = AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.enableExperimentalFeatures &&
+                const supportsTypedDictTypeArg = nodeInfo.getFileInfo(node).diagnosticRuleSet.enableExperimentalFeatures &&
                     types_1.ClassType.isBuiltIn(concreteSubtype, 'TypedDict');
                 let typeArgs = getTypeArgs(node, flags, {
                     isAnnotatedClass,
@@ -6056,7 +6080,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 // treated as a type. The others can be regular (non-type) objects.
                 adjFlags =
                     32 /* EvalFlags.NoParamSpec */ | 64 /* EvalFlags.NoTypeVarTuple */ | 2 /* EvalFlags.NoSpecialize */ | 131072 /* EvalFlags.NoClassVar */;
-                if ((0, analyzerFileInfo_1.isAnnotationEvaluationPostponed)(AnalyzerNodeInfo.getFileInfo(node))) {
+                if ((0, analyzerFileInfo_1.isAnnotationEvaluationPostponed)(nodeInfo.getFileInfo(node))) {
                     adjFlags |= 4 /* EvalFlags.ForwardRefs */;
                 }
                 typeResult = {
@@ -6146,7 +6170,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     function getTypeArg(node, flags, supportsDictExpression) {
         let typeResult;
         let adjustedFlags = flags | 128 /* EvalFlags.InstantiableType */ | 1 /* EvalFlags.ConvertEllipsisToAny */ | 8 /* EvalFlags.StrLiteralAsType */;
-        const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
+        const fileInfo = nodeInfo.getFileInfo(node);
         if (fileInfo.isStubFile) {
             adjustedFlags |= 4 /* EvalFlags.ForwardRefs */;
         }
@@ -6163,7 +6187,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         else if (node.nodeType === 18 /* ParseNodeType.Dictionary */ && supportsDictExpression) {
             const inlinedTypeDict = prefetched?.typedDictClass && (0, types_1.isInstantiableClass)(prefetched.typedDictClass)
-                ? (0, typedDicts_1.createTypedDictTypeInlined)(evaluatorInterface, node, prefetched.typedDictClass)
+                ? (0, typedDicts_1.createTypedDictTypeInlined)(evaluatorInterface, node, prefetched.typedDictClass, nodeInfo)
                 : undefined;
             const keyTypeFallback = prefetched?.strClass && (0, types_1.isInstantiableClass)(prefetched.strClass)
                 ? prefetched.strClass
@@ -6329,7 +6353,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // have invalid type parameters.
             const isCyclicalTypeVarCall = (0, types_1.isInstantiableClass)(baseTypeResult.type) &&
                 types_1.ClassType.isBuiltIn(baseTypeResult.type, 'TypeVar') &&
-                AnalyzerNodeInfo.getFileInfo(node).isTypingStubFile;
+                nodeInfo.getFileInfo(node).isTypingStubFile;
             const isTypeFormCall = (0, types_1.isInstantiableClass)(baseTypeResult.type) && isTypeFormClass(baseTypeResult.type);
             if (!isCyclicalTypeVarCall && !isTypeFormCall) {
                 argList.forEach((arg) => {
@@ -6694,7 +6718,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         let curNode = node;
         let scope;
         while (curNode) {
-            scope = ScopeUtils.getScopeForNode(curNode);
+            scope = getScopeForNode(curNode);
             // Stop when we get a valid scope that's not a list comprehension
             // scope. That includes lambdas, functions, classes, and modules.
             if (scope && scope.type !== 1 /* ScopeType.Comprehension */) {
@@ -6726,7 +6750,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (node.d.args.length > 2) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.superCallArgCount(), node.d.args[2]);
         }
-        const enclosingFunction = ParseTreeUtils.getEnclosingFunctionEvaluationScope(node);
+        const enclosingFunction = ParseTreeUtils.getEnclosingFunctionEvaluationScope(node, nodeInfo);
         const enclosingClass = enclosingFunction ? ParseTreeUtils.getEnclosingClass(enclosingFunction) : undefined;
         const enclosingClassType = enclosingClass ? getTypeOfClass(enclosingClass)?.classType : undefined;
         // Determine which class the "super" call is applied to. If
@@ -6748,7 +6772,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 // This results in a runtime exception.
                 if (enclosingFunction) {
                     const functionInfo = (0, decorators_1.getFunctionInfoFromDecorators)(evaluatorInterface, enclosingFunction, 
-                    /* isInClass */ true);
+                    /* isInClass */ true, nodeInfo);
                     if ((functionInfo?.flags & 4 /* FunctionTypeFlags.StaticMethod */) !== 0) {
                         addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.superCallZeroArgFormStaticMethod(), node.d.leftExpr);
                     }
@@ -6815,7 +6839,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         if (methodType.shared.parameters.length > 0 &&
                             types_1.FunctionParam.isTypeDeclared(methodType.shared.parameters[0])) {
                             let paramType = types_1.FunctionType.getParamType(methodType, 0);
-                            const liveScopeIds = ParseTreeUtils.getTypeVarScopesForNode(node);
+                            const liveScopeIds = getTypeVarScopesForNode(node);
                             paramType = (0, typeUtils_1.makeTypeVarsBound)(paramType, liveScopeIds);
                             implicitBindToType = makeTopLevelTypeVarsConcrete(paramType);
                         }
@@ -7894,7 +7918,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (types_1.FunctionType.isBuiltIn(type, 'namedtuple')) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUntypedNamedTuple, localize_1.LocMessage.namedTupleNoTypes(), errorNode);
             const result = {
-                returnType: (0, namedTuples_1.createNamedTupleType)(evaluatorInterface, errorNode, argList, /* includesTypes */ false),
+                returnType: (0, namedTuples_1.createNamedTupleType)(evaluatorInterface, errorNode, argList, 
+                /* includesTypes */ false, nodeInfo),
             };
             validateArgs(errorNode, argList, { type: type }, constraints, skipUnknownArgCheck, inferenceContext);
             return result;
@@ -7968,18 +7993,20 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             return undefined;
         }
         let isAbstract = false;
-        const lastFunctionInfo = (0, decorators_1.getFunctionInfoFromDecorators)(evaluatorInterface, lastDecl.node, /* isInClass */ true);
+        const lastFunctionInfo = (0, decorators_1.getFunctionInfoFromDecorators)(evaluatorInterface, lastDecl.node, 
+        /* isInClass */ true, nodeInfo);
         if ((lastFunctionInfo.flags & 8 /* FunctionTypeFlags.AbstractMethod */) !== 0) {
             isAbstract = true;
         }
-        const isStubFile = AnalyzerNodeInfo.getFileInfo(lastDecl.node).isStubFile;
+        const isStubFile = nodeInfo.getFileInfo(lastDecl.node).isStubFile;
         // In an overloaded method, the first overload can also be marked abstract.
         // In stub files, there is no implementation, so this is the only way to mark
         // an overloaded method as abstract.
         const firstDecl = symbol.getDeclarations()[0];
         let firstFunctionInfo;
         if (firstDecl !== lastDecl && firstDecl.type === 5 /* DeclarationType.Function */) {
-            firstFunctionInfo = (0, decorators_1.getFunctionInfoFromDecorators)(evaluatorInterface, firstDecl.node, /* isInClass */ true);
+            firstFunctionInfo = (0, decorators_1.getFunctionInfoFromDecorators)(evaluatorInterface, firstDecl.node, 
+            /* isInClass */ true, nodeInfo);
             if ((firstFunctionInfo.flags & 8 /* FunctionTypeFlags.AbstractMethod */) !== 0) {
                 isAbstract = true;
             }
@@ -8129,7 +8156,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             if (className === 'NamedTuple') {
                 const result = {
-                    returnType: (0, namedTuples_1.createNamedTupleType)(evaluatorInterface, errorNode, argList, /* includesTypes */ true),
+                    returnType: (0, namedTuples_1.createNamedTupleType)(evaluatorInterface, errorNode, argList, 
+                    /* includesTypes */ true, nodeInfo),
                 };
                 const initTypeResult = (0, constructors_1.getBoundInitMethod)(evaluatorInterface, errorNode, types_1.ClassType.cloneAsInstance(expandedCallType), 
                 /* diag */ undefined, 0 /* MemberAccessFlags.Default */);
@@ -8147,14 +8175,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (expandedCallType.shared.fullName === 'builtins.sentinel' ||
                 expandedCallType.shared.fullName === 'typing_extensions.sentinel' ||
                 expandedCallType.shared.fullName === 'typing_extensions.Sentinel') {
-                return { returnType: (0, sentinel_1.createSentinelType)(evaluatorInterface, errorNode, argList) };
+                return {
+                    returnType: (0, sentinel_1.createSentinelType)(evaluatorInterface, errorNode, argList, expandedCallType, nodeInfo),
+                };
             }
             if (types_1.ClassType.isSpecialFormClass(expandedCallType)) {
                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.typeNotIntantiable().format({ type: className }), errorNode);
                 return { returnType: types_1.UnknownType.create(), argumentErrors: true };
             }
             if (className === 'TypedDict') {
-                return { returnType: (0, typedDicts_1.createTypedDictType)(evaluatorInterface, errorNode, expandedCallType, argList) };
+                return {
+                    returnType: (0, typedDicts_1.createTypedDictType)(evaluatorInterface, errorNode, expandedCallType, argList, nodeInfo),
+                };
             }
             if (className === 'auto' && argList.length === 0) {
                 return { returnType: (0, enums_1.getEnumAutoValueType)(evaluatorInterface, errorNode) };
@@ -8165,9 +8197,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             expandedCallType.shared.effectiveMetaclass &&
             (0, types_1.isClass)(expandedCallType.shared.effectiveMetaclass) &&
             (0, enums_1.isEnumMetaclass)(expandedCallType.shared.effectiveMetaclass) &&
-            !(0, enums_1.isEnumClassWithMembers)(evaluatorInterface, expandedCallType)) {
+            !(0, enums_1.isEnumClassWithMembers)(evaluatorInterface, expandedCallType, nodeInfo)) {
             return {
-                returnType: (0, enums_1.createEnumType)(evaluatorInterface, errorNode, expandedCallType, argList) ??
+                returnType: (0, enums_1.createEnumType)(evaluatorInterface, errorNode, expandedCallType, argList, nodeInfo) ??
                     (0, typeUtils_1.convertToInstance)(unexpandedCallType),
             };
         }
@@ -8211,6 +8243,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         const overloadsUsedForCall = constructorResult.overloadsUsedForCall;
         const argumentErrors = constructorResult.argumentErrors;
         const isTypeIncomplete = constructorResult.isTypeIncomplete;
+        const usesBuiltInTypeNew = overloadsUsedForCall?.some((overload) => types_1.FunctionType.isBuiltIn(overload, 'builtins.type.__new__'));
         let returnType = constructorResult.returnType;
         // If the expandedCallType originated from a TypeVar, convert
         // the constructed type back to the TypeVar. For example, if
@@ -8241,11 +8274,24 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     newClassName = firstArgType.priv.literalValue;
                 }
             }
-            const newClassType = types_1.ClassType.createInstantiable(newClassName, '', '', AnalyzerNodeInfo.getFileInfo(errorNode).fileUri, 0 /* ClassTypeFlags.None */, ParseTreeUtils.getTypeSourceId(errorNode), types_1.ClassType.cloneAsInstantiable(returnType), types_1.ClassType.cloneAsInstantiable(returnType));
-            newClassType.shared.baseClasses.push(getBuiltInType(errorNode, 'object'));
+            const newClassType = types_1.ClassType.createInstantiable(newClassName, '', '', nodeInfo.getFileInfo(errorNode).fileUri, 0 /* ClassTypeFlags.None */, ParseTreeUtils.getTypeSourceId(errorNode), types_1.ClassType.cloneAsInstantiable(returnType), types_1.ClassType.cloneAsInstantiable(returnType));
+            if (usesBuiltInTypeNew && argList.length >= 2) {
+                const baseTupleType = getTypeOfArg(argList[1], /* inferenceContext */ undefined).type;
+                if ((0, types_1.isClassInstance)(baseTupleType)) {
+                    const baseClasses = getBaseClassesFromTypeCall(baseTupleType);
+                    if (baseClasses) {
+                        newClassType.shared.baseClasses.push(...baseClasses);
+                    }
+                }
+            }
+            if (newClassType.shared.baseClasses.length === 0) {
+                newClassType.shared.baseClasses.push(getBuiltInType(errorNode, 'object'));
+            }
             newClassType.shared.effectiveMetaclass = expandedCallType;
             newClassType.shared.declaration = returnType.shared.declaration;
-            (0, typeUtils_1.computeMroLinearization)(newClassType);
+            if (!(0, typeUtils_1.computeMroLinearization)(newClassType)) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.methodOrdering(), errorNode);
+            }
             returnType = newClassType;
         }
         return { returnType, overloadsUsedForCall, argumentErrors, isTypeIncomplete };
@@ -8285,7 +8331,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         // Verify that the cast is necessary.
         let castToType = getTypeOfArgExpectingType(argList[0], { typeExpression: true }).type;
-        const liveScopeIds = ParseTreeUtils.getTypeVarScopesForNode(errorNode);
+        const liveScopeIds = getTypeVarScopesForNode(errorNode);
         castToType = (0, typeUtils_1.makeTypeVarsBound)(castToType, liveScopeIds);
         let castFromType = getTypeOfArg(argList[1], /* inferenceContext */ undefined).type;
         if (castFromType.props?.specialForm) {
@@ -9262,7 +9308,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         return validateArgTypesWithExpectedType(errorNode, matchResults, constraints, skipUnknownArgCheck, expectedType, returnType);
     }
     function validateArgTypesWithExpectedType(errorNode, matchResults, constraints, skipUnknownArgCheck = false, expectedType, returnType) {
-        const liveTypeVarScopes = ParseTreeUtils.getTypeVarScopesForNode(errorNode);
+        const liveTypeVarScopes = getTypeVarScopesForNode(errorNode);
         let assignFlags = 2048 /* AssignTypeFlags.PopulateExpectedType */;
         if ((0, typeUtils_1.containsLiteralType)(expectedType, /* includeTypeArgs */ true)) {
             assignFlags |= 256 /* AssignTypeFlags.RetainLiteralsForTypeVar */;
@@ -9483,7 +9529,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if ((0, types_1.isUnpackedClass)(specializedReturnType)) {
             specializedReturnType = types_1.ClassType.cloneForPacked(specializedReturnType);
         }
-        const liveTypeVarScopes = ParseTreeUtils.getTypeVarScopesForNode(errorNode);
+        const liveTypeVarScopes = getTypeVarScopesForNode(errorNode);
         specializedReturnType = adjustCallableReturnType(errorNode, specializedReturnType, liveTypeVarScopes);
         if (specializedInitSelfType) {
             specializedInitSelfType = solveAndApplyConstraints(specializedInitSelfType, constraints);
@@ -9546,7 +9592,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // Create a new scope ID based on the caller's position. This
         // will guarantee uniqueness. If another caller uses the same
         // call and arguments, the type vars will not conflict.
-        const newScopeId = ParseTreeUtils.getScopeIdForNode(callNode);
+        const newScopeId = getScopeIdForNode(callNode);
         const solution = new constraintSolution_1.ConstraintSolution();
         const newTypeParams = typeParams.map((typeVar) => {
             const newTypeParam = types_1.TypeVarType.cloneForScopeId(typeVar, newScopeId, typeVar.priv.scopeName, 1 /* TypeVarScopeType.Function */);
@@ -9818,7 +9864,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (!options?.skipReportError) {
                 // Mismatching parameter types are common in untyped code; don't bother spending time
                 // printing types if the diagnostic is disabled.
-                const fileInfo = AnalyzerNodeInfo.getFileInfo(argParam.errorNode);
+                const fileInfo = nodeInfo.getFileInfo(argParam.errorNode);
                 if (fileInfo.diagnosticRuleSet.reportArgumentType !== 'none' &&
                     !canSkipDiagnosticForNode(argParam.errorNode) &&
                     !isTypeIncomplete) {
@@ -9870,7 +9916,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         if (!options.skipUnknownArgCheck) {
             const simplifiedType = makeTopLevelTypeVarsConcrete((0, types_1.removeUnbound)(argType));
-            const fileInfo = AnalyzerNodeInfo.getFileInfo(argParam.errorNode);
+            const fileInfo = nodeInfo.getFileInfo(argParam.errorNode);
             function getDiagAddendum() {
                 const diagAddendum = new diagnostic_1.DiagnosticAddendum();
                 if (argParam.paramName) {
@@ -9993,7 +10039,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         }).type;
                     typeVar.shared.defaultType = (0, typeUtils_1.convertToInstance)(argType);
                     typeVar.shared.isDefaultExplicit = true;
-                    const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
+                    const fileInfo = nodeInfo.getFileInfo(errorNode);
                     if (!fileInfo.isStubFile &&
                         pythonVersion_1.PythonVersion.isLessThan(fileInfo.executionEnvironment.pythonVersion, pythonVersion_1.pythonVersion3_13) &&
                         classType.shared.moduleName !== 'typing_extensions') {
@@ -10099,7 +10145,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             typeVar.shared.isDefaultExplicit = true;
                         }
                     }
-                    const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
+                    const fileInfo = nodeInfo.getFileInfo(errorNode);
                     if (!fileInfo.isStubFile &&
                         pythonVersion_1.PythonVersion.isLessThan(fileInfo.executionEnvironment.pythonVersion, pythonVersion_1.pythonVersion3_13) &&
                         classType.shared.moduleName !== 'typing_extensions') {
@@ -10160,7 +10206,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             paramSpec.shared.isDefaultExplicit = true;
                         }
                     }
-                    const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
+                    const fileInfo = nodeInfo.getFileInfo(errorNode);
                     if (!fileInfo.isStubFile &&
                         pythonVersion_1.PythonVersion.isLessThan(fileInfo.executionEnvironment.pythonVersion, pythonVersion_1.pythonVersion3_13) &&
                         classType.shared.moduleName !== 'typing_extensions') {
@@ -10239,7 +10285,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeAliasTypeMustBeAssigned(), errorNode);
             return undefined;
         }
-        const scope = ScopeUtils.getScopeForNode(errorNode);
+        const scope = getScopeForNode(errorNode);
         if (scope) {
             if (scope.type !== 3 /* ScopeType.Class */ && scope.type !== 4 /* ScopeType.Module */ && scope.type !== 5 /* ScopeType.Builtin */) {
                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeAliasTypeBadScope(), errorNode.parent.d.leftExpr);
@@ -10300,7 +10346,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         isTypeParamListValid = false;
                     }
                     else {
-                        entryType = types_1.TypeVarType.cloneForScopeId(entryType, ParseTreeUtils.getScopeIdForNode(nameNode), nameNode.d.value, 2 /* TypeVarScopeType.TypeAlias */);
+                        entryType = types_1.TypeVarType.cloneForScopeId(entryType, getScopeIdForNode(nameNode), nameNode.d.value, 2 /* TypeVarScopeType.TypeAlias */);
                     }
                     typeParams.push(entryType);
                 }
@@ -10346,7 +10392,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // in the Python specification: The static type checker will treat
     // the new type as if it were a subclass of the original type.
     function createNewType(errorNode, argList) {
-        const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
+        const fileInfo = nodeInfo.getFileInfo(errorNode);
         let className = '';
         if (argList.length !== 2) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.newTypeParamCount(), errorNode);
@@ -10413,29 +10459,33 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return classType;
     }
+    function getBaseClassesFromTypeCall(baseTupleType) {
+        if (!(0, typeUtils_1.isTupleClass)(baseTupleType) || baseTupleType.priv.tupleTypeArgs === undefined) {
+            return undefined;
+        }
+        return baseTupleType.priv.tupleTypeArgs.map((typeArg) => {
+            const specializedType = makeTopLevelTypeVarsConcrete(typeArg.type);
+            return (0, typeUtils_1.isEffectivelyInstantiable)(specializedType) ? specializedType : types_1.UnknownType.create();
+        });
+    }
     // Implements the semantics of the multi-parameter variant of the "type" call.
     function createClassFromMetaclass(errorNode, argList, metaclass) {
-        const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
+        const fileInfo = nodeInfo.getFileInfo(errorNode);
         const arg0Type = getTypeOfArg(argList[0], /* inferenceContext */ undefined).type;
         if (!(0, types_1.isClassInstance)(arg0Type) || !types_1.ClassType.isBuiltIn(arg0Type, 'str')) {
             return undefined;
         }
         const className = arg0Type.priv.literalValue || '_';
-        const arg1Type = getTypeOfArg(argList[1], /* inferenceContext */ undefined).type;
-        // TODO - properly handle case where tuple of base classes is provided.
-        if (!(0, types_1.isClassInstance)(arg1Type) || !(0, typeUtils_1.isTupleClass)(arg1Type) || arg1Type.priv.tupleTypeArgs === undefined) {
+        const baseTupleType = getTypeOfArg(argList[1], /* inferenceContext */ undefined).type;
+        if (!(0, types_1.isClassInstance)(baseTupleType)) {
             return undefined;
         }
-        const classType = types_1.ClassType.createInstantiable(className, ParseTreeUtils.getClassFullName(errorNode, fileInfo.moduleName, className), fileInfo.moduleName, fileInfo.fileUri, 4194304 /* ClassTypeFlags.ValidTypeAliasClass */, ParseTreeUtils.getTypeSourceId(errorNode), metaclass, arg1Type.shared.effectiveMetaclass);
-        arg1Type.priv.tupleTypeArgs.forEach((typeArg) => {
-            const specializedType = makeTopLevelTypeVarsConcrete(typeArg.type);
-            if ((0, typeUtils_1.isEffectivelyInstantiable)(specializedType)) {
-                classType.shared.baseClasses.push(specializedType);
-            }
-            else {
-                classType.shared.baseClasses.push(types_1.UnknownType.create());
-            }
-        });
+        const baseClasses = getBaseClassesFromTypeCall(baseTupleType);
+        if (!baseClasses) {
+            return undefined;
+        }
+        const classType = types_1.ClassType.createInstantiable(className, ParseTreeUtils.getClassFullName(errorNode, fileInfo.moduleName, className), fileInfo.moduleName, fileInfo.fileUri, 4194304 /* ClassTypeFlags.ValidTypeAliasClass */, ParseTreeUtils.getTypeSourceId(errorNode), metaclass, baseTupleType.shared.effectiveMetaclass);
+        classType.shared.baseClasses.push(...baseClasses);
         if (!(0, typeUtils_1.computeMroLinearization)(classType)) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.methodOrdering(), errorNode);
         }
@@ -10663,7 +10713,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 return undefined;
             }
             const dictConstraints = new constraintTracker_1.ConstraintTracker();
-            if (!(0, constraintSolver_1.addConstraintsForExpectedType)(evaluatorInterface, builtInDict, inferenceContext.expectedType, dictConstraints, ParseTreeUtils.getTypeVarScopesForNode(node), node.start)) {
+            if (!(0, constraintSolver_1.addConstraintsForExpectedType)(evaluatorInterface, builtInDict, inferenceContext.expectedType, dictConstraints, getTypeVarScopesForNode(node), node.start)) {
                 return undefined;
             }
             const specializedDict = solveAndApplyConstraints(types_1.ClassType.cloneAsInstantiable(builtInDict), dictConstraints);
@@ -10728,7 +10778,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         const keyTypes = keyTypeResults.map((t) => (0, typeUtils_1.stripTypeForm)(convertSpecialFormToRuntimeValue(stripLiteralValue(t.type), flags, !hasExpectedType)));
         const valueTypes = valueTypeResults.map((t) => (0, typeUtils_1.stripTypeForm)(convertSpecialFormToRuntimeValue(stripLiteralValue(t.type), flags, !hasExpectedType)));
         if (keyTypes.length > 0) {
-            if (AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.strictDictionaryInference || hasExpectedType) {
+            if (nodeInfo.getFileInfo(node).diagnosticRuleSet.strictDictionaryInference || hasExpectedType) {
                 keyType = (0, types_1.combineTypes)(keyTypes);
             }
             else {
@@ -10744,7 +10794,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // are the same type, we'll assume that all values in this dictionary should
         // be the same.
         if (valueTypes.length > 0) {
-            if (AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.strictDictionaryInference || hasExpectedType) {
+            if (nodeInfo.getFileInfo(node).diagnosticRuleSet.strictDictionaryInference || hasExpectedType) {
                 valueType = (0, types_1.combineTypes)(valueTypes);
             }
             else {
@@ -10804,7 +10854,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     let effectiveValueType = expectedTypedDictEntries.knownItems.get(keyType.priv.literalValue)?.valueType ??
                         expectedTypedDictEntries.extraItems?.valueType;
                     if (effectiveValueType) {
-                        const liveTypeVarScopes = ParseTreeUtils.getTypeVarScopesForNode(node);
+                        const liveTypeVarScopes = getTypeVarScopesForNode(node);
                         effectiveValueType = (0, typeUtils_1.transformExpectedType)(effectiveValueType, liveTypeVarScopes, node.start);
                     }
                     entryInferenceContext = (0, typeUtils_1.makeInferenceContext)(effectiveValueType);
@@ -10813,7 +10863,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 else {
                     let effectiveValueType = expectedValueType ?? (forceStrictInference ? types_1.NeverType.createNever() : undefined);
                     if (effectiveValueType) {
-                        const liveTypeVarScopes = ParseTreeUtils.getTypeVarScopesForNode(node);
+                        const liveTypeVarScopes = getTypeVarScopesForNode(node);
                         effectiveValueType = (0, typeUtils_1.transformExpectedType)(effectiveValueType, liveTypeVarScopes, node.start);
                     }
                     entryInferenceContext = (0, typeUtils_1.makeInferenceContext)(effectiveValueType);
@@ -11070,7 +11120,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             return undefined;
         }
         const constraints = new constraintTracker_1.ConstraintTracker();
-        if (!(0, constraintSolver_1.addConstraintsForExpectedType)(evaluatorInterface, types_1.ClassType.cloneAsInstance(expectedClassType), inferenceContext.expectedType, constraints, ParseTreeUtils.getTypeVarScopesForNode(node), node.start)) {
+        if (!(0, constraintSolver_1.addConstraintsForExpectedType)(evaluatorInterface, types_1.ClassType.cloneAsInstance(expectedClassType), inferenceContext.expectedType, constraints, getTypeVarScopesForNode(node), node.start)) {
             return undefined;
         }
         const specializedListOrSet = solveAndApplyConstraints(expectedClassType, constraints);
@@ -11112,7 +11162,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         entryTypes = entryTypes.map((t) => stripLiteralValue(t));
         let inferredEntryType = hasExpectedType ? types_1.AnyType.create() : types_1.UnknownType.create();
         if (entryTypes.length > 0) {
-            const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
+            const fileInfo = nodeInfo.getFileInfo(node);
             // If there was an expected type or we're using strict list inference,
             // combine the types into a union.
             if ((builtInClassName === 'list' && fileInfo.diagnosticRuleSet.strictListInference) ||
@@ -11205,7 +11255,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (functionTypeInfo) {
                 let returnType = types_1.FunctionType.getEffectiveReturnType(functionTypeInfo.functionType);
                 if (returnType) {
-                    const liveScopeIds = ParseTreeUtils.getTypeVarScopesForNode(node);
+                    const liveScopeIds = getTypeVarScopesForNode(node);
                     returnType = (0, typeUtils_1.makeTypeVarsBound)(returnType, liveScopeIds);
                     expectedYieldType = (0, typeUtils_1.getGeneratorYieldType)(returnType, !!enclosingFunction.d.isAsync);
                     const generatorTypeArgs = (0, typeUtils_1.getGeneratorTypeArgs)(returnType);
@@ -11287,13 +11337,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         let expectedReturnType;
         let expectedParamDetails;
         if (expectedType) {
-            const liveTypeVarScopes = ParseTreeUtils.getTypeVarScopesForNode(node);
+            const liveTypeVarScopes = getTypeVarScopesForNode(node);
             expectedType = (0, typeUtils_1.transformExpectedType)(expectedType, liveTypeVarScopes, node.start);
             expectedParamDetails = (0, parameterUtils_1.getParamListDetails)(expectedType);
             expectedReturnType = getEffectiveReturnType(expectedType);
         }
         let functionType = types_1.FunctionType.createInstance('', '', '', 131072 /* FunctionTypeFlags.PartiallyEvaluated */);
-        functionType.shared.typeVarScopeId = ParseTreeUtils.getScopeIdForNode(node);
+        functionType.shared.typeVarScopeId = getScopeIdForNode(node);
         return (0, cancellationUtils_1.invalidateTypeCacheIfCanceled)(() => {
             // Pre-cache the incomplete function type in case the evaluation of the
             // lambda depends on itself.
@@ -11655,7 +11705,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         let isValidTypeForm = true;
         types_1.TypeBase.setSpecialForm(functionType, types_1.ClassType.cloneAsInstance(classType));
         functionType.shared.declaredReturnType = types_1.UnknownType.create();
-        functionType.shared.typeVarScopeId = ParseTreeUtils.getScopeIdForNode(errorNode);
+        functionType.shared.typeVarScopeId = getScopeIdForNode(errorNode);
         if (typeArgs && typeArgs.length > 0) {
             functionType.priv.isCallableWithTypeArgs = true;
             if (typeArgs[0].typeList) {
@@ -12034,7 +12084,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         const enclosingFunction = ParseTreeUtils.getEnclosingFunction(errorNode);
         if (enclosingFunction) {
             const functionInfo = (0, decorators_1.getFunctionInfoFromDecorators)(evaluatorInterface, enclosingFunction, 
-            /* isInClass */ true);
+            /* isInClass */ true, nodeInfo);
             const isInnerFunction = !!ParseTreeUtils.getEnclosingFunction(enclosingFunction);
             if (!isInnerFunction) {
                 // Check for static methods.
@@ -12388,7 +12438,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     }
     // Unpacks the index expression for a "Union[X, Y, Z]" type annotation.
     function createUnionType(classType, errorNode, typeArgs, flags) {
-        const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
+        const fileInfo = nodeInfo.getFileInfo(errorNode);
         const types = [];
         let allowSingleTypeArg = false;
         let isValidTypeForm = true;
@@ -12571,7 +12621,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         return typeAlias;
     }
     function createSpecialBuiltInClass(node, assignedName, aliasMapEntry) {
-        const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
+        const fileInfo = nodeInfo.getFileInfo(node);
         let specialClassType = types_1.ClassType.createInstantiable(assignedName, ParseTreeUtils.getClassFullName(node, fileInfo.moduleName, assignedName), fileInfo.moduleName, fileInfo.fileUri, 1 /* ClassTypeFlags.BuiltIn */ | 2 /* ClassTypeFlags.SpecialBuiltIn */, 
         /* typeSourceId */ 0, 
         /* declaredMetaclass */ undefined, 
@@ -12586,12 +12636,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // specified in the alias map entry.
         if (aliasMapEntry.typeParamVariance !== undefined) {
             let typeParam = types_1.TypeVarType.createInstance('T');
-            typeParam = types_1.TypeVarType.cloneForScopeId(typeParam, ParseTreeUtils.getScopeIdForNode(node), assignedName, 0 /* TypeVarScopeType.Class */);
+            typeParam = types_1.TypeVarType.cloneForScopeId(typeParam, getScopeIdForNode(node), assignedName, 0 /* TypeVarScopeType.Class */);
             typeParam.shared.declaredVariance = aliasMapEntry.typeParamVariance;
             specialClassType.shared.typeParams.push(typeParam);
         }
-        const specialBuiltInClassDeclaration = (AnalyzerNodeInfo.getDeclaration(node) ??
-            (node.parent ? AnalyzerNodeInfo.getDeclaration(node.parent) : undefined));
+        const specialBuiltInClassDeclaration = (nodeInfo.getDeclaration(node) ??
+            (node.parent ? nodeInfo.getDeclaration(node.parent) : undefined));
         specialClassType.shared.declaration = specialBuiltInClassDeclaration;
         if (fileInfo.isTypingExtensionsStubFile) {
             specialClassType.shared.flags |= 4096 /* ClassTypeFlags.TypingExtensionClass */;
@@ -12782,7 +12832,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
     }
     function evaluateTypesForAssignmentStatement(node) {
-        const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
+        const fileInfo = nodeInfo.getFileInfo(node);
         // If the entire statement has already been evaluated, don't
         // re-evaluate it.
         if (isTypeCached(node)) {
@@ -12874,7 +12924,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 declaredType = getDeclaredTypeForExpression(node.d.leftExpr, { method: 'set' });
             }
             if (declaredType) {
-                const liveTypeVarScopes = ParseTreeUtils.getTypeVarScopesForNode(node);
+                const liveTypeVarScopes = getTypeVarScopesForNode(node);
                 declaredType = (0, typeUtils_1.makeTypeVarsBound)(declaredType, liveTypeVarScopes);
             }
             const srcTypeResult = getTypeOfExpression(node.d.rightExpr, flags, (0, typeUtils_1.makeInferenceContext)(declaredType));
@@ -12928,8 +12978,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     function synthesizeTypeAliasPlaceholder(nameNode, isTypeAliasType = false) {
         const placeholder = types_1.TypeVarType.createInstantiable(`__type_alias_${nameNode.d.value}`);
         placeholder.shared.isSynthesized = true;
-        const typeVarScopeId = ParseTreeUtils.getScopeIdForNode(nameNode);
-        const fileInfo = AnalyzerNodeInfo.getFileInfo(nameNode);
+        const typeVarScopeId = getScopeIdForNode(nameNode);
+        const fileInfo = nodeInfo.getFileInfo(nameNode);
         placeholder.shared.recursiveAlias = {
             name: nameNode.d.value,
             fullName: ParseTreeUtils.getClassFullName(nameNode, fileInfo.moduleName, nameNode.d.value),
@@ -12968,9 +13018,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // Write the type to the type cache to support recursive type alias definitions.
         writeTypeCache(nameNode, { type: typeAliasTypeVar }, /* flags */ undefined);
         // Set a partial type to handle recursive (self-referential) type aliases.
-        const scope = ScopeUtils.getScopeForNode(declNode);
+        const scope = getScopeForNode(declNode);
         const typeAliasSymbol = scope?.lookUpSymbolRecursive(nameNode.d.value);
-        const typeAliasDecl = AnalyzerNodeInfo.getDeclaration(declNode);
+        const typeAliasDecl = nodeInfo.getDeclaration(declNode);
         if (typeAliasDecl && typeAliasSymbol) {
             setSymbolResolutionPartialType(typeAliasSymbol.symbol, typeAliasDecl, typeAliasTypeVar);
         }
@@ -13038,7 +13088,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         const className = `<subclass of ${printType((0, typeUtils_1.convertToInstance)(type1), {
             omitTypeArgsIfUnknown: true,
         })} and ${printType((0, typeUtils_1.convertToInstance)(type2), { omitTypeArgsIfUnknown: true })}>`;
-        const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
+        const fileInfo = nodeInfo.getFileInfo(errorNode);
         // The effective metaclass of the intersection is the narrower of the two metaclasses.
         let effectiveMetaclass = type1.shared.effectiveMetaclass;
         if (type2.shared.effectiveMetaclass) {
@@ -13073,8 +13123,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             };
         }
         // The type wasn't cached, so we need to create a new one.
-        const scope = ScopeUtils.getScopeForNode(node);
-        const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
+        const scope = getScopeForNode(node);
+        const fileInfo = nodeInfo.getFileInfo(node);
         let classFlags = 0 /* ClassTypeFlags.None */;
         if (scope?.type === 5 /* ScopeType.Builtin */ ||
             fileInfo.isTypingStubFile ||
@@ -13098,7 +13148,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         const classType = types_1.ClassType.createInstantiable(node.d.name.d.value, ParseTreeUtils.getClassFullName(node, fileInfo.moduleName, node.d.name.d.value), fileInfo.moduleName, fileInfo.fileUri, classFlags, ParseTreeUtils.getTypeSourceId(node), 
         /* declaredMetaclass */ undefined, 
         /* effectiveMetaclass */ undefined, ParseTreeUtils.getDocString(node.d.suite.d.statements));
-        classType.shared.typeVarScopeId = ParseTreeUtils.getScopeIdForNode(node);
+        classType.shared.typeVarScopeId = getScopeIdForNode(node);
         // Is this a special type that supports type promotions according to PEP 484?
         if (typePromotions.has(classType.shared.fullName)) {
             classType.priv.includePromotions = true;
@@ -13108,7 +13158,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // to allow these to be resolved.
         const classSymbol = scope?.lookUpSymbol(node.d.name.d.value);
         let classDecl;
-        const decl = AnalyzerNodeInfo.getDeclaration(node);
+        const decl = nodeInfo.getDeclaration(node);
         if (decl) {
             classDecl = decl;
         }
@@ -13451,7 +13501,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.methodOrdering(), node.d.name);
             }
             // The scope for this class becomes the "fields" for the corresponding type.
-            const innerScope = ScopeUtils.getScopeForNode(node.d.suite);
+            const innerScope = getScopeForNode(node.d.suite);
             classType.shared.fields = innerScope?.symbolTable
                 ? new Map(innerScope.symbolTable)
                 : new Map();
@@ -13496,9 +13546,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                                 classType.shared.typeParams = genericParams.map((param) => {
                                     const typeVar = types_1.TypeVarType.createInstance(getPseudoGenericTypeVarName(param.d.name.d.value));
                                     typeVar.shared.isSynthesized = true;
-                                    typeVar.priv.scopeId = ParseTreeUtils.getScopeIdForNode(initDeclNode);
+                                    typeVar.priv.scopeId = getScopeIdForNode(initDeclNode);
                                     typeVar.shared.boundType = types_1.UnknownType.create();
-                                    return types_1.TypeVarType.cloneForScopeId(typeVar, ParseTreeUtils.getScopeIdForNode(node), node.d.name.d.value, 0 /* TypeVarScopeType.Class */);
+                                    return types_1.TypeVarType.cloneForScopeId(typeVar, getScopeIdForNode(node), node.d.name.d.value, 0 /* TypeVarScopeType.Class */);
                                 });
                             }
                         }
@@ -13542,7 +13592,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             const effectiveMetaclass = computeEffectiveMetaclass(classType, node.d.name);
             const enumMemberSetMayBeDynamicallyModified = types_1.ClassType.isEnumClass(classType) &&
-                (AnalyzerNodeInfo.getScope(node)?.hasPotentiallyDynamicSymbolTable ||
+                (nodeInfo.getScope(node)?.hasPotentiallyDynamicSymbolTable ||
                     classType.shared.mro.some((mroClass) => (0, types_1.isClass)(mroClass) && types_1.ClassType.isEnumMemberSetMayBeDynamicallyModified(mroClass)));
             if (enumMemberSetMayBeDynamicallyModified) {
                 classType.shared.flags |= 67108864 /* ClassTypeFlags.EnumMemberSetMayBeDynamicallyModified */;
@@ -13565,7 +13615,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             let foundUnknown = false;
             for (let i = node.d.decorators.length - 1; i >= 0; i--) {
                 const decorator = node.d.decorators[i];
-                const newDecoratedType = useSignatureTracker(node.parent ?? node, () => (0, decorators_1.applyClassDecorator)(evaluatorInterface, decoratedType, classType, decorator));
+                const newDecoratedType = useSignatureTracker(node.parent ?? node, () => (0, decorators_1.applyClassDecorator)(evaluatorInterface, decoratedType, classType, decorator, nodeInfo));
                 const unknownOrAny = (0, typeUtils_1.containsAnyOrUnknown)(newDecoratedType, /* recurse */ false);
                 if (unknownOrAny && (0, types_1.isUnknown)(unknownOrAny)) {
                     // Report this error only on the first unknown type.
@@ -13596,7 +13646,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
             }
             if (dataClassBehaviors) {
-                (0, dataClasses_1.applyDataClassClassBehaviorOverrides)(evaluatorInterface, node.d.name, classType, initSubclassArgs, dataClassBehaviors);
+                (0, dataClasses_1.applyDataClassClassBehaviorOverrides)(evaluatorInterface, node.d.name, classType, initSubclassArgs, dataClassBehaviors, nodeInfo);
             }
             // Run any deferred class completions that depend on this class.
             runDeferredClassCompletions(classType);
@@ -13620,7 +13670,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 if (foundInvalidBaseClass) {
                     addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typedDictBaseClass() + diag.getString(), node.d.name);
                 }
-                (0, typedDicts_1.synthesizeTypedDictClassMethods)(evaluatorInterface, node, classType);
+                (0, typedDicts_1.synthesizeTypedDictClassMethods)(evaluatorInterface, node, classType, nodeInfo);
             }
             // Synthesize dataclass methods.
             if (types_1.ClassType.isDataClass(classType) || isNamedTupleSubclass) {
@@ -13641,7 +13691,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 if (hashSymbol && hashSymbol.isClassMember() && !hashSymbol.getSynthesizedType()) {
                     skipSynthesizeHash = true;
                 }
-                const synthesizeMethods = () => (0, dataClasses_1.synthesizeDataClassMethods)(evaluatorInterface, node, classType, isNamedTupleSubclass, skipSynthesizedInit, hasExistingInitMethod, skipSynthesizeHash);
+                const synthesizeMethods = () => (0, dataClasses_1.synthesizeDataClassMethods)(evaluatorInterface, node, classType, isNamedTupleSubclass, skipSynthesizedInit, hasExistingInitMethod, skipSynthesizeHash, nodeInfo);
                 // If this is a NamedTuple subclass, immediately synthesize dataclass methods
                 // because we also need to update the MRO classes in this case. For regular
                 // dataclasses, we'll defer the  method synthesis to avoid circular dependencies.
@@ -13805,7 +13855,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     }
     function evaluateTypeParamList(node) {
         const paramTypes = [];
-        const typeParamScope = AnalyzerNodeInfo.getScope(node);
+        const typeParamScope = nodeInfo.getScope(node);
         node.d.params.forEach((param) => {
             const paramSymbol = typeParamScope?.symbolTable.get(param.d.name.d.value);
             if (!paramSymbol) {
@@ -14091,7 +14141,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             const decorator = node.d.decorators[i];
             const newDecoratedType = useSignatureTracker(node.parent ?? node, () => {
                 (0, debug_1.assert)(decoratedType !== undefined);
-                return (0, decorators_1.applyFunctionDecorator)(evaluatorInterface, decoratedType, functionType, decorator, node);
+                return (0, decorators_1.applyFunctionDecorator)(evaluatorInterface, decoratedType, functionType, decorator, node, nodeInfo);
             });
             const unknownOrAny = (0, typeUtils_1.containsAnyOrUnknown)(newDecoratedType, /* recurse */ false);
             if (unknownOrAny && (0, types_1.isUnknown)(unknownOrAny)) {
@@ -14116,7 +14166,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 });
             }
         }
-        decoratedType = (0, decorators_1.addOverloadsToFunctionType)(evaluatorInterface, node, decoratedType);
+        decoratedType = (0, decorators_1.addOverloadsToFunctionType)(evaluatorInterface, node, decoratedType, nodeInfo);
         writeTypeCache(node, { type: decoratedType }, 0 /* EvalFlags.None */);
         // Now that the decorator has been applied, we can clear the
         // "partially evaluated" flag.
@@ -14126,14 +14176,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // Evaluates the type of a "def" statement without applying an async
     // modifier or any decorators.
     function getTypeOfFunctionPredecorated(node) {
-        const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
+        const fileInfo = nodeInfo.getFileInfo(node);
         // Is this type already cached?
         const cachedFunctionType = readTypeCache(node.d.name, 0 /* EvalFlags.None */);
         if (cachedFunctionType && (0, types_1.isFunction)(cachedFunctionType)) {
             return cachedFunctionType;
         }
         let functionDecl;
-        const decl = AnalyzerNodeInfo.getDeclaration(node);
+        const decl = nodeInfo.getDeclaration(node);
         if (decl) {
             functionDecl = decl;
         }
@@ -14144,7 +14194,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (containingClassNode) {
             containingClassType = getTypeOfClass(containingClassNode)?.classType;
         }
-        const functionInfo = (0, decorators_1.getFunctionInfoFromDecorators)(evaluatorInterface, node, !!containingClassNode);
+        const functionInfo = (0, decorators_1.getFunctionInfoFromDecorators)(evaluatorInterface, node, !!containingClassNode, nodeInfo);
         let functionFlags = functionInfo.flags;
         if (functionDecl?.isGenerator) {
             functionFlags |= 16 /* FunctionTypeFlags.Generator */;
@@ -14159,12 +14209,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             functionFlags |= 512 /* FunctionTypeFlags.Async */;
         }
         const functionType = types_1.FunctionType.createInstance(node.d.name.d.value, getFunctionFullName(node, fileInfo.moduleName, node.d.name.d.value), fileInfo.moduleName, functionFlags | 131072 /* FunctionTypeFlags.PartiallyEvaluated */, ParseTreeUtils.getDocString(node.d.suite.d.statements));
-        functionType.shared.typeVarScopeId = ParseTreeUtils.getScopeIdForNode(node);
+        functionType.shared.typeVarScopeId = getScopeIdForNode(node);
         functionType.shared.deprecatedMessage = functionInfo.deprecationMessage;
         functionType.shared.methodClass = containingClassType;
         if (node.d.name.d.value === '__init__' || node.d.name.d.value === '__new__') {
             if (containingClassNode) {
-                functionType.priv.constructorTypeVarScopeId = ParseTreeUtils.getScopeIdForNode(containingClassNode);
+                functionType.priv.constructorTypeVarScopeId = getScopeIdForNode(containingClassNode);
             }
         }
         if (fileInfo.isBuiltInStubFile || fileInfo.isTypingStubFile || fileInfo.isTypingExtensionsStubFile) {
@@ -14173,7 +14223,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         functionType.shared.declaration = functionDecl;
         // Allow recursion by caching and registering the partially-constructed function type.
-        const scope = ScopeUtils.getScopeForNode(node);
+        const scope = getScopeForNode(node);
         const functionSymbol = scope?.lookUpSymbolRecursive(node.d.name.d.value);
         if (functionDecl && functionSymbol) {
             setSymbolResolutionPartialType(functionSymbol.symbol, functionDecl, functionType);
@@ -14372,7 +14422,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 types_1.FunctionType.addPositionOnlyParamSeparator(functionType);
             }
             // Update the types for the nodes associated with the parameters.
-            const scopeIds = ParseTreeUtils.getTypeVarScopesForNode(node);
+            const scopeIds = getTypeVarScopesForNode(node);
             paramTypes.forEach((paramType, index) => {
                 const paramNameNode = node.d.params[index].d.name;
                 if (paramNameNode) {
@@ -14456,7 +14506,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             const symbolWithScope = lookUpSymbolRecursive(param.d.name, param.d.name.d.value, 
             /* honorCodeFlow */ false);
             if (symbolWithScope) {
-                setSymbolAccessed(AnalyzerNodeInfo.getFileInfo(param), symbolWithScope.symbol, param.d.name);
+                setSymbolAccessed(nodeInfo.getFileInfo(param), symbolWithScope.symbol, param.d.name);
             }
         }
     }
@@ -14468,7 +14518,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (param.d.defaultValue?.nodeType === 14 /* ParseNodeType.Constant */ &&
             param.d.defaultValue.d.constType === 27 /* KeywordType.None */ &&
             !(0, typeUtils_1.isOptionalType)(type) &&
-            !AnalyzerNodeInfo.getFileInfo(param).diagnosticRuleSet.strictParameterNoneValue) {
+            !nodeInfo.getFileInfo(param).diagnosticRuleSet.strictParameterNoneValue) {
             return (0, types_1.combineTypes)([type, getNoneType()]);
         }
         return type;
@@ -14506,7 +14556,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             if ((0, typeUtils_1.requiresSpecialization)(inferredParamType) && (0, types_1.isClass)(baseClassMemberInfo.classType)) {
                                 const scopeIds = (0, typeUtils_1.getTypeVarScopeIds)(baseClassMemberInfo.classType);
                                 const solution = (0, typeUtils_1.buildSolutionFromSpecializedClass)(baseClassMemberInfo.classType);
-                                scopeIds.push(ParseTreeUtils.getScopeIdForNode(baseClassMethodNode));
+                                scopeIds.push(getScopeIdForNode(baseClassMethodNode));
                                 // Replace any unsolved TypeVars with Unknown (including all function-scoped TypeVars).
                                 inferredParamType = (0, typeUtils_1.applySolvedTypeVars)(inferredParamType, solution, {
                                     replaceUnsolved: {
@@ -14515,7 +14565,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                                     },
                                 });
                             }
-                            const fileInfo = AnalyzerNodeInfo.getFileInfo(functionNode);
+                            const fileInfo = nodeInfo.getFileInfo(functionNode);
                             if (fileInfo.isInPyTypedPackage && !fileInfo.isStubFile) {
                                 inferredParamType = types_1.TypeBase.cloneForAmbiguousType(inferredParamType);
                             }
@@ -14567,7 +14617,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
         }
         if (inferredParamType) {
-            const fileInfo = AnalyzerNodeInfo.getFileInfo(paramValueExpr);
+            const fileInfo = nodeInfo.getFileInfo(paramValueExpr);
             if (fileInfo.isInPyTypedPackage && !fileInfo.isStubFile) {
                 inferredParamType = types_1.TypeBase.cloneForAmbiguousType(inferredParamType);
             }
@@ -14698,14 +14748,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             functionRecursionMap.set(node.id, recursionEntry);
             try {
                 let functionDecl;
-                const decl = AnalyzerNodeInfo.getDeclaration(node);
+                const decl = nodeInfo.getDeclaration(node);
                 if (decl) {
                     functionDecl = decl;
                 }
                 const functionNeverReturns = !isAfterNodeReachable(node);
                 const implicitlyReturnsNone = isAfterNodeReachable(node.d.suite);
                 // Infer the return type based on all of the return statements in the function's body.
-                if (AnalyzerNodeInfo.getFileInfo(node).isStubFile) {
+                if (nodeInfo.getFileInfo(node).isStubFile) {
                     // If a return type annotation is missing in a stub file, assume
                     // it's an "unknown" type. In normal source files, we can infer the
                     // type from the implementation.
@@ -14850,7 +14900,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 // cases, we can get very deep stacks when inferring return types
                 // within untyped code.
                 if (err?.message === 'Maximum call stack size exceeded') {
-                    const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
+                    const fileInfo = nodeInfo.getFileInfo(node);
                     console.error(`Overflowed stack when inferring return type for function: ${node.d.name.d.value} in file ${fileInfo.fileUri.toUserVisibleString()}`);
                     return;
                 }
@@ -15081,7 +15131,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             return;
         }
         const aliasNode = node.d.alias || node.d.name;
-        const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
+        const fileInfo = nodeInfo.getFileInfo(node);
         // If this is a redundant form of an import, assume it is an intentional
         // export and mark the symbol as accessed.
         if (node.d.alias?.d.value === node.d.name.d.value) {
@@ -15103,7 +15153,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             const parentNode = node.parent;
             (0, debug_1.assert)(parentNode && parentNode.nodeType === 25 /* ParseNodeType.ImportFrom */);
             (0, debug_1.assert)(!parentNode.d.isWildcardImport);
-            const importInfo = AnalyzerNodeInfo.getImportInfo(parentNode.d.module);
+            const importInfo = nodeInfo.getImportInfo(parentNode.d.module);
             if (importInfo && importInfo.isImportFound && !importInfo.isNativeLib) {
                 const resolvedPath = importInfo.resolvedUris[importInfo.resolvedUris.length - 1];
                 const importLookupInfo = importLookup(resolvedPath);
@@ -15151,7 +15201,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         for (const caseStatement of node.d.cases) {
             if (!caseStatement.d.guardExpr) {
                 subjectType = (0, patternMatching_1.narrowTypeBasedOnPattern)(evaluatorInterface, subjectType, caseStatement.d.pattern, 
-                /* isPositiveTest */ false);
+                /* isPositiveTest */ false, nodeInfo);
             }
         }
         writeTypeCache(node, { type: subjectType, isIncomplete: !!subjectTypeResult.isIncomplete }, 0 /* EvalFlags.None */);
@@ -15164,7 +15214,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             (0, debug_1.fail)('Expected parent of case statement to be match statement');
             return;
         }
-        const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
+        const fileInfo = nodeInfo.getFileInfo(node);
         const subjectTypeResult = getTypeOfExpression(node.parent.d.expr);
         let subjectType = subjectTypeResult.type;
         // Apply negative narrowing for each of the cases prior to the current one
@@ -15173,17 +15223,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (caseStatement === node) {
                 if (fileInfo.diagnosticRuleSet.reportUnnecessaryComparison !== 'none') {
                     if (!subjectTypeResult.isIncomplete) {
-                        (0, patternMatching_1.checkForUnusedPattern)(evaluatorInterface, node.d.pattern, subjectType);
+                        (0, patternMatching_1.checkForUnusedPattern)(evaluatorInterface, node.d.pattern, subjectType, nodeInfo);
                     }
                 }
                 break;
             }
             if (!caseStatement.d.guardExpr) {
                 subjectType = (0, patternMatching_1.narrowTypeBasedOnPattern)(evaluatorInterface, subjectType, caseStatement.d.pattern, 
-                /* isPositiveTest */ false);
+                /* isPositiveTest */ false, nodeInfo);
             }
         }
-        const narrowedSubjectType = (0, patternMatching_1.assignTypeToPatternTargets)(evaluatorInterface, subjectType, !!subjectTypeResult.isIncomplete, node.d.pattern);
+        const narrowedSubjectType = (0, patternMatching_1.assignTypeToPatternTargets)(evaluatorInterface, subjectType, !!subjectTypeResult.isIncomplete, node.d.pattern, nodeInfo);
         writeTypeCache(node, { type: narrowedSubjectType, isIncomplete: !!subjectTypeResult.isIncomplete }, 0 /* EvalFlags.None */);
     }
     function evaluateTypesForImportFrom(node) {
@@ -15193,7 +15243,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (node.d.isWildcardImport) {
             // Write back a dummy type so we don't evaluate this node again.
             writeTypeCache(node, { type: types_1.AnyType.create() }, 0 /* EvalFlags.None */);
-            const flowNode = AnalyzerNodeInfo.getFlowNode(node);
+            const flowNode = nodeInfo.getFlowNode(node);
             if (flowNode && (flowNode.flags & codeFlowTypes_1.FlowFlags.WildcardImport) !== 0) {
                 const wildcardFlowNode = flowNode;
                 wildcardFlowNode.names.forEach((name) => {
@@ -15278,7 +15328,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             return undefined;
         }
         (0, debug_1.assert)(aliasDecl.type === 8 /* DeclarationType.Alias */);
-        const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
+        const fileInfo = nodeInfo.getFileInfo(node);
         // Try to resolve the alias while honoring external visibility.
         const resolvedAliasInfo = resolveAliasDeclarationWithInfo(aliasDecl, /* resolveLocalNames */ true, {
             allowExternallyHiddenAccess: fileInfo.isStubFile,
@@ -15561,7 +15611,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         ? getDeclaredReturnType(enclosingFunctionNode)
                         : undefined;
                     if (declaredReturnType) {
-                        const liveScopeIds = ParseTreeUtils.getTypeVarScopesForNode(node);
+                        const liveScopeIds = getTypeVarScopesForNode(node);
                         declaredReturnType = (0, typeUtils_1.makeTypeVarsBound)(declaredReturnType, liveScopeIds);
                     }
                     getTypeOfExpression(parent.d.expr, 0 /* EvalFlags.None */, (0, typeUtils_1.makeInferenceContext)(declaredReturnType));
@@ -15609,7 +15659,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (typeAnnotation) {
             const param = functionNode.d.params[paramIndex];
             let annotatedType = getTypeOfParamAnnotation(typeAnnotation, functionNode.d.params[paramIndex].d.category);
-            const liveTypeVarScopes = ParseTreeUtils.getTypeVarScopesForNode(param);
+            const liveTypeVarScopes = getTypeVarScopesForNode(param);
             annotatedType = (0, typeUtils_1.makeTypeVarsBound)(annotatedType, liveTypeVarScopes);
             const adjType = transformVariadicParamType(node, node.d.category, adjustParamAnnotatedType(param, annotatedType));
             writeTypeCache(node.d.name, { type: adjType }, 0 /* EvalFlags.None */);
@@ -15631,9 +15681,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // infer the type of the parameter from a method of the same name in
         // a parent class if it has an annotated type.
         const functionFlags = (0, decorators_1.getFunctionInfoFromDecorators)(evaluatorInterface, functionNode, 
-        /* isInClass */ true).flags;
+        /* isInClass */ true, nodeInfo).flags;
         let inferredParamType = inferParamType(functionNode, functionFlags, paramIndex, classInfo?.classType) ?? types_1.UnknownType.create();
-        const liveTypeVarScopes = ParseTreeUtils.getTypeVarScopesForNode(node);
+        const liveTypeVarScopes = getTypeVarScopesForNode(node);
         inferredParamType = (0, typeUtils_1.makeTypeVarsBound)(inferredParamType, liveTypeVarScopes);
         writeTypeCache(node.d.name, { type: transformVariadicParamType(node, node.d.category, inferredParamType) }, 0 /* EvalFlags.None */);
     }
@@ -15809,8 +15859,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     function getFlowTypeOfReference(reference, startNode, options) {
         // See if this execution scope requires code flow for this reference expression.
         const referenceKey = (0, codeFlowTypes_1.createKeyForReference)(reference);
-        const executionNode = ParseTreeUtils.getExecutionScopeNode(startNode?.parent ?? reference);
-        const codeFlowExpressions = AnalyzerNodeInfo.getCodeFlowExpressions(executionNode);
+        const executionNode = ParseTreeUtils.getExecutionScopeNode(startNode?.parent ?? reference, nodeInfo);
+        const codeFlowExpressions = nodeInfo.getCodeFlowExpressions(executionNode);
         if (!codeFlowExpressions ||
             (!codeFlowExpressions.has(referenceKey) && !codeFlowExpressions.has(codeFlowTypes_1.wildcardImportReferenceKey))) {
             return codeFlowEngine_1.FlowNodeTypeResult.create(/* type */ undefined, /* isIncomplete */ false);
@@ -15834,7 +15884,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         else {
             analyzer = getCodeFlowAnalyzerForNode(executionNode, options?.typeAtStart);
         }
-        const flowNode = AnalyzerNodeInfo.getFlowNode(startNode ?? reference);
+        const flowNode = nodeInfo.getFlowNode(startNode ?? reference);
         if (flowNode === undefined) {
             return codeFlowEngine_1.FlowNodeTypeResult.create(/* type */ undefined, /* isIncomplete */ false);
         }
@@ -15901,8 +15951,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     if ((flags &
                         (67108864 /* EvalFlags.NoNonTypeSpecialForms */ | 256 /* EvalFlags.TypeExpression */ | 1073741824 /* EvalFlags.TypeFormArg */)) !==
                         0) {
-                        const isInlinedTypedDict = AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.enableExperimentalFeatures &&
-                            !!typeArgs;
+                        const isInlinedTypedDict = nodeInfo.getFileInfo(errorNode).diagnosticRuleSet.enableExperimentalFeatures && !!typeArgs;
                         if (!isInlinedTypedDict) {
                             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typedDictNotAllowed(), errorNode);
                         }
@@ -15974,10 +16023,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
             }
         }
-        const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
+        const fileInfo = nodeInfo.getFileInfo(errorNode);
         if (fileInfo.isStubFile ||
             pythonVersion_1.PythonVersion.isGreaterOrEqualTo(fileInfo.executionEnvironment.pythonVersion, pythonVersion_1.pythonVersion3_9) ||
-            (0, analyzerFileInfo_1.isAnnotationEvaluationPostponed)(AnalyzerNodeInfo.getFileInfo(errorNode)) ||
+            (0, analyzerFileInfo_1.isAnnotationEvaluationPostponed)(nodeInfo.getFileInfo(errorNode)) ||
             (flags & 4 /* EvalFlags.ForwardRefs */) !== 0) {
             // Handle "type" specially, since it needs to act like "Type"
             // in Python 3.9 and newer.
@@ -16294,7 +16343,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (options?.enforceClassTypeVarScope) {
             flags |= -2147483648 /* EvalFlags.EnforceClassTypeVarScope */;
         }
-        const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
+        const fileInfo = nodeInfo.getFileInfo(node);
         if (((0, analyzerFileInfo_1.isAnnotationEvaluationPostponed)(fileInfo) || options?.forwardRefs) && !options?.runtimeTypeExpression) {
             flags |= 4 /* EvalFlags.ForwardRefs */;
         }
@@ -16349,7 +16398,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         return getTypeOfExpression(node, flags);
     }
     function getBuiltInType(node, name) {
-        const scope = ScopeUtils.getScopeForNode(node);
+        const scope = getScopeForNode(node);
         if (scope) {
             const builtInScope = ScopeUtils.getBuiltInScope(scope);
             const nameType = builtInScope.lookUpSymbol(name);
@@ -16371,8 +16420,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         return nameType;
     }
     function lookUpSymbolRecursive(node, name, honorCodeFlow, preferGlobalScope = false) {
-        const scopeNodeInfo = ParseTreeUtils.getEvaluationScopeNode(node);
-        const scope = AnalyzerNodeInfo.getScope(scopeNodeInfo.node);
+        const scopeNodeInfo = ParseTreeUtils.getEvaluationScopeNode(node, nodeInfo);
+        const scope = nodeInfo.getScope(scopeNodeInfo.node);
         let symbolWithScope = scope?.lookUpSymbolRecursive(name, {
             useProxyScope: !!scopeNodeInfo.useProxyScope,
             useChainedModuleLevelScopes: !!scopeNodeInfo.useChainedModuleLevelScopes,
@@ -16391,20 +16440,20 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             const reachableDecl = symbolWithScope.symbol.getDeclarations().find((decl) => {
                 if (decl.type !== 8 /* DeclarationType.Alias */ && decl.type !== 0 /* DeclarationType.Intrinsic */) {
                     // Determine if the declaration is in the same execution scope as the "usageNode" node.
-                    let usageScopeNode = ParseTreeUtils.getExecutionScopeNode(node);
+                    let usageScopeNode = ParseTreeUtils.getExecutionScopeNode(node, nodeInfo);
                     const declNode = decl.type === 6 /* DeclarationType.Class */ ||
                         decl.type === 5 /* DeclarationType.Function */ ||
                         decl.type === 4 /* DeclarationType.TypeAlias */
                         ? decl.node.d.name
                         : decl.node;
-                    const declScopeNode = ParseTreeUtils.getExecutionScopeNode(declNode);
+                    const declScopeNode = ParseTreeUtils.getExecutionScopeNode(declNode, nodeInfo);
                     // If this is a type parameter scope, it will be a proxy for its
                     // containing scope, so we need to use that instead.
-                    const usageScope = AnalyzerNodeInfo.getScope(usageScopeNode);
+                    const usageScope = nodeInfo.getScope(usageScopeNode);
                     if (usageScope?.proxy) {
-                        const typeParamScope = AnalyzerNodeInfo.getScope(usageScopeNode);
+                        const typeParamScope = nodeInfo.getScope(usageScopeNode);
                         if (!typeParamScope?.symbolTable.has(name) && usageScopeNode.parent) {
-                            usageScopeNode = ParseTreeUtils.getExecutionScopeNode(usageScopeNode.parent);
+                            usageScopeNode = ParseTreeUtils.getExecutionScopeNode(usageScopeNode.parent, nodeInfo);
                         }
                     }
                     if (usageScopeNode === declScopeNode) {
@@ -16412,7 +16461,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             // If there was no control flow path from the usage back
                             // to the source, see if the usage node is reachable by
                             // any path.
-                            const flowNode = AnalyzerNodeInfo.getFlowNode(node);
+                            const flowNode = nodeInfo.getFlowNode(node);
                             const isReachable = flowNode &&
                                 codeFlowEngine.getFlowNodeReachability(flowNode, 
                                 /* sourceFlowNode */ undefined, 
@@ -16588,7 +16637,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 const functionDecl = type.shared.declaration;
                 if (functionDecl.type === 5 /* DeclarationType.Function */) {
                     const functionNode = functionDecl.node;
-                    const functionScope = AnalyzerNodeInfo.getScope(functionNode);
+                    const functionScope = nodeInfo.getScope(functionNode);
                     if (functionScope) {
                         const paramSymbol = functionScope.lookUpSymbol(paramName);
                         if (paramSymbol) {
@@ -16609,6 +16658,48 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return undefined;
     }
+    // functools.partial(func, kw=value) forwards keyword arguments to the wrapped callable, but
+    // partial's own signature absorbs them through **kwargs, so they don't resolve to a declaration.
+    // Resolve the keyword against the wrapped callable (the first positional argument) instead so IDE
+    // features like go-to-definition and rename bind to the underlying parameter. Returns true when
+    // baseType is functools.partial, so the caller suppresses the default keyword-argument handling.
+    function _tryAddPartialKeywordParamDecls(baseType, callNode, paramName, decls) {
+        if (!(0, types_1.isInstantiableClass)(baseType) || baseType.shared.fullName !== 'functools.partial') {
+            return false;
+        }
+        const wrappedArg = callNode.d.args.find((arg) => arg.d.argCategory === 0 /* ArgCategory.Simple */ && !arg.d.name);
+        if (!wrappedArg) {
+            return true;
+        }
+        const wrappedType = getType(wrappedArg.d.valueExpr);
+        if (!wrappedType) {
+            return true;
+        }
+        if ((0, types_1.isFunction)(wrappedType)) {
+            const paramDecl = getDeclarationFromKeywordParam(wrappedType, paramName);
+            if (paramDecl) {
+                decls.push(paramDecl);
+            }
+        }
+        else if ((0, types_1.isOverloaded)(wrappedType)) {
+            types_1.OverloadedType.getOverloads(wrappedType).forEach((f) => {
+                const paramDecl = getDeclarationFromKeywordParam(f, paramName);
+                if (paramDecl) {
+                    decls.push(paramDecl);
+                }
+            });
+        }
+        else if ((0, types_1.isInstantiableClass)(wrappedType)) {
+            const initMethodType = (0, constructors_1.getBoundInitMethod)(evaluatorInterface, wrappedArg.d.valueExpr, types_1.ClassType.cloneAsInstance(wrappedType))?.type;
+            if (initMethodType && (0, types_1.isFunction)(initMethodType)) {
+                const paramDecl = getDeclarationFromKeywordParam(initMethodType, paramName);
+                if (paramDecl) {
+                    decls.push(paramDecl);
+                }
+            }
+        }
+        return true;
+    }
     function _shouldFallBackToClassEntryForKeywordArg(baseType, paramName) {
         return (types_1.ClassType.isDataClass(baseType) ||
             types_1.ClassType.isTypedDictClass(baseType) ||
@@ -16675,7 +16766,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         return undefined;
     }
     function getDeclInfoForNameNode(node, skipUnreachableCode = true) {
-        if (skipUnreachableCode && AnalyzerNodeInfo.isCodeUnreachable(node)) {
+        if (skipUnreachableCode && nodeInfo.isCodeUnreachable(node)) {
             return undefined;
         }
         const decls = [];
@@ -16685,7 +16776,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // since the non-aliased name is not in the symbol table.
         const alias = getAliasFromImport(node);
         if (alias) {
-            const scope = ScopeUtils.getScopeForNode(node);
+            const scope = getScopeForNode(node);
             if (scope) {
                 // Look up the alias symbol.
                 const symbolInScope = scope.lookUpSymbolRecursive(alias.d.value);
@@ -16751,7 +16842,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         else if (node.parent && node.parent.nodeType === 37 /* ParseNodeType.ModuleName */) {
             const namePartIndex = node.parent.d.nameParts.findIndex((part) => part === node);
-            const importInfo = AnalyzerNodeInfo.getImportInfo(node.parent);
+            const importInfo = nodeInfo.getImportInfo(node.parent);
             if (namePartIndex >= 0 &&
                 importInfo &&
                 !importInfo.isNativeLib &&
@@ -16773,7 +16864,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (argNode.parent?.nodeType === 9 /* ParseNodeType.Call */) {
                 const baseType = getType(argNode.parent.d.leftExpr);
                 if (baseType) {
-                    if ((0, types_1.isFunction)(baseType) && baseType.shared.declaration) {
+                    if (_tryAddPartialKeywordParamDecls(baseType, argNode.parent, paramName, decls)) {
+                        // functools.partial keyword args are resolved against the wrapped callable.
+                    }
+                    else if ((0, types_1.isFunction)(baseType) && baseType.shared.declaration) {
                         const paramDecl = getDeclarationFromKeywordParam(baseType, paramName);
                         if (paramDecl) {
                             decls.push(paramDecl);
@@ -16817,10 +16911,45 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
             }
         }
+        else if (node.parent &&
+            node.parent.nodeType === 74 /* ParseNodeType.PatternClassArgument */ &&
+            node === node.parent.d.name &&
+            node.parent.parent?.nodeType === 68 /* ParseNodeType.PatternClass */) {
+            // The target node is the keyword name in a class pattern argument
+            // (e.g. `case Foo(prop=...)`). Map it to the corresponding class member
+            // declaration so that find-all-references and rename bind to the attribute.
+            // Only the keyword (left of `=`) is handled here; the capture target on the
+            // right (e.g. the second `prop` in `case Foo(prop=prop)`) is a separate local
+            // binding that is resolved through the normal name-lookup path.
+            const memberName = node.d.value;
+            let classType = getType(node.parent.parent.d.className);
+            if (classType) {
+                classType = makeTopLevelTypeVarsConcrete(classType);
+                (0, typeUtils_1.doForEachSubtype)(classType, (subtype) => {
+                    subtype = makeTopLevelTypeVarsConcrete(subtype);
+                    // The class name in a class pattern usually evaluates to an instantiable class,
+                    // but analysis can still yield Unknown/Any (e.g. an unresolved class name), so
+                    // the isInstantiableClass gate skips those subtypes rather than assuming
+                    // every subtype is a class.
+                    if ((0, types_1.isInstantiableClass)(subtype)) {
+                        // Try to find a member that has a declared type. If so, that
+                        // overrides any inferred types.
+                        let member = (0, typeUtils_1.lookUpClassMember)(subtype, memberName, 64 /* MemberAccessFlags.DeclaredTypesOnly */);
+                        if (!member) {
+                            member = (0, typeUtils_1.lookUpClassMember)(subtype, memberName);
+                        }
+                        if (member) {
+                            _addSymbolDeclInfo(member.symbol, decls, synthesizedTypes, 
+                            /* preferTypedDeclarations */ true);
+                        }
+                    }
+                });
+            }
+        }
         else {
-            const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
+            const fileInfo = nodeInfo.getFileInfo(node);
             // Determine if this node is within a quoted type annotation.
-            const isWithinTypeAnnotation = ParseTreeUtils.isWithinTypeAnnotation(node, !(0, analyzerFileInfo_1.isAnnotationEvaluationPostponed)(AnalyzerNodeInfo.getFileInfo(node)));
+            const isWithinTypeAnnotation = ParseTreeUtils.isWithinTypeAnnotation(node, !(0, analyzerFileInfo_1.isAnnotationEvaluationPostponed)(nodeInfo.getFileInfo(node)), nodeInfo);
             // Determine if this is part of a "type" statement.
             const isWithinTypeAliasStatement = !!ParseTreeUtils.getParentNodeOfType(node, 77 /* ParseNodeType.TypeAlias */);
             const allowForwardReferences = isWithinTypeAnnotation || isWithinTypeAliasStatement || fileInfo.isStubFile;
@@ -16908,7 +17037,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
                 if (typeAnnotationNode) {
                     let declaredType = getTypeOfParamAnnotation(typeAnnotationNode, declaration.node.d.category);
-                    const liveTypeVarScopes = ParseTreeUtils.getTypeVarScopesForNode(declaration.node);
+                    const liveTypeVarScopes = getTypeVarScopesForNode(declaration.node);
                     declaredType = (0, typeUtils_1.makeTypeVarsBound)(declaredType, liveTypeVarScopes);
                     return {
                         type: transformVariadicParamType(declaration.node, declaration.node.d.category, adjustParamAnnotatedType(declaration.node, declaredType)),
@@ -16956,9 +17085,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         if (declaration.isDefinedByMemberAccess) {
                             const enclosingClass = ParseTreeUtils.getEnclosingClass(declaration.node);
                             if (enclosingClass) {
-                                declaredType = (0, typeUtils_1.makeTypeVarsFree)(declaredType, [
-                                    ParseTreeUtils.getScopeIdForNode(enclosingClass),
-                                ]);
+                                declaredType = (0, typeUtils_1.makeTypeVarsFree)(declaredType, [getScopeIdForNode(enclosingClass)]);
                             }
                         }
                         if ((0, types_1.isClassInstance)(declaredType) && types_1.ClassType.isBuiltIn(declaredType, 'TypeAlias')) {
@@ -17103,7 +17230,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 typeVar.shared.declaredVariance =
                     (0, types_1.isParamSpec)(typeVar) || (0, types_1.isTypeVarTuple)(typeVar) ? 2 /* Variance.Invariant */ : 0 /* Variance.Auto */;
             }
-            typeVar = types_1.TypeVarType.cloneForScopeId(typeVar, ParseTreeUtils.getScopeIdForNode(scopeNode.nodeType === 77 /* ParseNodeType.TypeAlias */ ? scopeNode.d.name : scopeNode), scopeNode.d.name.d.value, scopeType);
+            typeVar = types_1.TypeVarType.cloneForScopeId(typeVar, getScopeIdForNode(scopeNode.nodeType === 77 /* ParseNodeType.TypeAlias */ ? scopeNode.d.name : scopeNode), scopeNode.d.name.d.value, scopeType);
         }
         writeTypeCache(node, { type: typeVar }, /* flags */ undefined);
         writeTypeCache(node.d.name, { type: typeVar }, /* flags */ undefined);
@@ -17111,7 +17238,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     }
     function getInferredTypeOfDeclaration(symbol, decl) {
         const resolvedDecl = resolveAliasDeclaration(decl, /* resolveLocalNames */ true, {
-            allowExternallyHiddenAccess: AnalyzerNodeInfo.getFileInfo(decl.node).isStubFile,
+            allowExternallyHiddenAccess: nodeInfo.getFileInfo(decl.node).isStubFile,
         });
         // We couldn't resolve the alias. Substitute an unknown
         // type in this case.
@@ -17197,7 +17324,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         // If this is part of a "py.typed" package, don't fall back on type inference
         // unless it's marked Final, is a constant, or is a declared type alias.
-        const fileInfo = AnalyzerNodeInfo.getFileInfo(resolvedDecl.node);
+        const fileInfo = nodeInfo.getFileInfo(resolvedDecl.node);
         let isUnambiguousType = !fileInfo.isInPyTypedPackage || fileInfo.isStubFile;
         // If this is a py.typed package, determine if this is a case where an unannotated
         // variable is considered "unambiguous" because all type checkers are almost
@@ -17409,7 +17536,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (decl.type === 1 /* DeclarationType.Variable */) {
                 // Exempt typing.pyi and typingExtensions.pyi, which use variables to
                 // define some special forms.
-                const fileInfo = AnalyzerNodeInfo.getFileInfo(decl.node);
+                const fileInfo = nodeInfo.getFileInfo(decl.node);
                 if (!fileInfo.isTypingStubFile && !fileInfo.isTypingExtensionsStubFile) {
                     return true;
                 }
@@ -17473,7 +17600,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         let sawExplicitTypeAlias = false;
         decls.forEach((decl, index) => {
             const resolvedDecl = resolveAliasDeclaration(decl, /* resolveLocalNames */ true, {
-                allowExternallyHiddenAccess: AnalyzerNodeInfo.getFileInfo(decl.node).isStubFile,
+                allowExternallyHiddenAccess: nodeInfo.getFileInfo(decl.node).isStubFile,
             }) ?? decl;
             if (!isPossibleTypeAliasDeclaration(resolvedDecl) && !isExplicitTypeAliasDeclaration(resolvedDecl)) {
                 includesIllegalTypeAliasDecl = true;
@@ -17504,8 +17631,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     // Is the declaration in the same execution scope as the "usageNode" node?
                     // If so, we can skip it because code flow analysis will allow us
                     // to determine the type in this context.
-                    const usageScope = ParseTreeUtils.getExecutionScopeNode(usageNode);
-                    const declScope = ParseTreeUtils.getExecutionScopeNode(decl.node);
+                    const usageScope = ParseTreeUtils.getExecutionScopeNode(usageNode, nodeInfo);
+                    const declScope = ParseTreeUtils.getExecutionScopeNode(decl.node, nodeInfo);
                     if (usageScope === declScope) {
                         // Skip declarations that appear after the usage in the source.
                         // Such declarations are typically only reached via loop back-edges,
@@ -17693,8 +17820,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 const filteredTypedDecls = typedDecls.filter((decl) => {
                     if (decl.type !== 8 /* DeclarationType.Alias */) {
                         // Is the declaration in the same execution scope as the "usageNode" node?
-                        const usageScope = ParseTreeUtils.getExecutionScopeNode(usageNode);
-                        const declScope = ParseTreeUtils.getExecutionScopeNode(decl.node);
+                        const usageScope = ParseTreeUtils.getExecutionScopeNode(usageNode, nodeInfo);
+                        const declScope = ParseTreeUtils.getExecutionScopeNode(decl.node, nodeInfo);
                         if (usageScope === declScope) {
                             // For typed declarations we use the precise flow-graph reachability
                             // check rather than a simple position comparison, because typed decls
@@ -17780,7 +17907,35 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     function getEffectiveReturnTypeResult(type, options) {
         const specializedReturnType = types_1.FunctionType.getEffectiveReturnType(type, /* includeInferred */ false);
         if (specializedReturnType && !(0, types_1.isUnknown)(specializedReturnType)) {
-            return { type: specializedReturnType };
+            // A partially-unknown *inferred* return type (e.g. `Foo | Unknown`) can be
+            // cached on a specialized/bound copy of an unannotated function. Because
+            // `isUnknown` matches only a fully-unknown type, such a partial type would
+            // otherwise short-circuit here and prevent call-site return-type inference
+            // from ever running (e.g. an unannotated factory whose body narrows a
+            // parameter-derived local with `isinstance`). When a call site is available,
+            // fall through so the argument types can refine the inferred return type.
+            //
+            // NOTE: This gate intentionally mirrors a subset of the downstream call-site
+            // refinement guard in `_getInferredReturnTypeResult` (search `isPartlyUnknown(returnType)`),
+            // but tests the cached *specialized* return type here rather than the freshly-inferred
+            // one, and omits the `!isStubDefinition`/`!isPyTypedDefinition`/`!isIncomplete`
+            // conjuncts (not yet known at this point). Keep the two in sync if either is edited.
+            const canRefineWithCallSite = options?.callSiteInfo !== undefined &&
+                !type.shared.declaredReturnType &&
+                types_1.FunctionType.hasUnannotatedParams(type) &&
+                (0, typeUtils_1.isPartlyUnknown)(specializedReturnType);
+            if (!canRefineWithCallSite) {
+                return { type: specializedReturnType };
+            }
+            // Refine the cached partly-unknown return type using the call site. If the
+            // refinement comes back incomplete -- e.g. a self- or mutually-recursive
+            // factory whose base case returns the isinstance-narrowed local -- fall back
+            // to the already-cached specialized return type rather than propagating the
+            // incomplete result. The cached type is already correct in that case, and
+            // propagating `isIncomplete` would suppress caller-side diagnostics that only
+            // fire on a complete type (for example, `reveal_type`).
+            const refinedResult = getInferredReturnTypeResult(type, options?.callSiteInfo);
+            return refinedResult.isIncomplete ? { type: specializedReturnType } : refinedResult;
         }
         return getInferredReturnTypeResult(type, options?.callSiteInfo);
     }
@@ -17819,11 +17974,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             else if (type.shared.declaration) {
                 const functionNode = type.shared.declaration.node;
-                const skipUnannotatedFunction = !AnalyzerNodeInfo.getFileInfo(functionNode).diagnosticRuleSet.analyzeUnannotatedFunctions &&
+                const skipUnannotatedFunction = !nodeInfo.getFileInfo(functionNode).diagnosticRuleSet.analyzeUnannotatedFunctions &&
                     ParseTreeUtils.isUnannotatedFunction(functionNode);
                 // Skip return type inference if we are in "skip unannotated function" mode.
                 if (!skipUnannotatedFunction && !checkCodeFlowTooComplex(functionNode.d.suite)) {
-                    const codeFlowComplexity = AnalyzerNodeInfo.getCodeFlowComplexity(functionNode);
+                    const codeFlowComplexity = nodeInfo.getCodeFlowComplexity(functionNode);
                     // For very complex functions that have no annotated parameter types,
                     // don't attempt to infer the return type because it can be extremely
                     // expensive.
@@ -17887,7 +18042,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     returnType = contextualReturnType;
                     if (type.shared.declaration?.node) {
                         // Externalize any TypeVars that appear in the type.
-                        const liveScopeIds = ParseTreeUtils.getTypeVarScopesForNode(type.shared.declaration.node);
+                        const liveScopeIds = getTypeVarScopesForNode(type.shared.declaration.node);
                         returnType = (0, typeUtils_1.makeTypeVarsFree)(returnType, liveScopeIds);
                     }
                 }
@@ -17902,7 +18057,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             return undefined;
         }
         const functionNode = type.shared.declaration.node;
-        const codeFlowComplexity = AnalyzerNodeInfo.getCodeFlowComplexity(functionNode);
+        const codeFlowComplexity = nodeInfo.getCodeFlowComplexity(functionNode);
         if (codeFlowComplexity >= maxReturnCallSiteTypeInferenceCodeFlowComplexity) {
             return undefined;
         }
@@ -19928,6 +20083,24 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             srcDetails.positionOnlyParamCount = Math.max(0, srcDetails.params.findIndex((p) => p.kind !== parameterUtils_1.ParamKind.Positional || p.param.category !== 0 /* ParamCategory.Simple */ || !!p.defaultType));
         }
     }
+    // Determines whether the source's variadic **kwargs keyword parameter
+    // is assignable to the keyword form of a destination positional-or-keyword
+    // parameter.
+    function assignNamedParam(destDetails, srcDetails, paramIndex, diag, constraints, flags, recursionCount) {
+        const destParam = destDetails.params[paramIndex];
+        if (srcDetails.kwargsIndex === undefined) {
+            diag?.addMessage(localize_1.LocAddendum.namedParamMissingInSource().format({
+                name: destParam.param.name ?? '',
+            }));
+            return false;
+        }
+        else if (!assignParam(destParam.type, srcDetails.params[srcDetails.kwargsIndex].type, paramIndex, diag?.createAddendum(), constraints, flags, recursionCount)) {
+            return (flags & 32 /* AssignTypeFlags.PartialOverloadOverlap */) !== 0;
+        }
+        else {
+            return true;
+        }
+    }
     function assignFunction(destType, srcType, diag, constraints, flags, recursionCount) {
         let canAssign = true;
         const checkReturnType = (flags & 64 /* AssignTypeFlags.SkipReturnTypeCheck */) === 0;
@@ -20039,14 +20212,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             else if (destParam.kind !== parameterUtils_1.ParamKind.Positional &&
                 destParam.kind !== parameterUtils_1.ParamKind.ExpandedArgs &&
                 srcParam.kind === parameterUtils_1.ParamKind.Positional &&
-                srcParamDetails.kwargsIndex === undefined &&
                 !srcParamDetails.params.some((p) => p.kind === parameterUtils_1.ParamKind.Keyword &&
                     p.param.category === 0 /* ParamCategory.Simple */ &&
                     p.param.name === destParam.param.name)) {
-                diag?.addMessage(localize_1.LocAddendum.namedParamMissingInSource().format({
-                    name: destParam.param.name ?? '',
-                }));
-                canAssign = false;
+                if (!assignNamedParam(destParamDetails, srcParamDetails, paramIndex, diag, constraints, flags, recursionCount)) {
+                    canAssign = false;
+                }
             }
         }
         if (!types_1.FunctionType.isGradualCallableForm(destType) &&
@@ -20132,13 +20303,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             canAssign = false;
                         }
                         const destParamKind = destParamDetails.params[paramIndex].kind;
-                        if (destParamKind !== parameterUtils_1.ParamKind.Positional &&
-                            destParamKind !== parameterUtils_1.ParamKind.ExpandedArgs &&
-                            srcParamDetails.kwargsIndex === undefined) {
-                            diag?.addMessage(localize_1.LocAddendum.namedParamMissingInSource().format({
-                                name: destParamDetails.params[paramIndex].param.name ?? '',
-                            }));
-                            canAssign = false;
+                        if (destParamKind !== parameterUtils_1.ParamKind.Positional && destParamKind !== parameterUtils_1.ParamKind.ExpandedArgs) {
+                            if (!assignNamedParam(destParamDetails, srcParamDetails, paramIndex, diag, constraints, flags, recursionCount)) {
+                                canAssign = false;
+                            }
                         }
                     }
                 }
@@ -20232,7 +20400,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         srcParamInfo.kind === parameterUtils_1.ParamKind.Positional) {
                         return;
                     }
-                    const destParamInfo = destParamMap.get(srcParamInfo.param.name);
+                    const destParamInfo = destParamMap.get(srcParamInfo.param.name) ??
+                        destParamDetails.params.find((paramInfo) => paramInfo.param.name === srcParamInfo.param.name &&
+                            paramInfo.kind === parameterUtils_1.ParamKind.Standard &&
+                            paramInfo.param.category === 0 /* ParamCategory.Simple */);
                     const paramDiag = diag?.createAddendum();
                     const srcParamType = srcParamInfo.type;
                     if (!destParamInfo) {
@@ -20263,6 +20434,20 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         }
                         return;
                     }
+                    // A keyword-only source parameter was matched to a positional-or-keyword
+                    // dest parameter. The dest parameter can be called positionally, but a
+                    // keyword-only source parameter with no default would be left unsatisfied.
+                    if (destParamInfo.kind === parameterUtils_1.ParamKind.Standard &&
+                        srcParamInfo.kind === parameterUtils_1.ParamKind.Keyword &&
+                        !srcParamInfo.defaultType) {
+                        if ((flags & 32 /* AssignTypeFlags.PartialOverloadOverlap */) === 0) {
+                            paramDiag?.addMessage(localize_1.LocAddendum.functionParamDefaultMissing().format({
+                                name: srcParamInfo.param.name,
+                            }));
+                            canAssign = false;
+                            return;
+                        }
+                    }
                     // If we're performing a partial overload match and both the source
                     // and dest parameters provide defaults, assume that there could
                     // be a match.
@@ -20285,7 +20470,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                                 destType: printType(srcParamType),
                             }));
                         }
-                        canAssign = false;
+                        if (destParamInfo.kind !== parameterUtils_1.ParamKind.Standard ||
+                            (flags & 32 /* AssignTypeFlags.PartialOverloadOverlap */) === 0) {
+                            canAssign = false;
+                        }
                     }
                     if (destParamInfo.defaultType && !srcParamInfo.defaultType) {
                         diag?.createAddendum().addMessage(localize_1.LocAddendum.functionParamDefaultMissing().format({
@@ -21386,7 +21574,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // expression tree because we don't want to mutate the latter; the
     // expression tree created by this function is therefore used only temporarily.
     function parseStringAsTypeAnnotation(node, reportErrors) {
-        const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
+        const fileInfo = nodeInfo.getFileInfo(node);
         const parser = new parser_1.Parser();
         const textValue = node.d.strings[0].d.value;
         // Determine the offset within the file where the string
@@ -21404,14 +21592,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         parseOptions.pythonVersion = fileInfo.executionEnvironment.pythonVersion;
         parseOptions.reportErrorsForParsedStringContents = true;
         const parseResults = parser.parseTextExpression(dummyFileContents, valueOffset, textValue.length, parseOptions, 0 /* ParseTextMode.Expression */, 
-        /* initialParenDepth */ undefined, fileInfo.typingSymbolAliases);
+        /* initialParenDepth */ undefined, fileInfo.typingSymbolAliases, node.a);
         if (parseResults.parseTree) {
             // If there are errors but we are not reporting them, return
             // undefined to indicate that the parse failed.
             if (!reportErrors && parseResults.diagnostics.length > 0) {
                 return undefined;
             }
-            const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
+            const fileInfo = nodeInfo.getFileInfo(node);
             parseResults.diagnostics.forEach((diag) => {
                 fileInfo.diagnosticSink.addDiagnosticWithTextRange('error', diag.message, node);
             });
@@ -21419,7 +21607,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // Optionally add the new subtree to the parse tree so it can
             // participate in language server operations like find and replace.
             if (reportErrors) {
-                node.d.annotation = parseResults.parseTree;
+                nodeInfo.setStringAnnotation(node, parseResults.parseTree, parseResults.stringAnnotations);
             }
             return parseResults.parseTree;
         }
@@ -21429,7 +21617,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // var can be "narrowed" to a single one of its constraints based on isinstance
     // checks within the code flow.
     function narrowConstrainedTypeVar(node, typeVar) {
-        const flowNode = AnalyzerNodeInfo.getFlowNode(node);
+        const flowNode = nodeInfo.getFlowNode(node);
         if (!flowNode) {
             return undefined;
         }
@@ -21439,7 +21627,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         return ' '.repeat(printExpressionSpaceCount);
     }
     function getLineNum(node) {
-        const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
+        const fileInfo = nodeInfo.getFileInfo(node);
         const range = (0, positionUtils_1.convertOffsetsToRange)(node.start, node.start + node.length, fileInfo.lines);
         return (range.start.line + 1).toString();
     }
@@ -21450,6 +21638,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     const getInferredReturnTypeResult = wrapWithLogger(_getInferredReturnTypeResult);
     const evaluatorInterface = {
         runWithCancellationToken,
+        getAnalyzerNodeInfoReader: () => nodeInfo,
         getType,
         getTypeResult,
         getTypeResultForDecorator,
@@ -21560,7 +21749,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         checkForCancellation,
         printControlFlowGraph,
     };
-    const codeFlowEngine = (0, codeFlowEngine_1.getCodeFlowEngine)(evaluatorInterface, speculativeTypeTracker);
+    const codeFlowEngine = (0, codeFlowEngine_1.getCodeFlowEngine)(evaluatorInterface, speculativeTypeTracker, nodeInfo);
     return evaluatorInterface;
 }
 //# sourceMappingURL=typeEvaluator.js.map