Extend save+restore of partial vars around overload calls to all placeholder vars

Summary: Fixes #3002.

Reviewed By: migeed-z

Differential Revision: D100591004

fbshipit-source-id: 1bb3e81a6f668f70ae9b3ed3993265db6dd3b5e6

Author: rchen152

pyrefly/lib/alt/overload.rs

@@ -502,14 +502,14 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         hint: Option<HintRef>,
         ctor_targs: &Option<&mut TArgs>,
     ) -> (CalledOverload<'c>, bool) {
-        // Collect partial vars so we can save/restore them around each overload evaluation. This
-        // prevents premature pinning of partial vars on failed overload calls.
-        let partial_vars = self.collect_partial_vars(self_obj, args, keywords);
+        // Collect placeholder vars so we can save/restore them around each overload evaluation. This
+        // prevents premature pinning of vars on failed overload calls.
+        let placeholder_vars = self.collect_placeholder_vars(self_obj, args, keywords);
 
         let mut matched_overloads = Vec::with_capacity(overloads.len());
         let mut closest_unmatched_overload: Option<CalledOverload<'c>> = None;
         for callable in overloads {
-            let snapshot = self.solver().snapshot_vars(&partial_vars);
+            let snapshot = self.solver().snapshot_vars(&placeholder_vars);
             let called_overload = self.call_overload(
                 callable,
                 metadata,
@@ -630,7 +630,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                     matched_overloads
                         .iter()
                         .find_position(|o| {
-                            let snapshot = self.solver().snapshot_vars(&partial_vars);
+                            let snapshot = self.solver().snapshot_vars(&placeholder_vars);
                             let res = self.call_overload(
                                 o.func,
                                 metadata,
@@ -747,18 +747,18 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         Some(candidate)
     }
 
-    /// Collect partial vars from self_obj and Type-valued arguments.
-    fn collect_partial_vars(
+    /// Collect placeholder vars from self_obj and Type-valued arguments.
+    fn collect_placeholder_vars(
         &self,
         self_obj: Option<&Type>,
         args: &[CallArg],
         keywords: &[CallKeyword],
     ) -> Vec<Var> {
-        let mut partial_vars: Vec<Var> = Vec::new();
+        let mut placeholder_vars: Vec<Var> = Vec::new();
         let mut collect = |ty: &Type| {
             for var in ty.collect_maybe_placeholder_vars() {
-                if self.solver().var_is_partial(var) && !partial_vars.contains(&var) {
-                    partial_vars.push(var);
+                if !placeholder_vars.contains(&var) {
+                    placeholder_vars.push(var);
                 }
             }
         };
@@ -777,7 +777,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 collect(ty);
             }
         }
-        partial_vars
+        placeholder_vars
     }
 
     fn call_overload<'c>(

pyrefly/lib/test/constructors.rs

@@ -1003,3 +1003,26 @@ def f(x: dict[Kind, int]) -> None:
     g(dict(x))
     "#,
 );
+
+testcase!(
+    test_overloaded_constructor_with_hint,
+    r#"
+from collections.abc import Mapping
+from typing import assert_type, Generic, Never, overload, SupportsInt, TypeVar
+
+_T_co = TypeVar("_T_co", covariant=True)
+_T = TypeVar("_T")
+
+class Box(Generic[_T_co]):
+    @overload
+    def __init__(self: "Box[Never]", val: Mapping[Never, SupportsInt], /) -> None: ...
+    @overload
+    def __init__(self: "Box[_T]", val: Mapping[_T, SupportsInt], /) -> None: ...
+    def __init__(self, val: object, /) -> None:
+        pass
+
+def process(items: Box[_T]) -> "Box[_T]": ...
+
+assert_type(process(Box({1: 1})), Box[int])
+    "#,
+);