Fix type hierarchy registration and subtype expansion

Signed-off-by: Anders Jenbo <anders@jenbo.dk>

Author: sidux

docs/CHANGELOG.md

@@ -27,6 +27,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Fixed
 
+- **Type Hierarchy works in more clients.** The `textDocument/prepareTypeHierarchy` capability was registered without registration options, so some clients (notably Zed) did not reliably expose the Type Hierarchy action. The dynamic registration now carries proper `TypeHierarchyRegistrationOptions` with a PHP document selector, so those clients recognise that the feature applies to PHP files. Contributed by @sidux in https://github.com/PHPantom-dev/phpantom_lsp/pull/179.
 - **Extract method generates correct code for more selections.** A variable that the selection reads before it first assigns (for example a parameter the extracted code both consults and updates) is now passed in as an argument as well as returned, instead of being left undefined inside the new method. And an early `return` whose value references a variable defined inside the selection is now kept inside the extracted method and propagated to the caller, instead of being copied to the call site where that variable does not exist.
 - **The editor stays responsive during fast typing in large files.** Editors send a burst of requests on every keystroke (completion, a documentation lookup for each suggestion, diagnostics, code lens, semantic highlighting, and more). The server processed only a few at a time, so during continuous typing the burst backed up until the server stopped answering anything at all, including the completion the user was waiting on, and it only recovered after a restart. Now the burst is processed concurrently and every expensive request runs off the main loop: diagnostics (which re-analyze the whole file on each edit) compute in the background instead of on the request that asked for them, so a diagnostic pull returns immediately and never blocks the threads that deliver completion and hover, and repeated whole-file requests (semantic highlighting, code lens, the document outline, folding, document links) are collapsed so a fast typist's superseded requests no longer pile up and monopolize the CPU. Completion and other requests keep coming back while you type.
 - **Typing in a large file no longer pegs the CPU and stalls completion.** Semantic highlighting recomputed every token's position by rescanning the file from the beginning, so a large file took many seconds at full CPU to highlight. Editors request highlighting on every keystroke, so this ran continuously while typing and starved completion, hover, and other requests until they appeared to hang. Highlighting a large file is now effectively instant, and the same speedup applies to the document outline and code folding, which used the same per-position rescan.

src/server.rs

@@ -397,11 +397,7 @@ impl LanguageServer for Backend {
             .supports_type_hierarchy_dynamic_registration
             .load(Ordering::Acquire)
         {
-            registrations.push(Registration {
-                id: "type-hierarchy".to_string(),
-                method: "textDocument/prepareTypeHierarchy".to_string(),
-                register_options: None,
-            });
+            registrations.push(type_hierarchy_registration());
         }
 
         // Register file watchers for staleness detection.  The client
@@ -1588,6 +1584,27 @@ impl LanguageServer for Backend {
     }
 }
 
+fn type_hierarchy_registration() -> Registration {
+    Registration {
+        id: "type-hierarchy".to_string(),
+        method: "textDocument/prepareTypeHierarchy".to_string(),
+        register_options: Some(
+            serde_json::to_value(TypeHierarchyRegistrationOptions {
+                text_document_registration_options: TextDocumentRegistrationOptions {
+                    document_selector: Some(vec![DocumentFilter {
+                        language: Some("php".to_string()),
+                        scheme: None,
+                        pattern: None,
+                    }]),
+                },
+                type_hierarchy_options: TypeHierarchyOptions::default(),
+                static_registration_options: StaticRegistrationOptions::default(),
+            })
+            .expect("type hierarchy registration options serialize"),
+        ),
+    }
+}
+
 /// Convert a `Vec<Location>` into a `GotoDefinitionResponse`.
 ///
 /// Returns `Scalar` for a single location, `Array` for multiple, and
