Propagate variable rename into closure and arrow function captures

Author: AJenbo

docs/CHANGELOG.md

@@ -55,9 +55,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Fixed
 
-- **Blade diagnostics in `analyze` command.** Blade template files now receive full diagnostics (unknown members, unknown classes, unused variables, etc.) when running `phpantom_lsp analyze`.
-- **Blade unknown-member diagnostic positions.** Unknown-member diagnostics in Blade files now point to the correct line in the original template instead of the virtual PHP line number.
-- **False-positive unused `$loop` in Blade templates.** The `$loop` variable injected by `@foreach`/`@forelse` is no longer flagged as unused when the template body doesn't reference it.
+- **Rename propagates into closures and arrow functions.** Renaming a variable now follows explicit `use ($var)` captures into closure bodies and implicit captures into arrow function bodies, instead of leaving those occurrences unchanged.
 - **Spurious function auto-imports.** Import statements like `use function is_array;` were misidentified as function declarations, polluting the completion list with phantom entries that inserted incorrect imports.
 - **Duplicate `use function` insertion.** Accepting a function completion no longer inserts a `use function` statement when the exact import already exists in the file.
 - **Function import conflict handling.** When a different function with the same short name is already imported, completing a namespaced function now inserts the fully-qualified name instead of the ambiguous short name.
@@ -71,10 +69,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **Foreach narrowing with break in else.** The variable state from break paths is now included in the post-loop type.
 - **Foreach target type after non-empty literal array.** The pre-loop sentinel value no longer survives as a possible post-loop type.
 - **Foreach over `::class` literal arrays resolves static access.** `$className::CONST` and `$className::method()` no longer produce unresolved-member diagnostics.
-- **Foreach loop variable resolution in Blade.** Loop variables now resolve their element type correctly when the iterable is typed via a standalone `@var` docblock.
 - **Hover on reassigned variable shows post-assignment type.** Hovering on the left-hand side of a reassignment now shows the type produced by the assignment.
-- **Blade hover positions.** Hover ranges in `.blade.php` files now highlight the correct symbol under the cursor.
-- **Blade echo delimiter hover.** Hovering on `{{` or `}}` now shows hover for the `e()` function.
 - **Multi-namespace class resolution.** Short class names now resolve against the correct namespace for the current scope.
 - **Multi-namespace variable isolation.** Variable resolution now only considers the namespace block containing the cursor.
 - **Multi-namespace function return type resolution.** Function return types are now resolved against the function's own namespace.

src/references/mod.rs

@@ -30,7 +30,7 @@ use std::sync::Arc;
 use tower_lsp::lsp_types::{Location, Position, Range, Url};
 
 use crate::Backend;
