Implement goto implementations for entity to component declaration

Author: kraigher

vhdl_lang/src/analysis.rs

@@ -32,4 +32,4 @@ mod visibility;
 mod tests;
 
 pub use self::root::DesignRoot;
-pub use named_entity::{AnyEnt, AnyEntKind, EntRef, EntityId, HasEntityId, Related};
+pub use named_entity::{AnyEnt, AnyEntKind, Design, EntRef, EntityId, HasEntityId, Related};

vhdl_lang/src/analysis/root.rs

@@ -467,6 +467,20 @@ impl DesignRoot {
         NotFound
     }
 
+    pub fn search_library(
+        &self,
+        library_name: &Symbol,
+        searcher: &mut impl Searcher,
+    ) -> SearchResult {
+        if let Some(library) = self.libraries.get(library_name) {
+            for unit_id in library.sorted_unit_ids() {
+                let unit = library.units.get(unit_id.key()).unwrap();
+                return_if_found!(unit.unit.write().search(searcher));
+            }
+        }
+        NotFound
+    }
+
     pub fn symbol_utf8(&self, name: &str) -> Symbol {
         self.symbols.symtab().insert_utf8(name)
     }

vhdl_lang/src/ast/search.rs

@@ -1343,6 +1343,35 @@ impl<'a, T: Fn(EntRef<'a>) -> bool> Searcher for FindEnt<'a, T> {
     }
 }
 
+pub struct FindAllEnt<'a, T: Fn(EntRef<'a>) -> bool> {
+    root: &'a DesignRoot,
+    cond: T,
+    pub result: Vec<EntRef<'a>>,
+}
+
+impl<'a, T: Fn(EntRef<'a>) -> bool> FindAllEnt<'a, T> {
+    pub fn new(root: &'a DesignRoot, cond: T) -> FindAllEnt<'a, T> {
+        FindAllEnt {
+            root,
+            cond,
+            result: Vec::default(),
+        }
+    }
+}
+
+impl<'a, T: Fn(EntRef<'a>) -> bool> Searcher for FindAllEnt<'a, T> {
+    fn search_decl(&mut self, decl: FoundDeclaration) -> SearchState {
+        if let Some(id) = decl.ent_id() {
+            let ent = self.root.get_ent(id);
+            if (self.cond)(ent) {
+                self.result.push(ent);
+            }
+        }
+
+        SearchState::NotFinished
+    }
+}
+
 // Search for a declaration/definition and format it
 pub struct FormatDeclaration<'a> {
     ent: EntRef<'a>,

vhdl_lang/src/project.rs

@@ -4,7 +4,8 @@
 //
 // Copyright (c) 2018, Olof Kraigher [email protected]
 
-use crate::analysis::{AnyEnt, AnyEntKind, DesignRoot, EntRef, Related};
+use crate::analysis::{AnyEnt, AnyEntKind, Design, DesignRoot, EntRef, Related};
+use crate::ast::search::FindAllEnt;
 use crate::ast::{DesignFile, Designator};
 use crate::config::Config;
 use crate::data::*;
@@ -237,32 +238,50 @@ impl Project {
         }
     }
 
-    /// Find entity with same name as component in the library
+    fn get_library(&self, source: &Source) -> Option<Symbol> {
+        let file = self.files.get(source.file_name())?;
+        file.library_names.iter().next().cloned()
+    }
+
     pub fn find_implementation<'a>(
         &'a self,
         source: &Source,
         cursor: Position,
-    ) -> Option<EntRef<'a>> {
+    ) -> Option<Vec<EntRef<'a>>> {
         let ent = self.find_declaration(source, cursor)?;
-        if !matches!(ent.kind(), AnyEntKind::Component(_)) {
-            return None;
-        }
 
         let ident = if let Designator::Identifier(ident) = ent.designator() {
             ident
         } else {
             return None;
         };
 
-        let decl_pos = ent.decl_pos()?;
-
-        let file = self.files.get(decl_pos.source().file_name())?;
-        for library_name in file.library_names.iter() {
-            if let Some(design) = self.root.get_design_entity(library_name, ident) {
-                return Some(design.into());
+        match ent.kind() {
+            // Find entity with same name as component in the library
+            AnyEntKind::Component(_) => {
+                let decl_pos = ent.decl_pos()?;
+                let library_name = self.get_library(decl_pos.source())?;
+                let design = self.root.get_design_entity(&library_name, ident)?;
+                Some(vec![design.into()])
+            }
+            // Find all components with same name as entity in the library
+            AnyEntKind::Design(Design::Entity(..)) => {
+                let decl_pos = ent.decl_pos()?;
+                let library_name = self.get_library(decl_pos.source())?;
+
+                let mut searcher = FindAllEnt::new(&self.root, |ent| {
+                    matches!(ent.kind(), AnyEntKind::Component(_))
+                        && matches!(
+                            ent.designator(),
+                            Designator::Identifier(comp_ident) if comp_ident == ident
+                        )
+                });
+
+                let _ = self.root.search_library(&library_name, &mut searcher);
+                Some(searcher.result)
             }
+            _ => None,
         }
-        None
     }
 
     /// Search for the declaration at decl_pos and format it

vhdl_ls/src/vhdl_server.rs

@@ -349,16 +349,20 @@ impl VHDLServer {
     pub fn text_document_implementation(
         &mut self,
         params: &TextDocumentPositionParams,
-    ) -> Option<Location> {
+    ) -> Option<GotoDefinitionResponse> {
         let source = self
             .project
             .get_source(&uri_to_file_name(&params.text_document.uri))?;
 
-        let ent = self
+        let ents = self
             .project
             .find_implementation(&source, from_lsp_pos(params.position))?;
 
-        Some(srcpos_to_location(ent.decl_pos()?))
+        Some(GotoDefinitionResponse::Array(
+            ents.into_iter()
+                .filter_map(|ent| ent.decl_pos().map(srcpos_to_location))
+                .collect(),
+        ))
     }
 
     pub fn text_document_hover(&mut self, params: &TextDocumentPositionParams) -> Option<Hover> {