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

package/dist/analyzer/types.js

@@ -281,91 +281,74 @@ var ClassTypeFlags;
     // formally as a class. Examples include 'Optional'
     // and 'Union'.
     ClassTypeFlags[ClassTypeFlags["SpecialBuiltIn"] = 2] = "SpecialBuiltIn";
-    // Introduced in Python 3.7 - class either derives directly
-    // from NamedTuple or has a @dataclass class decorator.
-    ClassTypeFlags[ClassTypeFlags["DataClass"] = 4] = "DataClass";
-    // Indicates that the dataclass is frozen.
-    ClassTypeFlags[ClassTypeFlags["FrozenDataClass"] = 8] = "FrozenDataClass";
-    // Flags that control whether methods should be
-    // synthesized for a dataclass class.
-    ClassTypeFlags[ClassTypeFlags["SkipSynthesizedDataClassInit"] = 16] = "SkipSynthesizedDataClassInit";
-    ClassTypeFlags[ClassTypeFlags["SkipSynthesizedDataClassEq"] = 32] = "SkipSynthesizedDataClassEq";
-    ClassTypeFlags[ClassTypeFlags["SynthesizedDataClassOrder"] = 64] = "SynthesizedDataClassOrder";
     // Introduced in PEP 589, TypedDict classes provide a way
     // to specify type hints for dictionaries with different
     // value types and a limited set of static keys.
-    ClassTypeFlags[ClassTypeFlags["TypedDictClass"] = 128] = "TypedDictClass";
+    ClassTypeFlags[ClassTypeFlags["TypedDictClass"] = 4] = "TypedDictClass";
     // Used in conjunction with TypedDictClass, indicates that
     // the TypedDict class is marked "closed".
-    ClassTypeFlags[ClassTypeFlags["TypedDictMarkedClosed"] = 256] = "TypedDictMarkedClosed";
+    ClassTypeFlags[ClassTypeFlags["TypedDictMarkedClosed"] = 8] = "TypedDictMarkedClosed";
     // Used in conjunction with TypedDictClass, indicates that
     // the TypedDict class is marked "closed" or one or more of
     // its superclasses is marked "closed".
-    ClassTypeFlags[ClassTypeFlags["TypedDictEffectivelyClosed"] = 512] = "TypedDictEffectivelyClosed";
+    ClassTypeFlags[ClassTypeFlags["TypedDictEffectivelyClosed"] = 16] = "TypedDictEffectivelyClosed";
     // Used in conjunction with TypedDictClass, indicates that
     // the dictionary values can be omitted.
-    ClassTypeFlags[ClassTypeFlags["CanOmitDictValues"] = 1024] = "CanOmitDictValues";
+    ClassTypeFlags[ClassTypeFlags["CanOmitDictValues"] = 32] = "CanOmitDictValues";
     // The class derives from a class that has the ABCMeta
     // metaclass. Such classes are allowed to contain
     // @abstractmethod decorators.
-    ClassTypeFlags[ClassTypeFlags["SupportsAbstractMethods"] = 2048] = "SupportsAbstractMethods";
+    ClassTypeFlags[ClassTypeFlags["SupportsAbstractMethods"] = 64] = "SupportsAbstractMethods";
     // Derives from property class and has the semantics of
     // a property (with optional setter, deleter).
-    ClassTypeFlags[ClassTypeFlags["PropertyClass"] = 4096] = "PropertyClass";
+    ClassTypeFlags[ClassTypeFlags["PropertyClass"] = 128] = "PropertyClass";
     // The class is decorated with a "@final" decorator
     // indicating that it cannot be subclassed.
-    ClassTypeFlags[ClassTypeFlags["Final"] = 8192] = "Final";
+    ClassTypeFlags[ClassTypeFlags["Final"] = 256] = "Final";
     // The class derives directly from "Protocol".
-    ClassTypeFlags[ClassTypeFlags["ProtocolClass"] = 16384] = "ProtocolClass";
+    ClassTypeFlags[ClassTypeFlags["ProtocolClass"] = 512] = "ProtocolClass";
     // A class whose constructor (__init__ method) does not have
     // annotated types and is treated as though each parameter
     // is a generic type for purposes of type inference.
