Handle special cases for parent:: static:: and self::r

Author: AJenbo

example.php

@@ -304,7 +304,7 @@ public function getDisplayName(): string
 
 // ─── Child Class (parent:: resolution) ──────────────────────────────────────
 
-class AdminUser extends User
+final class AdminUser extends User
 {
     /** @var string[] */
     private array $permissions = [];
@@ -366,6 +366,7 @@ class Container
      * @template TClass
      * @param string|null $abstract
      * @return ($abstract is class-string<TClass> ? TClass : mixed)
+     * @throws Exception
      */
     public function make(?string $abstract = null): mixed
     {

src/completion/builder.rs

@@ -91,8 +91,20 @@ impl Backend {
 
         // Methods — filtered by static / instance, excluding magic methods
         for method in &target_class.methods {
+            // `__construct` is meaningful to call explicitly via `::` or
+            // `parent::` (e.g. `parent::__construct(...)` in a child class),
+            // so we only suppress it for `->` access.  All other magic
+            // methods are always suppressed.
+            let is_constructor = method.name.eq_ignore_ascii_case("__construct");
             if Self::is_magic_method(&method.name) {
-                continue;
+                let allow = is_constructor
+                    && matches!(
+                        access_kind,
+                        AccessKind::DoubleColon | AccessKind::ParentDoubleColon
+                    );
+                if !allow {
+                    continue;
+                }
             }
 
             // parent:: excludes private members
@@ -104,7 +116,11 @@ impl Backend {
 
             let include = match access_kind {
                 AccessKind::Arrow => !method.is_static,
-                AccessKind::DoubleColon => method.is_static,
+                // `::` normally shows only static methods, but `__construct`
+                // is an exception — it's an instance method that is routinely
+                // called via `parent::__construct(...)`, `self::__construct()`,
+                // `static::__construct()`, or even `ClassName::__construct()`.
+                AccessKind::DoubleColon => method.is_static || is_constructor,
                 // parent:: shows both static and non-static methods
                 AccessKind::ParentDoubleColon => true,
                 AccessKind::Other => true,

src/parser.rs

@@ -557,6 +557,8 @@ impl Backend {
                     let start_offset = class.left_brace.start.offset;
                     let end_offset = class.right_brace.end.offset;
 
+                    let is_final = class.modifiers.contains_final();
+
                     classes.push(ClassInfo {
                         name: class_name,
                         methods,
@@ -567,6 +569,7 @@ impl Backend {
                         parent_class,
                         used_traits,
                         mixins,
+                        is_final,
                     });
                 }
                 Statement::Interface(iface) => {
@@ -625,6 +628,7 @@ impl Backend {
                         parent_class,
                         used_traits,
                         mixins,
+                        is_final: false,
                     });
                 }
                 Statement::Trait(trait_def) => {
@@ -679,6 +683,7 @@ impl Backend {
                         parent_class: None,
                         used_traits,
                         mixins,
+                        is_final: false,
                     });
                 }
                 Statement::Enum(enum_def) => {
@@ -736,6 +741,7 @@ impl Backend {
                     let start_offset = enum_def.left_brace.start.offset;
                     let end_offset = enum_def.right_brace.end.offset;
 
+                    // Enums are implicitly final — they cannot be extended.
                     classes.push(ClassInfo {
                         name: enum_name,
                         methods,
@@ -746,6 +752,7 @@ impl Backend {
                         parent_class,
                         used_traits,
                         mixins,
+                        is_final: true,
                     });
                 }
                 Statement::Namespace(namespace) => {

src/server.rs

@@ -326,16 +326,26 @@ impl LanguageServer for Backend {
                     self.find_or_load_function(&candidates)
                 };
 
-                let candidates = Self::resolve_target_classes(
-                    &target.subject,
-                    target.access_kind,
-                    current_class,
-                    &classes,
-                    &content,
-                    cursor_offset.unwrap_or(0),
-                    &class_loader,
-                    Some(&function_loader),
-                );
+                // `static::` in a final class is equivalent to `self::` but
+                // suggests the class can be subclassed — which it can't.
+                // Suppress suggestions to nudge the developer toward `self::`.
+                let suppress =
+                    target.subject == "static" && current_class.is_some_and(|cc| cc.is_final);
+
+                let candidates = if suppress {
+                    vec![]
+                } else {
+                    Self::resolve_target_classes(
+                        &target.subject,
+                        target.access_kind,
+                        current_class,
+                        &classes,
+                        &content,
+                        cursor_offset.unwrap_or(0),
+                        &class_loader,
+                        Some(&function_loader),
+                    )
+                };
 
                 if !candidates.is_empty() {
                     // `parent::` is syntactically `::` but semantically

src/types.rs

@@ -210,4 +210,9 @@ pub struct ClassInfo {
     /// classes via magic methods (`__call`, `__get`, `__set`, etc.).
     /// Resolved to fully-qualified names during post-processing.
     pub mixins: Vec<String>,
+    /// Whether the class is declared `final`.
+    ///
+    /// Final classes cannot be extended, so `static::` is equivalent to
+    /// `self::` and need not be offered as a separate completion subject.
+    pub is_final: bool,
 }