Implement unset() variable tracking

Author: AJenbo

docs/CHANGELOG.md

@@ -13,6 +13,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **Template parameter bound resolution.** When a property or variable type is a `@template` parameter (e.g. `TNode`), the resolver falls back to the upper bound declared via `of` (e.g. `@template TNode of SomeClass`) for completion and go-to-definition.
 - **Transitive interface inheritance in go-to-implementation.** If `InterfaceB extends InterfaceA` and `ClassC implements InterfaceB`, go-to-implementation on `InterfaceA` now finds `ClassC`. Works through arbitrary depth and with interfaces that extend multiple parents.
 - **Switch statement variable type tracking.** Variables assigned inside `switch` case bodies now resolve their types. Both brace-delimited and colon-delimited (`switch(): … endswitch;`) forms are supported, and all cases contribute to a union type.
+- **`unset()` variable tracking.** After `unset($var)`, the variable no longer appears in name suggestions and `$var->` does not resolve to its previous type. Re-assignment after `unset` restores the variable with the new type. Conditional `unset` (inside `if` blocks) is handled conservatively, keeping the variable because it might still exist.
 
 ### Fixed
 

docs/todo.md

@@ -92,22 +92,16 @@ variable's concrete type.
 (the class the subject resolved to) rather than the class that declares
 the method.
 
-### 15. `unset()` tracking
-**Priority: Medium**
-
-`unset($var)` removes a variable from scope, and `unset($arr['key'])` removes
-a key from an array shape. Neither is tracked today.
+### ~~15. `unset()` tracking (variable scope)~~ ✅
 
-- **Variable scope.** After `unset($x)`, the variable `$x` should no longer
-  appear in variable name suggestions, and `$x->` should not resolve to the
-  type it had before the `unset`.
-- **Array shape keys.** After `unset($config['host'])`, the key `host` should
-  no longer appear in `$config['` key completions, and the inferred shape
-  should reflect its removal.
+Variable scope tracking is complete. After `unset($x)`, the variable `$x`
+no longer appears in variable name suggestions and `$x->` does not resolve
+to the type it had before the `unset`. Re-assignment after `unset` restores
+the variable with its new type. Conditional `unset` (inside `if` blocks)
+is treated conservatively: the variable is kept because it might still exist.
 
-Both cases require the assignment/variable scanner in
-`completion/variable_resolution.rs` to recognise `unset(...)` statements
-and update its tracking accordingly.
+**Remaining:** Array shape key removal (`unset($config['host'])` removing
+the `host` key from `$config['` key completions) is not yet tracked.
 
 ### 20. Non-`$this` property access in text-based assignment path
 **Priority: Low**

example.php

@@ -1297,6 +1297,53 @@ public function demo(): void
 }
 
 
+
+// ── unset() Tracking ────────────────────────────────────────────────────────
+
+/**
+ * Demonstrates that `unset($var)` removes the variable from scope.
+ *
+ * After `unset($x)`, completion on `$x->` should produce no results.
+ * Re-assigning the variable restores its type.
+ */
+class UnsetDemo
+{
+    public function basicUnset(): void
+    {
+        $user = new User('Alice', 'alice@example.com');
+        $user->getEmail();                // resolves to User
+        unset($user);
+        //$user->
+        // Try: $user->  — no completions (variable was unset)
+    }
+
+    public function reassignAfterUnset(): void
+    {
+        $item = new User('Bob', 'bob@example.com');
+        unset($item);
+        $item = new AdminUser('Admin', 'admin@example.com');
+        $item->grantPermission('edit');   // resolves to AdminUser
+    }
+
+    public function unsetMultiple(): void
+    {
+        $user = new User('A', 'a@b.com');
+        $profile = new UserProfile($user);
+        unset($user, $profile);
+        // Try: $user->   — no completions
+        // Try: $profile-> — no completions
+    }
+
+    public function unsetOnlyAffectsTarget(): void
+    {
+        $user = new User('A', 'a@b.com');
+        $profile = new UserProfile($user);
+        unset($user);
+        $profile->getDisplayName();       // still resolves to UserProfile
+    }
+}
+
+
 // ═══════════════════════════════════════════════════════════════════════════
 // ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
 // ┃  SCAFFOLDING — Supporting definitions below this line.              ┃

