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

package/dist/analyzer/typeUtils.js

@@ -8,9 +8,9 @@
  * 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.combineVariances = exports.requiresSpecialization = 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.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 = 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.requiresTypeArgs = exports.getGeneratorTypeArgs = exports.specializeTupleClass = exports.combineTupleTypeArgs = exports.combineSameSizedTuples = exports.explodeGenericClass = exports.isPartlyUnknown = exports.containsAnyOrUnknown = exports.containsAnyRecursive = exports.getMembersForModule = exports.getMembersForClass = exports.convertToInstantiable = exports.convertToInstance = exports.isEffectivelyInstantiable = exports.isMetaclassInstance = exports.isInstantiableMetaclass = exports.getGeneratorYieldType = exports.getDeclaredGeneratorReturnType = exports.synthesizeTypeVarForSelfCls = exports.derivesFromClassRecursive = exports.derivesFromStdlibClass = exports.specializeForBaseClass = exports.buildTypeVarContext = exports.buildTypeVarContextFromSpecializedClass = exports.setTypeArgsRecursive = exports.specializeClassType = exports.getTypeVarArgsRecursive = exports.addTypeVarsToListIfUnique = exports.getClassFieldsRecursive = exports.getClassIterator = exports.getClassMemberIterator = exports.lookUpClassMember = exports.lookUpObjectMember = exports.getContainerDepth = exports.getProtocolSymbolsRecursive = exports.getProtocolSymbols = exports.transformExpectedType = exports.replaceTypeVarsWithAny = exports.validateTypeVarDefault = exports.applyInScopePlaceholders = exports.applySourceContextTypeVarsToSignature = exports.applySourceContextTypeVars = exports.applySolvedTypeVars = exports.updateTypeWithExternalTypeVars = exports.updateTypeWithInternalTypeVars = exports.ensureFunctionSignaturesAreUnique = exports.populateTypeVarContextForSelfType = exports.partiallySpecializeType = exports.isTupleIndexUnambiguous = exports.isUnboundedTupleClass = void 0;
+exports.convertParamSpecValueToType = exports.setTypeVarType = exports.convertTypeToParamSpecValue = exports.convertNodeToArg = exports.getDeclaringModulesForType = exports.computeMroLinearization = exports.isVarianceOfTypeArgCompatible = exports.combineVariances = exports.requiresSpecialization = void 0;
 const collectionUtils_1 = require("../common/collectionUtils");
 const debug_1 = require("../common/debug");
 const symbol_1 = require("./symbol");
@@ -96,15 +96,13 @@ var AssignTypeFlags;
     // as incompatible. Also, treat all source TypeVars as their
     // concrete counterparts. This option is used for validating
     // whether overload signatures overlap.
-    AssignTypeFlags[AssignTypeFlags["OverloadOverlapCheck"] = 16] = "OverloadOverlapCheck";
+    AssignTypeFlags[AssignTypeFlags["OverloadOverlap"] = 16] = "OverloadOverlap";
     // When used in conjunction with OverloadOverlapCheck, look
     // for partial overlaps. For example, `int | list` overlaps
     // partially with `int | str`.
-    AssignTypeFlags[AssignTypeFlags["PartialOverloadOverlapCheck"] = 32] = "PartialOverloadOverlapCheck";
+    AssignTypeFlags[AssignTypeFlags["PartialOverloadOverlap"] = 32] = "PartialOverloadOverlap";
     // For function types, skip the return type check.
-    AssignTypeFlags[AssignTypeFlags["SkipFunctionReturnTypeCheck"] = 64] = "SkipFunctionReturnTypeCheck";
-    // Allow bool values to be assigned to TypeGuard[x] types.
-    AssignTypeFlags[AssignTypeFlags["AllowBoolTypeGuard"] = 128] = "AllowBoolTypeGuard";
+    AssignTypeFlags[AssignTypeFlags["SkipReturnTypeCheck"] = 64] = "SkipReturnTypeCheck";
     // In most cases, literals are stripped when assigning to a
     // type variable. This overrides the standard behavior.
     AssignTypeFlags[AssignTypeFlags["RetainLiteralsForTypeVar"] = 256] = "RetainLiteralsForTypeVar";
@@ -128,18 +126,14 @@ 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";
-    // PEP 544 says that if the dest type is a type[Proto] class,
-    // the source must be a "concrete" (non-protocol) class. This
-    // flag skips this check.
-    AssignTypeFlags[AssignTypeFlags["IgnoreProtocolAssignmentCheck"] = 16384] = "IgnoreProtocolAssignmentCheck";
+    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.
-    AssignTypeFlags[AssignTypeFlags["AllowIsinstanceSpecialForms"] = 32768] = "AllowIsinstanceSpecialForms";
+    AssignTypeFlags[AssignTypeFlags["AllowIsinstanceSpecialForms"] = 16384] = "AllowIsinstanceSpecialForms";
     // When comparing two methods, skip the type check for the "self" or "cls"
     // parameters. This is used for variance inference and validation.
-    AssignTypeFlags[AssignTypeFlags["IgnoreSelfClsParamCompatibility"] = 65536] = "IgnoreSelfClsParamCompatibility";
+    AssignTypeFlags[AssignTypeFlags["SkipSelfClsParamCheck"] = 32768] = "SkipSelfClsParamCheck";
 })(AssignTypeFlags || (exports.AssignTypeFlags = AssignTypeFlags = {}));
 // Tracks whether a function signature has been seen before within
 // an expression. For example, in the expression "foo(foo, foo)", the
@@ -220,7 +214,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) || !type1.shared.boundType) {
         return false;
     }
     // If the second type isn't a union, return false.
@@ -243,17 +237,18 @@ function isTypeVarSame(type1, type2) {
     return isCompatible;
 }
 exports.isTypeVarSame = isTypeVarSame;
