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

package/dist/analyzer/constraintSolver.js

@@ -17,10 +17,10 @@ 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;
+const maxSubtypeCountForTypeVarLowerBound = 64;
 // This debugging switch enables logging of the TypeVarContext before and
 // after it is updated by the constraint solver.
 const logTypeVarContextUpdates = false;
@@ -39,7 +39,6 @@ function assignTypeToTypeVar(evaluator, destType, srcType, diag, typeVarContext,
         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);
     }
     let isTypeVarInScope = true;
@@ -66,16 +65,16 @@ function assignTypeToTypeVar(evaluator, destType, srcType, diag, typeVarContext,
         }
         // 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 (!srcType.priv.typeArgs ||
+                srcType.priv.typeArgs.length < 1 ||
+                (0, types_1.isAnyOrUnknown)(srcType.priv.typeArgs[0])) {
                 if (types_1.TypeBase.isInstantiable(destType)) {
                     return true;
                 }
             }
         }
         // Is this the equivalent of an "Unknown" for a ParamSpec?
-        if (destType.shared.isParamSpec &&
+        if ((0, types_1.isParamSpec)(destType) &&
             (0, types_1.isFunction)(srcType) &&
             types_1.FunctionType.isParamSpecValue(srcType) &&
             types_1.FunctionType.isGradualCallableForm(srcType)) {
@@ -109,16 +108,16 @@ function assignTypeToTypeVar(evaluator, destType, srcType, diag, typeVarContext,
         /* destTypeVarContext */ undefined, 
         /* srcTypeVarContext */ undefined, flags, recursionCount);
     }
-    if (destType.shared.isParamSpec) {
+    if ((0, types_1.isParamSpec)(destType)) {
         return assignTypeToParamSpec(evaluator, destType, srcType, diag, typeVarContext, recursionCount);
     }
-    if (destType.shared.isVariadic && !destType.priv.isVariadicInUnion) {
+    if ((0, types_1.isTypeVarTuple)(destType) && !destType.priv.isVariadicInUnion) {
         if (!(0, types_1.isUnpacked)(srcType)) {
             const tupleClassType = evaluator.getTupleClassType();
             if (tupleClassType && (0, types_1.isInstantiableClass)(tupleClassType)) {
                 // Package up the type into a tuple.
                 srcType = (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(tupleClassType, [{ type: srcType, isUnbounded: false }], 
-                /* isTypeArgumentExplicit */ true, 
+                /* isTypeArgExplicit */ true, 
                 /* isUnpackedTuple */ true));
             }
             else {
@@ -128,11 +127,10 @@ function assignTypeToTypeVar(evaluator, destType, srcType, diag, typeVarContext,
     }
     // 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 &&
+    if ((0, types_1.isTypeVarTuple)(srcType) &&
         srcType.priv.isVariadicUnpacked &&
         !srcType.priv.isVariadicInUnion &&
-        !destType.shared.isVariadic) {
+        !(0, types_1.isTypeVarTuple)(destType)) {
         srcType = types_1.TypeVarType.cloneForUnpacked(srcType, /* isInUnion */ true);
     }
     // Handle the constrained case. This case needs to be handled specially
@@ -143,19 +141,19 @@ function assignTypeToTypeVar(evaluator, destType, srcType, diag, typeVarContext,
         return assignTypeToConstrainedTypeVar(evaluator, destType, srcType, diag, typeVarContext, flags, isTypeVarInScope, recursionCount);
     }
     // 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 = typeVarContext.getMainSolutionSet().getTypeVar(destType);
+    let curUpperBound = curEntry === null || curEntry === void 0 ? void 0 : curEntry.upperBound;
+    if (!curUpperBound && !destType.shared.isSynthesizedSelf) {
+        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 +185,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;
+        // Update the upper bound.
+        if (!curUpperBound || (0, types_1.isTypeSame)(destType, curUpperBound)) {
+            newUpperTypeBound = adjSrcType;
         }
-        else if (!(0, types_1.isTypeSame)(curWideTypeBound, adjSrcType, {}, recursionCount)) {
-            if (evaluator.assignType(curWideTypeBound, evaluator.makeTopLevelTypeVarsConcrete(adjSrcType), diagAddendum, 
+        else if (!(0, types_1.isTypeSame)(curUpperBound, adjSrcType, {}, recursionCount)) {
+            if (evaluator.assignType(curUpperBound, evaluator.makeTopLevelTypeVarsConcrete(adjSrcType), diagAddendum, 
             /* destTypeVarContext */ undefined, 
             /* srcTypeVarContext */ undefined, flags & 1024 /* AssignTypeFlags.IgnoreTypeVarScope */, recursionCount)) {
-                // The srcType is narrower than the current wideTypeBound, so replace it.
-                newWideTypeBound = adjSrcType;
+                // The srcType is narrower than the current upper bound, so replace it.
+                newUpperTypeBound = adjSrcType;
             }
-            else if (!evaluator.assignType(adjSrcType, curWideTypeBound, diagAddendum, 
+            else if (!evaluator.assignType(adjSrcType, curUpperBound, diagAddendum, 
             /* destTypeVarContext */ undefined, 
             /* srcTypeVarContext */ undefined, flags & 1024 /* AssignTypeFlags.IgnoreTypeVarScope */, 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)) {
                 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,138 +237,132 @@ 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, 
+            if (evaluator.assignType(curLowerBound, adjSrcType, diagAddendum, typeVarContext, 
             /* srcTypeVarContext */ 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, 
+                    evaluator.assignType(adjSrcType, curLowerBound, 
                     /* diag */ undefined, typeVarContext, 
                     /* srcTypeVarContext */ undefined, flags & 1024 /* AssignTypeFlags.IgnoreTypeVarScope */, recursionCount)) {
-                    newNarrowTypeBound = adjSrcType;
+                    newLowerBound = adjSrcType;
                 }
                 else {
-                    newNarrowTypeBound = (0, typeUtils_1.applySolvedTypeVars)(curNarrowTypeBound, typeVarContext);
+                    newLowerBound = (0, typeUtils_1.applySolvedTypeVars)(curLowerBound, typeVarContext);
                 }
             }
-            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, 
+                evaluator.assignType(evaluator.makeTopLevelTypeVarsConcrete(curLowerBound), adjSrcType, diagAddendum, typeVarContext, 
                 /* srcTypeVarContext */ undefined, flags, recursionCount)) {
-                // If the existing narrow type bound was a TypeVar that is not
+                // 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)));
+                    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, 
+                if (evaluator.assignType(adjSrcType, curLowerBound, 
                 /* diag */ undefined, typeVarContext, 
                 /* srcTypeVarContext */ undefined, flags & 1024 /* AssignTypeFlags.IgnoreTypeVarScope */, recursionCount)) {
-                    newNarrowTypeBound = adjSrcType;
+                    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;
                     }
-                    const curSolvedNarrowTypeBound = (0, typeUtils_1.applySolvedTypeVars)(curNarrowTypeBound, typeVarContext);
-                    // In some extreme edge cases, the narrow type bound can become
+                    const curSolvedLowerBound = (0, typeUtils_1.applySolvedTypeVars)(curLowerBound, typeVarContext);
+                    // In some extreme edge cases, the lower bound can become
                     // a union with so many subtypes that performance grinds to a
                     // halt. We'll detect this case and widen the resulting type
                     // 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 &&
+                    if ((0, types_1.isUnion)(curSolvedLowerBound) &&
+                        curSolvedLowerBound.priv.subtypes.length > typeEvaluatorTypes_1.maxSubtypesForInferredType &&
                         destType.shared.boundType !== undefined &&
                         (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(), 
+        if (isInvariant && newLowerBound) {
+            if (!evaluator.assignType(adjSrcType, newLowerBound, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), 
             /* destTypeVarContext */ undefined, 
             /* srcTypeVarContext */ undefined, 1024 /* AssignTypeFlags.IgnoreTypeVarScope */, recursionCount)) {
                 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
+                // Convert any remaining (non-top-level) TypeVars in the upper
                 // bound to in-scope placeholders.
-                adjWideTypeBound = (0, typeUtils_1.transformExpectedType)(adjWideTypeBound, 
+                adjUpperBound = (0, typeUtils_1.transformExpectedType)(adjUpperBound, 
                 /* liveTypeVarScopes */ [], 
                 /* usageOffset */ undefined);
-                if (!evaluator.assignType(adjWideTypeBound, newNarrowTypeBound, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), 
+                if (!evaluator.assignType(adjUpperBound, newLowerBound, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), 
                 /* destTypeVarContext */ undefined, 
                 /* srcTypeVarContext */ undefined, 1024 /* AssignTypeFlags.IgnoreTypeVarScope */, 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.
@@ -397,56 +389,45 @@ 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);
+        updateTypeVarType(evaluator, typeVarContext, destType, newLowerBound, newUpperTypeBound, (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);
     }
     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
+// 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 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);
+// the upper bound.
+function updateTypeVarType(evaluator, typeVarContext, destType, lowerBound, upperBound, forceRetainLiterals = false) {
+    let lowerBoundNoLiterals;
+    if (lowerBound && !forceRetainLiterals) {
+        const strippedLiteral = (0, types_1.isTypeVarTuple)(destType)
+            ? stripLiteralValueForUnpackedTuple(evaluator, lowerBound)
+            : evaluator.stripLiteralValue(lowerBound);
+        // Strip the literals from the lower bound and see if it is still
+        // narrower than the upper bound.
+        if (strippedLiteral !== lowerBound) {
+            if (!upperBound || evaluator.assignType(upperBound, strippedLiteral)) {
+                lowerBoundNoLiterals = strippedLiteral;
+            }
+        }
+    }
+    typeVarContext.setTypeVarType(destType, lowerBound, lowerBoundNoLiterals, upperBound); //, tupleTypes);
 }
 exports.updateTypeVarType = updateTypeVarType;
 function assignTypeToConstrainedTypeVar(evaluator, destType, srcType, diag, typeVarContext, flags, isTypeVarInScope, recursionCount) {
     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 = typeVarContext.getMainSolutionSet().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, 
@@ -542,26 +523,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)) {
             // 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);
+                    updateTypeVarType(evaluator, typeVarContext, 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;
             }
@@ -570,8 +551,7 @@ 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);
+            updateTypeVarType(evaluator, typeVarContext, destType, constrainedType, curUpperBound, forceRetainLiterals);
         }
     }
     return true;
@@ -579,9 +559,9 @@ function assignTypeToConstrainedTypeVar(evaluator, destType, srcType, diag, type
 function assignTypeToParamSpec(evaluator, destType, srcType, diag, typeVarContext, recursionCount = 0) {
     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);
+    typeVarContext.doForEachSolutionSet((solutionSet) => {
+        if ((0, types_1.isParamSpec)(adjSrcType)) {
+            const existingType = solutionSet.getTypeVarType(destType);
             if (existingType) {
                 const existingTypeParamSpec = types_1.FunctionType.getParamSpecFromArgsKwargs(existingType);
                 const existingTypeWithoutArgsKwargs = types_1.FunctionType.cloneRemoveParamSpecArgsKwargs(existingType);
@@ -594,7 +574,7 @@ function assignTypeToParamSpec(evaluator, destType, srcType, diag, typeVarContex
             }
             else {
                 if (!typeVarContext.isLocked() && typeVarContext.hasSolveForScope(destType.priv.scopeId)) {
-                    signatureContext.setTypeVarType(destType, (0, typeUtils_1.convertTypeToParamSpecValue)(adjSrcType));
+                    solutionSet.setTypeVarType(destType, (0, typeUtils_1.convertTypeToParamSpecValue)(adjSrcType));
                 }
                 return;
             }
@@ -602,7 +582,7 @@ 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 = solutionSet.getTypeVarType(destType);
             if (existingType) {
                 // Convert the remaining portion of the signature to a function
                 // for comparison purposes.
@@ -610,11 +590,11 @@ function assignTypeToParamSpec(evaluator, destType, srcType, diag, typeVarContex
                 const isNewNarrower = evaluator.assignType(existingFunction, newFunction, 
                 /* diag */ undefined, 
                 /* destTypeVarContext */ undefined, 
-                /* srcTypeVarContext */ undefined, 64 /* AssignTypeFlags.SkipFunctionReturnTypeCheck */, recursionCount);
+                /* srcTypeVarContext */ undefined, 64 /* AssignTypeFlags.SkipReturnTypeCheck */, recursionCount);
                 const isNewWider = evaluator.assignType(newFunction, existingFunction, 
                 /* diag */ undefined, 
                 /* destTypeVarContext */ undefined, 
-                /* srcTypeVarContext */ undefined, 64 /* AssignTypeFlags.SkipFunctionReturnTypeCheck */, recursionCount);
+                /* srcTypeVarContext */ 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.
@@ -643,7 +623,7 @@ function assignTypeToParamSpec(evaluator, destType, srcType, diag, typeVarContex
             }
             if (updateContextWithNewFunction) {
                 if (!typeVarContext.isLocked() && typeVarContext.hasSolveForScope(destType.priv.scopeId)) {
-                    signatureContext.setTypeVarType(destType, newFunction);
+                    solutionSet.setTypeVarType(destType, newFunction);
                 }
                 return;
             }
@@ -673,7 +653,7 @@ function assignTypeToParamSpec(evaluator, destType, srcType, diag, typeVarContex
 // it returns false.
 function addConstraintsForExpectedType(evaluator, type, expectedType, typeVarContext, liveTypeVarScopes, usageOffset = undefined) {
     if ((0, types_1.isAny)(expectedType)) {
-        type.shared.typeParameters.forEach((typeParam) => {
+        type.shared.typeParams.forEach((typeParam) => {
             updateTypeVarType(evaluator, typeVarContext, typeParam, expectedType, expectedType);
         });
         return true;
@@ -685,84 +665,64 @@ function addConstraintsForExpectedType(evaluator, type, expectedType, typeVarCon
         return false;
     }
     // If the expected type is generic (but not specialized), we can't proceed.
-    const expectedTypeArgs = expectedType.priv.typeArguments;
+    const expectedTypeArgs = expectedType.priv.typeArgs;
     if (!expectedTypeArgs) {
         return evaluator.assignType(type, expectedType, 
         /* diag */ undefined, typeVarContext, 
         /* srcTypeVarContext */ undefined, 2048 /* AssignTypeFlags.PopulatingExpectedType */);
     }
-    evaluator.inferTypeParameterVarianceForClass(type);
+    evaluator.inferVarianceForClass(type);
     // If the expected type is the same as the target type (commonly the case),
     // we can use a faster method.
     if (types_1.ClassType.isSameGenericClass(expectedType, type)) {
         const sameClassTypeVarContext = (0, typeUtils_1.buildTypeVarContextFromSpecializedClass)(expectedType);
         sameClassTypeVarContext
-            .getPrimarySignature()
+            .getMainSolutionSet()
             .getTypeVars()
             .forEach((entry) => {
-            let typeArgValue = sameClassTypeVarContext.getPrimarySignature().getTypeVarType(entry.typeVar);
+            let typeArgValue = sameClassTypeVarContext.getMainSolutionSet().getTypeVarType(entry.typeVar);
             if (typeArgValue && liveTypeVarScopes) {
                 typeArgValue = (0, typeUtils_1.transformExpectedType)(typeArgValue, liveTypeVarScopes, usageOffset);
             }
             if (typeArgValue) {
                 const variance = types_1.TypeVarType.getVariance(entry.typeVar);
                 updateTypeVarType(evaluator, typeVarContext, entry.typeVar, variance === 3 /* Variance.Covariant */ ? undefined : typeArgValue, variance === 4 /* Variance.Contravariant */ ? undefined : typeArgValue);
-                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}`);
+    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;
-        if (typeParam.shared.isParamSpec) {
-            typeVar.shared.isParamSpec = true;
-        }
-        // Use invariance here so we set the narrow and wide values on the TypeVar.
+        // 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.cloneForSpecialization(expectedType, synthExpectedTypeArgs, 
-    /* isTypeArgumentExplicit */ true);
+    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.getTypeParameters(type).map((typeParam, index) => {
-        const typeVar = types_1.TypeVarType.createInstance(`__source${index}`);
+    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;
-        if (typeParam.shared.isParamSpec) {
-            typeVar.shared.isParamSpec = true;
-        }
         return types_1.TypeVarType.cloneAsInScopePlaceholder(typeVar);
     });
-    const specializedType = types_1.ClassType.cloneForSpecialization(type, typeArgs, /* isTypeArgumentExplicit */ true);
+    const specializedType = types_1.ClassType.specialize(type, typeArgs);
     const syntheticTypeVarContext = new typeVarContext_1.TypeVarContext(expectedTypeScopeId);
     if (evaluator.assignType(genericExpectedType, specializedType, 
     /* diag */ undefined, syntheticTypeVarContext, 
     /* srcTypeVarContext */ undefined, 2048 /* AssignTypeFlags.PopulatingExpectedType */)) {
         let isResultValid = true;
         synthExpectedTypeArgs.forEach((typeVar, index) => {
-            let synthTypeVar = syntheticTypeVarContext.getPrimarySignature().getTypeVarType(typeVar);
+            let synthTypeVar = syntheticTypeVarContext.getMainSolutionSet().getTypeVarType(typeVar);
             const otherSubtypes = [];
             // If the resulting type is a union, try to find a matching type var and move
             // the remaining subtypes to the "otherSubtypes" array.
             if (synthTypeVar) {
-                if (typeVar.shared.isParamSpec && (0, types_1.isFunction)(synthTypeVar)) {
+                if ((0, types_1.isParamSpec)(typeVar) && (0, types_1.isFunction)(synthTypeVar)) {
                     synthTypeVar = (0, typeUtils_1.convertParamSpecValueToType)(synthTypeVar);
                 }
                 if ((0, types_1.isUnion)(synthTypeVar)) {
@@ -789,7 +749,7 @@ function addConstraintsForExpectedType(evaluator, type, expectedType, typeVarCon
                 (0, types_1.isTypeVar)(synthTypeVar) &&
                 synthTypeVar.shared.isSynthesized &&
                 synthTypeVar.shared.synthesizedIndex !== undefined) {
-                const targetTypeVar = types_1.ClassType.getTypeParameters(specializedType)[synthTypeVar.shared.synthesizedIndex];
+                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) {
@@ -803,7 +763,7 @@ function addConstraintsForExpectedType(evaluator, type, expectedType, typeVarCon
                         // 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)) {
+                        if (typeVarContext.getMainSolutionSet().getTypeVarType(targetTypeVar)) {
                             isResultValid = false;
                             typeArgValue = types_1.UnknownType.create();
                         }
@@ -823,7 +783,7 @@ exports.addConstraintsForExpectedType = addConstraintsForExpectedType;
 // For normal TypeVars, the constraint solver can widen a type by combining
 // two otherwise incompatible types into a union. For TypeVarTuples, we need
 // to do the equivalent operation for unpacked tuples.
-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 +793,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 +808,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 +826,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) {
+    const solutionSetCount = typeVarContext.getSolutionSets().length;
+    if (solutionSetCount === 0) {
         console.log(`${indent}  no signatures`);
     }
-    else if (signatureContextCount === 1) {
-        logTypeVarSignatureContext(evaluator, typeVarContext.getSignatureContexts()[0], `${indent}  `);
+    else if (solutionSetCount === 1) {
+        logTypeVarSolutionSet(evaluator, typeVarContext.getSolutionSets()[0], `${indent}  `);
     }
     else {
-        typeVarContext.doForEachSignatureContext((context, signatureIndex) => {
-            console.log(`${indent}  signature ${signatureIndex}`);
-            logTypeVarSignatureContext(evaluator, context, `${indent}    `);
+        typeVarContext.doForEachSolutionSet((solutionSet, index) => {
+            console.log(`${indent}  signature ${index}`);
+            logTypeVarSolutionSet(evaluator, solutionSet, `${indent}    `);
         });
     }
 }
-function logTypeVarSignatureContext(evaluator, context, indent) {
+function logTypeVarSolutionSet(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;
             }
         }