@zzzen/pyright-internal 1.2.0-dev.20240901 → 1.2.0-dev.20240908

package/dist/analyzer/types.js

@@ -119,6 +119,7 @@ var TypeBase;
             type.props = {
                 instantiableDepth: undefined,
                 specialForm: undefined,
+                typeForm: undefined,
                 typeAliasInfo: undefined,
                 condition: undefined,
             };
@@ -138,6 +139,10 @@ var TypeBase;
         TypeBase.addProps(type).typeAliasInfo = typeAliasInfo;
     }
     TypeBase.setTypeAliasInfo = setTypeAliasInfo;
+    function setTypeForm(type, typeForm) {
+        TypeBase.addProps(type).typeForm = typeForm;
+    }
+    TypeBase.setTypeForm = setTypeForm;
     function setCondition(type, condition) {
         TypeBase.addProps(type).condition = condition;
     }
@@ -161,10 +166,14 @@ var TypeBase;
     }
     TypeBase.cloneAsSpecialForm = cloneAsSpecialForm;
     function cloneTypeAsInstance(type, cache) {
-        var _a;
+        var _a, _b;
         (0, debug_1.assert)(TypeBase.isInstantiable(type));
         const newInstance = TypeBase.cloneType(type);
-        const depth = (_a = newInstance.props) === null || _a === void 0 ? void 0 : _a.instantiableDepth;
+        // Remove type form information from the type.
+        if ((_a = newInstance.props) === null || _a === void 0 ? void 0 : _a.typeForm) {
+            TypeBase.setTypeForm(newInstance, undefined);
+        }
+        const depth = (_b = newInstance.props) === null || _b === void 0 ? void 0 : _b.instantiableDepth;
         if (depth === undefined) {
             newInstance.flags &= ~1 /* TypeFlags.Instantiable */;
             newInstance.flags |= 2 /* TypeFlags.Instance */;
@@ -186,7 +195,7 @@ var TypeBase;
     }
     TypeBase.cloneTypeAsInstance = cloneTypeAsInstance;
     function cloneTypeAsInstantiable(type, cache) {
-        var _a, _b;
+        var _a, _b, _c;
         const newInstance = TypeBase.cloneType(type);
         if (TypeBase.isInstance(type)) {
             newInstance.flags &= ~2 /* TypeFlags.Instance */;
@@ -201,6 +210,10 @@ var TypeBase;
         if ((_b = newInstance.props) === null || _b === void 0 ? void 0 : _b.typeAliasInfo) {
             TypeBase.setTypeAliasInfo(newInstance, undefined);
         }
+        // Remove type form information from the type.
+        if ((_c = newInstance.props) === null || _c === void 0 ? void 0 : _c.typeForm) {
+            TypeBase.setTypeForm(newInstance, undefined);
+        }
         // Should we cache it for next time?
         if (cache) {
             if (!type.cached) {
@@ -217,6 +230,12 @@ var TypeBase;
         return typeClone;
     }
     TypeBase.cloneForTypeAlias = cloneForTypeAlias;
+    function cloneWithTypeForm(type, typeForm) {
+        const typeClone = cloneType(type);
+        TypeBase.setTypeForm(typeClone, typeForm);
+        return typeClone;
+    }
+    TypeBase.cloneWithTypeForm = cloneWithTypeForm;
     function cloneForCondition(type, condition) {
         var _a;
         // Handle the common case where there are no conditions. In this case,
@@ -419,9 +438,6 @@ var ClassTypeFlags;
     ClassTypeFlags[ClassTypeFlags["ClassProperty"] = 131072] = "ClassProperty";
     // Class is declared within a type stub file.
     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"] = 524288] = "ReadOnlyInstanceVariables";
     // Decorated with @type_check_only.
     ClassTypeFlags[ClassTypeFlags["TypeCheckOnly"] = 1048576] = "TypeCheckOnly";
     // Created with the NewType call.
@@ -822,10 +838,6 @@ var ClassType;
         return !!(classType.shared.flags & 32768 /* ClassTypeFlags.TupleClass */);
     }
     ClassType.isTupleClass = isTupleClass;
-    function isReadOnlyInstanceVariables(classType) {
-        return !!(classType.shared.flags & 524288 /* ClassTypeFlags.ReadOnlyInstanceVariables */);
-    }
-    ClassType.isReadOnlyInstanceVariables = isReadOnlyInstanceVariables;
     function getTypeParams(classType) {
         return classType.shared.typeParams;
     }
@@ -857,6 +869,13 @@ var ClassType;
             classType.shared.mro.some((mroClass) => isClass(mroClass) && ClassType.isPartiallyEvaluated(mroClass)));
     }
     ClassType.isHierarchyPartiallyEvaluated = isHierarchyPartiallyEvaluated;
+    function hasNamedTupleEntry(classType, name) {
+        if (!classType.shared.namedTupleEntries) {
+            return false;
+        }
+        return classType.shared.namedTupleEntries.has(name);
+    }
+    ClassType.hasNamedTupleEntry = hasNamedTupleEntry;
     // Same as isTypeSame except that it doesn't compare type arguments.
     function isSameGenericClass(classType, type2, recursionCount = 0) {
         if (!classType.priv.isTypedDictPartial !== !type2.priv.isTypedDictPartial) {
@@ -1556,6 +1575,9 @@ var OverloadedType;
         overloads.forEach((overload) => {
             OverloadedType.addOverload(newType, overload);
         });
+        if (implementation && isFunction(implementation)) {
+            implementation.priv.overloaded = newType;
+        }
         return newType;
     }
     OverloadedType.create = create;
@@ -1601,9 +1623,9 @@ var NeverType;
     }
     NeverType.createNoReturn = createNoReturn;
     function convertToInstance(type) {
-        var _a;
-        // Remove the "special form" if present. Otherwise return the existing type.
-        if (!((_a = type.props) === null || _a === void 0 ? void 0 : _a.specialForm)) {
+        var _a, _b;
+        // Remove the specialForm or typeForm if present. Otherwise return the existing type.
+        if (!((_a = type.props) === null || _a === void 0 ? void 0 : _a.specialForm) && !((_b = type.props) === null || _b === void 0 ? void 0 : _b.typeForm)) {
             return type;
         }
         return type.priv.isNoReturn ? NeverType.createNoReturn() : NeverType.createNever();
@@ -1793,7 +1815,7 @@ var UnionType;
     // Determines whether the union contains a specified subtype. If exclusionSet is passed,
     // the method skips any subtype indexes that are in the set and adds a found index to
     // the exclusion set. This speeds up union type comparisons.
-    function containsType(unionType, subtype, exclusionSet, recursionCount = 0) {
+    function containsType(unionType, subtype, options = {}, exclusionSet, recursionCount = 0) {
         var _a;
         // Handle string literals as a special case because unions can sometimes
         // contain hundreds of string literal types.
@@ -1816,7 +1838,7 @@ var UnionType;
             if (exclusionSet === null || exclusionSet === void 0 ? void 0 : exclusionSet.has(i)) {
                 return false;
             }
-            return isTypeSame(t, subtype, {}, recursionCount);
+            return isTypeSame(t, subtype, options, recursionCount);
         });
         if (foundIndex < 0) {
             return false;
@@ -1912,18 +1934,19 @@ var TypeVarType;
     }
     TypeVarType.cloneAsInstantiable = cloneAsInstantiable;
     function cloneForNewName(type, name) {
+        var _a;
         const newInstance = TypeBase.cloneType(type);
         newInstance.shared = { ...type.shared };
         newInstance.shared.name = name;
         if (newInstance.priv.scopeId) {
-            newInstance.priv.nameWithScope = makeNameWithScope(name, newInstance.priv.scopeId);
+            newInstance.priv.nameWithScope = makeNameWithScope(name, newInstance.priv.scopeId, (_a = newInstance.priv.scopeName) !== null && _a !== void 0 ? _a : '');
         }
         return newInstance;
     }
     TypeVarType.cloneForNewName = cloneForNewName;
     function cloneForScopeId(type, scopeId, scopeName, scopeType) {
         const newInstance = TypeBase.cloneType(type);
-        newInstance.priv.nameWithScope = makeNameWithScope(type.shared.name, scopeId);
+        newInstance.priv.nameWithScope = makeNameWithScope(type.shared.name, scopeId, scopeName !== null && scopeName !== void 0 ? scopeName : '');
         newInstance.priv.scopeId = scopeId;
         newInstance.priv.scopeName = scopeName;
         newInstance.priv.scopeType = scopeType;
@@ -2006,8 +2029,12 @@ var TypeVarType;
         return newInstance;
     }
     TypeVarType.cloneAsUnificationVar = cloneAsUnificationVar;
-    function makeNameWithScope(name, scopeId) {
-        return `${name}.${scopeId}`;
+    function makeNameWithScope(name, scopeId, scopeName) {
+        // We include the scopeName here even though it's normally already part
+        // of the scopeId. There are cases where it can diverge, specifically
+        // in scenarios involving higher-order functions that return generic
+        // callable types. See adjustCallableReturnType for details.
+        return `${name}.${scopeId}.${scopeName}`;
     }
     TypeVarType.makeNameWithScope = makeNameWithScope;
     function makeBoundScopeId(scopeId) {
@@ -2203,7 +2230,7 @@ function getTypeAliasInfo(type) {
 // type arguments for "pseudo-generic" classes (non-generic classes whose init
 // methods are not annotated and are therefore treated as generic) are ignored.
 function isTypeSame(type1, type2, options = {}, recursionCount = 0) {
-    var _a, _b, _c, _d, _e, _f;
+    var _a, _b, _c, _d, _e, _f, _g, _h;
     if (type1 === type2) {
         return true;
     }
@@ -2227,6 +2254,21 @@ function isTypeSame(type1, type2, options = {}, recursionCount = 0) {
         return true;
     }
     recursionCount++;
+    if (options.honorTypeForm) {
+        const typeForm1 = (_a = type1.props) === null || _a === void 0 ? void 0 : _a.typeForm;
+        const typeForm2 = (_b = type2.props) === null || _b === void 0 ? void 0 : _b.typeForm;
+        if (typeForm1) {
+            if (!typeForm2) {
+                return false;
+            }
+            if (!isTypeSame(typeForm1, typeForm2, options, recursionCount)) {
+                return false;
+            }
+        }
+        else if (typeForm2) {
+            return false;
+        }
+    }
     switch (type1.category) {
         case 6 /* TypeCategory.Class */: {
             const classType2 = type2;
@@ -2234,7 +2276,7 @@ function isTypeSame(type1, type2, options = {}, recursionCount = 0) {
             if (!ClassType.isSameGenericClass(type1, classType2, recursionCount)) {
                 return false;
             }
-            if (!options.ignoreConditions && !TypeCondition.isSame((_a = type1.props) === null || _a === void 0 ? void 0 : _a.condition, (_b = type2.props) === null || _b === void 0 ? void 0 : _b.condition)) {
+            if (!options.ignoreConditions && !TypeCondition.isSame((_c = type1.props) === null || _c === void 0 ? void 0 : _c.condition, (_d = type2.props) === null || _d === void 0 ? void 0 : _d.condition)) {
                 return false;
             }
             if (!options.ignorePseudoGeneric || !ClassType.isPseudoGenericClass(type1)) {
@@ -2374,7 +2416,7 @@ function isTypeSame(type1, type2, options = {}, recursionCount = 0) {
             // The types do not have a particular order, so we need to
             // do the comparison in an order-independent manner.
             const exclusionSet = new Set();
-            return (findSubtype(type1, (subtype) => !UnionType.containsType(unionType2, subtype, exclusionSet, recursionCount)) === undefined);
+            return (findSubtype(type1, (subtype) => !UnionType.containsType(unionType2, subtype, options, exclusionSet, recursionCount)) === undefined);
         }
         case 9 /* TypeCategory.TypeVar */: {
             const type2TypeVar = type2;
@@ -2384,8 +2426,8 @@ function isTypeSame(type1, type2, options = {}, recursionCount = 0) {
             // Handle the case where this is a generic recursive type alias. Make
             // sure that the type argument types match.
             if (type1.shared.recursiveAlias && type2TypeVar.shared.recursiveAlias) {
-                const type1TypeArgs = ((_d = (_c = type1 === null || type1 === void 0 ? void 0 : type1.props) === null || _c === void 0 ? void 0 : _c.typeAliasInfo) === null || _d === void 0 ? void 0 : _d.typeArgs) || [];
-                const type2TypeArgs = ((_f = (_e = type2 === null || type2 === void 0 ? void 0 : type2.props) === null || _e === void 0 ? void 0 : _e.typeAliasInfo) === null || _f === void 0 ? void 0 : _f.typeArgs) || [];
+                const type1TypeArgs = ((_f = (_e = type1 === null || type1 === void 0 ? void 0 : type1.props) === null || _e === void 0 ? void 0 : _e.typeAliasInfo) === null || _f === void 0 ? void 0 : _f.typeArgs) || [];
+                const type2TypeArgs = ((_h = (_g = type2 === null || type2 === void 0 ? void 0 : type2.props) === null || _g === void 0 ? void 0 : _g.typeAliasInfo) === null || _h === void 0 ? void 0 : _h.typeArgs) || [];
                 const typeArgCount = Math.max(type1TypeArgs.length, type2TypeArgs.length);
                 for (let i = 0; i < typeArgCount; i++) {
                     // Assume that missing type args are "Any".
@@ -2662,7 +2704,7 @@ function _addTypeIfUnique(unionType, typeToAdd, elideRedundantLiterals) {
     for (let i = 0; i < unionType.priv.subtypes.length; i++) {
         const type = unionType.priv.subtypes[i];
         // Does this type already exist in the types array?
-        if (isTypeSame(type, typeToAdd)) {
+        if (isTypeSame(type, typeToAdd, { honorTypeForm: true })) {
             return;
         }
         // Handle the case where pseudo-generic classes with different
@@ -2672,7 +2714,7 @@ function _addTypeIfUnique(unionType, typeToAdd, elideRedundantLiterals) {
         // we can hit recursive cases (where a pseudo-generic class is
         // parameterized with its own class) ad infinitum.
         if (isPseudoGeneric) {
-            if (isTypeSame(type, typeToAdd, { ignorePseudoGeneric: true })) {
+            if (isTypeSame(type, typeToAdd, { ignorePseudoGeneric: true, honorTypeForm: true })) {
                 unionType.priv.subtypes[i] = ClassType.specialize(typeToAdd, typeToAdd.shared.typeParams.map(() => UnknownType.create()));
                 return;
             }