Implement goto implementations for component to entity

Author: kraigher

vhdl_lang/src/analysis/analyze.rs

@@ -355,8 +355,9 @@ impl<'a> AnalyzeContext<'a> {
             if let Some(unit) = self.get_primary_unit(library_name, primary_name) {
                 let data = self.get_analysis(Some(pos), unit)?;
                 if let AnyDesignUnit::Primary(primary) = data.deref() {
-                    if let Some(ent) = primary.ent_id() {
-                        let design = DesignEnt::from_any(self.arena.get(ent)).map_err(|ent| {
+                    if let Some(id) = primary.ent_id() {
+                        let ent = self.arena.get(id);
+                        let design = DesignEnt::from_any(ent).ok_or_else(|| {
                             // Almost impossible but better not fail silently
                             Diagnostic::error(
                                 pos,

vhdl_lang/src/analysis/named_entity/design.rs

@@ -47,11 +47,11 @@ impl<'a> Design<'a> {
 pub struct DesignEnt<'a>(pub EntRef<'a>);
 
 impl<'a> DesignEnt<'a> {
-    pub fn from_any(ent: &'a AnyEnt) -> Result<DesignEnt<'a>, EntRef<'a>> {
+    pub fn from_any(ent: &'a AnyEnt) -> Option<DesignEnt<'a>> {
         if matches!(ent.kind(), AnyEntKind::Design(..)) {
-            Ok(DesignEnt(ent))
+            Some(DesignEnt(ent))
         } else {
-            Err(ent)
+            None
         }
     }
 

vhdl_lang/src/analysis/names.rs

@@ -1472,12 +1472,12 @@ impl<'a> AnalyzeContext<'a> {
                 Ok(subtype.type_mark().selected(prefix_pos, suffix)?.into_any())
             }
             AnyEntKind::Design(_) => {
-                let design = DesignEnt::from_any(prefix).map_err(|ent| {
+                let design = DesignEnt::from_any(prefix).ok_or_else(|| {
                     Diagnostic::error(
                         &suffix.pos,
                         format!(
                             "Internal error when expecting design unit, got {}",
-                            ent.describe()
+                            prefix.describe()
                         ),
                     )
                 })?;

vhdl_lang/src/analysis/root.rs

@@ -317,6 +317,26 @@ impl DesignRoot {
             .map(|library| &library.units)
     }
 
+    pub(crate) fn get_design_entity<'a>(
+        &'a self,
+        library_name: &Symbol,
+        ident: &Symbol,
+    ) -> Option<DesignEnt<'a>> {
+        let units = self.get_library_units(library_name)?;
+        let unit = units.get(&UnitKey::Primary(ident.clone()))?;
+        let data = self.get_analysis(unit);
+
+        if let AnyDesignUnit::Primary(primary) = data.deref() {
+            if let Some(id) = primary.ent_id() {
+                let design = DesignEnt::from_any(self.arenas.get(id))?;
+                if matches!(design.kind(), Design::Entity(..)) {
+                    return Some(design);
+                }
+            }
+        }
+        None
+    }
+
     /// Get a named entity corresponding to the library
     pub(super) fn get_library_arena(
         &self,

vhdl_lang/src/project.rs

@@ -4,8 +4,8 @@
 //
 // Copyright (c) 2018, Olof Kraigher [email protected]
 
-use crate::analysis::{AnyEnt, DesignRoot, EntRef, Related};
-use crate::ast::DesignFile;
+use crate::analysis::{AnyEnt, AnyEntKind, DesignRoot, EntRef, Related};
+use crate::ast::{DesignFile, Designator};
 use crate::config::Config;
 use crate::data::*;
 use crate::syntax::VHDLParser;
@@ -237,6 +237,34 @@ impl Project {
         }
     }
 
+    /// Find entity with same name as component in the library
+    pub fn find_implementation<'a>(
+        &'a self,
+        source: &Source,
+        cursor: Position,
+    ) -> Option<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());
+            }
+        }
+        None
+    }
+
     /// Search for the declaration at decl_pos and format it
     pub fn format_declaration(&self, ent: &AnyEnt) -> Option<String> {
         self.root.format_declaration(ent)

vhdl_ls/src/stdio_server.rs

@@ -138,6 +138,15 @@ impl ConnectionRpcChannel {
             }
             Err(request) => request,
         };
+        let request = match extract::<request::GotoImplementation>(request) {
+            Ok((id, params)) => {
+                let result =
+                    server.text_document_implementation(&params.text_document_position_params);
+                self.send_response(lsp_server::Response::new_ok(id, result));
+                return;
+            }
+            Err(request) => request,
+        };
         let request = match extract::<request::HoverRequest>(request) {
             Ok((id, params)) => {
                 let result = server.text_document_hover(&params.text_document_position_params);

vhdl_ls/src/vhdl_server.rs

@@ -116,6 +116,7 @@ impl VHDLServer {
             definition_provider: Some(OneOf::Left(true)),
             hover_provider: Some(HoverProviderCapability::Simple(true)),
             references_provider: Some(OneOf::Left(true)),
+            implementation_provider: Some(ImplementationProviderCapability::Simple(true)),
             ..Default::default()
         };
 
@@ -331,7 +332,6 @@ impl VHDLServer {
         Some(srcpos_to_location(ent.decl_pos()?))
     }
 
-    // Copy goto-declaration for now
     pub fn text_document_definition(
         &mut self,
         params: &TextDocumentPositionParams,
@@ -346,6 +346,21 @@ impl VHDLServer {
         Some(srcpos_to_location(ent.decl_pos()?))
     }
 
+    pub fn text_document_implementation(
+        &mut self,
+        params: &TextDocumentPositionParams,
+    ) -> Option<Location> {
+        let source = self
+            .project
+            .get_source(&uri_to_file_name(&params.text_document.uri))?;
+
+        let ent = self
+            .project
+            .find_implementation(&source, from_lsp_pos(params.position))?;
+
+        Some(srcpos_to_location(ent.decl_pos()?))
+    }
+
     pub fn text_document_hover(&mut self, params: &TextDocumentPositionParams) -> Option<Hover> {
         let source = self
             .project