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

package/dist/analyzer/constraintSolver.js

@@ -10,145 +10,397 @@
  *
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.addConstraintsForExpectedType = exports.updateTypeVarType = exports.assignTypeToTypeVar = void 0;
+exports.assignTypeVar = assignTypeVar;
+exports.solveConstraints = solveConstraints;
+exports.applySourceSolutionToConstraints = applySourceSolutionToConstraints;
+exports.solveConstraintSet = solveConstraintSet;
+exports.addConstraintsForExpectedType = addConstraintsForExpectedType;
 const diagnostic_1 = require("../common/diagnostic");
 const localize_1 = require("../localization/localize");
+const constraintSolution_1 = require("./constraintSolution");
+const constraintTracker_1 = require("./constraintTracker");
 const typeEvaluatorTypes_1 = require("./typeEvaluatorTypes");
 const types_1 = require("./types");
 const typeUtils_1 = require("./typeUtils");
-const typeVarContext_1 = require("./typeVarContext");
 // As we widen the lower bound of a type variable, we may end up with
 // many subtypes. For performance reasons, we need to cap this at some
 // point. This constant determines the cap.
 const maxSubtypeCountForTypeVarLowerBound = 64;
-// This debugging switch enables logging of the TypeVarContext before and
+// This debugging switch enables logging of the constraints before and
 // after it is updated by the constraint solver.
-const logTypeVarContextUpdates = false;
+const logConstraintsUpdates = false;
 // Assigns the source type to the dest type var in the type var context. If an existing
 // type is already associated with that type var name, it attempts to either widen or
 // narrow the type (depending on the value of the isContravariant parameter). The goal is
 // to produce the narrowest type that meets all of the requirements. If the type var context
 // has been "locked", it simply validates that the srcType is compatible (with no attempt
 // to widen or narrow).