src/completion/variable_completion.rs

@@ -486,6 +486,16 @@ fn collect_from_statements<'b>(
                     }
                 }
             }
+            // ── unset($var) ──
+            // When `unset($var)` appears before the cursor, the variable
+            // is no longer in scope and should not be suggested.
+            Statement::Unset(unset_stmt) => {
+                for val in unset_stmt.values.iter() {
+                    if let Expression::Variable(Variable::Direct(dv)) = val {
+                        vars.remove(&dv.name.to_string());
+                    }
+                }
+            }
             // Skip class/function/namespace declarations (they have their
             // own scopes handled by find_scope_and_collect).
             Statement::Class(_)

src/completion/variable_resolution.rs

@@ -101,32 +101,29 @@ impl Backend {
                     if ctx.cursor_offset < start || ctx.cursor_offset > end {
                         continue;
                     }
-                    let results = Self::resolve_variable_in_members(class.members.iter(), ctx);
-                    if !results.is_empty() {
-                        return results;
-                    }
+                    // The cursor is inside this class body.  PHP method
+                    // scopes are isolated — they cannot access variables
+                    // from enclosing or top-level code.  Return whatever
+                    // the member scan found (even if empty, e.g. after
+                    // `unset($var)`), and never fall through to the
+                    // top-level walk.
+                    return Self::resolve_variable_in_members(class.members.iter(), ctx);
                 }
                 Statement::Interface(iface) => {
                     let start = iface.left_brace.start.offset;
                     let end = iface.right_brace.end.offset;
                     if ctx.cursor_offset < start || ctx.cursor_offset > end {
                         continue;
                     }
-                    let results = Self::resolve_variable_in_members(iface.members.iter(), ctx);
-                    if !results.is_empty() {
-                        return results;
-                    }
+                    return Self::resolve_variable_in_members(iface.members.iter(), ctx);
                 }
                 Statement::Enum(enum_def) => {
                     let start = enum_def.left_brace.start.offset;
                     let end = enum_def.right_brace.end.offset;
                     if ctx.cursor_offset < start || ctx.cursor_offset > end {
                         continue;
                     }
-                    let results = Self::resolve_variable_in_members(enum_def.members.iter(), ctx);
-                    if !results.is_empty() {
-                        return results;
-                    }
+                    return Self::resolve_variable_in_members(enum_def.members.iter(), ctx);
                 }
                 Statement::Namespace(ns) => {
                     let results = Self::resolve_variable_in_statements(ns.statements().iter(), ctx);
@@ -142,6 +139,9 @@ impl Backend {
                     let body_start = func.body.left_brace.start.offset;
                     let body_end = func.body.right_brace.end.offset;
                     if ctx.cursor_offset >= body_start && ctx.cursor_offset <= body_end {
+                        // The cursor is inside this function body.  PHP
+                        // function scopes are isolated, so return the
+                        // result directly (even if empty after `unset`).
                         let mut results: Vec<ClassInfo> = Vec::new();
                         Self::resolve_closure_params(&func.parameter_list, ctx, &mut results);
                         Self::walk_statements_for_assignments(
@@ -150,9 +150,7 @@ impl Backend {
                             &mut results,
                             false,
                         );
-                        if !results.is_empty() {
-                            return results;
-                        }
+                        return results;
                     }
                 }
                 _ => {}
@@ -391,6 +389,26 @@ impl Backend {
                         );
                     }
                 }
+                // ── unset($var) tracking ──
+                // When `unset($var)` appears unconditionally before the
+                // cursor, the variable no longer has a type.  Clear all
+                // previously accumulated results so that `$var->` does
+                // not resolve to the type it had before the unset.
+                //
+                // Inside conditional branches (`conditional == true`)
+                // the variable *might* still exist, so we leave the
+                // results untouched.
+                Statement::Unset(unset_stmt) => {
+                    if !conditional {
+                        for val in unset_stmt.values.iter() {
+                            if let Expression::Variable(Variable::Direct(dv)) = val
+                                && dv.name == ctx.var_name
+                            {
+                                results.clear();
+                            }
+                        }
+                    }
+                }
                 _ => {}
             }
         }