@@ -1603,6 +1620,26 @@ fn wrap_locations(locations: Vec<Location>) -> Option<GotoDefinitionResponse> {
     }
 }
 
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn type_hierarchy_registration_includes_php_document_selector() {
+        let registration = type_hierarchy_registration();
+
+        assert_eq!(registration.id, "type-hierarchy");
+        assert_eq!(registration.method, "textDocument/prepareTypeHierarchy");
+
+        let options = registration
+            .register_options
+            .expect("type hierarchy registration should include options");
+        assert_eq!(options["documentSelector"][0]["language"], "php");
+        assert!(options["documentSelector"][0].get("scheme").is_none());
+        assert!(options["documentSelector"][0].get("pattern").is_none());
+    }
+}
+
 // ─── Self-scan helpers ──────────────────────────────────────────────────────
 
 impl Backend {

src/type_hierarchy.rs

@@ -139,6 +139,13 @@ impl Backend {
 
         // direct_only = true so only immediate children are returned;
         // the client walks the tree one level at a time.
+        //
+        // We can't shortcut to the reverse inheritance index (`gti_index`)
+        // alone: it is populated only from files that have been fully
+        // parsed, so a parent may have one child already indexed while
+        // other children live in files discovered on disk but not yet
+        // parsed.  `find_implementors` uses `gti_index` as its first phase
+        // and then scans for the rest, so it returns the complete set.
         let implementors = self.find_implementors(short, &fqn, &class_loader, true, true);
 
         let mut result = Vec::new();

tests/integration/type_hierarchy.rs

@@ -1060,3 +1060,73 @@ async fn supertypes_items_have_nonzero_selection_range() {
         );
     }
 }
+
+// ─── Subtypes: completeness when some children already indexed ──────────────
+
+/// Subtypes must list every direct child even when one child file is
+/// already parsed (so it lives in the reverse inheritance index) while
+/// another child file has only been discovered on disk and not yet
+/// parsed.  Returning only the indexed children silently hides the rest.
+#[tokio::test]
+async fn subtypes_includes_unopened_children_when_some_are_indexed() {
+    let composer = r#"{
+        "autoload": {
+            "psr-4": {
+                "App\\": "src/"
+            }
+        }
+    }"#;
+    let files = &[
+        (
+            "src/Repository.php",
+            "<?php\nnamespace App;\ninterface Repository {\n}\n",
+        ),
+        (
+            "src/UserRepository.php",
+            "<?php\nnamespace App;\nclass UserRepository implements Repository {\n}\n",
+        ),
+        (
+            "src/AdminRepository.php",
+            "<?php\nnamespace App;\nclass AdminRepository implements Repository {\n}\n",
+        ),
+    ];
+
+    let (backend, dir) = create_psr4_workspace(composer, files);
+
+    // Open the interface and ONE implementor.  Opening UserRepository
+    // parses it and records App\UserRepository as a child of
+    // App\Repository in the reverse inheritance index — but
+    // AdminRepository stays on disk, discovered only by a wider scan.
+    let iface_uri = Url::from_file_path(dir.path().join("src/Repository.php")).unwrap();
+    open(
+        &backend,
+        &iface_uri,
+        "<?php\nnamespace App;\ninterface Repository {\n}\n",
+    )
+    .await;
+    let user_uri = Url::from_file_path(dir.path().join("src/UserRepository.php")).unwrap();
+    open(
+        &backend,
+        &user_uri,
+        "<?php\nnamespace App;\nclass UserRepository implements Repository {\n}\n",
+    )
+    .await;
+
+    // Prepare on the `Repository` interface name (line 2, on the name).
+    let items = prepare_at(&backend, &iface_uri, 2, 12).await;
+    assert_eq!(items.len(), 1, "Should prepare on Repository interface");
+    assert_eq!(item_fqn(&items[0]), "App\\Repository");
+
+    let subs = subtypes_of(&backend, &items[0]).await;
+    let names = item_names(&subs);
+    assert!(
+        names.contains(&"UserRepository".to_string()),
+        "subtypes should include the already-indexed UserRepository, got: {:?}",
+        names
+    );
+    assert!(
+        names.contains(&"AdminRepository".to_string()),
+        "subtypes should include the unopened AdminRepository, got: {:?}",
+        names
+    );
+}