Add line index

5 files changed, 147 insertions, 24 deletions

diff --git a/codeless/server/src/caps.rs b/codeless/server/src/caps.rs
index b2fad6732..3d89c64a9 100644
--- a/codeless/server/src/caps.rs
+++ b/codeless/server/src/caps.rs
@@ -1,7 +1,20 @@
-use languageserver_types::ServerCapabilities;
+use languageserver_types::{
+    ServerCapabilities,
+    TextDocumentSyncCapability,
+    TextDocumentSyncOptions,
+    TextDocumentSyncKind,
+};
 
 pub const SERVER_CAPABILITIES: ServerCapabilities = ServerCapabilities {
-    text_document_sync: None,
+    text_document_sync: Some(TextDocumentSyncCapability::Options(
+        TextDocumentSyncOptions {
+            open_close: Some(true),
+            change: Some(TextDocumentSyncKind::Full),
+            will_save: None,
+            will_save_wait_until: None,
+            save: None,
+        }
+    )),
     hover_provider: None,
     completion_provider: None,
     signature_help_provider: None,
diff --git a/codeless/server/src/dispatch.rs b/codeless/server/src/dispatch.rs
index ee87fa6c3..41437b62a 100644
--- a/codeless/server/src/dispatch.rs
+++ b/codeless/server/src/dispatch.rs
@@ -9,8 +9,8 @@ use drop_bomb::DropBomb;
 
 use ::{
     Result,
-    req::Request,
-    io::{Io, RawMsg, RawResponse, RawRequest},
+    req::{Request, Notification},
+    io::{Io, RawMsg, RawResponse, RawRequest, RawNotification},
 };
 
 pub struct Responder<R: Request> {
@@ -52,7 +52,7 @@ impl<R: Request> Responder<R>
 }
 
 
-pub fn parse_as<R>(raw: RawRequest) -> Result<::std::result::Result<(R::Params, Responder<R>), RawRequest>>
+pub fn parse_request_as<R>(raw: RawRequest) -> Result<::std::result::Result<(R::Params, Responder<R>), RawRequest>>
     where
         R: Request,
         R::Params: DeserializeOwned,
@@ -71,13 +71,13 @@ pub fn parse_as<R>(raw: RawRequest) -> Result<::std::result::Result<(R::Params,
     Ok(Ok((params, responder)))
 }
 
-pub fn expect<R>(io: &mut Io, raw: RawRequest) -> Result<Option<(R::Params, Responder<R>)>>
+pub fn expect_request<R>(io: &mut Io, raw: RawRequest) -> Result<Option<(R::Params, Responder<R>)>>
     where
         R: Request,
         R::Params: DeserializeOwned,
         R::Result: Serialize,
 {
-    let ret = match parse_as::<R>(raw)? {
+    let ret = match parse_request_as::<R>(raw)? {
         Ok(x) => Some(x),
         Err(raw) => {
             unknown_method(io, raw)?;
@@ -87,6 +87,37 @@ pub fn expect<R>(io: &mut Io, raw: RawRequest) -> Result<Option<(R::Params, Resp
     Ok(ret)
 }
 
+pub fn parse_notification_as<N>(raw: RawNotification) -> Result<::std::result::Result<N::Params, RawNotification>>
+    where
+        N: Notification,
+        N::Params: DeserializeOwned,
+{
+    if raw.method != N::METHOD {
+        return Ok(Err(raw));
+    }
+    let params: N::Params = serde_json::from_value(raw.params)?;
+    Ok(Ok(params))
+}
+
+pub fn handle_notification<N, F>(not: &mut Option<RawNotification>, f: F) -> Result<()>
+    where
+        N: Notification,
+        N::Params: DeserializeOwned,
+        F: FnOnce(N::Params) -> Result<()>
+{
+    match not.take() {
+        None => Ok(()),
+        Some(n) => match parse_notification_as::<N>(n)? {
+            Ok(params) => f(params),
+            Err(n) => {
+                *not = Some(n);
+                Ok(())
+            },
+        }
+    }
+}
+
+
 pub fn unknown_method(io: &mut Io, raw: RawRequest) -> Result<()> {
     error(io, raw.id, ErrorCode::MethodNotFound, "unknown method")
 }
diff --git a/codeless/server/src/handlers.rs b/codeless/server/src/handlers.rs
new file mode 100644
index 000000000..3f257941a
--- /dev/null
+++ b/codeless/server/src/handlers.rs
@@ -0,0 +1,13 @@
+use libanalysis::World;
+use libeditor;
+use {req, Result};
+
+pub fn handle_syntax_tree(
+    world: World,
+    params: req::SyntaxTreeParams
+) -> Result<String> {
+    let path = params.text_document.uri.to_file_path()
+        .map_err(|()| format_err!("invalid path"))?;
+    let file = world.file_syntax(&path)?;
+    Ok(libeditor::syntax_tree(&file))
+}
diff --git a/codeless/server/src/main.rs b/codeless/server/src/main.rs
index fdb2fe2d5..287d650fa 100644
--- a/codeless/server/src/main.rs
+++ b/codeless/server/src/main.rs
@@ -19,20 +19,25 @@ mod io;
 mod caps;
 mod req;
 mod dispatch;
+mod handlers;
+
+use std::path::PathBuf;
 
 use threadpool::ThreadPool;
 use crossbeam_channel::{bounded, Sender, Receiver};
 use flexi_logger::Logger;
 use libanalysis::WorldState;
+use languageserver_types::{TextDocumentItem, VersionedTextDocumentIdentifier, TextDocumentIdentifier};
 
 use ::{
     io::{Io, RawMsg},
+    handlers::handle_syntax_tree,
 };
 
 pub type Result<T> = ::std::result::Result<T, ::failure::Error>;
 
 fn main() -> Result<()> {
-    Logger::with_env_or_str("m=trace")
+    Logger::with_env_or_str("m=trace, libanalysis=trace")
         .log_to_file()
         .directory("log")
         .start()?;
@@ -70,7 +75,7 @@ fn initialize(io: &mut Io) -> Result<()> {
     loop {
         match io.recv()? {
             RawMsg::Request(req) => {
-                if let Some((_params, resp)) = dispatch::expect::<req::Initialize>(io, req)? {
+                if let Some((_params, resp)) = dispatch::expect_request::<req::Initialize>(io, req)? {
                     resp.result(io, req::InitializeResult {
                         capabilities: caps::SERVER_CAPABILITIES
                     })?;
@@ -148,18 +153,12 @@ fn main_loop(
 
         match msg {
             RawMsg::Request(req) => {
-                let req = match dispatch::parse_as::<req::SyntaxTree>(req)? {
+                let req = match dispatch::parse_request_as::<req::SyntaxTree>(req)? {
                     Ok((params, resp)) => {
                         let world = world.snapshot();
                         let sender = sender.clone();
                         pool.execute(move || {
-                            let res: Result<String> = (|| {
-                                let path = params.text_document.uri.to_file_path()
-                                    .map_err(|()| format_err!("invalid path"))?;
-                                let file = world.file_syntax(&path)?;
-                                Ok(libeditor::syntax_tree(&file))
-                            })();
-
+                            let res: Result<String> = handle_syntax_tree(world, params);
                             sender.send(Box::new(|io: &mut Io| resp.response(io, res)))
                         });
                         continue;
@@ -167,12 +166,38 @@ fn main_loop(
                     Err(req) => req,
                 };
 
-                if let Some(((), resp)) = dispatch::expect::<req::Shutdown>(io, req)? {
-                    info!("shutdown request");
+                if let Some(((), resp)) = dispatch::expect_request::<req::Shutdown>(io, req)? {
+                    info!("clean shutdown started");
                     resp.result(io, ())?;
                     return Ok(());
                 }
             }
+            RawMsg::Notification(not) => {
+                use dispatch::handle_notification as h;
+                let mut not = Some(not);
+                h::<req::DidOpenTextDocument, _>(&mut not, |params| {
+                    let path = params.text_document.file_path()?;
+                    world.change_overlay(path, Some(params.text_document.text));
+                    Ok(())
+                })?;
+                h::<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));
+                    Ok(())
+                })?;
+                h::<req::DidCloseTextDocument, _>(&mut not, |params| {
+                    let path = params.text_document.file_path()?;
+                    world.change_overlay(path, None);
+                    Ok(())
+                })?;
+
+                if let Some(not) = not {
+                    error!("unhandled notification: {:?}", not)
+                }
+            }
             msg => {
                 eprintln!("msg = {:?}", msg);
             }
@@ -180,7 +205,6 @@ fn main_loop(
     }
 }
 
-
 trait FnBox<A, R>: Send {
     fn call_box(self: Box<Self>, a: A) -> R;
 }
@@ -190,3 +214,28 @@ impl<A, R, F: FnOnce(A) -> R + Send> FnBox<A, R> for F {
         (*self)(a)
     }
 }
+
+trait FilePath {
+    fn file_path(&self) -> Result<PathBuf>;
+}
+
+impl FilePath for TextDocumentItem {
+    fn file_path(&self) -> Result<PathBuf> {
+        self.uri.to_file_path()
+            .map_err(|()| format_err!("invalid uri: {}", self.uri))
+    }
+}
+
+impl FilePath for VersionedTextDocumentIdentifier {
+    fn file_path(&self) -> Result<PathBuf> {
+        self.uri.to_file_path()
+            .map_err(|()| format_err!("invalid uri: {}", self.uri))
+    }
+}
+
+impl FilePath for TextDocumentIdentifier {
+    fn file_path(&self) -> Result<PathBuf> {
+        self.uri.to_file_path()
+            .map_err(|()| format_err!("invalid uri: {}", self.uri))
+    }
+}
diff --git a/codeless/server/src/req.rs b/codeless/server/src/req.rs
index 35a20a229..ee4a786c7 100644
--- a/codeless/server/src/req.rs
+++ b/codeless/server/src/req.rs
@@ -1,6 +1,9 @@
-use languageserver_types::TextDocumentIdentifier;
-pub use languageserver_types::request::*;
-pub use languageserver_types::{InitializeResult};
+use languageserver_types::{TextDocumentIdentifier, Range};
+
+pub use languageserver_types::{
+    request::*, notification::*,
+    InitializeResult,
+};
 
 pub enum SyntaxTree {}
 
@@ -11,7 +14,21 @@ impl Request for SyntaxTree {
 }
 
 #[derive(Deserialize, Debug)]
-#[serde(rename_all="camelCase")]
+#[serde(rename_all = "camelCase")]
 pub struct SyntaxTreeParams {
     pub text_document: TextDocumentIdentifier
 }
+
+pub enum ExtendSelection {}
+
+#[derive(Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct ExtendSelectionParams {
+    pub text_document: TextDocumentIdentifier,
+    pub selections: Vec<Range>,
+}
+
+
+pub struct ExtendSelectionResult {
+    pub selections: Vec<Range>,
+}