Implement two more features from the todo list

Author: AJenbo

docs/CHANGELOG.md

@@ -17,6 +17,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Fixed
 
+- **Parenthesized RHS expressions now resolved.** Assignments like `$var = (new Foo())` and `$var = ($cond ? $a : $b)` now resolve correctly through the AST path. Previously the `Expression::Parenthesized` wrapper was not unwrapped in `resolve_rhs_expression`.
+- **`$var::` completion for class-string variables.** When a variable holds a class-string (e.g. `$cls = User::class`), using `$cls::` now offers the referenced class's static members, constants, and static properties. Handles `self::class`, `static::class`, `parent::class`, and unions from match/ternary/null-coalescing expressions.
 - **`?->` chaining fallback now recurses correctly.** The `?->` fallback branch in subject extraction called `extract_simple_variable` instead of `extract_arrow_subject`. The primary `->` branch already handled `?->` chains correctly via a `?` skip, so this was not user-visible, but the fallback is now consistent.
 - **Multi-extends interfaces now fully stored.** Interfaces extending multiple parents (e.g. `interface C extends A, B`) now store all parent names, not just the first one.
 

docs/todo.md

@@ -11,57 +11,6 @@ section.
 
 ## Completion & Go-to-Definition Gaps
 
-### Quick wins
-
-#### 28. Parenthesized RHS expression not unwrapped in variable resolution ✅ **[DONE]**
-
-**Completed:**  
-`resolve_rhs_expression` now correctly unwraps `Expression::Parenthesized` nodes, so assignments like `$var = (new Foo())` and `$var = ($condition ? $a : $b)` resolve through the AST-based path.
-
----
-
-#### 29 / 35. Namespace-level `const` declarations not indexed
-
-Only `define('NAME', value)` calls are extracted and stored in
-`global_defines`. PHP's `const NAME = value;` syntax at namespace or
-top level is not indexed, so these constants don't appear in completion
-and can't be navigated to via go-to-definition.
-
-```php
-namespace App\Config;
-
-const MAX_RETRIES = 3;   // ← not indexed, no completion or go-to-definition
-define('APP_NAME', '…');  // ← works fine
-```
-
-**Fix:** in `extract_defines_from_statements`, also handle
-`Statement::Constant` nodes and store their names (namespace-qualified)
-in `global_defines`. This fixes both completion and go-to-definition
-(§35) in one change.
-
----
-
-#### 25. No completion after `$var::` where variable holds a class-string
-
-When a variable holds a class-string value (e.g. from `$cls = User::class`),
-using the `::` operator on it (`$cls::`) does not offer static members of
-the referenced class. The subject `$cls` is passed to `resolve_target_classes`
-which resolves it to its *value type* (`string` / `class-string`) rather than
-the *referenced class* (`User`).
-
-```php
-$cls = User::class;
-$cls::  // ← no completion (should offer User's static members/constants)
-```
-
-**Fix:** in `resolve_target_classes`, when the subject is a bare `$var`
-and `access_kind` is `DoubleColon`, check if the variable was assigned a
-`Foo::class` literal (or a union of `::class` literals from a match
-expression). If so, resolve to those class(es) instead of the variable's
-value type.
-
----
-
 ### High impact
 
 #### 23. Match-expression class-string not forwarded to conditional return types

example.php

@@ -51,6 +51,17 @@
 $ternaryUser->grantPermission('edit'); // only on AdminUser branch
 
 
+// ── Class-String Variable Static Access ─────────────────────────────────────
+// When a variable holds a class-string from `Foo::class`, using `$var::`
+// resolves to the referenced class and offers its static members.
+
+$cls = User::class;
+$cls::findByEmail('a@b.c');  // static method from User
+$cls::TYPE_ADMIN;            // class constant
+$cls::$defaultRole;          // static property
+
+$ref = self::class;          // also works with self::class / static::class
+
 
 // ── Static & Enum Completion ────────────────────────────────────────────────
 

src/completion/resolver.rs

@@ -297,6 +297,26 @@ impl Backend {
                     &dummy_class
                 }
             };
