Fix false positive unexpected-keyword for named params before *args: P.args

Summary:
Functions like call_with_retry(f, max_attempts=10, *args: P.args, **kwargs: P.kwargs) should allow max_attempts to be passed as a keyword argument, matching mypy and pyright behavior. Pyrefly incorrectly rejected call_with_retry(write_data, max_attempts=5) with "Unexpected keyword argument max_attempts".

The issue is in callable_infer's handling of the Type::Var(var) branch — the path taken when P hasn't been solved yet (e.g. before matching f to write_data resolves P to ()). This branch constructs a param list from prefix params via ParamList::new_types, which calls into_param(). That method unconditionally converts all PrefixParam::Pos to Param::PosOnly, so max_attempts never enters the keyword params map and any keyword usage is rejected.

The fix switches this branch to use to_subset_param(), which preserves the Pos kind. The PosOnly conversion is deliberately kept for the Type::Quantified branch (ParamSpec forwarding), where foo(x=1, *args, **kwargs) must be rejected — passing a prefix param as keyword while also forwarding *args positionally would cause "multiple values for argument" at runtime. The existing test_paramspec_named_arguments_concatenate test validates this distinction.

Fixes #3052

Reviewed By: grievejia

Differential Revision: D99916739

fbshipit-source-id: c2d92232f8ca5399f3c4d34fa2b2e140d75db07f

Author: tejasreddyvepala

crates/pyrefly_types/src/callable.rs

@@ -296,9 +296,9 @@ impl PrefixParam {
         }
     }
 
-    /// Convert to a positional-only `Param`. Per the typing spec, params before
-    /// `*args: P.args` are always positional-only at the call site, regardless of
-    /// whether they were originally `Pos` or `PosOnly` in the function definition.
+    /// Convert to a positional-only `Param`. Per the typing spec, params in
+    /// `Concatenate` are positional-only at the call site. This is also appropriate
+    /// for ParamSpec forwarding where prefix params must be passed positionally.
     pub fn into_param(self) -> Param {
         match self {
             Self::PosOnly(name, ty, required) => Param::PosOnly(name, ty, required),
@@ -319,7 +319,8 @@ impl PrefixParam {
     }
 
     /// Convert to a `Param` preserving the Pos vs PosOnly distinction.
-    /// Used for subset/subtype checking where name matching matters.
+    /// Used for subset/subtype checking where name matching matters,
+    /// and for direct calls where prefix params should remain keyword-passable.
     pub fn to_subset_param(&self) -> Param {
         match self {
             Self::PosOnly(name, ty, required) => {

pyrefly/lib/alt/callable.rs

@@ -1345,9 +1345,11 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                     ),
                     // This can happen with a signature like `(f: Callable[P, None], *args: P.args, **kwargs: P.kwargs)`.
                     // Before we match an argument to `f`, we don't know what `P` is, so we don't have an answer for the Var yet.
+                    // Use to_subset_param to preserve Pos vs PosOnly: prefix params from a
+                    // function definition should remain keyword-passable in direct calls.
                     Type::Var(var) => self.callable_infer_params(
                         callable_name,
-                        &ParamList::new_types(concatenate.into_vec()),
+                        &ParamList::new(concatenate.iter().map(|p| p.to_subset_param()).collect()),
                         Some(var),
                         self_arg,
                         self_qs,

pyrefly/lib/test/paramspec.rs

@@ -824,3 +824,49 @@ def bare_fn(a: int) -> str: ...
 reveal_type(bare_fn) # E: Wrapper[[a: int], str]
 "#,
 );
+
+testcase!(
+    test_paramspec_named_params_before_args,
+    r#"
+from typing import ParamSpec, TypeVar, Callable
+
+P = ParamSpec("P")
+R = TypeVar("R")
+
+def call_with_retry(
+    f: Callable[P, R],
+    max_attempts: int = 10,
+    *args: P.args,
+    **kwargs: P.kwargs,
+) -> R:
+    return f(*args, **kwargs)
+
+def write_data() -> None:
+    pass
+
+call_with_retry(write_data, max_attempts=5)
+call_with_retry(write_data, 5)
+
+def compute(x: int, y: str) -> bool:
+    return True
+
+call_with_retry(compute, max_attempts=3, x=1, y="hello")
+call_with_retry(compute, 3, 1, "hello")
+"#,
+);
+
+testcase!(
+    test_paramspec_forwarding_prefix_param_keyword,
+    r#"
+from typing import ParamSpec, Callable
+
+P = ParamSpec("P")
+Q = ParamSpec("Q")
+
+def call_fn(f: Callable[P, None], x: int, *args: P.args, **kwargs: P.kwargs) -> None:
+    f(*args, **kwargs)
+
+def forward(g: Callable[Q, None], *args: Q.args, **kwargs: Q.kwargs) -> None:
+    call_fn(g, x=1, *args, **kwargs)
+"#,
+);