Closure/arrow-function parameters passed after reordering named

arguments now infer correctly

Author: AJenbo

docs/CHANGELOG.md

@@ -46,6 +46,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - **Completion works after closing a multi-line closure argument on the same line as the next chain operator.** Typing `->` immediately after a call like `->map(function (...) { ... })->` now resolves the full receiver instead of returning no member suggestions until the operator is moved to a new line. Contributed by @calebdw.
 - **Conditional return types recognize interpolated strings as strings.** A function with a conditional return type like `($key is string ? mixed : null)` now correctly resolves the `string` branch when called with an interpolated string argument (e.g. `config("{$prefix}.host")`). Previously the interpolated string was not recognized as a string literal, causing the return type to fall through to the else branch and resolve as `null`. Contributed by @calebdw.
+- **Closure/arrow-function parameters passed after reordering named arguments now infer correctly.** When a call used named arguments to reorder or skip parameters ahead of a closure argument (e.g. `process(class: Product::class, cb: function ($p) {...}, flag: true)`), the closure's own parameter type stopped being inferred from the target function/method's `callable(...)`/`Closure(...)` signature, silently losing completions and hover for the closure's parameters. Argument-to-parameter binding now follows PHP's actual named-argument rules instead of assuming call position matches declared position.
 - **Deprecated enum cases are recognized.** Enum cases annotated with `@deprecated` or `#[Deprecated]` now carry deprecation metadata, so usages like `self::Low` can be highlighted as deprecated in contextual semantic-token mode. Contributed by @calebdw.
 - **Class constant accesses use constant semantic highlighting.** `self::CONSTANT`, `static::CONSTANT`, `parent::CONSTANT`, and `ClassName::CONSTANT` now emit the `enumMember` semantic token instead of being colored as properties, while `ClassName::$property` still emits `property`. Contributed by @calebdw.
 - **PHP attributes use decorator semantic highlighting.** Attribute class names in `#[...]` now emit the `decorator` semantic token instead of `class`, so editor themes can color attributes differently from normal class references. Contributed by @calebdw.

docs/todo/bugs.md

@@ -64,60 +64,3 @@ own reasons (semantic tokens at `semantic_tokens.rs:757-770`, hover at
 There is no existing test coverage for promoted-property rename or
 references (`src/rename/tests.rs` and `tests/integration/references.rs`
 have no `__construct`/promoted-property cases).
-
-## B115. Closure-parameter inference uses call-position instead of the declared parameter index, so named arguments that reorder a call break it
-
-**Severity: Low-Medium (closure/arrow-function parameters silently lose
-their inferred type — falling back to no completions/hover — for any
-call that uses named arguments to reorder or skip parameters ahead of
-the callable argument) · Discovered while deduplicating the receiver
-resolution helpers shared between `closure_resolution.rs` and
-`forward_walk/callable_inference.rs`; confirmed with a regression test**
-
-```php
-/**
- * @template T
- * @param bool $flag
- * @param class-string<T> $class
- * @param callable(T): void $cb
- */
-function process(bool $flag, string $class, callable $cb): void {}
-
-process(class: Product::class, flag: true, function ($p) {
-    $p-> // no completions: T never binds to Product
-});
-```
-
-The forward walker's closure-argument inference
-(`walk_closures_in_call_args` and `walk_closure_in_partial_call_args` in
-`src/type_engine/variable/forward_walk/diagnostic_walk.rs`, and the
-completion/hover-path counterpart `infer_callable_params_for_call` in
-`src/type_engine/variable/forward_walk/callable_inference.rs`) computes
-`arg_idx` from `arguments.iter().enumerate()` — the argument's position
-in the *call*. That index is then used directly as the *declared*
-parameter index, both to decide whether the argument at that slot is a
-closure and to look up `fi.parameters[arg_idx]` /
-`class.get_method(..).parameters[arg_idx]` for the callable's own
-`callable(...)`/`Closure(...)` type hint (see
-`extract_callable_params_at_fw` and its callers).
-
-PHP argument binding does not guarantee call-position equals declared
-position once named arguments are involved: a named argument can appear
-anywhere in the call, and named arguments before the closure can be
-reordered or a preceding optional parameter can be omitted entirely.
-Whenever that happens, `arg_idx` no longer identifies the closure's own
-parameter, so `extract_callable_params_at_fw` looks up the wrong
-parameter (typically a non-callable one), returns no callable param
-types, and the closure gets none of its parameters inferred — even
-though the same call resolves correctly when arguments are positional
-and in declaration order.
-
-Fix by resolving each argument's *declared* parameter index (via
-something like the existing `bind_text_args_to_params` /
-`param_name_bare` machinery in `src/call_args.rs`, which already knows
-how to route named arguments to their declared slot) before using that
-index to look up the callable's own parameter type or to decide which
-argument is "the closure at position N". This affects both the
-diagnostic-path walker (`diagnostic_walk.rs`) and the completion/hover
-path (`callable_inference.rs`), which must stay in sync per the
-project's shared-pipeline convention.

