@zzzen/pyright-internal 1.2.0-dev.20261018 → 1.2.0-dev.20261101

package/dist/analyzer/types.js

@@ -8,7 +8,7 @@
  * Representation of types used during type analysis within Python.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-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.OverloadResultType = exports.UnknownType = exports.UnboundType = exports.TypeBase = exports.maxTypeRecursionCount = exports.SentinelLiteral = exports.EnumLiteral = exports.UnificationScopeId = exports.TypeFlags = exports.TypeCategory = void 0;
+exports.maxSubtypesForInferredType = 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.OverloadResultType = exports.UnknownType = exports.UnboundType = exports.TypeBase = exports.maxTypeRecursionCount = exports.SentinelLiteral = exports.EnumLiteral = exports.UnificationScopeId = exports.TypeFlags = exports.TypeCategory = void 0;
 exports.isPositionOnlySeparator = isPositionOnlySeparator;
 exports.isKeywordOnlySeparator = isKeywordOnlySeparator;
 exports.isNever = isNever;
@@ -40,6 +40,11 @@ exports.removeUnknownFromUnion = removeUnknownFromUnion;
 exports.removeUnbound = removeUnbound;
 exports.removeFromUnion = removeFromUnion;
 exports.findSubtype = findSubtype;
+exports.getInferredTupleLiteralBase = getInferredTupleLiteralBase;
+exports.getTupleLiteralTypeComplexity = getTupleLiteralTypeComplexity;
+exports.retainInferredTupleLiterals = retainInferredTupleLiterals;
+exports.preserveInferredTupleLiterals = preserveInferredTupleLiterals;
+exports.exceedsInferredTupleLiteralProduct = exceedsInferredTupleLiteralProduct;
 exports.combineTypes = combineTypes;
 exports.isSameWithoutLiteralValue = isSameWithoutLiteralValue;
 const collectionUtils_1 = require("../common/collectionUtils");
@@ -539,6 +544,16 @@ var ClassType;
         if (includeSubclasses) {
             newInstance.priv.includeSubclasses = true;
         }
+        const inferred = newInstance.props?.inferredTupleLiteral;
+        if (inferred) {
+            const convert = (base) => isInstantiableClass(base) ? cloneAsInstance(base, includeSubclasses) : base;
+            TypeBase.addProps(newInstance).inferredTupleLiteral = {
+                ...inferred,
+                baseType: isUnion(inferred.baseType)
+                    ? combineTypes(inferred.baseType.priv.subtypes.map(convert))
+                    : convert(inferred.baseType),
+            };
+        }
         return newInstance;
     }
     ClassType.cloneAsInstance = cloneAsInstance;
@@ -550,6 +565,16 @@ var ClassType;
         if (includeSubclasses) {
             newInstance.priv.includeSubclasses = true;
         }
+        const inferred = newInstance.props?.inferredTupleLiteral;
+        if (inferred) {
+            const convert = (base) => isClassInstance(base) ? cloneAsInstantiable(base, includeSubclasses) : base;
+            TypeBase.addProps(newInstance).inferredTupleLiteral = {
+                ...inferred,
+                baseType: isUnion(inferred.baseType)
+                    ? combineTypes(inferred.baseType.priv.subtypes.map(convert))
+                    : convert(inferred.baseType),
+            };
+        }
         return newInstance;
     }
     ClassType.cloneAsInstantiable = cloneAsInstantiable;
@@ -569,6 +594,35 @@ var ClassType;
         if (isEmptyContainer !== undefined) {
             newClassType.priv.isEmptyContainer = isEmptyContainer;
         }
