Merge branch 'lsp-async-init'

2 files changed, 55 insertions, 56 deletions

diff --git a/helix-term/src/application.rs b/helix-term/src/application.rs
index 1fcca681..e21c5504 100644
--- a/helix-term/src/application.rs
+++ b/helix-term/src/application.rs
@@ -4,7 +4,7 @@ use helix_view::{theme, Editor};
 
 use crate::{args::Args, compositor::Compositor, config::Config, job::Jobs, ui};
 
-use log::error;
+use log::{error, warn};
 
 use std::{
     io::{stdout, Write},
@@ -275,16 +275,42 @@ impl Application {
                 };
 
                 match notification {
-                    Notification::PublishDiagnostics(params) => {
-                        let path = Some(params.uri.to_file_path().unwrap());
+                    Notification::Initialized => {
+                        let language_server =
+                            match self.editor.language_servers.get_by_id(server_id) {
+                                Some(language_server) => language_server,
+                                None => {
+                                    warn!("can't find language server with id `{}`", server_id);
+                                    return;
+                                }
+                            };
+
+                        let docs = self.editor.documents().filter(|doc| {
+                            doc.language_server().map(|server| server.id()) == Some(server_id)
+                        });
 
-                        let doc = self
-                            .editor
-                            .documents
-                            .iter_mut()
-                            .find(|(_, doc)| doc.path() == path.as_ref());
+                        // trigger textDocument/didOpen for docs that are already open
+                        for doc in docs {
+                            // TODO: extract and share with editor.open
+                            let language_id = doc
+                                .language()
+                                .and_then(|s| s.split('.').last()) // source.rust
+                                .map(ToOwned::to_owned)
+                                .unwrap_or_default();
+
+                            tokio::spawn(language_server.text_document_did_open(
+                                doc.url().unwrap(),
+                                doc.version(),
+                                doc.text(),
+                                language_id,
+                            ));
+                        }
+                    }
+                    Notification::PublishDiagnostics(params) => {
+                        let path = params.uri.to_file_path().unwrap();
+                        let doc = self.editor.document_by_path_mut(&path);
 
-                        if let Some((_, doc)) = doc {
+                        if let Some(doc) = doc {
                             let text = doc.text();
 
                             let diagnostics = params
@@ -429,10 +455,27 @@ impl Application {
             Call::MethodCall(helix_lsp::jsonrpc::MethodCall {
                 method, params, id, ..
             }) => {
+                let language_server = match self.editor.language_servers.get_by_id(server_id) {
+                    Some(language_server) => language_server,
+                    None => {
+                        warn!("can't find language server with id `{}`", server_id);
+                        return;
+                    }
+                };
+
                 let call = match MethodCall::parse(&method, params) {
                     Some(call) => call,
                     None => {
                         error!("Method not found {}", method);
+                        // language_server.reply(
+                        //     call.id,
+                        //     // TODO: make a Into trait that can cast to Err(jsonrpc::Error)
+                        //     Err(helix_lsp::jsonrpc::Error {
+                        //         code: helix_lsp::jsonrpc::ErrorCode::MethodNotFound,
+                        //         message: "Method not found".to_string(),
+                        //         data: None,
+                        //     }),
+                        // );
                         return;
                     }
                 };
@@ -445,53 +488,9 @@ impl Application {
                         if spinner.is_stopped() {
                             spinner.start();
                         }
-
-                        let doc = self.editor.documents().find(|doc| {
-                            doc.language_server()
-                                .map(|server| server.id() == server_id)
-                                .unwrap_or_default()
-                        });
-                        match doc {
-                            Some(doc) => {
-                                // it's ok to unwrap, we check for the language server before
-                                let server = doc.language_server().unwrap();
-                                tokio::spawn(server.reply(id, Ok(serde_json::Value::Null)));
-                            }
-                            None => {
-                                if let Some(server) =
-                                    self.editor.language_servers.get_by_id(server_id)
-                                {
-                                    log::warn!(
-                                        "missing document with language server id `{}`",
-                                        server_id
-                                    );
-                                    tokio::spawn(server.reply(
-                                        id,
-                                        Err(helix_lsp::jsonrpc::Error {
-                                            code: helix_lsp::jsonrpc::ErrorCode::InternalError,
-                                            message: "document missing".to_string(),
-                                            data: None,
-                                        }),
-                                    ));
-                                } else {
-                                    log::warn!(
-                                        "can't find language server with id `{}`",
-                                        server_id
-                                    );
-                                }
-                            }
-                        }
+                        tokio::spawn(language_server.reply(id, Ok(serde_json::Value::Null)));
                     }
                 }
-                // self.language_server.reply(
-                //     call.id,
-                //     // TODO: make a Into trait that can cast to Err(jsonrpc::Error)
-                //     Err(helix_lsp::jsonrpc::Error {
-                //         code: helix_lsp::jsonrpc::ErrorCode::MethodNotFound,
-                //         message: "Method not found".to_string(),
-                //         data: None,
-                //     }),
-                // );
             }
             e => unreachable!("{:?}", e),
         }
diff --git a/helix-term/src/job.rs b/helix-term/src/job.rs
index 2ac41926..4fa38174 100644
--- a/helix-term/src/job.rs
+++ b/helix-term/src/job.rs
@@ -61,7 +61,7 @@ impl Jobs {
     }
 
     pub fn handle_callback(
-        &mut self,
+        &self,
         editor: &mut Editor,
         compositor: &mut Compositor,
         call: anyhow::Result<Option<Callback>>,
@@ -84,7 +84,7 @@ impl Jobs {
         }
     }
 
-    pub fn add(&mut self, j: Job) {
+    pub fn add(&self, j: Job) {
         if j.wait {
             self.wait_futures.push(j.future);
         } else {