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

package/dist/analyzer/typeUtils.js

@@ -8,15 +8,15 @@
  * Functions that operate on Type objects.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-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.getUnknownTypeForVariadicTypeVar = exports.getUnknownTypeForParamSpec = exports.getUnknownTypeForTypeVar = 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.requiresTypeArguments = exports.getGeneratorTypeArgs = exports.specializeTupleClass = 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.setTypeArgumentsRecursive = exports.specializeClassType = exports.getTypeVarArgumentsRecursive = 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 = exports.isTupleClass = void 0;
-exports.convertParamSpecValueToType = exports.convertTypeToParamSpecValue = exports.convertArgumentNodeToFunctionArgument = exports.getDeclaringModulesForType = exports.computeMroLinearization = exports.isVarianceOfTypeArgumentCompatible = exports.combineVariances = exports.requiresSpecialization = void 0;
+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.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
@@ -103,8 +103,6 @@ var AssignTypeFlags;
     AssignTypeFlags[AssignTypeFlags["PartialOverloadOverlap"] = 32] = "PartialOverloadOverlap";
     // For function types, skip the return type check.
     AssignTypeFlags[AssignTypeFlags["SkipReturnTypeCheck"] = 64] = "SkipReturnTypeCheck";
-    // Allow bool values to be assigned to TypeGuard[x] types.
-    AssignTypeFlags[AssignTypeFlags["AllowBoolTypeGuard"] = 128] = "AllowBoolTypeGuard";
     // In most cases, literals are stripped when assigning to a
     // type variable. This overrides the standard behavior.
     AssignTypeFlags[AssignTypeFlags["RetainLiteralsForTypeVar"] = 256] = "RetainLiteralsForTypeVar";
@@ -113,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";
@@ -128,7 +122,7 @@ var AssignTypeFlags;
     // hasn't previously been specialized, it will be specialized with
     // default type arguments (typically "Unknown"). This flag skips
     // this step.
-    AssignTypeFlags[AssignTypeFlags["AllowUnspecifiedTypeArguments"] = 8192] = "AllowUnspecifiedTypeArguments";
+    AssignTypeFlags[AssignTypeFlags["AllowUnspecifiedTypeArgs"] = 8192] = "AllowUnspecifiedTypeArgs";
     // Normally all special form classes are incompatible with type[T],
     // but a few of them are allowed in the context of an isinstance
     // or issubclass call.
@@ -216,7 +210,7 @@ function isTypeVarSame(type1, type2) {
         return true;
     }
     // If this isn't a bound TypeVar, return false.
-    if (type1.shared.isParamSpec || type1.shared.isVariadic || !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.
@@ -269,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);
                     }
                 }
