Merge branch 'lsp-async-init'

2 files changed, 48 insertions, 26 deletions

diff --git a/helix-view/src/document.rs b/helix-view/src/document.rs
index b2c02927..6de60995 100644
--- a/helix-view/src/document.rs
+++ b/helix-view/src/document.rs
@@ -386,21 +386,24 @@ impl Document {
     /// If supported, returns the changes that should be applied to this document in order
     /// to format it nicely.
     pub fn format(&self) -> Option<impl Future<Output = LspFormatting> + 'static> {
-        if let Some(language_server) = self.language_server.clone() {
+        if let Some(language_server) = self.language_server() {
             let text = self.text.clone();
-            let id = self.identifier();
+            let offset_encoding = language_server.offset_encoding();
+            let request = language_server.text_document_formatting(
+                self.identifier(),
+                lsp::FormattingOptions::default(),
+                None,
+            )?;
+
             let fut = async move {
-                let edits = language_server
-                    .text_document_formatting(id, lsp::FormattingOptions::default(), None)
-                    .await
-                    .unwrap_or_else(|e| {
-                        log::warn!("LSP formatting failed: {}", e);
-                        Default::default()
-                    });
+                let edits = request.await.unwrap_or_else(|e| {
+                    log::warn!("LSP formatting failed: {}", e);
+                    Default::default()
+                });
                 LspFormatting {
                     doc: text,
                     edits,
-                    offset_encoding: language_server.offset_encoding(),
+                    offset_encoding,
                 }
             };
             Some(fut)
@@ -469,9 +472,14 @@ impl Document {
             to_writer(&mut file, encoding, &text).await?;
 
             if let Some(language_server) = language_server {
-                language_server
-                    .text_document_did_save(identifier, &text)
-                    .await?;
+                if language_server.is_initialized() {
+                    return Ok(());
+                }
+                if let Some(notification) =
+                    language_server.text_document_did_save(identifier, &text)
+                {
+                    notification.await?;
+                }
             }
 
             Ok(())
@@ -646,7 +654,7 @@ impl Document {
             // }
 
             // emit lsp notification
-            if let Some(language_server) = &self.language_server {
+            if let Some(language_server) = self.language_server() {
                 let notify = language_server.text_document_did_change(
                     self.versioned_identifier(),
                     &old_doc,
@@ -795,9 +803,18 @@ impl Document {
         self.version
     }
 
-    #[inline]
     pub fn language_server(&self) -> Option<&helix_lsp::Client> {
-        self.language_server.as_deref()
+        let server = self.language_server.as_deref();
+        let initialized = server
+            .map(|server| server.is_initialized())
+            .unwrap_or(false);
+
+        // only resolve language_server if it's initialized
+        if initialized {
+            server
+        } else {
+            None
+        }
     }
 
     #[inline]
diff --git a/helix-view/src/editor.rs b/helix-view/src/editor.rs
index 562c3c60..3d2d4a87 100644
--- a/helix-view/src/editor.rs
+++ b/helix-view/src/editor.rs
@@ -255,20 +255,21 @@ impl Editor {
                 .and_then(|language| self.language_servers.get(language).ok());
 
             if let Some(language_server) = language_server {
-                doc.set_language_server(Some(language_server.clone()));
-
                 let language_id = doc
                     .language()
                     .and_then(|s| s.split('.').last()) // source.rust
                     .map(ToOwned::to_owned)
                     .unwrap_or_default();
 
+                // TODO: this now races with on_init code if the init happens too quickly
                 tokio::spawn(language_server.text_document_did_open(
                     doc.url().unwrap(),
                     doc.version(),
                     doc.text(),
                     language_id,
                 ));
+
+                doc.set_language_server(Some(language_server));
             }
 
             let id = self.documents.insert(doc);
@@ -287,14 +288,9 @@ impl Editor {
 
         if close_buffer {
             // get around borrowck issues
-            let language_servers = &mut self.language_servers;
             let doc = &self.documents[view.doc];
 
-            let language_server = doc
-                .language
-                .as_ref()
-                .and_then(|language| language_servers.get(language).ok());
-            if let Some(language_server) = language_server {
+            if let Some(language_server) = doc.language_server() {
                 tokio::spawn(language_server.text_document_did_close(doc.identifier()));
             }
             self.documents.remove(view.doc);
@@ -324,20 +320,24 @@ impl Editor {
         view.ensure_cursor_in_view(doc, self.config.scrolloff)
     }
 
+    #[inline]
     pub fn document(&self, id: DocumentId) -> Option<&Document> {
         self.documents.get(id)
     }
 
+    #[inline]
     pub fn document_mut(&mut self, id: DocumentId) -> Option<&mut Document> {
         self.documents.get_mut(id)
     }
 
+    #[inline]
     pub fn documents(&self) -> impl Iterator<Item = &Document> {
-        self.documents.iter().map(|(_id, doc)| doc)
+        self.documents.values()
     }
 
+    #[inline]
     pub fn documents_mut(&mut self) -> impl Iterator<Item = &mut Document> {
-        self.documents.iter_mut().map(|(_id, doc)| doc)
+        self.documents.values_mut()
     }
 
     pub fn document_by_path<P: AsRef<Path>>(&self, path: P) -> Option<&Document> {
@@ -345,6 +345,11 @@ impl Editor {
             .find(|doc| doc.path().map(|p| p == path.as_ref()).unwrap_or(false))
     }
 
+    pub fn document_by_path_mut<P: AsRef<Path>>(&mut self, path: P) -> Option<&mut Document> {
+        self.documents_mut()
+            .find(|doc| doc.path().map(|p| p == path.as_ref()).unwrap_or(false))
+    }
+
     pub fn cursor(&self) -> (Option<Position>, CursorKind) {
         let view = view!(self);
         let doc = &self.documents[view.doc];