Fix TypeVar resolution order in union type aliases (#2056)

Summary:
Union type aliases like `Result = Ok[_T] | Error[_TE]` were collecting type parameters in the wrong order because union members get sorted alphabetically during simplification. This caused `Result[T, TE]` to incorrectly match `T` to `_TE` instead of `_T`.

The fix sorts collected type parameters by their source location after traversal, restoring the user's intended order.

Fixes #1759.

Pull Request resolved: #2056

Test Plan:
- Added `test_union_type_alias_typevar_order` - original issue reproduction
- Added `test_union_type_alias_typevar_order_multiple` - 3 TypeVars with reversed alphabetical order
- Added `test_union_type_alias_duplicate_typevar` - same TypeVar appearing multiple times

Reviewed By: grievejia

Differential Revision: D90423141

Pulled By: stroxler

fbshipit-source-id: 07b5e9024f9373a1ffbf769d6bf14560314cc222

Author: Adist319

pyrefly/lib/alt/solve.rs

@@ -967,7 +967,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         seen_type_vars: &mut SmallMap<TypeVar, Quantified>,
         seen_type_var_tuples: &mut SmallMap<TypeVarTuple, Quantified>,
         seen_param_specs: &mut SmallMap<ParamSpec, Quantified>,
-        tparams: &mut Vec<TParam>,
+        tparams: &mut Vec<(TextRange, TParam)>,
     ) {
         match ty {
             Type::Union(box Union { members: ts, .. }) => {
@@ -1049,10 +1049,13 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                             ty_var.restriction().clone(),
                         );
                         e.insert(q.clone());
-                        tparams.push(TParam {
-                            quantified: q.clone(),
-                            variance: ty_var.variance(),
-                        });
+                        tparams.push((
+                            ty_var.qname().range(),
+                            TParam {
+                                quantified: q.clone(),
+                                variance: ty_var.variance(),
+                            },
+                        ));
                         q
                     }
                 };
@@ -1068,10 +1071,13 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                             ty_var_tuple.default().cloned(),
                         );
                         e.insert(q.clone());
-                        tparams.push(TParam {
-                            quantified: q.clone(),
-                            variance: PreInferenceVariance::Invariant,
-                        });
+                        tparams.push((
+                            ty_var_tuple.qname().range(),
+                            TParam {
+                                quantified: q.clone(),
+                                variance: PreInferenceVariance::Invariant,
+                            },
+                        ));
                         q
                     }
                 };
@@ -1087,10 +1093,13 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                             param_spec.default().cloned(),
                         );
                         e.insert(q.clone());
-                        tparams.push(TParam {
-                            quantified: q.clone(),
-                            variance: PreInferenceVariance::Invariant,
-                        });
+                        tparams.push((
+                            param_spec.qname().range(),
+                            TParam {
+                                quantified: q.clone(),
+                                variance: PreInferenceVariance::Invariant,
+                            },
+                        ));
                         q
                     }
                 };
@@ -1175,13 +1184,19 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 .filter_map(|key| self.get_idx(*key).deref().parameter().cloned())
                 .collect();
         } else {
+            let mut tparams_with_ranges = Vec::new();
             self.tvars_to_tparams_for_type_alias(
                 &mut ty,
                 &mut seen_type_vars,
                 &mut seen_type_var_tuples,
                 &mut seen_param_specs,
-                &mut tparams,
+                &mut tparams_with_ranges,
             );
+            // Sort by source location to restore the user's intended type parameter order.
+            // This is needed because union members get sorted alphabetically during
+            // simplification, which can change the traversal order.
+            tparams_with_ranges.sort_by_key(|(range, _)| range.start());
+            tparams.extend(tparams_with_ranges.into_iter().map(|(_, tp)| tp));
         }
         if let Some(n) = tparams_for_type_alias_type {
             for extra_tparam in tparams.iter().skip(n) {

pyrefly/lib/test/type_alias.rs

@@ -885,3 +885,97 @@ type U = (a := 1)  # E: Named expression cannot be used within a type alias # E:
 type V = int | (b := str)  # E: Named expression cannot be used within a type alias
     "#,
 );
+
+testcase!(
+    test_union_type_alias_typevar_order,
+    r#"
+import dataclasses as dc
+from typing import TypeVar, Iterable
+
+@dc.dataclass
+class Ok[T]:
+    value: T
+
+@dc.dataclass
+class Error[T: Exception]:
+    error: T
+
+_T = TypeVar("_T")
+_TE = TypeVar("_TE", bound=Exception)
+Result = Ok[_T] | Error[_TE]
+
+def func[T, TE: Exception](
+    results: Iterable[Result[T, TE]],
+) -> tuple[Iterable[Ok[T]], Iterable[Error[TE]]]: ...
+
+# Verify instantiation works correctly
+def test(r: Result[int, ValueError]) -> None:
+    pass
+
+test(Ok(42))
+test(Error(ValueError("error")))
+    "#,
+);
+
+testcase!(
+    test_union_type_alias_typevar_order_multiple,
+    r#"
+from typing import TypeVar, assert_type
+import dataclasses as dc
+
+@dc.dataclass
+class Zebra[T]:
+    value: T
+
+@dc.dataclass
+class Bee[T]:
+    value: T
+
+@dc.dataclass
+class Aardvark[T]:
+    value: T
+
+_T1 = TypeVar("_T1")
+_T2 = TypeVar("_T2")
+_T3 = TypeVar("_T3")
+
+# Source order: _T1, _T2, _T3 (from Zebra, Bee, Aardvark)
+# Alphabetical order would be: Aardvark[_T3], Bee[_T2], Zebra[_T1] -> _T3, _T2, _T1
+Combined = Zebra[_T1] | Bee[_T2] | Aardvark[_T3]
+
+# This should work: int->_T1, str->_T2, float->_T3
+x: Combined[int, str, float] = Zebra(42)
+assert_type(x, Zebra[int] | Bee[str] | Aardvark[float])
+
+y: Combined[int, str, float] = Bee("hello")
+z: Combined[int, str, float] = Aardvark(3.14)
+    "#,
+);
+
+// Test that duplicate TypeVars are handled correctly (only first occurrence counts)
+testcase!(
+    test_union_type_alias_duplicate_typevar,
+    r#"
+from typing import TypeVar, assert_type
+import dataclasses as dc
+
+_T = TypeVar("_T")
+
+@dc.dataclass
+class First[T]:
+    value: T
+
+@dc.dataclass
+class Second[T]:
+    value: T
+
+# _T appears in both, but should only be one type parameter
+Alias = First[_T] | Second[_T]
+
+x: Alias[int] = First(42)
+assert_type(x, First[int] | Second[int])
+
+y: Alias[str] = Second("hello")
+assert_type(y, First[str] | Second[str])
+    "#,
+);