@zzzen/pyright-internal 1.2.0-dev.20240804 → 1.2.0-dev.20240811

package/dist/analyzer/types.js

@@ -8,37 +8,58 @@
  * Representation of types used during type analysis within Python.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.removeUnbound = exports.removeUnknownFromUnion = exports.isTypeSame = exports.getTypeAliasInfo = exports.isOverloadedFunction = exports.isFunction = exports.isUnpacked = exports.isUnpackedClass = exports.isUnpackedTypeVarTuple = exports.isTypeVarTuple = exports.isParamSpec = exports.isTypeVar = exports.isModule = exports.isClassInstance = exports.isInstantiableClass = exports.isClass = exports.isPossiblyUnbound = exports.isUnion = exports.isUnbound = exports.isAnyOrUnknown = exports.isUnknown = exports.isAny = exports.isNever = exports.TypeVarType = exports.ParamSpecType = exports.TypeVarScopeType = exports.TypeVarKind = exports.Variance = exports.UnionType = exports.TypeCondition = exports.AnyType = exports.NeverType = exports.OverloadedFunctionType = exports.FunctionType = exports.FunctionTypeFlags = exports.isKeywordOnlySeparator = exports.isPositionOnlySeparator = exports.FunctionParam = exports.FunctionParamFlags = exports.ClassType = exports.ClassTypeFlags = exports.ModuleType = exports.UnknownType = exports.UnboundType = exports.TypeBase = exports.maxTypeRecursionCount = exports.EnumLiteral = exports.UnificationScopeId = exports.TypeFlags = exports.TypeCategory = void 0;
-exports.isSameWithoutLiteralValue = exports.combineTypes = exports.findSubtype = exports.removeFromUnion = void 0;
+exports.TypeVarType = exports.ParamSpecType = exports.TypeVarScopeType = exports.TypeVarKind = exports.Variance = exports.UnionType = exports.TypeCondition = exports.AnyType = exports.NeverType = exports.OverloadedType = exports.FunctionType = exports.FunctionTypeFlags = exports.FunctionParam = exports.FunctionParamFlags = exports.ClassType = exports.ClassTypeFlags = exports.ModuleType = exports.UnknownType = exports.UnboundType = exports.TypeBase = exports.maxTypeRecursionCount = exports.EnumLiteral = exports.UnificationScopeId = exports.TypeFlags = exports.TypeCategory = void 0;
+exports.isPositionOnlySeparator = isPositionOnlySeparator;
+exports.isKeywordOnlySeparator = isKeywordOnlySeparator;
+exports.isNever = isNever;
+exports.isAny = isAny;
+exports.isUnknown = isUnknown;
+exports.isAnyOrUnknown = isAnyOrUnknown;
+exports.isUnbound = isUnbound;
+exports.isUnion = isUnion;
+exports.isPossiblyUnbound = isPossiblyUnbound;
+exports.isClass = isClass;
+exports.isInstantiableClass = isInstantiableClass;
+exports.isClassInstance = isClassInstance;
+exports.isModule = isModule;
+exports.isTypeVar = isTypeVar;
+exports.isParamSpec = isParamSpec;
+exports.isTypeVarTuple = isTypeVarTuple;
+exports.isUnpackedTypeVarTuple = isUnpackedTypeVarTuple;
+exports.isUnpackedClass = isUnpackedClass;
+exports.isUnpacked = isUnpacked;
+exports.isFunction = isFunction;
+exports.isOverloaded = isOverloaded;
+exports.getTypeAliasInfo = getTypeAliasInfo;
+exports.isTypeSame = isTypeSame;
+exports.removeUnknownFromUnion = removeUnknownFromUnion;
+exports.removeUnbound = removeUnbound;
+exports.removeFromUnion = removeFromUnion;
+exports.findSubtype = findSubtype;
+exports.combineTypes = combineTypes;
+exports.isSameWithoutLiteralValue = isSameWithoutLiteralValue;
 const debug_1 = require("../common/debug");
