Fix linked editing

Author: AJenbo

src/linked_editing.rs

@@ -219,6 +219,7 @@ fn span_in_region(
     span_offset: u32,
     symbol_map: &SymbolMap,
     var_name: &str,
+    all_regions: &[Region],
 ) -> bool {
     // Case 1: the span is the definition token of this region.
     if span_offset == region.def_offset {
@@ -236,8 +237,16 @@ fn span_in_region(
             // Compound assignments (+=, -=, .=, etc.) modify in place
             // and belong to the current region.
             Some(VarDefKind::CompoundAssignment) => return true,
-            // Any other definition kind starts its own region.
-            Some(_) => {}
+            // If this definition starts its own region, it doesn't
+            // belong here. But if it was skipped by build_regions
+            // (e.g. a deeper-nested conditional assignment), it
+            // belongs to the enclosing region.
+            Some(_) => {
+                let starts_own_region = all_regions.iter().any(|r| r.def_offset == span_offset);
+                if !starts_own_region {
+                    return true;
+                }
+            }
         }
     }
 
@@ -295,7 +304,7 @@ fn collect_variable_ranges_in_region(
             if span_scope != scope_start {
                 continue;
             }
-            if !span_in_region(region, span.start, symbol_map, var_name) {
+            if !span_in_region(region, span.start, symbol_map, var_name, &regions) {
                 continue;
             }
             if !seen_offsets.insert(span.start) {
@@ -327,6 +336,109 @@ fn collect_variable_ranges_in_region(
         }
     }
 
+    // ── Closure use() capture bridging ──────────────────────────────────
+    //
+    // When a variable is captured via `use ($var)`, renaming it must
+    // propagate across both the outer scope (where the variable is
+    // defined) and the inner closure scope (where it is used).  The
+    // `use ($var)` token sits physically in the outer scope but has a
+    // `ClosureCapture` VarDefSite scoped to the closure body.
+    //
+    // Case A (cursor in outer scope): find ClosureCapture defs whose
+    // offset falls within this region, then include all occurrences of
+    // the variable inside each captured closure.
+    //
+    // Case B (cursor in closure scope): if the region's definition is
+    // a ClosureCapture, bridge outward to the outer scope's region and
+    // include those occurrences too.
+
+    // Case A: outer scope → closure bodies
+    for def in &symbol_map.var_defs {
+        if def.name == var_name
+            && def.kind == VarDefKind::ClosureCapture
+            && span_in_region(region, def.offset, symbol_map, var_name, &regions)
+        {
+            // The use() token itself (in outer scope) is already collected
+            // above.  Now collect all occurrences inside the closure body.
+            let closure_scope = def.scope_start;
+            for span in &symbol_map.spans {
+                if let SymbolKind::Variable { name } = &span.kind {
+                    if name != var_name {
+                        continue;
+                    }
+                    let ss = symbol_map.find_variable_scope(name, span.start);
+                    if ss != closure_scope {
+                        continue;
+                    }
+                    if !seen_offsets.insert(span.start) {
+                        continue;
+                    }
+                    ranges.push(variable_range_without_sigil(
+                        content,
+                        span.start as usize,
+                        span.end as usize,
+                    ));
+                }
+            }
+        }
+    }
+
+    // Case B: closure scope → outer scope
+    // Check if the current region's definition is a ClosureCapture.
+    if let Some(capture_def) = symbol_map.var_defs.iter().find(|d| {
+        d.name == var_name
+            && d.kind == VarDefKind::ClosureCapture
+            && d.offset == region.def_offset
+            && d.scope_start == scope_start
+    }) {
+        // The use() token sits in the outer scope.  Find which outer
+        // region it belongs to and include all outer occurrences.
+        let outer_scope = symbol_map.find_enclosing_scope(capture_def.offset);
+        let outer_regions = build_regions(symbol_map, var_name, outer_scope);
+        if let Some(outer_region) = outer_regions.iter().find(|r| {
+            capture_def.offset >= r.effective_from && capture_def.offset < r.reads_until
+                || capture_def.offset == r.def_offset
+        }) {
+            for span in &symbol_map.spans {
+                if let SymbolKind::Variable { name } = &span.kind {
+                    if name != var_name {
+                        continue;
+                    }
+                    let ss = symbol_map.find_variable_scope(name, span.start);
+                    if ss != outer_scope {
+                        continue;
+                    }
+                    if !span_in_region(
+                        outer_region,
+                        span.start,
+                        symbol_map,
+                        var_name,
+                        &outer_regions,
+                    ) {
+                        continue;
+                    }
+                    if !seen_offsets.insert(span.start) {
+                        continue;
+                    }
+                    ranges.push(variable_range_without_sigil(
+                        content,
+                        span.start as usize,
+                        span.end as usize,
+                    ));
+                }
+            }
+            // Also include the outer region's def site if not yet seen.
+            if seen_offsets.insert(outer_region.def_offset) {
+                let end_offset = outer_region.def_offset + 1 + var_name.len() as u32;
+                ranges.push(variable_range_without_sigil(
+                    content,
+                    outer_region.def_offset as usize,
+                    end_offset as usize,
+                ));
+            }
+        }
+    }
+
     // Sort by position for a deterministic response.
     ranges.sort_by(|a, b| {
         a.start

src/symbol_map/extraction.rs

@@ -436,9 +436,12 @@ fn extract_from_statement<'a>(
         }
         Statement::Try(try_stmt) => {
             emit_keyword(&try_stmt.r#try, ctx);
+            let try_block_end = try_stmt.block.span().end.offset;
+            push_cond_nesting(ctx, try_block_end);
             for s in try_stmt.block.statements.iter() {
                 extract_from_statement(s, ctx, scope_start);
             }
+            pop_cond_nesting(ctx);
             for catch in try_stmt.catch_clauses.iter() {
                 emit_keyword(&catch.r#catch, ctx);
                 // Catch type hint is a navigable class reference.

tests/integration/linked_editing.rs

@@ -568,3 +568,116 @@ function demo() {
     // `$abc` in `echo $abc` starts at col 9, so `abc` is col 10..13.
     assert_range(&ranges[1], 3, 10, 13);
 }
+
+#[test]
+fn linked_editing_conditional_reassignment_belongs_to_outer_region() {
+    let backend = create_test_backend();
+    let php = r#"<?php
+function test(bool $bool): void {
+    $a = 'a';
+    $a .= 'a';
+    $a = $a . 'b';
+    if ($bool) {
+        $a = 'b';
+    }
+    echo $a;
+}
+"#;
+
+    // Cursor on `echo $a` (line 8, col 10) — region 2 starts at `$a = $a . 'b'`
+    // and should include the conditional `$a = 'b'` inside the if and `echo $a`.
+    let result = linked_editing_at(&backend, "file:///test.php", php, 8, 10);
+    let ranges = result.expect("expected linked editing ranges").ranges;
+    // Region 2: `$a` on line 4 (LHS of `$a = $a . 'b'`), `$a` on line 6
+    // (inside if), `$a` on line 8 (echo)
+    assert_eq!(
+        ranges.len(),
+        3,
+        "should include LHS assignment, conditional reassignment, and echo"
+    );
+    assert_range(&ranges[0], 4, 5, 6); // $a = $a . 'b' (LHS)
+    assert_range(&ranges[1], 6, 9, 10); // $a = 'b' inside if
+    assert_range(&ranges[2], 8, 10, 11); // echo $a
+}
+
+#[test]
+fn linked_editing_try_catch_reassignment_same_region() {
+    let backend = create_test_backend();
+    let php = r#"<?php
+function test(): void {
+    $conn = null;
+    try {
+        $conn = 'connected';
+    } catch (\Exception $e) {
+        $conn = 'failed';
+    }
+    echo $conn;
+}
+"#;
+
+    // Cursor on `echo $conn` (line 8) — all $conn should be one region
+    let result = linked_editing_at(&backend, "file:///test.php", php, 8, 10);
+    let ranges = result.expect("expected linked editing ranges").ranges;
+    assert_eq!(
+        ranges.len(),
+        4,
+        "should include initial assignment, try, catch, and echo: got {:?}",
+        ranges
+    );
+}
+
+#[test]
+fn linked_editing_closure_use_capture_links_across_scopes() {
+    let backend = create_test_backend();
+    let php = r#"<?php
+function demo(): void {
+    $name = 'world';
+    $fn = function () use ($name) {
+        echo $name;
+    };
+    echo $name;
+}
+"#;
+
+    // All 4 occurrences of $name should link: the outer assignment,
+    // the use() capture, the inner echo, and the outer echo.
+    // Cursor on `$name` inside the closure body (line 4)
+    let result = linked_editing_at(&backend, "file:///test.php", php, 4, 14);
+    let ranges = result.expect("inner $name should bridge to outer").ranges;
+    assert_eq!(
+        ranges.len(),
+        4,
+        "expected all 4 occurrences linked: got {:?}",
+        ranges
+    );
+
+    // Cursor on `$name` in the use() clause (line 3)
+    let result = linked_editing_at(&backend, "file:///test.php", php, 3, 29);
+    let ranges = result.expect("use($name) should link all").ranges;
+    assert_eq!(
+        ranges.len(),
+        4,
+        "expected all 4 occurrences from use() cursor: got {:?}",
+        ranges
+    );
+
+    // Cursor on outer `$name` (line 2, assignment)
+    let result = linked_editing_at(&backend, "file:///test.php", php, 2, 5);
+    let ranges = result.expect("outer $name should bridge to closure").ranges;
+    assert_eq!(
+        ranges.len(),
+        4,
+        "expected all 4 occurrences from outer cursor: got {:?}",
+        ranges
+    );
+
+    // Cursor on outer `echo $name` (line 6)
+    let result = linked_editing_at(&backend, "file:///test.php", php, 6, 10);
+    let ranges = result.expect("outer echo $name should link all").ranges;
+    assert_eq!(
+        ranges.len(),
+        4,
+        "expected all 4 occurrences from outer echo: got {:?}",
+        ranges
+    );
+}