Merge pull request #658 from Xanewok/update-ls-types

Update languageserver-types and clean up a bit

Author: nrc

Cargo.lock

@@ -14,7 +14,7 @@ cargo = { git = "https://github.com/rust-lang/cargo" }
 env_logger = "0.4"
 failure = "0.1.1"
 jsonrpc-core = "8.0.1"
-languageserver-types = { git = "https://github.com/Xanewok/languageserver-types", branch = "backport-0.17-fix-params-types" }
+languageserver-types = "0.27"
 lazy_static = "0.2"
 log = "0.3"
 racer = "2.0.12"

Cargo.toml

@@ -21,8 +21,8 @@ use Span;
 
 use build::*;
 use lsp_data::*;
-use lsp_data::request::{Request, RangeFormatting};
-use lsp_data::notification::{Notification, RegisterCapability, UnregisterCapability};
+use lsp_data::request::{RangeFormatting, RegisterCapability, UnregisterCapability};
+use server::Request;
 
 pub use lsp_data::notification::{
     Initialized,
@@ -46,21 +46,19 @@ impl BlockingNotificationAction for Initialized {
 
         let ctx = ctx.inited();
 
-        let options = FileWatch::new(&ctx).watchers_config();
-        let output = serde_json::to_string(&RequestMessage::new(
-            out.provide_id(),
-            <RegisterCapability as Notification>::METHOD.to_owned(),
-            RegistrationParams {
-                registrations: vec![
-                    Registration {
-                        id: WATCH_ID.to_owned(),
-                        method: <DidChangeWatchedFiles as Notification>::METHOD.to_owned(),
-                        register_options: options,
-                    },
-                ],
-            },
-        )).unwrap();
-        out.response(output);
+        let id = out.provide_id() as usize;
+        let params = RegistrationParams {
+            registrations: vec![
+                Registration {
+                    id: WATCH_ID.to_owned(),
+                    method: <DidChangeWatchedFiles as LSPNotification>::METHOD.to_owned(),
+                    register_options: FileWatch::new(&ctx).watchers_config(),
+                },
+            ],
+        };
+
+        let request = Request::<RegisterCapability>::new(id, params);
+        out.request(request);
         Ok(())
     }
 }
@@ -111,7 +109,7 @@ impl BlockingNotificationAction for DidChangeTextDocument {
             .expect("error committing to VFS");
         if !changes.is_empty() {
             ctx.build_queue
-                .mark_file_dirty(file_path, params.text_document.version)
+                .mark_file_dirty(file_path, params.text_document.version.unwrap())
         }
 
         if !ctx.config.lock().unwrap().build_on_save {
@@ -198,35 +196,32 @@ impl BlockingNotificationAction for DidChangeConfiguration {
 
         const RANGE_FORMATTING_ID: &'static str = "rls-range-formatting";
         // FIXME should handle the response
+        let id = out.provide_id() as usize;
         if unstable_features {
-            let output = serde_json::to_string(&RequestMessage::new(
-                out.provide_id(),
-                <RegisterCapability as Notification>::METHOD.to_owned(),
-                RegistrationParams {
+            let params = RegistrationParams {
                     registrations: vec![
                         Registration {
                             id: RANGE_FORMATTING_ID.to_owned(),
-                            method: <RangeFormatting as Request>::METHOD.to_owned(),
+                            method: <RangeFormatting as LSPRequest>::METHOD.to_owned(),
                             register_options: serde_json::Value::Null,
                         },
                     ],
-                },
-            )).unwrap();
-            out.response(output);
+            };
+
+            let request = Request::<RegisterCapability>::new(id, params);
+            out.request(request);
         } else {
-            let output = serde_json::to_string(&RequestMessage::new(
-                out.provide_id(),
-                <UnregisterCapability as Notification>::METHOD.to_owned(),
-                UnregistrationParams {
-                    unregisterations: vec![
-                        Unregistration {
-                            id: RANGE_FORMATTING_ID.to_owned(),
-                            method: <RangeFormatting as Request>::METHOD.to_owned(),
-                        },
-                    ],
-                },
-            )).unwrap();
-            out.response(output);
+            let params = UnregistrationParams {
+                unregisterations: vec![
+                    Unregistration {
+                        id: RANGE_FORMATTING_ID.to_owned(),
+                        method: <RangeFormatting as LSPRequest>::METHOD.to_owned(),
+                    },
+                ],
+            };
+
+            let request = Request::<UnregisterCapability>::new(id, params);
+            out.request(request);
         }
         Ok(())
     }

src/actions/notifications.rs

@@ -27,9 +27,10 @@ use rayon;
 use lsp_data;
 use lsp_data::*;
 use server;
-use server::{Ack, Output, RequestAction, ResponseError};
+use server::{Ack, Output, Request, RequestAction, ResponseError};
 use jsonrpc_core::types::ErrorCode;
 
+use lsp_data::request::ApplyWorkspaceEdit;
 pub use lsp_data::request::{
     WorkspaceSymbol,
     DocumentSymbol as Symbols,
@@ -370,7 +371,8 @@ impl RequestAction for Rename {
 
     fn fallback_response() -> Result<Self::Response, ResponseError> {
         Ok(WorkspaceEdit {
-            changes: HashMap::new(),
+            changes: None,
+            document_changes: None,
         })
     }
 
@@ -422,7 +424,7 @@ impl RequestAction for Rename {
                 });
         }
 
-        Ok(WorkspaceEdit { changes: edits })
+        Ok(WorkspaceEdit { changes: Some(edits), document_changes: None })
     }
 }
 
