Parameter name inlay hints no longer shift to the wrong parameter when

only part of a multi-line call is visible

Author: AJenbo

docs/CHANGELOG.md

@@ -50,6 +50,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Fixed
 
+- **Parameter name inlay hints no longer shift to the wrong parameter when only part of a multi-line call is visible.** Editors request inlay hints only for the currently visible viewport, and when a call's arguments were split across the viewport boundary, every hint after the first excluded argument was labelled with the previous parameter's name instead of its own. This was most noticeable on multi-line constructor calls with several arguments, such as those using constructor property promotion.
 - **Linked editing no longer types into unrelated parts of the file.** Adding a line above a variable (for example inserting a `/** */` docblock) and then typing could insert the typed characters at two arbitrary places further down, such as in the middle of a method name and in front of a trailing comment. PHPantom is re-reading the file in the background while you type, and linked editing was handing the editor positions measured against the previous version of the file, which the editor then edited on trust. Linked editing now verifies that the positions it reports still point at the variable, and offers nothing at all if they do not, so a keystroke can never land somewhere unexpected. It also becomes available in Blade templates, where the reported positions are checked against the template itself rather than the generated PHP.
 - **Diagnostic and request workers no longer copy the embedded stub indexes.** Every diagnostic pass and every hover, completion, or go-to-definition request cloned the full embedded stub class, function, and constant indexes (thousands of entries each) instead of sharing them. During workspace analysis this happened twice per file, and the resulting allocation churn serialised the parallel diagnostic workers in the memory allocator. The indexes are now shared, roughly halving `analyze` wall time on large Laravel projects and removing the same overhead from every editor request.
 - **Member resolution no longer degrades on deeply nested class dependencies.** Class resolution previously cut off at internal nesting limits, silently returning incomplete member sets (missing completions, spurious unknown-member diagnostics) on projects with deeply intertwined hierarchies and virtual members. Those limits are gone: only genuine dependency cycles, such as two Eloquent models whose relationships reference each other, fall back to a partial view, and they now do so deterministically instead of depending on which class happened to resolve first on a given thread.

src/inlay_hints.rs

@@ -462,11 +462,6 @@ impl Backend {
         let mut positional_counter: usize = 0;
 
         for (arg_idx, &arg_offset) in call_site.arg_offsets.iter().enumerate() {
-            // Skip arguments outside the viewport range.
-            if arg_offset < range_start || arg_offset > range_end {
-                continue;
-            }
-
             // Skip named arguments — the parameter name is already visible.
             if call_site.named_arg_indices.contains(&(arg_idx as u32)) {
                 continue;
@@ -498,6 +493,14 @@ impl Backend {
 
             positional_counter += 1;
 
+            // Skip rendering arguments outside the viewport range, but only
+            // after the positional counter above has been advanced — the
+            // counter must track every argument regardless of visibility so
+            // that arguments rendered later still map to the right parameter.
+            if arg_offset < range_start || arg_offset > range_end {
+                continue;
+            }
+
             let param = &params[param_idx];
 
             // Build the hint label parts.

tests/integration/inlay_hints.rs

@@ -608,6 +608,58 @@ foo('line4');
     );
 }
 
+#[tokio::test]
+async fn range_excluding_early_arg_does_not_shift_later_hints() {
+    let backend = create_test_backend();
+    let uri = Url::parse("file:///test/inlay.php").unwrap();
+    let text = r#"<?php
+function make(string $prefix, string $name, int $entries, int $versions, int $stale): void {}
+make(
+    'p',
+    'n',
+    1,
+    2,
+    3,
+);
+"#;
+
+    let open_params = DidOpenTextDocumentParams {
+        text_document: TextDocumentItem {
+            uri: uri.clone(),
+            language_id: "php".to_string(),
+            version: 1,
+            text: text.to_string(),
+        },
+    };
+    backend.did_open(open_params).await;
+
+    // Exclude the first argument's line ('p') from the requested range; the
+    // remaining arguments must still map to their own parameter, not the
+    // previous one, even though the positional counter must skip over the
+    // excluded argument.
+    let range = Range {
+        start: Position {
+            line: 4,
+            character: 0,
+        },
+        end: Position {
+            line: 8,
+            character: 20,
+        },
+    };
+
+    let hints = backend
+        .handle_inlay_hints(uri.as_ref(), text, range)
+        .unwrap_or_default();
+
+    let lbls: Vec<String> = hints.iter().map(hint_label).collect();
+    assert_eq!(
+        lbls,
+        vec!["name:", "entries:", "versions:", "stale:"],
+        "hints after a range-excluded argument must still map to their own parameter"
+    );
+}
+
 // ─── String literal matching suppression ────────────────────────────────────
 
 #[tokio::test]