add enable_extensions config and set up gopls extensions (#1072)

Author: martskins

doc/LanguageClient.txt

@@ -569,8 +569,9 @@ Example setting 3. Set the preferred markup kind to `markdown`
 
   ```
   let g:LanguageClient_preferredMarkupKind: ['markdown']
+  ```
 
-This setting may have no effect of the server decides not to honour it.
+This setting may have no effect if the server decides not to honour it.
 
 Default: v:null
 Valid options: Array<String>
@@ -603,6 +604,31 @@ Full path to languageclient binary.
 Default: 'bin/languageclient' relative to plugin root.
 Valid options: String
 
+2.39 g:LanguageClient_enableExtensions          *g:LanguageClient_enableExtensions*
+
+LanguageClient-neovim provides extensions for some language servers, such as gopls or rust-analyzer.
+These extensions can be turned on or off, and they are configurable per language (not per language
+server).
+
+An example of the extensions provided is running Rust or Go tests in a vim terminal. This takes
+advantage of the commands provided by rust-analyzer or gopls (respectively) and executes those
+commands in a vim terminal.
+
+Example config:
+  ```
+  let g:LanguageClient_enableExtensions = {
+    \ 'go': v:false,
+    \ 'rust': v:true,
+    \ }
+  ```
+In this example we explicitly disable extensions for the filetype `go`, and enable them for `rust`.
+Filetypes not included in this config will also have their extensions disabled, unless you
+explicitly enable them like we did for `rust`.
+
+The default value for this config, or the absence of this config, enables extensions for all filetypes.
+
+Default: v:null
+
 ==============================================================================
 3. Commands                                           *LanguageClientCommands*
 

src/extensions/gopls.rs

@@ -0,0 +1,89 @@
+use crate::language_client::LanguageClient;
+use anyhow::Result;
+use lsp_types::Command;
+use serde::Deserialize;
+use serde_json::Value;
+
+pub mod command {
+    pub const TEST: &str = "test";
+    pub const GENERATE: &str = "generate";
+}
+
+impl LanguageClient {
+    pub fn handle_gopls_command(&self, cmd: &Command) -> Result<bool> {
+        match cmd.command.as_str() {
+            command::TEST => {
+                if let Some(args) = &cmd.arguments {
+                    if let Some(file) = args.get(0) {
+                        let file = String::deserialize(file)?;
+                        let path = parse_package_path(file.as_str()).unwrap_or("./...".into());
+                        let run = <Option<Vec<String>>>::deserialize(
+                            args.get(1).unwrap_or(&Value::Null),
+                        )?;
+
+                        let bench = <Option<Vec<String>>>::deserialize(
+                            args.get(2).unwrap_or(&Value::Null),
+                        )?;
+
+                        let run = run.unwrap_or_default();
+                        let bench = bench.unwrap_or_default();
+
+                        if run.len() > 0 {
+                            let cmd = format!("term go test -run '{}' {}", run.join("|"), path);
+                            self.vim()?.command(cmd)?;
+                        } else if bench.len() > 0 {
+                            let cmd = format!("term go test -bench '{}' {}", bench.join("|"), path);
+                            self.vim()?.command(cmd)?;
+                        } else {
+                            self.vim()?.echoerr("No tests to run")?;
+                        }
+                    }
+                }
+            }
+            command::GENERATE => {
+                if let Some(arguments) = &cmd.arguments {
+                    if let Some(package) = arguments.get(0) {
+                        let package = String::deserialize(package)?;
+                        let recursive =
+                            bool::deserialize(arguments.get(1).unwrap_or(&Value::Bool(false)))?;
+                        let cmd = match (package, recursive) {
+                            (package, false) => format!("term go generate -x {}", package),
+                            (_, true) => "term go generate -x ./...".into(),
+                        };
+                        self.vim()?.command(cmd)?;
+                    }
+                }
+            }
+
+            _ => return Ok(false),
+        }
+
+        Ok(true)
+    }
+}
+
+fn parse_package_path(path: &str) -> Option<String> {
+    let path = if path.starts_with("file://") {
+        path.strip_prefix("file://")?
+    } else {
+        path
+    };
+    let path = std::path::PathBuf::from(path);
+    Some(path.parent()?.to_str()?.to_owned())
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_parse_package_path() {
+        let folder = parse_package_path("file:///home/dev/someone/project/file.go");
+        assert!(folder.is_some());
+        assert_eq!("/home/dev/someone/project", folder.unwrap());
+
+        let folder = parse_package_path("/home/dev/someone/project/file.go");
+        assert!(folder.is_some());
+        assert_eq!("/home/dev/someone/project", folder.unwrap());
+    }
+}

src/extensions/mod.rs

@@ -1,2 +1,3 @@
+pub mod gopls;
 pub mod java;
 pub mod rust_analyzer;

src/language_server_protocol.rs

@@ -1,4 +1,4 @@
-use crate::extensions::{java, rust_analyzer};
+use crate::extensions::java;
 use crate::language_client::LanguageClient;
 use crate::vim::{try_get, Mode};
 use crate::{
@@ -177,6 +177,7 @@ impl LanguageClient {
             apply_completion_text_edits,
             preferred_markup_kind,
             hide_virtual_texts_on_insert,
+            enable_extensions,
         ): (
             Option<usize>,
             String,
@@ -190,6 +191,7 @@ impl LanguageClient {
             u8,
             Option<Vec<MarkupKind>>,
             u8,
+            Option<HashMap<String, bool>>,
         ) = self.vim()?.eval(
             [
                 "get(g:, 'LanguageClient_diagnosticsSignsMax', v:null)",
@@ -204,6 +206,7 @@ impl LanguageClient {
                 "get(g:, 'LanguageClient_applyCompletionAdditionalTextEdits', 1)",
                 "get(g:, 'LanguageClient_preferredMarkupKind', v:null)",
                 "s:GetVar('LanguageClient_hideVirtualTextsOnInsert', 0)",
+                "get(g:, 'LanguageClient_enableExtensions', v:null)",
             ]
             .as_ref(),
         )?;
@@ -320,6 +323,7 @@ impl LanguageClient {
             state.server_stderr = server_stderr;
             state.is_nvim = is_nvim;
             state.preferred_markup_kind = preferred_markup_kind;
+            state.enable_extensions = enable_extensions;
             Ok(())
         })?;
 
@@ -1017,15 +1021,32 @@ impl LanguageClient {
     }
 
     fn try_handle_command_by_client(&self, cmd: &Command) -> Result<bool> {
-        match cmd.command.as_str() {
-            java::command::APPLY_WORKSPACE_EDIT => self.handle_java_command(cmd),
-            rust_analyzer::command::RUN
-            | rust_analyzer::command::RUN_SINGLE
-            | rust_analyzer::command::SHOW_REFERENCES
-            | rust_analyzer::command::SELECT_APPLY_SOURCE_CHANGE
-            | rust_analyzer::command::APPLY_SOURCE_CHANGE => self.handle_rust_analyzer_command(cmd),
-
-            _ => Ok(false),
+        let filetype: String = self.vim()?.eval("&filetype")?;
+        let enabled_extensions = self.get(|state| state.enable_extensions.clone())?;
+        if !enabled_extensions
+            .unwrap_or_default()
+            .get(&filetype)
+            .cloned()
+            .unwrap_or(true)
+        {
+            return Ok(false);
+        }
+
+        let capabilities = self.get(|state| state.capabilities.get(&filetype).cloned())?;
+        let server_name = capabilities
+            .unwrap_or_default()
+            .server_info
+            .unwrap_or_default()
+            .name;
+
+        match server_name.as_str() {
+            "gopls" => self.handle_gopls_command(cmd),
+            "rust-analyzer" => self.handle_rust_analyzer_command(cmd),
+            _ => match cmd.command.as_str() {
+                // not sure which name java's language server advertises
+                java::command::APPLY_WORKSPACE_EDIT => self.handle_java_command(cmd),
+                _ => Ok(false),
+            },
         }
     }
 
@@ -1247,10 +1268,11 @@ impl LanguageClient {
             },
         )?;
 
+        let initialize_result = InitializeResult::deserialize(&result)?;
         self.update(|state| {
             state
                 .capabilities
-                .insert(language_id.clone(), result.clone());
+                .insert(language_id.clone(), initialize_result);
             Ok(())
         })?;
 
@@ -2122,9 +2144,7 @@ impl LanguageClient {
         if let Some(initialize_result) = capabilities.get(&language_id) {
             // XXX: the capabilities state field stores the initialize result, not the capabilities
             // themselves, so we need to deserialize to InitializeResult.
-            let initialize_result: InitializeResult =
-                serde_json::from_value(initialize_result.clone())?;
-            let capabilities = initialize_result.capabilities;
+            let capabilities = initialize_result.capabilities.clone();
 
             if let Some(code_lens_provider) = capabilities.code_lens_provider {
                 info!("Begin {}", lsp_types::request::CodeLensRequest::METHOD);

src/types.rs

@@ -13,8 +13,8 @@ use log::*;
 use lsp_types::{
     CodeAction, CodeLens, Command, CompletionItem, CompletionTextEdit, Diagnostic,
     DiagnosticSeverity, DocumentHighlightKind, FileChangeType, FileEvent, Hover, HoverContents,
-    InsertTextFormat, Location, MarkedString, MarkupContent, MarkupKind, MessageType,
-    NumberOrString, Registration, SemanticHighlightingInformation, SymbolInformation,
+    InitializeResult, InsertTextFormat, Location, MarkedString, MarkupContent, MarkupKind,
+    MessageType, NumberOrString, Registration, SemanticHighlightingInformation, SymbolInformation,
     TextDocumentItem, TextDocumentPositionParams, TraceOption, Url, WorkspaceEdit,
 };
 use maplit::hashmap;
@@ -146,7 +146,7 @@ pub struct State {
     #[serde(skip_serializing)]
     pub vim: Vim,
 
-    pub capabilities: HashMap<String, Value>,
+    pub capabilities: HashMap<String, InitializeResult>,
     pub registrations: Vec<Registration>,
     pub roots: HashMap<String, String>,
     pub text_documents: HashMap<String, TextDocumentItem>,
@@ -209,6 +209,7 @@ pub struct State {
     pub use_virtual_text: UseVirtualText,
     pub hide_virtual_texts_on_insert: bool,
     pub echo_project_root: bool,
+    pub enable_extensions: Option<HashMap<String, bool>>,
 
     pub server_stderr: Option<String>,
     pub logger: Logger,
@@ -292,6 +293,7 @@ impl State {
             echo_project_root: true,
             server_stderr: None,
             preferred_markup_kind: None,
+            enable_extensions: None,
 
             logger,
         })