@zzzen/pyright-internal 1.2.0-dev.20260809 → 1.2.0-dev.20260823

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 = [];
@@ -203,6 +204,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     let functionRecursionMap = new Map();
     let codeFlowAnalyzerCache = new Map();
     let typeCache = new Map();
+    let typeFormTypeCache = new Map();
     let effectiveTypeCache = new Map();
     let expectedTypeCache = new Map();
     let asymmetricAccessorAssignmentCache = new Set();
@@ -212,8 +214,24 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     let incompleteGenCount = 0;
     const returnTypeInferenceContextStack = [];
     let returnTypeInferenceTypeCache;
+    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;
@@ -252,6 +270,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         functionRecursionMap = new Map();
         codeFlowAnalyzerCache = new Map();
         typeCache = new Map();
+        typeFormTypeCache = new Map();
         effectiveTypeCache = new Map();
         expectedTypeCache = new Map();
         asymmetricAccessorAssignmentCache = new Set();
@@ -266,8 +285,51 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             return typeCache.get(node.id);
         }
     }
+    function getTypeFormTypeCache(node) {
+        if (returnTypeInferenceTypeFormTypeCache && isNodeInReturnTypeInferenceContext(node)) {
+            return returnTypeInferenceTypeFormTypeCache;
+        }
+        return typeFormTypeCache;
+    }
+    function readTypeFormTypeCacheEntry(node, expectedType) {
+        return getTypeFormTypeCache(node)
+            .get(node.id)
+            ?.find((entry) => (0, typeCacheUtils_1.contextualTypeCacheEntryMatches)(entry, expectedType));
+    }
+    // Contextual reads consult expectedTypeCache and prefer a matching TypeForm result.
+    // Runtime-only consumers must use readTypeCacheEntry so this precedence is not
+    // accidentally applied where an ordinary runtime type is required.
+    function readContextualTypeCacheEntryForNode(node) {
+        const expectedType = expectedTypeCache.get(node.id)?.type;
+        if (expectedType && expectedTypeWantsTypeForm(expectedType)) {
+            return (readTypeFormTypeCacheEntry(node, expectedType) ??
+                readTypeFormTypeCacheEntry(node, /* expectedType */ undefined) ??
+                readTypeCacheEntry(node));
+        }
+        return readTypeCacheEntry(node) ?? readTypeFormTypeCacheEntry(node, /* expectedType */ undefined);
+    }
+    // Bumps the incomplete generation count using the same rules for both the
+    // regular type cache and the TypeForm type cache so the two cache-invalidation
+    // paths cannot drift. A complete result always bumps the count (invalidating
+    // dependent incomplete entries); an incomplete result bumps only when its type
+    // differs from the previously-cached value.
+    function updateIncompleteGenerationCount(typeResult, oldTypeResult) {
+        if (!typeResult.isIncomplete) {
+            incompleteGenCount++;
+        }
+        else if (oldTypeResult !== undefined && !(0, types_1.isTypeSame)(typeResult.type, oldTypeResult.type)) {
+            incompleteGenCount++;
+        }
+    }
     function isTypeCached(node) {
-        const cacheEntry = readTypeCacheEntry(node);
+        // This helper is used by runtime-evaluation guards. A contextual TypeForm
+        // entry does not prove that the ordinary runtime type was evaluated.
+        return isTypeCacheEntryValid(readTypeCacheEntry(node));
+    }
+    function isTypeFormTypeCached(node, expectedType) {
+        return isTypeCacheEntryValid(readTypeFormTypeCacheEntry(node, expectedType));
+    }
+    function isTypeCacheEntryValid(cacheEntry) {
         if (!cacheEntry) {
             return false;
         }
@@ -282,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'}): ` +
@@ -300,20 +362,29 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         return cacheEntry.typeResult.type;
     }
     function writeTypeCache(node, typeResult, flags, inferenceContext, allowSpeculativeCaching = false) {
+        const useTypeFormCache = (flags !== undefined && (flags & 1073741824 /* EvalFlags.TypeFormArg */) !== 0) ||
+            (!!inferenceContext && expectedTypeWantsTypeForm(inferenceContext.expectedType));
+        if (useTypeFormCache) {
+            const expectedType = inferenceContext?.expectedType;
+            // Speculative TypeForm results are not retained, so they must not invalidate
+            // persistent incomplete entries through the global generation counter.
+            if (isSpeculativeModeInUse(node)) {
+                return;
+            }
+            const typeFormCache = getTypeFormTypeCache(node);
+            const cacheEntries = typeFormCache.get(node.id) ?? [];
+            const oldEntry = cacheEntries.find((entry) => (0, typeCacheUtils_1.contextualTypeCacheEntryMatches)(entry, expectedType));
+            updateIncompleteGenerationCount(typeResult, oldEntry?.typeResult);
+            typeFormCache.set(node.id, (0, typeCacheUtils_1.addContextualTypeCacheEntry)(cacheEntries, { typeResult, flags, incompleteGenCount, expectedType }));
+            return;
+        }
         // Should we use a temporary cache associated with a contextual
         // analysis of a function, contextualized based on call-site argument types?
         const typeCacheToUse = returnTypeInferenceTypeCache && isNodeInReturnTypeInferenceContext(node)
             ? returnTypeInferenceTypeCache
             : typeCache;
-        if (!typeResult.isIncomplete) {
-            incompleteGenCount++;
-        }
-        else {
-            const oldValue = typeCacheToUse.get(node.id);
-            if (oldValue !== undefined && !(0, types_1.isTypeSame)(typeResult.type, oldValue.typeResult.type)) {
-                incompleteGenCount++;
-            }
-        }
+        const oldValue = typeCacheToUse.get(node.id);
+        updateIncompleteGenerationCount(typeResult, oldValue?.typeResult);
         typeCacheToUse.set(node.id, { typeResult, flags, incompleteGenCount });
         // If the entry is located within a part of the parse tree that is currently being
         // "speculatively" evaluated, track it so we delete the cached entry when we leave
@@ -404,7 +475,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // type of surrounding statements to be evaluated.
     function getType(node) {
         initializePrefetchedTypes(node);
-        let type = evaluateTypeForSubnode(node, () => {
+        let type = evaluateContextualTypeForSubnode(node, () => {
             evaluateTypesForExpressionInContext(node);
         })?.type;
         // If this is a type parameter with a calculated variance, see if we
@@ -441,18 +512,24 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         return type;
     }
     function getTypeResult(node) {
-        return evaluateTypeForSubnode(node, () => {
+        return evaluateContextualTypeForSubnode(node, () => {
             evaluateTypesForExpressionInContext(node);
         });
     }
     function getTypeResultForDecorator(node) {
-        return evaluateTypeForSubnode(node, () => {
+        return evaluateContextualTypeForSubnode(node, () => {
             evaluateTypesForExpressionInContext(node.d.expr);
         });
     }
     // Reads the type of the node from the cache.
     function getCachedType(node) {
-        return readTypeCache(node, 0 /* EvalFlags.None */);
+        // Prefer the ordinary runtime type when both caches contain an entry for this node.
+        // Fall back to the contextual cache so TypeForm-only evaluations remain discoverable.
+        const cacheEntry = readTypeCacheEntry(node) ?? readContextualTypeCacheEntryForNode(node);
+        if (!cacheEntry || cacheEntry.typeResult.isIncomplete) {
+            return undefined;
+        }
+        return cacheEntry.typeResult.type;
     }
     // Determines the expected type of a specified node based on surrounding
     // context. For example, if it's a subexpression of an argument expression,
@@ -512,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');
@@ -570,8 +647,21 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
     }
     function getTypeOfExpression(node, flags = 0 /* EvalFlags.None */, inferenceContext) {
+        let useTypeFormCache = (flags & 1073741824 /* EvalFlags.TypeFormArg */) !== 0;
+        if (inferenceContext) {
+            inferenceContext.expectedType = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(inferenceContext.expectedType);
+            useTypeFormCache || (useTypeFormCache = expectedTypeWantsTypeForm(inferenceContext.expectedType));
+            if (expectedTypeRequiresTypeForm(inferenceContext.expectedType)) {
+                flags |= 1073741824 /* EvalFlags.TypeFormArg */;
+            }
+        }
+        if ((flags & 1073741824 /* EvalFlags.TypeFormArg */) !== 0 && (flags & 33554432 /* EvalFlags.NoConvertSpecialForm */) === 0) {
+            flags |= 32 /* EvalFlags.NoParamSpec */ | 64 /* EvalFlags.NoTypeVarTuple */;
+        }
         // Is this type already cached?
-        const cacheEntry = readTypeCacheEntry(node);
+        const cacheEntry = useTypeFormCache
+            ? readTypeFormTypeCacheEntry(node, inferenceContext?.expectedType)
+            : readTypeCacheEntry(node);
         if (cacheEntry) {
             if (!cacheEntry.typeResult.isIncomplete || cacheEntry.incompleteGenCount === incompleteGenCount) {
                 if (printExpressionTypes) {
@@ -581,7 +671,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
         }
         // Is it cached in the speculative type cache?
-        const specCacheEntry = speculativeTypeTracker.getSpeculativeType(node, inferenceContext?.expectedType);
+        const specCacheEntry = useTypeFormCache
+            ? undefined
+            : speculativeTypeTracker.getSpeculativeType(node, inferenceContext?.expectedType);
         if (specCacheEntry) {
             if (!specCacheEntry.typeResult.isIncomplete ||
                 specCacheEntry.incompleteGenerationCount === incompleteGenCount) {
@@ -599,9 +691,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // the cancellation check. If the operation is canceled, an exception
         // will be thrown at this point.
         checkForCancellation();
-        if (inferenceContext) {
-            inferenceContext.expectedType = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(inferenceContext.expectedType);
-        }
         // If we haven't already fetched some core type definitions from the
         // typeshed stubs, do so here. It would be better to fetch this when it's
         // needed in assignType, but we don't have access to the parse tree
@@ -613,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),
@@ -680,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 */: {
@@ -715,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 */: {
@@ -736,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 */: {
@@ -838,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);
             }
@@ -966,7 +1055,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     }
     function getTypeOfStringList(node, flags, inferenceContext) {
         let typeResult;
-        if ((flags & 8 /* EvalFlags.StrLiteralAsType */) !== 0 && (flags & 1073741824 /* EvalFlags.TypeFormArg */) === 0) {
+        if ((flags & 8 /* EvalFlags.StrLiteralAsType */) !== 0 &&
+            ((flags & 1073741824 /* EvalFlags.TypeFormArg */) === 0 || (flags & 33554432 /* EvalFlags.NoConvertSpecialForm */) !== 0)) {
             return getTypeOfStringListAsType(node, flags);
         }
         const isBytesNode = (node) => (node.d.token.flags & 32 /* StringTokenFlags.Bytes */) !== 0;
@@ -1071,9 +1161,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if ((flags & 16777216 /* EvalFlags.ParsesStringLiteral */) === 0) {
             updatedFlags |= 524288 /* EvalFlags.NotParsed */;
         }
-        updatedFlags &= ~1073741824 /* EvalFlags.TypeFormArg */;
-        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;
@@ -1213,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) {
@@ -2346,7 +2436,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;
@@ -2358,8 +2448,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 */) {
@@ -2368,7 +2458,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;
         }
@@ -2384,18 +2474,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;
         }
@@ -2406,7 +2496,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;
         }
@@ -2429,8 +2519,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;
         }
@@ -2448,7 +2538,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 ||
@@ -2463,7 +2553,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);
         }
     }
@@ -2476,7 +2566,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;
@@ -2501,7 +2591,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;
@@ -2509,7 +2599,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) &&
@@ -2519,7 +2609,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;
             }
@@ -2551,7 +2641,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 */) {
@@ -2571,7 +2661,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)) {
@@ -2597,7 +2687,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) &&
@@ -2695,7 +2785,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;
@@ -3101,8 +3191,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);
@@ -3327,7 +3417,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;
@@ -3448,6 +3538,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 type = types_1.UnknownType.create();
             }
         }
