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

package/dist/analyzer/constraintSolver.js

@@ -10,152 +10,382 @@
  *
  */
 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 narrow bound of a type variable, we may end up with
+// 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 maxSubtypeCountForTypeVarNarrowBound = 64;
-// This debugging switch enables logging of the TypeVarContext before and
+const maxSubtypeCountForTypeVarLowerBound = 64;
+// 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(', ')}`);
-        console.log(`${indent}pre-call context #${typeVarContext.getId()}: `);
-        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.typeArguments ||
-                srcType.priv.typeArguments.length < 1 ||
-                (0, types_1.isAnyOrUnknown)(srcType.priv.typeArguments[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 (destType.shared.isParamSpec &&
-            (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.isClass)(expectedType)) {
+        return false;
     }
-    if (destType.shared.isParamSpec) {
-        return assignTypeToParamSpec(evaluator, destType, srcType, diag, typeVarContext, recursionCount);
+    // 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 */);
     }
-    if (destType.shared.isVariadic && !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 }], 
-                /* isTypeArgumentExplicit */ true, 
-                /* isUnpackedTuple */ true));
+    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 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.isTypeVar)(srcType) &&
-        srcType.shared.isVariadic &&
-        srcType.priv.isVariadicUnpacked &&
-        !srcType.priv.isVariadicInUnion &&
-        !destType.shared.isVariadic) {
-        srcType = types_1.TypeVarType.cloneForUnpacked(srcType, /* isInUnion */ true);
+    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;
     }
-    // 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);
+    // 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 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.getPrimarySignature().getTypeVar(destType);
-    let curWideTypeBound = curEntry === null || curEntry === void 0 ? void 0 : curEntry.wideBound;
-    if (!curWideTypeBound && !destType.shared.isSynthesizedSelf) {
-        curWideTypeBound = destType.shared.boundType;
-    }
-    let curNarrowTypeBound = curEntry === null || curEntry === void 0 ? void 0 : curEntry.narrowBound;
-    let newNarrowTypeBound = curNarrowTypeBound;
-    let newWideTypeBound = curWideTypeBound;
+    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 && !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;
     const diagAddendum = diag ? new diagnostic_1.DiagnosticAddendum() : undefined;
     let adjSrcType = srcType;
     // If the source is a class that is missing type arguments, fill
     // in missing type arguments with Unknown.
