Fix unwrap_iterable for union types by distributing over members

Summary:
The `unwrap_iterable` function checks whether a type is a subtype of `Iterable[T]` by creating a fresh type variable `T` and calling `is_subset_eq`. For union types like `tuple[int, ...] | tuple[str, ...]`, the solver pins `T` on the first member (e.g. `T = int`), then rejects later members with different element types (e.g. `str`).

Fix this by using `distribute_over_union` to check each member independently with its own fresh type variable, then union the results. This also fixes `unwrap_async_iterable` which had the same issue.

This addresses a regression from D95478317 where `tuple()` constructor calls now return structural `Type::Tuple` instead of nominal `ClassType`. When the result is a union of structural tuples used in star unpacking (`*expr`), pyrefly incorrectly reported a `not-iterable` error because `unwrap_iterable` couldn't handle the union.

Reviewed By: ndmitchell

Differential Revision: D95621346

fbshipit-source-id: 66b6ba5be8f7b6dbeca5f69bc5af74b14a70d72f

Author: grievejia

pyrefly/lib/alt/unwrap.rs

@@ -259,28 +259,42 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
 
     /// Warning: this returns `Some` if the type is `Any` or a class that extends `Any`
     pub fn unwrap_iterable(&self, ty: &Type) -> Option<Type> {
-        let iter_ty = self.fresh_var();
-        let iterable_ty = self
-            .heap
-            .mk_class_type(self.stdlib.iterable(iter_ty.to_type(self.heap)));
-        if self.is_subset_eq(ty, &iterable_ty) {
-            Some(self.resolve_var(ty, iter_ty))
-        } else {
-            None
-        }
+        // Distribute over union members so each gets its own fresh type
+        // variable. Checking the whole union at once fails because the solver
+        // pins the variable on the first member, then rejects later members
+        // with different element types.
+        let mut failed = false;
+        let result = self.distribute_over_union(ty, |member| {
+            let iter_ty = self.fresh_var();
+            let iterable_ty = self
+                .heap
+                .mk_class_type(self.stdlib.iterable(iter_ty.to_type(self.heap)));
+            if self.is_subset_eq(member, &iterable_ty) {
+                self.resolve_var(member, iter_ty)
+            } else {
+                failed = true;
+                self.heap.mk_never()
+            }
+        });
+        if failed { None } else { Some(result) }
     }
 
     /// Warning: this returns `Some` if the type is `Any` or a class that extends `Any`
     pub fn unwrap_async_iterable(&self, ty: &Type) -> Option<Type> {
-        let iter_ty = self.fresh_var();
-        let iterable_ty = self
-            .heap
-            .mk_class_type(self.stdlib.async_iterable(iter_ty.to_type(self.heap)));
-        if self.is_subset_eq(ty, &iterable_ty) {
-            Some(self.resolve_var(ty, iter_ty))
-        } else {
-            None
-        }
+        let mut failed = false;
+        let result = self.distribute_over_union(ty, |member| {
+            let iter_ty = self.fresh_var();
+            let iterable_ty = self
+                .heap
+                .mk_class_type(self.stdlib.async_iterable(iter_ty.to_type(self.heap)));
+            if self.is_subset_eq(member, &iterable_ty) {
+                self.resolve_var(member, iter_ty)
+            } else {
+                failed = true;
+                self.heap.mk_never()
+            }
+        });
+        if failed { None } else { Some(result) }
     }
 
     /// Warning: this returns `Some` if the type is `Any` or a class that extends `Any`

pyrefly/lib/test/tuple.rs

@@ -429,6 +429,25 @@ assert_type(m, MyTuple)
 "#,
 );
 
+testcase!(
+    test_star_unpack_single_unbounded_tuple,
+    r#"
+from typing import assert_type
+def test(x: tuple[int, ...]) -> None:
+    y = (*x,)
+"#,
+);
+
+testcase!(
+    test_star_unpack_union_of_tuples,
+    r#"
+from typing import assert_type
+def f() -> tuple[int, ...] | tuple[str, ...]:
+    ...
+x = (*f(),)
+"#,
+);
+
 testcase!(
     test_tuple_aug_assign,
     r#"