src/call_args.rs

@@ -67,6 +67,50 @@ pub(crate) fn bind_args_to_params<'b>(
     bound
 }
 
+/// For each argument in `argument_list` (by call position), resolve the
+/// declared parameter index in `params` that it binds to under PHP's
+/// binding rules.
+///
+/// This is the call-position-to-declared-index counterpart of
+/// [`bind_args_to_params`] (which goes the other way: declared index to
+/// bound expression). Consumers that key off "the Nth argument in the
+/// call" — e.g. closure-argument inference matching a `callable(...)`
+/// type hint to the closure's own declared parameter — must translate
+/// through this first, since a named argument can appear anywhere in the
+/// call and reorder or skip parameters ahead of it.
+///
+/// Returns a vector parallel to `argument_list.arguments`: entry `i` holds
+/// the declared parameter index bound to call-position `i`, or `None` when
+/// the argument matches no declared parameter (an unknown named argument,
+/// or a positional overflow with no variadic parameter).
+pub(crate) fn resolve_declared_arg_indices(
+    params: &[ParameterInfo],
+    argument_list: &ArgumentList<'_>,
+) -> Vec<Option<usize>> {
+    let variadic_idx = params.iter().position(|p| p.is_variadic);
+    let mut next_positional = 0usize;
+
+    argument_list
+        .arguments
+        .iter()
+        .map(|arg| match arg {
+            Argument::Positional(_) => {
+                let target = if next_positional < params.len() {
+                    Some(next_positional)
+                } else {
+                    variadic_idx
+                };
+                next_positional += 1;
+                target
+            }
+            Argument::Named(named) => {
+                let name = bytes_to_str(named.name.value);
+                params.iter().position(|p| param_name_bare(p) == name)
+            }
+        })
+        .collect()
+}
+
 /// Split a textual argument into an optional parameter name and its value.
 ///
 /// `"signature: Foo::class"` → `(Some("signature"), "Foo::class")`.

src/type_engine/variable/forward_walk/callable_inference.rs

