Add support to specify server name and initialization options in server command (#1116)

* Add support to specify server name to send the correct initializationOptions

* Clippy fixes

* Remove unnecessary dev dependency

* Log instead of error if using `initializationOptions` in workspace settings

* Fall back to default if no workspace settings are found

* Merge all server's intialization options in under State::initialization_options

* Simplify merged_initialization_options

Author: martskins

doc/LanguageClient.txt

@@ -75,25 +75,64 @@ To use the language server with Vim's formatting operator |gq|, set 'formatexpr'
 
 2.1 g:LanguageClient_serverCommands          *g:LanguageClient_serverCommands*
 
-String to list map. Defines commands to start language server for specific
-filetype. For example: >
+Dictionary to specify the servers to be used for each filetype. The keys are
+strings representing the filetypes and the values are either
+  1 - a list of strings that form a command
+  2 - a dictionary with keys name, command and initializationOptions, where:
+    - name: is the name of the server, which should match the root node of the
+      configuration options specified in the settings.json file for this server
+    - command: is the same list of strings in option 1
+    - initializationOptions: is an optional dictionary with options to be passed
+      to the server. The values to be set here are highly dependent on each
+      server so you should see the documentation for each server to find out
+      what to configure in here (if anything).  The options set in
+      initializationOptions are merged with the default settings for each
+      language server and with the workspace settings defined by the user in
+      the files specified in the variable `LanguageClient_settingsPath'. The
+      order in which these settings are merged is first the defualt settings,
+      then the server settings configured in this section and lastly the
+      contents of the files in the `LanguageClient_settingsPath` variable in
+      the order in which they were listed.
+
+For example: >
 
     let g:LanguageClient_serverCommands = {
         \ 'rust': ['rustup', 'run', 'stable', 'rls'],
-        \ }
-
-In the example above, 'run', 'stable', and 'rls' are arguments to the
-'rustup' command line tool.
-
-Or tcp connection string to the server, >
+        \ 'go': {
+        \   'name': 'gopls',
+        \   'command': ['gopls'],
+        \   'initializationOptions': {
+        \     'usePlaceholders': v:true,
+        \     'codelens': {
+        \       'generate': v:true,
+        \       'test': v:true,
+        \     },
+        \   },
+        \ },
+        \}
+
+In the configuration for the rust filetype above, 'run', 'stable', and 'rls'
+are arguments to the 'rustup' command line tool. And in the configuration for
+the go filetype the server is configured to run the command `gopls` with no
+additional arguments, and with the initialization options set in the
+`initializationOptions` key.
+
+You can also use a tcp connection to the server, for example: >
     let g:LanguageClient_serverCommands = {
         \ 'javascript': ['tcp://127.0.0.1:2089'],
         \ }
 
 Note: environmental variables are not supported except home directory alias `~`.
 
 Default: {}
-Valid Option: Map<String, List<String> | String>
+
+
+
+Valid Option: Map<String, List<String> | {
+    name: String
+    command: List<String>
+    initializationOptions?: Map<String, Any>
+  }>
 
 2.2 g:LanguageClient_diagnosticsDisplay  *g:LanguageClient_diagnosticsDisplay*
 
@@ -231,9 +270,34 @@ path this is relative to the workspace directory. If several paths are
 provided, then the corresponding settings are merged with precedence going to
 the last file.
 
+The initialization options found in the files in this config are combined with
+the initialization options specified in the server command, if any. The former
+taking precedence over the latter.
+
+Note that the key under which the initialization options for each server lives
+matches the key under which the server expects it's configuration. This is
+important for servers that can request configuration via a
+`workspace/configuration` request.
+
+Previously, the initialization options lived under a `initializationOptions`
+key, which worked, but made answering that `workspace/configuration` request
+hard, since we couldn't really get the correct path to the setting the server
+requested. Since version 0.1.161 of this plugin, that key has been deprecated
+and you'll see a message saying that you should move off of it if your settings
+file includes an `initializationOptions` key.
+
 Example settings file content: >
     {
-        "rust.clippy_preference": "on"
+        "gopls": {
+          "usePlaceholders": true,
+          "local": "github.com/my/pkg",
+        },
+        "rust-analyzer": {
+          "inlayHints": {
+            "enable": true,
+            "chainingHints": true
+          },
+        },
     }
 
 Default: ".vim/settings.json"

src/config.rs src/config/mod.rs

@@ -1,3 +1,7 @@
+mod server_command;
+
+pub use server_command::*;
+
 use crate::{
     types::{
         CodeLensDisplay, DiagnosticsDisplay, DiagnosticsList, DocumentHighlightDisplay,
@@ -14,7 +18,7 @@ use std::{path::PathBuf, str::FromStr, time::Duration};
 #[derive(Debug)]
 pub struct Config {
     pub auto_start: bool,
-    pub server_commands: HashMap<String, Vec<String>>,
+    pub server_commands: HashMap<String, ServerCommand>,
     pub selection_ui: SelectionUI,
     pub trace: TraceOption,
     pub settings_path: Vec<String>,
@@ -98,7 +102,7 @@ struct DeserializableConfig {
     logging_level: log::LevelFilter,
     server_stderr: Option<String>,
     auto_start: u8,
-    server_commands: HashMap<String, Vec<String>>,
+    server_commands: HashMap<String, ServerCommand>,
     selection_ui: Option<String>,
     trace: Option<String>,
     settings_path: Vec<String>,

src/config/server_command.rs

@@ -0,0 +1,83 @@
+use crate::utils::expand_json_path;
+use jsonrpc_core::Value;
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ServerDetails {
+    pub command: Vec<String>,
+    pub name: String,
+    pub initialization_options: Option<Value>,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum ServerCommand {
+    Simple(Vec<String>),
+    Detailed(ServerDetails),
+}
+
+impl ServerCommand {
+    pub fn get_command(&self) -> &[String] {
+        match self {
+            ServerCommand::Simple(cmd) => &cmd,
+            ServerCommand::Detailed(cmd) => &cmd.command,
+        }
+    }
+
+    /// Returns the server name from a ServerCommand. For compatibility purposes, this
+    /// makes a rather wild assumption when the server name hasn't been explicitly
+    /// configured. The assumption is that the command for this server is an
+    /// executable and that the name of the executable is the name of the server.
+    /// This may not be true for many cases, but it's the best we can do to try and
+    /// guess the name of the server.
+    pub fn name(&self) -> String {
+        match self {
+            ServerCommand::Simple(cmd) => ServerCommand::name_from_command(&cmd),
+            ServerCommand::Detailed(cmd) => cmd.name.clone(),
+        }
+    }
+
+    pub fn initialization_options(&self) -> Value {
+        match self {
+            ServerCommand::Simple(_) => Value::Null,
+            ServerCommand::Detailed(cmd) => {
+                let options = cmd.initialization_options.clone();
+                expand_json_path(options.unwrap_or_default())
+            }
+        }
+    }
+
+    #[cfg(not(target_os = "windows"))]
+    fn name_from_command(cmd: &[String]) -> String {
+        // it's safe to assume there is at least one item in cmd, otherwise
+        // this would be an empty server command
+        let first = cmd.first().cloned().unwrap_or_default();
+        first.split('/').last().unwrap_or_default().to_string()
+    }
+
+    #[cfg(target_os = "windows")]
+    fn name_from_command(cmd: &[String]) -> String {
+        // it's safe to assume there is at least one item in cmd, otherwise
+        // this would be an empty server command
+        let first = cmd.first().cloned().unwrap_or_default();
+        first.split('\\').last().unwrap_or_default().to_string()
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_name_from_command_handles_binary_name() {
+        let name = ServerCommand::name_from_command(&vec!["gopls".into()]);
+        assert_eq!(name.as_str(), "gopls");
+    }
+
+    #[test]
+    fn test_name_from_command_handles_binary_path() {
+        let name = ServerCommand::name_from_command(&vec!["/path/to/gopls".into()]);
+        assert_eq!(name.as_str(), "gopls");
+    }
+}

src/extensions/rust_analyzer.rs

@@ -94,8 +94,8 @@ pub mod request {
     }
 }
 
-const FILETYPE: &'static str = "rust";
-pub const SERVER_NAME: &'static str = "rust-analyzer";
+const FILETYPE: &str = "rust";
+pub const SERVER_NAME: &str = "rust-analyzer";
 
 impl LanguageClient {
     pub fn rust_analyzer_inlay_hints(&self, filename: &str) -> Result<Vec<types::InlayHint>> {

src/language_client.rs

@@ -22,9 +22,9 @@ pub struct LanguageClient {
 }
 
 impl LanguageClient {
-    pub fn new(version: String, state: State) -> Self {
+    pub fn new(version: impl Into<String>, state: State) -> Self {
         LanguageClient {
-            version,
+            version: version.into(),
             state_mutex: Arc::new(Mutex::new(state)),
             clients_mutex: Arc::new(Mutex::new(HashMap::new())),
             config: Arc::new(RwLock::new(Config::default())),