-function makeInferenceContext(expectedType, isTypeIncomplete) {
+function makeInferenceContext(expectedType, isTypeIncomplete, returnTypeOverride) {
     if (!expectedType) {
         return undefined;
     }
-    return { expectedType, isTypeIncomplete };
+    return { expectedType, isTypeIncomplete, returnTypeOverride };
 }
 exports.makeInferenceContext = makeInferenceContext;
 // Calls a callback for each subtype and combines the results
 // into a final type. It performs no memory allocations if the
 // transformed type is the same as the original.
 function mapSubtypes(type, callback, options) {
+    var _a;
     if ((0, types_1.isUnion)(type)) {
         const subtypes = (options === null || options === void 0 ? void 0 : options.sortSubtypes) ? sortTypes(type.priv.subtypes) : type.priv.subtypes;
         for (let i = 0; i < subtypes.length; i++) {
@@ -275,9 +270,16 @@ function mapSubtypes(type, callback, options) {
                 const newType = (0, types_1.combineTypes)(typesToCombine, {
                     skipElideRedundantLiterals: options === null || options === void 0 ? void 0 : options.skipElideRedundantLiterals,
                 });
-                // Do our best to retain type aliases.
-                if (newType.category === 8 /* TypeCategory.Union */) {
-                    types_1.UnionType.addTypeAliasSource(newType, type);
+                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);
+                    }
+                }
+                else {
+                    // Do our best to retain type aliases.
+                    if (newType.category === 8 /* TypeCategory.Union */) {
+                        types_1.UnionType.addTypeAliasSource(newType, type);
+                    }
                 }
                 return newType;
             }
@@ -345,10 +347,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;
@@ -360,11 +362,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;
@@ -372,7 +374,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);
                 }
             }
         }
@@ -420,7 +422,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.getEffectiveParamType(a, i), types_1.FunctionType.getEffectiveParamType(bFunc, i));
                 if (typeComparison !== 0) {
                     return typeComparison;
                 }
@@ -480,12 +482,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.
@@ -498,8 +500,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;
             }
@@ -508,7 +510,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;
                 }
@@ -740,17 +742,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));
+            const typeVarContext = buildTypeVarContext(type.shared.recursiveAlias.typeParams, aliasInfo.typeArgs, getTypeVarScopeId(type));
             return applySolvedTypeVars(unspecializedType, typeVarContext);
         }
         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.name, aliasInfo.fullName, aliasInfo.moduleName, aliasInfo.fileUri, aliasInfo.typeVarScopeId, aliasInfo.isPep695Syntax, aliasInfo.typeParams, aliasInfo.typeArgs);
             }
             return newType;
         }
@@ -794,58 +796,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;
 }
@@ -854,14 +849,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;
-    return types_1.ClassType.cloneForSpecialization(type, typeParams, /* isTypeArgumentExplicit */ true);
+    const typeParams = type.shared.typeParams.map((typeParam) => {
+        return (options === null || options === void 0 ? void 0 : options.useInternalTypeVars) ? types_1.TypeVarType.cloneWithInternalScopeId(typeParam) : typeParam;
+    });
+    return types_1.ClassType.specialize(type, typeParams);
 }
 exports.selfSpecializeClass = selfSpecializeClass;
 // Determines whether the type derives from tuple. If so, it returns
@@ -1028,10 +1025,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) {
@@ -1042,32 +1039,30 @@ 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.tupleTypeArgs.findIndex((t) => t.isUnbounded || (0, types_1.isUnpackedTypeVarTuple)(t.type));
     if (index < 0) {
-        if (isUnboundedTupleClass(type) || type.priv.tupleTypeArguments.length + index < 0) {
-            return false;
-        }
-    }
-    let unambiguousIndexLimit = type.priv.tupleTypeArguments.findIndex((t) => t.isUnbounded || (0, types_1.isUnpackedVariadicTypeVar)(t.type));
-    if (unambiguousIndexLimit < 0) {
-        unambiguousIndexLimit = type.priv.tupleTypeArguments.length;
+        const lowerIndexLimit = unboundedIndex < 0 ? 0 : unboundedIndex;
+        index += type.priv.tupleTypeArgs.length;
+        return index >= lowerIndexLimit;
     }
-    return index < unambiguousIndexLimit;
+    const upperIndexLimit = unboundedIndex < 0 ? type.priv.tupleTypeArgs.length : unboundedIndex;
+    return index < upperIndexLimit;
 }
 exports.isTupleIndexUnambiguous = isTupleIndexUnambiguous;
 // Partially specializes a type within the context of a specified
 // (presumably specialized) class. Optionally specializes the `Self`
 // type variables, replacing them with selfClass.
-function partiallySpecializeType(type, contextClassType, selfClass, typeClassType) {
+function partiallySpecializeType(type, contextClassType, typeClassType, selfClass) {
     // If the context class is not specialized (or doesn't need specialization),
     // then there's no need to do any more work.
     if (types_1.ClassType.isUnspecialized(contextClassType) && !selfClass) {
@@ -1088,7 +1083,7 @@ function partiallySpecializeType(type, contextClassType, selfClass, typeClassTyp
                     return undefined;
                 }
                 return {
-                    methodType: partiallySpecializeType(methodInfo.methodType, contextClassType, selfClass, typeClassType),
+                    methodType: partiallySpecializeType(methodInfo.methodType, contextClassType, typeClassType, selfClass),
                     classType: methodInfo.classType,
                 };
             }
@@ -1115,7 +1110,7 @@ function populateTypeVarContextForSelfType(typeVarContext, contextClassType, sel
         return subtype;
     });
     if (!(0, types_1.isTypeSame)(synthesizedSelfTypeVar, selfWithoutLiteral)) {
-        typeVarContext.setTypeVarType(synthesizedSelfTypeVar, selfInstance, selfWithoutLiteral);
+        setTypeVarType(typeVarContext, synthesizedSelfTypeVar, selfInstance, selfWithoutLiteral);
     }
 }
 exports.populateTypeVarContextForSelfType = populateTypeVarContextForSelfType;
@@ -1126,6 +1121,16 @@ function ensureFunctionSignaturesAreUnique(type, signatureTracker, expressionOff
     return transformer.apply(type, 0);
 }
 exports.ensureFunctionSignaturesAreUnique = ensureFunctionSignaturesAreUnique;