-const typeUtils_1 = require("./typeUtils");
 var TypeCategory;
 (function (TypeCategory) {
-    // Name is not bound to a value of any type.
+    // Name is not bound to a value of any type
     TypeCategory[TypeCategory["Unbound"] = 0] = "Unbound";
-    // Type exists but is not currently known by the
-    // type analyzer (e.g. there is no available typings file).
-    // Unknown types are treated the same as "Any" at analysis time.
+    // Implicit Any type
     TypeCategory[TypeCategory["Unknown"] = 1] = "Unknown";
-    // Type can be anything.
+    // Type can be anything
     TypeCategory[TypeCategory["Any"] = 2] = "Any";
-    // Used in type narrowing to indicate that all possible
-    // subtypes in a union have been eliminated, and execution
-    // should never get to this point.
+    // The bottom type, equivalent to an empty union
     TypeCategory[TypeCategory["Never"] = 3] = "Never";
-    // Callable type with typed input parameters and return parameter.
+    // Callable type
     TypeCategory[TypeCategory["Function"] = 4] = "Function";
-    // Functions defined with @overload decorator in stub files that
-    // have multiple function declarations for a common implementation.
-    TypeCategory[TypeCategory["OverloadedFunction"] = 5] = "OverloadedFunction";
-    // Class definition, including associated instance methods,
-    // class methods, static methods, properties, and variables.
+    // Functions defined with @overload decorator
+    TypeCategory[TypeCategory["Overloaded"] = 5] = "Overloaded";
+    // Class definition
     TypeCategory[TypeCategory["Class"] = 6] = "Class";
-    // Module instance.
+    // Module instance
     TypeCategory[TypeCategory["Module"] = 7] = "Module";
-    // Composite type (e.g. Number OR String).
+    // Union of two or more other types
     TypeCategory[TypeCategory["Union"] = 8] = "Union";
-    // Type variable (defined with TypeVar)
+    // Type variable
     TypeCategory[TypeCategory["TypeVar"] = 9] = "TypeVar";
 })(TypeCategory || (exports.TypeCategory = TypeCategory = {}));
 var TypeFlags;
@@ -56,12 +77,15 @@ var TypeFlags;
     TypeFlags[TypeFlags["TypeCompatibilityMask"] = 3] = "TypeCompatibilityMask";
 })(TypeFlags || (exports.TypeFlags = TypeFlags = {}));
 exports.UnificationScopeId = '-';
+// Information about an enum member that can be used within a Literal
+// type annotation.
 class EnumLiteral {
-    constructor(classFullName, className, itemName, itemType) {
+    constructor(classFullName, className, itemName, itemType, isReprEnum) {
         this.classFullName = classFullName;
         this.className = className;
         this.itemName = itemName;
         this.itemType = itemType;
+        this.isReprEnum = isReprEnum;
     }
     getName() {
         return `${this.classFullName}.${this.itemName}`;
@@ -658,8 +682,9 @@ var ClassType;
         }
         if (className !== undefined) {
             const classArray = Array.isArray(className) ? className : [className];
-            return (classArray.some((name) => name === classType.shared.name) ||
-                classArray.some((name) => name === classType.priv.aliasName));
+            return classArray.some((name) => name === classType.shared.name ||
+                name === classType.shared.fullName ||
+                name === classType.priv.aliasName);
         }
         return true;
     }
@@ -979,12 +1004,10 @@ function isPositionOnlySeparator(param) {
     // A simple parameter with no name is treated as a "/" separator.
     return param.category === 0 /* ParamCategory.Simple */ && !param.name;
 }
-exports.isPositionOnlySeparator = isPositionOnlySeparator;
 function isKeywordOnlySeparator(param) {
     // An *args parameter with no name is treated as a "*" separator.
     return param.category === 1 /* ParamCategory.ArgsList */ && !param.name;
 }
-exports.isKeywordOnlySeparator = isKeywordOnlySeparator;
 var FunctionTypeFlags;
 (function (FunctionTypeFlags) {
     FunctionTypeFlags[FunctionTypeFlags["None"] = 0] = "None";
@@ -1090,7 +1113,7 @@ var FunctionType;
         newFunction.priv.boundToType = boundToType;
         if (boundToType) {
             if (type.shared.name === '__new__' || type.shared.name === '__init__') {
-                newFunction.priv.constructorTypeVarScopeId = (0, typeUtils_1.getTypeVarScopeId)(boundToType);
+                newFunction.priv.constructorTypeVarScopeId = boundToType.shared.typeVarScopeId;
             }
         }
         if (stripFirstParam) {
@@ -1456,7 +1479,7 @@ var FunctionType;
         }
         if (name !== undefined) {
             const functionArray = Array.isArray(name) ? name : [name];
-            return functionArray.some((name) => name === type.shared.name);
+            return functionArray.some((name) => name === type.shared.name || name === type.shared.fullName);
         }
         return true;
     }
@@ -1516,40 +1539,41 @@ var FunctionType;
     }
     FunctionType.getEffectiveReturnType = getEffectiveReturnType;
 })(FunctionType || (exports.FunctionType = FunctionType = {}));
