Resolve completion item

helix-lsp/src/client.rs

@@ -556,6 +556,13 @@ impl Client {
         self.call::<lsp::request::Completion>(params)
     }
 
+    pub fn resolve_completion(
+        &self,
+        completion_item: lsp::CompletionItem,
+    ) -> impl Future<Output = Result<Value>> {
+        self.call::<lsp::request::ResolveCompletionItem>(completion_item)
+    }
+
     pub fn text_document_signature_help(
         &self,
         text_document: lsp::TextDocumentIdentifier,

helix-term/src/ui/completion.rs

@@ -154,8 +154,8 @@ impl Completion {
                     );
                     doc.apply(&transaction, view.id);
 
+                    // apply additional edits, mostly used to auto import unqualified types
                     if let Some(additional_edits) = &item.additional_text_edits {
-                        // gopls uses this to add extra imports
                         if !additional_edits.is_empty() {
                             let transaction = util::generate_transaction_from_edits(
                                 doc.text(),
@@ -164,6 +164,21 @@ impl Completion {
                             );
                             doc.apply(&transaction, view.id);
                         }
+                    } else {
+                        let additional_text_edits =
+                            Completion::resolve_completion_item(doc, item.clone())
+                                .and_then(|item| item.additional_text_edits);
+
+                        if let Some(additional_edits) = additional_text_edits {
+                            if !additional_edits.is_empty() {
+                                let transaction = util::generate_transaction_from_edits(
+                                    doc.text(),
+                                    additional_edits.clone(),
+                                    offset_encoding, // TODO: should probably transcode in Client
+                                );
+                                doc.apply(&transaction, view.id);
+                            }
+                        }
                     }
                 }
             };
@@ -181,6 +196,29 @@ impl Completion {
         completion
     }
 
+    fn resolve_completion_item(
+        document: &Document,
+        completion_item: lsp::CompletionItem,
+    ) -> Option<CompletionItem> {
+        let language_server = match document.language_server() {
+            Some(language_server) => language_server,
+            None => return None,
+        };
+        let future = language_server.resolve_completion(completion_item);
+        let response = helix_lsp::block_on(future)
+            .map_err(anyhow::Error::from)
+            .and_then(|value| {
+                serde_json::from_value::<lsp::CompletionItem>(value).map_err(anyhow::Error::from)
+            });
+        match response {
+            Ok(completion_item) => Some(completion_item),
+            Err(err) => {
+                log::error!("execute LSP command: {}", err);
+                None
+            }
+        }
+    }
+
     pub fn recompute_filter(&mut self, editor: &Editor) {
         // recompute menu based on matches
         let menu = self.popup.contents_mut();