+        const inferredTupleLiteral = classType.props?.inferredTupleLiteral;
+        const hasInferredEntries = tupleTypeArgs
+            ? tupleTypeArgs.some((arg) => arg.type.props?.inferredTupleLiteral)
+            : typeArgs?.some((type) => type.props?.inferredTupleLiteral);
+        const unchangedTupleArgs = (inferredTupleLiteral || hasInferredEntries) &&
+            tupleTypeArgs &&
+            tupleTypeArgs.length === classType.priv.tupleTypeArgs?.length &&
+            tupleTypeArgs.every((arg, index) => arg.type === classType.priv.tupleTypeArgs[index].type &&
+                arg.isUnbounded === classType.priv.tupleTypeArgs[index].isUnbounded &&
+                arg.isOptional === classType.priv.tupleTypeArgs[index].isOptional);
+        if (inferredTupleLiteral && !unchangedTupleArgs) {
+            TypeBase.addProps(newClassType).inferredTupleLiteral = undefined;
+        }
+        if (hasInferredEntries && !unchangedTupleArgs) {
+            const baseType = TypeBase.cloneType(newClassType);
+            TypeBase.addProps(baseType).inferredTupleLiteral = undefined;
+            baseType.priv.typeArgs = typeArgs?.map(getInferredTupleLiteralBase);
+            baseType.priv.tupleTypeArgs = tupleTypeArgs?.map((arg) => ({
+                ...arg,
+                type: getInferredTupleLiteralBase(arg.type),
+            }));
+            const complexity = ClassType.isBuiltIn(newClassType, 'tuple')
+                ? getTupleLiteralTypeComplexity([newClassType])
+                : undefined;
+            if (!complexity) {
+                return baseType;
+            }
+            TypeBase.addProps(newClassType).inferredTupleLiteral = { baseType, ...complexity };
+        }
         return newClassType;
     }
     ClassType.specialize = specialize;