@@ -46,7 +46,7 @@ pub(crate) fn infer_callable_params_from_function_fw(
         None
     };
     if let Some(fi) = func_info {
-        let mut params = extract_callable_params_at_fw(&fi.parameters, arg_idx);
+        let mut params = extract_callable_params_at_fw(&fi.parameters, argument_list, arg_idx);
 
         if !params.is_empty() && !fi.template_params.is_empty() && !fi.template_bindings.is_empty()
         {
@@ -70,14 +70,15 @@ pub(crate) fn infer_callable_params_from_function_fw(
 /// Infer callable parameter types for a closure passed at position
 /// `arg_idx` to an instance method call.
 pub(crate) fn infer_callable_params_from_receiver_fw(
-    obj_start: u32,
-    obj_end: u32,
+    obj_span: (u32, u32),
     method_name: &str,
     arg_idx: usize,
+    argument_list: &ArgumentList<'_>,
     first_arg_text: Option<&str>,
     scope: &ScopeState,
     ctx: &ForwardWalkCtx<'_>,
 ) -> Vec<PhpType> {
+    let (obj_start, obj_end) = obj_span;
     let scope_locals = &scope.locals;
     let scope_resolver = |var_name: &str| -> Vec<ResolvedType> {
         scope_locals
@@ -105,7 +106,13 @@ pub(crate) fn infer_callable_params_from_receiver_fw(
         return override_params;
     }
 
-    let params = find_callable_params_on_classes_fw(&receiver_classes, method_name, arg_idx, ctx);
+    let params = find_callable_params_on_classes_fw(
+        &receiver_classes,
+        method_name,
+        arg_idx,
+        argument_list,
+        ctx,
+    );
 
     // Build a template substitution map from the receiver's generic
     // args.  When the receiver resolves to e.g. `Builder<Product>`,
@@ -299,6 +306,7 @@ pub(crate) fn infer_callable_params_from_static_receiver_fw(
     class_expr: &Expression<'_>,
     method_name: &str,
     arg_idx: usize,
+    argument_list: &ArgumentList<'_>,
     first_arg_text: Option<&str>,
     scope: &ScopeState,
     ctx: &ForwardWalkCtx<'_>,
@@ -334,7 +342,8 @@ pub(crate) fn infer_callable_params_from_static_receiver_fw(
             ctx.class_loader,
             ctx.resolved_class_cache,
         );
-        let params = find_callable_params_on_method_fw(&resolved, method_name, arg_idx);
+        let params =
+            find_callable_params_on_method_fw(&resolved, method_name, arg_idx, argument_list);
 
         // Build a template substitution map from the owner class.
         // When the owner is a generic class (e.g. `Builder<Customer>`
@@ -388,6 +397,7 @@ pub(crate) fn find_callable_params_on_classes_fw(
     classes: &[Arc<ClassInfo>],
     method_name: &str,
     arg_idx: usize,
+    argument_list: &ArgumentList<'_>,
     ctx: &ForwardWalkCtx<'_>,
 ) -> Vec<PhpType> {
     for cls in classes {
@@ -397,7 +407,7 @@ pub(crate) fn find_callable_params_on_classes_fw(
         // `resolve_class_fully_maybe_cached` would load the base
         // class definition (keyed by FQN with empty generic args),
         // discarding those substitutions.
-        let result = find_callable_params_on_method_fw(cls, method_name, arg_idx);
+        let result = find_callable_params_on_method_fw(cls, method_name, arg_idx, argument_list);
         if !result.is_empty() {
             return result;
         }
@@ -412,7 +422,8 @@ pub(crate) fn find_callable_params_on_classes_fw(
             ctx.class_loader,
             ctx.resolved_class_cache,
         );
-        let result = find_callable_params_on_method_fw(&resolved, method_name, arg_idx);
+        let result =
+            find_callable_params_on_method_fw(&resolved, method_name, arg_idx, argument_list);
         if !result.is_empty() {
             return result;
         }
@@ -421,27 +432,39 @@ pub(crate) fn find_callable_params_on_classes_fw(
 }
 
 /// Look up method `method_name` on `class` and extract callable
-/// parameter types from the parameter at position `arg_idx`.
+/// parameter types from the parameter bound to call-position `arg_idx`.
 pub(crate) fn find_callable_params_on_method_fw(
     class: &ClassInfo,
     method_name: &str,
     arg_idx: usize,
+    argument_list: &ArgumentList<'_>,
 ) -> Vec<PhpType> {
     let method = class.get_method(method_name);
     if let Some(m) = method {
-        extract_callable_params_at_fw(&m.parameters, arg_idx)
+        extract_callable_params_at_fw(&m.parameters, argument_list, arg_idx)
     } else {
         vec![]
     }
 }
 
-/// Given a list of parameters, look at `arg_idx` and extract callable
-/// parameter types if the type hint is `callable(...)` or `Closure(...)`.
+/// Given a list of parameters and the call's argument list, resolve the
+/// call-position `arg_idx` to its *declared* parameter index (accounting
+/// for named arguments, which can reorder or skip parameters) and extract
+/// callable parameter types if that parameter's type hint is
+/// `callable(...)` or `Closure(...)`.
 pub(crate) fn extract_callable_params_at_fw(
     params: &[crate::types::ParameterInfo],
+    argument_list: &ArgumentList<'_>,
     arg_idx: usize,
 ) -> Vec<PhpType> {
-    let param = params.get(arg_idx);
+    let Some(declared_idx) = crate::call_args::resolve_declared_arg_indices(params, argument_list)
+        .get(arg_idx)
+        .copied()
+        .flatten()
+    else {
+        return vec![];
+    };
+    let param = params.get(declared_idx);
     if let Some(p) = param
         && let Some(ref hint) = p.type_hint
         && let Some(callable_params) = hint.callable_param_types()
@@ -533,10 +556,10 @@ pub(crate) fn infer_callable_params_for_call(
                 let first_arg =
                     extract_first_arg_string_fw(&mc.argument_list.arguments, ctx.content);
                 infer_callable_params_from_receiver_fw(
-                    obj_span.start.offset,
-                    obj_span.end.offset,
+                    (obj_span.start.offset, obj_span.end.offset),
                     name,
                     arg_idx,
+                    &mc.argument_list,
                     first_arg.as_deref(),
                     scope,
                     ctx,
@@ -556,10 +579,10 @@ pub(crate) fn infer_callable_params_for_call(
                 let first_arg =
                     extract_first_arg_string_fw(&mc.argument_list.arguments, ctx.content);
                 infer_callable_params_from_receiver_fw(
-                    obj_span.start.offset,
-                    obj_span.end.offset,
+                    (obj_span.start.offset, obj_span.end.offset),
                     name,
                     arg_idx,
+                    &mc.argument_list,
                     first_arg.as_deref(),
                     scope,
                     ctx,
@@ -581,6 +604,7 @@ pub(crate) fn infer_callable_params_for_call(
                     sc.class,
                     name,
                     arg_idx,
+                    &sc.argument_list,
                     first_arg.as_deref(),
                     scope,
                     ctx,

src/type_engine/variable/forward_walk/diagnostic_walk.rs

@@ -434,10 +434,10 @@ pub(crate) fn walk_closures_in_call<'b>(
             walk_closures_in_call_args(&mc.argument_list.arguments, outer_scope, ctx, |arg_idx| {
                 if let Some(ref name) = method_name {
                     infer_callable_params_from_receiver_fw(
-                        obj_span.start.offset,
-                        obj_span.end.offset,
+                        (obj_span.start.offset, obj_span.end.offset),
                         name,
                         arg_idx,
+                        &mc.argument_list,
                         first_arg.as_deref(),
                         outer_scope,
                         ctx,
@@ -460,10 +460,10 @@ pub(crate) fn walk_closures_in_call<'b>(
             walk_closures_in_call_args(&mc.argument_list.arguments, outer_scope, ctx, |arg_idx| {
                 if let Some(ref name) = method_name {
                     infer_callable_params_from_receiver_fw(
-                        obj_span.start.offset,
-                        obj_span.end.offset,
+                        (obj_span.start.offset, obj_span.end.offset),
                         name,
                         arg_idx,
+                        &mc.argument_list,
                         first_arg.as_deref(),
                         outer_scope,
                         ctx,
@@ -488,6 +488,7 @@ pub(crate) fn walk_closures_in_call<'b>(
                         sc.class,
                         name,
                         arg_idx,
+                        &sc.argument_list,
                         first_arg.as_deref(),
                         outer_scope,
                         ctx,