Simplify vhdl server

kraigher · kraigher · commit b4ff5de159de · 2023-01-03T22:03:10.000+01:00
diff --git a/vhdl_ls/src/rpc_channel.rs b/vhdl_ls/src/rpc_channel.rs
@@ -6,80 +6,49 @@
 
 //! Contains the RpcChannel Traid and associated convenience functions
 
-use lsp_types::*;
-use vhdl_lang::{Message, MessageHandler};
+use serde_json::Value;
+use std::rc::Rc;
 
 pub trait RpcChannel {
     /// Send notification to the client.
-    fn send_notification(
-        &self,
-        method: impl Into<String>,
-        notification: impl serde::ser::Serialize,
-    );
+    fn send_notification(&self, method: String, notification: Value);
 
     /// Send request to the client.
-    fn send_request(&self, method: impl Into<String>, params: impl serde::ser::Serialize);
-
-    fn window_show_message(&self, typ: MessageType, message: impl Into<String>) {
-        self.send_notification(
-            "window/showMessage",
-            ShowMessageParams {
-                typ,
-                message: message.into(),
-            },
-        );
-    }
-
-    fn window_log_message(&self, typ: MessageType, message: impl Into<String>) {
-        self.send_notification(
-            "window/logMessage",
-            LogMessageParams {
-                typ,
-                message: message.into(),
-            },
-        );
-    }
-
-    fn push_msg(&self, msg: Message) {
-        if matches!(
-            msg.message_type,
-            vhdl_lang::MessageType::Warning | vhdl_lang::MessageType::Error
-        ) {
-            self.window_show_message(to_lsp_message_type(&msg.message_type), msg.message.clone());
-        }
-        self.window_log_message(to_lsp_message_type(&msg.message_type), msg.message);
-    }
+    fn send_request(&self, method: String, params: Value);
 }
 
-pub struct MessageChannel<'a, T: RpcChannel> {
-    channel: &'a T,
+#[derive(Clone)]
+pub struct SharedRpcChannel {
+    chan: Rc<dyn RpcChannel>,
 }
 