+        if ((0, types_1.isTypeVarTuple)(type) && (flags & 64 /* EvalFlags.NoTypeVarTuple */) !== 0 && !type.priv.isInUnion) {
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeVarTupleContext(), node);
+            type = types_1.UnknownType.create();
+        }
         // If we're expecting a type expression and got a sentinel literal instance,
         // treat it as its instantiable counterpart. This is similar to how None
         // is treated in a type expression context.
@@ -3458,16 +3552,64 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if ((flags & 256 /* EvalFlags.TypeExpression */) === 0) {
             reportUseOfTypeCheckOnly(type, node);
         }
-        if ((flags & 128 /* EvalFlags.InstantiableType */) !== 0) {
+        if ((flags & (128 /* EvalFlags.InstantiableType */ | 1073741824 /* EvalFlags.TypeFormArg */)) !== 0) {
             if ((flags & 1024 /* EvalFlags.AllowGeneric */) === 0) {
                 if ((0, types_1.isInstantiableClass)(type) && types_1.ClassType.isBuiltIn(type, 'Generic')) {
                     addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.genericNotAllowed(), node);
+                    if ((flags & 1073741824 /* EvalFlags.TypeFormArg */) !== 0) {
+                        type = types_1.UnknownType.create();
+                    }
                 }
             }
         }
         return { type, isIncomplete };
     }
+    const typeFormSpecialFormDiagnosticFactories = [
+        ['Final', () => localize_1.LocMessage.finalContext()],
+        ['Optional', () => localize_1.LocMessage.optionalExtraArgs()],
+        ['Protocol', () => localize_1.LocMessage.protocolNotAllowed()],
+        ['TypedDict', () => localize_1.LocMessage.typedDictNotAllowed()],
+        ['TypeAlias', () => localize_1.LocMessage.typeAnnotationVariable()],
+        ['Literal', () => localize_1.LocMessage.literalNotAllowed()],
+        [['TypeGuard', 'TypeIs'], () => localize_1.LocMessage.typeGuardArgCount()],
+        ['Union', () => localize_1.LocMessage.unionTypeArgCount()],
+        ['Annotated', () => localize_1.LocMessage.annotatedTypeArgMissing()],
+        ['ClassVar', () => localize_1.LocMessage.classVarNotAllowed()],
+        ['Required', () => localize_1.LocMessage.requiredArgCount()],
+        ['NotRequired', () => localize_1.LocMessage.notRequiredArgCount()],
+        ['ReadOnly', () => localize_1.LocMessage.readOnlyArgCount()],
+        ['Unpack', () => localize_1.LocMessage.unpackArgCount()],
+        ['Concatenate', () => localize_1.LocMessage.concatenateContext()],
+    ];
+    function rejectBareSpecialFormInTypeForm(type, node) {
+        for (const [className, diagnosticFactory] of typeFormSpecialFormDiagnosticFactories) {
+            if (types_1.ClassType.isBuiltIn(type, className)) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, diagnosticFactory(), node);
+                return types_1.UnknownType.create();
+            }
+        }
+        return undefined;
+    }
     function addTypeFormForSymbol(node, type, flags, includesVarDecl) {
+        const isIndexBase = node.parent?.nodeType === 27 /* ParseNodeType.Index */ && node.parent.d.leftExpr === node;
+        if ((flags & 1073741824 /* EvalFlags.TypeFormArg */) !== 0 && (0, types_1.isTypeVar)(type) && types_1.TypeVarType.isSelf(type)) {
+            type = types_1.TypeBase.cloneWithTypeForm(type, (0, typeUtils_1.convertToInstance)(type));
+        }
+        if ((flags & 1073741824 /* EvalFlags.TypeFormArg */) !== 0 && (0, types_1.isInstantiableClass)(type) && !isIndexBase) {
+            if (isTypeFormClass(type)) {
+                return createTypeFormType(type, node, /* typeArgs */ undefined);
+            }
+            const rejectedType = rejectBareSpecialFormInTypeForm(type, node);
+            if (rejectedType) {
+                return rejectedType;
+            }
+            if (types_1.ClassType.isBuiltIn(type, 'Self')) {
+                type = createSelfType(type, node, /* typeArgs */ undefined, flags);
+                if ((0, types_1.isTypeVar)(type)) {
+                    type = types_1.TypeBase.cloneWithTypeForm(type, (0, typeUtils_1.convertToInstance)(type));
+                }
+            }
+        }
         const isValid = isSymbolValidTypeExpression(type, includesVarDecl);
         // If the type already has type information associated with it, don't replace.
         if (type.props?.typeForm) {
@@ -3486,7 +3628,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)));
             }
         }
@@ -3535,7 +3677,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;
         }
@@ -3598,28 +3740,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
@@ -3630,7 +3771,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;
                         }
