@zzzen/pyright-internal 1.2.0-dev.20241027 → 1.2.0-dev.20241110

package/dist/analyzer/typeEvaluator.js

@@ -206,6 +206,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     let strClass;
     let dictClass;
     let moduleTypeClass;
+    let typedDictClass;
     let typedDictPrivateClass;
     let supportsKeysAndGetItemClass;
     let mappingClass;
@@ -500,6 +501,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             strClass = getBuiltInType(node, 'str');
             dictClass = getBuiltInType(node, 'dict');
             moduleTypeClass = getTypingType(node, 'ModuleType');
+            typedDictClass = getTypingType(node, 'TypedDict');
             typedDictPrivateClass = getTypingType(node, '_TypedDict');
             awaitableClass = getTypingType(node, 'Awaitable');
             mappingClass = getTypingType(node, 'Mapping');
@@ -1210,6 +1212,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 if (tupleBaseClass && (0, types_1.isClass)(tupleBaseClass) && tupleBaseClass.priv.tupleTypeArgs) {
                     return (0, typeUtils_1.isUnboundedTupleClass)(tupleBaseClass) || tupleBaseClass.priv.tupleTypeArgs.length === 0;
                 }
+                // Handle TypedDicts specially. If one or more entries are required
+                // or known to exist, we can say for sure that the type is not falsy.
+                if (types_1.ClassType.isTypedDictClass(type)) {
+                    const tdEntries = (0, typedDicts_1.getTypedDictMembersForClass)(evaluatorInterface, type, /* allowNarrowed */ true);
+                    if (tdEntries) {
+                        for (const tdEntry of tdEntries.knownItems.values()) {
+                            if (tdEntry.isRequired || tdEntry.isProvided) {
+                                return false;
+                            }
+                        }
+                    }
+                }
                 // Check for bool, int, str and bytes literals that are never falsy.
                 if (type.priv.literalValue !== undefined) {
                     if (types_1.ClassType.isBuiltIn(type, ['bool', 'int', 'str', 'bytes'])) {
@@ -2380,7 +2394,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 if (classTypeResults && (0, types_1.isInstantiableClass)(classTypeResults.classType)) {
                     enclosingClass = classTypeResults.classType;
                     if ((0, types_1.isClassInstance)(baseType)) {
-                        if (types_1.ClassType.isSameGenericClass(baseType, classTypeResults.classType)) {
+                        if (types_1.ClassType.isSameGenericClass(types_1.ClassType.cloneAsInstantiable(baseType), classTypeResults.classType)) {
                             assignTypeToMemberVariable(target, typeResult, /* isInstanceMember */ true, srcExpr);
                         }
                     }
@@ -2455,9 +2469,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 if (isThisClass && isInstanceMember && memberClass) {
                     const inheritedSlotsNames = types_1.ClassType.getInheritedSlotsNames(memberClass);
                     if (inheritedSlotsNames && memberClass.shared.localSlotsNames) {
-                        // Skip this check if the local slots is specified but empty because this pattern
-                        // is used in a legitimate manner for mix-in classes.
-                        if (memberClass.shared.localSlotsNames.length > 0 &&
+                        // Skip this check if the local slots is specified but empty
+                        // and the class isn't final. This pattern is used in a
+                        // legitimate manner for mix-in classes.
+                        if ((memberClass.shared.localSlotsNames.length > 0 || types_1.ClassType.isFinal(memberClass)) &&
                             !inheritedSlotsNames.some((name) => name === memberName)) {
                             // Determine whether the assignment corresponds to a descriptor
                             // that was assigned as a class variable. If so, then slots will not
@@ -2951,7 +2966,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
         }
     }
-    function verifyRaiseExceptionType(node) {
+    function verifyRaiseExceptionType(node, allowNone) {
         const baseExceptionType = getBuiltInType(node, 'BaseException');
         const exceptionType = getTypeOfExpression(node).type;
         // Validate that the argument of "raise" is an exception object or class.
@@ -2961,7 +2976,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             const diag = new diagnostic_1.DiagnosticAddendum();
             (0, typeUtils_1.doForEachSubtype)(exceptionType, (subtype) => {
                 const concreteSubtype = makeTopLevelTypeVarsConcrete(subtype);
-                if ((0, types_1.isAnyOrUnknown)(concreteSubtype) || (0, types_1.isNever)(concreteSubtype) || (0, typeUtils_1.isNoneInstance)(concreteSubtype)) {
+                if ((0, types_1.isAnyOrUnknown)(concreteSubtype) || (0, types_1.isNever)(concreteSubtype)) {
+                    return;
+                }
+                if (allowNone && (0, typeUtils_1.isNoneInstance)(concreteSubtype)) {
                     return;
                 }
                 if ((0, types_1.isInstantiableClass)(concreteSubtype) && concreteSubtype.priv.literalValue === undefined) {
@@ -3828,7 +3846,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     else {
                         // Is this an attempt to delete or overwrite an enum member?
                         if ((0, types_1.isClassInstance)(enumMemberResult.type) &&
-                            types_1.ClassType.isSameGenericClass(enumMemberResult.type, baseType) &&
+                            types_1.ClassType.isSameGenericClass(enumMemberResult.type, types_1.ClassType.cloneAsInstance(baseType)) &&
                             enumMemberResult.type.priv.literalValue !== undefined) {
                             const diagMessage = usage.method === 'set' ? localize_1.LocMessage.enumMemberSet() : localize_1.LocMessage.enumMemberDelete();
                             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportAttributeAccessIssue, diagMessage.format({ name: memberName }) + diag.getString(), node.d.member, (_c = diag.getEffectiveTextRange()) !== null && _c !== void 0 ? _c : node.d.member);
@@ -4107,7 +4125,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 const containingClassType = (_a = getTypeOfClass(containingClass)) === null || _a === void 0 ? void 0 : _a.classType;
                 if (containingClassType &&
                     (0, types_1.isInstantiableClass)(containingClassType) &&
-                    types_1.ClassType.isSameGenericClass(containingClassType, classType)) {
+                    types_1.ClassType.isSameGenericClass(isAccessedThroughObject ? types_1.ClassType.cloneAsInstance(containingClassType) : containingClassType, classType)) {
                     type = (_b = getDeclaredTypeOfSymbol(memberInfo.symbol)) === null || _b === void 0 ? void 0 : _b.type;
                     if (type && (0, types_1.isInstantiableClass)(memberInfo.classType)) {
                         type = (0, typeUtils_1.partiallySpecializeType)(type, memberInfo.classType, 
@@ -4165,7 +4183,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // Mark the member accessed if it's not coming from a parent class.
             if (errorNode &&
                 (0, types_1.isInstantiableClass)(memberInfo.classType) &&
-                types_1.ClassType.isSameGenericClass(memberInfo.classType, classType)) {
+                types_1.ClassType.isSameGenericClass(memberInfo.classType, isAccessedThroughObject ? types_1.ClassType.cloneAsInstantiable(classType) : classType)) {
                 setSymbolAccessed(AnalyzerNodeInfo.getFileInfo(errorNode), memberInfo.symbol, errorNode);
             }
             // Special-case `__init_subclass` and `__class_getitem__` because
@@ -4521,8 +4539,28 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             isAsymmetric = false;
         }
         else {
-            const getterType = getEffectiveTypeOfSymbol(getterSymbolResult.symbol);
+            let getterType = getEffectiveTypeOfSymbol(getterSymbolResult.symbol);
             const setterType = getEffectiveTypeOfSymbol(setterSymbolResult.symbol);
+            // If this is an overload, find the appropriate overload.
+            if ((0, types_1.isOverloaded)(getterType)) {
+                const getOverloads = types_1.OverloadedType.getOverloads(getterType).filter((overload) => {
+                    if (overload.shared.parameters.length < 2) {
+                        return false;
+                    }
+                    const param1Type = types_1.FunctionType.getParamType(overload, 1);
+                    return !(0, typeUtils_1.isNoneInstance)(param1Type);
+                });
+                if (getOverloads.length === 1) {
+                    getterType = getOverloads[0];
+                }
+                else {
+                    isAsymmetric = true;
+                }
+            }
+            // If this is an overload, find the appropriate overload.
+            if ((0, types_1.isOverloaded)(setterType)) {
+                isAsymmetric = true;
+            }
             // If either the setter or getter is an overload (or some other non-function type),
             // conservatively assume that it's not asymmetric.
             if ((0, types_1.isFunction)(getterType) && (0, types_1.isFunction)(setterType)) {
@@ -5195,11 +5233,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     types_1.ClassType.isPartiallyEvaluated(concreteSubtype);
                 const isFinalAnnotation = (0, types_1.isInstantiableClass)(concreteSubtype) && types_1.ClassType.isBuiltIn(concreteSubtype, 'Final');
                 const isClassVarAnnotation = (0, types_1.isInstantiableClass)(concreteSubtype) && types_1.ClassType.isBuiltIn(concreteSubtype, 'ClassVar');
+                // This feature is currently experimental.
+                const supportsTypedDictTypeArg = AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.enableExperimentalFeatures &&
+                    types_1.ClassType.isBuiltIn(concreteSubtype, 'TypedDict');
                 let typeArgs = getTypeArgs(node, flags, {
                     isAnnotatedClass,
                     hasCustomClassGetItem: hasCustomClassGetItem || !isGenericClass,
                     isFinalAnnotation,
                     isClassVarAnnotation,
+                    supportsTypedDictTypeArg,
                 });
                 if (!isAnnotatedClass) {
                     typeArgs = adjustTypeArgsForTypeVarTuple(typeArgs, concreteSubtype.shared.typeParams, node);
@@ -5586,7 +5628,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 };
             }
             else {
-                typeResult = getTypeArg(expr, adjFlags);
+                typeResult = getTypeArg(expr, adjFlags, !!(options === null || options === void 0 ? void 0 : options.supportsTypedDictTypeArg) && argIndex === 0);
             }
             return typeResult;
         };
@@ -5664,7 +5706,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return undefined;
     }
-    function getTypeArg(node, flags) {
+    function getTypeArg(node, flags, supportsDictExpression) {
         let typeResult;
         let adjustedFlags = flags | 128 /* EvalFlags.InstantiableType */ | 1 /* EvalFlags.ConvertEllipsisToAny */ | 8 /* EvalFlags.StrLiteralAsType */;
         const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
@@ -5682,6 +5724,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // Set the node's type so it isn't reevaluated later.
             setTypeResultForNode(node, { type: types_1.UnknownType.create() });
         }
+        else if (node.nodeType === 18 /* ParseNodeType.Dictionary */ && supportsDictExpression) {
+            const inlinedTypeDict = typedDictClass && (0, types_1.isInstantiableClass)(typedDictClass)
+                ? (0, typedDicts_1.createTypedDictTypeInlined)(evaluatorInterface, node, typedDictClass)
+                : undefined;
+            const keyTypeFallback = strClass && (0, types_1.isInstantiableClass)(strClass) ? strClass : types_1.UnknownType.create();
+            typeResult = {
+                type: keyTypeFallback,
+                inlinedTypeDict,
+                node,
+            };
+        }
         else {
             typeResult = { ...getTypeOfExpression(node, adjustedFlags), node };
             if (node.nodeType === 18 /* ParseNodeType.Dictionary */) {
@@ -6192,7 +6245,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (bindToType &&
                 types_1.ClassType.isProtocolClass(bindToType) &&
                 effectiveTargetClass &&
-                !types_1.ClassType.isSameGenericClass(bindToType, effectiveTargetClass)) {
+                !types_1.ClassType.isSameGenericClass(types_1.TypeBase.isInstance(bindToType) ? types_1.ClassType.cloneAsInstantiable(bindToType) : bindToType, effectiveTargetClass)) {
                 isProtocolClass = true;
                 effectiveTargetClass = undefined;
             }
@@ -6248,7 +6301,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // class.
             if (bindToType) {
                 let nextBaseClassType;
-                if (types_1.ClassType.isSameGenericClass(bindToType, concreteTargetClassType)) {
+                if (types_1.ClassType.isSameGenericClass(types_1.TypeBase.isInstance(bindToType) ? types_1.ClassType.cloneAsInstantiable(bindToType) : bindToType, concreteTargetClassType)) {
                     if (bindToType.shared.baseClasses.length > 0) {
                         nextBaseClassType = bindToType.shared.baseClasses[0];
                     }
@@ -8811,7 +8864,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             return { isCompatible: false, argType, isTypeIncomplete, skippedBareTypeVarExpectedType, condition };
         }
         if (!options.skipUnknownArgCheck) {
-            const simplifiedType = (0, types_1.removeUnbound)(argType);
+            const simplifiedType = makeTopLevelTypeVarsConcrete((0, types_1.removeUnbound)(argType));
             const fileInfo = AnalyzerNodeInfo.getFileInfo(argParam.errorNode);
             function getDiagAddendum() {
                 const diagAddendum = new diagnostic_1.DiagnosticAddendum();
@@ -9475,7 +9528,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if ((0, typeUtils_1.isNoneInstance)(subtype)) {
                 if (objectClass && (0, types_1.isInstantiableClass)(objectClass)) {
                     // Use 'object' for 'None'.
-                    return handleSubtype((0, typeUtils_1.convertToInstance)(objectClass));
+                    return handleSubtype(types_1.ClassType.cloneAsInstance(objectClass));
                 }
             }
             if ((0, typeUtils_1.isNoneTypeClass)(subtype)) {
@@ -12019,6 +12072,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     }
                     argType = (0, typeUtils_1.stripTypeFormRecursive)(argType);
                     if (!(0, types_1.isAnyOrUnknown)(argType) && !(0, types_1.isUnbound)(argType)) {
+                        // If the specified base class is type(T), use the metaclass
+                        // of T if it's known.
+                        if ((0, types_1.isClass)(argType) &&
+                            types_1.TypeBase.getInstantiableDepth(argType) > 0 &&
+                            argType.shared.effectiveMetaclass &&
+                            (0, types_1.isClass)(argType.shared.effectiveMetaclass)) {
+                            argType = argType.shared.effectiveMetaclass;
+                        }
                         if ((0, typeUtils_1.isMetaclassInstance)(argType)) {
                             (0, debug_1.assert)((0, types_1.isClassInstance)(argType));
                             argType =
@@ -12125,8 +12186,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                                     if (protocolTypeParams) {
                                         addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.duplicateGenericAndProtocolBase(), arg.d.valueExpr);
                                     }
-                                    genericTypeParams = [];
-                                    (0, typeUtils_1.addTypeVarsToListIfUnique)(genericTypeParams, (0, typeUtils_1.getTypeVarArgsRecursive)(argType));
+                                    genericTypeParams = buildTypeParamsFromTypeArgs(argType);
                                 }
                             }
                         }
@@ -12137,8 +12197,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                                 if (genericTypeParams) {
                                     addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.duplicateGenericAndProtocolBase(), arg.d.valueExpr);
                                 }
-                                protocolTypeParams = [];
-                                (0, typeUtils_1.addTypeVarsToListIfUnique)(protocolTypeParams, (0, typeUtils_1.getTypeVarArgsRecursive)(argType));
+                                protocolTypeParams = buildTypeParamsFromTypeArgs(argType);
                                 if (node.d.typeParams && protocolTypeParams.length > 0) {
                                     addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.protocolBaseClassWithTypeArgs(), arg.d.valueExpr);
                                     protocolTypeParams = [];
@@ -12336,11 +12395,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             // Determine the effective metaclass.
             if (metaclassNode) {
-                const metaclassType = getTypeOfExpression(metaclassNode, exprFlags).type;
+                let metaclassType = getTypeOfExpression(metaclassNode, exprFlags).type;
                 if ((0, types_1.isInstantiableClass)(metaclassType) || (0, types_1.isUnknown)(metaclassType)) {
                     if ((0, typeUtils_1.requiresSpecialization)(metaclassType, { ignorePseudoGeneric: true })) {
                         addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.metaclassIsGeneric(), metaclassNode);
                     }
+                    // If the specified metaclass is type(T), use the metaclass
+                    // of T if it's known.
+                    if (types_1.TypeBase.getInstantiableDepth(metaclassType) > 0 &&
+                        (0, types_1.isClass)(metaclassType) &&
+                        metaclassType.shared.effectiveMetaclass &&
+                        (0, types_1.isClass)(metaclassType.shared.effectiveMetaclass)) {
+                        metaclassType = metaclassType.shared.effectiveMetaclass;
+                    }
                     classType.shared.declaredMetaclass = metaclassType;
                     if ((0, types_1.isInstantiableClass)(metaclassType)) {
                         if ((0, enums_1.isEnumMetaclass)(metaclassType)) {
@@ -12487,6 +12554,22 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             return { classType, decoratedType };
         });
     }
+    function buildTypeParamsFromTypeArgs(classType) {
+        var _a;
+        const typeParams = [];
+        const typeArgs = (_a = classType.priv.typeArgs) !== null && _a !== void 0 ? _a : [];
+        typeArgs.forEach((typeArg, index) => {
+            if ((0, types_1.isTypeVar)(typeArg)) {
+                typeParams.push(typeArg);
+                return;
+            }
+            // Synthesize a dummy type parameter.
+            const typeVar = types_1.TypeVarType.createInstance(`__P${index}`);
+            typeVar.shared.isSynthesized = true;
+            typeParams.push(typeVar);
+        });
+        return typeParams;
+    }
     // Determines whether the type parameters has a default that refers to another
     // type parameter. If so, validates that it is in the list of "live" type
     // parameters and updates the scope of the type parameter referred to in the
@@ -13618,6 +13701,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
                 writeTypeCache(node.d.suite, { type: inferredReturnType, isIncomplete }, 0 /* EvalFlags.None */);
             }
+            catch (err) {
+                // Attempt to handle a stack overflow without crashing. In rare
+                // cases, we can get very deep stacks when inferring return types
+                // within untyped code.
+                if ((err === null || err === void 0 ? void 0 : err.message) === 'Maximum call stack size exceeded') {
+                    const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
+                    console.error(`Overflowed stack when inferring return type for function: ${node.d.name.d.value} in file ${fileInfo.fileUri.toUserVisibleString()}`);
+                    return;
+                }
+                throw err;
+            }
             finally {
                 functionRecursionMap.delete(node.id);
             }
@@ -14628,7 +14722,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
                 case 'TypedDict': {
                     if ((flags & (67108864 /* EvalFlags.NoNonTypeSpecialForms */ | 256 /* EvalFlags.TypeExpression */)) !== 0) {
-                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typedDictNotAllowed(), errorNode);
+                        const isInlinedTypedDict = AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.enableExperimentalFeatures &&
+                            !!typeArgs;
+                        if (!isInlinedTypedDict) {
+                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typedDictNotAllowed(), errorNode);
+                        }
                     }
                     isValidTypeForm = false;
                     break;
@@ -14744,7 +14842,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (firstDefaultParamIndex >= 0) {
                 minTypeArgCount = firstDefaultParamIndex;
             }
-            if (typeArgCount > typeParams.length) {
+            // Classes that accept inlined type dict type args allow only one.
+            if (typeArgs.length > 0 && typeArgs[0].inlinedTypeDict) {
+                if (typeArgs.length > 1) {
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeArguments, localize_1.LocMessage.typeArgsTooMany().format({
+                        name: classType.priv.aliasName || classType.shared.name,
+                        expected: 1,
+                        received: typeArgCount,
+                    }), typeArgs[1].node);
+                }
+                return { type: typeArgs[0].inlinedTypeDict };
+            }
+            else if (typeArgCount > typeParams.length) {
                 if (!types_1.ClassType.isPartiallyEvaluated(classType) && !types_1.ClassType.isTupleClass(classType)) {
                     if (typeParams.length === 0) {
                         isValidTypeForm = false;
@@ -15635,12 +15744,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             ((_c = declaration.node.parent) === null || _c === void 0 ? void 0 : _c.nodeType) === 35 /* ParseNodeType.MemberAccess */
                             ? declaration.node.parent
                             : declaration.node;
+                        const allowClassVar = ParseTreeUtils.isClassVarAllowedForAssignmentTarget(declNode);
+                        const allowFinal = ParseTreeUtils.isFinalAllowedForAssignmentTarget(declNode);
+                        const allowRequired = ParseTreeUtils.isRequiredAllowedForAssignmentTarget(declNode) ||
+                            !!declaration.isInInlinedTypedDict;
                         declaredType = getTypeOfAnnotation(typeAnnotationNode, {
                             varTypeAnnotation: true,
-                            allowClassVar: ParseTreeUtils.isClassVarAllowedForAssignmentTarget(declNode),
-                            allowFinal: ParseTreeUtils.isFinalAllowedForAssignmentTarget(declNode),
-                            allowRequired: ParseTreeUtils.isRequiredAllowedForAssignmentTarget(declNode),
-                            allowReadOnly: ParseTreeUtils.isRequiredAllowedForAssignmentTarget(declNode),
+                            allowClassVar,
+                            allowFinal,
+                            allowRequired,
+                            allowReadOnly: allowRequired,
                             enforceClassTypeVarScope: declaration.isDefinedByMemberAccess,
                         });
                     }
@@ -17098,7 +17211,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 errorSource = localize_1.LocAddendum.typeVarIsCovariant;
             }
             else if (variance === 4 /* Variance.Contravariant */) {
-                effectiveFlags = (flags ^ 2 /* AssignTypeFlags.Contravariant */) | 256 /* AssignTypeFlags.RetainLiteralsForTypeVar */;
+                effectiveFlags = flags | 2 /* AssignTypeFlags.Contravariant */ | 256 /* AssignTypeFlags.RetainLiteralsForTypeVar */;
                 errorSource = localize_1.LocAddendum.typeVarIsContravariant;
             }
             else {
@@ -17467,7 +17580,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 // the metaclass of the instantiable dest type.
                 const destMetaclass = destType.shared.effectiveMetaclass;
                 if (destMetaclass && (0, types_1.isInstantiableClass)(destMetaclass)) {
-                    if (assignClass(types_1.ClassType.cloneAsInstance(destMetaclass), expandedSrcType, diag, constraints, flags, recursionCount, 
+                    if (assignClass(destMetaclass, types_1.ClassType.cloneAsInstantiable(expandedSrcType), diag, constraints, flags, recursionCount, 
                     /* reportErrorsUsingObjType */ false)) {
                         return true;
                     }
@@ -17588,9 +17701,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     if ((0, types_1.isAnyOrUnknown)(metaclass)) {
                         return true;
                     }
-                    else {
-                        return assignClass(types_1.ClassType.cloneAsInstantiable(destType), metaclass, diag, constraints, flags, recursionCount, 
-                        /* reportErrorsUsingObjType */ false);
+                    if (assignClass(types_1.ClassType.cloneAsInstantiable(destType), metaclass, 
+                    /* diag */ undefined, constraints, flags, recursionCount, 
+                    /* reportErrorsUsingObjType */ true)) {
+                        return true;
                     }
                 }
             }
@@ -19151,6 +19265,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         var _a, _b;
         const baseParamDetails = (0, parameterUtils_1.getParamListDetails)(baseMethod);
         const overrideParamDetails = (0, parameterUtils_1.getParamListDetails)(overrideMethod);
+        const constraints = new constraintTracker_1.ConstraintTracker();
         let canOverride = true;
         if (!types_1.FunctionType.isGradualCallableForm(baseMethod) && !types_1.FunctionType.isGradualCallableForm(overrideMethod)) {
             // Verify that we're not overriding a static, class or instance method with
@@ -19183,8 +19298,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 else {
                     const overrideArgsType = overrideParamDetails.params[overrideParamDetails.argsIndex].type;
                     for (let i = overrideParamDetails.positionParamCount; i < baseParamDetails.positionParamCount; i++) {
-                        if (!assignType(overrideArgsType, baseParamDetails.params[i].type, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), 
-                        /* constraints */ undefined, 0 /* AssignTypeFlags.Default */)) {
+                        if (!assignType(overrideArgsType, baseParamDetails.params[i].type, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), constraints, 2 /* AssignTypeFlags.Contravariant */)) {
                             localize_1.LocAddendum.overrideParamType().format({
                                 index: i + 1,
                                 baseType: printType(baseParamDetails.params[i].type),
@@ -19273,8 +19387,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     const overrideIsSynthesizedTypeVar = (0, types_1.isTypeVar)(overrideParamType) && overrideParamType.shared.isSynthesized;
                     if (!exemptSelfClsParam || (!baseIsSynthesizedTypeVar && !overrideIsSynthesizedTypeVar)) {
                         if (baseParam.category !== overrideParam.category ||
-                            !assignType(overrideParamType, baseParamType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), 
-                            /* constraints */ undefined, 0 /* AssignTypeFlags.Default */)) {
+                            !assignType(overrideParamType, baseParamType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), constraints, 2 /* AssignTypeFlags.Contravariant */)) {
                             diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.overrideParamType().format({
                                 index: i + 1,
                                 baseType: printType(baseParamType),
@@ -19316,8 +19429,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 else {
                     const overrideParamType = overrideParamDetails.params[overrideParamDetails.argsIndex].type;
                     const baseParamType = baseParamDetails.params[baseParamDetails.argsIndex].type;
-                    if (!assignType(overrideParamType, baseParamType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), 
-                    /* constraints */ undefined, 0 /* AssignTypeFlags.Default */)) {
+                    if (!assignType(overrideParamType, baseParamType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), constraints, 2 /* AssignTypeFlags.Contravariant */)) {
                         diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.overrideParamKeywordType().format({
                             name: (_b = overrideParamDetails.params[overrideParamDetails.argsIndex].param.name) !== null && _b !== void 0 ? _b : '?',
                             baseType: printType(baseParamType),
@@ -19344,8 +19456,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     if (!targetParamType) {
                         targetParamType = overrideParamDetails.params[overrideParamDetails.kwargsIndex].type;
                     }
-                    if (!assignType(targetParamType, paramInfo.type, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), 
-                    /* constraints */ undefined, 0 /* AssignTypeFlags.Default */)) {
+                    if (!assignType(targetParamType, paramInfo.type, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), constraints, 2 /* AssignTypeFlags.Contravariant */)) {
                         diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.overrideParamKeywordType().format({
                             name: (_b = paramInfo.param.name) !== null && _b !== void 0 ? _b : '?',
                             baseType: printType(paramInfo.type),
@@ -19402,9 +19513,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         // Now check the return type.
         const baseReturnType = getEffectiveReturnType(baseMethod);
-        const overrideReturnType = getEffectiveReturnType(overrideMethod);
-        if (!assignType(baseReturnType, overrideReturnType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), 
-        /* constraints */ undefined, 0 /* AssignTypeFlags.Default */)) {
+        const overrideReturnType = solveAndApplyConstraints(getEffectiveReturnType(overrideMethod), constraints);
+        if (!assignType(baseReturnType, overrideReturnType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), constraints, 0 /* AssignTypeFlags.Default */)) {
             diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.overrideReturnType().format({
                 baseType: printType(baseReturnType),
                 overrideType: printType(overrideReturnType),