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

package/dist/analyzer/typeUtils.js

@@ -9,14 +9,14 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isTupleClass = exports.isTupleGradualForm = exports.isMaybeDescriptorInstance = exports.isDescriptorInstance = exports.isCallableType = exports.isProperty = exports.isEllipsisType = exports.getUnionSubtypeCount = exports.getLiteralTypeClassName = exports.containsLiteralType = exports.isLiteralTypeOrUnion = exports.isLiteralType = exports.getSpecializedTupleType = exports.selfSpecializeClass = exports.getUnknownTypeForCallable = exports.getUnknownForTypeVarTuple = exports.getUnknownForTypeVar = exports.specializeWithUnknownTypeArgs = exports.specializeWithDefaultTypeArgs = exports.getTypeVarScopeIds = exports.getTypeVarScopeId = exports.transformPossibleRecursiveTypeAlias = exports.isTypeAliasRecursive = exports.isTypeAliasPlaceholder = exports.getTypeCondition = exports.addConditionToType = exports.getFullNameOfType = exports.derivesFromAnyOrUnknown = exports.isUnionableType = exports.preserveUnknown = exports.areTypesSame = exports.doForEachSignature = exports.allSubtypes = exports.someSubtypes = exports.doForEachSubtype = exports.sortTypes = exports.cleanIncompleteUnknown = exports.mapSignatures = exports.mapSubtypes = exports.makeInferenceContext = exports.isTypeVarSame = exports.isIncompleteUnknown = exports.removeNoneFromUnion = exports.isNoneTypeClass = exports.isNoneInstance = exports.isOptionalType = exports.UniqueSignatureTracker = exports.AssignTypeFlags = exports.ClassIteratorFlags = exports.MemberAccessFlags = void 0;
-exports.requiresTypeArgs = exports.getGeneratorTypeArgs = exports.specializeTupleClass = exports.combineTupleTypeArgs = exports.combineSameSizedTuples = exports.explodeGenericClass = exports.isPartlyUnknown = exports.containsAnyOrUnknown = exports.containsAnyRecursive = exports.getMembersForModule = exports.getMembersForClass = exports.convertToInstantiable = exports.convertToInstance = exports.isEffectivelyInstantiable = exports.isMetaclassInstance = exports.isInstantiableMetaclass = exports.getGeneratorYieldType = exports.getDeclaredGeneratorReturnType = exports.synthesizeTypeVarForSelfCls = exports.derivesFromClassRecursive = exports.derivesFromStdlibClass = exports.specializeForBaseClass = exports.buildTypeVarContext = exports.buildTypeVarContextFromSpecializedClass = exports.setTypeArgsRecursive = exports.specializeClassType = exports.getTypeVarArgsRecursive = exports.addTypeVarsToListIfUnique = exports.getClassFieldsRecursive = exports.getClassIterator = exports.getClassMemberIterator = exports.lookUpClassMember = exports.lookUpObjectMember = exports.getContainerDepth = exports.getProtocolSymbolsRecursive = exports.getProtocolSymbols = exports.transformExpectedType = exports.replaceTypeVarsWithAny = exports.validateTypeVarDefault = exports.applyInScopePlaceholders = exports.applySourceContextTypeVarsToSignature = exports.applySourceContextTypeVars = exports.applySolvedTypeVars = exports.updateTypeWithExternalTypeVars = exports.updateTypeWithInternalTypeVars = exports.ensureFunctionSignaturesAreUnique = exports.populateTypeVarContextForSelfType = exports.partiallySpecializeType = exports.isTupleIndexUnambiguous = exports.isUnboundedTupleClass = void 0;
-exports.convertParamSpecValueToType = exports.setTypeVarType = exports.convertTypeToParamSpecValue = exports.convertNodeToArg = exports.getDeclaringModulesForType = exports.computeMroLinearization = exports.isVarianceOfTypeArgCompatible = exports.combineVariances = exports.requiresSpecialization = void 0;
+exports.combineVariances = exports.requiresSpecialization = exports.requiresTypeArgs = exports.getGeneratorTypeArgs = exports.specializeTupleClass = exports.combineTupleTypeArgs = exports.combineSameSizedTuples = exports.explodeGenericClass = exports.isPartlyUnknown = exports.containsAnyOrUnknown = exports.containsAnyRecursive = exports.getMembersForModule = exports.getMembersForClass = exports.convertToInstantiable = exports.convertToInstance = exports.isEffectivelyInstantiable = exports.isMetaclassInstance = exports.isInstantiableMetaclass = exports.getGeneratorYieldType = exports.getDeclaredGeneratorReturnType = exports.synthesizeTypeVarForSelfCls = exports.derivesFromClassRecursive = exports.derivesFromStdlibClass = exports.specializeForBaseClass = exports.buildSolution = exports.buildSolutionFromSpecializedClass = exports.setTypeArgsRecursive = exports.specializeClassType = exports.getTypeVarArgsRecursive = exports.addTypeVarsToListIfUnique = exports.getClassFieldsRecursive = exports.getClassIterator = exports.getClassMemberIterator = exports.lookUpClassMember = exports.lookUpObjectMember = exports.getContainerDepth = exports.getProtocolSymbolsRecursive = exports.getProtocolSymbols = exports.transformExpectedType = exports.validateTypeVarDefault = exports.applySourceContextTypeVarsToSignature = exports.applySourceContextTypeVars = exports.applySolvedTypeVars = exports.makeTypeVarsFree = exports.makeTypeVarsBound = exports.ensureSignaturesAreUnique = exports.addSolutionForSelfType = exports.partiallySpecializeType = exports.isTupleIndexUnambiguous = exports.isUnboundedTupleClass = void 0;
+exports.TypeVarTransformer = exports.simplifyFunctionToParamSpec = exports.convertTypeToParamSpecValue = exports.convertNodeToArg = exports.getDeclaringModulesForType = exports.computeMroLinearization = exports.isVarianceOfTypeArgCompatible = void 0;
 const collectionUtils_1 = require("../common/collectionUtils");
 const debug_1 = require("../common/debug");
+const constraintSolution_1 = require("./constraintSolution");
 const symbol_1 = require("./symbol");
 const symbolUtils_1 = require("./symbolUtils");
 const types_1 = require("./types");
