@zzzen/pyright-internal 1.2.0-dev.20240804 → 1.2.0-dev.20240811

package/dist/analyzer/typeEvaluator.js

@@ -38,7 +38,8 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createTypeEvaluator = exports.maxCodeComplexity = void 0;
+exports.maxCodeComplexity = void 0;
+exports.createTypeEvaluator = createTypeEvaluator;
 const cancellationUtils_1 = require("../common/cancellationUtils");
 const collectionUtils_1 = require("../common/collectionUtils");
 const debug_1 = require("../common/debug");
@@ -571,8 +572,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 const diag = new diagnostic_1.DiagnosticAddendum();
                 // Make sure the resulting type is assignable to the expected type.
                 if (!assignType(inferenceContext.expectedType, typeResult.type, diag, 
-                /* destConstraints */ undefined, 
-                /* srcConstraints */ undefined, 0 /* AssignTypeFlags.Default */)) {
+                /* constraints */ undefined, 0 /* AssignTypeFlags.Default */)) {
                     typeResult.typeErrors = true;
                     typeResult.expectedTypeDiagAddendum = diag;
                     diag.addTextRange(node);
@@ -1123,7 +1123,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 return (0, types_1.findSubtype)(type, (subtype) => canBeFalsy(subtype, recursionCount)) !== undefined;
             }
             case 4 /* TypeCategory.Function */:
-            case 5 /* TypeCategory.OverloadedFunction */:
+            case 5 /* TypeCategory.Overloaded */:
             case 7 /* TypeCategory.Module */:
             case 9 /* TypeCategory.TypeVar */: {
                 return false;
@@ -1142,9 +1142,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     return (0, typeUtils_1.isUnboundedTupleClass)(tupleBaseClass) || tupleBaseClass.priv.tupleTypeArgs.length === 0;
                 }
                 // Check for bool, int, str and bytes literals that are never falsy.
-                if (type.priv.literalValue !== undefined &&
-                    types_1.ClassType.isBuiltIn(type, ['bool', 'int', 'str', 'bytes'])) {
-                    return !type.priv.literalValue || type.priv.literalValue === BigInt(0);
+                if (type.priv.literalValue !== undefined) {
+                    if (types_1.ClassType.isBuiltIn(type, ['bool', 'int', 'str', 'bytes'])) {
+                        return !type.priv.literalValue || type.priv.literalValue === BigInt(0);
+                    }
+                    if (type.priv.literalValue instanceof types_1.EnumLiteral) {
+                        // Does the Enum class forward the truthiness check to the
+                        // underlying member type?
+                        if (type.priv.literalValue.isReprEnum) {
+                            return canBeFalsy(type.priv.literalValue.itemType, recursionCount);
+                        }
+                    }
                 }
                 // If this is a protocol class, don't make any assumptions about the absence
                 // of specific methods. These could be provided by a class that conforms
@@ -1189,7 +1197,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         switch (type.category) {
             case 1 /* TypeCategory.Unknown */:
             case 4 /* TypeCategory.Function */:
-            case 5 /* TypeCategory.OverloadedFunction */:
+            case 5 /* TypeCategory.Overloaded */:
             case 7 /* TypeCategory.Module */:
             case 9 /* TypeCategory.TypeVar */:
             case 3 /* TypeCategory.Never */:
@@ -1214,9 +1222,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     return false;
                 }
                 // Check for bool, int, str and bytes literals that are never falsy.
-                if (type.priv.literalValue !== undefined &&
-                    types_1.ClassType.isBuiltIn(type, ['bool', 'int', 'str', 'bytes'])) {
-                    return !!type.priv.literalValue && type.priv.literalValue !== BigInt(0);
+                if (type.priv.literalValue !== undefined) {
+                    if (types_1.ClassType.isBuiltIn(type, ['bool', 'int', 'str', 'bytes'])) {
+                        return !!type.priv.literalValue && type.priv.literalValue !== BigInt(0);
+                    }
+                    if (type.priv.literalValue instanceof types_1.EnumLiteral) {
+                        // Does the Enum class forward the truthiness check to the
+                        // underlying member type?
+                        if (type.priv.literalValue.isReprEnum) {
+                            return canBeTruthy(type.priv.literalValue.itemType, recursionCount);
+                        }
+                    }
                 }
                 // If this is a protocol class, don't make any assumptions about the absence
                 // of specific methods. These could be provided by a class that conforms
@@ -1344,9 +1360,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         });
     }
     function solveAndApplyConstraints(type, constraints, applyOptions, solveOptions) {
-        if (solveOptions === null || solveOptions === void 0 ? void 0 : solveOptions.applyUnificationVars) {
-            (0, constraintSolver_1.applyUnificationVars)(evaluatorInterface, constraints);
-        }
         const solution = (0, constraintSolver_1.solveConstraints)(evaluatorInterface, constraints, solveOptions);
         return (0, typeUtils_1.applySolvedTypeVars)(type, solution, applyOptions);
     }
@@ -1484,7 +1497,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (!boundMethodResult || boundMethodResult.typeErrors) {
             return undefined;
         }
