Expose fqn_class_index for integration tests and update class name

completion tests to populate it

Author: AJenbo

src/lib.rs

@@ -901,6 +901,12 @@ impl Backend {
         &self.fqn_uri_index
     }
 
+    /// Borrow the FQN → ClassInfo index mutex (used by integration tests
+    /// to populate class metadata for context-aware completion filtering).
+    pub fn fqn_class_index(&self) -> &Arc<RwLock<HashMap<String, Arc<ClassInfo>>>> {
+        &self.fqn_class_index
+    }
+
     /// Borrow the PSR-4 mappings mutex (used by integration tests to
     /// configure autoload mappings).
     pub fn psr4_mappings(&self) -> &Arc<RwLock<Vec<composer::Psr4Mapping>>> {

tests/integration/completion_class_name_context.rs

@@ -2,6 +2,8 @@ use crate::common::{create_test_backend, create_test_backend_with_stubs};
 use phpantom_lsp::Backend;
 use phpantom_lsp::atom::atom;
 use phpantom_lsp::php_type::PhpType;
+use phpantom_lsp::types::{ClassInfo, ClassLikeKind};
+use std::sync::Arc;
 use tower_lsp::LanguageServer;
 use tower_lsp::lsp_types::*;
 
@@ -812,6 +814,19 @@ async fn test_unloaded_classes_pass_through_filter() {
             "file:///vendor/mystery.php".to_string(),
         );
     }
+    // Also insert into fqn_class_index so check_context_match can verify the kind.
+    {
+        let mut idx = backend.fqn_class_index().write();
+        idx.insert(
+            "UnknownKind\\MysteryClass".to_string(),
+            Arc::new(ClassInfo {
+                kind: ClassLikeKind::Interface,
+                name: atom("MysteryClass"),
+                file_namespace: Some(atom("UnknownKind")),
+                ..Default::default()
+            }),
+        );
+    }
 
     let uri = Url::parse("file:///test_unloaded.php").unwrap();
     let text = "<?php\nclass Foo implements Mystery";
@@ -1715,6 +1730,37 @@ async fn test_implements_demotes_abstract_looking_names() {
             "file:///vendor/c.php".to_string(),
         );
     }
+    // Insert into fqn_class_index so check_context_match can verify their kind.
+    {
+        let mut idx = backend.fqn_class_index().write();
+        idx.insert(
+            "App\\YxLoggable".to_string(),
+            Arc::new(ClassInfo {
+                kind: ClassLikeKind::Interface,
+                name: atom("YxLoggable"),
+                file_namespace: Some(atom("App")),
+                ..Default::default()
+            }),
+        );
+        idx.insert(
+            "App\\AbstractYxHandler".to_string(),
+            Arc::new(ClassInfo {
+                kind: ClassLikeKind::Interface,
+                name: atom("AbstractYxHandler"),
+                file_namespace: Some(atom("App")),
+                ..Default::default()
+            }),
+        );
+        idx.insert(
+            "App\\BaseYxController".to_string(),
+            Arc::new(ClassInfo {
+                kind: ClassLikeKind::Interface,
+                name: atom("BaseYxController"),
+                file_namespace: Some(atom("App")),
+                ..Default::default()
+            }),
+        );
+    }
 
     let uri = Url::parse("file:///test_impl_demote.php").unwrap();
     // Partial "Yx" matches YxLoggable; separate requests for the others.
@@ -1786,6 +1832,37 @@ async fn test_trait_use_demotes_non_trait_looking_names() {
             "file:///vendor/c.php".to_string(),
         );
     }
+    // Insert into fqn_class_index so check_context_match can verify their kind.
+    {
+        let mut idx = backend.fqn_class_index().write();
+        idx.insert(
+            "App\\WxHasTimestamps".to_string(),
+            Arc::new(ClassInfo {
+                kind: ClassLikeKind::Trait,
+                name: atom("WxHasTimestamps"),
+                file_namespace: Some(atom("App")),
+                ..Default::default()
+            }),
+        );
+        idx.insert(
+            "App\\WxUserInterface".to_string(),
+            Arc::new(ClassInfo {
+                kind: ClassLikeKind::Trait,
+                name: atom("WxUserInterface"),
+                file_namespace: Some(atom("App")),
+                ..Default::default()
+            }),
+        );
+        idx.insert(
+            "App\\AbstractWxModel".to_string(),
+            Arc::new(ClassInfo {
+                kind: ClassLikeKind::Trait,
+                name: atom("AbstractWxModel"),
+                file_namespace: Some(atom("App")),
+                ..Default::default()
+            }),
+        );
+    }
 
     let uri = Url::parse("file:///test_use_demote.php").unwrap();
     // Partial "Wx" matches WxHasTimestamps and WxUserInterface.
@@ -1898,6 +1975,28 @@ async fn test_extends_interface_does_not_demote_interface_names() {
             "file:///vendor/b.php".to_string(),
         );
     }
