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

package/dist/analyzer/typeEvaluator.js

@@ -203,6 +203,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,6 +213,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     let incompleteGenCount = 0;
     const returnTypeInferenceContextStack = [];
     let returnTypeInferenceTypeCache;
+    let returnTypeInferenceTypeFormTypeCache;
     const signatureTrackerStack = [];
     let prefetched;
     function runWithCancellationToken(token, callback) {
@@ -252,6 +254,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 +269,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;
         }
@@ -300,20 +346,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 +459,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 +496,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,
@@ -570,8 +631,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 +655,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 +675,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
@@ -966,7 +1039,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,7 +1145,6 @@ 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);
         }
@@ -3448,6 +3521,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 +3535,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) {
@@ -3794,7 +3919,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,
@@ -5199,6 +5324,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 +5447,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 +5602,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;
                     }
@@ -5562,12 +5695,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 +5999,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,
@@ -6191,12 +6330,20 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             const isCyclicalTypeVarCall = (0, types_1.isInstantiableClass)(baseTypeResult.type) &&
                 types_1.ClassType.isBuiltIn(baseTypeResult.type, 'TypeVar') &&
                 AnalyzerNodeInfo.getFileInfo(node).isTypingStubFile;
-            if (!isCyclicalTypeVarCall) {
+            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 +6413,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 +6593,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,
@@ -6672,13 +6991,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 +7042,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 +7057,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     }
                     else {
                         returnTypes.push(callResult.returnType);
+                        effectiveInitSelfType = getEffectiveInitSelfType(matchedOverloadInfo);
                         isDefinitiveMatchFound = true;
                         break;
                     }
@@ -6743,20 +7071,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 +7128,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 +7140,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 +7165,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 +7201,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 +7213,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 +7233,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 +7540,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]];
@@ -8628,7 +9295,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 +9395,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 */) {
@@ -11100,7 +11770,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 +11840,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 +11932,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 +11956,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 +11989,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 +12021,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();
@@ -11393,18 +12073,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 +12125,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 +12149,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 +12165,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 +12197,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);
@@ -11707,7 +12396,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 +12430,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 +12457,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) {
@@ -12069,6 +12762,25 @@ 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);
         // If the entire statement has already been evaluated, don't
@@ -12092,6 +12804,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,7 +12870,9 @@ 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);
                 declaredType = (0, typeUtils_1.makeTypeVarsBound)(declaredType, liveTypeVarScopes);
@@ -12745,6 +13471,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
@@ -12814,6 +13541,23 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
             }
             const effectiveMetaclass = computeEffectiveMetaclass(classType, node.d.name);
+            const enumMemberSetMayBeDynamicallyModified = types_1.ClassType.isEnumClass(classType) &&
+                (AnalyzerNodeInfo.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.
@@ -12905,6 +13649,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();
@@ -14998,9 +15745,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 +15767,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             return typeResult;
         }
         callback();
-        cacheEntry = readTypeCacheEntry(subnode);
+        cacheEntry = readCacheEntry(subnode);
         if (cacheEntry) {
             return cacheEntry.typeResult;
         }
@@ -15128,7 +15881,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,7 +15898,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     };
                 }
                 case 'TypedDict': {
-                    if ((flags & (67108864 /* EvalFlags.NoNonTypeSpecialForms */ | 256 /* EvalFlags.TypeExpression */)) !== 0) {
+                    if ((flags &
+                        (67108864 /* EvalFlags.NoNonTypeSpecialForms */ | 256 /* EvalFlags.TypeExpression */ | 1073741824 /* EvalFlags.TypeFormArg */)) !==
+                        0) {
                         const isInlinedTypedDict = AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.enableExperimentalFeatures &&
                             !!typeArgs;
                         if (!isInlinedTypedDict) {
@@ -15154,12 +15911,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, 
@@ -15269,7 +16035,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 +16149,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;
@@ -17173,12 +17943,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 +18012,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             finally {
                 returnTypeInferenceContextStack.pop();
                 returnTypeInferenceTypeCache = prevTypeCache;
+                returnTypeInferenceTypeFormTypeCache = prevTypeFormTypeCache;
             }
         });
         if (contextualReturnType) {
@@ -17386,6 +18159,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 +18572,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 +18793,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 +18906,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 +19156,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 +19228,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 +20497,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.),