@zzzen/pyright-internal 1.2.0-dev.20240128 → 1.2.0-dev.20240225

package/dist/analyzer/types.js

@@ -295,69 +295,76 @@ var ClassTypeFlags;
     // value types and a limited set of static keys.
     ClassTypeFlags[ClassTypeFlags["TypedDictClass"] = 128] = "TypedDictClass";
     // Used in conjunction with TypedDictClass, indicates that
+    // the TypedDict class is marked "closed".
+    ClassTypeFlags[ClassTypeFlags["TypedDictMarkedClosed"] = 256] = "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";
+    // Used in conjunction with TypedDictClass, indicates that
     // the dictionary values can be omitted.
-    ClassTypeFlags[ClassTypeFlags["CanOmitDictValues"] = 256] = "CanOmitDictValues";
+    ClassTypeFlags[ClassTypeFlags["CanOmitDictValues"] = 1024] = "CanOmitDictValues";
     // The class derives from a class that has the ABCMeta
     // metaclass. Such classes are allowed to contain
     // @abstractmethod decorators.
-    ClassTypeFlags[ClassTypeFlags["SupportsAbstractMethods"] = 1024] = "SupportsAbstractMethods";
+    ClassTypeFlags[ClassTypeFlags["SupportsAbstractMethods"] = 2048] = "SupportsAbstractMethods";
     // Derives from property class and has the semantics of
     // a property (with optional setter, deleter).
-    ClassTypeFlags[ClassTypeFlags["PropertyClass"] = 2048] = "PropertyClass";
+    ClassTypeFlags[ClassTypeFlags["PropertyClass"] = 4096] = "PropertyClass";
     // The class is decorated with a "@final" decorator
     // indicating that it cannot be subclassed.
-    ClassTypeFlags[ClassTypeFlags["Final"] = 4096] = "Final";
+    ClassTypeFlags[ClassTypeFlags["Final"] = 8192] = "Final";
     // The class derives directly from "Protocol".
-    ClassTypeFlags[ClassTypeFlags["ProtocolClass"] = 8192] = "ProtocolClass";
+    ClassTypeFlags[ClassTypeFlags["ProtocolClass"] = 16384] = "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"] = 16384] = "PseudoGenericClass";
+    ClassTypeFlags[ClassTypeFlags["PseudoGenericClass"] = 32768] = "PseudoGenericClass";
     // A protocol class that is "runtime checkable" can be used
     // in an isinstance call.
-    ClassTypeFlags[ClassTypeFlags["RuntimeCheckable"] = 32768] = "RuntimeCheckable";
+    ClassTypeFlags[ClassTypeFlags["RuntimeCheckable"] = 65536] = "RuntimeCheckable";
     // The type is defined in the typing_extensions.pyi file.
-    ClassTypeFlags[ClassTypeFlags["TypingExtensionClass"] = 65536] = "TypingExtensionClass";
+    ClassTypeFlags[ClassTypeFlags["TypingExtensionClass"] = 131072] = "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"] = 131072] = "PartiallyEvaluated";
+    ClassTypeFlags[ClassTypeFlags["PartiallyEvaluated"] = 262144] = "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"] = 262144] = "HasCustomClassGetItem";
+    ClassTypeFlags[ClassTypeFlags["HasCustomClassGetItem"] = 524288] = "HasCustomClassGetItem";
     // The tuple class uses a variadic type parameter and requires
     // special-case handling of its type arguments.
-    ClassTypeFlags[ClassTypeFlags["TupleClass"] = 524288] = "TupleClass";
+    ClassTypeFlags[ClassTypeFlags["TupleClass"] = 1048576] = "TupleClass";
     // The class has a metaclass of EnumMeta or derives from
     // a class that has this metaclass.
-    ClassTypeFlags[ClassTypeFlags["EnumClass"] = 1048576] = "EnumClass";
+    ClassTypeFlags[ClassTypeFlags["EnumClass"] = 2097152] = "EnumClass";
     // For dataclasses, should __init__ method always be generated
     // with keyword-only parameters?