-const typeVarContext_1 = require("./typeVarContext");
 const typeWalker_1 = require("./typeWalker");
 var MemberAccessFlags;
 (function (MemberAccessFlags) {
@@ -88,10 +88,10 @@ var AssignTypeFlags;
     // This has the potential of recursing infinitely. This flag allows us
     // to detect the recursion after the first level of checking.
     AssignTypeFlags[AssignTypeFlags["SkipRecursiveTypeCheck"] = 4] = "SkipRecursiveTypeCheck";
-    // Normally type vars are treated as variables that need to
-    // be "solved". If this flag is set, they are treated as types
-    // that must match. It is used for overload consistency checking.
-    AssignTypeFlags[AssignTypeFlags["SkipSolveTypeVars"] = 8] = "SkipSolveTypeVars";
+    // During TypeVar solving for a function call, this flag is set if
+    // this is the first of multiple passes. It adjusts certain heuristics
+    // for constraint solving.
+    AssignTypeFlags[AssignTypeFlags["ArgAssignmentFirstPass"] = 8] = "ArgAssignmentFirstPass";
     // If the dest is not Any but the src is Any, treat it
     // as incompatible. Also, treat all source TypeVars as their
     // concrete counterparts. This option is used for validating
@@ -111,11 +111,7 @@ var AssignTypeFlags;
     // because overloads can provide explicit type annotations for self
     // or cls.
     AssignTypeFlags[AssignTypeFlags["SkipSelfClsTypeCheck"] = 512] = "SkipSelfClsTypeCheck";
-    // If an assignment is made to a TypeVar that is out of scope,
-    // do not generate an error. This is used for populating the
-    // typeVarContext when handling contravariant parameters in a callable.
-    AssignTypeFlags[AssignTypeFlags["IgnoreTypeVarScope"] = 1024] = "IgnoreTypeVarScope";
-    // We're initially populating the typeVarContext with an expected type,
+    // We're initially populating the constraints with an expected type,
     // so TypeVars should match the specified type exactly rather than
     // employing narrowing or widening, and don't strip literals.
     AssignTypeFlags[AssignTypeFlags["PopulatingExpectedType"] = 2048] = "PopulatingExpectedType";
@@ -214,7 +210,7 @@ function isTypeVarSame(type1, type2) {
         return true;
     }
     // If this isn't a bound TypeVar, return false.
-    if ((0, types_1.isParamSpec)(type1) || (0, types_1.isTypeVarTuple)(type1) || !type1.shared.boundType) {
+    if ((0, types_1.isParamSpec)(type1) || (0, types_1.isTypeVarTuple)(type1) || !types_1.TypeVarType.hasBound(type1)) {
         return false;
     }
     // If the second type isn't a union, return false.
@@ -267,17 +263,17 @@ function mapSubtypes(type, callback, options) {
                 for (i++; i < subtypes.length; i++) {
                     accumulateSubtype(callback(subtypes[i]));
                 }
-                const newType = (0, types_1.combineTypes)(typesToCombine, {
+                let newType = (0, types_1.combineTypes)(typesToCombine, {
                     skipElideRedundantLiterals: options === null || options === void 0 ? void 0 : options.skipElideRedundantLiterals,
                 });
                 if (options === null || options === void 0 ? void 0 : options.retainTypeAlias) {
                     if ((_a = type.props) === null || _a === void 0 ? void 0 : _a.typeAliasInfo) {
-                        types_1.TypeBase.setTypeAliasInfo(newType, type.props.typeAliasInfo);
+                        newType = types_1.TypeBase.cloneForTypeAlias(newType, type.props.typeAliasInfo);
                     }
                 }
                 else {
                     // Do our best to retain type aliases.
-                    if (newType.category === 8 /* TypeCategory.Union */) {
+                    if ((0, types_1.isUnion)(newType)) {
                         types_1.UnionType.addTypeAliasSource(newType, type);
                     }
                 }
@@ -422,7 +418,7 @@ function compareTypes(a, b, recursionCount = 0) {
                 if (aParam.category !== bParam.category) {
                     return bParam.category - aParam.category;
                 }
-                const typeComparison = compareTypes(types_1.FunctionType.getEffectiveParamType(a, i), types_1.FunctionType.getEffectiveParamType(bFunc, i));
+                const typeComparison = compareTypes(types_1.FunctionType.getParamType(a, i), types_1.FunctionType.getParamType(bFunc, i));
                 if (typeComparison !== 0) {
                     return typeComparison;
                 }
@@ -667,7 +663,7 @@ function addConditionToType(type, condition, skipSelfCondition = false) {
         return type;
     }
     if (skipSelfCondition) {
-        condition = condition.filter((c) => !c.typeVar.shared.isSynthesizedSelf);
+        condition = condition.filter((c) => !types_1.TypeVarType.isSelf(c.typeVar));
         if (condition.length === 0) {
             return type;
         }
@@ -745,14 +741,14 @@ function transformPossibleRecursiveTypeAlias(type) {
             if (!(aliasInfo === null || aliasInfo === void 0 ? void 0 : aliasInfo.typeArgs) || !type.shared.recursiveAlias.typeParams) {
                 return unspecializedType;
             }
-            const typeVarContext = buildTypeVarContext(type.shared.recursiveAlias.typeParams, aliasInfo.typeArgs, getTypeVarScopeId(type));
-            return applySolvedTypeVars(unspecializedType, typeVarContext);
+            const solution = buildSolution(type.shared.recursiveAlias.typeParams, aliasInfo.typeArgs);
+            return applySolvedTypeVars(unspecializedType, solution);
         }
         if ((0, types_1.isUnion)(type) && type.priv.includesRecursiveTypeAlias) {
             let newType = mapSubtypes(type, (subtype) => transformPossibleRecursiveTypeAlias(subtype));
             if (newType !== type && aliasInfo) {
                 // Copy the type alias information if present.
-                newType = types_1.TypeBase.cloneForTypeAlias(newType, aliasInfo.name, aliasInfo.fullName, aliasInfo.moduleName, aliasInfo.fileUri, aliasInfo.typeVarScopeId, aliasInfo.isPep695Syntax, aliasInfo.typeParams, aliasInfo.typeArgs);
+                newType = types_1.TypeBase.cloneForTypeAlias(newType, aliasInfo);
             }
             return newType;
         }
@@ -785,9 +781,6 @@ function getTypeVarScopeIds(type) {
         if (type.priv.constructorTypeVarScopeId) {
             scopeIds.push(type.priv.constructorTypeVarScopeId);
         }
-        if (type.priv.higherOrderTypeVarScopeIds) {
-            scopeIds.push(...type.priv.higherOrderTypeVarScopeIds);
-        }
     }
     return scopeIds;
 }
@@ -856,7 +849,7 @@ function selfSpecializeClass(type, options) {
         return type;
     }
     const typeParams = type.shared.typeParams.map((typeParam) => {
-        return (options === null || options === void 0 ? void 0 : options.useInternalTypeVars) ? types_1.TypeVarType.cloneWithInternalScopeId(typeParam) : typeParam;
+        return (options === null || options === void 0 ? void 0 : options.useBoundTypeVars) ? types_1.TypeVarType.cloneAsBound(typeParam) : typeParam;
     });
     return types_1.ClassType.specialize(type, typeParams);
 }
@@ -883,8 +876,8 @@ function getSpecializedTupleType(type) {
     if (types_1.ClassType.isSameGenericClass(classType, tupleClass)) {
         return classType;
     }
-    const typeVarContext = buildTypeVarContextFromSpecializedClass(classType);
-    return applySolvedTypeVars(tupleClass, typeVarContext);
+    const solution = buildSolutionFromSpecializedClass(classType);
+    return applySolvedTypeVars(tupleClass, solution);
 }
 exports.getSpecializedTupleType = getSpecializedTupleType;
 function isLiteralType(type) {
@@ -1069,11 +1062,11 @@ function partiallySpecializeType(type, contextClassType, typeClassType, selfClas
         return type;
     }
     // Partially specialize the type using the specialized class type vars.
-    const typeVarContext = buildTypeVarContextFromSpecializedClass(contextClassType);
+    const solution = buildSolutionFromSpecializedClass(contextClassType);
     if (selfClass) {
-        populateTypeVarContextForSelfType(typeVarContext, contextClassType, selfClass);
+        addSolutionForSelfType(solution, contextClassType, selfClass);
     }
-    let result = applySolvedTypeVars(type, typeVarContext, { typeClassType });
+    let result = applySolvedTypeVars(type, solution, { typeClassType });
     // If this is a property, we may need to partially specialize the
     // access methods associated with it.
     if ((0, types_1.isClass)(result)) {
@@ -1096,7 +1089,7 @@ function partiallySpecializeType(type, contextClassType, typeClassType, selfClas
     return result;
 }
 exports.partiallySpecializeType = partiallySpecializeType;
-function populateTypeVarContextForSelfType(typeVarContext, contextClassType, selfClass) {
+function addSolutionForSelfType(solution, contextClassType, selfClass) {
     const synthesizedSelfTypeVar = synthesizeTypeVarForSelfCls(contextClassType, /* isClsParam */ false);
     const selfInstance = convertToInstance(selfClass);
     // We can't call stripLiteralValue here because that method requires the type evaluator.
@@ -1109,89 +1102,58 @@ function populateTypeVarContextForSelfType(typeVarContext, contextClassType, sel
         }
         return subtype;
     });
-    if (!(0, types_1.isTypeSame)(synthesizedSelfTypeVar, selfWithoutLiteral)) {
-        setTypeVarType(typeVarContext, synthesizedSelfTypeVar, selfInstance, selfWithoutLiteral);
-    }
+    solution.setType(synthesizedSelfTypeVar, selfWithoutLiteral);
 }
-exports.populateTypeVarContextForSelfType = populateTypeVarContextForSelfType;
+exports.addSolutionForSelfType = addSolutionForSelfType;
 // Looks for duplicate function types within the type and ensures that
 // if they are generic, they have unique type variables.
-function ensureFunctionSignaturesAreUnique(type, signatureTracker, expressionOffset) {
+function ensureSignaturesAreUnique(type, signatureTracker, expressionOffset) {
     const transformer = new UniqueFunctionSignatureTransformer(signatureTracker, expressionOffset);
     return transformer.apply(type, 0);
 }
-exports.ensureFunctionSignaturesAreUnique = ensureFunctionSignaturesAreUnique;
-function updateTypeWithInternalTypeVars(type, scopeIds) {
-    const transformer = new InternalScopeUpdateTransform(scopeIds);
+exports.ensureSignaturesAreUnique = ensureSignaturesAreUnique;
+function makeTypeVarsBound(type, scopeIds) {
+    const transformer = new BoundTypeVarTransform(scopeIds);
     return transformer.apply(type, 0);
 }
-exports.updateTypeWithInternalTypeVars = updateTypeWithInternalTypeVars;
-function updateTypeWithExternalTypeVars(type, scopeIds) {
-    const transformer = new ExternalScopeUpdateTransform(scopeIds);
+exports.makeTypeVarsBound = makeTypeVarsBound;
+function makeTypeVarsFree(type, scopeIds) {
+    const transformer = new FreeTypeVarTransform(scopeIds);
     return transformer.apply(type, 0);
 }
-exports.updateTypeWithExternalTypeVars = updateTypeWithExternalTypeVars;
+exports.makeTypeVarsFree = makeTypeVarsFree;
 // Specializes a (potentially generic) type by substituting
 // type variables from a type var map.
-function applySolvedTypeVars(type, typeVarContext, options = {}) {
-    // Use a shortcut if the typeVarContext is empty and no transform is necessary.
-    if (typeVarContext.isEmpty() &&
-        !options.unknownIfNotFound &&
-        !options.eliminateUnsolvedInUnions &&
-        !options.applyInScopePlaceholders) {
+function applySolvedTypeVars(type, solution, options = {}) {
+    // Use a shortcut if constraints is empty and no transform is necessary.
+    if (solution.isEmpty() && !options.replaceUnsolved) {
         return type;
     }
-    if (options.applyInScopePlaceholders) {
-        applyInScopePlaceholders(typeVarContext);
-    }
-    const transformer = new ApplySolvedTypeVarsTransformer(typeVarContext, options);
+    const transformer = new ApplySolvedTypeVarsTransformer(solution, options);
     return transformer.apply(type, 0);
 }
 exports.applySolvedTypeVars = applySolvedTypeVars;
 // Applies solved TypeVars from one context to this context.
-function applySourceContextTypeVars(destContext, srcContext) {
-    if (srcContext.isEmpty()) {
+function applySourceContextTypeVars(destContext, srcSolution) {
+    if (srcSolution.isEmpty()) {
         return;
     }
-    destContext.doForEachSolutionSet((solutionSet) => {
-        applySourceContextTypeVarsToSignature(solutionSet, srcContext);
+    destContext.doForEachConstraintSet((set) => {
+        applySourceContextTypeVarsToSignature(set, srcSolution);
     });
 }
 exports.applySourceContextTypeVars = applySourceContextTypeVars;
-function applySourceContextTypeVarsToSignature(solutionSet, srcContext) {
-    solutionSet.getTypeVars().forEach((entry) => {
-        const newLowerBound = entry.lowerBound ? applySolvedTypeVars(entry.lowerBound, srcContext) : undefined;
+function applySourceContextTypeVarsToSignature(set, srcSolution) {
+    set.getTypeVars().forEach((entry) => {
+        const newLowerBound = entry.lowerBound ? applySolvedTypeVars(entry.lowerBound, srcSolution) : undefined;
         const newLowerBoundNoLiterals = entry.lowerBoundNoLiterals
-            ? applySolvedTypeVars(entry.lowerBoundNoLiterals, srcContext)
+            ? applySolvedTypeVars(entry.lowerBoundNoLiterals, srcSolution)
             : undefined;
-        const newUpperBound = entry.upperBound ? applySolvedTypeVars(entry.upperBound, srcContext) : undefined;
-        solutionSet.setTypeVarType(entry.typeVar, newLowerBound, newLowerBoundNoLiterals, newUpperBound);
+        const newUpperBound = entry.upperBound ? applySolvedTypeVars(entry.upperBound, srcSolution) : undefined;
+        set.setBounds(entry.typeVar, newLowerBound, newLowerBoundNoLiterals, newUpperBound);
     });
 }
 exports.applySourceContextTypeVarsToSignature = applySourceContextTypeVarsToSignature;
-// If the TypeVarContext contains any type variables whose types depend on
-// in-scope placeholders used for bidirectional type inference, replace those
-// with the solved type associated with those in-scope placeholders.
-function applyInScopePlaceholders(typeVarContext) {
-    typeVarContext.doForEachSolutionSet((solutionSet) => {
-        solutionSet.getTypeVars().forEach((entry) => {
-            const typeVar = entry.typeVar;
-            if (!typeVar.priv.isInScopePlaceholder) {
-                const newLowerBound = entry.lowerBound
-                    ? applyInScopePlaceholdersToType(entry.lowerBound, solutionSet)
-                    : undefined;
-                const newLowerBoundNoLiterals = entry.lowerBoundNoLiterals
-                    ? applyInScopePlaceholdersToType(entry.lowerBoundNoLiterals, solutionSet)
-                    : undefined;
-                const newUpperBound = entry.upperBound
-                    ? applyInScopePlaceholdersToType(entry.upperBound, solutionSet)
-                    : undefined;
-                solutionSet.setTypeVarType(entry.typeVar, newLowerBound, newLowerBoundNoLiterals, newUpperBound);
-            }
-        });
-    });
-}
-exports.applyInScopePlaceholders = applyInScopePlaceholders;
 // Validates that a default type associated with a TypeVar does not refer to
 // other TypeVars or ParamSpecs that are out of scope.
 function validateTypeVarDefault(typeVar, liveTypeParams, invalidTypeVars) {
@@ -1203,11 +1165,6 @@ function validateTypeVarDefault(typeVar, liveTypeParams, invalidTypeVars) {
     }
 }
 exports.validateTypeVarDefault = validateTypeVarDefault;
-function replaceTypeVarsWithAny(type) {
-    const transformer = new TypeVarAnyReplacer();
-    return transformer.apply(type, 0);
-}
-exports.replaceTypeVarsWithAny = replaceTypeVarsWithAny;
 // During bidirectional type inference for constructors, an "expected type"
 // is used to prepopulate the type var map. This is problematic when the
 // expected type uses TypeVars that are not part of the context of the
@@ -1593,7 +1550,7 @@ function getTypeVarArgsRecursive(type, recursionCount = 0) {
     if ((0, types_1.isFunction)(type)) {
         const combinedList = [];
         for (let i = 0; i < type.shared.parameters.length; i++) {
-            addTypeVarsToListIfUnique(combinedList, getTypeVarArgsRecursive(types_1.FunctionType.getEffectiveParamType(type, i), recursionCount));
+            addTypeVarsToListIfUnique(combinedList, getTypeVarArgsRecursive(types_1.FunctionType.getParamType(type, i), recursionCount));
         }
         const returnType = types_1.FunctionType.getEffectiveReturnType(type);
         if (returnType) {
@@ -1607,68 +1564,68 @@ exports.getTypeVarArgsRecursive = getTypeVarArgsRecursive;
 // Creates a specialized version of the class, filling in any unspecified
 // type arguments with Unknown.
 function specializeClassType(type) {
-    const typeVarContext = new typeVarContext_1.TypeVarContext(getTypeVarScopeId(type));
+    const solution = new constraintSolution_1.ConstraintSolution();
     const typeParams = types_1.ClassType.getTypeParams(type);
     typeParams.forEach((typeParam) => {
-        setTypeVarType(typeVarContext, typeParam, applySolvedTypeVars(typeParam.shared.defaultType, typeVarContext));
+        solution.setType(typeParam, applySolvedTypeVars(typeParam.shared.defaultType, solution));
     });
-    return applySolvedTypeVars(type, typeVarContext);
+    return applySolvedTypeVars(type, solution);
 }
 exports.specializeClassType = specializeClassType;
 // Recursively finds all of the type arguments and sets them
 // to the specified srcType.
-function setTypeArgsRecursive(destType, srcType, typeVarContext, recursionCount = 0) {
+function setTypeArgsRecursive(destType, srcType, constraints, recursionCount = 0) {
     if (recursionCount > types_1.maxTypeRecursionCount) {
         return;
     }
     recursionCount++;
-    if (typeVarContext.isLocked()) {
+    if (constraints.isLocked()) {
         return;
     }
     switch (destType.category) {
         case 8 /* TypeCategory.Union */:
             doForEachSubtype(destType, (subtype) => {
-                setTypeArgsRecursive(subtype, srcType, typeVarContext, recursionCount);
+                setTypeArgsRecursive(subtype, srcType, constraints, recursionCount);
             });
             break;
         case 6 /* TypeCategory.Class */:
             if (destType.priv.typeArgs) {
                 destType.priv.typeArgs.forEach((typeArg) => {
-                    setTypeArgsRecursive(typeArg, srcType, typeVarContext, recursionCount);
+                    setTypeArgsRecursive(typeArg, srcType, constraints, recursionCount);
                 });
             }
             if (destType.priv.tupleTypeArgs) {
                 destType.priv.tupleTypeArgs.forEach((typeArg) => {
-                    setTypeArgsRecursive(typeArg.type, srcType, typeVarContext, recursionCount);
+                    setTypeArgsRecursive(typeArg.type, srcType, constraints, recursionCount);
                 });
             }
             break;
         case 4 /* TypeCategory.Function */:
             if (destType.priv.specializedTypes) {
                 destType.priv.specializedTypes.parameterTypes.forEach((paramType) => {
-                    setTypeArgsRecursive(paramType, srcType, typeVarContext, recursionCount);
+                    setTypeArgsRecursive(paramType, srcType, constraints, recursionCount);
                 });
                 if (destType.priv.specializedTypes.returnType) {
-                    setTypeArgsRecursive(destType.priv.specializedTypes.returnType, srcType, typeVarContext, recursionCount);
+                    setTypeArgsRecursive(destType.priv.specializedTypes.returnType, srcType, constraints, recursionCount);
                 }
             }
             else {
-                destType.shared.parameters.forEach((param) => {
-                    setTypeArgsRecursive(param.type, srcType, typeVarContext, recursionCount);
+                destType.shared.parameters.forEach((_, index) => {
+                    setTypeArgsRecursive(types_1.FunctionType.getParamType(destType, index), srcType, constraints, recursionCount);
                 });
                 if (destType.shared.declaredReturnType) {
-                    setTypeArgsRecursive(destType.shared.declaredReturnType, srcType, typeVarContext, recursionCount);
+                    setTypeArgsRecursive(destType.shared.declaredReturnType, srcType, constraints, recursionCount);
                 }
             }
             break;
         case 5 /* TypeCategory.OverloadedFunction */:
             destType.priv.overloads.forEach((subtype) => {
-                setTypeArgsRecursive(subtype, srcType, typeVarContext, recursionCount);
+                setTypeArgsRecursive(subtype, srcType, constraints, recursionCount);
             });
             break;
         case 9 /* TypeCategory.TypeVar */:
-            if (!typeVarContext.getMainSolutionSet().getTypeVar(destType)) {
-                setTypeVarType(typeVarContext, destType, srcType);
+            if (!constraints.getMainConstraintSet().getTypeVar(destType)) {
+                constraints.setBounds(destType, srcType);
             }
             break;
     }
@@ -1678,7 +1635,7 @@ exports.setTypeArgsRecursive = setTypeArgsRecursive;
 // types. For example, if the generic type is Dict[_T1, _T2] and the
 // specialized type is Dict[str, int], it returns a map that associates
 // _T1 with str and _T2 with int.
-function buildTypeVarContextFromSpecializedClass(classType) {
+function buildSolutionFromSpecializedClass(classType) {
     const typeParams = types_1.ClassType.getTypeParams(classType);
     let typeArgs;
     if (classType.priv.tupleTypeArgs) {
@@ -1690,45 +1647,22 @@ function buildTypeVarContextFromSpecializedClass(classType) {
     else {
         typeArgs = classType.priv.typeArgs;
     }
-    return buildTypeVarContext(typeParams, typeArgs, getTypeVarScopeId(classType));
+    return buildSolution(typeParams, typeArgs);
 }
-exports.buildTypeVarContextFromSpecializedClass = buildTypeVarContextFromSpecializedClass;
-function buildTypeVarContext(typeParams, typeArgs, typeVarScopeId) {
-    const typeVarContext = new typeVarContext_1.TypeVarContext(typeVarScopeId);
+exports.buildSolutionFromSpecializedClass = buildSolutionFromSpecializedClass;
+function buildSolution(typeParams, typeArgs) {
+    const solution = new constraintSolution_1.ConstraintSolution();
+    if (!typeArgs) {
+        return solution;
+    }
     typeParams.forEach((typeParam, index) => {
-        let typeArgType;
-        if (typeArgs) {
-            if ((0, types_1.isParamSpec)(typeParam)) {
-                if (index < typeArgs.length) {
-                    typeArgType = typeArgs[index];
-                    if ((0, types_1.isFunction)(typeArgType) && types_1.FunctionType.isParamSpecValue(typeArgType)) {
-                        const parameters = [];
-                        const typeArgFunctionType = typeArgType;
-                        typeArgType.shared.parameters.forEach((param, paramIndex) => {
-                            parameters.push(types_1.FunctionParam.create(param.category, types_1.FunctionType.getEffectiveParamType(typeArgFunctionType, paramIndex), param.flags & types_1.FunctionParamFlags.NameSynthesized, param.name, param.defaultType));
-                        });
-                        setTypeVarType(typeVarContext, typeParam, typeArgType);
-                    }
-                    else if ((0, types_1.isParamSpec)(typeArgType) || (0, types_1.isAnyOrUnknown)(typeArgType)) {
-                        setTypeVarType(typeVarContext, typeParam, typeArgType);
-                    }
-                }
-            }
-            else {
-                if (index >= typeArgs.length) {
-                    typeArgType = types_1.AnyType.create();
-                }
-                else {
-                    typeArgType = typeArgs[index];
-                }
-                setTypeVarType(typeVarContext, typeParam, typeArgType, 
-                /* lowerBoundNoLiterals */ undefined, typeArgType);
-            }
+        if (index < typeArgs.length) {
+            solution.setType(typeParam, typeArgs[index]);
         }
     });
-    return typeVarContext;
+    return solution;
 }
-exports.buildTypeVarContext = buildTypeVarContext;
+exports.buildSolution = buildSolution;
 // Determines the specialized base class type that srcType derives from.
 function specializeForBaseClass(srcType, baseClass) {
     const typeParams = types_1.ClassType.getTypeParams(baseClass);
@@ -1737,8 +1671,8 @@ function specializeForBaseClass(srcType, baseClass) {
     if (typeParams.length === 0) {
         return baseClass;
     }
-    const typeVarContext = buildTypeVarContextFromSpecializedClass(srcType);
-    const specializedType = applySolvedTypeVars(baseClass, typeVarContext);
+    const solution = buildSolutionFromSpecializedClass(srcType);
+    const specializedType = applySolvedTypeVars(baseClass, solution);
     (0, debug_1.assert)((0, types_1.isInstantiableClass)(specializedType));
     return specializedType;
 }
@@ -1921,7 +1855,7 @@ function convertToInstance(type, includeSubclasses = true) {
     // Copy over any type alias information.
     const aliasInfo = (_b = type.props) === null || _b === void 0 ? void 0 : _b.typeAliasInfo;
     if (aliasInfo && type !== result) {
-        result = types_1.TypeBase.cloneForTypeAlias(result, aliasInfo.name, aliasInfo.fullName, aliasInfo.moduleName, aliasInfo.fileUri, aliasInfo.typeVarScopeId, aliasInfo.isPep695Syntax, aliasInfo.typeParams, aliasInfo.typeArgs);
+        result = types_1.TypeBase.cloneForTypeAlias(result, aliasInfo);
     }
     if (type !== result && includeSubclasses) {
         // Cache the converted value for next time.
@@ -2147,7 +2081,7 @@ function isPartlyUnknown(type, recursionCount = 0) {
         for (let i = 0; i < type.shared.parameters.length; i++) {
             // Ignore parameters such as "*" that have no name.
             if (type.shared.parameters[i].name) {
-                const paramType = types_1.FunctionType.getEffectiveParamType(type, i);
+                const paramType = types_1.FunctionType.getParamType(type, i);
                 if (isPartlyUnknown(paramType, recursionCount)) {
                     return true;
                 }
@@ -2247,7 +2181,7 @@ function specializeTupleClass(classType, typeArgs, isTypeArgExplicit = true, isU
     return clonedClassType;
 }
 exports.specializeTupleClass = specializeTupleClass;
-function _expandVariadicUnpackedUnion(type) {
+function _expandUnpackedTypeVarTupleUnion(type) {
     if ((0, types_1.isClassInstance)(type) && isTupleClass(type) && type.priv.tupleTypeArgs && type.priv.isUnpacked) {
         return (0, types_1.combineTypes)(type.priv.tupleTypeArgs.map((t) => t.type));
     }
@@ -2350,7 +2284,7 @@ function _requiresSpecialization(type, options, recursionCount = 0) {
         }
         case 4 /* TypeCategory.Function */: {
             for (let i = 0; i < type.shared.parameters.length; i++) {
-                if (requiresSpecialization(types_1.FunctionType.getEffectiveParamType(type, i), options, recursionCount)) {
+                if (requiresSpecialization(types_1.FunctionType.getParamType(type, i), options, recursionCount)) {
                     return true;
                 }
             }
@@ -2378,7 +2312,7 @@ function _requiresSpecialization(type, options, recursionCount = 0) {
         case 9 /* TypeCategory.TypeVar */: {
             // Most TypeVar types need to be specialized.
             if (!type.shared.recursiveAlias) {
-                if (type.shared.isSynthesizedSelf && (options === null || options === void 0 ? void 0 : options.ignoreSelf)) {
+                if (types_1.TypeVarType.isSelf(type) && (options === null || options === void 0 ? void 0 : options.ignoreSelf)) {
                     return false;
                 }
                 return true;
@@ -2492,9 +2426,9 @@ function computeMroLinearization(classType) {
     const classListsToMerge = [];
     filteredBaseClasses.forEach((baseClass) => {
         if ((0, types_1.isInstantiableClass)(baseClass)) {
-            const typeVarContext = buildTypeVarContextFromSpecializedClass(baseClass);
+            const solution = buildSolutionFromSpecializedClass(baseClass);
             classListsToMerge.push(baseClass.shared.mro.map((mroClass) => {
-                return applySolvedTypeVars(mroClass, typeVarContext);
+                return applySolvedTypeVars(mroClass, solution);
             }));
         }
         else {
@@ -2502,12 +2436,12 @@ function computeMroLinearization(classType) {
         }
     });
     classListsToMerge.push(filteredBaseClasses.map((baseClass) => {
-        const typeVarContext = buildTypeVarContextFromSpecializedClass(classType);
-        return applySolvedTypeVars(baseClass, typeVarContext);
+        const solution = buildSolutionFromSpecializedClass(classType);
+        return applySolvedTypeVars(baseClass, solution);
     }));
     // The first class in the MRO is the class itself.
-    const typeVarContext = buildTypeVarContextFromSpecializedClass(classType);
-    let specializedClassType = applySolvedTypeVars(classType, typeVarContext);
+    const solution = buildSolutionFromSpecializedClass(classType);
+    let specializedClassType = applySolvedTypeVars(classType, solution);
     if (!(0, types_1.isClass)(specializedClassType) && !(0, types_1.isAnyOrUnknown)(specializedClassType)) {
         specializedClassType = types_1.UnknownType.create();
     }
@@ -2650,41 +2584,25 @@ function convertTypeToParamSpecValue(type) {
         return newFunction;
     }
     if ((0, types_1.isFunction)(type)) {
+        // If it's already a ParamSpecValue, return it as is.
+        if (types_1.FunctionType.isParamSpecValue(type)) {
+            return type;
+        }
         const newFunction = types_1.FunctionType.createInstance('', '', '', type.shared.flags | 65536 /* FunctionTypeFlags.ParamSpecValue */, type.shared.docString);
         newFunction.shared.deprecatedMessage = type.shared.deprecatedMessage;
         type.shared.parameters.forEach((param, index) => {
-            types_1.FunctionType.addParam(newFunction, types_1.FunctionParam.create(param.category, types_1.FunctionType.getEffectiveParamType(type, index), param.flags & types_1.FunctionParamFlags.NameSynthesized, param.name, param.defaultType));
+            types_1.FunctionType.addParam(newFunction, types_1.FunctionParam.create(param.category, types_1.FunctionType.getParamType(type, index), param.flags, param.name, types_1.FunctionType.getParamDefaultType(type, index)));
         });
-        if (type.priv.higherOrderTypeVarScopeIds) {
-            newFunction.priv.higherOrderTypeVarScopeIds = [...type.priv.higherOrderTypeVarScopeIds];
-            newFunction.shared.typeVarScopeId = newFunction.priv.higherOrderTypeVarScopeIds.pop();
-        }
+        newFunction.shared.typeVarScopeId = type.shared.typeVarScopeId;
         newFunction.priv.constructorTypeVarScopeId = type.priv.constructorTypeVarScopeId;
         return newFunction;
     }
     return types_1.ParamSpecType.getUnknown();
 }
 exports.convertTypeToParamSpecValue = convertTypeToParamSpecValue;
-// This function calls the setTypeVarType method on the TypeVarContext after
-// converting the parameters for use with a ParamSpec.
-function setTypeVarType(typeVarContext, typeVar, lowerBound, lowerBoundNoLiterals, upperBound) {
-    if ((0, types_1.isParamSpec)(typeVar)) {
-        if (lowerBound) {
-            lowerBound = convertTypeToParamSpecValue(lowerBound);
-        }
-        if (lowerBoundNoLiterals) {
-            lowerBoundNoLiterals = convertTypeToParamSpecValue(lowerBoundNoLiterals);
-        }
-        if (upperBound) {
-            lowerBound = convertTypeToParamSpecValue(upperBound);
-        }
-    }
-    typeVarContext.setTypeVarType(typeVar, lowerBound, lowerBoundNoLiterals, upperBound);
-}
-exports.setTypeVarType = setTypeVarType;
 // Converts a FunctionType into a ParamSpec if it consists only of
 // (* args: P.args, ** kwargs: P.kwargs). Otherwise returns the original type.
-function convertParamSpecValueToType(type) {
+function simplifyFunctionToParamSpec(type) {
     const paramSpec = types_1.FunctionType.getParamSpecFromArgsKwargs(type);
     const withoutParamSpec = types_1.FunctionType.cloneRemoveParamSpecArgsKwargs(type);
     let hasParams = withoutParamSpec.shared.parameters.length > 0;
@@ -2700,31 +2618,19 @@ function convertParamSpecValueToType(type) {
     if (!hasParams && paramSpec) {
         return paramSpec;
     }
-    // Create a function type from the param spec entries.
-    const functionType = types_1.FunctionType.createInstance('', '', '', 65536 /* FunctionTypeFlags.ParamSpecValue */ | withoutParamSpec.shared.flags);
-    types_1.FunctionType.addHigherOrderTypeVarScopeIds(functionType, withoutParamSpec.shared.typeVarScopeId);
-    types_1.FunctionType.addHigherOrderTypeVarScopeIds(functionType, withoutParamSpec.priv.higherOrderTypeVarScopeIds);
-    functionType.priv.constructorTypeVarScopeId = withoutParamSpec.priv.constructorTypeVarScopeId;
-    withoutParamSpec.shared.parameters.forEach((entry, index) => {
-        types_1.FunctionType.addParam(functionType, types_1.FunctionParam.create(entry.category, types_1.FunctionType.getEffectiveParamType(withoutParamSpec, index), (entry.flags & types_1.FunctionParamFlags.NameSynthesized) | types_1.FunctionParamFlags.TypeDeclared, entry.name, entry.defaultType));
-    });
-    if (paramSpec) {
-        types_1.FunctionType.addParamSpecVariadics(functionType, paramSpec);
-    }
-    functionType.shared.docString = withoutParamSpec.shared.docString;
-    functionType.shared.deprecatedMessage = withoutParamSpec.shared.deprecatedMessage;
-    functionType.shared.methodClass = withoutParamSpec.shared.methodClass;
-    return functionType;
+    return type;
 }
-exports.convertParamSpecValueToType = convertParamSpecValueToType;
+exports.simplifyFunctionToParamSpec = simplifyFunctionToParamSpec;
 // Recursively walks a type and calls a callback for each TypeVar, allowing
 // it to be replaced with something else.
 class TypeVarTransformer {
     constructor() {
-        this._isTransformingTypeArg = false;
         this._pendingTypeVarTransformations = new Set();
         this._pendingFunctionTransformations = [];
     }
+    get pendingTypeVarTransformations() {
+        return this._pendingTypeVarTransformations;
+    }
     apply(type, recursionCount) {
         var _a, _b, _c;
         if (recursionCount > types_1.maxTypeRecursionCount) {
@@ -2765,7 +2671,7 @@ class TypeVarTransformer {
                     return replacementType;
                 });
                 if (requiresUpdate) {
-                    return types_1.TypeBase.cloneForTypeAlias(type, aliasInfo.name, aliasInfo.fullName, aliasInfo.moduleName, aliasInfo.fileUri, aliasInfo.typeVarScopeId, aliasInfo.isPep695Syntax, aliasInfo.typeParams, typeArgs);
+                    return types_1.TypeBase.cloneForTypeAlias(type, { ...aliasInfo, typeArgs });
                 }
                 return type;
             }
@@ -2774,43 +2680,36 @@ class TypeVarTransformer {
             // type variables in the same scope recursively by setting it the scope in the
             // _pendingTypeVarTransformations set.
             if (!this._isTypeVarScopePending(type.priv.scopeId)) {
-                if ((0, types_1.isParamSpec)(type)) {
-                    let paramSpecWithoutAccess = type;
-                    if ((0, types_1.isParamSpec)(type) && type.priv.paramSpecAccess) {
-                        paramSpecWithoutAccess = types_1.TypeVarType.cloneForParamSpecAccess(type, /* access */ undefined);
+                let paramSpecAccess;
+                // If this is a ParamSpec with a ".args" or ".kwargs" access, strip
+                // it off for now. We'll add it back later if appropriate.
+                if ((0, types_1.isParamSpec)(type) && type.priv.paramSpecAccess) {
+                    paramSpecAccess = type.priv.paramSpecAccess;
+                    type = types_1.TypeVarType.cloneForParamSpecAccess(type, /* access */ undefined);
+                }
+                replacementType = (_c = this.transformTypeVar(type, recursionCount)) !== null && _c !== void 0 ? _c : type;
+                if ((0, types_1.isParamSpec)(type) && replacementType !== type) {
+                    replacementType = simplifyFunctionToParamSpec(convertTypeToParamSpecValue(replacementType));
+                }
+                // If the original type was a ParamSpec with a ".args" or ".kwargs" access,
+                // preserve that information in the transformed type.
+                if (paramSpecAccess) {
+                    if ((0, types_1.isParamSpec)(replacementType)) {
+                        replacementType = types_1.TypeVarType.cloneForParamSpecAccess(replacementType, paramSpecAccess);
                     }
-                    const paramSpecValue = this.transformParamSpec(paramSpecWithoutAccess, recursionCount);
-                    if (paramSpecValue) {
-                        const paramSpecType = convertParamSpecValueToType(paramSpecValue);
-                        if (type.priv.paramSpecAccess) {
-                            if ((0, types_1.isParamSpec)(paramSpecType)) {
-                                replacementType = types_1.TypeVarType.cloneForParamSpecAccess(paramSpecType, type.priv.paramSpecAccess);
-                            }
-                            else {
-                                replacementType = types_1.UnknownType.create();
-                            }
-                        }
-                        else {
-                            replacementType = paramSpecType;
-                        }
+                    else {
+                        replacementType = types_1.UnknownType.create();
                     }
                 }
-                else {
-                    replacementType = (_c = this.transformTypeVar(type, recursionCount)) !== null && _c !== void 0 ? _c : type;
-                    if (!this._isTransformingTypeArg) {
-                        if (type.priv.scopeId) {
-                            this._pendingTypeVarTransformations.add(type.priv.scopeId);
-                        }
-                        replacementType = this.apply(replacementType, recursionCount);
-                        if (type.priv.scopeId) {
-                            this._pendingTypeVarTransformations.delete(type.priv.scopeId);
-                        }
-                    }
-                    // If we're transforming a variadic type variable that was in a union,
-                    // expand the union types.
-                    if ((0, types_1.isTypeVarTuple)(type) && type.priv.isVariadicInUnion) {
-                        replacementType = _expandVariadicUnpackedUnion(replacementType);
-                    }
+                // If we're transforming a TypeVarTuple that was in a union,
+                // expand the union types.
+                if ((0, types_1.isTypeVarTuple)(type) && type.priv.isInUnion) {
+                    replacementType = _expandUnpackedTypeVarTupleUnion(replacementType);
+                }
+                if (type.priv.scopeId) {
+                    this._pendingTypeVarTransformations.add(type.priv.scopeId);
+                    replacementType = this.apply(replacementType, recursionCount);
+                    this._pendingTypeVarTransformations.delete(type.priv.scopeId);
                 }
             }
             return replacementType;
@@ -2818,12 +2717,12 @@ class TypeVarTransformer {
         if ((0, types_1.isUnion)(type)) {
             const newUnionType = mapSubtypes(type, (subtype) => {
                 let transformedType = this.apply(subtype, recursionCount);
-                // If we're transforming a variadic type variable within a union,
-                // combine the individual types within the variadic type variable.
+                // If we're transforming a TypeVarTuple within a union,
+                // combine the individual types within the TypeVarTuple.
                 if ((0, types_1.isTypeVarTuple)(subtype) && !(0, types_1.isTypeVarTuple)(transformedType)) {
                     const subtypesToCombine = [];
                     doForEachSubtype(transformedType, (transformedSubtype) => {
-                        subtypesToCombine.push(_expandVariadicUnpackedUnion(transformedSubtype));
+                        subtypesToCombine.push(_expandUnpackedTypeVarTupleUnion(transformedSubtype));
                     });
                     transformedType = (0, types_1.combineTypes)(subtypesToCombine);
                 }
@@ -2880,13 +2779,10 @@ class TypeVarTransformer {
     transformTupleTypeVar(paramSpec, recursionCount) {
         return undefined;
     }
-    transformParamSpec(paramSpec, recursionCount) {
-        return undefined;
-    }
     transformUnionSubtype(preTransform, postTransform, recursionCount) {
         return postTransform;
     }
-    doForEachSolutionSet(callback) {
+    doForEachConstraintSet(callback) {
         // By default, simply return the result of the callback. Subclasses
         // can override this method as they see fit.
         return callback();
@@ -2905,15 +2801,14 @@ class TypeVarTransformer {
             }
             return updatedType;
         });
-        return requiresUpdate
-            ? types_1.TypeBase.cloneForTypeAlias(type, aliasInfo.name, aliasInfo.fullName, aliasInfo.moduleName, aliasInfo.fileUri, aliasInfo.typeVarScopeId, aliasInfo.isPep695Syntax, aliasInfo.typeParams, newTypeArgs)
-            : type;
+        return requiresUpdate ? types_1.TypeBase.cloneForTypeAlias(type, { ...aliasInfo, typeArgs: newTypeArgs }) : type;
     }
     transformConditionalType(type, recursionCount) {
         // By default, do not perform any transform.
         return type;
     }
     transformTypeVarsInClassType(classType, recursionCount) {
+        var _a;
         const typeParams = types_1.ClassType.getTypeParams(classType);
         // Handle the common case where the class has no type parameters.
         if (typeParams.length === 0 &&
@@ -2924,18 +2819,6 @@ class TypeVarTransformer {
         let newTypeArgs;
         let newTupleTypeArgs;
         let specializationNeeded = false;
-        const transformParamSpec = (paramSpec) => {
-            const paramSpecValue = this.transformParamSpec(paramSpec, recursionCount);
-            if (paramSpecValue) {
-                specializationNeeded = true;
-                return convertParamSpecValueToType(paramSpecValue);
-            }
-            else {
-                return paramSpec;
-            }
-        };
-        const wasTransformingTypeArg = this._isTransformingTypeArg;
-        this._isTransformingTypeArg = true;
         // If type args were previously provided, specialize them.
         // Handle tuples specially.
         if (types_1.ClassType.isTupleClass(classType)) {
@@ -2987,52 +2870,20 @@ class TypeVarTransformer {
             }
         }
         if (!newTypeArgs) {
-            if (classType.priv.typeArgs) {
-                newTypeArgs = classType.priv.typeArgs.map((oldTypeArgType) => {
-                    if ((0, types_1.isParamSpec)(oldTypeArgType)) {
-                        return transformParamSpec(oldTypeArgType);
-                    }
-                    let newTypeArgType = this.apply(oldTypeArgType, recursionCount);
-                    if (newTypeArgType !== oldTypeArgType) {
-                        specializationNeeded = true;
-                        // If this was a variadic type variable that was part of a union
-                        // (e.g. Union[Unpack[Vs]]), expand the subtypes into a union here.
-                        if ((0, types_1.isTypeVar)(oldTypeArgType) &&
-                            (0, types_1.isTypeVarTuple)(oldTypeArgType) &&
-                            oldTypeArgType.priv.isVariadicInUnion) {
-                            newTypeArgType = _expandVariadicUnpackedUnion(newTypeArgType);
-                        }
-                    }
-                    return newTypeArgType;
-                });
-            }
-            else {
-                newTypeArgs = [];
-                typeParams.forEach((typeParam) => {
-                    let replacementType = typeParam;
-                    if ((0, types_1.isParamSpec)(typeParam)) {
-                        replacementType = transformParamSpec(typeParam);
-                        if (replacementType !== typeParam) {
-                            specializationNeeded = true;
-                        }
-                    }
-                    else {
-                        if (!this._isTypeVarScopePending(typeParam.priv.scopeId)) {
-                            const transformedType = this.transformTypeVar(typeParam, recursionCount);
-                            replacementType = transformedType !== null && transformedType !== void 0 ? transformedType : typeParam;
-                            if (replacementType !== typeParam) {
-                                specializationNeeded = true;
-                            }
-                            else if (transformedType !== undefined && !classType.priv.typeArgs) {
-                                specializationNeeded = true;
-                            }
-                        }
+            const typeArgs = (_a = classType.priv.typeArgs) !== null && _a !== void 0 ? _a : typeParams;
+            newTypeArgs = typeArgs.map((oldTypeArgType) => {
+                let newTypeArgType = this.apply(oldTypeArgType, recursionCount);
+                if (newTypeArgType !== oldTypeArgType) {
+                    specializationNeeded = true;
+                    // If this was a TypeVarTuple that was part of a union
+                    // (e.g. Union[Unpack[Vs]]), expand the subtypes into a union here.
+                    if ((0, types_1.isTypeVar)(oldTypeArgType) && (0, types_1.isTypeVarTuple)(oldTypeArgType) && oldTypeArgType.priv.isInUnion) {
+                        newTypeArgType = _expandUnpackedTypeVarTupleUnion(newTypeArgType);
                     }
-                    newTypeArgs.push(replacementType);
-                });
-            }
+                }
+                return newTypeArgType;
+            });
         }
-        this._isTransformingTypeArg = wasTransformingTypeArg;
         // If specialization wasn't needed, don't allocate a new class.
         if (!specializationNeeded) {
             return classType;
@@ -3042,7 +2893,7 @@ class TypeVarTransformer {
         /* includeSubclasses */ undefined, newTupleTypeArgs);
     }
     transformTypeVarsInFunctionType(sourceType, recursionCount) {
-        return this.doForEachSolutionSet(() => {
+        return this.doForEachConstraintSet(() => {
             let functionType = sourceType;
             const declaredReturnType = types_1.FunctionType.getEffectiveReturnType(functionType);
             const specializedReturnType = declaredReturnType
@@ -3051,32 +2902,31 @@ class TypeVarTransformer {
             let typesRequiredSpecialization = declaredReturnType !== specializedReturnType;
             const specializedParams = {
                 parameterTypes: [],
-                parameterDefaultArgs: undefined,
+                parameterDefaultTypes: undefined,
                 returnType: specializedReturnType,
             };
             const paramSpec = types_1.FunctionType.getParamSpecFromArgsKwargs(functionType);
             if (paramSpec) {
-                const paramSpecType = this.transformParamSpec(paramSpec, recursionCount);
+                const paramSpecType = this.transformTypeVar(paramSpec, recursionCount);
                 if (paramSpecType) {
-                    const transformedParamSpec = types_1.FunctionType.getParamSpecFromArgsKwargs(paramSpecType);
-                    if (paramSpecType.shared.parameters.length > 0 ||
+                    const paramSpecValue = convertTypeToParamSpecValue(paramSpecType);
+                    const transformedParamSpec = types_1.FunctionType.getParamSpecFromArgsKwargs(paramSpecValue);
+                    if (paramSpecValue.shared.parameters.length > 0 ||
                         !transformedParamSpec ||
                         !(0, types_1.isTypeSame)(paramSpec, transformedParamSpec)) {
-                        functionType = types_1.FunctionType.applyParamSpecValue(functionType, paramSpecType);
+                        functionType = types_1.FunctionType.applyParamSpecValue(functionType, paramSpecValue);
                     }
                 }
             }
             let variadicParamIndex;
             let variadicTypesToUnpack;
             const specializedDefaultArgs = [];
-            const wasTransformingTypeArg = this._isTransformingTypeArg;
-            this._isTransformingTypeArg = true;
             for (let i = 0; i < functionType.shared.parameters.length; i++) {
-                const paramType = types_1.FunctionType.getEffectiveParamType(functionType, i);
+                const paramType = types_1.FunctionType.getParamType(functionType, i);
                 const specializedType = this.apply(paramType, recursionCount);
                 specializedParams.parameterTypes.push(specializedType);
                 // Do we need to specialize the default argument type for this parameter?
-                let defaultArgType = types_1.FunctionType.getEffectiveParamDefaultArgType(functionType, i);
+                let defaultArgType = types_1.FunctionType.getParamDefaultType(functionType, i);
                 if (defaultArgType) {
                     const specializedArgType = this.apply(defaultArgType, recursionCount);
                     if (specializedArgType !== defaultArgType) {
@@ -3121,12 +2971,11 @@ class TypeVarTransformer {
                     functionType.priv.strippedFirstParamType = newStrippedType;
                 }
             }
-            this._isTransformingTypeArg = wasTransformingTypeArg;
             if (!typesRequiredSpecialization) {
                 return functionType;
             }
             if (specializedDefaultArgs.some((t) => t !== undefined)) {
-                specializedParams.parameterDefaultArgs = specializedDefaultArgs;
+                specializedParams.parameterDefaultTypes = specializedDefaultArgs;
             }
             // If there was no unpacked variadic type variable, we're done.
             if (!variadicTypesToUnpack) {
@@ -3158,7 +3007,7 @@ class TypeVarTransformer {
                     }
                 }
                 else {
-                    const param = { ...functionType.shared.parameters[index] };
+                    const param = functionType.shared.parameters[index];
                     if ((0, types_1.isKeywordOnlySeparator)(param)) {
                         insertKeywordOnlySeparator = false;
                     }
@@ -3166,17 +3015,15 @@ class TypeVarTransformer {
                         insertKeywordOnlySeparator = false;
                     }
                     // Insert a keyword-only separator parameter if we previously
-                    // unpacked a variadic TypeVar.
+                    // unpacked a TypeVarTuple.
                     if (param.category === 0 /* ParamCategory.Simple */ && param.name && insertKeywordOnlySeparator) {
                         types_1.FunctionType.addKeywordOnlyParamSeparator(newFunctionType);
                         insertKeywordOnlySeparator = false;
                     }
-                    param.type = paramType;
-                    if (param.name && types_1.FunctionParam.isNameSynthesized(param)) {
-                        param.name = `__p${newFunctionType.shared.parameters.length}`;
-                    }
                     if (param.category !== 0 /* ParamCategory.Simple */ || param.name || !swallowPositionOnlySeparator) {
-                        types_1.FunctionType.addParam(newFunctionType, param);
+                        types_1.FunctionType.addParam(newFunctionType, types_1.FunctionParam.create(param.category, paramType, param.flags, param.name && types_1.FunctionParam.isNameSynthesized(param)
+                            ? `__p${newFunctionType.shared.parameters.length}`
+                            : param.name, types_1.FunctionType.getParamDefaultType(functionType, index)));
                     }
                 }
             });
@@ -3188,18 +3035,7 @@ class TypeVarTransformer {
         return !!typeVarScopeId && this._pendingTypeVarTransformations.has(typeVarScopeId);
     }
 }
-// Converts all type variables to Any.
-class TypeVarAnyReplacer extends TypeVarTransformer {
-    constructor() {
-        super();
-    }
-    transformTypeVar(typeVar) {
-        return types_1.AnyType.create();
-    }
-    transformParamSpec(paramSpec) {
-        return types_1.ParamSpecType.getUnknown();
-    }
-}
+exports.TypeVarTransformer = TypeVarTransformer;
 // For a TypeVar with a default type, validates whether the default type is using
 // any other TypeVars that are not currently in scope.
 class TypeVarDefaultValidator extends TypeVarTransformer {
@@ -3210,18 +3046,11 @@ class TypeVarDefaultValidator extends TypeVarTransformer {
     }
     transformTypeVar(typeVar) {
         const replacementType = this._liveTypeParams.find((param) => param.shared.name === typeVar.shared.name);
-        if (!replacementType || (0, types_1.isParamSpec)(replacementType)) {
+        if (!replacementType || (0, types_1.isParamSpec)(replacementType) !== (0, types_1.isParamSpec)(typeVar)) {
             this._invalidTypeVars.add(typeVar.shared.name);
         }
         return types_1.UnknownType.create();
     }
-    transformParamSpec(paramSpec) {
-        const replacementType = this._liveTypeParams.find((param) => param.shared.name === paramSpec.shared.name);
-        if (!replacementType || !(0, types_1.isParamSpec)(replacementType)) {
-            this._invalidTypeVars.add(paramSpec.shared.name);
-        }
-        return undefined;
-    }
 }
 class UniqueFunctionSignatureTransformer extends TypeVarTransformer {
     constructor(_signatureTracker, _expressionOffset) {
@@ -3250,16 +3079,16 @@ class UniqueFunctionSignatureTransformer extends TypeVarTransformer {
                 offsetIndex = existingSignature.expressionOffsets.length;
             }
             if (offsetIndex > 0) {
-                const typeVarContext = new typeVarContext_1.TypeVarContext(getTypeVarScopeIds(sourceType));
+                const solution = new constraintSolution_1.ConstraintSolution();
                 // Create new type variables with the same scope but with
                 // different (unique) names.
                 sourceType.shared.typeParams.forEach((typeParam) => {
                     if (typeParam.priv.scopeType === 1 /* TypeVarScopeType.Function */) {
                         const replacement = types_1.TypeVarType.cloneForNewName(typeParam, `${typeParam.shared.name}(${offsetIndex})`);
-                        setTypeVarType(typeVarContext, typeParam, replacement);
+                        solution.setType(typeParam, replacement);
                     }
                 });
-                updatedSourceType = applySolvedTypeVars(sourceType, typeVarContext);
+                updatedSourceType = applySolvedTypeVars(sourceType, solution);
                 (0, debug_1.assert)((0, types_1.isFunction)(updatedSourceType) || (0, types_1.isOverloadedFunction)(updatedSourceType));
             }
         }
@@ -3267,9 +3096,10 @@ class UniqueFunctionSignatureTransformer extends TypeVarTransformer {
         return updatedSourceType;
     }
 }
-// Replaces the TypeVars within a type with their corresponding "internal"
-// types if they are in one of the specified scopes.
-class InternalScopeUpdateTransform extends TypeVarTransformer {
+// Replaces the free type vars within a type with their corresponding bound
+// type vars if they are in one of the specified scopes. If undefined is
+// passed for the scopeIds list, all free type vars are replaced.
+class BoundTypeVarTransform extends TypeVarTransformer {
     constructor(_scopeIds) {
         super();
         this._scopeIds = _scopeIds;
@@ -3280,35 +3110,30 @@ class InternalScopeUpdateTransform extends TypeVarTransformer {
         }
         return undefined;
     }
-    transformParamSpec(paramSpec) {
-        if (this._isTypeVarInScope(paramSpec)) {
-            return convertTypeToParamSpecValue(this._replaceTypeVar(paramSpec));
-        }
-        return undefined;
-    }
     _isTypeVarInScope(typeVar) {
-        return typeVar.priv.scopeId !== undefined && this._scopeIds.includes(typeVar.priv.scopeId);
+        if (!typeVar.priv.scopeId) {
+            return false;
+        }
+        // If no scopeIds were specified, transform all Type Vars.
+        if (!this._scopeIds) {
+            return true;
+        }
+        return this._scopeIds.includes(typeVar.priv.scopeId);
     }
     _replaceTypeVar(typeVar) {
-        return types_1.TypeVarType.cloneWithInternalScopeId(typeVar);
+        return types_1.TypeVarType.cloneAsBound(typeVar);
     }
 }
-// Replaces the internal TypeVars within a type with their corresponding
-// "external" types.
-class ExternalScopeUpdateTransform extends TypeVarTransformer {
+// Replaces the bound type vars within a type with their corresponding
+// free type vars.
+class FreeTypeVarTransform extends TypeVarTransformer {
     constructor(_scopeIds) {
         super();
         this._scopeIds = _scopeIds;
     }
     transformTypeVar(typeVar) {
-        if (typeVar.priv.externalTypeVar && this._isTypeVarInScope(typeVar.priv.externalTypeVar)) {
-            return typeVar.priv.externalTypeVar;
-        }
-        return undefined;
-    }
-    transformParamSpec(paramSpec) {
-        if (paramSpec.priv.externalTypeVar && this._isTypeVarInScope(paramSpec.priv.externalTypeVar)) {
-            return convertTypeToParamSpecValue(paramSpec.priv.externalTypeVar);
+        if (typeVar.priv.freeTypeVar && this._isTypeVarInScope(typeVar.priv.freeTypeVar)) {
+            return typeVar.priv.freeTypeVar;
         }
         return undefined;
     }
@@ -3322,144 +3147,120 @@ class ExternalScopeUpdateTransform extends TypeVarTransformer {
 // Specializes a (potentially generic) type by substituting
 // type variables from a type var map.
 class ApplySolvedTypeVarsTransformer extends TypeVarTransformer {
-    constructor(_typeVarContext, _options) {
+    constructor(_solution, _options) {
         super();
-        this._typeVarContext = _typeVarContext;
+        this._solution = _solution;
         this._options = _options;
         this._isSolvingDefaultType = false;
     }
     transformTypeVar(typeVar, recursionCount) {
-        var _a, _b;
-        const solutionSet = this._typeVarContext.getSolutionSet((_a = this._activeSolutionSetIndex) !== null && _a !== void 0 ? _a : 0);
-        // If the type variable is unrelated to the scopes we're solving,
-        // don't transform that type variable.
-        if (typeVar.priv.scopeId && this._typeVarContext.hasSolveForScope(typeVar.priv.scopeId)) {
-            let replacement = solutionSet.getTypeVarType(typeVar, !!this._options.useLowerBoundOnly);
-            // If there was no lower bound but there is an upper bound that
-            // contains literals or a TypeVar, we'll use the upper bound even if
-            // "useLowerBoundOnly" is specified.
-            if (!replacement && this._options.useLowerBoundOnly) {
-                const wideType = solutionSet.getTypeVarType(typeVar);
-                if (wideType) {
-                    if ((0, types_1.isTypeVar)(wideType) || containsLiteralType(wideType, /* includeTypeArgs */ true)) {
-                        replacement = wideType;
-                    }
-                }
-            }
+        var _a, _b, _c;
+        const solutionSet = this._solution.getSolutionSet((_a = this._activeConstraintSetIndex) !== null && _a !== void 0 ? _a : 0);
+        // If we're solving a default type, handle type variables with no scope ID.
+        if (this._isSolvingDefaultType && !typeVar.priv.scopeId) {
+            const replacement = this._getReplacementForDefaultByName(typeVar, solutionSet);
             if (replacement) {
-                if (types_1.TypeBase.isInstantiable(typeVar)) {
-                    if ((0, types_1.isAnyOrUnknown)(replacement) &&
-                        this._options.typeClassType &&
-                        (0, types_1.isInstantiableClass)(this._options.typeClassType)) {
-                        replacement = types_1.ClassType.specialize(types_1.ClassType.cloneAsInstance(this._options.typeClassType), [
-                            replacement,
-                        ]);
-                    }
-                    else {
-                        replacement = convertToInstantiable(replacement, /* includeSubclasses */ false);
-                    }
+                return replacement;
+            }
+            if (typeVar.shared.isDefaultExplicit) {
+                return this.apply(typeVar.shared.defaultType, recursionCount);
+            }
+            return types_1.UnknownType.create();
+        }
+        if (!this._shouldReplaceTypeVar(typeVar)) {
+            return undefined;
+        }
+        let replacement = solutionSet.getType(typeVar);
+        if (replacement) {
+            // No more processing is needed for ParamSpecs.
+            if ((0, types_1.isParamSpec)(typeVar)) {
+                return replacement;
+            }
+            if (types_1.TypeBase.isInstantiable(typeVar)) {
+                if ((0, types_1.isAnyOrUnknown)(replacement) &&
+                    this._options.typeClassType &&
+                    (0, types_1.isInstantiableClass)(this._options.typeClassType)) {
+                    replacement = types_1.ClassType.specialize(types_1.ClassType.cloneAsInstance(this._options.typeClassType), [
+                        replacement,
+                    ]);
                 }
                 else {
-                    // If the TypeVar is not instantiable (i.e. not a type[T]), then
-                    // it represents an instance of a type. If the replacement includes
-                    // a generic class that has not been specialized, specialize it
-                    // now with default type arguments.
-                    replacement = mapSubtypes(replacement, (subtype) => {
-                        if ((0, types_1.isClassInstance)(subtype)) {
-                            // If the includeSubclasses wasn't set, force it to be set by
-                            // converting to/from an instantiable.
-                            if (!subtype.priv.includeSubclasses) {
-                                subtype = types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneAsInstantiable(subtype));
-                            }
-                            if (subtype.shared.typeParams && !subtype.priv.typeArgs) {
-                                if (this._options.unknownIfNotFound) {
-                                    return this._options.useUnknownOverDefault
-                                        ? specializeWithUnknownTypeArgs(subtype, this._options.tupleClassType)
-                                        : specializeWithDefaultTypeArgs(subtype);
-                                }
+                    replacement = convertToInstantiable(replacement, /* includeSubclasses */ false);
+                }
+            }
+            else {
+                // If the TypeVar is not instantiable (i.e. not a type[T]), then
+                // it represents an instance of a type. If the replacement includes
+                // a generic class that has not been specialized, specialize it
+                // now with default type arguments.
+                replacement = mapSubtypes(replacement, (subtype) => {
+                    if ((0, types_1.isClassInstance)(subtype)) {
+                        // If the includeSubclasses wasn't set, force it to be set by
+                        // converting to/from an instantiable.
+                        if (!subtype.priv.includeSubclasses) {
+                            subtype = types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneAsInstantiable(subtype));
+                        }
+                        if (subtype.shared.typeParams && !subtype.priv.typeArgs) {
+                            if (this._options.replaceUnsolved) {
+                                return this._options.replaceUnsolved.useUnknown
+                                    ? specializeWithUnknownTypeArgs(subtype, this._options.replaceUnsolved.tupleClassType)
+                                    : specializeWithDefaultTypeArgs(subtype);
                             }
                         }
-                        return subtype;
-                    });
-                }
-                if ((0, types_1.isTypeVarTuple)(replacement) && (0, types_1.isTypeVarTuple)(typeVar) && typeVar.priv.isVariadicUnpacked) {
-                    return types_1.TypeVarType.cloneForUnpacked(replacement, typeVar.priv.isVariadicInUnion);
-                }
-                // If this isn't a variadic typeVar, combine all of the tuple
-                // type args into a common type.
-                if (!(0, types_1.isTypeVarTuple)(typeVar) &&
-                    (0, types_1.isClassInstance)(replacement) &&
-                    replacement.priv.tupleTypeArgs &&
-                    replacement.priv.isUnpacked) {
-                    replacement = combineTupleTypeArgs(replacement.priv.tupleTypeArgs);
-                }
-                if (!(0, types_1.isTypeVar)(replacement) ||
-                    !replacement.priv.isInScopePlaceholder ||
-                    !this._options.unknownIfNotFound) {
-                    return replacement;
-                }
+                    }
+                    return subtype;
+                });
             }
-            // If this typeVar is in scope for what we're solving but the type
-            // var map doesn't contain any entry for it, replace with the
-            // default or Unknown.
-            let useDefaultOrUnknown = false;
-            if (this._options.unknownIfNotFound) {
-                const exemptTypeVars = (_b = this._options.unknownExemptTypeVars) !== null && _b !== void 0 ? _b : [];
-                const typeVarInstance = types_1.TypeBase.isInstance(typeVar) ? typeVar : types_1.TypeVarType.cloneAsInstance(typeVar);
-                if (!exemptTypeVars.some((t) => (0, types_1.isTypeSame)(t, typeVarInstance))) {
-                    useDefaultOrUnknown = true;
-                }
+            if ((0, types_1.isTypeVarTuple)(replacement) && (0, types_1.isTypeVarTuple)(typeVar) && typeVar.priv.isUnpacked) {
+                return types_1.TypeVarType.cloneForUnpacked(replacement, typeVar.priv.isInUnion);
             }
-            else if (this._options.applyInScopePlaceholders && typeVar.priv.isInScopePlaceholder) {
-                useDefaultOrUnknown = true;
+            // If this isn't a TypeVarTuple, combine all of the tuple
+            // type args into a common type.
+            if (!(0, types_1.isTypeVarTuple)(typeVar) &&
+                (0, types_1.isClassInstance)(replacement) &&
+                replacement.priv.tupleTypeArgs &&
+                replacement.priv.isUnpacked) {
+                replacement = combineTupleTypeArgs(replacement.priv.tupleTypeArgs);
             }
-            if (useDefaultOrUnknown) {
-                // Use the default value if there is one.
-                if (typeVar.shared.isDefaultExplicit && !this._options.useUnknownOverDefault) {
-                    return this._solveDefaultType(typeVar, recursionCount);
-                }
-                return getUnknownForTypeVar(typeVar, this._options.tupleClassType);
+            if (!(0, types_1.isTypeVar)(replacement) || !types_1.TypeVarType.isUnification(replacement) || !this._options.replaceUnsolved) {
+                return replacement;
             }
         }
-        // If we're solving a default type, handle type variables with no scope ID.
-        if (this._isSolvingDefaultType && !typeVar.priv.scopeId) {
-            const replacementEntry = solutionSet
-                .getTypeVars()
-                .find((entry) => entry.typeVar.shared.name === typeVar.shared.name);
-            if (replacementEntry) {
-                return solutionSet.getTypeVarType(replacementEntry.typeVar);
-            }
-            if (typeVar.shared.isDefaultExplicit) {
-                return this.apply(typeVar.shared.defaultType, recursionCount);
-            }
-            return types_1.UnknownType.create();
+        if (!this._shouldReplaceUnsolvedTypeVar(typeVar)) {
+            return undefined;
         }
-        return undefined;
+        // Use the default value if there is one.
+        if (typeVar.shared.isDefaultExplicit && !((_b = this._options.replaceUnsolved) === null || _b === void 0 ? void 0 : _b.useUnknown)) {
+            return this._solveDefaultType(typeVar, recursionCount);
+        }
+        return getUnknownForTypeVar(typeVar, (_c = this._options.replaceUnsolved) === null || _c === void 0 ? void 0 : _c.tupleClassType);
     }
     transformUnionSubtype(preTransform, postTransform) {
-        var _a;
+        var _a, _b;
         // If a union contains unsolved TypeVars within scope, eliminate them
         // unless this results in an empty union. This elimination is needed
         // in cases where TypeVars can go unsolved due to unions in parameter
         // annotations, like this:
         //   def test(x: Union[str, T]) -> Union[str, T]
-        if (this._options.eliminateUnsolvedInUnions) {
+        if ((_a = this._options.replaceUnsolved) === null || _a === void 0 ? void 0 : _a.eliminateUnsolvedInUnions) {
             if ((0, types_1.isTypeVar)(preTransform) &&
-                preTransform.priv.scopeId !== undefined &&
-                this._typeVarContext.hasSolveForScope(preTransform.priv.scopeId)) {
-                const solutionSet = this._typeVarContext.getSolutionSet((_a = this._activeSolutionSetIndex) !== null && _a !== void 0 ? _a : 0);
-                const typeVarType = solutionSet.getTypeVarType(preTransform);
+                this._shouldReplaceTypeVar(preTransform) &&
+                this._shouldReplaceUnsolvedTypeVar(preTransform)) {
+                const solutionSet = this._solution.getSolutionSet((_b = this._activeConstraintSetIndex) !== null && _b !== void 0 ? _b : 0);
+                const typeVarType = solutionSet.getType(preTransform);
                 // Did the TypeVar remain unsolved?
-                if (!typeVarType || ((0, types_1.isTypeVar)(typeVarType) && typeVarType.priv.isInScopePlaceholder)) {
+                if (!typeVarType || ((0, types_1.isTypeVar)(typeVarType) && types_1.TypeVarType.isUnification(typeVarType))) {
                     // If the TypeVar was not transformed, then it was unsolved,
                     // and we'll eliminate it.
                     if (preTransform === postTransform) {
                         return undefined;
                     }
-                    // If unknownIfNotFound is true, the postTransform type will
+                    // If useDefaultForUnsolved or useUnknownForUnsolved is true, the postTransform type will
                     // be Unknown, which we want to eliminate.
-                    if ((0, types_1.isUnknown)(postTransform) && this._options.unknownIfNotFound) {
-                        return undefined;
+                    if (this._options.replaceUnsolved) {
+                        if ((0, types_1.isUnknown)(postTransform)) {
+                            return undefined;
+                        }
                     }
                 }
             }
@@ -3468,84 +3269,41 @@ class ApplySolvedTypeVarsTransformer extends TypeVarTransformer {
     }
     transformTupleTypeVar(typeVar) {
         var _a;
-        if (!typeVar.priv.scopeId || !this._typeVarContext.hasSolveForScope(typeVar.priv.scopeId)) {
+        if (!this._shouldReplaceTypeVar(typeVar)) {
             const defaultType = typeVar.shared.defaultType;
             if (typeVar.shared.isDefaultExplicit && (0, types_1.isClassInstance)(defaultType) && defaultType.priv.tupleTypeArgs) {
                 return defaultType.priv.tupleTypeArgs;
             }
             return undefined;
         }
-        const solutionSet = this._typeVarContext.getSolutionSet((_a = this._activeSolutionSetIndex) !== null && _a !== void 0 ? _a : 0);
-        const value = solutionSet.getTypeVarType(typeVar);
+        const solutionSet = this._solution.getSolutionSet((_a = this._activeConstraintSetIndex) !== null && _a !== void 0 ? _a : 0);
+        const value = solutionSet.getType(typeVar);
         if (value && (0, types_1.isClassInstance)(value) && value.priv.tupleTypeArgs && (0, types_1.isUnpackedClass)(value)) {
             return value.priv.tupleTypeArgs;
         }
         return undefined;
     }
-    transformParamSpec(paramSpec, recursionCount) {
-        var _a, _b;
-        const solutionSet = this._typeVarContext.getSolutionSet((_a = this._activeSolutionSetIndex) !== null && _a !== void 0 ? _a : 0);
-        // If we're solving a default type, handle param specs with no scope ID.
-        if (this._isSolvingDefaultType && !paramSpec.priv.scopeId) {
-            const replacementEntry = solutionSet
-                .getTypeVars()
-                .find((entry) => entry.typeVar.shared.name === paramSpec.shared.name);
-            if (replacementEntry && (0, types_1.isParamSpec)(replacementEntry.typeVar)) {
-                return solutionSet.getTypeVarType(replacementEntry.typeVar);
-            }
-            if (paramSpec.shared.isDefaultExplicit) {
-                return convertTypeToParamSpecValue(this.apply(paramSpec.shared.defaultType, recursionCount));
-            }
-            return types_1.ParamSpecType.getUnknown();
-        }
-        if (!paramSpec.priv.scopeId || !this._typeVarContext.hasSolveForScope(paramSpec.priv.scopeId)) {
-            return undefined;
-        }
-        const transformedParamSpec = solutionSet.getTypeVarType(paramSpec);
-        if (transformedParamSpec) {
-            return transformedParamSpec;
-        }
-        let useDefaultOrUnknown = false;
-        if (this._options.unknownIfNotFound) {
-            const exemptTypeVars = (_b = this._options.unknownExemptTypeVars) !== null && _b !== void 0 ? _b : [];
-            if (!exemptTypeVars.some((t) => (0, types_1.isTypeSame)(t, paramSpec, { ignoreTypeFlags: true }))) {
-                useDefaultOrUnknown = true;
-            }
-        }
-        else if (this._options.applyInScopePlaceholders && paramSpec.priv.isInScopePlaceholder) {
-            useDefaultOrUnknown = true;
-        }
-        if (useDefaultOrUnknown) {
-            // Use the default value if there is one.
-            if (paramSpec.shared.isDefaultExplicit && !this._options.useUnknownOverDefault) {
-                return convertTypeToParamSpecValue(this._solveDefaultType(paramSpec, recursionCount));
-            }
-            // Convert to the ParamSpec equivalent of "Unknown".
-            return types_1.ParamSpecType.getUnknown();
-        }
-        return undefined;
-    }
     transformConditionalType(type, recursionCount) {
         var _a, _b, _c, _d;
         if (!((_a = type.props) === null || _a === void 0 ? void 0 : _a.condition)) {
             return type;
         }
-        const solutionSet = this._typeVarContext.getSolutionSet((_b = this._activeSolutionSetIndex) !== null && _b !== void 0 ? _b : 0);
+        const solutionSet = this._solution.getSolutionSet((_b = this._activeConstraintSetIndex) !== null && _b !== void 0 ? _b : 0);
         for (const condition of type.props.condition) {
             // This doesn't apply to bound type variables.
-            if (condition.typeVar.shared.constraints.length === 0) {
+            if (!types_1.TypeVarType.hasConstraints(condition.typeVar)) {
                 continue;
             }
-            const conditionTypeVar = (_d = (_c = condition.typeVar.priv) === null || _c === void 0 ? void 0 : _c.externalTypeVar) !== null && _d !== void 0 ? _d : condition.typeVar;
-            const typeVarEntry = solutionSet.getTypeVar(conditionTypeVar);
-            if (!typeVarEntry || condition.constraintIndex >= typeVarEntry.typeVar.shared.constraints.length) {
+            const conditionTypeVar = (_d = (_c = condition.typeVar.priv) === null || _c === void 0 ? void 0 : _c.freeTypeVar) !== null && _d !== void 0 ? _d : condition.typeVar;
+            const replacement = solutionSet.getType(conditionTypeVar);
+            if (!replacement || condition.constraintIndex >= conditionTypeVar.shared.constraints.length) {
                 continue;
             }
-            const value = solutionSet.getTypeVarType(typeVarEntry.typeVar);
+            const value = solutionSet.getType(conditionTypeVar);
             if (!value) {
                 continue;
             }
-            const constraintType = typeVarEntry.typeVar.shared.constraints[condition.constraintIndex];
+            const constraintType = conditionTypeVar.shared.constraints[condition.constraintIndex];
             // If this violates the constraint, substitute a Never type.
             if (!(0, types_1.isTypeSame)(constraintType, value)) {
                 return types_1.NeverType.createNever();
@@ -3553,19 +3311,19 @@ class ApplySolvedTypeVarsTransformer extends TypeVarTransformer {
         }
         return type;
     }
-    doForEachSolutionSet(callback) {
-        const solutionSet = this._typeVarContext.getSolutionSets();
+    doForEachConstraintSet(callback) {
+        const solutionSets = this._solution.getSolutionSets();
         // Handle the common case where there are not multiple signature contexts.
-        if (solutionSet.length <= 1) {
+        if (solutionSets.length <= 1) {
             return callback();
         }
         // Loop through all of the signature contexts in the type var context
         // to create an overload type.
-        const overloadTypes = solutionSet.map((_, index) => {
-            this._activeSolutionSetIndex = index;
+        const overloadTypes = solutionSets.map((_, index) => {
+            this._activeConstraintSetIndex = index;
             return callback();
         });
-        this._activeSolutionSetIndex = undefined;
+        this._activeConstraintSetIndex = undefined;
         const filteredOverloads = [];
         doForEachSubtype((0, types_1.combineTypes)(overloadTypes), (subtype) => {
             (0, debug_1.assert)((0, types_1.isFunction)(subtype));
@@ -3577,6 +3335,50 @@ class ApplySolvedTypeVarsTransformer extends TypeVarTransformer {
         }
         return types_1.OverloadedFunctionType.create(filteredOverloads);
     }
+    // Handle the case where we need the default replacement value for a typeVar
+    // that has no scope and therefore doesn't have an assigned scopeID. We'll
+    // look it up by name in the solution set. This is a bit hacky because there
+    // could be multiple typeVars with the same name, but we'll assume that this
+    // won't happen.
+    _getReplacementForDefaultByName(typeVar, solutionSet) {
+        let replacementValue;
+        const partialScopeId = `${typeVar.shared.name}.`;
+        solutionSet.doForEachTypeVar((value, typeVarId) => {
+            if (typeVarId.startsWith(partialScopeId)) {
+                replacementValue = value;
+            }
+        });
+        return replacementValue;
+    }
+    _shouldReplaceTypeVar(typeVar) {
+        if (!typeVar.priv.scopeId || types_1.TypeVarType.isBound(typeVar)) {
+            return false;
+        }
+        return true;
+    }
+    _shouldReplaceUnsolvedTypeVar(typeVar) {
+        var _a;
+        // Never replace nested TypeVars with unknown.
+        if (this.pendingTypeVarTransformations.size > 0) {
+            return false;
+        }
+        if (!typeVar.priv.scopeId) {
+            return false;
+        }
+        if (!this._options.replaceUnsolved) {
+            return false;
+        }
+        if (!this._options.replaceUnsolved.scopeIds.includes(typeVar.priv.scopeId)) {
+            return false;
+        }
+        const exemptTypeVars = (_a = this._options.replaceUnsolved) === null || _a === void 0 ? void 0 : _a.unsolvedExemptTypeVars;
+        if (exemptTypeVars) {
+            if (exemptTypeVars.some((t) => (0, types_1.isTypeSame)(t, typeVar, { ignoreTypeFlags: true }))) {
+                return false;
+            }
+        }
+        return true;
+    }
     _solveDefaultType(typeVar, recursionCount) {
         const defaultType = typeVar.shared.defaultType;
         const wasSolvingDefaultType = this._isSolvingDefaultType;
@@ -3594,46 +3396,12 @@ class ExpectedTypeTransformer extends TypeVarTransformer {
     }
     transformTypeVar(typeVar) {
         if (!this._isTypeVarLive(typeVar)) {
-            return types_1.TypeVarType.cloneAsInScopePlaceholder(typeVar, this._usageOffset);
-        }
-        return undefined;
-    }
-    transformParamSpec(paramSpec) {
-        if (!this._isTypeVarLive(paramSpec)) {
-            return convertTypeToParamSpecValue(types_1.TypeVarType.cloneAsInScopePlaceholder(paramSpec, this._usageOffset));
+            return types_1.TypeVarType.cloneAsUnificationVar(typeVar, this._usageOffset);
         }
         return undefined;
     }
     _isTypeVarLive(typeVar) {
-        return this._liveTypeVarScopes.some((scopeId) => { var _a; return typeVar.priv.scopeId === scopeId || ((_a = typeVar.priv.externalTypeVar) === null || _a === void 0 ? void 0 : _a.priv.scopeId) === scopeId; });
-    }
-}
-class InScopePlaceholderTransformer extends TypeVarTransformer {
-    constructor(_solutionSet) {
-        super();
-        this._solutionSet = _solutionSet;
+        return this._liveTypeVarScopes.some((scopeId) => { var _a; return typeVar.priv.scopeId === scopeId || ((_a = typeVar.priv.freeTypeVar) === null || _a === void 0 ? void 0 : _a.priv.scopeId) === scopeId; });
     }
-    transformTypeVar(typeVar) {
-        var _a;
-        if (typeVar.priv.isInScopePlaceholder) {
-            return (_a = this._solutionSet.getTypeVarType(typeVar)) !== null && _a !== void 0 ? _a : typeVar;
-        }
-        return undefined;
-    }
-    transformParamSpec(paramSpec) {
-        if (paramSpec.priv.isInScopePlaceholder) {
-            return this._solutionSet.getTypeVarType(paramSpec);
-        }
-        return undefined;
-    }
-}
-function applyInScopePlaceholdersToType(type, solutionSet) {
-    // Handle the common case where there are no in-scope placeholders.
-    // No more work is required in this case.
-    if (!solutionSet.getTypeVars().some((entry) => entry.typeVar.priv.isInScopePlaceholder)) {
-        return type;
-    }
-    const transformer = new InScopePlaceholderTransformer(solutionSet);
-    return transformer.apply(type, 0);
 }
 //# sourceMappingURL=typeUtils.js.map