Overload is resolved to the first option when forced through a generic `Callable`

[fangyi-zhou]

Describe the Bug

from typing import Callable, overload, reveal_type

@overload
def foo(x: int) -> int: ...
@overload
def foo(x: str) -> str: ...
def foo(x: int | str) -> int | str: ...

def copy[A, B](c: Callable[[A], B]) -> Callable[[A], B]: ...

foo_copy = copy(foo)
reveal_type(foo_copy) # (int) -> int
foo_copy(1)
foo_copy("42") # should not error here

This is minimised from the conformance test issue in #2450

Sandbox Link

https://pyrefly.org/sandbox/?project=N4IgZglgNgpgziAXKOBDAdgEwEYHsAeAdAA4CeS4ATrgLYAEALqcROgOZ0Q3G6UN0BhVFCipssADR1cANxiUouVJimUYc4QH0mxGAB10BgAKz5i5QcwwwdMLlwAKfIk7oGASjoBaAHyuGLoRBxqYKSpiW1rb2Ti5wDJSevnTxlIHBWFF2js7%2BdAA%2BKQlJfqz8hanphAaRNgDGuGQA2gCCUgBCALoOdS5CImKwTa2dHZ0lgsKi4jDDLaN0XVU16NmaDWR0ALx0G6QO2e4GahpQ2swwB-brjaRHq9d7DgCM92tPeiAALABMn%2B4gCQgACuDGgcBI5EQIAAxHQAKpgqAQJi2YHoOpg3DoOArKw2OyUGioBiadDAmjYeSxfwTSoGOiMuhqBjAyjoWyfAByFKpaTowHwAF9PgZASAyGowFBSIQGLQoBQ4QAFUhSmUpDA4Ai7bGQNhskkQbHVdBwgDKMBgdAAFgwGMQ4IgAPTOyXWGWEXhsZ0wdDOzC4OpwZ0NVYQA2UI3Y53RSh0VAyVDQQbWsP6w1YjmNLMQgxkBg27FeOSUODGjk7T4AZkIzz%2BIDFQqBqExEDkADFoDAKGgsHgiGQQEKgA

(Only applicable for extension issues) IDE Information

No response

[fangyi-zhou]

I have the vibe-coded solution in #2472, but I'm not happy with the change. I did some digging into the issue but I'm not confident with coming up with a fix that is clean.

With some help from Claude, the main issue lies in how subtyping is handled when typechecking paramspec with overloads.
(1) We iterate through overloads, and return if one of the overload succeeds:

pyrefly/pyrefly/lib/solver/subset.rs

Lines 1038 to 1045 in 3209baa

	fn is_subset_overload(&mut self, overload: &Overload, want: &Type) -> Result<(), SubsetError> {
	if any(overload.signatures.iter(), |l| {
	self.is_subset_eq(&l.as_type(), want)
	})
	.is_ok()
	{
	return Ok(());
	}

(2) Since the wanted type is a ParamSpec with a variable, this subtyping call will succeed and the paramspec is pinned with the first overload.

Therefore, the returned callable type will have the first overload type.

Note that the iteration is short-circuiting (which is the first issue pointed out by Claude). However, changing the iteration with a non short-circuiting one wouldn't help since the paramspec is "locked" to the first overload during the subtyping process. This means trying subsequent overloads will fail due to mismatched paramspec.

The solution provided by Claude in #2472 goes around this issue by inferring the callable multiple times when the input parameter is a generic callable. There might be a way to simplify the solution, but I'm not entirely sure that's the right way to fix.

With that said, some help and guidance would be helpful on how to tackle this issue in subtyping.