fix(rename): handle variables in dynamic property selectors

Dynamic property selectors like `$message->{$attribute}` were only
partially
walked. The scope collector skipped selector expressions when tracking
local
variable reads, which caused false `unused_variable` diagnostics for the
selector variable.

The symbol map extractor also ignored non-identifier property selectors,
so
find-references and rename missed variable occurrences inside dynamic
property
accesses. Renaming `$attribute` updated plain variable uses but not the
selector inside `$message->{$attribute}`.

Walk selector expressions during scope collection and emit variable
symbol
spans for dynamic property selectors in the symbol map. Add regression
tests
covering unused-variable diagnostics, references, and rename behavior
for this
pattern.

Signed-off-by: Anders Jenbo <anders@jenbo.dk>

Author: calebdw

docs/CHANGELOG.md

@@ -53,6 +53,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **Go-to-definition, rename, and highlight accuracy.** References in `@see` tags to qualified names like `App\Foo::bar()` now land on the correct location, and renaming a property selects the whole `$name` instead of `$nam`.
 - **`@phpstan-require-extends` and `@phpstan-require-implements` navigation.** Class and interface names in these trait constraint tags now support go-to-definition and hover, and an import used only by such a tag is no longer flagged as unused. Contributed by @calebdw in https://github.com/PHPantom-dev/phpantom_lsp/pull/172.
 - **Renaming variables captured by nested closures and arrow functions.** Renaming or finding references to a variable used inside deeply nested arrow functions (`fn () => fn () => $var`) or closures with `use ($var)` now updates every occurrence, whether the rename is triggered on the declaration or from deep inside the nesting. Contributed by @calebdw in https://github.com/AJenbo/phpantom_lsp/pull/145.
+- **Variables inside dynamic property accesses are tracked.** A variable used as a dynamic property selector (`$message->{$attribute}`) now counts as a use, so it is no longer wrongly reported as unused, find-references includes it, and renaming the variable updates the selector along with its other occurrences. Contributed by @calebdw in https://github.com/PHPantom-dev/phpantom_lsp/pull/174.
 - **Member rename stays scoped to the declaration it targets.** Renaming a method or property no longer touches same-named members on unrelated classes. A private method rename updates only that method and its real usages, calls on a receiver whose type cannot be resolved are left alone, renaming one implementation of an interface no longer renames sibling implementations, and renaming a child override stays on the child branch. Renaming a parent or interface declaration still updates the inherited overrides and implemented usages. Contributed by @calebdw in https://github.com/PHPantom-dev/phpantom_lsp/pull/160.
 - **Find references on a constructor lists every call site.** Finding references to a `__construct` declaration now reports the `new ClassName(...)` instantiations, `#[ClassName(...)]` attribute usages, and explicit delegation calls written as `parent::__construct()`, `self::__construct()`, or `Class::__construct()`, including for subclasses that inherit the constructor (and excluding subclasses that override it). Attribute classes that are never written as `new` are now found. Contributed by @RemcoSmitsDev in https://github.com/AJenbo/phpantom_lsp/pull/155.
 - **Positions on lines with multibyte characters.** Signature help, go-to-definition on virtual properties, named-argument completion, unused-import removal, and the `@phpstan-ignore` quickfix placed cursors and edits at the wrong column on lines containing multibyte characters; they now use the correct UTF-16 columns. Type strings containing `*` wildcards or variance annotations are also no longer mangled.

src/diagnostics/unused_variables.rs

@@ -622,6 +622,22 @@ function foo() {
         assert!(diags.is_empty());
     }
 
