Renaming a constructor-promoted property parameter now cascades to

`$this->prop` usages

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.
+- **Renaming a constructor-promoted property parameter now cascades to `$this->prop` usages.** Renaming `private int $someField` in a constructor's parameter list previously only updated the parameter declaration itself, leaving every `$this->someField` reference elsewhere in the class stale. Rename, find references, document highlight, and linked editing now treat a promoted property parameter the same as an ordinary property declaration.
 - **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.

docs/todo/bugs.md

@@ -7,60 +7,4 @@ pipeline so it produces correct data. Downstream consumers
 (diagnostics, hover, completion, definition) should never need
 to second-guess upstream output.
 
-## B116. Renaming a constructor-promoted property parameter doesn't cascade to `$this->prop` usages
-
-**Severity: Low-Medium (rename only updates the parameter declaration
-itself; every `$this->field` reference elsewhere in the class is left
-stale, silently producing a broken rename) · Discovered while
-investigating a user-reported GitHub Q&A about rename support for
-promoted properties**
-
-```php
-final class SomeService {
-    public function __construct(
-        private int $someField, // renaming this parameter...
-    ) {}
-
-    public function handle(): void {
-        $this->someField; // ...doesn't rename this usage
-    }
-}
-```
-
-The symbol-map extraction for constructor parameters
-(`src/symbol_map/extraction/class_like.rs:605-642`) unconditionally
-tags every parameter's `VarDefSite`/`SymbolSpan` with
-`kind: VarDefKind::Parameter` (line 633), with no check for
-`param.is_promoted_property()`. This is the symbol map that
-`find_references`/rename consult, and it's a separate structure from
-the properties list the type engine builds in
-`src/parser/classes.rs:1040-1049`, which *does* special-case
-`is_promoted_property()` to synthesize a property for hover/completion/
-type-inference of `$this->someField` — but that data isn't wired back
-into the symbol map's `VarDefKind`.
-
-Because of this, `lookup_var_def_kind_at` (`src/definition/resolve.rs:130`)
-reports `VarDefKind::Parameter` for a promoted property, so
-`src/references/dispatch.rs:136-172` routes the rename to
-`find_variable_references` (`src/references/variables.rs:22`) instead
-of the cross-file, member-access-aware `find_member_references`.
-`find_variable_references` is explicitly file-local/scope-local and
-never looks at `$this->foo` sites, so it only renames the parameter's
-own token(s). The same `VarDefKind::Property` check gates
-`is_property_rename` in `src/rename/prepare.rs:302-306`, so the rename
-is also misclassified as a plain-variable rename rather than a
-property rename, which skips the `$this->foo` prefix-fixup logic
-`src/rename/mod.rs` documents for property renames.
-
-Fix by making the symbol-map extraction in `class_like.rs` emit
-`VarDefKind::Property` (or an equivalent alias treated like `Property`
-everywhere) for parameters where `param.is_promoted_property()` is
-true, and register the declaration wherever
-`find_member_references`/the declaration-hierarchy resolvers expect
-property declarations to live. Audit the other call sites that branch
-on `VarDefKind::Parameter` vs `Property` for promoted params for their
-own reasons (semantic tokens at `semantic_tokens.rs:757-770`, hover at
-`hover/mod.rs:152-158`) so they keep working once the kind changes.
-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).
+No outstanding items.

src/definition/resolve.rs

@@ -138,6 +138,25 @@ impl Backend {
         map.var_def_kind_at(var_name, cursor_offset).cloned()
     }
 
+    /// Whether `offset` is the declaration site of a constructor-promoted
+    /// property parameter (`public function __construct(private int $x) {}`).
+    ///
+    /// Promoted parameters share the same byte offset as their
+    /// `VarDefKind::Parameter` symbol-map entry, but they declare a real
+    /// class property, not a local variable — callers that special-case
+    /// `VarDefKind::Property` (cross-file references, rename, linked
+    /// editing, document highlight) must treat these the same way.
+    /// `ClassInfo::properties` already carries promoted parameters (built
+    /// in `parser/classes.rs`), so this checks membership there instead of
+    /// teaching the symbol map a new `VarDefKind`.
+    pub(crate) fn is_promoted_property_param(&self, uri: &str, offset: u32) -> bool {
+        self.get_classes_for_uri(uri)
+            .iter()
+            .flat_map(|classes| classes.iter())
+            .flat_map(|c| c.properties.iter())
+            .any(|p| p.name_offset != 0 && p.name_offset == offset)
+    }
+
     /// If the cursor is on a variable at its assignment definition site,
     /// return the `effective_from` offset (end of the assignment statement).
     ///

src/highlight/mod.rs

