more modules

3 files changed, 206 insertions, 179 deletions

diff --git a/crates/server/src/main.rs b/crates/server/src/main.rs
index fe94e901e..fccfe9b3b 100644
--- a/crates/server/src/main.rs
+++ b/crates/server/src/main.rs
@@ -21,21 +21,17 @@ mod io;
 mod caps;
 mod req;
 mod dispatch;
-mod handlers;
 mod util;
 mod conv;
+mod main_loop;
 
 use threadpool::ThreadPool;
-use crossbeam_channel::{bounded, Sender, Receiver};
+use crossbeam_channel::bounded;
 use flexi_logger::Logger;
-use languageserver_types::Url;
-use libanalysis::{WorldState, World};
+use libanalysis::WorldState;
 
 use ::{
-    io::{Io, RawMsg, RawRequest, RawResponse, RawNotification},
-    handlers::{handle_syntax_tree, handle_extend_selection, publish_diagnostics, publish_decorations,
-               handle_document_symbol, handle_code_action},
-    util::FilePath,
+    io::{Io, RawMsg, RawResponse, RawNotification}
 };
 
 pub type Result<T> = ::std::result::Result<T, ::failure::Error>;
@@ -121,7 +117,7 @@ fn initialized(io: &mut Io) -> Result<()> {
         let mut pool = ThreadPool::new(4);
         let (sender, receiver) = bounded::<Task>(16);
         info!("lifecycle: handshake finished, server ready to serve requests");
-        let res = main_loop(io, &mut world, &mut pool, sender, receiver.clone());
+        let res = main_loop::main_loop(io, &mut world, &mut pool, sender, receiver.clone());
         info!("waiting for background jobs to finish...");
         receiver.for_each(drop);
         pool.join();
@@ -142,173 +138,3 @@ fn initialized(io: &mut Io) -> Result<()> {
         }
     }
 }
