Add line index

6 files changed, 198 insertions, 28 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>,
+}
diff --git a/codeless/src/extension.ts b/codeless/src/extension.ts
index c64065e6b..792af5a73 100644
--- a/codeless/src/extension.ts
+++ b/codeless/src/extension.ts
@@ -6,7 +6,8 @@ import {
     ServerOptions,
     TransportKind,
     Executable,
-    TextDocumentIdentifier
+    TextDocumentIdentifier,
+    Range
 } from 'vscode-languageclient';
 
 
@@ -18,6 +19,7 @@ let uris = {
 
 
 export function activate(context: vscode.ExtensionContext) {
+    let textDocumentContentProvider = new TextDocumentContentProvider()
     let dispose = (disposable) => {
         context.subscriptions.push(disposable);
     }
@@ -26,11 +28,39 @@ export function activate(context: vscode.ExtensionContext) {
     }
 
     registerCommand('libsyntax-rust.syntaxTree', () => openDoc(uris.syntaxTree))
+    registerCommand('libsyntax-rust.extendSelection', async () => {
+        let editor = vscode.window.activeTextEditor
+        if (editor == null || editor.document.languageId != "rust") return
+        let request: ExtendSelectionParams = {
+            textDocument: { uri: editor.document.uri.toString() },
+            selections: editor.selections.map((s) => {
+                let r: Range = { start: s.start, end: s.end }
+                return r;
+            })
+        }
+        let response = await client.sendRequest<ExtendSelectionResult>("m/extendSelection", request)
+        editor.selections = response.selections.map((range) => {
+            return new vscode.Selection(
+                new vscode.Position(range.start.line, range.start.character),
+                new vscode.Position(range.end.line, range.end.character),
+            )
+        })
+    })
+
     dispose(vscode.workspace.registerTextDocumentContentProvider(
         'libsyntax-rust',
-        new TextDocumentContentProvider()
+        textDocumentContentProvider
     ))
     startServer()
+    vscode.workspace.onDidChangeTextDocument((event: vscode.TextDocumentChangeEvent) => {
+        let doc = event.document
+        if (doc.languageId != "rust") return
+        // We need to order this after LS updates, but there's no API for that.
+        // Hence, good old setTimeout.
+        setTimeout(() => {
+            textDocumentContentProvider.eventEmitter.fire(uris.syntaxTree)
+        }, 10)
+    }, null, context.subscriptions)
 }
 
 export function deactivate(): Thenable<void> {
@@ -76,11 +106,28 @@ class TextDocumentContentProvider implements vscode.TextDocumentContentProvider
     public provideTextDocumentContent(uri: vscode.Uri): vscode.ProviderResult<string> {
         let editor = vscode.window.activeTextEditor;
         if (editor == null) return ""
-        let textDocument: TextDocumentIdentifier = { uri: editor.document.uri.toString() };
-        return client.sendRequest("m/syntaxTree", { textDocument })
+        let request: SyntaxTreeParams = {
+            textDocument: { uri: editor.document.uri.toString() }
+        };
+        return client.sendRequest<SyntaxTreeResult>("m/syntaxTree", request);
     }
 
     get onDidChange(): vscode.Event<vscode.Uri> {
         return this.eventEmitter.event
     }
 }
+
+interface SyntaxTreeParams {
+    textDocument: TextDocumentIdentifier;
+}
+
+type SyntaxTreeResult = string
+
+interface ExtendSelectionParams {
+    textDocument: TextDocumentIdentifier;
+    selections: Range[];
+}
+
+interface ExtendSelectionResult {
+    selections: Range[];
+}