-    if ((flags & 8192 /* AssignTypeFlags.AllowUnspecifiedTypeArguments */) === 0) {
+    if ((flags & 8192 /* AssignTypeFlags.AllowUnspecifiedTypeArgs */) === 0) {
         if ((0, types_1.isClass)(adjSrcType) && adjSrcType.priv.includeSubclasses) {
             adjSrcType = (0, typeUtils_1.specializeWithDefaultTypeArgs)(adjSrcType);
         }
@@ -187,51 +417,51 @@ function assignTypeToTypeVar(evaluator, destType, srcType, diag, typeVarContext,
             return true;
         }
         // If we're populating the expected type, constrain either the
-        // narrow type bound, wide type bound or both. Don't overwrite
+        // lower type bound, upper type bound or both. Don't overwrite
         // an existing entry.
         if (!curEntry) {
             if (isInvariant) {
-                newNarrowTypeBound = adjSrcType;
-                newWideTypeBound = adjSrcType;
+                newLowerBound = adjSrcType;
+                newUpperTypeBound = adjSrcType;
             }
             else if (isContravariant) {
-                newNarrowTypeBound = adjSrcType;
+                newLowerBound = adjSrcType;
             }
             else {
-                newWideTypeBound = adjSrcType;
+                newUpperTypeBound = adjSrcType;
             }
         }
     }
     else if (isContravariant) {
-        // Update the wide type bound.
-        if (!curWideTypeBound || (0, types_1.isTypeSame)(destType, curWideTypeBound)) {
-            newWideTypeBound = adjSrcType;
-        }
-        else if (!(0, types_1.isTypeSame)(curWideTypeBound, adjSrcType, {}, recursionCount)) {
-            if (evaluator.assignType(curWideTypeBound, evaluator.makeTopLevelTypeVarsConcrete(adjSrcType), diagAddendum, 
-            /* destTypeVarContext */ undefined, 
-            /* srcTypeVarContext */ undefined, flags & 1024 /* AssignTypeFlags.IgnoreTypeVarScope */, recursionCount)) {
-                // The srcType is narrower than the current wideTypeBound, so replace it.
-                newWideTypeBound = adjSrcType;
-            }
-            else if (!evaluator.assignType(adjSrcType, curWideTypeBound, diagAddendum, 
-            /* destTypeVarContext */ undefined, 
-            /* srcTypeVarContext */ undefined, flags & 1024 /* AssignTypeFlags.IgnoreTypeVarScope */, recursionCount)) {
+        // Update the upper bound.
+        if (!curUpperBound || (0, types_1.isTypeSame)(destType, curUpperBound)) {
+            newUpperTypeBound = adjSrcType;
+        }
+        else if (!(0, types_1.isTypeSame)(curUpperBound, adjSrcType, {}, recursionCount)) {
+            if (evaluator.assignType(curUpperBound, evaluator.makeTopLevelTypeVarsConcrete(adjSrcType), diagAddendum, 
+            /* 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, 
+            /* destConstraints */ undefined, 
+            /* srcConstraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount)) {
                 if (diag && diagAddendum) {
-                    diag.addMessage(localize_1.LocAddendum.typeAssignmentMismatch().format(evaluator.printSrcDestTypes(curWideTypeBound, adjSrcType)));
+                    diag.addMessage(localize_1.LocAddendum.typeAssignmentMismatch().format(evaluator.printSrcDestTypes(curUpperBound, adjSrcType)));
                     diag.addAddendum(diagAddendum);
                 }
                 return false;
             }
         }
-        // Make sure we haven't narrowed it beyond the current narrow bound.
-        if (curNarrowTypeBound) {
-            if (!evaluator.assignType(newWideTypeBound, curNarrowTypeBound, 
+        // Make sure we haven't narrowed it beyond the current lower bound.
+        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(curNarrowTypeBound, newWideTypeBound)));
+                    diag.addMessage(localize_1.LocAddendum.typeAssignmentMismatch().format(evaluator.printSrcDestTypes(curLowerBound, newUpperTypeBound)));
                     diag.addAddendum(diagAddendum);
                 }
                 return false;
@@ -239,152 +469,150 @@ function assignTypeToTypeVar(evaluator, destType, srcType, diag, typeVarContext,
         }
     }
     else {
-        if (!curNarrowTypeBound || (0, types_1.isTypeSame)(destType, curNarrowTypeBound)) {
-            // There was previously no narrow bound. We've now established one.
-            newNarrowTypeBound = adjSrcType;
+        if (!curLowerBound || (0, types_1.isTypeSame)(destType, curLowerBound)) {
+            // There was previously no lower bound. We've now established one.
+            newLowerBound = adjSrcType;
         }
-        else if ((0, types_1.isTypeSame)(curNarrowTypeBound, adjSrcType, {}, recursionCount)) {
-            // If this is an invariant context and there is currently no wide type bound
-            // established, use the "no literals" version of the narrow type bounds rather
+        else if ((0, types_1.isTypeSame)(curLowerBound, adjSrcType, {}, recursionCount)) {
+            // 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 (!newWideTypeBound && isInvariant && (curEntry === null || curEntry === void 0 ? void 0 : curEntry.narrowBoundNoLiterals)) {
-                newNarrowTypeBound = curEntry.narrowBoundNoLiterals;
+            if (!newUpperTypeBound && isInvariant && (curEntry === null || curEntry === void 0 ? void 0 : curEntry.lowerBoundNoLiterals)) {
+                newLowerBound = curEntry.lowerBoundNoLiterals;
             }
         }
         else {
-            if ((0, types_1.isAnyOrUnknown)(adjSrcType) && (curEntry === null || curEntry === void 0 ? void 0 : curEntry.tupleTypes)) {
-                // Handle the tuple case specially. If Any or Unknown is assigned
-                // during the construction of a tuple, the resulting tuple type must
-                // be tuple[Any, ...], which is compatible with any tuple.
-                newNarrowTypeBound = adjSrcType;
-            }
-            else if (evaluator.assignType(curNarrowTypeBound, 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 narrow bound.
-                if ((0, typeUtils_1.isPartlyUnknown)(curNarrowTypeBound) &&
+                // 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, curNarrowTypeBound, 
-                    /* diag */ undefined, typeVarContext, 
-                    /* srcTypeVarContext */ undefined, flags & 1024 /* AssignTypeFlags.IgnoreTypeVarScope */, recursionCount)) {
-                    newNarrowTypeBound = adjSrcType;
+                    evaluator.assignType(adjSrcType, curLowerBound, 
+                    /* diag */ undefined, constraints, 
+                    /* srcConstraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount)) {
+                    newLowerBound = adjSrcType;
                 }
                 else {
-                    newNarrowTypeBound = (0, typeUtils_1.applySolvedTypeVars)(curNarrowTypeBound, typeVarContext);
+                    newLowerBound = curLowerBound;
+                    if (constraints) {
+                        newLowerBound = evaluator.solveAndApplyConstraints(newLowerBound, constraints);
+                    }
                 }
             }
-            else if ((0, types_1.isTypeVar)(curNarrowTypeBound) &&
+            else if ((0, types_1.isTypeVar)(curLowerBound) &&
                 !(0, types_1.isTypeVar)(adjSrcType) &&
-                evaluator.assignType(evaluator.makeTopLevelTypeVarsConcrete(curNarrowTypeBound), adjSrcType, diagAddendum, typeVarContext, 
-                /* srcTypeVarContext */ undefined, flags, recursionCount)) {
-                // If the existing narrow type bound was a TypeVar that is not
+                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.
-                newNarrowTypeBound = adjSrcType;
+                newLowerBound = adjSrcType;
             }
             else {
                 // We need to widen the type.
-                if (typeVarContext.isLocked()) {
-                    diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.typeAssignmentMismatch().format(evaluator.printSrcDestTypes(adjSrcType, curNarrowTypeBound)));
+                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, curNarrowTypeBound, 
-                /* diag */ undefined, typeVarContext, 
-                /* srcTypeVarContext */ undefined, flags & 1024 /* AssignTypeFlags.IgnoreTypeVarScope */, recursionCount)) {
-                    newNarrowTypeBound = adjSrcType;
+                if (evaluator.assignType(adjSrcType, curLowerBound, 
+                /* diag */ undefined, constraints, 
+                /* srcConstraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount)) {
+                    newLowerBound = adjSrcType;
                 }
-                else if ((0, types_1.isVariadicTypeVar)(destType)) {
-                    const widenedType = widenTypeForVariadicTypeVar(evaluator, curNarrowTypeBound, adjSrcType);
+                else if ((0, types_1.isTypeVarTuple)(destType)) {
+                    const widenedType = widenTypeForTypeVarTuple(evaluator, curLowerBound, adjSrcType);
                     if (!widenedType) {
-                        diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.typeAssignmentMismatch().format(evaluator.printSrcDestTypes(curNarrowTypeBound, adjSrcType)));
+                        diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.typeAssignmentMismatch().format(evaluator.printSrcDestTypes(curLowerBound, adjSrcType)));
                         return false;
                     }
-                    newNarrowTypeBound = widenedType;
+                    newLowerBound = widenedType;
                 }
                 else {
                     const objectType = evaluator.getObjectType();
-                    // If this is an invariant context and there is currently no wide type bound
-                    // established, use the "no literals" version of the narrow type bounds rather
+                    // 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 (!newWideTypeBound && isInvariant && (curEntry === null || curEntry === void 0 ? void 0 : curEntry.narrowBoundNoLiterals)) {
-                        curNarrowTypeBound = curEntry.narrowBoundNoLiterals;
+                    if (!newUpperTypeBound && isInvariant && (curEntry === null || curEntry === void 0 ? void 0 : curEntry.lowerBoundNoLiterals)) {
+                        curLowerBound = curEntry.lowerBoundNoLiterals;
+                    }
+                    let curSolvedLowerBound = curLowerBound;
+                    if (constraints) {
+                        curSolvedLowerBound = evaluator.solveAndApplyConstraints(curLowerBound, constraints);
                     }
-                    const curSolvedNarrowTypeBound = (0, typeUtils_1.applySolvedTypeVars)(curNarrowTypeBound, typeVarContext);
-                    // In some extreme edge cases, the narrow type bound can become
+                    // 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
                     // to an 'object' instead of making the union even bigger. This
                     // is still a valid solution to the TypeVar.
-                    if ((0, types_1.isUnion)(curSolvedNarrowTypeBound) &&
-                        curSolvedNarrowTypeBound.priv.subtypes.length > typeEvaluatorTypes_1.maxSubtypesForInferredType &&
-                        destType.shared.boundType !== undefined &&
+                    if ((0, types_1.isUnion)(curSolvedLowerBound) &&
+                        curSolvedLowerBound.priv.subtypes.length > typeEvaluatorTypes_1.maxSubtypesForInferredType &&
+                        types_1.TypeVarType.hasBound(destType) &&
                         (0, types_1.isClassInstance)(objectType)) {
-                        newNarrowTypeBound = (0, types_1.combineTypes)([curSolvedNarrowTypeBound, objectType], {
-                            maxSubtypeCount: maxSubtypeCountForTypeVarNarrowBound,
+                        newLowerBound = (0, types_1.combineTypes)([curSolvedLowerBound, objectType], {
+                            maxSubtypeCount: maxSubtypeCountForTypeVarLowerBound,
                         });
                     }
                     else {
-                        newNarrowTypeBound = (0, types_1.combineTypes)([curSolvedNarrowTypeBound, adjSrcType], {
-                            maxSubtypeCount: maxSubtypeCountForTypeVarNarrowBound,
+                        newLowerBound = (0, types_1.combineTypes)([curSolvedLowerBound, adjSrcType], {
+                            maxSubtypeCount: maxSubtypeCountForTypeVarLowerBound,
                         });
                     }
                 }
             }
         }
-        // If this is an invariant context, make sure the narrow type bound
+        // If this is an invariant context, make sure the lower bound
         // isn't too wide.
-        if (isInvariant && newNarrowTypeBound) {
-            if (!evaluator.assignType(adjSrcType, newNarrowTypeBound, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), 
-            /* destTypeVarContext */ undefined, 
-            /* srcTypeVarContext */ undefined, 1024 /* AssignTypeFlags.IgnoreTypeVarScope */, recursionCount)) {
+        if (isInvariant && newLowerBound) {
+            if (!evaluator.assignType(adjSrcType, newLowerBound, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), 
+            /* destConstraints */ undefined, 
+            /* srcConstraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount)) {
                 if (diag && diagAddendum) {
-                    diag.addMessage(localize_1.LocAddendum.typeAssignmentMismatch().format(evaluator.printSrcDestTypes(newNarrowTypeBound, adjSrcType)));
+                    diag.addMessage(localize_1.LocAddendum.typeAssignmentMismatch().format(evaluator.printSrcDestTypes(newLowerBound, adjSrcType)));
                 }
                 return false;
             }
         }
-        // Make sure we don't exceed the wide type bound.
-        if (curWideTypeBound && newNarrowTypeBound) {
-            if (!(0, types_1.isTypeSame)(curWideTypeBound, newNarrowTypeBound, {}, recursionCount)) {
-                let adjWideTypeBound = evaluator.makeTopLevelTypeVarsConcrete(curWideTypeBound, 
+        // 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 wide type
-                // bound to in-scope placeholders.
-                adjWideTypeBound = (0, typeUtils_1.transformExpectedType)(adjWideTypeBound, 
+                // Convert any remaining (non-top-level) TypeVars in the upper
+                // bound to unification vars.
+                adjUpperBound = (0, typeUtils_1.transformExpectedType)(adjUpperBound, 
                 /* liveTypeVarScopes */ [], 
                 /* usageOffset */ undefined);
-                if (!evaluator.assignType(adjWideTypeBound, newNarrowTypeBound, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), 
-                /* destTypeVarContext */ undefined, 
-                /* srcTypeVarContext */ undefined, 1024 /* AssignTypeFlags.IgnoreTypeVarScope */, recursionCount)) {
+                if (!evaluator.assignType(adjUpperBound, newLowerBound, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), 
+                /* destConstraints */ undefined, 
+                /* srcConstraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount)) {
                     if (diag && diagAddendum) {
-                        diag.addMessage(localize_1.LocAddendum.typeAssignmentMismatch().format(evaluator.printSrcDestTypes(newNarrowTypeBound, adjWideTypeBound)));
+                        diag.addMessage(localize_1.LocAddendum.typeAssignmentMismatch().format(evaluator.printSrcDestTypes(newLowerBound, adjUpperBound)));
                     }
                     return false;
                 }
             }
         }
     }
-    if (!newWideTypeBound && isInvariant) {
-        newWideTypeBound = newNarrowTypeBound;
+    if (!newUpperTypeBound && isInvariant) {
+        newUpperTypeBound = newLowerBound;
     }
     // If there's a bound type, make sure the source is assignable to it.
     if (destType.shared.boundType) {
-        const updatedType = (newNarrowTypeBound || newWideTypeBound);
+        const updatedType = (newLowerBound || newUpperTypeBound);
         // 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) {
@@ -397,61 +625,24 @@ function assignTypeToTypeVar(evaluator, destType, srcType, diag, typeVarContext,
             return false;
         }
     }
-    // Update the tuple types based on the new type bounds. We need to
-    // switch to an unbounded tuple type since the length of the resulting
-    // tuple is indeterminate.
-    let newTupleTypes = curEntry === null || curEntry === void 0 ? void 0 : curEntry.tupleTypes;
-    if (newTupleTypes) {
-        const updatedType = newNarrowTypeBound !== null && newNarrowTypeBound !== void 0 ? newNarrowTypeBound : newWideTypeBound;
-        if (updatedType) {
-            newTupleTypes = [{ type: updatedType, isUnbounded: true }];
-        }
-    }
-    if (!typeVarContext.isLocked() && isTypeVarInScope) {
-        updateTypeVarType(evaluator, typeVarContext, destType, newNarrowTypeBound, newWideTypeBound, newTupleTypes, (flags & (2048 /* AssignTypeFlags.PopulatingExpectedType */ | 256 /* AssignTypeFlags.RetainLiteralsForTypeVar */)) !== 0);
-    }
-    if (logTypeVarContextUpdates) {
-        const indent = ' '.repeat(recursionCount * 2);
-        console.log(`${indent}`);
-        console.log(`${indent}post-call context #${typeVarContext.getId()}: `);
-        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 narrow and wide type bounds for a type variable. It also calculates the
-// narrowTypeBoundNoLiterals, which is a variant of the narrow type 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 wide type bound.
-function updateTypeVarType(evaluator, typeVarContext, destType, narrowTypeBound, wideTypeBound, tupleTypes = undefined, forceRetainLiterals = false) {
-    let narrowTypeBoundNoLiterals;
-    if (narrowTypeBound && !forceRetainLiterals) {
-        const strippedLiteral = (0, types_1.isVariadicTypeVar)(destType)
-            ? stripLiteralValueForUnpackedTuple(evaluator, narrowTypeBound)
-            : evaluator.stripLiteralValue(narrowTypeBound);
-        // Strip the literals from the narrow type bound and see if it is still
-        // narrower than the wide bound.
-        if (strippedLiteral !== narrowTypeBound) {
-            if (!wideTypeBound || evaluator.assignType(wideTypeBound, strippedLiteral)) {
-                narrowTypeBoundNoLiterals = strippedLiteral;
-            }
-        }
-    }
-    typeVarContext.setTypeVarType(destType, narrowTypeBound, narrowTypeBoundNoLiterals, wideTypeBound, 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.getPrimarySignature().getTypeVar(destType);
-    const curWideTypeBound = curEntry === null || curEntry === void 0 ? void 0 : curEntry.wideBound;
-    const curNarrowTypeBound = curEntry === null || curEntry === void 0 ? void 0 : curEntry.narrowBound;
+    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).
@@ -479,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;
                     }
@@ -524,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);
             });
         }
     }
