Fix self:: and parent:: lacking content

AJenbo · AJenbo · commit 43d2ea8ba5a9 · 2026-02-16T19:19:23.000+01:00
diff --git a/src/completion/builder.rs b/src/completion/builder.rs
@@ -98,9 +98,9 @@ impl Backend {
     /// `is_self_or_ancestor` should be `true` when the cursor is inside the
     /// target class itself or inside a class that (transitively) extends the
     /// target.  When `true`, `__construct` is offered for `::` access
-    /// (e.g. `self::__construct()`, `parent::__construct()`,
-    /// `ClassName::__construct()` from within a subclass).  When `false`,
-    /// magic methods are suppressed entirely.
+    /// (e.g. `self::__construct()`, `static::__construct()`,
+    /// `parent::__construct()`, `ClassName::__construct()` from within a
+    /// subclass).  When `false`, magic methods are suppressed entirely.
     pub(crate) fn build_completion_items(
         target_class: &ClassInfo,
         access_kind: AccessKind,
@@ -115,9 +115,9 @@ 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::` when inside the same class or a subclass
-            // (e.g. `parent::__construct(...)`, `self::__construct()`).
+            // `__construct` is meaningful to call explicitly via `::` when
+            // inside the same class or a subclass (e.g.
+            // `parent::__construct(...)`, `self::__construct()`).
             // Outside of that relationship, magic methods are suppressed.
             let is_constructor = method.name.eq_ignore_ascii_case("__construct");
             if Self::is_magic_method(&method.name) {
@@ -145,12 +145,14 @@ impl Backend {
 
             let include = match access_kind {
                 AccessKind::Arrow => !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()`.
+                // External `ClassName::` shows only static methods, but
+                // `__construct` is an exception — it's an instance method
+                // that is routinely called via `ClassName::__construct()`
+                // from within a subclass.
                 AccessKind::DoubleColon => method.is_static || is_constructor,
-                // parent:: shows both static and non-static methods
+                // `self::`, `static::`, and `parent::` show both static and
+                // non-static methods (PHP allows calling instance methods
+                // via `::` from within the class hierarchy).
                 AccessKind::ParentDoubleColon => true,
                 AccessKind::Other => true,
             };
@@ -187,9 +189,9 @@ impl Backend {
                 continue;
             }
 
-            // Static properties accessed via `::` or `parent::` need the `$`
-            // prefix (e.g. `self::$path`), while instance properties via `->`
-            // use the bare name (e.g. `$this->path`).
+            // Static properties accessed via `::` need the `$` prefix
+            // (e.g. `self::$path`, `ClassName::$path`), while instance
+            // properties via `->` use the bare name (e.g. `$this->path`).
             let display_name = if access_kind == AccessKind::DoubleColon
                 || access_kind == AccessKind::ParentDoubleColon
             {
diff --git a/src/server.rs b/src/server.rs
@@ -376,14 +376,19 @@ impl LanguageServer for Backend {
                 };
 
                 if !candidates.is_empty() {
-                    // `parent::` is syntactically `::` but semantically
-                    // different: it shows both static and instance members
-                    // while excluding private ones.
-                    let effective_access = if target.subject == "parent" {
-                        AccessKind::ParentDoubleColon
-                    } else {
-                        target.access_kind
-                    };
+                    // `parent::`, `self::`, and `static::` are syntactically
+                    // `::` but semantically different from external static
+                    // access: they show both static and instance members
+                    // (PHP allows `self::nonStaticMethod()` etc. from an
+                    // instance context).  `parent::` additionally excludes
+                    // private members, which is handled by visibility
+                    // filtering below.
+                    let effective_access =
+                        if matches!(target.subject.as_str(), "parent" | "self" | "static") {
+                            AccessKind::ParentDoubleColon
+                        } else {
+                            target.access_kind
+                        };
 
                     // Merge completion items from all candidate classes,
                     // deduplicating by label so ambiguous variables show
diff --git a/src/types.rs b/src/types.rs
@@ -88,11 +88,15 @@ pub enum AccessKind {
     Arrow,
     /// Completion triggered after `::` (static access).
     DoubleColon,
-    /// Completion triggered after `parent::`.
+    /// Completion triggered after `parent::`, `self::`, or `static::`.
     ///
-    /// This is an oddball: it shows both static **and** instance methods
-    /// (since PHP allows `parent::nonStaticMethod()` from a child class),
-    /// plus constants and static properties — but excludes private members.
+    /// All three keywords use `::` syntax but differ from external static
+    /// access (`ClassName::`): they show both static **and** instance
+    /// methods (PHP allows `self::nonStaticMethod()`,
+    /// `static::nonStaticMethod()`, and `parent::nonStaticMethod()` from
+    /// an instance context), plus constants and static properties.
+    /// Visibility filtering (e.g. excluding private members for `parent::`)
+    /// is handled separately via `current_class_name`.
     ParentDoubleColon,
     /// No specific access operator detected (e.g. inside class body).
     Other,
diff --git a/tests/completion_access_kind.rs b/tests/completion_access_kind.rs
@@ -196,7 +196,7 @@ async fn test_completion_arrow_shows_only_non_static() {
 }
 
 #[tokio::test]
-async fn test_completion_double_colon_shows_only_static_and_constants() {
+async fn test_completion_self_double_colon_shows_all_members() {
     let backend = create_test_backend();
 
     let uri = Url::parse("file:///dcolon.php").unwrap();
@@ -262,33 +262,35 @@ async fn test_completion_double_colon_shows_only_static_and_constants() {
             // Should include static method `create`
             assert!(
                 method_names.contains(&"create"),
-                "DoubleColon should include static method 'create'"
+                "self:: should include static method 'create'"
             );
-            // Should NOT include non-static methods `run` and `helper`
+            // self:: shows both static and non-static methods (PHP allows
+            // calling instance methods via `self::` from within the class).
             assert!(
-                !method_names.contains(&"run"),
-                "DoubleColon should exclude non-static method 'run'"
+                method_names.contains(&"run"),
+                "self:: should include non-static method 'run'"
             );
             assert!(
-                !method_names.contains(&"helper"),
-                "DoubleColon should exclude non-static method 'helper'"
+                method_names.contains(&"helper"),
+                "self:: should include non-static method 'helper'"
             );
 
             // Should include static property `$instance` (with $ prefix for :: access)
             assert!(
                 property_names.contains(&"$instance"),
-                "DoubleColon should include static property '$instance'"
+                "self:: should include static property '$instance'"
             );
-            // Should NOT include non-static property `count` (or `$count`)
+            // Non-static properties are still excluded — `self::$count`
+            // is not valid PHP for instance properties.
             assert!(
                 !property_names.contains(&"count") && !property_names.contains(&"$count"),
-                "DoubleColon should exclude non-static property 'count'"
+                "self:: should exclude non-static property 'count'"
             );
 
             // Should include constant `MAX`
             assert!(
                 constant_names.contains(&"MAX"),
-                "DoubleColon should include constant 'MAX'"
+                "self:: should include constant 'MAX'"
             );
         }
         _ => panic!("Expected CompletionResponse::Array"),
@@ -900,3 +902,174 @@ async fn test_double_colon_shows_class_keyword() {
         _ => panic!("Expected CompletionResponse::Array"),
     }
 }
+
+// ─── self:: and static:: show the same symbols as parent:: ──────────────────
+
+/// `self::` and `static::` should show both static **and** non-static methods,
+/// just like `parent::` does, because PHP allows calling instance methods via
+/// `self::method()` and `static::method()` from within the class hierarchy.
+#[tokio::test]
+async fn test_self_and_static_show_non_static_methods_like_parent() {
+    let backend = create_test_backend();
+
+    let uri = Url::parse("file:///self_static_parity.php").unwrap();
+    let text = concat!(
+        "<?php\n",
+        "class Animal {\n",
+        "    public function breathe(): void {}\n",
+        "    public static function kingdom(): string { return 'Animalia'; }\n",
+        "    public const LEGS = 4;\n",
+        "    public static string $species = '';\n",
+        "    public int $age = 0;\n",
+        "}\n",
+        "class Dog extends Animal {\n",
+        "    public function bark(): void {}\n",
+        "    function testSelf() {\n",
+        "        self::\n",
+        "    }\n",
+        "    function testStatic() {\n",
+        "        static::\n",
+        "    }\n",
+        "}\n",
+    );
+
+    let open_params = DidOpenTextDocumentParams {
+        text_document: TextDocumentItem {
+            uri: uri.clone(),
+            language_id: "php".to_string(),
+            version: 1,
+            text: text.to_string(),
+        },
+    };
+    backend.did_open(open_params).await;
+
+    // ── self:: (line 11, character 14) ──
+    let self_params = CompletionParams {
+        text_document_position: TextDocumentPositionParams {
+            text_document: TextDocumentIdentifier { uri: uri.clone() },
+            position: Position {
+                line: 11,
+                character: 14,
+            },
+        },
+        work_done_progress_params: WorkDoneProgressParams::default(),
+        partial_result_params: PartialResultParams::default(),
+        context: None,
+    };
+
+    let self_result = backend.completion(self_params).await.unwrap();
+    assert!(self_result.is_some(), "self:: should return completions");
+
+    let self_items = match self_result.unwrap() {
+        CompletionResponse::Array(items) => items,
+        _ => panic!("Expected CompletionResponse::Array"),
+    };
+
+    let self_method_names: Vec<&str> = self_items
+        .iter()
+        .filter(|i| i.kind == Some(CompletionItemKind::METHOD))
+        .map(|i| i.filter_text.as_deref().unwrap())
+        .collect();
+    let self_property_names: Vec<&str> = self_items
+        .iter()
+        .filter(|i| i.kind == Some(CompletionItemKind::PROPERTY))
+        .map(|i| i.label.as_str())
+        .collect();
+    let self_constant_names: Vec<&str> = self_items
+        .iter()
+        .filter(|i| i.kind == Some(CompletionItemKind::CONSTANT))
+        .map(|i| i.label.as_str())
+        .collect();
+
+    // self:: should show both static and non-static methods
+    assert!(
+        self_method_names.contains(&"breathe"),
+        "self:: should include inherited non-static 'breathe', got: {:?}",
+        self_method_names
+    );
+    assert!(
+        self_method_names.contains(&"kingdom"),
+        "self:: should include inherited static 'kingdom', got: {:?}",
+        self_method_names
+    );
+    assert!(
+        self_method_names.contains(&"bark"),
+        "self:: should include own non-static 'bark', got: {:?}",
+        self_method_names
+    );
+    // Static properties shown, instance properties excluded
+    assert!(
+        self_property_names.contains(&"$species"),
+        "self:: should include static property '$species', got: {:?}",
+        self_property_names
+    );
+    assert!(
+        !self_property_names.contains(&"age") && !self_property_names.contains(&"$age"),
+        "self:: should exclude non-static property 'age', got: {:?}",
+        self_property_names
+    );
+    // Constants shown
+    assert!(
+        self_constant_names.contains(&"LEGS"),
+        "self:: should include constant 'LEGS', got: {:?}",
+        self_constant_names
+    );
+
+    // ── static:: (line 14, character 16) ──
+    let static_params = CompletionParams {
+        text_document_position: TextDocumentPositionParams {
+            text_document: TextDocumentIdentifier { uri },
+            position: Position {
+                line: 14,
+                character: 16,
+            },
+        },
+        work_done_progress_params: WorkDoneProgressParams::default(),
+        partial_result_params: PartialResultParams::default(),
+        context: None,
+    };
+
+    let static_result = backend.completion(static_params).await.unwrap();
+    assert!(
+        static_result.is_some(),
+        "static:: should return completions"
+    );
+
+    let static_items = match static_result.unwrap() {
+        CompletionResponse::Array(items) => items,
+        _ => panic!("Expected CompletionResponse::Array"),
+    };
+
+    let static_method_names: Vec<&str> = static_items
+        .iter()
+        .filter(|i| i.kind == Some(CompletionItemKind::METHOD))
+        .map(|i| i.filter_text.as_deref().unwrap())
+        .collect();
+    let static_constant_names: Vec<&str> = static_items
+        .iter()
+        .filter(|i| i.kind == Some(CompletionItemKind::CONSTANT))
+        .map(|i| i.label.as_str())
+        .collect();
+
+    // static:: should also show both static and non-static methods
+    assert!(
+        static_method_names.contains(&"breathe"),
+        "static:: should include inherited non-static 'breathe', got: {:?}",
+        static_method_names
+    );
+    assert!(
+        static_method_names.contains(&"kingdom"),
+        "static:: should include inherited static 'kingdom', got: {:?}",
+        static_method_names
+    );
+    assert!(
+        static_method_names.contains(&"bark"),
+        "static:: should include own non-static 'bark', got: {:?}",
+        static_method_names
+    );
+    assert!(
+        static_constant_names.contains(&"LEGS"),
+        "static:: should include constant 'LEGS', got: {:?}",
+        static_constant_names
+    );
+}
diff --git a/tests/completion_variables.rs b/tests/completion_variables.rs
@@ -499,8 +499,8 @@ async fn test_completion_static_double_colon() {
                 "Should include static 'create'"
             );
             assert!(
-                !method_names.contains(&"run"),
-                "Should exclude non-static 'run'"
+                method_names.contains(&"run"),
+                "static:: should include non-static 'run'"
             );
             assert!(
                 constant_names.contains(&"MAX"),
