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

package/dist/analyzer/typeUtils.js

@@ -8,7 +8,7 @@
  * Functions that operate on Type objects.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypeVarTransformer = exports.UniqueSignatureTracker = exports.AssignTypeFlags = exports.ClassIteratorFlags = exports.MemberAccessFlags = void 0;
+exports.TypeVarTransformer = exports.UniqueSignatureTracker = exports.ClassIteratorFlags = exports.MemberAccessFlags = void 0;
 exports.isOptionalType = isOptionalType;
 exports.isNoneInstance = isNoneInstance;
 exports.isNoneTypeClass = isNoneTypeClass;
@@ -47,6 +47,8 @@ exports.isLiteralTypeOrUnion = isLiteralTypeOrUnion;
 exports.isLiteralLikeType = isLiteralLikeType;
 exports.containsLiteralType = containsLiteralType;
 exports.getLiteralTypeClassName = getLiteralTypeClassName;
+exports.stripTypeForm = stripTypeForm;
+exports.stripTypeFormRecursive = stripTypeFormRecursive;
 exports.getUnionSubtypeCount = getUnionSubtypeCount;
 exports.isEllipsisType = isEllipsisType;
 exports.isProperty = isProperty;
@@ -72,6 +74,7 @@ exports.getContainerDepth = getContainerDepth;
 exports.lookUpObjectMember = lookUpObjectMember;
 exports.lookUpClassMember = lookUpClassMember;
 exports.getClassMemberIterator = getClassMemberIterator;
+exports.isMemberReadOnly = isMemberReadOnly;
 exports.getClassIterator = getClassIterator;
 exports.getClassFieldsRecursive = getClassFieldsRecursive;
 exports.addTypeVarsToListIfUnique = addTypeVarsToListIfUnique;
@@ -172,64 +175,6 @@ var ClassIteratorFlags;
     // Skip the 'type' base class in particular.
     ClassIteratorFlags[ClassIteratorFlags["SkipTypeBaseClass"] = 4] = "SkipTypeBaseClass";
 })(ClassIteratorFlags || (exports.ClassIteratorFlags = ClassIteratorFlags = {}));
-var AssignTypeFlags;
-(function (AssignTypeFlags) {
-    AssignTypeFlags[AssignTypeFlags["Default"] = 0] = "Default";
-    // Require invariance with respect to class matching? Normally
-    // subclasses are allowed.
-    AssignTypeFlags[AssignTypeFlags["Invariant"] = 1] = "Invariant";
-    // The caller has swapped the source and dest types because
-    // the types are contravariant. Perform type var matching
-    // on dest type vars rather than source type var.
-    AssignTypeFlags[AssignTypeFlags["Contravariant"] = 2] = "Contravariant";
-    // We're comparing type compatibility of two distinct recursive types.
-    // This has the potential of recursing infinitely. This flag allows us
-    // to detect the recursion after the first level of checking.
-    AssignTypeFlags[AssignTypeFlags["SkipRecursiveTypeCheck"] = 4] = "SkipRecursiveTypeCheck";
-    // During TypeVar solving for a function call, this flag is set if
-    // this is the first of multiple passes. It adjusts certain heuristics
-    // for constraint solving.
-    AssignTypeFlags[AssignTypeFlags["ArgAssignmentFirstPass"] = 8] = "ArgAssignmentFirstPass";
-    // If the dest is not Any but the src is Any, treat it
-    // as incompatible. Also, treat all source TypeVars as their
-    // concrete counterparts. This option is used for validating
-    // whether overload signatures overlap.
-    AssignTypeFlags[AssignTypeFlags["OverloadOverlap"] = 16] = "OverloadOverlap";
-    // When used in conjunction with OverloadOverlapCheck, look
-    // for partial overlaps. For example, `int | list` overlaps
-    // partially with `int | str`.
-    AssignTypeFlags[AssignTypeFlags["PartialOverloadOverlap"] = 32] = "PartialOverloadOverlap";
-    // For function types, skip the return type check.
-    AssignTypeFlags[AssignTypeFlags["SkipReturnTypeCheck"] = 64] = "SkipReturnTypeCheck";
-    // In most cases, literals are stripped when assigning to a
-    // type variable. This overrides the standard behavior.
-    AssignTypeFlags[AssignTypeFlags["RetainLiteralsForTypeVar"] = 256] = "RetainLiteralsForTypeVar";
-    // When validating the type of a self or cls parameter, allow
-    // a type mismatch. This is used in overload consistency validation
-    // because overloads can provide explicit type annotations for self
-    // or cls.
-    AssignTypeFlags[AssignTypeFlags["SkipSelfClsTypeCheck"] = 512] = "SkipSelfClsTypeCheck";
-    // We're initially populating the constraints with an expected type,
-    // so TypeVars should match the specified type exactly rather than
-    // employing narrowing or widening. The variance context determines
-    // whether the upper bound, lower bound, or both are established.
-    AssignTypeFlags[AssignTypeFlags["PopulateExpectedType"] = 2048] = "PopulateExpectedType";
-    // Used with PopulatingExpectedType, this flag indicates that a TypeVar
-    // constraint that is Unknown should be ignored.
-    AssignTypeFlags[AssignTypeFlags["SkipPopulateUnknownExpectedType"] = 4096] = "SkipPopulateUnknownExpectedType";
-    // Normally, when a class type is assigned to a TypeVar and that class
-    // hasn't previously been specialized, it will be specialized with
-    // default type arguments (typically "Unknown"). This flag skips
-    // this step.
-    AssignTypeFlags[AssignTypeFlags["AllowUnspecifiedTypeArgs"] = 8192] = "AllowUnspecifiedTypeArgs";
-    // Normally all special form classes are incompatible with type[T],
-    // but a few of them are allowed in the context of an isinstance
-    // or issubclass call.
-    AssignTypeFlags[AssignTypeFlags["AllowIsinstanceSpecialForms"] = 16384] = "AllowIsinstanceSpecialForms";
-    // When comparing two methods, skip the type check for the "self" or "cls"
-    // parameters. This is used for variance inference and validation.
-    AssignTypeFlags[AssignTypeFlags["SkipSelfClsParamCheck"] = 32768] = "SkipSelfClsParamCheck";
-})(AssignTypeFlags || (exports.AssignTypeFlags = AssignTypeFlags = {}));
 // Tracks whether a function signature has been seen before within
 // an expression. For example, in the expression "foo(foo, foo)", the
 // signature for "foo" will be seen three times at three different