@@ -437,14 +439,13 @@ impl server::Response for ExecuteCommandResponse {
         // FIXME should handle the client's responses
         match *self {
             ExecuteCommandResponse::ApplyEdit(ref params) => {
-                let output = serde_json::to_string(&RequestMessage::new(
-                    out.provide_id(),
-                    "workspace/applyEdit".to_owned(),
-                    ApplyWorkspaceEditParams {
+                let id = out.provide_id() as usize;
+                let params = ApplyWorkspaceEditParams {
                         edit: params.edit.clone(),
-                    },
-                )).unwrap();
-                out.response(output);
+                };
+
+                let request = Request::<ApplyWorkspaceEdit>::new(id, params);
+                out.request(request);
             }
         }
 
@@ -515,11 +516,15 @@ fn apply_deglobs(args: Vec<serde_json::Value>) -> Result<ApplyWorkspaceEditParam
             }
         })
         .collect();
-    let mut edit = WorkspaceEdit {
-        changes: HashMap::new(),
-    };
     // all deglob results will share the same URI
-    edit.changes.insert(uri, text_edits);
+    let changes: HashMap<_, _> = vec![(uri, text_edits)]
+        .into_iter()
+        .collect();
+
+    let edit = WorkspaceEdit {
+        changes: Some(changes),
+        document_changes: None,
+    };
 
     Ok(ApplyWorkspaceEditParams { edit })
 }

src/actions/requests.rs

@@ -10,20 +10,20 @@
 
 //! Types, helpers, and conversions to and from LSP and `racer` types.
 
-use std::collections::HashMap;
-use std::fmt::{self, Debug};
+use std::fmt;
 use std::path::PathBuf;
 use std::error::Error;
 
 use analysis::DefKind;
 use url::Url;
-use serde::Serialize;
 use span;
 use racer;
 use vfs::FileContents;
 use ls_types;
 
 pub use ls_types::*;
+pub use ls_types::request::Request as LSPRequest;
+pub use ls_types::notification::Notification as LSPNotification;
 
 /// Errors that can occur when parsing a file URI.
 #[derive(Debug)]
@@ -64,21 +64,20 @@ pub fn parse_file_path(uri: &Url) -> Result<PathBuf, UrlFileParseError> {
 
 /// Create an edit for the given location and text.
 pub fn make_workspace_edit(location: Location, new_text: String) -> WorkspaceEdit {
-    let mut edit = WorkspaceEdit {
-        changes: HashMap::new(),
-    };
-
-    edit.changes.insert(
+    let changes = vec![(
         location.uri,
         vec![
             TextEdit {
                 range: location.range,
                 new_text,
             },
         ],
-    );
+    )].into_iter().collect();
 
-    edit
+    WorkspaceEdit {
+        changes: Some(changes),
+        document_changes: None,
+    }
 }
 
 /// Utilities for working with the language server protocol.
@@ -294,44 +293,14 @@ impl ClientCapabilities {
     }
 }
 