@@ -3749,7 +3890,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) {
@@ -3774,7 +3915,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),
@@ -3794,7 +3935,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // Is this a generic class that needs to be specialized?
         if ((0, types_1.isInstantiableClass)(type)) {
             if ((flags & 128 /* EvalFlags.InstantiableType */) !== 0 && (flags & 512 /* EvalFlags.AllowMissingTypeArgs */) === 0) {
-                if (!type.props?.typeAliasInfo && (0, typeUtils_1.requiresTypeArgs)(type)) {
+                if (!type.props?.typeAliasInfo && !isTypeFormClass(type) && (0, typeUtils_1.requiresTypeArgs)(type)) {
                     if (!type.priv.typeArgs || !type.priv.isTypeArgExplicit) {
                         addDiagnostic(diagnosticRules_1.DiagnosticRule.reportMissingTypeArgument, localize_1.LocMessage.typeArgsMissingForClass().format({
                             name: type.priv.aliasName || type.shared.name,
@@ -3995,7 +4136,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.
@@ -4006,7 +4147,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;
@@ -4098,7 +4239,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;
@@ -4448,7 +4589,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
@@ -4956,13 +5097,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) {
@@ -5199,6 +5340,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }), { ...aliasInfo, typeArgs: defaultTypeArgs });
         return type;
     }
+    function convertTypeArgToInstance(type, flags) {
+        const contextualType = (flags & 1073741824 /* EvalFlags.TypeFormArg */) !== 0 ? type.props?.typeForm ?? type : type;
+        return (0, typeUtils_1.convertToInstance)(contextualType);
+    }
     // Handles index expressions that are providing type arguments for a
     // generic type alias.
     function createSpecializedTypeAlias(node, baseType, flags) {
@@ -5318,7 +5463,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
                 let typeArgType;
                 if (index < typeArgs.length) {
-                    typeArgType = (0, typeUtils_1.convertToInstance)(typeArgs[index].type);
+                    typeArgType = convertTypeArgToInstance(typeArgs[index].type, flags);
                 }
                 else if (param.shared.isDefaultExplicit) {
                     typeArgType = solveAndApplyConstraints(param, constraints, {
@@ -5473,11 +5618,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 if (types_1.ClassType.isBuiltIn(concreteSubtype, 'InitVar')) {
                     // Special-case InitVar, used in dataclasses.
                     const typeArgs = getTypeArgs(node, flags);
-                    if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
-                        if ((flags & 32768 /* EvalFlags.VarTypeAnnotation */) === 0) {
+                    const isTypeFormArg = (flags & 1073741824 /* EvalFlags.TypeFormArg */) !== 0;
+                    if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0 || isTypeFormArg) {
+                        if (isTypeFormArg || (flags & 32768 /* EvalFlags.VarTypeAnnotation */) === 0) {
                             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.initVarNotAllowed(), node.d.leftExpr);
                         }
                     }
+                    if (isTypeFormArg) {
+                        return types_1.UnknownType.create();
+                    }
                     if (typeArgs.length === 1) {
                         return typeArgs[0].type;
                     }
@@ -5503,7 +5652,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,
@@ -5562,12 +5711,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             return types_1.UnknownType.create();
         });
-        // In case we didn't walk the list items above, do so now.
-        // If we have, this information will be cached.
+        // In case we didn't walk the list items above, do so now. TypeForm arguments
+        // use a separate cache, so check it when the enclosing expression is a TypeForm.
         if (!baseTypeResult.isIncomplete) {
+            const isTypeFormArg = (flags & 1073741824 /* EvalFlags.TypeFormArg */) !== 0;
             node.d.items.forEach((item) => {
-                if (!isTypeCached(item.d.valueExpr)) {
-                    getTypeOfExpression(item.d.valueExpr, flags & 4 /* EvalFlags.ForwardRefs */);
+                const isItemCached = isTypeFormArg
+                    ? isTypeFormTypeCached(item.d.valueExpr, /* expectedType */ undefined)
+                    : isTypeCached(item.d.valueExpr);
+                if (!isItemCached) {
+                    getTypeOfExpression(item.d.valueExpr, flags & (4 /* EvalFlags.ForwardRefs */ | 1073741824 /* EvalFlags.TypeFormArg */));
                 }
             });
         }
@@ -5862,7 +6015,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     function getTypeArgs(node, flags, options) {
         const typeArgs = [];
         let adjFlags = flags | 33554432 /* EvalFlags.NoConvertSpecialForm */;
-        adjFlags &= ~1073741824 /* EvalFlags.TypeFormArg */;
+        if ((adjFlags & 1073741824 /* EvalFlags.TypeFormArg */) !== 0) {
+            adjFlags |= 256 /* EvalFlags.TypeExpression */;
+        }
         const allowFinalClassVar = () => {
             // If the annotation is a variable within the body of a dataclass, a
             // Final is allowed with a ClassVar annotation. In all other cases,
@@ -5917,7 +6072,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 = {
@@ -6007,7 +6162,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 */;
         }
@@ -6024,7 +6179,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
@@ -6190,13 +6345,21 @@ 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;
-            if (!isCyclicalTypeVarCall) {
+                nodeInfo.getFileInfo(node).isTypingStubFile;
+            const isTypeFormCall = (0, types_1.isInstantiableClass)(baseTypeResult.type) && isTypeFormClass(baseTypeResult.type);
+            if (!isCyclicalTypeVarCall && !isTypeFormCall) {
                 argList.forEach((arg) => {
-                    if (arg.valueExpression &&
-                        arg.valueExpression.nodeType !== 48 /* ParseNodeType.StringList */ &&
-                        !isTypeCached(arg.valueExpression)) {
-                        getTypeOfExpression(arg.valueExpression);
+                    const valueExpression = arg.valueExpression;
+                    if (valueExpression &&
+                        valueExpression.nodeType !== 48 /* ParseNodeType.StringList */ &&
+                        !isTypeCached(valueExpression)) {
+                        const expectedType = expectedTypeCache.get(valueExpression.id)?.type;
+                        if (isTypeFormTypeCached(valueExpression, expectedType)) {
+                            suppressDiagnostics(valueExpression, () => getTypeOfExpression(valueExpression));
+                        }
+                        else {
+                            getTypeOfExpression(valueExpression);
+                        }
                     }
                 });
             }
@@ -6266,6 +6429,166 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return typeFormResult;
     }
+    function expandEnumTypeForLiteralComparison(typeToExpand, comparisonType, concretizeTypeVars) {
+        // Assignment checks apply this at each recursive assignType call so existing
+        // variance and constraint handling remains intact. Keep this equivalence
+        // relation aligned with the recursive normalization used by assert_type below.
+        if (!containsTopLevelLiteralEnum(comparisonType)) {
+            return typeToExpand;
+        }
+        const literalEnumClasses = collectLiteralEnumClasses(comparisonType);
+        if (literalEnumClasses.length === 0) {
+            return typeToExpand;
+        }
+        // Concretize top-level TypeVars only to probe for a matching enum subtype.
+        // If no enum expansion actually occurs (for example, an unrelated source
+        // TypeVar whose bound is not one of the comparison's enum classes), preserve
+        // the original type rather than replacing the TypeVar with its bound. Doing so
+        // keeps unrelated invariant comparisons like `list[T]` vs `list[ColorLiterals]`
+        // unaffected.
+        const concreteType = concretizeTypeVars ? makeTopLevelTypeVarsConcrete(typeToExpand) : typeToExpand;
+        const expandedType = expandEnumTypeForLiteralClasses(concreteType, literalEnumClasses);
+        return expandedType === concreteType ? typeToExpand : expandedType;
+    }
+    function containsTopLevelLiteralEnum(type) {
+        if ((0, types_1.isClassInstance)(type) && types_1.ClassType.isEnumClass(type) && type.priv.literalValue instanceof types_1.EnumLiteral) {
+            return true;
+        }
+        if (!(0, types_1.isUnion)(type)) {
+            return false;
+        }
+        return type.priv.includesEnumLiteral;
+    }
+    function expandEnumTypeForLiteralClasses(typeToExpand, literalEnumClasses) {
+        if (literalEnumClasses.length === 0) {
+            return typeToExpand;
+        }
+        return (0, typeUtils_1.mapSubtypes)(typeToExpand, (subtype) => {
+            if ((0, types_1.isClassInstance)(subtype) &&
+                types_1.ClassType.isEnumClass(subtype) &&
+                !types_1.ClassType.isEnumMemberSetMayBeIncomplete(subtype) &&
+                subtype.priv.literalValue === undefined &&
+                literalEnumClasses.some((enumClass) => types_1.ClassType.isSameGenericClass(enumClass, subtype))) {
+                const literalTypes = (0, typeGuards_1.enumerateLiteralsForType)(evaluatorInterface, subtype);
+                if (literalTypes && literalTypes.length > 0) {
+                    return (0, types_1.combineTypes)(literalTypes);
+                }
+            }
+            return subtype;
+        });
+    }
+    function collectLiteralEnumClasses(type, literalEnumClasses = [], recursively = false, recursionCount = 0) {
+        if (recursionCount > types_1.maxTypeRecursionCount) {
+            return literalEnumClasses;
+        }
+        recursionCount++;
+        if (recursively && (0, types_1.isFunction)(type)) {
+            type.shared.parameters.forEach((_, index) => collectLiteralEnumClasses(types_1.FunctionType.getParamType(type, index), literalEnumClasses, recursively, recursionCount));
+            const returnType = types_1.FunctionType.getEffectiveReturnType(type);
+            if (returnType) {
+                collectLiteralEnumClasses(returnType, literalEnumClasses, recursively, recursionCount);
+            }
+        }
+        else if (recursively && (0, types_1.isOverloaded)(type)) {
+            types_1.OverloadedType.getOverloads(type).forEach((overload) => collectLiteralEnumClasses(overload, literalEnumClasses, recursively, recursionCount));
+            const implementation = types_1.OverloadedType.getImplementation(type);
+            if (implementation) {
+                collectLiteralEnumClasses(implementation, literalEnumClasses, recursively, recursionCount);
+            }
+        }
+        (0, typeUtils_1.doForEachSubtype)(type, (subtype) => {
+            if (!(0, types_1.isClass)(subtype)) {
+                return;
+            }
+            if ((0, types_1.isClassInstance)(subtype) &&
+                types_1.ClassType.isEnumClass(subtype) &&
+                subtype.priv.literalValue instanceof types_1.EnumLiteral &&
+                !literalEnumClasses.some((enumClass) => types_1.ClassType.isSameGenericClass(enumClass, subtype))) {
+                literalEnumClasses.push(subtype);
+            }
+            if (recursively && subtype.priv.typeArgs) {
+                if (subtype.priv.tupleTypeArgs) {
+                    subtype.priv.tupleTypeArgs.forEach((typeArg) => collectLiteralEnumClasses(typeArg.type, literalEnumClasses, recursively, recursionCount));
+                }
+                else {
+                    subtype.priv.typeArgs.forEach((typeArg) => collectLiteralEnumClasses(typeArg, literalEnumClasses, recursively, recursionCount));
+                }
+            }
+        });
+        return literalEnumClasses;
+    }
+    function normalizeEnumTypes(typeToNormalize, literalEnumClasses, recursionCount = 0) {
+        if (recursionCount > types_1.maxTypeRecursionCount) {
+            return typeToNormalize;
+        }
+        recursionCount++;
+        typeToNormalize = expandEnumTypeForLiteralClasses(typeToNormalize, literalEnumClasses);
+        if ((0, types_1.isUnion)(typeToNormalize)) {
+            return (0, typeUtils_1.mapSubtypes)(typeToNormalize, (subtype) => normalizeEnumTypes(subtype, literalEnumClasses, recursionCount));
+        }
+        if ((0, types_1.isFunction)(typeToNormalize)) {
+            let typeChanged = false;
+            const parameterTypes = typeToNormalize.shared.parameters.map((_, index) => {
+                const parameterType = types_1.FunctionType.getParamType(typeToNormalize, index);
+                const normalizedType = normalizeEnumTypes(parameterType, literalEnumClasses, recursionCount);
+                typeChanged || (typeChanged = normalizedType !== parameterType);
+                return normalizedType;
+            });
+            const returnType = types_1.FunctionType.getEffectiveReturnType(typeToNormalize);
+            const normalizedReturnType = returnType
+                ? normalizeEnumTypes(returnType, literalEnumClasses, recursionCount)
+                : undefined;
+            typeChanged || (typeChanged = normalizedReturnType !== returnType);
+            return typeChanged
+                ? types_1.FunctionType.specialize(typeToNormalize, {
+                    parameterTypes,
+                    parameterDefaultTypes: typeToNormalize.priv.specializedTypes?.parameterDefaultTypes,
+                    returnType: normalizedReturnType,
+                })
+                : typeToNormalize;
+        }
+        if ((0, types_1.isOverloaded)(typeToNormalize)) {
+            let typeChanged = false;
+            const overloads = types_1.OverloadedType.getOverloads(typeToNormalize).map((overload) => {
+                const normalizedType = normalizeEnumTypes(overload, literalEnumClasses, recursionCount);
+                typeChanged || (typeChanged = normalizedType !== overload);
+                return (0, types_1.isFunction)(normalizedType) ? normalizedType : overload;
+            });
+            const implementation = types_1.OverloadedType.getImplementation(typeToNormalize);
+            const normalizedImplementation = implementation
+                ? normalizeEnumTypes(implementation, literalEnumClasses, recursionCount)
+                : undefined;
+            typeChanged || (typeChanged = normalizedImplementation !== implementation);
+            return typeChanged ? types_1.OverloadedType.create(overloads, normalizedImplementation) : typeToNormalize;
+        }
+        if (!(0, types_1.isClass)(typeToNormalize) || !typeToNormalize.priv.typeArgs) {
+            return typeToNormalize;
+        }
+        if (typeToNormalize.priv.tupleTypeArgs) {
+            let typeChanged = false;
+            const tupleTypeArgs = typeToNormalize.priv.tupleTypeArgs.map((typeArg) => {
+                const normalizedType = normalizeEnumTypes(typeArg.type, literalEnumClasses, recursionCount);
+                if (normalizedType !== typeArg.type) {
+                    typeChanged = true;
+                }
+                return { ...typeArg, type: normalizedType };
+            });
+            return typeChanged
+                ? (0, typeUtils_1.specializeTupleClass)(typeToNormalize, tupleTypeArgs, !!typeToNormalize.priv.isTypeArgExplicit, !!typeToNormalize.priv.isUnpacked)
+                : typeToNormalize;
+        }
+        let typeChanged = false;
+        const typeArgs = typeToNormalize.priv.typeArgs.map((typeArg) => {
+            const normalizedType = normalizeEnumTypes(typeArg, literalEnumClasses, recursionCount);
+            if (normalizedType !== typeArg) {
+                typeChanged = true;
+            }
+            return normalizedType;
+        });
+        return typeChanged
+            ? types_1.ClassType.specialize(typeToNormalize, typeArgs, typeToNormalize.priv.isTypeArgExplicit)
+            : typeToNormalize;
+    }
     function getTypeOfAssertType(node, inferenceContext) {
         if (node.d.args.length !== 2 ||
             node.d.args[0].d.argCategory !== 0 /* ArgCategory.Simple */ ||
@@ -6286,11 +6609,23 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // The spec is unclear on whether this is the correct behavior, but it seems to be
         // what mypy does -- and what various library authors expect.
         const arg0Type = stripTypeGuard(arg0TypeResult.type);
-        if (!(0, types_1.isTypeSame)(assertedType, arg0Type, {
+        const typeSameOptions = {
             treatAnySameAsUnknown: true,
             ignorePseudoGeneric: true,
             ignoreConditions: true,
-        })) {
+        };
+        let typesMatch = (0, types_1.isTypeSame)(assertedType, arg0Type, typeSameOptions);
+        if (!typesMatch) {
+            // Unlike assignType, assert_type requires exact structural identity, so
+            // normalize both types recursively. Keep this equivalence relation aligned
+            // with expandEnumTypeForLiteralComparison, which assignType applies as it recurses.
+            const literalEnumClasses = collectLiteralEnumClasses(assertedType, [], /* recursively */ true);
+            collectLiteralEnumClasses(arg0Type, literalEnumClasses, /* recursively */ true);
+            const normalizedAssertedType = normalizeEnumTypes(assertedType, literalEnumClasses);
+            const normalizedArg0Type = normalizeEnumTypes(arg0Type, literalEnumClasses);
+            typesMatch = (0, types_1.isTypeSame)(normalizedAssertedType, normalizedArg0Type, typeSameOptions);
+        }
+        if (!typesMatch) {
             const srcDestTypes = printSrcDestTypes(arg0TypeResult.type, assertedType, { expandTypeAlias: true });
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportAssertTypeFailure, localize_1.LocMessage.assertTypeTypeMismatch().format({
                 expected: srcDestTypes.destType,
@@ -6375,7 +6710,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 */) {
@@ -6407,7 +6742,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
@@ -6429,7 +6764,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);
                     }
@@ -6496,7 +6831,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);
                         }
@@ -6672,13 +7007,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // list will grow to include union expansions.
     function validateOverloadsWithExpandedTypes(errorNode, expandedArgTypes, argParamMatches, constraints, skipUnknownArgCheck, inferenceContext) {
         const returnTypes = [];
+        const specializedInitSelfTypes = [];
         let matchedOverloads = [];
         let isTypeIncomplete = false;
-        let overloadsUsedForCall = [];
+        const overloadsUsedForCall = [];
         let isDefinitiveMatchFound = false;
+        let hasInitSelfMaterializationAmbiguity = false;
+        let hasEffectiveInitSelfType = false;
         const speculativeNode = getSpeculativeNodeForCall(errorNode);
         for (let expandedTypesIndex = 0; expandedTypesIndex < expandedArgTypes.length; expandedTypesIndex++) {
+            const overloadsUsedStartIndex = overloadsUsedForCall.length;
             let matchedOverload;
+            let effectiveInitSelfType;
             const argTypeOverride = expandedArgTypes[expandedTypesIndex];
             const hasArgTypeOverride = argTypeOverride.some((a) => a !== undefined);
             let possibleMatchResults = [];
@@ -6718,9 +7058,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         constraints: effectiveConstraints,
                         returnType: callResult.returnType,
                         argResults: callResult.argResults ?? [],
+                        specializedInitSelfType: callResult.specializedInitSelfType,
                     };
                     matchedOverloads.push(matchedOverloadInfo);
-                    if (callResult.anyOrUnknownArg || matchResults.unpackedArgOfUnknownLength) {
+                    if (callResult.anyOrUnknownArg ||
+                        matchResults.unpackedArgOfUnknownLength ||
+                        possibleMatchResults.length > 0) {
                         possibleMatchResults.push(matchedOverloadInfo);
                         if (callResult.anyOrUnknownArg) {
                             if ((0, typeUtils_1.isIncompleteUnknown)(callResult.anyOrUnknownArg)) {
@@ -6730,6 +7073,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     }
                     else {
                         returnTypes.push(callResult.returnType);
+                        effectiveInitSelfType = getEffectiveInitSelfType(matchedOverloadInfo);
                         isDefinitiveMatchFound = true;
                         break;
                     }
@@ -6743,20 +7087,53 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (!isDefinitiveMatchFound && possibleMatchResults.length > 0) {
                 possibleMatchResults = filterOverloadMatchesForUnpackedArgs(possibleMatchResults);
                 possibleMatchResults = filterOverloadMatchesForAnyArgs(possibleMatchResults);
+                // Keep diagnostic bookkeeping aligned with the candidates that remain possible.
+                // This applies to both top-level gradual arguments and nested materialization,
+                // so deprecation diagnostics are reported only for retained overloads.
+                overloadsUsedForCall.splice(overloadsUsedStartIndex, overloadsUsedForCall.length - overloadsUsedStartIndex, ...possibleMatchResults.map((result) => result.overload));
                 // Did the filtering produce a single result? If so, we're done.
                 if (possibleMatchResults.length === 1) {
-                    overloadsUsedForCall = [possibleMatchResults[0].overload];
                     returnTypes.push(possibleMatchResults[0].returnType);
+                    effectiveInitSelfType = getEffectiveInitSelfType(possibleMatchResults[0]);
                     matchedOverloads = [possibleMatchResults[0]];
                 }
                 else {
+                    const firstArgParamPairs = getOverloadArgParamPairs(possibleMatchResults[0]);
+                    let ambiguousMatchIncludesNestedAny = false;
+                    let ambiguousMatchIncludesNestedUnknown = false;
+                    let ambiguousMatchIncludesTopLevelAnyOrUnknown = false;
+                    firstArgParamPairs.forEach((pair, index) => {
+                        const paramTypes = possibleMatchResults.map((match) => {
+                            const argParamPairs = getOverloadArgParamPairs(match);
+                            return index < argParamPairs.length ? argParamPairs[index].paramType : types_1.UnknownType.create();
+                        });
+                        if (!(0, typeUtils_1.areTypesSame)(paramTypes, { treatAnySameAsUnknown: true })) {
+                            if ((0, types_1.isAnyOrUnknown)(pair.argType)) {
+                                ambiguousMatchIncludesTopLevelAnyOrUnknown = true;
+                            }
+                            else {
+                                const anyOrUnknown = getAnyOrUnknownInInvariantPosition(pair.argType);
+                                if (anyOrUnknown && (0, types_1.isAny)(anyOrUnknown)) {
+                                    ambiguousMatchIncludesNestedAny = true;
+                                }
+                                else if (anyOrUnknown && (0, types_1.isUnknown)(anyOrUnknown)) {
+                                    ambiguousMatchIncludesNestedUnknown = true;
+                                }
+                            }
+                        }
+                    });
                     // Eliminate any return types that are subsumed by other return types.
                     let dedupedMatchResults = [];
                     let dedupedResultsIncludeAny = false;
+                    const isInitSelfMaterializationAmbiguity = (ambiguousMatchIncludesNestedAny || ambiguousMatchIncludesNestedUnknown) &&
+                        possibleMatchResults.some((result) => !!result.specializedInitSelfType);
                     possibleMatchResults.forEach((result) => {
+                        const resultType = isInitSelfMaterializationAmbiguity
+                            ? getEffectiveOverloadReturnType(result)
+                            : result.returnType;
                         let isSubtypeSubsumed = false;
                         for (let dedupedIndex = 0; dedupedIndex < dedupedMatchResults.length; dedupedIndex++) {
-                            if (assignType(dedupedMatchResults[dedupedIndex], result.returnType)) {
+                            if (assignType(dedupedMatchResults[dedupedIndex], resultType)) {
                                 const anyOrUnknown = (0, typeUtils_1.containsAnyOrUnknown)(dedupedMatchResults[dedupedIndex], 
                                 /* recurse */ false);
                                 if (!anyOrUnknown) {
@@ -6767,8 +7144,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                                 }
                                 break;
                             }
-                            else if (assignType(result.returnType, dedupedMatchResults[dedupedIndex])) {
-                                const anyOrUnknown = (0, typeUtils_1.containsAnyOrUnknown)(result.returnType, /* recurse */ false);
+                            else if (assignType(resultType, dedupedMatchResults[dedupedIndex])) {
+                                const anyOrUnknown = (0, typeUtils_1.containsAnyOrUnknown)(resultType, /* recurse */ false);
                                 if (!anyOrUnknown) {
                                     dedupedMatchResults[dedupedIndex] = types_1.NeverType.createNever();
                                 }
@@ -6779,13 +7156,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             }
                         }
                         if (!isSubtypeSubsumed) {
-                            dedupedMatchResults.push(result.returnType);
+                            dedupedMatchResults.push(resultType);
                         }
                     });
                     dedupedMatchResults = dedupedMatchResults.filter((t) => !(0, types_1.isNever)(t));
                     const combinedTypes = (0, types_1.combineTypes)(dedupedMatchResults);
                     let returnType = combinedTypes;
-                    if (dedupedMatchResults.length > 1) {
+                    if (ambiguousMatchIncludesNestedUnknown) {
+                        returnType = types_1.UnknownType.createPossibleType(combinedTypes, possibleMatchInvolvesIncompleteUnknown);
+                    }
+                    else if (ambiguousMatchIncludesNestedAny && !ambiguousMatchIncludesTopLevelAnyOrUnknown) {
+                        returnType = types_1.AnyType.create();
+                    }
+                    else if (dedupedMatchResults.length > 1) {
                         // If one or more of the deduped types is Any or contains Any,
                         // we will assume that the person who defined the overload really
                         // wanted Any rather than Unknown. In cases where the deduped types
@@ -6798,13 +7181,33 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             returnType = types_1.UnknownType.createPossibleType(combinedTypes, possibleMatchInvolvesIncompleteUnknown);
                         }
                     }
-                    returnTypes.push(returnType);
+                    if (isInitSelfMaterializationAmbiguity) {
+                        // Overloaded __init__ methods normally return None. Preserve that
+                        // ordinary return as a placeholder while union-expanded calls are
+                        // combined, and carry the effective constructed types separately.
+                        // validateInitMethod consumes specializedInitSelfType to reconstruct
+                        // the constructor result after call validation is complete.
+                        effectiveInitSelfType = returnType;
+                        hasInitSelfMaterializationAmbiguity = true;
+                        returnTypes.push(possibleMatchResults[0].returnType);
+                    }
+                    else {
+                        returnTypes.push(returnType);
+                    }
                 }
             }
+            if (effectiveInitSelfType) {
+                specializedInitSelfTypes.push(effectiveInitSelfType);
+                hasEffectiveInitSelfType = true;
+            }
             if (!matchedOverload) {
                 return { argumentErrors: true, isTypeIncomplete, overloadsUsedForCall };
             }
         }
+        // Union expansion requires one constructor handoff per expanded argument list.
+        // Materialization ambiguity requires a combined handoff even when there is only
+        // one argument list because multiple overload candidates contribute to its result.
+        const shouldCombineInitSelfTypes = hasInitSelfMaterializationAmbiguity || (expandedArgTypes.length > 1 && hasEffectiveInitSelfType);
         // We found a match for all of the expanded argument lists. Copy the
         // resulting type var context back into the caller's type var context.
         // Use the type var context from the last matched overload because it
@@ -6814,7 +7217,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         // And run through the first expanded argument list one more time to
         // populate the type cache.
-        const finalConstraints = constraints ?? matchedOverloads[0].constraints;
+        const finalConstraints = shouldCombineInitSelfTypes
+            ? matchedOverloads[0].constraints
+            : constraints ?? matchedOverloads[0].constraints;
         const finalCallResult = validateArgTypesWithContext(errorNode, matchedOverloads[0].matchResults, finalConstraints, skipUnknownArgCheck, inferenceContext);
         if (finalCallResult.isTypeIncomplete) {
             isTypeIncomplete = true;
@@ -6824,7 +7229,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             anyOrUnknownArg: finalCallResult.anyOrUnknownArg,
             returnType: (0, types_1.combineTypes)(returnTypes),
             isTypeIncomplete,
-            specializedInitSelfType: finalCallResult.specializedInitSelfType,
+            specializedInitSelfType: specializedInitSelfTypes.length > 0 && shouldCombineInitSelfTypes
+                ? (0, types_1.combineTypes)(specializedInitSelfTypes)
+                : finalCallResult.specializedInitSelfType,
             overloadsUsedForCall,
         };
     }
@@ -6842,28 +7249,303 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return unpackedArgsOverloads;
     }
+    // assignType cannot be used for this detection because it accepts Any and Unknown
+    // without exposing whether acceptance depends on a gradual invariant type argument.
+    function getAnyOrUnknownInInvariantPosition(type, recursionCount = 0) {
+        if (recursionCount > types_1.maxTypeRecursionCount) {
+            return undefined;
+        }
+        recursionCount++;
+        let result;
+        const addResult = (newResult) => {
+            if (newResult) {
+                result = result ? (0, typeUtils_1.preserveUnknown)(result, newResult) : newResult;
+            }
+        };
+        if ((0, types_1.isUnion)(type)) {
+            (0, typeUtils_1.doForEachSubtype)(type, (subtype) => {
+                addResult(getAnyOrUnknownInInvariantPosition(subtype, recursionCount));
+            });
+            return result;
+        }
+        if (!(0, types_1.isClass)(type)) {
+            return undefined;
+        }
+        // Tuple entries are covariant, but they can contain an invariant type.
+        if (type.priv.tupleTypeArgs) {
+            type.priv.tupleTypeArgs.forEach((typeArg) => {
+                addResult(getAnyOrUnknownInInvariantPosition(typeArg.type, recursionCount));
+            });
+            return result;
+        }
+        if (!type.priv.typeArgs) {
+            return undefined;
+        }
+        inferVarianceForClass(type);
+        const typeParams = types_1.ClassType.getTypeParams(type);
+        type.priv.typeArgs.forEach((typeArg, index) => {
+            const typeParam = index < typeParams.length ? typeParams[index] : undefined;
+            const variance = typeParam ? types_1.TypeVarType.getVariance(typeParam) : 2 /* Variance.Invariant */;
+            if (variance === 2 /* Variance.Invariant */) {
+                addResult((0, typeUtils_1.containsAnyOrUnknown)(typeArg, /* recurse */ true));
+            }
+            else {
+                addResult(getAnyOrUnknownInInvariantPosition(typeArg, recursionCount));
+            }
+        });
+        return result;
+    }
+    function getEffectiveOverloadReturnType(match) {
+        return getEffectiveInitSelfType(match) ?? match.returnType;
+    }
+    function getEffectiveInitSelfType(match) {
+        if (match.specializedInitSelfType) {
+            return match.specializedInitSelfType;
+        }
+        const boundToType = match.overload.priv.boundToType;
+        if (match.overload.shared.name === '__init__' && boundToType && (0, types_1.isClassInstance)(boundToType)) {
+            return solveAndApplyConstraints(boundToType, match.constraints, {
+                replaceUnsolved: {
+                    scopeIds: (0, typeUtils_1.getTypeVarScopeIds)(boundToType),
+                    tupleClassType: getTupleClassType(),
+                },
+            });
+        }
+        return undefined;
+    }
+    function getOverloadArgParamPairs(match) {
+        const pairs = [];
+        // argResults and argParams share validation order: supplied arguments in caller
+        // order, followed by synthesized defaults. Preserve that order so the same index
+        // across overloads represents the same supplied argument, even for keyword calls.
+        match.argResults.forEach((argResult, index) => {
+            const argParam = index < match.matchResults.argParams.length ? match.matchResults.argParams[index] : undefined;
+            if (!argParam?.isDefaultArg) {
+                pairs.push({
+                    argType: argResult.argType,
+                    paramType: argParam?.paramType ?? types_1.UnknownType.create(),
+                });
+            }
+        });
+        if (match.overload.priv.boundToType && match.overload.priv.strippedFirstParamType) {
+            pairs.unshift({
+                argType: match.overload.priv.boundToType,
+                paramType: match.overload.priv.strippedFirstParamType,
+            });
+        }
+        return pairs;
+    }
+    function combineMaterializationCoverage(results) {
+        if (results.some((result) => result === false)) {
+            return false;
+        }
+        return results.some((result) => result === undefined) ? undefined : true;
+    }
+    function areAllMaterializationsEquivalent(destType, srcType, recursionCount = 0) {
+        if (recursionCount > types_1.maxTypeRecursionCount) {
+            return undefined;
+        }
+        recursionCount++;
+        if (!(0, typeUtils_1.containsAnyOrUnknown)(srcType, /* recurse */ true)) {
+            return (0, types_1.isTypeSame)(destType, srcType, { treatAnySameAsUnknown: true });
+        }
+        if ((0, types_1.isAnyOrUnknown)(destType)) {
+            return true;
+        }
+        if ((0, types_1.isTypeSame)(destType, srcType, { treatAnySameAsUnknown: true })) {
+            return true;
+        }
+        if ((0, types_1.isTypeVar)(destType) ||
+            (0, types_1.isUnion)(destType) ||
+            (0, types_1.isFunction)(destType) ||
+            (0, types_1.isOverloaded)(destType) ||
+            ((0, types_1.isClass)(destType) && types_1.ClassType.isProtocolClass(destType))) {
+            return undefined;
+        }
+        if ((0, types_1.isAnyOrUnknown)(srcType)) {
+            return false;
+        }
+        if ((0, types_1.isUnion)(srcType) || (0, types_1.isUnion)(destType) || (0, types_1.isFunction)(srcType) || (0, types_1.isFunction)(destType)) {
+            return undefined;
+        }
+        if (!(0, types_1.isClass)(destType) || !(0, types_1.isClass)(srcType)) {
+            return false;
+        }
+        if (!types_1.ClassType.isSameGenericClass(destType, srcType)) {
+            return false;
+        }
+        if (destType.priv.tupleTypeArgs || srcType.priv.tupleTypeArgs) {
+            const destTupleTypeArgs = destType.priv.tupleTypeArgs;
+            const srcTupleTypeArgs = srcType.priv.tupleTypeArgs;
+            if (!destTupleTypeArgs ||
+                !srcTupleTypeArgs ||
+                destTupleTypeArgs.length !== srcTupleTypeArgs.length ||
+                destTupleTypeArgs.some((destTypeArg, index) => destTypeArg.isUnbounded !== srcTupleTypeArgs[index].isUnbounded)) {
+                return false;
+            }
+            return combineMaterializationCoverage(srcTupleTypeArgs.map((srcTypeArg, index) => areAllMaterializationsEquivalent(destTupleTypeArgs[index].type, srcTypeArg.type, recursionCount)));
+        }
+        const destTypeArgs = destType.priv.typeArgs;
+        const srcTypeArgs = srcType.priv.typeArgs;
+        if (!destTypeArgs || !srcTypeArgs || destTypeArgs.length !== srcTypeArgs.length) {
+            return false;
+        }
+        return combineMaterializationCoverage(srcTypeArgs.map((srcTypeArg, index) => areAllMaterializationsEquivalent(destTypeArgs[index], srcTypeArg, recursionCount)));
+    }
+    function areAllMaterializationsAssignable(destType, srcType, recursionCount = 0) {
+        if (recursionCount > types_1.maxTypeRecursionCount) {
+            return undefined;
+        }
+        recursionCount++;
+        if (!(0, typeUtils_1.containsAnyOrUnknown)(srcType, /* recurse */ true)) {
+            return assignType(destType, srcType);
+        }
+        if ((0, types_1.isAnyOrUnknown)(destType)) {
+            return true;
+        }
+        if ((0, types_1.isTypeSame)(destType, srcType, { treatAnySameAsUnknown: true })) {
+            return true;
+        }
+        if ((0, types_1.isTypeVar)(destType) ||
+            (0, types_1.isUnion)(destType) ||
+            (0, types_1.isFunction)(destType) ||
+            (0, types_1.isOverloaded)(destType) ||
+            ((0, types_1.isClass)(destType) && types_1.ClassType.isProtocolClass(destType))) {
+            return undefined;
+        }
+        if ((0, types_1.isAnyOrUnknown)(srcType)) {
+            return assignType(destType, getObjectType());
+        }
+        if ((0, types_1.isUnion)(srcType) ||
+            (0, types_1.isUnion)(destType) ||
+            (0, types_1.isFunction)(srcType) ||
+            (0, types_1.isFunction)(destType) ||
+            (0, types_1.isOverloaded)(srcType) ||
+            (0, types_1.isOverloaded)(destType)) {
+            return undefined;
+        }
+        if (!(0, types_1.isClass)(destType) || !(0, types_1.isClass)(srcType)) {
+            return false;
+        }
+        if ((0, typeUtils_1.isTupleClass)(destType) && (0, typeUtils_1.isTupleClass)(srcType)) {
+            const destTupleTypeArgs = destType.priv.tupleTypeArgs;
+            const srcTupleTypeArgs = srcType.priv.tupleTypeArgs;
+            if (!destTupleTypeArgs || !srcTupleTypeArgs) {
+                return undefined;
+            }
+            if (destTupleTypeArgs.length === 1 && destTupleTypeArgs[0].isUnbounded) {
+                return combineMaterializationCoverage(srcTupleTypeArgs.map((srcTypeArg) => areAllMaterializationsAssignable(destTupleTypeArgs[0].type, srcTypeArg.type, recursionCount)));
+            }
+            if (destTupleTypeArgs.length !== srcTupleTypeArgs.length ||
+                destTupleTypeArgs.some((destTypeArg, index) => destTypeArg.isUnbounded !== srcTupleTypeArgs[index].isUnbounded)) {
+                return false;
+            }
+            return combineMaterializationCoverage(srcTupleTypeArgs.map((srcTypeArg, index) => areAllMaterializationsAssignable(destTupleTypeArgs[index].type, srcTypeArg.type, recursionCount)));
+        }
+        let specializedSrcType;
+        if (types_1.ClassType.isSameGenericClass(destType, srcType)) {
+            specializedSrcType = srcType;
+        }
+        else {
+            const instantiableDestType = (0, types_1.isClassInstance)(destType) ? types_1.ClassType.cloneAsInstantiable(destType) : destType;
+            const baseClass = srcType.shared.mro.find((mroClass) => (0, types_1.isClass)(mroClass) && types_1.ClassType.isSameGenericClass(instantiableDestType, mroClass));
+            if (baseClass && (0, types_1.isClass)(baseClass)) {
+                specializedSrcType = (0, typeUtils_1.specializeForBaseClass)(srcType, baseClass);
+            }
+        }
+        if (!specializedSrcType) {
+            return types_1.ClassType.isBuiltIn(destType, 'object') ? true : undefined;
+        }
+        const typeParams = types_1.ClassType.getTypeParams(destType);
+        if (typeParams.length === 0) {
+            return true;
+        }
+        const destTypeArgs = destType.priv.typeArgs;
+        const srcTypeArgs = specializedSrcType.priv.typeArgs;
+        if (!destTypeArgs) {
+            return true;
+        }
+        if (!srcTypeArgs) {
+            return false;
+        }
+        inferVarianceForClass(destType);
+        return combineMaterializationCoverage(srcTypeArgs.map((srcTypeArg, index) => {
+            const destTypeArg = index < destTypeArgs.length ? destTypeArgs[index] : types_1.UnknownType.create();
+            const typeParam = index < typeParams.length ? typeParams[index] : undefined;
+            const variance = typeParam ? types_1.TypeVarType.getVariance(typeParam) : 2 /* Variance.Invariant */;
+            if (variance === 3 /* Variance.Covariant */) {
+                return areAllMaterializationsAssignable(destTypeArg, srcTypeArg, recursionCount);
+            }
+            if (variance === 2 /* Variance.Invariant */) {
+                return areAllMaterializationsEquivalent(destTypeArg, srcTypeArg, recursionCount);
+            }
+            return undefined;
+        }));
+    }
     // Determines whether multiple incompatible overloads match
     // due to an Any or Unknown argument type.
     function filterOverloadMatchesForAnyArgs(matches) {
         if (matches.length < 2) {
             return matches;
         }
-        // If all of the return types match, select the first one.
-        if ((0, typeUtils_1.areTypesSame)(matches.map((match) => match.returnType), { treatAnySameAsUnknown: true })) {
+        let firstArgParamPairs = getOverloadArgParamPairs(matches[0]);
+        const hasInvariantAnyOrUnknownArg = firstArgParamPairs.some((pair) => getAnyOrUnknownInInvariantPosition(pair.argType));
+        // If all of the effective return types match, select the first one.
+        if ((0, typeUtils_1.areTypesSame)(matches.map((match) => hasInvariantAnyOrUnknownArg ? getEffectiveOverloadReturnType(match) : match.returnType), { treatAnySameAsUnknown: true })) {
             return [matches[0]];
         }
-        const firstArgResults = matches[0].argResults;
-        if (!firstArgResults) {
-            return matches;
+        // Apply overload step 5 to arguments that contain a gradual type in an
+        // invariant position. An overload that covers all materializations
+        // eliminates only the overloads that follow it.
+        if (hasInvariantAnyOrUnknownArg) {
+            let materializationCheckSupported = true;
+            for (let matchIndex = 0; matchIndex < matches.length; matchIndex++) {
+                const argParamPairs = getOverloadArgParamPairs(matches[matchIndex]);
+                const coverage = argParamPairs.length === firstArgParamPairs.length
+                    ? combineMaterializationCoverage(argParamPairs.map((pair, index) => {
+                        const argType = firstArgParamPairs[index].argType;
+                        return areAllMaterializationsAssignable(pair.paramType, argType);
+                    }))
+                    : false;
+                if (coverage === undefined) {
+                    materializationCheckSupported = false;
+                    break;
+                }
+                if (coverage) {
+                    matches = matches.slice(0, matchIndex + 1);
+                    break;
+                }
+            }
+            if (materializationCheckSupported) {
+                if (matches.length < 2) {
+                    return matches;
+                }
+                if ((0, typeUtils_1.areTypesSame)(matches.map((match) => getEffectiveOverloadReturnType(match)), { treatAnySameAsUnknown: true })) {
+                    return [matches[0]];
+                }
+                firstArgParamPairs = getOverloadArgParamPairs(matches[0]);
+                for (let i = 0; i < firstArgParamPairs.length; i++) {
+                    if (getAnyOrUnknownInInvariantPosition(firstArgParamPairs[i].argType)) {
+                        const paramTypes = matches.map((match) => {
+                            const argParamPairs = getOverloadArgParamPairs(match);
+                            return i < argParamPairs.length ? argParamPairs[i].paramType : types_1.UnknownType.create();
+                        });
+                        if (!(0, typeUtils_1.areTypesSame)(paramTypes, { treatAnySameAsUnknown: true })) {
+                            return matches;
+                        }
+                    }
+                }
+            }
         }
         let foundAmbiguousAnyArg = false;
-        for (let i = 0; i < firstArgResults.length; i++) {
+        for (let i = 0; i < firstArgParamPairs.length; i++) {
             // If the arg is Any or Unknown, see if the corresponding
             // parameter types differ in any way.
-            if ((0, types_1.isAnyOrUnknown)(firstArgResults[i].argType)) {
-                const paramTypes = matches.map((match) => i < match.matchResults.argParams.length
-                    ? match.matchResults.argParams[i].paramType
-                    : types_1.UnknownType.create());
+            if ((0, types_1.isAnyOrUnknown)(firstArgParamPairs[i].argType)) {
+                const paramTypes = matches.map((match) => {
+                    const argParamPairs = getOverloadArgParamPairs(match);
+                    return i < argParamPairs.length ? argParamPairs[i].paramType : types_1.UnknownType.create();
+                });
                 if (!(0, typeUtils_1.areTypesSame)(paramTypes, { treatAnySameAsUnknown: true })) {
                     foundAmbiguousAnyArg = true;
                 }
@@ -6874,7 +7556,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // that one of the arguments is an unpacked iterator, and it maps to
         // an indeterminate number of parameters, which means that the overload
         // selection is ambiguous.
-        if (foundAmbiguousAnyArg || matches.some((match) => match.argResults.length !== firstArgResults.length)) {
+        if (foundAmbiguousAnyArg ||
+            matches.some((match) => getOverloadArgParamPairs(match).length !== firstArgParamPairs.length)) {
             return matches;
         }
         return [matches[0]];
@@ -7227,7 +7910,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;
@@ -7301,18 +7985,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;
             }
@@ -7462,7 +8148,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 */);
@@ -7480,14 +8167,16 @@ 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, 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) };
@@ -7498,9 +8187,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),
             };
         }
@@ -7574,7 +8263,7 @@ 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));
+            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));
             newClassType.shared.baseClasses.push(getBuiltInType(errorNode, 'object'));
             newClassType.shared.effectiveMetaclass = expandedCallType;
             newClassType.shared.declaration = returnType.shared.declaration;
@@ -7618,7 +8307,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) {
@@ -8595,7 +9284,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 */;
@@ -8628,7 +9317,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         let argumentErrors = false;
         let argumentMatchScore = 0;
         let specializedInitSelfType;
-        let anyOrUnknownArg;
+        let anyOrUnknownArg = type.priv.boundToType
+            ? getAnyOrUnknownInInvariantPosition(type.priv.boundToType)
+            : undefined;
         const speculativeNode = getSpeculativeNodeForCall(errorNode);
         const typeCondition = (0, typeUtils_1.getTypeCondition)(type);
         const paramSpec = types_1.FunctionType.getParamSpecFromArgsKwargs(type);
@@ -8726,10 +9417,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (argResult.condition) {
                 condition = types_1.TypeCondition.combine(condition, argResult.condition) ?? [];
             }
-            if ((0, types_1.isAnyOrUnknown)(argResult.argType)) {
-                anyOrUnknownArg = anyOrUnknownArg
-                    ? (0, typeUtils_1.preserveUnknown)(argResult.argType, anyOrUnknownArg)
-                    : argResult.argType;
+            const argAnyOrUnknown = (0, types_1.isAnyOrUnknown)(argResult.argType)
+                ? argResult.argType
+                : getAnyOrUnknownInInvariantPosition(argResult.argType);
+            if (argAnyOrUnknown && !argParam.isDefaultArg) {
+                anyOrUnknownArg = anyOrUnknownArg ? (0, typeUtils_1.preserveUnknown)(argAnyOrUnknown, anyOrUnknownArg) : argAnyOrUnknown;
             }
             if (paramSpec) {
                 if (argParam.argument.argCategory === 1 /* ArgCategory.UnpackedList */) {
@@ -8813,7 +9505,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);
@@ -8876,7 +9568,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 */);
@@ -9148,7 +9840,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) {
@@ -9200,7 +9892,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) {
@@ -9323,7 +10015,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') {
@@ -9429,7 +10121,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') {
@@ -9490,7 +10182,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') {
@@ -9569,7 +10261,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);
@@ -9630,7 +10322,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);
                 }
@@ -9676,7 +10368,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);
@@ -9745,7 +10437,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     }
     // 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;
@@ -9993,7 +10685,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);
@@ -10058,7 +10750,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 {
@@ -10074,7 +10766,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 {
@@ -10134,7 +10826,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);
@@ -10143,7 +10835,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);
@@ -10400,7 +11092,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);
@@ -10442,7 +11134,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) ||
@@ -10535,7 +11227,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);
@@ -10617,13 +11309,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.
@@ -10985,7 +11677,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) {
@@ -11100,7 +11792,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // If no type arguments are provided, the resulting type
             // depends on whether we're evaluating a type annotation or
             // we're in some other context.
-            if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
+            if ((flags & (256 /* EvalFlags.TypeExpression */ | 1073741824 /* EvalFlags.TypeFormArg */)) !== 0) {
                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.optionalExtraArgs(), errorNode);
                 return types_1.UnknownType.create();
             }
@@ -11170,7 +11862,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     isValidTypeForm = false;
                 }
             }
-            else if (itemExpr.nodeType === 48 /* ParseNodeType.StringList */) {
+            else if (itemExpr.nodeType === 48 /* ParseNodeType.StringList */ &&
+                itemExpr.d.strings.every((stringNode) => stringNode.nodeType === 49 /* ParseNodeType.String */)) {
                 const isBytes = (itemExpr.d.strings[0].d.token.flags & 32 /* StringTokenFlags.Bytes */) !== 0;
                 const value = itemExpr.d.strings.map((s) => s.d.value).join('');
                 if (isBytes) {
@@ -11261,9 +11954,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     }
     // Creates a ClassVar type.
     function createClassVarType(classType, errorNode, typeArgs, flags) {
-        if (flags & 131072 /* EvalFlags.NoClassVar */) {
+        if (flags & (131072 /* EvalFlags.NoClassVar */ | 1073741824 /* EvalFlags.TypeFormArg */)) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.classVarNotAllowed(), errorNode);
-            return types_1.AnyType.create();
+            return (flags & 1073741824 /* EvalFlags.TypeFormArg */) !== 0 ? types_1.UnknownType.create() : types_1.AnyType.create();
         }
         if (!typeArgs) {
             return classType;
@@ -11285,8 +11978,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         return type;
     }
     function createTypeFormType(classType, errorNode, typeArgs) {
-        if (!typeArgs || typeArgs.length === 0) {
-            return types_1.ClassType.specialize(classType, [types_1.UnknownType.create()]);
+        if (!typeArgs) {
+            const specializedType = types_1.ClassType.specialize(classType, [types_1.AnyType.create()]);
+            return types_1.TypeBase.cloneWithTypeForm(specializedType, types_1.ClassType.cloneAsInstance(specializedType));
+        }
+        if (typeArgs.length === 0) {
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeArgsTooFew().format({
+                name: classType.priv.aliasName || classType.shared.name,
+                expected: 1,
+                received: 0,
+            }), errorNode);
+            return types_1.UnknownType.create();
         }
         if (typeArgs.length > 1) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeArgsTooMany().format({
@@ -11309,10 +12011,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // depends on whether we're evaluating a type annotation or
         // we're in some other context.
         if (!typeArgs) {
-            if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
+            if ((flags & (256 /* EvalFlags.TypeExpression */ | 1073741824 /* EvalFlags.TypeFormArg */)) !== 0) {
                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeGuardArgCount(), errorNode);
             }
-            return classType;
+            return (flags & 1073741824 /* EvalFlags.TypeFormArg */) !== 0 ? types_1.UnknownType.create() : classType;
         }
         else if (typeArgs.length !== 1) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeGuardArgCount(), errorNode);
@@ -11341,7 +12043,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         const enclosingClassTypeResult = enclosingClass ? getTypeOfClass(enclosingClass) : undefined;
         if (!enclosingClassTypeResult) {
-            if ((flags & (256 /* EvalFlags.TypeExpression */ | 128 /* EvalFlags.InstantiableType */)) !== 0) {
+            if ((flags & (256 /* EvalFlags.TypeExpression */ | 128 /* EvalFlags.InstantiableType */ | 1073741824 /* EvalFlags.TypeFormArg */)) !== 0) {
                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.selfTypeContext(), errorNode);
             }
             return types_1.UnknownType.create();
@@ -11354,7 +12056,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.
@@ -11393,18 +12095,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // If no type arguments are provided, the resulting type
         // depends on whether we're evaluating a type annotation or
         // we're in some other context.
-        if (!typeArgs && (flags & 256 /* EvalFlags.TypeExpression */) === 0) {
+        const typeExpressionFlags = 256 /* EvalFlags.TypeExpression */ | 1073741824 /* EvalFlags.TypeFormArg */;
+        if (!typeArgs && (flags & typeExpressionFlags) === 0) {
             return { type: classType };
         }
         if (!typeArgs || typeArgs.length !== 1) {
-            if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
+            if ((flags & typeExpressionFlags) !== 0) {
                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, classType.shared.name === 'ReadOnly'
                     ? localize_1.LocMessage.readOnlyArgCount()
                     : classType.shared.name === 'Required'
                         ? localize_1.LocMessage.requiredArgCount()
                         : localize_1.LocMessage.notRequiredArgCount(), errorNode);
             }
-            return { type: classType };
+            return { type: (flags & 1073741824 /* EvalFlags.TypeFormArg */) !== 0 ? types_1.UnknownType.create() : classType };
         }
         const typeArgType = typeArgs[0].type;
         // Make sure this is used only in a dataclass.
@@ -11444,23 +12147,23 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             isNotRequired = classType.shared.name === 'NotRequired';
         }
         if (!isUsageLegal) {
-            if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
+            if ((flags & typeExpressionFlags) !== 0) {
                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, classType.shared.name === 'ReadOnly'
                     ? localize_1.LocMessage.readOnlyNotInTypedDict()
                     : classType.shared.name === 'Required'
                         ? localize_1.LocMessage.requiredNotInTypedDict()
                         : localize_1.LocMessage.notRequiredNotInTypedDict(), errorNode);
             }
-            return { type: classType };
+            return { type: (flags & 1073741824 /* EvalFlags.TypeFormArg */) !== 0 ? types_1.UnknownType.create() : classType };
         }
         return { type: typeArgType, isReadOnly, isRequired, isNotRequired };
     }
     function createUnpackType(classType, errorNode, typeArgs, flags) {
         if (!typeArgs || typeArgs.length !== 1) {
-            if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
+            if ((flags & (256 /* EvalFlags.TypeExpression */ | 1073741824 /* EvalFlags.TypeFormArg */)) !== 0) {
                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.unpackArgCount(), errorNode);
             }
-            return classType;
+            return (flags & 1073741824 /* EvalFlags.TypeFormArg */) !== 0 ? types_1.UnknownType.create() : classType;
         }
         const typeArgType = typeArgs[0].type;
         if ((flags & 4194304 /* EvalFlags.AllowUnpackedTuple */) !== 0) {
@@ -11468,7 +12171,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (unpackedType) {
                 return unpackedType;
             }
-            if ((flags & 256 /* EvalFlags.TypeExpression */) === 0) {
+            if ((flags & (256 /* EvalFlags.TypeExpression */ | 1073741824 /* EvalFlags.TypeFormArg */)) === 0) {
                 return classType;
             }
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.unpackExpectedTypeVarTuple(), errorNode);
@@ -11484,19 +12187,27 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.unpackExpectedTypedDict(), errorNode);
             return types_1.UnknownType.create();
         }
-        if ((flags & 256 /* EvalFlags.TypeExpression */) === 0) {
+        if ((flags & (256 /* EvalFlags.TypeExpression */ | 1073741824 /* EvalFlags.TypeFormArg */)) === 0) {
             return classType;
         }
+        if ((flags & 1073741824 /* EvalFlags.TypeFormArg */) !== 0) {
+            if ((0, types_1.isUnknown)(typeArgType)) {
+                return typeArgType;
+            }
+            if ((0, types_1.isTypeVar)(typeArgType) && !typeArgType.priv.scopeId) {
+                return types_1.UnknownType.create();
+            }
+        }
         addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.unpackNotAllowed(), errorNode);
         return types_1.UnknownType.create();
     }
     // Creates a "Final" type.
     function createFinalType(classType, errorNode, typeArgs, flags) {
-        if (flags & 16 /* EvalFlags.NoFinal */) {
-            if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
+        if (flags & (16 /* EvalFlags.NoFinal */ | 1073741824 /* EvalFlags.TypeFormArg */)) {
+            if ((flags & (256 /* EvalFlags.TypeExpression */ | 1073741824 /* EvalFlags.TypeFormArg */)) !== 0) {
                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.finalContext(), errorNode);
             }
-            return classType;
+            return (flags & 1073741824 /* EvalFlags.TypeFormArg */) !== 0 ? types_1.UnknownType.create() : classType;
         }
         if ((flags & 256 /* EvalFlags.TypeExpression */) === 0 || !typeArgs || typeArgs.length === 0) {
             return classType;
@@ -11508,10 +12219,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     }
     function createConcatenateType(classType, errorNode, typeArgs, flags) {
         if ((flags & 134217728 /* EvalFlags.AllowConcatenate */) === 0) {
-            if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
+            if ((flags & (256 /* EvalFlags.TypeExpression */ | 1073741824 /* EvalFlags.TypeFormArg */)) !== 0) {
                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.concatenateContext(), errorNode);
             }
-            return classType;
+            return (flags & 1073741824 /* EvalFlags.TypeFormArg */) !== 0 ? types_1.UnknownType.create() : classType;
         }
         if (!typeArgs || typeArgs.length === 0) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.concatenateTypeArgsMissing(), errorNode);