+function updateTypeWithInternalTypeVars(type, scopeIds) {
+    const transformer = new InternalScopeUpdateTransform(scopeIds);
+    return transformer.apply(type, 0);
+}
+exports.updateTypeWithInternalTypeVars = updateTypeWithInternalTypeVars;
+function updateTypeWithExternalTypeVars(type, scopeIds) {
+    const transformer = new ExternalScopeUpdateTransform(scopeIds);
+    return transformer.apply(type, 0);
+}
+exports.updateTypeWithExternalTypeVars = updateTypeWithExternalTypeVars;
 // Specializes a (potentially generic) type by substituting
 // type variables from a type var map.
 function applySolvedTypeVars(type, typeVarContext, options = {}) {
@@ -1148,28 +1153,19 @@ function applySourceContextTypeVars(destContext, srcContext) {
     if (srcContext.isEmpty()) {
         return;
     }
-    destContext.doForEachSignatureContext((destSignature) => {
-        applySourceContextTypeVarsToSignature(destSignature, srcContext);
+    destContext.doForEachSolutionSet((solutionSet) => {
+        applySourceContextTypeVarsToSignature(solutionSet, srcContext);
     });
 }
 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(solutionSet, srcContext) {
+    solutionSet.getTypeVars().forEach((entry) => {
+        const newLowerBound = entry.lowerBound ? applySolvedTypeVars(entry.lowerBound, srcContext) : undefined;
+        const newLowerBoundNoLiterals = entry.lowerBoundNoLiterals
+            ? applySolvedTypeVars(entry.lowerBoundNoLiterals, srcContext)
             : 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, srcContext) : undefined;
+        solutionSet.setTypeVarType(entry.typeVar, newLowerBound, newLowerBoundNoLiterals, newUpperBound);
     });
 }
 exports.applySourceContextTypeVarsToSignature = applySourceContextTypeVarsToSignature;
@@ -1177,29 +1173,20 @@ exports.applySourceContextTypeVarsToSignature = applySourceContextTypeVarsToSign
 // 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) => {
+    typeVarContext.doForEachSolutionSet((solutionSet) => {
+        solutionSet.getTypeVars().forEach((entry) => {
             const typeVar = entry.typeVar;
             if (!typeVar.priv.isInScopePlaceholder) {
-                const newNarrowTypeBound = entry.narrowBound
-                    ? applyInScopePlaceholdersToType(entry.narrowBound, signature)
+                const newLowerBound = entry.lowerBound
+                    ? applyInScopePlaceholdersToType(entry.lowerBound, solutionSet)
                     : undefined;
-                const newNarrowTypeBoundNoLiterals = entry.narrowBoundNoLiterals
-                    ? applyInScopePlaceholdersToType(entry.narrowBoundNoLiterals, signature)
+                const newLowerBoundNoLiterals = entry.lowerBoundNoLiterals
+                    ? applyInScopePlaceholdersToType(entry.lowerBoundNoLiterals, solutionSet)
                     : undefined;
-                const newWideTypeBound = entry.wideBound
-                    ? applyInScopePlaceholdersToType(entry.wideBound, signature)
+                const newUpperBound = entry.upperBound
+                    ? applyInScopePlaceholdersToType(entry.upperBound, solutionSet)
                     : 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,
-                        };
-                    }));
-                }
+                solutionSet.setTypeVarType(entry.typeVar, newLowerBound, newLowerBoundNoLiterals, newUpperBound);
             }
         });
     });
@@ -1279,16 +1266,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);
@@ -1487,7 +1474,7 @@ function* getClassIterator(classType, flags = 0 /* ClassIteratorFlags.Default */
             }
             // If mroClass is an ancestor of classType, partially specialize
             // it in the context of classType.