@@ -584,6 +638,9 @@ var ClassType;
     function cloneWithLiteral(classType, value) {
         const newClassType = TypeBase.cloneType(classType);
         newClassType.priv.literalValue = value;
+        if (value === undefined && newClassType.props?.inferredTupleLiteral) {
+            TypeBase.addProps(newClassType).inferredTupleLiteral = undefined;
+        }
         // Remove type alias information because the type will no longer match
         // that of the type alias definition if we change the literal type.
         if (newClassType.props?.typeAliasInfo) {
@@ -2765,11 +2822,132 @@ function findSubtype(type, filter) {
     }
     return filter(type) ? type : undefined;
 }
+exports.maxSubtypesForInferredType = 64;
+function getInferredTupleLiteralBase(type) {
+    return type.props?.inferredTupleLiteral?.baseType ?? type;
+}
+// Bound both the representation and its possible combinations before building unions.
+function getTupleLiteralTypeComplexity(types, isUnionCombination = false) {
+    let size = 0;
+    const visit = (type, depth) => {
+        if (++size > exports.maxSubtypesForInferredType || depth > exports.maxTypeRecursionCount) {
+            return undefined;
+        }
+        if (isUnion(type)) {
+            let alternatives = 0;
+            for (const subtype of type.priv.subtypes) {
+                const count = visit(subtype, depth + 1);
+                if (count === undefined || (alternatives += count) > exports.maxSubtypesForInferredType) {
+                    return undefined;
+                }
+            }
+            return alternatives;
+        }
+        if (!isClass(type)) {
+            return undefined;
+        }
+        if (ClassType.isBuiltIn(type, 'tuple') && type.priv.tupleTypeArgs) {
+            let alternatives = 1;
+            for (const arg of type.priv.tupleTypeArgs) {
+                if (arg.isUnbounded || arg.isOptional) {
+                    return undefined;
+                }
+                const count = visit(arg.type, depth + 1);
+                if (count === undefined || (alternatives *= count) > exports.maxSubtypesForInferredType) {
+                    return undefined;
+                }
+            }
+            return alternatives;
+        }
+        return type.priv.typeArgs?.length ? undefined : 1;
+    };
+    let alternatives = isUnionCombination ? 0 : 1;
+    for (const type of types) {
+        const count = visit(type, 0);
+        if (count === undefined) {
+            return undefined;
+        }
+        alternatives = isUnionCombination ? alternatives + count : alternatives * count;
+        if (alternatives > exports.maxSubtypesForInferredType) {
+            return undefined;
+        }
+    }
+    return { size, alternatives };
+}
+function retainInferredTupleLiterals(type, baseType) {
+    if (type === baseType) {
+        return baseType;
+    }
+    const complexity = getTupleLiteralTypeComplexity([type]);
+    if (!complexity || isTypeSame(type, baseType)) {
+        return baseType;
+    }
+    if (isUnion(type) &&
+        type.priv.subtypes.some((subtype) => isClass(subtype) && subtype.priv.literalValue !== undefined)) {
+        type = _combineTypes(type.priv.subtypes.map((subtype) => isClass(subtype) && subtype.priv.literalValue !== undefined
+            ? retainInferredTupleLiterals(subtype, ClassType.cloneWithLiteral(subtype, /* value */ undefined))
+            : subtype));
+    }
+    const retainedType = TypeBase.cloneType(type);
+    TypeBase.addProps(retainedType).inferredTupleLiteral = { baseType, ...complexity };
+    return retainedType;
+}
+// A validated annotation opts into its literal precision, independently of inference.
+function preserveInferredTupleLiterals(type) {
+    if (!type.props?.inferredTupleLiteral) {
+        return type;
+    }
+    if (isUnion(type)) {
+        return combineTypes(type.priv.subtypes.map(preserveInferredTupleLiterals));
+    }
+    const result = TypeBase.cloneType(type);
+    TypeBase.addProps(result).inferredTupleLiteral = undefined;
+    if (isClass(result)) {
+        result.priv.typeArgs = result.priv.typeArgs?.map(preserveInferredTupleLiterals);
+        result.priv.tupleTypeArgs = result.priv.tupleTypeArgs?.map((arg) => ({
+            ...arg,
+            type: preserveInferredTupleLiterals(arg.type),
+        }));
+    }
+    return result;
+}
+function exceedsInferredTupleLiteralProduct(left, right) {
+    const leftInfo = left.props?.inferredTupleLiteral;
+    const rightInfo = right.props?.inferredTupleLiteral;
+    if (!leftInfo && !rightInfo) {
+        return false;
+    }
+    const leftCount = leftInfo?.alternatives ?? getTupleLiteralTypeComplexity([left])?.alternatives;
+    const rightCount = rightInfo?.alternatives ?? getTupleLiteralTypeComplexity([right])?.alternatives;
+    return leftCount === undefined || rightCount === undefined || leftCount * rightCount > exports.maxSubtypesForInferredType;
+}
 // 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.
 // If no types remain in the end, a NeverType is returned.
 function combineTypes(subtypes, options) {
+    if (subtypes.length === 1) {
+        return subtypes[0];
+    }
+    if (!subtypes.some((type) => type.props?.inferredTupleLiteral)) {
+        return _combineTypes(subtypes, options);
+    }
+    if (subtypes.every((type) => type === subtypes[0])) {
+        return subtypes[0];
+    }
+    const baseType = _combineTypes(subtypes.map(getInferredTupleLiteralBase), options);
+    const complexity = getTupleLiteralTypeComplexity(subtypes, /* isUnion */ true);
+    if (!complexity) {
+        return baseType;
+    }
+    const structuralCount = subtypes.reduce((count, type) => count +
+        (isUnion(type) ? type.priv.subtypes : [type]).filter((subtype) => isClass(subtype) && !!subtype.priv.tupleTypeArgs).length, 0);
+    if ((structuralCount * (structuralCount - 1)) / 2 > exports.maxSubtypesForInferredType) {
+        return baseType;
+    }
+    return retainInferredTupleLiterals(_combineTypes(subtypes, options), baseType);
+}
+function _combineTypes(subtypes, options) {
     let neverTypes;
     // Filter out any Never or NoReturn types.
     [neverTypes, subtypes] = (0, collectionUtils_1.partition)(subtypes, isNever);
@@ -2898,26 +3076,20 @@ function _addTypeIfUnique(unionType, typeToAdd, elideRedundantLiterals) {
         if (ClassType.isBuiltIn(typeToAdd, 'str') &&
             typeToAdd.priv.literalValue !== undefined &&
             literalMaps.literalStrMap !== undefined) {
-            if (!literalMaps.literalStrMap.has(typeToAdd.priv.literalValue)) {
-                UnionType.addType(unionType, typeToAdd);
-            }
+            _addLiteralTypeIfUnique(unionType, literalMaps.literalStrMap, typeToAdd.priv.literalValue, typeToAdd);
             return;
         }
         else if (ClassType.isBuiltIn(typeToAdd, 'int') &&
             typeToAdd.priv.literalValue !== undefined &&
             literalMaps.literalIntMap !== undefined) {
-            if (!literalMaps.literalIntMap.has(typeToAdd.priv.literalValue)) {
-                UnionType.addType(unionType, typeToAdd);
-            }
+            _addLiteralTypeIfUnique(unionType, literalMaps.literalIntMap, typeToAdd.priv.literalValue, typeToAdd);
             return;
         }
         else if (ClassType.isEnumClass(typeToAdd) &&
             typeToAdd.priv.literalValue !== undefined &&
             literalMaps.literalEnumMap !== undefined) {
             const enumLiteral = typeToAdd.priv.literalValue;
-            if (!literalMaps.literalEnumMap.has(enumLiteral.getName())) {
-                UnionType.addType(unionType, typeToAdd);
-            }
+            _addLiteralTypeIfUnique(unionType, literalMaps.literalEnumMap, enumLiteral.getName(), typeToAdd);
             return;
         }
     }
@@ -2933,6 +3105,7 @@ function _addTypeIfUnique(unionType, typeToAdd, elideRedundantLiterals) {
         }
         // Does this type already exist in the types array?
         if (isTypeSame(type, typeToAdd, { honorTypeForm: true })) {
+            unionType.priv.subtypes[i] = _mergeInferredTupleLiterals(type, typeToAdd);
             return;
         }
         // Handle the case where pseudo-generic classes with different
@@ -2999,4 +3172,36 @@ function _addTypeIfUnique(unionType, typeToAdd, elideRedundantLiterals) {
     }
     UnionType.addType(unionType, typeToAdd);
 }
+function _addLiteralTypeIfUnique(unionType, literalMap, key, typeToAdd) {
+    const previous = literalMap.get(key);
+    if (!previous) {
+        UnionType.addType(unionType, typeToAdd);
+    }
+    else if (previous.props?.inferredTupleLiteral || typeToAdd.props?.inferredTupleLiteral) {
+        const merged = _mergeInferredTupleLiterals(previous, typeToAdd);
+        unionType.priv.subtypes[unionType.priv.subtypes.indexOf(previous)] = merged;
+        literalMap.set(key, merged);
+    }
+}
+function _mergeInferredTupleLiterals(type, other) {
+    if (type === other ||
+        (!type.props?.inferredTupleLiteral && !other.props?.inferredTupleLiteral) ||
+        !isClass(type) ||
+        !isClass(other)) {
+        return type;
+    }
+    const result = TypeBase.cloneType(type);
+    result.priv.typeArgs = type.priv.typeArgs?.map((arg, index) => combineTypes([arg, other.priv.typeArgs?.[index] ?? arg]));
+    result.priv.tupleTypeArgs = type.priv.tupleTypeArgs?.map((arg, index) => ({
+        ...arg,
+        type: combineTypes([arg.type, other.priv.tupleTypeArgs?.[index].type ?? arg.type]),
+    }));
+    const complexity = getTupleLiteralTypeComplexity([result]);
+    (0, debug_1.assert)(complexity !== undefined);
+    TypeBase.addProps(result).inferredTupleLiteral = {
+        baseType: combineTypes([getInferredTupleLiteralBase(type), getInferredTupleLiteralBase(other)]),
+        ...complexity,
+    };
+    return result;
+}
 //# sourceMappingURL=types.js.map