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

package/dist/analyzer/constraintSolver.js

@@ -10,7 +10,11 @@
  *
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.applyUnificationVars = exports.addConstraintsForExpectedType = exports.updateTypeVarType = exports.solveConstraintSet = exports.solveConstraints = exports.assignTypeVar = void 0;
+exports.assignTypeVar = assignTypeVar;
+exports.solveConstraints = solveConstraints;
+exports.applySourceSolutionToConstraints = applySourceSolutionToConstraints;
+exports.solveConstraintSet = solveConstraintSet;
+exports.addConstraintsForExpectedType = addConstraintsForExpectedType;
 const diagnostic_1 = require("../common/diagnostic");
 const localize_1 = require("../localization/localize");
 const constraintSolution_1 = require("./constraintSolution");
@@ -105,7 +109,6 @@ function assignTypeVar(evaluator, destType, srcType, diag, constraints, flags =
     }
     return isAssignable;
 }
-exports.assignTypeVar = assignTypeVar;
 // Returns a solution for the type variables tracked by the constraint tracker.
 function solveConstraints(evaluator, constraints, options) {
     const solutionSets = [];
@@ -115,40 +118,64 @@ function solveConstraints(evaluator, constraints, options) {
     });
     return new constraintSolution_1.ConstraintSolution(solutionSets);
 }
-exports.solveConstraints = solveConstraints;
+// Applies solved TypeVars from one context to this context.
+function applySourceSolutionToConstraints(constraints, srcSolution) {
+    if (srcSolution.isEmpty()) {
+        return;
+    }
+    constraints.doForEachConstraintSet((constraintSet) => {
+        constraintSet.getTypeVars().forEach((entry) => {
+            constraintSet.setBounds(entry.typeVar, entry.lowerBound ? (0, typeUtils_1.applySolvedTypeVars)(entry.lowerBound, srcSolution) : undefined, entry.upperBound ? (0, typeUtils_1.applySolvedTypeVars)(entry.upperBound, srcSolution) : undefined, entry.retainLiterals);
+        });
+    });
+}
 function solveConstraintSet(evaluator, constraintSet, options) {
     const solutionSet = new constraintSolution_1.ConstraintSolutionSet(constraintSet.getScopeIds());
     constraintSet.doForEachTypeVar((entry) => {
-        const value = getTypeVarType(evaluator, constraintSet, entry.typeVar, options === null || options === void 0 ? void 0 : options.useLowerBoundOnly);
-        if (value) {
-            solutionSet.setType(entry.typeVar, value);
-        }
+        solveTypeVarRecursive(evaluator, constraintSet, options, solutionSet, entry);
     });
     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);
+function solveTypeVarRecursive(evaluator, constraintSet, options, solutionSet, entry) {
+    // If this TypeVar already has a solution, don't attempt to re-solve it.
+    if (solutionSet.hasType(entry.typeVar)) {
+        return solutionSet.getType(entry.typeVar);
+    }
+    // Protect against infinite recursion by setting the initial value to undefined.
+    solutionSet.setType(entry.typeVar, undefined);
+    let value = getTypeVarType(evaluator, constraintSet, entry.typeVar, options === null || options === void 0 ? void 0 : options.useLowerBoundOnly);
+    if (value) {
+        // Are there any unsolved TypeVars in this type?
+        const typeVars = (0, typeUtils_1.getTypeVarArgsRecursive)(value);
+        if (typeVars.length > 0) {
+            const dependentSolution = new constraintSolution_1.ConstraintSolution();
+            for (const typeVar of typeVars) {
+                // Don't attempt to replace a TypeVar with itself.
+                if ((0, types_1.isTypeSame)(typeVar, entry.typeVar, { ignoreTypeFlags: true })) {
+                    continue;
+                }
+                // Don't attempt to solve or replace bound TypeVars.
+                if (types_1.TypeVarType.isBound(typeVar)) {
+                    continue;
+                }
+                const dependentEntry = constraintSet.getTypeVar(typeVar);
+                if (!dependentEntry) {
+                    continue;
+                }
+                const dependentType = solveTypeVarRecursive(evaluator, constraintSet, options, solutionSet, dependentEntry);
+                if (dependentType) {
+                    dependentSolution.setType(typeVar, dependentType);
+                }
+            }
+            // Apply the dependent TypeVar values to the current TypeVar value.
+            if (!dependentSolution.isEmpty()) {
+                value = (0, typeUtils_1.applySolvedTypeVars)(value, dependentSolution);
+            }
+        }
+    }
+    solutionSet.setType(entry.typeVar, value);
+    return value;
 }