-    ClassTypeFlags[ClassTypeFlags["PseudoGenericClass"] = 32768] = "PseudoGenericClass";
+    ClassTypeFlags[ClassTypeFlags["PseudoGenericClass"] = 1024] = "PseudoGenericClass";
     // A protocol class that is "runtime checkable" can be used
     // in an isinstance call.
-    ClassTypeFlags[ClassTypeFlags["RuntimeCheckable"] = 65536] = "RuntimeCheckable";
+    ClassTypeFlags[ClassTypeFlags["RuntimeCheckable"] = 2048] = "RuntimeCheckable";
     // The type is defined in the typing_extensions.pyi file.
-    ClassTypeFlags[ClassTypeFlags["TypingExtensionClass"] = 131072] = "TypingExtensionClass";
+    ClassTypeFlags[ClassTypeFlags["TypingExtensionClass"] = 4096] = "TypingExtensionClass";
     // The class type is in the process of being evaluated and
     // is not yet complete. This allows us to detect cases where
     // the class refers to itself (e.g. uses itself as a type
     // argument to one of its generic base classes).
-    ClassTypeFlags[ClassTypeFlags["PartiallyEvaluated"] = 262144] = "PartiallyEvaluated";
+    ClassTypeFlags[ClassTypeFlags["PartiallyEvaluated"] = 8192] = "PartiallyEvaluated";
     // The class or one of its ancestors defines a __class_getitem__
     // method that is used for subscripting. This is not set if the
     // class is generic, and therefore supports standard subscripting
     // semantics.
-    ClassTypeFlags[ClassTypeFlags["HasCustomClassGetItem"] = 524288] = "HasCustomClassGetItem";
+    ClassTypeFlags[ClassTypeFlags["HasCustomClassGetItem"] = 16384] = "HasCustomClassGetItem";
     // The tuple class uses a variadic type parameter and requires
     // special-case handling of its type arguments.
-    ClassTypeFlags[ClassTypeFlags["TupleClass"] = 1048576] = "TupleClass";
+    ClassTypeFlags[ClassTypeFlags["TupleClass"] = 32768] = "TupleClass";
     // The class has a metaclass of EnumMeta or derives from
     // a class that has this metaclass.
-    ClassTypeFlags[ClassTypeFlags["EnumClass"] = 2097152] = "EnumClass";
-    // For dataclasses, should __init__ method always be generated
-    // with keyword-only parameters?
-    ClassTypeFlags[ClassTypeFlags["DataClassKeywordOnlyParams"] = 4194304] = "DataClassKeywordOnlyParams";
+    ClassTypeFlags[ClassTypeFlags["EnumClass"] = 65536] = "EnumClass";
     // Properties that are defined using the @classmethod decorator.
-    ClassTypeFlags[ClassTypeFlags["ClassProperty"] = 8388608] = "ClassProperty";
+    ClassTypeFlags[ClassTypeFlags["ClassProperty"] = 131072] = "ClassProperty";
     // Class is declared within a type stub file.
-    ClassTypeFlags[ClassTypeFlags["DefinedInStub"] = 16777216] = "DefinedInStub";
+    ClassTypeFlags[ClassTypeFlags["DefinedInStub"] = 262144] = "DefinedInStub";
     // Class does not allow writing or deleting its instance variables
     // through a member access. Used with named tuples.
-    ClassTypeFlags[ClassTypeFlags["ReadOnlyInstanceVariables"] = 33554432] = "ReadOnlyInstanceVariables";
-    // For dataclasses, should __slots__ be generated?
-    ClassTypeFlags[ClassTypeFlags["GenerateDataClassSlots"] = 67108864] = "GenerateDataClassSlots";
-    // For dataclasses, should __hash__ be generated?
-    ClassTypeFlags[ClassTypeFlags["SynthesizeDataClassUnsafeHash"] = 134217728] = "SynthesizeDataClassUnsafeHash";
+    ClassTypeFlags[ClassTypeFlags["ReadOnlyInstanceVariables"] = 524288] = "ReadOnlyInstanceVariables";
     // Decorated with @type_check_only.
