@zzzen/pyright-internal 1.2.0-dev.20240609 → 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) {
@@ -452,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;
@@ -606,99 +595,106 @@ var ClassType;
     }
     ClassType.isBuiltIn = isBuiltIn;
     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) {
@@ -708,27 +704,27 @@ 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) {
@@ -974,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 */) {
@@ -1012,7 +1009,6 @@ var FunctionType;
             };
         }
         newFunction.inferredReturnType = type.inferredReturnType;
-        newFunction.boundTypeVarScopeId = boundTypeVarScopeId !== null && boundTypeVarScopeId !== void 0 ? boundTypeVarScopeId : type.boundTypeVarScopeId;
         return newFunction;
     }
     FunctionType.clone = clone;
@@ -1039,16 +1035,13 @@ 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;