@@ -542,26 +733,26 @@ function assignTypeToConstrainedTypeVar(evaluator, destType, srcType, diag, type
     else if ((0, typeUtils_1.isLiteralTypeOrUnion)(constrainedType)) {
         forceRetainLiterals = true;
     }
-    if (curNarrowTypeBound && !(0, types_1.isAnyOrUnknown)(curNarrowTypeBound)) {
-        if (!evaluator.assignType(curNarrowTypeBound, constrainedType, 
+    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, curNarrowTypeBound, 
+            if (evaluator.assignType(constrainedType, curLowerBound, 
             /* diag */ undefined, 
-            /* destTypeVarContext */ undefined, 
-            /* srcTypeVarContext */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount)) {
-                if (!typeVarContext.isLocked() && isTypeVarInScope) {
-                    updateTypeVarType(evaluator, typeVarContext, destType, constrainedType, curWideTypeBound);
+            /* destConstraints */ undefined, 
+            /* srcConstraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount)) {
+                if (constraints && !constraints.isLocked()) {
+                    updateTypeVarType(evaluator, constraints, destType, constrainedType, curUpperBound);
                 }
             }
             else {
                 diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.typeConstrainedTypeVar().format({
                     type: evaluator.printType(constrainedType),
-                    name: evaluator.printType(curNarrowTypeBound),
+                    name: evaluator.printType(curLowerBound),
                 }));
                 return false;
             }
@@ -569,22 +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, curWideTypeBound, 
-            /* tupleTypes */ undefined, 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.doForEachSignature((signatureContext) => {
-        if ((0, types_1.isTypeVar)(adjSrcType) && adjSrcType.shared.isParamSpec) {
-            const existingType = signatureContext.getParamSpecType(destType);
+    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 = (_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)) {
@@ -593,8 +794,8 @@ function assignTypeToParamSpec(evaluator, destType, srcType, diag, typeVarContex
                 }
             }
             else {
-                if (!typeVarContext.isLocked() && typeVarContext.hasSolveForScope(destType.priv.scopeId)) {
-                    signatureContext.setTypeVarType(destType, (0, typeUtils_1.convertTypeToParamSpecValue)(adjSrcType));
+                if (!constraints.isLocked()) {
+                    constraintSet.setBounds(destType, adjSrcType);
                 }
                 return;
             }
@@ -602,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 = signatureContext.getParamSpecType(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.
@@ -642,8 +843,8 @@ function assignTypeToParamSpec(evaluator, destType, srcType, diag, typeVarContex
                 updateContextWithNewFunction = true;
             }
             if (updateContextWithNewFunction) {
-                if (!typeVarContext.isLocked() && typeVarContext.hasSolveForScope(destType.priv.scopeId)) {
-                    signatureContext.setTypeVarType(destType, newFunction);
+                if (!constraints.isLocked()) {
+                    constraintSet.setBounds(destType, newFunction);
                 }
                 return;
             }
@@ -657,173 +858,30 @@ 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.typeParameters.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.typeArguments;
-    if (!expectedTypeArgs) {
-        return evaluator.assignType(type, expectedType, 
-        /* diag */ undefined, typeVarContext, 
-        /* srcTypeVarContext */ undefined, 2048 /* AssignTypeFlags.PopulatingExpectedType */);
+class UnificationVarTransformer extends typeUtils_1.TypeVarTransformer {
+    constructor(_evaluator, _constraintSet) {
+        super();
+        this._evaluator = _evaluator;
+        this._constraintSet = _constraintSet;
     }
-    evaluator.inferTypeParameterVarianceForClass(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
-            .getPrimarySignature()
-            .getTypeVars()
-            .forEach((entry) => {
-            let typeArgValue = sameClassTypeVarContext.getPrimarySignature().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);
-                if (entry.tupleTypes) {
-                    typeVarContext.setTupleTypeVar(entry.typeVar, entry.tupleTypes.map((tupleEntry) => {
-                        let tupleType = tupleEntry.type;
-                        if (liveTypeVarScopes) {
-                            tupleType = (0, typeUtils_1.transformExpectedType)(tupleEntry.type, liveTypeVarScopes, usageOffset);
-                        }
-                        return {
-                            type: tupleType,
-                            isUnbounded: tupleEntry.isUnbounded,
-                            isOptional: tupleEntry.isOptional,
-                        };
-                    }));
-                }
-            }
-        });
-        return true;
-    }
-    // Create a generic version of the expected type.
-    const expectedTypeScopeId = (0, typeUtils_1.getTypeVarScopeId)(expectedType);
-    const synthExpectedTypeArgs = types_1.ClassType.getTypeParameters(expectedType).map((typeParam, index) => {
-        const typeVar = types_1.TypeVarType.createInstance(`__dest${index}`);
-        typeVar.shared.isSynthesized = true;
-        if (typeParam.shared.isParamSpec) {
-            typeVar.shared.isParamSpec = true;
-        }
-        // Use invariance here so we set the narrow and wide values on the TypeVar.
-        typeVar.shared.declaredVariance = 2 /* Variance.Invariant */;
-        typeVar.priv.scopeId = expectedTypeScopeId;
-        return typeVar;
-    });
-    const genericExpectedType = types_1.ClassType.cloneForSpecialization(expectedType, synthExpectedTypeArgs, 
-    /* isTypeArgumentExplicit */ true);
-    // For each type param in the target type, create a placeholder type variable.
-    const typeArgs = types_1.ClassType.getTypeParameters(type).map((typeParam, index) => {
-        const typeVar = types_1.TypeVarType.createInstance(`__source${index}`);
-        typeVar.shared.isSynthesized = true;
-        typeVar.shared.synthesizedIndex = index;
-        typeVar.shared.isExemptFromBoundCheck = true;
-        if (typeParam.shared.isParamSpec) {
-            typeVar.shared.isParamSpec = true;
+    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 types_1.TypeVarType.cloneAsInScopePlaceholder(typeVar);
-    });
-    const specializedType = types_1.ClassType.cloneForSpecialization(type, typeArgs, /* isTypeArgumentExplicit */ true);
-    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.getPrimarySignature().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 (typeVar.shared.isParamSpec && (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.getTypeParameters(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.getPrimarySignature().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 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.
-function widenTypeForVariadicTypeVar(evaluator, type1, type2) {
+function widenTypeForTypeVarTuple(evaluator, type1, type2) {
     // The typing spec indicates that the type should always be "exactly
     // the same type" if a TypeVarTuple is used in multiple locations.
     // This is problematic for a number of reasons, but in the interest
@@ -833,9 +891,9 @@ function widenTypeForVariadicTypeVar(evaluator, type1, type2) {
         return undefined;
     }
     // If the two unpacked tuples are not the same length, we can't combine them.
-    if (!type1.priv.tupleTypeArguments ||
-        !type2.priv.tupleTypeArguments ||
-        type1.priv.tupleTypeArguments.length !== type2.priv.tupleTypeArguments.length) {
+    if (!type1.priv.tupleTypeArgs ||
+        !type2.priv.tupleTypeArgs ||
+        type1.priv.tupleTypeArgs.length !== type2.priv.tupleTypeArgs.length) {
         return undefined;
     }
     const strippedType1 = stripLiteralValueForUnpackedTuple(evaluator, type1);
@@ -848,11 +906,11 @@ function widenTypeForVariadicTypeVar(evaluator, type1, type2) {
 // If the provided type is an unpacked tuple, this function strips the
 // literals from types of the corresponding elements.
 function stripLiteralValueForUnpackedTuple(evaluator, type) {
-    if (!(0, types_1.isUnpackedClass)(type) || !type.priv.tupleTypeArguments) {
+    if (!(0, types_1.isUnpackedClass)(type) || !type.priv.tupleTypeArgs) {
         return type;
     }
     let strippedLiteral = false;
-    const tupleTypeArgs = type.priv.tupleTypeArguments.map((arg) => {
+    const tupleTypeArgs = type.priv.tupleTypeArgs.map((arg) => {
         const strippedType = evaluator.stripLiteralValue(arg.type);
         if (strippedType !== arg.type) {
             strippedLiteral = true;
@@ -866,44 +924,44 @@ function stripLiteralValueForUnpackedTuple(evaluator, type) {
     if (!strippedLiteral) {
         return type;
     }
-    return (0, typeUtils_1.specializeTupleClass)(type, tupleTypeArgs, /* isTypeArgumentExplicit */ true, /* isUnpackedTuple */ true);
+    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 signatureContextCount = typeVarContext.getSignatureContexts().length;
-    if (signatureContextCount === 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 (signatureContextCount === 1) {
-        logTypeVarSignatureContext(evaluator, typeVarContext.getSignatureContexts()[0], `${indent}  `);
+    else if (constraintSetCount === 1) {
+        logTypeVarConstraintSet(evaluator, constraints.getConstraintSets()[0], `${indent}  `);
     }
     else {
-        typeVarContext.doForEachSignatureContext((context, signatureIndex) => {
-            console.log(`${indent}  signature ${signatureIndex}`);
-            logTypeVarSignatureContext(evaluator, context, `${indent}    `);
+        constraints.doForEachConstraintSet((set, index) => {
+            console.log(`${indent}  signature ${index}`);
+            logTypeVarConstraintSet(evaluator, set, `${indent}    `);
         });
     }
 }
-function logTypeVarSignatureContext(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 narrowBound = (_a = entry.narrowBoundNoLiterals) !== null && _a !== void 0 ? _a : entry.narrowBound;
-        const wideBound = entry.wideBound;
-        // Log the narrow and wide bounds.
-        if (narrowBound && wideBound && (0, types_1.isTypeSame)(narrowBound, wideBound)) {
-            console.log(`${typeVarName} = ${evaluator.printType(narrowBound)}`);
+        const lowerBound = (_a = entry.lowerBoundNoLiterals) !== null && _a !== void 0 ? _a : entry.lowerBound;
+        const upperBound = entry.upperBound;
+        // Log the lower and upper bounds.
+        if (lowerBound && upperBound && (0, types_1.isTypeSame)(lowerBound, upperBound)) {
+            console.log(`${typeVarName} = ${evaluator.printType(lowerBound)}`);
             loggedConstraint = true;
         }
         else {
-            if (narrowBound) {
-                console.log(`${typeVarName} ≤ ${evaluator.printType(narrowBound)}`);
+            if (lowerBound) {
+                console.log(`${typeVarName} ≤ ${evaluator.printType(lowerBound)}`);
                 loggedConstraint = true;
             }
-            if (wideBound) {
-                console.log(`${typeVarName} ≥ ${evaluator.printType(wideBound)}`);
+            if (upperBound) {
+                console.log(`${typeVarName} ≥ ${evaluator.printType(upperBound)}`);
                 loggedConstraint = true;
             }
         }