Implement rename refactor

Author: kraigher

README.md

@@ -24,6 +24,7 @@ I very much appreciate help from other people especially regarding semantic anal
   - From component declaration to matching entity by default binding
   - From entity to matching component declaration by default binding
 - Supports hovering symbols
+- Rename symbol
 
 ## Trying it out
 A language server is never used directly by the end user and it is integrated into different editor plugins. The ones I know about are listed here.

vhdl_lang/src/analysis/root.rs

@@ -365,11 +365,20 @@ impl DesignRoot {
     ///
     /// 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>> {
+    pub fn item_at_cursor<'a>(
+        &'a self,
+        source: &Source,
+        cursor: Position,
+    ) -> Option<(SrcPos, EntRef<'a>)> {
         let mut searcher = ItemAtCursor::new(source, cursor);
         let _ = self.search(&mut searcher);
-        let id = searcher.result?;
+        let (pos, id) = searcher.result?;
         let ent = self.get_ent(id);
+        Some((pos, ent))
+    }
+
+    pub fn search_reference<'a>(&'a self, source: &Source, cursor: Position) -> Option<EntRef<'a>> {
+        let (_, ent) = self.item_at_cursor(source, cursor)?;
         Some(ent)
     }
 

vhdl_lang/src/ast/search.rs

@@ -1315,7 +1315,7 @@ impl Search for CaseStatement {
 pub struct ItemAtCursor {
     source: Source,
     cursor: Position,
-    pub result: Option<EntityId>,
+    pub result: Option<(SrcPos, EntityId)>,
 }
 
 impl ItemAtCursor {
@@ -1333,11 +1333,16 @@ impl ItemAtCursor {
         pos.start() <= self.cursor && self.cursor <= pos.end()
     }
 
-    fn is_inside_opt(&self, pos: Option<&SrcPos>) -> bool {
-        if let Some(pos) = pos {
-            self.is_inside(pos)
+    fn search_decl_pos(&mut self, pos: &SrcPos, decl: &FoundDeclaration) -> SearchState {
+        if self.is_inside(pos) {
+            if let Some(id) = decl.ent_id() {
+                self.result = Some((pos.clone(), id));
+                Finished(Found)
+            } else {
+                Finished(NotFound)
+            }
         } else {
-            false
+            NotFinished
         }
     }
 }
@@ -1355,13 +1360,12 @@ impl Searcher for ItemAtCursor {
 
     fn search_decl(&mut self, decl: FoundDeclaration) -> SearchState {
         let pos = decl.pos();
-        if self.is_inside(pos) || self.is_inside_opt(decl.end_ident_pos()) {
-            if let Some(id) = decl.ent_id() {
-                self.result = Some(id);
-                Finished(Found)
-            } else {
-                Finished(NotFound)
-            }
+        if let Finished(res) = self.search_decl_pos(pos, &decl) {
+            return Finished(res);
+        }
+
+        if let Some(end_pos) = decl.end_ident_pos() {
+            self.search_decl_pos(end_pos, &decl)
         } else {
             NotFinished
         }
@@ -1370,7 +1374,7 @@ impl Searcher for ItemAtCursor {
     fn search_pos_with_ref(&mut self, pos: &SrcPos, reference: &mut Reference) -> SearchState {
         if self.is_inside(pos) {
             if let Some(id) = reference {
-                self.result = Some(*id);
+                self.result = Some((pos.clone(), *id));
                 Finished(Found)
             } else {
                 Finished(NotFound)

vhdl_lang/src/project.rs

@@ -233,6 +233,14 @@ impl Project {
         Some(ent.declaration())
     }
 
+    pub fn item_at_cursor<'a>(
+        &'a self,
+        source: &Source,
+        cursor: Position,
+    ) -> Option<(SrcPos, EntRef<'a>)> {
+        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()

vhdl_ls/src/stdio_server.rs

@@ -147,6 +147,22 @@ impl ConnectionRpcChannel {
             }
             Err(request) => request,
         };
+        let request = match extract::<request::Rename>(request) {
+            Ok((id, params)) => {
+                let result = server.rename(&params);
+                self.send_response(lsp_server::Response::new_ok(id, result));
+                return;
+            }
+            Err(request) => request,
+        };
+        let request = match extract::<request::PrepareRenameRequest>(request) {
+            Ok((id, params)) => {
+                let result = server.prepare_rename(&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

@@ -8,6 +8,8 @@ use lsp_types::*;
 
 use fnv::FnvHashMap;
 use std::collections::hash_map::Entry;
+use std::collections::HashMap;
+use vhdl_lang::ast::Designator;
 
 use crate::rpc_channel::SharedRpcChannel;
 use std::io;
@@ -117,6 +119,10 @@ impl VHDLServer {
             hover_provider: Some(HoverProviderCapability::Simple(true)),
             references_provider: Some(OneOf::Left(true)),
             implementation_provider: Some(ImplementationProviderCapability::Simple(true)),
+            rename_provider: Some(OneOf::Right(RenameOptions {
+                prepare_provider: Some(true),
+                work_done_progress_options: Default::default(),
+            })),
             ..Default::default()
         };
 
@@ -365,6 +371,54 @@ impl VHDLServer {
         ))
     }
 
+    pub fn prepare_rename(
+        &mut self,
+        params: &TextDocumentPositionParams,
+    ) -> Option<PrepareRenameResponse> {
+        let source = self
+            .project
+            .get_source(&uri_to_file_name(&params.text_document.uri))?;
+
+        let (pos, ent) = self
+            .project
+            .item_at_cursor(&source, from_lsp_pos(params.position))?;
+
+        if let Designator::Identifier(_) = ent.designator() {
+            Some(PrepareRenameResponse::Range(to_lsp_range(pos.range)))
+        } else {
+            // It does not make sense to rename operator symbols and character literals
+            // Also they have different representations that would not be handled consistently
+            // Such as function "+"(arg1, arg2 : integer) but used as foo + bar
+            None
+        }
+    }
+
+    pub fn rename(&mut self, params: &RenameParams) -> Option<WorkspaceEdit> {
+        let source = self.project.get_source(&uri_to_file_name(
+            &params.text_document_position.text_document.uri,
+        ))?;
+
+        let ent = self.project.find_declaration(
+            &source,
+            from_lsp_pos(params.text_document_position.position),
+        )?;
+
+        let mut changes: HashMap<Url, Vec<TextEdit>> = Default::default();
+
+        for srcpos in self.project.find_all_references(ent) {
+            let loc = srcpos_to_location(&srcpos);
+            changes.entry(loc.uri).or_default().push(TextEdit {
+                range: loc.range,
+                new_text: params.new_name.clone(),
+            });
+        }
+
+        Some(WorkspaceEdit {
+            changes: Some(changes),
+            ..Default::default()
+        })
+    }
+
     pub fn text_document_hover(&mut self, params: &TextDocumentPositionParams) -> Option<Hover> {
         let source = self
             .project