Implement LSP goto declaration and definition differently

kraigher · kraigher · commit 1ba8c3a33291 · 2023-02-11T17:22:24.000+01:00
diff --git a/vhdl_lang/src/analysis/declarative.rs b/vhdl_lang/src/analysis/declarative.rs
@@ -640,7 +640,6 @@ impl<'a> AnalyzeContext<'a> {
                                 if let AnyEntKind::Type(Type::Protected(ptype_region, is_body)) =
                                     ent.kind()
                                 {
-                                    body.type_reference.set_unique_reference(ent);
                                     let region = Scope::extend(ptype_region, Some(scope));
                                     self.analyze_declarative_part(
                                         &region,
diff --git a/vhdl_lang/src/analysis/root.rs b/vhdl_lang/src/analysis/root.rs
@@ -351,6 +351,21 @@ impl DesignRoot {
         Some(self.get_ent(id))
     }
 
+    pub fn find_definition_of<'a>(&'a self, decl: EntRef<'a>) -> Option<EntRef<'a>> {
+        if decl.is_protected_type()
+            || decl.is_subprogram_decl()
+            || decl.kind().is_deferred_constant()
+        {
+            let mut searcher = FindEnt::new(self, |ent| ent.is_declared_by(decl));
+            let _ = self.search(&mut searcher);
+
+            Some(searcher.result.unwrap_or(decl))
+        } else {
+            // The definition is the same as the declaration
+            Some(decl)
+        }
+    }
+
     #[cfg(test)]
     pub fn search_reference_pos(&self, source: &Source, cursor: Position) -> Option<SrcPos> {
         self.search_reference(source, cursor)
diff --git a/vhdl_lang/src/analysis/tests/protected_type.rs b/vhdl_lang/src/analysis/tests/protected_type.rs
@@ -265,7 +265,7 @@ end package;",
 
     assert_eq!(
         root.search_reference_pos(code.source(), code.s("prot_t", 2).start()),
-        Some(code.s1("prot_t").pos())
+        Some(code.s("prot_t", 2).pos())
     );
 
     assert_eq!(
@@ -284,4 +284,9 @@ end package;",
             code.s("prot_t", 3).pos()
         ]
     );
+
+    assert_eq!(
+        root.find_definition_of(ptype).unwrap().decl_pos(),
+        Some(&code.s("prot_t", 2).pos())
+    );
 }
diff --git a/vhdl_lang/src/analysis/tests/resolves_names.rs b/vhdl_lang/src/analysis/tests/resolves_names.rs
@@ -1787,6 +1787,16 @@ end;
             code.s("myfun", 3).pos()
         ]
     );
+
+    assert_eq!(
+        root.find_definition_of(
+            root.search_reference(code.source(), code.s1("myfun").start())
+                .unwrap()
+        )
+        .unwrap()
+        .decl_pos(),
+        Some(&code.s("myfun", 2).pos())
+    );
 }
 
 #[test]
@@ -1820,4 +1830,14 @@ end package body;
         &root.find_all_references_pos(&code.s("c0", 2).pos()),
         &references,
     );
+
+    assert_eq!(
+        root.find_definition_of(
+            root.search_reference(code.source(), code.s1("c0").start())
+                .unwrap()
+        )
+        .unwrap()
+        .decl_pos(),
+        Some(&code.s("c0", 2).pos())
+    );
 }
diff --git a/vhdl_lang/src/ast.rs b/vhdl_lang/src/ast.rs
@@ -537,7 +537,6 @@ pub struct ProtectedTypeDeclaration {
 /// LRM 5.6.3 Protected type bodies
 #[derive(PartialEq, Debug, Clone)]
 pub struct ProtectedTypeBody {
-    pub type_reference: Reference,
     pub decl: Vec<Declaration>,
 }
 
diff --git a/vhdl_lang/src/ast/search.rs b/vhdl_lang/src/ast/search.rs
@@ -674,18 +674,12 @@ impl Search for DiscreteRange {
 
 impl Search for TypeDeclaration {
     fn search(&mut self, searcher: &mut impl Searcher) -> SearchResult {
-        if !matches!(self.def, TypeDefinition::ProtectedBody(_)) {
-            return_if_found!(searcher
-                .search_decl(FoundDeclaration::Type(self))
-                .or_not_found());
-        }
+        return_if_found!(searcher
+            .search_decl(FoundDeclaration::Type(self))
+            .or_not_found());
 
         match self.def {
             TypeDefinition::ProtectedBody(ref mut body) => {
-                // Protected type body is not considered a declaration
-                return_if_found!(searcher
-                    .search_pos_with_ref(self.ident.pos(), &mut body.type_reference)
-                    .or_not_found());
                 return_if_found!(body.decl.search(searcher));
             }
             TypeDefinition::Protected(ref mut prot_decl) => {
@@ -1318,6 +1312,37 @@ impl Searcher for ItemAtCursor {
     }
 }
 
+// Search for reference to declaration/definition at cursor
+pub struct FindEnt<'a, T: Fn(EntRef<'a>) -> bool> {
+    root: &'a DesignRoot,
+    cond: T,
+    pub result: Option<EntRef<'a>>,
+}
+
+impl<'a, T: Fn(EntRef<'a>) -> bool> FindEnt<'a, T> {
+    pub fn new(root: &'a DesignRoot, cond: T) -> FindEnt<'a, T> {
+        FindEnt {
+            root,
+            cond,
+            result: None,
+        }
+    }
+}
+
+impl<'a, T: Fn(EntRef<'a>) -> bool> Searcher for FindEnt<'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 = Some(ent);
+                return SearchState::Finished(SearchResult::Found);
+            }
+        }
+
+        SearchState::NotFinished
+    }
+}
+
 // Search for a declaration/definition and format it
 pub struct FormatDeclaration<'a> {
     ent: EntRef<'a>,