-impl<'a, T: RpcChannel> MessageChannel<'a, T> {
-    pub fn new(channel: &'a T) -> MessageChannel<'a, T> {
-        MessageChannel { channel }
+impl SharedRpcChannel {
+    pub fn new(chan: Rc<dyn RpcChannel>) -> Self {
+        Self { chan }
     }
-}
 
-impl<'a, T: RpcChannel> MessageHandler for MessageChannel<'a, T> {
-    fn push(&mut self, message: Message) {
-        self.channel.push_msg(message);
+    /// Send notification to the client.
+    pub fn send_notification(
+        &self,
+        method: impl Into<String>,
+        notification: impl serde::ser::Serialize,
+    ) {
+        self.chan
+            .send_notification(method.into(), serde_json::to_value(&notification).unwrap())
     }
-}
 
-fn to_lsp_message_type(message_type: &vhdl_lang::MessageType) -> MessageType {
-    match message_type {
-        vhdl_lang::MessageType::Error => MessageType::ERROR,
-        vhdl_lang::MessageType::Warning => MessageType::WARNING,
-        vhdl_lang::MessageType::Info => MessageType::INFO,
-        vhdl_lang::MessageType::Log => MessageType::LOG,
+    /// Send request to the client.
+    pub fn send_request(&self, method: impl Into<String>, params: impl serde::ser::Serialize) {
+        self.chan
+            .send_request(method.into(), serde_json::to_value(&params).unwrap())
     }
 }
 
 #[cfg(test)]
 pub mod test_support {
 
     use pretty_assertions::assert_eq;
+    use serde_json::Value;
     use std::cell::RefCell;
     use std::collections::VecDeque;
     use std::rc::Rc;
@@ -191,13 +160,7 @@ pub mod test_support {
     }
 
     impl super::RpcChannel for RpcMock {
-        fn send_notification(
-            &self,
-            method: impl Into<String>,
-            notification: impl serde::ser::Serialize,
-        ) {
-            let method = method.into();
-            let notification = serde_json::to_value(notification).unwrap();
+        fn send_notification(&self, method: String, notification: Value) {
             let expected = self
                 .expected
                 .borrow_mut()
@@ -240,9 +203,7 @@ pub mod test_support {
             }
         }
 
-        fn send_request(&self, method: impl Into<String>, params: impl serde::ser::Serialize) {
-            let method = method.into();
-            let params = serde_json::to_value(params).unwrap();
+        fn send_request(&self, method: String, params: Value) {
             let expected = self
                 .expected
                 .borrow_mut()
diff --git a/vhdl_ls/src/stdio_server.rs b/vhdl_ls/src/stdio_server.rs
@@ -10,18 +10,20 @@
 
 use lsp_server::{Connection, ExtractError, Request, RequestId};
 use lsp_types::{notification, request, InitializeParams};
+use serde_json::Value;
+
 use std::{cell::RefCell, rc::Rc};
 
-use crate::rpc_channel::RpcChannel;
+use crate::rpc_channel::{RpcChannel, SharedRpcChannel};
 use crate::vhdl_server::VHDLServer;
 use crate::vhdl_server::VHDLServerSettings;
 
 /// Set up the IO channel for `stdio` and start the VHDL language server.
 pub fn start(settings: VHDLServerSettings) {
     let (connection, io_threads) = Connection::stdio();
-    let connection_rpc = ConnectionRpcChannel::new(connection);
-    let mut server = VHDLServer::new_settings(connection_rpc.clone(), settings);
-
+    let connection_rpc = Rc::new(ConnectionRpcChannel::new(connection));
+    let rpc = SharedRpcChannel::new(connection_rpc.clone());
+    let mut server = VHDLServer::new_settings(rpc, settings);
     connection_rpc.handle_initialization(&mut server);
     connection_rpc.main_event_loop(server);
 
@@ -38,29 +40,18 @@ struct ConnectionRpcChannel {
 
 impl RpcChannel for ConnectionRpcChannel {
     /// Send notification to the client.
-    fn send_notification(
-        &self,
-        method: impl Into<String>,
-        notification: impl serde::ser::Serialize,
-    ) {
-        let notification = lsp_server::Notification {
-            method: method.into(),
-            params: serde_json::to_value(notification).unwrap(),
-        };
+    fn send_notification(&self, method: String, params: Value) {
+        let notification = lsp_server::Notification { method, params };
 
         trace!("Sending notification: {:?}", notification);
         self.connection.sender.send(notification.into()).unwrap();
     }
 
     /// Send request to the client.
-    fn send_request(&self, method: impl Into<String>, params: impl serde::ser::Serialize) {
+    fn send_request(&self, method: String, params: Value) {
         let request_id = self.next_outgoing_request_id.replace_with(|&mut id| id + 1);
 
-        let request = Request::new(
-            RequestId::from(request_id),
-            method.into(),
-            serde_json::to_value(params).unwrap(),
-        );
+        let request = Request::new(RequestId::from(request_id), method, params);
         self.connection.sender.send(request.into()).unwrap();
     }
 }
@@ -74,7 +65,7 @@ impl ConnectionRpcChannel {
     }
 
     /// Wait for initialize request from the client and let the server respond to it.
-    fn handle_initialization<T: RpcChannel + Clone>(&self, server: &mut VHDLServer<T>) {
+    fn handle_initialization(&self, server: &mut VHDLServer) {
         let (initialize_id, initialize_params) = self.connection.initialize_start().unwrap();
         let initialize_params =
             serde_json::from_value::<InitializeParams>(initialize_params).unwrap();
@@ -90,7 +81,7 @@ impl ConnectionRpcChannel {
     }
 
     /// Main event loop handling incoming messages from the client.
-    fn main_event_loop<T: RpcChannel + Clone>(&self, mut server: VHDLServer<T>) {
+    fn main_event_loop(&self, mut server: VHDLServer) {
         info!("Language server initialized, waiting for messages ...");
         while let Ok(message) = self.connection.receiver.recv() {
             trace!("Received message: {:?}", message);
@@ -113,11 +104,7 @@ impl ConnectionRpcChannel {
     }
 
     /// Handle incoming requests from the client.
-    fn handle_request<T: RpcChannel + Clone>(
-        &self,
-        server: &mut VHDLServer<T>,
-        request: lsp_server::Request,
-    ) {
+    fn handle_request(&self, server: &mut VHDLServer, request: lsp_server::Request) {
         fn extract<R>(
             request: lsp_server::Request,
         ) -> Result<(lsp_server::RequestId, R::Params), lsp_server::Request>
@@ -185,11 +172,7 @@ impl ConnectionRpcChannel {
     }
 
     /// Handle incoming notifications from the client.
-    fn handle_notification<T: RpcChannel + Clone>(
-        &self,
-        server: &mut VHDLServer<T>,
-        notification: lsp_server::Notification,
-    ) {
+    fn handle_notification(&self, server: &mut VHDLServer, notification: lsp_server::Notification) {
         fn extract<N>(
             notification: lsp_server::Notification,
         ) -> Result<N::Params, lsp_server::Notification>
@@ -233,11 +216,7 @@ impl ConnectionRpcChannel {
     }
 
     /// Handle incoming responses (to requests sent by us) from the client.
-    fn handle_response<T: RpcChannel + Clone>(
-        &self,
-        _server: &mut VHDLServer<T>,
-        response: lsp_server::Response,
-    ) {
+    fn handle_response(&self, _server: &mut VHDLServer, response: lsp_server::Response) {
         trace!("Handling response: {:?}", response);
         // We currently can ignore incoming responses as the implemented
         // outgoing requests do not require confirmation by the client.
diff --git a/vhdl_ls/src/vhdl_server.rs b/vhdl_ls/src/vhdl_server.rs