+
+            // ── `$var::` where `$var` holds a class-string ──
+            // When the access kind is `::`, the user wants static members
+            // of the class that the variable *references*, not the value
+            // type (`string`).  Scan for `$var = Foo::class` assignments
+            // and resolve to those class(es).
+            if _access_kind == AccessKind::DoubleColon {
+                let class_string_targets = Self::resolve_class_string_targets(
+                    subject,
+                    effective_class,
+                    all_classes,
+                    ctx.content,
+                    ctx.cursor_offset,
+                    class_loader,
+                );
+                if !class_string_targets.is_empty() {
+                    return class_string_targets;
+                }
+            }
+
             return Self::resolve_variable_types(
                 subject,
                 effective_class,

src/completion/variable_resolution.rs

@@ -42,7 +42,9 @@ use crate::util::{
     ARRAY_ELEMENT_FUNCS, ARRAY_PRESERVING_FUNCS, find_semicolon_balanced, short_name,
 };
 
-use super::conditional_resolution::{resolve_conditional_with_args, split_call_subject};
+use super::conditional_resolution::{
+    extract_class_string_from_expr, resolve_conditional_with_args, split_call_subject,
+};
 use super::resolver::{FunctionLoaderFn, VarResolutionCtx};
 
 impl Backend {
@@ -82,6 +84,219 @@ impl Backend {
         })
     }
 
