diff --git a/jsonrpc/src/client.rs b/jsonrpc/src/client.rs
index 5e42aa32b..fd8305c58 100644
--- a/jsonrpc/src/client.rs
+++ b/jsonrpc/src/client.rs
@@ -77,7 +77,7 @@ where
 
             let result = match response.error {
                 Some(why) => Err(why),
-                None => Ok(response.result.unwrap_or(serde_json::Value::Null))
+                None => Ok(response.result.unwrap_or(serde_json::Value::Null)),
             };
             sender.send(result).unwrap();
         };
diff --git a/jsonrpc/src/lib.rs b/jsonrpc/src/lib.rs
index 5bd51e7ff..f9c61fe46 100644
--- a/jsonrpc/src/lib.rs
+++ b/jsonrpc/src/lib.rs
@@ -6,7 +6,7 @@ mod types;
 
 pub use self::{
     client::{Client, ResponseHandler},
-    server::{handle_notification, handle_request, EventHandler, Server},
+    server::{handle_notification, handle_request, EventHandler, RequestHandler},
     types::*,
 };
 
@@ -16,37 +16,21 @@ use futures::prelude::*;
 use futures::task::*;
 use std::sync::Arc;
 
-pub struct MessageHandler<S, H, I, O> {
-    server: Arc<S>,
-    response_handler: Arc<H>,
-    input: I,
-    output: Arc<Mutex<O>>,
-    pool: ThreadPool,
+pub struct MessageHandler<S, C, I, O> {
+    pub server: Arc<S>,
+    pub client: Arc<C>,
+    pub input: I,
+    pub output: Arc<Mutex<O>>,
+    pub pool: ThreadPool,
 }
 
-impl<S, H, I, O> MessageHandler<S, H, I, O>
+impl<S, C, I, O> MessageHandler<S, C, I, O>
 where
-    S: Server + EventHandler + Send + Sync + 'static,
-    H: ResponseHandler + Send + Sync + 'static,
+    S: RequestHandler + EventHandler + Send + Sync + 'static,
+    C: ResponseHandler + Send + Sync + 'static,
     I: Stream<Item = std::io::Result<String>> + Unpin,
     O: Sink<String> + Unpin + Send + 'static,
 {
-    pub fn new(
-        server: S,
-        response_handler: Arc<H>,
-        input: I,
-        output: Arc<Mutex<O>>,
-        pool: ThreadPool,
-    ) -> Self {
-        MessageHandler {
-            server: Arc::new(server),
-            response_handler,
-            input,
-            output,
-            pool,
-        }
-    }
-
     pub async fn listen(&mut self) {
         while let Some(json) = await!(self.input.next()) {
             let message = serde_json::from_str(&json.expect("")).map_err(|_| Error {
@@ -73,12 +57,14 @@ where
                     self.server.handle_notification(notification);
 
                     let server = Arc::clone(&self.server);
-                    self.pool.spawn(async move {
+                    let handler = async move {
                         await!(server.handle_events());
-                    });
+                    };
+
+                    self.pool.spawn(handler).unwrap();
                 }
                 Ok(Message::Response(response)) => {
-                    await!(self.response_handler.handle(response));
+                    await!(self.client.handle(response));
                 }
                 Err(why) => {
                     let response = Response::error(why, None);
diff --git a/jsonrpc/src/server.rs b/jsonrpc/src/server.rs
index b4b61c4c0..27428392d 100644
--- a/jsonrpc/src/server.rs
+++ b/jsonrpc/src/server.rs
@@ -7,7 +7,7 @@ use serde_json::json;
 
 pub type Result<T> = std::result::Result<T, String>;
 
-pub trait Server {
+pub trait RequestHandler {
     fn handle_request(&self, request: Request) -> BoxFuture<'_, Response>;
 
     fn handle_notification(&self, notification: Notification);
diff --git a/jsonrpc_derive/src/lib.rs b/jsonrpc_derive/src/lib.rs
index 4c0412fe5..21991f26e 100644
--- a/jsonrpc_derive/src/lib.rs
+++ b/jsonrpc_derive/src/lib.rs
@@ -72,7 +72,7 @@ pub fn jsonrpc_server(
     let tokens = quote! {
         #impl_
 
-        impl #generics jsonrpc::Server for #self_ty {
+        impl #generics jsonrpc::RequestHandler for #self_ty {
             fn handle_request(&self, request: jsonrpc::Request)
                 -> futures::future::BoxFuture<'_, jsonrpc::Response> {
                 use futures::prelude::*;
diff --git a/src/main.rs b/src/main.rs
index 195a05476..b0a2bf9e8 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -50,7 +50,14 @@ async fn run(pool: ThreadPool) {
     let input = FramedRead::new(stdin, LspCodec).compat();
     let output = Arc::new(Mutex::new(FramedWrite::new(stdout, LspCodec).sink_compat()));
     let client = Arc::new(LatexLspClient::new(Arc::clone(&output)));
-    let server = LatexLspServer::new(Arc::clone(&client));
-    let mut handler = MessageHandler::new(server, client, input, output, pool);
+    let server = Arc::new(LatexLspServer::new(Arc::clone(&client)));
+    let mut handler = MessageHandler {
+        server,
+        client,
+        input,
+        output,
+        pool,
+    };
+
     await!(handler.listen());
 }
diff --git a/src/server.rs b/src/server.rs
index 8cb907428..f7f21bac5 100644
--- a/src/server.rs
+++ b/src/server.rs
@@ -161,7 +161,8 @@ impl<C: LspClient + Send + Sync> LatexLspServer<C> {
 
     #[jsonrpc_method("textDocument/didSave", kind = "notification")]
     pub fn did_save(&self, params: DidSaveTextDocumentParams) {
-        self.event_manager.push(Event::Saved(params.text_document.uri));
+        self.event_manager
+            .push(Event::Saved(params.text_document.uri));
         self.event_manager.push(Event::WorkspaceChanged);
     }
 
@@ -321,7 +322,8 @@ impl<C: LspClient + Send + Sync> jsonrpc::EventHandler for LatexLspServer<C> {
                                 method: Cow::from("workspace/didChangeWatchedFiles"),
                                 register_options: Some(serde_json::to_value(options).unwrap()),
                             }]
-                        })).unwrap();
+                        }))
+                        .unwrap();
 
                         match TexResolver::load() {
                             Ok(res) => {