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

package/dist/analyzer/typeEvaluator.js

@@ -56,6 +56,7 @@ const AnalyzerNodeInfo = __importStar(require("./analyzerNodeInfo"));
 const codeFlowEngine_1 = require("./codeFlowEngine");
 const codeFlowTypes_1 = require("./codeFlowTypes");
 const constraintSolver_1 = require("./constraintSolver");
+const constraintTracker_1 = require("./constraintTracker");
 const constructors_1 = require("./constructors");
 const dataClasses_1 = require("./dataClasses");
 const declarationUtils_1 = require("./declarationUtils");
@@ -76,12 +77,11 @@ const symbolNameUtils_1 = require("./symbolNameUtils");
 const symbolUtils_1 = require("./symbolUtils");
 const tuples_1 = require("./tuples");
 const typeCacheUtils_1 = require("./typeCacheUtils");
+const typedDicts_1 = require("./typedDicts");
 const typeEvaluatorTypes_1 = require("./typeEvaluatorTypes");
 const TypePrinter = __importStar(require("./typePrinter"));
-const typeUtils_1 = require("./typeUtils");
-const typeVarContext_1 = require("./typeVarContext");
-const typedDicts_1 = require("./typedDicts");
 const types_1 = require("./types");
+const typeUtils_1 = require("./typeUtils");
 // This table contains the names of several built-in types that
 // are not subscriptable at runtime on older versions of Python.
 // It lists the first version of Python where subscripting is
@@ -571,8 +571,8 @@ 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, 
-                /* destTypeVarContext */ undefined, 
-                /* srcTypeVarContext */ undefined, 1024 /* AssignTypeFlags.IgnoreTypeVarScope */)) {
+                /* destConstraints */ undefined, 
+                /* srcConstraints */ undefined, 0 /* AssignTypeFlags.Default */)) {
                     typeResult.typeErrors = true;
                     typeResult.expectedTypeDiagAddendum = diag;
                     diag.addTextRange(node);
@@ -779,7 +779,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             return;
         }
         if ((flags & 64 /* EvalFlags.NoTypeVarTuple */) !== 0) {
-            if ((0, types_1.isTypeVarTuple)(typeResult.type) && !typeResult.type.priv.isVariadicInUnion) {
+            if ((0, types_1.isTypeVarTuple)(typeResult.type) && !typeResult.type.priv.isInUnion) {
                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeVarTupleContext(), node);
                 typeResult.type = types_1.UnknownType.create();
             }
@@ -862,7 +862,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         const iterTypeResult = getTypeOfExpression(node.d.expr, flags, (0, typeUtils_1.makeInferenceContext)(iterExpectedType));
         const iterType = iterTypeResult.type;
-        if ((flags & 64 /* EvalFlags.NoTypeVarTuple */) === 0 && (0, types_1.isTypeVarTuple)(iterType) && !iterType.priv.isVariadicUnpacked) {
+        if ((flags & 64 /* EvalFlags.NoTypeVarTuple */) === 0 && (0, types_1.isTypeVarTuple)(iterType) && !iterType.priv.isUnpacked) {
             typeResult = { type: types_1.TypeVarType.cloneForUnpacked(iterType) };
         }
         else if ((flags & 2097152 /* EvalFlags.AllowUnpackedTuple */) !== 0 &&
@@ -1343,6 +1343,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             return subtype;
         });
     }
+    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);
+    }
     // Gets a member type from an object or class. If it's a function, binds
     // it to the object or class. If selfType is undefined, the binding is done
     // using the objectType parameter. Callers can specify these separately
@@ -1535,7 +1542,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         function addOneFunctionToSignature(type) {
             let callResult;
             useSpeculativeMode(callNode, () => {
-                callResult = validateArgs(exprNode, argList, { type }, new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(type)), 
+                callResult = validateArgs(exprNode, argList, { type }, 
+                /* constraints */ undefined, 
                 /* skipUnknownArgCheck */ true, 
                 /* inferenceContext */ undefined);
             });
@@ -1606,7 +1614,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             return functionType;
         }
         (0, debug_1.assert)(kwargsIndex === functionType.shared.parameters.length - 1);
-        const kwargsType = types_1.FunctionType.getEffectiveParamType(functionType, kwargsIndex);
+        const kwargsType = types_1.FunctionType.getParamType(functionType, kwargsIndex);
         if (!(0, types_1.isClassInstance)(kwargsType) || !types_1.ClassType.isTypedDictClass(kwargsType) || !kwargsType.priv.isUnpacked) {
             return functionType;
         }