@@ -349,10 +343,10 @@ function cleanIncompleteUnknown(type, recursionCount = 0) {
         if ((0, types_1.isUnknown)(subtype) && subtype.priv.isIncomplete) {
             return undefined;
         }
-        if ((0, types_1.isClass)(subtype) && subtype.priv.typeArguments) {
+        if ((0, types_1.isClass)(subtype) && subtype.priv.typeArgs) {
             let typeChanged = false;
-            if (subtype.priv.tupleTypeArguments) {
-                const updatedTupleTypeArgs = subtype.priv.tupleTypeArguments.map((tupleTypeArg) => {
+            if (subtype.priv.tupleTypeArgs) {
+                const updatedTupleTypeArgs = subtype.priv.tupleTypeArgs.map((tupleTypeArg) => {
                     const newTypeArg = cleanIncompleteUnknown(tupleTypeArg.type, recursionCount);
                     if (newTypeArg !== tupleTypeArg.type) {
                         typeChanged = true;
@@ -364,11 +358,11 @@ function cleanIncompleteUnknown(type, recursionCount = 0) {
                     };
                 });
                 if (typeChanged) {
-                    return specializeTupleClass(subtype, updatedTupleTypeArgs, !!subtype.priv.isTypeArgumentExplicit, !!subtype.priv.isUnpacked);
+                    return specializeTupleClass(subtype, updatedTupleTypeArgs, !!subtype.priv.isTypeArgExplicit, !!subtype.priv.isUnpacked);
                 }
             }
             else {
-                const updatedTypeArgs = subtype.priv.typeArguments.map((typeArg) => {
+                const updatedTypeArgs = subtype.priv.typeArgs.map((typeArg) => {
                     const newTypeArg = cleanIncompleteUnknown(typeArg, recursionCount);
                     if (newTypeArg !== typeArg) {
                         typeChanged = true;
@@ -376,7 +370,7 @@ function cleanIncompleteUnknown(type, recursionCount = 0) {
                     return newTypeArg;
                 });
                 if (typeChanged) {
-                    return types_1.ClassType.cloneForSpecialization(subtype, updatedTypeArgs, !!subtype.priv.isTypeArgumentExplicit);
+                    return types_1.ClassType.specialize(subtype, updatedTypeArgs, !!subtype.priv.isTypeArgExplicit);
                 }
             }
         }
@@ -424,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.getEffectiveParameterType(a, i), types_1.FunctionType.getEffectiveParameterType(bFunc, i));
+                const typeComparison = compareTypes(types_1.FunctionType.getParamType(a, i), types_1.FunctionType.getParamType(bFunc, i));
                 if (typeComparison !== 0) {
                     return typeComparison;
                 }
@@ -484,12 +478,12 @@ function compareTypes(a, b, recursionCount = 0) {
                 return -1;
             }
             // Sort non-generics before generics.
-            if (a.shared.typeParameters.length > 0 || isTupleClass(a)) {
-                if (bClass.shared.typeParameters.length === 0) {
+            if (a.shared.typeParams.length > 0 || isTupleClass(a)) {
+                if (bClass.shared.typeParams.length === 0) {
                     return 1;
                 }
             }
-            else if (bClass.shared.typeParameters.length > 0 || isTupleClass(bClass)) {
+            else if (bClass.shared.typeParams.length > 0 || isTupleClass(bClass)) {
                 return -1;
             }
             // Sort by class name.
@@ -502,8 +496,8 @@ function compareTypes(a, b, recursionCount = 0) {
                 return 1;
             }
             // Sort by type argument count.
-            const aTypeArgCount = a.priv.typeArguments ? a.priv.typeArguments.length : 0;
-            const bTypeArgCount = bClass.priv.typeArguments ? bClass.priv.typeArguments.length : 0;
+            const aTypeArgCount = a.priv.typeArgs ? a.priv.typeArgs.length : 0;
+            const bTypeArgCount = bClass.priv.typeArgs ? bClass.priv.typeArgs.length : 0;
             if (aTypeArgCount < bTypeArgCount) {
                 return -1;
             }
@@ -512,7 +506,7 @@ function compareTypes(a, b, recursionCount = 0) {
             }
             // Sort by type argument.
             for (let i = 0; i < aTypeArgCount; i++) {
-                const typeComparison = compareTypes(a.priv.typeArguments[i], bClass.priv.typeArguments[i], recursionCount);
+                const typeComparison = compareTypes(a.priv.typeArgs[i], bClass.priv.typeArgs[i], recursionCount);
                 if (typeComparison !== 0) {
                     return typeComparison;
                 }
@@ -669,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;
         }
@@ -744,17 +738,17 @@ function transformPossibleRecursiveTypeAlias(type) {
             const unspecializedType = types_1.TypeBase.isInstance(type)
                 ? convertToInstance(type.shared.boundType)
                 : type.shared.boundType;
-            if (!(aliasInfo === null || aliasInfo === void 0 ? void 0 : aliasInfo.typeArguments) || !type.shared.recursiveAlias.typeParameters) {
+            if (!(aliasInfo === null || aliasInfo === void 0 ? void 0 : aliasInfo.typeArgs) || !type.shared.recursiveAlias.typeParams) {
                 return unspecializedType;
             }
-            const typeVarContext = buildTypeVarContext(type.shared.recursiveAlias.typeParameters, aliasInfo.typeArguments, 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.typeParameters, aliasInfo.typeArguments);
+                newType = types_1.TypeBase.cloneForTypeAlias(newType, aliasInfo);
             }
             return newType;
         }
@@ -787,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;
 }
@@ -798,58 +789,51 @@ exports.getTypeVarScopeIds = getTypeVarScopeIds;
 // specified, specialize it with default type arguments (Unknown or the
 // default type if provided).
 function specializeWithDefaultTypeArgs(type) {
-    if (type.shared.typeParameters.length === 0 || type.priv.typeArguments) {
+    if (type.shared.typeParams.length === 0 || type.priv.typeArgs) {
         return type;
     }
-    return types_1.ClassType.cloneForSpecialization(type, type.shared.typeParameters.map((param) => param.shared.defaultType), 
-    /* isTypeArgumentExplicit */ false, 
+    return types_1.ClassType.specialize(type, type.shared.typeParams.map((param) => param.shared.defaultType), 
+    /* isTypeArgExplicit */ false, 
     /* includeSubclasses */ type.priv.includeSubclasses);
 }
 exports.specializeWithDefaultTypeArgs = specializeWithDefaultTypeArgs;
 // Specializes the class with "Unknown" type args (or the equivalent for ParamSpecs
 // or TypeVarTuples).
 function specializeWithUnknownTypeArgs(type, tupleClassType) {
-    if (type.shared.typeParameters.length === 0) {
+    if (type.shared.typeParams.length === 0) {
         return type;
     }
     if (isTupleClass(type)) {
         return types_1.ClassType.cloneIncludeSubclasses(specializeTupleClass(type, [{ type: types_1.UnknownType.create(), isUnbounded: true }], 
-        /* isTypeArgumentExplicit */ false), !!type.priv.includeSubclasses);
+        /* isTypeArgExplicit */ false), !!type.priv.includeSubclasses);
     }
-    return types_1.ClassType.cloneForSpecialization(type, type.shared.typeParameters.map((param) => getUnknownTypeForTypeVar(param, tupleClassType)), 
-    /* isTypeArgumentExplicit */ false, 
+    return types_1.ClassType.specialize(type, type.shared.typeParams.map((param) => getUnknownForTypeVar(param, tupleClassType)), 
+    /* isTypeArgExplicit */ false, 
     /* includeSubclasses */ type.priv.includeSubclasses);
 }
 exports.specializeWithUnknownTypeArgs = specializeWithUnknownTypeArgs;
 // Returns "Unknown" for simple TypeVars or the equivalent for a ParamSpec.
-function getUnknownTypeForTypeVar(typeVar, tupleClassType) {
-    if (typeVar.shared.isParamSpec) {
-        return getUnknownTypeForParamSpec();
+function getUnknownForTypeVar(typeVar, tupleClassType) {
+    if ((0, types_1.isParamSpec)(typeVar)) {
+        return types_1.ParamSpecType.getUnknown();
     }
-    if (typeVar.shared.isVariadic && tupleClassType) {
-        return getUnknownTypeForVariadicTypeVar(tupleClassType);
+    if ((0, types_1.isTypeVarTuple)(typeVar) && tupleClassType) {
+        return getUnknownForTypeVarTuple(tupleClassType);
     }
     return types_1.UnknownType.create();
 }
-exports.getUnknownTypeForTypeVar = getUnknownTypeForTypeVar;
-// Returns the "Unknown" equivalent for a ParamSpec.
-function getUnknownTypeForParamSpec() {
-    const newFunction = types_1.FunctionType.createInstance('', '', '', 65536 /* FunctionTypeFlags.ParamSpecValue */ | 32768 /* FunctionTypeFlags.GradualCallableForm */);
-    types_1.FunctionType.addDefaultParameters(newFunction);
-    return newFunction;
-}
-exports.getUnknownTypeForParamSpec = getUnknownTypeForParamSpec;
-function getUnknownTypeForVariadicTypeVar(tupleClassType) {
+exports.getUnknownForTypeVar = getUnknownForTypeVar;
+function getUnknownForTypeVarTuple(tupleClassType) {
     (0, debug_1.assert)((0, types_1.isInstantiableClass)(tupleClassType) && types_1.ClassType.isBuiltIn(tupleClassType, 'tuple'));
     return types_1.ClassType.cloneAsInstance(specializeTupleClass(tupleClassType, [{ type: types_1.UnknownType.create(), isUnbounded: true }], 
-    /* isTypeArgumentExplicit */ true, 
+    /* isTypeArgExplicit */ true, 
     /* isUnpackedTuple */ true));
 }
-exports.getUnknownTypeForVariadicTypeVar = getUnknownTypeForVariadicTypeVar;
+exports.getUnknownForTypeVarTuple = getUnknownForTypeVarTuple;
 // Returns the equivalent of "Callable[..., Unknown]".
 function getUnknownTypeForCallable() {
     const newFunction = types_1.FunctionType.createSynthesizedInstance('', 32768 /* FunctionTypeFlags.GradualCallableForm */);
-    types_1.FunctionType.addDefaultParameters(newFunction);
+    types_1.FunctionType.addDefaultParams(newFunction);
     newFunction.shared.declaredReturnType = types_1.UnknownType.create();
     return newFunction;
 }
@@ -858,16 +842,16 @@ exports.getUnknownTypeForCallable = getUnknownTypeForCallable;
 // "self specializes" the class, filling in its own type parameters
 // as type arguments.
 function selfSpecializeClass(type, options) {
-    if (type.shared.typeParameters.length === 0) {
+    if (type.shared.typeParams.length === 0) {
         return type;
     }
-    if (type.priv.typeArguments && !(options === null || options === void 0 ? void 0 : options.overrideTypeArgs)) {
+    if (type.priv.typeArgs && !(options === null || options === void 0 ? void 0 : options.overrideTypeArgs)) {
         return type;
     }
-    const typeParams = type.shared.typeParameters.map((typeParam) => {
-        return (options === null || options === void 0 ? void 0 : options.useInternalTypeVars) ? types_1.TypeVarType.cloneWithInternalScopeId(typeParam) : typeParam;
+    const typeParams = type.shared.typeParams.map((typeParam) => {
+        return (options === null || options === void 0 ? void 0 : options.useBoundTypeVars) ? types_1.TypeVarType.cloneAsBound(typeParam) : typeParam;
     });
-    return types_1.ClassType.cloneForSpecialization(type, typeParams, /* isTypeArgumentExplicit */ true);
+    return types_1.ClassType.specialize(type, typeParams);
 }
 exports.selfSpecializeClass = selfSpecializeClass;
 // Determines whether the type derives from tuple. If so, it returns
@@ -892,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) {
@@ -1034,10 +1018,10 @@ exports.isMaybeDescriptorInstance = isMaybeDescriptorInstance;
 function isTupleGradualForm(type) {
     return ((0, types_1.isClassInstance)(type) &&
         isTupleClass(type) &&
-        type.priv.tupleTypeArguments &&
-        type.priv.tupleTypeArguments.length === 1 &&
-        (0, types_1.isAnyOrUnknown)(type.priv.tupleTypeArguments[0].type) &&
-        type.priv.tupleTypeArguments[0].isUnbounded);
+        type.priv.tupleTypeArgs &&
+        type.priv.tupleTypeArgs.length === 1 &&
+        (0, types_1.isAnyOrUnknown)(type.priv.tupleTypeArgs[0].type) &&
+        type.priv.tupleTypeArgs[0].isUnbounded);
 }
 exports.isTupleGradualForm = isTupleGradualForm;
 function isTupleClass(type) {
@@ -1048,23 +1032,23 @@ exports.isTupleClass = isTupleClass;
 // the form tuple[x, ...] where the number of elements
 // in the tuple is unknown.
 function isUnboundedTupleClass(type) {
-    return (type.priv.tupleTypeArguments &&
-        type.priv.tupleTypeArguments.some((t) => t.isUnbounded || (0, types_1.isUnpackedVariadicTypeVar)(t.type)));
+    var _a;
+    return (_a = type.priv.tupleTypeArgs) === null || _a === void 0 ? void 0 : _a.some((t) => t.isUnbounded || (0, types_1.isUnpackedTypeVarTuple)(t.type));
 }
 exports.isUnboundedTupleClass = isUnboundedTupleClass;
 // Indicates whether the specified index is within range and its type is unambiguous
 // in that it doesn't involve any element ranges that are of indeterminate length.
 function isTupleIndexUnambiguous(type, index) {
-    if (!type.priv.tupleTypeArguments) {
+    if (!type.priv.tupleTypeArgs) {
         return false;
     }
-    const unboundedIndex = type.priv.tupleTypeArguments.findIndex((t) => t.isUnbounded || (0, types_1.isUnpackedVariadicTypeVar)(t.type));
+    const unboundedIndex = type.priv.tupleTypeArgs.findIndex((t) => t.isUnbounded || (0, types_1.isUnpackedTypeVarTuple)(t.type));
     if (index < 0) {
         const lowerIndexLimit = unboundedIndex < 0 ? 0 : unboundedIndex;
-        index += type.priv.tupleTypeArguments.length;
+        index += type.priv.tupleTypeArgs.length;
         return index >= lowerIndexLimit;
     }
-    const upperIndexLimit = unboundedIndex < 0 ? type.priv.tupleTypeArguments.length : unboundedIndex;
+    const upperIndexLimit = unboundedIndex < 0 ? type.priv.tupleTypeArgs.length : unboundedIndex;
     return index < upperIndexLimit;
 }
 exports.isTupleIndexUnambiguous = isTupleIndexUnambiguous;
@@ -1078,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)) {
@@ -1105,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.
@@ -1118,107 +1102,58 @@ function populateTypeVarContextForSelfType(typeVarContext, contextClassType, sel
         }
         return subtype;
     });
-    if (!(0, types_1.isTypeSame)(synthesizedSelfTypeVar, selfWithoutLiteral)) {
-        typeVarContext.setTypeVarType(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.doForEachSignatureContext((destSignature) => {
-        applySourceContextTypeVarsToSignature(destSignature, srcContext);
+    destContext.doForEachConstraintSet((set) => {
+        applySourceContextTypeVarsToSignature(set, srcSolution);
     });
 }
 exports.applySourceContextTypeVars = applySourceContextTypeVars;
-function applySourceContextTypeVarsToSignature(destSignature, srcContext) {
-    destSignature.getTypeVars().forEach((entry) => {
-        const newNarrowTypeBound = entry.narrowBound ? applySolvedTypeVars(entry.narrowBound, srcContext) : undefined;
-        const newNarrowTypeBoundNoLiterals = entry.narrowBoundNoLiterals
-            ? applySolvedTypeVars(entry.narrowBoundNoLiterals, srcContext)
+function applySourceContextTypeVarsToSignature(set, srcSolution) {
+    set.getTypeVars().forEach((entry) => {
+        const newLowerBound = entry.lowerBound ? applySolvedTypeVars(entry.lowerBound, srcSolution) : undefined;
+        const newLowerBoundNoLiterals = entry.lowerBoundNoLiterals
+            ? applySolvedTypeVars(entry.lowerBoundNoLiterals, srcSolution)
             : undefined;
-        const newWideTypeBound = entry.wideBound ? applySolvedTypeVars(entry.wideBound, srcContext) : undefined;
-        destSignature.setTypeVarType(entry.typeVar, newNarrowTypeBound, newNarrowTypeBoundNoLiterals, newWideTypeBound);
-        if (entry.tupleTypes) {
-            destSignature.setTupleTypeVar(entry.typeVar, entry.tupleTypes.map((arg) => {
-                return {
-                    type: applySolvedTypeVars(arg.type, srcContext),
-                    isUnbounded: arg.isUnbounded,
-                    isOptional: arg.isOptional,
-                };
-            }));
-        }
+        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.doForEachSignatureContext((signature) => {
-        signature.getTypeVars().forEach((entry) => {
-            const typeVar = entry.typeVar;
-            if (!typeVar.priv.isInScopePlaceholder) {
-                const newNarrowTypeBound = entry.narrowBound
-                    ? applyInScopePlaceholdersToType(entry.narrowBound, signature)
-                    : undefined;
-                const newNarrowTypeBoundNoLiterals = entry.narrowBoundNoLiterals
-                    ? applyInScopePlaceholdersToType(entry.narrowBoundNoLiterals, signature)
-                    : undefined;
-                const newWideTypeBound = entry.wideBound
-                    ? applyInScopePlaceholdersToType(entry.wideBound, signature)
-                    : undefined;
-                signature.setTypeVarType(entry.typeVar, newNarrowTypeBound, newNarrowTypeBoundNoLiterals, newWideTypeBound);
-                if (entry.tupleTypes) {
-                    signature.setTupleTypeVar(entry.typeVar, entry.tupleTypes.map((arg) => {
-                        return {
-                            type: applyInScopePlaceholdersToType(arg.type, signature),
-                            isUnbounded: arg.isUnbounded,
-                            isOptional: arg.isOptional,
-                        };
-                    }));
-                }
-            }
-        });
-    });
-}
-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) {
@@ -1230,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
@@ -1293,16 +1223,16 @@ function getContainerDepth(type, recursionCount = 0) {
         return 0;
     }
     let maxChildDepth = 0;
-    if (type.priv.tupleTypeArguments) {
-        type.priv.tupleTypeArguments.forEach((typeArgInfo) => {
+    if (type.priv.tupleTypeArgs) {
+        type.priv.tupleTypeArgs.forEach((typeArgInfo) => {
             doForEachSubtype(typeArgInfo.type, (subtype) => {
                 const childDepth = getContainerDepth(subtype, recursionCount);
                 maxChildDepth = Math.max(childDepth, maxChildDepth);
             });
         });
     }
-    else if (type.priv.typeArguments) {
-        type.priv.typeArguments.forEach((typeArg) => {
+    else if (type.priv.typeArgs) {
+        type.priv.typeArgs.forEach((typeArg) => {
             doForEachSubtype(typeArg, (subtype) => {
                 const childDepth = getContainerDepth(subtype, recursionCount);
                 maxChildDepth = Math.max(childDepth, maxChildDepth);
@@ -1575,17 +1505,17 @@ exports.addTypeVarsToListIfUnique = addTypeVarsToListIfUnique;
 // of unique type variables. For example, if the type is
 // Union[List[Dict[_T1, _T2]], _T1, _T3], the result would be
 // [_T1, _T2, _T3].
-function getTypeVarArgumentsRecursive(type, recursionCount = 0) {
+function getTypeVarArgsRecursive(type, recursionCount = 0) {
     var _a;
     if (recursionCount > types_1.maxTypeRecursionCount) {
         return [];
     }
     recursionCount++;
     const aliasInfo = (_a = type.props) === null || _a === void 0 ? void 0 : _a.typeAliasInfo;
-    if (aliasInfo === null || aliasInfo === void 0 ? void 0 : aliasInfo.typeArguments) {
+    if (aliasInfo === null || aliasInfo === void 0 ? void 0 : aliasInfo.typeArgs) {
         const combinedList = [];
-        aliasInfo === null || aliasInfo === void 0 ? void 0 : aliasInfo.typeArguments.forEach((typeArg) => {
-            addTypeVarsToListIfUnique(combinedList, getTypeVarArgumentsRecursive(typeArg, recursionCount));
+        aliasInfo === null || aliasInfo === void 0 ? void 0 : aliasInfo.typeArgs.forEach((typeArg) => {
+            addTypeVarsToListIfUnique(combinedList, getTypeVarArgsRecursive(typeArg, recursionCount));
         });
         return combinedList;
     }
@@ -1602,12 +1532,10 @@ function getTypeVarArgumentsRecursive(type, recursionCount = 0) {
     }
     if ((0, types_1.isClass)(type)) {
         const combinedList = [];
-        const typeArgs = type.priv.tupleTypeArguments
-            ? type.priv.tupleTypeArguments.map((e) => e.type)
-            : type.priv.typeArguments;
+        const typeArgs = type.priv.tupleTypeArgs ? type.priv.tupleTypeArgs.map((e) => e.type) : type.priv.typeArgs;
         if (typeArgs) {
             typeArgs.forEach((typeArg) => {
-                addTypeVarsToListIfUnique(combinedList, getTypeVarArgumentsRecursive(typeArg, recursionCount));
+                addTypeVarsToListIfUnique(combinedList, getTypeVarArgsRecursive(typeArg, recursionCount));
             });
         }
         return combinedList;
@@ -1615,153 +1543,136 @@ function getTypeVarArgumentsRecursive(type, recursionCount = 0) {
     if ((0, types_1.isUnion)(type)) {
         const combinedList = [];
         doForEachSubtype(type, (subtype) => {
-            addTypeVarsToListIfUnique(combinedList, getTypeVarArgumentsRecursive(subtype, recursionCount));
+            addTypeVarsToListIfUnique(combinedList, getTypeVarArgsRecursive(subtype, recursionCount));
         });
         return combinedList;
     }
     if ((0, types_1.isFunction)(type)) {
         const combinedList = [];
         for (let i = 0; i < type.shared.parameters.length; i++) {
-            addTypeVarsToListIfUnique(combinedList, getTypeVarArgumentsRecursive(types_1.FunctionType.getEffectiveParameterType(type, i), recursionCount));
+            addTypeVarsToListIfUnique(combinedList, getTypeVarArgsRecursive(types_1.FunctionType.getParamType(type, i), recursionCount));
         }
         const returnType = types_1.FunctionType.getEffectiveReturnType(type);
         if (returnType) {
-            addTypeVarsToListIfUnique(combinedList, getTypeVarArgumentsRecursive(returnType, recursionCount));
+            addTypeVarsToListIfUnique(combinedList, getTypeVarArgsRecursive(returnType, recursionCount));
         }
         return combinedList;
     }
     return [];
 }
-exports.getTypeVarArgumentsRecursive = getTypeVarArgumentsRecursive;
+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 typeParams = types_1.ClassType.getTypeParameters(type);
+    const solution = new constraintSolution_1.ConstraintSolution();
+    const typeParams = types_1.ClassType.getTypeParams(type);
     typeParams.forEach((typeParam) => {
-        typeVarContext.setTypeVarType(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 setTypeArgumentsRecursive(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) => {
-                setTypeArgumentsRecursive(subtype, srcType, typeVarContext, recursionCount);
+                setTypeArgsRecursive(subtype, srcType, constraints, recursionCount);
             });
             break;
         case 6 /* TypeCategory.Class */:
-            if (destType.priv.typeArguments) {
-                destType.priv.typeArguments.forEach((typeArg) => {
-                    setTypeArgumentsRecursive(typeArg, srcType, typeVarContext, recursionCount);
+            if (destType.priv.typeArgs) {
+                destType.priv.typeArgs.forEach((typeArg) => {
+                    setTypeArgsRecursive(typeArg, srcType, constraints, recursionCount);
                 });
             }
-            if (destType.priv.tupleTypeArguments) {
-                destType.priv.tupleTypeArguments.forEach((typeArg) => {
-                    setTypeArgumentsRecursive(typeArg.type, srcType, typeVarContext, recursionCount);
+            if (destType.priv.tupleTypeArgs) {
+                destType.priv.tupleTypeArgs.forEach((typeArg) => {
+                    setTypeArgsRecursive(typeArg.type, srcType, constraints, recursionCount);
                 });
             }
             break;
         case 4 /* TypeCategory.Function */:
             if (destType.priv.specializedTypes) {
                 destType.priv.specializedTypes.parameterTypes.forEach((paramType) => {
-                    setTypeArgumentsRecursive(paramType, srcType, typeVarContext, recursionCount);
+                    setTypeArgsRecursive(paramType, srcType, constraints, recursionCount);
                 });
                 if (destType.priv.specializedTypes.returnType) {
-                    setTypeArgumentsRecursive(destType.priv.specializedTypes.returnType, srcType, typeVarContext, recursionCount);
+                    setTypeArgsRecursive(destType.priv.specializedTypes.returnType, srcType, constraints, recursionCount);
                 }
             }
             else {
-                destType.shared.parameters.forEach((param) => {
-                    setTypeArgumentsRecursive(param.type, srcType, typeVarContext, recursionCount);
+                destType.shared.parameters.forEach((_, index) => {
+                    setTypeArgsRecursive(types_1.FunctionType.getParamType(destType, index), srcType, constraints, recursionCount);
                 });
                 if (destType.shared.declaredReturnType) {
-                    setTypeArgumentsRecursive(destType.shared.declaredReturnType, srcType, typeVarContext, recursionCount);
+                    setTypeArgsRecursive(destType.shared.declaredReturnType, srcType, constraints, recursionCount);
                 }
             }
             break;
         case 5 /* TypeCategory.OverloadedFunction */:
             destType.priv.overloads.forEach((subtype) => {
-                setTypeArgumentsRecursive(subtype, srcType, typeVarContext, recursionCount);
+                setTypeArgsRecursive(subtype, srcType, constraints, recursionCount);
             });
             break;
         case 9 /* TypeCategory.TypeVar */:
-            if (!typeVarContext.getPrimarySignature().getTypeVar(destType)) {
-                typeVarContext.setTypeVarType(destType, srcType);
+            if (!constraints.getMainConstraintSet().getTypeVar(destType)) {
+                constraints.setBounds(destType, srcType);
             }
             break;
     }
 }
-exports.setTypeArgumentsRecursive = setTypeArgumentsRecursive;
+exports.setTypeArgsRecursive = setTypeArgsRecursive;
 // Builds a mapping between type parameters and their specialized
 // 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) {
-    const typeParameters = types_1.ClassType.getTypeParameters(classType);
-    const typeVarContext = buildTypeVarContext(typeParameters, classType.priv.typeArguments, getTypeVarScopeId(classType));
-    if (types_1.ClassType.isTupleClass(classType) && classType.priv.tupleTypeArguments) {
-        typeVarContext.setTupleTypeVar(typeParameters[0], classType.priv.tupleTypeArguments);
-    }
-    return typeVarContext;
-}
-exports.buildTypeVarContextFromSpecializedClass = buildTypeVarContextFromSpecializedClass;
-function buildTypeVarContext(typeParameters, typeArgs, typeVarScopeId) {
-    const typeVarContext = new typeVarContext_1.TypeVarContext(typeVarScopeId);
-    typeParameters.forEach((typeParam, index) => {
-        let typeArgType;
-        if (typeArgs) {
-            if (typeParam.shared.isParamSpec) {
-                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.getEffectiveParameterType(typeArgFunctionType, paramIndex), param.flags & types_1.FunctionParamFlags.NameSynthesized, param.name, param.defaultType));
-                        });
-                        typeVarContext.setTypeVarType(typeParam, convertTypeToParamSpecValue(typeArgType));
-                    }
-                    else if ((0, types_1.isParamSpec)(typeArgType) || (0, types_1.isAnyOrUnknown)(typeArgType)) {
-                        typeVarContext.setTypeVarType(typeParam, convertTypeToParamSpecValue(typeArgType));
-                    }
-                }
-            }
-            else {
-                if (index >= typeArgs.length) {
-                    typeArgType = types_1.AnyType.create();
-                }
-                else {
-                    typeArgType = typeArgs[index];
-                }
-                typeVarContext.setTypeVarType(typeParam, typeArgType, 
-                /* narrowBoundNoLiterals */ undefined, typeArgType);
-            }
+function buildSolutionFromSpecializedClass(classType) {
+    const typeParams = types_1.ClassType.getTypeParams(classType);
+    let typeArgs;
+    if (classType.priv.tupleTypeArgs) {
+        typeArgs = [
+            convertToInstance(specializeTupleClass(classType, classType.priv.tupleTypeArgs, classType.priv.isTypeArgExplicit, 
+            /* isUnpackedTuple */ true)),
+        ];
+    }
+    else {
+        typeArgs = classType.priv.typeArgs;
+    }
+    return buildSolution(typeParams, typeArgs);
+}
+exports.buildSolutionFromSpecializedClass = buildSolutionFromSpecializedClass;
+function buildSolution(typeParams, typeArgs) {
+    const solution = new constraintSolution_1.ConstraintSolution();
+    if (!typeArgs) {
+        return solution;
+    }
+    typeParams.forEach((typeParam, index) => {
+        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.getTypeParameters(baseClass);
+    const typeParams = types_1.ClassType.getTypeParams(baseClass);
     // If there are no type parameters for the specified base class,
     // no specialization is required.
     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;
 }
@@ -1799,9 +1710,9 @@ function synthesizeTypeVarForSelfCls(classType, isClsParam) {
     selfType.shared.isSynthesizedSelf = true;
     selfType.priv.nameWithScope = types_1.TypeVarType.makeNameWithScope(selfType.shared.name, scopeId);
     selfType.priv.scopeId = scopeId;
-    const boundType = types_1.ClassType.cloneForSpecialization(classType, 
-    /* typeArguments */ undefined, 
-    /* isTypeArgumentExplicit */ false, 
+    const boundType = types_1.ClassType.specialize(classType, 
+    /* typeArgs */ undefined, 
+    /* isTypeArgExplicit */ false, 
     /* includeSubclasses */ !!classType.priv.includeSubclasses);
     selfType.shared.boundType = types_1.ClassType.cloneAsInstance(boundType);
     return isClsParam ? types_1.TypeVarType.cloneAsInstantiable(selfType) : selfType;
@@ -1838,8 +1749,8 @@ function getGeneratorYieldType(declaredReturnType, isAsync) {
                 ['', 'AwaitableGenerator'],
             ];
             if (expectedClasses.some((classes) => types_1.ClassType.isBuiltIn(subtype, isAsync ? classes[0] : classes[1]))) {
-                return subtype.priv.typeArguments && subtype.priv.typeArguments.length >= 1
-                    ? subtype.priv.typeArguments[0]
+                return subtype.priv.typeArgs && subtype.priv.typeArgs.length >= 1
+                    ? subtype.priv.typeArgs[0]
                     : types_1.UnknownType.create();
             }
         }
@@ -1895,17 +1806,17 @@ function convertToInstance(type, includeSubclasses = true) {
                 // Handle type[x] as a special case.
                 if (types_1.ClassType.isBuiltIn(subtype, 'type')) {
                     if (types_1.TypeBase.isInstance(subtype)) {
-                        if (!subtype.priv.typeArguments || subtype.priv.typeArguments.length < 1) {
+                        if (!subtype.priv.typeArgs || subtype.priv.typeArgs.length < 1) {
                             return types_1.UnknownType.create();
                         }
                         else {
-                            return subtype.priv.typeArguments[0];
+                            return subtype.priv.typeArgs[0];
                         }
                     }
                     else {
-                        if (subtype.priv.typeArguments && subtype.priv.typeArguments.length > 0) {
-                            if (!(0, types_1.isAnyOrUnknown)(subtype.priv.typeArguments[0])) {
-                                return convertToInstantiable(subtype.priv.typeArguments[0]);
+                        if (subtype.priv.typeArgs && subtype.priv.typeArgs.length > 0) {
+                            if (!(0, types_1.isAnyOrUnknown)(subtype.priv.typeArgs[0])) {
+                                return convertToInstantiable(subtype.priv.typeArgs[0]);
                             }
                         }
                     }
@@ -1944,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.typeParameters, aliasInfo.typeArguments);
+        result = types_1.TypeBase.cloneForTypeAlias(result, aliasInfo);
     }
     if (type !== result && includeSubclasses) {
         // Cache the converted value for next time.
@@ -2131,8 +2042,8 @@ function isPartlyUnknown(type, recursionCount = 0) {
     // If this is a generic type alias, see if any of its type arguments
     // are either unspecified or are partially known.
     const aliasInfo = (_a = type.props) === null || _a === void 0 ? void 0 : _a.typeAliasInfo;
-    if (aliasInfo === null || aliasInfo === void 0 ? void 0 : aliasInfo.typeArguments) {
-        if (aliasInfo.typeArguments.some((typeArg) => isPartlyUnknown(typeArg, recursionCount))) {
+    if (aliasInfo === null || aliasInfo === void 0 ? void 0 : aliasInfo.typeArgs) {
+        if (aliasInfo.typeArgs.some((typeArg) => isPartlyUnknown(typeArg, recursionCount))) {
             return true;
         }
     }
@@ -2149,7 +2060,7 @@ function isPartlyUnknown(type, recursionCount = 0) {
             return false;
         }
         if (!types_1.ClassType.isPseudoGenericClass(type)) {
-            const typeArgs = ((_b = type.priv.tupleTypeArguments) === null || _b === void 0 ? void 0 : _b.map((t) => t.type)) || type.priv.typeArguments;
+            const typeArgs = ((_b = type.priv.tupleTypeArgs) === null || _b === void 0 ? void 0 : _b.map((t) => t.type)) || type.priv.typeArgs;
             if (typeArgs) {
                 for (const argType of typeArgs) {
                     if (isPartlyUnknown(argType, recursionCount)) {
@@ -2170,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.getEffectiveParameterType(type, i);
+                const paramType = types_1.FunctionType.getParamType(type, i);
                 if (isPartlyUnknown(paramType, recursionCount)) {
                     return true;
                 }
@@ -2190,13 +2101,11 @@ exports.isPartlyUnknown = isPartlyUnknown;
 // that is a union, it "explodes" the class into a union of classes with
 // each element of the union - e.g. Foo[A | B] becomes Foo[A] | Foo[B].
 function explodeGenericClass(classType) {
-    if (!classType.priv.typeArguments ||
-        classType.priv.typeArguments.length !== 1 ||
-        !(0, types_1.isUnion)(classType.priv.typeArguments[0])) {
+    if (!classType.priv.typeArgs || classType.priv.typeArgs.length !== 1 || !(0, types_1.isUnion)(classType.priv.typeArgs[0])) {
         return classType;
     }
-    return (0, types_1.combineTypes)(classType.priv.typeArguments[0].priv.subtypes.map((subtype) => {
-        return types_1.ClassType.cloneForSpecialization(classType, [subtype], /* isTypeArgumentExplicit */ true);
+    return (0, types_1.combineTypes)(classType.priv.typeArgs[0].priv.subtypes.map((subtype) => {
+        return types_1.ClassType.specialize(classType, [subtype]);
     }));
 }
 exports.explodeGenericClass = explodeGenericClass;
@@ -2219,10 +2128,10 @@ function combineSameSizedTuples(type, tupleType) {
                 // tuple with a known size. This includes named tuples.
                 tupleClass = subtype.shared.mro.find((mroClass) => (0, types_1.isClass)(mroClass) && isTupleClass(mroClass) && !isUnboundedTupleClass(mroClass));
             }
-            if (tupleClass && (0, types_1.isClass)(tupleClass) && tupleClass.priv.tupleTypeArguments) {
+            if (tupleClass && (0, types_1.isClass)(tupleClass) && tupleClass.priv.tupleTypeArgs) {
                 if (tupleEntries) {
-                    if (tupleEntries.length === tupleClass.priv.tupleTypeArguments.length) {
-                        tupleClass.priv.tupleTypeArguments.forEach((entry, index) => {
+                    if (tupleEntries.length === tupleClass.priv.tupleTypeArgs.length) {
+                        tupleClass.priv.tupleTypeArgs.forEach((entry, index) => {
                             tupleEntries[index].push(entry.type);
                         });
                     }
@@ -2231,7 +2140,7 @@ function combineSameSizedTuples(type, tupleType) {
                     }
                 }
                 else {
-                    tupleEntries = tupleClass.priv.tupleTypeArguments.map((entry) => [entry.type]);
+                    tupleEntries = tupleClass.priv.tupleTypeArgs.map((entry) => [entry.type]);
                 }
             }
             else {
@@ -2250,18 +2159,21 @@ function combineSameSizedTuples(type, tupleType) {
     })));
 }
 exports.combineSameSizedTuples = combineSameSizedTuples;
-// Tuples require special handling for specialization. This method computes
-// the "effective" type argument, which is a union of the variadic type
-// arguments.
-function specializeTupleClass(classType, typeArgs, isTypeArgumentExplicit = true, isUnpackedTuple = false) {
-    const combinedTupleType = (0, types_1.combineTypes)(typeArgs.map((t) => {
-        if ((0, types_1.isTypeVar)(t.type) && (0, types_1.isUnpackedVariadicTypeVar)(t.type)) {
+function combineTupleTypeArgs(typeArgs) {
+    return (0, types_1.combineTypes)(typeArgs.map((t) => {
+        if ((0, types_1.isTypeVar)(t.type) && (0, types_1.isUnpackedTypeVarTuple)(t.type)) {
             // Treat the unpacked TypeVarTuple as a union.
             return types_1.TypeVarType.cloneForUnpacked(t.type, /* isInUnion */ true);
         }
         return t.type;
     }));
-    const clonedClassType = types_1.ClassType.cloneForSpecialization(classType, [combinedTupleType], isTypeArgumentExplicit, 
+}
+exports.combineTupleTypeArgs = combineTupleTypeArgs;
+// Tuples require special handling for specialization. This method computes
+// the "effective" type argument, which is a union of the variadic type
+// arguments.
+function specializeTupleClass(classType, typeArgs, isTypeArgExplicit = true, isUnpackedTuple = false) {
+    const clonedClassType = types_1.ClassType.specialize(classType, [combineTupleTypeArgs(typeArgs)], isTypeArgExplicit, 
     /* includeSubclasses */ undefined, typeArgs);
     if (isUnpackedTuple) {
         clonedClassType.priv.isUnpacked = true;
@@ -2269,9 +2181,9 @@ function specializeTupleClass(classType, typeArgs, isTypeArgumentExplicit = true
     return clonedClassType;
 }
 exports.specializeTupleClass = specializeTupleClass;
-function _expandVariadicUnpackedUnion(type) {
-    if ((0, types_1.isClassInstance)(type) && isTupleClass(type) && type.priv.tupleTypeArguments && type.priv.isUnpacked) {
-        return (0, types_1.combineTypes)(type.priv.tupleTypeArguments.map((t) => t.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));
     }
     return type;
 }
@@ -2281,20 +2193,20 @@ function getGeneratorTypeArgs(returnType) {
     var _a;
     if ((0, types_1.isClassInstance)(returnType)) {
         if (types_1.ClassType.isBuiltIn(returnType, ['Generator', 'AsyncGenerator'])) {
-            return returnType.priv.typeArguments;
+            return returnType.priv.typeArgs;
         }
         else if (types_1.ClassType.isBuiltIn(returnType, 'AwaitableGenerator')) {
             // AwaitableGenerator has four type arguments, and the first 3
             // correspond to the generator.
-            return (_a = returnType.priv.typeArguments) === null || _a === void 0 ? void 0 : _a.slice(0, 3);
+            return (_a = returnType.priv.typeArgs) === null || _a === void 0 ? void 0 : _a.slice(0, 3);
         }
     }
     return undefined;
 }
 exports.getGeneratorTypeArgs = getGeneratorTypeArgs;
-function requiresTypeArguments(classType) {
-    if (classType.shared.typeParameters.length > 0) {
-        const firstTypeParam = classType.shared.typeParameters[0];
+function requiresTypeArgs(classType) {
+    if (classType.shared.typeParams.length > 0) {
+        const firstTypeParam = classType.shared.typeParams[0];
         // If there are type parameters, type arguments are needed.
         // The exception is if type parameters have been synthesized
         // for classes that have untyped constructors.
@@ -2309,7 +2221,7 @@ function requiresTypeArguments(classType) {
         return true;
     }
     // There are a few built-in special classes that require
-    // type arguments even though typeParameters is empty.
+    // type arguments even though typeParams is empty.
     if (types_1.ClassType.isSpecialBuiltIn(classType)) {
         const specialClasses = [
             'Tuple',
@@ -2329,7 +2241,7 @@ function requiresTypeArguments(classType) {
     }
     return false;
 }
-exports.requiresTypeArguments = requiresTypeArguments;
+exports.requiresTypeArgs = requiresTypeArgs;
 function requiresSpecialization(type, options, recursionCount = 0) {
     var _a;
     if (recursionCount > types_1.maxTypeRecursionCount) {
@@ -2362,17 +2274,17 @@ function _requiresSpecialization(type, options, recursionCount = 0) {
             if (types_1.ClassType.isPseudoGenericClass(type) && (options === null || options === void 0 ? void 0 : options.ignorePseudoGeneric)) {
                 return false;
             }
-            if (!type.priv.isTypeArgumentExplicit && (options === null || options === void 0 ? void 0 : options.ignoreImplicitTypeArgs)) {
+            if (!type.priv.isTypeArgExplicit && (options === null || options === void 0 ? void 0 : options.ignoreImplicitTypeArgs)) {
                 return false;
             }
-            if (type.priv.typeArguments) {
-                return type.priv.typeArguments.some((typeArg) => requiresSpecialization(typeArg, options, recursionCount));
+            if (type.priv.typeArgs) {
+                return type.priv.typeArgs.some((typeArg) => requiresSpecialization(typeArg, options, recursionCount));
             }
-            return types_1.ClassType.getTypeParameters(type).length > 0;
+            return types_1.ClassType.getTypeParams(type).length > 0;
         }
         case 4 /* TypeCategory.Function */: {
             for (let i = 0; i < type.shared.parameters.length; i++) {
-                if (requiresSpecialization(types_1.FunctionType.getEffectiveParameterType(type, i), options, recursionCount)) {
+                if (requiresSpecialization(types_1.FunctionType.getParamType(type, i), options, recursionCount)) {
                     return true;
                 }
             }
@@ -2400,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;
@@ -2408,8 +2320,8 @@ function _requiresSpecialization(type, options, recursionCount = 0) {
             // If this is a recursive type alias, it may need to be specialized
             // if it has generic type arguments.
             const aliasInfo = (_b = type.props) === null || _b === void 0 ? void 0 : _b.typeAliasInfo;
-            if (aliasInfo === null || aliasInfo === void 0 ? void 0 : aliasInfo.typeArguments) {
-                return aliasInfo.typeArguments.some((typeArg) => requiresSpecialization(typeArg, options, recursionCount));
+            if (aliasInfo === null || aliasInfo === void 0 ? void 0 : aliasInfo.typeArgs) {
+                return aliasInfo.typeArgs.some((typeArg) => requiresSpecialization(typeArg, options, recursionCount));
             }
         }
     }
@@ -2430,25 +2342,25 @@ function combineVariances(variance1, variance2) {
 exports.combineVariances = combineVariances;
 // Determines if the variance of the type argument for a generic class is compatible
 // With the declared variance of the corresponding type parameter.
-function isVarianceOfTypeArgumentCompatible(type, typeParamVariance) {
+function isVarianceOfTypeArgCompatible(type, typeParamVariance) {
     if (typeParamVariance === 1 /* Variance.Unknown */ || typeParamVariance === 0 /* Variance.Auto */) {
         return true;
     }
-    if ((0, types_1.isTypeVar)(type) && !type.shared.isParamSpec && !type.shared.isVariadic) {
+    if ((0, types_1.isTypeVar)(type) && !(0, types_1.isParamSpec)(type) && !(0, types_1.isTypeVarTuple)(type)) {
         const typeArgVariance = type.shared.declaredVariance;
         if (typeArgVariance === 4 /* Variance.Contravariant */ || typeArgVariance === 3 /* Variance.Covariant */) {
             return typeArgVariance === typeParamVariance;
         }
     }
     else if ((0, types_1.isClassInstance)(type)) {
-        if (type.shared.typeParameters && type.shared.typeParameters.length > 0) {
-            return type.shared.typeParameters.every((typeParam, index) => {
+        if (type.shared.typeParams && type.shared.typeParams.length > 0) {
+            return type.shared.typeParams.every((typeParam, index) => {
                 let typeArgType;
-                if (typeParam.shared.isParamSpec || typeParam.shared.isVariadic) {
+                if ((0, types_1.isParamSpec)(typeParam) || (0, types_1.isTypeVarTuple)(typeParam)) {
                     return true;
                 }
-                if (type.priv.typeArguments && index < type.priv.typeArguments.length) {
-                    typeArgType = type.priv.typeArguments[index];
+                if (type.priv.typeArgs && index < type.priv.typeArgs.length) {
+                    typeArgType = type.priv.typeArgs[index];
                 }
                 const declaredVariance = typeParam.shared.declaredVariance;
                 if (declaredVariance === 0 /* Variance.Auto */) {
@@ -2470,13 +2382,13 @@ function isVarianceOfTypeArgumentCompatible(type, typeParamVariance) {
                         effectiveVariance = 3 /* Variance.Covariant */;
                     }
                 }
-                return isVarianceOfTypeArgumentCompatible(typeArgType !== null && typeArgType !== void 0 ? typeArgType : types_1.UnknownType.create(), effectiveVariance);
+                return isVarianceOfTypeArgCompatible(typeArgType !== null && typeArgType !== void 0 ? typeArgType : types_1.UnknownType.create(), effectiveVariance);
             });
         }
     }
     return true;
 }
-exports.isVarianceOfTypeArgumentCompatible = isVarianceOfTypeArgumentCompatible;
+exports.isVarianceOfTypeArgCompatible = isVarianceOfTypeArgCompatible;
 // Computes the method resolution ordering for a class whose base classes
 // have already been filled in. The algorithm for computing MRO is described
 // here: https://www.python.org/download/releases/2.3/mro/. It returns true
@@ -2501,8 +2413,8 @@ function computeMroLinearization(classType) {
                 if (classType.shared.baseClasses.some((innerBaseClass, innerIndex) => {
                     return (innerIndex > index &&
                         (0, types_1.isInstantiableClass)(innerBaseClass) &&
-                        innerBaseClass.priv.typeArguments &&
-                        innerBaseClass.priv.isTypeArgumentExplicit);
+                        innerBaseClass.priv.typeArgs &&
+                        innerBaseClass.priv.isTypeArgExplicit);
                 })) {
                     return false;
                 }
@@ -2514,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 {
@@ -2524,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();
     }
@@ -2616,14 +2528,14 @@ function getDeclaringModulesForType(type) {
     return moduleList;
 }
 exports.getDeclaringModulesForType = getDeclaringModulesForType;
-function convertArgumentNodeToFunctionArgument(node) {
+function convertNodeToArg(node) {
     return {
-        argumentCategory: node.d.argCategory,
+        argCategory: node.d.argCategory,
         name: node.d.name,
         valueExpression: node.d.valueExpr,
     };
 }
-exports.convertArgumentNodeToFunctionArgument = convertArgumentNodeToFunctionArgument;
+exports.convertNodeToArg = convertNodeToArg;
 function addDeclaringModuleNamesForType(type, moduleList, recursionCount = 0) {
     if (recursionCount > types_1.maxTypeRecursionCount) {
         return;
@@ -2672,64 +2584,53 @@ 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.addParameter(newFunction, types_1.FunctionParam.create(param.category, types_1.FunctionType.getEffectiveParameterType(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 getUnknownTypeForParamSpec();
+    return types_1.ParamSpecType.getUnknown();
 }
 exports.convertTypeToParamSpecValue = convertTypeToParamSpecValue;
 // 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 hasParameters = withoutParamSpec.shared.parameters.length > 0;
+    let hasParams = withoutParamSpec.shared.parameters.length > 0;
     if (withoutParamSpec.shared.parameters.length === 1) {
         // If the ParamSpec has a position-only separator as its only parameter,
         // treat it as though there are no parameters.
         const onlyParam = withoutParamSpec.shared.parameters[0];
         if ((0, types_1.isPositionOnlySeparator)(onlyParam)) {
-            hasParameters = false;
+            hasParams = false;
         }
     }
     // Can we simplify it to just a paramSpec?
-    if (!hasParameters && paramSpec) {
+    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.addParameter(functionType, types_1.FunctionParam.create(entry.category, types_1.FunctionType.getEffectiveParameterType(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) {
@@ -2758,11 +2659,11 @@ class TypeVarTransformer {
             // type aliases.
             const aliasInfo = (_b = type.props) === null || _b === void 0 ? void 0 : _b.typeAliasInfo;
             if (type.shared.recursiveAlias) {
-                if (!(aliasInfo === null || aliasInfo === void 0 ? void 0 : aliasInfo.typeArguments)) {
+                if (!(aliasInfo === null || aliasInfo === void 0 ? void 0 : aliasInfo.typeArgs)) {
                     return type;
                 }
                 let requiresUpdate = false;
-                const typeArgs = aliasInfo.typeArguments.map((typeArg) => {
+                const typeArgs = aliasInfo.typeArgs.map((typeArg) => {
                     const replacementType = this.apply(typeArg, recursionCount);
                     if (replacementType !== typeArg) {
                         requiresUpdate = true;
@@ -2770,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.typeParameters, typeArgs);
+                    return types_1.TypeBase.cloneForTypeAlias(type, { ...aliasInfo, typeArgs });
                 }
                 return type;
             }
@@ -2779,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 (type.shared.isParamSpec) {
-                    let paramSpecWithoutAccess = type;
-                    if (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.isVariadicTypeVar)(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;
@@ -2823,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 ((0, types_1.isVariadicTypeVar)(subtype) && !(0, types_1.isVariadicTypeVar)(transformedType)) {
+                // 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);
                 }
@@ -2885,13 +2779,10 @@ class TypeVarTransformer {
     transformTupleTypeVar(paramSpec, recursionCount) {
         return undefined;
     }
-    transformParamSpec(paramSpec, recursionCount) {
-        return undefined;
-    }
     transformUnionSubtype(preTransform, postTransform, recursionCount) {
         return postTransform;
     }
-    doForEachSignatureContext(callback) {
+    doForEachConstraintSet(callback) {
         // By default, simply return the result of the callback. Subclasses
         // can override this method as they see fit.
         return callback();
@@ -2899,27 +2790,26 @@ class TypeVarTransformer {
     transformGenericTypeAlias(type, recursionCount) {
         var _a;
         const aliasInfo = (_a = type.props) === null || _a === void 0 ? void 0 : _a.typeAliasInfo;
-        if (!aliasInfo || !aliasInfo.typeParameters || !aliasInfo.typeArguments) {
+        if (!aliasInfo || !aliasInfo.typeParams || !aliasInfo.typeArgs) {
             return type;
         }
         let requiresUpdate = false;
-        const newTypeArgs = aliasInfo.typeArguments.map((typeArg) => {
+        const newTypeArgs = aliasInfo.typeArgs.map((typeArg) => {
             const updatedType = this.apply(typeArg, recursionCount);
             if (type !== updatedType) {
                 requiresUpdate = true;
             }
             return updatedType;
         });
-        return requiresUpdate
-            ? types_1.TypeBase.cloneForTypeAlias(type, aliasInfo.name, aliasInfo.fullName, aliasInfo.moduleName, aliasInfo.fileUri, aliasInfo.typeVarScopeId, aliasInfo.isPep695Syntax, aliasInfo.typeParameters, 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) {
-        const typeParams = types_1.ClassType.getTypeParameters(classType);
+        var _a;
+        const typeParams = types_1.ClassType.getTypeParams(classType);
         // Handle the common case where the class has no type parameters.
         if (typeParams.length === 0 &&
             !types_1.ClassType.isSpecialBuiltIn(classType) &&
@@ -2929,33 +2819,21 @@ 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)) {
-            if (classType.priv.tupleTypeArguments) {
+            if (classType.priv.tupleTypeArgs) {
                 newTupleTypeArgs = [];
-                classType.priv.tupleTypeArguments.forEach((oldTypeArgType) => {
+                classType.priv.tupleTypeArgs.forEach((oldTypeArgType) => {
                     const newTypeArgType = this.apply(oldTypeArgType.type, recursionCount);
                     if (newTypeArgType !== oldTypeArgType.type) {
                         specializationNeeded = true;
                     }
-                    if ((0, types_1.isUnpackedVariadicTypeVar)(oldTypeArgType.type) &&
+                    if ((0, types_1.isUnpackedTypeVarTuple)(oldTypeArgType.type) &&
                         (0, types_1.isClassInstance)(newTypeArgType) &&
                         isTupleClass(newTypeArgType) &&
-                        newTypeArgType.priv.tupleTypeArguments) {
-                        (0, collectionUtils_1.appendArray)(newTupleTypeArgs, newTypeArgType.priv.tupleTypeArguments);
+                        newTypeArgType.priv.tupleTypeArgs) {
+                        (0, collectionUtils_1.appendArray)(newTupleTypeArgs, newTypeArgType.priv.tupleTypeArgs);
                     }
                     else {
                         // Handle the special case where tuple[T, ...] is being specialized
@@ -2963,7 +2841,7 @@ class TypeVarTransformer {
                         const isEmptyTuple = oldTypeArgType.isUnbounded &&
                             (0, types_1.isTypeVar)(oldTypeArgType.type) &&
                             (0, types_1.isNever)(newTypeArgType) &&
-                            classType.priv.tupleTypeArguments.length === 1;
+                            classType.priv.tupleTypeArgs.length === 1;
                         if (!isEmptyTuple) {
                             newTupleTypeArgs.push({
                                 type: newTypeArgType,
@@ -2988,108 +2866,67 @@ class TypeVarTransformer {
             // If this is an empty tuple, don't recompute the non-tuple type argument.
             if (newTupleTypeArgs && newTupleTypeArgs.length > 0) {
                 // Combine the tuple type args into a single non-tuple type argument.
-                newTypeArgs = [
-                    (0, types_1.combineTypes)(newTupleTypeArgs.map((t) => {
-                        if ((0, types_1.isTypeVar)(t.type) && (0, types_1.isUnpackedVariadicTypeVar)(t.type)) {
-                            // Treat the unpacked TypeVarTuple as a union.
-                            return types_1.TypeVarType.cloneForUnpacked(t.type, /* isInUnion */ true);
-                        }
-                        return t.type;
-                    })),
-                ];
+                newTypeArgs = [combineTupleTypeArgs(newTupleTypeArgs)];
             }
         }
         if (!newTypeArgs) {
-            if (classType.priv.typeArguments) {
-                newTypeArgs = classType.priv.typeArguments.map((oldTypeArgType) => {
-                    if ((0, types_1.isTypeVar)(oldTypeArgType) && oldTypeArgType.shared.isParamSpec) {
-                        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.isVariadicTypeVar)(oldTypeArgType) &&
-                            oldTypeArgType.priv.isVariadicInUnion) {
-                            newTypeArgType = _expandVariadicUnpackedUnion(newTypeArgType);
-                        }
-                    }
-                    return newTypeArgType;
-                });
-            }
-            else {
-                newTypeArgs = [];
-                typeParams.forEach((typeParam) => {
-                    let replacementType = typeParam;
-                    if (typeParam.shared.isParamSpec) {
-                        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.typeArguments) {
-                                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;
         }
-        return types_1.ClassType.cloneForSpecialization(classType, newTypeArgs, 
-        /* isTypeArgumentExplicit */ true, 
+        return types_1.ClassType.specialize(classType, newTypeArgs, 
+        /* isTypeArgExplicit */ true, 
         /* includeSubclasses */ undefined, newTupleTypeArgs);
     }
     transformTypeVarsInFunctionType(sourceType, recursionCount) {
-        return this.doForEachSignatureContext(() => {
+        return this.doForEachConstraintSet(() => {
             let functionType = sourceType;
             const declaredReturnType = types_1.FunctionType.getEffectiveReturnType(functionType);
             const specializedReturnType = declaredReturnType
                 ? this.apply(declaredReturnType, recursionCount)
                 : undefined;
             let typesRequiredSpecialization = declaredReturnType !== specializedReturnType;
-            const specializedParameters = {
+            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.getEffectiveParameterType(functionType, i);
+                const paramType = types_1.FunctionType.getParamType(functionType, i);
                 const specializedType = this.apply(paramType, recursionCount);
-                specializedParameters.parameterTypes.push(specializedType);
+                specializedParams.parameterTypes.push(specializedType);
                 // Do we need to specialize the default argument type for this parameter?
-                let defaultArgType = types_1.FunctionType.getEffectiveParameterDefaultArgType(functionType, i);
+                let defaultArgType = types_1.FunctionType.getParamDefaultType(functionType, i);
                 if (defaultArgType) {
                     const specializedArgType = this.apply(defaultArgType, recursionCount);
                     if (specializedArgType !== defaultArgType) {
@@ -3099,13 +2936,13 @@ class TypeVarTransformer {
                 }
                 specializedDefaultArgs.push(defaultArgType);
                 if (variadicParamIndex === undefined &&
-                    (0, types_1.isVariadicTypeVar)(paramType) &&
-                    functionType.shared.parameters[i].category === 1 /* ParameterCategory.ArgsList */) {
+                    (0, types_1.isTypeVarTuple)(paramType) &&
+                    functionType.shared.parameters[i].category === 1 /* ParamCategory.ArgsList */) {
                     variadicParamIndex = i;
                     if ((0, types_1.isClassInstance)(specializedType) &&
                         isTupleClass(specializedType) &&
                         specializedType.priv.isUnpacked) {
-                        variadicTypesToUnpack = specializedType.priv.tupleTypeArguments;
+                        variadicTypesToUnpack = specializedType.priv.tupleTypeArgs;
                     }
                 }
                 if (paramType !== specializedType) {
@@ -3134,16 +2971,15 @@ class TypeVarTransformer {
                     functionType.priv.strippedFirstParamType = newStrippedType;
                 }
             }
-            this._isTransformingTypeArg = wasTransformingTypeArg;
             if (!typesRequiredSpecialization) {
                 return functionType;
             }
             if (specializedDefaultArgs.some((t) => t !== undefined)) {
-                specializedParameters.parameterDefaultArgs = specializedDefaultArgs;
+                specializedParams.parameterDefaultTypes = specializedDefaultArgs;
             }
             // If there was no unpacked variadic type variable, we're done.
             if (!variadicTypesToUnpack) {
-                return types_1.FunctionType.cloneForSpecialization(functionType, specializedParameters, specializedInferredReturnType);
+                return types_1.FunctionType.specialize(functionType, specializedParams, specializedInferredReturnType);
             }
             // Unpack the tuple and synthesize a new function in the process.
             const newFunctionType = types_1.TypeBase.isInstantiable(functionType)
@@ -3151,14 +2987,14 @@ class TypeVarTransformer {
                 : types_1.FunctionType.createSynthesizedInstance('', functionType.shared.flags);
             let insertKeywordOnlySeparator = false;
             let swallowPositionOnlySeparator = false;
-            specializedParameters.parameterTypes.forEach((paramType, index) => {
+            specializedParams.parameterTypes.forEach((paramType, index) => {
                 if (index === variadicParamIndex) {
                     let sawUnboundedEntry = false;
                     // Unpack the tuple into individual parameters.
                     variadicTypesToUnpack.forEach((unpackedType) => {
-                        types_1.FunctionType.addParameter(newFunctionType, types_1.FunctionParam.create(unpackedType.isUnbounded || (0, types_1.isVariadicTypeVar)(unpackedType.type)
-                            ? 1 /* ParameterCategory.ArgsList */
-                            : 0 /* ParameterCategory.Simple */, unpackedType.type, types_1.FunctionParamFlags.NameSynthesized | types_1.FunctionParamFlags.TypeDeclared, `__p${newFunctionType.shared.parameters.length}`));
+                        types_1.FunctionType.addParam(newFunctionType, types_1.FunctionParam.create(unpackedType.isUnbounded || (0, types_1.isTypeVarTuple)(unpackedType.type)
+                            ? 1 /* ParamCategory.ArgsList */
+                            : 0 /* ParamCategory.Simple */, unpackedType.type, types_1.FunctionParamFlags.NameSynthesized | types_1.FunctionParamFlags.TypeDeclared, `__p${newFunctionType.shared.parameters.length}`));
                         if (unpackedType.isUnbounded) {
                             sawUnboundedEntry = true;
                         }
@@ -3171,29 +3007,27 @@ class TypeVarTransformer {
                     }
                 }
                 else {
-                    const param = { ...functionType.shared.parameters[index] };
+                    const param = functionType.shared.parameters[index];
                     if ((0, types_1.isKeywordOnlySeparator)(param)) {
                         insertKeywordOnlySeparator = false;
                     }
-                    else if (param.category === 2 /* ParameterCategory.KwargsDict */) {
+                    else if (param.category === 2 /* ParamCategory.KwargsDict */) {
                         insertKeywordOnlySeparator = false;
                     }
                     // Insert a keyword-only separator parameter if we previously
-                    // unpacked a variadic TypeVar.
-                    if (param.category === 0 /* ParameterCategory.Simple */ && param.name && insertKeywordOnlySeparator) {
-                        types_1.FunctionType.addKeywordOnlyParameterSeparator(newFunctionType);
+                    // 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 /* ParameterCategory.Simple */ || param.name || !swallowPositionOnlySeparator) {
-                        types_1.FunctionType.addParameter(newFunctionType, param);
+                    if (param.category !== 0 /* ParamCategory.Simple */ || param.name || !swallowPositionOnlySeparator) {
+                        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)));
                     }
                 }
             });
-            newFunctionType.shared.declaredReturnType = specializedParameters.returnType;
+            newFunctionType.shared.declaredReturnType = specializedParams.returnType;
             return newFunctionType;
         });
     }
@@ -3201,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 getUnknownTypeForParamSpec();
-    }
-}
+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 {
@@ -3223,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) {
@@ -3252,7 +3068,7 @@ class UniqueFunctionSignatureTransformer extends TypeVarTransformer {
     }
     transformTypeVarsInFunctionType(sourceType, recursionCount) {
         // If this function is not generic, there's no need to check for uniqueness.
-        if (sourceType.shared.typeParameters.length === 0) {
+        if (sourceType.shared.typeParams.length === 0) {
             return super.transformTypeVarsInFunctionType(sourceType, recursionCount);
         }
         let updatedSourceType = sourceType;
@@ -3263,19 +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.typeParameters.forEach((typeParam) => {
+                sourceType.shared.typeParams.forEach((typeParam) => {
                     if (typeParam.priv.scopeType === 1 /* TypeVarScopeType.Function */) {
-                        let replacement = types_1.TypeVarType.cloneForNewName(typeParam, `${typeParam.shared.name}(${offsetIndex})`);
-                        if (replacement.shared.isParamSpec) {
-                            replacement = convertTypeToParamSpecValue(replacement);
-                        }
-                        typeVarContext.setTypeVarType(typeParam, replacement);
+                        const replacement = types_1.TypeVarType.cloneForNewName(typeParam, `${typeParam.shared.name}(${offsetIndex})`);
+                        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));
             }
         }
@@ -3283,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;
@@ -3296,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;
     }
@@ -3338,135 +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 signatureContext = this._typeVarContext.getSignatureContext((_a = this._activeTypeVarSignatureContextIndex) !== 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 = signatureContext.getTypeVarType(typeVar, !!this._options.useNarrowBoundOnly);
-            // If there was no narrow bound but there is a wide bound that
-            // contains literals or a TypeVar, we'll use the wide bound even if
-            // "useNarrowBoundOnly" is specified.
-            if (!replacement && this._options.useNarrowBoundOnly) {
-                const wideType = signatureContext.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.cloneForSpecialization(types_1.ClassType.cloneAsInstance(this._options.typeClassType), [replacement], 
-                        /* isTypeArgumentExplicit */ true);
-                    }
-                    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.typeParameters && !subtype.priv.typeArguments) {
-                                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.isTypeVar)(replacement) && typeVar.priv.isVariadicUnpacked && replacement.shared.isVariadic) {
-                    return types_1.TypeVarType.cloneForUnpacked(replacement, typeVar.priv.isVariadicInUnion);
-                }
-                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 getUnknownTypeForTypeVar(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 = signatureContext
-                .getTypeVars()
-                .find((entry) => entry.typeVar.shared.name === typeVar.shared.name);
-            if (replacementEntry) {
-                return signatureContext.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 signatureContext = this._typeVarContext.getSignatureContext((_a = this._activeTypeVarSignatureContextIndex) !== null && _a !== void 0 ? _a : 0);
-                const typeVarType = signatureContext.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;
+                        }
                     }
                 }
             }
@@ -3475,58 +3269,17 @@ 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.tupleTypeArguments) {
-                return defaultType.priv.tupleTypeArguments;
+            if (typeVar.shared.isDefaultExplicit && (0, types_1.isClassInstance)(defaultType) && defaultType.priv.tupleTypeArgs) {
+                return defaultType.priv.tupleTypeArgs;
             }
             return undefined;
         }
-        const signatureContext = this._typeVarContext.getSignatureContext((_a = this._activeTypeVarSignatureContextIndex) !== null && _a !== void 0 ? _a : 0);
-        return signatureContext.getTupleTypeVar(typeVar);
-    }
-    transformParamSpec(paramSpec, recursionCount) {
-        var _a, _b;
-        const signatureContext = this._typeVarContext.getSignatureContext((_a = this._activeTypeVarSignatureContextIndex) !== 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 = signatureContext
-                .getTypeVars()
-                .find((entry) => entry.typeVar.shared.name === paramSpec.shared.name);
-            if (replacementEntry) {
-                return signatureContext.getParamSpecType(replacementEntry.typeVar);
-            }
-            if (paramSpec.shared.isDefaultExplicit) {
-                return convertTypeToParamSpecValue(this.apply(paramSpec.shared.defaultType, recursionCount));
-            }
-            return getUnknownTypeForParamSpec();
-        }
-        if (!paramSpec.priv.scopeId || !this._typeVarContext.hasSolveForScope(paramSpec.priv.scopeId)) {
-            return undefined;
-        }
-        const transformedParamSpec = signatureContext.getParamSpecType(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 getUnknownTypeForParamSpec();
+        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;
     }
@@ -3535,22 +3288,22 @@ class ApplySolvedTypeVarsTransformer extends TypeVarTransformer {
         if (!((_a = type.props) === null || _a === void 0 ? void 0 : _a.condition)) {
             return type;
         }
-        const signatureContext = this._typeVarContext.getSignatureContext((_b = this._activeTypeVarSignatureContextIndex) !== 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 = signatureContext.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 = signatureContext.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();
@@ -3558,19 +3311,19 @@ class ApplySolvedTypeVarsTransformer extends TypeVarTransformer {
         }
         return type;
     }
-    doForEachSignatureContext(callback) {
-        const signatureContexts = this._typeVarContext.getSignatureContexts();
+    doForEachConstraintSet(callback) {
+        const solutionSets = this._solution.getSolutionSets();
         // Handle the common case where there are not multiple signature contexts.
-        if (signatureContexts.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 = signatureContexts.map((_, index) => {
-            this._activeTypeVarSignatureContextIndex = index;
+        const overloadTypes = solutionSets.map((_, index) => {
+            this._activeConstraintSetIndex = index;
             return callback();
         });
-        this._activeTypeVarSignatureContextIndex = undefined;
+        this._activeConstraintSetIndex = undefined;
         const filteredOverloads = [];
         doForEachSubtype((0, types_1.combineTypes)(overloadTypes), (subtype) => {
             (0, debug_1.assert)((0, types_1.isFunction)(subtype));
@@ -3582,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;
@@ -3599,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(_signatureContext) {
-        super();
-        this._signatureContext = _signatureContext;
+        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._signatureContext.getTypeVarType(typeVar)) !== null && _a !== void 0 ? _a : typeVar;
-        }
-        return undefined;
-    }
-    transformParamSpec(paramSpec) {
-        if (paramSpec.priv.isInScopePlaceholder) {
-            return this._signatureContext.getParamSpecType(paramSpec);
-        }
-        return undefined;
-    }
-}
-function applyInScopePlaceholdersToType(type, signatureContext) {
-    // Handle the common case where there are no in-scope placeholders.
-    // No more work is required in this case.
-    if (!signatureContext.getTypeVars().some((entry) => entry.typeVar.priv.isInScopePlaceholder)) {
-        return type;
-    }
-    const transformer = new InScopePlaceholderTransformer(signatureContext);
-    return transformer.apply(type, 0);
 }
 //# sourceMappingURL=typeUtils.js.map