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

package/dist/analyzer/constraintSolver.js

@@ -10,140 +10,372 @@
  *
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.addConstraintsForExpectedType = exports.updateTypeVarType = exports.assignTypeToTypeVar = void 0;
+exports.applyUnificationVars = exports.addConstraintsForExpectedType = exports.updateTypeVarType = exports.solveConstraintSet = exports.solveConstraints = exports.assignTypeVar = void 0;
 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);
         }
     }
-    // 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) {
+    return isAssignable;
+}
+exports.assignTypeVar = assignTypeVar;
+// 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);
+}
+exports.solveConstraints = solveConstraints;
+function solveConstraintSet(evaluator, constraintSet, options) {
+    const solutionSet = new constraintSolution_1.ConstraintSolutionSet(constraintSet.getScopeIds());
+    constraintSet.doForEachTypeVar((entry) => {
+        const value = getTypeVarType(evaluator, constraintSet, entry.typeVar, options === null || options === void 0 ? void 0 : options.useLowerBoundOnly);
+        if (value) {
+            solutionSet.setType(entry.typeVar, value);
+        }
+    });
+    return solutionSet;
+}
+exports.solveConstraintSet = solveConstraintSet;
+// 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, constraints, 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;
+            }
+        }
+    }
+    constraints.setBounds(destType, lowerBound, lowerBoundNoLiterals, upperBound);
+}
+exports.updateTypeVarType = updateTypeVarType;
+// 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) => {
+            updateTypeVarType(evaluator, constraints, 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, 
+        /* srcConstraints */ 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 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);
+                updateTypeVarType(evaluator, constraints, 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, 
+    /* srcConstraints */ undefined, 2048 /* AssignTypeFlags.PopulatingExpectedType */)) {
+        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();
+                        }
+                        updateTypeVarType(evaluator, constraints, targetTypeVar, variance === 3 /* Variance.Covariant */ ? undefined : typeArgValue, variance === 4 /* Variance.Contravariant */ ? undefined : typeArgValue);
+                    }
+                    else {
+                        isResultValid = false;
+                    }
+                }
+            }
+        });
+        return isResultValid;
+    }
+    return false;
+}
+exports.addConstraintsForExpectedType = addConstraintsForExpectedType;
+// If the constraint tracker contains any type variables whose types depend on
+// unification vars used for bidirectional type inference, replace those
+// with the solved type associated with those unification vars.
+function applyUnificationVars(evaluator, constraints) {
+    constraints.doForEachConstraintSet((constraintSet) => {
+        if (!constraintSet.hasUnificationVars()) {
+            return;
+        }
+        constraintSet.getTypeVars().forEach((entry) => {
+            if (!types_1.TypeVarType.isUnification(entry.typeVar)) {
+                const newLowerBound = entry.lowerBound
+                    ? applyUnificationVarsToType(evaluator, entry.lowerBound, constraintSet)
+                    : undefined;
+                const newLowerBoundNoLiterals = entry.lowerBoundNoLiterals
+                    ? applyUnificationVarsToType(evaluator, entry.lowerBoundNoLiterals, constraintSet)
+                    : undefined;
+                const newUpperBound = entry.upperBound
+                    ? applyUnificationVarsToType(evaluator, entry.upperBound, constraintSet)
+                    : undefined;
+                constraintSet.setBounds(entry.typeVar, newLowerBound, newLowerBoundNoLiterals, newUpperBound);
             }
+        });
+    });
+}
+exports.applyUnificationVars = applyUnificationVars;
+function getTypeVarType(evaluator, constraintSet, typeVar, useLowerBoundOnly) {
+    var _a, _b;
+    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();
+        }
+    }
+    if (useLowerBoundOnly) {
+        return entry.lowerBound;
+    }
+    // Prefer the lower bound with no literals. It will be undefined
+    // if the literal type couldn't be widened due to constraints imposed
+    // by the upper bound.
+    return (_b = (_a = entry.lowerBoundNoLiterals) !== null && _a !== void 0 ? _a : entry.lowerBound) !== null && _b !== void 0 ? _b : entry.upperBound;
+}
+// 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.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.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.EnforceInvariance */ | 2 /* AssignTypeFlags.ReverseTypeVarMatching */)) === 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.EnforceInvariance */) !== 0;
+    const isContravariant = (flags & 2 /* AssignTypeFlags.ReverseTypeVarMatching */) !== 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;
@@ -207,14 +439,14 @@ function assignTypeToTypeVar(evaluator, destType, srcType, diag, typeVarContext,
         }
         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)) {
+            /* destConstraints */ undefined, 
+            /* srcConstraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount)) {
                 // The srcType is narrower than the current upper bound, so replace it.
                 newUpperTypeBound = adjSrcType;
             }
             else if (!evaluator.assignType(adjSrcType, curUpperBound, diagAddendum, 
-            /* destTypeVarContext */ undefined, 
-            /* srcTypeVarContext */ undefined, flags & 1024 /* AssignTypeFlags.IgnoreTypeVarScope */, recursionCount)) {
+            /* destConstraints */ undefined, 
+            /* srcConstraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount)) {
                 if (diag && diagAddendum) {
                     diag.addMessage(localize_1.LocAddendum.typeAssignmentMismatch().format(evaluator.printSrcDestTypes(curUpperBound, adjSrcType)));
                     diag.addAddendum(diagAddendum);
@@ -226,8 +458,8 @@ function assignTypeToTypeVar(evaluator, destType, srcType, diag, typeVarContext,
         if (curLowerBound) {
             if (!evaluator.assignType(newUpperTypeBound, curLowerBound, 
             /* diag */ undefined, 
-            /* destTypeVarContext */ undefined, 
-            /* srcTypeVarContext */ undefined, flags & 1024 /* AssignTypeFlags.IgnoreTypeVarScope */, recursionCount)) {
+            /* destConstraints */ undefined, 
+            /* srcConstraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount)) {
                 if (diag && diagAddendum) {
                     diag.addMessage(localize_1.LocAddendum.typeAssignmentMismatch().format(evaluator.printSrcDestTypes(curLowerBound, newUpperTypeBound)));
                     diag.addAddendum(diagAddendum);
@@ -250,26 +482,29 @@ function assignTypeToTypeVar(evaluator, destType, srcType, diag, typeVarContext,
             }
         }
         else {
-            if (evaluator.assignType(curLowerBound, adjSrcType, diagAddendum, typeVarContext, 
-            /* srcTypeVarContext */ undefined, flags, recursionCount)) {
+            if (evaluator.assignType(curLowerBound, adjSrcType, diagAddendum, constraints, 
+            /* srcConstraints */ undefined, 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, 
+                    /* srcConstraints */ undefined, 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, 
+                /* srcConstraints */ undefined, 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 +512,13 @@ 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, 
+                /* srcConstraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount)) {
                     newLowerBound = adjSrcType;
                 }
                 else if ((0, types_1.isTypeVarTuple)(destType)) {
@@ -302,7 +537,10 @@ function assignTypeToTypeVar(evaluator, destType, srcType, diag, typeVarContext,
                     if (!newUpperTypeBound && isInvariant && (curEntry === null || curEntry === void 0 ? void 0 : curEntry.lowerBoundNoLiterals)) {
                         curLowerBound = curEntry.lowerBoundNoLiterals;
                     }
-                    const curSolvedLowerBound = (0, typeUtils_1.applySolvedTypeVars)(curLowerBound, typeVarContext);
+                    let curSolvedLowerBound = curLowerBound;
+                    if (constraints) {
+                        curSolvedLowerBound = evaluator.solveAndApplyConstraints(curLowerBound, constraints);
+                    }
                     // 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 +548,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 +566,8 @@ 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)) {
+            /* destConstraints */ undefined, 
+            /* srcConstraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount)) {
                 if (diag && diagAddendum) {
                     diag.addMessage(localize_1.LocAddendum.typeAssignmentMismatch().format(evaluator.printSrcDestTypes(newLowerBound, adjSrcType)));
                 }
@@ -342,13 +580,13 @@ function assignTypeToTypeVar(evaluator, destType, srcType, diag, typeVarContext,
                 let adjUpperBound = evaluator.makeTopLevelTypeVarsConcrete(curUpperBound, 
                 /* makeParamSpecsConcrete */ true);
                 // Convert any remaining (non-top-level) TypeVars in the upper
-                // bound to in-scope placeholders.
+                // bound to unification vars.
                 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)) {
+                /* destConstraints */ undefined, 
+                /* srcConstraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount)) {
                     if (diag && diagAddendum) {
                         diag.addMessage(localize_1.LocAddendum.typeAssignmentMismatch().format(evaluator.printSrcDestTypes(newLowerBound, adjUpperBound)));
                     }
@@ -366,17 +604,15 @@ function assignTypeToTypeVar(evaluator, destType, srcType, diag, typeVarContext,
         // 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, 
+        /* srcConstraints */ undefined, 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 +625,24 @@ 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()) {
+        updateTypeVarType(evaluator, constraints, destType, newLowerBound, newUpperTypeBound, (flags & (2048 /* AssignTypeFlags.PopulatingExpectedType */ | 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;
     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, 
+        /* destConstraints */ undefined, 
+        /* srcConstraints */ 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 +670,15 @@ function assignTypeToConstrainedTypeVar(evaluator, destType, srcType, diag, type
                     : constraint;
                 if (evaluator.assignType(adjustedConstraint, srcSubtype, 
                 /* diag */ undefined, 
-                /* destTypeVarContext */ undefined, 
-                /* srcTypeVarContext */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount)) {
+                /* destConstraints */ undefined, 
+                /* srcConstraints */ 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)) {
+                        /* destConstraints */ undefined, 
+                        /* srcConstraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount)) {
                         constrainedSubtype = (0, typeUtils_1.addConditionToType)(constraint, (0, typeUtils_1.getTypeCondition)(srcSubtype));
                         constraintIndexUsed = i;
                     }
@@ -505,8 +715,8 @@ function assignTypeToConstrainedTypeVar(evaluator, destType, srcType, diag, type
                     : constraint;
                 return evaluator.assignType(adjustedConstraint, concreteSrcType, 
                 /* diag */ undefined, 
-                /* destTypeVarContext */ undefined, 
-                /* srcTypeVarContext */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount);
+                /* destConstraints */ undefined, 
+                /* srcConstraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount);
             });
         }
     }
@@ -526,17 +736,17 @@ function assignTypeToConstrainedTypeVar(evaluator, destType, srcType, diag, type
     if (curLowerBound && !(0, types_1.isAnyOrUnknown)(curLowerBound)) {
         if (!evaluator.assignType(curLowerBound, constrainedType, 
         /* diag */ undefined, 
-        /* destTypeVarContext */ undefined, 
-        /* srcTypeVarContext */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount)) {
+        /* destConstraints */ undefined, 
+        /* srcConstraints */ 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);
+            /* destConstraints */ undefined, 
+            /* srcConstraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount)) {
+                if (constraints && !constraints.isLocked()) {
+                    updateTypeVarType(evaluator, constraints, destType, constrainedType, curUpperBound);
                 }
             }
             else {
@@ -550,21 +760,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()) {
+            updateTypeVarType(evaluator, constraints, destType, constrainedType, curUpperBound, forceRetainLiterals);
         }
     }
     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 +794,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 +803,19 @@ 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);
+                /* destConstraints */ undefined, 
+                /* srcConstraints */ undefined, 64 /* AssignTypeFlags.SkipReturnTypeCheck */, recursionCount);
                 const isNewWider = evaluator.assignType(newFunction, existingFunction, 
                 /* diag */ undefined, 
-                /* destTypeVarContext */ undefined, 
-                /* srcTypeVarContext */ undefined, 64 /* AssignTypeFlags.SkipReturnTypeCheck */, recursionCount);
+                /* destConstraints */ undefined, 
+                /* srcConstraints */ 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 +843,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 +858,26 @@ 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;
+class UnificationVarTransformer extends typeUtils_1.TypeVarTransformer {
+    constructor(_evaluator, _constraintSet) {
+        super();
+        this._evaluator = _evaluator;
+        this._constraintSet = _constraintSet;
     }
-    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;
+    transformTypeVar(typeVar) {
+        var _a;
+        if (types_1.TypeVarType.isUnification(typeVar)) {
+            return (_a = getTypeVarType(this._evaluator, this._constraintSet, typeVar)) !== null && _a !== void 0 ? _a : typeVar;
+        }
+        return undefined;
     }
-    return false;
 }
-exports.addConstraintsForExpectedType = addConstraintsForExpectedType;
+function applyUnificationVarsToType(evaluator, type, constraintSet) {
+    const transformer = new UnificationVarTransformer(evaluator, constraintSet);
+    return transformer.apply(type, 0);
+}
 // 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,23 +927,23 @@ 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;