+    #[test]
+    fn no_diagnostic_when_variable_is_used_in_dynamic_property_access() {
+        let diags = collect(
+            r#"<?php
+function foo(object $message, string $type) {
+    $attribute = strtolower($type);
+    return $message->{$attribute};
+}
+"#,
+        );
+        assert!(
+            diags.is_empty(),
+            "dynamic property selector should count as a read"
+        );
+    }
+
     #[test]
     fn skips_unused_parameter() {
         // Parameters are intentionally not flagged until suppression

src/rename/tests.rs

@@ -185,6 +185,36 @@ async fn rename_variable_updates_compact_string() {
     assert!(updated.contains("compact('person')"));
 }
 
+#[tokio::test]
+async fn rename_variable_updates_dynamic_property_selector() {
+    let backend = Backend::new_test();
+    let uri = Url::parse("file:///test.php").unwrap();
+    let text = concat!(
+        "<?php\n",
+        "function demo(object $message, string $type): void {\n",
+        "    $attribute = strtolower($type);\n",
+        "    if (empty($message->{$attribute})) {\n",
+        "        return;\n",
+        "    }\n",
+        "    echo $attribute;\n",
+        "}\n",
+    );
+
+    open_file(&backend, &uri, text).await;
+
+    let edit = rename(&backend, &uri, 2, 6, "$field").await;
+    assert!(
+        edit.is_some(),
+        "Expected a workspace edit for variable rename"
+    );
+
+    let file_edits = edits_for_uri(&edit.unwrap(), &uri);
+    let updated = apply_edits(text, &file_edits);
+    assert!(updated.contains("$field = strtolower($type);"));
+    assert!(updated.contains("$message->{$field}"));
+    assert!(updated.contains("echo $field;"));
+}
+
 #[tokio::test]
 async fn rename_from_compact_string_updates_variable() {
     let backend = Backend::new_test();

src/scope_collector/mod.rs

@@ -1046,10 +1046,25 @@ fn walk_expression(expr: &Expression<'_>, collector: &mut Collector<'_>) {
         Expression::Access(access) => match access {
             Access::Property(pa) => {
                 walk_expression(pa.object, collector);
-                // property selector is not a variable read
+                match &pa.property {
+                    ClassLikeMemberSelector::Identifier(_)
+                    | ClassLikeMemberSelector::Missing(_) => {}
+                    ClassLikeMemberSelector::Variable(var) => walk_variable_read(var, collector),
+                    ClassLikeMemberSelector::Expression(selector) => {
+                        walk_expression(selector.expression, collector)
+                    }
+                }
             }
             Access::NullSafeProperty(pa) => {
                 walk_expression(pa.object, collector);
+                match &pa.property {
+                    ClassLikeMemberSelector::Identifier(_)
+                    | ClassLikeMemberSelector::Missing(_) => {}
+                    ClassLikeMemberSelector::Variable(var) => walk_variable_read(var, collector),
+                    ClassLikeMemberSelector::Expression(selector) => {
+                        walk_expression(selector.expression, collector)
+                    }
+                }
             }
             Access::StaticProperty(spa) => {
                 walk_expression(spa.class, collector);
@@ -1354,9 +1369,23 @@ fn walk_expression_as_write(expr: &Expression<'_>, collector: &mut Collector<'_>
         Expression::Access(Access::Property(pa)) => {
             // `$obj->prop = …` — $obj is read, prop is written.
             walk_expression(pa.object, collector);
+            match &pa.property {
+                ClassLikeMemberSelector::Identifier(_) | ClassLikeMemberSelector::Missing(_) => {}
+                ClassLikeMemberSelector::Variable(var) => walk_variable_read(var, collector),
+                ClassLikeMemberSelector::Expression(selector) => {
+                    walk_expression(selector.expression, collector)
+                }
+            }
         }
         Expression::Access(Access::NullSafeProperty(pa)) => {
             walk_expression(pa.object, collector);
+            match &pa.property {
+                ClassLikeMemberSelector::Identifier(_) | ClassLikeMemberSelector::Missing(_) => {}
+                ClassLikeMemberSelector::Variable(var) => walk_variable_read(var, collector),
+                ClassLikeMemberSelector::Expression(selector) => {
+                    walk_expression(selector.expression, collector)
+                }
+            }
         }
         Expression::Access(Access::StaticProperty(spa)) => {
             walk_expression(spa.class, collector);

src/scope_collector/tests.rs

@@ -532,6 +532,20 @@ function test() {
     assert_eq!(count_kind(&scope_map, "$config", AccessKind::Read), 1);
 }
 
+#[test]
+fn dynamic_property_selector_reads_variable() {
+    let php = r#"<?php
+function test(object $message, string $type) {
+    $attribute = strtolower($type);
+    return $message->{$attribute};
+}
+"#;
+    let scope_map = collect_from_function(php);
+
+    assert_eq!(count_kind(&scope_map, "$attribute", AccessKind::Write), 1);
+    assert_eq!(count_kind(&scope_map, "$attribute", AccessKind::Read), 1);
+}
+
 // ─── Unset ──────────────────────────────────────────────────────────────────
 
 #[test]

src/symbol_map/extraction.rs

@@ -1767,6 +1767,34 @@ fn extract_from_hint_ctx(hint: &Hint<'_>, spans: &mut Vec<SymbolSpan>, ref_ctx:
 
 // ─── Expression extractor ───────────────────────────────────────────────────
 
+fn extract_variable_symbol_spans<'a>(
+    var: &'a Variable<'a>,
+    ctx: &mut ExtractionCtx<'a>,
+    scope_start: u32,
+) {
+    match var {
+        Variable::Direct(dv) => {
+            let raw = bytes_to_str(dv.name);
+            if raw == "$this" {
+                ctx.spans.push(SymbolSpan {
+                    start: dv.span.start.offset,
+                    end: dv.span.end.offset,
+                    kind: SymbolKind::SelfStaticParent(SelfStaticParentKind::This),
+                });
+            } else {
+                let name = raw.strip_prefix('$').unwrap_or(raw).to_string();
+                ctx.spans.push(SymbolSpan {
+                    start: dv.span.start.offset,
+                    end: dv.span.end.offset,
+                    kind: SymbolKind::Variable { name },
+                });
+            }
+        }
+        Variable::Indirect(iv) => extract_from_expression(iv.expression, ctx, scope_start),
+        Variable::Nested(nv) => extract_variable_symbol_spans(nv.variable, ctx, scope_start),
+    }
+}
+
 fn extract_from_expression<'a>(
     expr: &'a Expression<'a>,
     ctx: &mut ExtractionCtx<'a>,
@@ -2105,38 +2133,56 @@ fn extract_from_expression<'a>(
                     let subject_text = expr_to_subject_text(pa.object);
                     extract_from_expression(pa.object, ctx, scope_start);
 
-                    if let ClassLikeMemberSelector::Identifier(ident) = &pa.property {
-                        let member_name = bytes_to_str(ident.value).to_string();
-                        ctx.spans.push(SymbolSpan {
-                            start: ident.span.start.offset,
-                            end: ident.span.end.offset,
-                            kind: SymbolKind::MemberAccess {
-                                subject_text,
-                                member_name,
-                                is_static: false,
-                                is_method_call: false,
-                                is_docblock_reference: false,
-                            },
-                        });
+                    match &pa.property {
+                        ClassLikeMemberSelector::Identifier(ident) => {
+                            let member_name = bytes_to_str(ident.value).to_string();
+                            ctx.spans.push(SymbolSpan {
+                                start: ident.span.start.offset,
+                                end: ident.span.end.offset,
+                                kind: SymbolKind::MemberAccess {
+                                    subject_text,
+                                    member_name,
+                                    is_static: false,
+                                    is_method_call: false,
+                                    is_docblock_reference: false,
+                                },
+                            });
+                        }
+                        ClassLikeMemberSelector::Variable(var) => {
+                            extract_variable_symbol_spans(var, ctx, scope_start)
+                        }
+                        ClassLikeMemberSelector::Expression(selector) => {
+                            extract_from_expression(selector.expression, ctx, scope_start)
+                        }
+                        ClassLikeMemberSelector::Missing(_) => {}
                     }
                 }
                 Access::NullSafeProperty(pa) => {
                     let subject_text = expr_to_subject_text(pa.object);
                     extract_from_expression(pa.object, ctx, scope_start);
 
-                    if let ClassLikeMemberSelector::Identifier(ident) = &pa.property {
-                        let member_name = bytes_to_str(ident.value).to_string();
-                        ctx.spans.push(SymbolSpan {
-                            start: ident.span.start.offset,
-                            end: ident.span.end.offset,
-                            kind: SymbolKind::MemberAccess {
-                                subject_text,
-                                member_name,
-                                is_static: false,
-                                is_method_call: false,
-                                is_docblock_reference: false,
-                            },
-                        });
+                    match &pa.property {
+                        ClassLikeMemberSelector::Identifier(ident) => {
+                            let member_name = bytes_to_str(ident.value).to_string();
+                            ctx.spans.push(SymbolSpan {
+                                start: ident.span.start.offset,
+                                end: ident.span.end.offset,
+                                kind: SymbolKind::MemberAccess {
+                                    subject_text,
+                                    member_name,
+                                    is_static: false,
+                                    is_method_call: false,
+                                    is_docblock_reference: false,
+                                },
+                            });
+                        }
+                        ClassLikeMemberSelector::Variable(var) => {
+                            extract_variable_symbol_spans(var, ctx, scope_start)
+                        }
+                        ClassLikeMemberSelector::Expression(selector) => {
+                            extract_from_expression(selector.expression, ctx, scope_start)
+                        }
+                        ClassLikeMemberSelector::Missing(_) => {}
                     }
                 }
                 Access::StaticProperty(spa) => {

tests/integration/references.rs

@@ -423,6 +423,37 @@ function test(): void {
     );
 }
 
+#[test]
+fn variable_references_include_dynamic_property_selector() {
+    let backend = create_test_backend();
+    let uri = "file:///tmp/test_refs_dynamic_selector.php";
+    let content = r#"<?php
+
+function test(object $message, string $type): void {
+    $attribute = strtolower($type);
+    if (empty($message->{$attribute})) {
+        return;
+    }
+    echo $attribute;
+}
+"#;
+
+    open_file(&backend, uri, content);
+
+    let results = backend
+        .find_references(uri, content, Position::new(3, 5), true)
+        .expect("should find references");
+
+    assert_no_duplicates(&results, "variable_references_dynamic_selector");
+    assert_eq!(
+        results.len(),
+        3,
+        "Expected 3 references (definition + dynamic selector + echo), got {}: {:#?}",
+        results.len(),
+        results
+    );
+}
+
 // ─── Static member references ───────────────────────────────────────────────
 
 #[test]