@@ -11699,7 +12410,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;
@@ -11707,7 +12418,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // If no type arguments are provided, the resulting type
             // depends on whether we're evaluating a type annotation or
             // we're in some other context.
-            if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
+            if ((flags & (256 /* EvalFlags.TypeExpression */ | 1073741824 /* EvalFlags.TypeFormArg */)) !== 0) {
                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.unionTypeArgCount(), errorNode);
                 return types_1.NeverType.createNever();
             }
@@ -11741,7 +12452,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // is allowed if it's an unpacked TypeVarTuple or tuple. None is also allowed
         // since it is used to define NoReturn in typeshed stubs).
         if (types.length === 1 && !allowSingleTypeArg && !(0, typeUtils_1.isNoneInstance)(types[0])) {
-            if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
+            if ((flags & (256 /* EvalFlags.TypeExpression */ | 1073741824 /* EvalFlags.TypeFormArg */)) !== 0) {
                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeArguments, localize_1.LocMessage.unionTypeArgCount(), errorNode);
             }
             isValidTypeForm = false;
@@ -11768,10 +12479,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // If no type arguments are provided, the resulting type
             // depends on whether we're evaluating a type annotation or
             // we're in some other context.
-            if ((flags & (256 /* EvalFlags.TypeExpression */ | 262144 /* EvalFlags.NoNakedGeneric */)) !== 0) {
+            if ((flags & (256 /* EvalFlags.TypeExpression */ | 262144 /* EvalFlags.NoNakedGeneric */ | 1073741824 /* EvalFlags.TypeFormArg */)) !== 0) {
                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.genericTypeArgMissing(), errorNode);
             }
