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

package/dist/analyzer/types.js

@@ -8,9 +8,10 @@
  * Representation of types used during type analysis within Python.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.findSubtype = exports.removeFromUnion = exports.removeUnbound = exports.removeUnknownFromUnion = exports.isTypeSame = exports.getTypeAliasInfo = exports.isOverloadedFunction = exports.isFunction = exports.isParamSpec = exports.isUnpacked = exports.isUnpackedClass = exports.isUnpackedVariadicTypeVar = exports.isVariadicTypeVar = exports.isTypeVar = exports.isModule = exports.isClassInstance = exports.isInstantiableClass = exports.isClass = exports.isPossiblyUnbound = exports.isUnion = exports.isUnbound = exports.isAnyOrUnknown = exports.isUnknown = exports.isAny = exports.isNever = exports.TypeVarType = exports.TypeVarScopeType = exports.Variance = exports.UnionType = exports.TypeCondition = exports.AnyType = exports.NeverType = exports.OverloadedFunctionType = exports.FunctionType = exports.FunctionTypeFlags = exports.isKeywordOnlySeparator = exports.isPositionOnlySeparator = exports.FunctionParam = exports.FunctionParamFlags = exports.ClassType = exports.ClassTypeFlags = exports.ModuleType = exports.UnknownType = exports.UnboundType = exports.TypeBase = exports.maxTypeRecursionCount = exports.EnumLiteral = exports.InScopePlaceholderScopeId = exports.TypeFlags = exports.TypeCategory = void 0;
-exports.isSameWithoutLiteralValue = exports.combineTypes = void 0;
+exports.removeUnbound = exports.removeUnknownFromUnion = exports.isTypeSame = exports.getTypeAliasInfo = exports.isOverloadedFunction = exports.isFunction = exports.isUnpacked = exports.isUnpackedClass = exports.isUnpackedTypeVarTuple = exports.isTypeVarTuple = exports.isParamSpec = exports.isTypeVar = exports.isModule = exports.isClassInstance = exports.isInstantiableClass = exports.isClass = exports.isPossiblyUnbound = exports.isUnion = exports.isUnbound = exports.isAnyOrUnknown = exports.isUnknown = exports.isAny = exports.isNever = exports.TypeVarType = exports.ParamSpecType = exports.TypeVarScopeType = exports.TypeVarKind = exports.Variance = exports.UnionType = exports.TypeCondition = exports.AnyType = exports.NeverType = exports.OverloadedFunctionType = exports.FunctionType = exports.FunctionTypeFlags = exports.isKeywordOnlySeparator = exports.isPositionOnlySeparator = exports.FunctionParam = exports.FunctionParamFlags = exports.ClassType = exports.ClassTypeFlags = exports.ModuleType = exports.UnknownType = exports.UnboundType = exports.TypeBase = exports.maxTypeRecursionCount = exports.EnumLiteral = exports.UnificationScopeId = exports.TypeFlags = exports.TypeCategory = void 0;
+exports.isSameWithoutLiteralValue = exports.combineTypes = exports.findSubtype = exports.removeFromUnion = void 0;
 const debug_1 = require("../common/debug");
+const typeUtils_1 = require("./typeUtils");
 var TypeCategory;
 (function (TypeCategory) {
     // Name is not bound to a value of any type.
@@ -54,7 +55,7 @@ var TypeFlags;
     // when comparing two types for equivalence.
     TypeFlags[TypeFlags["TypeCompatibilityMask"] = 3] = "TypeCompatibilityMask";
 })(TypeFlags || (exports.TypeFlags = TypeFlags = {}));
-exports.InScopePlaceholderScopeId = '-';
+exports.UnificationScopeId = '-';
 class EnumLiteral {
     constructor(classFullName, className, itemName, itemType) {
         this.classFullName = classFullName;
@@ -186,19 +187,9 @@ var TypeBase;
         return newInstance;
     }
     TypeBase.cloneTypeAsInstantiable = cloneTypeAsInstantiable;
-    function cloneForTypeAlias(type, name, fullName, moduleName, fileUri, typeVarScopeId, isPep695Syntax, typeParams, typeArgs) {
+    function cloneForTypeAlias(type, aliasInfo) {
         const typeClone = cloneType(type);
-        TypeBase.setTypeAliasInfo(typeClone, {
-            name,
-            fullName,
-            moduleName,
-            fileUri,
-            typeVarScopeId,
-            isPep695Syntax,
-            typeParameters: typeParams,
-            usageVariance: undefined,
-            typeArguments: typeArgs,
-        });
+        TypeBase.setTypeAliasInfo(typeClone, aliasInfo);
         return typeClone;
     }
     TypeBase.cloneForTypeAlias = cloneForTypeAlias;
@@ -395,8 +386,7 @@ var ClassTypeFlags;
     // class is generic, and therefore supports standard subscripting
     // semantics.
     ClassTypeFlags[ClassTypeFlags["HasCustomClassGetItem"] = 16384] = "HasCustomClassGetItem";
-    // The tuple class uses a variadic type parameter and requires
-    // special-case handling of its type arguments.
+    // The tuple class requires special-case handling for its type arguments.
     ClassTypeFlags[ClassTypeFlags["TupleClass"] = 32768] = "TupleClass";
     // The class has a metaclass of EnumMeta or derives from
     // a class that has this metaclass.
@@ -442,7 +432,7 @@ var ClassType;
                 effectiveMetaclass,
                 mro: [],
                 fields: new Map(),
-                typeParameters: [],
+                typeParams: [],
                 docString,
             },
             priv: {},
@@ -480,20 +470,25 @@ var ClassType;
         return newInstance;
     }
     ClassType.cloneAsInstantiable = cloneAsInstantiable;