@@ -1707,7 +1715,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 if (baseType && (0, types_1.isClassInstance)(baseType)) {
                     const setItemType = getBoundMagicMethod(baseType, '__setitem__');
                     if (setItemType && (0, types_1.isFunction)(setItemType) && setItemType.shared.parameters.length >= 2) {
-                        const paramType = types_1.FunctionType.getEffectiveParamType(setItemType, 1);
+                        const paramType = types_1.FunctionType.getParamType(setItemType, 1);
                         if (!(0, types_1.isAnyOrUnknown)(paramType)) {
                             return paramType;
                         }
@@ -1729,7 +1737,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 if (useDescriptorSetterType && (0, types_1.isClassInstance)(declaredType)) {
                     const setter = getBoundMagicMethod(declaredType, '__set__');
                     if (setter && (0, types_1.isFunction)(setter) && setter.shared.parameters.length >= 2) {
-                        declaredType = setter.shared.parameters[1].type;
+                        declaredType = types_1.FunctionType.getParamType(setter, 1);
                         if ((0, types_1.isAnyOrUnknown)(declaredType)) {
                             return undefined;
                         }
@@ -1766,9 +1774,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             const diag = errorNode ? new diagnostic_1.DiagnosticAddendum() : undefined;
             if ((0, types_1.isClassInstance)(subtype)) {
-                const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(awaitableProtocolObj));
-                if (assignType(awaitableProtocolObj, subtype, diag, typeVarContext)) {
-                    const specializedType = (0, typeUtils_1.applySolvedTypeVars)(awaitableProtocolObj, typeVarContext);
+                const constraints = new constraintTracker_1.ConstraintTracker();
+                if (assignType(awaitableProtocolObj, subtype, diag, constraints)) {
+                    const specializedType = solveAndApplyConstraints(awaitableProtocolObj, constraints);
                     if ((0, types_1.isClass)(specializedType) &&
                         specializedType.priv.typeArgs &&
                         specializedType.priv.typeArgs.length > 0) {
@@ -1799,6 +1807,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             type = (0, typeUtils_1.removeNoneFromUnion)(type);
         }
         const iterableType = (0, typeUtils_1.mapSubtypes)(type, (subtype) => {
+            var _a, _b;
             subtype = makeTopLevelTypeVarsConcrete(subtype);
             if ((0, types_1.isAnyOrUnknown)(subtype)) {
                 return subtype;
@@ -1812,18 +1821,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     subtype.priv.tupleTypeArgs.length === 0) {
                     return types_1.NeverType.createNever();
                 }
-                const iterReturnType = getTypeOfMagicMethodCall(subtype, iterMethodName, [], errorNode);
+                const iterReturnType = (_a = getTypeOfMagicMethodCall(subtype, iterMethodName, [], errorNode)) === null || _a === void 0 ? void 0 : _a.type;
                 if (!iterReturnType) {
                     // There was no __iter__. See if we can fall back to
                     // the __getitem__ method instead.
                     if (!isAsync && (0, types_1.isClassInstance)(subtype)) {
-                        const getItemReturnType = getTypeOfMagicMethodCall(subtype, '__getitem__', [
+                        const getItemReturnType = (_b = getTypeOfMagicMethodCall(subtype, '__getitem__', [
                             {
                                 type: intClass && (0, types_1.isInstantiableClass)(intClass)
                                     ? types_1.ClassType.cloneAsInstance(intClass)
                                     : types_1.UnknownType.create(),
                             },
-                        ], errorNode);
+                        ], errorNode)) === null || _b === void 0 ? void 0 : _b.type;
                         if (getItemReturnType) {
                             return getItemReturnType;
                         }
@@ -1833,10 +1842,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 else {
                     const iterReturnTypeDiag = new diagnostic_1.DiagnosticAddendum();
                     const returnType = mapSubtypesExpandTypeVars(iterReturnType, /* options */ undefined, (subtype) => {
+                        var _a;
                         if ((0, types_1.isAnyOrUnknown)(subtype)) {
                             return subtype;
                         }
-                        let nextReturnType = getTypeOfMagicMethodCall(subtype, nextMethodName, [], errorNode);
+                        let nextReturnType = (_a = getTypeOfMagicMethodCall(subtype, nextMethodName, [], errorNode)) === null || _a === void 0 ? void 0 : _a.type;
                         if (!nextReturnType) {
                             iterReturnTypeDiag.addMessage(localize_1.LocMessage.methodNotDefinedOnType().format({
                                 name: nextMethodName,
@@ -1887,11 +1897,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             type = (0, typeUtils_1.removeNoneFromUnion)(type);
         }
         const iterableType = (0, typeUtils_1.mapSubtypes)(type, (subtype) => {
+            var _a;
             if ((0, types_1.isAnyOrUnknown)(subtype)) {
                 return subtype;
             }
             if ((0, types_1.isClass)(subtype)) {
-                const iterReturnType = getTypeOfMagicMethodCall(subtype, iterMethodName, [], errorNode);
+                const iterReturnType = (_a = getTypeOfMagicMethodCall(subtype, iterMethodName, [], errorNode)) === null || _a === void 0 ? void 0 : _a.type;
                 if (iterReturnType) {
                     return makeTopLevelTypeVarsConcrete(iterReturnType);
                 }
@@ -2332,7 +2343,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (enclosingClass === null || enclosingClass === void 0 ? void 0 : enclosingClass.shared.typeVarScopeId) {
             memberResultToCache = {
                 ...resultToCache,
-                type: (0, typeUtils_1.updateTypeWithExternalTypeVars)(resultToCache.type, [enclosingClass.shared.typeVarScopeId]),
+                type: (0, typeUtils_1.makeTypeVarsFree)(resultToCache.type, [enclosingClass.shared.typeVarScopeId]),
                 memberAccessDeprecationInfo: setTypeResult.memberAccessDeprecationInfo,
             };
         }
@@ -2561,16 +2572,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
             }
             // If this is a function that contains only a ParamSpec (no additional
-            // parameters), convert it to a concrete type of (*args: Any, **kwargs: Any).
+            // parameters), convert it to a concrete type of (*args: Unknown, **kwargs: Unknown).
             if (makeParamSpecsConcrete && (0, types_1.isFunction)(subtype)) {
-                const convertedType = (0, typeUtils_1.convertParamSpecValueToType)(subtype);
+                const convertedType = (0, typeUtils_1.simplifyFunctionToParamSpec)(subtype);
                 if ((0, types_1.isParamSpec)(convertedType)) {
-                    return types_1.FunctionType.applyParamSpecValue(subtype, (0, typeUtils_1.getUnknownTypeForCallable)());
+                    return types_1.ParamSpecType.getUnknown();
                 }
             }
             if ((0, types_1.isTypeVarTuple)(subtype)) {
                 // If it's in a union, convert to type or object.
-                if (subtype.priv.isVariadicInUnion) {
+                if (subtype.priv.isInUnion) {
                     if (types_1.TypeBase.isInstantiable(subtype)) {
                         if (typeClass && (0, types_1.isInstantiableClass)(typeClass)) {
                             return typeClass;
@@ -2590,7 +2601,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 if (subtype.shared.recursiveAlias) {
                     return subtype;
                 }
-                if (subtype.shared.constraints.length > 0) {
+                if (types_1.TypeVarType.hasConstraints(subtype)) {
                     const typesToCombine = [];
                     // Expand the list of constrained subtypes, filtering out any that are
                     // disallowed by the conditionFilter.
@@ -2617,9 +2628,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 // Fall back to a bound of "object" if no bound is provided.
                 let boundType = (_a = subtype.shared.boundType) !== null && _a !== void 0 ? _a : getObjectType();
                 // If this is a synthesized self/cls type var, self-specialize its type arguments.
-                if (subtype.shared.isSynthesizedSelf && (0, types_1.isClass)(boundType)) {
+                if (types_1.TypeVarType.isSelf(subtype) && (0, types_1.isClass)(boundType) && !types_1.ClassType.isPseudoGenericClass(boundType)) {
                     boundType = (0, typeUtils_1.selfSpecializeClass)(boundType, {
-                        useInternalTypeVars: types_1.TypeVarType.hasInternalScopeId(subtype),
+                        useBoundTypeVars: types_1.TypeVarType.isBound(subtype),
                     });
                 }
                 boundType = types_1.TypeBase.isInstantiable(subtype) ? (0, typeUtils_1.convertToInstantiable)(boundType) : boundType;
@@ -2658,7 +2669,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
                 if (transformedType) {
                     // Apply the type condition if it's associated with a constrained TypeVar.
-                    const typeCondition = (_a = (0, typeUtils_1.getTypeCondition)(subtype)) === null || _a === void 0 ? void 0 : _a.filter((condition) => condition.typeVar.shared.constraints.length > 0);
+                    const typeCondition = (_a = (0, typeUtils_1.getTypeCondition)(subtype)) === null || _a === void 0 ? void 0 : _a.filter((condition) => types_1.TypeVarType.hasConstraints(condition.typeVar));
                     if (typeCondition && typeCondition.length > 0) {
                         transformedType = (0, typeUtils_1.addConditionToType)(transformedType, typeCondition);
                     }
@@ -3210,22 +3221,21 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (!type.priv.scopeId) {
             type = assignTypeVarScopeId(node, type, flags);
         }
-        // If this TypeVar has an external scope ID, see if we need to
-        // make it into an internal scope ID instead.
-        if (type.priv.scopeId && !types_1.TypeVarType.hasInternalScopeId(type)) {
+        // If this is a free type var, see if we need to make it into a bound type var.
+        if (type.priv.scopeId && !types_1.TypeVarType.isBound(type)) {
             // If this is a reference to a TypeVar defined in an outer scope,
-            // change it to have an internal scope ID.
+            // mark it as bound.
             const scopedNode = (_a = findScopedTypeVar(node, type)) === null || _a === void 0 ? void 0 : _a.scopeNode;
             if (scopedNode) {
                 const enclosingSuite = ParseTreeUtils.getEnclosingClassOrFunctionSuite(node);
                 if (enclosingSuite && ParseTreeUtils.isNodeContainedWithin(enclosingSuite, scopedNode)) {
                     if (scopedNode.nodeType !== 10 /* ParseNodeType.Class */ || scopedNode.d.suite !== enclosingSuite) {
-                        type = types_1.TypeVarType.cloneWithInternalScopeId(type);
+                        type = types_1.TypeVarType.cloneAsBound(type);
                     }
                 }
             }
         }
-        // If this type var is variadic, the name refers to the packed form. It
+        // If this is a TypeVarTuple, the name refers to the packed form. It
         // must be unpacked in most contexts.
         if ((0, types_1.isUnpackedTypeVarTuple)(type)) {
             type = types_1.TypeVarType.cloneForPacked(type);
@@ -3318,7 +3328,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // an outer class that contains the class definition.
     function enforceClassTypeVarScope(node, type) {
         var _a, _b;
-        const scopeId = (_b = (_a = type.priv.externalTypeVar) === null || _a === void 0 ? void 0 : _a.priv.scopeId) !== null && _b !== void 0 ? _b : type.priv.scopeId;
+        const scopeId = (_b = (_a = type.priv.freeTypeVar) === null || _a === void 0 ? void 0 : _a.priv.scopeId) !== null && _b !== void 0 ? _b : type.priv.scopeId;
         if (!scopeId) {
             return true;
         }
@@ -3366,16 +3376,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             !aliasInfo.typeArgs) {
             let reportMissingTypeArgs = false;
             const defaultTypeArgs = [];
-            const typeVarContext = new typeVarContext_1.TypeVarContext(aliasInfo.typeVarScopeId);
+            const constraints = new constraintTracker_1.ConstraintTracker();
             aliasInfo.typeParams.forEach((param) => {
                 if (!param.shared.isDefaultExplicit) {
                     reportMissingTypeArgs = true;
                 }
                 let defaultType;
                 if (param.shared.isDefaultExplicit || (0, types_1.isParamSpec)(param)) {
-                    defaultType = (0, typeUtils_1.applySolvedTypeVars)(param, typeVarContext, {
-                        unknownIfNotFound: true,
-                        tupleClassType: getTupleClassType(),
+                    defaultType = solveAndApplyConstraints(param, constraints, {
+                        replaceUnsolved: {
+                            scopeIds: [aliasInfo.typeVarScopeId],
+                            tupleClassType: getTupleClassType(),
+                        },
                     });
                 }
                 else if ((0, types_1.isTypeVarTuple)(param) && tupleClass && (0, types_1.isInstantiableClass)(tupleClass)) {
@@ -3386,17 +3398,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     defaultType = types_1.UnknownType.create();
                 }
                 defaultTypeArgs.push(defaultType);
-                (0, typeUtils_1.setTypeVarType)(typeVarContext, param, defaultType);
+                constraints.setBounds(param, defaultType);
             });
             if (reportMissingTypeArgs) {
                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportMissingTypeArgument, localize_1.LocMessage.typeArgsMissingForAlias().format({
                     name: aliasInfo.name,
                 }), node);
             }
-            type = types_1.TypeBase.cloneForTypeAlias((0, typeUtils_1.applySolvedTypeVars)(type, typeVarContext, {
-                unknownIfNotFound: true,
-                tupleClassType: getTupleClassType(),
-            }), aliasInfo.name, aliasInfo.fullName, aliasInfo.moduleName, aliasInfo.fileUri, aliasInfo.typeVarScopeId, aliasInfo.isPep695Syntax, aliasInfo.typeParams, defaultTypeArgs);
+            type = types_1.TypeBase.cloneForTypeAlias(solveAndApplyConstraints(type, constraints, {
+                replaceUnsolved: {
+                    scopeIds: [aliasInfo.typeVarScopeId],
+                    tupleClassType: getTupleClassType(),
+                },
+            }), { ...aliasInfo, typeArgs: defaultTypeArgs });
         }
         return type;
     }
@@ -4161,7 +4175,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 return { type: types_1.AnyType.create(), typeErrors: true };
             }
             if (classType.shared.typeVarScopeId) {
-                memberType = (0, typeUtils_1.updateTypeWithInternalTypeVars)(memberType, [classType.shared.typeVarScopeId]);
+                memberType = (0, typeUtils_1.makeTypeVarsBound)(memberType, [classType.shared.typeVarScopeId]);
             }
             return { type: memberType };
         }
@@ -4208,11 +4222,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 accessMethodClass = (_c = concreteMemberType.priv.fdelInfo) === null || _c === void 0 ? void 0 : _c.classType;
             }
             if (accessMethodClass) {
-                const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(accessMethodClass));
+                const constraints = new constraintTracker_1.ConstraintTracker();
                 accessMethodClass = (0, typeUtils_1.selfSpecializeClass)(accessMethodClass);
                 assignType(types_1.ClassType.cloneAsInstance(accessMethodClass), types_1.ClassType.cloneAsInstance(memberInfo.classType), 
-                /* diag */ undefined, typeVarContext);
-                accessMethodClass = (0, typeUtils_1.applySolvedTypeVars)(accessMethodClass, typeVarContext);
+                /* 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)) {
                     methodType = specializedType;
@@ -4284,7 +4298,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // Suppress diagnostics for these method calls because they would be redundant.
         const callResult = suppressDiagnostics(errorNode, () => {
             return validateCallArgs(errorNode, argList, { type: methodType }, 
-            /* typeVarContext */ undefined, 
+            /* constraints */ undefined, 
             /* skipUnknownArgCheck */ true, 
             /* inferenceContext */ undefined);
         }, (suppressedDiags) => {
@@ -4369,7 +4383,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if ((0, types_1.isFunction)(getterType) && (0, types_1.isFunction)(setterType)) {
                 // If there's no declared return type on the getter, assume it's symmetric.
                 if (setterType.shared.parameters.length >= 3 && getterType.shared.declaredReturnType) {
-                    const setterValueType = types_1.FunctionType.getEffectiveParamType(setterType, 2);
+                    const setterValueType = types_1.FunctionType.getParamType(setterType, 2);
                     const getterReturnType = (_a = types_1.FunctionType.getEffectiveReturnType(getterType)) !== null && _a !== void 0 ? _a : types_1.UnknownType.create();
                     if (!(0, types_1.isTypeSame)(setterValueType, getterReturnType)) {
                         isAsymmetric = true;
@@ -4401,7 +4415,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if ((0, types_1.isFunction)(getterType) && (0, types_1.isFunction)(setterType)) {
                 // If there's no declared return type on the getter, assume it's symmetric.
                 if (setterType.shared.parameters.length >= 3 && getterType.shared.declaredReturnType) {
-                    const setterValueType = types_1.FunctionType.getEffectiveParamType(setterType, 2);
+                    const setterValueType = types_1.FunctionType.getParamType(setterType, 2);
                     const getterReturnType = (_a = types_1.FunctionType.getEffectiveReturnType(getterType)) !== null && _a !== void 0 ? _a : types_1.UnknownType.create();
                     if (!(0, types_1.isTypeSame)(setterValueType, getterReturnType)) {
                         isAsymmetric = true;
@@ -4467,8 +4481,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // TODO - emit an error for this condition.
             return undefined;
         }
-        const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(accessMemberType));
-        const callResult = validateCallArgs(errorNode, argList, { type: accessMemberType }, typeVarContext, 
+        const callResult = validateCallArgs(errorNode, argList, { type: accessMemberType }, 
+        /* constraints */ undefined, 
         /* skipUnknownArgCheck */ true, 
         /* inferenceContext */ undefined);
         let isAsymmetricAccessor = false;
@@ -4577,7 +4591,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             srcUnboundedTupleIndex >= 0 &&
             variadicIndex >= 0 &&
             typeArgs.length < typeParams.length) {
-            // "Smear" the tuple type across type argument slots prior to the variadic type var.
+            // "Smear" the tuple type across type argument slots prior to the TypeVarTuple.
             while (variadicIndex > srcUnboundedTupleIndex) {
                 typeArgs = [
                     ...typeArgs.slice(0, srcUnboundedTupleIndex),
@@ -4586,7 +4600,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 ];
                 srcUnboundedTupleIndex++;
             }
-            // "Smear" the tuple type across type argument slots following the variadic type var.
+            // "Smear" the tuple type across type argument slots following the TypeVarTuple.
             while (typeArgs.length < typeParams.length) {
                 typeArgs = [
                     ...typeArgs.slice(0, srcUnboundedTupleIndex + 1),
@@ -4667,7 +4681,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     }
     // If the variadic type variable is not unpacked, report an error.
     function validateTypeVarTupleIsUnpacked(type, node) {
-        if (!type.priv.isVariadicUnpacked) {
+        if (!type.priv.isUnpacked) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.unpackedTypeVarTupleExpected().format({
                 name1: type.shared.name,
                 name2: type.shared.name,
@@ -4734,7 +4748,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             typeArgs.length >= 1) {
             return { node, type: typeArgs[0].type };
         }
-        const typeVarContext = new typeVarContext_1.TypeVarContext(aliasInfo.typeVarScopeId);
+        const constraints = new constraintTracker_1.ConstraintTracker();
         const diag = new diagnostic_1.DiagnosticAddendum();
         typeParams.forEach((param, index) => {
             if ((0, types_1.isParamSpec)(param) && index < typeArgs.length) {
@@ -4748,10 +4762,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     if (typeList.length > 0) {
                         types_1.FunctionType.addPositionOnlyParamSeparator(functionType);
                     }
-                    (0, constraintSolver_1.assignTypeToTypeVar)(evaluatorInterface, param, functionType, diag, typeVarContext, 256 /* AssignTypeFlags.RetainLiteralsForTypeVar */);
+                    (0, constraintSolver_1.assignTypeVar)(evaluatorInterface, param, functionType, diag, constraints, 256 /* AssignTypeFlags.RetainLiteralsForTypeVar */);
                 }
                 else if ((0, types_1.isParamSpec)(typeArgType)) {
-                    (0, constraintSolver_1.assignTypeToTypeVar)(evaluatorInterface, param, (0, typeUtils_1.convertToInstance)(typeArgType), diag, typeVarContext, 256 /* AssignTypeFlags.RetainLiteralsForTypeVar */);
+                    (0, constraintSolver_1.assignTypeVar)(evaluatorInterface, param, (0, typeUtils_1.convertToInstance)(typeArgType), diag, constraints, 256 /* AssignTypeFlags.RetainLiteralsForTypeVar */);
                 }
                 else if ((0, types_1.isInstantiableClass)(typeArgType) && types_1.ClassType.isBuiltIn(typeArgType, 'Concatenate')) {
                     const concatTypeArgs = typeArgType.priv.typeArgs;
@@ -4773,12 +4787,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             }
                         });
                     }
-                    (0, constraintSolver_1.assignTypeToTypeVar)(evaluatorInterface, param, functionType, diag, typeVarContext, 256 /* AssignTypeFlags.RetainLiteralsForTypeVar */);
+                    (0, constraintSolver_1.assignTypeVar)(evaluatorInterface, param, functionType, diag, constraints, 256 /* AssignTypeFlags.RetainLiteralsForTypeVar */);
                 }
                 else if ((0, typeUtils_1.isEllipsisType)(typeArgType)) {
                     const functionType = types_1.FunctionType.createSynthesizedInstance('', 65536 /* FunctionTypeFlags.ParamSpecValue */ | 32768 /* FunctionTypeFlags.GradualCallableForm */);
                     types_1.FunctionType.addDefaultParams(functionType);
-                    (0, constraintSolver_1.assignTypeToTypeVar)(evaluatorInterface, param, functionType, diag, typeVarContext);
+                    (0, constraintSolver_1.assignTypeVar)(evaluatorInterface, param, functionType, diag, constraints);
                 }
                 else {
                     addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeArgListExpected(), typeArgs[index].node);
@@ -4793,9 +4807,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     typeArgType = (0, typeUtils_1.convertToInstance)(typeArgs[index].type);
                 }
                 else if (param.shared.isDefaultExplicit) {
-                    typeArgType = (0, typeUtils_1.applySolvedTypeVars)(param, typeVarContext, {
-                        unknownIfNotFound: true,
-                        tupleClassType: getTupleClassType(),
+                    typeArgType = solveAndApplyConstraints(param, constraints, {
+                        replaceUnsolved: {
+                            scopeIds: [aliasInfo.typeVarScopeId],
+                            tupleClassType: getTupleClassType(),
+                        },
                     });
                 }
                 else {
@@ -4821,34 +4837,27 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     messageDiag.addTextRange(typeArgs[index].node);
                     typeArgType = types_1.UnknownType.create();
                 }
-                (0, constraintSolver_1.assignTypeToTypeVar)(evaluatorInterface, param, typeArgType, diag, typeVarContext, 256 /* AssignTypeFlags.RetainLiteralsForTypeVar */);
+                (0, constraintSolver_1.assignTypeVar)(evaluatorInterface, param, typeArgType, diag, constraints, 256 /* AssignTypeFlags.RetainLiteralsForTypeVar */);
             }
         });
         if (!diag.isEmpty()) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeNotSpecializable().format({ type: printType(baseType) }) + diag.getString(), node, (_b = diag.getEffectiveTextRange()) !== null && _b !== void 0 ? _b : node);
         }
-        const mainSolutionSet = typeVarContext.getMainSolutionSet();
+        const solutionSet = (0, constraintSolver_1.solveConstraints)(evaluatorInterface, constraints).getMainSolutionSet();
         const aliasTypeArgs = [];
         (_c = aliasInfo.typeParams) === null || _c === void 0 ? void 0 : _c.forEach((typeParam) => {
-            let typeVarType;
-            if ((0, types_1.isParamSpec)(typeParam)) {
-                const paramSpecType = mainSolutionSet.getTypeVarType(typeParam);
-                typeVarType = paramSpecType ? (0, typeUtils_1.convertParamSpecValueToType)(paramSpecType) : types_1.UnknownType.create();
-                if (!typeVarType) {
-                    typeVarType = types_1.ParamSpecType.getUnknown();
-                    mainSolutionSet.setTypeVarType(typeParam, (0, typeUtils_1.convertTypeToParamSpecValue)(typeVarType));
-                }
-            }
-            else {
-                typeVarType = mainSolutionSet.getTypeVarType(typeParam);
-                if (!typeVarType) {
-                    typeVarType = types_1.UnknownType.create();
-                    mainSolutionSet.setTypeVarType(typeParam, typeVarType);
-                }
+            let typeVarType = solutionSet.getType(typeParam);
+            // Fill in any unsolved type arguments with unknown.
+            if (!typeVarType) {
+                typeVarType = (0, typeUtils_1.getUnknownForTypeVar)(typeParam, getTupleClassType());
+                constraints.setBounds(typeParam, typeVarType);
             }
             aliasTypeArgs.push(typeVarType);
         });
-        const type = types_1.TypeBase.cloneForTypeAlias((0, typeUtils_1.applySolvedTypeVars)(baseType, typeVarContext), aliasInfo.name, aliasInfo.fullName, aliasInfo.moduleName, aliasInfo.fileUri, aliasInfo.typeVarScopeId, aliasInfo.isPep695Syntax, aliasInfo.typeParams, aliasTypeArgs);
+        const type = types_1.TypeBase.cloneForTypeAlias(solveAndApplyConstraints(baseType, constraints), {
+            ...aliasInfo,
+            typeArgs: aliasTypeArgs,
+        });
         return { type, node };
     }
     function getTypeOfIndexWithBaseType(node, baseTypeResult, usage, flags) {
@@ -4859,7 +4868,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         if ((0, types_1.isTypeVar)(baseTypeResult.type) && (0, typeUtils_1.isTypeAliasPlaceholder)(baseTypeResult.type)) {
             const typeArgTypes = getTypeArgs(node, flags).map((t) => (0, typeUtils_1.convertToInstance)(t.type));
-            const type = types_1.TypeBase.cloneForTypeAlias(baseTypeResult.type, baseTypeResult.type.shared.recursiveAlias.name, '', '', uri_1.Uri.empty(), baseTypeResult.type.shared.recursiveAlias.scopeId, !!baseTypeResult.type.shared.recursiveAlias.isPep695Syntax, baseTypeResult.type.shared.recursiveAlias.typeParams, typeArgTypes);
+            const type = types_1.TypeBase.cloneForTypeAlias(baseTypeResult.type, {
+                name: baseTypeResult.type.shared.recursiveAlias.name,
+                fullName: '',
+                moduleName: '',
+                fileUri: uri_1.Uri.empty(),
+                typeVarScopeId: baseTypeResult.type.shared.recursiveAlias.scopeId,
+                isPep695Syntax: !!baseTypeResult.type.shared.recursiveAlias.isPep695Syntax,
+                typeParams: baseTypeResult.type.shared.recursiveAlias.typeParams,
+                usageVariance: undefined,
+                typeArgs: typeArgTypes,
+            });
             return { type };
         }
         let isIncomplete = baseTypeResult.isIncomplete;
@@ -5229,7 +5248,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (usage.method === 'set') {
             let setType = (_b = (_a = usage.setType) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : types_1.AnyType.create();
             // Expand constrained type variables.
-            if ((0, types_1.isTypeVar)(setType) && setType.shared.constraints.length > 0) {
+            if ((0, types_1.isTypeVar)(setType) && types_1.TypeVarType.hasConstraints(setType)) {
                 const conditionFilter = (0, types_1.isClassInstance)(baseType) ? (_c = baseType.props) === null || _c === void 0 ? void 0 : _c.condition : undefined;
                 setType = makeTopLevelTypeVarsConcrete(setType, 
                 /* makeParamSpecsConcrete */ undefined, conditionFilter);
@@ -5258,7 +5277,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             });
         });
         const callResult = validateCallArgs(node, argList, { type: itemMethodType }, 
-        /* typeVarContext */ undefined, 
+        /* constraints */ undefined, 
         /* skipUnknownArgCheck */ true, 
         /* inferenceContext */ undefined);
         return {
@@ -5348,7 +5367,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 if (arg.d.argCategory !== 0 /* ArgCategory.Simple */) {
                     if (arg.d.argCategory === 1 /* ArgCategory.UnpackedList */) {
                         if (!(options === null || options === void 0 ? void 0 : options.isAnnotatedClass) || index === 0) {
-                            if ((0, types_1.isTypeVarTuple)(typeResult.type) && !typeResult.type.priv.isVariadicUnpacked) {
+                            if ((0, types_1.isTypeVarTuple)(typeResult.type) && !typeResult.type.priv.isUnpacked) {
                                 typeResult.type = types_1.TypeVarType.cloneForUnpacked(typeResult.type);
                             }
                             else if ((0, types_1.isInstantiableClass)(typeResult.type) &&
@@ -5483,11 +5502,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
         }
         else {
-            const tupleTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(tupleClass));
-            if (!(0, constraintSolver_1.addConstraintsForExpectedType)(evaluatorInterface, types_1.ClassType.cloneAsInstance(tupleClass), inferenceContext.expectedType, tupleTypeVarContext, ParseTreeUtils.getTypeVarScopesForNode(node), node.start)) {
+            const tupleConstraints = new constraintTracker_1.ConstraintTracker();
+            if (!(0, constraintSolver_1.addConstraintsForExpectedType)(evaluatorInterface, types_1.ClassType.cloneAsInstance(tupleClass), inferenceContext.expectedType, tupleConstraints, ParseTreeUtils.getTypeVarScopesForNode(node), node.start)) {
                 return undefined;
             }
-            const specializedTuple = (0, typeUtils_1.applySolvedTypeVars)(tupleClass, tupleTypeVarContext);
+            const specializedTuple = solveAndApplyConstraints(tupleClass, tupleConstraints);
             if (!specializedTuple.priv.typeArgs || specializedTuple.priv.typeArgs.length !== 1) {
                 return undefined;
             }
@@ -5628,7 +5647,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             else {
                 const callResult = validateCallArgs(node, argList, baseTypeResult, 
-                /* typeVarContext */ undefined, 
+                /* constraints */ undefined, 
                 /* skipUnknownArgCheck */ false, inferenceContext);
                 typeResult.type = (_a = callResult.returnType) !== null && _a !== void 0 ? _a : types_1.UnknownType.create();
                 if (callResult.argumentErrors) {
@@ -5932,9 +5951,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         types_1.FunctionType.isInstanceMethod(methodType)) {
                         if (methodType.shared.parameters.length > 0 &&
                             types_1.FunctionParam.isTypeDeclared(methodType.shared.parameters[0])) {
-                            let paramType = methodType.shared.parameters[0].type;
+                            let paramType = types_1.FunctionType.getParamType(methodType, 0);
                             const liveScopeIds = ParseTreeUtils.getTypeVarScopesForNode(node);
-                            paramType = (0, typeUtils_1.updateTypeWithInternalTypeVars)(paramType, liveScopeIds);
+                            paramType = (0, typeUtils_1.makeTypeVarsBound)(paramType, liveScopeIds);
                             implicitBindToType = makeTopLevelTypeVarsConcrete(paramType);
                         }
                     }
@@ -5985,7 +6004,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 effectiveTargetClass = undefined;
             }
             if (bindToType) {
-                bindToType = (0, typeUtils_1.selfSpecializeClass)(bindToType, { useInternalTypeVars: true });
+                bindToType = (0, typeUtils_1.selfSpecializeClass)(bindToType, { useBoundTypeVars: true });
             }
             const lookupResults = bindToType
                 ? (0, typeUtils_1.lookUpClassMember)(bindToType, memberName, 0 /* MemberAccessFlags.Default */, effectiveTargetClass)
@@ -6009,8 +6028,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             let bindToSelfType;
             if (bindToType) {
-                bindToSelfType = types_1.TypeBase.cloneForCondition(types_1.TypeVarType.cloneWithInternalScopeId((0, typeUtils_1.synthesizeTypeVarForSelfCls)(types_1.ClassType.cloneIncludeSubclasses(bindToType, /* includeSubclasses */ false), 
-                /* isClsParam */ false)), (_b = bindToType.props) === null || _b === void 0 ? void 0 : _b.condition);
+                if (node.d.args.length > 1) {
+                    // If this is a two-argument form of super(), use the
+                    // bindToType evaluated from the arguments.
+                    bindToSelfType = (0, typeUtils_1.convertToInstance)(bindToType);
+                }
+                else {
+                    // If this is a zero-argument form of super(), synthesize
+                    // a Self type to bind to.
+                    bindToSelfType = types_1.TypeBase.cloneForCondition(types_1.TypeVarType.cloneAsBound((0, typeUtils_1.synthesizeTypeVarForSelfCls)(types_1.ClassType.cloneIncludeSubclasses(bindToType, /* includeSubclasses */ false), 
+                    /* isClsParam */ false)), (_b = bindToType.props) === null || _b === void 0 ? void 0 : _b.condition);
+                }
             }
             const type = resultIsInstance ? (0, typeUtils_1.convertToInstance)(resultType, /* includeSubclasses */ false) : resultType;
             return { type, bindToSelfType };
@@ -6097,7 +6125,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // there will be only one argument list in expandedArgTypes, and all entries
     // (one for each argument) will be undefined. On subsequent calls, this
     // list will grow to include union expansions.
-    function validateOverloadsWithExpandedTypes(errorNode, expandedArgTypes, argParamMatches, typeVarContext, skipUnknownArgCheck, inferenceContext) {
+    function validateOverloadsWithExpandedTypes(errorNode, expandedArgTypes, argParamMatches, constraints, skipUnknownArgCheck, inferenceContext) {
         var _a, _b;
         const returnTypes = [];
         const matchedOverloads = [];
@@ -6126,14 +6154,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         return argParamCopy;
                     });
                 }
-                // Clone the typeVarContext so we don't modify the original.
-                const effectiveTypeVarContext = (_a = typeVarContext === null || typeVarContext === void 0 ? void 0 : typeVarContext.clone()) !== null && _a !== void 0 ? _a : new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(overload));
-                effectiveTypeVarContext.addSolveForScope((0, typeUtils_1.getTypeVarScopeIds)(overload));
-                effectiveTypeVarContext.unlock();
+                // Clone the constraints so we don't modify the original.
+                const effectiveConstraints = (_a = constraints === null || constraints === void 0 ? void 0 : constraints.clone()) !== null && _a !== void 0 ? _a : new constraintTracker_1.ConstraintTracker();
+                effectiveConstraints.unlock();
                 // Use speculative mode so we don't output any diagnostics or
                 // record any final types in the type cache.
                 const callResult = useSpeculativeMode(speculativeNode, () => {
-                    return validateArgTypesWithContext(errorNode, matchResults, effectiveTypeVarContext, 
+                    return validateArgTypesWithContext(errorNode, matchResults, effectiveConstraints, 
                     /* skipUnknownArgCheck */ true, inferenceContext);
                 });
                 if (callResult.isTypeIncomplete) {
@@ -6145,7 +6172,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     const matchedOverloadInfo = {
                         overload: matchedOverload,
                         matchResults,
-                        typeVarContext: effectiveTypeVarContext,
+                        constraints: effectiveConstraints,
                         returnType: callResult.returnType,
                         argResults: (_b = callResult.argResults) !== null && _b !== void 0 ? _b : [],
                     };
@@ -6235,15 +6262,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // resulting type var context back into the caller's type var context.
         // Use the type var context from the last matched overload because it
         // includes the type var solutions for all earlier matched overloads.
-        if (typeVarContext && isDefinitiveMatchFound) {
-            typeVarContext.copyFromClone(matchedOverloads[matchedOverloads.length - 1].typeVarContext);
+        if (constraints && isDefinitiveMatchFound) {
+            constraints.copyFromClone(matchedOverloads[matchedOverloads.length - 1].constraints);
         }
         // And run through the first expanded argument list one more time to
         // populate the type cache.
-        const finalTypeVarContext = typeVarContext !== null && typeVarContext !== void 0 ? typeVarContext : matchedOverloads[0].typeVarContext;
-        finalTypeVarContext.unlock();
-        finalTypeVarContext.addSolveForScope((0, typeUtils_1.getTypeVarScopeId)(matchedOverloads[0].overload));
-        const finalCallResult = validateArgTypesWithContext(errorNode, matchedOverloads[0].matchResults, finalTypeVarContext, skipUnknownArgCheck, inferenceContext);
+        const finalConstraints = constraints !== null && constraints !== void 0 ? constraints : matchedOverloads[0].constraints;
+        finalConstraints.unlock();
+        const finalCallResult = validateArgTypesWithContext(errorNode, matchedOverloads[0].matchResults, finalConstraints, skipUnknownArgCheck, inferenceContext);
         if (finalCallResult.isTypeIncomplete) {
             isTypeIncomplete = true;
         }
@@ -6323,7 +6349,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         matches.forEach((match, matchIndex) => {
             if (winningOverloadIndex === undefined) {
                 useSpeculativeMode(speculativeNode, () => {
-                    const callResult = validateArgTypes(errorNode, match, new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(match.overload)), 
+                    const callResult = validateArgTypes(errorNode, match, new constraintTracker_1.ConstraintTracker(), 
                     /* skipUnknownArgCheck */ true);
                     if (callResult && !callResult.argumentErrors) {
                         winningOverloadIndex = matchIndex;
@@ -6342,7 +6368,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             return a.overloadIndex - b.overloadIndex;
         });
     }
-    function validateOverloadedArgTypes(errorNode, argList, typeResult, typeVarContext, skipUnknownArgCheck, inferenceContext) {
+    function validateOverloadedArgTypes(errorNode, argList, typeResult, constraints, skipUnknownArgCheck, inferenceContext) {
         let filteredMatchResults = [];
         let contextFreeArgTypes;
         let isTypeIncomplete = !!typeResult.isIncomplete;
@@ -6412,10 +6438,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     diagnostic.addRelatedInfo(localize_1.LocAddendum.overloadIndex().format({ index: bestMatch.overloadIndex + 1 }), overrideDecl.uri, overrideDecl.range);
                 }
             }
-            const effectiveTypeVarContext = typeVarContext !== null && typeVarContext !== void 0 ? typeVarContext : new typeVarContext_1.TypeVarContext();
-            effectiveTypeVarContext.addSolveForScope((0, typeUtils_1.getTypeVarScopeIds)(bestMatch.overload));
-            effectiveTypeVarContext.unlock();
-            return validateArgTypesWithContext(errorNode, bestMatch, effectiveTypeVarContext, skipUnknownArgCheck, inferenceContext);
+            const effectiveConstraints = constraints !== null && constraints !== void 0 ? constraints : new constraintTracker_1.ConstraintTracker();
+            effectiveConstraints.unlock();
+            return validateArgTypesWithContext(errorNode, bestMatch, effectiveConstraints, skipUnknownArgCheck, inferenceContext);
         }
         // If there is only one possible arg/param match among the overloads,
         // use the normal type matching mechanism because it is faster and
@@ -6427,7 +6452,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         let expandedArgTypes = [argList.map((arg) => undefined)];
         while (true) {
-            const callResult = validateOverloadsWithExpandedTypes(errorNode, expandedArgTypes, filteredMatchResults, typeVarContext, skipUnknownArgCheck, inferenceContext);
+            const callResult = validateOverloadsWithExpandedTypes(errorNode, expandedArgTypes, filteredMatchResults, constraints, skipUnknownArgCheck, inferenceContext);
             if (callResult.isTypeIncomplete) {
                 isTypeIncomplete = true;
             }
@@ -6500,7 +6525,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 unionToExpand = makeTopLevelTypeVarsConcrete(argType);
                 break;
             }
-            else if ((0, types_1.isTypeVar)(argType) && argType.shared.constraints.length > 1) {
+            else if ((0, types_1.isTypeVar)(argType) && types_1.TypeVarType.hasConstraints(argType)) {
                 unionToExpand = makeTopLevelTypeVarsConcrete(argType);
                 break;
             }
@@ -6525,7 +6550,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // list, specializes the call based on arg types, and returns the
     // specialized type of the return value. If it detects an error along
     // the way, it emits a diagnostic and sets argumentErrors to true.
-    function validateCallArgs(errorNode, argList, callTypeResult, typeVarContext, skipUnknownArgCheck, inferenceContext, recursionCount = 0) {
+    function validateCallArgs(errorNode, argList, callTypeResult, constraints, skipUnknownArgCheck, inferenceContext, recursionCount = 0) {
         var _a;
         let argumentErrors = false;
         let isTypeIncomplete = false;
@@ -6545,7 +6570,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         let returnType = mapSubtypesExpandTypeVars(callTypeResult.type, { sortSubtypes: true }, (expandedSubtype, unexpandedSubtype, isLastIteration) => {
             return useSpeculativeMode(isLastIteration ? undefined : getSpeculativeNodeForCall(errorNode), () => {
-                const callResult = validateCallArgsForSubtype(errorNode, argList, expandedSubtype, unexpandedSubtype, !!callTypeResult.isIncomplete, typeVarContext, skipUnknownArgCheck, inferenceContext, recursionCount);
+                const callResult = validateCallArgsForSubtype(errorNode, argList, expandedSubtype, unexpandedSubtype, !!callTypeResult.isIncomplete, constraints, skipUnknownArgCheck, inferenceContext, recursionCount);
                 if (callResult.argumentErrors) {
                     argumentErrors = true;
                 }
@@ -6575,7 +6600,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             overloadsUsedForCall,
         };
     }
-    function validateCallArgsForSubtype(errorNode, argList, expandedCallType, unexpandedCallType, isCallTypeIncomplete, typeVarContext, skipUnknownArgCheck, inferenceContext, recursionCount) {
+    function validateCallArgsForSubtype(errorNode, argList, expandedCallType, unexpandedCallType, isCallTypeIncomplete, constraints, skipUnknownArgCheck, inferenceContext, recursionCount) {
         switch (expandedCallType.category) {
             case 3 /* TypeCategory.Never */:
             case 1 /* TypeCategory.Unknown */:
@@ -6593,10 +6618,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 return { returnType: expandedCallType };
             }
             case 4 /* TypeCategory.Function */: {
-                return validateCallForFunction(errorNode, argList, expandedCallType, isCallTypeIncomplete, typeVarContext, skipUnknownArgCheck, inferenceContext);
+                return validateCallForFunction(errorNode, argList, expandedCallType, isCallTypeIncomplete, constraints, skipUnknownArgCheck, inferenceContext);
             }
             case 5 /* TypeCategory.OverloadedFunction */: {
-                return validateCallForOverloadedFunction(errorNode, argList, expandedCallType, isCallTypeIncomplete, typeVarContext, skipUnknownArgCheck, inferenceContext);
+                return validateCallForOverloadedFunction(errorNode, argList, expandedCallType, isCallTypeIncomplete, constraints, skipUnknownArgCheck, inferenceContext);
             }
             case 6 /* TypeCategory.Class */: {
                 if ((0, typeUtils_1.isNoneInstance)(expandedCallType)) {
@@ -6606,14 +6631,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 if (types_1.TypeBase.isInstantiable(expandedCallType)) {
                     return validateCallForInstantiableClass(errorNode, argList, expandedCallType, unexpandedCallType, skipUnknownArgCheck, inferenceContext);
                 }
-                return validateCallForClassInstance(errorNode, argList, expandedCallType, unexpandedCallType, typeVarContext, skipUnknownArgCheck, inferenceContext, recursionCount);
+                return validateCallForClassInstance(errorNode, argList, expandedCallType, unexpandedCallType, constraints, skipUnknownArgCheck, inferenceContext, recursionCount);
             }
             // TypeVars should have been expanded in most cases,
             // but we still need to handle the case of Type[T] where
             // T is a constrained type that contains a union. We also
             // need to handle recursive type aliases.
             case 9 /* TypeCategory.TypeVar */: {
-                return validateCallArgs(errorNode, argList, { type: (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(expandedCallType), isIncomplete: isCallTypeIncomplete }, typeVarContext, skipUnknownArgCheck, inferenceContext, recursionCount);
+                return validateCallArgs(errorNode, argList, { type: (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(expandedCallType), isIncomplete: isCallTypeIncomplete }, constraints, skipUnknownArgCheck, inferenceContext, recursionCount);
             }
             case 7 /* TypeCategory.Module */: {
                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.moduleNotCallable(), errorNode);
@@ -6622,7 +6647,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return { argumentErrors: true };
     }
-    function validateCallForFunction(errorNode, argList, type, isCallTypeIncomplete, typeVarContext, skipUnknownArgCheck, inferenceContext) {
+    function validateCallForFunction(errorNode, argList, type, isCallTypeIncomplete, constraints, skipUnknownArgCheck, inferenceContext) {
         var _a;
         if (types_1.TypeBase.isInstantiable(type)) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.callableNotInstantiable().format({
@@ -6630,7 +6655,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }), errorNode);
             return { returnType: undefined, argumentErrors: true };
         }
-        const effectiveTypeVarContext = typeVarContext !== null && typeVarContext !== void 0 ? typeVarContext : new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeIds)(type));
         // The stdlib collections/__init__.pyi stub file defines namedtuple
         // as a function rather than a class, so we need to check for it here.
         if (types_1.FunctionType.isBuiltIn(type, 'namedtuple')) {
@@ -6638,14 +6662,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             const result = {
                 returnType: (0, namedTuples_1.createNamedTupleType)(evaluatorInterface, errorNode, argList, /* includesTypes */ false),
             };
-            validateArgs(errorNode, argList, { type: type }, effectiveTypeVarContext, skipUnknownArgCheck, inferenceContext);
+            validateArgs(errorNode, argList, { type: type }, constraints, skipUnknownArgCheck, inferenceContext);
             return result;
         }
         // Handle the NewType specially, replacing the normal return type.
         if (types_1.FunctionType.isBuiltIn(type, 'NewType')) {
             return { returnType: createNewType(errorNode, argList) };
         }
-        const functionResult = validateArgs(errorNode, argList, { type, isIncomplete: isCallTypeIncomplete }, effectiveTypeVarContext, skipUnknownArgCheck, inferenceContext);
+        const functionResult = validateArgs(errorNode, argList, { type, isIncomplete: isCallTypeIncomplete }, constraints, skipUnknownArgCheck, inferenceContext);
         let isTypeIncomplete = !!functionResult.isTypeIncomplete;
         let returnType = functionResult.returnType;
         let argumentErrors = !!functionResult.argumentErrors;
@@ -6752,13 +6776,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return { symbol, symbolName, classType, hasImplementation };
     }
-    function validateCallForOverloadedFunction(errorNode, argList, expandedCallType, isCallTypeIncomplete, typeVarContext, skipUnknownArgCheck, inferenceContext) {
+    function validateCallForOverloadedFunction(errorNode, argList, expandedCallType, isCallTypeIncomplete, constraints, skipUnknownArgCheck, inferenceContext) {
         var _a, _b;
         // Handle the 'cast' call as a special case.
         if (types_1.FunctionType.isBuiltIn(expandedCallType.priv.overloads[0], 'cast') && argList.length === 2) {
             return { returnType: evaluateCastCall(argList, errorNode) };
         }
-        const callResult = validateOverloadedArgTypes(errorNode, argList, { type: expandedCallType, isIncomplete: isCallTypeIncomplete }, typeVarContext, skipUnknownArgCheck, inferenceContext);
+        const callResult = validateOverloadedArgTypes(errorNode, argList, { type: expandedCallType, isIncomplete: isCallTypeIncomplete }, constraints, skipUnknownArgCheck, inferenceContext);
         let returnType = (_a = callResult.returnType) !== null && _a !== void 0 ? _a : types_1.UnknownType.create();
         let isTypeIncomplete = !!callResult.isTypeIncomplete;
         let argumentErrors = !!callResult.argumentErrors;
@@ -6868,7 +6892,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 /* diag */ undefined, 0 /* MemberAccessFlags.Default */);
                 if (initTypeResult && (0, types_1.isOverloadedFunction)(initTypeResult.type)) {
                     validateOverloadedArgTypes(errorNode, argList, { type: initTypeResult.type }, 
-                    /* typeVarContext */ undefined, skipUnknownArgCheck, 
+                    /* constraints */ undefined, skipUnknownArgCheck, 
                     /* inferenceContext */ undefined);
                 }
                 return result;
@@ -6976,7 +7000,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return { returnType, overloadsUsedForCall, argumentErrors, isTypeIncomplete };
     }
-    function validateCallForClassInstance(errorNode, argList, expandedCallType, unexpandedCallType, typeVarContext, skipUnknownArgCheck, inferenceContext, recursionCount) {
+    function validateCallForClassInstance(errorNode, argList, expandedCallType, unexpandedCallType, constraints, skipUnknownArgCheck, inferenceContext, recursionCount) {
         var _a;
         const callDiag = new diagnostic_1.DiagnosticAddendum();
         const callMethodResult = getTypeOfBoundMember(errorNode, expandedCallType, '__call__', 
@@ -6989,7 +7013,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }) + callDiag.getString(), errorNode);
             return { returnType: types_1.UnknownType.create(), argumentErrors: true };
         }
-        const callResult = validateCallArgs(errorNode, argList, { type: callMethodType }, typeVarContext, skipUnknownArgCheck, inferenceContext, recursionCount);
+        const callResult = validateCallArgs(errorNode, argList, { type: callMethodType }, constraints, skipUnknownArgCheck, inferenceContext, recursionCount);
         let returnType = (_a = callResult.returnType) !== null && _a !== void 0 ? _a : types_1.UnknownType.create();
         if ((0, types_1.isTypeVar)(unexpandedCallType) &&
             types_1.TypeBase.isInstantiable(unexpandedCallType) &&
@@ -7074,7 +7098,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // validation is left to the caller.
     // This logic is based on PEP 3102: https://www.python.org/dev/peps/pep-3102/
     function matchArgsToParams(errorNode, argList, typeResult, overloadIndex) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        var _a, _b, _c, _d, _e, _f, _g, _h;
         const overload = typeResult.type;
         const paramDetails = (0, parameterUtils_1.getParamListDetails)(overload);
         const paramSpec = types_1.FunctionType.getParamSpecFromArgsKwargs(overload);
@@ -7092,7 +7116,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             const param = paramInfo.param;
             if (param.name && param.category === 0 /* ParamCategory.Simple */) {
                 paramMap.set(param.name, {
-                    argsNeeded: param.category === 0 /* ParamCategory.Simple */ && !param.defaultType ? 1 : 0,
+                    argsNeeded: param.category === 0 /* ParamCategory.Simple */ && !paramInfo.defaultType ? 1 : 0,
                     argsReceived: 0,
                     isPositionalOnly: paramInfo.kind === parameterUtils_1.ParamKind.Positional,
                 });
@@ -7116,22 +7140,22 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         if (varArgListParamIndex !== undefined && varArgDictParamIndex !== undefined) {
             (0, debug_1.assert)(paramDetails.params[varArgListParamIndex], 'varArgListParamIndex params entry is undefined');
-            const varArgListParam = paramDetails.params[varArgListParamIndex].param;
+            const varArgListParamType = paramDetails.params[varArgListParamIndex].type;
             (0, debug_1.assert)(paramDetails.params[varArgDictParamIndex], 'varArgDictParamIndex params entry is undefined');
-            const varArgDictParam = paramDetails.params[varArgDictParamIndex].param;
-            if ((0, types_1.isParamSpec)(varArgListParam.type) &&
-                varArgListParam.type.priv.paramSpecAccess === 'args' &&
-                (0, types_1.isParamSpec)(varArgDictParam.type) &&
-                varArgDictParam.type.priv.paramSpecAccess === 'kwargs' &&
-                varArgListParam.type.shared.name === varArgDictParam.type.shared.name) {
+            const varArgDictParamType = paramDetails.params[varArgDictParamIndex].type;
+            if ((0, types_1.isParamSpec)(varArgListParamType) &&
+                varArgListParamType.priv.paramSpecAccess === 'args' &&
+                (0, types_1.isParamSpec)(varArgDictParamType) &&
+                varArgDictParamType.priv.paramSpecAccess === 'kwargs' &&
+                varArgListParamType.shared.name === varArgDictParamType.shared.name) {
                 hasParamSpecArgsKwargs = true;
                 // Does this function define the param spec, or is it an inner
                 // function nested within another function that defines the param
                 // spec? We need to handle these two cases differently.
-                const paramSpecScopeId = varArgListParam.type.priv.scopeId;
-                if ((_b = (0, typeUtils_1.getTypeVarScopeIds)(overload)) === null || _b === void 0 ? void 0 : _b.some((id) => id === paramSpecScopeId)) {
+                const paramSpecScopeId = varArgListParamType.priv.scopeId;
+                if ((0, typeUtils_1.getTypeVarScopeIds)(overload).some((id) => id === paramSpecScopeId)) {
                     paramSpecArgList = [];
-                    paramSpecTarget = types_1.TypeVarType.cloneForParamSpecAccess(varArgListParam.type, /* access */ undefined);
+                    paramSpecTarget = types_1.TypeVarType.cloneForParamSpecAccess(varArgListParamType, /* access */ undefined);
                 }
                 else {
                     positionalOnlyLimitIndex = varArgListParamIndex;
@@ -7141,7 +7165,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
         }
         else if (paramSpec) {
-            if ((_c = (0, typeUtils_1.getTypeVarScopeIds)(overload)) === null || _c === void 0 ? void 0 : _c.some((id) => id === paramSpec.priv.scopeId)) {
+            if ((0, typeUtils_1.getTypeVarScopeIds)(overload).some((id) => id === paramSpec.priv.scopeId)) {
                 hasParamSpecArgsKwargs = true;
                 paramSpecArgList = [];
                 paramSpecTarget = paramSpec;
@@ -7226,7 +7250,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                                 ? localize_1.LocMessage.argPositionalExpectedOne()
                                 : localize_1.LocMessage.argPositionalExpectedCount().format({
                                     expected: positionParamLimitIndex,
-                                }), (_d = argList[argIndex].valueExpression) !== null && _d !== void 0 ? _d : errorNode);
+                                }), (_b = argList[argIndex].valueExpression) !== null && _b !== void 0 ? _b : errorNode);
                         }
                         reportedArgError = true;
                     }
@@ -7259,15 +7283,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                                 ? localize_1.LocMessage.argPositionalExpectedOne()
                                 : localize_1.LocMessage.argPositionalExpectedCount().format({
                                     expected: positionParamLimitIndex,
-                                }), (_e = argList[argIndex].valueExpression) !== null && _e !== void 0 ? _e : errorNode);
+                                }), (_c = argList[argIndex].valueExpression) !== null && _c !== void 0 ? _c : errorNode);
                         }
                         reportedArgError = true;
                     }
                 }
                 const argType = argTypeResult.type;
                 if (isParamVariadic && (0, types_1.isUnpackedTypeVarTuple)(argType)) {
-                    // Allow an unpacked variadic type variable to satisfy an
-                    // unpacked variadic type variable.
+                    // Allow an unpacked TypeVarTuple arg to satisfy an
+                    // unpacked TypeVarTuple param.
                     listElementType = argType;
                     isArgCompatibleWithVariadic = true;
                     advanceToNextArg = true;
@@ -7278,7 +7302,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     argType.priv.tupleTypeArgs &&
                     argType.priv.tupleTypeArgs.length === 1 &&
                     (0, types_1.isUnpackedTypeVarTuple)(argType.priv.tupleTypeArgs[0].type)) {
-                    // Handle the case where an unpacked variadic type var has
+                    // Handle the case where an unpacked TypeVarTuple has
                     // been packaged into a tuple.
                     listElementType = argType.priv.tupleTypeArgs[0].type;
                     isArgCompatibleWithVariadic = true;
@@ -7301,9 +7325,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     listElementType = undefined;
                 }
                 else {
-                    listElementType = (_f = getTypeOfIterator({ type: argType, isIncomplete: argTypeResult.isIncomplete }, 
+                    listElementType = (_d = getTypeOfIterator({ type: argType, isIncomplete: argTypeResult.isIncomplete }, 
                     /* isAsync */ false, errorNode, 
-                    /* emitNotIterableError */ false)) === null || _f === void 0 ? void 0 : _f.type;
+                    /* emitNotIterableError */ false)) === null || _d === void 0 ? void 0 : _d.type;
                     if (paramInfo.param.category !== 1 /* ParamCategory.ArgsList */) {
                         matchedUnpackedListOfUnknownLength = true;
                     }
@@ -7335,7 +7359,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             paramType,
                             requiresTypeVarMatching: (0, typeUtils_1.requiresSpecialization)(paramType),
                             argument: funcArg,
-                            errorNode: (_g = argList[argIndex].valueExpression) !== null && _g !== void 0 ? _g : errorNode,
+                            errorNode: (_e = argList[argIndex].valueExpression) !== null && _e !== void 0 ? _e : errorNode,
                             paramName,
                             isParamNameSynthesized: types_1.FunctionParam.isNameSynthesized(paramInfo.param),
                             mapsToVarArgList: isParamVariadic && remainingArgCount > remainingParamCount,
@@ -7430,7 +7454,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             paramIndex < positionalOnlyLimitIndex &&
             paramIndex < paramDetails.params.length &&
             paramDetails.params[paramIndex].param.category === 1 /* ParamCategory.ArgsList */ &&
-            !(0, types_1.isParamSpec)(paramDetails.params[paramIndex].param.type)) {
+            !(0, types_1.isParamSpec)(paramDetails.params[paramIndex].type)) {
             paramIndex++;
             skippedArgsParam = true;
         }
@@ -7439,7 +7463,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (positionalOnlyLimitIndex >= 0 &&
             paramIndex < positionalOnlyLimitIndex &&
             (!foundUnpackedListArg || hasParamSpecArgsKwargs)) {
-            const firstParamWithDefault = paramDetails.params.findIndex((paramInfo) => !!paramInfo.param.defaultType);
+            const firstParamWithDefault = paramDetails.params.findIndex((paramInfo) => !!paramInfo.defaultType);
             const positionOnlyWithoutDefaultsCount = firstParamWithDefault >= 0 && firstParamWithDefault < positionalOnlyLimitIndex
                 ? firstParamWithDefault
                 : positionalOnlyLimitIndex;
@@ -7450,7 +7474,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 // because it's permitted to pass zero arguments to *args.
                 argsRemainingCount--;
             }
-            const firstArgsParam = paramDetails.params.findIndex((paramInfo) => paramInfo.param.category === 1 /* ParamCategory.ArgsList */ && !(0, types_1.isParamSpec)(paramInfo.param.type));
+            const firstArgsParam = paramDetails.params.findIndex((paramInfo) => paramInfo.param.category === 1 /* ParamCategory.ArgsList */ && !(0, types_1.isParamSpec)(paramInfo.type));
             if (firstArgsParam >= paramIndex && firstArgsParam < positionalOnlyLimitIndex) {
                 // If there is another args parameter beyond the current param index,
                 // reduce the count by one because it's permitted to pass zero arguments
@@ -7569,7 +7593,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             (0, types_1.isInstantiableClass)(supportsKeysAndGetItemClass) &&
                             strObjType &&
                             (0, types_1.isClassInstance)(strObjType)) {
-                            const mappingTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(supportsKeysAndGetItemClass));
+                            const mappingConstraints = new constraintTracker_1.ConstraintTracker();
                             let isValidMappingType = false;
                             // If this was a TypeVar (e.g. for pseudo-generic classes),
                             // don't emit this error.
@@ -7577,8 +7601,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                                 isValidMappingType = true;
                             }
                             else if (assignType(types_1.ClassType.cloneAsInstance(supportsKeysAndGetItemClass), argType, 
-                            /* diag */ undefined, mappingTypeVarContext)) {
-                                const specializedMapping = (0, typeUtils_1.applySolvedTypeVars)(supportsKeysAndGetItemClass, mappingTypeVarContext);
+                            /* diag */ undefined, mappingConstraints)) {
+                                const specializedMapping = solveAndApplyConstraints(supportsKeysAndGetItemClass, mappingConstraints);
                                 const typeArgs = specializedMapping.priv.typeArgs;
                                 if (typeArgs && typeArgs.length >= 2) {
                                     if (assignType(strObjType, typeArgs[0])) {
@@ -7640,7 +7664,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                                     paramType,
                                     requiresTypeVarMatching: (0, typeUtils_1.requiresSpecialization)(paramType),
                                     argument: argList[argIndex],
-                                    errorNode: (_h = argList[argIndex].valueExpression) !== null && _h !== void 0 ? _h : errorNode,
+                                    errorNode: (_f = argList[argIndex].valueExpression) !== null && _f !== void 0 ? _f : errorNode,
                                     paramName: paramNameValue,
                                 });
                                 trySetActive(argList[argIndex], paramDetails.params[paramInfoIndex].param);
@@ -7663,7 +7687,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                                     paramType,
                                     requiresTypeVarMatching: (0, typeUtils_1.requiresSpecialization)(paramType),
                                     argument: argList[argIndex],
-                                    errorNode: (_j = argList[argIndex].valueExpression) !== null && _j !== void 0 ? _j : errorNode,
+                                    errorNode: (_g = argList[argIndex].valueExpression) !== null && _g !== void 0 ? _g : errorNode,
                                     paramName: paramNameValue,
                                 });
                                 // Remember that this parameter has already received a value.
@@ -7714,7 +7738,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                                     requiresTypeVarMatching: false,
                                     argument: argList[argIndex],
                                     argType: (0, types_1.isParamSpec)(argType) ? undefined : types_1.AnyType.create(),
-                                    errorNode: (_k = argList[argIndex].valueExpression) !== null && _k !== void 0 ? _k : errorNode,
+                                    errorNode: (_h = argList[argIndex].valueExpression) !== null && _h !== void 0 ? _h : errorNode,
                                 });
                             }
                         }
@@ -7779,15 +7803,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 // and _T is a TypeVar, we need to match the TypeVar to the default
                 // value's type if it's not provided by the caller.
                 paramDetails.params.forEach((paramInfo) => {
-                    var _a;
                     const param = paramInfo.param;
                     if (param.category === 0 /* ParamCategory.Simple */ && param.name) {
                         const entry = paramMap.get(param.name);
                         if (entry.argsNeeded === 0 && entry.argsReceived === 0) {
-                            const defaultArgType = (_a = paramInfo.defaultArgType) !== null && _a !== void 0 ? _a : param.defaultType;
+                            const defaultArgType = paramInfo.defaultType;
                             if (defaultArgType &&
                                 !(0, typeUtils_1.isEllipsisType)(defaultArgType) &&
-                                (0, typeUtils_1.requiresSpecialization)(param.type)) {
+                                (0, typeUtils_1.requiresSpecialization)(paramInfo.declaredType)) {
                                 validateArgTypeParams.push({
                                     paramCategory: param.category,
                                     paramType: paramInfo.type,
@@ -7812,8 +7835,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // correct overload.
         if (!reportedArgError || !isSpeculativeModeInUse(undefined)) {
             // If there are arguments that map to a variadic *args parameter that hasn't
-            // already been matched, see if the type of that *args parameter is a variadic
-            // type variable. If so, we'll preprocess those arguments and combine them
+            // already been matched, see if the type of that *args parameter is a
+            // TypeVarTuple. If so, we'll preprocess those arguments and combine them
             // into a tuple.
             (0, debug_1.assert)(paramDetails.argsIndex === undefined || paramDetails.argsIndex < paramDetails.params.length, 'paramDetails.argsIndex params entry is invalid');
             if (paramDetails.argsIndex !== undefined &&
@@ -7822,7 +7845,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 !isTypeVarTupleFullyMatched) {
                 const paramType = paramDetails.params[paramDetails.argsIndex].type;
                 const variadicArgs = validateArgTypeParams.filter((argParam) => argParam.mapsToVarArgList);
-                if ((0, types_1.isTypeVarTuple)(paramType) && !paramType.priv.isVariadicInUnion) {
+                if ((0, types_1.isTypeVarTuple)(paramType) && !paramType.priv.isInUnion) {
                     const tupleTypeArgs = variadicArgs.map((argParam) => {
                         var _a;
                         const argType = getTypeOfArg(argParam.argument, /* inferenceContext */ undefined).type;
@@ -7904,7 +7927,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // After having matched arguments with parameters, this function evaluates the
     // types of each argument expression and validates that the resulting type is
     // compatible with the declared type of the corresponding parameter.
-    function validateArgTypesWithContext(errorNode, matchResults, typeVarContext, skipUnknownArgCheck = false, inferenceContext) {
+    function validateArgTypesWithContext(errorNode, matchResults, constraints, skipUnknownArgCheck = false, inferenceContext) {
         var _a;
         const type = matchResults.overload;
         let expectedType = inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.expectedType;
@@ -7915,20 +7938,20 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             expectedType = undefined;
         }
         const tryExpectedType = (expectedSubtype) => {
-            const clonedTypeVarContext = typeVarContext.clone();
-            const callResult = validateArgTypesWithExpectedType(errorNode, matchResults, clonedTypeVarContext, 
+            const clonedConstraints = constraints.clone();
+            const callResult = validateArgTypesWithExpectedType(errorNode, matchResults, clonedConstraints, 
             /* skipUnknownArgCheck */ true, expectedSubtype, returnType);
             // Use a heuristic to pick a subtype that is most likely to be correct.
             // We'll look for a subtype that produces no argument errors and has
             // no Unknowns in the return type.
             if (!callResult.argumentErrors && callResult.returnType) {
                 const returnType = (inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.returnTypeOverride)
-                    ? (0, typeUtils_1.applySolvedTypeVars)(inferenceContext.returnTypeOverride, clonedTypeVarContext)
+                    ? solveAndApplyConstraints(inferenceContext.returnTypeOverride, clonedConstraints)
                     : callResult.returnType;
                 if (assignType(expectedSubtype, returnType, 
                 /* diag */ undefined, 
-                /* destTypeVarContext */ undefined, 
-                /* srcTypeVarContext */ undefined, 1024 /* AssignTypeFlags.IgnoreTypeVarScope */)) {
+                /* destConstraints */ undefined, 
+                /* srcConstraints */ 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) {
@@ -7974,39 +7997,41 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // If there is no expected type, or the expected type is Any or Unknown,
         // there's nothing left to do here.
         if (!expectedType || (0, types_1.isAnyOrUnknown)(expectedType) || (0, types_1.isNever)(expectedType)) {
-            return validateArgTypes(errorNode, matchResults, typeVarContext, skipUnknownArgCheck);
+            return validateArgTypes(errorNode, matchResults, constraints, skipUnknownArgCheck);
         }
-        return validateArgTypesWithExpectedType(errorNode, matchResults, typeVarContext, skipUnknownArgCheck, expectedType, returnType);
+        return validateArgTypesWithExpectedType(errorNode, matchResults, constraints, skipUnknownArgCheck, expectedType, returnType);
     }
-    function validateArgTypesWithExpectedType(errorNode, matchResults, typeVarContext, skipUnknownArgCheck = false, expectedType, returnType) {
+    function validateArgTypesWithExpectedType(errorNode, matchResults, constraints, skipUnknownArgCheck = false, expectedType, returnType) {
         const liveTypeVarScopes = ParseTreeUtils.getTypeVarScopesForNode(errorNode);
         let assignFlags = 2048 /* AssignTypeFlags.PopulatingExpectedType */;
         if ((0, typeUtils_1.containsLiteralType)(expectedType, /* includeTypeArgs */ true)) {
             assignFlags |= 256 /* AssignTypeFlags.RetainLiteralsForTypeVar */;
         }
-        // Prepopulate the typeVarContext based on the specialized expected type.
+        // Prepopulate the constraints based on the specialized expected type.
         // This will allow us to more closely match the expected type if possible.
         if ((0, types_1.isClassInstance)(returnType) && (0, types_1.isClassInstance)(expectedType) && !(0, types_1.isTypeSame)(returnType, expectedType)) {
-            const tempTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(returnType));
-            if ((0, constraintSolver_1.addConstraintsForExpectedType)(evaluatorInterface, returnType, expectedType, tempTypeVarContext, liveTypeVarScopes, errorNode.start)) {
+            const tempConstraints = new constraintTracker_1.ConstraintTracker();
+            if ((0, constraintSolver_1.addConstraintsForExpectedType)(evaluatorInterface, returnType, expectedType, tempConstraints, liveTypeVarScopes, errorNode.start)) {
                 const genericReturnType = (0, typeUtils_1.selfSpecializeClass)(returnType, {
                     overrideTypeArgs: true,
                 });
-                expectedType = (0, typeUtils_1.applySolvedTypeVars)(genericReturnType, tempTypeVarContext, {
-                    unknownIfNotFound: true,
-                    useUnknownOverDefault: true,
-                    tupleClassType: getTupleClassType(),
+                expectedType = solveAndApplyConstraints(genericReturnType, tempConstraints, {
+                    replaceUnsolved: {
+                        scopeIds: (0, typeUtils_1.getTypeVarScopeIds)(returnType),
+                        useUnknown: true,
+                        tupleClassType: getTupleClassType(),
+                    },
                 });
                 assignFlags |= 4096 /* AssignTypeFlags.SkipPopulateUnknownExpectedType */;
             }
         }
         expectedType = (0, typeUtils_1.transformExpectedType)(expectedType, liveTypeVarScopes, errorNode.start);
         assignType(returnType, expectedType, 
-        /* diag */ undefined, typeVarContext, 
-        /* srcTypeVarContext */ undefined, assignFlags);
-        return validateArgTypes(errorNode, matchResults, typeVarContext, skipUnknownArgCheck);
+        /* diag */ undefined, constraints, 
+        /* srcConstraints */ undefined, assignFlags);
+        return validateArgTypes(errorNode, matchResults, constraints, skipUnknownArgCheck);
     }
-    function validateArgTypes(errorNode, matchResults, typeVarContext, skipUnknownArgCheck) {
+    function validateArgTypes(errorNode, matchResults, constraints, skipUnknownArgCheck) {
         const type = matchResults.overload;
         let isTypeIncomplete = matchResults.isTypeIncomplete;
         let argumentErrors = false;
@@ -8040,7 +8065,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 if (index < typeParams.length) {
                     const typeParam = typeParams[index];
                     if (!(0, types_1.isTypeSame)(typeParam, typeArg, { ignorePseudoGeneric: true })) {
-                        (0, typeUtils_1.setTypeVarType)(typeVarContext, typeParams[index], typeArg);
+                        constraints.setBounds(typeParams[index], typeArg);
                     }
                 }
             });
@@ -8071,24 +8096,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         if (!argParam.requiresTypeVarMatching) {
                             return;
                         }
-                        // Populate the typeVarContext for the argument. If the argument
+                        // 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.
-                        // We set useLowerBoundOnly to true if this is the first
-                        // (but not only) pass through the parameter list because a wide
-                        // bound on a TypeVar (if a lower bound has not yet been
-                        // established) will unnecessarily constrain the expected type.
                         // 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, typeVarContext, { type, isIncomplete: matchResults.isTypeIncomplete }, {
+                        const argResult = validateArgType(argParam, constraints, { type, isIncomplete: matchResults.isTypeIncomplete }, {
                             skipUnknownArgCheck,
-                            skipOverloadArg: i === 0,
-                            skipBareTypeVarExpectedType: i === 0,
-                            useLowerBoundOnly: passCount > 1 && i === 0,
+                            isArgFirstPass: passCount > 1 && i === 0,
                             conditionFilter: typeCondition,
+                            skipReportError: true,
                         });
                         if (argResult.isTypeIncomplete) {
                             isTypeIncomplete = true;
@@ -8103,7 +8123,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             // Lock the type var map so it cannot be modified when revalidating
             // the arguments in a second pass.
-            typeVarContext.lock();
+            constraints.lock();
         }
         let sawParamSpecArgs = false;
         let sawParamSpecKwargs = false;
@@ -8111,7 +8131,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         const argResults = [];
         matchResults.argParams.forEach((argParam, argParamIndex) => {
             var _a;
-            const argResult = validateArgType(argParam, typeVarContext, { type, isIncomplete: matchResults.isTypeIncomplete }, {
+            const argResult = validateArgType(argParam, constraints, { type, isIncomplete: matchResults.isTypeIncomplete }, {
                 skipUnknownArgCheck,
                 conditionFilter: typeCondition,
             });
@@ -8147,15 +8167,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
             }
         });
-        let paramSpecTypeVarContext = [];
+        let paramSpecConstraints = [];
         // Handle the assignment of additional arguments that map to a param spec.
         if (matchResults.paramSpecArgList && matchResults.paramSpecTarget) {
-            const paramSpecArgResult = validateArgTypesForParamSpec(errorNode, matchResults.paramSpecArgList, matchResults.paramSpecTarget, typeVarContext);
+            const paramSpecArgResult = validateArgTypesForParamSpec(errorNode, matchResults.paramSpecArgList, matchResults.paramSpecTarget, constraints);
             if (paramSpecArgResult.argumentErrors) {
                 argumentErrors = true;
                 argumentMatchScore += 1;
             }
-            paramSpecTypeVarContext = paramSpecArgResult.typeVarContexts;
+            paramSpecConstraints = paramSpecArgResult.constraintTrackers;
         }
         else if (paramSpec) {
             if (!sawParamSpecArgs || !sawParamSpecKwargs) {
@@ -8171,56 +8191,32 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (condition.length > 0) {
             returnType = types_1.TypeBase.cloneForCondition(returnType, condition);
         }
-        // Determine whether the expression being evaluated is within the current TypeVar
-        // scope. If not, then the expression is invoking a function in another scope,
-        // and we should eliminate unsolved type variables from union types that appear
-        // in the return type. If we're within the same scope, we should retain these
-        // extra type variables because they are still potentially relevant within this
-        // scope.
         let eliminateUnsolvedInUnions = true;
-        let curNode = errorNode;
-        while (curNode) {
-            const typeVarScopeNode = ParseTreeUtils.getTypeVarScopeNode(curNode);
-            if (!typeVarScopeNode) {
-                break;
-            }
-            const typeVarScopeId = ParseTreeUtils.getScopeIdForNode(typeVarScopeNode);
-            if (typeVarContext.hasSolveForScope(typeVarScopeId)) {
-                eliminateUnsolvedInUnions = false;
-            }
-            curNode = typeVarScopeNode.parent;
-        }
         // 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)) {
             eliminateUnsolvedInUnions = false;
         }
-        // We'll leave TypeVars unsolved if the call is a recursive
-        // call to a generic function or if this isn't a callable
-        // return with type parameters that are rescoped from the original
-        // function to the returned callable.
-        const liveTypeVarScopes = ParseTreeUtils.getTypeVarScopesForNode(errorNode);
-        const unknownIfNotFound = !liveTypeVarScopes.some((typeVarScope) => typeVarContext.hasSolveForScope(typeVarScope) ||
-            typeVarContext.hasSolveForScope(types_1.TypeVarType.makeInternalScopeId(typeVarScope)));
-        let specializedReturnType = (0, typeUtils_1.applySolvedTypeVars)(returnType, typeVarContext, {
-            unknownIfNotFound,
-            tupleClassType: getTupleClassType(),
-            unknownExemptTypeVars: getUnknownExemptTypeVarsForReturnType(type, returnType),
-            eliminateUnsolvedInUnions,
-            applyInScopePlaceholders: true,
-        });
+        let specializedReturnType = solveAndApplyConstraints(returnType, constraints, {
+            replaceUnsolved: {
+                scopeIds: (0, typeUtils_1.getTypeVarScopeIds)(type),
+                unsolvedExemptTypeVars: getUnknownExemptTypeVarsForReturnType(type, returnType),
+                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.
-        if (paramSpecTypeVarContext.length > 0) {
-            paramSpecTypeVarContext.forEach((paramSpecTypeVarContext) => {
-                if (paramSpecTypeVarContext) {
-                    specializedReturnType = (0, typeUtils_1.applySolvedTypeVars)(specializedReturnType, paramSpecTypeVarContext);
+        if (paramSpecConstraints.length > 0) {
+            paramSpecConstraints.forEach((paramSpecConstraints) => {
+                if (paramSpecConstraints) {
+                    specializedReturnType = solveAndApplyConstraints(specializedReturnType, paramSpecConstraints);
                     // It's possible that one or more of the TypeVars or ParamSpecs
-                    // in the typeVarContext refer to TypeVars that were solved in
-                    // the paramSpecTypeVarContext. Apply these solved TypeVars accordingly.
-                    (0, typeUtils_1.applySourceContextTypeVars)(typeVarContext, paramSpecTypeVarContext);
+                    // 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));
                 }
             });
         }
@@ -8228,9 +8224,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if ((0, types_1.isUnpackedClass)(specializedReturnType)) {
             specializedReturnType = types_1.ClassType.cloneForUnpacked(specializedReturnType, /* isUnpackedTuple */ false);
         }
+        const liveTypeVarScopes = ParseTreeUtils.getTypeVarScopesForNode(errorNode);
         specializedReturnType = adjustCallableReturnType(type, specializedReturnType, liveTypeVarScopes);
         if (specializedInitSelfType) {
-            specializedInitSelfType = (0, typeUtils_1.applySolvedTypeVars)(specializedInitSelfType, typeVarContext);
+            specializedInitSelfType = solveAndApplyConstraints(specializedInitSelfType, constraints);
         }
         matchResults.argumentMatchScore = argumentMatchScore;
         return {
@@ -8259,9 +8256,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (returnTypeScopeId && functionType.shared.typeVarScopeId) {
                 let typeVarsInReturnType = (0, typeUtils_1.getTypeVarArgsRecursive)(returnType);
                 // Remove any type variables that appear in the function's input parameters.
-                functionType.shared.parameters.forEach((param) => {
+                functionType.shared.parameters.forEach((param, index) => {
                     if (types_1.FunctionParam.isTypeDeclared(param)) {
-                        const typeVarsInInputParam = (0, typeUtils_1.getTypeVarArgsRecursive)(param.type);
+                        const typeVarsInInputParam = (0, typeUtils_1.getTypeVarArgsRecursive)(types_1.FunctionType.getParamType(functionType, index));
                         typeVarsInReturnType = typeVarsInReturnType.filter((returnTypeVar) => !typeVarsInInputParam.some((inputTypeVar) => (0, types_1.isTypeSame)(returnTypeVar, inputTypeVar)));
                     }
                 });
@@ -8276,14 +8273,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // or unions of callables. It's intended for a specific use case. We may
     // 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 typeVarsInReturnType = (0, typeUtils_1.getTypeVarArgsRecursive)(returnType).filter((t) => !liveTypeVarScopes.some((scopeId) => t.priv.scopeId === scopeId));
+            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 (typeVarsInReturnType.length > 0) {
-                return types_1.FunctionType.cloneWithNewTypeVarScopeId(returnType, callableType.shared.typeVarScopeId, callableType.priv.constructorTypeVarScopeId, typeVarsInReturnType);
+            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);
             }
         }
         return returnType;
@@ -8291,7 +8290,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // Tries to assign the call arguments to the function parameter
     // list and reports any mismatches in types or counts. Returns the
     // specialized return type of the call.
-    function validateArgs(errorNode, argList, typeResult, typeVarContext, skipUnknownArgCheck = false, inferenceContext) {
+    function validateArgs(errorNode, argList, typeResult, constraints, skipUnknownArgCheck = false, inferenceContext) {
         const matchResults = matchArgsToParams(errorNode, argList, typeResult, 0);
         if (matchResults.argumentErrors) {
             // Evaluate types of all args. This will ensure that referenced symbols are
@@ -8307,46 +8306,45 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 overloadsUsedForCall: [],
             };
         }
-        return validateArgTypesWithContext(errorNode, matchResults, typeVarContext, skipUnknownArgCheck, (0, typeUtils_1.makeInferenceContext)(inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.expectedType, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.isTypeIncomplete, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.returnTypeOverride));
+        return validateArgTypesWithContext(errorNode, matchResults, constraints !== null && constraints !== void 0 ? constraints : new constraintTracker_1.ConstraintTracker(), skipUnknownArgCheck, (0, typeUtils_1.makeInferenceContext)(inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.expectedType, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.isTypeIncomplete, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.returnTypeOverride));
     }
     // Determines whether the specified argument list satisfies the function
     // signature bound to the specified ParamSpec. Return value indicates success.
-    function validateArgTypesForParamSpec(errorNode, argList, paramSpec, destTypeVarContext) {
-        const solutionSets = destTypeVarContext.getSolutionSets();
+    function validateArgTypesForParamSpec(errorNode, argList, paramSpec, destConstraints) {
+        const sets = destConstraints.getConstraintSets();
         // Handle the common case where there is only one signature context.
-        if (solutionSets.length === 1) {
-            return validateArgTypesForParamSpecSignature(errorNode, argList, paramSpec, solutionSets[0]);
+        if (sets.length === 1) {
+            return validateArgTypesForParamSpecSignature(errorNode, argList, paramSpec, sets[0]);
         }
-        const filteredSolutionSets = [];
-        const typeVarContexts = [];
+        const filteredSets = [];
+        const constraintTrackers = [];
         const speculativeNode = getSpeculativeNodeForCall(errorNode);
-        solutionSets.forEach((context) => {
+        sets.forEach((context) => {
             // Use speculative mode to avoid emitting errors or caching types.
             useSpeculativeMode(speculativeNode, () => {
                 const paramSpecArgResult = validateArgTypesForParamSpecSignature(errorNode, argList, paramSpec, context);
                 if (!paramSpecArgResult.argumentErrors) {
-                    filteredSolutionSets.push(context);
+                    filteredSets.push(context);
                 }
-                (0, collectionUtils_1.appendArray)(typeVarContexts, paramSpecArgResult.typeVarContexts);
+                (0, collectionUtils_1.appendArray)(constraintTrackers, paramSpecArgResult.constraintTrackers);
             });
         });
         // Copy back any compatible signature contexts if any were compatible.
-        if (filteredSolutionSets.length > 0) {
-            destTypeVarContext.addSolutionSets(filteredSolutionSets);
+        if (filteredSets.length > 0) {
+            destConstraints.addConstraintSets(filteredSets);
         }
         // Evaluate non-speculatively to produce a final result and cache types.
-        const paramSpecArgResult = validateArgTypesForParamSpecSignature(errorNode, argList, paramSpec, filteredSolutionSets.length > 0 ? filteredSolutionSets[0] : solutionSets[0]);
-        return { argumentErrors: paramSpecArgResult.argumentErrors, typeVarContexts };
+        const paramSpecArgResult = validateArgTypesForParamSpecSignature(errorNode, argList, paramSpec, filteredSets.length > 0 ? filteredSets[0] : sets[0]);
+        return { argumentErrors: paramSpecArgResult.argumentErrors, constraintTrackers: constraintTrackers };
     }
-    function validateArgTypesForParamSpecSignature(errorNode, argList, paramSpec, typeVarContext) {
+    function validateArgTypesForParamSpecSignature(errorNode, argList, paramSpec, constraintSet) {
         var _a;
-        let paramSpecType = typeVarContext.getTypeVarType(paramSpec);
-        if (!paramSpecType) {
-            paramSpecType = (0, typeUtils_1.convertTypeToParamSpecValue)(paramSpec);
-        }
+        const solutionSet = (0, constraintSolver_1.solveConstraintSet)(evaluatorInterface, constraintSet);
+        let paramSpecType = solutionSet.getType(paramSpec);
+        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 srcTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeIds)(paramSpecType));
+        const srcConstraints = new constraintTracker_1.ConstraintTracker();
         if (matchResults.argumentErrors) {
             // Evaluate types of all args. This will ensure that referenced symbols are
             // not reported as unaccessed.
@@ -8355,7 +8353,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     getTypeOfExpression(arg.valueExpression);
                 }
             });
-            return { argumentErrors: true, typeVarContexts: [srcTypeVarContext] };
+            return { argumentErrors: true, constraintTrackers: [srcConstraints] };
         }
         const functionParamSpec = types_1.FunctionType.getParamSpecFromArgsKwargs(functionType);
         const functionWithoutParamSpec = types_1.FunctionType.cloneRemoveParamSpecArgsKwargs(functionType);
@@ -8395,13 +8393,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     type: printType(functionParamSpec),
                 }), argErrorNode !== null && argErrorNode !== void 0 ? argErrorNode : errorNode);
             }
-            return { argumentErrors, typeVarContexts: [srcTypeVarContext] };
+            return { argumentErrors, constraintTrackers: [srcConstraints] };
         }
-        const result = validateArgTypes(errorNode, matchResults, srcTypeVarContext, 
-        /* skipUnknownArgCheck */ undefined);
-        return { argumentErrors: !!result.argumentErrors, typeVarContexts: [srcTypeVarContext] };
+        const result = validateArgTypes(errorNode, matchResults, srcConstraints, /* skipUnknownArgCheck */ undefined);
+        return { argumentErrors: !!result.argumentErrors, constraintTrackers: [srcConstraints] };
     }
-    function validateArgType(argParam, typeVarContext, typeResult, options) {
+    function validateArgType(argParam, constraints, typeResult, options) {
         var _a, _b;
         let argType;
         let expectedTypeDiag;
@@ -8409,7 +8406,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         let isCompatible = true;
         const functionName = typeResult === null || typeResult === void 0 ? void 0 : typeResult.type.shared.name;
         let skippedBareTypeVarExpectedType = false;
-        let skipSolveTypeVars = false;
         if (argParam.argument.valueExpression) {
             let expectedType;
             // Is the expected type a "bare" in-scope TypeVar or a union of bare in-scope TypeVars?
@@ -8419,29 +8415,22 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     isExpectedTypeBareTypeVar = false;
                 }
             });
-            if (!options.skipBareTypeVarExpectedType || !isExpectedTypeBareTypeVar) {
+            if (!options.isArgFirstPass || !isExpectedTypeBareTypeVar) {
                 expectedType = argParam.paramType;
                 // If the parameter type is a function with a ParamSpec, don't apply
-                // the solved TypeVars if the typeVarContext has more than one signature.
+                // the solved TypeVars if the constraint tracker has more than one signature.
                 // This will expand the ParamSpec into an overload, which will cause problems.
                 const skipApplySolvedTypeVars = (0, types_1.isFunction)(argParam.paramType) &&
                     types_1.FunctionType.getParamSpecFromArgsKwargs(argParam.paramType) &&
-                    typeVarContext.getSolutionSets().length > 1;
+                    constraints.getConstraintSets().length > 1;
                 if (!skipApplySolvedTypeVars) {
-                    expectedType = (0, typeUtils_1.applySolvedTypeVars)(expectedType, typeVarContext, {
-                        useLowerBoundOnly: !!options.useLowerBoundOnly,
+                    expectedType = solveAndApplyConstraints(expectedType, constraints, /* applyOptions */ undefined, {
+                        useLowerBoundOnly: !!options.isArgFirstPass,
                     });
                 }
             }
             else {
                 skippedBareTypeVarExpectedType = true;
-                // If the expected type is a union of bare TypeVars, it's not clear which of the two
-                // (or both) should be constrained. We'll skip any attempt to solve the TypeVars during
-                // this pass and hope that subsequent arg assignments will help us establish the correct
-                // constraints.
-                if ((0, types_1.isUnion)(argParam.paramType)) {
-                    skipSolveTypeVars = true;
-                }
             }
             // If the expected type is unknown, don't use an expected type. Instead,
             // use default rules for evaluating the expression type.
@@ -8466,10 +8455,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
                 else if (expectedType && (0, typeUtils_1.requiresSpecialization)(expectedType)) {
                     // Assign the argument type back to the expected type to assign
-                    // values to any in-scope placeholder type variables.
-                    const typeVarContextClone = typeVarContext.clone();
-                    if (assignType(expectedType, argType, /* diag */ undefined, typeVarContextClone)) {
-                        typeVarContext.copyFromClone(typeVarContextClone);
+                    // 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 */)) {
+                        constraints.copyFromClone(clonedConstraints);
                     }
                     else {
                         isCompatible = false;
@@ -8496,7 +8487,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // If the argument came from a parameter's default argument value,
             // we may need to specialize the type.
             if (argParam.isDefaultArg) {
-                argType = (0, typeUtils_1.applySolvedTypeVars)(argType, typeVarContext);
+                argType = solveAndApplyConstraints(argType, constraints);
             }
         }
         // If we're assigning to a var arg dictionary with a TypeVar type,
@@ -8514,7 +8505,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             });
         }
         const condition = (_a = argType.props) === null || _a === void 0 ? void 0 : _a.condition;
-        let diag = new diagnostic_1.DiagnosticAddendum();
+        let diag = (options === null || options === void 0 ? void 0 : options.skipReportError) ? undefined : new diagnostic_1.DiagnosticAddendum();
         if ((0, types_1.isParamSpec)(argParam.paramType)) {
             // Handle the case where we're assigning a *args or **kwargs argument
             // to a *P.args or **P.kwargs parameter.
@@ -8527,107 +8518,65 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 return { isCompatible, argType, isTypeIncomplete, condition };
             }
         }
-        // If we are asked to skip overload arguments, determine whether the argument
-        // is an explicit overload type, an overloaded class constructor, or a
-        // an overloaded callback protocol.
-        if (options.skipOverloadArg) {
-            if ((0, types_1.isOverloadedFunction)(argType)) {
-                return {
-                    isCompatible,
-                    argType,
-                    isTypeIncomplete,
-                    skippedOverloadArg: true,
-                    skippedBareTypeVarExpectedType,
-                    condition,
-                };
-            }
-            const concreteParamType = makeTopLevelTypeVarsConcrete(argParam.paramType);
-            if ((0, types_1.isFunction)(concreteParamType) || (0, types_1.isOverloadedFunction)(concreteParamType)) {
-                if ((0, types_1.isInstantiableClass)(argType)) {
-                    const constructor = (0, constructors_1.createFunctionFromConstructor)(evaluatorInterface, argType);
-                    if (constructor) {
-                        return {
-                            isCompatible,
-                            argType,
-                            isTypeIncomplete,
-                            skippedOverloadArg: true,
-                            skippedBareTypeVarExpectedType,
-                            condition,
-                        };
-                    }
-                }
-                if ((0, types_1.isClassInstance)(argType)) {
-                    const callMember = (0, typeUtils_1.lookUpObjectMember)(argType, '__call__', 16 /* MemberAccessFlags.SkipInstanceMembers */);
-                    if (callMember) {
-                        const memberType = getTypeOfMember(callMember);
-                        if ((0, types_1.isOverloadedFunction)(memberType)) {
-                            return {
-                                isCompatible,
-                                argType,
-                                isTypeIncomplete,
-                                skippedOverloadArg: true,
-                                skippedBareTypeVarExpectedType,
-                                condition,
-                            };
-                        }
-                    }
-                }
-            }
-        }
-        let assignTypeFlags = skipSolveTypeVars ? 8 /* AssignTypeFlags.SkipSolveTypeVars */ : 0 /* AssignTypeFlags.Default */;
+        let assignTypeFlags = 0 /* AssignTypeFlags.Default */;
         if (argParam.isinstanceParam) {
             assignTypeFlags |= 16384 /* AssignTypeFlags.AllowIsinstanceSpecialForms */;
         }
-        if (!assignType(argParam.paramType, argType, diag.createAddendum(), typeVarContext, 
-        /* srcTypeVarContext */ undefined, assignTypeFlags)) {
-            // Mismatching parameter types are common in untyped code; don't bother spending time
-            // printing types if the diagnostic is disabled.
-            const fileInfo = AnalyzerNodeInfo.getFileInfo(argParam.errorNode);
-            if (fileInfo.diagnosticRuleSet.reportArgumentType !== 'none' &&
-                !canSkipDiagnosticForNode(argParam.errorNode) &&
-                !isTypeIncomplete) {
-                const argTypeText = printType(argType);
-                const paramTypeText = printType(argParam.paramType);
-                let message;
-                if (argParam.paramName && !argParam.isParamNameSynthesized) {
-                    if (functionName) {
-                        message = localize_1.LocMessage.argAssignmentParamFunction().format({
-                            argType: argTypeText,
-                            paramType: paramTypeText,
-                            functionName,
-                            paramName: argParam.paramName,
-                        });
+        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 (!(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.
+                const fileInfo = AnalyzerNodeInfo.getFileInfo(argParam.errorNode);
+                if (fileInfo.diagnosticRuleSet.reportArgumentType !== 'none' &&
+                    !canSkipDiagnosticForNode(argParam.errorNode) &&
+                    !isTypeIncomplete) {
+                    const argTypeText = printType(argType);
+                    const paramTypeText = printType(argParam.paramType);
+                    let message;
+                    if (argParam.paramName && !argParam.isParamNameSynthesized) {
+                        if (functionName) {
+                            message = localize_1.LocMessage.argAssignmentParamFunction().format({
+                                argType: argTypeText,
+                                paramType: paramTypeText,
+                                functionName,
+                                paramName: argParam.paramName,
+                            });
+                        }
+                        else {
+                            message = localize_1.LocMessage.argAssignmentParam().format({
+                                argType: argTypeText,
+                                paramType: paramTypeText,
+                                paramName: argParam.paramName,
+                            });
+                        }
                     }
                     else {
-                        message = localize_1.LocMessage.argAssignmentParam().format({
-                            argType: argTypeText,
-                            paramType: paramTypeText,
-                            paramName: argParam.paramName,
-                        });
-                    }
-                }
-                else {
-                    if (functionName) {
-                        message = localize_1.LocMessage.argAssignmentFunction().format({
-                            argType: argTypeText,
-                            paramType: paramTypeText,
-                            functionName,
-                        });
+                        if (functionName) {
+                            message = localize_1.LocMessage.argAssignmentFunction().format({
+                                argType: argTypeText,
+                                paramType: paramTypeText,
+                                functionName,
+                            });
+                        }
+                        else {
+                            message = localize_1.LocMessage.argAssignment().format({
+                                argType: argTypeText,
+                                paramType: paramTypeText,
+                            });
+                        }
                     }
-                    else {
-                        message = localize_1.LocMessage.argAssignment().format({
-                            argType: argTypeText,
-                            paramType: paramTypeText,
-                        });
+                    // If we have an expected type diagnostic addendum, use that
+                    // instead of the local diagnostic addendum because it will
+                    // be more informative.
+                    if (expectedTypeDiag) {
+                        diag = expectedTypeDiag;
                     }
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportArgumentType, message + (diag === null || diag === void 0 ? void 0 : diag.getString()), argParam.errorNode, (_b = diag === null || diag === void 0 ? void 0 : diag.getEffectiveTextRange()) !== null && _b !== void 0 ? _b : argParam.errorNode);
                 }
-                // If we have an expected type diagnostic addendum, use that
-                // instead of the local diagnostic addendum because it will
-                // be more informative.
-                if (expectedTypeDiag) {
-                    diag = expectedTypeDiag;
-                }
-                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportArgumentType, message + diag.getString(), argParam.errorNode, (_b = diag.getEffectiveTextRange()) !== null && _b !== void 0 ? _b : argParam.errorNode);
             }
             return { isCompatible: false, argType, isTypeIncomplete, skippedBareTypeVarExpectedType, condition };
         }
@@ -8699,7 +8648,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.duplicateParam().format({ name: paramName }), argList[i].valueExpression || errorNode);
                 }
                 if (paramName === 'bound') {
-                    if (typeVar.shared.constraints.length > 0) {
+                    if (types_1.TypeVarType.hasConstraints(typeVar)) {
                         addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarBoundAndConstrained(), argList[i].valueExpression || errorNode);
                     }
                     else {
@@ -8768,7 +8717,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 paramNameMap.set(paramName, paramName);
             }
             else {
-                if (typeVar.shared.boundType) {
+                if (types_1.TypeVarType.hasBound(typeVar)) {
                     addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarBoundAndConstrained(), argList[i].valueExpression || errorNode);
                 }
                 else {
@@ -8797,22 +8746,24 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     }
     function verifyTypeVarDefaultIsCompatible(typeVar, defaultValueNode) {
         (0, debug_1.assert)(typeVar.shared.isDefaultExplicit);
-        const typeVarContext = new typeVarContext_1.TypeVarContext(typeVar.priv.scopeId);
-        const concreteDefaultType = makeTopLevelTypeVarsConcrete((0, typeUtils_1.applySolvedTypeVars)(typeVar.shared.defaultType, typeVarContext, {
-            unknownIfNotFound: true,
-            tupleClassType: getTupleClassType(),
+        const constraints = new constraintTracker_1.ConstraintTracker();
+        const concreteDefaultType = makeTopLevelTypeVarsConcrete(solveAndApplyConstraints(typeVar.shared.defaultType, constraints, {
+            replaceUnsolved: {
+                scopeIds: (0, typeUtils_1.getTypeVarScopeIds)(typeVar),
+                tupleClassType: getTupleClassType(),
+            },
         }));
         if (typeVar.shared.boundType) {
             if (!assignType(typeVar.shared.boundType, concreteDefaultType)) {
                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarDefaultBoundMismatch(), defaultValueNode);
             }
         }
-        else if (typeVar.shared.constraints.length > 0) {
+        else if (types_1.TypeVarType.hasConstraints(typeVar)) {
             let isConstraintCompatible = true;
             // If the default type is a constrained TypeVar, make sure all of its constraints
             // are also constraints in typeVar. If the default type is not a constrained TypeVar,
             // use its concrete type to compare against the constraints.
-            if ((0, types_1.isTypeVar)(typeVar.shared.defaultType) && typeVar.shared.defaultType.shared.constraints.length > 0) {
+            if ((0, types_1.isTypeVar)(typeVar.shared.defaultType) && types_1.TypeVarType.hasConstraints(typeVar.shared.defaultType)) {
                 for (const constraint of typeVar.shared.defaultType.shared.constraints) {
                     if (!typeVar.shared.constraints.some((c) => (0, types_1.isTypeSame)(c, constraint))) {
                         isConstraintCompatible = false;
@@ -9047,7 +8998,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             typeParamsExpr.d.items.map((expr) => {
                 let entryType = getTypeOfExpression(expr, 128 /* EvalFlags.InstantiableType */ | 4096 /* EvalFlags.AllowTypeVarWithoutScopeId */).type;
                 if ((0, types_1.isTypeVar)(entryType)) {
-                    if (entryType.priv.scopeId || ((0, types_1.isTypeVarTuple)(entryType) && entryType.priv.isVariadicUnpacked)) {
+                    if (entryType.priv.scopeId || ((0, types_1.isTypeVarTuple)(entryType) && entryType.priv.isUnpacked)) {
                         isTypeParamListValid = false;
                     }
                     else {
@@ -9219,6 +9170,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     }
     function getTypeOfMagicMethodCall(objType, methodName, argList, errorNode, inferenceContext, diag) {
         let magicMethodSupported = true;
+        let isIncomplete = false;
+        let deprecationInfo;
+        const overloadsUsedForCall = [];
         // Create a helper lambda for object subtypes.
         const handleSubtype = (subtype) => {
             let magicMethodType;
@@ -9237,7 +9191,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 callResult = useSpeculativeMode(errorNode, () => {
                     (0, debug_1.assert)(magicMethodType !== undefined);
                     return validateCallArgs(errorNode, functionArgs, { type: magicMethodType }, 
-                    /* typeVarContext */ undefined, 
+                    /* constraints */ undefined, 
                     /* skipUnknownArgCheck */ true, inferenceContext);
                 });
                 // If there were errors with the expected type, try
@@ -9246,7 +9200,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     callResult = useSpeculativeMode(errorNode, () => {
                         (0, debug_1.assert)(magicMethodType !== undefined);
                         return validateCallArgs(errorNode, functionArgs, { type: magicMethodType }, 
-                        /* typeVarContext */ undefined, 
+                        /* constraints */ undefined, 
                         /* skipUnknownArgCheck */ true, 
                         /* inferenceContext */ undefined);
                     });
@@ -9254,6 +9208,22 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 if (callResult.argumentErrors) {
                     magicMethodSupported = false;
                 }
+                else if (callResult.overloadsUsedForCall) {
+                    callResult.overloadsUsedForCall.forEach((overload) => {
+                        overloadsUsedForCall.push(overload);
+                        // If one of the overloads is deprecated, note the message.
+                        if (overload.shared.deprecatedMessage && (0, types_1.isClass)(concreteSubtype)) {
+                            deprecationInfo = {
+                                deprecatedMessage: overload.shared.deprecatedMessage,
+                                className: concreteSubtype.shared.name,
+                                methodName,
+                            };
+                        }
+                    });
+                }
+                if (callResult.isTypeIncomplete) {
+                    isIncomplete = true;
+                }
                 return callResult.returnType;
             }
             magicMethodSupported = false;
@@ -9284,7 +9254,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (!magicMethodSupported) {
             return undefined;
         }
-        return returnType;
+        return { type: returnType, isIncomplete, magicMethodDeprecationInfo: deprecationInfo, overloadsUsedForCall };
     }
     function getTypeOfDictionary(node, flags, inferenceContext) {
         var _a;
@@ -9381,11 +9351,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (!(0, types_1.isClassInstance)(builtInDict)) {
                 return undefined;
             }
-            const dictTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(builtInDict));
-            if (!(0, constraintSolver_1.addConstraintsForExpectedType)(evaluatorInterface, builtInDict, inferenceContext.expectedType, dictTypeVarContext, ParseTreeUtils.getTypeVarScopesForNode(node), node.start)) {
+            const dictConstraints = new constraintTracker_1.ConstraintTracker();
+            if (!(0, constraintSolver_1.addConstraintsForExpectedType)(evaluatorInterface, builtInDict, inferenceContext.expectedType, dictConstraints, ParseTreeUtils.getTypeVarScopesForNode(node), node.start)) {
                 return undefined;
             }
-            const specializedDict = (0, typeUtils_1.applySolvedTypeVars)(types_1.ClassType.cloneAsInstantiable(builtInDict), dictTypeVarContext);
+            const specializedDict = solveAndApplyConstraints(types_1.ClassType.cloneAsInstantiable(builtInDict), dictConstraints);
             if (!specializedDict.priv.typeArgs || specializedDict.priv.typeArgs.length !== 2) {
                 return undefined;
             }
@@ -9511,12 +9481,20 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     (0, typeUtils_1.isLiteralType)(keyType) &&
                     (expectedTypedDictEntries.knownItems.has(keyType.priv.literalValue) ||
                         expectedTypedDictEntries.extraItems)) {
-                    const effectiveValueType = (_b = (_a = expectedTypedDictEntries.knownItems.get(keyType.priv.literalValue)) === null || _a === void 0 ? void 0 : _a.valueType) !== null && _b !== void 0 ? _b : (_c = expectedTypedDictEntries.extraItems) === null || _c === void 0 ? void 0 : _c.valueType;
+                    let effectiveValueType = (_b = (_a = expectedTypedDictEntries.knownItems.get(keyType.priv.literalValue)) === null || _a === void 0 ? void 0 : _a.valueType) !== null && _b !== void 0 ? _b : (_c = expectedTypedDictEntries.extraItems) === null || _c === void 0 ? void 0 : _c.valueType;
+                    if (effectiveValueType) {
+                        const liveTypeVarScopes = ParseTreeUtils.getTypeVarScopesForNode(node);
+                        effectiveValueType = (0, typeUtils_1.transformExpectedType)(effectiveValueType, liveTypeVarScopes, node.start);
+                    }
                     entryInferenceContext = (0, typeUtils_1.makeInferenceContext)(effectiveValueType);
                     valueTypeResult = getTypeOfExpression(entryNode.d.valueExpr, flags | 268435456 /* EvalFlags.StripTupleLiterals */, entryInferenceContext);
                 }
                 else {
-                    const effectiveValueType = expectedValueType !== null && expectedValueType !== void 0 ? expectedValueType : (forceStrictInference ? types_1.NeverType.createNever() : undefined);
+                    let effectiveValueType = expectedValueType !== null && expectedValueType !== void 0 ? expectedValueType : (forceStrictInference ? types_1.NeverType.createNever() : undefined);
+                    if (effectiveValueType) {
+                        const liveTypeVarScopes = ParseTreeUtils.getTypeVarScopesForNode(node);
+                        effectiveValueType = (0, typeUtils_1.transformExpectedType)(effectiveValueType, liveTypeVarScopes, node.start);
+                    }
                     entryInferenceContext = (0, typeUtils_1.makeInferenceContext)(effectiveValueType);
                     valueTypeResult = getTypeOfExpression(entryNode.d.valueExpr, flags | 268435456 /* EvalFlags.StripTupleLiterals */, entryInferenceContext);
                 }
@@ -9602,12 +9580,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     }
                 }
                 else if (supportsKeysAndGetItemClass && (0, types_1.isInstantiableClass)(supportsKeysAndGetItemClass)) {
-                    const mappingTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(supportsKeysAndGetItemClass));
+                    const mappingConstraints = new constraintTracker_1.ConstraintTracker();
                     supportsKeysAndGetItemClass = (0, typeUtils_1.selfSpecializeClass)(supportsKeysAndGetItemClass);
                     if (assignType(types_1.ClassType.cloneAsInstance(supportsKeysAndGetItemClass), unexpandedType, 
-                    /* diag */ undefined, mappingTypeVarContext, 
-                    /* srcTypeVarContext */ undefined, 256 /* AssignTypeFlags.RetainLiteralsForTypeVar */)) {
-                        const specializedMapping = (0, typeUtils_1.applySolvedTypeVars)(supportsKeysAndGetItemClass, mappingTypeVarContext);
+                    /* diag */ undefined, mappingConstraints, 
+                    /* srcConstraints */ undefined, 256 /* AssignTypeFlags.RetainLiteralsForTypeVar */)) {
+                        const specializedMapping = solveAndApplyConstraints(supportsKeysAndGetItemClass, mappingConstraints);
                         const typeArgs = specializedMapping.priv.typeArgs;
                         if (typeArgs && typeArgs.length >= 2) {
                             if (forceStrictInference || index < maxEntriesToUseForInference) {
@@ -9763,11 +9741,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (!(0, types_1.isClassInstance)(inferenceContext.expectedType)) {
             return undefined;
         }
-        const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(expectedClassType));
-        if (!(0, constraintSolver_1.addConstraintsForExpectedType)(evaluatorInterface, types_1.ClassType.cloneAsInstance(expectedClassType), inferenceContext.expectedType, typeVarContext, ParseTreeUtils.getTypeVarScopesForNode(node), node.start)) {
+        const constraints = new constraintTracker_1.ConstraintTracker();
+        if (!(0, constraintSolver_1.addConstraintsForExpectedType)(evaluatorInterface, types_1.ClassType.cloneAsInstance(expectedClassType), inferenceContext.expectedType, constraints, ParseTreeUtils.getTypeVarScopesForNode(node), node.start)) {
             return undefined;
         }
-        const specializedListOrSet = (0, typeUtils_1.applySolvedTypeVars)(expectedClassType, typeVarContext);
+        const specializedListOrSet = solveAndApplyConstraints(expectedClassType, constraints);
         if (!specializedListOrSet.priv.typeArgs) {
             return undefined;
         }
@@ -9851,11 +9829,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if ((0, types_1.isAny)(inferenceContext.expectedType)) {
             return inferenceContext.expectedType;
         }
-        const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(inferenceContext.expectedType));
+        const constraints = new constraintTracker_1.ConstraintTracker();
         const expectedType = inferenceContext.expectedType;
         let isCompatible = true;
         entryTypes.forEach((entryType) => {
-            if (isCompatible && !assignType(expectedType, entryType, /* diag */ undefined, typeVarContext)) {
+            if (isCompatible && !assignType(expectedType, entryType, /* diag */ undefined, constraints)) {
                 isCompatible = false;
             }
         });
@@ -9868,7 +9846,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 ? combinedTypes
                 : stripLiteralValue(combinedTypes);
         }
-        return (0, typeUtils_1.mapSubtypes)((0, typeUtils_1.applySolvedTypeVars)(inferenceContext.expectedType, typeVarContext, { applyInScopePlaceholders: true }), (subtype) => {
+        return (0, typeUtils_1.mapSubtypes)(solveAndApplyConstraints(inferenceContext.expectedType, constraints, {
+            replaceUnsolved: {
+                scopeIds: [],
+                tupleClassType: getTupleClassType(),
+            },
+        }, { applyUnificationVars: true }), (subtype) => {
             if (entryTypes.length !== 1) {
                 return subtype;
             }
@@ -9894,11 +9877,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 let returnType = types_1.FunctionType.getEffectiveReturnType(functionTypeInfo.functionType);
                 if (returnType) {
                     const liveScopeIds = ParseTreeUtils.getTypeVarScopesForNode(node);
-                    returnType = (0, typeUtils_1.updateTypeWithInternalTypeVars)(returnType, liveScopeIds);
+                    returnType = (0, typeUtils_1.makeTypeVarsBound)(returnType, liveScopeIds);
                     expectedYieldType = (0, typeUtils_1.getGeneratorYieldType)(returnType, !!enclosingFunction.d.isAsync);
                     const generatorTypeArgs = (0, typeUtils_1.getGeneratorTypeArgs)(returnType);
                     if (generatorTypeArgs && generatorTypeArgs.length >= 2) {
-                        sentType = (0, typeUtils_1.updateTypeWithInternalTypeVars)(generatorTypeArgs[1], liveScopeIds);
+                        sentType = (0, typeUtils_1.makeTypeVarsBound)(generatorTypeArgs[1], liveScopeIds);
                     }
                 }
             }
@@ -10082,12 +10065,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     // If the expectedReturnType is generic, see if the actual return type
                     // provides types for some or all type variables.
                     if ((0, typeUtils_1.requiresSpecialization)(expectedReturnType)) {
-                        const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(functionType));
-                        if (assignType(expectedReturnType, returnTypeResult.type, 
-                        /* diag */ undefined, typeVarContext)) {
-                            functionType = (0, typeUtils_1.applySolvedTypeVars)(functionType, typeVarContext, {
-                                applyInScopePlaceholders: true,
-                            });
+                        const constraints = new constraintTracker_1.ConstraintTracker();
+                        if (assignType(expectedReturnType, returnTypeResult.type, /* diag */ undefined, constraints)) {
+                            functionType = solveAndApplyConstraints(functionType, constraints, {
+                                replaceUnsolved: {
+                                    scopeIds: [],
+                                    tupleClassType: getTupleClassType(),
+                                },
+                            }, { applyUnificationVars: true });
                         }
                     }
                 }
@@ -10290,7 +10275,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 return false;
             }
         }
-        if ((0, types_1.isTypeVarTuple)(argResult.type) && !argResult.type.priv.isVariadicInUnion) {
+        if ((0, types_1.isTypeVarTuple)(argResult.type) && !argResult.type.priv.isInUnion) {
             if (!(options === null || options === void 0 ? void 0 : options.allowTypeVarTuple)) {
                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeVarTupleContext(), argResult.node);
                 return false;
@@ -10328,7 +10313,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 let sawUnpacked = false;
                 let reportedUnpackedError = false;
                 const noteSawUnpacked = (entry) => {
-                    // Make sure we have at most one unpacked variadic type variable.
+                    // Make sure we have at most one unpacked TypeVarTuple.
                     if (sawUnpacked) {
                         if (!reportedUnpackedError) {
                             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.variadicTypeArgsTooMany(), entry.node);
@@ -10416,7 +10401,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             functionType.shared.flags |= 32768 /* FunctionTypeFlags.GradualCallableForm */;
         }
         if (paramSpec) {
-            types_1.FunctionType.addParamSpecVariadics(functionType, paramSpec);
+            types_1.FunctionType.addParamSpecVariadics(functionType, (0, typeUtils_1.convertToInstance)(paramSpec));
         }
         return functionType;
     }
@@ -10653,7 +10638,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         const annotationType = getTypeOfAnnotation(firstParamTypeAnnotation, {
                             typeVarGetsCurScope: true,
                         });
-                        if (!(0, types_1.isTypeVar)(annotationType) || !annotationType.shared.isSynthesizedSelf) {
+                        if (!(0, types_1.isTypeVar)(annotationType) || !types_1.TypeVarType.isSelf(annotationType)) {
                             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.selfTypeWithTypedSelfOrCls(), errorNode);
                         }
                     }
@@ -10663,11 +10648,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         let result = (0, typeUtils_1.synthesizeTypeVarForSelfCls)(enclosingClassTypeResult.classType, /* isClsParam */ true);
         if (enclosingClass) {
             // If "Self" is used as a type expression within a function suite, it needs
-            // to be marked as "internal".
+            // to be marked as bound.
             const enclosingSuite = ParseTreeUtils.getEnclosingClassOrFunctionSuite(errorNode);
             if (enclosingSuite && ParseTreeUtils.isNodeContainedWithin(enclosingSuite, enclosingClass)) {
                 if (enclosingClass.d.suite !== enclosingSuite) {
-                    result = types_1.TypeVarType.cloneWithInternalScopeId(result);
+                    result = types_1.TypeVarType.cloneAsBound(result);
                 }
             }
         }
@@ -10751,7 +10736,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if ((0, types_1.isInstantiableClass)(typeArgType) && !typeArgType.priv.includeSubclasses && (0, typeUtils_1.isTupleClass)(typeArgType)) {
                 return types_1.ClassType.cloneForUnpacked(typeArgType);
             }
-            if ((0, types_1.isTypeVarTuple)(typeArgType) && !typeArgType.priv.isVariadicUnpacked) {
+            if ((0, types_1.isTypeVarTuple)(typeArgType) && !typeArgType.priv.isUnpacked) {
                 return types_1.TypeVarType.cloneForUnpacked(typeArgType);
             }
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.unpackExpectedTypeVarTuple(), errorNode);
@@ -10858,7 +10843,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         typeResult: { type: (0, typeUtils_1.convertToInstance)(annotatedType) },
                     },
                 ], { type: supportsTypeMethod }, 
-                /* typeVarContext */ undefined, 
+                /* constraints */ undefined, 
                 /* skipUnknownArgCheck */ true, 
                 /* inferenceContext */ undefined));
                 if (callResult.isTypeIncomplete || !callResult.returnType) {
@@ -10911,7 +10896,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.ellipsisSecondArg(), typeArg.node);
                         }
                         else {
-                            if ((0, types_1.isTypeVarTuple)(typeArgs[0].type) && !typeArgs[0].type.priv.isVariadicInUnion) {
+                            if ((0, types_1.isTypeVarTuple)(typeArgs[0].type) && !typeArgs[0].type.priv.isInUnion) {
                                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.typeVarTupleContext(), typeArgs[0].node);
                             }
                             else if ((0, types_1.isUnpackedClass)(typeArgs[0].type)) {
@@ -10923,7 +10908,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         // Nothing to do - this is allowed.
                     }
                     else if (paramLimit === undefined && (0, types_1.isTypeVarTuple)(typeArg.type)) {
-                        if (!typeArg.type.priv.isVariadicInUnion) {
+                        if (!typeArg.type.priv.isInUnion) {
                             noteSawUnpacked(typeArg);
                         }
                         validateTypeVarTupleIsUnpacked(typeArg.type, typeArg.node);
@@ -11046,7 +11031,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
         }
         // Validate that we received at least two type arguments. One type argument
-        // is allowed if it's an unpacked variadic type var or tuple. None is also allowed
+        // is allowed if it's an unpacked TypeVarTuple or tuple. None is also allowed
         // since it is used to define NoReturn in typeshed stubs).
         if (types.length === 1 && !allowSingleTypeArg && !(0, typeUtils_1.isNoneInstance)(types[0])) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeArguments, localize_1.LocMessage.unionTypeArgCount(), errorNode);
@@ -11137,7 +11122,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             validateTypeParamDefault(bestErrorNode, typeParam, typeParams.slice(0, index), typeAliasScopeId);
         });
-        // Verify that we have at most one variadic type variable.
+        // Verify that we have at most one TypeVarTuple.
         const variadics = typeParams.filter((param) => (0, types_1.isTypeVarTuple)(param));
         if (variadics.length > 1) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.variadicTypeParamTooManyAlias().format({
@@ -11153,7 +11138,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
         }
         const fileInfo = AnalyzerNodeInfo.getFileInfo(name);
-        let typeAlias = types_1.TypeBase.cloneForTypeAlias(type, name.d.value, ParseTreeUtils.getClassFullName(name, fileInfo.moduleName, name.d.value), fileInfo.moduleName, fileInfo.fileUri, typeAliasScopeId, isPep695Syntax, typeParams.length > 0 ? typeParams : undefined);
+        let typeAlias = types_1.TypeBase.cloneForTypeAlias(type, {
+            name: name.d.value,
+            fullName: ParseTreeUtils.getClassFullName(name, fileInfo.moduleName, name.d.value),
+            moduleName: fileInfo.moduleName,
+            fileUri: fileInfo.fileUri,
+            typeVarScopeId: typeAliasScopeId,
+            isPep695Syntax,
+            typeParams: typeParams.length > 0 ? typeParams : undefined,
+            usageVariance: undefined,
+            typeArgs: undefined,
+        });
         // All PEP 695 type aliases are special forms because they are
         // TypeAliasType objects at runtime.
         if (isPep695Syntax || isPep695TypeVarType) {
@@ -11886,7 +11881,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (classType.shared.typeParams.some((param) => param.shared.declaredVariance === 0 /* Variance.Auto */ && param.priv.computedVariance === undefined)) {
                 classType.shared.requiresVarianceInference = true;
             }
-            // Make sure there's at most one variadic type parameter.
+            // Make sure there's at most one TypeVarTuple.
             const variadics = typeParams.filter((param) => (0, types_1.isTypeVarTuple)(param));
             if (variadics.length > 1) {
                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.variadicTypeParamTooManyClass().format({
@@ -11894,7 +11889,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }), node.d.name, textRange_1.TextRange.combine(node.d.arguments) || node.d.name);
             }
             else if (variadics.length > 0) {
-                // Make sure a TypeVar with a default doesn't come after a variadic type parameter.
+                // Make sure a TypeVar with a default doesn't come after a TypeVarTuple.
                 const firstVariadicIndex = classType.shared.typeParams.findIndex((param) => (0, types_1.isTypeVarTuple)(param));
                 const typeVarWithDefaultIndex = classType.shared.typeParams.findIndex((param, index) => index > firstVariadicIndex && !(0, types_1.isParamSpec)(param) && param.shared.isDefaultExplicit);
                 if (typeVarWithDefaultIndex >= 0) {
@@ -12138,9 +12133,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // parameters and updates the scope of the type parameter referred to in the
     // default type expression.
     function validateTypeParamDefault(errorNode, typeParam, otherLiveTypeParams, scopeId) {
-        if (!typeParam.shared.isDefaultExplicit &&
-            !typeParam.shared.isSynthesized &&
-            !typeParam.shared.isSynthesizedSelf) {
+        if (!typeParam.shared.isDefaultExplicit && !typeParam.shared.isSynthesized && !types_1.TypeVarType.isSelf(typeParam)) {
             const typeVarWithDefault = otherLiveTypeParams.find((param) => param.shared.isDefaultExplicit && param.priv.scopeId === scopeId);
             if (typeVarWithDefault) {
                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarWithoutDefault().format({
@@ -12179,7 +12172,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         });
         const dummyTypeObject = types_1.ClassType.createInstantiable('__varianceDummy', '', '', uri_1.Uri.empty(), 0, 0, undefined, undefined);
         classType.shared.typeParams.forEach((param, paramIndex) => {
-            // Skip variadics and ParamSpecs.
+            // Skip TypeVarTuples and ParamSpecs.
             if ((0, types_1.isTypeVarTuple)(param) || (0, types_1.isParamSpec)(param)) {
                 return;
             }
@@ -12413,7 +12406,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                                     argument: arg,
                                     errorNode: (_b = arg.valueExpression) !== null && _b !== void 0 ? _b : node.d.name,
                                 };
-                                validateArgType(argParam, new typeVarContext_1.TypeVarContext(), { type: newMethodType }, { skipUnknownArgCheck: true, skipOverloadArg: true });
+                                validateArgType(argParam, new constraintTracker_1.ConstraintTracker(), { type: newMethodType }, { skipUnknownArgCheck: true });
                                 paramMap.delete(arg.name.d.value);
                             }
                             else {
@@ -12426,7 +12419,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     const unassignedParams = [];
                     paramMap.forEach((index, paramName) => {
                         const paramInfo = paramListDetails.params[index];
-                        if (!paramInfo.param.defaultType) {
+                        if (!paramInfo.defaultType) {
                             unassignedParams.push(paramName);
                         }
                     });
@@ -12451,7 +12444,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 const initSubclassMethodType = initSubclassMethodInfo.type;
                 if (initSubclassMethodType && initSubclassMethodInfo.classType) {
                     const callResult = validateCallArgs(node.d.name, argList, { type: initSubclassMethodType }, 
-                    /* typeVarContext */ undefined, 
+                    /* constraints */ undefined, 
                     /* skipUnknownArgCheck */ false, (0, typeUtils_1.makeInferenceContext)(getNoneType()));
                     if (callResult.argumentErrors) {
                         const diag = addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.initSubclassCallFailed(), node.d.name);
@@ -12682,7 +12675,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     if (annotatedType) {
                         (0, typeUtils_1.addTypeVarsToListIfUnique)(typeParamsSeen, (0, typeUtils_1.getTypeVarArgsRecursive)(annotatedType), functionType.shared.typeVarScopeId);
                     }
-                    if ((0, types_1.isTypeVarTuple)(annotatedType) && !annotatedType.priv.isVariadicUnpacked) {
+                    if ((0, types_1.isTypeVarTuple)(annotatedType) && !annotatedType.priv.isUnpacked) {
                         addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeForm, localize_1.LocMessage.unpackedTypeVarTupleExpected().format({
                             name1: annotatedType.shared.name,
                             name2: annotatedType.shared.name,
@@ -12724,13 +12717,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     // that the default value matches the annotation.
                     if (param.d.defaultValue && defaultValueType) {
                         const diagAddendum = new diagnostic_1.DiagnosticAddendum();
-                        const typeVarContext = new typeVarContext_1.TypeVarContext(functionType.shared.typeVarScopeId);
-                        if (containingClassType && containingClassType.shared.typeVarScopeId !== undefined) {
-                            if (node.d.name.d.value === '__init__' || node.d.name.d.value === '__new__') {
-                                typeVarContext.addSolveForScope(containingClassType.shared.typeVarScopeId);
-                            }
-                        }
-                        if (!assignType(annotatedType, defaultValueType, diagAddendum, typeVarContext)) {
+                        if (!assignType(annotatedType, defaultValueType, diagAddendum)) {
                             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportArgumentType, localize_1.LocMessage.paramAssignmentMismatch().format({
                                 sourceType: printType(defaultValueType),
                                 paramType: printType(annotatedType),
@@ -12777,18 +12764,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         paramType = inferredType;
                     }
                 }
-                const functionParam = types_1.FunctionParam.create(param.d.category, paramType !== null && paramType !== void 0 ? paramType : types_1.UnknownType.create(), (isTypeInferred ? types_1.FunctionParamFlags.TypeInferred : types_1.FunctionParamFlags.None) |
+                paramType = paramType !== null && paramType !== void 0 ? paramType : types_1.UnknownType.create();
+                const functionParam = types_1.FunctionParam.create(param.d.category, paramType, (isTypeInferred ? types_1.FunctionParamFlags.TypeInferred : types_1.FunctionParamFlags.None) |
                     (paramTypeNode ? types_1.FunctionParamFlags.TypeDeclared : types_1.FunctionParamFlags.None), param.d.name ? param.d.name.d.value : undefined, defaultValueType);
                 types_1.FunctionType.addParam(functionType, functionParam);
                 if (types_1.FunctionParam.isTypeDeclared(functionParam)) {
-                    (0, typeUtils_1.addTypeVarsToListIfUnique)(typeParamsSeen, (0, typeUtils_1.getTypeVarArgsRecursive)(functionParam.type), functionType.shared.typeVarScopeId);
+                    (0, typeUtils_1.addTypeVarsToListIfUnique)(typeParamsSeen, (0, typeUtils_1.getTypeVarArgsRecursive)(paramType), functionType.shared.typeVarScopeId);
                 }
                 if (param.d.name) {
-                    const variadicParamType = transformVariadicParamType(node, param.d.category, functionParam.type);
+                    const variadicParamType = transformVariadicParamType(node, param.d.category, paramType);
                     paramTypes.push(variadicParamType);
                 }
                 else {
-                    paramTypes.push(functionParam.type);
+                    paramTypes.push(paramType);
                 }
             });
             if (paramsArePositionOnly && functionType.shared.parameters.length > firstNonClsSelfParamIndex) {
@@ -12802,7 +12790,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     if ((0, types_1.isUnknown)(paramType)) {
                         functionType.shared.flags |= 16384 /* FunctionTypeFlags.UnannotatedParams */;
                     }
-                    paramType = (0, typeUtils_1.updateTypeWithInternalTypeVars)(paramType, scopeIds);
+                    paramType = (0, typeUtils_1.makeTypeVarsBound)(paramType, scopeIds);
                     writeTypeCache(paramNameNode, { type: paramType }, 0 /* EvalFlags.None */);
                 }
             });
@@ -12821,7 +12809,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // If the function contains an *args and a **kwargs parameter and both
             // are annotated as Any or are unannotated, make it exempt from
             // args/kwargs compatibility checks.
-            const variadicsWithAnyType = functionType.shared.parameters.filter((param) => param.category !== 0 /* ParamCategory.Simple */ && param.name && (0, types_1.isAnyOrUnknown)(param.type));
+            const variadicsWithAnyType = functionType.shared.parameters.filter((param, index) => param.category !== 0 /* ParamCategory.Simple */ &&
+                param.name &&
+                (0, types_1.isAnyOrUnknown)(types_1.FunctionType.getParamType(functionType, index)));
             if (variadicsWithAnyType.length >= 2) {
                 functionType.shared.flags |= 32768 /* FunctionTypeFlags.GradualCallableForm */;
             }
@@ -12944,13 +12934,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             // If the parameter type is generic, specialize it in the context
                             // of the child class.
                             if ((0, typeUtils_1.requiresSpecialization)(inferredParamType) && (0, types_1.isClass)(baseClassMemberInfo.classType)) {
-                                const typeVarContext = (0, typeUtils_1.buildTypeVarContextFromSpecializedClass)(baseClassMemberInfo.classType);
-                                // Add the scope of the method to handle any function-scoped TypeVars.
-                                typeVarContext.addSolveForScope(ParseTreeUtils.getScopeIdForNode(baseClassMethodNode));
+                                const scopeIds = (0, typeUtils_1.getTypeVarScopeIds)(baseClassMemberInfo.classType);
+                                const solution = (0, typeUtils_1.buildSolutionFromSpecializedClass)(baseClassMemberInfo.classType);
+                                scopeIds.push(ParseTreeUtils.getScopeIdForNode(baseClassMethodNode));
                                 // Replace any unsolved TypeVars with Unknown (including all function-scoped TypeVars).
-                                inferredParamType = (0, typeUtils_1.applySolvedTypeVars)(inferredParamType, typeVarContext, {
-                                    unknownIfNotFound: true,
-                                    tupleClassType: getTupleClassType(),
+                                inferredParamType = (0, typeUtils_1.applySolvedTypeVars)(inferredParamType, solution, {
+                                    replaceUnsolved: {
+                                        scopeIds,
+                                        tupleClassType: getTupleClassType(),
+                                    },
                                 });
                             }
                             const fileInfo = AnalyzerNodeInfo.getFileInfo(functionNode);
@@ -13367,14 +13359,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // Verify that the target has an __enter__ or __aenter__ method defined.
         const enterMethodName = isAsync ? '__aenter__' : '__enter__';
         const scopedType = (0, typeUtils_1.mapSubtypes)(exprType, (subtype) => {
+            var _a, _b;
             subtype = makeTopLevelTypeVarsConcrete(subtype);
             if ((0, types_1.isAnyOrUnknown)(subtype)) {
                 return subtype;
             }
             const additionalHelp = new diagnostic_1.DiagnosticAddendum();
             if ((0, types_1.isClass)(subtype)) {
-                let enterType = getTypeOfMagicMethodCall(subtype, enterMethodName, [], node.d.expr, 
-                /* inferenceContext */ undefined, additionalHelp.createAddendum());
+                let enterType = (_a = getTypeOfMagicMethodCall(subtype, enterMethodName, [], node.d.expr, 
+                /* inferenceContext */ undefined, additionalHelp.createAddendum())) === null || _a === void 0 ? void 0 : _a.type;
                 if (enterType) {
                     // For "async while", an implicit "await" is performed.
                     if (isAsync) {
@@ -13383,8 +13376,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     return enterType;
                 }
                 if (!isAsync) {
-                    if (getTypeOfMagicMethodCall(subtype, '__aenter__', [], node.d.expr, 
-                    /* inferenceContext */ undefined)) {
+                    if ((_b = getTypeOfMagicMethodCall(subtype, '__aenter__', [], node.d.expr, 
+                    /* inferenceContext */ undefined)) === null || _b === void 0 ? void 0 : _b.type) {
                         additionalHelp.addMessage(localize_1.LocAddendum.asyncHelp());
                     }
                 }
@@ -13396,14 +13389,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // Verify that the target has an __exit__ or __aexit__ method defined.
         const exitMethodName = isAsync ? '__aexit__' : '__exit__';
         (0, typeUtils_1.doForEachSubtype)(exprType, (subtype) => {
+            var _a;
             subtype = makeTopLevelTypeVarsConcrete(subtype);
             if ((0, types_1.isAnyOrUnknown)(subtype)) {
                 return;
             }
             if ((0, types_1.isClass)(subtype)) {
                 const anyArg = { type: types_1.AnyType.create() };
-                const exitType = getTypeOfMagicMethodCall(subtype, exitMethodName, [anyArg, anyArg, anyArg], node.d.expr, 
-                /* inferenceContext */ undefined);
+                const exitType = (_a = getTypeOfMagicMethodCall(subtype, exitMethodName, [anyArg, anyArg, anyArg], node.d.expr, 
+                /* inferenceContext */ undefined)) === null || _a === void 0 ? void 0 : _a.type;
                 if (exitType) {
                     return;
                 }
@@ -13937,7 +13931,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         : undefined;
                     if (declaredReturnType) {
                         const liveScopeIds = ParseTreeUtils.getTypeVarScopesForNode(node);
-                        declaredReturnType = (0, typeUtils_1.updateTypeWithInternalTypeVars)(declaredReturnType, liveScopeIds);
+                        declaredReturnType = (0, typeUtils_1.makeTypeVarsBound)(declaredReturnType, liveScopeIds);
                     }
                     getTypeOfExpression(parent.d.expr, 0 /* EvalFlags.None */, (0, typeUtils_1.makeInferenceContext)(declaredReturnType));
                     return;
@@ -13993,7 +13987,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             const typeParamName = getPseudoGenericTypeVarName(node.d.name.d.value);
             const paramType = classInfo.classType.shared.typeParams.find((param) => param.shared.name === typeParamName);
             if (paramType) {
-                writeTypeCache(node.d.name, { type: types_1.TypeVarType.cloneWithInternalScopeId(paramType) }, 0 /* EvalFlags.None */);
+                writeTypeCache(node.d.name, { type: types_1.TypeVarType.cloneAsBound(paramType) }, 0 /* EvalFlags.None */);
                 return;
             }
         }
@@ -14004,7 +13998,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         /* isInClass */ true).flags;
         let inferredParamType = (_a = inferParamType(functionNode, functionFlags, paramIndex, classInfo === null || classInfo === void 0 ? void 0 : classInfo.classType)) !== null && _a !== void 0 ? _a : types_1.UnknownType.create();
         const liveTypeVarScopes = ParseTreeUtils.getTypeVarScopesForNode(node);
-        inferredParamType = (0, typeUtils_1.updateTypeWithInternalTypeVars)(inferredParamType, liveTypeVarScopes);
+        inferredParamType = (0, typeUtils_1.makeTypeVarsBound)(inferredParamType, liveTypeVarScopes);
         writeTypeCache(node.d.name, { type: transformVariadicParamType(node, node.d.category, inferredParamType) }, 0 /* EvalFlags.None */);
     }
     // Evaluates the types that are assigned within the statement that contains
@@ -14390,8 +14384,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             typeArgs.forEach((typeArg, index) => {
                 if (index === variadicTypeParamIndex) {
-                    // The types that make up the tuple that maps to the variadic
-                    // type variable have already been validated when the tuple
+                    // The types that make up the tuple that maps to the
+                    // TypeVarTuple have already been validated when the tuple
                     // object was created in adjustTypeArgsForTypeVarTuple.
                     if ((0, types_1.isClassInstance)(typeArg.type) && (0, typeUtils_1.isTupleClass)(typeArg.type)) {
                         return;
@@ -14444,7 +14438,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
             }
         }
-        const typeVarContext = new typeVarContext_1.TypeVarContext(classType.shared.typeVarScopeId);
+        const constraints = new constraintTracker_1.ConstraintTracker();
         fullTypeParams.forEach((typeParam, index) => {
             if (typeArgs && index < typeArgs.length) {
                 if ((0, types_1.isParamSpec)(typeParam)) {
@@ -14454,7 +14448,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         types_1.FunctionType.addDefaultParams(functionType);
                         functionType.shared.flags |= 32768 /* FunctionTypeFlags.GradualCallableForm */;
                         typeArgTypes.push(functionType);
-                        (0, typeUtils_1.setTypeVarType)(typeVarContext, typeParam, functionType);
+                        constraints.setBounds(typeParam, functionType);
                         return;
                     }
                     if (typeArg.typeList) {
@@ -14465,7 +14459,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             types_1.FunctionType.addPositionOnlyParamSeparator(functionType);
                         }
                         typeArgTypes.push(functionType);
-                        (0, typeUtils_1.setTypeVarType)(typeVarContext, typeParam, functionType);
+                        constraints.setBounds(typeParam, functionType);
                         return;
                     }
                     if ((0, types_1.isInstantiableClass)(typeArg.type) && types_1.ClassType.isBuiltIn(typeArg.type, 'Concatenate')) {
@@ -14492,15 +14486,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
                 const typeArgType = (0, typeUtils_1.convertToInstance)(typeArgs[index].type);
                 typeArgTypes.push(typeArgType);
-                (0, typeUtils_1.setTypeVarType)(typeVarContext, typeParam, typeArgType);
+                constraints.setBounds(typeParam, typeArgType);
                 return;
             }
-            const solvedDefaultType = (0, typeUtils_1.applySolvedTypeVars)(typeParam, typeVarContext, {
-                unknownIfNotFound: true,
-                tupleClassType: getTupleClassType(),
+            const solvedDefaultType = solveAndApplyConstraints(typeParam, constraints, {
+                replaceUnsolved: {
+                    scopeIds: (0, typeUtils_1.getTypeVarScopeIds)(classType),
+                    tupleClassType: getTupleClassType(),
+                },
             });
             typeArgTypes.push(solvedDefaultType);
-            (0, typeUtils_1.setTypeVarType)(typeVarContext, typeParam, solvedDefaultType);
+            constraints.setBounds(typeParam, solvedDefaultType);
         });
         typeArgTypes = typeArgTypes.map((typeArgType, index) => {
             if (index < typeArgCount) {
@@ -14806,7 +14802,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             return type;
         }
         if ((0, types_1.isFunction)(type) || (0, types_1.isOverloadedFunction)(type)) {
-            return (0, typeUtils_1.ensureFunctionSignaturesAreUnique)(type, tracker, node.start);
+            return (0, typeUtils_1.ensureSignaturesAreUnique)(type, tracker, node.start);
         }
         return type;
     }
@@ -15151,7 +15147,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 if (typeAnnotationNode) {
                     let declaredType = getTypeOfParamAnnotation(typeAnnotationNode, declaration.node.d.category);
                     const liveTypeVarScopes = ParseTreeUtils.getTypeVarScopesForNode(declaration.node);
-                    declaredType = (0, typeUtils_1.updateTypeWithInternalTypeVars)(declaredType, liveTypeVarScopes);
+                    declaredType = (0, typeUtils_1.makeTypeVarsBound)(declaredType, liveTypeVarScopes);
                     return {
                         type: transformVariadicParamType(declaration.node, declaration.node.d.category, adjustParamAnnotatedType(declaration.node, declaredType)),
                     };
@@ -15186,12 +15182,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     }
                     if (declaredType) {
                         // If this is a declaration for a member variable within a method,
-                        // we need to convert any "internal" TypeVars associated with the
-                        // class to their "external" counterparts.
+                        // we need to convert any bound TypeVars associated with the
+                        // class to their free counterparts.
                         if (declaration.isDefinedByMemberAccess) {
                             const enclosingClass = ParseTreeUtils.getEnclosingClass(declaration.node);
                             if (enclosingClass) {
-                                declaredType = (0, typeUtils_1.updateTypeWithExternalTypeVars)(declaredType, [
+                                declaredType = (0, typeUtils_1.makeTypeVarsFree)(declaredType, [
                                     ParseTreeUtils.getScopeIdForNode(enclosingClass),
                                 ]);
                             }
@@ -15242,6 +15238,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     const constraintType = getTypeOfExpressionExpectingType(constraint, {
                         noNonTypeSpecialForms: true,
                         forwardRefs: true,
+                        typeExpression: true,
                     }).type;
                     if ((0, typeUtils_1.requiresSpecialization)(constraintType, {
                         ignorePseudoGeneric: true,
@@ -15942,6 +15939,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (types_1.FunctionType.isStubDefinition(type)) {
             return types_1.UnknownType.create();
         }
+        // Don't infer the return type for a ParamSpec value.
+        if (types_1.FunctionType.isParamSpecValue(type)) {
+            return types_1.UnknownType.create();
+        }
         // Don't infer the return type for an overloaded function (unless it's synthesized,
         // which is needed for proper operation of the __get__ method in properties).
         if (types_1.FunctionType.isOverloaded(type) && !types_1.FunctionType.isSynthesizedMethod(type)) {
@@ -15995,7 +15996,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if ((_a = type.shared.methodClass) === null || _a === void 0 ? void 0 : _a.shared.typeVarScopeId) {
                 typeVarScopes.push(type.shared.methodClass.shared.typeVarScopeId);
             }
-            returnType = (0, typeUtils_1.updateTypeWithExternalTypeVars)(returnType, typeVarScopes);
+            returnType = (0, typeUtils_1.makeTypeVarsFree)(returnType, typeVarScopes);
             // Cache the type for next time.
             if (!isIncomplete) {
                 type.priv.inferredReturnType = returnType;
@@ -16031,7 +16032,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     if ((_c = type.shared.declaration) === null || _c === void 0 ? void 0 : _c.node) {
                         // Externalize any TypeVars that appear in the type.
                         const liveScopeIds = ParseTreeUtils.getTypeVarScopesForNode(type.shared.declaration.node);
-                        returnType = (0, typeUtils_1.updateTypeWithExternalTypeVars)(returnType, liveScopeIds);
+                        returnType = (0, typeUtils_1.makeTypeVarsFree)(returnType, liveScopeIds);
                     }
                 }
             }
@@ -16061,8 +16062,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (returnTypeInferenceContextStack.some((context) => context.functionNode === functionNode)) {
             return undefined;
         }
-        const functionType = getTypeOfFunction(functionNode);
-        if (!functionType) {
+        const functionTypeResult = getTypeOfFunction(functionNode);
+        if (!functionTypeResult) {
             return undefined;
         }
         // Very complex functions with many arguments can take a long time to analyze,
@@ -16113,11 +16114,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         else if (index === 0) {
                             // If this is an instance or class method, use the implied
                             // parameter type for the "self" or "cls" parameter.
-                            if (types_1.FunctionType.isInstanceMethod(functionType.functionType) ||
-                                types_1.FunctionType.isClassMethod(functionType.functionType)) {
-                                if (functionType.functionType.shared.parameters.length > 0) {
+                            if (types_1.FunctionType.isInstanceMethod(functionTypeResult.functionType) ||
+                                types_1.FunctionType.isClassMethod(functionTypeResult.functionType)) {
+                                if (functionTypeResult.functionType.shared.parameters.length > 0) {
                                     if (functionNode.d.params[0].d.name) {
-                                        paramType = functionType.functionType.shared.parameters[0].type;
+                                        paramType = types_1.FunctionType.getParamType(functionTypeResult.functionType, 0);
                                     }
                                 }
                             }
@@ -16137,7 +16138,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 if (!allArgTypesAreUnknown) {
                     // See if the return type is already cached. If so, skip the
                     // inference step, which is potentially very expensive.
-                    const cacheEntry = (_a = functionType.functionType.priv.callSiteReturnTypeCache) === null || _a === void 0 ? void 0 : _a.find((entry) => {
+                    const cacheEntry = (_a = functionTypeResult.functionType.priv.callSiteReturnTypeCache) === null || _a === void 0 ? void 0 : _a.find((entry) => {
                         return (entry.paramTypes.length === paramTypes.length &&
                             entry.paramTypes.every((t, i) => (0, types_1.isTypeSame)(t, paramTypes[i])));
                     });
@@ -16159,14 +16160,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             contextualReturnType = (0, types_1.removeUnbound)(contextualReturnType);
             if (!isResultFromCache) {
                 // Cache the resulting type.
-                if (!functionType.functionType.priv.callSiteReturnTypeCache) {
-                    functionType.functionType.priv.callSiteReturnTypeCache = [];
+                if (!functionTypeResult.functionType.priv.callSiteReturnTypeCache) {
+                    functionTypeResult.functionType.priv.callSiteReturnTypeCache = [];
                 }
-                if (functionType.functionType.priv.callSiteReturnTypeCache.length >= maxCallSiteReturnTypeCacheSize) {
-                    functionType.functionType.priv.callSiteReturnTypeCache =
-                        functionType.functionType.priv.callSiteReturnTypeCache.slice(1);
+                if (functionTypeResult.functionType.priv.callSiteReturnTypeCache.length >=
+                    maxCallSiteReturnTypeCacheSize) {
+                    functionTypeResult.functionType.priv.callSiteReturnTypeCache =
+                        functionTypeResult.functionType.priv.callSiteReturnTypeCache.slice(1);
                 }
-                functionType.functionType.priv.callSiteReturnTypeCache.push({
+                functionTypeResult.functionType.priv.callSiteReturnTypeCache.push({
                     paramTypes,
                     returnType: contextualReturnType,
                 });
@@ -16238,7 +16240,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             isIncomplete: !!typeResult.isIncomplete,
         };
     }
-    function assignClass(destType, srcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount, reportErrorsUsingObjType) {
+    function assignClass(destType, srcType, diag, destConstraints, srcConstraints, 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.
@@ -16249,7 +16251,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, destTypeVarContext, flags, recursionCount)) {
+                if (!(0, typedDicts_1.assignTypedDictToTypedDict)(evaluatorInterface, destType, srcType, diag, destConstraints, flags, recursionCount)) {
                     return false;
                 }
                 if (types_1.ClassType.isFinal(destType) !== types_1.ClassType.isFinal(srcType)) {
@@ -16263,7 +16265,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 if ((flags & 1 /* AssignTypeFlags.EnforceInvariance */) !== 0) {
                     return (0, typedDicts_1.assignTypedDictToTypedDict)(evaluatorInterface, srcType, destType, 
                     /* diag */ undefined, 
-                    /* typeVarContext */ undefined, flags, recursionCount);
+                    /* constraints */ undefined, flags, recursionCount);
                 }
                 return true;
             }
@@ -16311,7 +16313,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(), destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
+            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)) {
                 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)),
@@ -16330,7 +16332,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if ((flags & 1 /* AssignTypeFlags.EnforceInvariance */) === 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(), destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
+                if (assignClassWithTypeArgs(destType, srcType, inheritanceChain, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destConstraints, srcConstraints, flags, recursionCount)) {
                     return true;
                 }
             }
@@ -16373,7 +16375,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     function assignClassToSelf(destType, srcType, assumedVariance, ignoreBaseClassVariance = true, recursionCount = 0) {
         (0, debug_1.assert)(types_1.ClassType.isSameGenericClass(destType, srcType));
         (0, debug_1.assert)(destType.shared.typeParams.length > 0);
-        const typeVarContext = new typeVarContext_1.TypeVarContext();
+        srcType = (0, typeUtils_1.makeTypeVarsBound)(srcType, (0, typeUtils_1.getTypeVarScopeIds)(srcType));
+        destType = (0, typeUtils_1.makeTypeVarsBound)(destType, (0, typeUtils_1.getTypeVarScopeIds)(destType));
         let isAssignable = true;
         // Use a try/catch block here to make sure that we reset
         // the assignClassToSelfClass to undefined if an exception occurs.
@@ -16400,8 +16403,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     (0, types_1.isClassInstance)(srcMemberType) &&
                     types_1.ClassType.isPropertyClass(srcMemberType)) {
                     if (!(0, properties_1.assignProperty)(evaluatorInterface, types_1.ClassType.cloneAsInstantiable(destMemberType), types_1.ClassType.cloneAsInstantiable(srcMemberType), destType, srcType, 
-                    /* diag */ undefined, typeVarContext, 
-                    /* selfTypeVarContext */ undefined, recursionCount)) {
+                    /* diag */ undefined, 
+                    /* constraints */ undefined, 
+                    /* selfConstraints */ undefined, recursionCount)) {
                         isAssignable = false;
                     }
                 }
@@ -16410,6 +16414,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     let flags = 0 /* AssignTypeFlags.Default */;
                     if ((primaryDecl === null || primaryDecl === void 0 ? void 0 : primaryDecl.type) === 1 /* DeclarationType.Variable */ &&
                         !isFinalVariableDeclaration(primaryDecl) &&
+                        !types_1.ClassType.isReadOnlyInstanceVariables(destType) &&
                         !types_1.ClassType.isDataClassFrozen(destType)) {
                         // Class and instance variables that are mutable need to
                         // enforce invariance. We will exempt variables that are
@@ -16420,8 +16425,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         }
                     }
                     if (!assignType(destMemberType, srcMemberType, 
-                    /* diag */ undefined, typeVarContext, 
-                    /* srcTypeVarContext */ undefined, flags | 32768 /* AssignTypeFlags.SkipSelfClsParamCheck */, recursionCount)) {
+                    /* diag */ undefined, 
+                    /* destConstraints */ undefined, 
+                    /* srcConstraints */ undefined, flags | 32768 /* AssignTypeFlags.SkipSelfClsParamCheck */, recursionCount)) {
                         isAssignable = false;
                     }
                 }
@@ -16476,7 +16482,7 @@ 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, destTypeVarContext, srcTypeVarContext, flags, recursionCount) {
+    function assignClassWithTypeArgs(destType, srcType, inheritanceChain, diag, destConstraints, srcConstraints, flags, recursionCount) {
         let curSrcType = srcType;
         let prevSrcType;
         inferVarianceForClass(destType);
@@ -16540,7 +16546,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, destTypeVarContext, srcTypeVarContext, flags, recursionCount);
+            return (0, tuples_1.assignTupleTypeArgs)(evaluatorInterface, destType, curSrcType, diag, destConstraints, srcConstraints, flags, recursionCount);
         }
         if (destType.priv.typeArgs) {
             // If the dest type is specialized, make sure the specialized source
@@ -16549,9 +16555,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, destTypeVarContext, srcTypeVarContext, flags, recursionCount);
+            (flags & 1 /* AssignTypeFlags.EnforceInvariance */) === 0 ? diag : undefined, destConstraints, srcConstraints, flags, recursionCount);
         }
-        if (destTypeVarContext && curSrcType.priv.typeArgs && !destTypeVarContext.isLocked()) {
+        if (destConstraints && curSrcType.priv.typeArgs && !destConstraints.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++) {
@@ -16564,10 +16570,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 else {
                     typeArgType = i < srcTypeArgs.length ? srcTypeArgs[i] : types_1.UnknownType.create();
                 }
-                if ((0, types_1.isParamSpec)(typeParam)) {
-                    typeArgType = (0, typeUtils_1.convertTypeToParamSpecValue)(typeArgType);
-                }
-                (0, constraintSolver_1.updateTypeVarType)(evaluatorInterface, destTypeVarContext, typeParam, variance !== 4 /* Variance.Contravariant */ ? typeArgType : undefined, variance !== 3 /* Variance.Covariant */ ? typeArgType : undefined, 
+                (0, constraintSolver_1.updateTypeVarType)(evaluatorInterface, destConstraints, typeParam, variance !== 4 /* Variance.Contravariant */ ? typeArgType : undefined, variance !== 3 /* Variance.Covariant */ ? typeArgType : undefined, 
                 /* forceRetainLiterals */ true);
             }
         }
@@ -16583,7 +16586,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return undefined;
     }
-    function assignTypeArgs(destType, srcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount) {
+    function assignTypeArgs(destType, srcType, diag, destConstraints, srcConstraints, flags, recursionCount) {
         var _a, _b, _c;
         (0, debug_1.assert)(types_1.ClassType.isSameGenericClass(destType, srcType));
         inferVarianceForClass(destType);
@@ -16637,7 +16640,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 // 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 */ ? srcTypeVarContext : destTypeVarContext, variance === 4 /* Variance.Contravariant */ ? destTypeVarContext : srcTypeVarContext, effectiveFlags, recursionCount)) {
+            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)) {
                 // Don't report errors with type variables in "pseudo-random"
                 // classes since these type variables are not real.
                 if (!types_1.ClassType.isPseudoGenericClass(destType)) {
@@ -16675,11 +16678,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         return isCompatible;
     }
     // Determines if the source type can be assigned to the dest type.
-    // If typeVarContext is provided, type variables within the destType are
+    // If constraint are provided, type variables within the destType are
     // 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, destTypeVarContext, srcTypeVarContext, flags = 0 /* AssignTypeFlags.Default */, recursionCount = 0) {
+    function assignType(destType, srcType, diag, destConstraints, srcConstraints, 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,
@@ -16724,7 +16727,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, destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
+                    if (!assignType(destTypeArg, srcTypeArg, diag, destConstraints, srcConstraints, flags, recursionCount)) {
                         isAssignable = false;
                     }
                 });
@@ -16769,12 +16772,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // TypeVar that we are attempting to match.
         if ((0, types_1.isTypeVar)(destType)) {
             if ((0, typeUtils_1.isTypeVarSame)(destType, srcType)) {
-                if (destType.priv.scopeId && (destTypeVarContext === null || destTypeVarContext === void 0 ? void 0 : destTypeVarContext.hasSolveForScope(destType.priv.scopeId))) {
-                    // If the dest TypeVar has no current value bound to it, bind itself.
-                    if (!destTypeVarContext.getMainSolutionSet().getTypeVar(destType)) {
-                        return (0, constraintSolver_1.assignTypeToTypeVar)(evaluatorInterface, destType, srcType, diag, destTypeVarContext, flags, recursionCount);
-                    }
-                }
                 return true;
             }
             // If the dest is a constrained or bound type variable and all of the
@@ -16789,7 +16786,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (types_1.TypeBase.isInstantiable(destType) === types_1.TypeBase.isInstantiable(srcType) &&
                 ((_d = srcType.props) === null || _d === void 0 ? void 0 : _d.condition) &&
                 srcType.props.condition.some((cond) => {
-                    return (cond.typeVar.shared.constraints.length === 0 &&
+                    return (!types_1.TypeVarType.hasConstraints(cond.typeVar) &&
                         cond.typeVar.priv.nameWithScope === destTypeVar.priv.nameWithScope);
                 })) {
                 return true;
@@ -16803,19 +16800,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // Handle the special case where both types are Self types. We'll allow
             // them to be treated as equivalent to handle certain common idioms.
             if ((0, types_1.isTypeVar)(srcType) &&
-                srcType.shared.isSynthesizedSelf &&
-                srcType.shared.boundType &&
-                destType.shared.isSynthesizedSelf &&
-                destType.shared.boundType &&
-                types_1.TypeVarType.hasInternalScopeId(destType) === types_1.TypeVarType.hasInternalScopeId(srcType) &&
+                types_1.TypeVarType.isSelf(srcType) &&
+                types_1.TypeVarType.hasBound(srcType) &&
+                types_1.TypeVarType.isSelf(destType) &&
+                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 && destTypeVarContext) {
-                    (0, constraintSolver_1.assignTypeToTypeVar)(evaluatorInterface, destType, srcType, diag, destTypeVarContext, flags, recursionCount);
+                if ((flags & 2 /* AssignTypeFlags.ReverseTypeVarMatching */) === 0 && destConstraints) {
+                    (0, constraintSolver_1.assignTypeVar)(evaluatorInterface, destType, srcType, diag, destConstraints, flags, recursionCount);
                 }
                 return true;
             }
-            // If the dest is a variadic type variable, and the source is a tuple
-            // with a single entry that is the same variadic type variable, it's a match.
+            // If the dest is a TypeVarTuple, and the source is a tuple
+            // with a single entry that is the same TypeVarTuple, it's a match.
             if ((0, types_1.isTypeVarTuple)(destType) &&
                 (0, types_1.isClassInstance)(srcType) &&
                 (0, typeUtils_1.isTupleClass)(srcType) &&
@@ -16826,8 +16823,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
             }
             if ((flags & 2 /* AssignTypeFlags.ReverseTypeVarMatching */) === 0 || !(0, types_1.isTypeVar)(srcType)) {
-                const targetTypeVarContext = (flags & 2 /* AssignTypeFlags.ReverseTypeVarMatching */) === 0 ? destTypeVarContext : srcTypeVarContext;
-                if (!(0, constraintSolver_1.assignTypeToTypeVar)(evaluatorInterface, destType, srcType, diag, targetTypeVarContext !== null && targetTypeVarContext !== void 0 ? targetTypeVarContext : new typeVarContext_1.TypeVarContext(), flags, recursionCount)) {
+                const targetConstraints = (flags & 2 /* AssignTypeFlags.ReverseTypeVarMatching */) === 0 ? destConstraints : srcConstraints;
+                if (!(0, constraintSolver_1.assignTypeVar)(evaluatorInterface, destType, srcType, diag, targetConstraints, flags, recursionCount)) {
                     return false;
                 }
                 if ((0, types_1.isAnyOrUnknown)(srcType) && (flags & 16 /* AssignTypeFlags.OverloadOverlap */) !== 0) {
@@ -16839,30 +16836,25 @@ 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 the type variable is not in the scope of the
-                // provided TypeVarContext, simply verify that the concrete types are
-                // compatible.
-                if ((flags & 1024 /* AssignTypeFlags.IgnoreTypeVarScope */) === 0 &&
-                    (!srcTypeVarContext || !srcTypeVarContext.hasSolveForScope((0, typeUtils_1.getTypeVarScopeId)(srcType)))) {
+                // rather than dest.
+                if (types_1.TypeVarType.isBound(srcType)) {
                     return assignType(makeTopLevelTypeVarsConcrete(destType), makeTopLevelTypeVarsConcrete(srcType), diag, 
-                    /* destTypeVarContext */ undefined, 
-                    /* srcTypeVarContext */ undefined, flags, recursionCount);
+                    /* destConstraints */ undefined, 
+                    /* srcConstraints */ undefined, flags, recursionCount);
                 }
-                else {
-                    if ((0, constraintSolver_1.assignTypeToTypeVar)(evaluatorInterface, srcType, destType, diag, srcTypeVarContext !== null && srcTypeVarContext !== void 0 ? srcTypeVarContext : new typeVarContext_1.TypeVarContext(), 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.assignTypeToTypeVar)(evaluatorInterface, srcType, destSubtype, diag, srcTypeVarContext !== null && srcTypeVarContext !== void 0 ? srcTypeVarContext : new typeVarContext_1.TypeVarContext(), flags, recursionCount)) {
-                                isAssignable = true;
-                            }
-                        });
-                    }
-                    return isAssignable;
+                if ((0, constraintSolver_1.assignTypeVar)(evaluatorInterface, srcType, destType, diag, srcConstraints, 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)) {
+                            isAssignable = true;
+                        }
+                    });
+                }
+                return isAssignable;
             }
             if ((flags & 1 /* AssignTypeFlags.EnforceInvariance */) !== 0) {
                 if ((0, types_1.isAnyOrUnknown)(destType)) {
@@ -16898,13 +16890,13 @@ 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 targetTypeVarContext = (flags & 2 /* AssignTypeFlags.ReverseTypeVarMatching */) === 0 ? destTypeVarContext : srcTypeVarContext;
-            if (targetTypeVarContext) {
+            const targetConstraints = (flags & 2 /* AssignTypeFlags.ReverseTypeVarMatching */) === 0 ? destConstraints : srcConstraints;
+            if (targetConstraints) {
                 // 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, targetTypeVarContext, recursionCount);
+                (0, typeUtils_1.setTypeArgsRecursive)(destType, typeVarSubstitution, targetConstraints, recursionCount);
             }
             if ((flags & 16 /* AssignTypeFlags.OverloadOverlap */) === 0) {
                 return true;
@@ -16918,9 +16910,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.typeAssignmentMismatch().format(printSrcDestTypes(srcType, destType)));
                 return false;
             }
-            const targetTypeVarContext = (flags & 2 /* AssignTypeFlags.ReverseTypeVarMatching */) === 0 ? destTypeVarContext : srcTypeVarContext;
-            if (targetTypeVarContext) {
-                (0, typeUtils_1.setTypeArgsRecursive)(destType, types_1.UnknownType.create(), targetTypeVarContext, recursionCount);
+            const targetConstraints = (flags & 2 /* AssignTypeFlags.ReverseTypeVarMatching */) === 0 ? destConstraints : srcConstraints;
+            if (targetConstraints) {
+                (0, typeUtils_1.setTypeArgsRecursive)(destType, types_1.UnknownType.create(), targetConstraints, recursionCount);
             }
             return true;
         }
@@ -16929,27 +16921,27 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // special-case logic to handle this case.
             if ((0, types_1.isUnion)(srcType)) {
                 return assignFromUnionType(destType, srcType, 
-                /* diag */ undefined, destTypeVarContext, srcTypeVarContext, flags, recursionCount);
+                /* diag */ undefined, destConstraints, srcConstraints, flags, recursionCount);
             }
-            const clonedDestTypeVarContext = destTypeVarContext === null || destTypeVarContext === void 0 ? void 0 : destTypeVarContext.clone();
-            const clonedSrcTypeVarContext = srcTypeVarContext === null || srcTypeVarContext === void 0 ? void 0 : srcTypeVarContext.clone();
+            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, clonedDestTypeVarContext, clonedSrcTypeVarContext, flags, recursionCount)) {
-                if (destTypeVarContext && clonedDestTypeVarContext) {
-                    destTypeVarContext.copyFromClone(clonedDestTypeVarContext);
+            /* diag */ undefined, clonedDestConstraints, clonedSrcConstraints, flags, recursionCount)) {
+                if (destConstraints && clonedDestConstraints) {
+                    destConstraints.copyFromClone(clonedDestConstraints);
                 }
-                if (srcTypeVarContext && clonedSrcTypeVarContext) {
-                    srcTypeVarContext.copyFromClone(clonedSrcTypeVarContext);
+                if (srcConstraints && clonedSrcConstraints) {
+                    srcConstraints.copyFromClone(clonedSrcConstraints);
                 }
                 return true;
             }
         }
         const expandedSrcType = makeTopLevelTypeVarsConcrete(srcType);
         if ((0, types_1.isUnion)(expandedSrcType)) {
-            return assignFromUnionType(destType, expandedSrcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount);
+            return assignFromUnionType(destType, expandedSrcType, diag, destConstraints, srcConstraints, flags, recursionCount);
         }
         if ((0, types_1.isUnion)(destType)) {
-            return assignToUnionType(destType, srcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount);
+            return assignToUnionType(destType, srcType, diag, destConstraints, srcConstraints, flags, recursionCount);
         }
         // Is the src a specialized "type" object?
         if ((0, types_1.isClassInstance)(expandedSrcType) && types_1.ClassType.isBuiltIn(expandedSrcType, 'type')) {
@@ -16967,7 +16959,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(), destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
+                if (assignType(destType, (0, typeUtils_1.convertToInstantiable)(typeTypeArg), diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destConstraints, srcConstraints, flags, recursionCount)) {
                     return true;
                 }
                 diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.typeAssignmentMismatch().format(printSrcDestTypes(srcType, destType)));
@@ -16994,10 +16986,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, destTypeVarContext, srcTypeVarContext, flags, recursionCount);
+                        return assignType(destType.props.specialForm, expandedSrcType, diag, destConstraints, srcConstraints, flags, recursionCount);
                     }
                 }
-                else if (assignClass(destType, expandedSrcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount, 
+                else if (assignClass(destType, expandedSrcType, diag, destConstraints, srcConstraints, flags, recursionCount, 
                 /* reportErrorsUsingObjType */ false)) {
                     return true;
                 }
@@ -17009,7 +17001,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, destTypeVarContext, srcTypeVarContext, flags, recursionCount, 
+                    if (assignClass(types_1.ClassType.cloneAsInstance(destMetaclass), expandedSrcType, diag, destConstraints, srcConstraints, flags, recursionCount, 
                     /* reportErrorsUsingObjType */ false)) {
                         return true;
                     }
@@ -17029,7 +17021,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, destTypeVarContext, srcTypeVarContext, flags, recursionCount);
+                        return assignType(destTypeArgs[0], (0, typeUtils_1.convertToInstance)(srcType), diag, destConstraints, srcConstraints, flags, recursionCount);
                     }
                 }
                 // Is the dest a "type" object? Assume that all instantiable
@@ -17041,6 +17033,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             let concreteSrcType = makeTopLevelTypeVarsConcrete(srcType);
             if ((0, types_1.isClass)(concreteSrcType) && types_1.TypeBase.isInstance(concreteSrcType)) {
+                // Handle enum literals that are assignable to another (non-Enum) literal.
+                // This can happen for IntEnum and StrEnum members.
+                if (types_1.ClassType.isEnumClass(concreteSrcType) &&
+                    concreteSrcType.priv.literalValue instanceof types_1.EnumLiteral &&
+                    concreteSrcType.shared.mro.some((base) => (0, types_1.isClass)(base) && types_1.ClassType.isBuiltIn(base, ['int', 'str', 'bytes'])) &&
+                    (0, types_1.isClassInstance)(concreteSrcType.priv.literalValue.itemType) &&
+                    (0, typeUtils_1.isLiteralType)(concreteSrcType.priv.literalValue.itemType) &&
+                    assignType(destType, concreteSrcType.priv.literalValue.itemType)) {
+                    return true;
+                }
                 if (destType.priv.literalValue !== undefined) {
                     const srcLiteral = concreteSrcType.priv.literalValue;
                     if (srcLiteral === undefined || !types_1.ClassType.isLiteralValueSame(concreteSrcType, destType)) {
@@ -17067,7 +17069,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     (flags & 1 /* AssignTypeFlags.EnforceInvariance */) === 0) {
                     concreteSrcType = types_1.ClassType.cloneAsInstance(strClass);
                 }
-                if (!assignClass(types_1.ClassType.cloneAsInstantiable(destType), types_1.ClassType.cloneAsInstantiable(concreteSrcType), diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount, 
+                if (!assignClass(types_1.ClassType.cloneAsInstantiable(destType), types_1.ClassType.cloneAsInstantiable(concreteSrcType), diag, destConstraints, srcConstraints, flags, recursionCount, 
                 /* reportErrorsUsingObjType */ true)) {
                     return false;
                 }
@@ -17077,14 +17079,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 // Is the destination a callback protocol (defined in PEP 544)?
                 const destCallbackType = getCallbackProtocolType(destType, recursionCount);
                 if (destCallbackType) {
-                    if (destTypeVarContext) {
-                        destTypeVarContext.addSolveForScope((0, typeUtils_1.getTypeVarScopeId)(destCallbackType));
-                    }
-                    return assignType(destCallbackType, concreteSrcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount);
+                    return assignType(destCallbackType, concreteSrcType, diag, destConstraints, srcConstraints, flags, recursionCount);
                 }
                 // All functions are considered instances of "builtins.function".
                 if (functionClass) {
-                    return assignType(destType, (0, typeUtils_1.convertToInstance)(functionClass), diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount);
+                    return assignType(destType, (0, typeUtils_1.convertToInstance)(functionClass), diag, destConstraints, srcConstraints, flags, recursionCount);
                 }
             }
             else if ((0, types_1.isModule)(concreteSrcType)) {
@@ -17093,7 +17092,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, destTypeVarContext, flags, recursionCount);
+                    return (0, protocols_1.assignModuleToProtocol)(evaluatorInterface, types_1.ClassType.cloneAsInstantiable(destType), concreteSrcType, diag, destConstraints, flags, recursionCount);
                 }
             }
             else if ((0, types_1.isInstantiableClass)(concreteSrcType)) {
@@ -17101,12 +17100,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 // class that is effectively a function.
                 const callbackType = getCallbackProtocolType(destType, recursionCount);
                 if (callbackType) {
-                    return assignType(callbackType, concreteSrcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount);
+                    return assignType(callbackType, concreteSrcType, diag, destConstraints, srcConstraints, 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, destTypeVarContext, srcTypeVarContext, flags, recursionCount);
+                    return (0, protocols_1.assignClassToProtocol)(evaluatorInterface, types_1.ClassType.cloneAsInstantiable(destType), concreteSrcType, diag, destConstraints, srcConstraints, flags, recursionCount);
                 }
                 // Determine if the metaclass can be assigned to the object.
                 const metaclass = concreteSrcType.shared.effectiveMetaclass;
@@ -17115,7 +17114,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         return true;
                     }
                     else {
-                        return assignClass(types_1.ClassType.cloneAsInstantiable(destType), metaclass, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount, 
+                        return assignClass(types_1.ClassType.cloneAsInstantiable(destType), metaclass, diag, destConstraints, srcConstraints, flags, recursionCount, 
                         /* reportErrorsUsingObjType */ false);
                     }
                 }
@@ -17124,7 +17123,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 return (flags & 16 /* AssignTypeFlags.OverloadOverlap */) === 0;
             }
             else if ((0, types_1.isUnion)(concreteSrcType)) {
-                return assignType(destType, concreteSrcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount);
+                return assignType(destType, concreteSrcType, diag, destConstraints, srcConstraints, flags, recursionCount);
             }
         }
         if ((0, types_1.isFunction)(destType)) {
@@ -17145,7 +17144,7 @@ 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, destTypeVarContext, srcTypeVarContext, flags, recursionCount);
+                        return assignType(destType, concreteSrcType, diag, destConstraints, srcConstraints, flags, recursionCount);
                     }
                 }
             }
@@ -17153,6 +17152,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 return (flags & 16 /* AssignTypeFlags.OverloadOverlap */) === 0;
             }
             if ((0, types_1.isOverloadedFunction)(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
+                // filter the overloads at this time. We will do this work on
+                // subsequent passes.
+                if ((flags & 8 /* AssignTypeFlags.ArgAssignmentFirstPass */) !== 0) {
+                    return true;
+                }
                 // Find all of the overloaded functions that match the parameters.
                 const overloads = types_1.OverloadedFunctionType.getOverloads(concreteSrcType);
                 const filteredOverloads = [];
@@ -17161,16 +17168,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 overloads.forEach((overload) => {
                     var _a;
                     const overloadScopeId = (_a = (0, typeUtils_1.getTypeVarScopeId)(overload)) !== null && _a !== void 0 ? _a : '';
-                    const destTypeVarContextClone = destTypeVarContext === null || destTypeVarContext === void 0 ? void 0 : destTypeVarContext.cloneWithSignature(overloadScopeId);
-                    const srcTypeVarContextClone = srcTypeVarContext === null || srcTypeVarContext === void 0 ? void 0 : srcTypeVarContext.cloneWithSignature(overloadScopeId);
+                    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, destTypeVarContextClone, srcTypeVarContextClone, flags, recursionCount)) {
+                    /* diag */ undefined, destConstraintsClone, srcConstraintsClone, flags, recursionCount)) {
                         filteredOverloads.push(overload);
-                        if (destTypeVarContextClone) {
-                            (0, collectionUtils_1.appendArray)(destTypeVarSignatures, destTypeVarContextClone.getSolutionSets());
+                        if (destConstraintsClone) {
+                            (0, collectionUtils_1.appendArray)(destTypeVarSignatures, destConstraintsClone.getConstraintSets());
                         }
-                        if (srcTypeVarContextClone) {
-                            (0, collectionUtils_1.appendArray)(srcTypeVarSignatures, srcTypeVarContextClone.getSolutionSets());
+                        if (srcConstraintsClone) {
+                            (0, collectionUtils_1.appendArray)(srcTypeVarSignatures, srcConstraintsClone.getConstraintSets());
                         }
                     }
                 });
@@ -17178,16 +17185,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.noOverloadAssignable().format({ type: printType(destType) }));
                     return false;
                 }
-                if (destTypeVarContext) {
-                    destTypeVarContext.addSolutionSets(destTypeVarSignatures);
-                }
-                if (srcTypeVarContext) {
-                    srcTypeVarContext.addSolutionSets(srcTypeVarSignatures);
+                if (filteredOverloads.length === 1 || (flags & 8 /* AssignTypeFlags.ArgAssignmentFirstPass */) === 0) {
+                    if (destConstraints) {
+                        destConstraints.addConstraintSets(destTypeVarSignatures);
+                    }
+                    if (srcConstraints) {
+                        srcConstraints.addConstraintSets(srcTypeVarSignatures);
+                    }
                 }
                 return true;
             }
             if ((0, types_1.isFunction)(concreteSrcType)) {
-                if (assignFunction(destType, concreteSrcType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destTypeVarContext !== null && destTypeVarContext !== void 0 ? destTypeVarContext : new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeIds)(destType)), srcTypeVarContext !== null && srcTypeVarContext !== void 0 ? srcTypeVarContext : new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeIds)(concreteSrcType)), flags, recursionCount)) {
+                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)) {
                     return true;
                 }
             }
@@ -17205,17 +17214,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     if (destOverloads.every((destOverload, index) => {
                         const srcOverload = srcOverloads[index];
                         return assignType(destOverload, srcOverload, 
-                        /* diag */ undefined, destTypeVarContext !== null && destTypeVarContext !== void 0 ? destTypeVarContext : new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(destOverload)), srcTypeVarContext, flags, recursionCount);
+                        /* diag */ undefined, destConstraints, srcConstraints, flags, recursionCount);
                     })) {
                         return true;
                     }
                 }
             }
             const isAssignable = destOverloads.every((destOverload) => {
-                if (destTypeVarContext) {
-                    destTypeVarContext.addSolveForScope((0, typeUtils_1.getTypeVarScopeId)(destOverload));
-                }
-                const result = assignType(destOverload, srcType, overloadDiag === null || overloadDiag === void 0 ? void 0 : overloadDiag.createAddendum(), destTypeVarContext !== null && destTypeVarContext !== void 0 ? destTypeVarContext : new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(destOverload)), srcTypeVarContext, flags, recursionCount);
+                const result = assignType(destOverload, srcType, overloadDiag === null || overloadDiag === void 0 ? void 0 : overloadDiag.createAddendum(), destConstraints, srcConstraints, flags, recursionCount);
                 return result;
             });
             if (!isAssignable) {
@@ -17239,7 +17245,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, destTypeVarContext, srcTypeVarContext, flags, recursionCount);
+                return (0, protocols_1.assignClassToProtocol)(evaluatorInterface, types_1.ClassType.cloneAsInstantiable(destType), types_1.ClassType.cloneAsInstance(noneTypeClass), diag, destConstraints, srcConstraints, flags, recursionCount);
             }
         }
         if ((0, typeUtils_1.isNoneInstance)(destType)) {
@@ -17249,7 +17255,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, destTypeVarContext, srcTypeVarContext, flags, recursionCount) {
+    function assignFromUnionType(destType, srcType, diag, destConstraints, srcConstraints, 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)) {
@@ -17267,7 +17273,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             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, destTypeVarContext, srcTypeVarContext, flags, recursionCount);
+                /* diag */ undefined, destConstraints, srcConstraints, flags, recursionCount);
                 // This always succeeds because the destination contains Any.
                 return true;
             }
@@ -17308,8 +17314,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         if (types_1.ClassType.isTypedDictClass(srcSubtype) && types_1.ClassType.isTypedDictClass(destSubtype)) {
                             if (assignType(srcSubtype, destSubtype, 
                             /* diag */ undefined, 
-                            /* destTypeVarContext */ undefined, 
-                            /* srcTypeVarContext */ undefined, flags, recursionCount)) {
+                            /* destConstraints */ undefined, 
+                            /* srcConstraints */ undefined, flags, recursionCount)) {
                                 return true;
                             }
                         }
@@ -17323,7 +17329,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 });
                 if (destTypeIndex >= 0) {
                     if (assignType(remainingDestSubtypes[destTypeIndex], srcSubtype, 
-                    /* diag */ undefined, destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
+                    /* diag */ undefined, destConstraints, srcConstraints, flags, recursionCount)) {
                         // Note that we have matched at least one subtype indicating
                         // there is at least some overlap.
                         matchedSomeSubtypes = true;
@@ -17360,7 +17366,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(), destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
+                            if (assignType(reorderedDestSubtypes[destIndex], remainingSrcSubtypes[srcIndex], diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destConstraints, srcConstraints, 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,7 +17389,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         // dest TypeVars.
                         remainingDestSubtypes.forEach((destSubtype) => {
                             assignType(destSubtype, srcType, 
-                            /* diag */ undefined, destTypeVarContext, srcTypeVarContext, flags, recursionCount);
+                            /* diag */ undefined, destConstraints, srcConstraints, flags, recursionCount);
                         });
                     }
                     // If we've assigned all of the source subtypes but one or more dest
@@ -17392,7 +17398,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(), destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
+                    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)) {
                         canUseFastPath = false;
                     }
                 }
@@ -17412,14 +17418,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 return;
             }
             if (!assignType(destType, subtype, 
-            /* diag */ undefined, destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
+            /* diag */ undefined, destConstraints, srcConstraints, 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(), destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
+                    !assignType(destType, subtype, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destConstraints, srcConstraints, flags, recursionCount)) {
                     isIncompatible = true;
                 }
             }
@@ -17486,14 +17492,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return (assignType(destType, srcType, 
         /* diag */ undefined, 
-        /* destTypeVarContext */ undefined, 
-        /* srcTypeVarContext */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount) &&
+        /* destConstraints */ undefined, 
+        /* srcConstraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount) &&
             !assignType(srcType, destType, 
             /* diag */ undefined, 
-            /* destTypeVarContext */ undefined, 
-            /* srcTypeVarContext */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount));
+            /* destConstraints */ undefined, 
+            /* srcConstraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount));
     }
-    function assignToUnionType(destType, srcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount) {
+    function assignToUnionType(destType, srcType, diag, destConstraints, srcConstraints, 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.
@@ -17501,18 +17507,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             let isIncompatible = false;
             (0, typeUtils_1.doForEachSubtype)(destType, (subtype, index) => {
                 if (!isIncompatible &&
-                    !assignType(subtype, srcType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
-                    // Determine whether this subtype is assignable to
-                    // another subtype elsewhere in the union. If so, we can ignore
-                    // the incompatibility.
+                    !assignType(subtype, srcType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destConstraints, srcConstraints, 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;
                     if (!(0, types_1.isAnyOrUnknown)(subtype)) {
+                        const adjSubtype = (0, typeUtils_1.makeTypeVarsBound)(subtype, /* scopeIds */ undefined);
                         (0, typeUtils_1.doForEachSubtype)(destType, (otherSubtype, otherIndex) => {
                             if (index !== otherIndex && !skipSubtype) {
-                                if (assignType(otherSubtype, subtype, 
+                                const adjOtherSubtype = (0, typeUtils_1.makeTypeVarsBound)(otherSubtype, /* scopeIds */ undefined);
+                                if (assignType(adjOtherSubtype, adjSubtype, 
                                 /* diag */ undefined, 
-                                /* destTypeVarContext */ undefined, 
-                                /* srcTypeVarContext */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount)) {
+                                /* destConstraints */ undefined, 
+                                /* srcConstraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount)) {
                                     skipSubtype = true;
                                 }
                             }
@@ -17536,7 +17543,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(), destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
+                if (assignType(subtype, srcType, diagAddendum === null || diagAddendum === void 0 ? void 0 : diagAddendum.createAddendum(), destConstraints, srcConstraints, flags, recursionCount)) {
                     foundMatch = true;
                     break;
                 }
@@ -17551,9 +17558,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 foundMatch = true;
             }
             else {
-                let bestDestTypeVarContext;
-                let bestSrcTypeVarContext;
-                let bestTypeVarContextScore;
+                let bestDestConstraints;
+                let bestSrcConstraints;
+                let bestConstraintsScore;
+                let nakedTypeVarMatches = 0;
                 // If the srcType is a literal, try to use the fast-path lookup
                 // in case the destType is a union with hundreds of literals.
                 if ((0, types_1.isClassInstance)(srcType) &&
@@ -17562,44 +17570,61 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     return true;
                 }
                 (0, typeUtils_1.doForEachSubtype)(destType, (subtype) => {
-                    // Make a temporary clone of the typeVarContext. We don't want to modify
-                    // the original typeVarContext until we find the "optimal" typeVar mapping.
-                    const destTypeVarContextClone = destTypeVarContext === null || destTypeVarContext === void 0 ? void 0 : destTypeVarContext.clone();
-                    const srcTypeVarContextClone = srcTypeVarContext === null || srcTypeVarContext === void 0 ? void 0 : srcTypeVarContext.clone();
-                    if (assignType(subtype, srcType, diagAddendum === null || diagAddendum === void 0 ? void 0 : diagAddendum.createAddendum(), destTypeVarContextClone, srcTypeVarContextClone, flags, recursionCount)) {
+                    // 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)) {
                         foundMatch = true;
-                        if (destTypeVarContextClone) {
-                            // Ask the typeVarContext to compute a "score" for the current
+                        if (destConstraintsClone) {
+                            // Ask the constraints to compute a "score" for the current
                             // contents of the table.
-                            let typeVarContextScore = destTypeVarContextClone.getScore();
+                            let constraintsScore = destConstraintsClone.getScore();
+                            if ((0, types_1.isTypeVar)(subtype)) {
+                                if (!(destConstraints === null || destConstraints === void 0 ? void 0 : destConstraints.getMainConstraintSet().getTypeVar(subtype))) {
+                                    nakedTypeVarMatches++;
+                                    // Handicap the solution slightly so another type var with
+                                    // existing constraints will be preferred.
+                                    constraintsScore += 0.001;
+                                }
+                            }
                             // If the type matches exactly, prefer it over other types.
                             if ((0, types_1.isTypeSame)(subtype, stripLiteralValue(srcType))) {
-                                typeVarContextScore = Number.POSITIVE_INFINITY;
+                                constraintsScore = Number.POSITIVE_INFINITY;
                             }
-                            if (bestTypeVarContextScore === undefined ||
-                                bestTypeVarContextScore <= typeVarContextScore) {
+                            if (bestConstraintsScore === undefined || bestConstraintsScore <= constraintsScore) {
                                 // We found a typeVar mapping with a higher score than before.
-                                bestTypeVarContextScore = typeVarContextScore;
-                                bestDestTypeVarContext = destTypeVarContextClone;
-                                bestSrcTypeVarContext = srcTypeVarContextClone;
+                                bestConstraintsScore = constraintsScore;
+                                bestDestConstraints = destConstraintsClone;
+                                bestSrcConstraints = srcConstraintsClone;
                             }
                         }
                     }
-                });
-                // If we found a winning type var mapping, copy it back to typeVarContext.
-                if (destTypeVarContext && bestDestTypeVarContext) {
-                    destTypeVarContext.copyFromClone(bestDestTypeVarContext);
+                }, 
+                /* sortSubtypes */ true);
+                // If we saw more than one "naked" type vars that have no
+                // previous constraints recorded, it's dangerous for us to
+                // assign a value to any of these type vars at this time.
+                // Typically, they will receive some constraints via some
+                // later argument assignment.
+                if (nakedTypeVarMatches > 1 && (flags & 8 /* AssignTypeFlags.ArgAssignmentFirstPass */) !== 0) {
+                    bestDestConstraints = undefined;
+                    bestSrcConstraints = undefined;
+                }
+                // If we found a winning type var mapping, copy it back to constraints.
+                if (destConstraints && bestDestConstraints) {
+                    destConstraints.copyFromClone(bestDestConstraints);
                 }
-                if (srcTypeVarContext && bestSrcTypeVarContext) {
-                    srcTypeVarContext.copyFromClone(bestSrcTypeVarContext);
+                if (srcConstraints && bestSrcConstraints) {
+                    srcConstraints.copyFromClone(bestSrcConstraints);
                 }
             }
         }
         // If the source is a constrained TypeVar, see if we can assign all of the
         // constraints to the union.
         if (!foundMatch) {
-            if ((0, types_1.isTypeVar)(srcType) && srcType.shared.constraints.length > 0) {
-                foundMatch = assignType(destType, makeTopLevelTypeVarsConcrete(srcType), diagAddendum === null || diagAddendum === void 0 ? void 0 : diagAddendum.createAddendum(), destTypeVarContext, srcTypeVarContext, flags, recursionCount);
+            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);
             }
         }
         if (!foundMatch) {
@@ -17635,15 +17660,15 @@ 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, 
-                        /* destTypeVarContext */ undefined, 
-                        /* srcTypeVarContext */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount);
+                        /* destConstraints */ undefined, 
+                        /* srcConstraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount);
                     }
-                    if (destType.shared.constraints.length > 0) {
+                    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, 
-                        /* destTypeVarContext */ undefined, 
-                        /* srcTypeVarContext */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount);
+                        /* destConstraints */ undefined, 
+                        /* srcConstraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount);
                     }
                     // This is a non-bound and non-constrained type variable with a matching condition.
                     return true;
@@ -17681,7 +17706,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return getBoundMagicMethod(objType, '__call__', /* selfType */ undefined, /* diag */ undefined, recursionCount);
     }
-    function assignParam(destType, srcType, paramIndex, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount) {
+    function assignParam(destType, srcType, paramIndex, diag, destConstraints, srcConstraints, flags, recursionCount) {
         // Handle the special case where the dest type is a synthesized
         // "self" for a protocol class.
         if ((0, types_1.isTypeVar)(destType) &&
@@ -17698,28 +17723,39 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         let specializedDestType = destType;
         let doSpecializationStep = false;
         if ((flags & 16 /* AssignTypeFlags.OverloadOverlap */) === 0) {
+            const isFirstPass = (flags & 8 /* AssignTypeFlags.ArgAssignmentFirstPass */) !== 0;
             if ((flags & 2 /* AssignTypeFlags.ReverseTypeVarMatching */) === 0) {
-                specializedDestType = (0, typeUtils_1.applySolvedTypeVars)(destType, destTypeVarContext, { useLowerBoundOnly: true });
+                if (!isFirstPass) {
+                    specializedDestType = solveAndApplyConstraints(destType, destConstraints, 
+                    /* applyOptions */ undefined, {
+                        useLowerBoundOnly: true,
+                    });
+                }
                 doSpecializationStep = (0, typeUtils_1.requiresSpecialization)(specializedDestType);
             }
             else {
-                specializedSrcType = (0, typeUtils_1.applySolvedTypeVars)(srcType, srcTypeVarContext, { useLowerBoundOnly: true });
+                if (!isFirstPass) {
+                    specializedSrcType = solveAndApplyConstraints(srcType, srcConstraints, 
+                    /* applyOptions */ undefined, {
+                        useLowerBoundOnly: true,
+                    });
+                }
                 doSpecializationStep = (0, typeUtils_1.requiresSpecialization)(specializedSrcType);
             }
         }
         // Is an additional specialization step required?
         if (doSpecializationStep) {
             if (assignType(specializedSrcType, specializedDestType, 
-            /* diag */ undefined, srcTypeVarContext, destTypeVarContext, (flags ^ 2 /* AssignTypeFlags.ReverseTypeVarMatching */) | 256 /* AssignTypeFlags.RetainLiteralsForTypeVar */, recursionCount)) {
+            /* diag */ undefined, srcConstraints, destConstraints, (flags ^ 2 /* AssignTypeFlags.ReverseTypeVarMatching */) | 256 /* AssignTypeFlags.RetainLiteralsForTypeVar */, recursionCount)) {
                 if ((flags & 2 /* AssignTypeFlags.ReverseTypeVarMatching */) === 0) {
-                    specializedDestType = (0, typeUtils_1.applySolvedTypeVars)(destType, destTypeVarContext);
+                    specializedDestType = solveAndApplyConstraints(destType, destConstraints);
                 }
                 else {
-                    specializedSrcType = (0, typeUtils_1.applySolvedTypeVars)(srcType, srcTypeVarContext);
+                    specializedSrcType = solveAndApplyConstraints(srcType, srcConstraints);
                 }
             }
         }
-        if (!assignType(specializedSrcType, specializedDestType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), srcTypeVarContext, destTypeVarContext, flags, recursionCount)) {
+        if (!assignType(specializedSrcType, specializedDestType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), srcConstraints, destConstraints, flags, recursionCount)) {
             if (diag && paramIndex !== undefined) {
                 diag.addMessage(localize_1.LocAddendum.paramAssignment().format({
                     index: paramIndex + 1,
@@ -17778,7 +17814,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
             }
             else {
-                srcTupleTypes.push({ type: entry.type, isUnbounded: false, isOptional: !!entry.param.defaultType });
+                srcTupleTypes.push({ type: entry.type, isUnbounded: false, isOptional: !!entry.defaultType });
             }
         });
         if (srcTupleTypes.length !== 1 || !(0, types_1.isTypeVarTuple)(srcTupleTypes[0].type)) {
@@ -17791,6 +17827,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 {
                     param: types_1.FunctionParam.create(1 /* ParamCategory.ArgsList */, srcPositionalsType, types_1.FunctionParamFlags.NameSynthesized | types_1.FunctionParamFlags.TypeDeclared, '_arg_combined'),
                     type: srcPositionalsType,
+                    declaredType: srcPositionalsType,
                     index: -1,
                     kind: parameterUtils_1.ParamKind.Positional,
                 },
@@ -17802,12 +17839,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             srcDetails.kwargsIndex = kwargsIndex >= 0 ? kwargsIndex : undefined;
             const firstKeywordOnlyIndex = srcDetails.params.findIndex((param) => param.kind === parameterUtils_1.ParamKind.Keyword);
             srcDetails.firstKeywordOnlyIndex = firstKeywordOnlyIndex >= 0 ? firstKeywordOnlyIndex : undefined;
-            srcDetails.positionOnlyParamCount = Math.max(0, srcDetails.params.findIndex((p) => p.kind !== parameterUtils_1.ParamKind.Positional ||
-                p.param.category !== 0 /* ParamCategory.Simple */ ||
-                !!p.param.defaultType));
+            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, destTypeVarContext, srcTypeVarContext, flags, recursionCount) {
+    function assignFunction(destType, srcType, diag, destConstraints, srcConstraints, flags, recursionCount) {
         var _a, _b, _c, _d, _e, _f, _g, _h;
         let canAssign = true;
         const checkReturnType = (flags & 64 /* AssignTypeFlags.SkipReturnTypeCheck */) === 0;
@@ -17869,9 +17904,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     }
                 }
             }
-            if (destParam.param.defaultType &&
-                !srcParam.param.defaultType &&
-                paramIndex !== srcParamDetails.argsIndex) {
+            if (destParam.defaultType && !srcParam.defaultType && paramIndex !== srcParamDetails.argsIndex) {
                 diag === null || diag === void 0 ? void 0 : diag.createAddendum().addMessage(localize_1.LocAddendum.functionParamDefaultMissing().format({
                     name: srcParamName,
                 }));
@@ -17891,7 +17924,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(), destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
+            else if (!assignParam(destParamType, srcParamType, paramIndex, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destConstraints, srcConstraints, flags, recursionCount)) {
                 // Handle the special case where the source parameter is a synthesized
                 // TypeVar for "self" or "cls".
                 if ((flags & 512 /* AssignTypeFlags.SkipSelfClsTypeCheck */) === 0 ||
@@ -17928,7 +17961,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(), destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
+                    if (!assignParam(destArgsType, srcParamType, i, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destConstraints, srcConstraints, flags, recursionCount)) {
                         canAssign = false;
                     }
                     continue;
@@ -17936,14 +17969,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 // If The source parameter has a default value, it is OK for the
                 // corresponding dest parameter to be missing.
                 const srcParam = srcParamDetails.params[i];
-                if (srcParam.param.defaultType) {
+                if (srcParam.defaultType) {
                     // Assign default arg value in case it is needed for
                     // populating TypeVar constraints.
                     const paramInfo = srcParamDetails.params[i];
-                    const defaultArgType = (_f = paramInfo.defaultArgType) !== null && _f !== void 0 ? _f : paramInfo.param.defaultType;
+                    const defaultArgType = (_f = paramInfo.defaultType) !== null && _f !== void 0 ? _f : paramInfo.defaultType;
                     if (defaultArgType &&
-                        !assignType(paramInfo.type, defaultArgType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), srcTypeVarContext, 
-                        /* destTypeVarContext */ undefined, flags, recursionCount)) {
+                        !assignType(paramInfo.type, defaultArgType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), srcConstraints, 
+                        /* destConstraints */ undefined, flags, recursionCount)) {
                         canAssign = false;
                     }
                     continue;
@@ -17958,7 +17991,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 if (srcParam.param.category === 1 /* ParamCategory.ArgsList */) {
                     continue;
                 }
-                const nonDefaultSrcParamCount = srcParamDetails.params.filter((p) => !!p.param.name && !p.param.defaultType && p.param.category === 0 /* ParamCategory.Simple */).length;
+                const nonDefaultSrcParamCount = srcParamDetails.params.filter((p) => !!p.param.name && !p.defaultType && p.param.category === 0 /* ParamCategory.Simple */).length;
                 diag === null || diag === void 0 ? void 0 : diag.createAddendum().addMessage(localize_1.LocAddendum.functionTooFewParams().format({
                     expected: nonDefaultSrcParamCount,
                     received: destPositionalCount,
@@ -17982,7 +18015,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         canAssign = false;
                     }
                     else {
-                        if (!assignParam(destParamType, srcArgsType, paramIndex, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
+                        if (!assignParam(destParamType, srcArgsType, paramIndex, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destConstraints, srcConstraints, flags, recursionCount)) {
                             canAssign = false;
                         }
                         if (destParamDetails.params[paramIndex].kind !== parameterUtils_1.ParamKind.Positional &&
@@ -18024,7 +18057,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(), destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
+            if (!assignParam(destArgsType, srcArgsType, destParamDetails.params[destParamDetails.argsIndex].index, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destConstraints, srcConstraints, flags, recursionCount)) {
                 canAssign = false;
             }
         }
@@ -18072,7 +18105,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             const paramDiag = diag === null || diag === void 0 ? void 0 : diag.createAddendum();
                             const srcParamType = srcParamInfo.type;
                             if (!destParamInfo) {
-                                if (destParamDetails.kwargsIndex === undefined && !srcParamInfo.param.defaultType) {
+                                if (destParamDetails.kwargsIndex === undefined && !srcParamInfo.defaultType) {
                                     if (paramDiag) {
                                         paramDiag.addMessage(localize_1.LocAddendum.namedParamMissingInDest().format({
                                             name: srcParamInfo.param.name,
@@ -18082,28 +18115,28 @@ 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(), destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
+                                    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)) {
                                         canAssign = false;
                                     }
                                 }
-                                else if (srcParamInfo.param.defaultType) {
+                                else if (srcParamInfo.defaultType) {
                                     // Assign default arg values in case they are needed for
                                     // populating TypeVar constraints.
-                                    const defaultArgType = (_a = srcParamInfo.defaultArgType) !== null && _a !== void 0 ? _a : srcParamInfo.param.defaultType;
+                                    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(), srcTypeVarContext, 
-                                        /* destTypeVarContext */ undefined, flags, recursionCount)) {
+                                        !assignType(srcParamInfo.type, defaultArgType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), srcConstraints, 
+                                        /* destConstraints */ undefined, flags, recursionCount)) {
                                         canAssign = false;
                                     }
                                 }
                             }
                             else {
                                 const destParamType = destParamInfo.type;
-                                const specializedDestParamType = destTypeVarContext
-                                    ? (0, typeUtils_1.applySolvedTypeVars)(destParamType, destTypeVarContext)
+                                const specializedDestParamType = destConstraints
+                                    ? solveAndApplyConstraints(destParamType, destConstraints)
                                     : destParamType;
                                 if (!assignParam(destParamInfo.type, srcParamType, 
-                                /* paramIndex */ undefined, paramDiag === null || paramDiag === void 0 ? void 0 : paramDiag.createAddendum(), destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
+                                /* paramIndex */ undefined, paramDiag === null || paramDiag === void 0 ? void 0 : paramDiag.createAddendum(), destConstraints, srcConstraints, flags, recursionCount)) {
                                     if (paramDiag) {
                                         paramDiag.addMessage(localize_1.LocAddendum.namedParamTypeMismatch().format({
                                             name: srcParamInfo.param.name,
@@ -18113,7 +18146,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                                     }
                                     canAssign = false;
                                 }
-                                if (destParamInfo.param.defaultType && !srcParamInfo.param.defaultType) {
+                                if (destParamInfo.defaultType && !srcParamInfo.defaultType) {
                                     diag === null || diag === void 0 ? void 0 : diag.createAddendum().addMessage(localize_1.LocAddendum.functionParamDefaultMissing().format({
                                         name: srcParamInfo.param.name,
                                     }));
@@ -18129,7 +18162,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.param.type, srcParamDetails.params[srcParamDetails.kwargsIndex].type, destParamInfo.index, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
+                    if (!assignParam(destParamInfo.type, srcParamDetails.params[srcParamDetails.kwargsIndex].type, destParamInfo.index, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destConstraints, srcConstraints, flags, recursionCount)) {
                         canAssign = false;
                     }
                     destParamMap.delete(paramName);
@@ -18141,7 +18174,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(), destTypeVarContext, srcTypeVarContext, 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(), destConstraints, srcConstraints, flags, recursionCount)) {
                     canAssign = false;
                 }
             }
@@ -18164,14 +18197,20 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 canAssign = false;
             }
         }
-        const effectiveSrcTypeVarContext = reverseMatching ? destTypeVarContext : srcTypeVarContext;
         // 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 solutionSet = effectiveSrcTypeVarContext.getMainSolutionSet();
-        solutionSet.getTypeVars().forEach((typeVarEntry) => {
-            assignType(typeVarEntry.typeVar, solutionSet.getTypeVarType(typeVarEntry.typeVar), 
-            /* diag */ undefined, destTypeVarContext, srcTypeVarContext, 0 /* AssignTypeFlags.Default */, recursionCount);
-        });
+        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;
@@ -18179,11 +18218,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             const effectiveSrcParamSpec = reverseMatching ? destParamSpec : srcParamSpec;
             const effectiveDestParamSpec = reverseMatching ? srcParamSpec : destParamSpec;
             if (effectiveDestParamSpec) {
-                const requiredMatchParamCount = effectiveDestType.shared.parameters.filter((p) => {
+                const requiredMatchParamCount = effectiveDestType.shared.parameters.filter((p, i) => {
                     if (!p.name) {
                         return false;
                     }
-                    if (p.category === 0 /* ParamCategory.Simple */ && (0, types_1.isParamSpec)(p.type)) {
+                    const paramType = types_1.FunctionType.getParamType(effectiveDestType, i);
+                    if (p.category === 0 /* ParamCategory.Simple */ && (0, types_1.isParamSpec)(paramType)) {
                         return false;
                     }
                     return true;
@@ -18204,7 +18244,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         // is the first remaining param.
                     }
                     else {
-                        remainingParams.push(types_1.FunctionParam.create(p.category, types_1.FunctionType.getEffectiveParamType(effectiveSrcType, index), p.flags, p.name, p.defaultType ? types_1.AnyType.create(/* isEllipsis */ true) : undefined));
+                        remainingParams.push(types_1.FunctionParam.create(p.category, types_1.FunctionType.getParamType(effectiveSrcType, index), p.flags, p.name, types_1.FunctionType.getParamDefaultType(effectiveSrcType, index)
+                            ? types_1.AnyType.create(/* isEllipsis */ true)
+                            : undefined));
                     }
                 });
                 // If there are remaining parameters and the source and dest do not contain
@@ -18223,16 +18265,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     if (effectiveSrcParamSpec) {
                         types_1.FunctionType.addParamSpecVariadics(remainingFunction, (0, typeUtils_1.convertToInstance)(effectiveSrcParamSpec));
                     }
-                    types_1.FunctionType.addHigherOrderTypeVarScopeIds(remainingFunction, effectiveSrcType.priv.higherOrderTypeVarScopeIds);
                     if (!assignType(effectiveDestParamSpec, remainingFunction, 
-                    /* diag */ undefined, destTypeVarContext, srcTypeVarContext, flags)) {
+                    /* diag */ undefined, destConstraints, srcConstraints, 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, destTypeVarContext, srcTypeVarContext, flags)) {
+                            /* diag */ undefined, destConstraints, srcConstraints, flags)) {
                             canAssign = false;
                         }
                     }
@@ -18243,7 +18284,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (checkReturnType) {
             const destReturnType = getFunctionEffectiveReturnType(destType);
             if (!(0, types_1.isAnyOrUnknown)(destReturnType)) {
-                const srcReturnType = (0, typeUtils_1.applySolvedTypeVars)(getFunctionEffectiveReturnType(srcType), srcTypeVarContext);
+                const srcReturnType = solveAndApplyConstraints(getFunctionEffectiveReturnType(srcType), srcConstraints);
                 const returnDiag = diag === null || diag === void 0 ? void 0 : diag.createAddendum();
                 let isReturnTypeCompatible = false;
                 let effectiveFlags = flags;
@@ -18254,7 +18295,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(), destTypeVarContext, srcTypeVarContext, effectiveFlags, recursionCount)) {
+                if (assignType(destReturnType, srcReturnType, returnDiag === null || returnDiag === void 0 ? void 0 : returnDiag.createAddendum(), destConstraints, srcConstraints, effectiveFlags, recursionCount)) {
                     isReturnTypeCompatible = true;
                 }
                 else {
@@ -18265,7 +18306,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(), destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
+                        if (assignType(destReturnType, types_1.ClassType.cloneAsInstance(boolClass), returnDiag === null || returnDiag === void 0 ? void 0 : returnDiag.createAddendum(), destConstraints, srcConstraints, flags, recursionCount)) {
                             isReturnTypeCompatible = true;
                         }
                     }
@@ -18283,7 +18324,7 @@ 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)(destTypeVarContext, srcTypeVarContext);
+        (0, typeUtils_1.applySourceContextTypeVars)(destConstraints, (0, constraintSolver_1.solveConstraints)(evaluatorInterface, srcConstraints));
         return canAssign;
     }
     // If the declaredType contains type arguments that are "Any" and
@@ -18300,12 +18341,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             assignedType.priv.typeArgs &&
             assignedType.priv.typeArgs.length <= assignedType.shared.typeParams.length &&
             !assignedType.priv.tupleTypeArgs) {
-            const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(assignedType));
-            (0, constraintSolver_1.addConstraintsForExpectedType)(evaluatorInterface, types_1.ClassType.specialize(assignedType, /* typeArgs */ undefined), declaredType, typeVarContext, ParseTreeUtils.getTypeVarScopesForNode(node), node.start);
+            const constraints = new constraintTracker_1.ConstraintTracker();
+            (0, constraintSolver_1.addConstraintsForExpectedType)(evaluatorInterface, types_1.ClassType.specialize(assignedType, /* typeArgs */ undefined), declaredType, constraints, ParseTreeUtils.getTypeVarScopesForNode(node), node.start);
             let replacedTypeArg = false;
+            const solution = (0, constraintSolver_1.solveConstraints)(evaluatorInterface, constraints).getMainSolutionSet();
             const newTypeArgs = assignedType.priv.typeArgs.map((typeArg, index) => {
                 const typeParam = assignedType.shared.typeParams[index];
-                const expectedTypeArgType = typeVarContext.getMainSolutionSet().getTypeVarType(typeParam);
+                const expectedTypeArgType = solution.getType(typeParam);
                 if (expectedTypeArgType) {
                     if ((0, types_1.isAnyOrUnknown)(expectedTypeArgType) || (0, types_1.isAnyOrUnknown)(typeArg)) {
                         replacedTypeArg = true;
@@ -18536,10 +18578,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         const childSelfOrClsType = types_1.FunctionType.isInstanceMethod(baseMethod)
             ? types_1.ClassType.cloneAsInstance(childClass)
             : childClass;
-        return assignType(baseParamType.type, childSelfOrClsType, 
+        return assignType(baseParamDetails.params[0].type, childSelfOrClsType, 
         /* diag */ undefined, 
-        /* destTypeVarContext */ undefined, 
-        /* srcTypeVarContext */ undefined, 8 /* AssignTypeFlags.SkipSolveTypeVars */);
+        /* destConstraints */ undefined, 
+        /* srcConstraints */ 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
@@ -18584,7 +18626,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 else {
                     const overrideArgsType = overrideParamDetails.params[overrideParamDetails.argsIndex].type;
                     for (let i = overrideParamDetails.positionParamCount; i < baseParamDetails.positionParamCount; i++) {
-                        if (!assignType(overrideArgsType, baseParamDetails.params[i].type, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(overrideMethod)), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(baseMethod)), 8 /* AssignTypeFlags.SkipSolveTypeVars */)) {
+                        if (!assignType(overrideArgsType, baseParamDetails.params[i].type, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), 
+                        /* destConstraints */ undefined, 
+                        /* srcConstraints */ undefined, 0 /* AssignTypeFlags.Default */)) {
                             localize_1.LocAddendum.overrideParamType().format({
                                 index: i + 1,
                                 baseType: printType(baseParamDetails.params[i].type),
@@ -18603,7 +18647,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     const overrideParam = overrideParamDetails.params[i].param;
                     if (overrideParam.category === 0 /* ParamCategory.Simple */ &&
                         overrideParam.name &&
-                        !overrideParam.defaultType) {
+                        !overrideParamDetails.params[i].defaultType) {
                         foundParamCountMismatch = true;
                     }
                 }
@@ -18672,7 +18716,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     const overrideIsSynthesizedTypeVar = (0, types_1.isTypeVar)(overrideParamType) && overrideParamType.shared.isSynthesized;
                     if (!exemptSelfClsParam || (!baseIsSynthesizedTypeVar && !overrideIsSynthesizedTypeVar)) {
                         if (baseParam.category !== overrideParam.category ||
-                            !assignType(overrideParamType, baseParamType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(overrideMethod)), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(baseMethod)), 8 /* AssignTypeFlags.SkipSolveTypeVars */)) {
+                            !assignType(overrideParamType, baseParamType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), 
+                            /* destConstraints */ undefined, 
+                            /* srcConstraints */ undefined, 0 /* AssignTypeFlags.Default */)) {
                             diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.overrideParamType().format({
                                 index: i + 1,
                                 baseType: printType(baseParamType),
@@ -18681,8 +18727,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             canOverride = false;
                         }
                     }
-                    if (baseParamDetails.params[i].param.defaultType &&
-                        !overrideParamDetails.params[i].param.defaultType) {
+                    if (baseParamDetails.params[i].defaultType && !overrideParamDetails.params[i].defaultType) {
                         diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.overrideParamNoDefault().format({
                             index: i + 1,
                         }));
@@ -18715,8 +18760,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 else {
                     const overrideParamType = overrideParamDetails.params[overrideParamDetails.argsIndex].type;
                     const baseParamType = baseParamDetails.params[baseParamDetails.argsIndex].type;
-                    if (!assignType(overrideParamType, baseParamType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(overrideMethod)), 
-                    /* srcTypeVarContext */ undefined, 8 /* AssignTypeFlags.SkipSolveTypeVars */)) {
+                    if (!assignType(overrideParamType, baseParamType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), 
+                    /* destConstraints */ undefined, 
+                    /* srcConstraints */ 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),
@@ -18743,7 +18789,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     if (!targetParamType) {
                         targetParamType = overrideParamDetails.params[overrideParamDetails.kwargsIndex].type;
                     }
-                    if (!assignType(targetParamType, paramInfo.type, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(overrideMethod)), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(baseMethod)), 8 /* AssignTypeFlags.SkipSolveTypeVars */)) {
+                    if (!assignType(targetParamType, paramInfo.type, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), 
+                    /* destConstraints */ undefined, 
+                    /* srcConstraints */ 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),
@@ -18752,7 +18800,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         canOverride = false;
                     }
                     if (overrideParamInfo) {
-                        if (paramInfo.param.defaultType && !overrideParamInfo.param.defaultType) {
+                        if (paramInfo.defaultType && !overrideParamInfo.defaultType) {
                             diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.overrideParamKeywordNoDefault().format({
                                 name: (_c = overrideParamInfo.param.name) !== null && _c !== void 0 ? _c : '?',
                             }));
@@ -18768,7 +18816,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 const baseParamInfo = baseKwOnlyParams.find((pi) => paramInfo.param.name === pi.param.name);
                 if (!baseParamInfo) {
                     if (baseParamDetails.kwargsIndex === undefined) {
-                        if (!paramInfo.param.defaultType) {
+                        if (!paramInfo.defaultType) {
                             diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.overrideParamNameExtra().format({
                                 name: (_a = paramInfo.param.name) !== null && _a !== void 0 ? _a : '?',
                             }));
@@ -18801,7 +18849,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // Now check the return type.
         const baseReturnType = getFunctionEffectiveReturnType(baseMethod);
         const overrideReturnType = getFunctionEffectiveReturnType(overrideMethod);
-        if (!assignType(baseReturnType, overrideReturnType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(baseMethod)), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(overrideMethod)), 8 /* AssignTypeFlags.SkipSolveTypeVars */)) {
+        if (!assignType(baseReturnType, overrideReturnType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), 
+        /* destConstraints */ undefined, 
+        /* srcConstraints */ undefined, 0 /* AssignTypeFlags.Default */)) {
             diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.overrideReturnType().format({
                 baseType: printType(baseReturnType),
                 overrideType: printType(overrideReturnType),
@@ -18833,8 +18883,8 @@ 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(), 
-            /* destTypeVarContext */ undefined, 
-            /* srcTypeVarContext */ undefined)) {
+            /* destConstraints */ undefined, 
+            /* srcConstraints */ undefined)) {
                 // Avoid adding a message that will confuse users if the TypeVar was
                 // synthesized for internal purposes.
                 if (!destType.shared.isSynthesized) {
@@ -18875,7 +18925,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if ((0, typeUtils_1.isTypeAliasPlaceholder)(srcType)) {
             return srcType;
         }
-        if ((0, types_1.isTypeVar)(srcType) && srcType.shared.constraints.length > 0) {
+        if ((0, types_1.isTypeVar)(srcType) && types_1.TypeVarType.hasConstraints(srcType)) {
             // Make sure all the source constraint types map to constraint types in the dest.
             if (srcType.shared.constraints.every((sourceConstraint) => {
                 return constraints.some((destConstraint) => assignType(destConstraint, sourceConstraint));
@@ -18961,18 +19011,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 else if (memberClass && (0, typeUtils_1.isInstantiableMetaclass)(memberClass)) {
                     stripFirstParam = true;
                 }
-                return partiallySpecializeBoundMethod(baseType, functionType, memberClass !== null && memberClass !== void 0 ? memberClass : types_1.ClassType.cloneAsInstantiable(baseObj), diag, recursionCount, selfType !== null && selfType !== void 0 ? selfType : baseObj, stripFirstParam);
+                return partiallySpecializeBoundMethod(baseType, functionType, diag, recursionCount, selfType !== null && selfType !== void 0 ? selfType : baseObj, stripFirstParam);
             }
             if (types_1.FunctionType.isClassMethod(functionType) ||
                 (treatConstructorAsClassMethod && types_1.FunctionType.isConstructorMethod(functionType))) {
                 const baseClass = (0, types_1.isInstantiableClass)(baseType) ? baseType : types_1.ClassType.cloneAsInstantiable(baseType);
                 const clsType = selfType ? (0, typeUtils_1.convertToInstantiable)(selfType) : undefined;
-                return partiallySpecializeBoundMethod(baseClass, functionType, memberClass !== null && memberClass !== void 0 ? memberClass : baseClass, diag, recursionCount, clsType !== null && clsType !== void 0 ? clsType : baseClass, 
+                return partiallySpecializeBoundMethod(baseClass, functionType, diag, recursionCount, clsType !== null && clsType !== void 0 ? clsType : baseClass, 
                 /* stripFirstParam */ true);
             }
             if (types_1.FunctionType.isStaticMethod(functionType)) {
                 const baseClass = (0, types_1.isInstantiableClass)(baseType) ? baseType : types_1.ClassType.cloneAsInstantiable(baseType);
-                return partiallySpecializeBoundMethod(baseClass, functionType, memberClass !== null && memberClass !== void 0 ? memberClass : baseClass, diag, recursionCount, 
+                return partiallySpecializeBoundMethod(baseClass, functionType, diag, recursionCount, 
                 /* firstParamType */ undefined, 
                 /* stripFirstParam */ false);
             }
@@ -18982,16 +19032,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // Specializes the specified function for the specified class,
     // optionally stripping the first first parameter (the "self" or "cls")
     // off of the specialized function in the process. The baseType
-    // is the type used to reference the member, and the memberClass
-    // is the class that provided the member (could be an ancestor of
-    // the baseType's class).
-    function partiallySpecializeBoundMethod(baseType, memberType, memberClass, diag, recursionCount, firstParamType, stripFirstParam = true) {
-        const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(memberClass));
+    // is the type used to reference the member.
+    function partiallySpecializeBoundMethod(baseType, memberType, diag, recursionCount, firstParamType, stripFirstParam = true) {
+        const constraints = new constraintTracker_1.ConstraintTracker();
         if (firstParamType && memberType.shared.parameters.length > 0) {
             const memberTypeFirstParam = memberType.shared.parameters[0];
-            const memberTypeFirstParamType = types_1.FunctionType.getEffectiveParamType(memberType, 0);
-            // Fill out the typeVarContext for the "self" or "cls" parameter.
-            typeVarContext.addSolveForScope((0, typeUtils_1.getTypeVarScopeId)(memberType));
+            const memberTypeFirstParamType = types_1.FunctionType.getParamType(memberType, 0);
             if ((0, types_1.isTypeVar)(memberTypeFirstParamType) &&
                 memberTypeFirstParamType.shared.boundType &&
                 (0, types_1.isClassInstance)(memberTypeFirstParamType.shared.boundType) &&
@@ -19000,16 +19046,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 // contain references to themselves or their subclasses, so if
                 // we attempt to call assignType, we'll risk infinite recursion.
                 // Instead, we'll assume it's assignable.
-                if (!typeVarContext.isLocked()) {
-                    (0, typeUtils_1.setTypeVarType)(typeVarContext, memberTypeFirstParamType, types_1.TypeBase.isInstantiable(memberTypeFirstParamType)
+                if (!constraints.isLocked()) {
+                    constraints.setBounds(memberTypeFirstParamType, types_1.TypeBase.isInstantiable(memberTypeFirstParamType)
                         ? (0, typeUtils_1.convertToInstance)(firstParamType)
                         : firstParamType);
                 }
             }
             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(), typeVarContext, 
-                /* srcTypeVarContext */ undefined, 8192 /* AssignTypeFlags.AllowUnspecifiedTypeArgs */, recursionCount)) {
+                if (!assignType(memberTypeFirstParamType, firstParamType, subDiag === null || subDiag === void 0 ? void 0 : subDiag.createAddendum(), constraints, 
+                /* srcConstraints */ undefined, 8192 /* AssignTypeFlags.AllowUnspecifiedTypeArgs */, recursionCount)) {
                     if (memberTypeFirstParam.name &&
                         !types_1.FunctionParam.isNameSynthesized(memberTypeFirstParam) &&
                         types_1.FunctionParam.isTypeDeclared(memberTypeFirstParam)) {
@@ -19028,14 +19074,8 @@ 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);
-        const specializedFunction = (0, typeUtils_1.applySolvedTypeVars)(memberType, typeVarContext);
-        // If this is a constructor method, provide the base type's TypeVar scope ID
-        // so any TypeVars in this type can be solved.
-        let baseTypeTypeVarScopeId;
-        if (types_1.FunctionType.isConstructorMethod(specializedFunction) || specializedFunction.shared.name === '__init__') {
-            baseTypeTypeVarScopeId = (0, typeUtils_1.getTypeVarScopeId)(baseType);
-        }
-        return types_1.FunctionType.clone(specializedFunction, stripFirstParam, baseType, baseTypeTypeVarScopeId);
+        const specializedFunction = solveAndApplyConstraints(memberType, constraints);
+        return types_1.FunctionType.clone(specializedFunction, stripFirstParam, baseType);
     }
     function isFinalVariable(symbol) {
         return symbol.getDeclarations().some((decl) => isFinalVariableDeclaration(decl));
@@ -19257,18 +19297,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     function printControlFlowGraph(flowNode, reference, callName, logger) {
         return codeFlowEngine.printControlFlowGraph(flowNode, reference, callName, logger);
     }
-    function printTypeVarContext(typeVarContext) {
-        const solutionSets = typeVarContext.getSolutionSets();
-        solutionSets.forEach((context, index) => {
-            if (solutionSets.length > 1) {
-                console.log(`Solution set ${index + 1}:`);
-            }
-            context.getTypeVars().forEach((typeVarEntry) => {
-                const type = context.getTypeVarType(typeVarEntry.typeVar);
-                console.log(`  ${typeVarEntry.typeVar.shared.name}: ${type ? printType(type) : '<none>'}`);
-            });
-        });
-    }
     // Track these apis internal usages when logging is on. otherwise, it should be noop.
     const getFunctionInferredReturnType = wrapWithLogger(_getFunctionInferredReturnType);
     const evaluatorInterface = {
@@ -19295,6 +19323,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         removeTruthinessFromType,
         removeFalsinessFromType,
         stripTypeGuard,
+        solveAndApplyConstraints,
         verifyRaiseExceptionType,
         verifyDeleteExpression,
         validateOverloadedArgTypes,
@@ -19375,7 +19404,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         setTypeResultForNode,
         checkForCancellation,
         printControlFlowGraph,
-        printTypeVarContext,
     };
     const codeFlowEngine = (0, codeFlowEngine_1.getCodeFlowEngine)(evaluatorInterface, speculativeTypeTracker);
     return evaluatorInterface;