-            return classType;
+            return (flags & 1073741824 /* EvalFlags.TypeFormArg */) !== 0 ? types_1.UnknownType.create() : classType;
+        }
+        if ((flags & 1073741824 /* EvalFlags.TypeFormArg */) !== 0) {
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.genericNotAllowed(), errorNode);
+            return types_1.UnknownType.create();
         }
         const uniqueTypeVars = [];
         if (typeArgs) {
@@ -11878,7 +12593,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, 
@@ -11893,12 +12608,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 */;
@@ -12069,8 +12784,27 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return undefined;
     }
+    function cachedAssignmentTargetMayHaveDeclaredType(expression) {
+        switch (expression.nodeType) {
+            case 38 /* ParseNodeType.Name */: {
+                const symbolWithScope = lookUpSymbolRecursive(expression, expression.d.value, /* honorCodeFlow */ true);
+                return (!!symbolWithScope &&
+                    (symbolWithScope.symbol.hasTypedDeclarations() || symbolWithScope.scope.type === 3 /* ScopeType.Class */));
+            }
+            case 54 /* ParseNodeType.TypeAnnotation */:
+            case 35 /* ParseNodeType.MemberAccess */:
+            case 27 /* ParseNodeType.Index */:
+                return true;
+            case 52 /* ParseNodeType.Tuple */:
+                return (expression.d.items.length > 0 &&
+                    !expression.d.items.some((item) => item.nodeType === 56 /* ParseNodeType.Unpack */) &&
+                    expression.d.items.every((item) => cachedAssignmentTargetMayHaveDeclaredType(item)));
+            default:
+                return false;
+        }
+    }
     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)) {
@@ -12092,6 +12826,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         let rightHandType = readTypeCache(node.d.rightExpr, /* flags */ undefined);
         let isIncomplete = false;
         let expectedTypeDiagAddendum;
+        let declaredType;
+        let declaredTypeResolved = false;
+        // A runtime-first query may have cached the RHS without its assignment
+        // context. Re-evaluate it when the annotation expects a TypeForm so the
+        // ordinary cache cannot suppress contextual validation and conversion.
+        if (rightHandType && cachedAssignmentTargetMayHaveDeclaredType(node.d.leftExpr)) {
+            declaredType = getDeclaredTypeForExpression(node.d.leftExpr, { method: 'set' });
+            declaredTypeResolved = true;
+            if (declaredType && expectedTypeWantsTypeForm(declaredType)) {
+                rightHandType = undefined;
+            }
+        }
         if (!rightHandType) {
             // Special-case the typing.pyi file, which contains some special
             // types that the type analyzer needs to interpret differently.
@@ -12146,9 +12892,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     writeTypeCache(node.d.leftExpr.d.valueExpr, { type: typeAliasPlaceholder }, /* flags */ undefined);
                 }
             }
