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

package/dist/analyzer/types.d.ts

@@ -184,7 +184,7 @@ interface ClassDetails {
     flags: ClassTypeFlags;
     typeSourceId: TypeSourceId;
     baseClasses: Type[];
-    mro: Type[];
+    mro: (ClassType | AnyType | UnknownType)[];
     declaration?: ClassDeclaration | SpecialBuiltInClassDeclaration | undefined;
     declaredMetaclass?: ClassType | UnknownType | undefined;
     effectiveMetaclass?: ClassType | UnknownType | undefined;
@@ -257,7 +257,6 @@ export declare namespace ClassType {
     function isUnspecialized(classType: ClassType): boolean;
     function isSpecialBuiltIn(classType: ClassType, className?: string): boolean;
     function isBuiltIn(classType: ClassType, className?: string | string[]): boolean;
-    function derivesFromAnyOrUnknown(classType: ClassType): boolean;
     function supportsAbstractMethods(classType: ClassType): boolean;
     function isDataClass(classType: ClassType): boolean;
     function isSkipSynthesizedDataClassInit(classType: ClassType): boolean;
@@ -290,13 +289,13 @@ export declare namespace ClassType {
     function isTupleClass(classType: ClassType): boolean;
     function isReadOnlyInstanceVariables(classType: ClassType): boolean;
     function getTypeParameters(classType: ClassType): TypeVarType[];
-    function hasUnknownBaseClass(classType: ClassType): boolean;
+    function derivesFromAnyOrUnknown(classType: ClassType): boolean;
     function getSymbolTable(classType: ClassType): SymbolTable;
     function getInheritedSlotsNames(classType: ClassType): string[] | undefined;
     function isHierarchyPartiallyEvaluated(classType: ClassType): boolean;
     function isSameGenericClass(classType: ClassType, type2: ClassType, recursionCount?: number): boolean;
     function isDerivedFrom(subclassType: ClassType, parentClassType: ClassType, inheritanceChain?: InheritanceChain): boolean;
-    function getReverseMro(classType: ClassType): Type[];
+    function getReverseMro(classType: ClassType): (ClassType | UnknownType | AnyType)[];
 }
 export interface FunctionParameter {
     category: ParameterCategory;
@@ -328,7 +327,7 @@ export declare const enum FunctionTypeFlags {
     PyTypedDefinition = 4096,
     Final = 8192,
     UnannotatedParams = 16384,
-    SkipArgsKwargsCompatibilityCheck = 32768,
+    GradualCallableForm = 32768,
     ParamSpecValue = 65536,
     PartiallyEvaluated = 131072,
     Overridden = 262144,
@@ -349,7 +348,6 @@ interface FunctionDetails {
     deprecatedMessage?: string | undefined;
     methodClass?: ClassType | undefined;
     decoratorDataClassBehaviors?: DataClassBehaviors | undefined;
-    paramSpec?: TypeVarType | undefined;
     constructorTypeVarScopeId?: TypeVarScopeId | undefined;
     higherOrderTypeVarScopeIds?: TypeVarScopeId[];
 }
@@ -388,14 +386,15 @@ export declare namespace FunctionType {
     function cloneAsInstance(type: FunctionType): FunctionType;
     function cloneAsInstantiable(type: FunctionType): FunctionType;
     function cloneForSpecialization(type: FunctionType, specializedTypes: SpecializedFunctionTypes, specializedInferredReturnType: Type | undefined): FunctionType;
-    function cloneForParamSpec(type: FunctionType, paramSpecValue: FunctionType | undefined): FunctionType;
+    function applyParamSpecValue(type: FunctionType, paramSpecValue: FunctionType): FunctionType;
     function cloneWithNewFlags(type: FunctionType, flags: FunctionTypeFlags): FunctionType;
     function cloneWithNewTypeVarScopeId(type: FunctionType, newScopeId: TypeVarScopeId, typeParameters: TypeVarType[], trackedSignatures?: SignatureWithOffsets[]): FunctionType;
     function cloneWithDocString(type: FunctionType, docString?: string): FunctionType;
     function cloneWithDeprecatedMessage(type: FunctionType, deprecatedMessage?: string): FunctionType;
-    function cloneForParamSpecApplication(type: FunctionType, paramSpecValue: FunctionType): FunctionType;
-    function cloneRemoveParamSpecVariadics(type: FunctionType, paramSpec: TypeVarType): FunctionType;
-    function addDefaultParameters(functionType: FunctionType, useUnknown?: boolean): void;
+    function cloneRemoveParamSpecArgsKwargs(type: FunctionType, stripPositionOnlySeparator?: boolean): FunctionType;
+    function getParamSpecFromArgsKwargs(type: FunctionType): TypeVarType | undefined;
+    function addParamSpecVariadics(type: FunctionType, paramSpec: TypeVarType): void;
+    function addDefaultParameters(type: FunctionType, useUnknown?: boolean): void;
     function addHigherOrderTypeVarScopeIds(functionType: FunctionType, scopeIds: (TypeVarScopeId | undefined)[] | TypeVarScopeId | undefined): void;
     function getDefaultParameters(useUnknown?: boolean): FunctionParameter[];
     function hasDefaultParameters(functionType: FunctionType): boolean;
@@ -414,7 +413,7 @@ export declare namespace FunctionType {
     function isPyTypedDefinition(type: FunctionType): boolean;
     function isFinal(type: FunctionType): boolean;
     function hasUnannotatedParams(type: FunctionType): boolean;
-    function shouldSkipArgsKwargsCompatibilityCheck(type: FunctionType): boolean;
+    function isGradualCallableForm(type: FunctionType): boolean;
     function isParamSpecValue(type: FunctionType): boolean;
     function isPartiallyEvaluated(type: FunctionType): boolean;
     function isOverridden(type: FunctionType): boolean;
@@ -423,7 +422,7 @@ export declare namespace FunctionType {
     function addParameter(type: FunctionType, param: FunctionParameter): void;
     function addPositionOnlyParameterSeparator(type: FunctionType): void;
     function addKeywordOnlyParameterSeparator(type: FunctionType): void;
-    function getSpecializedReturnType(type: FunctionType, includeInferred?: boolean): Type | undefined;
+    function getEffectiveReturnType(type: FunctionType, includeInferred?: boolean): Type | undefined;
 }
 export interface OverloadedFunctionType extends TypeBase {
     category: TypeCategory.OverloadedFunction;

package/dist/analyzer/types.js

@@ -427,11 +427,7 @@ var ClassType;
         if (includeSubclasses) {
             newClassType.includeSubclasses = true;
         }
-        newClassType.tupleTypeArguments = tupleTypeArguments
-            ? tupleTypeArguments.map((t) => isNever(t.type)
-                ? { type: UnknownType.create(), isUnbounded: t.isUnbounded, isOptional: t.isOptional }
-                : t)
-            : undefined;
+        newClassType.tupleTypeArguments = tupleTypeArguments === null || tupleTypeArguments === void 0 ? void 0 : tupleTypeArguments.map((t) => isNever(t.type) ? { type: UnknownType.create(), isUnbounded: t.isUnbounded, isOptional: t.isOptional } : t);
         if (isEmptyContainer !== undefined) {
             newClassType.isEmptyContainer = isEmptyContainer;
         }
@@ -609,10 +605,6 @@ var ClassType;
         return true;
     }
     ClassType.isBuiltIn = isBuiltIn;
-    function derivesFromAnyOrUnknown(classType) {
-        return classType.details.mro.some((mroClass) => !isClass(mroClass));
-    }
-    ClassType.derivesFromAnyOrUnknown = derivesFromAnyOrUnknown;
     function supportsAbstractMethods(classType) {
         return !!(classType.details.flags & 2048 /* ClassTypeFlags.SupportsAbstractMethods */);
     }
@@ -743,10 +735,10 @@ var ClassType;
         return classType.details.typeParameters;
     }
     ClassType.getTypeParameters = getTypeParameters;
-    function hasUnknownBaseClass(classType) {
+    function derivesFromAnyOrUnknown(classType) {
         return classType.details.mro.some((baseClass) => isAnyOrUnknown(baseClass));
     }
-    ClassType.hasUnknownBaseClass = hasUnknownBaseClass;
+    ClassType.derivesFromAnyOrUnknown = derivesFromAnyOrUnknown;
     function getSymbolTable(classType) {
         var _a, _b;
         (_b = (_a = classType.details).synthesizeMethodsDeferred) === null || _b === void 0 ? void 0 : _b.call(_a);
@@ -933,7 +925,7 @@ var FunctionTypeFlags;
     // The *args and **kwargs parameters do not need to be present for this
     // function to be compatible. This is used for Callable[..., x] and
     // ... type arguments to ParamSpec and Concatenate.
-    FunctionTypeFlags[FunctionTypeFlags["SkipArgsKwargsCompatibilityCheck"] = 32768] = "SkipArgsKwargsCompatibilityCheck";
+    FunctionTypeFlags[FunctionTypeFlags["GradualCallableForm"] = 32768] = "GradualCallableForm";
     // This function represents the value bound to a ParamSpec, so its return
     // type is not meaningful.
     FunctionTypeFlags[FunctionTypeFlags["ParamSpecValue"] = 65536] = "ParamSpecValue";
@@ -1061,89 +1053,70 @@ var FunctionType;
     }
     FunctionType.cloneForSpecialization = cloneForSpecialization;
     // Creates a new function based on the parameters of another function.
-    function cloneForParamSpec(type, paramSpecValue) {
-        const newFunction = create(type.details.name, type.details.fullName, type.details.moduleName, type.details.flags, type.flags, type.details.docString);
+    function applyParamSpecValue(type, paramSpecValue) {
+        const hasPositionalOnly = paramSpecValue.details.parameters.some((param) => isPositionOnlySeparator(param));
+        const newFunction = FunctionType.cloneRemoveParamSpecArgsKwargs(TypeBase.cloneType(type), hasPositionalOnly);
+        const paramSpec = FunctionType.getParamSpecFromArgsKwargs(type);
+        (0, debug_1.assert)(paramSpec !== undefined);
         // Make a shallow clone of the details.
-        newFunction.details = { ...type.details };
-        newFunction.details.typeParameters = newFunction.details.typeParameters.filter((t) => !newFunction.details.paramSpec || !isTypeSame(t, newFunction.details.paramSpec));
-        // The clone should no longer have a parameter specification
-        // since we're replacing it.
-        delete newFunction.details.paramSpec;
-        if (paramSpecValue) {
-            const typeParameters = Array.from(type.details.parameters);
-            let droppedLastParam = false;
-            // If the paramSpec includes a position-only separator
-            // and the existing function ends on a position-only separator,
-            // we need to remove the latter in favor of the former.
-            if (paramSpecValue.details.parameters.some((param) => isPositionOnlySeparator(param))) {
-                if (typeParameters.length > 0 && isPositionOnlySeparator(typeParameters[typeParameters.length - 1])) {
-                    typeParameters.pop();
-                    droppedLastParam = true;
-                }
-            }
-            newFunction.details.parameters = [
-                ...typeParameters,
-                ...paramSpecValue.details.parameters.map((param) => {
-                    return {
-                        category: param.category,
-                        name: param.name,
-                        hasDefault: param.hasDefault,
-                        defaultValueExpression: param.defaultValueExpression,
-                        isNameSynthesized: param.isNameSynthesized,
-                        hasDeclaredType: true,
-                        type: param.type,
-                    };
-                }),
-            ];
-            if (newFunction.details.docString === undefined) {
-                newFunction.details.docString = paramSpecValue.details.docString;
-            }
-            if (newFunction.details.deprecatedMessage === undefined) {
-                newFunction.details.deprecatedMessage = paramSpecValue.details.deprecatedMessage;
-            }
-            newFunction.details.flags =
-                (paramSpecValue.details.flags &
-                    (2 /* FunctionTypeFlags.ClassMethod */ |
-                        4 /* FunctionTypeFlags.StaticMethod */ |
-                        1 /* FunctionTypeFlags.ConstructorMethod */ |
-                        256 /* FunctionTypeFlags.Overloaded */ |
-                        32768 /* FunctionTypeFlags.SkipArgsKwargsCompatibilityCheck */)) |
-                    64 /* FunctionTypeFlags.SynthesizedMethod */;
-            if (FunctionType.isParamSpecValue(type)) {
-                newFunction.details.flags |= 65536 /* FunctionTypeFlags.ParamSpecValue */;
-            }
-            // Update the specialized parameter types as well.
-            if (type.specializedTypes) {
-                newFunction.specializedTypes = {
-                    parameterTypes: Array.from(type.specializedTypes.parameterTypes),
-                    returnType: type.specializedTypes.returnType,
+        newFunction.details = { ...newFunction.details };
+        newFunction.details.typeParameters = newFunction.details.typeParameters.filter((t) => !isTypeSame(t, paramSpec));
+        const prevParams = Array.from(newFunction.details.parameters);
+        newFunction.details.parameters = [
+            ...prevParams,
+            ...paramSpecValue.details.parameters.map((param) => {
+                return {
+                    category: param.category,
+                    name: param.name,
+                    hasDefault: param.hasDefault,
+                    defaultValueExpression: param.defaultValueExpression,
+                    isNameSynthesized: param.isNameSynthesized,
+                    hasDeclaredType: true,
+                    type: param.type,
                 };
-                if (droppedLastParam) {
-                    newFunction.specializedTypes.parameterTypes.pop();
-                }
-                if (type.specializedTypes.parameterDefaultArgs) {
-                    newFunction.specializedTypes.parameterDefaultArgs = Array.from(type.specializedTypes.parameterDefaultArgs);
-                    if (droppedLastParam) {
-                        newFunction.specializedTypes.parameterDefaultArgs.pop();
-                    }
-                }
-                paramSpecValue.details.parameters.forEach((paramInfo) => {
-                    newFunction.specializedTypes.parameterTypes.push(paramInfo.type);
-                    if (newFunction.specializedTypes.parameterDefaultArgs) {
-                        // Assume that the parameters introduced via paramSpec have no specialized
-                        // default arg types. Fall back on the original default arg type in this case.
-                        newFunction.specializedTypes.parameterDefaultArgs.push(undefined);
-                    }
-                });
-            }
-            FunctionType.addHigherOrderTypeVarScopeIds(newFunction, paramSpecValue.details.typeVarScopeId);
-            FunctionType.addHigherOrderTypeVarScopeIds(newFunction, paramSpecValue.details.higherOrderTypeVarScopeIds);
-            newFunction.details.paramSpec = paramSpecValue.details.paramSpec;
+            }),
+        ];
+        if (newFunction.details.docString === undefined) {
+            newFunction.details.docString = paramSpecValue.details.docString;
+        }
+        if (newFunction.details.deprecatedMessage === undefined) {
+            newFunction.details.deprecatedMessage = paramSpecValue.details.deprecatedMessage;
+        }
+        const origFlagsMask = 256 /* FunctionTypeFlags.Overloaded */ | 65536 /* FunctionTypeFlags.ParamSpecValue */;
+        newFunction.details.flags = type.details.flags & origFlagsMask;
+        const methodFlagsMask = 2 /* FunctionTypeFlags.ClassMethod */ | 4 /* FunctionTypeFlags.StaticMethod */ | 1 /* FunctionTypeFlags.ConstructorMethod */;
+        // If the original function was a method, use its method type. Otherwise
+        // use the method type of the param spec.
+        if (type.details.methodClass) {
+            newFunction.details.flags |= type.details.flags & methodFlagsMask;
+        }
+        else {
+            newFunction.details.flags |= paramSpecValue.details.flags & methodFlagsMask;
+        }
+        // Use the "..." flag from the param spec.
+        newFunction.details.flags |= paramSpecValue.details.flags & 32768 /* FunctionTypeFlags.GradualCallableForm */;
+        // Mark the function as synthesized since there is no user-defined declaration for it.
+        newFunction.details.flags |= 64 /* FunctionTypeFlags.SynthesizedMethod */;
+        delete newFunction.details.declaration;
+        // Update the specialized parameter types as well.
+        const specializedTypes = newFunction.specializedTypes;
+        if (specializedTypes) {
+            paramSpecValue.details.parameters.forEach((paramInfo) => {
+                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);
+            });
+        }
+        FunctionType.addHigherOrderTypeVarScopeIds(newFunction, paramSpecValue.details.typeVarScopeId);
+        FunctionType.addHigherOrderTypeVarScopeIds(newFunction, paramSpecValue.details.higherOrderTypeVarScopeIds);
+        if (!newFunction.details.methodClass && paramSpecValue.details.methodClass) {
             newFunction.details.methodClass = paramSpecValue.details.methodClass;
         }
         return newFunction;
     }
-    FunctionType.cloneForParamSpec = cloneForParamSpec;
+    FunctionType.applyParamSpecValue = applyParamSpecValue;
     function cloneWithNewFlags(type, flags) {
         const newFunction = TypeBase.cloneType(type);
         // Make a shallow clone of the details.
@@ -1179,82 +1152,92 @@ var FunctionType;
         return newFunction;
     }
     FunctionType.cloneWithDeprecatedMessage = cloneWithDeprecatedMessage;
-    // Creates a new function based on a solved ParamSpec. The input type is assumed to
-    // have a signature that ends in "*args: P.args, **kwargs: P.kwargs". These will be
-    // replaced by the parameters in the ParamSpec.
-    function cloneForParamSpecApplication(type, paramSpecValue) {
-        const newFunction = TypeBase.cloneType(type);
-        // Make a shallow clone of the details.
-        newFunction.details = { ...type.details };
-        // Remove the last two parameters, which are the *args and **kwargs.
-        newFunction.details.parameters = newFunction.details.parameters.slice(0, newFunction.details.parameters.length - 2);
-        if (newFunction.specializedTypes) {
-            newFunction.specializedTypes.parameterTypes = newFunction.specializedTypes.parameterTypes.slice(0, newFunction.specializedTypes.parameterTypes.length - 2);
-        }
-        // Update the flags of the function.
-        newFunction.details.flags &= ~32768 /* FunctionTypeFlags.SkipArgsKwargsCompatibilityCheck */;
-        if (paramSpecValue.details.flags & 32768 /* FunctionTypeFlags.SkipArgsKwargsCompatibilityCheck */) {
-            newFunction.details.flags |= 32768 /* FunctionTypeFlags.SkipArgsKwargsCompatibilityCheck */;
-        }
-        // If there is a position-only separator in the captured param spec signature,
-        // remove the position-only separator in the existing signature. Otherwise,
-        // we'll end up with redundant position-only separators.
-        if (paramSpecValue.details.parameters.some((entry) => isPositionOnlySeparator(entry))) {
-            if (newFunction.details.parameters.length > 0) {
-                const lastParam = newFunction.details.parameters[newFunction.details.parameters.length - 1];
-                if (isPositionOnlySeparator(lastParam)) {
-                    newFunction.details.parameters.pop();
-                }
-            }
+    // If the function ends with "*args: P.args, **kwargs: P.kwargs", this function
+    // returns a new function that is a clone of the input function with the
+    // *args and **kwargs parameters removed. If stripPositionOnlySeparator is true,
+    // a trailing positional-only separator will be removed.
+    function cloneRemoveParamSpecArgsKwargs(type, stripPositionOnlySeparator = false) {
+        const paramCount = type.details.parameters.length;
+        if (paramCount < 2) {
+            return type;
         }
-        paramSpecValue.details.parameters.forEach((param) => {
-            newFunction.details.parameters.push({
-                category: param.category,
-                name: param.name,
-                hasDefault: param.hasDefault,
-                defaultValueExpression: param.defaultValueExpression,
-                isNameSynthesized: param.isNameSynthesized,
-                hasDeclaredType: true,
-                type: param.type,
-            });
-        });
-        newFunction.details.paramSpec = paramSpecValue.details.paramSpec;
-        if (!newFunction.details.docString) {
-            newFunction.details.docString = paramSpecValue.details.docString;
+        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 */) {
+            return type;
         }
-        if (!newFunction.details.deprecatedMessage) {
-            newFunction.details.deprecatedMessage = paramSpecValue.details.deprecatedMessage;
+        const argsType = FunctionType.getEffectiveParameterType(type, paramCount - 2);
+        const kwargsType = FunctionType.getEffectiveParameterType(type, paramCount - 1);
+        if (!isParamSpec(argsType) || !isParamSpec(kwargsType) || !isTypeSame(argsType, kwargsType)) {
+            return type;
         }
-        FunctionType.addHigherOrderTypeVarScopeIds(newFunction, paramSpecValue.details.typeVarScopeId);
-        return newFunction;
-    }
-    FunctionType.cloneForParamSpecApplication = cloneForParamSpecApplication;
-    function cloneRemoveParamSpecVariadics(type, paramSpec) {
-        const newFunction = create(type.details.name, type.details.fullName, type.details.moduleName, type.details.flags, type.flags, type.details.docString);
+        const newFunction = TypeBase.cloneType(type);
         // Make a shallow clone of the details.
         newFunction.details = { ...type.details };
-        // Remove the last two parameters, which are the *args and **kwargs.
-        newFunction.details.parameters = newFunction.details.parameters.slice(0, newFunction.details.parameters.length - 2);
+        const details = newFunction.details;
+        let paramsToDrop = 2;
+        // If the last remaining parameter is a position-only separator, remove it as well.
+        // Always remove it if it's the only remaining parameter.
+        if (paramCount >= 3 && isPositionOnlySeparator(details.parameters[paramCount - 3])) {
+            if (paramCount === 3 || stripPositionOnlySeparator) {
+                paramsToDrop = 3;
+            }
+        }
+        // Remove the last parameters, which are the *args and **kwargs.
+        details.parameters = details.parameters.slice(0, details.parameters.length - paramsToDrop);
         if (type.specializedTypes) {
             newFunction.specializedTypes = { ...type.specializedTypes };
-            newFunction.specializedTypes.parameterTypes = newFunction.specializedTypes.parameterTypes.slice(0, newFunction.specializedTypes.parameterTypes.length - 2);
+            newFunction.specializedTypes.parameterTypes = newFunction.specializedTypes.parameterTypes.slice(0, newFunction.specializedTypes.parameterTypes.length - paramsToDrop);
             if (newFunction.specializedTypes.parameterDefaultArgs) {
                 newFunction.specializedTypes.parameterDefaultArgs =
-                    newFunction.specializedTypes.parameterDefaultArgs.slice(0, newFunction.specializedTypes.parameterDefaultArgs.length - 2);
+                    newFunction.specializedTypes.parameterDefaultArgs.slice(0, newFunction.specializedTypes.parameterDefaultArgs.length - paramsToDrop);
             }
         }
-        if (!newFunction.details.paramSpec) {
-            newFunction.details.paramSpec = paramSpec;
-        }
         if (type.inferredReturnType) {
             newFunction.inferredReturnType = type.inferredReturnType;
         }
         return newFunction;
     }
-    FunctionType.cloneRemoveParamSpecVariadics = cloneRemoveParamSpecVariadics;
-    function addDefaultParameters(functionType, useUnknown = false) {
+    FunctionType.cloneRemoveParamSpecArgsKwargs = cloneRemoveParamSpecArgsKwargs;
+    // If the function ends with "*args: P.args, **kwargs: P.kwargs", this function
+    // returns P. Otherwise, it returns undefined.
+    function getParamSpecFromArgsKwargs(type) {
+        const params = type.details.parameters;
+        if (params.length < 2) {
+            return undefined;
+        }
+        const secondLastParam = params[params.length - 2];
+        const lastParam = params[params.length - 1];
+        if (secondLastParam.category === 1 /* ParameterCategory.ArgsList */ &&
+            isTypeVar(secondLastParam.type) &&
+            secondLastParam.type.paramSpecAccess === 'args' &&
+            lastParam.category === 2 /* ParameterCategory.KwargsDict */ &&
+            isTypeVar(lastParam.type) &&
+            lastParam.type.paramSpecAccess === 'kwargs') {
+            return TypeVarType.cloneForParamSpecAccess(secondLastParam.type, /* access */ undefined);
+        }
+        return undefined;
+    }
+    FunctionType.getParamSpecFromArgsKwargs = getParamSpecFromArgsKwargs;
+    function addParamSpecVariadics(type, paramSpec) {
+        FunctionType.addParameter(type, {
+            category: 1 /* ParameterCategory.ArgsList */,
+            name: 'args',
+            type: TypeVarType.cloneForParamSpecAccess(paramSpec, 'args'),
+            hasDeclaredType: true,
+        });
+        FunctionType.addParameter(type, {
+            category: 2 /* ParameterCategory.KwargsDict */,
+            name: 'kwargs',
+            type: TypeVarType.cloneForParamSpecAccess(paramSpec, 'kwargs'),
+            hasDeclaredType: true,
+        });
+    }
+    FunctionType.addParamSpecVariadics = addParamSpecVariadics;
+    function addDefaultParameters(type, useUnknown = false) {
         getDefaultParameters(useUnknown).forEach((param) => {
-            FunctionType.addParameter(functionType, param);
+            FunctionType.addParameter(type, param);
         });
     }
     FunctionType.addDefaultParameters = addDefaultParameters;
@@ -1386,10 +1369,10 @@ var FunctionType;
         return (type.details.flags & 16384 /* FunctionTypeFlags.UnannotatedParams */) !== 0;
     }
     FunctionType.hasUnannotatedParams = hasUnannotatedParams;
-    function shouldSkipArgsKwargsCompatibilityCheck(type) {
-        return (type.details.flags & 32768 /* FunctionTypeFlags.SkipArgsKwargsCompatibilityCheck */) !== 0;
+    function isGradualCallableForm(type) {
+        return (type.details.flags & 32768 /* FunctionTypeFlags.GradualCallableForm */) !== 0;
     }
-    FunctionType.shouldSkipArgsKwargsCompatibilityCheck = shouldSkipArgsKwargsCompatibilityCheck;
+    FunctionType.isGradualCallableForm = isGradualCallableForm;
     function isParamSpecValue(type) {
         return (type.details.flags & 65536 /* FunctionTypeFlags.ParamSpecValue */) !== 0;
     }
@@ -1443,7 +1426,7 @@ var FunctionType;
         });
     }
     FunctionType.addKeywordOnlyParameterSeparator = addKeywordOnlyParameterSeparator;
-    function getSpecializedReturnType(type, includeInferred = true) {
+    function getEffectiveReturnType(type, includeInferred = true) {
         var _a;
         if ((_a = type.specializedTypes) === null || _a === void 0 ? void 0 : _a.returnType) {
             return type.specializedTypes.returnType;
@@ -1456,7 +1439,7 @@ var FunctionType;
         }
         return undefined;
     }
-    FunctionType.getSpecializedReturnType = getSpecializedReturnType;
+    FunctionType.getEffectiveReturnType = getEffectiveReturnType;
 })(FunctionType || (exports.FunctionType = FunctionType = {}));
 var OverloadedFunctionType;
 (function (OverloadedFunctionType) {
@@ -2102,8 +2085,7 @@ function isTypeSame(type1, type2, options = {}, recursionCount = 0) {
                 return false;
             }
             // If one function is ... and the other is not, they are not the same.
-            if (FunctionType.shouldSkipArgsKwargsCompatibilityCheck(type1) !==
-                FunctionType.shouldSkipArgsKwargsCompatibilityCheck(functionType2)) {
+            if (FunctionType.isGradualCallableForm(type1) !== FunctionType.isGradualCallableForm(functionType2)) {
                 return false;
             }
             const positionOnlyIndex1 = params1.findIndex((param) => isPositionOnlySeparator(param));
@@ -2137,20 +2119,6 @@ function isTypeSame(type1, type2, options = {}, recursionCount = 0) {
                     return false;
                 }
             }
-            // If the functions have ParamSpecs associated with them, make sure those match.
-            const paramSpec1 = type1.details.paramSpec;
-            const paramSpec2 = functionType2.details.paramSpec;
-            if (paramSpec1) {
-                if (!paramSpec2) {
-                    return false;
-                }
-                if (!isTypeSame(paramSpec1, paramSpec2, options, recursionCount)) {
-                    return false;
-                }
-            }
-            else if (paramSpec2) {
-                return false;
-            }
             // Make sure the return types match.
             let return1Type = type1.details.declaredReturnType;
             if (type1.specializedTypes && type1.specializedTypes.returnType) {