@@ -45,7 +45,14 @@ impl Backend {
             SymbolKind::Variable { name } | SymbolKind::CompactVariable { name } => {
                 // Check if this is actually a property declaration — if
                 // so, highlight member accesses instead of local vars.
-                if let Some(VarDefKind::Property) = symbol_map.var_def_kind_at(name, span.start) {
+                // Constructor-promoted properties are tagged
+                // VarDefKind::Parameter (the token is also a real
+                // parameter) but still declare a class property.
+                let is_property = matches!(
+                    symbol_map.var_def_kind_at(name, span.start),
+                    Some(VarDefKind::Property)
+                ) || self.is_promoted_property_param(uri, span.start);
+                if is_property {
                     self.highlight_member_name(symbol_map, content, name)
                 } else {
                     self.highlight_variable(symbol_map, content, name, span.start)

src/linked_editing.rs

@@ -57,8 +57,15 @@ impl Backend {
         match &span.kind {
             SymbolKind::Variable { name } => {
                 // Property declarations should not trigger linked editing —
-                // renaming a property requires cross-file awareness.
-                if let Some(VarDefKind::Property) = symbol_map.var_def_kind_at(name, span.start) {
+                // renaming a property requires cross-file awareness. This
+                // includes constructor-promoted properties, which are
+                // tagged VarDefKind::Parameter (the token is also a real
+                // parameter) but still declare a class property.
+                let is_property = matches!(
+                    symbol_map.var_def_kind_at(name, span.start),
+                    Some(VarDefKind::Property)
+                ) || self.is_promoted_property_param(uri, span.start);
+                if is_property {
                     return None;
                 }
 

src/references/dispatch.rs

@@ -137,9 +137,14 @@ impl Backend {
                 // Property declarations use Variable spans (so GTD can
                 // jump to the type hint), but Find References should
                 // search for member accesses, not local variable uses.
-                if let Some(crate::symbol_map::VarDefKind::Property) =
-                    self.lookup_var_def_kind_at(uri, name, span_start)
-                {
+                // Constructor-promoted properties are also Variable spans
+                // (tagged VarDefKind::Parameter, since the token is also a
+                // real parameter) but declare a property just the same.
+                let is_property = matches!(
+                    self.lookup_var_def_kind_at(uri, name, span_start),
+                    Some(crate::symbol_map::VarDefKind::Property)
+                ) || self.is_promoted_property_param(uri, span_start);
+                if is_property {
                     // Properties are never static in the Variable span
                     // context ($this->prop).  Static properties use
                     // MemberAccess spans at their usage sites with

src/rename/prepare.rs

@@ -300,9 +300,13 @@ impl Backend {
                 !is_method && !is_constant
             }
             SymbolKind::Variable { name } => {
-                // Variable spans can represent property declarations.
+                // Variable spans can represent property declarations,
+                // including constructor-promoted properties (tagged
+                // VarDefKind::Parameter since the token is also a real
+                // parameter, but still declares a class property).
                 self.lookup_var_def_kind_at(uri, name, span.start)
                     .is_some_and(|k| k == crate::symbol_map::VarDefKind::Property)
+                    || self.is_promoted_property_param(uri, span.start)
             }
             SymbolKind::CompactVariable { .. } => false,
             _ => false,

src/rename/tests.rs

@@ -616,6 +616,57 @@ async fn rename_property_from_access() {
     }
 }
 
+#[tokio::test]
+async fn rename_promoted_property_from_parameter() {
+    let backend = Backend::new_test();
+    let uri = Url::parse("file:///test.php").unwrap();
+    let text = concat!(
+        "<?php\n",
+        "class SomeService {\n",
+        "    public function __construct(\n",
+        "        private int $someField,\n",
+        "    ) {}\n",
+        "\n",
+        "    public function handle(): int {\n",
+        "        return $this->someField;\n",
+        "    }\n",
+        "}\n",
+    );
+
+    open_file(&backend, &uri, text).await;
+
+    // Rename from the constructor-promoted parameter declaration itself.
+    let (line, character) = line_char_of(text, "$someField,");
+    let edit = rename(&backend, &uri, line, character, "otherField").await;
+    assert!(
+        edit.is_some(),
+        "Expected a workspace edit for promoted property rename"
+    );
+
+    let file_edits = edits_for_uri(&edit.unwrap(), &uri);
+    // Should have edits for: the promoted parameter and $this->someField.
+    assert!(
+        file_edits.len() >= 2,
+        "Expected at least 2 edits for someField, got {}",
+        file_edits.len()
+    );
+
+    // The declaration site includes `$`, the `$this->` access site doesn't.
+    for te in &file_edits {
+        assert!(
+            te.new_text == "otherField" || te.new_text == "$otherField",
+            "Unexpected edit text: {}",
+            te.new_text
+        );
+    }
+
+    let updated = apply_edits(text, &file_edits);
+    assert!(
+        updated.contains("$this->otherField"),
+        "Expected $this->someField usage to cascade to otherField:\n{updated}"
+    );
+}
+
 // ─── Function Rename ────────────────────────────────────────────────────────
 
 #[tokio::test]

tests/integration/references.rs

@@ -389,6 +389,50 @@ class Foo {
     );
 }
 
+#[test]
+fn promoted_property_references_cascade() {
+    let backend = create_test_backend();
+    let uri = "file:///tmp/test_refs_promoted_prop.php";
+    let content = r#"<?php
+
+class SomeService {
+    public function __construct(
+        private int $someField,
+    ) {}
+
+    public function handle(): int {
+        return $this->someField;
+    }
+}
+"#;
+
+    open_file(&backend, uri, content);
+
+    // Cursor on `someField` in the promoted constructor parameter (line 4).
+    let results = backend
+        .find_references(uri, content, Position::new(4, 22), true)
+        .expect("should find references");
+
+    assert_no_duplicates(&results, "promoted_property_references");
+
+    // Expect: 1 declaration (the parameter) + 1 access ($this->someField).
+    assert_eq!(
+        results.len(),
+        2,
+        "Expected 2 references (1 declaration + 1 access), got {}: {:#?}",
+        results.len(),
+        results
+    );
+
+    // The access reference must land on the `$this->someField` usage, not
+    // just the constructor's own local parameter uses.
+    let access = results
+        .iter()
+        .find(|loc| loc.range.start.line == 8)
+        .expect("should include the $this->someField access site");
+    assert_eq!(access.range.start.character, 22);
+}
+
 // ─── Variable references ────────────────────────────────────────────────────
 
 #[test]