-            let declaredType = getDeclaredTypeForExpression(node.d.leftExpr, { method: 'set' });
+            if (!declaredTypeResolved) {
+                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));
@@ -12202,8 +12950,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),
@@ -12242,9 +12990,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);
         }
@@ -12312,7 +13060,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) {
@@ -12347,8 +13095,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 ||
@@ -12372,7 +13120,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;
@@ -12382,7 +13130,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;
         }
@@ -12725,7 +13473,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();
@@ -12745,6 +13493,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (slotsNames) {
                 classType.shared.localSlotsNames = slotsNames;
             }
+            classType.shared.hasNonEmptySlots = innerScope?.hasNonEmptySlots;
             // Determine if the class should be a "pseudo-generic" class, characterized
             // by having an __init__ method with parameters that lack type annotations.
             // For such classes, we'll treat them as generic, with the type arguments provided
@@ -12769,9 +13518,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 */);
                                 });
                             }
                         }
@@ -12814,6 +13563,23 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
             }
             const effectiveMetaclass = computeEffectiveMetaclass(classType, node.d.name);
+            const enumMemberSetMayBeDynamicallyModified = types_1.ClassType.isEnumClass(classType) &&
+                (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 */;
+            }
+            if (types_1.ClassType.isEnumClass(classType) &&
+                (node.d.decorators.length > 0 ||
+                    enumMemberSetMayBeDynamicallyModified ||
+                    !(0, types_1.isInstantiableClass)(effectiveMetaclass) ||
+                    !types_1.ClassType.isBuiltIn(effectiveMetaclass, ['EnumMeta', 'EnumType']) ||
+                    classType.shared.mro.some((mroClass) => (0, types_1.isClass)(mroClass) &&
+                        (types_1.ClassType.isEnumMemberSetMayBeIncomplete(mroClass) ||
+                            (!types_1.ClassType.isBuiltIn(mroClass, 'Enum') &&
+                                types_1.ClassType.getSymbolTable(mroClass).has('_missing_')))))) {
+                classType.shared.flags |= 33554432 /* ClassTypeFlags.EnumMemberSetMayBeIncomplete */;
+            }
             // Clear the "partially constructed" flag.
             classType.shared.flags &= ~8192 /* ClassTypeFlags.PartiallyEvaluated */;
             // Now determine the decorated type of the class.