-use crate::symbol_map::{SelfStaticParentKind, SymbolKind, SymbolMap};
+use crate::symbol_map::{SelfStaticParentKind, SymbolKind, SymbolMap, VarDefKind};
 use crate::types::{ClassInfo, MAX_INHERITANCE_DEPTH};
 use crate::util::{
     build_fqn, collect_php_files_gitignore, find_class_at_offset, offset_to_position,
@@ -253,17 +253,18 @@ impl Backend {
             Err(_) => return locations,
         };
 
+        // Build the set of reachable scopes: the primary scope plus any
+        // closure/arrow-function scopes that capture this variable.
+        let reachable_scopes = Self::collect_capture_scopes(symbol_map, var_name, scope_start);
+
         for span in &symbol_map.spans {
             if let SymbolKind::Variable { name } = &span.kind {
                 if name != var_name {
                     continue;
                 }
-                // Check that this variable is in the same scope.
-                // `find_variable_scope` correctly handles parameter
-                // spans and docblock `@param` mentions that sit before
-                // the body `{`.
+                // Check that this variable is in a reachable scope.
                 let span_scope = symbol_map.find_variable_scope(name, span.start);
-                if span_scope != scope_start {
+                if !reachable_scopes.contains(&span_scope) {
                     continue;
                 }
                 // Optionally skip declaration sites.
@@ -291,7 +292,7 @@ impl Backend {
 
             for def in &symbol_map.var_defs {
                 if def.name == var_name
-                    && def.scope_start == scope_start
+                    && reachable_scopes.contains(&def.scope_start)
                     && seen_offsets.insert(def.offset)
                 {
                     let start = offset_to_position(content, def.offset as usize);
@@ -318,6 +319,164 @@ impl Backend {
         locations
     }
 
+    /// Collect all scopes reachable from `root_scope` for `var_name`
+    /// through closure `use` captures and implicit arrow-function captures.
+    ///
+    /// Returns a set containing `root_scope` plus every nested
+    /// closure/arrow scope that captures the variable without shadowing
+    /// it with a new parameter of the same name.
+    fn collect_capture_scopes(
+        symbol_map: &SymbolMap,
+        var_name: &str,
+        root_scope: u32,
+    ) -> HashSet<u32> {
+        let mut reachable = HashSet::new();
+        reachable.insert(root_scope);
+
+        // Explicit closure captures: `function () use ($var) { … }`
+        // These have VarDefKind::ClosureCapture with scope_start
+        // pointing to the closure body.
+        for def in &symbol_map.var_defs {
+            if def.name != var_name || def.kind != VarDefKind::ClosureCapture {
+                continue;
+            }
+            // The `use ($var)` token sits physically in the outer scope.
+            // Check if the outer scope is already reachable.
+            let outer_scope = symbol_map.find_enclosing_scope(def.offset);
+            if reachable.contains(&outer_scope) {
+                reachable.insert(def.scope_start);
+            }
+        }
+
+        // Implicit arrow-function captures: `fn () => $var`
+        // Arrow functions have a scope entry but no ClosureCapture def.
+        // A variable is implicitly captured if:
+        //   1. The arrow scope is directly nested in a reachable scope.
+        //   2. There is no parameter with the same name in the arrow scope.
+        for &(scope_start, _scope_end) in &symbol_map.scopes {
+            if reachable.contains(&scope_start) {
+                continue; // Already reachable, skip.
+            }
+            // Find the parent scope of this scope.
+            let parent = symbol_map.find_enclosing_scope(scope_start.saturating_sub(1));
+            if !reachable.contains(&parent) {
+                continue;
+            }
+            // Check if this is an arrow function scope (no ClosureCapture
+            // or Parameter def that would indicate a closure with `use`).
+            // Arrow scopes don't have braces; their scope_start is the
+            // arrow function expression's start offset.
+            //
+            // Skip if there's a parameter with the same name (shadowed).
+            let has_shadowing_param = symbol_map.var_defs.iter().any(|d| {
+                d.name == var_name
+                    && d.scope_start == scope_start
+                    && d.kind == VarDefKind::Parameter
+            });
+            if has_shadowing_param {
+                continue;
+            }
+            // Check if this scope actually uses the variable (has a
+            // Variable span in it).  Only include it if the variable
+            // appears there to avoid false positives with unrelated
+            // nested functions.
+            //
+            // But we also need to check: is this scope a closure body
+            // (not an arrow function)?  Closures create new variable
+            // scopes and require explicit `use` — if there's no
+            // ClosureCapture def for this scope, the variable is NOT
+            // available inside a regular closure.  We only auto-include
+            // arrow function scopes.
+            //
+            // Heuristic: if there's any ClosureCapture or Parameter def
+            // for *any* variable scoped to this scope_start, and there's
+            // no ClosureCapture for *our* variable, this is likely a
+            // closure that didn't capture our variable — skip it.
+            let is_closure_scope = symbol_map
+                .var_defs
+                .iter()
+                .any(|d| d.scope_start == scope_start && d.kind == VarDefKind::ClosureCapture);
+            if is_closure_scope {
+                // It's a closure scope.  Our variable is not in the `use`
+                // list (we already handled ClosureCapture above), so the
+                // variable is not available here.
+                continue;
+            }
+            // This is an arrow function scope or similar transparent
+            // scope.  The variable is implicitly captured.
+            let has_usage = symbol_map.spans.iter().any(|s| {
+                if let SymbolKind::Variable { name } = &s.kind {
+                    name == var_name && symbol_map.find_variable_scope(name, s.start) == scope_start
+                } else {
+                    false
+                }
+            });
+            if has_usage {
+                reachable.insert(scope_start);
+            }
+        }
+
+        // Recurse: newly added scopes may themselves contain nested
+        // closures/arrows that capture the same variable.
+        // Fixed-point iteration until no new scopes are added.
+        let mut prev_len = 0;
+        while reachable.len() != prev_len {
+            prev_len = reachable.len();
+            let current: Vec<u32> = reachable.iter().copied().collect();
+
+            for def in &symbol_map.var_defs {
+                if def.name != var_name || def.kind != VarDefKind::ClosureCapture {
+                    continue;
+                }
+                if reachable.contains(&def.scope_start) {
+                    continue;
+                }
+                let outer_scope = symbol_map.find_enclosing_scope(def.offset);
+                if reachable.contains(&outer_scope) {
+                    reachable.insert(def.scope_start);
+                }
+            }
+
+            for &(scope_start, _scope_end) in &symbol_map.scopes {
+                if reachable.contains(&scope_start) {
+                    continue;
+                }
+                let parent = symbol_map.find_enclosing_scope(scope_start.saturating_sub(1));
+                if !current.contains(&parent) {
+                    continue;
+                }
+                let has_shadowing_param = symbol_map.var_defs.iter().any(|d| {
+                    d.name == var_name
+                        && d.scope_start == scope_start
+                        && d.kind == VarDefKind::Parameter
+                });
+                if has_shadowing_param {
+                    continue;
+                }
+                let is_closure_scope = symbol_map
+                    .var_defs
+                    .iter()
+                    .any(|d| d.scope_start == scope_start && d.kind == VarDefKind::ClosureCapture);
+                if is_closure_scope {
+                    continue;
+                }
+                let has_usage = symbol_map.spans.iter().any(|s| {
+                    if let SymbolKind::Variable { name } = &s.kind {
+                        name == var_name
+                            && symbol_map.find_variable_scope(name, s.start) == scope_start
+                    } else {
+                        false
+                    }
+                });
+                if has_usage {
+                    reachable.insert(scope_start);
+                }
+            }
+        }
+
+        reachable
+    }
+
     /// Find all references to `$this` within the enclosing class body.
     ///
     /// `$this` is scoped to the enclosing class — it must not match

src/rename/tests.rs

@@ -2364,6 +2364,56 @@ async fn rename_closure_parameter_does_not_leak_to_outer_scope() {
     );
 }
 
+#[tokio::test]
+async fn rename_function_param_propagates_into_closure_use_and_arrow() {
+    let backend = Backend::new_test();
+    let uri = Url::parse("file:///test.php").unwrap();
+    let text = concat!(
+        "<?php\n",
+        "function test(string $param): void\n",
+        "{\n",
+        "    function () use ($param): void {\n",
+        "        echo $param;\n",
+        "    };\n",
+        "\n",
+        "    fn () => $param;\n",
+        "}\n",
+    );
+
+    open_file(&backend, &uri, text).await;
+
+    // Cursor on `$param` in the function parameter list (line 1, col 22).
+    let edit = rename(&backend, &uri, 1, 22, "$renamed").await;
+    assert!(edit.is_some(), "Expected a workspace edit");
+    let file_edits = edits_for_uri(&edit.unwrap(), &uri);
+    let result = apply_edits(text, &file_edits);
+
+    // Function parameter should be renamed.
+    assert!(
+        result.contains("function test(string $renamed)"),
+        "Function parameter not renamed: {}",
+        result
+    );
+    // Closure use should be renamed.
+    assert!(
+        result.contains("use ($renamed)"),
+        "Closure use not renamed: {}",
+        result
+    );
+    // Variable inside closure body should be renamed.
+    assert!(
+        result.contains("echo $renamed;"),
+        "Closure body variable not renamed: {}",
+        result
+    );
+    // Arrow function body should be renamed.
+    assert!(
+        result.contains("fn () => $renamed;"),
+        "Arrow function body not renamed: {}",
+        result
+    );
+}
+
 // ─── Namespace rename tests ─────────────────────────────────────────────────
 
 #[tokio::test]