@zzzen/pyright-internal 1.2.0-dev.20240929 → 1.2.0-dev.20241013

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;
@@ -110,7 +112,6 @@ exports.combineVariances = combineVariances;
 exports.isVarianceOfTypeArgCompatible = isVarianceOfTypeArgCompatible;
 exports.computeMroLinearization = computeMroLinearization;
 exports.getDeclaringModulesForType = getDeclaringModulesForType;
-exports.convertNodeToArg = convertNodeToArg;
 exports.convertTypeToParamSpecValue = convertTypeToParamSpecValue;
 exports.simplifyFunctionToParamSpec = simplifyFunctionToParamSpec;
 const collectionUtils_1 = require("../common/collectionUtils");
@@ -502,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;
@@ -863,7 +878,7 @@ function getUnknownTypeForCallable() {
 // "self specializes" the class, filling in its own type parameters
 // as type arguments.
 function selfSpecializeClass(type, options) {
-    if (type.shared.typeParams.length === 0) {
+    if (!requiresTypeArgs(type)) {
         return type;
     }
     if (type.priv.typeArgs && !(options === null || options === void 0 ? void 0 : options.overrideTypeArgs)) {
@@ -1067,7 +1082,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.
@@ -1075,7 +1090,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;
@@ -1188,10 +1203,10 @@ function validateTypeVarDefault(typeVar, liveTypeParams, invalidTypeVars) {
 // During bidirectional type inference for constructors, an "expected type"
 // is used to prepopulate the type var map. This is problematic when the
 // expected type uses TypeVars that are not part of the context of the
-// class we are constructing. We'll replace these type variables with dummy
-// type variables.
+// class we are constructing. We'll replace these type variables with
+// so-called "unification" type variables.
 function transformExpectedType(expectedType, liveTypeVarScopes, usageOffset) {
-    const transformer = new ExpectedTypeTransformer(liveTypeVarScopes, usageOffset);
+    const transformer = new UnificationTypeTransformer(liveTypeVarScopes, usageOffset);
     return transformer.apply(expectedType, 0);
 }
 // Given a protocol class (or abstract class), this function returns
@@ -2114,13 +2129,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
@@ -2139,6 +2168,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) {
@@ -2226,6 +2280,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));
             }
@@ -2492,13 +2551,6 @@ function getDeclaringModulesForType(type) {
     addDeclaringModuleNamesForType(type, moduleList);
     return moduleList;
 }
-function convertNodeToArg(node) {
-    return {
-        argCategory: node.d.argCategory,
-        name: node.d.name,
-        valueExpression: node.d.valueExpr,
-    };
-}
 function addDeclaringModuleNamesForType(type, moduleList, recursionCount = 0) {
     if (recursionCount > types_1.maxTypeRecursionCount) {
         return;
@@ -2810,6 +2862,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[()].
@@ -3189,6 +3244,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) &&
@@ -3197,6 +3258,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;
             }
@@ -3368,7 +3432,7 @@ class ApplySolvedTypeVarsTransformer extends TypeVarTransformer {
         return result;
     }
 }
-class ExpectedTypeTransformer extends TypeVarTransformer {
+class UnificationTypeTransformer extends TypeVarTransformer {
     constructor(_liveTypeVarScopes, _usageOffset) {
         super();
         this._liveTypeVarScopes = _liveTypeVarScopes;