@zzzen/pyright-internal 1.2.0-dev.20240602 → 1.2.0-dev.20240609

package/dist/analyzer/typeUtils.d.ts

@@ -4,6 +4,7 @@ import { TypeVarContext, TypeVarSignatureContext } from './typeVarContext';
 export interface ClassMember {
     symbol: Symbol;
     classType: ClassType | UnknownType | AnyType;
+    unspecializedClassType: ClassType | UnknownType | AnyType;
     isInstanceMember: boolean;
     isClassMember: boolean;
     isClassVar: boolean;
@@ -112,7 +113,7 @@ export declare function specializeWithUnknownTypeArgs(type: ClassType): ClassTyp
 export declare function getUnknownTypeForTypeVar(typeVar: TypeVarType): Type;
 export declare function getUnknownTypeForParamSpec(): FunctionType;
 export declare function getUnknownTypeForCallable(): FunctionType;
-export declare function selfSpecializeClass(type: ClassType): ClassType;
+export declare function selfSpecializeClass(type: ClassType, overrideTypeArgs?: boolean): ClassType;
 export declare function getSpecializedTupleType(type: Type): ClassType | undefined;
 export declare function isLiteralType(type: ClassType): boolean;
 export declare function isLiteralTypeOrUnion(type: Type, allowNone?: boolean): boolean;
@@ -172,8 +173,6 @@ export declare function isPartlyUnknown(type: Type, recursionCount?: number): bo
 export declare function explodeGenericClass(classType: ClassType): Type;
 export declare function combineSameSizedTuples(type: Type, tupleType: Type | undefined): Type;
 export declare function specializeTupleClass(classType: ClassType, typeArgs: TupleTypeArgument[], isTypeArgumentExplicit?: boolean, isUnpackedTuple?: boolean): ClassType;
-export declare function removeParamSpecVariadicsFromSignature(type: FunctionType | OverloadedFunctionType): FunctionType | OverloadedFunctionType;
-export declare function removeParamSpecVariadicsFromFunction(type: FunctionType): FunctionType;
 export declare function getGeneratorTypeArgs(returnType: Type): Type[] | undefined;
 export declare function requiresTypeArguments(classType: ClassType): boolean;
 export declare function requiresSpecialization(type: Type, options?: RequiresSpecializationOptions, recursionCount?: number): boolean;
@@ -182,4 +181,4 @@ export declare function isVarianceOfTypeArgumentCompatible(type: Type, typeParam
 export declare function computeMroLinearization(classType: ClassType): boolean;
 export declare function getDeclaringModulesForType(type: Type): string[];
 export declare function convertTypeToParamSpecValue(type: Type): FunctionType;
-export declare function convertParamSpecValueToType(paramSpecValue: FunctionType, omitParamSpec?: boolean): Type;
+export declare function convertParamSpecValueToType(type: FunctionType): Type;

package/dist/analyzer/typeUtils.js

@@ -9,8 +9,8 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isTupleClass = 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.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.isBuiltInDeprecatedType = exports.isTypeVarSame = exports.isIncompleteUnknown = exports.removeNoneFromUnion = exports.isNoneTypeClass = exports.isNoneInstance = exports.isOptionalType = exports.UniqueSignatureTracker = exports.AssignTypeFlags = exports.ClassIteratorFlags = exports.MemberAccessFlags = void 0;
-exports.requiresSpecialization = exports.requiresTypeArguments = exports.getGeneratorTypeArgs = exports.removeParamSpecVariadicsFromFunction = exports.removeParamSpecVariadicsFromSignature = 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 = void 0;
-exports.convertParamSpecValueToType = exports.convertTypeToParamSpecValue = exports.getDeclaringModulesForType = exports.computeMroLinearization = exports.isVarianceOfTypeArgumentCompatible = exports.combineVariances = void 0;
+exports.isVarianceOfTypeArgumentCompatible = 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 = void 0;
+exports.convertParamSpecValueToType = exports.convertTypeToParamSpecValue = exports.getDeclaringModulesForType = exports.computeMroLinearization = void 0;
 const collectionUtils_1 = require("../common/collectionUtils");
 const debug_1 = require("../common/debug");
 const symbol_1 = require("./symbol");
@@ -431,7 +431,7 @@ function compareTypes(a, b, recursionCount = 0) {
                     return typeComparison;
                 }
             }
-            const returnTypeComparison = compareTypes((_a = types_1.FunctionType.getSpecializedReturnType(a)) !== null && _a !== void 0 ? _a : types_1.UnknownType.create(), (_b = types_1.FunctionType.getSpecializedReturnType(bFunc)) !== null && _b !== void 0 ? _b : types_1.UnknownType.create());
+            const returnTypeComparison = compareTypes((_a = types_1.FunctionType.getEffectiveReturnType(a)) !== null && _a !== void 0 ? _a : types_1.UnknownType.create(), (_b = types_1.FunctionType.getEffectiveReturnType(bFunc)) !== null && _b !== void 0 ? _b : types_1.UnknownType.create());
             if (returnTypeComparison !== 0) {
                 return returnTypeComparison;
             }
@@ -631,12 +631,12 @@ function derivesFromAnyOrUnknown(type) {
             anyOrUnknown = true;
         }
         else if ((0, types_1.isInstantiableClass)(subtype)) {
-            if (types_1.ClassType.hasUnknownBaseClass(subtype)) {
+            if (types_1.ClassType.derivesFromAnyOrUnknown(subtype)) {
                 anyOrUnknown = true;
             }
         }
         else if ((0, types_1.isClassInstance)(subtype)) {
-            if (types_1.ClassType.hasUnknownBaseClass(subtype)) {
+            if (types_1.ClassType.derivesFromAnyOrUnknown(subtype)) {
                 anyOrUnknown = true;
             }
         }
@@ -829,14 +829,14 @@ function getUnknownTypeForTypeVar(typeVar) {
 exports.getUnknownTypeForTypeVar = getUnknownTypeForTypeVar;
 // Returns the "Unknown" equivalent for a ParamSpec.
 function getUnknownTypeForParamSpec() {
-    const newFunction = types_1.FunctionType.createInstance('', '', '', 65536 /* FunctionTypeFlags.ParamSpecValue */ | 32768 /* FunctionTypeFlags.SkipArgsKwargsCompatibilityCheck */);
+    const newFunction = types_1.FunctionType.createInstance('', '', '', 65536 /* FunctionTypeFlags.ParamSpecValue */ | 32768 /* FunctionTypeFlags.GradualCallableForm */);
     types_1.FunctionType.addDefaultParameters(newFunction);
     return newFunction;
 }
 exports.getUnknownTypeForParamSpec = getUnknownTypeForParamSpec;
 // Returns the equivalent of "Callable[..., Unknown]".
 function getUnknownTypeForCallable() {
-    const newFunction = types_1.FunctionType.createSynthesizedInstance('', 32768 /* FunctionTypeFlags.SkipArgsKwargsCompatibilityCheck */);
+    const newFunction = types_1.FunctionType.createSynthesizedInstance('', 32768 /* FunctionTypeFlags.GradualCallableForm */);
     types_1.FunctionType.addDefaultParameters(newFunction);
     newFunction.details.declaredReturnType = types_1.UnknownType.create();
     return newFunction;
@@ -845,8 +845,11 @@ exports.getUnknownTypeForCallable = getUnknownTypeForCallable;
 // If the class is generic and not already specialized, this function
 // "self specializes" the class, filling in its own type parameters
 // as type arguments.
-function selfSpecializeClass(type) {
-    if (type.details.typeParameters.length === 0 || type.typeArguments) {
+function selfSpecializeClass(type, overrideTypeArgs = false) {
+    if (type.details.typeParameters.length === 0) {
+        return type;
+    }
+    if (type.typeArguments && !overrideTypeArgs) {
         return type;
     }
     return types_1.ClassType.cloneForSpecialization(type, type.details.typeParameters, /* isTypeArgumentExplicit */ true);
@@ -1236,6 +1239,7 @@ function getProtocolSymbolsRecursive(classType, symbolMap, classFlags = 16384 /*
             symbolMap.set(name, {
                 symbol,
                 classType,
+                unspecializedClassType: classType,
                 isInstanceMember: symbol.isInstanceMember(),
                 isClassMember: symbol.isClassMember(),
                 isClassVar: (0, symbolUtils_1.isEffectivelyClassVar)(symbol, /* isDataclass */ false),
@@ -1343,6 +1347,7 @@ function* getClassMemberIterator(classType, memberName, flags = 0 /* MemberAcces
         for (const [mroClass, specializedMroClass] of classItr) {
             if (!(0, types_1.isInstantiableClass)(mroClass)) {
                 if (!declaredTypesOnly) {
+                    const classType = (0, types_1.isAnyOrUnknown)(mroClass) ? mroClass : types_1.UnknownType.create();
                     // The class derives from an unknown type, so all bets are off
                     // when trying to find a member. Return an unknown symbol.
                     const cm = {
@@ -1350,7 +1355,8 @@ function* getClassMemberIterator(classType, memberName, flags = 0 /* MemberAcces
                         isInstanceMember: false,
                         isClassMember: true,
                         isClassVar: false,
-                        classType: (0, types_1.isAnyOrUnknown)(mroClass) ? mroClass : types_1.UnknownType.create(),
+                        classType,
+                        unspecializedClassType: classType,
                         isTypeDeclared: false,
                         skippedUndeclaredType: false,
                     };
@@ -1374,6 +1380,7 @@ function* getClassMemberIterator(classType, memberName, flags = 0 /* MemberAcces
                             isClassMember: symbol.isClassMember(),
                             isClassVar: (0, symbolUtils_1.isEffectivelyClassVar)(symbol, types_1.ClassType.isDataClass(specializedMroClass)),
                             classType: specializedMroClass,
+                            unspecializedClassType: mroClass,
                             isTypeDeclared: hasDeclaredType,
                             skippedUndeclaredType,
                         };
@@ -1412,6 +1419,7 @@ function* getClassMemberIterator(classType, memberName, flags = 0 /* MemberAcces
                             isClassMember,
                             isClassVar: (0, symbolUtils_1.isEffectivelyClassVar)(symbol, isDataclass),
                             classType: specializedMroClass,
+                            unspecializedClassType: mroClass,
                             isTypeDeclared: hasDeclaredType,
                             skippedUndeclaredType,
                         };
@@ -1433,6 +1441,7 @@ function* getClassMemberIterator(classType, memberName, flags = 0 /* MemberAcces
             isClassMember: true,
             isClassVar: false,
             classType,
+            unspecializedClassType: classType,
             isTypeDeclared: false,
             skippedUndeclaredType: false,
         };
@@ -1496,6 +1505,7 @@ function getClassFieldsRecursive(classType) {
                 if (!symbol.isIgnoredForProtocolMatch() && symbol.hasTypedDeclarations()) {
                     memberMap.set(name, {
                         classType: specializedMroClass,
+                        unspecializedClassType: mroClass,
                         symbol,
                         isInstanceMember: symbol.isInstanceMember(),
                         isClassMember: symbol.isClassMember(),
@@ -1553,7 +1563,7 @@ function getTypeVarArgumentsRecursive(type, recursionCount = 0) {
         }
         // Don't return any P.args or P.kwargs types.
         if ((0, types_1.isParamSpec)(type) && type.paramSpecAccess) {
-            return [];
+            return [types_1.TypeVarType.cloneForParamSpecAccess(type, /* access */ undefined)];
         }
         return [types_1.TypeBase.isInstantiable(type) ? types_1.TypeVarType.cloneAsInstance(type) : type];
     }
@@ -1579,10 +1589,7 @@ function getTypeVarArgumentsRecursive(type, recursionCount = 0) {
         for (let i = 0; i < type.details.parameters.length; i++) {
             addTypeVarsToListIfUnique(combinedList, getTypeVarArgumentsRecursive(types_1.FunctionType.getEffectiveParameterType(type, i), recursionCount));
         }
-        if (type.details.paramSpec) {
-            addTypeVarsToListIfUnique(combinedList, [type.details.paramSpec]);
-        }
-        const returnType = types_1.FunctionType.getSpecializedReturnType(type);
+        const returnType = types_1.FunctionType.getEffectiveReturnType(type);
         if (returnType) {
             addTypeVarsToListIfUnique(combinedList, getTypeVarArgumentsRecursive(returnType, recursionCount));
         }
@@ -1647,12 +1654,6 @@ function setTypeArgumentsRecursive(destType, srcType, typeVarContext, recursionC
                     setTypeArgumentsRecursive(destType.details.declaredReturnType, srcType, typeVarContext, recursionCount);
                 }
             }
-            if (destType.details.paramSpec) {
-                // Fill in an empty signature for a ParamSpec.
-                if (!typeVarContext.getPrimarySignature().getTypeVar(destType.details.paramSpec)) {
-                    typeVarContext.setTypeVarType(destType.details.paramSpec, getUnknownTypeForParamSpec());
-                }
-            }
             break;
         case 5 /* TypeCategory.OverloadedFunction */:
             destType.overloads.forEach((subtype) => {
@@ -1674,7 +1675,7 @@ exports.setTypeArgumentsRecursive = setTypeArgumentsRecursive;
 function buildTypeVarContextFromSpecializedClass(classType) {
     const typeParameters = types_1.ClassType.getTypeParameters(classType);
     const typeVarContext = buildTypeVarContext(typeParameters, classType.typeArguments, getTypeVarScopeId(classType));
-    if (types_1.ClassType.isTupleClass(classType) && classType.tupleTypeArguments && typeParameters.length >= 1) {
+    if (types_1.ClassType.isTupleClass(classType) && classType.tupleTypeArguments) {
         typeVarContext.setTupleTypeVar(typeParameters[0], classType.tupleTypeArguments);
     }
     return typeVarContext;
@@ -1780,7 +1781,7 @@ exports.synthesizeTypeVarForSelfCls = synthesizeTypeVarForSelfCls;
 // Returns the declared "return" type (the type returned from a return statement)
 // if it was declared, or undefined otherwise.
 function getDeclaredGeneratorReturnType(functionType) {
-    const returnType = types_1.FunctionType.getSpecializedReturnType(functionType);
+    const returnType = types_1.FunctionType.getEffectiveReturnType(functionType);
     if (returnType) {
         const generatorTypeArgs = getGeneratorTypeArgs(returnType);
         if (generatorTypeArgs) {
@@ -2056,7 +2057,7 @@ function containsAnyOrUnknown(type, recurse) {
         visitFunction(type) {
             if (this._recurse) {
                 // A function with a "..." type is effectively an "Any".
-                if (types_1.FunctionType.shouldSkipArgsKwargsCompatibilityCheck(type)) {
+                if (types_1.FunctionType.isGradualCallableForm(type)) {
                     this.anyOrUnknownType = this.anyOrUnknownType
                         ? preserveUnknown(this.anyOrUnknownType, types_1.AnyType.create())
                         : types_1.AnyType.create();
@@ -2221,42 +2222,6 @@ function specializeTupleClass(classType, typeArgs, isTypeArgumentExplicit = true
     return clonedClassType;
 }
 exports.specializeTupleClass = specializeTupleClass;
-// If the type is a function or overloaded function that has a paramSpec
-// associated with it and P.args and P.kwargs at the end of the signature,
-// it removes these parameters from the function.
-function removeParamSpecVariadicsFromSignature(type) {
-    if ((0, types_1.isFunction)(type)) {
-        return removeParamSpecVariadicsFromFunction(type);
-    }
-    const newOverloads = [];
-    let newTypeNeeded = false;
-    for (const overload of type.overloads) {
-        const newOverload = removeParamSpecVariadicsFromFunction(overload);
-        newOverloads.push(newOverload);
-        if (newOverload !== overload) {
-            newTypeNeeded = true;
-        }
-    }
-    return newTypeNeeded ? types_1.OverloadedFunctionType.create(newOverloads) : type;
-}
-exports.removeParamSpecVariadicsFromSignature = removeParamSpecVariadicsFromSignature;
-function removeParamSpecVariadicsFromFunction(type) {
-    const paramCount = type.details.parameters.length;
-    if (paramCount < 2) {
-        return type;
-    }
-    const argsParam = type.details.parameters[paramCount - 2];
-    const kwargsParam = type.details.parameters[paramCount - 1];
-    if (argsParam.category !== 1 /* ParameterCategory.ArgsList */ ||
-        kwargsParam.category !== 2 /* ParameterCategory.KwargsDict */ ||
-        !(0, types_1.isParamSpec)(argsParam.type) ||
-        !(0, types_1.isParamSpec)(kwargsParam.type) ||
-        !(0, types_1.isTypeSame)(argsParam.type, kwargsParam.type)) {
-        return type;
-    }
-    return types_1.FunctionType.cloneRemoveParamSpecVariadics(type, types_1.TypeVarType.cloneForParamSpecAccess(argsParam.type, /* access */ undefined));
-}
-exports.removeParamSpecVariadicsFromFunction = removeParamSpecVariadicsFromFunction;
 function _expandVariadicUnpackedUnion(type) {
     if ((0, types_1.isClassInstance)(type) && isTupleClass(type) && type.tupleTypeArguments && type.isUnpacked) {
         return (0, types_1.combineTypes)(type.tupleTypeArguments.map((t) => t.type));
@@ -2359,9 +2324,6 @@ function _requiresSpecialization(type, options, recursionCount = 0) {
             return types_1.ClassType.getTypeParameters(type).length > 0;
         }
         case 4 /* TypeCategory.Function */: {
-            if (type.details.paramSpec) {
-                return true;
-            }
             for (let i = 0; i < type.details.parameters.length; i++) {
                 if (requiresSpecialization(types_1.FunctionType.getEffectiveParameterType(type, i), options, recursionCount)) {
                     return true;
@@ -2519,7 +2481,9 @@ function computeMroLinearization(classType) {
     }));
     // The first class in the MRO is the class itself.
     const typeVarContext = buildTypeVarContextFromSpecializedClass(classType);
-    classType.details.mro.push(applySolvedTypeVars(classType, typeVarContext));
+    const specializedClassType = applySolvedTypeVars(classType, typeVarContext);
+    (0, debug_1.assert)((0, types_1.isClass)(specializedClassType) || (0, types_1.isAny)(specializedClassType) || (0, types_1.isUnknown)(specializedClassType));
+    classType.details.mro.push(specializedClassType);
     // Helper function that returns true if the specified searchClass
     // is found in the "tail" (i.e. in elements 1 through n) of any
     // of the class lists.
@@ -2549,6 +2513,7 @@ function computeMroLinearization(classType) {
                 }
                 if (!(0, types_1.isInstantiableClass)(classList[0])) {
                     foundValidHead = true;
+                    (0, debug_1.assert)((0, types_1.isClass)(classList[0]) || (0, types_1.isAnyOrUnknown)(classList[0]));
                     classType.details.mro.push(classList[0]);
                     classList.shift();
                     break;
@@ -2573,6 +2538,7 @@ function computeMroLinearization(classType) {
             // Handle the situation by pull the head off the first empty list.
             // This allows us to make forward progress.
             if (!(0, types_1.isInstantiableClass)(nonEmptyList[0])) {
+                (0, debug_1.assert)((0, types_1.isClass)(nonEmptyList[0]) || (0, types_1.isAnyOrUnknown)(nonEmptyList[0]));
                 classType.details.mro.push(nonEmptyList[0]);
                 nonEmptyList.shift();
             }
@@ -2631,10 +2597,13 @@ function addDeclaringModuleNamesForType(type, moduleList, recursionCount = 0) {
         }
     }
 }
+// Converts a function into a FunctionType that represents the function's
+// input signature and converts a ParamSpec into a FunctionType with the input
+// signature (*args: P.args, **kwargs: P.kwargs).
 function convertTypeToParamSpecValue(type) {
     if ((0, types_1.isParamSpec)(type)) {
         const newFunction = types_1.FunctionType.createInstance('', '', '', 65536 /* FunctionTypeFlags.ParamSpecValue */);
-        newFunction.details.paramSpec = type;
+        types_1.FunctionType.addParamSpecVariadics(newFunction, type);
         newFunction.details.typeVarScopeId = getTypeVarScopeId(type);
         return newFunction;
     }
@@ -2655,45 +2624,51 @@ function convertTypeToParamSpecValue(type) {
             newFunction.details.higherOrderTypeVarScopeIds = [...type.details.higherOrderTypeVarScopeIds];
             newFunction.details.typeVarScopeId = newFunction.details.higherOrderTypeVarScopeIds.pop();
         }
-        newFunction.details.paramSpec = type.details.paramSpec;
         return newFunction;
     }
     return getUnknownTypeForParamSpec();
 }
 exports.convertTypeToParamSpecValue = convertTypeToParamSpecValue;
-function convertParamSpecValueToType(paramSpecValue, omitParamSpec = false) {
-    let hasParameters = paramSpecValue.details.parameters.length > 0;
-    if (paramSpecValue.details.parameters.length === 1) {
+// 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.details.parameters.length > 0;
+    if (withoutParamSpec.details.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 = paramSpecValue.details.parameters[0];
+        const onlyParam = withoutParamSpec.details.parameters[0];
         if ((0, types_1.isPositionOnlySeparator)(onlyParam)) {
             hasParameters = false;
         }
     }
-    if (hasParameters || !paramSpecValue.details.paramSpec || omitParamSpec) {
-        // Create a function type from the param spec entries.
-        const functionType = types_1.FunctionType.createInstance('', '', '', 65536 /* FunctionTypeFlags.ParamSpecValue */ | paramSpecValue.details.flags);
-        types_1.FunctionType.addHigherOrderTypeVarScopeIds(functionType, paramSpecValue.details.typeVarScopeId);
-        paramSpecValue.details.parameters.forEach((entry) => {
-            types_1.FunctionType.addParameter(functionType, {
-                category: entry.category,
-                name: entry.name,
-                hasDefault: entry.hasDefault,
-                defaultValueExpression: entry.defaultValueExpression,
-                isNameSynthesized: entry.isNameSynthesized,
-                hasDeclaredType: true,
-                type: entry.type,
-            });
+    // Can we simplify it to just a paramSpec?
+    if (!hasParameters && paramSpec) {
+        return paramSpec;
+    }
+    // Create a function type from the param spec entries.
+    const functionType = types_1.FunctionType.createInstance('', '', '', 65536 /* FunctionTypeFlags.ParamSpecValue */ | withoutParamSpec.details.flags);
+    types_1.FunctionType.addHigherOrderTypeVarScopeIds(functionType, withoutParamSpec.details.typeVarScopeId);
+    types_1.FunctionType.addHigherOrderTypeVarScopeIds(functionType, withoutParamSpec.details.higherOrderTypeVarScopeIds);
+    withoutParamSpec.details.parameters.forEach((entry) => {
+        types_1.FunctionType.addParameter(functionType, {
+            category: entry.category,
+            name: entry.name,
+            hasDefault: entry.hasDefault,
+            defaultValueExpression: entry.defaultValueExpression,
+            isNameSynthesized: entry.isNameSynthesized,
+            hasDeclaredType: true,
+            type: entry.type,
         });
-        if (!omitParamSpec) {
-            functionType.details.paramSpec = paramSpecValue.details.paramSpec;
-        }
-        functionType.details.docString = paramSpecValue.details.docString;
-        functionType.details.deprecatedMessage = paramSpecValue.details.deprecatedMessage;
-        return functionType;
+    });
+    if (paramSpec) {
+        types_1.FunctionType.addParamSpecVariadics(functionType, paramSpec);
     }
-    return paramSpecValue.details.paramSpec;
+    functionType.details.docString = withoutParamSpec.details.docString;
+    functionType.details.deprecatedMessage = withoutParamSpec.details.deprecatedMessage;
+    functionType.details.methodClass = withoutParamSpec.details.methodClass;
+    return functionType;
 }
 exports.convertParamSpecValueToType = convertParamSpecValueToType;
 // Recursively walks a type and calls a callback for each TypeVar, allowing
@@ -2929,11 +2904,19 @@ class TypeVarTransformer {
                         (0, collectionUtils_1.appendArray)(newTupleTypeArgs, newTypeArgType.tupleTypeArguments);
                     }
                     else {
-                        newTupleTypeArgs.push({
-                            type: newTypeArgType,
-                            isUnbounded: oldTypeArgType.isUnbounded,
-                            isOptional: oldTypeArgType.isOptional,
-                        });
+                        // Handle the special case where tuple[T, ...] is being specialized
+                        // to tuple[Never, ...]. This is equivalent to tuple[()].
+                        const isEmptyTuple = oldTypeArgType.isUnbounded &&
+                            (0, types_1.isTypeVar)(oldTypeArgType.type) &&
+                            (0, types_1.isNever)(newTypeArgType) &&
+                            classType.tupleTypeArguments.length === 1;
+                        if (!isEmptyTuple) {
+                            newTupleTypeArgs.push({
+                                type: newTypeArgType,
+                                isUnbounded: oldTypeArgType.isUnbounded,
+                                isOptional: oldTypeArgType.isOptional,
+                            });
+                        }
                     }
                 });
             }
@@ -3020,14 +3003,7 @@ class TypeVarTransformer {
     transformTypeVarsInFunctionType(sourceType, recursionCount) {
         return this.doForEachSignatureContext(() => {
             let functionType = sourceType;
-            // Handle functions with a parameter specification in a special manner.
-            if (functionType.details.paramSpec) {
-                const paramSpec = this.transformParamSpec(functionType.details.paramSpec, recursionCount);
-                if (paramSpec) {
-                    functionType = types_1.FunctionType.cloneForParamSpec(functionType, paramSpec);
-                }
-            }
-            const declaredReturnType = types_1.FunctionType.getSpecializedReturnType(functionType);
+            const declaredReturnType = types_1.FunctionType.getEffectiveReturnType(functionType);
             const specializedReturnType = declaredReturnType
                 ? this.apply(declaredReturnType, recursionCount)
                 : undefined;
@@ -3036,26 +3012,15 @@ class TypeVarTransformer {
                 parameterTypes: [],
                 returnType: specializedReturnType,
             };
-            // Does this function end with *args: P.args, **args: P.kwargs? If so, we'll
-            // modify the function and replace these parameters with the signature captured
-            // by the ParamSpec.
-            if (functionType.details.parameters.length >= 2) {
-                const argsParam = functionType.details.parameters[functionType.details.parameters.length - 2];
-                const kwargsParam = functionType.details.parameters[functionType.details.parameters.length - 1];
-                const argsParamType = types_1.FunctionType.getEffectiveParameterType(functionType, functionType.details.parameters.length - 2);
-                const kwargsParamType = types_1.FunctionType.getEffectiveParameterType(functionType, functionType.details.parameters.length - 1);
-                if (argsParam.category === 1 /* ParameterCategory.ArgsList */ &&
-                    kwargsParam.category === 2 /* ParameterCategory.KwargsDict */ &&
-                    (0, types_1.isParamSpec)(argsParamType) &&
-                    (0, types_1.isParamSpec)(kwargsParamType) &&
-                    (0, types_1.isTypeSame)(argsParamType, kwargsParamType)) {
-                    const paramSpecType = this.transformParamSpec(argsParamType, recursionCount);
-                    if (paramSpecType) {
-                        if (paramSpecType.details.parameters.length > 0 ||
-                            paramSpecType.details.paramSpec === undefined ||
-                            !(0, types_1.isTypeSame)(argsParamType, paramSpecType.details.paramSpec)) {
-                            functionType = types_1.FunctionType.cloneForParamSpecApplication(functionType, paramSpecType);
-                        }
+            const paramSpec = types_1.FunctionType.getParamSpecFromArgsKwargs(functionType);
+            if (paramSpec) {
+                const paramSpecType = this.transformParamSpec(paramSpec, recursionCount);
+                if (paramSpecType) {
+                    const transformedParamSpec = types_1.FunctionType.getParamSpecFromArgsKwargs(paramSpecType);
+                    if (paramSpecType.details.parameters.length > 0 ||
+                        !transformedParamSpec ||
+                        !(0, types_1.isTypeSame)(paramSpec, transformedParamSpec)) {
+                        functionType = types_1.FunctionType.applyParamSpecValue(functionType, paramSpecType);
                     }
                 }
             }