-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
@@ -158,7 +185,7 @@ exports.updateTypeVarType = updateTypeVarType;
 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);
+            constraints.setBounds(typeParam, expectedType, expectedType);
         });
         return true;
     }
@@ -172,8 +199,7 @@ function addConstraintsForExpectedType(evaluator, type, expectedType, constraint
     const expectedTypeArgs = expectedType.priv.typeArgs;
     if (!expectedTypeArgs) {
         return evaluator.assignType(type, expectedType, 
-        /* diag */ undefined, constraints, 
-        /* srcConstraints */ undefined, 2048 /* AssignTypeFlags.PopulatingExpectedType */);
+        /* diag */ undefined, constraints, 2048 /* AssignTypeFlags.PopulateExpectedType */);
     }
     evaluator.inferVarianceForClass(type);
     // If the expected type is the same as the target type (commonly the case),
@@ -188,7 +214,7 @@ function addConstraintsForExpectedType(evaluator, type, expectedType, constraint
             }
             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);
+                constraints.setBounds(typeParam, variance === 3 /* Variance.Covariant */ ? undefined : typeArgValue, variance === 4 /* Variance.Contravariant */ ? undefined : typeArgValue);
             }
         });
         return true;
@@ -215,8 +241,7 @@ function addConstraintsForExpectedType(evaluator, type, expectedType, constraint
     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 */)) {
+    /* diag */ undefined, syntheticConstraints, 2048 /* AssignTypeFlags.PopulateExpectedType */)) {
         let isResultValid = true;
         synthExpectedTypeArgs.forEach((typeVar, index) => {
             let synthTypeVar = getTypeVarType(evaluator, syntheticConstraints.getMainConstraintSet(), typeVar);
@@ -269,7 +294,7 @@ function addConstraintsForExpectedType(evaluator, type, expectedType, constraint
                             isResultValid = false;
                             typeArgValue = types_1.UnknownType.create();
                         }
-                        updateTypeVarType(evaluator, constraints, targetTypeVar, variance === 3 /* Variance.Covariant */ ? undefined : typeArgValue, variance === 4 /* Variance.Contravariant */ ? undefined : typeArgValue);
+                        constraints.setBounds(targetTypeVar, variance === 3 /* Variance.Covariant */ ? undefined : typeArgValue, variance === 4 /* Variance.Contravariant */ ? undefined : typeArgValue);
                     }
                     else {
                         isResultValid = false;
@@ -281,34 +306,12 @@ function addConstraintsForExpectedType(evaluator, type, expectedType, constraint
     }
     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);
-            }
-        });
-    });
+function stripLiteralsForLowerBound(evaluator, typeVar, lowerBound) {
+    return (0, types_1.isTypeVarTuple)(typeVar)
+        ? stripLiteralValueForUnpackedTuple(evaluator, lowerBound)
+        : evaluator.stripLiteralValue(lowerBound);
 }