@@ -12821,7 +13587,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.
@@ -12852,7 +13618,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);
@@ -12876,7 +13642,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) {
@@ -12897,7 +13663,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.
@@ -12905,6 +13671,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     synthesizeMethods();
                 }
                 else {
+                    if (types_1.ClassType.isDataClassGenerateSlots(classType)) {
+                        classType.shared.synthesizeDataClassSlotsDeferred = () => (0, dataClasses_1.synthesizeDataClassSlots)(evaluatorInterface, classType);
+                    }
                     classType.shared.synthesizeMethodsDeferred = () => {
                         delete classType.shared.synthesizeMethodsDeferred;
                         synthesizeMethods();
@@ -13058,7 +13827,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) {
@@ -13344,7 +14113,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)) {
@@ -13369,7 +14138,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.
@@ -13379,14 +14148,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;
         }
@@ -13397,7 +14166,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 */;
@@ -13412,12 +14181,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) {
@@ -13426,7 +14195,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);
@@ -13625,7 +14394,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) {
@@ -13709,7 +14478,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);
             }
         }
     }
@@ -13721,7 +14490,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;
@@ -13759,7 +14528,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: {
@@ -13768,7 +14537,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);
                             }
@@ -13820,7 +14589,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);
             }
@@ -13951,14 +14720,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.
@@ -14103,7 +14872,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;
                 }
@@ -14334,7 +15103,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) {
@@ -14356,7 +15125,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);
@@ -14404,7 +15173,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 */);
@@ -14417,7 +15186,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
@@ -14426,17 +15195,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) {
@@ -14446,7 +15215,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) => {
@@ -14531,7 +15300,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,
@@ -14814,7 +15583,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));
@@ -14862,7 +15631,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 */);
@@ -14884,9 +15653,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 */);
     }
@@ -14998,9 +15767,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // within that tree. If the type cannot be determined (because it's part
     // of a cyclical dependency), the function returns undefined.
     function evaluateTypeForSubnode(subnode, callback) {
+        return evaluateTypeForSubnodeWithCache(subnode, callback, readTypeCacheEntry);
+    }
+    function evaluateContextualTypeForSubnode(subnode, callback) {
+        return evaluateTypeForSubnodeWithCache(subnode, callback, readContextualTypeCacheEntryForNode);
+    }
+    function evaluateTypeForSubnodeWithCache(subnode, callback, readCacheEntry) {
         // If the type cache is already populated with a complete type,
         // don't bother doing additional work.
-        let cacheEntry = readTypeCacheEntry(subnode);
+        let cacheEntry = readCacheEntry(subnode);
         if (cacheEntry && !cacheEntry.typeResult.isIncomplete) {
             const typeResult = cacheEntry.typeResult;
             // Handle the special case where a function or class is partially evaluated.
@@ -15014,7 +15789,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             return typeResult;
         }
         callback();
-        cacheEntry = readTypeCacheEntry(subnode);
+        cacheEntry = readCacheEntry(subnode);
         if (cacheEntry) {
             return cacheEntry.typeResult;
         }
@@ -15056,8 +15831,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);
@@ -15081,7 +15856,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);
         }
@@ -15128,7 +15903,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     return { type: createClassVarType(classType, errorNode, typeArgs, flags) };
                 }
                 case 'Protocol': {
-                    if ((flags & (67108864 /* EvalFlags.NoNonTypeSpecialForms */ | 256 /* EvalFlags.TypeExpression */)) !== 0) {
+                    if ((flags &
+                        (67108864 /* EvalFlags.NoNonTypeSpecialForms */ | 256 /* EvalFlags.TypeExpression */ | 1073741824 /* EvalFlags.TypeFormArg */)) !==
+                        0) {
                         addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.protocolNotAllowed(), errorNode);
                     }
                     typeArgs?.forEach((typeArg) => {
@@ -15143,9 +15920,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     };
                 }
                 case 'TypedDict': {
-                    if ((flags & (67108864 /* EvalFlags.NoNonTypeSpecialForms */ | 256 /* EvalFlags.TypeExpression */)) !== 0) {
-                        const isInlinedTypedDict = AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.enableExperimentalFeatures &&
-                            !!typeArgs;
+                    if ((flags &
+                        (67108864 /* EvalFlags.NoNonTypeSpecialForms */ | 256 /* EvalFlags.TypeExpression */ | 1073741824 /* EvalFlags.TypeFormArg */)) !==
+                        0) {
+                        const isInlinedTypedDict = nodeInfo.getFileInfo(errorNode).diagnosticRuleSet.enableExperimentalFeatures && !!typeArgs;
                         if (!isInlinedTypedDict) {
                             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typedDictNotAllowed(), errorNode);
                         }
@@ -15154,12 +15932,21 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     break;
                 }
                 case 'Literal': {
-                    if ((flags & (67108864 /* EvalFlags.NoNonTypeSpecialForms */ | 256 /* EvalFlags.TypeExpression */)) !== 0) {
+                    if ((flags &
+                        (67108864 /* EvalFlags.NoNonTypeSpecialForms */ | 256 /* EvalFlags.TypeExpression */ | 1073741824 /* EvalFlags.TypeFormArg */)) !==
+                        0) {
                         addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.literalNotAllowed(), errorNode);
                     }
                     isValidTypeForm = false;
                     break;
                 }
+                case 'TypeAlias': {
+                    if ((flags & 1073741824 /* EvalFlags.TypeFormArg */) !== 0) {
+                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeAnnotationVariable(), errorNode);
+                    }
+                    isValidTypeForm = false;
+                    break;
+                }
                 case 'Tuple': {
                     return {
                         type: createSpecialType(classType, typeArgs, 
@@ -15208,10 +15995,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.
@@ -15269,7 +16056,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         received: typeArgCount,
                     }), typeArgs[1].node);
                 }