-var OverloadedFunctionType;
-(function (OverloadedFunctionType) {
-    function create(overloads) {
+var OverloadedType;
+(function (OverloadedType) {
+    function create(overloads, implementation) {
         const newType = {
-            category: 5 /* TypeCategory.OverloadedFunction */,
+            category: 5 /* TypeCategory.Overloaded */,
             flags: 2 /* TypeFlags.Instance */,
             props: undefined,
             cached: undefined,
             shared: undefined,
             priv: {
-                overloads: [],
+                _overloads: [],
+                _implementation: implementation,
             },
         };
         overloads.forEach((overload) => {
-            OverloadedFunctionType.addOverload(newType, overload);
+            OverloadedType.addOverload(newType, overload);
         });
         return newType;
     }
-    OverloadedFunctionType.create = create;
+    OverloadedType.create = create;
     // Adds a new overload or an implementation.
     function addOverload(type, functionType) {
         functionType.priv.overloaded = type;
-        type.priv.overloads.push(functionType);
+        type.priv._overloads.push(functionType);
     }
-    OverloadedFunctionType.addOverload = addOverload;
+    OverloadedType.addOverload = addOverload;
     function getOverloads(type) {
-        return type.priv.overloads.filter((func) => FunctionType.isOverloaded(func));
+        return type.priv._overloads;
     }
-    OverloadedFunctionType.getOverloads = getOverloads;
+    OverloadedType.getOverloads = getOverloads;
     function getImplementation(type) {
-        return type.priv.overloads.find((func) => !FunctionType.isOverloaded(func));
+        return type.priv._implementation;
     }
-    OverloadedFunctionType.getImplementation = getImplementation;
-})(OverloadedFunctionType || (exports.OverloadedFunctionType = OverloadedFunctionType = {}));
+    OverloadedType.getImplementation = getImplementation;
+})(OverloadedType || (exports.OverloadedType = OverloadedType = {}));
 var NeverType;
 (function (NeverType) {
     const _neverInstance = {
@@ -2093,15 +2117,12 @@ var TypeVarType;
 function isNever(type) {
     return type.category === 3 /* TypeCategory.Never */;
 }
-exports.isNever = isNever;
 function isAny(type) {
     return type.category === 2 /* TypeCategory.Any */;
 }
-exports.isAny = isAny;
 function isUnknown(type) {
     return type.category === 1 /* TypeCategory.Unknown */;
 }
-exports.isUnknown = isUnknown;
 function isAnyOrUnknown(type) {
     if (type.category === 2 /* TypeCategory.Any */ || type.category === 1 /* TypeCategory.Unknown */) {
         return true;
@@ -2111,15 +2132,12 @@ function isAnyOrUnknown(type) {
     }
     return false;
 }
-exports.isAnyOrUnknown = isAnyOrUnknown;
 function isUnbound(type) {
     return type.category === 0 /* TypeCategory.Unbound */;
 }
-exports.isUnbound = isUnbound;
 function isUnion(type) {
     return type.category === 8 /* TypeCategory.Union */;
 }
-exports.isUnion = isUnion;
 function isPossiblyUnbound(type) {
     if (isUnbound(type)) {
         return true;
@@ -2129,58 +2147,45 @@ function isPossiblyUnbound(type) {
     }
     return false;
 }
-exports.isPossiblyUnbound = isPossiblyUnbound;
 function isClass(type) {
     return type.category === 6 /* TypeCategory.Class */;
 }
-exports.isClass = isClass;
 function isInstantiableClass(type) {
     return type.category === 6 /* TypeCategory.Class */ && TypeBase.isInstantiable(type);
 }
-exports.isInstantiableClass = isInstantiableClass;
 function isClassInstance(type) {
     return type.category === 6 /* TypeCategory.Class */ && TypeBase.isInstance(type);
 }
-exports.isClassInstance = isClassInstance;
 function isModule(type) {
     return type.category === 7 /* TypeCategory.Module */;
 }
-exports.isModule = isModule;
 function isTypeVar(type) {
     return type.category === 9 /* TypeCategory.TypeVar */;
 }
-exports.isTypeVar = isTypeVar;
 function isParamSpec(type) {
     return type.category === 9 /* TypeCategory.TypeVar */ && type.shared.kind === TypeVarKind.ParamSpec;
 }
-exports.isParamSpec = isParamSpec;
 function isTypeVarTuple(type) {
     return type.category === 9 /* TypeCategory.TypeVar */ && type.shared.kind === TypeVarKind.TypeVarTuple;
 }
-exports.isTypeVarTuple = isTypeVarTuple;
 function isUnpackedTypeVarTuple(type) {
     return isTypeVarTuple(type) && !!type.priv.isUnpacked && !type.priv.isInUnion;
 }
-exports.isUnpackedTypeVarTuple = isUnpackedTypeVarTuple;
 function isUnpackedClass(type) {
     if (!isClass(type) || !type.priv.isUnpacked) {
         return false;
     }
     return true;
 }
-exports.isUnpackedClass = isUnpackedClass;
 function isUnpacked(type) {
     return isUnpackedTypeVarTuple(type) || isUnpackedClass(type);
 }
-exports.isUnpacked = isUnpacked;
 function isFunction(type) {
     return type.category === 4 /* TypeCategory.Function */;
 }
-exports.isFunction = isFunction;
-function isOverloadedFunction(type) {
-    return type.category === 5 /* TypeCategory.OverloadedFunction */;
+function isOverloaded(type) {
+    return type.category === 5 /* TypeCategory.Overloaded */;
 }
-exports.isOverloadedFunction = isOverloadedFunction;
 function getTypeAliasInfo(type) {
     var _a, _b;
     if ((_a = type.props) === null || _a === void 0 ? void 0 : _a.typeAliasInfo) {
@@ -2194,7 +2199,6 @@ function getTypeAliasInfo(type) {
     }
     return undefined;
 }
-exports.getTypeAliasInfo = getTypeAliasInfo;
 // Determines whether two types are the same. If ignorePseudoGeneric is true,
 // type arguments for "pseudo-generic" classes (non-generic classes whose init
 // methods are not annotated and are therefore treated as generic) are ignored.
@@ -2342,16 +2346,16 @@ function isTypeSame(type1, type2, options = {}, recursionCount = 0) {
             }
             return true;
         }
-        case 5 /* TypeCategory.OverloadedFunction */: {
+        case 5 /* TypeCategory.Overloaded */: {
             // Make sure the overload counts match.
             const functionType2 = type2;
-            if (type1.priv.overloads.length !== functionType2.priv.overloads.length) {
+            if (type1.priv._overloads.length !== functionType2.priv._overloads.length) {
                 return false;
             }
             // We assume here that overloaded functions always appear
             // in the same order from one analysis pass to another.
-            for (let i = 0; i < type1.priv.overloads.length; i++) {
-                if (!isTypeSame(type1.priv.overloads[i], functionType2.priv.overloads[i], options, recursionCount)) {
+            for (let i = 0; i < type1.priv._overloads.length; i++) {
+                if (!isTypeSame(type1.priv._overloads[i], functionType2.priv._overloads[i], options, recursionCount)) {
                     return false;
                 }
             }
@@ -2455,13 +2459,11 @@ function isTypeSame(type1, type2, options = {}, recursionCount = 0) {
     }
     return true;
 }
-exports.isTypeSame = isTypeSame;
 // If the type is a union, remove an "unknown" type from the union,
 // returning only the known types.
 function removeUnknownFromUnion(type) {
     return removeFromUnion(type, (t) => isUnknown(t));
 }
-exports.removeUnknownFromUnion = removeUnknownFromUnion;
 // If the type is a union, remove an "unbound" type from the union,
 // returning only the known types.
 function removeUnbound(type) {
@@ -2473,7 +2475,6 @@ function removeUnbound(type) {
     }
     return type;
 }
-exports.removeUnbound = removeUnbound;
 function removeFromUnion(type, removeFilter) {
     if (isUnion(type)) {
         const remainingTypes = type.priv.subtypes.filter((t) => !removeFilter(t));
@@ -2487,7 +2488,6 @@ function removeFromUnion(type, removeFilter) {
     }
     return type;
 }
-exports.removeFromUnion = removeFromUnion;
 function findSubtype(type, filter) {
     if (isUnion(type)) {
         return type.priv.subtypes.find((subtype) => {
@@ -2496,7 +2496,6 @@ function findSubtype(type, filter) {
     }
     return filter(type) ? type : undefined;
 }
-exports.findSubtype = findSubtype;
 // Combines multiple types into a single type. If the types are
 // the same, only one is returned. If they differ, they
 // are combined into a UnionType. NeverTypes are filtered out.
@@ -2601,7 +2600,6 @@ function combineTypes(subtypes, options) {
     }
     return newUnionType;
 }
-exports.combineTypes = combineTypes;
 // Determines whether the dest type is the same as the source type with
 // the possible exception that the source type has a literal value when
 // the dest does not.
@@ -2622,7 +2620,6 @@ function isSameWithoutLiteralValue(destType, srcType) {
     }
     return false;
 }
-exports.isSameWithoutLiteralValue = isSameWithoutLiteralValue;
 function _addTypeIfUnique(unionType, typeToAdd, elideRedundantLiterals) {
     var _a, _b, _c;
     // Handle the addition of a string literal in a special manner to