Merge pull request #587 from alexheretic/more-nonblocking-requests

Add nonblocking Formatting, RangeFormatting, ResolveCompletion

Author: nrc

src/actions/requests.rs

@@ -764,21 +764,26 @@ impl Action for Formatting {
     const METHOD: &'static str = "textDocument/formatting";
 }
 
-impl<'a> BlockingRequestAction<'a> for Formatting {
+impl RequestAction for Formatting {
     type Response = [TextEdit; 1];
 
-    fn new(_: &'a mut LsState) -> Self {
+    fn new() -> Self {
         Formatting
     }
 
-    fn handle<O: Output>(
+    fn fallback_response(&self) -> Result<Self::Response, ResponseError> {
+        Err(ResponseError::Message(
+            ErrorCode::InternalError,
+            "Reformat failed to complete successfully".into(),
+        ))
+    }
+
+    fn handle(
         &mut self,
-        id: usize,
+        ctx: InitActionContext,
         params: Self::Params,
-        ctx: &mut ActionContext,
-        out: O,
-    ) -> Result<Self::Response, ()> {
-        reformat(id, params.text_document, None, &params.options, ctx, out)
+    ) -> Result<Self::Response, ResponseError> {
+        reformat(params.text_document, None, &params.options, ctx)
     }
 }
 
@@ -790,69 +795,64 @@ impl Action for RangeFormatting {
     const METHOD: &'static str = "textDocument/rangeFormatting";
 }
 
-impl<'a> BlockingRequestAction<'a> for RangeFormatting {
+impl RequestAction for RangeFormatting {
     type Response = [TextEdit; 1];
 
-    fn new(_: &'a mut LsState) -> Self {
+    fn new() -> Self {
         RangeFormatting
     }
 
-    fn handle<O: Output>(
+    fn fallback_response(&self) -> Result<Self::Response, ResponseError> {
+        Err(ResponseError::Message(
+            ErrorCode::InternalError,
+            "Reformat failed to complete successfully".into(),
+        ))
+    }
+
+    fn handle(
         &mut self,
-        id: usize,
+        ctx: InitActionContext,
         params: Self::Params,
-        ctx: &mut ActionContext,
-        out: O,
-    ) -> Result<Self::Response, ()> {
+    ) -> Result<Self::Response, ResponseError> {
         reformat(
-            id,
             params.text_document,
             Some(params.range),
             &params.options,
             ctx,
-            out,
         )
     }
 }
 
-fn reformat<O: Output>(
-    id: usize,
+fn reformat(
     doc: TextDocumentIdentifier,
     selection: Option<Range>,
     opts: &FormattingOptions,
-    ctx: &mut ActionContext,
-    out: O,
-) -> Result<[TextEdit; 1], ()> {
+    ctx: InitActionContext,
+) -> Result<[TextEdit; 1], ResponseError> {
     trace!(
-        "Reformat: {} {:?} {:?} {} {}",
-        id,
+        "Reformat: {:?} {:?} {} {}",
         doc,
         selection,
         opts.tab_size,
         opts.insert_spaces
     );
-    let ctx = ctx.inited();
     let path = parse_file_path!(&doc.uri, "reformat")?;
 
     let input = match ctx.vfs.load_file(&path) {
         Ok(FileContents::Text(s)) => FmtInput::Text(s),
         Ok(_) => {
             debug!("Reformat failed, found binary file");
-            out.failure_message(
-                id,
+            return Err(ResponseError::Message(
                 ErrorCode::InternalError,
-                "Reformat failed to complete successfully",
-            );
-            return Err(());
+                "Reformat failed to complete successfully".into(),
+            ));
         }
         Err(e) => {
             debug!("Reformat failed: {:?}", e);
-            out.failure_message(
-                id,
+            return Err(ResponseError::Message(
                 ErrorCode::InternalError,
-                "Reformat failed to complete successfully",
-            );
-            return Err(());
+                "Reformat failed to complete successfully".into(),
+            ));
         }
     };
 
@@ -900,22 +900,19 @@ fn reformat<O: Output>(
                     summary
                 );
 
-                out.failure_message(
-                    id,
+                return Err(ResponseError::Message(
                     ErrorCode::InternalError,
-                    "Reformat failed to complete successfully",
-                );
-                Err(())
+                    "Reformat failed to complete successfully".into(),
+                ));
             }
         }
         Err(e) => {
             debug!("Reformat failed: {:?}", e);
-            out.failure_message(
-                id,
+
+            return Err(ResponseError::Message(
                 ErrorCode::InternalError,
-                "Reformat failed to complete successfully",
-            );
-            Err(())
+                "Reformat failed to complete successfully".into(),
+            ));
         }
     }
 }
@@ -931,24 +928,26 @@ impl Action for ResolveCompletion {
     const METHOD: &'static str = "completionItem/resolve";
 }
 
-impl<'a> BlockingRequestAction<'a> for ResolveCompletion {
+impl RequestAction for ResolveCompletion {
     type Response = CompletionItem;
 
-    fn new(_: &'a mut LsState) -> Self {
+    fn new() -> Self {
         ResolveCompletion
     }
 
-    fn handle<O: Output>(
+    fn fallback_response(&self) -> Result<Self::Response, ResponseError> {
+        Err(ResponseError::Empty)
+    }
+
+    fn handle(
         &mut self,
-        _id: usize,
+        _: InitActionContext,
         params: Self::Params,
-        _ctx: &mut ActionContext,
-        _out: O,
-    ) -> Result<Self::Response, ()> {
+    ) -> Result<Self::Response, ResponseError> {
         // currently, we safely ignore this as a pass-through since we fully handle
         // textDocument/completion.  In the future, we may want to use this method as a
         // way to more lazily fill out completion information
-        Ok(params)
+        Ok(params.into())
     }
 }
 

src/server/dispatch.rs

@@ -76,7 +76,10 @@ define_dispatch_request_enum!(
     FindImpls,
     DocumentHighlight,
     Rename,
-    CodeAction
+    CodeAction,
+    ResolveCompletion,
+    Formatting,
+    RangeFormatting
 );
 
 /// Provides ability to dispatch requests to a worker thread that will
@@ -163,6 +166,7 @@ pub trait RequestAction: Action {
 }
 
 /// Wrapper for a response error
+#[derive(Debug)]
 pub enum ResponseError {
     /// Error with no special response to the client
     Empty,

src/server/mod.rs

@@ -501,11 +501,11 @@ impl<O: Output> LsService<O> {
             blocking_requests:
                 ShutdownRequest,
                 InitializeRequest,
-                requests::ResolveCompletion,
-                requests::ExecuteCommand,
-                requests::Formatting,
-                requests::RangeFormatting;
+                requests::ExecuteCommand;
             requests:
+                requests::Formatting,
+                requests::RangeFormatting,
+                requests::ResolveCompletion,
                 requests::Rename,
                 requests::CodeAction,
                 requests::DocumentHighlight,

src/test/mod.rs

@@ -552,7 +552,7 @@ fn test_reformat() {
     let text_doc = TextDocumentIdentifier::new(url);
     let messages = vec![
         initialize(0, root_path.as_os_str().to_str().map(|x| x.to_owned())).to_string(),
-        blocking_request::<requests::Formatting>(
+        request::<requests::Formatting>(
             42,
             DocumentFormattingParams {
                 text_document: text_doc,
@@ -600,7 +600,7 @@ fn test_reformat_with_range() {
     let text_doc = TextDocumentIdentifier::new(url);
     let messages = vec![
         initialize(0, root_path.as_os_str().to_str().map(|x| x.to_owned())).to_string(),
-        blocking_request::<requests::RangeFormatting>(
+        request::<requests::RangeFormatting>(
             42,
             DocumentRangeFormattingParams {
                 text_document: text_doc,