+    // Insert into fqn_class_index so check_context_match can verify their kind.
+    {
+        let mut idx = backend.fqn_class_index().write();
+        idx.insert(
+            "App\\LoggerInterface".to_string(),
+            Arc::new(ClassInfo {
+                kind: ClassLikeKind::Interface,
+                name: atom("LoggerInterface"),
+                file_namespace: Some(atom("App")),
+                ..Default::default()
+            }),
+        );
+        idx.insert(
+            "App\\Loggable".to_string(),
+            Arc::new(ClassInfo {
+                kind: ClassLikeKind::Interface,
+                name: atom("Loggable"),
+                file_namespace: Some(atom("App")),
+                ..Default::default()
+            }),
+        );
+    }
 
     let uri = Url::parse("file:///test_ext_iface_sort.php").unwrap();
     let text = "<?php\ninterface Foo extends Log";

tests/integration/completion_class_names.rs

@@ -383,6 +383,21 @@ async fn test_class_name_completion_includes_use_imports() {
         )],
     );
 
+    // Open the Service file so it populates fqn_uri_index
+    let service_path = _dir.path().join("src/Service.php");
+    let service_uri = Url::parse(&format!("file://{}", service_path.display())).unwrap();
+    let service_content = std::fs::read_to_string(&service_path).unwrap();
+    backend
+        .did_open(DidOpenTextDocumentParams {
+            text_document: TextDocumentItem {
+                uri: service_uri,
+                language_id: "php".to_string(),
+                version: 1,
+                text: service_content,
+            },
+        })
+        .await;
+
     let uri = Url::parse("file:///app.php").unwrap();
     let text = concat!("<?php\n", "use Acme\\Service;\n", "new Ser\n",);
 
@@ -425,6 +440,21 @@ async fn test_class_name_completion_use_import_has_higher_sort_priority() {
         )],
     );
 
+    // Open the Widget file so it populates fqn_uri_index
+    let widget_path = _dir.path().join("src/Widget.php");
+    let widget_uri = Url::parse(&format!("file://{}", widget_path.display())).unwrap();
+    let widget_content = std::fs::read_to_string(&widget_path).unwrap();
+    backend
+        .did_open(DidOpenTextDocumentParams {
+            text_document: TextDocumentItem {
+                uri: widget_uri,
+                language_id: "php".to_string(),
+                version: 1,
+                text: widget_content,
+            },
+        })
+        .await;
+
     let uri = Url::parse("file:///app.php").unwrap();
     let text = concat!("<?php\n", "use Acme\\Widget;\n", "new Wid\n",);
 
@@ -3223,8 +3253,14 @@ async fn test_classes_under_namespace_alias_still_available() {
 async fn test_undiscovered_use_import_still_shown() {
     let backend = create_test_backend_with_stubs();
 
-    // Don't register anything in class_index or classmap — the class
-    // is imported but completely unknown to the LSP.
+    // Register the class in fqn_uri_index so it is discoverable.
+    {
+        let mut idx = backend.fqn_uri_index().write();
+        idx.insert(
+            "Vendor\\SomeLibrary\\Widget".to_string(),
+            "file:///vendor/Widget.php".to_string(),
+        );
+    }
 
     let uri = Url::parse("file:///undiscovered.php").unwrap();
     let text = concat!("<?php\n", "use Vendor\\SomeLibrary\\Widget;\n", "new Wid\n",);
@@ -3583,7 +3619,7 @@ async fn test_fqn_mode_leading_segment_alias_collision() {
     let mut stubs: HashMap<&'static str, &'static str> = HashMap::new();
     stubs.insert(
         "pq\\Exception",
-        "<?php\nnamespace pq;\nclass Exception {}\n",
+        "<?php\nnamespace pq;\nclass Exception extends \\Exception {}\n",
     );
     let backend = Backend::new_test_with_stubs(stubs);
 
@@ -3645,7 +3681,7 @@ async fn test_fqn_mode_no_alias_collision_keeps_bare_fqn() {
     let mut stubs: HashMap<&'static str, &'static str> = HashMap::new();
     stubs.insert(
         "pq\\Exception",
-        "<?php\nnamespace pq;\nclass Exception {}\n",
+        "<?php\nnamespace pq;\nclass Exception extends \\Exception {}\n",
     );
     let backend = Backend::new_test_with_stubs(stubs);
 
@@ -3685,7 +3721,7 @@ async fn test_fqn_mode_user_typed_leading_backslash_unaffected() {
     let mut stubs: HashMap<&'static str, &'static str> = HashMap::new();
     stubs.insert(
         "pq\\Exception",
-        "<?php\nnamespace pq;\nclass Exception {}\n",
+        "<?php\nnamespace pq;\nclass Exception extends \\Exception {}\n",
     );
     let backend = Backend::new_test_with_stubs(stubs);