Fix class definition lookup for unopened files via PSR-4

Author: AJenbo

src/definition/member/file_lookup.rs

@@ -112,9 +112,24 @@ impl Backend {
                     .map(|(u, _)| u.clone())
             }
         }
-        // Fallback: the target file may have been closed (didClose clears
-        // ast_map).  Check class_index which survives close (issue #99).
-        .or_else(|| self.class_index.read().get(class_name).cloned())?;
+        .or_else(|| {
+            // Fallback: the target file may have been closed (didClose
+            // clears ast_map) or was never opened.  Check class_index
+            // which survives close.
+            self.class_index.read().get(class_name).cloned()
+        })
+        .or_else(|| {
+            // Last resort: resolve the class via PSR-4 mappings to get
+            // the file URI.  This handles classes that were loaded into
+            // fqn_index (via parse_and_cache_file) but whose ast_map
+            // entry was later cleared by didClose, and whose class_index
+            // entry was never created (parse_and_cache_content does not
+            // populate class_index).
+            let workspace_root = self.workspace_root.read().clone()?;
+            let mappings = self.psr4_mappings.read();
+            let file_path = crate::composer::resolve_class_path(&mappings, &workspace_root, class_name)?;
+            Some(crate::util::path_to_uri(&file_path))
+        })?;
 
         // Get the file content.
         let file_content = if uri == current_uri {

src/resolution.rs

@@ -118,7 +118,8 @@ impl Backend {
         // classes that don't follow PSR-4 conventions and aren't in the
         // Composer classmap — e.g. global-namespace classes like `Mockery`
         // that are loaded via Composer's `files` autoloading.
-        if let Some(file_uri) = self.class_index.read().get(class_name).cloned()
+        let class_index_uri = self.class_index.read().get(class_name).cloned();
+        if let Some(file_uri) = class_index_uri
             && let Some(file_path) = Url::parse(&file_uri)
                 .ok()
                 .and_then(|u| u.to_file_path().ok())
@@ -456,15 +457,21 @@ impl Backend {
         // thousands of vendor files.  See P13.
 
         // Populate the fqn_index so that `find_class_in_ast_map` can
-        // resolve these classes via O(1) hash lookup.
+        // resolve these classes via O(1) hash lookup.  Also populate
+        // class_index (FQN → URI) so that `find_class_file_content` can
+        // locate the source file even after the ast_map entry is cleared
+        // by didClose.  The class_index cost is negligible (one string
+        // pair per class).
         {
             let mut fqn_idx = self.fqn_index.write();
+            let mut class_idx = self.class_index.write();
             for cls in &arc_classes {
                 if cls.name.starts_with("__anonymous@") {
                     continue;
                 }
                 let fqn = cls.fqn().to_string();
-                fqn_idx.insert(fqn, Arc::clone(cls));
+                fqn_idx.insert(fqn.clone(), Arc::clone(cls));
+                class_idx.entry(fqn).or_insert_with(|| uri.to_owned());
             }
         }
 

test_lsp.sh

@@ -53,4 +53,4 @@ with open("example.php", "r") as f:
 
     # 8. Exit
     send '{"jsonrpc":"2.0","method":"exit","params":{}}'
-} | cargo run 2>/dev/null
+} | cargo run 2>/dev/null