-            const specializedMroClass = partiallySpecializeType(mroClass, classType);
+            const specializedMroClass = partiallySpecializeType(mroClass, classType, /* typeClassType */ undefined);
             // Should we ignore members on the 'object' base class?
             if (flags & 2 /* ClassIteratorFlags.SkipObjectBaseClass */) {
                 if ((0, types_1.isInstantiableClass)(specializedMroClass)) {
@@ -1517,7 +1504,7 @@ function getClassFieldsRecursive(classType) {
     const memberMap = new Map();
     // Evaluate the types of members from the end of the MRO to the beginning.
     types_1.ClassType.getReverseMro(classType).forEach((mroClass) => {
-        const specializedMroClass = partiallySpecializeType(mroClass, classType);
+        const specializedMroClass = partiallySpecializeType(mroClass, classType, /* typeClassType */ undefined);
         if ((0, types_1.isClass)(specializedMroClass)) {
             types_1.ClassType.getSymbolTable(specializedMroClass).forEach((symbol, name) => {
                 if (!symbol.isIgnoredForProtocolMatch() && symbol.hasTypedDeclarations()) {
@@ -1561,17 +1548,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;
     }
@@ -1588,12 +1575,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;
@@ -1601,38 +1586,38 @@ 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.getEffectiveParamType(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 typeParams = types_1.ClassType.getTypeParams(type);
     typeParams.forEach((typeParam) => {
-        typeVarContext.setTypeVarType(typeParam, applySolvedTypeVars(typeParam.shared.defaultType, typeVarContext));
+        setTypeVarType(typeVarContext, typeParam, applySolvedTypeVars(typeParam.shared.defaultType, typeVarContext));
     });
     return applySolvedTypeVars(type, typeVarContext);
 }
 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, typeVarContext, recursionCount = 0) {
     if (recursionCount > types_1.maxTypeRecursionCount) {
         return;
     }
@@ -1643,83 +1628,89 @@ function setTypeArgumentsRecursive(destType, srcType, typeVarContext, recursionC
     switch (destType.category) {
         case 8 /* TypeCategory.Union */:
             doForEachSubtype(destType, (subtype) => {
-                setTypeArgumentsRecursive(subtype, srcType, typeVarContext, recursionCount);
+                setTypeArgsRecursive(subtype, srcType, typeVarContext, 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, typeVarContext, 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, typeVarContext, recursionCount);
                 });
             }
             break;
         case 4 /* TypeCategory.Function */:
             if (destType.priv.specializedTypes) {
                 destType.priv.specializedTypes.parameterTypes.forEach((paramType) => {
-                    setTypeArgumentsRecursive(paramType, srcType, typeVarContext, recursionCount);
+                    setTypeArgsRecursive(paramType, srcType, typeVarContext, recursionCount);
                 });
                 if (destType.priv.specializedTypes.returnType) {
-                    setTypeArgumentsRecursive(destType.priv.specializedTypes.returnType, srcType, typeVarContext, recursionCount);
+                    setTypeArgsRecursive(destType.priv.specializedTypes.returnType, srcType, typeVarContext, recursionCount);
                 }
             }
             else {
                 destType.shared.parameters.forEach((param) => {
-                    setTypeArgumentsRecursive(param.type, srcType, typeVarContext, recursionCount);
+                    setTypeArgsRecursive(param.type, srcType, typeVarContext, recursionCount);
                 });
                 if (destType.shared.declaredReturnType) {
-                    setTypeArgumentsRecursive(destType.shared.declaredReturnType, srcType, typeVarContext, recursionCount);
+                    setTypeArgsRecursive(destType.shared.declaredReturnType, srcType, typeVarContext, recursionCount);
                 }
             }
             break;
         case 5 /* TypeCategory.OverloadedFunction */:
             destType.priv.overloads.forEach((subtype) => {
-                setTypeArgumentsRecursive(subtype, srcType, typeVarContext, recursionCount);
+                setTypeArgsRecursive(subtype, srcType, typeVarContext, recursionCount);
             });
             break;
         case 9 /* TypeCategory.TypeVar */:
-            if (!typeVarContext.getPrimarySignature().getTypeVar(destType)) {
-                typeVarContext.setTypeVarType(destType, srcType);
+            if (!typeVarContext.getMainSolutionSet().getTypeVar(destType)) {
+                setTypeVarType(typeVarContext, 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);
+    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)),
+        ];
     }
-    return typeVarContext;
+    else {
+        typeArgs = classType.priv.typeArgs;
+    }
+    return buildTypeVarContext(typeParams, typeArgs, getTypeVarScopeId(classType));
 }
 exports.buildTypeVarContextFromSpecializedClass = buildTypeVarContextFromSpecializedClass;
-function buildTypeVarContext(typeParameters, typeArgs, typeVarScopeId) {
+function buildTypeVarContext(typeParams, typeArgs, typeVarScopeId) {
     const typeVarContext = new typeVarContext_1.TypeVarContext(typeVarScopeId);
-    typeParameters.forEach((typeParam, index) => {
+    typeParams.forEach((typeParam, index) => {
         let typeArgType;
         if (typeArgs) {
-            if (typeParam.shared.isParamSpec) {
+            if ((0, types_1.isParamSpec)(typeParam)) {
                 if (index < typeArgs.length) {
                     typeArgType = typeArgs[index];
                     if ((0, types_1.isFunction)(typeArgType) && types_1.FunctionType.isParamSpecValue(typeArgType)) {
                         const parameters = [];
                         const typeArgFunctionType = typeArgType;
                         typeArgType.shared.parameters.forEach((param, paramIndex) => {
-                            parameters.push(types_1.FunctionParam.create(param.category, types_1.FunctionType.getEffectiveParameterType(typeArgFunctionType, paramIndex), param.flags & types_1.FunctionParamFlags.NameSynthesized, param.name, param.defaultType));
+                            parameters.push(types_1.FunctionParam.create(param.category, types_1.FunctionType.getEffectiveParamType(typeArgFunctionType, paramIndex), param.flags & types_1.FunctionParamFlags.NameSynthesized, param.name, param.defaultType));
                         });
-                        typeVarContext.setTypeVarType(typeParam, convertTypeToParamSpecValue(typeArgType));
+                        setTypeVarType(typeVarContext, typeParam, typeArgType);
                     }
                     else if ((0, types_1.isParamSpec)(typeArgType) || (0, types_1.isAnyOrUnknown)(typeArgType)) {
-                        typeVarContext.setTypeVarType(typeParam, convertTypeToParamSpecValue(typeArgType));
+                        setTypeVarType(typeVarContext, typeParam, typeArgType);
                     }
                 }
             }
@@ -1730,8 +1721,8 @@ function buildTypeVarContext(typeParameters, typeArgs, typeVarScopeId) {
                 else {
                     typeArgType = typeArgs[index];
                 }
-                typeVarContext.setTypeVarType(typeParam, typeArgType, 
-                /* narrowBoundNoLiterals */ undefined, typeArgType);
+                setTypeVarType(typeVarContext, typeParam, typeArgType, 
+                /* lowerBoundNoLiterals */ undefined, typeArgType);
             }
         }
     });
@@ -1740,7 +1731,7 @@ function buildTypeVarContext(typeParameters, typeArgs, typeVarScopeId) {
 exports.buildTypeVarContext = buildTypeVarContext;
 // 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) {
@@ -1785,8 +1776,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, types_1.ClassType.getTypeParameters(classType), 
-    /* 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;
@@ -1823,8 +1815,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();
             }
         }
@@ -1880,17 +1872,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]);
                             }
                         }
                     }
@@ -1929,7 +1921,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.name, aliasInfo.fullName, aliasInfo.moduleName, aliasInfo.fileUri, aliasInfo.typeVarScopeId, aliasInfo.isPep695Syntax, aliasInfo.typeParams, aliasInfo.typeArgs);
     }
     if (type !== result && includeSubclasses) {
         // Cache the converted value for next time.
@@ -2116,8 +2108,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;
         }
     }
@@ -2134,7 +2126,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)) {
@@ -2155,7 +2147,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.getEffectiveParamType(type, i);
                 if (isPartlyUnknown(paramType, recursionCount)) {
                     return true;
                 }
@@ -2175,13 +2167,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;
@@ -2204,10 +2194,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);
                         });
                     }
@@ -2216,7 +2206,7 @@ function combineSameSizedTuples(type, tupleType) {
                     }
                 }
                 else {
-                    tupleEntries = tupleClass.priv.tupleTypeArguments.map((entry) => [entry.type]);
+                    tupleEntries = tupleClass.priv.tupleTypeArgs.map((entry) => [entry.type]);
                 }
             }
             else {
@@ -2235,18 +2225,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;
@@ -2255,8 +2248,8 @@ function specializeTupleClass(classType, typeArgs, isTypeArgumentExplicit = true
 }
 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));
+    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;
 }
@@ -2266,20 +2259,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.
@@ -2294,7 +2287,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',
@@ -2314,7 +2307,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) {
@@ -2347,17 +2340,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.getEffectiveParamType(type, i), options, recursionCount)) {
                     return true;
                 }
             }
@@ -2393,8 +2386,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));
             }
         }
     }
@@ -2415,25 +2408,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 */) {
@@ -2455,13 +2448,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
@@ -2486,8 +2479,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;
                 }
@@ -2601,14 +2594,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;
@@ -2660,7 +2653,7 @@ function convertTypeToParamSpecValue(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.getEffectiveParamType(type, index), param.flags & types_1.FunctionParamFlags.NameSynthesized, param.name, param.defaultType));
         });
         if (type.priv.higherOrderTypeVarScopeIds) {
             newFunction.priv.higherOrderTypeVarScopeIds = [...type.priv.higherOrderTypeVarScopeIds];
@@ -2669,25 +2662,42 @@ function convertTypeToParamSpecValue(type) {
         newFunction.priv.constructorTypeVarScopeId = type.priv.constructorTypeVarScopeId;
         return newFunction;
     }
-    return getUnknownTypeForParamSpec();
+    return types_1.ParamSpecType.getUnknown();
 }
 exports.convertTypeToParamSpecValue = convertTypeToParamSpecValue;
+// This function calls the setTypeVarType method on the TypeVarContext after
+// converting the parameters for use with a ParamSpec.
+function setTypeVarType(typeVarContext, typeVar, lowerBound, lowerBoundNoLiterals, upperBound) {
+    if ((0, types_1.isParamSpec)(typeVar)) {
+        if (lowerBound) {
+            lowerBound = convertTypeToParamSpecValue(lowerBound);
+        }
+        if (lowerBoundNoLiterals) {
+            lowerBoundNoLiterals = convertTypeToParamSpecValue(lowerBoundNoLiterals);
+        }
+        if (upperBound) {
+            lowerBound = convertTypeToParamSpecValue(upperBound);
+        }
+    }
+    typeVarContext.setTypeVarType(typeVar, lowerBound, lowerBoundNoLiterals, upperBound);
+}
+exports.setTypeVarType = setTypeVarType;
 // Converts a FunctionType into a ParamSpec if it consists only of
 // (* args: P.args, ** kwargs: P.kwargs). Otherwise returns the original type.
 function convertParamSpecValueToType(type) {
     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.
@@ -2696,7 +2706,7 @@ function convertParamSpecValueToType(type) {
     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));
+        types_1.FunctionType.addParam(functionType, types_1.FunctionParam.create(entry.category, types_1.FunctionType.getEffectiveParamType(withoutParamSpec, index), (entry.flags & types_1.FunctionParamFlags.NameSynthesized) | types_1.FunctionParamFlags.TypeDeclared, entry.name, entry.defaultType));
     });
     if (paramSpec) {
         types_1.FunctionType.addParamSpecVariadics(functionType, paramSpec);
@@ -2743,11 +2753,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;
@@ -2755,7 +2765,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.name, aliasInfo.fullName, aliasInfo.moduleName, aliasInfo.fileUri, aliasInfo.typeVarScopeId, aliasInfo.isPep695Syntax, aliasInfo.typeParams, typeArgs);
                 }
                 return type;
             }
@@ -2764,9 +2774,9 @@ 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) {
+                if ((0, types_1.isParamSpec)(type)) {
                     let paramSpecWithoutAccess = type;
-                    if (type.priv.paramSpecAccess) {
+                    if ((0, types_1.isParamSpec)(type) && type.priv.paramSpecAccess) {
                         paramSpecWithoutAccess = types_1.TypeVarType.cloneForParamSpecAccess(type, /* access */ undefined);
                     }
                     const paramSpecValue = this.transformParamSpec(paramSpecWithoutAccess, recursionCount);
@@ -2798,7 +2808,7 @@ class TypeVarTransformer {
                     }
                     // 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) {
+                    if ((0, types_1.isTypeVarTuple)(type) && type.priv.isVariadicInUnion) {
                         replacementType = _expandVariadicUnpackedUnion(replacementType);
                     }
                 }
@@ -2810,7 +2820,7 @@ class TypeVarTransformer {
                 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 ((0, types_1.isTypeVarTuple)(subtype) && !(0, types_1.isTypeVarTuple)(transformedType)) {
                     const subtypesToCombine = [];
                     doForEachSubtype(transformedType, (transformedSubtype) => {
                         subtypesToCombine.push(_expandVariadicUnpackedUnion(transformedSubtype));
@@ -2821,7 +2831,7 @@ class TypeVarTransformer {
                     return this.transformUnionSubtype(subtype, transformedType, recursionCount);
                 }
                 return transformedType;
-            });
+            }, { retainTypeAlias: true });
             return !(0, types_1.isNever)(newUnionType) ? newUnionType : types_1.UnknownType.create();
         }
         if ((0, types_1.isClass)(type)) {
@@ -2876,7 +2886,7 @@ class TypeVarTransformer {
     transformUnionSubtype(preTransform, postTransform, recursionCount) {
         return postTransform;
     }
-    doForEachSignatureContext(callback) {
+    doForEachSolutionSet(callback) {
         // By default, simply return the result of the callback. Subclasses
         // can override this method as they see fit.
         return callback();
@@ -2884,11 +2894,11 @@ 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;
@@ -2896,7 +2906,7 @@ class TypeVarTransformer {
             return updatedType;
         });
         return requiresUpdate
-            ? types_1.TypeBase.cloneForTypeAlias(type, aliasInfo.name, aliasInfo.fullName, aliasInfo.moduleName, aliasInfo.fileUri, aliasInfo.typeVarScopeId, aliasInfo.isPep695Syntax, aliasInfo.typeParameters, newTypeArgs)
+            ? types_1.TypeBase.cloneForTypeAlias(type, aliasInfo.name, aliasInfo.fullName, aliasInfo.moduleName, aliasInfo.fileUri, aliasInfo.typeVarScopeId, aliasInfo.isPep695Syntax, aliasInfo.typeParams, newTypeArgs)
             : type;
     }
     transformConditionalType(type, recursionCount) {
@@ -2904,7 +2914,7 @@ class TypeVarTransformer {
         return type;
     }
     transformTypeVarsInClassType(classType, recursionCount) {
-        const typeParams = types_1.ClassType.getTypeParameters(classType);
+        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,18 +2939,18 @@ class TypeVarTransformer {
         // 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
@@ -2948,7 +2958,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,
@@ -2973,21 +2983,13 @@ 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) {
+            if (classType.priv.typeArgs) {
+                newTypeArgs = classType.priv.typeArgs.map((oldTypeArgType) => {
+                    if ((0, types_1.isParamSpec)(oldTypeArgType)) {
                         return transformParamSpec(oldTypeArgType);
                     }
                     let newTypeArgType = this.apply(oldTypeArgType, recursionCount);
@@ -2996,7 +2998,7 @@ class TypeVarTransformer {
                         // 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) &&
+                            (0, types_1.isTypeVarTuple)(oldTypeArgType) &&
                             oldTypeArgType.priv.isVariadicInUnion) {
                             newTypeArgType = _expandVariadicUnpackedUnion(newTypeArgType);
                         }
@@ -3008,7 +3010,7 @@ class TypeVarTransformer {
                 newTypeArgs = [];
                 typeParams.forEach((typeParam) => {
                     let replacementType = typeParam;
-                    if (typeParam.shared.isParamSpec) {
+                    if ((0, types_1.isParamSpec)(typeParam)) {
                         replacementType = transformParamSpec(typeParam);
                         if (replacementType !== typeParam) {
                             specializationNeeded = true;
@@ -3021,7 +3023,7 @@ class TypeVarTransformer {
                             if (replacementType !== typeParam) {
                                 specializationNeeded = true;
                             }
-                            else if (transformedType !== undefined && !classType.priv.typeArguments) {
+                            else if (transformedType !== undefined && !classType.priv.typeArgs) {
                                 specializationNeeded = true;
                             }
                         }
@@ -3035,19 +3037,19 @@ class TypeVarTransformer {
         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.doForEachSolutionSet(() => {
             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,
                 returnType: specializedReturnType,
@@ -3070,11 +3072,11 @@ class TypeVarTransformer {
             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.getEffectiveParamType(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.getEffectiveParamDefaultArgType(functionType, i);
                 if (defaultArgType) {
                     const specializedArgType = this.apply(defaultArgType, recursionCount);
                     if (specializedArgType !== defaultArgType) {
@@ -3084,13 +3086,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) {
@@ -3124,11 +3126,11 @@ class TypeVarTransformer {
                 return functionType;
             }
             if (specializedDefaultArgs.some((t) => t !== undefined)) {
-                specializedParameters.parameterDefaultArgs = specializedDefaultArgs;
+                specializedParams.parameterDefaultArgs = 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)
@@ -3136,14 +3138,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;
                         }
@@ -3160,25 +3162,25 @@ class TypeVarTransformer {
                     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);
+                    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, param);
                     }
                 }
             });
-            newFunctionType.shared.declaredReturnType = specializedParameters.returnType;
+            newFunctionType.shared.declaredReturnType = specializedParams.returnType;
             return newFunctionType;
         });
     }
@@ -3195,7 +3197,7 @@ class TypeVarAnyReplacer extends TypeVarTransformer {
         return types_1.AnyType.create();
     }
     transformParamSpec(paramSpec) {
-        return getUnknownTypeForParamSpec();
+        return types_1.ParamSpecType.getUnknown();
     }
 }
 // For a TypeVar with a default type, validates whether the default type is using
@@ -3236,11 +3238,8 @@ class UniqueFunctionSignatureTransformer extends TypeVarTransformer {
         return classType;
     }
     transformTypeVarsInFunctionType(sourceType, recursionCount) {
-        if (sourceType.priv.trackedSignatures) {
-            this._signatureTracker.addTrackedSignatures(sourceType.priv.trackedSignatures);
-        }
         // 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;
@@ -3254,13 +3253,10 @@ class UniqueFunctionSignatureTransformer extends TypeVarTransformer {
                 const typeVarContext = new typeVarContext_1.TypeVarContext(getTypeVarScopeIds(sourceType));
                 // 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})`);
+                        setTypeVarType(typeVarContext, typeParam, replacement);
                     }
                 });
                 updatedSourceType = applySolvedTypeVars(sourceType, typeVarContext);
@@ -3271,6 +3267,58 @@ 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 {
+    constructor(_scopeIds) {
+        super();
+        this._scopeIds = _scopeIds;
+    }
+    transformTypeVar(typeVar) {
+        if (this._isTypeVarInScope(typeVar)) {
+            return this._replaceTypeVar(typeVar);
+        }
+        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);
+    }
+    _replaceTypeVar(typeVar) {
+        return types_1.TypeVarType.cloneWithInternalScopeId(typeVar);
+    }
+}
+// Replaces the internal TypeVars within a type with their corresponding
+// "external" types.
+class ExternalScopeUpdateTransform 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);
+        }
+        return undefined;
+    }
+    _isTypeVarInScope(typeVar) {
+        if (!typeVar.priv.scopeId) {
+            return false;
+        }
+        return this._scopeIds.includes(typeVar.priv.scopeId);
+    }
+}
 // Specializes a (potentially generic) type by substituting
 // type variables from a type var map.
 class ApplySolvedTypeVarsTransformer extends TypeVarTransformer {
@@ -3282,16 +3330,16 @@ class ApplySolvedTypeVarsTransformer extends TypeVarTransformer {
     }
     transformTypeVar(typeVar, recursionCount) {
         var _a, _b;
-        const signatureContext = this._typeVarContext.getSignatureContext((_a = this._activeTypeVarSignatureContextIndex) !== null && _a !== void 0 ? _a : 0);
+        const solutionSet = this._typeVarContext.getSolutionSet((_a = this._activeSolutionSetIndex) !== null && _a !== void 0 ? _a : 0);
         // If the type variable is unrelated to the scopes we're solving,
         // don't transform that type variable.
         if (typeVar.priv.scopeId && this._typeVarContext.hasSolveForScope(typeVar.priv.scopeId)) {
-            let replacement = 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);
+            let replacement = solutionSet.getTypeVarType(typeVar, !!this._options.useLowerBoundOnly);
+            // If there was no lower bound but there is an upper bound that
+            // contains literals or a TypeVar, we'll use the upper bound even if
+            // "useLowerBoundOnly" is specified.
+            if (!replacement && this._options.useLowerBoundOnly) {
+                const wideType = solutionSet.getTypeVarType(typeVar);
                 if (wideType) {
                     if ((0, types_1.isTypeVar)(wideType) || containsLiteralType(wideType, /* includeTypeArgs */ true)) {
                         replacement = wideType;
@@ -3303,8 +3351,9 @@ class ApplySolvedTypeVarsTransformer extends TypeVarTransformer {
                     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);
+                        replacement = types_1.ClassType.specialize(types_1.ClassType.cloneAsInstance(this._options.typeClassType), [
+                            replacement,
+                        ]);
                     }
                     else {
                         replacement = convertToInstantiable(replacement, /* includeSubclasses */ false);
@@ -3322,18 +3371,28 @@ class ApplySolvedTypeVarsTransformer extends TypeVarTransformer {
                             if (!subtype.priv.includeSubclasses) {
                                 subtype = types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneAsInstantiable(subtype));
                             }
-                            if (this._options.unknownIfNotFound) {
-                                return this._options.useUnknownOverDefault
-                                    ? specializeWithUnknownTypeArgs(subtype, this._options.tupleClassType)
-                                    : specializeWithDefaultTypeArgs(subtype);
+                            if (subtype.shared.typeParams && !subtype.priv.typeArgs) {
+                                if (this._options.unknownIfNotFound) {
+                                    return this._options.useUnknownOverDefault
+                                        ? specializeWithUnknownTypeArgs(subtype, this._options.tupleClassType)
+                                        : specializeWithDefaultTypeArgs(subtype);
+                                }
                             }
                         }
                         return subtype;
                     });
                 }
-                if ((0, types_1.isTypeVar)(replacement) && typeVar.priv.isVariadicUnpacked && replacement.shared.isVariadic) {
+                if ((0, types_1.isTypeVarTuple)(replacement) && (0, types_1.isTypeVarTuple)(typeVar) && typeVar.priv.isVariadicUnpacked) {
                     return types_1.TypeVarType.cloneForUnpacked(replacement, typeVar.priv.isVariadicInUnion);
                 }
+                // If this isn't a variadic typeVar, combine all of the tuple
+                // type args into a common type.
+                if (!(0, types_1.isTypeVarTuple)(typeVar) &&
+                    (0, types_1.isClassInstance)(replacement) &&
+                    replacement.priv.tupleTypeArgs &&
+                    replacement.priv.isUnpacked) {
+                    replacement = combineTupleTypeArgs(replacement.priv.tupleTypeArgs);
+                }
                 if (!(0, types_1.isTypeVar)(replacement) ||
                     !replacement.priv.isInScopePlaceholder ||
                     !this._options.unknownIfNotFound) {
@@ -3357,18 +3416,18 @@ class ApplySolvedTypeVarsTransformer extends TypeVarTransformer {
             if (useDefaultOrUnknown) {
                 // Use the default value if there is one.
                 if (typeVar.shared.isDefaultExplicit && !this._options.useUnknownOverDefault) {
-                    return this._solveDefaultType(typeVar.shared.defaultType, recursionCount);
+                    return this._solveDefaultType(typeVar, recursionCount);
                 }
-                return getUnknownTypeForTypeVar(typeVar, this._options.tupleClassType);
+                return getUnknownForTypeVar(typeVar, this._options.tupleClassType);
             }
         }
         // If we're solving a default type, handle type variables with no scope ID.
         if (this._isSolvingDefaultType && !typeVar.priv.scopeId) {
-            const replacementEntry = signatureContext
+            const replacementEntry = solutionSet
                 .getTypeVars()
                 .find((entry) => entry.typeVar.shared.name === typeVar.shared.name);
             if (replacementEntry) {
-                return signatureContext.getTypeVarType(replacementEntry.typeVar);
+                return solutionSet.getTypeVarType(replacementEntry.typeVar);
             }
             if (typeVar.shared.isDefaultExplicit) {
                 return this.apply(typeVar.shared.defaultType, recursionCount);
@@ -3388,8 +3447,8 @@ class ApplySolvedTypeVarsTransformer extends TypeVarTransformer {
             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);
+                const solutionSet = this._typeVarContext.getSolutionSet((_a = this._activeSolutionSetIndex) !== null && _a !== void 0 ? _a : 0);
+                const typeVarType = solutionSet.getTypeVarType(preTransform);
                 // Did the TypeVar remain unsolved?
                 if (!typeVarType || ((0, types_1.isTypeVar)(typeVarType) && typeVarType.priv.isInScopePlaceholder)) {
                     // If the TypeVar was not transformed, then it was unsolved,
@@ -3411,36 +3470,38 @@ class ApplySolvedTypeVarsTransformer extends TypeVarTransformer {
         var _a;
         if (!typeVar.priv.scopeId || !this._typeVarContext.hasSolveForScope(typeVar.priv.scopeId)) {
             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);
+        const solutionSet = this._typeVarContext.getSolutionSet((_a = this._activeSolutionSetIndex) !== null && _a !== void 0 ? _a : 0);
+        const value = solutionSet.getTypeVarType(typeVar);
+        if (value && (0, types_1.isClassInstance)(value) && value.priv.tupleTypeArgs && (0, types_1.isUnpackedClass)(value)) {
+            return value.priv.tupleTypeArgs;
+        }
+        return undefined;
     }
     transformParamSpec(paramSpec, recursionCount) {
         var _a, _b;
-        const signatureContext = this._typeVarContext.getSignatureContext((_a = this._activeTypeVarSignatureContextIndex) !== null && _a !== void 0 ? _a : 0);
+        const solutionSet = this._typeVarContext.getSolutionSet((_a = this._activeSolutionSetIndex) !== null && _a !== void 0 ? _a : 0);
         // If we're solving a default type, handle param specs with no scope ID.
         if (this._isSolvingDefaultType && !paramSpec.priv.scopeId) {
-            const replacementEntry = signatureContext
+            const replacementEntry = solutionSet
                 .getTypeVars()
                 .find((entry) => entry.typeVar.shared.name === paramSpec.shared.name);
-            if (replacementEntry) {
-                return signatureContext.getParamSpecType(replacementEntry.typeVar);
+            if (replacementEntry && (0, types_1.isParamSpec)(replacementEntry.typeVar)) {
+                return solutionSet.getTypeVarType(replacementEntry.typeVar);
             }
             if (paramSpec.shared.isDefaultExplicit) {
                 return convertTypeToParamSpecValue(this.apply(paramSpec.shared.defaultType, recursionCount));
             }
-            return getUnknownTypeForParamSpec();
+            return types_1.ParamSpecType.getUnknown();
         }
         if (!paramSpec.priv.scopeId || !this._typeVarContext.hasSolveForScope(paramSpec.priv.scopeId)) {
             return undefined;
         }
-        const transformedParamSpec = signatureContext.getParamSpecType(paramSpec);
+        const transformedParamSpec = solutionSet.getTypeVarType(paramSpec);
         if (transformedParamSpec) {
             return transformedParamSpec;
         }
@@ -3457,29 +3518,30 @@ class ApplySolvedTypeVarsTransformer extends TypeVarTransformer {
         if (useDefaultOrUnknown) {
             // Use the default value if there is one.
             if (paramSpec.shared.isDefaultExplicit && !this._options.useUnknownOverDefault) {
-                return convertTypeToParamSpecValue(this._solveDefaultType(paramSpec.shared.defaultType, recursionCount));
+                return convertTypeToParamSpecValue(this._solveDefaultType(paramSpec, recursionCount));
             }
             // Convert to the ParamSpec equivalent of "Unknown".
-            return getUnknownTypeForParamSpec();
+            return types_1.ParamSpecType.getUnknown();
         }
         return undefined;
     }
     transformConditionalType(type, recursionCount) {
-        var _a, _b;
+        var _a, _b, _c, _d;
         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._typeVarContext.getSolutionSet((_b = this._activeSolutionSetIndex) !== 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) {
                 continue;
             }
-            const typeVarEntry = signatureContext.getTypeVar(condition.typeVar);
+            const conditionTypeVar = (_d = (_c = condition.typeVar.priv) === null || _c === void 0 ? void 0 : _c.externalTypeVar) !== null && _d !== void 0 ? _d : condition.typeVar;
+            const typeVarEntry = solutionSet.getTypeVar(conditionTypeVar);
             if (!typeVarEntry || condition.constraintIndex >= typeVarEntry.typeVar.shared.constraints.length) {
                 continue;
             }
-            const value = signatureContext.getTypeVarType(typeVarEntry.typeVar);
+            const value = solutionSet.getTypeVarType(typeVarEntry.typeVar);
             if (!value) {
                 continue;
             }
@@ -3491,19 +3553,19 @@ class ApplySolvedTypeVarsTransformer extends TypeVarTransformer {
         }
         return type;
     }
-    doForEachSignatureContext(callback) {
-        const signatureContexts = this._typeVarContext.getSignatureContexts();
+    doForEachSolutionSet(callback) {
+        const solutionSet = this._typeVarContext.getSolutionSets();
         // Handle the common case where there are not multiple signature contexts.
-        if (signatureContexts.length <= 1) {
+        if (solutionSet.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 = solutionSet.map((_, index) => {
+            this._activeSolutionSetIndex = index;
             return callback();
         });
-        this._activeTypeVarSignatureContextIndex = undefined;
+        this._activeSolutionSetIndex = undefined;
         const filteredOverloads = [];
         doForEachSubtype((0, types_1.combineTypes)(overloadTypes), (subtype) => {
             (0, debug_1.assert)((0, types_1.isFunction)(subtype));
@@ -3515,7 +3577,8 @@ class ApplySolvedTypeVarsTransformer extends TypeVarTransformer {
         }
         return types_1.OverloadedFunctionType.create(filteredOverloads);
     }
-    _solveDefaultType(defaultType, recursionCount) {
+    _solveDefaultType(typeVar, recursionCount) {
+        const defaultType = typeVar.shared.defaultType;
         const wasSolvingDefaultType = this._isSolvingDefaultType;
         this._isSolvingDefaultType = true;
         const result = this.apply(defaultType, recursionCount);
@@ -3533,7 +3596,7 @@ class ExpectedTypeTransformer extends TypeVarTransformer {
         if (!this._isTypeVarLive(typeVar)) {
             return types_1.TypeVarType.cloneAsInScopePlaceholder(typeVar, this._usageOffset);
         }
-        return typeVar;
+        return undefined;
     }
     transformParamSpec(paramSpec) {
         if (!this._isTypeVarLive(paramSpec)) {
@@ -3542,35 +3605,35 @@ class ExpectedTypeTransformer extends TypeVarTransformer {
         return undefined;
     }
     _isTypeVarLive(typeVar) {
-        return this._liveTypeVarScopes.some((scopeId) => typeVar.priv.scopeId === scopeId);
+        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) {
+    constructor(_solutionSet) {
         super();
-        this._signatureContext = _signatureContext;
+        this._solutionSet = _solutionSet;
     }
     transformTypeVar(typeVar) {
         var _a;
         if (typeVar.priv.isInScopePlaceholder) {
-            return (_a = this._signatureContext.getTypeVarType(typeVar)) !== null && _a !== void 0 ? _a : typeVar;
+            return (_a = this._solutionSet.getTypeVarType(typeVar)) !== null && _a !== void 0 ? _a : typeVar;
         }
-        return typeVar;
+        return undefined;
     }
     transformParamSpec(paramSpec) {
         if (paramSpec.priv.isInScopePlaceholder) {
-            return this._signatureContext.getParamSpecType(paramSpec);
+            return this._solutionSet.getTypeVarType(paramSpec);
         }
         return undefined;
     }
 }
-function applyInScopePlaceholdersToType(type, signatureContext) {
+function applyInScopePlaceholdersToType(type, solutionSet) {
     // 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)) {
+    if (!solutionSet.getTypeVars().some((entry) => entry.typeVar.priv.isInScopePlaceholder)) {
         return type;
     }
-    const transformer = new InScopePlaceholderTransformer(signatureContext);
+    const transformer = new InScopePlaceholderTransformer(solutionSet);
     return transformer.apply(type, 0);
 }
 //# sourceMappingURL=typeUtils.js.map