fix(diagnostics): resolve callable return type for call-result invocations

When a function/method returns a callable type and the return value is
immediately invoked — e.g. `makeCallable('1', '2')('test')` — the LSP
previously used the outer function's parameter signature for the inner
invocation. This caused:
- False argument_count_mismatch diagnostics (expected 2 args, got 1)
- Wrong inlay hint parameter names ($a instead of $c)

The fix intercepts CallExpr resolution: after resolving the inner
callee, check if its return type is callable. If so, use the callable's
parameter signature instead of the callee's own params.

Handles:
- Typed callable: `callable(string): string` — extracts params
- Bare callable/Closure: flags accepts_any_args to suppress diagnostics
- Union types and nullable: recursively checks branches

Closes #184

Author: calebdw

src/completion/call_resolution.rs

@@ -793,7 +793,7 @@ impl Backend {
 
         let effective_args_text = call_args_text.or(args_text_from_parse);
 
-        match effective {
+        let result = match effective {
             // ── Constructor: `new ClassName` or `new ClassName()` ────
             SubjectExpr::NewExpr { class_name } => {
                 let resolved_class_name =
@@ -875,7 +875,31 @@ impl Backend {
 
             // ── Anything else doesn't resolve to a callable ─────────
             _ => None,
+        };
+
+        // ── Call-result invocation ──────────────────────────────────
+        // When the original expression was a `CallExpr`, the resolved
+        // target describes the inner callee (e.g. `makeCallable`), but
+        // the actual call is on the callee's *return value*:
+        //
+        //   makeCallable('1', '2')('test')
+        //   ^^^^^^^^^^^^^^^^^^^^^^^^       ← inner callee resolved above
+        //                          ^^^^^^^ ← outer call on the return value
+        //
+        // If the return type is a typed callable (`callable(string): T`)
+        // use its parameter signature.  For bare `callable` without a
+        // parameter spec, flag `accepts_any_args` so that argument-count
+        // diagnostics are suppressed and inlay hints don't show the
+        // wrong parameter names.
+        if matches!(&parsed, SubjectExpr::CallExpr { .. })
+            && let Some(ref target) = result
+            && let Some(ref return_type) = target.return_type
+            && let Some(invoked) = callable_type_as_target(return_type)
+        {
+            return Some(invoked);
         }
+
+        result
     }
 
     /// Resolve the return type of a call expression given a structured
@@ -2803,3 +2827,64 @@ impl Backend {
         None
     }
 }
+
+/// Convert a callable `PhpType` to a `ResolvedCallableTarget`.
+///
+/// Used when a function/method returns a callable type and that return
+/// value is immediately invoked: `makeCallable('1', '2')('test')`.
+///
+/// - `PhpType::Callable { params, return_type, .. }` (typed callable like
+///   `callable(string): string`) -> params are converted to `ParameterInfo`.
+/// - `PhpType::Named("callable")` or `PhpType::Named("Closure")` (bare
+///   callable without parameter specification) -> returns a target with
+///   `accepts_any_args: true` so diagnostics are suppressed.
+/// - Other types -> returns `None` (not a callable).
+fn callable_type_as_target(return_type: &PhpType) -> Option<ResolvedCallableTarget> {
+    match return_type {
+        PhpType::Callable {
+            params,
+            return_type,
+            ..
+        } => {
+            let parameters: Vec<ParameterInfo> = params
+                .iter()
+                .enumerate()
+                .map(|(i, p)| ParameterInfo {
+                    name: crate::atom::atom(&format!("$param{}", i + 1)),
+                    is_required: !p.optional && !p.variadic,
+                    type_hint: Some(p.type_hint.clone()),
+                    native_type_hint: None,
+                    description: None,
+                    default_value: None,
+                    is_variadic: p.variadic,
+                    is_reference: false,
+                    closure_this_type: None,
+                })
+                .collect();
+            Some(ResolvedCallableTarget {
+                parameters,
+                return_type: return_type.as_deref().cloned(),
+                accepts_any_args: false,
+            })
+        }
+        PhpType::Named(name)
+            if name.eq_ignore_ascii_case("callable") || name.eq_ignore_ascii_case("Closure") =>
+        {
+            Some(ResolvedCallableTarget {
+                parameters: vec![],
+                return_type: None,
+                accepts_any_args: true,
+            })
+        }
+        PhpType::Union(members) => {
+            for member in members {
+                if let Some(target) = callable_type_as_target(member) {
+                    return Some(target);
+                }
+            }
+            None
+        }
+        PhpType::Nullable(inner) => callable_type_as_target(inner),
+        _ => None,
+    }
+}

tests/integration/inlay_hints.rs

@@ -1368,3 +1368,55 @@ transform([1, 2, 3], function ($x) { return $x * 2; });
         all
     );
 }
+
+// ─── Call-result invocation: callable return type (#184) ────────────────────
+
+#[tokio::test]
+async fn callable_return_invocation_no_wrong_hints() {
+    // When a function returns `callable` and the result is immediately
+    // invoked, inlay hints must NOT show the outer function's parameter
+    // names on the inner call's arguments.
+    //
+    // Before the fix, `makeCallable('1', '2')('test')` showed `$a:`
+    // on `'test'` instead of suppressing the hint (bare `callable`
+    // has no known parameter names).
+    let backend = create_test_backend();
+    let uri = Url::parse("file:///test/callable_invoke.php").unwrap();
+    let text = r#"<?php
+function makeCallable(string $a, string $b): callable
+{
+    return fn (string $c) => "$a $b $c";
+}
+
+makeCallable('1', '2')('test');
+"#;
+
+    let hints = inlay_hints_for(&backend, &uri, text).await;
+
+    // Line 6: `makeCallable('1', '2')('test');`
+    let line6_hints = hints_at_line(&hints, 6);
+    let line6_labels: Vec<String> = line6_hints.iter().map(|h| hint_label(h)).collect();
+
+    // The outer call `makeCallable('1', '2')` should show `$a:` and `$b:`.
+    assert!(
+        line6_labels.iter().any(|l| l == "a:"),
+        "Should show 'a:' hint for makeCallable's first arg; got: {:?}",
+        line6_labels
+    );
+    assert!(
+        line6_labels.iter().any(|l| l == "b:"),
+        "Should show 'b:' hint for makeCallable's second arg; got: {:?}",
+        line6_labels
+    );
+
+    // The inner call `('test')` should NOT show `$a:` — it's invoking
+    // a bare `callable`, not `makeCallable`.
+    // Count how many `a:` hints there are — should be exactly 1 (from
+    // the outer call), not 2.
+    let a_count = line6_labels.iter().filter(|l| *l == "a:").count();
+    assert_eq!(
+        a_count, 1,
+        "Should have exactly 1 'a:' hint (outer call only), got {}: {:?}",
+        a_count, line6_labels
+    );
+}