Add support to specifiy server name to send the correct initializationOptions

Author: martskins

Diff for: autoload/LanguageClient.vim

@@ -81,6 +81,20 @@ function! s:Echowarn(message) abort
     echohl WarningMsg | echomsg s:AddPrefix(a:message) | echohl None
 endfunction
 
+function! s:ShowAlert(name, lines) abort
+    execute 'silent! pedit! +setlocal\\ ' .
+            \ 'buftype=nofile\\ nobuflisted\\ ' .
+            \ 'noswapfile\\ nonumber\\ ' .
+            \ 'filetype=help' . ' ' . a:name
+
+    if has('nvim')
+        let l:bufid = bufnr(a:name)
+        call nvim_buf_set_lines(l:bufid, 0, -1, 0, a:lines)
+    else
+        " call setbufline(a:name, 1, a:lines)
+    endif
+endfunction
+
 " timeout: skip function call f until this timeout, in seconds.
 function! s:Debounce(timeout, f) abort
     " Map function to its last execute time.

Diff for: src/language_server_protocol.rs

@@ -126,7 +126,7 @@ impl LanguageClient {
             is_nvim,
         ): (
             u64,
-            HashMap<String, Vec<String>>,
+            HashMap<String, ServerCommand>,
             Option<String>,
             Option<String>,
             Vec<String>,
@@ -295,7 +295,7 @@ impl LanguageClient {
             state.semantic_highlight_maps = semantic_highlight_maps;
             state.semantic_scope_separator = semantic_scope_separator;
             state.semantic_scope_to_hl_group_table.clear();
-            state.server_commands.extend(server_commands);
+            state.server_commands = server_commands;
             state.selection_ui = selection_ui;
             state.selection_ui_auto_open = selection_ui_auto_open;
             state.trace = trace;
@@ -1136,6 +1136,42 @@ impl LanguageClient {
         }
     }
 
+    fn get_server_initialization_options_for_language_id(
+        &self,
+        root: &str,
+        language_id: &str,
+    ) -> Result<Option<Value>> {
+        let server_name = self.server_name_for_language_id(&language_id)?;
+        let settings = self.get_workspace_settings(&root)?;
+        // warn the user that they are using a deprecated workspace settings
+        // file format and direct them to the documentation about the new one
+        if settings.pointer("/initializationOptions").is_some() {
+            let lines = vec![
+		"You seem to be using an incorrect workspace settings format for LanguageClient-neovim, to learn more about this error see `:help g:LanguageClient_settingsPath`",
+	    ];
+            self.vim()?
+                .rpcclient
+                .notify("s:ShowAlert", json!(["__LanguageClient__", lines]))?;
+        }
+
+        let section = format!("/{}", server_name);
+        let initialization_options = settings.pointer(section.as_str()).unwrap_or(&Value::Null);
+        let initialization_options =
+            get_default_initialization_options(&language_id).combine(&initialization_options);
+
+        if initialization_options.is_null() {
+            Ok(None)
+        } else {
+            Ok(Some(initialization_options))
+        }
+    }
+
+    pub fn server_name_for_language_id(&self, language_id: &str) -> Result<String> {
+        let server_commands = self.get(|state| state.server_commands.clone())?;
+        let server_command = server_commands.get(language_id).unwrap();
+        Ok(server_command.get_server_name())
+    }
+
     /////// LSP ///////
 
     fn initialize(&self, params: &Value) -> Result<Value> {
@@ -1147,23 +1183,12 @@ impl LanguageClient {
         let has_snippet_support = has_snippet_support > 0;
         let root = self.get(|state| state.roots.get(&language_id).cloned().unwrap_or_default())?;
 
-        let initialization_options = self
-            .get_workspace_settings(&root)
-            .map(|s| s["initializationOptions"].clone())
-            .unwrap_or_else(|err| {
-                warn!("Failed to get initializationOptions: {}", err);
-                json!(Value::Null)
-            });
-        let initialization_options =
-            get_default_initialization_options(&language_id).combine(&initialization_options);
-        let initialization_options = if initialization_options.is_null() {
-            None
-        } else {
-            Some(initialization_options)
-        };
-
         let trace = self.get(|state| state.trace)?;
         let preferred_markup_kind = self.get(|state| state.preferred_markup_kind.clone())?;
+        let initialization_options = self.get_server_initialization_options_for_language_id(
+            root.as_str(),
+            language_id.as_str(),
+        )?;
 
         let result: Value = self.get_client(&Some(language_id.clone()))?.call(
             lsp_types::request::Initialize::METHOD,
@@ -2923,7 +2948,7 @@ impl LanguageClient {
 
     pub fn register_server_commands(&self, params: &Value) -> Result<Value> {
         info!("Begin {}", REQUEST_REGISTER_SERVER_COMMANDS);
-        let commands = HashMap::<String, Vec<String>>::deserialize(params)?;
+        let commands = HashMap::<String, ServerCommand>::deserialize(params)?;
         self.update(|state| {
             state.server_commands.extend(commands);
             Ok(())
@@ -3892,6 +3917,7 @@ impl LanguageClient {
                     language_id: language_id.clone(),
                 })
             })?;
+        let command = command.get_command();
 
         let root_path: Option<String> = try_get("rootPath", &params)?;
         let root = if let Some(r) = root_path {
@@ -3995,16 +4021,6 @@ impl LanguageClient {
         self.initialize(&params)?;
         self.initialized(&params)?;
 
-        let root = self.get(|state| state.roots.get(&language_id).cloned().unwrap_or_default())?;
-        match self.get_workspace_settings(&root) {
-            Ok(Value::Null) => (),
-            Ok(settings) => self.workspace_did_change_configuration(&json!({
-                "languageId": language_id,
-                "settings": settings,
-            }))?,
-            Err(err) => warn!("Failed to get workspace settings: {}", err),
-        }
-
         self.vim()?
             .rpcclient
             .notify("setbufvar", json!([filename, VIM_IS_SERVER_RUNNING, 1]))?;

Diff for: src/types.rs

@@ -134,6 +134,50 @@ pub enum UseVirtualText {
     No,
 }
 
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct CommandWithMeta {
+    pub command: Vec<String>,
+    pub server_name: Option<String>,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum ServerCommand {
+    Command(Vec<String>),
+    CommandWithMeta(CommandWithMeta),
+}
+
+impl ServerCommand {
+    pub fn get_command(&self) -> &[String] {
+        match self {
+            ServerCommand::Command(cmd) => &cmd,
+            ServerCommand::CommandWithMeta(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 get_server_name(&self) -> String {
+        match self {
+            ServerCommand::Command(cmd) => ServerCommand::name_from_command(&cmd),
+            ServerCommand::CommandWithMeta(cmd) => {
+                let server_name = cmd.server_name.clone();
+                server_name.unwrap_or_else(|| ServerCommand::name_from_command(&cmd.command))
+            }
+        }
+    }
+
+    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
+        cmd.first().cloned().unwrap_or_default()
+    }
+}
+
 #[derive(Serialize)]
 pub struct State {
     // Program state.
@@ -183,7 +227,7 @@ pub struct State {
     pub stashed_code_action_actions: Vec<CodeAction>,
 
     // User settings.
-    pub server_commands: HashMap<String, Vec<String>>,
+    pub server_commands: HashMap<String, ServerCommand>,
     // languageId => (scope_regex => highlight group)
     pub semantic_highlight_maps: HashMap<String, HashMap<String, String>>,
     pub semantic_scope_separator: String,