-    function cloneForSpecialization(classType, typeArguments, isTypeArgumentExplicit, includeSubclasses = false, tupleTypeArguments, isEmptyContainer) {
+    function specialize(classType, typeArgs, isTypeArgExplicit, includeSubclasses = false, tupleTypeArgs, isEmptyContainer) {
         const newClassType = TypeBase.cloneType(classType);
-        newClassType.priv.typeArguments = (typeArguments === null || typeArguments === void 0 ? void 0 : typeArguments.length) === 0 ? undefined : typeArguments;
-        newClassType.priv.isTypeArgumentExplicit = isTypeArgumentExplicit;
+        newClassType.priv.typeArgs = (typeArgs === null || typeArgs === void 0 ? void 0 : typeArgs.length) === 0 ? undefined : typeArgs;
+        // If the user passed undefined for this argument, infer it
+        // based on whether typeArgs was provided.
+        if (isTypeArgExplicit === undefined) {
+            isTypeArgExplicit = !!typeArgs;
+        }
+        newClassType.priv.isTypeArgExplicit = isTypeArgExplicit;
         if (includeSubclasses) {
             newClassType.priv.includeSubclasses = true;
         }
-        newClassType.priv.tupleTypeArguments = tupleTypeArguments ? [...tupleTypeArguments] : undefined;
+        newClassType.priv.tupleTypeArgs = tupleTypeArgs ? [...tupleTypeArgs] : undefined;
         if (isEmptyContainer !== undefined) {
             newClassType.priv.isEmptyContainer = isEmptyContainer;
         }
         return newClassType;
     }
-    ClassType.cloneForSpecialization = cloneForSpecialization;
+    ClassType.specialize = specialize;
     function cloneIncludeSubclasses(classType, includeSubclasses = true) {
         if (!!classType.priv.includeSubclasses === includeSubclasses) {
             return classType;
@@ -550,13 +545,6 @@ var ClassType;
         return newClassType;
     }
     ClassType.cloneRemoveTypePromotions = cloneRemoveTypePromotions;
-    function cloneForTypeGuard(classType, typeGuardType, isStrictTypeGuard) {
-        const newClassType = TypeBase.cloneType(classType);
-        newClassType.priv.typeGuardType = typeGuardType;
-        newClassType.priv.isStrictTypeGuard = isStrictTypeGuard;
-        return newClassType;
-    }
-    ClassType.cloneForTypeGuard = cloneForTypeGuard;
     function cloneForSymbolTableUpdate(classType) {
         const newClassType = TypeBase.cloneType(classType);
         newClassType.shared = { ...newClassType.shared };
@@ -651,7 +639,7 @@ var ClassType;
     ClassType.isTypedDictNarrower = isTypedDictNarrower;
     // Is the class generic but not specialized?
     function isUnspecialized(classType) {
-        return classType.shared.typeParameters.length > 0 && classType.priv.typeArguments === undefined;
+        return classType.shared.typeParams.length > 0 && classType.priv.typeArgs === undefined;
     }
     ClassType.isUnspecialized = isUnspecialized;
     function isSpecialBuiltIn(classType, className) {
@@ -813,10 +801,10 @@ var ClassType;
         return !!(classType.shared.flags & 524288 /* ClassTypeFlags.ReadOnlyInstanceVariables */);
     }
     ClassType.isReadOnlyInstanceVariables = isReadOnlyInstanceVariables;
-    function getTypeParameters(classType) {
-        return classType.shared.typeParameters;
+    function getTypeParams(classType) {
+        return classType.shared.typeParams;
     }
-    ClassType.getTypeParameters = getTypeParameters;
+    ClassType.getTypeParams = getTypeParams;
     function derivesFromAnyOrUnknown(classType) {
         return classType.shared.mro.some((baseClass) => isAnyOrUnknown(baseClass));
     }
@@ -860,7 +848,7 @@ var ClassType;
             class1Details.flags !== class2Details.flags ||
             class1Details.typeSourceId !== class2Details.typeSourceId ||
             class1Details.baseClasses.length !== class2Details.baseClasses.length ||
-            class1Details.typeParameters.length !== class2Details.typeParameters.length) {
+            class1Details.typeParams.length !== class2Details.typeParams.length) {
             return false;
         }
         if (recursionCount > exports.maxTypeRecursionCount) {
@@ -888,8 +876,8 @@ var ClassType;
                 return false;
             }
         }
-        for (let i = 0; i < class1Details.typeParameters.length; i++) {
-            if (!isTypeSame(class1Details.typeParameters[i], class2Details.typeParameters[i], { ignorePseudoGeneric: true }, recursionCount)) {
+        for (let i = 0; i < class1Details.typeParams.length; i++) {
+            if (!isTypeSame(class1Details.typeParams[i], class2Details.typeParams[i], { ignorePseudoGeneric: true }, recursionCount)) {
                 return false;
             }
         }
@@ -971,7 +959,7 @@ var FunctionParamFlags;
 var FunctionParam;
 (function (FunctionParam) {
     function create(category, type, flags = FunctionParamFlags.None, name, defaultType) {
-        return { category, type, flags, name, defaultType };
+        return { category, flags, name, _type: type, _defaultType: defaultType };
     }
     FunctionParam.create = create;
     function isNameSynthesized(param) {
@@ -989,12 +977,12 @@ var FunctionParam;
 })(FunctionParam || (exports.FunctionParam = FunctionParam = {}));
 function isPositionOnlySeparator(param) {
     // A simple parameter with no name is treated as a "/" separator.
-    return param.category === 0 /* ParameterCategory.Simple */ && !param.name;
+    return param.category === 0 /* ParamCategory.Simple */ && !param.name;
 }
 exports.isPositionOnlySeparator = isPositionOnlySeparator;
 function isKeywordOnlySeparator(param) {
     // An *args parameter with no name is treated as a "*" separator.
-    return param.category === 1 /* ParameterCategory.ArgsList */ && !param.name;
+    return param.category === 1 /* ParamCategory.ArgsList */ && !param.name;
 }
 exports.isKeywordOnlySeparator = isKeywordOnlySeparator;
 var FunctionTypeFlags;
@@ -1078,7 +1066,7 @@ var FunctionType;
                 fullName,
                 moduleName,
                 flags: functionFlags,
-                typeParameters: [],
+                typeParams: [],
                 parameters: [],
                 declaredReturnType: undefined,
                 declaration: undefined,
@@ -1094,22 +1082,24 @@ var FunctionType;
     }
     // Creates a deep copy of the function type, including a fresh
     // version of _functionDetails.
-    function clone(type, stripFirstParam = false, boundToType, boundTypeVarScopeId) {
+    function clone(type, stripFirstParam = false, boundToType) {
         var _a, _b;
         const newFunction = TypeBase.cloneType(type);
         newFunction.shared = { ...type.shared };
         newFunction.priv.preBoundFlags = newFunction.shared.flags;
         newFunction.priv.boundToType = boundToType;
-        if (boundTypeVarScopeId) {
-            newFunction.priv.constructorTypeVarScopeId = boundTypeVarScopeId;
+        if (boundToType) {
+            if (type.shared.name === '__new__' || type.shared.name === '__init__') {
+                newFunction.priv.constructorTypeVarScopeId = (0, typeUtils_1.getTypeVarScopeId)(boundToType);
+            }
         }
         if (stripFirstParam) {
             if (type.shared.parameters.length > 0) {
-                if (type.shared.parameters[0].category === 0 /* ParameterCategory.Simple */) {
+                if (type.shared.parameters[0].category === 0 /* ParamCategory.Simple */) {
                     if (type.shared.parameters.length > 0 && !FunctionParam.isTypeInferred(type.shared.parameters[0])) {
                         // Stash away the effective type of the first parameter if it
                         // wasn't synthesized.
-                        newFunction.priv.strippedFirstParamType = getEffectiveParameterType(type, 0);
+                        newFunction.priv.strippedFirstParamType = getParamType(type, 0);
                     }
                     newFunction.shared.parameters = type.shared.parameters.slice(1);
                 }
@@ -1130,9 +1120,9 @@ var FunctionType;
                 parameterTypes: stripFirstParam
                     ? type.priv.specializedTypes.parameterTypes.slice(1)
                     : type.priv.specializedTypes.parameterTypes,
-                parameterDefaultArgs: stripFirstParam
-                    ? (_b = type.priv.specializedTypes.parameterDefaultArgs) === null || _b === void 0 ? void 0 : _b.slice(1)
-                    : type.priv.specializedTypes.parameterDefaultArgs,
+                parameterDefaultTypes: stripFirstParam
+                    ? (_b = type.priv.specializedTypes.parameterDefaultTypes) === null || _b === void 0 ? void 0 : _b.slice(1)
+                    : type.priv.specializedTypes.parameterDefaultTypes,
                 returnType: type.priv.specializedTypes.returnType,
             };
         }
@@ -1164,17 +1154,17 @@ var FunctionType;
     // Creates a shallow copy of the function type with new
     // specialized types. The clone shares the _functionDetails
     // with the object being cloned.
-    function cloneForSpecialization(type, specializedTypes, specializedInferredReturnType) {
+    function specialize(type, specializedTypes, specializedInferredReturnType) {
         const newFunction = TypeBase.cloneType(type);
         (0, debug_1.assert)(specializedTypes.parameterTypes.length === type.shared.parameters.length);
-        if (specializedTypes.parameterDefaultArgs) {
-            (0, debug_1.assert)(specializedTypes.parameterDefaultArgs.length === type.shared.parameters.length);
+        if (specializedTypes.parameterDefaultTypes) {
+            (0, debug_1.assert)(specializedTypes.parameterDefaultTypes.length === type.shared.parameters.length);
         }
         newFunction.priv.specializedTypes = specializedTypes;
         newFunction.priv.inferredReturnType = specializedInferredReturnType;
         return newFunction;
     }
-    FunctionType.cloneForSpecialization = cloneForSpecialization;
+    FunctionType.specialize = specialize;
     // Creates a new function based on the parameters of another function.
     function applyParamSpecValue(type, paramSpecValue) {
         const hasPositionalOnly = paramSpecValue.shared.parameters.some((param) => isPositionOnlySeparator(param));
@@ -1183,12 +1173,12 @@ var FunctionType;
         (0, debug_1.assert)(paramSpec !== undefined);
         // Make a shallow clone of the details.
         newFunction.shared = { ...newFunction.shared };
-        newFunction.shared.typeParameters = newFunction.shared.typeParameters.filter((t) => !isTypeSame(t, paramSpec));
+        newFunction.shared.typeParams = newFunction.shared.typeParams.filter((t) => !isTypeSame(t, paramSpec));
         const prevParams = Array.from(newFunction.shared.parameters);
         newFunction.shared.parameters = [
             ...prevParams,
-            ...paramSpecValue.shared.parameters.map((param) => {
-                return FunctionParam.create(param.category, param.type, (param.flags & FunctionParamFlags.NameSynthesized) | FunctionParamFlags.TypeDeclared, param.name, param.defaultType);
+            ...paramSpecValue.shared.parameters.map((param, index) => {
+                return FunctionParam.create(param.category, FunctionType.getParamType(paramSpecValue, index), (param.flags & FunctionParamFlags.NameSynthesized) | FunctionParamFlags.TypeDeclared, param.name, FunctionType.getParamDefaultType(paramSpecValue, index));
             }),
         ];
         if (newFunction.shared.docString === undefined) {
@@ -1218,16 +1208,14 @@ var FunctionType;
         // Update the specialized parameter types as well.
         const specializedTypes = newFunction.priv.specializedTypes;
         if (specializedTypes) {
-            paramSpecValue.shared.parameters.forEach((paramInfo) => {
+            paramSpecValue.shared.parameters.forEach((_, index) => {
                 var _a;
-                specializedTypes.parameterTypes.push(paramInfo.type);
-                // Assume that the parameters introduced via paramSpec have no specialized
-                // default arg types. Fall back on the original default arg type in this case.
-                (_a = specializedTypes.parameterDefaultArgs) === null || _a === void 0 ? void 0 : _a.push(undefined);
+                specializedTypes.parameterTypes.push(FunctionType.getParamType(paramSpecValue, index));
+                if (specializedTypes.parameterDefaultTypes) {
+                    (_a = specializedTypes.parameterDefaultTypes) === null || _a === void 0 ? void 0 : _a.push(FunctionType.getParamDefaultType(paramSpecValue, index));
+                }
             });
         }
-        FunctionType.addHigherOrderTypeVarScopeIds(newFunction, paramSpecValue.shared.typeVarScopeId);
-        FunctionType.addHigherOrderTypeVarScopeIds(newFunction, paramSpecValue.priv.higherOrderTypeVarScopeIds);
         newFunction.priv.constructorTypeVarScopeId = paramSpecValue.priv.constructorTypeVarScopeId;
         if (!newFunction.shared.methodClass && paramSpecValue.shared.methodClass) {
             newFunction.shared.methodClass = paramSpecValue.shared.methodClass;
@@ -1243,14 +1231,13 @@ var FunctionType;
         return newFunction;
     }
     FunctionType.cloneWithNewFlags = cloneWithNewFlags;
-    function cloneWithNewTypeVarScopeId(type, newScopeId, newConstructorScopeId, typeParameters) {
+    function cloneWithNewTypeVarScopeId(type, newScopeId, newConstructorScopeId, typeParams) {
         const newFunction = TypeBase.cloneType(type);
         // Make a shallow clone of the details.
         newFunction.shared = { ...type.shared };
         newFunction.shared.typeVarScopeId = newScopeId;
         newFunction.priv.constructorTypeVarScopeId = newConstructorScopeId;
-        newFunction.shared.typeParameters = typeParameters;
-        FunctionType.addHigherOrderTypeVarScopeIds(newFunction, typeParameters.map((t) => { var _a, _b; return (_b = (_a = t.priv.externalTypeVar) === null || _a === void 0 ? void 0 : _a.priv.scopeId) !== null && _b !== void 0 ? _b : t.priv.scopeId; }));
+        newFunction.shared.typeParams = typeParams;
         return newFunction;
     }
     FunctionType.cloneWithNewTypeVarScopeId = cloneWithNewTypeVarScopeId;
@@ -1281,12 +1268,11 @@ var FunctionType;
         }
         const argsParam = type.shared.parameters[paramCount - 2];
         const kwargsParam = type.shared.parameters[paramCount - 1];
-        if (argsParam.category !== 1 /* ParameterCategory.ArgsList */ ||
-            kwargsParam.category !== 2 /* ParameterCategory.KwargsDict */) {
+        if (argsParam.category !== 1 /* ParamCategory.ArgsList */ || kwargsParam.category !== 2 /* ParamCategory.KwargsDict */) {
             return type;
         }
-        const argsType = FunctionType.getEffectiveParameterType(type, paramCount - 2);
-        const kwargsType = FunctionType.getEffectiveParameterType(type, paramCount - 1);
+        const argsType = FunctionType.getParamType(type, paramCount - 2);
+        const kwargsType = FunctionType.getParamType(type, paramCount - 1);
         if (!isParamSpec(argsType) || !isParamSpec(kwargsType) || !isTypeSame(argsType, kwargsType)) {
             return type;
         }
@@ -1307,9 +1293,9 @@ var FunctionType;
         if (type.priv.specializedTypes) {
             newFunction.priv.specializedTypes = { ...type.priv.specializedTypes };
             newFunction.priv.specializedTypes.parameterTypes = newFunction.priv.specializedTypes.parameterTypes.slice(0, newFunction.priv.specializedTypes.parameterTypes.length - paramsToDrop);
-            if (newFunction.priv.specializedTypes.parameterDefaultArgs) {
-                newFunction.priv.specializedTypes.parameterDefaultArgs =
-                    newFunction.priv.specializedTypes.parameterDefaultArgs.slice(0, newFunction.priv.specializedTypes.parameterDefaultArgs.length - paramsToDrop);
+            if (newFunction.priv.specializedTypes.parameterDefaultTypes) {
+                newFunction.priv.specializedTypes.parameterDefaultTypes =
+                    newFunction.priv.specializedTypes.parameterDefaultTypes.slice(0, newFunction.priv.specializedTypes.parameterDefaultTypes.length - paramsToDrop);
             }
         }
         if (type.priv.inferredReturnType) {
@@ -1326,59 +1312,40 @@ var FunctionType;
             return undefined;
         }
         const secondLastParam = params[params.length - 2];
+        const secondLastParamType = FunctionType.getParamType(type, params.length - 2);
         const lastParam = params[params.length - 1];
-        if (secondLastParam.category === 1 /* ParameterCategory.ArgsList */ &&
-            isTypeVar(secondLastParam.type) &&
-            secondLastParam.type.priv.paramSpecAccess === 'args' &&
-            lastParam.category === 2 /* ParameterCategory.KwargsDict */ &&
-            isTypeVar(lastParam.type) &&
-            lastParam.type.priv.paramSpecAccess === 'kwargs') {
-            return TypeVarType.cloneForParamSpecAccess(secondLastParam.type, /* access */ undefined);
+        const lastParamType = FunctionType.getParamType(type, params.length - 1);
+        if (secondLastParam.category === 1 /* ParamCategory.ArgsList */ &&
+            isParamSpec(secondLastParamType) &&
+            secondLastParamType.priv.paramSpecAccess === 'args' &&
+            lastParam.category === 2 /* ParamCategory.KwargsDict */ &&
+            isParamSpec(lastParamType) &&
+            lastParamType.priv.paramSpecAccess === 'kwargs') {
+            return TypeVarType.cloneForParamSpecAccess(secondLastParamType, /* access */ undefined);
         }
         return undefined;
     }
     FunctionType.getParamSpecFromArgsKwargs = getParamSpecFromArgsKwargs;
     function addParamSpecVariadics(type, paramSpec) {
-        FunctionType.addParameter(type, FunctionParam.create(1 /* ParameterCategory.ArgsList */, TypeVarType.cloneForParamSpecAccess(paramSpec, 'args'), FunctionParamFlags.TypeDeclared, 'args'));
-        FunctionType.addParameter(type, FunctionParam.create(2 /* ParameterCategory.KwargsDict */, TypeVarType.cloneForParamSpecAccess(paramSpec, 'kwargs'), FunctionParamFlags.TypeDeclared, 'kwargs'));
+        FunctionType.addParam(type, FunctionParam.create(1 /* ParamCategory.ArgsList */, TypeVarType.cloneForParamSpecAccess(paramSpec, 'args'), FunctionParamFlags.TypeDeclared, 'args'));
+        FunctionType.addParam(type, FunctionParam.create(2 /* ParamCategory.KwargsDict */, TypeVarType.cloneForParamSpecAccess(paramSpec, 'kwargs'), FunctionParamFlags.TypeDeclared, 'kwargs'));
     }
     FunctionType.addParamSpecVariadics = addParamSpecVariadics;
-    function addDefaultParameters(type, useUnknown = false) {
-        getDefaultParameters(useUnknown).forEach((param) => {
-            FunctionType.addParameter(type, param);
-        });
-    }
-    FunctionType.addDefaultParameters = addDefaultParameters;
-    function addHigherOrderTypeVarScopeIds(functionType, scopeIds) {
-        if (!scopeIds) {
-            return;
-        }
-        if (!Array.isArray(scopeIds)) {
-            scopeIds = [scopeIds];
-        }
-        if (!functionType.priv.higherOrderTypeVarScopeIds) {
-            functionType.priv.higherOrderTypeVarScopeIds = [];
-        }
-        // Add the scope IDs to the function if they're unique.
-        scopeIds.forEach((scopeId) => {
-            if (!scopeId || scopeId === functionType.shared.typeVarScopeId) {
-                return;
-            }
-            if (!functionType.priv.higherOrderTypeVarScopeIds.some((id) => id === scopeId)) {
-                functionType.priv.higherOrderTypeVarScopeIds.push(scopeId);
-            }
+    function addDefaultParams(type, useUnknown = false) {
+        getDefaultParams(useUnknown).forEach((param) => {
+            FunctionType.addParam(type, param);
         });
     }
-    FunctionType.addHigherOrderTypeVarScopeIds = addHigherOrderTypeVarScopeIds;
-    function getDefaultParameters(useUnknown = false) {
+    FunctionType.addDefaultParams = addDefaultParams;
+    function getDefaultParams(useUnknown = false) {
         return [
-            FunctionParam.create(1 /* ParameterCategory.ArgsList */, useUnknown ? UnknownType.create() : AnyType.create(), useUnknown ? FunctionParamFlags.None : FunctionParamFlags.TypeDeclared, 'args'),
-            FunctionParam.create(2 /* ParameterCategory.KwargsDict */, useUnknown ? UnknownType.create() : AnyType.create(), useUnknown ? FunctionParamFlags.None : FunctionParamFlags.TypeDeclared, 'kwargs'),
+            FunctionParam.create(1 /* ParamCategory.ArgsList */, useUnknown ? UnknownType.create() : AnyType.create(), useUnknown ? FunctionParamFlags.None : FunctionParamFlags.TypeDeclared, 'args'),
+            FunctionParam.create(2 /* ParamCategory.KwargsDict */, useUnknown ? UnknownType.create() : AnyType.create(), useUnknown ? FunctionParamFlags.None : FunctionParamFlags.TypeDeclared, 'kwargs'),
         ];
     }
-    FunctionType.getDefaultParameters = getDefaultParameters;
+    FunctionType.getDefaultParams = getDefaultParams;
     // Indicates whether the input signature consists of (*args: Any, **kwargs: Any).
-    function hasDefaultParameters(functionType) {
+    function hasDefaultParams(functionType) {
         let sawArgs = false;
         let sawKwargs = false;
         for (let i = 0; i < functionType.shared.parameters.length; i++) {
@@ -1387,22 +1354,22 @@ var FunctionType;
             if (!param.name) {
                 continue;
             }
-            if (param.category === 0 /* ParameterCategory.Simple */) {
+            if (param.category === 0 /* ParamCategory.Simple */) {
                 return false;
             }
-            else if (param.category === 1 /* ParameterCategory.ArgsList */) {
+            else if (param.category === 1 /* ParamCategory.ArgsList */) {
                 sawArgs = true;
             }
-            else if (param.category === 2 /* ParameterCategory.KwargsDict */) {
+            else if (param.category === 2 /* ParamCategory.KwargsDict */) {
                 sawKwargs = true;
             }
-            if (!isAnyOrUnknown(FunctionType.getEffectiveParameterType(functionType, i))) {
+            if (!isAnyOrUnknown(FunctionType.getParamType(functionType, i))) {
                 return false;
             }
         }
         return sawArgs && sawKwargs;
     }
-    FunctionType.hasDefaultParameters = hasDefaultParameters;
+    FunctionType.hasDefaultParams = hasDefaultParams;
     function isInstanceMethod(type) {
         return ((type.shared.flags &
             (1 /* FunctionTypeFlags.ConstructorMethod */ |
@@ -1443,10 +1410,10 @@ var FunctionType;
         return (type.shared.flags & 256 /* FunctionTypeFlags.Overloaded */) !== 0;
     }
     FunctionType.isOverloaded = isOverloaded;
-    function isDefaultParameterCheckDisabled(type) {
+    function isDefaultParamCheckDisabled(type) {
         return (type.shared.flags & 32 /* FunctionTypeFlags.DisableDefaultChecks */) !== 0;
     }
-    FunctionType.isDefaultParameterCheckDisabled = isDefaultParameterCheckDisabled;
+    FunctionType.isDefaultParamCheckDisabled = isDefaultParamCheckDisabled;
     function isAsync(type) {
         return (type.shared.flags & 512 /* FunctionTypeFlags.Async */) !== 0;
     }
@@ -1494,42 +1461,46 @@ var FunctionType;
         return true;
     }
     FunctionType.isBuiltIn = isBuiltIn;
-    function getEffectiveParameterType(type, index) {
+    function getDeclaredParamType(type, index) {
+        return type.shared.parameters[index]._type;
+    }
+    FunctionType.getDeclaredParamType = getDeclaredParamType;
+    function getParamType(type, index) {
         (0, debug_1.assert)(index < type.shared.parameters.length, 'Parameter types array overflow');
         if (type.priv.specializedTypes && index < type.priv.specializedTypes.parameterTypes.length) {
             return type.priv.specializedTypes.parameterTypes[index];
         }
-        return type.shared.parameters[index].type;
+        return type.shared.parameters[index]._type;
     }
-    FunctionType.getEffectiveParameterType = getEffectiveParameterType;
-    function getEffectiveParameterDefaultArgType(type, index) {
+    FunctionType.getParamType = getParamType;
+    function getParamDefaultType(type, index) {
         var _a;
         (0, debug_1.assert)(index < type.shared.parameters.length, 'Parameter types array overflow');
-        if (((_a = type.priv.specializedTypes) === null || _a === void 0 ? void 0 : _a.parameterDefaultArgs) &&
-            index < type.priv.specializedTypes.parameterDefaultArgs.length) {
-            const defaultArgType = type.priv.specializedTypes.parameterDefaultArgs[index];
+        if (((_a = type.priv.specializedTypes) === null || _a === void 0 ? void 0 : _a.parameterDefaultTypes) &&
+            index < type.priv.specializedTypes.parameterDefaultTypes.length) {
+            const defaultArgType = type.priv.specializedTypes.parameterDefaultTypes[index];
             if (defaultArgType) {
                 return defaultArgType;
             }
         }
-        return type.shared.parameters[index].defaultType;
+        return type.shared.parameters[index]._defaultType;
     }
-    FunctionType.getEffectiveParameterDefaultArgType = getEffectiveParameterDefaultArgType;
-    function addParameter(type, param) {
+    FunctionType.getParamDefaultType = getParamDefaultType;
+    function addParam(type, param) {
         type.shared.parameters.push(param);
         if (type.priv.specializedTypes) {
-            type.priv.specializedTypes.parameterTypes.push(param.type);
+            type.priv.specializedTypes.parameterTypes.push(param._type);
         }
     }
-    FunctionType.addParameter = addParameter;
-    function addPositionOnlyParameterSeparator(type) {
-        addParameter(type, FunctionParam.create(0 /* ParameterCategory.Simple */, AnyType.create()));
+    FunctionType.addParam = addParam;
+    function addPositionOnlyParamSeparator(type) {
+        addParam(type, FunctionParam.create(0 /* ParamCategory.Simple */, AnyType.create()));
     }
-    FunctionType.addPositionOnlyParameterSeparator = addPositionOnlyParameterSeparator;
-    function addKeywordOnlyParameterSeparator(type) {
-        addParameter(type, FunctionParam.create(1 /* ParameterCategory.ArgsList */, AnyType.create()));
+    FunctionType.addPositionOnlyParamSeparator = addPositionOnlyParamSeparator;
+    function addKeywordOnlyParamSeparator(type) {
+        addParam(type, FunctionParam.create(1 /* ParamCategory.ArgsList */, AnyType.create()));
     }
-    FunctionType.addKeywordOnlyParameterSeparator = addKeywordOnlyParameterSeparator;
+    FunctionType.addKeywordOnlyParamSeparator = addKeywordOnlyParamSeparator;
     function getEffectiveReturnType(type, includeInferred = true) {
         var _a;
         if ((_a = type.priv.specializedTypes) === null || _a === void 0 ? void 0 : _a.returnType) {
@@ -1856,20 +1827,36 @@ var Variance;
     Variance[Variance["Covariant"] = 3] = "Covariant";
     Variance[Variance["Contravariant"] = 4] = "Contravariant";
 })(Variance || (exports.Variance = Variance = {}));
+var TypeVarKind;
+(function (TypeVarKind) {
+    TypeVarKind[TypeVarKind["TypeVar"] = 0] = "TypeVar";
+    TypeVarKind[TypeVarKind["TypeVarTuple"] = 1] = "TypeVarTuple";
+    TypeVarKind[TypeVarKind["ParamSpec"] = 2] = "ParamSpec";
+})(TypeVarKind || (exports.TypeVarKind = TypeVarKind = {}));
 var TypeVarScopeType;
 (function (TypeVarScopeType) {
     TypeVarScopeType[TypeVarScopeType["Class"] = 0] = "Class";
     TypeVarScopeType[TypeVarScopeType["Function"] = 1] = "Function";
     TypeVarScopeType[TypeVarScopeType["TypeAlias"] = 2] = "TypeAlias";
 })(TypeVarScopeType || (exports.TypeVarScopeType = TypeVarScopeType = {}));
+var ParamSpecType;
+(function (ParamSpecType) {
+    // Returns the "Unknown" equivalent for a ParamSpec.
+    function getUnknown() {
+        const newFunction = FunctionType.createInstance('', '', '', 65536 /* FunctionTypeFlags.ParamSpecValue */ | 32768 /* FunctionTypeFlags.GradualCallableForm */);
+        FunctionType.addDefaultParams(newFunction);
+        return newFunction;
+    }
+    ParamSpecType.getUnknown = getUnknown;
+})(ParamSpecType || (exports.ParamSpecType = ParamSpecType = {}));
 var TypeVarType;
 (function (TypeVarType) {
-    function createInstance(name) {
-        return create(name, /* isParamSpec */ false, 2 /* TypeFlags.Instance */);
+    function createInstance(name, kind = TypeVarKind.TypeVar) {
+        return create(name, kind, 2 /* TypeFlags.Instance */);
     }
     TypeVarType.createInstance = createInstance;
-    function createInstantiable(name, isParamSpec = false) {
-        return create(name, isParamSpec, 1 /* TypeFlags.Instantiable */);
+    function createInstantiable(name, kind = TypeVarKind.TypeVar) {
+        return create(name, kind, 1 /* TypeFlags.Instantiable */);
     }
     TypeVarType.createInstantiable = createInstantiable;
     function cloneAsInstance(type) {
@@ -1882,8 +1869,8 @@ var TypeVarType;
         if ((_b = newInstance.props) === null || _b === void 0 ? void 0 : _b.specialForm) {
             TypeBase.setSpecialForm(newInstance, undefined);
         }
-        if (newInstance.priv.externalTypeVar) {
-            newInstance.priv.externalTypeVar = TypeVarType.cloneAsInstance(newInstance.priv.externalTypeVar);
+        if (newInstance.priv.freeTypeVar) {
+            newInstance.priv.freeTypeVar = TypeVarType.cloneAsInstance(newInstance.priv.freeTypeVar);
         }
         return newInstance;
     }
@@ -1894,8 +1881,8 @@ var TypeVarType;
             return type.cached.typeBaseInstantiableType;
         }
         const newInstance = TypeBase.cloneTypeAsInstantiable(type, /* cache */ true);
-        if (newInstance.priv.externalTypeVar) {
-            newInstance.priv.externalTypeVar = TypeVarType.cloneAsInstantiable(newInstance.priv.externalTypeVar);
+        if (newInstance.priv.freeTypeVar) {
+            newInstance.priv.freeTypeVar = TypeVarType.cloneAsInstantiable(newInstance.priv.freeTypeVar);
         }
         return newInstance;
     }
@@ -1920,39 +1907,37 @@ var TypeVarType;
     }
     TypeVarType.cloneForScopeId = cloneForScopeId;
     function cloneForUnpacked(type, isInUnion = false) {
-        (0, debug_1.assert)(type.shared.isVariadic);
         const newInstance = TypeBase.cloneType(type);
-        newInstance.priv.isVariadicUnpacked = true;
-        newInstance.priv.isVariadicInUnion = isInUnion;
-        if (newInstance.priv.externalTypeVar) {
-            newInstance.priv.externalTypeVar = TypeVarType.cloneForUnpacked(newInstance.priv.externalTypeVar, isInUnion);
+        newInstance.priv.isUnpacked = true;
+        newInstance.priv.isInUnion = isInUnion;
+        if (newInstance.priv.freeTypeVar) {
+            newInstance.priv.freeTypeVar = TypeVarType.cloneForUnpacked(newInstance.priv.freeTypeVar, isInUnion);
         }
         return newInstance;
     }
     TypeVarType.cloneForUnpacked = cloneForUnpacked;
     function cloneForPacked(type) {
-        (0, debug_1.assert)(type.shared.isVariadic);
         const newInstance = TypeBase.cloneType(type);
-        newInstance.priv.isVariadicUnpacked = false;
-        newInstance.priv.isVariadicInUnion = false;
-        if (newInstance.priv.externalTypeVar) {
-            newInstance.priv.externalTypeVar = TypeVarType.cloneForPacked(newInstance.priv.externalTypeVar);
+        newInstance.priv.isUnpacked = false;
+        newInstance.priv.isInUnion = false;
+        if (newInstance.priv.freeTypeVar) {
+            newInstance.priv.freeTypeVar = TypeVarType.cloneForPacked(newInstance.priv.freeTypeVar);
         }
         return newInstance;
     }
     TypeVarType.cloneForPacked = cloneForPacked;
     // Creates a "simplified" version of the TypeVar with invariance
-    // and no bound or constraints. ParamSpecs and variadics are left
+    // and no bound or constraints. ParamSpecs and TypeVarTuples are left
     // unmodified. So are auto-variant type variables.
     function cloneAsInvariant(type) {
-        if (type.shared.isParamSpec || type.shared.isVariadic) {
+        if (isParamSpec(type) || isTypeVarTuple(type)) {
             return type;
         }
         if (type.shared.declaredVariance === 0 /* Variance.Auto */) {
             return type;
         }
         if (type.shared.declaredVariance === 2 /* Variance.Invariant */) {
-            if (type.shared.boundType === undefined && type.shared.constraints.length === 0) {
+            if (!TypeVarType.hasBound(type) && !TypeVarType.hasConstraints(type)) {
                 return type;
             }
         }
@@ -1971,15 +1956,15 @@ var TypeVarType;
     }
     TypeVarType.cloneForParamSpecAccess = cloneForParamSpecAccess;
     function cloneAsSpecializedSelf(type, specializedBoundType) {
-        (0, debug_1.assert)(type.shared.isSynthesizedSelf);
+        (0, debug_1.assert)(TypeVarType.isSelf(type));
         const newInstance = TypeBase.cloneType(type);
         newInstance.shared = { ...newInstance.shared };
         newInstance.shared.boundType = specializedBoundType;
         return newInstance;
     }
     TypeVarType.cloneAsSpecializedSelf = cloneAsSpecializedSelf;
-    function cloneAsInScopePlaceholder(type, usageOffset) {
-        if (type.priv.isInScopePlaceholder) {
+    function cloneAsUnificationVar(type, usageOffset) {
+        if (TypeVarType.isUnification(type)) {
             return type;
         }
         // If the caller specified a usage offset, append it to the TypeVar
@@ -1991,50 +1976,60 @@ var TypeVarType;
             newNameWithScope = `${type.priv.nameWithScope}-${usageOffset}`;
         }
         const newInstance = TypeBase.cloneType(type);
-        newInstance.priv.isInScopePlaceholder = true;
-        newInstance.priv.scopeId = exports.InScopePlaceholderScopeId;
+        newInstance.priv.isUnificationVar = true;
+        newInstance.priv.scopeId = exports.UnificationScopeId;
         newInstance.priv.nameWithScope = newNameWithScope;
         return newInstance;
     }
-    TypeVarType.cloneAsInScopePlaceholder = cloneAsInScopePlaceholder;
+    TypeVarType.cloneAsUnificationVar = cloneAsUnificationVar;
     function makeNameWithScope(name, scopeId) {
         return `${name}.${scopeId}`;
     }
     TypeVarType.makeNameWithScope = makeNameWithScope;
-    function makeInternalScopeId(scopeId) {
+    function makeBoundScopeId(scopeId) {
         if (!scopeId) {
             return undefined;
         }
+        // Append an asterisk to denote a bound scope.
         return `${scopeId}*`;
     }
-    TypeVarType.makeInternalScopeId = makeInternalScopeId;
-    function cloneWithInternalScopeId(type) {
-        if (type.priv.scopeId === undefined || type.priv.externalTypeVar) {
+    TypeVarType.makeBoundScopeId = makeBoundScopeId;
+    function cloneAsBound(type) {
+        if (type.priv.scopeId === undefined || type.priv.freeTypeVar) {
             return type;
         }
-        const clone = TypeVarType.cloneForScopeId(type, TypeVarType.makeInternalScopeId(type.priv.scopeId), type.priv.scopeName, type.priv.scopeType);
-        clone.priv.externalTypeVar = type;
+        const clone = TypeVarType.cloneForScopeId(type, TypeVarType.makeBoundScopeId(type.priv.scopeId), type.priv.scopeName, type.priv.scopeType);
+        clone.priv.freeTypeVar = type;
         return clone;
     }
-    TypeVarType.cloneWithInternalScopeId = cloneWithInternalScopeId;
-    function hasInternalScopeId(type) {
-        return !!type.priv.externalTypeVar;
-    }
-    TypeVarType.hasInternalScopeId = hasInternalScopeId;
-    function create(name, isParamSpec, typeFlags) {
+    TypeVarType.cloneAsBound = cloneAsBound;
+    // Indicates that the type var is a "free" or unbound type var. Free
+    // type variables can be solved whereas bound type vars are already bound
+    // to a value.
+    function isBound(type) {
+        // If the type var has an associated free type var, then it's
+        // considered bound. If it has no associated free var, then it's
+        // considered free.
+        return !!type.priv.freeTypeVar;
+    }
+    TypeVarType.isBound = isBound;
+    function isUnification(type) {
+        return type.priv.isUnificationVar;
+    }
+    TypeVarType.isUnification = isUnification;
+    function create(name, kind, typeFlags) {
         const newTypeVarType = {
             category: 9 /* TypeCategory.TypeVar */,
             flags: typeFlags,
             props: undefined,
             cached: undefined,
             shared: {
+                kind,
                 name,
                 constraints: [],
                 boundType: undefined,
                 isDefaultExplicit: false,
                 defaultType: UnknownType.create(),
-                isParamSpec,
-                isVariadic: false,
                 declaredVariance: 2 /* Variance.Invariant */,
                 isSynthesized: false,
                 isSynthesizedSelf: false,
@@ -2082,6 +2077,18 @@ var TypeVarType;
         return !!type.shared.recursiveAlias && !type.shared.boundType;
     }
     TypeVarType.isTypeAliasPlaceholder = isTypeAliasPlaceholder;
+    function isSelf(type) {
+        return !!type.shared.isSynthesizedSelf;
+    }
+    TypeVarType.isSelf = isSelf;
+    function hasConstraints(type) {
+        return type.shared.constraints.length > 0;
+    }
+    TypeVarType.hasConstraints = hasConstraints;
+    function hasBound(type) {
+        return !!type.shared.boundType;
+    }
+    TypeVarType.hasBound = hasBound;
 })(TypeVarType || (exports.TypeVarType = TypeVarType = {}));
 function isNever(type) {
     return type.category === 3 /* TypeCategory.Never */;
@@ -2143,17 +2150,18 @@ function isTypeVar(type) {
     return type.category === 9 /* TypeCategory.TypeVar */;
 }
 exports.isTypeVar = isTypeVar;
-function isVariadicTypeVar(type) {
-    return type.category === 9 /* TypeCategory.TypeVar */ && type.shared.isVariadic;
+function isParamSpec(type) {
+    return type.category === 9 /* TypeCategory.TypeVar */ && type.shared.kind === TypeVarKind.ParamSpec;
+}
+exports.isParamSpec = isParamSpec;
+function isTypeVarTuple(type) {
+    return type.category === 9 /* TypeCategory.TypeVar */ && type.shared.kind === TypeVarKind.TypeVarTuple;
 }
-exports.isVariadicTypeVar = isVariadicTypeVar;
-function isUnpackedVariadicTypeVar(type) {
-    return (type.category === 9 /* TypeCategory.TypeVar */ &&
-        type.shared.isVariadic &&
-        !!type.priv.isVariadicUnpacked &&
-        !type.priv.isVariadicInUnion);
+exports.isTypeVarTuple = isTypeVarTuple;
+function isUnpackedTypeVarTuple(type) {
+    return isTypeVarTuple(type) && !!type.priv.isUnpacked && !type.priv.isInUnion;
 }
-exports.isUnpackedVariadicTypeVar = isUnpackedVariadicTypeVar;
+exports.isUnpackedTypeVarTuple = isUnpackedTypeVarTuple;
 function isUnpackedClass(type) {
     if (!isClass(type) || !type.priv.isUnpacked) {
         return false;
@@ -2162,13 +2170,9 @@ function isUnpackedClass(type) {
 }
 exports.isUnpackedClass = isUnpackedClass;
 function isUnpacked(type) {
-    return isUnpackedVariadicTypeVar(type) || isUnpackedClass(type);
+    return isUnpackedTypeVarTuple(type) || isUnpackedClass(type);
 }
 exports.isUnpacked = isUnpacked;
-function isParamSpec(type) {
-    return type.category === 9 /* TypeCategory.TypeVar */ && type.shared.isParamSpec;
-}
-exports.isParamSpec = isParamSpec;
 function isFunction(type) {
     return type.category === 4 /* TypeCategory.Function */;
 }
@@ -2231,9 +2235,9 @@ function isTypeSame(type1, type2, options = {}, recursionCount = 0) {
             }
             if (!options.ignorePseudoGeneric || !ClassType.isPseudoGenericClass(type1)) {
                 // Make sure the type args match.
-                if (type1.priv.tupleTypeArguments && classType2.priv.tupleTypeArguments) {
-                    const type1TupleTypeArgs = type1.priv.tupleTypeArguments || [];
-                    const type2TupleTypeArgs = classType2.priv.tupleTypeArguments || [];
+                if (type1.priv.tupleTypeArgs && classType2.priv.tupleTypeArgs) {
+                    const type1TupleTypeArgs = type1.priv.tupleTypeArgs || [];
+                    const type2TupleTypeArgs = classType2.priv.tupleTypeArgs || [];
                     if (type1TupleTypeArgs.length !== type2TupleTypeArgs.length) {
                         return false;
                     }
@@ -2247,8 +2251,8 @@ function isTypeSame(type1, type2, options = {}, recursionCount = 0) {
                     }
                 }
                 else {
-                    const type1TypeArgs = type1.priv.typeArguments || [];
-                    const type2TypeArgs = classType2.priv.typeArguments || [];
+                    const type1TypeArgs = type1.priv.typeArgs || [];
+                    const type2TypeArgs = classType2.priv.typeArgs || [];
                     const typeArgCount = Math.max(type1TypeArgs.length, type2TypeArgs.length);
                     for (let i = 0; i < typeArgCount; i++) {
                         // Assume that missing type args are "Unknown".
@@ -2308,8 +2312,8 @@ function isTypeSame(type1, type2, options = {}, recursionCount = 0) {
                 else if (isKeywordOnlySeparator(param1) && isKeywordOnlySeparator(param2)) {
                     continue;
                 }
-                const param1Type = FunctionType.getEffectiveParameterType(type1, i);
-                const param2Type = FunctionType.getEffectiveParameterType(functionType2, i);
+                const param1Type = FunctionType.getParamType(type1, i);
+                const param2Type = FunctionType.getParamType(functionType2, i);
                 if (!isTypeSame(param1Type, param2Type, { ...options, ignoreTypeFlags: false }, recursionCount)) {
                     return false;
                 }
@@ -2373,8 +2377,8 @@ function isTypeSame(type1, type2, options = {}, recursionCount = 0) {
             // Handle the case where this is a generic recursive type alias. Make
             // sure that the type argument types match.
             if (type1.shared.recursiveAlias && type2TypeVar.shared.recursiveAlias) {
-                const type1TypeArgs = ((_d = (_c = type1 === null || type1 === void 0 ? void 0 : type1.props) === null || _c === void 0 ? void 0 : _c.typeAliasInfo) === null || _d === void 0 ? void 0 : _d.typeArguments) || [];
-                const type2TypeArgs = ((_f = (_e = type2 === null || type2 === void 0 ? void 0 : type2.props) === null || _e === void 0 ? void 0 : _e.typeAliasInfo) === null || _f === void 0 ? void 0 : _f.typeArguments) || [];
+                const type1TypeArgs = ((_d = (_c = type1 === null || type1 === void 0 ? void 0 : type1.props) === null || _c === void 0 ? void 0 : _c.typeAliasInfo) === null || _d === void 0 ? void 0 : _d.typeArgs) || [];
+                const type2TypeArgs = ((_f = (_e = type2 === null || type2 === void 0 ? void 0 : type2.props) === null || _e === void 0 ? void 0 : _e.typeAliasInfo) === null || _f === void 0 ? void 0 : _f.typeArgs) || [];
                 const typeArgCount = Math.max(type1TypeArgs.length, type2TypeArgs.length);
                 for (let i = 0; i < typeArgCount; i++) {
                     // Assume that missing type args are "Any".
@@ -2385,15 +2389,21 @@ function isTypeSame(type1, type2, options = {}, recursionCount = 0) {
                     }
                 }
             }
-            if (!type1.priv.isVariadicInUnion !== !type2TypeVar.priv.isVariadicInUnion) {
-                return false;
+            if (isTypeVarTuple(type1) && isTypeVarTuple(type2TypeVar)) {
+                if (!type1.priv.isInUnion !== !type2TypeVar.priv.isInUnion) {
+                    return false;
+                }
             }
             if (type1.shared === type2TypeVar.shared) {
                 return true;
             }
+            if (isParamSpec(type1) !== isParamSpec(type2TypeVar)) {
+                return false;
+            }
+            if (isTypeVarTuple(type1) !== isTypeVarTuple(type2TypeVar)) {
+                return false;
+            }
             if (type1.shared.name !== type2TypeVar.shared.name ||
-                type1.shared.isParamSpec !== type2TypeVar.shared.isParamSpec ||
-                type1.shared.isVariadic !== type2TypeVar.shared.isVariadic ||
                 type1.shared.isSynthesized !== type2TypeVar.shared.isSynthesized ||
                 type1.shared.declaredVariance !== type2TypeVar.shared.declaredVariance ||
                 type1.priv.scopeId !== type2TypeVar.priv.scopeId) {
@@ -2663,8 +2673,7 @@ function _addTypeIfUnique(unionType, typeToAdd, elideRedundantLiterals) {
         // parameterized with its own class) ad infinitum.
         if (isPseudoGeneric) {
             if (isTypeSame(type, typeToAdd, { ignorePseudoGeneric: true })) {
-                unionType.priv.subtypes[i] = ClassType.cloneForSpecialization(typeToAdd, typeToAdd.shared.typeParameters.map(() => UnknownType.create()), 
-                /* isTypeArgumentExplicit */ true);
+                unionType.priv.subtypes[i] = ClassType.specialize(typeToAdd, typeToAdd.shared.typeParams.map(() => UnknownType.create()));
                 return;
             }
         }
@@ -2692,7 +2701,7 @@ function _addTypeIfUnique(unionType, typeToAdd, elideRedundantLiterals) {
             // existing type, see if one of them is a proper subset of the other.
             if (ClassType.isTypedDictClass(type) && ClassType.isSameGenericClass(type, typeToAdd)) {
                 // Do not proceed if the TypedDicts are generic and have different type arguments.
-                if (!type.priv.typeArguments && !typeToAdd.priv.typeArguments) {
+                if (!type.priv.typeArgs && !typeToAdd.priv.typeArgs) {
                     if (ClassType.isTypedDictNarrower(typeToAdd, type)) {
                         return;
                     }