-exports.applyUnificationVars = applyUnificationVars;
 function getTypeVarType(evaluator, constraintSet, typeVar, useLowerBoundOnly) {
-    var _a, _b;
     const entry = constraintSet.getTypeVar(typeVar);
     if (!entry) {
         return undefined;
@@ -324,13 +327,33 @@ function getTypeVarType(evaluator, constraintSet, typeVar, useLowerBoundOnly) {
             return types_1.ParamSpecType.getUnknown();
         }
     }
-    if (useLowerBoundOnly) {
-        return entry.lowerBound;
+    let result;
+    let lowerBound = entry.lowerBound;
+    if (lowerBound) {
+        if (!entry.retainLiterals) {
+            const lowerNoLiterals = stripLiteralsForLowerBound(evaluator, typeVar, lowerBound);
+            // If we can widen the lower bound to a non-literal type without
+            // exceeding the upper bound, use the widened type.
+            if (lowerNoLiterals !== lowerBound) {
+                if (!entry.upperBound || evaluator.assignType(entry.upperBound, lowerNoLiterals)) {
+                    if (types_1.TypeVarType.hasConstraints(typeVar)) {
+                        // Does it still match a value constraint?
+                        if (typeVar.shared.constraints.some((constraint) => (0, types_1.isTypeSame)(lowerNoLiterals, constraint))) {
+                            lowerBound = lowerNoLiterals;
+                        }
+                    }
+                    else {
+                        lowerBound = lowerNoLiterals;
+                    }
+                }
+            }
+        }
+        result = lowerBound;
+    }
+    else if (!useLowerBoundOnly) {
+        result = entry.upperBound;
     }
-    // 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;
+    return result;
 }
 // Handles an assignment to a TypeVar that is "bound" rather than "free".
 // In general, such assignments are not allowed, but there are some special
@@ -341,14 +364,11 @@ function assignBoundTypeVar(evaluator, destType, srcType, diag, flags) {
         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)) {
+    if ((0, types_1.isParamSpec)(destType) && (0, types_1.isFunction)(srcType) && types_1.FunctionType.isGradualCallableForm(srcType)) {
         return true;
     }
     // Never is always assignable in a covariant context.
-    const isCovariant = (flags & (1 /* AssignTypeFlags.EnforceInvariance */ | 2 /* AssignTypeFlags.ReverseTypeVarMatching */)) === 0;
+    const isCovariant = (flags & (1 /* AssignTypeFlags.Invariant */ | 2 /* AssignTypeFlags.Contravariant */)) === 0;
     if ((0, types_1.isNever)(srcType) && isCovariant) {
         return true;
     }
@@ -370,8 +390,8 @@ function assignBoundTypeVar(evaluator, destType, srcType, diag, flags) {
 // 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;
+    const isInvariant = (flags & 1 /* AssignTypeFlags.Invariant */) !== 0;
+    const isContravariant = (flags & 2 /* AssignTypeFlags.Contravariant */) !== 0 && !isInvariant;
     // Handle the unconstrained (but possibly bound) case.
     const curEntry = constraints === null || constraints === void 0 ? void 0 : constraints.getMainConstraintSet().getTypeVar(destType);
     let curUpperBound = curEntry === null || curEntry === void 0 ? void 0 : curEntry.upperBound;
@@ -380,7 +400,7 @@ function assignUnconstrainedTypeVar(evaluator, destType, srcType, diag, constrai
     }
     let curLowerBound = curEntry === null || curEntry === void 0 ? void 0 : curEntry.lowerBound;
     let newLowerBound = curLowerBound;
-    let newUpperTypeBound = curUpperBound;
+    let newUpperBound = curUpperBound;
     const diagAddendum = diag ? new diagnostic_1.DiagnosticAddendum() : undefined;
     let adjSrcType = srcType;
     // If the source is a class that is missing type arguments, fill
@@ -412,7 +432,7 @@ function assignUnconstrainedTypeVar(evaluator, destType, srcType, diag, constrai
         diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.LocAddendum.typeAssignmentMismatch().format(evaluator.printSrcDestTypes(adjSrcType, destType)));
         return false;
     }
-    if ((flags & 2048 /* AssignTypeFlags.PopulatingExpectedType */) !== 0) {
+    if ((flags & 2048 /* AssignTypeFlags.PopulateExpectedType */) !== 0) {
         if ((flags & 4096 /* AssignTypeFlags.SkipPopulateUnknownExpectedType */) !== 0 && (0, types_1.isUnknown)(adjSrcType)) {
             return true;
         }
@@ -422,31 +442,29 @@ function assignUnconstrainedTypeVar(evaluator, destType, srcType, diag, constrai
         if (!curEntry) {
             if (isInvariant) {
                 newLowerBound = adjSrcType;
-                newUpperTypeBound = adjSrcType;
+                newUpperBound = adjSrcType;
             }
             else if (isContravariant) {
                 newLowerBound = adjSrcType;
             }
             else {
-                newUpperTypeBound = adjSrcType;
+                newUpperBound = adjSrcType;
             }
         }
     }
     else if (isContravariant) {
         // Update the upper bound.
         if (!curUpperBound || (0, types_1.isTypeSame)(destType, curUpperBound)) {
-            newUpperTypeBound = adjSrcType;
+            newUpperBound = adjSrcType;
         }
         else if (!(0, types_1.isTypeSame)(curUpperBound, adjSrcType, {}, recursionCount)) {
             if (evaluator.assignType(curUpperBound, evaluator.makeTopLevelTypeVarsConcrete(adjSrcType), diagAddendum, 
-            /* destConstraints */ undefined, 
-            /* srcConstraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount)) {
+            /* constraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount)) {
                 // The srcType is narrower than the current upper bound, so replace it.
-                newUpperTypeBound = adjSrcType;
+                newUpperBound = adjSrcType;
             }
             else if (!evaluator.assignType(adjSrcType, curUpperBound, diagAddendum, 
-            /* destConstraints */ undefined, 
-            /* srcConstraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount)) {
+            /* constraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount)) {
                 if (diag && diagAddendum) {
                     diag.addMessage(localize_1.LocAddendum.typeAssignmentMismatch().format(evaluator.printSrcDestTypes(curUpperBound, adjSrcType)));
                     diag.addAddendum(diagAddendum);
@@ -456,12 +474,11 @@ function assignUnconstrainedTypeVar(evaluator, destType, srcType, diag, constrai
         }
         // Make sure we haven't narrowed it beyond the current lower bound.
         if (curLowerBound) {
-            if (!evaluator.assignType(newUpperTypeBound, curLowerBound, 
+            if (!evaluator.assignType(newUpperBound, curLowerBound, 
             /* diag */ undefined, 
-            /* destConstraints */ undefined, 
-            /* srcConstraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount)) {
+            /* constraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount)) {
                 if (diag && diagAddendum) {
-                    diag.addMessage(localize_1.LocAddendum.typeAssignmentMismatch().format(evaluator.printSrcDestTypes(curLowerBound, newUpperTypeBound)));
+                    diag.addMessage(localize_1.LocAddendum.typeAssignmentMismatch().format(evaluator.printSrcDestTypes(curLowerBound, newUpperBound)));
                     diag.addAddendum(diagAddendum);
                 }
                 return false;
@@ -477,21 +494,19 @@ function assignUnconstrainedTypeVar(evaluator, destType, srcType, diag, constrai
             // If this is an invariant context and there is currently no upper bound
             // established, use the "no literals" version of the lower bound rather
             // than a version that has literals.
-            if (!newUpperTypeBound && isInvariant && (curEntry === null || curEntry === void 0 ? void 0 : curEntry.lowerBoundNoLiterals)) {
-                newLowerBound = curEntry.lowerBoundNoLiterals;
+            if (!newUpperBound && isInvariant && curEntry && !curEntry.retainLiterals) {
+                newLowerBound = stripLiteralsForLowerBound(evaluator, destType, curLowerBound);
             }
         }
         else {
-            if (evaluator.assignType(curLowerBound, adjSrcType, diagAddendum, constraints, 
-            /* srcConstraints */ undefined, flags, recursionCount)) {
+            if (evaluator.assignType(curLowerBound, adjSrcType, diagAddendum, constraints, flags, recursionCount)) {
                 // No need to widen. Stick with the existing type unless it's unknown
                 // or partly unknown, in which case we'll replace it with a known type
                 // as long as it doesn't violate the current lower bound.
                 if ((0, typeUtils_1.isPartlyUnknown)(curLowerBound) &&
                     !(0, types_1.isUnknown)(adjSrcType) &&
                     evaluator.assignType(adjSrcType, curLowerBound, 
-                    /* diag */ undefined, constraints, 
-                    /* srcConstraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount)) {
+                    /* diag */ undefined, constraints, 0 /* AssignTypeFlags.Default */, recursionCount)) {
                     newLowerBound = adjSrcType;
                 }
                 else {
@@ -503,8 +518,7 @@ function assignUnconstrainedTypeVar(evaluator, destType, srcType, diag, constrai
             }
             else if ((0, types_1.isTypeVar)(curLowerBound) &&
                 !(0, types_1.isTypeVar)(adjSrcType) &&
-                evaluator.assignType(evaluator.makeTopLevelTypeVarsConcrete(curLowerBound), adjSrcType, diagAddendum, constraints, 
-                /* srcConstraints */ undefined, flags, recursionCount)) {
+                evaluator.assignType(evaluator.makeTopLevelTypeVarsConcrete(curLowerBound), adjSrcType, diagAddendum, constraints, flags, recursionCount)) {
                 // If the existing lower bound was a TypeVar that is not
                 // part of the current context we can replace it with the new
                 // source type.
@@ -517,8 +531,7 @@ function assignUnconstrainedTypeVar(evaluator, destType, srcType, diag, constrai
                     return false;
                 }
                 if (evaluator.assignType(adjSrcType, curLowerBound, 
-                /* diag */ undefined, constraints, 
-                /* srcConstraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount)) {
+                /* diag */ undefined, constraints, 0 /* AssignTypeFlags.Default */, recursionCount)) {
                     newLowerBound = adjSrcType;
                 }
                 else if ((0, types_1.isTypeVarTuple)(destType)) {
@@ -534,8 +547,8 @@ function assignUnconstrainedTypeVar(evaluator, destType, srcType, diag, constrai
                     // If this is an invariant context and there is currently no upper bound
                     // established, use the "no literals" version of the lower bound rather
                     // than a version that has literals.
-                    if (!newUpperTypeBound && isInvariant && (curEntry === null || curEntry === void 0 ? void 0 : curEntry.lowerBoundNoLiterals)) {
-                        curLowerBound = curEntry.lowerBoundNoLiterals;
+                    if (!newUpperBound && isInvariant && curEntry && !curEntry.retainLiterals) {
+                        curLowerBound = stripLiteralsForLowerBound(evaluator, destType, curLowerBound);
                     }
                     let curSolvedLowerBound = curLowerBound;
                     if (constraints) {
@@ -566,8 +579,7 @@ function assignUnconstrainedTypeVar(evaluator, destType, srcType, diag, constrai
         // isn't too wide.
         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)) {
+            /* constraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount)) {
                 if (diag && diagAddendum) {
                     diag.addMessage(localize_1.LocAddendum.typeAssignmentMismatch().format(evaluator.printSrcDestTypes(newLowerBound, adjSrcType)));
                 }
@@ -577,30 +589,22 @@ function assignUnconstrainedTypeVar(evaluator, destType, srcType, diag, constrai
         // Make sure we don't exceed the upper bound.
         if (curUpperBound && newLowerBound) {
             if (!(0, types_1.isTypeSame)(curUpperBound, newLowerBound, {}, recursionCount)) {
-                let adjUpperBound = evaluator.makeTopLevelTypeVarsConcrete(curUpperBound, 
-                /* makeParamSpecsConcrete */ true);
-                // Convert any remaining (non-top-level) TypeVars in the upper
-                // bound to 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(), 
-                /* destConstraints */ undefined, 
-                /* srcConstraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount)) {
+                if (!evaluator.assignType(curUpperBound, newLowerBound, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), 
+                /* constraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount)) {
                     if (diag && diagAddendum) {
-                        diag.addMessage(localize_1.LocAddendum.typeAssignmentMismatch().format(evaluator.printSrcDestTypes(newLowerBound, adjUpperBound)));
+                        diag.addMessage(localize_1.LocAddendum.typeAssignmentMismatch().format(evaluator.printSrcDestTypes(newLowerBound, curUpperBound)));
                     }
                     return false;
                 }
             }
         }
     }
-    if (!newUpperTypeBound && isInvariant) {
-        newUpperTypeBound = newLowerBound;
+    if (!newUpperBound && isInvariant) {
+        newUpperBound = newLowerBound;
     }
     // If there's a bound type, make sure the source is assignable to it.
     if (destType.shared.boundType) {
-        const updatedType = (newLowerBound || newUpperTypeBound);
+        const updatedType = (newLowerBound || newUpperBound);
         // If the dest is a Type[T] but the source is not a valid Type,
         // skip the assignType check and the diagnostic addendum, which will
         // be confusing and inaccurate.
@@ -611,8 +615,7 @@ function assignUnconstrainedTypeVar(evaluator, destType, srcType, diag, constrai
         // exception. In this case, we need to use the original constraints
         // to solve for the generic type variable(s) in the bound type.
         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)) {
+        if (!evaluator.assignType(destType.shared.boundType, evaluator.makeTopLevelTypeVarsConcrete(updatedType), diag === null || diag === void 0 ? void 0 : diag.createAddendum(), effectiveConstraints, 0 /* AssignTypeFlags.Default */, recursionCount)) {
             // Avoid adding a message that will confuse users if the TypeVar was
             // synthesized for internal purposes.
             if (!destType.shared.isSynthesized) {
@@ -626,7 +629,7 @@ function assignUnconstrainedTypeVar(evaluator, destType, srcType, diag, constrai
         }
     }
     if (constraints && !constraints.isLocked()) {
-        updateTypeVarType(evaluator, constraints, destType, newLowerBound, newUpperTypeBound, (flags & (2048 /* AssignTypeFlags.PopulatingExpectedType */ | 256 /* AssignTypeFlags.RetainLiteralsForTypeVar */)) !== 0);
+        constraints.setBounds(destType, newLowerBound, newUpperBound, (flags & (2048 /* AssignTypeFlags.PopulateExpectedType */ | 256 /* AssignTypeFlags.RetainLiteralsForTypeVar */)) !== 0);
     }
     return true;
 }
@@ -637,12 +640,11 @@ function assignConstrainedTypeVar(evaluator, destType, srcType, diag, constraint
     const curEntry = constraints === null || constraints === void 0 ? void 0 : constraints.getMainConstraintSet().getTypeVar(destType);
     const curUpperBound = curEntry === null || curEntry === void 0 ? void 0 : curEntry.upperBound;
     const curLowerBound = curEntry === null || curEntry === void 0 ? void 0 : curEntry.lowerBound;
-    let forceRetainLiterals = false;
+    let retainLiterals = false;
     if ((0, types_1.isTypeVar)(srcType)) {
         if (evaluator.assignType(destType, concreteSrcType, 
         /* diag */ undefined, 
-        /* destConstraints */ undefined, 
-        /* srcConstraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount)) {
+        /* constraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount)) {
             constrainedType = srcType;
             // If the source and dest are both instantiables (type[T]), then
             // we need to convert to an instance (T).
@@ -670,15 +672,13 @@ function assignConstrainedTypeVar(evaluator, destType, srcType, diag, constraint
                     : constraint;
                 if (evaluator.assignType(adjustedConstraint, srcSubtype, 
                 /* diag */ undefined, 
-                /* destConstraints */ undefined, 
-                /* srcConstraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount)) {
+                /* constraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount)) {
                     if (!constrainedSubtype ||
                         evaluator.assignType(types_1.TypeBase.isInstantiable(destType)
                             ? (0, typeUtils_1.convertToInstantiable)(constrainedSubtype)
                             : constrainedSubtype, adjustedConstraint, 
                         /* diag */ undefined, 
-                        /* destConstraints */ undefined, 
-                        /* srcConstraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount)) {
+                        /* constraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount)) {
                         constrainedSubtype = (0, typeUtils_1.addConditionToType)(constraint, (0, typeUtils_1.getTypeCondition)(srcSubtype));
                         constraintIndexUsed = i;
                     }
@@ -688,7 +688,7 @@ function assignConstrainedTypeVar(evaluator, destType, srcType, diag, constraint
                 // We found a source subtype that is not compatible with the dest.
                 // This is OK if we're handling the contravariant case because only
                 // one subtype needs to be assignable in that case.
-                if ((flags & 2 /* AssignTypeFlags.ReverseTypeVarMatching */) === 0) {
+                if ((flags & 2 /* AssignTypeFlags.Contravariant */) === 0) {
                     isCompatible = false;
                 }
             }
@@ -715,8 +715,7 @@ function assignConstrainedTypeVar(evaluator, destType, srcType, diag, constraint
                     : constraint;
                 return evaluator.assignType(adjustedConstraint, concreteSrcType, 
                 /* diag */ undefined, 
-                /* destConstraints */ undefined, 
-                /* srcConstraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount);
+                /* constraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount);
             });
         }
     }
@@ -731,22 +730,20 @@ function assignConstrainedTypeVar(evaluator, destType, srcType, diag, constraint
         return false;
     }
     else if ((0, typeUtils_1.isLiteralTypeOrUnion)(constrainedType)) {
-        forceRetainLiterals = true;
+        retainLiterals = true;
     }
     if (curLowerBound && !(0, types_1.isAnyOrUnknown)(curLowerBound)) {
         if (!evaluator.assignType(curLowerBound, constrainedType, 
         /* diag */ undefined, 
-        /* destConstraints */ undefined, 
-        /* srcConstraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount)) {
+        /* constraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount)) {
             // Handle the case where one of the constrained types is a wider
             // version of another constrained type that was previously assigned
             // to the type variable.
             if (evaluator.assignType(constrainedType, curLowerBound, 
             /* diag */ undefined, 
-            /* destConstraints */ undefined, 
-            /* srcConstraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount)) {
+            /* constraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount)) {
                 if (constraints && !constraints.isLocked()) {
-                    updateTypeVarType(evaluator, constraints, destType, constrainedType, curUpperBound);
+                    constraints.setBounds(destType, constrainedType, curUpperBound);
                 }
             }
             else {
@@ -761,7 +758,7 @@ function assignConstrainedTypeVar(evaluator, destType, srcType, diag, constraint
     else {
         // Assign the type to the type var.
         if (constraints && !constraints.isLocked()) {
-            updateTypeVarType(evaluator, constraints, destType, constrainedType, curUpperBound, forceRetainLiterals);
+            constraints.setBounds(destType, constrainedType, curUpperBound, retainLiterals);
         }
     }
     return true;
@@ -810,12 +807,10 @@ function assignParamSpec(evaluator, destType, srcType, diag, constraints, recurs
                 const existingFunction = (0, typeUtils_1.simplifyFunctionToParamSpec)((0, typeUtils_1.convertTypeToParamSpecValue)(existingType));
                 const isNewNarrower = evaluator.assignType(existingFunction, newFunction, 
                 /* diag */ undefined, 
-                /* destConstraints */ undefined, 
-                /* srcConstraints */ undefined, 64 /* AssignTypeFlags.SkipReturnTypeCheck */, recursionCount);
+                /* constraints */ undefined, 64 /* AssignTypeFlags.SkipReturnTypeCheck */, recursionCount);
                 const isNewWider = evaluator.assignType(newFunction, existingFunction, 
                 /* diag */ undefined, 
-                /* destConstraints */ undefined, 
-                /* srcConstraints */ undefined, 64 /* AssignTypeFlags.SkipReturnTypeCheck */, recursionCount);
+                /* constraints */ undefined, 64 /* AssignTypeFlags.SkipReturnTypeCheck */, recursionCount);
                 // Should we widen the type?
                 if (isNewNarrower && isNewWider) {
                     // The new type is both a supertype and a subtype of the existing type.
@@ -860,24 +855,6 @@ function assignParamSpec(evaluator, destType, srcType, diag, constraints, recurs
     });
     return isAssignable;
 }
-class UnificationVarTransformer extends typeUtils_1.TypeVarTransformer {
-    constructor(_evaluator, _constraintSet) {
-        super();
-        this._evaluator = _evaluator;
-        this._constraintSet = _constraintSet;
-    }
-    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;
-    }
-}
-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.
@@ -946,9 +923,8 @@ function logConstraints(evaluator, constraints, indent) {
 function logTypeVarConstraintSet(evaluator, context, indent) {
     let loggedConstraint = false;
     context.getTypeVars().forEach((entry) => {
-        var _a;
         const typeVarName = `${indent}${entry.typeVar.shared.name}`;
-        const lowerBound = (_a = entry.lowerBoundNoLiterals) !== null && _a !== void 0 ? _a : entry.lowerBound;
+        const lowerBound = entry.lowerBound;
         const upperBound = entry.upperBound;
         // Log the lower and upper bounds.
         if (lowerBound && upperBound && (0, types_1.isTypeSame)(lowerBound, upperBound)) {