Merge pull request #519 from philip-alldredge/ack_responses

ack_responses

Author: nrc

src/server/mod.rs

@@ -45,6 +45,9 @@ pub fn run_server(analysis: Arc<AnalysisHost>, vfs: Arc<Vfs>) {
 #[derive(Debug, Serialize)]
 pub struct Ack;
 
+#[derive(Debug)]
+pub struct NoResponse;
+
 #[derive(Debug, Serialize, PartialEq)]
 pub struct NoParams;
 
@@ -56,6 +59,21 @@ impl<'de> Deserialize<'de> for NoParams {
     }
 }
 
+pub trait Response {
+    fn send<O: Output>(&self, id: usize, out: O); 
+}
+
+impl Response for NoResponse {
+    fn send<O: Output>(&self, _id: usize, _out: O) {
+    }
+}
+
+impl<R: ::serde::Serialize + fmt::Debug> Response for R {
+    fn send<O: Output>(&self, id: usize, out: O) {
+        out.success(id, &self);
+    }
+}
+
 pub trait Action<'a> {
     type Params: serde::Serialize + for<'de> ::serde::Deserialize<'de>;
     const METHOD: &'static str;
@@ -68,7 +86,7 @@ pub trait NotificationAction<'a>: Action<'a> {
 }
 
 pub trait RequestAction<'a>: Action<'a> {
-    type Response: ::serde::Serialize + fmt::Debug;
+    type Response: Response + fmt::Debug;
 
     fn handle<O: Output>(&mut self, id: usize, params: Self::Params, ctx: &mut ActionContext, out: O) -> Result<Self::Response, ()>;
 }
@@ -90,9 +108,7 @@ impl<'a, A: RequestAction<'a>> Request<'a, A> {
     fn dispatch<O: Output>(self, state: &'a mut LsState, ctx: &mut ActionContext, out: O) -> Result<A::Response, ()> {
         let mut action = A::new(state);
         let result = action.handle(self.id, self.params, ctx, out.clone())?;
-        if ::std::mem::size_of::<A::Response>() > 0 {
-            out.success(self.id, &result);
-        }
+        result.send(self.id, out);
         Ok(result)
     }
 }
@@ -196,8 +212,8 @@ impl<'a> Action<'a> for InitializeRequest {
 }
 
 impl<'a> RequestAction<'a> for InitializeRequest {
-    type Response = ();
-    fn handle<O: Output>(&mut self, id: usize, params: Self::Params, ctx: &mut ActionContext, out: O) -> Result<(), ()> {
+    type Response = NoResponse;
+    fn handle<O: Output>(&mut self, id: usize, params: Self::Params, ctx: &mut ActionContext, out: O) -> Result<NoResponse, ()> {
         let init_options: InitializationOptions = params
             .initialization_options
             .as_ref()
@@ -240,7 +256,7 @@ impl<'a> RequestAction<'a> for InitializeRequest {
         let root_path = params.root_path.as_ref().map(PathBuf::from).expect("No root path");
         ctx.init(root_path, &init_options, out);
 
-        Ok(())
+        Ok(NoResponse)
     }
 }
 

src/test/mod.rs

@@ -16,7 +16,7 @@ mod harness;
 use analysis;
 use actions::requests;
 use config::{Config, Inferrable};
-use server::{self as ls_server, Request};
+use server::{self as ls_server, Request, ShutdownRequest, NoParams};
 use jsonrpc_core;
 use vfs;
 
@@ -65,6 +65,31 @@ pub fn request<'a, T: ls_server::RequestAction<'a>>(id: usize, params: T::Params
     }
 }
 
+#[test]
+fn test_shutdown() {
+    let mut env = Environment::new("common");
+
+    let root_path = env.cache.abs_path(Path::new("."));
+
+    let messages = vec![
+        initialize(0, root_path.as_os_str().to_str().map(|x| x.to_owned())).to_string(),
+        request::<ShutdownRequest>(1, NoParams).to_string(),
+    ];
+
+    let (mut server, results) = env.mock_server(messages);
+    // Initialise and build.
+    assert_eq!(ls_server::LsService::handle_message(&mut server),
+               ls_server::ServerStateChange::Continue);
+    expect_messages(results.clone(), &[ExpectedMessage::new(Some(0)).expect_contains("capabilities"),
+                                       ExpectedMessage::new(None).expect_contains("beginBuild"),
+                                       ExpectedMessage::new(None).expect_contains("diagnosticsBegin"),
+                                       ExpectedMessage::new(None).expect_contains("diagnosticsEnd")]);
+
+    assert_eq!(ls_server::LsService::handle_message(&mut server),
+               ls_server::ServerStateChange::Continue);
+    expect_messages(results.clone(), &[&ExpectedMessage::new(Some(1))]);
+}
+
 #[test]
 fn test_goto_def() {
     let mut env = Environment::new("common");