Exit a language server if it sends a message with invalid json

helix-lsp/src/transport.rs

@@ -253,6 +253,39 @@ impl Transport {
         mut server_stdout: BufReader<ChildStdout>,
         client_tx: UnboundedSender<(usize, jsonrpc::Call)>,
     ) {
+        async fn exit_language_server(
+            transport: &Arc<Transport>,
+            client_tx: &UnboundedSender<(usize, crate::Call)>,
+        ) {
+            // Close any outstanding requests.
+            for (id, tx) in transport.pending_requests.lock().await.drain() {
+                match tx.send(Err(Error::StreamClosed)).await {
+                    Ok(_) => (),
+                    Err(_) => {
+                        error!("Could not close request on a closed channel (id={:?})", id)
+                    }
+                }
+            }
+
+            // Hack: inject a terminated notification so we trigger code that needs to happen after exit
+            use lsp_types::notification::Notification as _;
+            let notification =
+                ServerMessage::Call(jsonrpc::Call::Notification(jsonrpc::Notification {
+                    jsonrpc: None,
+                    method: lsp_types::notification::Exit::METHOD.to_string(),
+                    params: jsonrpc::Params::None,
+                }));
+            match transport
+                .process_server_message(client_tx, notification, &transport.name)
+                .await
+            {
+                Ok(_) => {}
+                Err(err) => {
+                    error!("err: <- {:?}", err);
+                }
+            }
+        }
+
         let mut recv_buffer = String::new();
         loop {
             match Self::recv_server_message(&mut server_stdout, &mut recv_buffer, &transport.name)
@@ -271,37 +304,15 @@ impl Transport {
                     };
                 }
                 Err(Error::StreamClosed) => {
-                    // Close any outstanding requests.
-                    for (id, tx) in transport.pending_requests.lock().await.drain() {
-                        match tx.send(Err(Error::StreamClosed)).await {
-                            Ok(_) => (),
-                            Err(_) => {
-                                error!("Could not close request on a closed channel (id={:?})", id)
-                            }
-                        }
-                    }
-
-                    // Hack: inject a terminated notification so we trigger code that needs to happen after exit
-                    use lsp_types::notification::Notification as _;
-                    let notification =
-                        ServerMessage::Call(jsonrpc::Call::Notification(jsonrpc::Notification {
-                            jsonrpc: None,
-                            method: lsp_types::notification::Exit::METHOD.to_string(),
-                            params: jsonrpc::Params::None,
-                        }));
-                    match transport
-                        .process_server_message(&client_tx, notification, &transport.name)
-                        .await
-                    {
-                        Ok(_) => {}
-                        Err(err) => {
-                            error!("err: <- {:?}", err);
-                        }
-                    }
+                    exit_language_server(&transport, &client_tx).await;
                     break;
                 }
                 Err(err) => {
-                    error!("{} err: <- {err:?}", transport.name);
+                    error!(
+                        "Exiting {} after unexpected error: {err:?}",
+                        &transport.name
+                    );
+                    exit_language_server(&transport, &client_tx).await;
                     break;
                 }
             }

helix-term/src/application.rs

@@ -676,8 +676,8 @@ impl Application {
                 let notification = match Notification::parse(&method, params) {
                     Ok(notification) => notification,
                     Err(err) => {
-                        log::error!(
-                            "received malformed notification from Language Server: {}",
+                        log::info!(
+                            "Ignoring unknown notification from Language Server: {}",
                             err
                         );
                         return;