Refctor

crates/server/src/main.rs

@@ -31,7 +31,7 @@ use flexi_logger::Logger;
 use libanalysis::WorldState;
 
 use ::{
-    io::{Io, RawMsg, RawResponse, RawNotification}
+    io::{Io, RawMsg, RawResponse, RawRequest, RawNotification}
 };
 
 pub type Result<T> = ::std::result::Result<T, ::failure::Error>;
@@ -104,6 +104,7 @@ fn initialize(io: &mut Io) -> Result<()> {
 
 enum Task {
     Respond(RawResponse),
+    Request(RawRequest),
     Notify(RawNotification),
     Die(::failure::Error),
 }

crates/server/src/main_loop/mod.rs

@@ -1,13 +1,16 @@
 mod handlers;
 
+use std::collections::HashSet;
+
 use threadpool::ThreadPool;
 use crossbeam_channel::{Sender, Receiver};
 use languageserver_types::Url;
 use libanalysis::{World, WorldState};
+
 use {
     req, dispatch,
     Task, Result,
-    io::{Io, RawMsg, RawRequest},
+    io::{Io, RawMsg, RawRequest, RawNotification},
     util::FilePath,
     main_loop::handlers::{
         handle_syntax_tree,
@@ -27,6 +30,8 @@ pub(super) fn main_loop(
     receiver: Receiver<Task>,
 ) -> Result<()> {
     info!("server initialized, serving requests");
+    let mut next_request_id = 0;
+    let mut pending_requests: HashSet<u64> = HashSet::new();
     loop {
         enum Event {
             Msg(RawMsg),
@@ -48,6 +53,12 @@ pub(super) fn main_loop(
             }
             Event::Task(task) => {
                 match task {
+                    Task::Request(mut request) => {
+                        request.id = next_request_id;
+                        pending_requests.insert(next_request_id);
+                        next_request_id += 1;
+                        io.send(RawMsg::Request(request));
+                    }
                     Task::Respond(response) =>
                         io.send(RawMsg::Response(response)),
                     Task::Notify(n) =>
@@ -58,23 +69,31 @@ pub(super) fn main_loop(
                 continue;
             }
             Event::Msg(msg) => {
-                if !on_msg(io, world, pool, &sender, msg)? {
+                match msg {
+                    RawMsg::Request(req) => {
+                        if !on_request(io, world, pool, &sender, req)? {
                             return Ok(());
                         }
                     }
+                    RawMsg::Notification(not) => {
+                        on_notification(io, world, pool, &sender, not)?
+                    }
+                    RawMsg::Response(resp) => {
+                        error!("unexpected response: {:?}", resp)
+                    }
+                }
+            }
         };
     }
 }
 
-fn on_msg(
+fn on_request(
     io: &mut Io,
-    world: &mut WorldState,
+    world: &WorldState,
-    pool: &mut ThreadPool,
+    pool: &ThreadPool,
     sender: &Sender<Task>,
-    msg: RawMsg,
+    req: RawRequest,
 ) -> Result<bool> {
-    match msg {
-        RawMsg::Request(req) => {
     let mut req = Some(req);
     handle_request_on_threadpool::<req::SyntaxTree>(
         &mut req, pool, world, sender, handle_syntax_tree,
@@ -88,6 +107,22 @@ fn on_msg(
     handle_request_on_threadpool::<req::CodeActionRequest>(
         &mut req, pool, world, sender, handle_code_action,
     )?;
+//    dispatch::handle_request::<req::ExecuteCommand, _>(&mut req, |(), resp| {
+//        let world = world.snapshot();
+//        let sender = sender.clone();
+//        pool.execute(move || {
+//            let task = match handle_execute_command(world, params) {
+//                Ok(req) => Task::Request(req),
+//                Err(e) => Task::Die(e),
+//            };
+//            sender.send(task)
+//        });
+//
+//        let resp = resp.into_response(Ok(()))?;
+//        io.send(RawMsg::Response(resp));
+//        shutdown = true;
+//        Ok(())
+//    })?;
 
     let mut shutdown = false;
     dispatch::handle_request::<req::Shutdown, _>(&mut req, |(), resp| {
@@ -104,8 +139,16 @@ fn on_msg(
         error!("unknown method: {:?}", req);
         io.send(RawMsg::Response(dispatch::unknown_method(req.id)?));
     }
-        }
+    Ok(true)
-        RawMsg::Notification(not) => {
+}
+
+fn on_notification(
+    io: &mut Io,
+    world: &mut WorldState,
+    pool: &ThreadPool,
+    sender: &Sender<Task>,
+    not: RawNotification,
+) -> Result<()> {
     let mut not = Some(not);
     dispatch::handle_notification::<req::DidOpenTextDocument, _>(&mut not, |params| {
         let path = params.text_document.file_path()?;
@@ -139,14 +182,9 @@ fn on_msg(
     })?;
 
     if let Some(not) = not {
-                error!("unhandled notification: {:?}", not)
+        error!("unhandled notification: {:?}", not);
     }
-        }
+    Ok(())
-        msg => {
-            eprintln!("msg = {:?}", msg);
-        }
-    };
-    Ok(true)
 }
 
 fn handle_request_on_threadpool<R: req::ClientRequest>(