Use library_name for find implementation and add test

Author: kraigher

vhdl_lang/src/analysis/named_entity.rs

@@ -289,6 +289,20 @@ impl<'a> AnyEnt<'a> {
         self.decl_pos.as_ref()
     }
 
+    pub fn library_name(&self) -> Option<&Symbol> {
+        if let AnyEntKind::Library = self.kind() {
+            if let Designator::Identifier(symbol) = self.designator() {
+                return Some(symbol);
+            }
+        }
+
+        if let Some(parent) = self.parent {
+            parent.library_name()
+        } else {
+            None
+        }
+    }
+
     pub fn designator(&self) -> &Designator {
         &self.designator
     }

vhdl_lang/src/analysis/root.rs

@@ -398,6 +398,36 @@ impl DesignRoot {
         }
     }
 
+    pub fn find_implementation<'a>(&'a self, ent: EntRef<'a>) -> Vec<EntRef<'a>> {
+        if let Designator::Identifier(ident) = ent.designator() {
+            if let Some(library_name) = ent.library_name() {
+                match ent.kind() {
+                    // Find entity with same name as component in the library
+                    AnyEntKind::Component(_) => {
+                        if let Some(design) = self.get_design_entity(library_name, ident) {
+                            return vec![design.into()];
+                        }
+                    }
+                    // Find all components with same name as entity in the library
+                    AnyEntKind::Design(Design::Entity(..)) => {
+                        let mut searcher = FindAllEnt::new(self, |ent| {
+                            matches!(ent.kind(), AnyEntKind::Component(_))
+                                && matches!(
+                                    ent.designator(),
+                                    Designator::Identifier(comp_ident) if comp_ident == ident
+                                )
+                        });
+
+                        let _ = self.search_library(library_name, &mut searcher);
+                        return searcher.result;
+                    }
+                    _ => {}
+                }
+            }
+        }
+        Vec::default()
+    }
+
     #[cfg(test)]
     pub fn search_reference_pos(&self, source: &Source, cursor: Position) -> Option<SrcPos> {
         self.search_reference(source, cursor)

vhdl_lang/src/analysis/tests/hierarchy.rs

@@ -163,3 +163,43 @@ fn hierarchy(ent: EntRef) -> String {
         ent.designator().to_string()
     }
 }
+
+#[test]
+fn find_implementation_of_entity_vs_component() {
+    let mut builder = LibraryBuilder::new();
+    let code = builder.code(
+        "libname",
+        "
+entity ent0 is
+end entity;
+
+architecture a of ent0 is
+begin
+end architecture;
+
+entity ent1 is
+end entity;
+
+architecture a of ent1 is
+  component ent0 is
+  end component;
+begin
+  inst: ent0;
+end architecture;
+
+      ",
+    );
+
+    let (root, diagnostics) = builder.get_analyzed_root();
+    check_no_diagnostics(&diagnostics);
+
+    let ent = root
+        .search_reference(code.source(), code.s1("ent0").start())
+        .unwrap();
+    let comp = root
+        .search_reference(code.source(), code.sa("component ", "ent0").start())
+        .unwrap();
+
+    assert_eq!(root.find_implementation(ent), vec![comp]);
+    assert_eq!(root.find_implementation(comp), vec![ent]);
+}

vhdl_lang/src/project.rs

@@ -4,9 +4,8 @@
 //
 // Copyright (c) 2018, Olof Kraigher olof.kraigher@gmail.com
 
-use crate::analysis::{AnyEnt, AnyEntKind, Design, DesignRoot, EntRef};
-use crate::ast::search::FindAllEnt;
-use crate::ast::{DesignFile, Designator};
+use crate::analysis::{AnyEnt, DesignRoot, EntRef};
+use crate::ast::DesignFile;
 use crate::config::Config;
 use crate::data::*;
 use crate::syntax::VHDLParser;
@@ -241,49 +240,11 @@ impl Project {
         self.root.item_at_cursor(source, cursor)
     }
 
-    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<Vec<EntRef<'a>>> {
-        let ent = self.find_declaration(source, cursor)?;
-
-        let ident = if let Designator::Identifier(ident) = ent.designator() {
-            ident
+    pub fn find_implementation<'a>(&'a self, source: &Source, cursor: Position) -> Vec<EntRef<'a>> {
+        if let Some(ent) = self.find_declaration(source, cursor) {
+            self.root.find_implementation(ent)
         } else {
-            return None;
-        };
-
-        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,
+            Vec::default()
         }
     }
 

vhdl_ls/src/vhdl_server.rs

@@ -362,7 +362,7 @@ impl VHDLServer {
 
         let ents = self
             .project
-            .find_implementation(&source, from_lsp_pos(params.position))?;
+            .find_implementation(&source, from_lsp_pos(params.position));
 
         Some(GotoDefinitionResponse::Array(
             ents.into_iter()