@zzzen/pyright-internal 1.2.0-dev.20241006 → 1.2.0-dev.20241020

package/dist/analyzer/typeUtils.d.ts

@@ -60,6 +60,10 @@ export interface ApplyTypeVarOptions {
         eliminateUnsolvedInUnions?: boolean;
     };
 }
+export interface AddConditionOptions {
+    skipSelfCondition?: boolean;
+    skipBoundTypeVars?: boolean;
+}
 export declare class UniqueSignatureTracker {
     private _trackedSignatures;
     constructor();
@@ -95,7 +99,7 @@ export declare function preserveUnknown(type1: Type, type2: Type): AnyType | Unk
 export declare function isUnionableType(subtypes: Type[]): boolean;
 export declare function derivesFromAnyOrUnknown(type: Type): boolean;
 export declare function getFullNameOfType(type: Type): string | undefined;
-export declare function addConditionToType<T extends Type>(type: T, condition: TypeCondition[] | undefined, skipSelfCondition?: boolean): T;
+export declare function addConditionToType<T extends Type>(type: T, condition: TypeCondition[] | undefined, options?: AddConditionOptions): T;
 export declare function getTypeCondition(type: Type): TypeCondition[] | undefined;
 export declare function isTypeAliasPlaceholder(type: Type): boolean;
 export declare function isTypeAliasRecursive(typeAliasPlaceholder: TypeVarType, type: Type): boolean | undefined;
@@ -173,6 +177,8 @@ export declare function explodeGenericClass(classType: ClassType): Type;
 export declare function combineSameSizedTuples(type: Type, tupleType: Type | undefined): Type;
 export declare function combineTupleTypeArgs(typeArgs: TupleTypeArg[]): Type;
 export declare function specializeTupleClass(classType: ClassType, typeArgs: TupleTypeArg[], isTypeArgExplicit?: boolean, isUnpacked?: boolean): ClassType;
+export declare function makePacked(type: Type): Type;
+export declare function makeUnpacked(type: Type): Type;
 export declare function getGeneratorTypeArgs(returnType: Type): Type[] | undefined;
 export declare function requiresTypeArgs(classType: ClassType): boolean;
 export declare function requiresSpecialization(type: Type, options?: RequiresSpecializationOptions, recursionCount?: number): boolean;

package/dist/analyzer/typeUtils.js

@@ -102,6 +102,8 @@ exports.explodeGenericClass = explodeGenericClass;
 exports.combineSameSizedTuples = combineSameSizedTuples;
 exports.combineTupleTypeArgs = combineTupleTypeArgs;
 exports.specializeTupleClass = specializeTupleClass;
+exports.makePacked = makePacked;
+exports.makeUnpacked = makeUnpacked;
 exports.getGeneratorTypeArgs = getGeneratorTypeArgs;
 exports.requiresTypeArgs = requiresTypeArgs;
 exports.requiresSpecialization = requiresSpecialization;
@@ -501,6 +503,20 @@ function compareTypes(a, b, recursionCount = 0) {
                 if (!isLiteralType(bClass)) {
                     return -1;
                 }
+                else if (types_1.ClassType.isSameGenericClass(a, bClass)) {
+                    // Sort by literal value.
+                    const aLiteralValue = a.priv.literalValue;
+                    const bLiteralValue = bClass.priv.literalValue;
+                    if ((typeof aLiteralValue === 'string' && typeof bLiteralValue === 'string') ||
+                        (typeof aLiteralValue === 'number' && typeof bLiteralValue === 'number')) {
+                        if (aLiteralValue < bLiteralValue) {
+                            return -1;
+                        }
+                        else if (aLiteralValue > bLiteralValue) {
+                            return 1;
+                        }
+                    }
+                }
             }
             else if (isLiteralType(bClass)) {
                 return 1;
@@ -696,17 +712,23 @@ function getFullNameOfType(type) {
     }
     return undefined;
 }
-function addConditionToType(type, condition, skipSelfCondition = false) {
+function addConditionToType(type, condition, options) {
     var _a, _b;
     if (!condition) {
         return type;
     }
-    if (skipSelfCondition) {
+    if (options === null || options === void 0 ? void 0 : options.skipSelfCondition) {
         condition = condition.filter((c) => !types_1.TypeVarType.isSelf(c.typeVar));
         if (condition.length === 0) {
             return type;
         }
     }
+    if (options === null || options === void 0 ? void 0 : options.skipBoundTypeVars) {
+        condition = condition.filter((c) => c.typeVar.shared.constraints.length > 0);
+        if (condition.length === 0) {
+            return type;
+        }
+    }
     switch (type.category) {
         case 0 /* TypeCategory.Unbound */:
         case 1 /* TypeCategory.Unknown */:
@@ -862,6 +884,8 @@ function getUnknownTypeForCallable() {
 // "self specializes" the class, filling in its own type parameters
 // as type arguments.
 function selfSpecializeClass(type, options) {
+    // We can't use requiresTypeArgs(type) here because it returns false
+    // if the type parameters have default values.
     if (type.shared.typeParams.length === 0) {
         return type;
     }
@@ -1066,7 +1090,7 @@ function isTupleClass(type) {
 // in the tuple is unknown.
 function isUnboundedTupleClass(type) {
     var _a;
-    return (_a = type.priv.tupleTypeArgs) === null || _a === void 0 ? void 0 : _a.some((t) => t.isUnbounded || (0, types_1.isUnpackedTypeVarTuple)(t.type));
+    return (_a = type.priv.tupleTypeArgs) === null || _a === void 0 ? void 0 : _a.some((t) => t.isUnbounded || (0, types_1.isUnpackedTypeVarTuple)(t.type) || (0, types_1.isUnpackedTypeVar)(t.type));
 }
 // Indicates whether the specified index is within range and its type is unambiguous
 // in that it doesn't involve any element ranges that are of indeterminate length.
@@ -1074,7 +1098,7 @@ function isTupleIndexUnambiguous(type, index) {
     if (!type.priv.tupleTypeArgs) {
         return false;
     }
-    const unboundedIndex = type.priv.tupleTypeArgs.findIndex((t) => t.isUnbounded || (0, types_1.isUnpackedTypeVarTuple)(t.type));
+    const unboundedIndex = type.priv.tupleTypeArgs.findIndex((t) => t.isUnbounded || (0, types_1.isUnpackedTypeVarTuple)(t.type) || (0, types_1.isUnpackedTypeVar)(t.type));
     if (index < 0) {
         const lowerIndexLimit = unboundedIndex < 0 ? 0 : unboundedIndex;
         index += type.priv.tupleTypeArgs.length;
@@ -1371,7 +1395,7 @@ function* getClassMemberIterator(classType, memberName, flags = 0 /* MemberAcces
             }
             // Next look at class members.
             if ((flags & 32 /* MemberAccessFlags.SkipClassMembers */) === 0) {
-                const symbol = memberFields.get(memberName);
+                let symbol = memberFields.get(memberName);
                 if (symbol && symbol.isClassMember()) {
                     const hasDeclaredType = symbol.hasTypedDeclarations();
                     if (!declaredTypesOnly || hasDeclaredType) {
@@ -1391,6 +1415,12 @@ function* getClassMemberIterator(classType, memberName, flags = 0 /* MemberAcces
                                 isClassMember = isDataclass;
                             }
                         }
+                        // Handle the special case of a __call__ class member in a partial class.
+                        if (memberName === '__call__' &&
+                            classType.priv.partialCallType &&
+                            types_1.ClassType.isSameGenericClass(classType, specializedMroClass)) {
+                            symbol = symbol_1.Symbol.createWithType(4 /* SymbolFlags.ClassMember */, classType.priv.partialCallType);
+                        }
                         const cm = {
                             symbol,
                             isInstanceMember,
@@ -2113,13 +2143,27 @@ function combineSameSizedTuples(type, tupleType) {
     })));
 }
 function combineTupleTypeArgs(typeArgs) {
-    return (0, types_1.combineTypes)(typeArgs.map((t) => {
-        if ((0, types_1.isTypeVar)(t.type) && (0, types_1.isUnpackedTypeVarTuple)(t.type)) {
-            // Treat the unpacked TypeVarTuple as a union.
-            return types_1.TypeVarType.cloneForUnpacked(t.type, /* isInUnion */ true);
+    const typesToCombine = [];
+    typeArgs.forEach((t) => {
+        if ((0, types_1.isTypeVar)(t.type)) {
+            if ((0, types_1.isUnpackedTypeVarTuple)(t.type)) {
+                // Treat the unpacked TypeVarTuple as a union.
+                typesToCombine.push(types_1.TypeVarType.cloneForUnpacked(t.type, /* isInUnion */ true));
+                return;
+            }
+            if ((0, types_1.isUnpackedTypeVar)(t.type)) {
+                if (t.type.shared.boundType &&
+                    (0, types_1.isClassInstance)(t.type.shared.boundType) &&
+                    isTupleClass(t.type.shared.boundType) &&
+                    t.type.shared.boundType.priv.tupleTypeArgs) {
+                    typesToCombine.push(combineTupleTypeArgs(t.type.shared.boundType.priv.tupleTypeArgs));
+                }
+                return;
+            }
         }
-        return t.type;
-    }));
+        typesToCombine.push(t.type);
+    });
+    return (0, types_1.combineTypes)(typesToCombine);
 }
 // Tuples require special handling for specialization. This method computes
 // the "effective" type argument, which is a union of the variadic type
@@ -2138,6 +2182,31 @@ function _expandUnpackedTypeVarTupleUnion(type) {
     }
     return type;
 }
+// If this is an unpacked type, returns the type as no longer unpacked.
+function makePacked(type) {
+    if ((0, types_1.isUnpackedClass)(type)) {
+        return types_1.ClassType.cloneForPacked(type);
+    }
+    if ((0, types_1.isUnpackedTypeVarTuple)(type) && !type.priv.isInUnion) {
+        return types_1.TypeVarType.cloneForPacked(type);
+    }
+    if ((0, types_1.isUnpackedTypeVar)(type)) {
+        return types_1.TypeVarType.cloneForPacked(type);
+    }
+    return type;
+}
+function makeUnpacked(type) {
+    if ((0, types_1.isClass)(type)) {
+        return types_1.ClassType.cloneForUnpacked(type);
+    }
+    if ((0, types_1.isTypeVarTuple)(type) && !type.priv.isInUnion) {
+        return types_1.TypeVarType.cloneForUnpacked(type);
+    }
+    if ((0, types_1.isTypeVar)(type)) {
+        return types_1.TypeVarType.cloneForUnpacked(type);
+    }
+    return type;
+}
 // If the declared return type for the function is a Generator or AsyncGenerator,
 // returns the type arguments for the type.
 function getGeneratorTypeArgs(returnType) {
@@ -2225,6 +2294,11 @@ function _requiresSpecialization(type, options, recursionCount = 0) {
             if (!type.priv.isTypeArgExplicit && (options === null || options === void 0 ? void 0 : options.ignoreImplicitTypeArgs)) {
                 return false;
             }
+            if (type.priv.tupleTypeArgs) {
+                if (type.priv.tupleTypeArgs.some((typeArg) => requiresSpecialization(typeArg.type, options, recursionCount))) {
+                    return true;
+                }
+            }
             if (type.priv.typeArgs) {
                 return type.priv.typeArgs.some((typeArg) => requiresSpecialization(typeArg, options, recursionCount));
             }
@@ -2802,6 +2876,9 @@ class TypeVarTransformer {
                         newTypeArgType.priv.tupleTypeArgs) {
                         (0, collectionUtils_1.appendArray)(newTupleTypeArgs, newTypeArgType.priv.tupleTypeArgs);
                     }
+                    else if ((0, types_1.isUnpackedClass)(newTypeArgType) && newTypeArgType.priv.tupleTypeArgs) {
+                        (0, collectionUtils_1.appendArray)(newTupleTypeArgs, newTypeArgType.priv.tupleTypeArgs);
+                    }
                     else {
                         // Handle the special case where tuple[T, ...] is being specialized
                         // to tuple[Never, ...]. This is equivalent to tuple[()].
@@ -3181,6 +3258,12 @@ class ApplySolvedTypeVarsTransformer extends TypeVarTransformer {
             if ((0, types_1.isTypeVarTuple)(replacement) && (0, types_1.isTypeVarTuple)(typeVar) && typeVar.priv.isUnpacked) {
                 return types_1.TypeVarType.cloneForUnpacked(replacement, typeVar.priv.isInUnion);
             }
+            if (!(0, types_1.isTypeVarTuple)(replacement) &&
+                (0, types_1.isTypeVar)(replacement) &&
+                (0, types_1.isTypeVar)(typeVar) &&
+                typeVar.priv.isUnpacked) {
+                return types_1.TypeVarType.cloneForUnpacked(replacement);
+            }
             // If this isn't a TypeVarTuple, combine all of the tuple
             // type args into a common type.
             if (!(0, types_1.isTypeVarTuple)(typeVar) &&
@@ -3189,6 +3272,9 @@ class ApplySolvedTypeVarsTransformer extends TypeVarTransformer {
                 replacement.priv.isUnpacked) {
                 replacement = combineTupleTypeArgs(replacement.priv.tupleTypeArgs);
             }
+            if ((0, types_1.isUnpackedTypeVar)(typeVar) && (0, types_1.isClass)(replacement)) {
+                replacement = types_1.ClassType.cloneForUnpacked(replacement);
+            }
             if (!(0, types_1.isTypeVar)(replacement) || !types_1.TypeVarType.isUnification(replacement) || !this._options.replaceUnsolved) {
                 return replacement;
             }