diff --git a/vhdl_lang/src/project.rs b/vhdl_lang/src/project.rs
@@ -4,7 +4,7 @@
 //
 // Copyright (c) 2018, Olof Kraigher olof.kraigher@gmail.com
 
-use crate::analysis::{AnyEnt, DesignRoot, EntRef};
+use crate::analysis::{AnyEnt, DesignRoot, EntRef, Related};
 use crate::ast::DesignFile;
 use crate::config::Config;
 use crate::data::*;
@@ -222,8 +222,19 @@ impl Project {
     ///
     /// If the character value is greater than the line length it defaults back to the
     /// line length.
-    pub fn search_reference<'a>(&'a self, source: &Source, cursor: Position) -> Option<EntRef<'a>> {
-        self.root.search_reference(source, cursor)
+    pub fn find_definition<'a>(&'a self, source: &Source, cursor: Position) -> Option<EntRef<'a>> {
+        let ent = self.root.search_reference(source, cursor)?;
+        self.root.find_definition_of(ent)
+    }
+
+    pub fn find_declaration<'a>(&'a self, source: &Source, cursor: Position) -> Option<EntRef<'a>> {
+        let ent = self.root.search_reference(source, cursor)?;
+
+        if let Related::DeclaredBy(other) = ent.related {
+            Some(other)
+        } else {
+            Some(ent)
+        }
     }
 
     /// Search for the declaration at decl_pos and format it
diff --git a/vhdl_lang/src/syntax/type_declaration.rs b/vhdl_lang/src/syntax/type_declaration.rs
@@ -257,7 +257,7 @@ pub fn parse_type_declaration(
                 // @TODO check name
                 stream.pop_if_kind(Identifier)?;
                 stream.expect_kind(SemiColon)?;
-                TypeDefinition::ProtectedBody(ProtectedTypeBody {type_reference: Reference::default(), decl})
+                TypeDefinition::ProtectedBody(ProtectedTypeBody {decl})
             } else {
                 let (protected_type_decl, end_ident) = parse_protected_type_declaration(stream, diagnostics)?;
                 diagnostics.push_some(error_on_end_identifier_mismatch(&ident, &end_ident));
@@ -699,10 +699,7 @@ end protected body;
             code.with_stream_no_diagnostics(parse_type_declaration),
             TypeDeclaration {
                 ident,
-                def: TypeDefinition::ProtectedBody(ProtectedTypeBody {
-                    type_reference: Reference::default(),
-                    decl
-                }),
+                def: TypeDefinition::ProtectedBody(ProtectedTypeBody { decl }),
             }
         )
     }
diff --git a/vhdl_ls/src/vhdl_server.rs b/vhdl_ls/src/vhdl_server.rs
@@ -327,7 +327,7 @@ impl VHDLServer {
 
         let ent = self
             .project
-            .search_reference(&source, from_lsp_pos(params.position))?;
+            .find_declaration(&source, from_lsp_pos(params.position))?;
         Some(srcpos_to_location(ent.decl_pos()?))
     }
 
@@ -336,7 +336,14 @@ impl VHDLServer {
         &mut self,
         params: &TextDocumentPositionParams,
     ) -> Option<Location> {
-        self.text_document_declaration(params)
+        let source = self
+            .project
+            .get_source(&uri_to_file_name(&params.text_document.uri))?;
+
+        let ent = self
+            .project
+            .find_definition(&source, from_lsp_pos(params.position))?;
+        Some(srcpos_to_location(ent.decl_pos()?))
     }
 
     pub fn text_document_hover(&mut self, params: &TextDocumentPositionParams) -> Option<Hover> {
@@ -345,7 +352,7 @@ impl VHDLServer {
             .get_source(&uri_to_file_name(&params.text_document.uri))?;
         let ent = self
             .project
-            .search_reference(&source, from_lsp_pos(params.position))?;
+            .find_declaration(&source, from_lsp_pos(params.position))?;
 
         let value = self.project.format_declaration(ent)?;
 
@@ -365,7 +372,7 @@ impl VHDLServer {
                 &params.text_document_position.text_document.uri,
             ))
             .and_then(|source| {
-                self.project.search_reference(
+                self.project.find_declaration(
                     &source,
                     from_lsp_pos(params.text_document_position.position),
                 )

Original file line number	Diff line number	Diff line change
`@@ -640,7 +640,6 @@ impl<'a> AnalyzeContext<'a> {`
`640`	`640`	`if let AnyEntKind::Type(Type::Protected(ptype_region, is_body)) =`
`641`	`641`	`ent.kind()`
`642`	`642`	`{`
`643`		`- body.type_reference.set_unique_reference(ent);`
`644`	`643`	`let region = Scope::extend(ptype_region, Some(scope));`
`645`	`644`	`self.analyze_declarative_part(`
`646`	`645`	`&region,`
Original file line number	Diff line number	Diff line change
`@@ -537,7 +537,6 @@ pub struct ProtectedTypeDeclaration {`
`537`	`537`	`/// LRM 5.6.3 Protected type bodies`
`538`	`538`	`#[derive(PartialEq, Debug, Clone)]`
`539`	`539`	`pub struct ProtectedTypeBody {`
`540`		`- pub type_reference: Reference,`
`541`	`540`	`pub decl: Vec<Declaration>,`
`542`	`541`	`}`
`543`	`542`