fix

Added a union-aware fast path in expr_infer_with_hint plus branch-aware
list inference so we can explore hints that don’t contain type variables
before the generic ones. Together with the new type_contains_var (now
driven by Type::universe) and prefer_union_branch_without_vars,
contextual typing no longer eagerly binds callable/lambda type vars when
a non-generic branch of a union would have sufficed.

Author: asukaminato0721

pyrefly/lib/alt/answers_solver.rs

@@ -857,4 +857,28 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
     pub fn error_swallower(&self) -> ErrorCollector {
         ErrorCollector::new(self.module().dupe(), ErrorStyle::Never)
     }
+
+    pub fn prefer_union_branch_without_vars(&self, ty: &Type) -> Option<Type> {
+        if let Type::Union(options) = ty {
+            let mut reordered = options.clone();
+            reordered.sort_by_key(|option| self.type_contains_var(option));
+            if reordered == *options {
+                None
+            } else {
+                Some(Type::Union(reordered))
+            }
+        } else {
+            None
+        }
+    }
+
+    pub(crate) fn type_contains_var(&self, ty: &Type) -> bool {
+        let mut has_var = false;
+        ty.universe(&mut |t| {
+            if matches!(t, Type::Var(_)) {
+                has_var = true;
+            }
+        });
+        has_var
+    }
 }

pyrefly/lib/alt/callable.rs

@@ -541,6 +541,12 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                             // We ignore positional-only parameters because they can't be passed in by name.
                             seen_names.insert(name, ty);
                         }
+                        let ty = if let Some(reordered) = self.prefer_union_branch_without_vars(ty)
+                        {
+                            type_owner.push(reordered)
+                        } else {
+                            ty
+                        };
                         arg_pre.post_check(
                             self,
                             callable_name,
@@ -568,17 +574,25 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                         ty,
                         name,
                         kind: PosParamKind::Variadic,
-                    }) => arg_pre.post_check(
-                        self,
-                        callable_name,
-                        ty,
-                        name,
-                        true,
-                        arg.range(),
-                        arg_errors,
-                        call_errors,
-                        context,
-                    ),
+                    }) => {
+                        let ty = if let Some(reordered) = self.prefer_union_branch_without_vars(ty)
+                        {
+                            type_owner.push(reordered)
+                        } else {
+                            ty
+                        };
+                        arg_pre.post_check(
+                            self,
+                            callable_name,
+                            ty,
+                            name,
+                            true,
+                            arg.range(),
+                            arg_errors,
+                            call_errors,
+                            context,
+                        )
+                    }
                     None => {
                         arg_pre.post_infer(self, arg_errors);
                         if !arg_pre.is_star() {

pyrefly/lib/alt/expr.rs

@@ -231,6 +231,19 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         hint: Option<HintRef>,
         errors: &ErrorCollector,
     ) -> Type {
+        if let Some(hint_ref) = hint
+            && let Type::Union(options) = hint_ref.ty()
+        {
+            let mut branches: Vec<&Type> = options.iter().collect();
+            branches.sort_by_key(|option| self.type_contains_var(option));
+            for option in branches {
+                let branch_hint = HintRef::new(option, hint_ref.errors());
+                let ty = self.expr_infer_with_hint(x, Some(branch_hint), errors);
+                if self.is_subset_eq(&ty, option) {
+                    return ty;
+                }
+            }
+        }
         self.expr_infer_type_info_with_hint(x, hint, errors)
             .into_ty()
     }
@@ -423,7 +436,9 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 if let Some(hint_ref) = hint.as_ref()
                     && let Type::Union(options) = hint_ref.ty()
                 {
-                    for option in options {
+                    let mut branches: Vec<&Type> = options.iter().collect();
+                    branches.sort_by_key(|option| self.type_contains_var(option));
+                    for option in branches {
                         let branch_hint =
                             self.decompose_list(HintRef::new(option, hint_ref.errors()));
                         let ty = self.list_with_hint(x, branch_hint, errors);