@zzzen/pyright-internal 1.2.0-dev.20260823 → 1.2.0-dev.20260906

package/dist/analyzer/typeUtils.js

@@ -117,6 +117,7 @@ exports.computeMroLinearization = computeMroLinearization;
 exports.getDeclaringModulesForType = getDeclaringModulesForType;
 exports.convertTypeToParamSpecValue = convertTypeToParamSpecValue;
 exports.simplifyFunctionToParamSpec = simplifyFunctionToParamSpec;
+exports.transformTypePair = transformTypePair;
 const collectionUtils_1 = require("../common/collectionUtils");
 const debug_1 = require("../common/debug");
 const constraintSolution_1 = require("./constraintSolution");
@@ -2712,6 +2713,117 @@ function simplifyFunctionToParamSpec(type) {
     }
     return type;
 }
+// Recursively transforms two structurally-aligned type trees. The callback
+// decides whether an aligned node should be replaced; this function owns only
+// the traversal and cloning needed to preserve the source tree's shape.
+function transformTypePair(sourceType, targetType, transformNode) {
+    return transformTypePairRecursive(sourceType, targetType, transformNode, new Set(), 0);
+}
+function transformTypePairRecursive(sourceType, targetType, transformNode, pendingTypes, recursionCount) {
+    const replacementType = transformNode(sourceType, targetType);
+    if (replacementType) {
+        return replacementType;
+    }
+    if (recursionCount > types_1.maxTypeRecursionCount || pendingTypes.has(sourceType)) {
+        return sourceType;
+    }
+    pendingTypes.add(sourceType);
+    try {
+        if ((0, types_1.isFunction)(sourceType) && (0, types_1.isFunction)(targetType)) {
+            if (sourceType.shared.parameters.length !== targetType.shared.parameters.length) {
+                return sourceType;
+            }
+            const parameterTypes = sourceType.shared.parameters.map((_, index) => transformTypePairRecursive(types_1.FunctionType.getParamType(sourceType, index), types_1.FunctionType.getParamType(targetType, index), transformNode, pendingTypes, recursionCount + 1));
+            const parameterDefaultTypes = sourceType.shared.parameters.map((_, index) => {
+                const sourceDefaultType = types_1.FunctionType.getParamDefaultType(sourceType, index);
+                const targetDefaultType = types_1.FunctionType.getParamDefaultType(targetType, index);
+                return sourceDefaultType && targetDefaultType
+                    ? transformTypePairRecursive(sourceDefaultType, targetDefaultType, transformNode, pendingTypes, recursionCount + 1)
+                    : sourceDefaultType;
+            });
+            const sourceReturnType = types_1.FunctionType.getEffectiveReturnType(sourceType);
+            const targetReturnType = types_1.FunctionType.getEffectiveReturnType(targetType);
+            const returnType = sourceReturnType && targetReturnType
+                ? transformTypePairRecursive(sourceReturnType, targetReturnType, transformNode, pendingTypes, recursionCount + 1)
+                : sourceReturnType;
+            if (parameterTypes.every((type, index) => type === types_1.FunctionType.getParamType(sourceType, index)) &&
+                parameterDefaultTypes.every((type, index) => type === types_1.FunctionType.getParamDefaultType(sourceType, index)) &&
+                returnType === sourceReturnType) {
+                return sourceType;
+            }
+            const transformedType = types_1.FunctionType.clone(sourceType);
+            transformedType.priv.specializedTypes = {
+                parameterTypes,
+                parameterDefaultTypes,
+                returnType,
+            };
+            return transformedType;
+        }
+        if ((0, types_1.isTypeVar)(sourceType) && (0, types_1.isTypeVar)(targetType)) {
+            if (sourceType.shared.constraints.length !== targetType.shared.constraints.length) {
+                return sourceType;
+            }
+            const constraints = sourceType.shared.constraints.map((constraint, index) => transformTypePairRecursive(constraint, targetType.shared.constraints[index], transformNode, pendingTypes, recursionCount + 1));
+            const boundType = sourceType.shared.boundType && targetType.shared.boundType
+                ? transformTypePairRecursive(sourceType.shared.boundType, targetType.shared.boundType, transformNode, pendingTypes, recursionCount + 1)
+                : sourceType.shared.boundType;
+            const defaultType = transformTypePairRecursive(sourceType.shared.defaultType, targetType.shared.defaultType, transformNode, pendingTypes, recursionCount + 1);
+            if (constraints.every((type, index) => type === sourceType.shared.constraints[index]) &&
+                boundType === sourceType.shared.boundType &&
+                defaultType === sourceType.shared.defaultType) {
+                return sourceType;
+            }
+            const transformedType = types_1.TypeBase.cloneType(sourceType);
+            transformedType.shared = {
+                ...sourceType.shared,
+                constraints,
+                boundType,
+                defaultType,
+            };
+            return transformedType;
+        }
+        if ((0, types_1.isUnion)(sourceType) && (0, types_1.isUnion)(targetType)) {
+            if (sourceType.priv.subtypes.length !== targetType.priv.subtypes.length) {
+                return sourceType;
+            }
+            const subtypes = sourceType.priv.subtypes.map((subtype, index) => {
+                const transformedSubtype = transformTypePairRecursive(subtype, targetType.priv.subtypes[index], transformNode, pendingTypes, recursionCount + 1);
+                return (0, types_1.isNever)(transformedSubtype) || (0, types_1.isUnion)(transformedSubtype) ? subtype : transformedSubtype;
+            });
+            if (subtypes.every((type, index) => type === sourceType.priv.subtypes[index])) {
+                return sourceType;
+            }
+            const transformedType = types_1.TypeBase.cloneType(sourceType);
+            transformedType.priv.subtypes = subtypes;
+            return transformedType;
+        }
+        if ((0, types_1.isClass)(sourceType) && (0, types_1.isClass)(targetType)) {
+            if (sourceType.shared.fullName !== targetType.shared.fullName ||
+                types_1.TypeBase.isInstance(sourceType) !== types_1.TypeBase.isInstance(targetType) ||
+                sourceType.priv.typeArgs?.length !== targetType.priv.typeArgs?.length ||
+                sourceType.priv.tupleTypeArgs?.length !== targetType.priv.tupleTypeArgs?.length) {
+                return sourceType;
+            }
+            const typeArgs = sourceType.priv.typeArgs?.map((typeArg, index) => transformTypePairRecursive(typeArg, targetType.priv.typeArgs[index], transformNode, pendingTypes, recursionCount + 1));
+            const tupleTypeArgs = sourceType.priv.tupleTypeArgs?.map((tupleTypeArg, index) => ({
+                ...tupleTypeArg,
+                type: transformTypePairRecursive(tupleTypeArg.type, targetType.priv.tupleTypeArgs[index].type, transformNode, pendingTypes, recursionCount + 1),
+            }));
+            if (!typeArgs?.some((type, index) => type !== sourceType.priv.typeArgs[index]) &&
+                !tupleTypeArgs?.some((tupleTypeArg, index) => tupleTypeArg.type !== sourceType.priv.tupleTypeArgs[index].type)) {
+                return sourceType;
+            }
+            const transformedType = types_1.TypeBase.cloneType(sourceType);
+            transformedType.priv.typeArgs = typeArgs;
+            transformedType.priv.tupleTypeArgs = tupleTypeArgs;
+            return transformedType;
+        }
+        return sourceType;
+    }
+    finally {
+        pendingTypes.delete(sourceType);
+    }
+}
 // Recursively walks a type and calls a callback for each TypeVar, allowing
 // it to be replaced with something else.
 class TypeVarTransformer {