-function assignTypeToTypeVar(evaluator, destType, srcType, diag, typeVarContext, flags = 0 /* AssignTypeFlags.Default */, recursionCount = 0) {
-    if (logTypeVarContextUpdates) {
+function assignTypeVar(evaluator, destType, srcType, diag, constraints, flags = 0 /* AssignTypeFlags.Default */, recursionCount = 0) {
+    let isAssignable;
+    if (logConstraintsUpdates) {
         const indent = ' '.repeat(recursionCount * 2);
         console.log(`${indent}`);
-        console.log(`${indent}assignTypeToTypeVar called with`);
+        console.log(`${indent}assignTypeVar called with`);
         console.log(`${indent}destType: ${evaluator.printType(destType)}`);
         console.log(`${indent}srcType: ${evaluator.printType(srcType)}`);
         console.log(`${indent}flags: ${flags}`);
-        console.log(`${indent}scopes: ${(typeVarContext.getSolveForScopes() || []).join(', ')}`);
-        logTypeVarContext(evaluator, typeVarContext, indent);
+        if (constraints) {
+            logConstraints(evaluator, constraints, indent);
+        }
     }
-    let isTypeVarInScope = true;
-    const isInvariant = (flags & 1 /* AssignTypeFlags.EnforceInvariance */) !== 0;
-    const isContravariant = (flags & 2 /* AssignTypeFlags.ReverseTypeVarMatching */) !== 0 && !isInvariant;
     // If the TypeVar doesn't have a scope ID, then it's being used
     // outside of a valid TypeVar scope. This will be reported as a
     // separate error. Just ignore this case to avoid redundant errors.
     if (!destType.priv.scopeId) {
         return true;
     }
+    if (types_1.TypeVarType.isBound(destType) && !types_1.TypeVarType.isUnification(destType)) {
+        return assignBoundTypeVar(evaluator, destType, srcType, diag, flags);
+    }
     // Handle type[T] as a dest and a special form as a source.
     if (types_1.TypeBase.isInstantiable(destType) &&
         (0, types_1.isInstantiableClass)(srcType) &&
         evaluator.isSpecialFormClass(srcType, flags)) {
         return false;
     }
-    // Verify that we are solving for the scope associated with this
-    // type variable.
-    if (!typeVarContext.hasSolveForScope(destType.priv.scopeId)) {
-        // Handle Any as a source.
-        if ((0, types_1.isAnyOrUnknown)(srcType) || ((0, types_1.isClass)(srcType) && types_1.ClassType.derivesFromAnyOrUnknown(srcType))) {
-            return true;
-        }
-        // Handle a type[Any] as a source.
-        if ((0, types_1.isClassInstance)(srcType) && types_1.ClassType.isBuiltIn(srcType, 'type')) {
-            if (!srcType.priv.typeArgs ||
-                srcType.priv.typeArgs.length < 1 ||
-                (0, types_1.isAnyOrUnknown)(srcType.priv.typeArgs[0])) {
-                if (types_1.TypeBase.isInstantiable(destType)) {
-                    return true;
-                }
+    // An TypeVar can always be assigned to itself, but we won't record this in the constraints.
+    if ((0, types_1.isTypeSame)(destType, srcType)) {
+        return true;
+    }
+    if ((0, types_1.isParamSpec)(destType)) {
+        // Handle ParamSpecs specially.
+        isAssignable = assignParamSpec(evaluator, destType, srcType, diag, constraints, recursionCount);
+    }
+    else {
+        if ((0, types_1.isTypeVarTuple)(destType) && !destType.priv.isInUnion) {
+            const tupleClassType = evaluator.getTupleClassType();
+            if (!(0, types_1.isUnpacked)(srcType) && tupleClassType) {
+                // Package up the type into a tuple.
+                srcType = (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(tupleClassType, [{ type: srcType, isUnbounded: false }], 
+                /* isTypeArgExplicit */ true, 
+                /* isUnpackedTuple */ true));
             }
         }
-        // Is this the equivalent of an "Unknown" for a ParamSpec?
-        if ((0, types_1.isParamSpec)(destType) &&
-            (0, types_1.isFunction)(srcType) &&
-            types_1.FunctionType.isParamSpecValue(srcType) &&
-            types_1.FunctionType.isGradualCallableForm(srcType)) {
-            return true;
+        // If we're assigning an unpacked TypeVarTuple to a regular TypeVar,
+        // we need to treat it as a union of the unpacked TypeVarTuple.
+        if ((0, types_1.isTypeVarTuple)(srcType) &&
+            srcType.priv.isUnpacked &&
+            !srcType.priv.isInUnion &&
+            !(0, types_1.isTypeVarTuple)(destType)) {
+            srcType = types_1.TypeVarType.cloneForUnpacked(srcType, /* isInUnion */ true);
         }
-        // Never or NoReturn is always assignable to all type variables unless
-        // we're enforcing invariance.
-        if ((0, types_1.isNever)(srcType) && !isInvariant) {
-            return true;
+        // Handle the constrained case. This case needs to be handled specially
+        // because type narrowing isn't used in this case. For example, if the
+        // source type is "Literal[1]" and the constraint list includes the type
+        // "float", the resulting type is float.
+        if (types_1.TypeVarType.hasConstraints(destType)) {
+            isAssignable = assignConstrainedTypeVar(evaluator, destType, srcType, diag, constraints, flags, recursionCount);
         }
-        // If we're in "ignore type var scope" mode, don't generate
-        // an error in this path.
-        if ((flags & 1024 /* AssignTypeFlags.IgnoreTypeVarScope */) !== 0) {
-            return true;
+        else {
+            isAssignable = assignUnconstrainedTypeVar(evaluator, destType, srcType, diag, constraints, flags, recursionCount);
         }
-        isTypeVarInScope = false;
-        // Emit an error unless this is a synthesized type variable used
-        // for pseudo-generic classes.
-        if (!destType.shared.isSynthesized || destType.shared.isSynthesizedSelf) {
-            diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.typeAssignmentMismatch().format(evaluator.printSrcDestTypes(srcType, destType)));
-            return false;
+    }
+    if (logConstraintsUpdates) {
+        const indent = ' '.repeat(recursionCount * 2);
+        console.log(`${indent}`);
+        if (constraints) {
+            logConstraints(evaluator, constraints, indent);
+        }
+    }
+    return isAssignable;
+}
+// Returns a solution for the type variables tracked by the constraint tracker.
+function solveConstraints(evaluator, constraints, options) {
+    const solutionSets = [];
+    constraints.doForEachConstraintSet((constraintSet) => {
+        const solutionSet = solveConstraintSet(evaluator, constraintSet, options);
+        solutionSets.push(solutionSet);
+    });
+    return new constraintSolution_1.ConstraintSolution(solutionSets);
+}
+// Applies solved TypeVars from one context to this context.
+function applySourceSolutionToConstraints(constraints, srcSolution) {
+    if (srcSolution.isEmpty()) {
+        return;
+    }
+    constraints.doForEachConstraintSet((constraintSet) => {
+        constraintSet.getTypeVars().forEach((entry) => {
+            constraintSet.setBounds(entry.typeVar, entry.lowerBound ? (0, typeUtils_1.applySolvedTypeVars)(entry.lowerBound, srcSolution) : undefined, entry.upperBound ? (0, typeUtils_1.applySolvedTypeVars)(entry.upperBound, srcSolution) : undefined, entry.retainLiterals);
+        });
+    });
+}
+function solveConstraintSet(evaluator, constraintSet, options) {
+    const solutionSet = new constraintSolution_1.ConstraintSolutionSet(constraintSet.getScopeIds());
+    constraintSet.doForEachTypeVar((entry) => {
+        solveTypeVarRecursive(evaluator, constraintSet, options, solutionSet, entry);
+    });
+    return solutionSet;
+}
+function solveTypeVarRecursive(evaluator, constraintSet, options, solutionSet, entry) {
+    // If this TypeVar already has a solution, don't attempt to re-solve it.
+    if (solutionSet.hasType(entry.typeVar)) {
+        return solutionSet.getType(entry.typeVar);
+    }
+    // Protect against infinite recursion by setting the initial value to undefined.
+    solutionSet.setType(entry.typeVar, undefined);
+    let value = getTypeVarType(evaluator, constraintSet, entry.typeVar, options === null || options === void 0 ? void 0 : options.useLowerBoundOnly);
+    if (value) {
+        // Are there any unsolved TypeVars in this type?
+        const typeVars = (0, typeUtils_1.getTypeVarArgsRecursive)(value);
+        if (typeVars.length > 0) {
+            const dependentSolution = new constraintSolution_1.ConstraintSolution();
+            for (const typeVar of typeVars) {
+                // Don't attempt to replace a TypeVar with itself.
+                if ((0, types_1.isTypeSame)(typeVar, entry.typeVar, { ignoreTypeFlags: true })) {
+                    continue;
+                }
+                // Don't attempt to solve or replace bound TypeVars.
+                if (types_1.TypeVarType.isBound(typeVar)) {
+                    continue;
+                }
+                const dependentEntry = constraintSet.getTypeVar(typeVar);
+                if (!dependentEntry) {
+                    continue;
+                }
+                const dependentType = solveTypeVarRecursive(evaluator, constraintSet, options, solutionSet, dependentEntry);
+                if (dependentType) {
+                    dependentSolution.setType(typeVar, dependentType);
+                }
+            }
+            // Apply the dependent TypeVar values to the current TypeVar value.
+            if (!dependentSolution.isEmpty()) {
+                value = (0, typeUtils_1.applySolvedTypeVars)(value, dependentSolution);
+            }
         }
     }
-    // An in-scope placeholder TypeVar can always be assigned to itself,
-    // but we won't record this in the typeVarContext.
-    if ((0, types_1.isTypeSame)(destType, srcType) && destType.priv.isInScopePlaceholder) {
+    solutionSet.setType(entry.typeVar, value);
+    return value;
+}
+// In cases where the expected type is a specialized base class of the
+// source type, we need to determine which type arguments in the derived
+// class will make it compatible with the specialized base class. This method
+// performs this reverse mapping of type arguments and populates the type var
+// map for the target type. If the type is not assignable to the expected type,
+// it returns false.
+function addConstraintsForExpectedType(evaluator, type, expectedType, constraints, liveTypeVarScopes, usageOffset = undefined) {
+    if ((0, types_1.isAny)(expectedType)) {
+        type.shared.typeParams.forEach((typeParam) => {
+            constraints.setBounds(typeParam, expectedType, expectedType);
+        });
         return true;
     }
-    if ((flags & 8 /* AssignTypeFlags.SkipSolveTypeVars */) !== 0) {
-        return evaluator.assignType(evaluator.makeTopLevelTypeVarsConcrete(destType), evaluator.makeTopLevelTypeVarsConcrete(srcType), diag, 
-        /* destTypeVarContext */ undefined, 
-        /* srcTypeVarContext */ undefined, flags, recursionCount);
+    if ((0, types_1.isTypeVar)(expectedType) && types_1.TypeVarType.isSelf(expectedType) && expectedType.shared.boundType) {
+        expectedType = expectedType.shared.boundType;
     }
-    if ((0, types_1.isParamSpec)(destType)) {
-        return assignTypeToParamSpec(evaluator, destType, srcType, diag, typeVarContext, recursionCount);
+    if (!(0, types_1.isClass)(expectedType)) {
+        return false;
     }
-    if ((0, types_1.isTypeVarTuple)(destType) && !destType.priv.isVariadicInUnion) {
-        if (!(0, types_1.isUnpacked)(srcType)) {
-            const tupleClassType = evaluator.getTupleClassType();
-            if (tupleClassType && (0, types_1.isInstantiableClass)(tupleClassType)) {
-                // Package up the type into a tuple.
-                srcType = (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(tupleClassType, [{ type: srcType, isUnbounded: false }], 
-                /* isTypeArgExplicit */ true, 
-                /* isUnpackedTuple */ true));
+    // If the expected type is generic (but not specialized), we can't proceed.
+    const expectedTypeArgs = expectedType.priv.typeArgs;
+    if (!expectedTypeArgs) {
+        return evaluator.assignType(type, expectedType, 
+        /* diag */ undefined, constraints, 2048 /* AssignTypeFlags.PopulateExpectedType */);
+    }
+    evaluator.inferVarianceForClass(type);
+    // If the expected type is the same as the target type (commonly the case),
+    // we can use a faster method.
+    if (types_1.ClassType.isSameGenericClass(expectedType, type)) {
+        const solution = (0, typeUtils_1.buildSolutionFromSpecializedClass)(expectedType);
+        const typeParams = types_1.ClassType.getTypeParams(expectedType);
+        typeParams.forEach((typeParam) => {
+            let typeArgValue = solution.getMainSolutionSet().getType(typeParam);
+            if (typeArgValue && liveTypeVarScopes) {
+                typeArgValue = (0, typeUtils_1.transformExpectedType)(typeArgValue, liveTypeVarScopes, usageOffset);
             }
-            else {
-                srcType = types_1.UnknownType.create();
+            if (typeArgValue) {
+                const variance = types_1.TypeVarType.getVariance(typeParam);
+                constraints.setBounds(typeParam, variance === 3 /* Variance.Covariant */ ? undefined : typeArgValue, variance === 4 /* Variance.Contravariant */ ? undefined : typeArgValue);
+            }
+        });
+        return true;
+    }
+    // Create a generic version of the expected type.
+    const expectedTypeScopeId = (0, typeUtils_1.getTypeVarScopeId)(expectedType);
+    const synthExpectedTypeArgs = types_1.ClassType.getTypeParams(expectedType).map((typeParam, index) => {
+        const typeVar = types_1.TypeVarType.createInstance(`__dest${index}`, (0, types_1.isParamSpec)(typeParam) ? types_1.TypeVarKind.ParamSpec : types_1.TypeVarKind.TypeVar);
+        typeVar.shared.isSynthesized = true;
+        // Use invariance here so we set the lower and upper bound on the TypeVar.
+        typeVar.shared.declaredVariance = 2 /* Variance.Invariant */;
+        typeVar.priv.scopeId = expectedTypeScopeId;
+        return typeVar;
+    });
+    const genericExpectedType = types_1.ClassType.specialize(expectedType, synthExpectedTypeArgs);
+    // For each type param in the target type, create a placeholder type variable.
+    const typeArgs = types_1.ClassType.getTypeParams(type).map((typeParam, index) => {
+        const typeVar = types_1.TypeVarType.createInstance(`__source${index}`, (0, types_1.isParamSpec)(typeParam) ? types_1.TypeVarKind.ParamSpec : types_1.TypeVarKind.TypeVar);
+        typeVar.shared.isSynthesized = true;
+        typeVar.shared.synthesizedIndex = index;
+        typeVar.shared.isExemptFromBoundCheck = true;
+        return types_1.TypeVarType.cloneAsUnificationVar(typeVar);
+    });
+    const specializedType = types_1.ClassType.specialize(type, typeArgs);
+    const syntheticConstraints = new constraintTracker_1.ConstraintTracker();
+    if (evaluator.assignType(genericExpectedType, specializedType, 
+    /* diag */ undefined, syntheticConstraints, 2048 /* AssignTypeFlags.PopulateExpectedType */)) {
+        let isResultValid = true;
+        synthExpectedTypeArgs.forEach((typeVar, index) => {
+            let synthTypeVar = getTypeVarType(evaluator, syntheticConstraints.getMainConstraintSet(), typeVar);
+            const otherSubtypes = [];
+            // If the resulting type is a union, try to find a matching type var and move
+            // the remaining subtypes to the "otherSubtypes" array.
+            if (synthTypeVar) {
+                if ((0, types_1.isParamSpec)(typeVar) && (0, types_1.isFunction)(synthTypeVar)) {
+                    synthTypeVar = (0, typeUtils_1.simplifyFunctionToParamSpec)(synthTypeVar);
+                }
+                if ((0, types_1.isUnion)(synthTypeVar)) {
+                    let foundSynthTypeVar;
+                    (0, typeUtils_1.sortTypes)(synthTypeVar.priv.subtypes).forEach((subtype) => {
+                        if ((0, types_1.isTypeVar)(subtype) &&
+                            subtype.shared.isSynthesized &&
+                            subtype.shared.synthesizedIndex !== undefined &&
+                            !foundSynthTypeVar) {
+                            foundSynthTypeVar = subtype;
+                        }
+                        else {
+                            otherSubtypes.push(subtype);
+                        }
+                    });
+                    if (foundSynthTypeVar) {
+                        synthTypeVar = foundSynthTypeVar;
+                    }
+                }
+            }
+            // Is this one of the synthesized type vars we allocated above? If so,
+            // the type arg that corresponds to this type var maps back to the target type.
+            if (synthTypeVar &&
+                (0, types_1.isTypeVar)(synthTypeVar) &&
+                synthTypeVar.shared.isSynthesized &&
+                synthTypeVar.shared.synthesizedIndex !== undefined) {
+                const targetTypeVar = types_1.ClassType.getTypeParams(specializedType)[synthTypeVar.shared.synthesizedIndex];
+                if (index < expectedTypeArgs.length) {
+                    let typeArgValue = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(expectedTypeArgs[index]);
+                    if (otherSubtypes.length > 0) {
+                        typeArgValue = (0, types_1.combineTypes)([typeArgValue, ...otherSubtypes]);
+                    }
+                    if (liveTypeVarScopes) {
+                        typeArgValue = (0, typeUtils_1.transformExpectedType)(typeArgValue, liveTypeVarScopes, usageOffset);
+                    }
+                    if (typeArgValue) {
+                        const variance = types_1.TypeVarType.getVariance(typeVar);
+                        // If this type variable already has a type, don't overwrite it. This can
+                        // happen if a single type variable in the derived class is used multiple times
+                        // in the specialized base class type (e.g. Mapping[T, T]).
+                        if (constraints.getMainConstraintSet().getTypeVar(targetTypeVar)) {
+                            isResultValid = false;
+                            typeArgValue = types_1.UnknownType.create();
+                        }
+                        constraints.setBounds(targetTypeVar, variance === 3 /* Variance.Covariant */ ? undefined : typeArgValue, variance === 4 /* Variance.Contravariant */ ? undefined : typeArgValue);
+                    }
+                    else {
+                        isResultValid = false;
+                    }
+                }
+            }
+        });
+        return isResultValid;
+    }
+    return false;
+}
+function stripLiteralsForLowerBound(evaluator, typeVar, lowerBound) {
+    return (0, types_1.isTypeVarTuple)(typeVar)
+        ? stripLiteralValueForUnpackedTuple(evaluator, lowerBound)
+        : evaluator.stripLiteralValue(lowerBound);
+}
+function getTypeVarType(evaluator, constraintSet, typeVar, useLowerBoundOnly) {
+    const entry = constraintSet.getTypeVar(typeVar);
+    if (!entry) {
+        return undefined;
+    }
+    if ((0, types_1.isParamSpec)(typeVar)) {
+        if (!entry.lowerBound) {
+            return undefined;
+        }
+        if ((0, types_1.isFunction)(entry.lowerBound)) {
+            return entry.lowerBound;
+        }
+        if ((0, types_1.isAnyOrUnknown)(entry.lowerBound)) {
+            return types_1.ParamSpecType.getUnknown();
+        }
+    }
+    let result;
+    let lowerBound = entry.lowerBound;
+    if (lowerBound) {
+        if (!entry.retainLiterals) {
+            const lowerNoLiterals = stripLiteralsForLowerBound(evaluator, typeVar, lowerBound);
+            // If we can widen the lower bound to a non-literal type without
+            // exceeding the upper bound, use the widened type.
+            if (lowerNoLiterals !== lowerBound) {
+                if (!entry.upperBound || evaluator.assignType(entry.upperBound, lowerNoLiterals)) {
+                    if (types_1.TypeVarType.hasConstraints(typeVar)) {
+                        // Does it still match a value constraint?
+                        if (typeVar.shared.constraints.some((constraint) => (0, types_1.isTypeSame)(lowerNoLiterals, constraint))) {
+                            lowerBound = lowerNoLiterals;
+                        }
+                    }
+                    else {
+                        lowerBound = lowerNoLiterals;
+                    }
+                }
             }
         }
+        result = lowerBound;
+    }
+    else if (!useLowerBoundOnly) {
+        result = entry.upperBound;
+    }
+    return result;
+}
+// Handles an assignment to a TypeVar that is "bound" rather than "free".
+// In general, such assignments are not allowed, but there are some special
+// cases to be handled.
+function assignBoundTypeVar(evaluator, destType, srcType, diag, flags) {
+    // Handle Any as a source.
+    if ((0, types_1.isAnyOrUnknown)(srcType) || ((0, types_1.isClass)(srcType) && types_1.ClassType.derivesFromAnyOrUnknown(srcType))) {
+        return true;
+    }
+    // Is this the equivalent of an "Unknown" for a ParamSpec?
+    if ((0, types_1.isParamSpec)(destType) && (0, types_1.isFunction)(srcType) && types_1.FunctionType.isGradualCallableForm(srcType)) {
+        return true;
     }
-    // If we're assigning an unpacked TypeVarTuple to a regular TypeVar,
-    // we need to treat it as a union of the unpacked TypeVarTuple.
-    if ((0, types_1.isTypeVarTuple)(srcType) &&
-        srcType.priv.isVariadicUnpacked &&
-        !srcType.priv.isVariadicInUnion &&
-        !(0, types_1.isTypeVarTuple)(destType)) {
-        srcType = types_1.TypeVarType.cloneForUnpacked(srcType, /* isInUnion */ true);
+    // Never is always assignable in a covariant context.
+    const isCovariant = (flags & (1 /* AssignTypeFlags.Invariant */ | 2 /* AssignTypeFlags.Contravariant */)) === 0;
+    if ((0, types_1.isNever)(srcType) && isCovariant) {
+        return true;
     }
-    // Handle the constrained case. This case needs to be handled specially
-    // because type narrowing isn't used in this case. For example, if the
-    // source type is "Literal[1]" and the constraint list includes the type
-    // "float", the resulting type is float.
-    if (destType.shared.constraints.length > 0) {
-        return assignTypeToConstrainedTypeVar(evaluator, destType, srcType, diag, typeVarContext, flags, isTypeVarInScope, recursionCount);
+    // Handle a type[Any] as a source.
+    if ((0, types_1.isClassInstance)(srcType) && types_1.ClassType.isBuiltIn(srcType, 'type')) {
+        if (!srcType.priv.typeArgs || srcType.priv.typeArgs.length < 1 || (0, types_1.isAnyOrUnknown)(srcType.priv.typeArgs[0])) {
+            if (types_1.TypeBase.isInstantiable(destType)) {
+                return true;
+            }
+        }
     }
+    // Emit an error unless this is a synthesized type variable used
+    // for pseudo-generic classes.
+    if (!destType.shared.isSynthesized || types_1.TypeVarType.isSelf(destType)) {
+        diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.typeAssignmentMismatch().format(evaluator.printSrcDestTypes(srcType, destType)));
+    }
+    return false;
+}
+// Handles assignments to a TypeVarTuple or a TypeVar that does not have
+// value constraints (but may have an upper bound).
+function assignUnconstrainedTypeVar(evaluator, destType, srcType, diag, constraints, flags, recursionCount) {
+    const isInvariant = (flags & 1 /* AssignTypeFlags.Invariant */) !== 0;
+    const isContravariant = (flags & 2 /* AssignTypeFlags.Contravariant */) !== 0 && !isInvariant;
     // Handle the unconstrained (but possibly bound) case.
-    const curEntry = typeVarContext.getMainSolutionSet().getTypeVar(destType);
+    const curEntry = constraints === null || constraints === void 0 ? void 0 : constraints.getMainConstraintSet().getTypeVar(destType);
     let curUpperBound = curEntry === null || curEntry === void 0 ? void 0 : curEntry.upperBound;
-    if (!curUpperBound && !destType.shared.isSynthesizedSelf) {
+    if (!curUpperBound && !types_1.TypeVarType.isSelf(destType)) {
         curUpperBound = destType.shared.boundType;
     }
     let curLowerBound = curEntry === null || curEntry === void 0 ? void 0 : curEntry.lowerBound;
     let newLowerBound = curLowerBound;
-    let newUpperTypeBound = curUpperBound;
+    let newUpperBound = curUpperBound;
     const diagAddendum = diag ? new diagnostic_1.DiagnosticAddendum() : undefined;
     let adjSrcType = srcType;
     // If the source is a class that is missing type arguments, fill
@@ -180,7 +432,7 @@ function assignTypeToTypeVar(evaluator, destType, srcType, diag, typeVarContext,
         diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.typeAssignmentMismatch().format(evaluator.printSrcDestTypes(adjSrcType, destType)));
         return false;
     }
-    if ((flags & 2048 /* AssignTypeFlags.PopulatingExpectedType */) !== 0) {
+    if ((flags & 2048 /* AssignTypeFlags.PopulateExpectedType */) !== 0) {
         if ((flags & 4096 /* AssignTypeFlags.SkipPopulateUnknownExpectedType */) !== 0 && (0, types_1.isUnknown)(adjSrcType)) {
             return true;
         }
@@ -190,31 +442,29 @@ function assignTypeToTypeVar(evaluator, destType, srcType, diag, typeVarContext,
         if (!curEntry) {
             if (isInvariant) {
                 newLowerBound = adjSrcType;
-                newUpperTypeBound = adjSrcType;
+                newUpperBound = adjSrcType;
             }
             else if (isContravariant) {
                 newLowerBound = adjSrcType;
             }
             else {
-                newUpperTypeBound = adjSrcType;
+                newUpperBound = adjSrcType;
             }
         }
     }
     else if (isContravariant) {
         // Update the upper bound.
         if (!curUpperBound || (0, types_1.isTypeSame)(destType, curUpperBound)) {
-            newUpperTypeBound = adjSrcType;
+            newUpperBound = adjSrcType;
         }
         else if (!(0, types_1.isTypeSame)(curUpperBound, adjSrcType, {}, recursionCount)) {
             if (evaluator.assignType(curUpperBound, evaluator.makeTopLevelTypeVarsConcrete(adjSrcType), diagAddendum, 
-            /* destTypeVarContext */ undefined, 
-            /* srcTypeVarContext */ undefined, flags & 1024 /* AssignTypeFlags.IgnoreTypeVarScope */, recursionCount)) {
+            /* constraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount)) {
                 // The srcType is narrower than the current upper bound, so replace it.
-                newUpperTypeBound = adjSrcType;
+                newUpperBound = adjSrcType;
             }
             else if (!evaluator.assignType(adjSrcType, curUpperBound, diagAddendum, 
-            /* destTypeVarContext */ undefined, 
-            /* srcTypeVarContext */ undefined, flags & 1024 /* AssignTypeFlags.IgnoreTypeVarScope */, recursionCount)) {
+            /* constraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount)) {
                 if (diag && diagAddendum) {
                     diag.addMessage(localize_1.LocAddendum.typeAssignmentMismatch().format(evaluator.printSrcDestTypes(curUpperBound, adjSrcType)));
                     diag.addAddendum(diagAddendum);
@@ -224,12 +474,11 @@ function assignTypeToTypeVar(evaluator, destType, srcType, diag, typeVarContext,
         }
         // Make sure we haven't narrowed it beyond the current lower bound.
         if (curLowerBound) {
-            if (!evaluator.assignType(newUpperTypeBound, curLowerBound, 
+            if (!evaluator.assignType(newUpperBound, curLowerBound, 
             /* diag */ undefined, 
-            /* destTypeVarContext */ undefined, 
-            /* srcTypeVarContext */ undefined, flags & 1024 /* AssignTypeFlags.IgnoreTypeVarScope */, recursionCount)) {
+            /* constraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount)) {
                 if (diag && diagAddendum) {
-                    diag.addMessage(localize_1.LocAddendum.typeAssignmentMismatch().format(evaluator.printSrcDestTypes(curLowerBound, newUpperTypeBound)));
+                    diag.addMessage(localize_1.LocAddendum.typeAssignmentMismatch().format(evaluator.printSrcDestTypes(curLowerBound, newUpperBound)));
                     diag.addAddendum(diagAddendum);
                 }
                 return false;
@@ -245,31 +494,31 @@ function assignTypeToTypeVar(evaluator, destType, srcType, diag, typeVarContext,
             // If this is an invariant context and there is currently no upper bound
             // established, use the "no literals" version of the lower bound rather
             // than a version that has literals.
-            if (!newUpperTypeBound && isInvariant && (curEntry === null || curEntry === void 0 ? void 0 : curEntry.lowerBoundNoLiterals)) {
-                newLowerBound = curEntry.lowerBoundNoLiterals;
+            if (!newUpperBound && isInvariant && curEntry && !curEntry.retainLiterals) {
+                newLowerBound = stripLiteralsForLowerBound(evaluator, destType, curLowerBound);
             }
         }
         else {
-            if (evaluator.assignType(curLowerBound, adjSrcType, diagAddendum, typeVarContext, 
-            /* srcTypeVarContext */ undefined, flags, recursionCount)) {
+            if (evaluator.assignType(curLowerBound, adjSrcType, diagAddendum, constraints, flags, recursionCount)) {
                 // No need to widen. Stick with the existing type unless it's unknown
                 // or partly unknown, in which case we'll replace it with a known type
                 // as long as it doesn't violate the current lower bound.
                 if ((0, typeUtils_1.isPartlyUnknown)(curLowerBound) &&
                     !(0, types_1.isUnknown)(adjSrcType) &&
                     evaluator.assignType(adjSrcType, curLowerBound, 
-                    /* diag */ undefined, typeVarContext, 
-                    /* srcTypeVarContext */ undefined, flags & 1024 /* AssignTypeFlags.IgnoreTypeVarScope */, recursionCount)) {
+                    /* diag */ undefined, constraints, 0 /* AssignTypeFlags.Default */, recursionCount)) {
                     newLowerBound = adjSrcType;
                 }
                 else {
-                    newLowerBound = (0, typeUtils_1.applySolvedTypeVars)(curLowerBound, typeVarContext);
+                    newLowerBound = curLowerBound;
+                    if (constraints) {
+                        newLowerBound = evaluator.solveAndApplyConstraints(newLowerBound, constraints);
+                    }
                 }
             }
             else if ((0, types_1.isTypeVar)(curLowerBound) &&
                 !(0, types_1.isTypeVar)(adjSrcType) &&
-                evaluator.assignType(evaluator.makeTopLevelTypeVarsConcrete(curLowerBound), adjSrcType, diagAddendum, typeVarContext, 
-                /* srcTypeVarContext */ undefined, flags, recursionCount)) {
+                evaluator.assignType(evaluator.makeTopLevelTypeVarsConcrete(curLowerBound), adjSrcType, diagAddendum, constraints, flags, recursionCount)) {
                 // If the existing lower bound was a TypeVar that is not
                 // part of the current context we can replace it with the new
                 // source type.
@@ -277,13 +526,12 @@ function assignTypeToTypeVar(evaluator, destType, srcType, diag, typeVarContext,
             }
             else {
                 // We need to widen the type.
-                if (typeVarContext.isLocked()) {
+                if (constraints === null || constraints === void 0 ? void 0 : constraints.isLocked()) {
                     diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.typeAssignmentMismatch().format(evaluator.printSrcDestTypes(adjSrcType, curLowerBound)));
                     return false;
                 }
                 if (evaluator.assignType(adjSrcType, curLowerBound, 
-                /* diag */ undefined, typeVarContext, 
-                /* srcTypeVarContext */ undefined, flags & 1024 /* AssignTypeFlags.IgnoreTypeVarScope */, recursionCount)) {
+                /* diag */ undefined, constraints, 0 /* AssignTypeFlags.Default */, recursionCount)) {
                     newLowerBound = adjSrcType;
                 }
                 else if ((0, types_1.isTypeVarTuple)(destType)) {
@@ -299,10 +547,13 @@ function assignTypeToTypeVar(evaluator, destType, srcType, diag, typeVarContext,
                     // If this is an invariant context and there is currently no upper bound
                     // established, use the "no literals" version of the lower bound rather
                     // than a version that has literals.
-                    if (!newUpperTypeBound && isInvariant && (curEntry === null || curEntry === void 0 ? void 0 : curEntry.lowerBoundNoLiterals)) {
-                        curLowerBound = curEntry.lowerBoundNoLiterals;
+                    if (!newUpperBound && isInvariant && curEntry && !curEntry.retainLiterals) {
+                        curLowerBound = stripLiteralsForLowerBound(evaluator, destType, curLowerBound);
+                    }
+                    let curSolvedLowerBound = curLowerBound;
+                    if (constraints) {
+                        curSolvedLowerBound = evaluator.solveAndApplyConstraints(curLowerBound, constraints);
                     }
-                    const curSolvedLowerBound = (0, typeUtils_1.applySolvedTypeVars)(curLowerBound, typeVarContext);
                     // In some extreme edge cases, the lower bound can become
                     // a union with so many subtypes that performance grinds to a
                     // halt. We'll detect this case and widen the resulting type
@@ -310,7 +561,7 @@ function assignTypeToTypeVar(evaluator, destType, srcType, diag, typeVarContext,
                     // is still a valid solution to the TypeVar.
                     if ((0, types_1.isUnion)(curSolvedLowerBound) &&
                         curSolvedLowerBound.priv.subtypes.length > typeEvaluatorTypes_1.maxSubtypesForInferredType &&
-                        destType.shared.boundType !== undefined &&
+                        types_1.TypeVarType.hasBound(destType) &&
                         (0, types_1.isClassInstance)(objectType)) {
                         newLowerBound = (0, types_1.combineTypes)([curSolvedLowerBound, objectType], {
                             maxSubtypeCount: maxSubtypeCountForTypeVarLowerBound,
@@ -328,8 +579,7 @@ function assignTypeToTypeVar(evaluator, destType, srcType, diag, typeVarContext,
         // isn't too wide.
         if (isInvariant && newLowerBound) {
             if (!evaluator.assignType(adjSrcType, newLowerBound, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), 
-            /* destTypeVarContext */ undefined, 
-            /* srcTypeVarContext */ undefined, 1024 /* AssignTypeFlags.IgnoreTypeVarScope */, recursionCount)) {
+            /* constraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount)) {
                 if (diag && diagAddendum) {
                     diag.addMessage(localize_1.LocAddendum.typeAssignmentMismatch().format(evaluator.printSrcDestTypes(newLowerBound, adjSrcType)));
                 }
@@ -339,44 +589,33 @@ function assignTypeToTypeVar(evaluator, destType, srcType, diag, typeVarContext,
         // Make sure we don't exceed the upper bound.
         if (curUpperBound && newLowerBound) {
             if (!(0, types_1.isTypeSame)(curUpperBound, newLowerBound, {}, recursionCount)) {
-                let adjUpperBound = evaluator.makeTopLevelTypeVarsConcrete(curUpperBound, 
-                /* makeParamSpecsConcrete */ true);
-                // Convert any remaining (non-top-level) TypeVars in the upper
-                // bound to in-scope placeholders.
-                adjUpperBound = (0, typeUtils_1.transformExpectedType)(adjUpperBound, 
-                /* liveTypeVarScopes */ [], 
-                /* usageOffset */ undefined);
-                if (!evaluator.assignType(adjUpperBound, newLowerBound, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), 
-                /* destTypeVarContext */ undefined, 
-                /* srcTypeVarContext */ undefined, 1024 /* AssignTypeFlags.IgnoreTypeVarScope */, recursionCount)) {
+                if (!evaluator.assignType(curUpperBound, newLowerBound, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), 
+                /* constraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount)) {
                     if (diag && diagAddendum) {
-                        diag.addMessage(localize_1.LocAddendum.typeAssignmentMismatch().format(evaluator.printSrcDestTypes(newLowerBound, adjUpperBound)));
+                        diag.addMessage(localize_1.LocAddendum.typeAssignmentMismatch().format(evaluator.printSrcDestTypes(newLowerBound, curUpperBound)));
                     }
                     return false;
                 }
             }
         }
     }
-    if (!newUpperTypeBound && isInvariant) {
-        newUpperTypeBound = newLowerBound;
+    if (!newUpperBound && isInvariant) {
+        newUpperBound = newLowerBound;
     }
     // If there's a bound type, make sure the source is assignable to it.
     if (destType.shared.boundType) {
-        const updatedType = (newLowerBound || newUpperTypeBound);
+        const updatedType = (newLowerBound || newUpperBound);
         // If the dest is a Type[T] but the source is not a valid Type,
         // skip the assignType check and the diagnostic addendum, which will
         // be confusing and inaccurate.
-        if (types_1.TypeBase.isInstantiable(destType) && !types_1.TypeBase.isInstantiable(srcType)) {
+        if (types_1.TypeBase.isInstantiable(destType) && !(0, typeUtils_1.isEffectivelyInstantiable)(srcType)) {
             return false;
         }
         // In general, bound types cannot be generic, but the "Self" type is an
-        // exception. In this case, we need to use the original TypeVarContext
+        // exception. In this case, we need to use the original constraints
         // to solve for the generic type variable(s) in the bound type.
-        const effectiveTypeVarContext = destType.shared.isSynthesizedSelf
-            ? typeVarContext
-            : new typeVarContext_1.TypeVarContext(destType.priv.scopeId);
-        if (!evaluator.assignType(destType.shared.boundType, evaluator.makeTopLevelTypeVarsConcrete(updatedType), diag === null || diag === void 0 ? void 0 : diag.createAddendum(), effectiveTypeVarContext, 
-        /* srcTypeVarContext */ undefined, flags & 1024 /* AssignTypeFlags.IgnoreTypeVarScope */, recursionCount)) {
+        const effectiveConstraints = types_1.TypeVarType.isSelf(destType) ? constraints : undefined;
+        if (!evaluator.assignType(destType.shared.boundType, evaluator.makeTopLevelTypeVarsConcrete(updatedType), diag === null || diag === void 0 ? void 0 : diag.createAddendum(), effectiveConstraints, 0 /* AssignTypeFlags.Default */, recursionCount)) {
             // Avoid adding a message that will confuse users if the TypeVar was
             // synthesized for internal purposes.
             if (!destType.shared.isSynthesized) {
@@ -389,50 +628,23 @@ function assignTypeToTypeVar(evaluator, destType, srcType, diag, typeVarContext,
             return false;
         }
     }
-    if (!typeVarContext.isLocked() && isTypeVarInScope) {
-        updateTypeVarType(evaluator, typeVarContext, destType, newLowerBound, newUpperTypeBound, (flags & (2048 /* AssignTypeFlags.PopulatingExpectedType */ | 256 /* AssignTypeFlags.RetainLiteralsForTypeVar */)) !== 0);
-    }
-    if (logTypeVarContextUpdates) {
-        const indent = ' '.repeat(recursionCount * 2);
-        console.log(`${indent}`);
-        logTypeVarContext(evaluator, typeVarContext, indent);
+    if (constraints && !constraints.isLocked()) {
+        constraints.setBounds(destType, newLowerBound, newUpperBound, (flags & (2048 /* AssignTypeFlags.PopulateExpectedType */ | 256 /* AssignTypeFlags.RetainLiteralsForTypeVar */)) !== 0);
     }
     return true;
 }
-exports.assignTypeToTypeVar = assignTypeToTypeVar;
-// Updates the lower and upper bounds for a type variable. It also calculates the
-// lowerBoundNoLiterals, which is a variant of the lower bound that has
-// literals stripped. By default, the constraint solver always uses the "no literals"
-// type in its solutions unless the version with literals is required to satisfy
-// the upper bound.
-function updateTypeVarType(evaluator, typeVarContext, destType, lowerBound, upperBound, forceRetainLiterals = false) {
-    let lowerBoundNoLiterals;
-    if (lowerBound && !forceRetainLiterals) {
-        const strippedLiteral = (0, types_1.isTypeVarTuple)(destType)
-            ? stripLiteralValueForUnpackedTuple(evaluator, lowerBound)
-            : evaluator.stripLiteralValue(lowerBound);
-        // Strip the literals from the lower bound and see if it is still
-        // narrower than the upper bound.
-        if (strippedLiteral !== lowerBound) {
-            if (!upperBound || evaluator.assignType(upperBound, strippedLiteral)) {
-                lowerBoundNoLiterals = strippedLiteral;
-            }
-        }
-    }
-    typeVarContext.setTypeVarType(destType, lowerBound, lowerBoundNoLiterals, upperBound); //, tupleTypes);
-}
-exports.updateTypeVarType = updateTypeVarType;
-function assignTypeToConstrainedTypeVar(evaluator, destType, srcType, diag, typeVarContext, flags, isTypeVarInScope, recursionCount) {
+// Handles assignments to a TypeVar with value constraints.
+function assignConstrainedTypeVar(evaluator, destType, srcType, diag, constraints, flags, recursionCount) {
     let constrainedType;
     const concreteSrcType = evaluator.makeTopLevelTypeVarsConcrete(srcType);
-    const curEntry = typeVarContext.getMainSolutionSet().getTypeVar(destType);
+    const curEntry = constraints === null || constraints === void 0 ? void 0 : constraints.getMainConstraintSet().getTypeVar(destType);
     const curUpperBound = curEntry === null || curEntry === void 0 ? void 0 : curEntry.upperBound;
     const curLowerBound = curEntry === null || curEntry === void 0 ? void 0 : curEntry.lowerBound;
-    let forceRetainLiterals = false;
+    let retainLiterals = false;
     if ((0, types_1.isTypeVar)(srcType)) {
         if (evaluator.assignType(destType, concreteSrcType, 
-        /* diag */ undefined, new typeVarContext_1.TypeVarContext(destType.priv.scopeId), 
-        /* srcTypeVarContext */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount)) {
+        /* diag */ undefined, 
+        /* constraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount)) {
             constrainedType = srcType;
             // If the source and dest are both instantiables (type[T]), then
             // we need to convert to an instance (T).
@@ -460,15 +672,13 @@ function assignTypeToConstrainedTypeVar(evaluator, destType, srcType, diag, type
                     : constraint;
                 if (evaluator.assignType(adjustedConstraint, srcSubtype, 
                 /* diag */ undefined, 
-                /* destTypeVarContext */ undefined, 
-                /* srcTypeVarContext */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount)) {
+                /* constraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount)) {
                     if (!constrainedSubtype ||
                         evaluator.assignType(types_1.TypeBase.isInstantiable(destType)
                             ? (0, typeUtils_1.convertToInstantiable)(constrainedSubtype)
                             : constrainedSubtype, adjustedConstraint, 
                         /* diag */ undefined, 
-                        /* destTypeVarContext */ undefined, 
-                        /* srcTypeVarContext */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount)) {
+                        /* constraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount)) {
                         constrainedSubtype = (0, typeUtils_1.addConditionToType)(constraint, (0, typeUtils_1.getTypeCondition)(srcSubtype));
                         constraintIndexUsed = i;
                     }
@@ -478,7 +688,7 @@ function assignTypeToConstrainedTypeVar(evaluator, destType, srcType, diag, type
                 // We found a source subtype that is not compatible with the dest.
                 // This is OK if we're handling the contravariant case because only
                 // one subtype needs to be assignable in that case.
-                if ((flags & 2 /* AssignTypeFlags.ReverseTypeVarMatching */) === 0) {
+                if ((flags & 2 /* AssignTypeFlags.Contravariant */) === 0) {
                     isCompatible = false;
                 }
             }
@@ -505,8 +715,7 @@ function assignTypeToConstrainedTypeVar(evaluator, destType, srcType, diag, type
                     : constraint;
                 return evaluator.assignType(adjustedConstraint, concreteSrcType, 
                 /* diag */ undefined, 
-                /* destTypeVarContext */ undefined, 
-                /* srcTypeVarContext */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount);
+                /* constraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount);
             });
         }
     }
@@ -521,22 +730,20 @@ function assignTypeToConstrainedTypeVar(evaluator, destType, srcType, diag, type
         return false;
     }
     else if ((0, typeUtils_1.isLiteralTypeOrUnion)(constrainedType)) {
-        forceRetainLiterals = true;
+        retainLiterals = true;
     }
     if (curLowerBound && !(0, types_1.isAnyOrUnknown)(curLowerBound)) {
         if (!evaluator.assignType(curLowerBound, constrainedType, 
         /* diag */ undefined, 
-        /* destTypeVarContext */ undefined, 
-        /* srcTypeVarContext */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount)) {
+        /* constraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount)) {
             // Handle the case where one of the constrained types is a wider
             // version of another constrained type that was previously assigned
             // to the type variable.
             if (evaluator.assignType(constrainedType, curLowerBound, 
             /* diag */ undefined, 
-            /* destTypeVarContext */ undefined, 
-            /* srcTypeVarContext */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount)) {
-                if (!typeVarContext.isLocked() && isTypeVarInScope) {
-                    updateTypeVarType(evaluator, typeVarContext, destType, constrainedType, curUpperBound);
+            /* constraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount)) {
+                if (constraints && !constraints.isLocked()) {
+                    constraints.setBounds(destType, constrainedType, curUpperBound);
                 }
             }
             else {
@@ -550,21 +757,32 @@ function assignTypeToConstrainedTypeVar(evaluator, destType, srcType, diag, type
     }
     else {
         // Assign the type to the type var.
-        if (!typeVarContext.isLocked() && isTypeVarInScope) {
-            updateTypeVarType(evaluator, typeVarContext, destType, constrainedType, curUpperBound, forceRetainLiterals);
+        if (constraints && !constraints.isLocked()) {
+            constraints.setBounds(destType, constrainedType, curUpperBound, retainLiterals);
         }
     }
     return true;
 }
-function assignTypeToParamSpec(evaluator, destType, srcType, diag, typeVarContext, recursionCount = 0) {
+// Handles assignments to a ParamSpec.
+function assignParamSpec(evaluator, destType, srcType, diag, constraints, recursionCount = 0) {
+    // If there is no constraint tracker, there's nothing to do because
+    // param specs have no upper bounds or constraints.
+    if (!constraints) {
+        return true;
+    }
     let isAssignable = true;
-    const adjSrcType = (0, types_1.isFunction)(srcType) ? (0, typeUtils_1.convertParamSpecValueToType)(srcType) : srcType;
-    typeVarContext.doForEachSolutionSet((solutionSet) => {
+    let adjSrcType = (0, types_1.isParamSpec)(srcType) ? srcType : (0, typeUtils_1.convertTypeToParamSpecValue)(srcType);
+    if ((0, types_1.isFunction)(adjSrcType)) {
+        adjSrcType = (0, typeUtils_1.simplifyFunctionToParamSpec)(adjSrcType);
+    }
+    constraints.doForEachConstraintSet((constraintSet) => {
+        var _a, _b;
         if ((0, types_1.isParamSpec)(adjSrcType)) {
-            const existingType = solutionSet.getTypeVarType(destType);
+            const existingType = (_a = constraintSet.getTypeVar(destType)) === null || _a === void 0 ? void 0 : _a.lowerBound;
             if (existingType) {
-                const existingTypeParamSpec = types_1.FunctionType.getParamSpecFromArgsKwargs(existingType);
-                const existingTypeWithoutArgsKwargs = types_1.FunctionType.cloneRemoveParamSpecArgsKwargs(existingType);
+                const paramSpecValue = (0, typeUtils_1.convertTypeToParamSpecValue)(existingType);
+                const existingTypeParamSpec = types_1.FunctionType.getParamSpecFromArgsKwargs(paramSpecValue);
+                const existingTypeWithoutArgsKwargs = types_1.FunctionType.cloneRemoveParamSpecArgsKwargs(paramSpecValue);
                 if (existingTypeWithoutArgsKwargs.shared.parameters.length === 0 && existingTypeParamSpec) {
                     // If there's an existing entry that matches, that's fine.
                     if ((0, types_1.isTypeSame)(existingTypeParamSpec, adjSrcType, {}, recursionCount)) {
@@ -573,8 +791,8 @@ function assignTypeToParamSpec(evaluator, destType, srcType, diag, typeVarContex
                 }
             }
             else {
-                if (!typeVarContext.isLocked() && typeVarContext.hasSolveForScope(destType.priv.scopeId)) {
-                    solutionSet.setTypeVarType(destType, (0, typeUtils_1.convertTypeToParamSpecValue)(adjSrcType));
+                if (!constraints.isLocked()) {
+                    constraintSet.setBounds(destType, adjSrcType);
                 }
                 return;
             }
@@ -582,19 +800,17 @@ function assignTypeToParamSpec(evaluator, destType, srcType, diag, typeVarContex
         else if ((0, types_1.isFunction)(adjSrcType)) {
             const newFunction = adjSrcType;
             let updateContextWithNewFunction = false;
-            const existingType = solutionSet.getTypeVarType(destType);
+            const existingType = (_b = constraintSet.getTypeVar(destType)) === null || _b === void 0 ? void 0 : _b.lowerBound;
             if (existingType) {
                 // Convert the remaining portion of the signature to a function
                 // for comparison purposes.
-                const existingFunction = (0, typeUtils_1.convertParamSpecValueToType)(existingType);
+                const existingFunction = (0, typeUtils_1.simplifyFunctionToParamSpec)((0, typeUtils_1.convertTypeToParamSpecValue)(existingType));
                 const isNewNarrower = evaluator.assignType(existingFunction, newFunction, 
                 /* diag */ undefined, 
-                /* destTypeVarContext */ undefined, 
-                /* srcTypeVarContext */ undefined, 64 /* AssignTypeFlags.SkipReturnTypeCheck */, recursionCount);
+                /* constraints */ undefined, 64 /* AssignTypeFlags.SkipReturnTypeCheck */, recursionCount);
                 const isNewWider = evaluator.assignType(newFunction, existingFunction, 
                 /* diag */ undefined, 
-                /* destTypeVarContext */ undefined, 
-                /* srcTypeVarContext */ undefined, 64 /* AssignTypeFlags.SkipReturnTypeCheck */, recursionCount);
+                /* constraints */ undefined, 64 /* AssignTypeFlags.SkipReturnTypeCheck */, recursionCount);
                 // Should we widen the type?
                 if (isNewNarrower && isNewWider) {
                     // The new type is both a supertype and a subtype of the existing type.
@@ -622,8 +838,8 @@ function assignTypeToParamSpec(evaluator, destType, srcType, diag, typeVarContex
                 updateContextWithNewFunction = true;
             }
             if (updateContextWithNewFunction) {
-                if (!typeVarContext.isLocked() && typeVarContext.hasSolveForScope(destType.priv.scopeId)) {
-                    solutionSet.setTypeVarType(destType, newFunction);
+                if (!constraints.isLocked()) {
+                    constraintSet.setBounds(destType, newFunction);
                 }
                 return;
             }
@@ -637,149 +853,8 @@ function assignTypeToParamSpec(evaluator, destType, srcType, diag, typeVarContex
         }));
         isAssignable = false;
     });
-    if (logTypeVarContextUpdates) {
-        const indent = ' '.repeat(recursionCount * 2);
-        console.log(`${indent}`);
-        console.log(`${indent}post-call typeVarContext: `);
-        logTypeVarContext(evaluator, typeVarContext, indent);
-    }
     return isAssignable;
 }
-// In cases where the expected type is a specialized base class of the
-// source type, we need to determine which type arguments in the derived
-// class will make it compatible with the specialized base class. This method
-// performs this reverse mapping of type arguments and populates the type var
-// map for the target type. If the type is not assignable to the expected type,
-// it returns false.
-function addConstraintsForExpectedType(evaluator, type, expectedType, typeVarContext, liveTypeVarScopes, usageOffset = undefined) {
-    if ((0, types_1.isAny)(expectedType)) {
-        type.shared.typeParams.forEach((typeParam) => {
-            updateTypeVarType(evaluator, typeVarContext, typeParam, expectedType, expectedType);
-        });
-        return true;
-    }
-    if ((0, types_1.isTypeVar)(expectedType) && expectedType.shared.isSynthesizedSelf && expectedType.shared.boundType) {
-        expectedType = expectedType.shared.boundType;
-    }
-    if (!(0, types_1.isClass)(expectedType)) {
-        return false;
-    }
-    // If the expected type is generic (but not specialized), we can't proceed.
-    const expectedTypeArgs = expectedType.priv.typeArgs;
-    if (!expectedTypeArgs) {
-        return evaluator.assignType(type, expectedType, 
-        /* diag */ undefined, typeVarContext, 
-        /* srcTypeVarContext */ undefined, 2048 /* AssignTypeFlags.PopulatingExpectedType */);
-    }
-    evaluator.inferVarianceForClass(type);
-    // If the expected type is the same as the target type (commonly the case),
-    // we can use a faster method.
-    if (types_1.ClassType.isSameGenericClass(expectedType, type)) {
-        const sameClassTypeVarContext = (0, typeUtils_1.buildTypeVarContextFromSpecializedClass)(expectedType);
-        sameClassTypeVarContext
-            .getMainSolutionSet()
-            .getTypeVars()
-            .forEach((entry) => {
-            let typeArgValue = sameClassTypeVarContext.getMainSolutionSet().getTypeVarType(entry.typeVar);
-            if (typeArgValue && liveTypeVarScopes) {
-                typeArgValue = (0, typeUtils_1.transformExpectedType)(typeArgValue, liveTypeVarScopes, usageOffset);
-            }
-            if (typeArgValue) {
-                const variance = types_1.TypeVarType.getVariance(entry.typeVar);
-                updateTypeVarType(evaluator, typeVarContext, entry.typeVar, variance === 3 /* Variance.Covariant */ ? undefined : typeArgValue, variance === 4 /* Variance.Contravariant */ ? undefined : typeArgValue);
-            }
-        });
-        return true;
-    }
-    // Create a generic version of the expected type.
-    const expectedTypeScopeId = (0, typeUtils_1.getTypeVarScopeId)(expectedType);
-    const synthExpectedTypeArgs = types_1.ClassType.getTypeParams(expectedType).map((typeParam, index) => {
-        const typeVar = types_1.TypeVarType.createInstance(`__dest${index}`, (0, types_1.isParamSpec)(typeParam) ? types_1.TypeVarKind.ParamSpec : types_1.TypeVarKind.TypeVar);
-        typeVar.shared.isSynthesized = true;
-        // Use invariance here so we set the lower and upper bound on the TypeVar.
-        typeVar.shared.declaredVariance = 2 /* Variance.Invariant */;
-        typeVar.priv.scopeId = expectedTypeScopeId;
-        return typeVar;
-    });
-    const genericExpectedType = types_1.ClassType.specialize(expectedType, synthExpectedTypeArgs);
-    // For each type param in the target type, create a placeholder type variable.
-    const typeArgs = types_1.ClassType.getTypeParams(type).map((typeParam, index) => {
-        const typeVar = types_1.TypeVarType.createInstance(`__source${index}`, (0, types_1.isParamSpec)(typeParam) ? types_1.TypeVarKind.ParamSpec : types_1.TypeVarKind.TypeVar);
-        typeVar.shared.isSynthesized = true;
-        typeVar.shared.synthesizedIndex = index;
-        typeVar.shared.isExemptFromBoundCheck = true;
-        return types_1.TypeVarType.cloneAsInScopePlaceholder(typeVar);
-    });
-    const specializedType = types_1.ClassType.specialize(type, typeArgs);
-    const syntheticTypeVarContext = new typeVarContext_1.TypeVarContext(expectedTypeScopeId);
-    if (evaluator.assignType(genericExpectedType, specializedType, 
-    /* diag */ undefined, syntheticTypeVarContext, 
-    /* srcTypeVarContext */ undefined, 2048 /* AssignTypeFlags.PopulatingExpectedType */)) {
-        let isResultValid = true;
-        synthExpectedTypeArgs.forEach((typeVar, index) => {
-            let synthTypeVar = syntheticTypeVarContext.getMainSolutionSet().getTypeVarType(typeVar);
-            const otherSubtypes = [];
-            // If the resulting type is a union, try to find a matching type var and move
-            // the remaining subtypes to the "otherSubtypes" array.
-            if (synthTypeVar) {
-                if ((0, types_1.isParamSpec)(typeVar) && (0, types_1.isFunction)(synthTypeVar)) {
-                    synthTypeVar = (0, typeUtils_1.convertParamSpecValueToType)(synthTypeVar);
-                }
-                if ((0, types_1.isUnion)(synthTypeVar)) {
-                    let foundSynthTypeVar;
-                    (0, typeUtils_1.sortTypes)(synthTypeVar.priv.subtypes).forEach((subtype) => {
-                        if ((0, types_1.isTypeVar)(subtype) &&
-                            subtype.shared.isSynthesized &&
-                            subtype.shared.synthesizedIndex !== undefined &&
-                            !foundSynthTypeVar) {
-                            foundSynthTypeVar = subtype;
-                        }
-                        else {
-                            otherSubtypes.push(subtype);
-                        }
-                    });
-                    if (foundSynthTypeVar) {
-                        synthTypeVar = foundSynthTypeVar;
-                    }
-                }
-            }
-            // Is this one of the synthesized type vars we allocated above? If so,
-            // the type arg that corresponds to this type var maps back to the target type.
-            if (synthTypeVar &&
-                (0, types_1.isTypeVar)(synthTypeVar) &&
-                synthTypeVar.shared.isSynthesized &&
-                synthTypeVar.shared.synthesizedIndex !== undefined) {
-                const targetTypeVar = types_1.ClassType.getTypeParams(specializedType)[synthTypeVar.shared.synthesizedIndex];
-                if (index < expectedTypeArgs.length) {
-                    let typeArgValue = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(expectedTypeArgs[index]);
-                    if (otherSubtypes.length > 0) {
-                        typeArgValue = (0, types_1.combineTypes)([typeArgValue, ...otherSubtypes]);
-                    }
-                    if (liveTypeVarScopes) {
-                        typeArgValue = (0, typeUtils_1.transformExpectedType)(typeArgValue, liveTypeVarScopes, usageOffset);
-                    }
-                    if (typeArgValue) {
-                        const variance = types_1.TypeVarType.getVariance(typeVar);
-                        // If this type variable already has a type, don't overwrite it. This can
-                        // happen if a single type variable in the derived class is used multiple times
-                        // in the specialized base class type (e.g. Mapping[T, T]).
-                        if (typeVarContext.getMainSolutionSet().getTypeVarType(targetTypeVar)) {
-                            isResultValid = false;
-                            typeArgValue = types_1.UnknownType.create();
-                        }
-                        updateTypeVarType(evaluator, typeVarContext, targetTypeVar, variance === 3 /* Variance.Covariant */ ? undefined : typeArgValue, variance === 4 /* Variance.Contravariant */ ? undefined : typeArgValue);
-                    }
-                    else {
-                        isResultValid = false;
-                    }
-                }
-            }
-        });
-        return isResultValid;
-    }
-    return false;
-}
-exports.addConstraintsForExpectedType = addConstraintsForExpectedType;
 // For normal TypeVars, the constraint solver can widen a type by combining
 // two otherwise incompatible types into a union. For TypeVarTuples, we need
 // to do the equivalent operation for unpacked tuples.
@@ -829,28 +904,27 @@ function stripLiteralValueForUnpackedTuple(evaluator, type) {
     return (0, typeUtils_1.specializeTupleClass)(type, tupleTypeArgs, /* isTypeArgExplicit */ true, /* isUnpackedTuple */ true);
 }
 // This function is used for debugging only. It dumps the current contents of
-// the TypeVarContext to the console.
-function logTypeVarContext(evaluator, typeVarContext, indent) {
-    const solutionSetCount = typeVarContext.getSolutionSets().length;
-    if (solutionSetCount === 0) {
+// the constraints to the console.
+function logConstraints(evaluator, constraints, indent) {
+    const constraintSetCount = constraints.getConstraintSets().length;
+    if (constraintSetCount === 0) {
         console.log(`${indent}  no signatures`);
     }
-    else if (solutionSetCount === 1) {
-        logTypeVarSolutionSet(evaluator, typeVarContext.getSolutionSets()[0], `${indent}  `);
+    else if (constraintSetCount === 1) {
+        logTypeVarConstraintSet(evaluator, constraints.getConstraintSets()[0], `${indent}  `);
     }
     else {
-        typeVarContext.doForEachSolutionSet((solutionSet, index) => {
+        constraints.doForEachConstraintSet((set, index) => {
             console.log(`${indent}  signature ${index}`);
-            logTypeVarSolutionSet(evaluator, solutionSet, `${indent}    `);
+            logTypeVarConstraintSet(evaluator, set, `${indent}    `);
         });
     }
 }
-function logTypeVarSolutionSet(evaluator, context, indent) {
+function logTypeVarConstraintSet(evaluator, context, indent) {
     let loggedConstraint = false;
     context.getTypeVars().forEach((entry) => {
-        var _a;
         const typeVarName = `${indent}${entry.typeVar.shared.name}`;
-        const lowerBound = (_a = entry.lowerBoundNoLiterals) !== null && _a !== void 0 ? _a : entry.lowerBound;
+        const lowerBound = entry.lowerBound;
         const upperBound = entry.upperBound;
         // Log the lower and upper bounds.
         if (lowerBound && upperBound && (0, types_1.isTypeSame)(lowerBound, upperBound)) {