-        if ((0, types_1.isFunction)(boundMethodResult.type) || (0, types_1.isOverloadedFunction)(boundMethodResult.type)) {
+        if ((0, types_1.isFunction)(boundMethodResult.type) || (0, types_1.isOverloaded)(boundMethodResult.type)) {
             return boundMethodResult.type;
         }
         if ((0, types_1.isClassInstance)(boundMethodResult.type)) {
@@ -1557,7 +1570,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 addOneFunctionToSignature(type);
             }
             else {
-                types_1.OverloadedFunctionType.getOverloads(type).forEach((func) => {
+                types_1.OverloadedType.getOverloads(type).forEach((func) => {
                     addOneFunctionToSignature(func);
                 });
             }
@@ -1565,7 +1578,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         (0, typeUtils_1.doForEachSubtype)(callType, (subtype) => {
             switch (subtype.category) {
                 case 4 /* TypeCategory.Function */:
-                case 5 /* TypeCategory.OverloadedFunction */: {
+                case 5 /* TypeCategory.Overloaded */: {
                     addFunctionToSignature(subtype);
                     break;
                 }
@@ -1574,7 +1587,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         const constructorType = (0, constructors_1.createFunctionFromConstructor)(evaluatorInterface, subtype);
                         if (constructorType) {
                             (0, typeUtils_1.doForEachSubtype)(constructorType, (subtype) => {
-                                if ((0, types_1.isFunction)(subtype) || (0, types_1.isOverloadedFunction)(subtype)) {
+                                if ((0, types_1.isFunction)(subtype) || (0, types_1.isOverloaded)(subtype)) {
                                     addFunctionToSignature(subtype);
                                 }
                             });
@@ -1629,7 +1642,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         const kwSeparatorIndex = functionType.shared.parameters.findIndex((param) => param.category === 1 /* ParamCategory.ArgsList */);
         // Add a keyword separator if necessary.
-        if (kwSeparatorIndex < 0) {
+        if (kwSeparatorIndex < 0 && tdEntries.size > 0) {
             types_1.FunctionType.addKeywordOnlyParamSeparator(newFunction);
         }
         tdEntries.forEach((tdEntry, name) => {
@@ -1747,7 +1760,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     if (memberAccessClass && (0, types_1.isInstantiableClass)(memberAccessClass)) {
                         declaredType = (0, typeUtils_1.partiallySpecializeType)(declaredType, memberAccessClass, getTypeClassType());
                     }
-                    if ((0, types_1.isFunction)(declaredType) || (0, types_1.isOverloadedFunction)(declaredType)) {
+                    if ((0, types_1.isFunction)(declaredType) || (0, types_1.isOverloaded)(declaredType)) {
                         if (bindFunction) {
                             declaredType = bindFunctionToClassOrObject(classOrObjectBase, declaredType);
                         }
@@ -2726,6 +2739,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 if (variance !== 3 /* Variance.Covariant */) {
                     return typeArg;
                 }
+                // Don't expand recursive type aliases because they can
+                // cause infinite recursion.
+                if ((0, types_1.isTypeVar)(typeArg) && typeArg.shared.recursiveAlias) {
+                    return typeArg;
+                }
                 const filteredTypeArg = mapSubtypesExpandTypeVars(typeArg, { conditionFilter }, (expandedSubtype) => {
                     return expandedSubtype;
                 }, recursionCount);
@@ -3776,7 +3794,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             if (isModuleGetAttrSupported) {
                                 const getAttrTypeResult = getEffectiveTypeOfSymbolForUsage(getAttrSymbol);
                                 if ((0, types_1.isFunction)(getAttrTypeResult.type)) {
-                                    type = getFunctionEffectiveReturnType(getAttrTypeResult.type);
+                                    type = getEffectiveReturnType(getAttrTypeResult.type);
                                     if (getAttrTypeResult.isIncomplete) {
                                         isIncomplete = true;
                                     }
@@ -3841,12 +3859,22 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 break;
             }
             case 4 /* TypeCategory.Function */:
-            case 5 /* TypeCategory.OverloadedFunction */: {
+            case 5 /* TypeCategory.Overloaded */: {
                 if (memberName === '__self__') {
                     // The "__self__" member is not currently defined in the "function"
                     // class, so we'll special-case it here.
-                    const functionType = (0, types_1.isFunction)(baseType) ? baseType : baseType.priv.overloads[0];
-                    if (functionType.priv.preBoundFlags !== undefined &&
+                    let functionType;
+                    if ((0, types_1.isFunction)(baseType)) {
+                        functionType = baseType;
+                    }
+                    else {
+                        const overloads = types_1.OverloadedType.getOverloads(baseType);
+                        if (overloads.length > 0) {
+                            functionType = overloads[0];
+                        }
+                    }
+                    if (functionType &&
+                        functionType.priv.preBoundFlags !== undefined &&
                         (functionType.priv.preBoundFlags & 4 /* FunctionTypeFlags.StaticMethod */) === 0) {
                         type = functionType.priv.boundToType;
                     }
@@ -3863,7 +3891,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // member could not be accessed.
         if (!type) {
             const isFunctionRule = (0, types_1.isFunction)(baseType) ||
-                (0, types_1.isOverloadedFunction)(baseType) ||
+                (0, types_1.isOverloaded)(baseType) ||
                 ((0, types_1.isClassInstance)(baseType) && types_1.ClassType.isBuiltIn(baseType, 'function'));
             if (!baseTypeResult.isIncomplete) {
                 let diagMessage = localize_1.LocMessage.memberAccess();
@@ -4058,7 +4086,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
                 resultType = descResult.type;
             }
-            else if ((0, types_1.isFunction)(concreteSubtype) || (0, types_1.isOverloadedFunction)(concreteSubtype)) {
+            else if ((0, types_1.isFunction)(concreteSubtype) || (0, types_1.isOverloaded)(concreteSubtype)) {
                 const typeResult = bindMethodForMemberAccess(subtype, concreteSubtype, memberInfo, classType, selfType, flags, memberName, usage, diag, recursionCount);
                 resultType = typeResult.type;
                 if (typeResult.typeErrors) {
@@ -4184,7 +4212,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (methodTypeResult.typeErrors || !methodClassType) {
             return { type: types_1.UnknownType.create(), typeErrors: true };
         }
-        if (!(0, types_1.isFunction)(methodType) && !(0, types_1.isOverloadedFunction)(methodType)) {
+        if (!(0, types_1.isFunction)(methodType) && !(0, types_1.isOverloaded)(methodType)) {
             if ((0, types_1.isAnyOrUnknown)(methodType)) {
                 return { type: methodType };
             }
@@ -4228,7 +4256,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 /* diag */ undefined, constraints);
                 accessMethodClass = solveAndApplyConstraints(accessMethodClass, constraints);
                 const specializedType = (0, typeUtils_1.partiallySpecializeType)(methodType, accessMethodClass, getTypeClassType(), selfType ? (0, typeUtils_1.convertToInstantiable)(selfType) : classType);
-                if ((0, types_1.isFunction)(specializedType) || (0, types_1.isOverloadedFunction)(specializedType)) {
+                if ((0, types_1.isFunction)(specializedType) || (0, types_1.isOverloaded)(specializedType)) {
                     methodType = specializedType;
                 }
             }
@@ -4342,10 +4370,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     function bindMethodForMemberAccess(type, concreteType, memberInfo, classType, selfType, flags, memberName, usage, diag, recursionCount = 0) {
         // Check for an attempt to overwrite a final method.
         if (usage.method === 'set') {
-            const impl = (0, types_1.isFunction)(concreteType)
-                ? concreteType
-                : types_1.OverloadedFunctionType.getImplementation(concreteType);
-            if (impl && types_1.FunctionType.isFinal(impl) && memberInfo && (0, types_1.isClass)(memberInfo.classType)) {
+            const impl = (0, types_1.isFunction)(concreteType) ? concreteType : types_1.OverloadedType.getImplementation(concreteType);
+            if (impl && (0, types_1.isFunction)(impl) && types_1.FunctionType.isFinal(impl) && memberInfo && (0, types_1.isClass)(memberInfo.classType)) {
                 diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocMessage.finalMethodOverride().format({
                     name: memberName,
                     className: memberInfo.classType.shared.name,
@@ -4474,7 +4500,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 },
             });
         }
-        if (!(0, types_1.isFunction)(accessMemberType) && !(0, types_1.isOverloadedFunction)(accessMemberType)) {
+        if (!(0, types_1.isFunction)(accessMemberType) && !(0, types_1.isOverloaded)(accessMemberType)) {
             if ((0, types_1.isAnyOrUnknown)(accessMemberType)) {
                 return { type: accessMemberType };
             }
@@ -4717,7 +4743,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 typeArgs = [
                     {
                         type: types_1.UnknownType.create(),
-                        node: typeArgs[0].node,
+                        node: typeArgs.length > 0 ? typeArgs[0].node : node,
                         typeList: typeArgs,
                     },
                 ];
@@ -5288,23 +5314,28 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     function getTypeArgs(node, flags, options) {
         const typeArgs = [];
         let adjFlags = flags | 33554432 /* EvalFlags.NoConvertSpecialForm */;
-        if (options === null || options === void 0 ? void 0 : options.isFinalAnnotation) {
-            adjFlags |= 131072 /* EvalFlags.NoClassVar */ | 16 /* EvalFlags.NoFinal */;
-        }
-        else if (options === null || options === void 0 ? void 0 : options.isClassVarAnnotation) {
-            adjFlags |= 131072 /* EvalFlags.NoClassVar */;
+        const allowFinalClassVar = () => {
             // If the annotation is a variable within the body of a dataclass, a
-            // Final is allowed within the ClassVar annotation. In all other cases,
+            // Final is allowed with a ClassVar annotation. In all other cases,
             // it's disallowed.
-            let disallowFinal = true;
             const enclosingClassNode = ParseTreeUtils.getEnclosingClass(node, /* stopeAtFunction */ true);
             if (enclosingClassNode) {
                 const classTypeInfo = getTypeOfClass(enclosingClassNode);
                 if (classTypeInfo && types_1.ClassType.isDataClass(classTypeInfo.classType)) {
-                    disallowFinal = false;
+                    return true;
                 }
             }
-            if (disallowFinal) {
+            return false;
+        };
+        if (options === null || options === void 0 ? void 0 : options.isFinalAnnotation) {
+            adjFlags |= 16 /* EvalFlags.NoFinal */;
+            if (!allowFinalClassVar()) {
+                adjFlags |= 131072 /* EvalFlags.NoClassVar */;
+            }
+        }
+        else if (options === null || options === void 0 ? void 0 : options.isClassVarAnnotation) {
+            adjFlags |= 131072 /* EvalFlags.NoClassVar */;
+            if (!allowFinalClassVar()) {
                 adjFlags |= 16 /* EvalFlags.NoFinal */;
             }
         }
@@ -6334,7 +6365,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         const speculativeNode = getSpeculativeNodeForCall(errorNode);
         useSignatureTracker(errorNode, () => {
             // Create a list of potential overload matches based on arguments.
-            types_1.OverloadedFunctionType.getOverloads(typeResult.type).forEach((overload) => {
+            types_1.OverloadedType.getOverloads(typeResult.type).forEach((overload) => {
                 useSpeculativeMode(speculativeNode, () => {
                     const matchResults = matchArgsToParams(errorNode, argList, { type: overload, isIncomplete: typeResult.isIncomplete }, overloadIndex);
                     if (!matchResults.argumentErrors) {
@@ -6381,7 +6412,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // cache or record any diagnostics at this stage.
         useSpeculativeMode(speculativeNode, () => {
             let overloadIndex = 0;
-            types_1.OverloadedFunctionType.getOverloads(type).forEach((overload) => {
+            types_1.OverloadedType.getOverloads(type).forEach((overload) => {
                 // Consider only the functions that have the @overload decorator,
                 // not the final function that omits the overload. This is the
                 // intended behavior according to PEP 484.
@@ -6399,7 +6430,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // Skip the error message if we're in speculative mode because it's very
             // expensive, and we're going to suppress the diagnostic anyway.
             if (!canSkipDiagnosticForNode(errorNode)) {
-                const functionName = type.priv.overloads[0].shared.name || '<anonymous function>';
+                const overloads = types_1.OverloadedType.getOverloads(type);
+                const functionName = overloads.length > 0 && overloads[0].shared.name
+                    ? overloads[0].shared.name
+                    : '<anonymous function>';
                 const diagAddendum = new diagnostic_1.DiagnosticAddendum();
                 const argTypes = argList.map((t) => {
                     const typeString = printType(getTypeOfArg(t, /* inferenceContext */ undefined).type);
@@ -6620,8 +6654,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             case 4 /* TypeCategory.Function */: {
                 return validateCallForFunction(errorNode, argList, expandedCallType, isCallTypeIncomplete, constraints, skipUnknownArgCheck, inferenceContext);
             }
-            case 5 /* TypeCategory.OverloadedFunction */: {
-                return validateCallForOverloadedFunction(errorNode, argList, expandedCallType, isCallTypeIncomplete, constraints, skipUnknownArgCheck, inferenceContext);
+            case 5 /* TypeCategory.Overloaded */: {
+                return validateCallForOverloaded(errorNode, argList, expandedCallType, isCallTypeIncomplete, constraints, skipUnknownArgCheck, inferenceContext);
             }
             case 6 /* TypeCategory.Class */: {
                 if ((0, typeUtils_1.isNoneInstance)(expandedCallType)) {
@@ -6776,10 +6810,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return { symbol, symbolName, classType, hasImplementation };
     }
-    function validateCallForOverloadedFunction(errorNode, argList, expandedCallType, isCallTypeIncomplete, constraints, skipUnknownArgCheck, inferenceContext) {
+    function validateCallForOverloaded(errorNode, argList, expandedCallType, isCallTypeIncomplete, constraints, skipUnknownArgCheck, inferenceContext) {
         var _a, _b;
+        const overloads = types_1.OverloadedType.getOverloads(expandedCallType);
         // Handle the 'cast' call as a special case.
-        if (types_1.FunctionType.isBuiltIn(expandedCallType.priv.overloads[0], 'cast') && argList.length === 2) {
+        if (overloads.length > 0 &&
+            types_1.FunctionType.isBuiltIn(overloads[0], ['typing.cast', 'typing_extensions.cast']) &&
+            argList.length === 2) {
             return { returnType: evaluateCastCall(argList, errorNode) };
         }
         const callResult = validateOverloadedArgTypes(errorNode, argList, { type: expandedCallType, isIncomplete: isCallTypeIncomplete }, constraints, skipUnknownArgCheck, inferenceContext);
@@ -6890,7 +6927,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 };
                 const initTypeResult = (0, constructors_1.getBoundInitMethod)(evaluatorInterface, errorNode, types_1.ClassType.cloneAsInstance(expandedCallType), 
                 /* diag */ undefined, 0 /* MemberAccessFlags.Default */);
-                if (initTypeResult && (0, types_1.isOverloadedFunction)(initTypeResult.type)) {
+                if (initTypeResult && (0, types_1.isOverloaded)(initTypeResult.type)) {
                     validateOverloadedArgTypes(errorNode, argList, { type: initTypeResult.type }, 
                     /* constraints */ undefined, skipUnknownArgCheck, 
                     /* inferenceContext */ undefined);
@@ -7240,6 +7277,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             argType.priv.tupleTypeArgs.length > 0) {
                             tooManyPositionals = true;
                         }
+                        else {
+                            matchedUnpackedListOfUnknownLength = true;
+                        }
                     }
                     else {
                         tooManyPositionals = true;
@@ -7495,7 +7535,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
         }
         if (!reportedArgError) {
-            let unpackedDictionaryArgType;
+            let unpackedDictKeyNames;
+            let unpackedDictArgType;
             // Now consume any keyword arguments.
             while (argIndex < argList.length) {
                 if (argList[argIndex].argCategory === 2 /* ArgCategory.UnpackedDictionary */) {
@@ -7506,7 +7547,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         isTypeIncomplete = true;
                     }
                     if ((0, types_1.isAnyOrUnknown)(argType)) {
-                        unpackedDictionaryArgType = argType;
+                        unpackedDictArgType = argType;
                     }
                     else if ((0, types_1.isClassInstance)(argType) && types_1.ClassType.isTypedDictClass(argType)) {
                         // Handle the special case where it is a TypedDict and we know which
@@ -7575,7 +7616,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         }
                     }
                     else if (paramSpec && (0, parameterUtils_1.isParamSpecKwargs)(paramSpec, argType)) {
-                        unpackedDictionaryArgType = types_1.AnyType.create();
+                        unpackedDictArgType = types_1.AnyType.create();
                         if (!paramSpecArgList) {
                             validateArgTypeParams.push({
                                 paramCategory: 2 /* ParamCategory.KwargsDict */,
@@ -7608,20 +7649,29 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                                     if (assignType(strObjType, typeArgs[0])) {
                                         isValidMappingType = true;
                                     }
-                                    unpackedDictionaryArgType = typeArgs[1];
+                                    unpackedDictKeyNames = [];
+                                    (0, typeUtils_1.doForEachSubtype)(typeArgs[0], (keyType) => {
+                                        if ((0, types_1.isClassInstance)(keyType) && typeof keyType.priv.literalValue === 'string') {
+                                            unpackedDictKeyNames === null || unpackedDictKeyNames === void 0 ? void 0 : unpackedDictKeyNames.push(keyType.priv.literalValue);
+                                        }
+                                        else {
+                                            unpackedDictKeyNames = undefined;
+                                        }
+                                    });
+                                    unpackedDictArgType = typeArgs[1];
                                 }
                                 else {
                                     isValidMappingType = true;
-                                    unpackedDictionaryArgType = types_1.UnknownType.create();
+                                    unpackedDictArgType = types_1.UnknownType.create();
                                 }
                             }
-                            if (paramDetails.kwargsIndex !== undefined && unpackedDictionaryArgType) {
+                            if (paramDetails.kwargsIndex !== undefined && unpackedDictArgType) {
                                 const paramType = paramDetails.params[paramDetails.kwargsIndex].type;
                                 validateArgTypeParams.push({
                                     paramCategory: 0 /* ParamCategory.Simple */,
                                     paramType,
                                     requiresTypeVarMatching: (0, typeUtils_1.requiresSpecialization)(paramType),
-                                    argType: unpackedDictionaryArgType,
+                                    argType: unpackedDictArgType,
                                     argument: argList[argIndex],
                                     errorNode: argList[argIndex].valueExpression || errorNode,
                                     paramName: paramDetails.params[paramDetails.kwargsIndex].param.name,
@@ -7748,7 +7798,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             // If there are keyword-only parameters that haven't been matched but we
             // have an unpacked dictionary arg, assume that it applies to them.
-            if (unpackedDictionaryArgType && (!foundUnpackedListArg || paramDetails.argsIndex !== undefined)) {
+            if (unpackedDictArgType && (!foundUnpackedListArg || paramDetails.argsIndex !== undefined)) {
                 // Don't consider any position-only parameters, since they cannot be matched to
                 // **kwargs arguments. Consider parameters that are either positional or keyword
                 // if there is no *args argument.
@@ -7761,19 +7811,21 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         paramMap.has(param.name) &&
                         paramMap.get(param.name).argsReceived === 0) {
                         const paramType = paramDetails.params[paramIndex].type;
-                        validateArgTypeParams.push({
-                            paramCategory: 0 /* ParamCategory.Simple */,
-                            paramType,
-                            requiresTypeVarMatching: (0, typeUtils_1.requiresSpecialization)(paramType),
-                            argument: {
-                                argCategory: 0 /* ArgCategory.Simple */,
-                                typeResult: { type: unpackedDictionaryArgType },
-                            },
-                            errorNode: (_b = (_a = argList.find((arg) => arg.argCategory === 2 /* ArgCategory.UnpackedDictionary */)) === null || _a === void 0 ? void 0 : _a.valueExpression) !== null && _b !== void 0 ? _b : errorNode,
-                            paramName: param.name,
-                            isParamNameSynthesized: types_1.FunctionParam.isNameSynthesized(param),
-                        });
-                        paramMap.get(param.name).argsReceived = 1;
+                        if (!unpackedDictKeyNames || unpackedDictKeyNames.includes(param.name)) {
+                            validateArgTypeParams.push({
+                                paramCategory: 0 /* ParamCategory.Simple */,
+                                paramType,
+                                requiresTypeVarMatching: (0, typeUtils_1.requiresSpecialization)(paramType),
+                                argument: {
+                                    argCategory: 0 /* ArgCategory.Simple */,
+                                    typeResult: { type: unpackedDictArgType },
+                                },
+                                errorNode: (_b = (_a = argList.find((arg) => arg.argCategory === 2 /* ArgCategory.UnpackedDictionary */)) === null || _a === void 0 ? void 0 : _a.valueExpression) !== null && _b !== void 0 ? _b : errorNode,
+                                paramName: param.name,
+                                isParamNameSynthesized: types_1.FunctionParam.isNameSynthesized(param),
+                            });
+                            paramMap.get(param.name).argsReceived = 1;
+                        }
                     }
                 });
             }
@@ -7781,7 +7833,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // but have not yet received them. If we received a dictionary argument
             // (i.e. an arg starting with a "**"), we will assume that all parameters
             // are matched.
-            if (!unpackedDictionaryArgType && !types_1.FunctionType.isDefaultParamCheckDisabled(overload)) {
+            if (!unpackedDictArgType && !types_1.FunctionType.isDefaultParamCheckDisabled(overload)) {
                 const unassignedParams = Array.from(paramMap.keys()).filter((name) => {
                     const entry = paramMap.get(name);
                     return !entry || entry.argsReceived < entry.argsNeeded;
@@ -7933,7 +7985,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         let expectedType = inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.expectedType;
         // Can we safely ignore the inference context, either because it's not provided
         // or will have no effect? If so, avoid the extra work.
-        const returnType = (_a = inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.returnTypeOverride) !== null && _a !== void 0 ? _a : getFunctionEffectiveReturnType(type);
+        const returnType = (_a = inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.returnTypeOverride) !== null && _a !== void 0 ? _a : getEffectiveReturnType(type);
         if (!returnType || !(0, typeUtils_1.requiresSpecialization)(returnType)) {
             expectedType = undefined;
         }
@@ -7950,8 +8002,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     : callResult.returnType;
                 if (assignType(expectedSubtype, returnType, 
                 /* diag */ undefined, 
-                /* destConstraints */ undefined, 
-                /* srcConstraints */ undefined, 0 /* AssignTypeFlags.Default */)) {
+                /* constraints */ undefined, 0 /* AssignTypeFlags.Default */)) {
                     const anyOrUnknown = (0, typeUtils_1.containsAnyOrUnknown)(callResult.returnType, /* recurse */ true);
                     // Prefer return types that have no unknown or Any.
                     if (!anyOrUnknown) {
@@ -8003,7 +8054,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     }
     function validateArgTypesWithExpectedType(errorNode, matchResults, constraints, skipUnknownArgCheck = false, expectedType, returnType) {
         const liveTypeVarScopes = ParseTreeUtils.getTypeVarScopesForNode(errorNode);
-        let assignFlags = 2048 /* AssignTypeFlags.PopulatingExpectedType */;
+        let assignFlags = 2048 /* AssignTypeFlags.PopulateExpectedType */;
         if ((0, typeUtils_1.containsLiteralType)(expectedType, /* includeTypeArgs */ true)) {
             assignFlags |= 256 /* AssignTypeFlags.RetainLiteralsForTypeVar */;
         }
@@ -8026,9 +8077,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
         }
         expectedType = (0, typeUtils_1.transformExpectedType)(expectedType, liveTypeVarScopes, errorNode.start);
-        assignType(returnType, expectedType, 
-        /* diag */ undefined, constraints, 
-        /* srcConstraints */ undefined, assignFlags);
+        assignType(returnType, expectedType, /* diag */ undefined, constraints, assignFlags);
         return validateArgTypes(errorNode, matchResults, constraints, skipUnknownArgCheck);
     }
     function validateArgTypes(errorNode, matchResults, constraints, skipUnknownArgCheck) {
@@ -8072,38 +8121,28 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         // Special-case a few built-in calls that are often used for
         // casting or checking for unknown types.
-        if (types_1.FunctionType.isBuiltIn(type, ['cast', 'isinstance', 'issubclass'])) {
+        if (types_1.FunctionType.isBuiltIn(type, [
+            'typing.cast',
+            'typing_extensions.cast',
+            'builtins.isinstance',
+            'builtins.issubclass',
+        ])) {
             skipUnknownArgCheck = true;
         }
         // Run through all args and validate them against their matched parameter.
-        // We'll do two passes. The first one will match any type arguments. The second
-        // will perform the actual validation. We can skip the first pass if there
-        // are no type vars to match.
-        const typeVarMatchingCount = matchResults.argParams.filter((arg) => arg.requiresTypeVarMatching).length;
-        if (typeVarMatchingCount > 0) {
-            // In theory, we may need to do up to n passes where n is the number of
-            // arguments that need type var matching. That's because later matches
-            // can provide bidirectional type hints for earlier matches. The best
-            // example of this is the built-in "map" method whose first parameter is
-            // a lambda and second parameter indicates what type the lambda should accept.
-            // In practice, we will limit the number of passes to 2 because it can get
-            // very expensive to go beyond this, and we don't generally see cases
-            // where more than two passes are needed.
-            let passCount = Math.min(typeVarMatchingCount, 2);
+        // We'll do two phases. The first one establishes constraints for type
+        // variables. The second perform type validation using the solved
+        // types. We can skip the first pass if there are no type vars to solve.
+        const typeVarCount = matchResults.argParams.filter((arg) => arg.requiresTypeVarMatching).length;
+        if (typeVarCount > 0) {
+            // Do up to two passes.
+            let passCount = Math.min(typeVarCount, 2);
             for (let i = 0; i < passCount; i++) {
                 useSpeculativeMode(speculativeNode, () => {
                     matchResults.argParams.forEach((argParam) => {
                         if (!argParam.requiresTypeVarMatching) {
                             return;
                         }
-                        // Populate the constraints for the argument. If the argument
-                        // is an overload function, skip it during the first pass
-                        // because the selection of the proper overload may depend
-                        // on type arguments supplied by other function arguments.
-                        // If the param type is a "bare" TypeVar, don't use it as an
-                        // expected type during the first pass. This causes problems for
-                        // cases where the the call expression result can influence the
-                        // type of the TypeVar, such as in the expression "min(1, max(2, 0.5))".
                         const argResult = validateArgType(argParam, constraints, { type, isIncomplete: matchResults.isTypeIncomplete }, {
                             skipUnknownArgCheck,
                             isArgFirstPass: passCount > 1 && i === 0,
@@ -8113,9 +8152,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         if (argResult.isTypeIncomplete) {
                             isTypeIncomplete = true;
                         }
-                        // If we skipped an overload arg or a bare type var during the first pass,
-                        // add another pass to ensure that we handle all of the type variables.
-                        if (i === 0 && (argResult.skippedOverloadArg || argResult.skippedBareTypeVarExpectedType)) {
+                        // If we skipped a bare type var during the first pass, add
+                        // another pass to ensure that we handle all of the type variables.
+                        if (i === 0 && passCount < 2 && argResult.skippedBareTypeVarExpectedType) {
                             passCount++;
                         }
                     });
@@ -8187,7 +8226,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
         }
         // Calculate the return type.
-        let returnType = getFunctionEffectiveReturnType(type, { args: matchResults.argParams, errorNode });
+        let returnType = getEffectiveReturnType(type, {
+            callSiteInfo: { args: matchResults.argParams, errorNode },
+        });
         if (condition.length > 0) {
             returnType = types_1.TypeBase.cloneForCondition(returnType, condition);
         }
@@ -8195,7 +8236,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // If the function is returning a callable, don't eliminate unsolved
         // type vars within a union. There are legit uses for unsolved type vars
         // within a callable.
-        if ((0, types_1.isFunction)(returnType) || (0, types_1.isOverloadedFunction)(returnType)) {
+        if ((0, types_1.isFunction)(returnType) || (0, types_1.isOverloaded)(returnType)) {
             eliminateUnsolvedInUnions = false;
         }
         let specializedReturnType = solveAndApplyConstraints(returnType, constraints, {
@@ -8205,7 +8246,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 tupleClassType: getTupleClassType(),
                 eliminateUnsolvedInUnions,
             },
-        }, { applyUnificationVars: true });
+        });
         specializedReturnType = (0, typeUtils_1.addConditionToType)(specializedReturnType, typeCondition);
         // If the function includes a ParamSpec and the captured signature(s) includes
         // generic types, we may need to apply those solved TypeVars.
@@ -8216,7 +8257,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     // It's possible that one or more of the TypeVars or ParamSpecs
                     // in the constraints refer to TypeVars that were solved in
                     // the paramSpecConstraints. Apply these solved TypeVars accordingly.
-                    (0, typeUtils_1.applySourceContextTypeVars)(constraints, (0, constraintSolver_1.solveConstraints)(evaluatorInterface, paramSpecConstraints));
+                    (0, constraintSolver_1.applySourceSolutionToConstraints)(constraints, (0, constraintSolver_1.solveConstraints)(evaluatorInterface, paramSpecConstraints));
                 }
             });
         }
@@ -8274,18 +8315,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // need to make this more sophisticated in the future.
     function adjustCallableReturnType(callableType, returnType, liveTypeVarScopes) {
         var _a, _b;
-        if ((0, types_1.isFunction)(returnType) && !returnType.shared.name && callableType.shared.typeVarScopeId) {
-            // What type variables are referenced in the callable return type? Do not include any live type variables.
-            const newTypeParams = (0, typeUtils_1.getTypeVarArgsRecursive)(returnType).filter((t) => !liveTypeVarScopes.some((scopeId) => t.priv.scopeId === scopeId));
-            // If there are no unsolved type variables, we're done. If there are
-            // unsolved type variables, treat them as though they are rescoped
-            // to the callable.
-            if (newTypeParams.length > 0) {
-                const newScopeId = (_b = (_a = newTypeParams[0].priv.freeTypeVar) === null || _a === void 0 ? void 0 : _a.priv.scopeId) !== null && _b !== void 0 ? _b : newTypeParams[0].priv.scopeId;
-                return types_1.FunctionType.cloneWithNewTypeVarScopeId(returnType, newScopeId, callableType.priv.constructorTypeVarScopeId, newTypeParams);
-            }
+        if (!(0, types_1.isFunction)(returnType) || returnType.shared.name || !callableType.shared.typeVarScopeId) {
+            return returnType;
         }
-        return returnType;
+        // What type variables are referenced in the callable return type? Do not include any live type variables.
+        const newTypeParams = (0, typeUtils_1.getTypeVarArgsRecursive)(returnType).filter((t) => !liveTypeVarScopes.some((scopeId) => t.priv.scopeId === scopeId));
+        // If there are no unsolved type variables, we're done. If there are
+        // unsolved type variables, treat them as though they are rescoped
+        // to the callable.
+        if (newTypeParams.length === 0) {
+            return returnType;
+        }
+        const newScopeId = (_b = (_a = newTypeParams[0].priv.freeTypeVar) === null || _a === void 0 ? void 0 : _a.priv.scopeId) !== null && _b !== void 0 ? _b : newTypeParams[0].priv.scopeId;
+        return types_1.FunctionType.cloneWithNewTypeVarScopeId(returnType, newScopeId, callableType.priv.constructorTypeVarScopeId, newTypeParams);
     }
     // Tries to assign the call arguments to the function parameter
     // list and reports any mismatches in types or counts. Returns the
@@ -8344,7 +8386,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         paramSpecType = (0, typeUtils_1.convertTypeToParamSpecValue)(paramSpecType !== null && paramSpecType !== void 0 ? paramSpecType : paramSpec);
         const matchResults = matchArgsToParams(errorNode, argList, { type: paramSpecType }, 0);
         const functionType = matchResults.overload;
-        const srcConstraints = new constraintTracker_1.ConstraintTracker();
+        const constraints = new constraintTracker_1.ConstraintTracker();
         if (matchResults.argumentErrors) {
             // Evaluate types of all args. This will ensure that referenced symbols are
             // not reported as unaccessed.
@@ -8353,7 +8395,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     getTypeOfExpression(arg.valueExpression);
                 }
             });
-            return { argumentErrors: true, constraintTrackers: [srcConstraints] };
+            return { argumentErrors: true, constraintTrackers: [constraints] };
         }
         const functionParamSpec = types_1.FunctionType.getParamSpecFromArgsKwargs(functionType);
         const functionWithoutParamSpec = types_1.FunctionType.cloneRemoveParamSpecArgsKwargs(functionType);
@@ -8393,10 +8435,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     type: printType(functionParamSpec),
                 }), argErrorNode !== null && argErrorNode !== void 0 ? argErrorNode : errorNode);
             }
-            return { argumentErrors, constraintTrackers: [srcConstraints] };
+            return { argumentErrors, constraintTrackers: [constraints] };
         }
-        const result = validateArgTypes(errorNode, matchResults, srcConstraints, /* skipUnknownArgCheck */ undefined);
-        return { argumentErrors: !!result.argumentErrors, constraintTrackers: [srcConstraints] };
+        const result = validateArgTypes(errorNode, matchResults, constraints, /* skipUnknownArgCheck */ undefined);
+        return { argumentErrors: !!result.argumentErrors, constraintTrackers: [constraints] };
     }
     function validateArgType(argParam, constraints, typeResult, options) {
         var _a, _b;
@@ -8458,8 +8500,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     // values to any unification variables.
                     const clonedConstraints = constraints.clone();
                     if (assignType(expectedType, argType, 
-                    /* diag */ undefined, clonedConstraints, 
-                    /* srcConstraints */ undefined, (options === null || options === void 0 ? void 0 : options.isArgFirstPass) ? 8 /* AssignTypeFlags.ArgAssignmentFirstPass */ : 0 /* AssignTypeFlags.Default */)) {
+                    /* diag */ undefined, clonedConstraints, (options === null || options === void 0 ? void 0 : options.isArgFirstPass) ? 8 /* AssignTypeFlags.ArgAssignmentFirstPass */ : 0 /* AssignTypeFlags.Default */)) {
                         constraints.copyFromClone(clonedConstraints);
                     }
                     else {
@@ -8525,8 +8566,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (options === null || options === void 0 ? void 0 : options.isArgFirstPass) {
             assignTypeFlags |= 8 /* AssignTypeFlags.ArgAssignmentFirstPass */;
         }
-        if (!assignType(argParam.paramType, argType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), constraints, 
-        /* srcConstraints */ undefined, assignTypeFlags)) {
+        if (!assignType(argParam.paramType, argType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), constraints, assignTypeFlags)) {
             if (!(options === null || options === void 0 ? void 0 : options.skipReportError)) {
                 // Mismatching parameter types are common in untyped code; don't bother spending time
                 // printing types if the diagnostic is disabled.
@@ -9583,8 +9623,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     const mappingConstraints = new constraintTracker_1.ConstraintTracker();
                     supportsKeysAndGetItemClass = (0, typeUtils_1.selfSpecializeClass)(supportsKeysAndGetItemClass);
                     if (assignType(types_1.ClassType.cloneAsInstance(supportsKeysAndGetItemClass), unexpandedType, 
-                    /* diag */ undefined, mappingConstraints, 
-                    /* srcConstraints */ undefined, 256 /* AssignTypeFlags.RetainLiteralsForTypeVar */)) {
+                    /* diag */ undefined, mappingConstraints, 256 /* AssignTypeFlags.RetainLiteralsForTypeVar */)) {
                         const specializedMapping = solveAndApplyConstraints(supportsKeysAndGetItemClass, mappingConstraints);
                         const typeArgs = specializedMapping.priv.typeArgs;
                         if (typeArgs && typeArgs.length >= 2) {
@@ -9851,7 +9890,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 scopeIds: [],
                 tupleClassType: getTupleClassType(),
             },
-        }, { applyUnificationVars: true }), (subtype) => {
+        }), (subtype) => {
             if (entryTypes.length !== 1) {
                 return subtype;
             }
@@ -9961,7 +10000,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             const liveTypeVarScopes = ParseTreeUtils.getTypeVarScopesForNode(node);
             expectedType = (0, typeUtils_1.transformExpectedType)(expectedType, liveTypeVarScopes, node.start);
             expectedParamDetails = (0, parameterUtils_1.getParamListDetails)(expectedType);
-            expectedReturnType = getFunctionEffectiveReturnType(expectedType);
+            expectedReturnType = getEffectiveReturnType(expectedType);
         }
         let functionType = types_1.FunctionType.createInstance('', '', '', 131072 /* FunctionTypeFlags.PartiallyEvaluated */);
         functionType.shared.typeVarScopeId = ParseTreeUtils.getScopeIdForNode(node);
@@ -10072,7 +10111,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                                     scopeIds: [],
                                     tupleClassType: getTupleClassType(),
                                 },
-                            }, { applyUnificationVars: true });
+                            });
                         }
                     }
                 }
@@ -10510,7 +10549,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
             }
             if (!type) {
-                const exprType = getTypeOfExpression(itemExpr, (flags & 4 /* EvalFlags.ForwardRefs */) | 33554432 /* EvalFlags.NoConvertSpecialForm */ | 256 /* EvalFlags.TypeExpression */);
+                const exprType = getTypeOfExpression(itemExpr, (flags & (4 /* EvalFlags.ForwardRefs */ | 256 /* EvalFlags.TypeExpression */)) | 33554432 /* EvalFlags.NoConvertSpecialForm */);
                 // Is this an enum type?
                 if ((0, types_1.isClassInstance)(exprType.type) &&
                     types_1.ClassType.isEnumClass(exprType.type) &&
@@ -10533,8 +10572,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
             }
             if (!type) {
-                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.literalUnsupportedType(), item);
-                type = types_1.UnknownType.create();
+                if ((flags & 256 /* EvalFlags.TypeExpression */) !== 0) {
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.literalUnsupportedType(), item);
+                    type = types_1.UnknownType.create();
+                }
+                else {
+                    return types_1.ClassType.cloneAsInstance(classType);
+                }
             }
             literalTypes.push(type);
         }
@@ -11534,7 +11578,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     function createSubclass(errorNode, type1, type2) {
         var _a, _b;
         (0, debug_1.assert)((0, types_1.isInstantiableClass)(type1) && (0, types_1.isInstantiableClass)(type2));
-        const className = `<subclass of ${type1.shared.name} and ${type2.shared.name}>`;
+        const className = `<subclass of ${printType((0, typeUtils_1.convertToInstance)(type1), {
+            omitTypeArgsIfUnknown: true,
+        })} and ${printType((0, typeUtils_1.convertToInstance)(type2), { omitTypeArgsIfUnknown: true })}>`;
         const fileInfo = AnalyzerNodeInfo.getFileInfo(errorNode);
         // The effective metaclass of the intersection is the narrower of the two metaclasses.
         let effectiveMetaclass = type1.shared.effectiveMetaclass;
@@ -11613,6 +11659,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         classType.shared.flags |= 8192 /* ClassTypeFlags.PartiallyEvaluated */;
         classType.shared.declaration = classDecl;
         return (0, cancellationUtils_1.invalidateTypeCacheIfCanceled)(() => {
+            var _a;
             writeTypeCache(node, { type: classType }, /* flags */ undefined);
             writeTypeCache(node.d.name, { type: classType }, /* flags */ undefined);
             // Keep a list of unique type parameters that are used in the
@@ -12001,7 +12048,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             let foundUnknown = false;
             for (let i = node.d.decorators.length - 1; i >= 0; i--) {
                 const decorator = node.d.decorators[i];
-                const newDecoratedType = (0, decorators_1.applyClassDecorator)(evaluatorInterface, decoratedType, classType, decorator);
+                const newDecoratedType = useSignatureTracker((_a = node.parent) !== null && _a !== void 0 ? _a : node, () => (0, decorators_1.applyClassDecorator)(evaluatorInterface, decoratedType, classType, decorator));
                 const unknownOrAny = (0, typeUtils_1.containsAnyOrUnknown)(newDecoratedType, /* recurse */ false);
                 if (unknownOrAny && (0, types_1.isUnknown)(unknownOrAny)) {
                     // Report this error only on the first unknown type.
@@ -12448,8 +12495,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     /* skipUnknownArgCheck */ false, (0, typeUtils_1.makeInferenceContext)(getNoneType()));
                     if (callResult.argumentErrors) {
                         const diag = addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.initSubclassCallFailed(), node.d.name);
-                        const initSubclassFunction = (0, types_1.isOverloadedFunction)(initSubclassMethodType)
-                            ? types_1.OverloadedFunctionType.getOverloads(initSubclassMethodType)[0]
+                        const initSubclassFunction = (0, types_1.isOverloaded)(initSubclassMethodType)
+                            ? types_1.OverloadedType.getOverloads(initSubclassMethodType)[0]
                             : initSubclassMethodType;
                         const initSubclassDecl = (0, types_1.isFunction)(initSubclassFunction)
                             ? initSubclassFunction.shared.declaration
@@ -12471,6 +12518,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         });
     }
     function getTypeOfFunction(node) {
+        var _a;
         initializePrefetchedTypes(node);
         // Is this predecorated function type cached?
         let functionType = readTypeCache(node.d.name, 0 /* EvalFlags.None */);
@@ -12504,7 +12552,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         let foundUnknown = false;
         for (let i = node.d.decorators.length - 1; i >= 0; i--) {
             const decorator = node.d.decorators[i];
-            const newDecoratedType = (0, decorators_1.applyFunctionDecorator)(evaluatorInterface, decoratedType, functionType, decorator, node);
+            const newDecoratedType = useSignatureTracker((_a = node.parent) !== null && _a !== void 0 ? _a : node, () => {
+                (0, debug_1.assert)(decoratedType !== undefined);
+                return (0, decorators_1.applyFunctionDecorator)(evaluatorInterface, decoratedType, functionType, decorator, node);
+            });
             const unknownOrAny = (0, typeUtils_1.containsAnyOrUnknown)(newDecoratedType, /* recurse */ false);
             if (unknownOrAny && (0, types_1.isUnknown)(unknownOrAny)) {
                 // Report this error only on the first unknown type.
@@ -12527,8 +12578,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     markParamAccessed(param);
                 });
             }
-            decoratedType = (0, decorators_1.addOverloadsToFunctionType)(evaluatorInterface, node, decoratedType);
         }
+        decoratedType = (0, decorators_1.addOverloadsToFunctionType)(evaluatorInterface, node, decoratedType);
         writeTypeCache(node, { type: decoratedType }, 0 /* EvalFlags.None */);
         return { functionType, decoratedType };
     }
@@ -12976,7 +13027,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         else {
             let skipInference = false;
-            if ((0, types_1.isFunction)(defaultValueType) || (0, types_1.isOverloadedFunction)(defaultValueType)) {
+            if ((0, types_1.isFunction)(defaultValueType) || (0, types_1.isOverloaded)(defaultValueType)) {
                 // Do not infer parameter types that use a lambda or another function as a
                 // default value. We're likely to generate false positives in this case.
                 // It's not clear whether parameters should be positional-only or not.
@@ -13486,7 +13537,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         if (getAttrSymbol) {
                             const getAttrType = getEffectiveTypeOfSymbol(getAttrSymbol);
                             if ((0, types_1.isFunction)(getAttrType)) {
-                                symbolType = getFunctionEffectiveReturnType(getAttrType);
+                                symbolType = getEffectiveReturnType(getAttrType);
                                 reportError = false;
                             }
                         }
@@ -13927,7 +13978,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 if (parent.d.expr) {
                     const enclosingFunctionNode = ParseTreeUtils.getEnclosingFunction(node);
                     let declaredReturnType = enclosingFunctionNode
-                        ? getFunctionDeclaredReturnType(enclosingFunctionNode)
+                        ? getDeclaredReturnType(enclosingFunctionNode)
                         : undefined;
                     if (declaredReturnType) {
                         const liveScopeIds = ParseTreeUtils.getTypeVarScopesForNode(node);
@@ -14317,7 +14368,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (types_1.ClassType.isBuiltIn(classType, 'type') && typeArgs) {
                 if (typeArgs.length >= 1) {
                     // Treat type[function] as illegal.
-                    if ((0, types_1.isFunction)(typeArgs[0].type) || (0, types_1.isOverloadedFunction)(typeArgs[0].type)) {
+                    if ((0, types_1.isFunction)(typeArgs[0].type) || (0, types_1.isOverloaded)(typeArgs[0].type)) {
                         addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeAnnotationWithCallable(), typeArgs[0].node);
                         return { type: types_1.UnknownType.create() };
                     }
@@ -14801,7 +14852,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (!tracker) {
             return type;
         }
-        if ((0, types_1.isFunction)(type) || (0, types_1.isOverloadedFunction)(type)) {
+        if ((0, types_1.isFunction)(type) || (0, types_1.isOverloaded)(type)) {
             return (0, typeUtils_1.ensureSignaturesAreUnique)(type, tracker, node.start);
         }
         return type;
@@ -15020,8 +15071,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             declarations.push(paramDecl);
                         }
                     }
-                    else if ((0, types_1.isOverloadedFunction)(baseType)) {
-                        baseType.priv.overloads.forEach((f) => {
+                    else if ((0, types_1.isOverloaded)(baseType)) {
+                        types_1.OverloadedType.getOverloads(baseType).forEach((f) => {
                             const paramDecl = getDeclarationFromKeywordParam(f, paramName);
                             if (paramDecl) {
                                 declarations.push(paramDecl);
@@ -15905,32 +15956,33 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     }
     function inferReturnTypeIfNecessary(type) {
         if ((0, types_1.isFunction)(type)) {
-            getFunctionEffectiveReturnType(type);
+            getEffectiveReturnType(type);
         }
-        else if ((0, types_1.isOverloadedFunction)(type)) {
-            type.priv.overloads.forEach((overload) => {
-                getFunctionEffectiveReturnType(overload);
+        else if ((0, types_1.isOverloaded)(type)) {
+            types_1.OverloadedType.getOverloads(type).forEach((overload) => {
+                getEffectiveReturnType(overload);
             });
+            const impl = types_1.OverloadedType.getImplementation(type);
+            if (impl && (0, types_1.isFunction)(impl)) {
+                getEffectiveReturnType(impl);
+            }
         }
     }
     // Returns the return type of the function. If the type is explicitly provided in
     // a type annotation, that type is returned. If not, an attempt is made to infer
     // the return type. If a list of args is provided, the inference logic may take
     // into account argument types to infer the return type.
-    function getFunctionEffectiveReturnType(type, callSiteInfo, inferTypeIfNeeded = true) {
+    function getEffectiveReturnType(type, options) {
         const specializedReturnType = types_1.FunctionType.getEffectiveReturnType(type, /* includeInferred */ false);
         if (specializedReturnType && !(0, types_1.isUnknown)(specializedReturnType)) {
-            const liveTypeVarScopes = (callSiteInfo === null || callSiteInfo === void 0 ? void 0 : callSiteInfo.errorNode)
-                ? ParseTreeUtils.getTypeVarScopesForNode(callSiteInfo === null || callSiteInfo === void 0 ? void 0 : callSiteInfo.errorNode)
-                : [];
-            return adjustCallableReturnType(type, specializedReturnType, liveTypeVarScopes);
+            return specializedReturnType;
         }
-        if (inferTypeIfNeeded) {
-            return getFunctionInferredReturnType(type, callSiteInfo);
+        if (!(options === null || options === void 0 ? void 0 : options.skipInferReturnType)) {
+            return getFunctionInferredReturnType(type, options === null || options === void 0 ? void 0 : options.callSiteInfo);
         }
         return types_1.UnknownType.create();
     }
-    function _getFunctionInferredReturnType(type, callSiteInfo) {
+    function _getInferredReturnType(type, callSiteInfo) {
         var _a, _b, _c;
         let returnType;
         let isIncomplete = false;
@@ -16026,7 +16078,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // We can't use this technique if decorators or async are used because they
             // would need to be applied to the inferred return type.
             if (!hasDecorators && !isAsync) {
-                const contextualReturnType = getFunctionInferredReturnTypeUsingArgs(type, callSiteInfo);
+                const contextualReturnType = inferReturnTypeForCallSite(type, callSiteInfo);
                 if (contextualReturnType) {
                     returnType = contextualReturnType;
                     if ((_c = type.shared.declaration) === null || _c === void 0 ? void 0 : _c.node) {
@@ -16039,7 +16091,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return returnType;
     }
-    function getFunctionInferredReturnTypeUsingArgs(type, callSiteInfo) {
+    function inferReturnTypeForCallSite(type, callSiteInfo) {
         const args = callSiteInfo.args;
         let contextualReturnType;
         if (!type.shared.declaration) {
@@ -16180,7 +16232,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // If the function has an explicitly-declared return type, it is returned
     // unaltered unless the function is a generator, in which case it is
     // modified to return only the return type for the generator.
-    function getFunctionDeclaredReturnType(node) {
+    function getDeclaredReturnType(node) {
         const functionTypeInfo = getTypeOfFunction(node);
         const returnType = functionTypeInfo === null || functionTypeInfo === void 0 ? void 0 : functionTypeInfo.functionType.shared.declaredReturnType;
         if (!returnType) {
@@ -16230,7 +16282,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             (0, typeUtils_1.requiresSpecialization)(typeResult.type, { ignoreSelf: true, ignoreImplicitTypeArgs: true })) {
             const specializedType = (0, typeUtils_1.partiallySpecializeType)(typeResult.type, member.unspecializedClassType, getTypeClassType(), (0, typeUtils_1.selfSpecializeClass)(selfClass, { overrideTypeArgs: true }));
             if ((0, types_1.findSubtype)(specializedType, (subtype) => !(0, types_1.isFunction)(subtype) &&
-                !(0, types_1.isOverloadedFunction)(subtype) &&
+                !(0, types_1.isOverloaded)(subtype) &&
                 (0, typeUtils_1.requiresSpecialization)(subtype, { ignoreSelf: true, ignoreImplicitTypeArgs: true }))) {
                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.genericInstanceVariableAccess(), errorNode);
             }
@@ -16240,7 +16292,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             isIncomplete: !!typeResult.isIncomplete,
         };
     }
-    function assignClass(destType, srcType, diag, destConstraints, srcConstraints, flags, recursionCount, reportErrorsUsingObjType) {
+    function assignClass(destType, srcType, diag, constraints, flags, recursionCount, reportErrorsUsingObjType) {
         // If the source or dest types are partially evaluated (i.e. they are in the
         // process of being constructed), assume they are assignable rather than risk
         // emitting false positives.
@@ -16251,7 +16303,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // checking, as defined in PEP 589.
         if (types_1.ClassType.isTypedDictClass(srcType)) {
             if (types_1.ClassType.isTypedDictClass(destType) && !types_1.ClassType.isSameGenericClass(destType, srcType)) {
-                if (!(0, typedDicts_1.assignTypedDictToTypedDict)(evaluatorInterface, destType, srcType, diag, destConstraints, flags, recursionCount)) {
+                if (!(0, typedDicts_1.assignTypedDictToTypedDict)(evaluatorInterface, destType, srcType, diag, constraints, flags, recursionCount)) {
                     return false;
                 }
                 if (types_1.ClassType.isFinal(destType) !== types_1.ClassType.isFinal(srcType)) {
@@ -16262,7 +16314,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     return false;
                 }
                 // If invariance is being enforced, the two TypedDicts must be assignable to each other.
-                if ((flags & 1 /* AssignTypeFlags.EnforceInvariance */) !== 0) {
+                if ((flags & 1 /* AssignTypeFlags.Invariant */) !== 0) {
                     return (0, typedDicts_1.assignTypedDictToTypedDict)(evaluatorInterface, srcType, destType, 
                     /* diag */ undefined, 
                     /* constraints */ undefined, flags, recursionCount);
@@ -16300,7 +16352,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             const promotionList = typePromotions.get(destType.shared.fullName);
             if (promotionList &&
                 promotionList.some((srcName) => srcType.shared.mro.some((mroClass) => (0, types_1.isClass)(mroClass) && srcName === mroClass.shared.fullName))) {
-                if ((flags & 1 /* AssignTypeFlags.EnforceInvariance */) === 0) {
+                if ((flags & 1 /* AssignTypeFlags.Invariant */) === 0) {
                     return true;
                 }
             }
@@ -16313,7 +16365,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // derive from the source. We also need to use this path if we're
         // testing to see if the metaclass matches the protocol.
         if (types_1.ClassType.isProtocolClass(destType) && !isDerivedFrom) {
-            if (!(0, protocols_1.assignClassToProtocol)(evaluatorInterface, destType, types_1.ClassType.cloneAsInstance(srcType), diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destConstraints, srcConstraints, flags, recursionCount)) {
+            if (!(0, protocols_1.assignClassToProtocol)(evaluatorInterface, destType, types_1.ClassType.cloneAsInstance(srcType), diag === null || diag === void 0 ? void 0 : diag.createAddendum(), constraints, flags, recursionCount)) {
                 diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.protocolIncompatible().format({
                     sourceType: printType((0, typeUtils_1.convertToInstance)(srcType)),
                     destType: printType((0, typeUtils_1.convertToInstance)(destType)),
@@ -16326,20 +16378,20 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // considered a subtype of `bool`.
         if ((0, types_1.isInstantiableClass)(srcType) && types_1.ClassType.isBuiltIn(srcType, ['TypeGuard', 'TypeIs'])) {
             if ((0, types_1.isInstantiableClass)(destType) && types_1.ClassType.isBuiltIn(destType, 'bool')) {
-                return (flags & 1 /* AssignTypeFlags.EnforceInvariance */) === 0;
+                return (flags & 1 /* AssignTypeFlags.Invariant */) === 0;
             }
         }
-        if ((flags & 1 /* AssignTypeFlags.EnforceInvariance */) === 0 || types_1.ClassType.isSameGenericClass(srcType, destType)) {
+        if ((flags & 1 /* AssignTypeFlags.Invariant */) === 0 || types_1.ClassType.isSameGenericClass(srcType, destType)) {
             if (isDerivedFrom) {
                 (0, debug_1.assert)(inheritanceChain.length > 0);
-                if (assignClassWithTypeArgs(destType, srcType, inheritanceChain, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destConstraints, srcConstraints, flags, recursionCount)) {
+                if (assignClassWithTypeArgs(destType, srcType, inheritanceChain, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), constraints, flags, recursionCount)) {
                     return true;
                 }
             }
         }
         // Everything is assignable to an object.
         if (types_1.ClassType.isBuiltIn(destType, 'object')) {
-            if ((flags & 1 /* AssignTypeFlags.EnforceInvariance */) === 0) {
+            if ((flags & 1 /* AssignTypeFlags.Invariant */) === 0) {
                 return true;
             }
         }
@@ -16421,13 +16473,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         // private or protected, since these are presumably
                         // not modifiable outside of the class.
                         if (!(0, symbolNameUtils_1.isPrivateOrProtectedName)(name)) {
-                            flags |= 1 /* AssignTypeFlags.EnforceInvariance */;
+                            flags |= 1 /* AssignTypeFlags.Invariant */;
                         }
                     }
                     if (!assignType(destMemberType, srcMemberType, 
                     /* diag */ undefined, 
-                    /* destConstraints */ undefined, 
-                    /* srcConstraints */ undefined, flags | 32768 /* AssignTypeFlags.SkipSelfClsParamCheck */, recursionCount)) {
+                    /* constraints */ undefined, flags | 32768 /* AssignTypeFlags.SkipSelfClsParamCheck */, recursionCount)) {
                         isAssignable = false;
                     }
                 }
@@ -16482,12 +16533,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     }
     // Determines whether the specified type can be assigned to the
     // specified inheritance chain, taking into account its type arguments.
-    function assignClassWithTypeArgs(destType, srcType, inheritanceChain, diag, destConstraints, srcConstraints, flags, recursionCount) {
+    function assignClassWithTypeArgs(destType, srcType, inheritanceChain, diag, constraints, flags, recursionCount) {
         let curSrcType = srcType;
         let prevSrcType;
         inferVarianceForClass(destType);
         // If we're enforcing invariance, literal types must match.
-        if ((flags & 1 /* AssignTypeFlags.EnforceInvariance */) !== 0) {
+        if ((flags & 1 /* AssignTypeFlags.Invariant */) !== 0) {
             const srcIsLiteral = srcType.priv.literalValue !== undefined;
             const destIsLiteral = destType.priv.literalValue !== undefined;
             if (srcIsLiteral !== destIsLiteral) {
@@ -16537,7 +16588,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             prevSrcType = curSrcType;
         }
         // If we're enforcing invariance, literal types must match as well.
-        if ((flags & 1 /* AssignTypeFlags.EnforceInvariance */) !== 0) {
+        if ((flags & 1 /* AssignTypeFlags.Invariant */) !== 0) {
             const srcIsLiteral = srcType.priv.literalValue !== undefined;
             const destIsLiteral = destType.priv.literalValue !== undefined;
             if (srcIsLiteral !== destIsLiteral) {
@@ -16546,7 +16597,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         // Handle tuple, which supports a variable number of type arguments.
         if (destType.priv.tupleTypeArgs && curSrcType.priv.tupleTypeArgs) {
-            return (0, tuples_1.assignTupleTypeArgs)(evaluatorInterface, destType, curSrcType, diag, destConstraints, srcConstraints, flags, recursionCount);
+            return (0, tuples_1.assignTupleTypeArgs)(evaluatorInterface, destType, curSrcType, diag, constraints, flags, recursionCount);
         }
         if (destType.priv.typeArgs) {
             // If the dest type is specialized, make sure the specialized source
@@ -16555,9 +16606,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // Don't emit a diag addendum if we're in an invariant context. It's
             // sufficient to simply indicate that the types are not the same
             // in this case. Adding more information is unnecessary and confusing.
-            (flags & 1 /* AssignTypeFlags.EnforceInvariance */) === 0 ? diag : undefined, destConstraints, srcConstraints, flags, recursionCount);
+            (flags & 1 /* AssignTypeFlags.Invariant */) === 0 ? diag : undefined, constraints, flags, recursionCount);
         }
-        if (destConstraints && curSrcType.priv.typeArgs && !destConstraints.isLocked()) {
+        if (constraints && curSrcType.priv.typeArgs && !constraints.isLocked()) {
             // Populate the typeVar map with type arguments of the source.
             const srcTypeArgs = curSrcType.priv.typeArgs;
             for (let i = 0; i < destType.shared.typeParams.length; i++) {
@@ -16570,8 +16621,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 else {
                     typeArgType = i < srcTypeArgs.length ? srcTypeArgs[i] : types_1.UnknownType.create();
                 }
-                (0, constraintSolver_1.updateTypeVarType)(evaluatorInterface, destConstraints, typeParam, variance !== 4 /* Variance.Contravariant */ ? typeArgType : undefined, variance !== 3 /* Variance.Covariant */ ? typeArgType : undefined, 
-                /* forceRetainLiterals */ true);
+                constraints.setBounds(typeParam, variance !== 4 /* Variance.Contravariant */ ? typeArgType : undefined, variance !== 3 /* Variance.Covariant */ ? typeArgType : undefined, 
+                /* retainLiterals */ true);
             }
         }
         return true;
@@ -16581,12 +16632,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             return undefined;
         }
         if (propertyClass.priv.fgetInfo) {
-            return getFunctionEffectiveReturnType(propertyClass.priv.fgetInfo.methodType, 
-            /* args */ undefined, inferTypeIfNeeded);
+            return getEffectiveReturnType(propertyClass.priv.fgetInfo.methodType);
         }
         return undefined;
     }
-    function assignTypeArgs(destType, srcType, diag, destConstraints, srcConstraints, flags, recursionCount) {
+    function assignTypeArgs(destType, srcType, diag, constraints, flags, recursionCount) {
         var _a, _b, _c;
         (0, debug_1.assert)(types_1.ClassType.isSameGenericClass(destType, srcType));
         inferVarianceForClass(destType);
@@ -16629,18 +16679,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 errorSource = localize_1.LocAddendum.typeVarIsCovariant;
             }
             else if (variance === 4 /* Variance.Contravariant */) {
-                effectiveFlags =
-                    (flags ^ 2 /* AssignTypeFlags.ReverseTypeVarMatching */) | 256 /* AssignTypeFlags.RetainLiteralsForTypeVar */;
+                effectiveFlags = (flags ^ 2 /* AssignTypeFlags.Contravariant */) | 256 /* AssignTypeFlags.RetainLiteralsForTypeVar */;
                 errorSource = localize_1.LocAddendum.typeVarIsContravariant;
             }
             else {
-                effectiveFlags = flags | 1 /* AssignTypeFlags.EnforceInvariance */ | 256 /* AssignTypeFlags.RetainLiteralsForTypeVar */;
+                effectiveFlags = flags | 1 /* AssignTypeFlags.Invariant */ | 256 /* AssignTypeFlags.RetainLiteralsForTypeVar */;
                 errorSource = localize_1.LocAddendum.typeVarIsInvariant;
                 // Omit the diagnostic addendum for the invariant case because it's obvious
                 // why two types are not the same.
                 includeDiagAddendum = false;
             }
-            if (!assignType(variance === 4 /* Variance.Contravariant */ ? srcTypeArg : destTypeArg, variance === 4 /* Variance.Contravariant */ ? destTypeArg : srcTypeArg, assignmentDiag, variance === 4 /* Variance.Contravariant */ ? srcConstraints : destConstraints, variance === 4 /* Variance.Contravariant */ ? destConstraints : srcConstraints, effectiveFlags, recursionCount)) {
+            if (!assignType(variance === 4 /* Variance.Contravariant */ ? srcTypeArg : destTypeArg, variance === 4 /* Variance.Contravariant */ ? destTypeArg : srcTypeArg, assignmentDiag, constraints, effectiveFlags, recursionCount)) {
                 // Don't report errors with type variables in "pseudo-random"
                 // classes since these type variables are not real.
                 if (!types_1.ClassType.isPseudoGenericClass(destType)) {
@@ -16682,7 +16731,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // matched against existing type variables in the map. If a type variable
     // in the dest type is not in the type map already, it is assigned a type
     // and added to the map.
-    function assignType(destType, srcType, diag, destConstraints, srcConstraints, flags = 0 /* AssignTypeFlags.Default */, recursionCount = 0) {
+    function assignType(destType, srcType, diag, constraints, flags = 0 /* AssignTypeFlags.Default */, recursionCount = 0) {
         var _a, _b, _c, _d, _e, _f, _g, _h, _j;
         // Handle the case where the dest and src types are the same object.
         // We can normally shortcut this and say that they are compatible,
@@ -16727,7 +16776,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 const srcTypeArgs = srcAliasInfo.typeArgs;
                 destAliasInfo.typeArgs.forEach((destTypeArg, index) => {
                     const srcTypeArg = index < srcTypeArgs.length ? srcTypeArgs[index] : types_1.UnknownType.create();
-                    if (!assignType(destTypeArg, srcTypeArg, diag, destConstraints, srcConstraints, flags, recursionCount)) {
+                    if (!assignType(destTypeArg, srcTypeArg, diag, constraints, flags, recursionCount)) {
                         isAssignable = false;
                     }
                 });
@@ -16806,8 +16855,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 types_1.TypeVarType.hasBound(destType) &&
                 types_1.TypeVarType.isBound(destType) === types_1.TypeVarType.isBound(srcType) &&
                 types_1.TypeBase.isInstance(srcType) === types_1.TypeBase.isInstance(destType)) {
-                if ((flags & 2 /* AssignTypeFlags.ReverseTypeVarMatching */) === 0 && destConstraints) {
-                    (0, constraintSolver_1.assignTypeVar)(evaluatorInterface, destType, srcType, diag, destConstraints, flags, recursionCount);
+                if ((flags & 2 /* AssignTypeFlags.Contravariant */) === 0 && constraints) {
+                    (0, constraintSolver_1.assignTypeVar)(evaluatorInterface, destType, srcType, diag, constraints, flags, recursionCount);
                 }
                 return true;
             }
@@ -16822,9 +16871,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     return true;
                 }
             }
-            if ((flags & 2 /* AssignTypeFlags.ReverseTypeVarMatching */) === 0 || !(0, types_1.isTypeVar)(srcType)) {
-                const targetConstraints = (flags & 2 /* AssignTypeFlags.ReverseTypeVarMatching */) === 0 ? destConstraints : srcConstraints;
-                if (!(0, constraintSolver_1.assignTypeVar)(evaluatorInterface, destType, srcType, diag, targetConstraints, flags, recursionCount)) {
+            if ((flags & 2 /* AssignTypeFlags.Contravariant */) === 0 || !(0, types_1.isTypeVar)(srcType)) {
+                if (!(0, constraintSolver_1.assignTypeVar)(evaluatorInterface, destType, srcType, diag, constraints, flags, recursionCount)) {
                     return false;
                 }
                 if ((0, types_1.isAnyOrUnknown)(srcType) && (flags & 16 /* AssignTypeFlags.OverloadOverlap */) !== 0) {
@@ -16834,29 +16882,26 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
         }
         if ((0, types_1.isTypeVar)(srcType)) {
-            if ((flags & 2 /* AssignTypeFlags.ReverseTypeVarMatching */) !== 0) {
-                // The caller has requested that we solve for source type variables
-                // rather than dest.
+            if ((flags & 2 /* AssignTypeFlags.Contravariant */) !== 0) {
                 if (types_1.TypeVarType.isBound(srcType)) {
                     return assignType(makeTopLevelTypeVarsConcrete(destType), makeTopLevelTypeVarsConcrete(srcType), diag, 
-                    /* destConstraints */ undefined, 
-                    /* srcConstraints */ undefined, flags, recursionCount);
+                    /* constraints */ undefined, flags, recursionCount);
                 }
-                if ((0, constraintSolver_1.assignTypeVar)(evaluatorInterface, srcType, destType, diag, srcConstraints, flags, recursionCount)) {
+                if ((0, constraintSolver_1.assignTypeVar)(evaluatorInterface, srcType, destType, diag, constraints, flags, recursionCount)) {
                     return true;
                 }
                 // If the dest type is a union, only one of the subtypes needs to match.
                 let isAssignable = false;
                 if ((0, types_1.isUnion)(destType)) {
                     (0, typeUtils_1.doForEachSubtype)(destType, (destSubtype) => {
-                        if ((0, constraintSolver_1.assignTypeVar)(evaluatorInterface, srcType, destSubtype, diag, srcConstraints, flags, recursionCount)) {
+                        if ((0, constraintSolver_1.assignTypeVar)(evaluatorInterface, srcType, destSubtype, diag, constraints, flags, recursionCount)) {
                             isAssignable = true;
                         }
                     });
                 }
                 return isAssignable;
             }
-            if ((flags & 1 /* AssignTypeFlags.EnforceInvariance */) !== 0) {
+            if ((flags & 1 /* AssignTypeFlags.Invariant */) !== 0) {
                 if ((0, types_1.isAnyOrUnknown)(destType)) {
                     return true;
                 }
@@ -16890,29 +16935,27 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             return true;
         }
         if ((0, types_1.isAnyOrUnknown)(srcType) && !((_e = srcType.props) === null || _e === void 0 ? void 0 : _e.specialForm)) {
-            const targetConstraints = (flags & 2 /* AssignTypeFlags.ReverseTypeVarMatching */) === 0 ? destConstraints : srcConstraints;
-            if (targetConstraints) {
+            if (constraints) {
                 // If it's an ellipsis type, convert it to a regular "Any"
                 // type. These are functionally equivalent, but "Any" looks
                 // better in the text representation.
                 const typeVarSubstitution = (0, typeUtils_1.isEllipsisType)(srcType) ? types_1.AnyType.create() : srcType;
-                (0, typeUtils_1.setTypeArgsRecursive)(destType, typeVarSubstitution, targetConstraints, recursionCount);
+                setConstraintsForFreeTypeVars(destType, typeVarSubstitution, constraints);
             }
             if ((flags & 16 /* AssignTypeFlags.OverloadOverlap */) === 0) {
                 return true;
             }
         }
         if ((0, types_1.isNever)(srcType)) {
-            if ((flags & 1 /* AssignTypeFlags.EnforceInvariance */) !== 0) {
+            if ((flags & 1 /* AssignTypeFlags.Invariant */) !== 0) {
                 if ((0, types_1.isNever)(destType)) {
                     return true;
                 }
                 diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.typeAssignmentMismatch().format(printSrcDestTypes(srcType, destType)));
                 return false;
             }
-            const targetConstraints = (flags & 2 /* AssignTypeFlags.ReverseTypeVarMatching */) === 0 ? destConstraints : srcConstraints;
-            if (targetConstraints) {
-                (0, typeUtils_1.setTypeArgsRecursive)(destType, types_1.UnknownType.create(), targetConstraints, recursionCount);
+            if (constraints) {
+                setConstraintsForFreeTypeVars(destType, types_1.UnknownType.create(), constraints);
             }
             return true;
         }
@@ -16920,28 +16963,22 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // If both the source and dest are unions, use assignFromUnionType which has
             // special-case logic to handle this case.
             if ((0, types_1.isUnion)(srcType)) {
-                return assignFromUnionType(destType, srcType, 
-                /* diag */ undefined, destConstraints, srcConstraints, flags, recursionCount);
+                return assignFromUnionType(destType, srcType, /* diag */ undefined, constraints, flags, recursionCount);
             }
-            const clonedDestConstraints = destConstraints === null || destConstraints === void 0 ? void 0 : destConstraints.clone();
-            const clonedSrcConstraints = srcConstraints === null || srcConstraints === void 0 ? void 0 : srcConstraints.clone();
-            if (assignToUnionType(destType, srcType, 
-            /* diag */ undefined, clonedDestConstraints, clonedSrcConstraints, flags, recursionCount)) {
-                if (destConstraints && clonedDestConstraints) {
-                    destConstraints.copyFromClone(clonedDestConstraints);
-                }
-                if (srcConstraints && clonedSrcConstraints) {
-                    srcConstraints.copyFromClone(clonedSrcConstraints);
+            const clonedConstraints = constraints === null || constraints === void 0 ? void 0 : constraints.clone();
+            if (assignToUnionType(destType, srcType, /* diag */ undefined, clonedConstraints, flags, recursionCount)) {
+                if (constraints && clonedConstraints) {
+                    constraints.copyFromClone(clonedConstraints);
                 }
                 return true;
             }
         }
         const expandedSrcType = makeTopLevelTypeVarsConcrete(srcType);
         if ((0, types_1.isUnion)(expandedSrcType)) {
-            return assignFromUnionType(destType, expandedSrcType, diag, destConstraints, srcConstraints, flags, recursionCount);
+            return assignFromUnionType(destType, expandedSrcType, diag, constraints, flags, recursionCount);
         }
         if ((0, types_1.isUnion)(destType)) {
-            return assignToUnionType(destType, srcType, diag, destConstraints, srcConstraints, flags, recursionCount);
+            return assignToUnionType(destType, srcType, diag, constraints, flags, recursionCount);
         }
         // Is the src a specialized "type" object?
         if ((0, types_1.isClassInstance)(expandedSrcType) && types_1.ClassType.isBuiltIn(expandedSrcType, 'type')) {
@@ -16959,7 +16996,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
             }
             else if ((0, types_1.isClassInstance)(typeTypeArg) || (0, types_1.isTypeVar)(typeTypeArg)) {
-                if (assignType(destType, (0, typeUtils_1.convertToInstantiable)(typeTypeArg), diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destConstraints, srcConstraints, flags, recursionCount)) {
+                if (assignType(destType, (0, typeUtils_1.convertToInstantiable)(typeTypeArg), diag === null || diag === void 0 ? void 0 : diag.createAddendum(), constraints, flags, recursionCount)) {
                     return true;
                 }
                 diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.typeAssignmentMismatch().format(printSrcDestTypes(srcType, destType)));
@@ -16986,10 +17023,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
                 if (isSpecialFormClass(expandedSrcType, flags)) {
                     if ((_h = destType.props) === null || _h === void 0 ? void 0 : _h.specialForm) {
-                        return assignType(destType.props.specialForm, expandedSrcType, diag, destConstraints, srcConstraints, flags, recursionCount);
+                        return assignType(destType.props.specialForm, expandedSrcType, diag, constraints, flags, recursionCount);
                     }
                 }
-                else if (assignClass(destType, expandedSrcType, diag, destConstraints, srcConstraints, flags, recursionCount, 
+                else if (assignClass(destType, expandedSrcType, diag, constraints, flags, recursionCount, 
                 /* reportErrorsUsingObjType */ false)) {
                     return true;
                 }
@@ -17001,7 +17038,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, destConstraints, srcConstraints, flags, recursionCount, 
+                    if (assignClass(types_1.ClassType.cloneAsInstance(destMetaclass), expandedSrcType, diag, constraints, flags, recursionCount, 
                     /* reportErrorsUsingObjType */ false)) {
                         return true;
                     }
@@ -17021,7 +17058,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 const destTypeArgs = destType.priv.typeArgs;
                 if (destTypeArgs && destTypeArgs.length >= 1) {
                     if (types_1.TypeBase.isInstance(destTypeArgs[0]) && types_1.TypeBase.isInstantiable(srcType)) {
-                        return assignType(destTypeArgs[0], (0, typeUtils_1.convertToInstance)(srcType), diag, destConstraints, srcConstraints, flags, recursionCount);
+                        return assignType(destTypeArgs[0], (0, typeUtils_1.convertToInstance)(srcType), diag, constraints, flags, recursionCount);
                     }
                 }
                 // Is the dest a "type" object? Assume that all instantiable
@@ -17057,7 +17094,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 if (types_1.ClassType.isBuiltIn(destType, 'LiteralString')) {
                     if (types_1.ClassType.isBuiltIn(concreteSrcType, 'str') &&
                         concreteSrcType.priv.literalValue !== undefined) {
-                        return (flags & 1 /* AssignTypeFlags.EnforceInvariance */) === 0;
+                        return (flags & 1 /* AssignTypeFlags.Invariant */) === 0;
                     }
                     else if (types_1.ClassType.isBuiltIn(concreteSrcType, 'LiteralString')) {
                         return true;
@@ -17066,24 +17103,24 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 else if (types_1.ClassType.isBuiltIn(concreteSrcType, 'LiteralString') &&
                     strClass &&
                     (0, types_1.isInstantiableClass)(strClass) &&
-                    (flags & 1 /* AssignTypeFlags.EnforceInvariance */) === 0) {
+                    (flags & 1 /* AssignTypeFlags.Invariant */) === 0) {
                     concreteSrcType = types_1.ClassType.cloneAsInstance(strClass);
                 }
-                if (!assignClass(types_1.ClassType.cloneAsInstantiable(destType), types_1.ClassType.cloneAsInstantiable(concreteSrcType), diag, destConstraints, srcConstraints, flags, recursionCount, 
+                if (!assignClass(types_1.ClassType.cloneAsInstantiable(destType), types_1.ClassType.cloneAsInstantiable(concreteSrcType), diag, constraints, flags, recursionCount, 
                 /* reportErrorsUsingObjType */ true)) {
                     return false;
                 }
                 return true;
             }
-            else if ((0, types_1.isFunction)(concreteSrcType) || (0, types_1.isOverloadedFunction)(concreteSrcType)) {
+            else if ((0, types_1.isFunction)(concreteSrcType) || (0, types_1.isOverloaded)(concreteSrcType)) {
                 // Is the destination a callback protocol (defined in PEP 544)?
                 const destCallbackType = getCallbackProtocolType(destType, recursionCount);
                 if (destCallbackType) {
-                    return assignType(destCallbackType, concreteSrcType, diag, destConstraints, srcConstraints, flags, recursionCount);
+                    return assignType(destCallbackType, concreteSrcType, diag, constraints, flags, recursionCount);
                 }
                 // All functions are considered instances of "builtins.function".
                 if (functionClass) {
-                    return assignType(destType, (0, typeUtils_1.convertToInstance)(functionClass), diag, destConstraints, srcConstraints, flags, recursionCount);
+                    return assignType(destType, (0, typeUtils_1.convertToInstance)(functionClass), diag, constraints, flags, recursionCount);
                 }
             }
             else if ((0, types_1.isModule)(concreteSrcType)) {
@@ -17092,7 +17129,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     return true;
                 }
                 if (types_1.ClassType.isProtocolClass(destType)) {
-                    return (0, protocols_1.assignModuleToProtocol)(evaluatorInterface, types_1.ClassType.cloneAsInstantiable(destType), concreteSrcType, diag, destConstraints, flags, recursionCount);
+                    return (0, protocols_1.assignModuleToProtocol)(evaluatorInterface, types_1.ClassType.cloneAsInstantiable(destType), concreteSrcType, diag, constraints, flags, recursionCount);
                 }
             }
             else if ((0, types_1.isInstantiableClass)(concreteSrcType)) {
@@ -17100,12 +17137,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 // class that is effectively a function.
                 const callbackType = getCallbackProtocolType(destType, recursionCount);
                 if (callbackType) {
-                    return assignType(callbackType, concreteSrcType, diag, destConstraints, srcConstraints, flags, recursionCount);
+                    return assignType(callbackType, concreteSrcType, diag, constraints, flags, recursionCount);
                 }
                 // If the destType is an instantiation of a Protocol,
                 // see if the class type itself satisfies the protocol.
                 if (types_1.ClassType.isProtocolClass(destType)) {
-                    return (0, protocols_1.assignClassToProtocol)(evaluatorInterface, types_1.ClassType.cloneAsInstantiable(destType), concreteSrcType, diag, destConstraints, srcConstraints, flags, recursionCount);
+                    return (0, protocols_1.assignClassToProtocol)(evaluatorInterface, types_1.ClassType.cloneAsInstantiable(destType), concreteSrcType, diag, constraints, flags, recursionCount);
                 }
                 // Determine if the metaclass can be assigned to the object.
                 const metaclass = concreteSrcType.shared.effectiveMetaclass;
@@ -17114,7 +17151,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         return true;
                     }
                     else {
-                        return assignClass(types_1.ClassType.cloneAsInstantiable(destType), metaclass, diag, destConstraints, srcConstraints, flags, recursionCount, 
+                        return assignClass(types_1.ClassType.cloneAsInstantiable(destType), metaclass, diag, constraints, flags, recursionCount, 
                         /* reportErrorsUsingObjType */ false);
                     }
                 }
@@ -17123,7 +17160,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 return (flags & 16 /* AssignTypeFlags.OverloadOverlap */) === 0;
             }
             else if ((0, types_1.isUnion)(concreteSrcType)) {
-                return assignType(destType, concreteSrcType, diag, destConstraints, srcConstraints, flags, recursionCount);
+                return assignType(destType, concreteSrcType, diag, constraints, flags, recursionCount);
             }
         }
         if ((0, types_1.isFunction)(destType)) {
@@ -17144,14 +17181,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     // The constructor conversion may result in a union of the
                     // __init__ and __new__ callables.
                     if ((0, types_1.isUnion)(concreteSrcType)) {
-                        return assignType(destType, concreteSrcType, diag, destConstraints, srcConstraints, flags, recursionCount);
+                        return assignType(destType, concreteSrcType, diag, constraints, flags, recursionCount);
                     }
                 }
             }
             if ((0, types_1.isAnyOrUnknown)(concreteSrcType)) {
                 return (flags & 16 /* AssignTypeFlags.OverloadOverlap */) === 0;
             }
-            if ((0, types_1.isOverloadedFunction)(concreteSrcType)) {
+            if ((0, types_1.isOverloaded)(concreteSrcType)) {
                 // If this is the first pass of an argument assignment, skip
                 // all attempts to assign an overloaded function to a function
                 // because we probably don't have enough information to properly
@@ -17161,23 +17198,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     return true;
                 }
                 // Find all of the overloaded functions that match the parameters.
-                const overloads = types_1.OverloadedFunctionType.getOverloads(concreteSrcType);
+                const overloads = types_1.OverloadedType.getOverloads(concreteSrcType);
                 const filteredOverloads = [];
-                const destTypeVarSignatures = [];
-                const srcTypeVarSignatures = [];
+                const typeVarSignatures = [];
                 overloads.forEach((overload) => {
                     var _a;
                     const overloadScopeId = (_a = (0, typeUtils_1.getTypeVarScopeId)(overload)) !== null && _a !== void 0 ? _a : '';
-                    const destConstraintsClone = destConstraints === null || destConstraints === void 0 ? void 0 : destConstraints.cloneWithSignature(overloadScopeId);
-                    const srcConstraintsClone = srcConstraints === null || srcConstraints === void 0 ? void 0 : srcConstraints.cloneWithSignature(overloadScopeId);
-                    if (assignType(destType, overload, 
-                    /* diag */ undefined, destConstraintsClone, srcConstraintsClone, flags, recursionCount)) {
+                    const constraintsClone = constraints === null || constraints === void 0 ? void 0 : constraints.cloneWithSignature(overloadScopeId);
+                    if (assignType(destType, overload, /* diag */ undefined, constraintsClone, flags, recursionCount)) {
                         filteredOverloads.push(overload);
-                        if (destConstraintsClone) {
-                            (0, collectionUtils_1.appendArray)(destTypeVarSignatures, destConstraintsClone.getConstraintSets());
-                        }
-                        if (srcConstraintsClone) {
-                            (0, collectionUtils_1.appendArray)(srcTypeVarSignatures, srcConstraintsClone.getConstraintSets());
+                        if (constraintsClone) {
+                            (0, collectionUtils_1.appendArray)(typeVarSignatures, constraintsClone.getConstraintSets());
                         }
                     }
                 });
@@ -17186,48 +17217,46 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     return false;
                 }
                 if (filteredOverloads.length === 1 || (flags & 8 /* AssignTypeFlags.ArgAssignmentFirstPass */) === 0) {
-                    if (destConstraints) {
-                        destConstraints.addConstraintSets(destTypeVarSignatures);
-                    }
-                    if (srcConstraints) {
-                        srcConstraints.addConstraintSets(srcTypeVarSignatures);
+                    if (constraints) {
+                        constraints.addConstraintSets(typeVarSignatures);
                     }
                 }
                 return true;
             }
             if ((0, types_1.isFunction)(concreteSrcType)) {
-                if (assignFunction(destType, concreteSrcType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destConstraints !== null && destConstraints !== void 0 ? destConstraints : new constraintTracker_1.ConstraintTracker(), srcConstraints !== null && srcConstraints !== void 0 ? srcConstraints : new constraintTracker_1.ConstraintTracker(), flags, recursionCount)) {
+                if (assignFunction(destType, concreteSrcType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), constraints !== null && constraints !== void 0 ? constraints : new constraintTracker_1.ConstraintTracker(), flags, recursionCount)) {
                     return true;
                 }
             }
         }
-        if ((0, types_1.isOverloadedFunction)(destType)) {
+        if ((0, types_1.isOverloaded)(destType)) {
             const overloadDiag = diag === null || diag === void 0 ? void 0 : diag.createAddendum();
             // All overloads in the dest must be assignable.
-            const destOverloads = types_1.OverloadedFunctionType.getOverloads(destType);
+            const destOverloads = types_1.OverloadedType.getOverloads(destType);
             // If the source is also an overload with the same number of overloads,
             // there's a good chance that there's a one-to-one mapping. Try this
             // first before using an n^2 algorithm.
-            if ((0, types_1.isOverloadedFunction)(srcType)) {
-                const srcOverloads = types_1.OverloadedFunctionType.getOverloads(srcType);
+            if ((0, types_1.isOverloaded)(srcType)) {
+                const srcOverloads = types_1.OverloadedType.getOverloads(srcType);
                 if (destOverloads.length === srcOverloads.length) {
                     if (destOverloads.every((destOverload, index) => {
                         const srcOverload = srcOverloads[index];
                         return assignType(destOverload, srcOverload, 
-                        /* diag */ undefined, destConstraints, srcConstraints, flags, recursionCount);
+                        /* diag */ undefined, constraints, flags, recursionCount);
                     })) {
                         return true;
                     }
                 }
             }
             const isAssignable = destOverloads.every((destOverload) => {
-                const result = assignType(destOverload, srcType, overloadDiag === null || overloadDiag === void 0 ? void 0 : overloadDiag.createAddendum(), destConstraints, srcConstraints, flags, recursionCount);
+                const result = assignType(destOverload, srcType, overloadDiag === null || overloadDiag === void 0 ? void 0 : overloadDiag.createAddendum(), constraints, flags, recursionCount);
                 return result;
             });
             if (!isAssignable) {
-                if (overloadDiag) {
+                const overloads = types_1.OverloadedType.getOverloads(destType);
+                if (overloadDiag && overloads.length > 0) {
                     overloadDiag.addMessage(localize_1.LocAddendum.overloadNotAssignable().format({
-                        name: destType.priv.overloads[0].shared.name,
+                        name: overloads[0].shared.name,
                     }));
                 }
                 return false;
@@ -17236,8 +17265,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         if ((0, types_1.isClass)(destType) && types_1.ClassType.isBuiltIn(destType, 'object')) {
             if (((0, types_1.isInstantiableClass)(destType) && types_1.TypeBase.isInstantiable(srcType)) || (0, types_1.isClassInstance)(destType)) {
-                if ((flags & 1 /* AssignTypeFlags.EnforceInvariance */) === 0) {
-                    // All types (including None, Module, OverloadedFunction) derive from object.
+                if ((flags & 1 /* AssignTypeFlags.Invariant */) === 0) {
+                    // All types (including None, Module, Overloaded) derive from object.
                     return true;
                 }
             }
@@ -17245,7 +17274,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // Are we trying to assign None to a protocol?
         if ((0, typeUtils_1.isNoneInstance)(srcType) && (0, types_1.isClassInstance)(destType) && types_1.ClassType.isProtocolClass(destType)) {
             if (noneTypeClass && (0, types_1.isInstantiableClass)(noneTypeClass)) {
-                return (0, protocols_1.assignClassToProtocol)(evaluatorInterface, types_1.ClassType.cloneAsInstantiable(destType), types_1.ClassType.cloneAsInstance(noneTypeClass), diag, destConstraints, srcConstraints, flags, recursionCount);
+                return (0, protocols_1.assignClassToProtocol)(evaluatorInterface, types_1.ClassType.cloneAsInstantiable(destType), types_1.ClassType.cloneAsInstance(noneTypeClass), diag, constraints, flags, recursionCount);
             }
         }
         if ((0, typeUtils_1.isNoneInstance)(destType)) {
@@ -17255,7 +17284,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.typeAssignmentMismatch().format(printSrcDestTypes(srcType, destType)));
         return false;
     }
-    function assignFromUnionType(destType, srcType, diag, destConstraints, srcConstraints, flags, recursionCount) {
+    function assignFromUnionType(destType, srcType, diag, constraints, flags, recursionCount) {
         // Start by checking for an exact match. This is needed to handle unions
         // that contain recursive type aliases.
         if ((0, types_1.isTypeSame)(srcType, destType, {}, recursionCount)) {
@@ -17272,8 +17301,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // the getattr function.
             const nonAnySubtypes = destType.priv.subtypes.filter((t) => !(0, types_1.isAnyOrUnknown)(t));
             if (nonAnySubtypes.length === 1 && (0, types_1.isTypeVar)(nonAnySubtypes[0])) {
-                assignType(nonAnySubtypes[0], srcType, 
-                /* diag */ undefined, destConstraints, srcConstraints, flags, recursionCount);
+                assignType(nonAnySubtypes[0], srcType, /* diag */ undefined, constraints, flags, recursionCount);
                 // This always succeeds because the destination contains Any.
                 return true;
             }
@@ -17314,14 +17342,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         if (types_1.ClassType.isTypedDictClass(srcSubtype) && types_1.ClassType.isTypedDictClass(destSubtype)) {
                             if (assignType(srcSubtype, destSubtype, 
                             /* diag */ undefined, 
-                            /* destConstraints */ undefined, 
-                            /* srcConstraints */ undefined, flags, recursionCount)) {
+                            /* constraints */ undefined, flags, recursionCount)) {
                                 return true;
                             }
                         }
                     }
-                    if ((0, types_1.isFunction)(srcSubtype) || (0, types_1.isOverloadedFunction)(srcSubtype)) {
-                        if ((0, types_1.isFunction)(destSubtype) || (0, types_1.isOverloadedFunction)(destSubtype)) {
+                    if ((0, types_1.isFunction)(srcSubtype) || (0, types_1.isOverloaded)(srcSubtype)) {
+                        if ((0, types_1.isFunction)(destSubtype) || (0, types_1.isOverloaded)(destSubtype)) {
                             return true;
                         }
                     }
@@ -17329,7 +17356,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 });
                 if (destTypeIndex >= 0) {
                     if (assignType(remainingDestSubtypes[destTypeIndex], srcSubtype, 
-                    /* diag */ undefined, destConstraints, srcConstraints, flags, recursionCount)) {
+                    /* diag */ undefined, constraints, flags, recursionCount)) {
                         // Note that we have matched at least one subtype indicating
                         // there is at least some overlap.
                         matchedSomeSubtypes = true;
@@ -17344,7 +17371,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // If there is are remaining dest subtypes and they're all type variables,
             // attempt to assign the remaining source subtypes to them.
             if (canUseFastPath && (remainingDestSubtypes.length !== 0 || remainingSrcSubtypes.length !== 0)) {
-                if ((flags & 1 /* AssignTypeFlags.EnforceInvariance */) !== 0) {
+                if ((flags & 1 /* AssignTypeFlags.Invariant */) !== 0) {
                     // If we have no src subtypes remaining but not all dest types have been subsumed
                     // by other dest types, then the types are not compatible if we're enforcing invariance.
                     if (remainingSrcSubtypes.length === 0) {
@@ -17352,8 +17379,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         /* allowAnyToSubsume */ true, recursionCount));
                     }
                 }
-                const isReversed = (flags & 2 /* AssignTypeFlags.ReverseTypeVarMatching */) !== 0;
-                const effectiveDestSubtypes = isReversed ? remainingSrcSubtypes : remainingDestSubtypes;
+                const isContra = (flags & 2 /* AssignTypeFlags.Contravariant */) !== 0;
+                const effectiveDestSubtypes = isContra ? remainingSrcSubtypes : remainingDestSubtypes;
                 if (effectiveDestSubtypes.length === 0 || effectiveDestSubtypes.some((t) => !(0, types_1.isTypeVar)(t))) {
                     canUseFastPath = false;
                     // We can avoid checking the source subtypes that have already been checked.
@@ -17366,7 +17393,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     for (let srcIndex = 0; srcIndex < remainingSrcSubtypes.length; srcIndex++) {
                         let foundMatchForSrc = false;
                         for (let destIndex = 0; destIndex < reorderedDestSubtypes.length; destIndex++) {
-                            if (assignType(reorderedDestSubtypes[destIndex], remainingSrcSubtypes[srcIndex], diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destConstraints, srcConstraints, flags, recursionCount)) {
+                            if (assignType(reorderedDestSubtypes[destIndex], remainingSrcSubtypes[srcIndex], diag === null || diag === void 0 ? void 0 : diag.createAddendum(), constraints, flags, recursionCount)) {
                                 foundMatchForSrc = true;
                                 // Move the matched dest TypeVar to the end of the list so the other
                                 // dest TypeVars have a better chance of being assigned to.
@@ -17383,13 +17410,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     sortedSrcTypes = remainingSrcSubtypes;
                 }
                 else if (remainingSrcSubtypes.length === 0) {
-                    if ((flags & 2048 /* AssignTypeFlags.PopulatingExpectedType */) !== 0) {
+                    if ((flags & 2048 /* AssignTypeFlags.PopulateExpectedType */) !== 0) {
                         // If we're populating an expected type, try not to leave
                         // any TypeVars unsolved. Assign the full type to the remaining
                         // dest TypeVars.
                         remainingDestSubtypes.forEach((destSubtype) => {
-                            assignType(destSubtype, srcType, 
-                            /* diag */ undefined, destConstraints, srcConstraints, flags, recursionCount);
+                            assignType(destSubtype, srcType, /* diag */ undefined, constraints, flags, recursionCount);
                         });
                     }
                     // If we've assigned all of the source subtypes but one or more dest
@@ -17398,7 +17424,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 else {
                     // Try to assign a union of the remaining source types to
                     // the first destination TypeVar.
-                    if (!assignType(isReversed ? (0, types_1.combineTypes)(remainingDestSubtypes) : remainingDestSubtypes[0], isReversed ? remainingSrcSubtypes[0] : (0, types_1.combineTypes)(remainingSrcSubtypes), diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destConstraints, srcConstraints, flags, recursionCount)) {
+                    if (!assignType(isContra ? (0, types_1.combineTypes)(remainingDestSubtypes) : remainingDestSubtypes[0], isContra ? remainingSrcSubtypes[0] : (0, types_1.combineTypes)(remainingSrcSubtypes), diag === null || diag === void 0 ? void 0 : diag.createAddendum(), constraints, flags, recursionCount)) {
                         canUseFastPath = false;
                     }
                 }
@@ -17417,15 +17443,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (isIncompatible) {
                 return;
             }
-            if (!assignType(destType, subtype, 
-            /* diag */ undefined, destConstraints, srcConstraints, flags, recursionCount)) {
+            if (!assignType(destType, subtype, /* diag */ undefined, constraints, flags, recursionCount)) {
                 // Determine if the current subtype is subsumed by another subtype
                 // in the same union. If so, we can ignore this.
                 const isSubtypeSubsumed = isTypeSubsumedByOtherType(subtype, srcType, 
                 /* allowAnyToSubsume */ false, recursionCount);
                 // Try again with a concrete version of the subtype.
                 if (!isSubtypeSubsumed &&
-                    !assignType(destType, subtype, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destConstraints, srcConstraints, flags, recursionCount)) {
+                    !assignType(destType, subtype, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), constraints, flags, recursionCount)) {
                     isIncompatible = true;
                 }
             }
@@ -17450,6 +17475,22 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return types_1.ClassType.isSpecialFormClass(classType);
     }
+    // Finds unsolved type variables in the destType and establishes constraints
+    // in the constraint tracker for them based on the srcType.
+    function setConstraintsForFreeTypeVars(destType, srcType, constraints) {
+        if (constraints.isLocked()) {
+            return;
+        }
+        const typeVars = (0, typeUtils_1.getTypeVarArgsRecursive)(destType);
+        typeVars.forEach((typeVar) => {
+            if (!types_1.TypeVarType.isBound(typeVar) && !constraints.getMainConstraintSet().getTypeVar(typeVar)) {
+                // Don't set ParamSpecs or TypeVarTuples.
+                if (!(0, types_1.isParamSpec)(srcType) && !(0, types_1.isTypeVarTuple)(srcType)) {
+                    constraints.setBounds(typeVar, srcType);
+                }
+            }
+        });
+    }
     // Determines whether a type is "subsumed by" (i.e. is a proper subtype of) another type.
     function isTypeSubsumedByOtherType(type, otherType, allowAnyToSubsume, recursionCount = 0) {
         const concreteType = makeTopLevelTypeVarsConcrete(type);
@@ -17492,22 +17533,20 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return (assignType(destType, srcType, 
         /* diag */ undefined, 
-        /* destConstraints */ undefined, 
-        /* srcConstraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount) &&
+        /* constraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount) &&
             !assignType(srcType, destType, 
             /* diag */ undefined, 
-            /* destConstraints */ undefined, 
-            /* srcConstraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount));
+            /* constraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount));
     }
-    function assignToUnionType(destType, srcType, diag, destConstraints, srcConstraints, flags, recursionCount) {
+    function assignToUnionType(destType, srcType, diag, constraints, flags, recursionCount) {
         // If we need to enforce invariance, the source needs to be compatible
         // with all subtypes in the dest, unless those subtypes are subclasses
         // of other subtypes.
-        if (flags & 1 /* AssignTypeFlags.EnforceInvariance */) {
+        if (flags & 1 /* AssignTypeFlags.Invariant */) {
             let isIncompatible = false;
             (0, typeUtils_1.doForEachSubtype)(destType, (subtype, index) => {
                 if (!isIncompatible &&
-                    !assignType(subtype, srcType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destConstraints, srcConstraints, flags, recursionCount)) {
+                    !assignType(subtype, srcType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), constraints, flags, recursionCount)) {
                     // Determine whether this subtype is subsumed by some other
                     // subtype in the union. If so, we can ignore the incompatibility.
                     let skipSubtype = false;
@@ -17518,8 +17557,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                                 const adjOtherSubtype = (0, typeUtils_1.makeTypeVarsBound)(otherSubtype, /* scopeIds */ undefined);
                                 if (assignType(adjOtherSubtype, adjSubtype, 
                                 /* diag */ undefined, 
-                                /* destConstraints */ undefined, 
-                                /* srcConstraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount)) {
+                                /* constraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount)) {
                                     skipSubtype = true;
                                 }
                             }
@@ -17543,7 +17581,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // If so, we need to use a slower path.
         if (!(0, typeUtils_1.requiresSpecialization)(destType)) {
             for (const subtype of destType.priv.subtypes) {
-                if (assignType(subtype, srcType, diagAddendum === null || diagAddendum === void 0 ? void 0 : diagAddendum.createAddendum(), destConstraints, srcConstraints, flags, recursionCount)) {
+                if (assignType(subtype, srcType, diagAddendum === null || diagAddendum === void 0 ? void 0 : diagAddendum.createAddendum(), constraints, flags, recursionCount)) {
                     foundMatch = true;
                     break;
                 }
@@ -17558,8 +17596,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 foundMatch = true;
             }
             else {
-                let bestDestConstraints;
-                let bestSrcConstraints;
+                let bestConstraints;
                 let bestConstraintsScore;
                 let nakedTypeVarMatches = 0;
                 // If the srcType is a literal, try to use the fast-path lookup
@@ -17572,16 +17609,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 (0, typeUtils_1.doForEachSubtype)(destType, (subtype) => {
                     // Make a temporary clone of the constraints. We don't want to modify
                     // the original constraints until we find the "optimal" typeVar mapping.
-                    const destConstraintsClone = destConstraints === null || destConstraints === void 0 ? void 0 : destConstraints.clone();
-                    const srcConstraintsClone = srcConstraints === null || srcConstraints === void 0 ? void 0 : srcConstraints.clone();
-                    if (assignType(subtype, srcType, diagAddendum === null || diagAddendum === void 0 ? void 0 : diagAddendum.createAddendum(), destConstraintsClone, srcConstraintsClone, flags, recursionCount)) {
+                    const constraintsClone = constraints === null || constraints === void 0 ? void 0 : constraints.clone();
+                    if (assignType(subtype, srcType, diagAddendum === null || diagAddendum === void 0 ? void 0 : diagAddendum.createAddendum(), constraintsClone, flags, recursionCount)) {
                         foundMatch = true;
-                        if (destConstraintsClone) {
+                        if (constraintsClone) {
                             // Ask the constraints to compute a "score" for the current
                             // contents of the table.
-                            let constraintsScore = destConstraintsClone.getScore();
+                            let constraintsScore = constraintsClone.getScore();
                             if ((0, types_1.isTypeVar)(subtype)) {
-                                if (!(destConstraints === null || destConstraints === void 0 ? void 0 : destConstraints.getMainConstraintSet().getTypeVar(subtype))) {
+                                if (!(constraints === null || constraints === void 0 ? void 0 : constraints.getMainConstraintSet().getTypeVar(subtype))) {
                                     nakedTypeVarMatches++;
                                     // Handicap the solution slightly so another type var with
                                     // existing constraints will be preferred.
@@ -17595,8 +17631,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             if (bestConstraintsScore === undefined || bestConstraintsScore <= constraintsScore) {
                                 // We found a typeVar mapping with a higher score than before.
                                 bestConstraintsScore = constraintsScore;
-                                bestDestConstraints = destConstraintsClone;
-                                bestSrcConstraints = srcConstraintsClone;
+                                bestConstraints = constraintsClone;
                             }
                         }
                     }
@@ -17608,15 +17643,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 // Typically, they will receive some constraints via some
                 // later argument assignment.
                 if (nakedTypeVarMatches > 1 && (flags & 8 /* AssignTypeFlags.ArgAssignmentFirstPass */) !== 0) {
-                    bestDestConstraints = undefined;
-                    bestSrcConstraints = undefined;
+                    bestConstraints = undefined;
                 }
                 // If we found a winning type var mapping, copy it back to constraints.
-                if (destConstraints && bestDestConstraints) {
-                    destConstraints.copyFromClone(bestDestConstraints);
-                }
-                if (srcConstraints && bestSrcConstraints) {
-                    srcConstraints.copyFromClone(bestSrcConstraints);
+                if (constraints && bestConstraints) {
+                    constraints.copyFromClone(bestConstraints);
                 }
             }
         }
@@ -17624,7 +17655,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // constraints to the union.
         if (!foundMatch) {
             if ((0, types_1.isTypeVar)(srcType) && types_1.TypeVarType.hasConstraints(srcType)) {
-                foundMatch = assignType(destType, makeTopLevelTypeVarsConcrete(srcType), diagAddendum === null || diagAddendum === void 0 ? void 0 : diagAddendum.createAddendum(), destConstraints, srcConstraints, flags, recursionCount);
+                foundMatch = assignType(destType, makeTopLevelTypeVarsConcrete(srcType), diagAddendum === null || diagAddendum === void 0 ? void 0 : diagAddendum.createAddendum(), constraints, flags, recursionCount);
             }
         }
         if (!foundMatch) {
@@ -17660,15 +17691,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         (0, debug_1.assert)(condition.constraintIndex === 0, 'Expected constraint for bound TypeVar to have index of 0');
                         return assignType(destType.shared.boundType, srcSubtype, 
                         /* diag */ undefined, 
-                        /* destConstraints */ undefined, 
-                        /* srcConstraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount);
+                        /* constraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount);
                     }
                     if (types_1.TypeVarType.hasConstraints(destType)) {
                         (0, debug_1.assert)(condition.constraintIndex < destType.shared.constraints.length, 'Constraint for constrained TypeVar is out of bounds');
                         return assignType(destType.shared.constraints[condition.constraintIndex], srcSubtype, 
                         /* diag */ undefined, 
-                        /* destConstraints */ undefined, 
-                        /* srcConstraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount);
+                        /* constraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount);
                     }
                     // This is a non-bound and non-constrained type variable with a matching condition.
                     return true;
@@ -17706,7 +17735,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return getBoundMagicMethod(objType, '__call__', /* selfType */ undefined, /* diag */ undefined, recursionCount);
     }
-    function assignParam(destType, srcType, paramIndex, diag, destConstraints, srcConstraints, flags, recursionCount) {
+    function assignParam(destType, srcType, paramIndex, diag, constraints, flags, recursionCount) {
         // Handle the special case where the dest type is a synthesized
         // "self" for a protocol class.
         if ((0, types_1.isTypeVar)(destType) &&
@@ -17724,19 +17753,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         let doSpecializationStep = false;
         if ((flags & 16 /* AssignTypeFlags.OverloadOverlap */) === 0) {
             const isFirstPass = (flags & 8 /* AssignTypeFlags.ArgAssignmentFirstPass */) !== 0;
-            if ((flags & 2 /* AssignTypeFlags.ReverseTypeVarMatching */) === 0) {
+            if ((flags & 2 /* AssignTypeFlags.Contravariant */) === 0) {
                 if (!isFirstPass) {
-                    specializedDestType = solveAndApplyConstraints(destType, destConstraints, 
-                    /* applyOptions */ undefined, {
-                        useLowerBoundOnly: true,
-                    });
+                    specializedDestType = solveAndApplyConstraints(destType, constraints, 
+                    /* applyOptions */ undefined, { useLowerBoundOnly: true });
                 }
                 doSpecializationStep = (0, typeUtils_1.requiresSpecialization)(specializedDestType);
             }
             else {
                 if (!isFirstPass) {
-                    specializedSrcType = solveAndApplyConstraints(srcType, srcConstraints, 
-                    /* applyOptions */ undefined, {
+                    specializedSrcType = solveAndApplyConstraints(srcType, constraints, /* applyOptions */ undefined, {
                         useLowerBoundOnly: true,
                     });
                 }
@@ -17746,16 +17772,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // Is an additional specialization step required?
         if (doSpecializationStep) {
             if (assignType(specializedSrcType, specializedDestType, 
-            /* diag */ undefined, srcConstraints, destConstraints, (flags ^ 2 /* AssignTypeFlags.ReverseTypeVarMatching */) | 256 /* AssignTypeFlags.RetainLiteralsForTypeVar */, recursionCount)) {
-                if ((flags & 2 /* AssignTypeFlags.ReverseTypeVarMatching */) === 0) {
-                    specializedDestType = solveAndApplyConstraints(destType, destConstraints);
-                }
-                else {
-                    specializedSrcType = solveAndApplyConstraints(srcType, srcConstraints);
-                }
+            /* diag */ undefined, constraints, (flags ^ 2 /* AssignTypeFlags.Contravariant */) | 256 /* AssignTypeFlags.RetainLiteralsForTypeVar */, recursionCount)) {
+                specializedDestType = solveAndApplyConstraints(destType, constraints);
             }
         }
-        if (!assignType(specializedSrcType, specializedDestType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), srcConstraints, destConstraints, flags, recursionCount)) {
+        if (!assignType(specializedSrcType, specializedDestType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), constraints, flags, recursionCount)) {
             if (diag && paramIndex !== undefined) {
                 diag.addMessage(localize_1.LocAddendum.paramAssignment().format({
                     index: paramIndex + 1,
@@ -17842,11 +17863,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             srcDetails.positionOnlyParamCount = Math.max(0, srcDetails.params.findIndex((p) => p.kind !== parameterUtils_1.ParamKind.Positional || p.param.category !== 0 /* ParamCategory.Simple */ || !!p.defaultType));
         }
     }
-    function assignFunction(destType, srcType, diag, destConstraints, srcConstraints, flags, recursionCount) {
+    function assignFunction(destType, srcType, diag, constraints, flags, recursionCount) {
         var _a, _b, _c, _d, _e, _f, _g, _h;
         let canAssign = true;
         const checkReturnType = (flags & 64 /* AssignTypeFlags.SkipReturnTypeCheck */) === 0;
-        const reverseMatching = (flags & 2 /* AssignTypeFlags.ReverseTypeVarMatching */) !== 0;
+        const isContra = (flags & 2 /* AssignTypeFlags.Contravariant */) !== 0;
         flags &= ~64 /* AssignTypeFlags.SkipReturnTypeCheck */;
         const destParamSpec = types_1.FunctionType.getParamSpecFromArgsKwargs(destType);
         if (destParamSpec) {
@@ -17858,8 +17879,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         const destParamDetails = (0, parameterUtils_1.getParamListDetails)(destType);
         const srcParamDetails = (0, parameterUtils_1.getParamListDetails)(srcType);
-        adjustSourceParamDetailsForDestVariadic(reverseMatching ? destParamDetails : srcParamDetails, reverseMatching ? srcParamDetails : destParamDetails);
-        const targetIncludesParamSpec = reverseMatching ? !!srcParamSpec : !!destParamSpec;
+        adjustSourceParamDetailsForDestVariadic(isContra ? destParamDetails : srcParamDetails, isContra ? srcParamDetails : destParamDetails);
+        const targetIncludesParamSpec = isContra ? !!srcParamSpec : !!destParamSpec;
         const destPositionalCount = (_a = destParamDetails.firstKeywordOnlyIndex) !== null && _a !== void 0 ? _a : destParamDetails.params.length;
         const srcPositionalCount = (_b = srcParamDetails.firstKeywordOnlyIndex) !== null && _b !== void 0 ? _b : srcParamDetails.params.length;
         const positionalsToMatch = Math.min(destPositionalCount, srcPositionalCount);
@@ -17924,7 +17945,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if ((0, types_1.isUnpacked)(srcParamType)) {
                 canAssign = false;
             }
-            else if (!assignParam(destParamType, srcParamType, paramIndex, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destConstraints, srcConstraints, flags, recursionCount)) {
+            else if (!assignParam(destParamType, srcParamType, paramIndex, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), constraints, flags, recursionCount)) {
                 // Handle the special case where the source parameter is a synthesized
                 // TypeVar for "self" or "cls".
                 if ((flags & 512 /* AssignTypeFlags.SkipSelfClsTypeCheck */) === 0 ||
@@ -17961,7 +17982,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 if (destParamDetails.argsIndex !== undefined) {
                     const destArgsType = destParamDetails.params[destParamDetails.argsIndex].type;
                     const srcParamType = srcParamDetails.params[i].type;
-                    if (!assignParam(destArgsType, srcParamType, i, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destConstraints, srcConstraints, flags, recursionCount)) {
+                    if (!assignParam(destArgsType, srcParamType, i, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), constraints, flags, recursionCount)) {
                         canAssign = false;
                     }
                     continue;
@@ -17974,9 +17995,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     // populating TypeVar constraints.
                     const paramInfo = srcParamDetails.params[i];
                     const defaultArgType = (_f = paramInfo.defaultType) !== null && _f !== void 0 ? _f : paramInfo.defaultType;
+                    // Enforce invariance below because the default arg value
+                    // is constructed prior to the call, so its type is already
+                    // fixed.
                     if (defaultArgType &&
-                        !assignType(paramInfo.type, defaultArgType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), srcConstraints, 
-                        /* destConstraints */ undefined, flags, recursionCount)) {
+                        !assignType(paramInfo.type, defaultArgType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), constraints, flags, recursionCount)) {
                         canAssign = false;
                     }
                     continue;
@@ -18015,7 +18038,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         canAssign = false;
                     }
                     else {
-                        if (!assignParam(destParamType, srcArgsType, paramIndex, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destConstraints, srcConstraints, flags, recursionCount)) {
+                        if (!assignParam(destParamType, srcArgsType, paramIndex, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), constraints, flags, recursionCount)) {
                             canAssign = false;
                         }
                         if (destParamDetails.params[paramIndex].kind !== parameterUtils_1.ParamKind.Positional &&
@@ -18057,7 +18080,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (!(0, types_1.isUnpacked)(srcArgsType)) {
                 srcArgsType = makeTupleObject([{ type: srcArgsType, isUnbounded: true }], /* isUnpackedTuple */ true);
             }
-            if (!assignParam(destArgsType, srcArgsType, destParamDetails.params[destParamDetails.argsIndex].index, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destConstraints, srcConstraints, flags, recursionCount)) {
+            if (!assignParam(destArgsType, srcArgsType, destParamDetails.params[destParamDetails.argsIndex].index, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), constraints, flags, recursionCount)) {
                 canAssign = false;
             }
         }
@@ -18115,7 +18138,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                                 }
                                 else if (destParamDetails.kwargsIndex !== undefined) {
                                     // Make sure we can assign the type to the Kwargs.
-                                    if (!assignParam(destParamDetails.params[destParamDetails.kwargsIndex].type, srcParamType, destParamDetails.params[destParamDetails.kwargsIndex].index, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destConstraints, srcConstraints, flags, recursionCount)) {
+                                    if (!assignParam(destParamDetails.params[destParamDetails.kwargsIndex].type, srcParamType, destParamDetails.params[destParamDetails.kwargsIndex].index, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), constraints, flags, recursionCount)) {
                                         canAssign = false;
                                     }
                                 }
@@ -18124,19 +18147,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                                     // populating TypeVar constraints.
                                     const defaultArgType = (_a = srcParamInfo.defaultType) !== null && _a !== void 0 ? _a : srcParamInfo.defaultType;
                                     if (defaultArgType &&
-                                        !assignType(srcParamInfo.type, defaultArgType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), srcConstraints, 
-                                        /* destConstraints */ undefined, flags, recursionCount)) {
+                                        !assignType(srcParamInfo.type, defaultArgType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), constraints, flags, recursionCount)) {
                                         canAssign = false;
                                     }
                                 }
                             }
                             else {
                                 const destParamType = destParamInfo.type;
-                                const specializedDestParamType = destConstraints
-                                    ? solveAndApplyConstraints(destParamType, destConstraints)
+                                const specializedDestParamType = constraints
+                                    ? solveAndApplyConstraints(destParamType, constraints)
                                     : destParamType;
                                 if (!assignParam(destParamInfo.type, srcParamType, 
-                                /* paramIndex */ undefined, paramDiag === null || paramDiag === void 0 ? void 0 : paramDiag.createAddendum(), destConstraints, srcConstraints, flags, recursionCount)) {
+                                /* paramIndex */ undefined, paramDiag === null || paramDiag === void 0 ? void 0 : paramDiag.createAddendum(), constraints, flags, recursionCount)) {
                                     if (paramDiag) {
                                         paramDiag.addMessage(localize_1.LocAddendum.namedParamTypeMismatch().format({
                                             name: srcParamInfo.param.name,
@@ -18162,7 +18184,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             destParamMap.forEach((destParamInfo, paramName) => {
                 if (srcParamDetails.kwargsIndex !== undefined && destParamInfo.param.name) {
                     // Make sure the src kwargs type is compatible.
-                    if (!assignParam(destParamInfo.type, srcParamDetails.params[srcParamDetails.kwargsIndex].type, destParamInfo.index, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destConstraints, srcConstraints, flags, recursionCount)) {
+                    if (!assignParam(destParamInfo.type, srcParamDetails.params[srcParamDetails.kwargsIndex].type, destParamInfo.index, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), constraints, flags, recursionCount)) {
                         canAssign = false;
                     }
                     destParamMap.delete(paramName);
@@ -18174,7 +18196,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             });
             // If both src and dest have a "**kwargs" parameter, make sure their types are compatible.
             if (srcParamDetails.kwargsIndex !== undefined && destParamDetails.kwargsIndex !== undefined) {
-                if (!assignParam(destParamDetails.params[destParamDetails.kwargsIndex].type, srcParamDetails.params[srcParamDetails.kwargsIndex].type, destParamDetails.params[destParamDetails.kwargsIndex].index, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destConstraints, srcConstraints, flags, recursionCount)) {
+                if (!assignParam(destParamDetails.params[destParamDetails.kwargsIndex].type, srcParamDetails.params[srcParamDetails.kwargsIndex].type, destParamDetails.params[destParamDetails.kwargsIndex].index, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), constraints, flags, recursionCount)) {
                     canAssign = false;
                 }
             }
@@ -18197,26 +18219,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 canAssign = false;
             }
         }
-        // If the target function was generic and we solved some of the type variables
-        // in that generic type, assign them back to the destination typeVar.
-        const effectiveSrcConstraints = reverseMatching ? destConstraints : srcConstraints;
-        if (!effectiveSrcConstraints.isEmpty()) {
-            const srcConstraintSet = effectiveSrcConstraints.getMainConstraintSet();
-            const solutionSet = (0, constraintSolver_1.solveConstraints)(evaluatorInterface, effectiveSrcConstraints).getMainSolutionSet();
-            srcConstraintSet.doForEachTypeVar((entry) => {
-                const solvedValue = solutionSet.getType(entry.typeVar);
-                if (solvedValue) {
-                    assignType(entry.typeVar, solvedValue, 
-                    /* diag */ undefined, destConstraints, srcConstraints, 0 /* AssignTypeFlags.Default */, recursionCount);
-                }
-            });
-        }
         // Are we assigning to a function with a ParamSpec?
         if (targetIncludesParamSpec) {
-            const effectiveSrcType = reverseMatching ? destType : srcType;
-            const effectiveDestType = reverseMatching ? srcType : destType;
-            const effectiveSrcParamSpec = reverseMatching ? destParamSpec : srcParamSpec;
-            const effectiveDestParamSpec = reverseMatching ? srcParamSpec : destParamSpec;
+            const effectiveSrcType = isContra ? destType : srcType;
+            const effectiveDestType = isContra ? srcType : destType;
+            const effectiveSrcParamSpec = isContra ? destParamSpec : srcParamSpec;
+            const effectiveDestParamSpec = isContra ? srcParamSpec : destParamSpec;
             if (effectiveDestParamSpec) {
                 const requiredMatchParamCount = effectiveDestType.shared.parameters.filter((p, i) => {
                     if (!p.name) {
@@ -18265,15 +18273,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     if (effectiveSrcParamSpec) {
                         types_1.FunctionType.addParamSpecVariadics(remainingFunction, (0, typeUtils_1.convertToInstance)(effectiveSrcParamSpec));
                     }
-                    if (!assignType(effectiveDestParamSpec, remainingFunction, 
-                    /* diag */ undefined, destConstraints, srcConstraints, flags)) {
+                    if (!assignType(effectiveDestParamSpec, remainingFunction, /* diag */ undefined, constraints, flags)) {
                         // If we couldn't assign the function to the ParamSpec, see if we can
                         // assign only the ParamSpec. This is possible if there were no
                         // remaining parameters.
                         if (remainingParams.length > 0 ||
                             !effectiveSrcParamSpec ||
                             !assignType((0, typeUtils_1.convertToInstance)(effectiveDestParamSpec), (0, typeUtils_1.convertToInstance)(effectiveSrcParamSpec), 
-                            /* diag */ undefined, destConstraints, srcConstraints, flags)) {
+                            /* diag */ undefined, constraints, flags)) {
                             canAssign = false;
                         }
                     }
@@ -18282,9 +18289,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         // Match the return parameter.
         if (checkReturnType) {
-            const destReturnType = getFunctionEffectiveReturnType(destType);
+            const destReturnType = getEffectiveReturnType(destType);
             if (!(0, types_1.isAnyOrUnknown)(destReturnType)) {
-                const srcReturnType = solveAndApplyConstraints(getFunctionEffectiveReturnType(srcType), srcConstraints);
+                const srcReturnType = solveAndApplyConstraints(getEffectiveReturnType(srcType), constraints);
                 const returnDiag = diag === null || diag === void 0 ? void 0 : diag.createAddendum();
                 let isReturnTypeCompatible = false;
                 let effectiveFlags = flags;
@@ -18295,7 +18302,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     (0, typeUtils_1.containsLiteralType)(srcType.shared.declaredReturnType, /* includeTypeArgs */ true)) {
                     effectiveFlags |= 256 /* AssignTypeFlags.RetainLiteralsForTypeVar */;
                 }
-                if (assignType(destReturnType, srcReturnType, returnDiag === null || returnDiag === void 0 ? void 0 : returnDiag.createAddendum(), destConstraints, srcConstraints, effectiveFlags, recursionCount)) {
+                if (assignType(destReturnType, srcReturnType, returnDiag === null || returnDiag === void 0 ? void 0 : returnDiag.createAddendum(), constraints, effectiveFlags, recursionCount)) {
                     isReturnTypeCompatible = true;
                 }
                 else {
@@ -18306,7 +18313,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         types_1.ClassType.isBuiltIn(srcReturnType, ['TypeGuard', 'TypeIs']) &&
                         boolClass &&
                         (0, types_1.isInstantiableClass)(boolClass)) {
-                        if (assignType(destReturnType, types_1.ClassType.cloneAsInstance(boolClass), returnDiag === null || returnDiag === void 0 ? void 0 : returnDiag.createAddendum(), destConstraints, srcConstraints, flags, recursionCount)) {
+                        if (assignType(destReturnType, types_1.ClassType.cloneAsInstance(boolClass), returnDiag === null || returnDiag === void 0 ? void 0 : returnDiag.createAddendum(), constraints, flags, recursionCount)) {
                             isReturnTypeCompatible = true;
                         }
                     }
@@ -18322,9 +18329,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
             }
         }
-        // Apply any solved source TypeVars to the dest TypeVar solutions. This
-        // allows for higher-order functions to accept generic callbacks.
-        (0, typeUtils_1.applySourceContextTypeVars)(destConstraints, (0, constraintSolver_1.solveConstraints)(evaluatorInterface, srcConstraints));
         return canAssign;
     }
     // If the declaredType contains type arguments that are "Any" and
@@ -18470,7 +18474,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     function validateOverrideMethod(baseMethod, overrideMethod, baseClass, diag, enforceParamNames = true) {
         // If we're overriding a non-method with a method, report it as an error.
         // This occurs when a non-property overrides a property.
-        if (!(0, types_1.isFunction)(baseMethod) && !(0, types_1.isOverloadedFunction)(baseMethod)) {
+        if (!(0, types_1.isFunction)(baseMethod) && !(0, types_1.isOverloaded)(baseMethod)) {
             diag.addMessage(localize_1.LocAddendum.overrideType().format({ type: printType(baseMethod) }));
             return false;
         }
@@ -18479,9 +18483,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if ((0, types_1.isFunction)(overrideMethod)) {
                 return validateOverrideMethodInternal(baseMethod, overrideMethod, diag, enforceParamNames);
             }
+            const overloadsAndImpl = [...types_1.OverloadedType.getOverloads(overrideMethod)];
+            const impl = types_1.OverloadedType.getImplementation(overrideMethod);
+            if (impl && (0, types_1.isFunction)(impl)) {
+                overloadsAndImpl.push(impl);
+            }
             // For an overload overriding a base method, at least one overload
             // or the implementation must be compatible with the base method.
-            if (overrideMethod.priv.overloads.some((overrideOverload) => {
+            if (overloadsAndImpl.some((overrideOverload) => {
                 return validateOverrideMethodInternal(baseMethod, overrideOverload, 
                 /* diag */ undefined, enforceParamNames);
             })) {
@@ -18493,7 +18502,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // For a non-overloaded method overriding an overloaded method, the
         // override must match all of the overloads.
         if ((0, types_1.isFunction)(overrideMethod)) {
-            return types_1.OverloadedFunctionType.getOverloads(baseMethod).every((overload) => {
+            return types_1.OverloadedType.getOverloads(baseMethod).every((overload) => {
                 // If the override isn't applicable for this base class, skip the check.
                 if (baseClass && !isOverrideMethodApplicable(overload, baseClass)) {
                     return true;
@@ -18505,8 +18514,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // must all match and be in the correct order. It is OK if the base method
         // has additional overloads that are not present in the override.
         let previousMatchIndex = -1;
-        const baseOverloads = types_1.OverloadedFunctionType.getOverloads(baseMethod);
-        for (const overrideOverload of types_1.OverloadedFunctionType.getOverloads(overrideMethod)) {
+        const baseOverloads = types_1.OverloadedType.getOverloads(baseMethod);
+        for (const overrideOverload of types_1.OverloadedType.getOverloads(overrideMethod)) {
             let possibleMatchIndex;
             let matchIndex = baseOverloads.findIndex((baseOverload, index) => {
                 // If the override isn't applicable for this base class, skip the check.
@@ -18580,8 +18589,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             : childClass;
         return assignType(baseParamDetails.params[0].type, childSelfOrClsType, 
         /* diag */ undefined, 
-        /* destConstraints */ undefined, 
-        /* srcConstraints */ undefined, 0 /* AssignTypeFlags.Default */);
+        /* constraints */ undefined, 0 /* AssignTypeFlags.Default */);
     }
     // Determines whether the override method is compatible with the overridden method.
     // This is used both for parent/child overrides and implicit overrides for peer
@@ -18627,8 +18635,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     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(), 
-                        /* destConstraints */ undefined, 
-                        /* srcConstraints */ undefined, 0 /* AssignTypeFlags.Default */)) {
+                        /* constraints */ undefined, 0 /* AssignTypeFlags.Default */)) {
                             localize_1.LocAddendum.overrideParamType().format({
                                 index: i + 1,
                                 baseType: printType(baseParamDetails.params[i].type),
@@ -18717,8 +18724,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     if (!exemptSelfClsParam || (!baseIsSynthesizedTypeVar && !overrideIsSynthesizedTypeVar)) {
                         if (baseParam.category !== overrideParam.category ||
                             !assignType(overrideParamType, baseParamType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), 
-                            /* destConstraints */ undefined, 
-                            /* srcConstraints */ undefined, 0 /* AssignTypeFlags.Default */)) {
+                            /* constraints */ undefined, 0 /* AssignTypeFlags.Default */)) {
                             diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.overrideParamType().format({
                                 index: i + 1,
                                 baseType: printType(baseParamType),
@@ -18761,8 +18767,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     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(), 
-                    /* destConstraints */ undefined, 
-                    /* srcConstraints */ undefined, 0 /* AssignTypeFlags.Default */)) {
+                    /* constraints */ undefined, 0 /* AssignTypeFlags.Default */)) {
                         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),
@@ -18790,8 +18795,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         targetParamType = overrideParamDetails.params[overrideParamDetails.kwargsIndex].type;
                     }
                     if (!assignType(targetParamType, paramInfo.type, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), 
-                    /* destConstraints */ undefined, 
-                    /* srcConstraints */ undefined, 0 /* AssignTypeFlags.Default */)) {
+                    /* constraints */ undefined, 0 /* AssignTypeFlags.Default */)) {
                         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),
@@ -18847,11 +18851,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
         }
         // Now check the return type.
-        const baseReturnType = getFunctionEffectiveReturnType(baseMethod);
-        const overrideReturnType = getFunctionEffectiveReturnType(overrideMethod);
+        const baseReturnType = getEffectiveReturnType(baseMethod);
+        const overrideReturnType = getEffectiveReturnType(overrideMethod);
         if (!assignType(baseReturnType, overrideReturnType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), 
-        /* destConstraints */ undefined, 
-        /* srcConstraints */ undefined, 0 /* AssignTypeFlags.Default */)) {
+        /* constraints */ undefined, 0 /* AssignTypeFlags.Default */)) {
             diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.overrideReturnType().format({
                 baseType: printType(baseReturnType),
                 overrideType: printType(overrideReturnType),
@@ -18883,8 +18886,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // If there's a bound type, make sure the source is derived from it.
         if (destType.shared.boundType && !(0, typeUtils_1.isTypeAliasPlaceholder)(effectiveSrcType)) {
             if (!assignType(destType.shared.boundType, effectiveSrcType, diag.createAddendum(), 
-            /* destConstraints */ undefined, 
-            /* srcConstraints */ undefined)) {
+            /* constraints */ undefined)) {
                 // Avoid adding a message that will confuse users if the TypeVar was
                 // synthesized for internal purposes.
                 if (!destType.shared.isSynthesized) {
@@ -19054,8 +19056,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             else {
                 const subDiag = diag === null || diag === void 0 ? void 0 : diag.createAddendum();
-                if (!assignType(memberTypeFirstParamType, firstParamType, subDiag === null || subDiag === void 0 ? void 0 : subDiag.createAddendum(), constraints, 
-                /* srcConstraints */ undefined, 8192 /* AssignTypeFlags.AllowUnspecifiedTypeArgs */, recursionCount)) {
+                if (!assignType(memberTypeFirstParamType, firstParamType, subDiag === null || subDiag === void 0 ? void 0 : subDiag.createAddendum(), constraints, 8192 /* AssignTypeFlags.AllowUnspecifiedTypeArgs */, recursionCount)) {
                     if (memberTypeFirstParam.name &&
                         !types_1.FunctionParam.isNameSynthesized(memberTypeFirstParam) &&
                         types_1.FunctionParam.isTypeDeclared(memberTypeFirstParam)) {
@@ -19073,7 +19074,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         // Get the effective return type, which will have the side effect of lazily
         // evaluating (and caching) the inferred return type if there is no defined return type.
-        getFunctionEffectiveReturnType(memberType);
+        getEffectiveReturnType(memberType);
         const specializedFunction = solveAndApplyConstraints(memberType, constraints);
         return types_1.FunctionType.clone(specializedFunction, stripFirstParam, baseType);
     }
@@ -19193,11 +19194,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         return false;
     }
     function printObjectTypeForClass(type) {
-        return TypePrinter.printObjectTypeForClass(type, evaluatorOptions.printTypeFlags, getFunctionEffectiveReturnType);
+        return TypePrinter.printObjectTypeForClass(type, evaluatorOptions.printTypeFlags, getEffectiveReturnType);
     }
     function printFunctionParts(type, extraFlags) {
         const flags = extraFlags ? evaluatorOptions.printTypeFlags | extraFlags : evaluatorOptions.printTypeFlags;
-        return TypePrinter.printFunctionParts(type, flags, getFunctionEffectiveReturnType);
+        return TypePrinter.printFunctionParts(type, flags, getEffectiveReturnType);
     }
     // Prints two types and determines whether they need to be output in
     // fully-qualified form for disambiguation.
@@ -19237,7 +19238,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (options === null || options === void 0 ? void 0 : options.useFullyQualifiedNames) {
             flags |= 4096 /* TypePrinter.PrintTypeFlags.UseFullyQualifiedNames */;
         }
-        return TypePrinter.printType(type, flags, getFunctionEffectiveReturnType);
+        return TypePrinter.printType(type, flags, getEffectiveReturnType);
     }
     // Calls back into the parser to parse the contents of a string literal.
     // This is unfortunately needed in some cases — specifically where the
@@ -19298,7 +19299,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         return codeFlowEngine.printControlFlowGraph(flowNode, reference, callName, logger);
     }
     // Track these apis internal usages when logging is on. otherwise, it should be noop.
-    const getFunctionInferredReturnType = wrapWithLogger(_getFunctionInferredReturnType);
+    const getFunctionInferredReturnType = wrapWithLogger(_getInferredReturnType);
     const evaluatorInterface = {
         runWithCancellationToken,
         getType,
@@ -19355,7 +19356,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         getEffectiveTypeOfSymbolForUsage,
         getInferredTypeOfDeclaration,
         getDeclaredTypeForExpression,
-        getFunctionDeclaredReturnType,
+        getFunctionDeclaredReturnType: getDeclaredReturnType,
         getFunctionInferredReturnType,
         getBestOverloadForArgs,
         getBuiltInType,
@@ -19408,5 +19409,4 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     const codeFlowEngine = (0, codeFlowEngine_1.getCodeFlowEngine)(evaluatorInterface, speculativeTypeTracker);
     return evaluatorInterface;
 }
-exports.createTypeEvaluator = createTypeEvaluator;
 //# sourceMappingURL=typeEvaluator.js.map