-
-fn main_loop(
-    io: &mut Io,
-    world: &mut WorldState,
-    pool: &mut ThreadPool,
-    sender: Sender<Task>,
-    receiver: Receiver<Task>,
-) -> Result<()> {
-    info!("server initialized, serving requests");
-    loop {
-        enum Event {
-            Msg(RawMsg),
-            Task(Task),
-            ReceiverDead,
-        }
-
-        let event = select! {
-            recv(io.receiver(), msg) => match msg {
-                Some(msg) => Event::Msg(msg),
-                None => Event::ReceiverDead,
-            },
-            recv(receiver, task) => Event::Task(task.unwrap()),
-        };
-
-        let msg = match event {
-            Event::ReceiverDead => {
-                io.cleanup_receiver()?;
-                unreachable!();
-            }
-            Event::Task(task) => {
-                match task {
-                    Task::Respond(response) =>
-                        io.send(RawMsg::Response(response)),
-                    Task::Notify(n) =>
-                        io.send(RawMsg::Notification(n)),
-                    Task::Die(error) =>
-                        return Err(error),
-                }
-                continue;
-            }
-            Event::Msg(msg) => msg,
-        };
-
-        match msg {
-            RawMsg::Request(req) => {
-                let mut req = Some(req);
-                handle_request_on_threadpool::<req::SyntaxTree>(
-                    &mut req, pool, world, &sender, handle_syntax_tree,
-                )?;
-                handle_request_on_threadpool::<req::ExtendSelection>(
-                    &mut req, pool, world, &sender, handle_extend_selection,
-                )?;
-                handle_request_on_threadpool::<req::DocumentSymbolRequest>(
-                    &mut req, pool, world, &sender, handle_document_symbol,
-                )?;
-                handle_request_on_threadpool::<req::CodeActionRequest>(
-                    &mut req, pool, world, &sender, handle_code_action,
-                )?;
-
-                let mut shutdown = false;
-                dispatch::handle_request::<req::Shutdown, _>(&mut req, |(), resp| {
-                    let resp = resp.into_response(Ok(()))?;
-                    io.send(RawMsg::Response(resp));
-                    shutdown = true;
-                    Ok(())
-                })?;
-                if shutdown {
-                    info!("lifecycle: initiating shutdown");
-                    drop(sender);
-                    return Ok(());
-                }
-                if let Some(req) = req {
-                    error!("unknown method: {:?}", req);
-                    dispatch::unknown_method(io, req)?;
-                }
-            }
-            RawMsg::Notification(not) => {
-                let mut not = Some(not);
-                dispatch::handle_notification::<req::DidOpenTextDocument, _>(&mut not, |params| {
-                    let path = params.text_document.file_path()?;
-                    world.change_overlay(path, Some(params.text_document.text));
-                    update_file_notifications_on_threadpool(
-                        pool, world.snapshot(), sender.clone(), params.text_document.uri,
-                    );
-                    Ok(())
-                })?;
-                dispatch::handle_notification::<req::DidChangeTextDocument, _>(&mut not, |mut params| {
-                    let path = params.text_document.file_path()?;
-                    let text = params.content_changes.pop()
-                        .ok_or_else(|| format_err!("empty changes"))?
-                        .text;
-                    world.change_overlay(path, Some(text));
-                    update_file_notifications_on_threadpool(
-                        pool, world.snapshot(), sender.clone(), params.text_document.uri,
-                    );
-                    Ok(())
-                })?;
-                dispatch::handle_notification::<req::DidCloseTextDocument, _>(&mut not, |params| {
-                    let path = params.text_document.file_path()?;
-                    world.change_overlay(path, None);
-                    let not = req::PublishDiagnosticsParams {
-                        uri: params.text_document.uri,
-                        diagnostics: Vec::new(),
-                    };
-                    let not = dispatch::send_notification::<req::PublishDiagnostics>(not);
-                    io.send(RawMsg::Notification(not));
-                    Ok(())
-                })?;
-
-                if let Some(not) = not {
-                    error!("unhandled notification: {:?}", not)
-                }
-            }
-            msg => {
-                eprintln!("msg = {:?}", msg);
-            }
-        }
-    }
-}
-
-fn handle_request_on_threadpool<R: req::ClientRequest>(
-    req: &mut Option<RawRequest>,
-    pool: &ThreadPool,
-    world: &WorldState,
-    sender: &Sender<Task>,
-    f: fn(World, R::Params) -> Result<R::Result>,
-) -> Result<()>
-{
-    dispatch::handle_request::<R, _>(req, |params, resp| {
-        let world = world.snapshot();
-        let sender = sender.clone();
-        pool.execute(move || {
-            let res = f(world, params);
-            let task = match resp.into_response(res) {
-                Ok(resp) => Task::Respond(resp),
-                Err(e) => Task::Die(e),
-            };
-            sender.send(task);
-        });
-        Ok(())
-    })
-}
-
-fn update_file_notifications_on_threadpool(
-    pool: &ThreadPool,
-    world: World,
-    sender: Sender<Task>,
-    uri: Url,
-) {
-    pool.execute(move || {
-        match publish_diagnostics(world.clone(), uri.clone()) {
-            Err(e) => {
-                error!("failed to compute diagnostics: {:?}", e)
-            }
-            Ok(params) => {
-                let not = dispatch::send_notification::<req::PublishDiagnostics>(params);
-                sender.send(Task::Notify(not));
-            }
-        }
-        match publish_decorations(world, uri) {
-            Err(e) => {
-                error!("failed to compute decorations: {:?}", e)
-            }
-            Ok(params) => {
-                let not = dispatch::send_notification::<req::PublishDecorations>(params);
-                sender.send(Task::Notify(not))
-            }
-        }
-    });
-}
diff --git a/crates/server/src/handlers.rs b/crates/server/src/main_loop/handlers.rs
index c6db22289..c6db22289 100644
--- a/crates/server/src/handlers.rs
+++ b/crates/server/src/main_loop/handlers.rs
diff --git a/crates/server/src/main_loop/mod.rs b/crates/server/src/main_loop/mod.rs
new file mode 100644
index 000000000..e7b24e53f
--- /dev/null
+++ b/crates/server/src/main_loop/mod.rs
@@ -0,0 +1,201 @@
+mod handlers;
+
+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},
+    util::FilePath,
+    main_loop::handlers::{
+        handle_syntax_tree,
+        handle_extend_selection,
+        publish_diagnostics,
+        publish_decorations,
+        handle_document_symbol,
+        handle_code_action,
+    },
+};
+
+pub(super) fn main_loop(
+    io: &mut Io,
+    world: &mut WorldState,
+    pool: &mut ThreadPool,
+    sender: Sender<Task>,
+    receiver: Receiver<Task>,
+) -> Result<()> {
+    info!("server initialized, serving requests");
+    loop {
+        enum Event {
+            Msg(RawMsg),
+            Task(Task),
+            ReceiverDead,
+        }
+        let event = select! {
+            recv(io.receiver(), msg) => match msg {
+                Some(msg) => Event::Msg(msg),
+                None => Event::ReceiverDead,
+            },
+            recv(receiver, task) => Event::Task(task.unwrap()),
+        };
+
+        match event {
+            Event::ReceiverDead => {
+                io.cleanup_receiver()?;
+                unreachable!();
+            }
+            Event::Task(task) => {
+                match task {
+                    Task::Respond(response) =>
+                        io.send(RawMsg::Response(response)),
+                    Task::Notify(n) =>
+                        io.send(RawMsg::Notification(n)),
+                    Task::Die(error) =>
+                        return Err(error),
+                }
+                continue;
+            }
+            Event::Msg(msg) => {
+                if !on_msg(io, world, pool, &sender, msg)? {
+                    return Ok(());
+                }
+            }
+        };
+    }
+}
+
+fn on_msg(
+    io: &mut Io,
+    world: &mut WorldState,
+    pool: &mut ThreadPool,
+    sender: &Sender<Task>,
+    msg: RawMsg,
+) -> 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,
+            )?;
+            handle_request_on_threadpool::<req::ExtendSelection>(
+                &mut req, pool, world, sender, handle_extend_selection,
+            )?;
+            handle_request_on_threadpool::<req::DocumentSymbolRequest>(
+                &mut req, pool, world, sender, handle_document_symbol,
+            )?;
+            handle_request_on_threadpool::<req::CodeActionRequest>(
+                &mut req, pool, world, sender, handle_code_action,
+            )?;
+
+            let mut shutdown = false;
+            dispatch::handle_request::<req::Shutdown, _>(&mut req, |(), resp| {
+                let resp = resp.into_response(Ok(()))?;
+                io.send(RawMsg::Response(resp));
+                shutdown = true;
+                Ok(())
+            })?;
+            if shutdown {
+                info!("lifecycle: initiating shutdown");
+                return Ok(false);
+            }
+            if let Some(req) = req {
+                error!("unknown method: {:?}", req);
+                dispatch::unknown_method(io, req)?;
+            }
+        }
+        RawMsg::Notification(not) => {
+            let mut not = Some(not);
+            dispatch::handle_notification::<req::DidOpenTextDocument, _>(&mut not, |params| {
+                let path = params.text_document.file_path()?;
+                world.change_overlay(path, Some(params.text_document.text));
+                update_file_notifications_on_threadpool(
+                    pool, world.snapshot(), sender.clone(), params.text_document.uri,
+                );
+                Ok(())
+            })?;
+            dispatch::handle_notification::<req::DidChangeTextDocument, _>(&mut not, |mut params| {
+                let path = params.text_document.file_path()?;
+                let text = params.content_changes.pop()
+                    .ok_or_else(|| format_err!("empty changes"))?
+                    .text;
+                world.change_overlay(path, Some(text));
+                update_file_notifications_on_threadpool(
+                    pool, world.snapshot(), sender.clone(), params.text_document.uri,
+                );
+                Ok(())
+            })?;
+            dispatch::handle_notification::<req::DidCloseTextDocument, _>(&mut not, |params| {
+                let path = params.text_document.file_path()?;
+                world.change_overlay(path, None);
+                let not = req::PublishDiagnosticsParams {
+                    uri: params.text_document.uri,
+                    diagnostics: Vec::new(),
+                };
+                let not = dispatch::send_notification::<req::PublishDiagnostics>(not);
+                io.send(RawMsg::Notification(not));
+                Ok(())
+            })?;
+
+            if let Some(not) = not {
+                error!("unhandled notification: {:?}", not)
+            }
+        }
+        msg => {
+            eprintln!("msg = {:?}", msg);
+        }
+    };
+    Ok(true)
+}
+
+fn handle_request_on_threadpool<R: req::ClientRequest>(
+    req: &mut Option<RawRequest>,
+    pool: &ThreadPool,
+    world: &WorldState,
+    sender: &Sender<Task>,
+    f: fn(World, R::Params) -> Result<R::Result>,
+) -> Result<()>
+{
+    dispatch::handle_request::<R, _>(req, |params, resp| {
+        let world = world.snapshot();
+        let sender = sender.clone();
+        pool.execute(move || {
+            let res = f(world, params);
+            let task = match resp.into_response(res) {
+                Ok(resp) => Task::Respond(resp),
+                Err(e) => Task::Die(e),
+            };
+            sender.send(task);
+        });
+        Ok(())
+    })
+}
+
+fn update_file_notifications_on_threadpool(
+    pool: &ThreadPool,
+    world: World,
+    sender: Sender<Task>,
+    uri: Url,
+) {
+    pool.execute(move || {
+        match publish_diagnostics(world.clone(), uri.clone()) {
+            Err(e) => {
+                error!("failed to compute diagnostics: {:?}", e)
+            }
+            Ok(params) => {
+                let not = dispatch::send_notification::<req::PublishDiagnostics>(params);
+                sender.send(Task::Notify(not));
+            }
+        }
+        match publish_decorations(world, uri) {
+            Err(e) => {
+                error!("failed to compute decorations: {:?}", e)
+            }
+            Ok(params) => {
+                let not = dispatch::send_notification::<req::PublishDecorations>(params);
+                sender.send(Task::Notify(not))
+            }
+        }
+    });
+}