@@ -689,6 +634,11 @@ function preserveUnknown(type1, type2) {
 // Determines whether the specified type is a type that can be
 // combined with other types for a union.
 function isUnionableType(subtypes) {
+    // If all of the subtypes are TypeForm types, we know that they
+    // are unionable.
+    if (subtypes.every((t) => { var _a; return ((_a = t.props) === null || _a === void 0 ? void 0 : _a.typeForm) !== undefined; })) {
+        return true;
+    }
     let typeFlags = 2 /* TypeFlags.Instance */ | 1 /* TypeFlags.Instantiable */;
     for (const subtype of subtypes) {
         typeFlags &= subtype.flags;
@@ -1030,6 +980,24 @@ function getLiteralTypeClassName(type) {
     }
     return undefined;
 }
+function stripTypeForm(type) {
+    var _a;
+    if ((_a = type.props) === null || _a === void 0 ? void 0 : _a.typeForm) {
+        return types_1.TypeBase.cloneWithTypeForm(type, undefined);
+    }
+    return type;
+}
+function stripTypeFormRecursive(type, recursionCount = 0) {
+    var _a;
+    if (recursionCount > types_1.maxTypeRecursionCount) {
+        return type;
+    }
+    recursionCount++;
+    if ((_a = type.props) === null || _a === void 0 ? void 0 : _a.typeForm) {
+        type = types_1.TypeBase.cloneWithTypeForm(type, undefined);
+    }
+    return mapSubtypes(type, (subtype) => stripTypeFormRecursive(subtype, recursionCount));
+}
 function getUnionSubtypeCount(type) {
     if ((0, types_1.isUnion)(type)) {
         return type.priv.subtypes.length;
@@ -1183,10 +1151,16 @@ function makeFunctionTypeVarsBound(type) {
     return makeTypeVarsBound(type, scopeIds);
 }
 function makeTypeVarsBound(type, scopeIds) {
+    if (scopeIds && scopeIds.length === 0) {
+        return type;
+    }
     const transformer = new BoundTypeVarTransform(scopeIds);
     return transformer.apply(type, 0);
 }
 function makeTypeVarsFree(type, scopeIds) {
+    if (scopeIds.length === 0) {
+        return type;
+    }
     const transformer = new FreeTypeVarTransform(scopeIds);
     return transformer.apply(type, 0);
 }
@@ -1248,6 +1222,7 @@ function getProtocolSymbolsRecursive(classType, symbolMap, classFlags = 512 /* C
                 isInstanceMember: symbol.isInstanceMember(),
                 isClassMember: symbol.isClassMember(),
                 isClassVar: (0, symbolUtils_1.isEffectivelyClassVar)(symbol, /* isDataclass */ false),
+                isReadOnly: false,
                 isTypeDeclared: symbol.hasTypedDeclarations(),
                 skippedUndeclaredType: false,
             });
@@ -1358,6 +1333,7 @@ function* getClassMemberIterator(classType, memberName, flags = 0 /* MemberAcces
                         isClassVar: false,
                         classType,
                         unspecializedClassType: classType,
+                        isReadOnly: false,
                         isTypeDeclared: false,
                         skippedUndeclaredType: false,
                     };
@@ -1382,6 +1358,7 @@ function* getClassMemberIterator(classType, memberName, flags = 0 /* MemberAcces
                             isClassVar: (0, symbolUtils_1.isEffectivelyClassVar)(symbol, types_1.ClassType.isDataClass(specializedMroClass)),
                             classType: specializedMroClass,
                             unspecializedClassType: mroClass,
+                            isReadOnly: isMemberReadOnly(specializedMroClass, memberName),
                             isTypeDeclared: hasDeclaredType,
                             skippedUndeclaredType,
                         };
@@ -1421,6 +1398,7 @@ function* getClassMemberIterator(classType, memberName, flags = 0 /* MemberAcces
                             isClassVar: (0, symbolUtils_1.isEffectivelyClassVar)(symbol, isDataclass),
                             classType: specializedMroClass,
                             unspecializedClassType: mroClass,
+                            isReadOnly: false,
                             isTypeDeclared: hasDeclaredType,
                             skippedUndeclaredType,
                         };
@@ -1443,6 +1421,7 @@ function* getClassMemberIterator(classType, memberName, flags = 0 /* MemberAcces
             isClassVar: false,
             classType,
             unspecializedClassType: classType,
+            isReadOnly: false,
             isTypeDeclared: false,
             skippedUndeclaredType: false,
         };
@@ -1450,6 +1429,21 @@ function* getClassMemberIterator(classType, memberName, flags = 0 /* MemberAcces
     }
     return undefined;
 }
+// Checks for whether the member is effectively read only because it
+// belongs to a frozen dataclass or a named tuple.
+function isMemberReadOnly(classType, name) {
+    var _a;
+    if (types_1.ClassType.hasNamedTupleEntry(classType, name)) {
+        return true;
+    }
+    if (types_1.ClassType.isDataClassFrozen(classType)) {
+        const dcEntries = (_a = classType.shared) === null || _a === void 0 ? void 0 : _a.dataClassEntries;
+        if (dcEntries === null || dcEntries === void 0 ? void 0 : dcEntries.some((entry) => entry.name === name)) {
+            return true;
+        }
+    }
+    return false;
+}
 function* getClassIterator(classType, flags = 0 /* ClassIteratorFlags.Default */, skipMroClass) {
     if ((0, types_1.isClass)(classType)) {
         let foundSkipMroClass = skipMroClass === undefined;
@@ -1509,6 +1503,7 @@ function getClassFieldsRecursive(classType) {
                         isInstanceMember: symbol.isInstanceMember(),
                         isClassMember: symbol.isClassMember(),
                         isClassVar: (0, symbolUtils_1.isEffectivelyClassVar)(symbol, types_1.ClassType.isDataClass(specializedMroClass)),
+                        isReadOnly: isMemberReadOnly(specializedMroClass, name),
                         isTypeDeclared: true,
                         skippedUndeclaredType: false,
                     });
@@ -1680,8 +1675,9 @@ function synthesizeTypeVarForSelfCls(classType, isClsParam) {
     const scopeId = (_a = getTypeVarScopeId(classType)) !== null && _a !== void 0 ? _a : '';
     selfType.shared.isSynthesized = true;
     selfType.shared.isSynthesizedSelf = true;
-    selfType.priv.nameWithScope = types_1.TypeVarType.makeNameWithScope(selfType.shared.name, scopeId);
     selfType.priv.scopeId = scopeId;
+    selfType.priv.scopeName = '';
+    selfType.priv.nameWithScope = types_1.TypeVarType.makeNameWithScope(selfType.shared.name, scopeId, selfType.priv.scopeName);
     const boundType = types_1.ClassType.specialize(classType, 
     /* typeArgs */ undefined, 
     /* isTypeArgExplicit */ false, 
@@ -3284,6 +3280,11 @@ class ApplySolvedTypeVarsTransformer extends TypeVarTransformer {
         if (solutionSets.length <= 1) {
             return callback();
         }
+        // Handle the case where we're already processing one of the signature contexts
+        // and are called recursively. Don't loop over all the signature contexts again.
+        if (this._activeConstraintSetIndex !== undefined) {
+            return callback();
+        }
         // Loop through all of the signature contexts in the type var context
         // to create an overload type.
         const overloadTypes = solutionSets.map((_, index) => {