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

package/dist/analyzer/types.js

@@ -8,8 +8,8 @@
  * 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.InScopePlaceholderScopeId = exports.TypeFlags = exports.TypeCategory = void 0;
+exports.isSameWithoutLiteralValue = exports.combineTypes = exports.findSubtype = exports.removeFromUnion = void 0;
 const debug_1 = require("../common/debug");
 var TypeCategory;
 (function (TypeCategory) {
@@ -195,9 +195,9 @@ var TypeBase;
             fileUri,
             typeVarScopeId,
             isPep695Syntax,
-            typeParameters: typeParams,
+            typeParams: typeParams,
             usageVariance: undefined,
-            typeArguments: typeArgs,
+            typeArgs: typeArgs,
         });
         return typeClone;
     }
@@ -442,7 +442,7 @@ var ClassType;
                 effectiveMetaclass,
                 mro: [],
                 fields: new Map(),
-                typeParameters: [],
+                typeParams: [],
                 docString,
             },
             priv: {},
@@ -480,20 +480,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 +555,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 +649,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 +811,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 +858,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 +886,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;
             }
         }
@@ -989,12 +987,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 +1076,7 @@ var FunctionType;
                 fullName,
                 moduleName,
                 flags: functionFlags,
-                typeParameters: [],
+                typeParams: [],
                 parameters: [],
                 declaredReturnType: undefined,
                 declaration: undefined,
@@ -1105,11 +1103,11 @@ var FunctionType;
         }
         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 = getEffectiveParamType(type, 0);
                     }
                     newFunction.shared.parameters = type.shared.parameters.slice(1);
                 }
@@ -1164,7 +1162,7 @@ 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) {
@@ -1174,7 +1172,7 @@ var FunctionType;
         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,7 +1181,7 @@ 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,
@@ -1243,14 +1241,14 @@ 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;
+        FunctionType.addHigherOrderTypeVarScopeIds(newFunction, typeParams.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; }));
         return newFunction;
     }
     FunctionType.cloneWithNewTypeVarScopeId = cloneWithNewTypeVarScopeId;
@@ -1281,12 +1279,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.getEffectiveParamType(type, paramCount - 2);
+        const kwargsType = FunctionType.getEffectiveParamType(type, paramCount - 1);
         if (!isParamSpec(argsType) || !isParamSpec(kwargsType) || !isTypeSame(argsType, kwargsType)) {
             return type;
         }
@@ -1327,11 +1324,11 @@ var FunctionType;
         }
         const secondLastParam = params[params.length - 2];
         const lastParam = params[params.length - 1];
-        if (secondLastParam.category === 1 /* ParameterCategory.ArgsList */ &&
-            isTypeVar(secondLastParam.type) &&
+        if (secondLastParam.category === 1 /* ParamCategory.ArgsList */ &&
+            isParamSpec(secondLastParam.type) &&
             secondLastParam.type.priv.paramSpecAccess === 'args' &&
-            lastParam.category === 2 /* ParameterCategory.KwargsDict */ &&
-            isTypeVar(lastParam.type) &&
+            lastParam.category === 2 /* ParamCategory.KwargsDict */ &&
+            isParamSpec(lastParam.type) &&
             lastParam.type.priv.paramSpecAccess === 'kwargs') {
             return TypeVarType.cloneForParamSpecAccess(secondLastParam.type, /* access */ undefined);
         }
@@ -1339,16 +1336,16 @@ var FunctionType;
     }
     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);
+    function addDefaultParams(type, useUnknown = false) {
+        getDefaultParams(useUnknown).forEach((param) => {
+            FunctionType.addParam(type, param);
         });
     }
-    FunctionType.addDefaultParameters = addDefaultParameters;
+    FunctionType.addDefaultParams = addDefaultParams;
     function addHigherOrderTypeVarScopeIds(functionType, scopeIds) {
         if (!scopeIds) {
             return;
@@ -1370,15 +1367,15 @@ var FunctionType;
         });
     }
     FunctionType.addHigherOrderTypeVarScopeIds = addHigherOrderTypeVarScopeIds;
-    function getDefaultParameters(useUnknown = false) {
+    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 +1384,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.getEffectiveParamType(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 +1440,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,15 +1491,15 @@ var FunctionType;
         return true;
     }
     FunctionType.isBuiltIn = isBuiltIn;
-    function getEffectiveParameterType(type, index) {
+    function getEffectiveParamType(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;
     }
-    FunctionType.getEffectiveParameterType = getEffectiveParameterType;
-    function getEffectiveParameterDefaultArgType(type, index) {
+    FunctionType.getEffectiveParamType = getEffectiveParamType;
+    function getEffectiveParamDefaultArgType(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) &&
@@ -1514,22 +1511,22 @@ var FunctionType;
         }
         return type.shared.parameters[index].defaultType;
     }
-    FunctionType.getEffectiveParameterDefaultArgType = getEffectiveParameterDefaultArgType;
-    function addParameter(type, param) {
+    FunctionType.getEffectiveParamDefaultArgType = getEffectiveParamDefaultArgType;
+    function addParam(type, param) {
         type.shared.parameters.push(param);
         if (type.priv.specializedTypes) {
             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 +1853,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) {
@@ -1920,7 +1933,6 @@ 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;
@@ -1931,7 +1943,6 @@ var TypeVarType;
     }
     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;
@@ -1945,7 +1956,7 @@ var TypeVarType;
     // and no bound or constraints. ParamSpecs and variadics 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 */) {
@@ -2021,20 +2032,19 @@ var TypeVarType;
         return !!type.priv.externalTypeVar;
     }
     TypeVarType.hasInternalScopeId = hasInternalScopeId;
-    function create(name, isParamSpec, typeFlags) {
+    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,
@@ -2143,17 +2153,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.isVariadicTypeVar = isVariadicTypeVar;
-function isUnpackedVariadicTypeVar(type) {
-    return (type.category === 9 /* TypeCategory.TypeVar */ &&
-        type.shared.isVariadic &&
-        !!type.priv.isVariadicUnpacked &&
-        !type.priv.isVariadicInUnion);
+exports.isParamSpec = isParamSpec;
+function isTypeVarTuple(type) {
+    return type.category === 9 /* TypeCategory.TypeVar */ && type.shared.kind === TypeVarKind.TypeVarTuple;
 }
-exports.isUnpackedVariadicTypeVar = isUnpackedVariadicTypeVar;
+exports.isTypeVarTuple = isTypeVarTuple;
+function isUnpackedTypeVarTuple(type) {
+    return isTypeVarTuple(type) && !!type.priv.isVariadicUnpacked && !type.priv.isVariadicInUnion;
+}
+exports.isUnpackedTypeVarTuple = isUnpackedTypeVarTuple;
 function isUnpackedClass(type) {
     if (!isClass(type) || !type.priv.isUnpacked) {
         return false;
@@ -2162,13 +2173,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 +2238,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 +2254,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 +2315,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.getEffectiveParamType(type1, i);
+                const param2Type = FunctionType.getEffectiveParamType(functionType2, i);
                 if (!isTypeSame(param1Type, param2Type, { ...options, ignoreTypeFlags: false }, recursionCount)) {
                     return false;
                 }
@@ -2373,8 +2380,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 +2392,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.isVariadicInUnion !== !type2TypeVar.priv.isVariadicInUnion) {
+                    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 +2676,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 +2704,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;
                     }