-    ClassTypeFlags[ClassTypeFlags["DataClassKeywordOnlyParams"] = 2097152] = "DataClassKeywordOnlyParams";
+    ClassTypeFlags[ClassTypeFlags["DataClassKeywordOnlyParams"] = 4194304] = "DataClassKeywordOnlyParams";
     // Properties that are defined using the @classmethod decorator.
-    ClassTypeFlags[ClassTypeFlags["ClassProperty"] = 4194304] = "ClassProperty";
+    ClassTypeFlags[ClassTypeFlags["ClassProperty"] = 8388608] = "ClassProperty";
     // Class is declared within a type stub file.
-    ClassTypeFlags[ClassTypeFlags["DefinedInStub"] = 8388608] = "DefinedInStub";
+    ClassTypeFlags[ClassTypeFlags["DefinedInStub"] = 16777216] = "DefinedInStub";
     // Class does not allow writing or deleting its instance variables
     // through a member access. Used with named tuples.
-    ClassTypeFlags[ClassTypeFlags["ReadOnlyInstanceVariables"] = 16777216] = "ReadOnlyInstanceVariables";
+    ClassTypeFlags[ClassTypeFlags["ReadOnlyInstanceVariables"] = 33554432] = "ReadOnlyInstanceVariables";
     // For dataclasses, should __slots__ be generated?
-    ClassTypeFlags[ClassTypeFlags["GenerateDataClassSlots"] = 33554432] = "GenerateDataClassSlots";
+    ClassTypeFlags[ClassTypeFlags["GenerateDataClassSlots"] = 67108864] = "GenerateDataClassSlots";
     // For dataclasses, should __hash__ be generated?
-    ClassTypeFlags[ClassTypeFlags["SynthesizeDataClassUnsafeHash"] = 67108864] = "SynthesizeDataClassUnsafeHash";
+    ClassTypeFlags[ClassTypeFlags["SynthesizeDataClassUnsafeHash"] = 134217728] = "SynthesizeDataClassUnsafeHash";
     // Decorated with @type_check_only.
-    ClassTypeFlags[ClassTypeFlags["TypeCheckOnly"] = 134217728] = "TypeCheckOnly";
+    ClassTypeFlags[ClassTypeFlags["TypeCheckOnly"] = 268435456] = "TypeCheckOnly";
     // Created with the NewType call.
-    ClassTypeFlags[ClassTypeFlags["NewTypeClass"] = 268435456] = "NewTypeClass";
+    ClassTypeFlags[ClassTypeFlags["NewTypeClass"] = 536870912] = "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"] = 536870912] = "ValidTypeAliasClass";
+    ClassTypeFlags[ClassTypeFlags["ValidTypeAliasClass"] = 1073741824] = "ValidTypeAliasClass";
     // A special form is not compatible with type[T] and cannot
     // be directly instantiated.