-    ClassTypeFlags[ClassTypeFlags["TypeCheckOnly"] = 268435456] = "TypeCheckOnly";
+    ClassTypeFlags[ClassTypeFlags["TypeCheckOnly"] = 1048576] = "TypeCheckOnly";
     // Created with the NewType call.
-    ClassTypeFlags[ClassTypeFlags["NewTypeClass"] = 536870912] = "NewTypeClass";
+    ClassTypeFlags[ClassTypeFlags["NewTypeClass"] = 2097152] = "NewTypeClass";
     // Class is allowed to be used as an implicit type alias even
     // though it is not defined using a `class` statement.
-    ClassTypeFlags[ClassTypeFlags["ValidTypeAliasClass"] = 1073741824] = "ValidTypeAliasClass";
+    ClassTypeFlags[ClassTypeFlags["ValidTypeAliasClass"] = 4194304] = "ValidTypeAliasClass";
     // A special form is not compatible with type[T] and cannot
     // be directly instantiated.
-    ClassTypeFlags[ClassTypeFlags["SpecialFormClass"] = -2147483648] = "SpecialFormClass";
+    ClassTypeFlags[ClassTypeFlags["SpecialFormClass"] = 8388608] = "SpecialFormClass";
 })(ClassTypeFlags || (exports.ClassTypeFlags = ClassTypeFlags = {}));
 var ClassType;
 (function (ClassType) {
@@ -427,11 +410,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;
         }
@@ -456,6 +435,12 @@ var ClassType;
         return newClassType;
     }
     ClassType.cloneWithLiteral = cloneWithLiteral;
+    function cloneForDeprecatedInstance(type, deprecatedMessage) {
+        const newClassType = TypeBase.cloneType(type);
+        newClassType.deprecatedInstanceMessage = deprecatedMessage;
+        return newClassType;
+    }
+    ClassType.cloneForDeprecatedInstance = cloneForDeprecatedInstance;
     function cloneForTypingAlias(classType, aliasName) {
         const newClassType = TypeBase.cloneType(classType);
         newClassType.aliasName = aliasName;
@@ -609,104 +594,107 @@ 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 */);
+        return !!(classType.details.flags & 64 /* ClassTypeFlags.SupportsAbstractMethods */);
     }
     ClassType.supportsAbstractMethods = supportsAbstractMethods;
     function isDataClass(classType) {
-        return !!(classType.details.flags & 4 /* ClassTypeFlags.DataClass */);
+        return !!classType.details.dataClassBehaviors;
     }
     ClassType.isDataClass = isDataClass;