+    /// Resolve a `$variable` that holds a class-string (e.g. `$cls = User::class`)
+    /// to the referenced class(es).
+    ///
+    /// This is used when the access kind is `::` (`$cls::`) — instead of
+    /// resolving the variable to its *value type* (`string`), we resolve it
+    /// to the *referenced class* so that static members are offered.
+    ///
+    /// Handles simple assignments (`$cls = User::class`), match expressions
+    /// (`$cls = match(...) { ... => A::class, ... => B::class }`), and
+    /// ternary / null-coalescing branches.
+    pub(super) fn resolve_class_string_targets(
+        var_name: &str,
+        current_class: &ClassInfo,
+        all_classes: &[ClassInfo],
+        content: &str,
+        cursor_offset: u32,
+        class_loader: &dyn Fn(&str) -> Option<ClassInfo>,
+    ) -> Vec<ClassInfo> {
+        with_parsed_program(
+            content,
+            "resolve_class_string_targets",
+            |program, _content| {
+                let ctx = VarResolutionCtx {
+                    var_name,
+                    current_class,
+                    all_classes,
+                    content,
+                    cursor_offset,
+                    class_loader,
+                    function_loader: None,
+                };
+                Self::resolve_class_string_in_statements(program.statements.iter(), &ctx)
+            },
+        )
+    }
+
+    /// Walk statements to find class-string assignments to the target variable.
+    fn resolve_class_string_in_statements<'b>(
+        statements: impl Iterator<Item = &'b Statement<'b>>,
+        ctx: &VarResolutionCtx<'_>,
+    ) -> Vec<ClassInfo> {
+        let stmts: Vec<&Statement> = statements.collect();
+
+        // Check class bodies first (same pattern as resolve_variable_in_statements).
+        for &stmt in &stmts {
+            match stmt {
+                Statement::Class(class) => {
+                    let start = class.left_brace.start.offset;
+                    let end = class.right_brace.end.offset;
+                    if ctx.cursor_offset >= start && ctx.cursor_offset <= end {
+                        return Self::resolve_class_string_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 {
+                        return Self::resolve_class_string_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 {
+                        return Self::resolve_class_string_in_members(enum_def.members.iter(), ctx);
+                    }
+                }
+                Statement::Namespace(ns) => {
+                    let results =
+                        Self::resolve_class_string_in_statements(ns.statements().iter(), ctx);
+                    if !results.is_empty() {
+                        return results;
+                    }
+                }
+                Statement::Function(func) => {
+                    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 {
+                        let mut results = Vec::new();
+                        Self::walk_class_string_assignments(
+                            func.body.statements.iter(),
+                            ctx,
+                            &mut results,
+                        );
+                        return results;
+                    }
+                }
+                _ => {}
+            }
+        }
+
+        // Top-level code.
+        let mut results = Vec::new();
+        Self::walk_class_string_assignments(stmts.into_iter(), ctx, &mut results);
+        results
+    }
+
+    /// Resolve class-string assignments inside class-like members.
+    fn resolve_class_string_in_members<'b>(
+        members: impl Iterator<Item = &'b ClassLikeMember<'b>>,
+        ctx: &VarResolutionCtx<'_>,
+    ) -> Vec<ClassInfo> {
+        for member in members {
+            if let ClassLikeMember::Method(method) = member {
+                let body = match &method.body {
+                    MethodBody::Concrete(body) => body,
+                    _ => continue,
+                };
+                let start = body.left_brace.start.offset;
+                let end = body.right_brace.end.offset;
+                if ctx.cursor_offset >= start && ctx.cursor_offset <= end {
+                    let mut results = Vec::new();
+                    Self::walk_class_string_assignments(body.statements.iter(), ctx, &mut results);
+                    return results;
+                }
+            }
+        }
+        vec![]
+    }
+
+    /// Walk statements collecting class names from `$var = Foo::class` assignments.
+    fn walk_class_string_assignments<'b>(
+        statements: impl Iterator<Item = &'b Statement<'b>>,
+        ctx: &VarResolutionCtx<'_>,
+        results: &mut Vec<ClassInfo>,
+    ) {
+        for stmt in statements {
+            if stmt.span().start.offset >= ctx.cursor_offset {
+                continue;
+            }
+            if let Statement::Expression(expr_stmt) = stmt {
+                Self::check_class_string_assignment(expr_stmt.expression, ctx, results);
+            }
+        }
+    }
+
+    /// Check if an expression is an assignment of a `::class` literal
+    /// to the target variable, and if so, resolve the class.
+    fn check_class_string_assignment(
+        expr: &Expression<'_>,
+        ctx: &VarResolutionCtx<'_>,
+        results: &mut Vec<ClassInfo>,
+    ) {
+        let Expression::Assignment(assignment) = expr else {
+            return;
+        };
+        if !assignment.operator.is_assign() {
+            return;
+        }
+        let lhs_name = match assignment.lhs {
+            Expression::Variable(Variable::Direct(dv)) => dv.name.to_string(),
+            _ => return,
+        };
+        if lhs_name != ctx.var_name {
+            return;
+        }
+
+        let class_names = Self::extract_class_string_names(assignment.rhs);
+        // Clear previous results — the last unconditional assignment wins.
+        results.clear();
+        for name in class_names {
+            let resolved_name = if name == "self" || name == "static" {
+                ctx.current_class.name.clone()
+            } else if name == "parent" {
+                match &ctx.current_class.parent_class {
+                    Some(p) => short_name(p).to_string(),
+                    None => continue,
+                }
+            } else {
+                name
+            };
+            let lookup = short_name(&resolved_name);
+            if let Some(cls) = ctx.all_classes.iter().find(|c| c.name == lookup) {
+                ClassInfo::push_unique(results, cls.clone());
+            } else if let Some(cls) = (ctx.class_loader)(&resolved_name) {
+                ClassInfo::push_unique(results, cls);
+            }
+        }
+    }
+
+    /// Extract class names from `::class` expressions, recursing into
+    /// match arms, ternary branches, null-coalescing, and parenthesized
+    /// expressions.
+    fn extract_class_string_names(expr: &Expression<'_>) -> Vec<String> {
+        if let Some(name) = extract_class_string_from_expr(expr) {
+            return vec![name];
+        }
+        match expr {
+            Expression::Parenthesized(p) => Self::extract_class_string_names(p.expression),
+            Expression::Match(match_expr) => {
+                let mut names = Vec::new();
+                for arm in match_expr.arms.iter() {
+                    names.extend(Self::extract_class_string_names(arm.expression()));
+                }
+                names
+            }
+            Expression::Conditional(cond) => {
+                let mut names = Vec::new();
+                let then_expr = cond.then.unwrap_or(cond.condition);
+                names.extend(Self::extract_class_string_names(then_expr));
+                names.extend(Self::extract_class_string_names(cond.r#else));
+                names
+            }
+            Expression::Binary(binary) if binary.operator.is_null_coalesce() => {
+                let mut names = Vec::new();
+                names.extend(Self::extract_class_string_names(binary.lhs));
+                names.extend(Self::extract_class_string_names(binary.rhs));
+                names
+            }
+            _ => vec![],
+        }
+    }
+
     /// Walk a sequence of top-level statements to find the class or
     /// function body that contains the cursor, then resolve the target
     /// variable's type within that scope.

src/parser/functions.rs

@@ -223,6 +223,12 @@ impl Backend {
                         defines.push(name);
                     }
                 }
+                // Handle namespace-level const declarations
+                Statement::Constant(const_decl) => {
+                    for item in const_decl.items.iter() {
+                        defines.push(item.name.value.to_string());
+                    }
+                }
                 Statement::Namespace(namespace) => {
                     Self::extract_defines_from_statements(namespace.statements().iter(), defines);
                 }