-/// A JSON language server protocol request that will have a matching response.
-#[derive(Debug, Serialize)]
-pub struct RequestMessage<T>
-where
-    T: Debug + Serialize,
-{
-    jsonrpc: &'static str,
-    /// The request id. The response will have a matching id.
-    pub id: u32,
-    /// The well-known language server protocol request method string.
-    pub method: String,
-    /// Extra request parameters.
-    pub params: T,
-}
-
-impl<T> RequestMessage<T>
-where
-    T: Debug + Serialize,
-{
-    /// Construct a new request.
-    pub fn new(id: u32, method: String, params: T) -> Self {
-        RequestMessage {
-            jsonrpc: "2.0",
-            id,
-            method: method,
-            params: params,
-        }
-    }
-}
-
 /* --------------- Custom JSON-RPC notifications -------------- */
 
 /// Custom LSP notification sent to client indicating that the server is currently
 /// processing data and may publish new diagnostics on `rustDocument/diagnosticsEnd`.
 #[derive(Debug)]
 pub enum DiagnosticsBegin { }
 
-impl notification::Notification for DiagnosticsBegin {
+impl LSPNotification for DiagnosticsBegin {
     type Params = ();
     const METHOD: &'static str = "rustDocument/diagnosticsBegin";
 }
@@ -344,7 +313,7 @@ impl notification::Notification for DiagnosticsBegin {
 #[derive(Debug)]
 pub enum DiagnosticsEnd { }
 
-impl notification::Notification for DiagnosticsEnd {
+impl LSPNotification for DiagnosticsEnd {
     type Params = ();
     const METHOD: &'static str = "rustDocument/diagnosticsEnd";
 }
@@ -353,7 +322,7 @@ impl notification::Notification for DiagnosticsEnd {
 #[derive(Debug)]
 pub enum BeginBuild { }
 
-impl notification::Notification for BeginBuild {
+impl LSPNotification for BeginBuild {
     type Params = ();
     const METHOD: &'static str = "rustDocument/beginBuild";
 }
@@ -364,9 +333,8 @@ impl notification::Notification for BeginBuild {
 #[derive(Debug)]
 pub enum FindImpls { }
 
-impl request::Request for FindImpls {
+impl LSPRequest for FindImpls {
     type Params = TextDocumentPositionParams;
     type Result = Vec<Location>;
     const METHOD: &'static str = "rustDocument/implementations";
 }
-

src/lsp_data.rs

@@ -14,7 +14,7 @@ use server;
 use server::{Request, Response};
 use server::io::Output;
 use actions::InitActionContext;
-use ls_types::request::Request as LSPRequest;
+use lsp_data::LSPRequest;
 use std::sync::mpsc;
 use std::thread;
 use std::time::Duration;

src/server/dispatch.rs

@@ -11,8 +11,8 @@
 use serde;
 use serde_json;
 
-use super::Notification;
-use ls_types::notification::Notification as LSPNotification;
+use super::{Notification, Request};
+use lsp_data::{LSPNotification, LSPRequest};
 
 use std::fmt;
 use std::io::{self, Read, Write};
@@ -145,13 +145,23 @@ pub trait Output: Sync + Send + Clone + 'static {
     }
 
     /// Send a notification along the output.
-    fn notify<A, P>(&self, notification: Notification<A>)
+    fn notify<A>(&self, notification: Notification<A>)
     where
-        A: LSPNotification<Params = P>,
-        P: serde::Serialize,
+        A: LSPNotification,
+        <A as LSPNotification>::Params: serde::Serialize,
     {
         self.response(format!("{}", notification));
     }
+
+    /// Send a one-shot request along the output.
+    /// Ignores any response associated with the request.
+    fn request<A>(&self, request: Request<A>)
+    where
+        A: LSPRequest,
+        <A as LSPRequest>::Params: serde::Serialize,
+    {
+        self.response(format!("{}", request));
+    }
 }
 
 /// An output that sends notifications and responses on `stdout`.