Fix error reporting when language server quit unexpectedly.

Author: autozimu

src/languageclient.rs

@@ -2360,14 +2360,24 @@ impl State {
             Ok(())
         })?;
 
-        let languageId_clone = languageId.clone();
         let thread_name = format!("reader-{}", languageId);
         let tx = self.tx.clone();
         std::thread::Builder::new()
             .name(thread_name.clone())
             .spawn(move || {
-                if let Err(err) = loop_reader(reader, &Some(languageId_clone), &tx) {
-                    error!("{} reader loop exited: {:?}", thread_name, err);
+                if let Err(err) = loop_reader(reader, &Some(languageId.clone()), &tx) {
+                    let _ = tx.send(Message::Notification(
+                        Some(languageId.clone()),
+                        rpc::Notification {
+                            jsonrpc: None,
+                            method: NOTIFICATION__ServerExited.into(),
+                            params: json!({
+                                "languageId": languageId,
+                                "message": format!("{}", err),
+                            }).to_params()
+                                .unwrap_or_default(),
+                        },
+                    ));
                 }
             })?;
 
@@ -2385,4 +2395,21 @@ impl State {
         self.call::<_, u8>(None, "s:ExecuteAutocmd", "LanguageClientStarted")?;
         Ok(Value::Null)
     }
+
+    pub fn languageClient_serverExited(&mut self, params: &Option<Params>) -> Result<()> {
+        let (languageId, message): (String, String) = self.gather_args(
+            [VimVar::LanguageId.to_key().as_str(), "message"].as_ref(),
+            params,
+        )?;
+
+        if self.writers.contains_key(&languageId) {
+            let _ = self.cleanup(languageId.as_str());
+            let _ = self.echoerr(format!(
+                "Language server {} exited unexpectedly: {}",
+                languageId, message
+            ));
+        }
+
+        Ok(())
+    }
 }

src/rpchandler.rs

@@ -80,20 +80,21 @@ impl State {
             REQUEST__OmniComplete => self.languageClient_omniComplete(&method_call.params),
 
             _ => {
-                if languageId.is_none() {
-                    // Request from vim, pass through.
-                    let (languageId,): (String,) =
+                let languageId_target = if languageId.is_some() {
+                    // Message from language server. Proxy to vim.
+                    None
+                } else {
+                    // Message from vim. Proxy to language server.
+                    let (languageId_target,): (String,) =
                         self.gather_args(&[VimVar::LanguageId], &method_call.params)?;
+                    Some(languageId_target)
+                };
 
-                    self.call(
-                        Some(languageId.as_str()),
-                        &method_call.method,
-                        &method_call.params,
-                    )
-                } else {
-                    // Request from language servers.
-                    Err(format_err!("No handler found for: {:?}", method_call))
-                }
+                self.call(
+                    languageId_target.as_deref(),
+                    &method_call.method,
+                    &method_call.params,
+                )
             }
         }
     }
@@ -166,22 +167,24 @@ impl State {
             }
             NOTIFICATION__WindowProgress => self.window_progress(&notification.params)?,
             NOTIFICATION__CqueryProgress => self.cquery_handleProgress(&notification.params)?,
+            NOTIFICATION__ServerExited => self.languageClient_serverExited(&notification.params)?,
 
             _ => {
-                if languageId.is_none() {
-                    // Notification from vim, pass through.
-                    let (languageId,): (String,) =
+                let languageId_target = if languageId.is_some() {
+                    // Message from language server. Proxy to vim.
+                    None
+                } else {
+                    // Message from vim. Proxy to language server.
+                    let (languageId_target,): (String,) =
                         self.gather_args(&[VimVar::LanguageId], &notification.params)?;
+                    Some(languageId_target)
+                };
 
-                    self.notify(
-                        Some(languageId.as_str()),
-                        &notification.method,
-                        &notification.params,
-                    )?;
-                } else {
-                    // Notification from language servers.
-                    warn!("No handler found for: {:?}", notification);
-                }
+                self.notify(
+                    languageId_target.as_deref(),
+                    &notification.method,
+                    &notification.params,
+                )?;
             }
         };
 

src/types.rs

@@ -25,6 +25,7 @@ pub const NOTIFICATION__HandleBufDelete: &str = "languageClient/handleBufDelete"
 pub const NOTIFICATION__HandleCursorMoved: &str = "languageClient/handleCursorMoved";
 pub const NOTIFICATION__FZFSinkLocation: &str = "LanguageClient_FZFSinkLocation";
 pub const NOTIFICATION__FZFSinkCommand: &str = "LanguageClient_FZFSinkCommand";
+pub const NOTIFICATION__ServerExited: &str = "$languageClient/serverExisted";
 
 // Extensions by language servers.
 pub const REQUEST__RustImplementations: &str = "rustDocument/implementations";

src/vim.rs

@@ -312,24 +312,12 @@ pub fn loop_reader<T: BufRead>(
             if line.is_empty() {
                 count_empty_lines += 1;
                 if count_empty_lines > 5 {
-                    // TODO
-                    // if let Err(err) = self.cleanup(&languageId) {
-                    //     error!("Error when cleanup: {:?}", err);
-                    // }
-
-                    let mut message =
-                        format!("Language server ({}) exited unexpectedly!", languageId);
-                    match get_log_server() {
-                        Ok(log_server) => {
-                            message += "\n\nlanguage server stderr:\n";
-                            message += &log_server;
-                        }
-                        Err(err) => error!("Error when get_log_server: {:?}", err),
+                    let mut message = "".to_string();
+                    if let Ok(log_server) = get_log_server() {
+                        message += "\n\nlanguage server stderr:\n";
+                        message += &log_server;
                     }
-                    // TODO
-                    // if let Err(err) = self.echoerr(&message) {
-                    //     error!("Error in echoerr: {:?}", err);
-                    // };
+
                     bail!("{}", message);
                 }