-                return { type: typeArgs[0].inlinedTypeDict };
+                let inlinedTypeDict = typeArgs[0].inlinedTypeDict;
+                if ((flags & 1073741824 /* EvalFlags.TypeFormArg */) !== 0) {
+                    inlinedTypeDict = types_1.TypeBase.cloneWithTypeForm(inlinedTypeDict, (0, typeUtils_1.convertToInstance)(inlinedTypeDict));
+                }
+                return { type: inlinedTypeDict };
             }
             else if (typeArgCount > typeParams.length) {
                 if (!types_1.ClassType.isPartiallyEvaluated(classType) && !types_1.ClassType.isTupleClass(classType)) {
@@ -15379,7 +16170,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         return;
                     }
                 }
-                const typeArgType = (0, typeUtils_1.convertToInstance)(typeArgs[index].type);
+                const typeArgType = convertTypeArgToInstance(typeArgs[index].type, flags);
                 typeArgTypes.push(typeArgType);
                 constraints.setBounds(typeParam, typeArgType);
                 return;
@@ -15524,7 +16315,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 */;
         }
@@ -15579,7 +16370,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);
@@ -15601,8 +16392,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,
@@ -15621,20 +16412,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) {
@@ -15642,7 +16433,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, 
@@ -15818,7 +16609,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) {
@@ -15839,6 +16630,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) ||
@@ -15905,7 +16738,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 = [];
@@ -15915,7 +16748,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);
@@ -15981,7 +16814,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 &&
@@ -16003,7 +16836,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);
@@ -16047,10 +16883,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;
@@ -16138,7 +17009,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)),
@@ -16186,9 +17057,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')) {
@@ -16333,7 +17202,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);
@@ -16341,7 +17210,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.
@@ -16427,7 +17296,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
@@ -16639,7 +17508,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;
                 }
@@ -16703,7 +17572,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;
@@ -16734,8 +17603,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,
@@ -16923,8 +17792,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
@@ -17010,7 +17879,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);
     }
@@ -17049,11 +17946,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.
@@ -17117,7 +18014,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);
                     }
                 }
@@ -17132,7 +18029,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;
         }
@@ -17173,12 +18070,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // this function so we can analyze it separately without polluting
             // the main type cache.
             const prevTypeCache = returnTypeInferenceTypeCache;
+            const prevTypeFormTypeCache = returnTypeInferenceTypeFormTypeCache;
             returnTypeInferenceContextStack.push({
                 functionNode,
                 codeFlowAnalyzer: codeFlowEngine.createCodeFlowAnalyzer(),
             });
             try {
                 returnTypeInferenceTypeCache = new Map();
+                returnTypeInferenceTypeFormTypeCache = new Map();
                 let allArgTypesAreUnknown = true;
                 functionNode.d.params.forEach((param, index) => {
                     if (param.d.name) {
@@ -17240,6 +18139,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             finally {
                 returnTypeInferenceContextStack.pop();
                 returnTypeInferenceTypeCache = prevTypeCache;
+                returnTypeInferenceTypeFormTypeCache = prevTypeFormTypeCache;
             }
         });
         if (contextualReturnType) {
@@ -17386,6 +18286,27 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
             }
         }
+        // A class value normally remains unspecialized so it can be subscripted.
+        // If every type parameter has an explicit default, apply those defaults
+        // when comparing it against a type specialization. Classes with defaultless
+        // parameters or defaults that resolve directly to Any or Unknown retain
+        // their unspecialized behavior, so they don't degrade inference.
+        if (types_1.TypeBase.isInstantiable(srcType) &&
+            srcType.props?.typeForm &&
+            !srcType.priv.typeArgs &&
+            !srcType.priv.includeSubclasses &&
+            srcType.shared.typeParams.length > 0 &&
+            srcType.shared.typeParams.every((typeParam) => typeParam.shared.isDefaultExplicit)) {
+            const specializedSrcType = (0, typeUtils_1.specializeWithDefaultTypeArgs)(srcType);
+            const specializedTypeArgs = specializedSrcType.priv.typeArgs ??
+                specializedSrcType.priv.tupleTypeArgs?.map((tupleTypeArg) => tupleTypeArg.type);
+            const hasGradualTypeArg = specializedTypeArgs?.some((typeArg) => !!(0, typeUtils_1.containsAnyOrUnknown)(typeArg, /* recurse */ false) ||
+                ((0, types_1.isFunction)(typeArg) && types_1.FunctionType.isGradualCallableForm(typeArg)) ||
+                ((0, types_1.isUnpackedClass)(typeArg) && !!(0, typeUtils_1.containsAnyOrUnknown)(typeArg, /* recurse */ true)));
+            if (hasGradualTypeArg === false) {
+                srcType = specializedSrcType;
+            }
+        }
         // Is it a structural type (i.e. a protocol)? If so, we need to
         // perform a member-by-member check.
         const inheritanceChain = [];
@@ -17778,6 +18699,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
             }
         }
+        // A subscripted runtime built-in such as list[int] is represented as its
+        // precise class type, but it is also a types.GenericAlias object at runtime.
+        if ((0, types_1.isClassInstance)(destType) &&
+            types_1.ClassType.isBuiltIn(destType, 'GenericAlias') &&
+            (0, types_1.isInstantiableClass)(srcType) &&
+            !types_1.ClassType.isSpecialBuiltIn(srcType) &&
+            !srcType.priv.aliasName &&
+            srcType.shared.moduleName === 'builtins' &&
+            srcType.priv.typeArgs !== undefined &&
+            srcType.props?.typeForm &&
+            classGetItemReturnsGenericAlias(srcType)) {
+            return true;
+        }
         // If the source is a class-like type created by a call to NewType, treat it
         // as a FunctionClass instance rather than an instantiable class for
         // purposes of assignability. This reflects its actual runtime type.
@@ -17986,6 +18920,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             return true;
         }
+        const isInvariant = (flags & 1 /* AssignTypeFlags.Invariant */) !== 0;
+        srcType = expandEnumTypeForLiteralComparison(srcType, destType, /* concretizeTypeVars */ !isInvariant);
+        if (isInvariant) {
+            destType = expandEnumTypeForLiteralComparison(destType, srcType, /* concretizeTypeVars */ false);
+        }
         if ((0, types_1.isUnion)(destType)) {
             // If both the source and dest are unions, use assignFromUnionType which has
             // special-case logic to handle this case.
@@ -18094,7 +19033,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (types_1.ClassType.isBuiltIn(destType, 'TypeForm')) {
                 const destTypeArg = destType.priv.typeArgs && destType.priv.typeArgs.length > 0
                     ? destType.priv.typeArgs[0]
-                    : types_1.UnknownType.create();
+                    : types_1.AnyType.create();
                 let srcTypeArg;
                 if ((0, types_1.isClassInstance)(concreteSrcType) && types_1.ClassType.isBuiltIn(concreteSrcType, 'type')) {
                     srcTypeArg = concreteSrcType;
@@ -18344,8 +19283,38 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         });
         return isAssignable;
     }
+    function isTypeFormClass(type) {
+        return (types_1.ClassType.isBuiltIn(type, 'TypeForm') ||
+            (types_1.ClassType.isSpecialBuiltIn(type) &&
+                (type.shared.name === 'TypeForm' || type.priv.aliasName === 'TypeForm')));
+    }
+    function isTypeFormType(type) {
+        return (0, types_1.isClassInstance)(type) && isTypeFormClass(type);
+    }
+    function classGetItemReturnsGenericAlias(classType) {
+        const member = (0, typeUtils_1.lookUpClassMember)(classType, '__class_getitem__', 16 /* MemberAccessFlags.SkipInstanceMembers */);
+        if (!member) {
+            return false;
+        }
+        const memberType = getTypeOfMember(member);
+        const functionReturnsGenericAlias = (functionType) => {
+            const returnType = types_1.FunctionType.getEffectiveReturnType(functionType);
+            return !!returnType && (0, types_1.isClassInstance)(returnType) && types_1.ClassType.isBuiltIn(returnType, 'GenericAlias');
+        };
+        if ((0, types_1.isFunction)(memberType)) {
+            return functionReturnsGenericAlias(memberType);
+        }
+        if ((0, types_1.isOverloaded)(memberType)) {
+            return types_1.OverloadedType.getOverloads(memberType).every(functionReturnsGenericAlias);
+        }
+        return false;
+    }
+    function expectedTypeRequiresTypeForm(expectedType) {
+        return ((0, typeUtils_1.someSubtypes)(expectedType, isTypeFormType) &&
+            !(0, typeUtils_1.someSubtypes)(expectedType, (subtype) => !isTypeFormType(subtype)));
+    }
     function expectedTypeWantsTypeForm(expectedType) {
-        return (0, typeUtils_1.someSubtypes)(expectedType, (subtype) => (0, types_1.isClassInstance)(subtype) && types_1.ClassType.isBuiltIn(subtype, 'TypeForm'));
+        return (0, typeUtils_1.someSubtypes)(expectedType, isTypeFormType);
     }
     // If the expected type is an explicit TypeForm type, see if the source
     // type has an implicit TypeForm type that can be assigned to it. If so,
@@ -18386,9 +19355,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (resultType || !(0, types_1.isClassInstance)(subtype) || !types_1.ClassType.isBuiltIn(subtype, 'TypeForm')) {
                 return;
             }
-            const destTypeFormType = subtype.priv.typeArgs && subtype.priv.typeArgs.length > 0
-                ? subtype.priv.typeArgs[0]
-                : types_1.UnknownType.create();
+            const destTypeFormType = subtype.priv.typeArgs && subtype.priv.typeArgs.length > 0 ? subtype.priv.typeArgs[0] : types_1.AnyType.create();
             if (assignType(destTypeFormType, srcTypeFormType)) {
                 resultType = types_1.ClassType.specialize(subtype, [srcTypeFormType]);
             }
@@ -19657,6 +20624,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 if ((0, types_1.isUnknown)(assignedSubtype)) {
                     return assignedSubtype;
                 }
+                // Preserve assignment narrowing when an enum literal is assigned
+                // to its non-literal enum class. A single-member enum is equivalent
+                // to its only literal, but the assigned value is still more precise.
+                if ((0, types_1.isClassInstance)(assignedSubtype) &&
+                    assignedSubtype.priv.literalValue instanceof types_1.EnumLiteral &&
+                    (0, types_1.isClassInstance)(declaredSubtype) &&
+                    declaredSubtype.priv.literalValue === undefined &&
+                    types_1.ClassType.isSameGenericClass(assignedSubtype, declaredSubtype)) {
+                    return assignedSubtype;
+                }
                 // If the two types are bidirectionally assignable, they are
                 // either equivalent (in which case it doesn't matter which
                 // one we choose) or one or both include gradual types (Any, etc.),
@@ -20536,7 +21513,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
@@ -20554,14 +21531,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);
             });
@@ -20569,7 +21546,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;
         }
@@ -20579,7 +21556,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;
         }
@@ -20589,7 +21566,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();
     }
@@ -20600,6 +21577,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     const getInferredReturnTypeResult = wrapWithLogger(_getInferredReturnTypeResult);
     const evaluatorInterface = {
         runWithCancellationToken,
+        getAnalyzerNodeInfoReader: () => nodeInfo,
         getType,
         getTypeResult,
         getTypeResultForDecorator,
@@ -20710,7 +21688,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