-    ClassTypeFlags[ClassTypeFlags["SpecialFormClass"] = 1073741824] = "SpecialFormClass";
+    ClassTypeFlags[ClassTypeFlags["SpecialFormClass"] = -2147483648] = "SpecialFormClass";
 })(ClassTypeFlags || (exports.ClassTypeFlags = ClassTypeFlags = {}));
 var ClassType;
 (function (ClassType) {
@@ -420,7 +427,9 @@ var ClassType;
             newClassType.includeSubclasses = true;
         }
         newClassType.tupleTypeArguments = tupleTypeArguments
-            ? tupleTypeArguments.map((t) => isNever(t.type) ? { type: UnknownType.create(), isUnbounded: t.isUnbounded } : t)
+            ? tupleTypeArguments.map((t) => isNever(t.type)
+                ? { type: UnknownType.create(), isUnbounded: t.isUnbounded, isOptional: t.isOptional }
+                : t)
             : undefined;
         if (isEmptyContainer !== undefined) {
             newClassType.isEmptyContainer = isEmptyContainer;
@@ -601,7 +610,7 @@ var ClassType;
     }
     ClassType.derivesFromAnyOrUnknown = derivesFromAnyOrUnknown;
     function supportsAbstractMethods(classType) {
-        return !!(classType.details.flags & 1024 /* ClassTypeFlags.SupportsAbstractMethods */);
+        return !!(classType.details.flags & 2048 /* ClassTypeFlags.SupportsAbstractMethods */);
     }
     ClassType.supportsAbstractMethods = supportsAbstractMethods;
     function isDataClass(classType) {
@@ -625,31 +634,31 @@ var ClassType;
     }
     ClassType.isSynthesizedDataclassOrder = isSynthesizedDataclassOrder;
     function isDataClassKeywordOnlyParams(classType) {
-        return !!(classType.details.flags & 2097152 /* ClassTypeFlags.DataClassKeywordOnlyParams */);
+        return !!(classType.details.flags & 4194304 /* ClassTypeFlags.DataClassKeywordOnlyParams */);
     }
     ClassType.isDataClassKeywordOnlyParams = isDataClassKeywordOnlyParams;
     function isGeneratedDataClassSlots(classType) {
-        return !!(classType.details.flags & 33554432 /* ClassTypeFlags.GenerateDataClassSlots */);
+        return !!(classType.details.flags & 67108864 /* ClassTypeFlags.GenerateDataClassSlots */);
     }
     ClassType.isGeneratedDataClassSlots = isGeneratedDataClassSlots;
     function isSynthesizeDataClassUnsafeHash(classType) {
-        return !!(classType.details.flags & 67108864 /* ClassTypeFlags.SynthesizeDataClassUnsafeHash */);
+        return !!(classType.details.flags & 134217728 /* ClassTypeFlags.SynthesizeDataClassUnsafeHash */);
     }
     ClassType.isSynthesizeDataClassUnsafeHash = isSynthesizeDataClassUnsafeHash;
     function isTypeCheckOnly(classType) {
-        return !!(classType.details.flags & 134217728 /* ClassTypeFlags.TypeCheckOnly */);
+        return !!(classType.details.flags & 268435456 /* ClassTypeFlags.TypeCheckOnly */);
     }
     ClassType.isTypeCheckOnly = isTypeCheckOnly;
     function isNewTypeClass(classType) {
-        return !!(classType.details.flags & 268435456 /* ClassTypeFlags.NewTypeClass */);
+        return !!(classType.details.flags & 536870912 /* ClassTypeFlags.NewTypeClass */);
     }
     ClassType.isNewTypeClass = isNewTypeClass;
     function isValidTypeAliasClass(classType) {
-        return !!(classType.details.flags & 536870912 /* ClassTypeFlags.ValidTypeAliasClass */);
+        return !!(classType.details.flags & 1073741824 /* ClassTypeFlags.ValidTypeAliasClass */);
     }
     ClassType.isValidTypeAliasClass = isValidTypeAliasClass;
     function isSpecialFormClass(classType) {
-        return !!(classType.details.flags & 1073741824 /* ClassTypeFlags.SpecialFormClass */);
+        return !!(classType.details.flags & -2147483648 /* ClassTypeFlags.SpecialFormClass */);
     }
     ClassType.isSpecialFormClass = isSpecialFormClass;
     function isTypedDictClass(classType) {
@@ -657,35 +666,43 @@ var ClassType;
     }
     ClassType.isTypedDictClass = isTypedDictClass;
     function isCanOmitDictValues(classType) {
-        return !!(classType.details.flags & 256 /* ClassTypeFlags.CanOmitDictValues */);
+        return !!(classType.details.flags & 1024 /* ClassTypeFlags.CanOmitDictValues */);
     }
     ClassType.isCanOmitDictValues = isCanOmitDictValues;
+    function isTypedDictMarkedClosed(classType) {
+        return !!(classType.details.flags & 256 /* ClassTypeFlags.TypedDictMarkedClosed */);
+    }
+    ClassType.isTypedDictMarkedClosed = isTypedDictMarkedClosed;
+    function isTypedDictEffectivelyClosed(classType) {
+        return !!(classType.details.flags & 512 /* ClassTypeFlags.TypedDictEffectivelyClosed */);
+    }
+    ClassType.isTypedDictEffectivelyClosed = isTypedDictEffectivelyClosed;
     function isEnumClass(classType) {
-        return !!(classType.details.flags & 1048576 /* ClassTypeFlags.EnumClass */);
+        return !!(classType.details.flags & 2097152 /* ClassTypeFlags.EnumClass */);
     }
     ClassType.isEnumClass = isEnumClass;
     function isPropertyClass(classType) {
-        return !!(classType.details.flags & 2048 /* ClassTypeFlags.PropertyClass */);
+        return !!(classType.details.flags & 4096 /* ClassTypeFlags.PropertyClass */);
     }
     ClassType.isPropertyClass = isPropertyClass;
     function isClassProperty(classType) {
-        return !!(classType.details.flags & 4194304 /* ClassTypeFlags.ClassProperty */);
+        return !!(classType.details.flags & 8388608 /* ClassTypeFlags.ClassProperty */);
     }
     ClassType.isClassProperty = isClassProperty;
     function isFinal(classType) {
-        return !!(classType.details.flags & 4096 /* ClassTypeFlags.Final */);
+        return !!(classType.details.flags & 8192 /* ClassTypeFlags.Final */);
     }
     ClassType.isFinal = isFinal;
     function isProtocolClass(classType) {
-        return !!(classType.details.flags & 8192 /* ClassTypeFlags.ProtocolClass */);
+        return !!(classType.details.flags & 16384 /* ClassTypeFlags.ProtocolClass */);
     }
     ClassType.isProtocolClass = isProtocolClass;
     function isDefinedInStub(classType) {
-        return !!(classType.details.flags & 8388608 /* ClassTypeFlags.DefinedInStub */);
+        return !!(classType.details.flags & 16777216 /* ClassTypeFlags.DefinedInStub */);
     }
     ClassType.isDefinedInStub = isDefinedInStub;
     function isPseudoGenericClass(classType) {
-        return !!(classType.details.flags & 16384 /* ClassTypeFlags.PseudoGenericClass */);
+        return !!(classType.details.flags & 32768 /* ClassTypeFlags.PseudoGenericClass */);
     }
     ClassType.isPseudoGenericClass = isPseudoGenericClass;
     function getDataClassEntries(classType) {
@@ -693,27 +710,27 @@ var ClassType;
     }
     ClassType.getDataClassEntries = getDataClassEntries;
     function isRuntimeCheckable(classType) {
-        return !!(classType.details.flags & 32768 /* ClassTypeFlags.RuntimeCheckable */);
+        return !!(classType.details.flags & 65536 /* ClassTypeFlags.RuntimeCheckable */);
     }
     ClassType.isRuntimeCheckable = isRuntimeCheckable;
     function isTypingExtensionClass(classType) {
-        return !!(classType.details.flags & 65536 /* ClassTypeFlags.TypingExtensionClass */);
+        return !!(classType.details.flags & 131072 /* ClassTypeFlags.TypingExtensionClass */);
     }
     ClassType.isTypingExtensionClass = isTypingExtensionClass;
     function isPartiallyEvaluated(classType) {
-        return !!(classType.details.flags & 131072 /* ClassTypeFlags.PartiallyEvaluated */);
+        return !!(classType.details.flags & 262144 /* ClassTypeFlags.PartiallyEvaluated */);
     }
     ClassType.isPartiallyEvaluated = isPartiallyEvaluated;
     function hasCustomClassGetItem(classType) {
-        return !!(classType.details.flags & 262144 /* ClassTypeFlags.HasCustomClassGetItem */);
+        return !!(classType.details.flags & 524288 /* ClassTypeFlags.HasCustomClassGetItem */);
     }
     ClassType.hasCustomClassGetItem = hasCustomClassGetItem;
     function isTupleClass(classType) {
-        return !!(classType.details.flags & 524288 /* ClassTypeFlags.TupleClass */);
+        return !!(classType.details.flags & 1048576 /* ClassTypeFlags.TupleClass */);
     }
     ClassType.isTupleClass = isTupleClass;
     function isReadOnlyInstanceVariables(classType) {
-        return !!(classType.details.flags & 16777216 /* ClassTypeFlags.ReadOnlyInstanceVariables */);
+        return !!(classType.details.flags & 33554432 /* ClassTypeFlags.ReadOnlyInstanceVariables */);
     }
     ClassType.isReadOnlyInstanceVariables = isReadOnlyInstanceVariables;
     function getTypeParameters(classType) {
@@ -1556,6 +1573,8 @@ var UnionType;
         const newUnionType = {
             category: 8 /* TypeCategory.Union */,
             subtypes: [],
+            literalInstances: {},
+            literalClasses: {},
             flags: 2 /* TypeFlags.Instance */ | 1 /* TypeFlags.Instantiable */,
         };
         return newUnionType;
@@ -1565,25 +1584,26 @@ var UnionType;
         // If we're adding a string, integer or enum literal, add it to the
         // corresponding literal map to speed up some operations. It's not
         // uncommon for unions to contain hundreds of literals.
-        if (isClassInstance(newType) && newType.literalValue !== undefined && newType.condition === undefined) {
+        if (isClass(newType) && newType.literalValue !== undefined && newType.condition === undefined) {
+            const literalMaps = isClassInstance(newType) ? unionType.literalInstances : unionType.literalClasses;
             if (ClassType.isBuiltIn(newType, 'str')) {
-                if (unionType.literalStrMap === undefined) {
-                    unionType.literalStrMap = new Map();
+                if (literalMaps.literalStrMap === undefined) {
+                    literalMaps.literalStrMap = new Map();
                 }
-                unionType.literalStrMap.set(newType.literalValue, newType);
+                literalMaps.literalStrMap.set(newType.literalValue, newType);
             }
             else if (ClassType.isBuiltIn(newType, 'int')) {
-                if (unionType.literalIntMap === undefined) {
-                    unionType.literalIntMap = new Map();
+                if (literalMaps.literalIntMap === undefined) {
+                    literalMaps.literalIntMap = new Map();
                 }
-                unionType.literalIntMap.set(newType.literalValue, newType);
+                literalMaps.literalIntMap.set(newType.literalValue, newType);
             }
             else if (ClassType.isEnumClass(newType)) {
-                if (unionType.literalEnumMap === undefined) {
-                    unionType.literalEnumMap = new Map();
+                if (literalMaps.literalEnumMap === undefined) {
+                    literalMaps.literalEnumMap = new Map();
                 }
                 const enumLiteral = newType.literalValue;
-                unionType.literalEnumMap.set(enumLiteral.getName(), newType);
+                literalMaps.literalEnumMap.set(enumLiteral.getName(), newType);
             }
         }
         unionType.flags &= newType.flags;
@@ -1601,16 +1621,17 @@ var UnionType;
     function containsType(unionType, subtype, exclusionSet, recursionCount = 0) {
         // Handle string literals as a special case because unions can sometimes
         // contain hundreds of string literal types.
-        if (isClassInstance(subtype) && subtype.condition === undefined && subtype.literalValue !== undefined) {
-            if (ClassType.isBuiltIn(subtype, 'str') && unionType.literalStrMap !== undefined) {
-                return unionType.literalStrMap.has(subtype.literalValue);
+        if (isClass(subtype) && subtype.condition === undefined && subtype.literalValue !== undefined) {
+            const literalMaps = isClassInstance(subtype) ? unionType.literalInstances : unionType.literalClasses;
+            if (ClassType.isBuiltIn(subtype, 'str') && literalMaps.literalStrMap !== undefined) {
+                return literalMaps.literalStrMap.has(subtype.literalValue);
             }
-            else if (ClassType.isBuiltIn(subtype, 'int') && unionType.literalIntMap !== undefined) {
-                return unionType.literalIntMap.has(subtype.literalValue);
+            else if (ClassType.isBuiltIn(subtype, 'int') && literalMaps.literalIntMap !== undefined) {
+                return literalMaps.literalIntMap.has(subtype.literalValue);
             }
-            else if (ClassType.isEnumClass(subtype) && unionType.literalEnumMap !== undefined) {
+            else if (ClassType.isEnumClass(subtype) && literalMaps.literalEnumMap !== undefined) {
                 const enumLiteral = subtype.literalValue;
-                return unionType.literalEnumMap.has(enumLiteral.getName());
+                return literalMaps.literalEnumMap.has(enumLiteral.getName());
             }
         }
         const foundIndex = unionType.subtypes.findIndex((t, i) => {
@@ -2276,10 +2297,14 @@ function combineTypes(subtypes, maxSubtypeCount) {
         return subtypes[0];
     }
     // Expand all union types.
-    let expandedTypes = [];
+    let expandedTypes;
     const typeAliasSources = new Set();
-    for (const subtype of subtypes) {
+    for (let i = 0; i < subtypes.length; i++) {
+        const subtype = subtypes[i];
         if (isUnion(subtype)) {
+            if (!expandedTypes) {
+                expandedTypes = subtypes.slice(0, i);
+            }
             expandedTypes = expandedTypes.concat(subtype.subtypes);
             if (subtype.typeAliasInfo) {
                 typeAliasSources.add(subtype);
@@ -2290,10 +2315,11 @@ function combineTypes(subtypes, maxSubtypeCount) {
                 });
             }
         }
-        else {
+        else if (expandedTypes) {
             expandedTypes.push(subtype);
         }
     }
+    expandedTypes = expandedTypes !== null && expandedTypes !== void 0 ? expandedTypes : subtypes;
     // Sort all of the literal and empty types to the end.
     expandedTypes = expandedTypes.sort((type1, type2) => {
         if (isClass(type1) && type1.literalValue !== undefined) {
@@ -2368,28 +2394,29 @@ function _addTypeIfUnique(unionType, typeToAdd) {
     // Handle the addition of a string literal in a special manner to
     // avoid n^2 behavior in unions that contain hundreds of string
     // literal types. Skip this for constrained types.
-    if (isClassInstance(typeToAdd) && typeToAdd.condition === undefined) {
+    if (isClass(typeToAdd) && typeToAdd.condition === undefined) {
+        const literalMaps = isClassInstance(typeToAdd) ? unionType.literalInstances : unionType.literalClasses;
         if (ClassType.isBuiltIn(typeToAdd, 'str') &&
             typeToAdd.literalValue !== undefined &&
-            unionType.literalStrMap !== undefined) {
-            if (!unionType.literalStrMap.has(typeToAdd.literalValue)) {
+            literalMaps.literalStrMap !== undefined) {
+            if (!literalMaps.literalStrMap.has(typeToAdd.literalValue)) {
                 UnionType.addType(unionType, typeToAdd);
             }
             return;
         }
         else if (ClassType.isBuiltIn(typeToAdd, 'int') &&
             typeToAdd.literalValue !== undefined &&
-            unionType.literalIntMap !== undefined) {
-            if (!unionType.literalIntMap.has(typeToAdd.literalValue)) {
+            literalMaps.literalIntMap !== undefined) {
+            if (!literalMaps.literalIntMap.has(typeToAdd.literalValue)) {
                 UnionType.addType(unionType, typeToAdd);
             }
             return;
         }
         else if (ClassType.isEnumClass(typeToAdd) &&
             typeToAdd.literalValue !== undefined &&
-            unionType.literalEnumMap !== undefined) {
+            literalMaps.literalEnumMap !== undefined) {
             const enumLiteral = typeToAdd.literalValue;
-            if (!unionType.literalEnumMap.has(enumLiteral.getName())) {
+            if (!literalMaps.literalEnumMap.has(enumLiteral.getName())) {
                 UnionType.addType(unionType, typeToAdd);
             }
             return;