Resolve self::class, static::class, and parent::class to current class

in type resolution

Author: AJenbo

docs/CHANGELOG.md

@@ -28,6 +28,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **Property `self`/`static` type resolution.** Properties declared with `@var self|null` or `static` type annotations now resolve to the owning class name instead of displaying the raw `self`/`static` keyword in hover and type inference.
 - **Magic `__get` property access.** Accessing undefined properties on objects with a `__get` method now resolves to the method's declared return type, even when `__get` has no template parameters (e.g. `SimpleXMLElement::$child` resolves to `SimpleXMLElement`).
 - **Magic `__call` method return type.** Calling undefined methods on objects with a `__call` method now resolves to `__call`'s declared return type for hover and type inference.
+- **`self::class` and `static::class` in template arguments.** Passing `self::class` or `static::class` to a method with `@template T` + `@param class-string<T>` now correctly resolves T to the enclosing class instead of failing to resolve or resolving to the called class.
 - **Multi-namespace function return type resolution.** In files with multiple `namespace { }` blocks, function return types were resolved against the first namespace instead of the function's own namespace. This caused incorrect type inference for variables assigned from function calls in later namespace blocks.
 - **Template inference through stub interfaces.** `@template-implements` on stub-loaded interfaces (e.g. `IteratorAggregate<int, Foo>`) now correctly propagates substituted return types to child methods that omit a return type annotation. Previously these resolved as untyped.
 - **Generic method return types from `@var` annotations.** When a variable is annotated with a generic type (e.g. `/** @var Collection<int, User> */ $items`), method calls on that variable now correctly substitute class-level template parameters into the return type. Previously, return types like `TValue` remained unsubstituted.

src/completion/call_resolution.rs

@@ -2444,6 +2444,19 @@ impl Backend {
                 .chars()
                 .all(|c| c.is_alphanumeric() || c == '_' || c == '\\')
         {
+            // self::class / static::class / parent::class resolve relative
+            // to the class at the call site.
+            if name.eq_ignore_ascii_case("self") || name.eq_ignore_ascii_case("static") {
+                return ctx
+                    .current_class
+                    .map(|c| PhpType::Named(c.fqn().to_string()));
+            }
+            if name.eq_ignore_ascii_case("parent") {
+                return ctx
+                    .current_class
+                    .and_then(|c| c.parent_class.as_ref())
+                    .map(|p| PhpType::Named(p.to_string()));
+            }
             let resolved_name = if let Some(cls) = (ctx.class_loader)(name) {
                 cls.fqn().to_string()
             } else {

tests/integration/completion_generics.rs

@@ -4979,6 +4979,77 @@ async fn test_method_template_general_does_not_break_class_string() {
     }
 }
 
+/// `self::class` passed to a `class-string<T>` template parameter should
+/// resolve T to the enclosing class, not the class that owns the method.
+#[tokio::test]
+async fn test_method_template_self_class_resolves_to_enclosing_class() {
+    let backend = create_test_backend();
+
+    let uri = Url::parse("file:///self_class_tpl.php").unwrap();
+    let text = concat!(
+        "<?php\n",
+        "class OrmService {\n",
+        "    /**\n",
+        "     * @template T of AbstractEntity\n",
+        "     * @param class-string<T> $class\n",
+        "     * @return T[]\n",
+        "     */\n",
+        "    public function getByQuery(string $class, string $query): array {}\n",
+        "}\n",
+        "class AbstractEntity {}\n",
+        "class Category extends AbstractEntity {\n",
+        "    public function isVisible(): bool {}\n",
+        "    public function getChildren(): array {\n",
+        "        $children = (new OrmService())->getByQuery(self::class, 'SELECT 1');\n",
+        "        foreach ($children as $child) {\n",
+        "            $child->\n",
+        "        }\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;
+
+    let line = text.lines().position(|l| l.contains("$child->")).unwrap() as u32;
+    let col = text.lines().nth(line as usize).unwrap().find("$child->").unwrap() as u32 + 8;
+    let completion_params = CompletionParams {
+        text_document_position: TextDocumentPositionParams {
+            text_document: TextDocumentIdentifier { uri },
+            position: Position { line, character: col },
+        },
+        work_done_progress_params: Default::default(),
+        partial_result_params: Default::default(),
+        context: None,
+    };
+    let result = backend.completion(completion_params).await.unwrap();
+    assert!(result.is_some(), "Completion should return results");
+
+    match result.unwrap() {
+        CompletionResponse::Array(items) => {
+            let method_names: Vec<&str> = items
+                .iter()
+                .filter(|i| i.kind == Some(CompletionItemKind::METHOD))
+                .map(|i| i.filter_text.as_deref().unwrap_or(&i.label))
+                .collect();
+
+            assert!(
+                method_names.contains(&"isVisible"),
+                "self::class should resolve T to Category, got methods: {:?}",
+                method_names
+            );
+        }
+        _ => panic!("Expected CompletionResponse::Array"),
+    }
+}
+
 /// $this->method($arg) inside a class body via assignment.
 /// Verifies the AST-based resolve_rhs_expression path.
 #[tokio::test]