-    function isSkipSynthesizedDataClassInit(classType) {
-        return !!(classType.details.flags & 16 /* ClassTypeFlags.SkipSynthesizedDataClassInit */);
+    function isDataClassSkipGenerateInit(classType) {
+        var _a;
+        return !!((_a = classType.details.dataClassBehaviors) === null || _a === void 0 ? void 0 : _a.skipGenerateInit);
     }
-    ClassType.isSkipSynthesizedDataClassInit = isSkipSynthesizedDataClassInit;
-    function isSkipSynthesizedDataClassEq(classType) {
-        return !!(classType.details.flags & 32 /* ClassTypeFlags.SkipSynthesizedDataClassEq */);
+    ClassType.isDataClassSkipGenerateInit = isDataClassSkipGenerateInit;
+    function isDataClassSkipGenerateEq(classType) {
+        var _a;
+        return !!((_a = classType.details.dataClassBehaviors) === null || _a === void 0 ? void 0 : _a.skipGenerateEq);
     }
-    ClassType.isSkipSynthesizedDataClassEq = isSkipSynthesizedDataClassEq;
-    function isFrozenDataClass(classType) {
-        return !!(classType.details.flags & 8 /* ClassTypeFlags.FrozenDataClass */);
+    ClassType.isDataClassSkipGenerateEq = isDataClassSkipGenerateEq;
+    function isDataClassFrozen(classType) {
+        var _a;
+        return !!((_a = classType.details.dataClassBehaviors) === null || _a === void 0 ? void 0 : _a.frozen);
     }
-    ClassType.isFrozenDataClass = isFrozenDataClass;
-    function isSynthesizedDataclassOrder(classType) {
-        return !!(classType.details.flags & 64 /* ClassTypeFlags.SynthesizedDataClassOrder */);
+    ClassType.isDataClassFrozen = isDataClassFrozen;
+    function isDataClassGenerateOrder(classType) {
+        var _a;
+        return !!((_a = classType.details.dataClassBehaviors) === null || _a === void 0 ? void 0 : _a.generateOrder);
     }
-    ClassType.isSynthesizedDataclassOrder = isSynthesizedDataclassOrder;
-    function isDataClassKeywordOnlyParams(classType) {
-        return !!(classType.details.flags & 4194304 /* ClassTypeFlags.DataClassKeywordOnlyParams */);
+    ClassType.isDataClassGenerateOrder = isDataClassGenerateOrder;
+    function isDataClassKeywordOnly(classType) {
+        var _a;
+        return !!((_a = classType.details.dataClassBehaviors) === null || _a === void 0 ? void 0 : _a.keywordOnly);
     }
-    ClassType.isDataClassKeywordOnlyParams = isDataClassKeywordOnlyParams;
-    function isGeneratedDataClassSlots(classType) {
-        return !!(classType.details.flags & 67108864 /* ClassTypeFlags.GenerateDataClassSlots */);
+    ClassType.isDataClassKeywordOnly = isDataClassKeywordOnly;
+    function isDataClassGenerateSlots(classType) {
+        var _a;
+        return !!((_a = classType.details.dataClassBehaviors) === null || _a === void 0 ? void 0 : _a.generateSlots);
     }
-    ClassType.isGeneratedDataClassSlots = isGeneratedDataClassSlots;
-    function isSynthesizeDataClassUnsafeHash(classType) {
-        return !!(classType.details.flags & 134217728 /* ClassTypeFlags.SynthesizeDataClassUnsafeHash */);
+    ClassType.isDataClassGenerateSlots = isDataClassGenerateSlots;
+    function isDataClassGenerateHash(classType) {
+        var _a;
+        return !!((_a = classType.details.dataClassBehaviors) === null || _a === void 0 ? void 0 : _a.generateHash);
     }
-    ClassType.isSynthesizeDataClassUnsafeHash = isSynthesizeDataClassUnsafeHash;
+    ClassType.isDataClassGenerateHash = isDataClassGenerateHash;
     function isTypeCheckOnly(classType) {
-        return !!(classType.details.flags & 268435456 /* ClassTypeFlags.TypeCheckOnly */);
+        return !!(classType.details.flags & 1048576 /* ClassTypeFlags.TypeCheckOnly */);
     }
     ClassType.isTypeCheckOnly = isTypeCheckOnly;
     function isNewTypeClass(classType) {
-        return !!(classType.details.flags & 536870912 /* ClassTypeFlags.NewTypeClass */);
+        return !!(classType.details.flags & 2097152 /* ClassTypeFlags.NewTypeClass */);
     }
     ClassType.isNewTypeClass = isNewTypeClass;
     function isValidTypeAliasClass(classType) {
-        return !!(classType.details.flags & 1073741824 /* ClassTypeFlags.ValidTypeAliasClass */);
+        return !!(classType.details.flags & 4194304 /* ClassTypeFlags.ValidTypeAliasClass */);
     }
     ClassType.isValidTypeAliasClass = isValidTypeAliasClass;
     function isSpecialFormClass(classType) {
-        return !!(classType.details.flags & -2147483648 /* ClassTypeFlags.SpecialFormClass */);
+        return !!(classType.details.flags & 8388608 /* ClassTypeFlags.SpecialFormClass */);
     }
     ClassType.isSpecialFormClass = isSpecialFormClass;
     function isTypedDictClass(classType) {
-        return !!(classType.details.flags & 128 /* ClassTypeFlags.TypedDictClass */);
+        return !!(classType.details.flags & 4 /* ClassTypeFlags.TypedDictClass */);
     }
     ClassType.isTypedDictClass = isTypedDictClass;
     function isCanOmitDictValues(classType) {
-        return !!(classType.details.flags & 1024 /* ClassTypeFlags.CanOmitDictValues */);
+        return !!(classType.details.flags & 32 /* ClassTypeFlags.CanOmitDictValues */);
     }
     ClassType.isCanOmitDictValues = isCanOmitDictValues;
     function isTypedDictMarkedClosed(classType) {
-        return !!(classType.details.flags & 256 /* ClassTypeFlags.TypedDictMarkedClosed */);
+        return !!(classType.details.flags & 8 /* ClassTypeFlags.TypedDictMarkedClosed */);
     }
     ClassType.isTypedDictMarkedClosed = isTypedDictMarkedClosed;
     function isTypedDictEffectivelyClosed(classType) {
-        return !!(classType.details.flags & 512 /* ClassTypeFlags.TypedDictEffectivelyClosed */);
+        return !!(classType.details.flags & 16 /* ClassTypeFlags.TypedDictEffectivelyClosed */);
     }
     ClassType.isTypedDictEffectivelyClosed = isTypedDictEffectivelyClosed;
     function isEnumClass(classType) {
-        return !!(classType.details.flags & 2097152 /* ClassTypeFlags.EnumClass */);
+        return !!(classType.details.flags & 65536 /* ClassTypeFlags.EnumClass */);
     }
     ClassType.isEnumClass = isEnumClass;
     function isPropertyClass(classType) {
-        return !!(classType.details.flags & 4096 /* ClassTypeFlags.PropertyClass */);
+        return !!(classType.details.flags & 128 /* ClassTypeFlags.PropertyClass */);
     }
     ClassType.isPropertyClass = isPropertyClass;
     function isClassProperty(classType) {
-        return !!(classType.details.flags & 8388608 /* ClassTypeFlags.ClassProperty */);
+        return !!(classType.details.flags & 131072 /* ClassTypeFlags.ClassProperty */);
     }
     ClassType.isClassProperty = isClassProperty;
     function isFinal(classType) {
-        return !!(classType.details.flags & 8192 /* ClassTypeFlags.Final */);
+        return !!(classType.details.flags & 256 /* ClassTypeFlags.Final */);
     }
     ClassType.isFinal = isFinal;
     function isProtocolClass(classType) {
-        return !!(classType.details.flags & 16384 /* ClassTypeFlags.ProtocolClass */);
+        return !!(classType.details.flags & 512 /* ClassTypeFlags.ProtocolClass */);
     }
     ClassType.isProtocolClass = isProtocolClass;
     function isDefinedInStub(classType) {
-        return !!(classType.details.flags & 16777216 /* ClassTypeFlags.DefinedInStub */);
+        return !!(classType.details.flags & 262144 /* ClassTypeFlags.DefinedInStub */);
     }
     ClassType.isDefinedInStub = isDefinedInStub;
     function isPseudoGenericClass(classType) {
-        return !!(classType.details.flags & 32768 /* ClassTypeFlags.PseudoGenericClass */);
+        return !!(classType.details.flags & 1024 /* ClassTypeFlags.PseudoGenericClass */);
     }
     ClassType.isPseudoGenericClass = isPseudoGenericClass;
     function getDataClassEntries(classType) {
@@ -716,37 +704,37 @@ var ClassType;
     }
     ClassType.getDataClassEntries = getDataClassEntries;
     function isRuntimeCheckable(classType) {
-        return !!(classType.details.flags & 65536 /* ClassTypeFlags.RuntimeCheckable */);
+        return !!(classType.details.flags & 2048 /* ClassTypeFlags.RuntimeCheckable */);
     }
     ClassType.isRuntimeCheckable = isRuntimeCheckable;
     function isTypingExtensionClass(classType) {
-        return !!(classType.details.flags & 131072 /* ClassTypeFlags.TypingExtensionClass */);
+        return !!(classType.details.flags & 4096 /* ClassTypeFlags.TypingExtensionClass */);
     }
     ClassType.isTypingExtensionClass = isTypingExtensionClass;
     function isPartiallyEvaluated(classType) {
-        return !!(classType.details.flags & 262144 /* ClassTypeFlags.PartiallyEvaluated */);
+        return !!(classType.details.flags & 8192 /* ClassTypeFlags.PartiallyEvaluated */);
     }
     ClassType.isPartiallyEvaluated = isPartiallyEvaluated;
     function hasCustomClassGetItem(classType) {
-        return !!(classType.details.flags & 524288 /* ClassTypeFlags.HasCustomClassGetItem */);
+        return !!(classType.details.flags & 16384 /* ClassTypeFlags.HasCustomClassGetItem */);
     }
     ClassType.hasCustomClassGetItem = hasCustomClassGetItem;
     function isTupleClass(classType) {
-        return !!(classType.details.flags & 1048576 /* ClassTypeFlags.TupleClass */);
+        return !!(classType.details.flags & 32768 /* ClassTypeFlags.TupleClass */);
     }
     ClassType.isTupleClass = isTupleClass;
     function isReadOnlyInstanceVariables(classType) {
-        return !!(classType.details.flags & 33554432 /* ClassTypeFlags.ReadOnlyInstanceVariables */);
+        return !!(classType.details.flags & 524288 /* ClassTypeFlags.ReadOnlyInstanceVariables */);
     }
     ClassType.isReadOnlyInstanceVariables = isReadOnlyInstanceVariables;
     function getTypeParameters(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 +921,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";
@@ -982,10 +970,11 @@ var FunctionType;
     // version of _functionDetails.
     function clone(type, stripFirstParam = false, boundToType, boundTypeVarScopeId) {
         var _a;
-        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);
         newFunction.details = { ...type.details };
-        newFunction.boundToType = boundToType !== null && boundToType !== void 0 ? boundToType : type.boundToType;
         newFunction.preBoundFlags = newFunction.details.flags;
+        newFunction.boundToType = boundToType;
+        newFunction.boundTypeVarScopeId = boundTypeVarScopeId;
         if (stripFirstParam) {
             if (type.details.parameters.length > 0) {
                 if (type.details.parameters[0].category === 0 /* ParameterCategory.Simple */) {
@@ -1020,7 +1009,6 @@ var FunctionType;
             };
         }
         newFunction.inferredReturnType = type.inferredReturnType;
-        newFunction.boundTypeVarScopeId = boundTypeVarScopeId !== null && boundTypeVarScopeId !== void 0 ? boundTypeVarScopeId : type.boundTypeVarScopeId;
         return newFunction;
     }
     FunctionType.clone = clone;
@@ -1047,103 +1035,81 @@ var FunctionType;
     // specialized types. The clone shares the _functionDetails
     // with the object being cloned.
     function cloneForSpecialization(type, specializedTypes, specializedInferredReturnType) {
-        const newFunction = create(type.details.name, type.details.fullName, type.details.moduleName, type.details.flags, type.flags, type.details.docString);
-        newFunction.details = type.details;
+        const newFunction = TypeBase.cloneType(type);
         (0, debug_1.assert)(specializedTypes.parameterTypes.length === type.details.parameters.length);
         if (specializedTypes.parameterDefaultArgs) {
             (0, debug_1.assert)(specializedTypes.parameterDefaultArgs.length === type.details.parameters.length);
         }
         newFunction.specializedTypes = specializedTypes;
-        if (specializedInferredReturnType) {
-            newFunction.inferredReturnType = specializedInferredReturnType;
-        }
+        newFunction.inferredReturnType = specializedInferredReturnType;
         return newFunction;
     }
     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 +1145,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 +1362,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 +1419,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 +1432,7 @@ var FunctionType;
         }
         return undefined;
     }
-    FunctionType.getSpecializedReturnType = getSpecializedReturnType;
+    FunctionType.getEffectiveReturnType = getEffectiveReturnType;
 })(FunctionType || (exports.FunctionType = FunctionType = {}));
 var OverloadedFunctionType;
 (function (OverloadedFunctionType) {
@@ -2102,8 +2078,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 +2112,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) {