Filter out language servers which fail to spawn (#8374)

helix-lsp/src/lib.rs

@@ -749,36 +749,40 @@ impl Registry {
         }
     }
 
-    pub fn get(
+    pub fn get<'a>(
-        &mut self,
+        &'a mut self,
-        language_config: &LanguageConfiguration,
+        language_config: &'a LanguageConfiguration,
-        doc_path: Option<&std::path::PathBuf>,
+        doc_path: Option<&'a std::path::PathBuf>,
-        root_dirs: &[PathBuf],
+        root_dirs: &'a [PathBuf],
         enable_snippets: bool,
-    ) -> Result<HashMap<LanguageServerName, Arc<Client>>> {
+    ) -> impl Iterator<Item = (LanguageServerName, Result<Arc<Client>>)> + 'a {
-        language_config
+        language_config.language_servers.iter().map(
-            .language_servers
+            move |LanguageServerFeatures { name, .. }| {
-            .iter()
-            .map(|LanguageServerFeatures { name, .. }| {
                 if let Some(clients) = self.inner.get(name) {
                     if let Some((_, client)) = clients.iter().enumerate().find(|(i, client)| {
                         client.try_add_doc(&language_config.roots, root_dirs, doc_path, *i == 0)
                     }) {
-                        return Ok((name.to_owned(), client.clone()));
+                        return (name.to_owned(), Ok(client.clone()));
                     }
                 }
-                let client = self.start_client(
+                match self.start_client(
                     name.clone(),
                     language_config,
                     doc_path,
                     root_dirs,
                     enable_snippets,
-                )?;
+                ) {
-                let clients = self.inner.entry(name.clone()).or_default();
+                    Ok(client) => {
-                clients.push(client.clone());
+                        self.inner
-                Ok((name.clone(), client))
+                            .entry(name.to_owned())
-            })
+                            .or_default()
-            .collect()
+                            .push(client.clone());
+                        (name.clone(), Ok(client))
+                    }
+                    Err(err) => (name.to_owned(), Err(err)),
+                }
+            },
+        )
     }
 
     pub fn iter_clients(&self) -> impl Iterator<Item = &Arc<Client>> {

helix-view/src/editor.rs

@@ -1188,41 +1188,52 @@ impl Editor {
     }
 
     /// Refreshes the language server for a given document
-    pub fn refresh_language_servers(&mut self, doc_id: DocumentId) -> Option<()> {
+    pub fn refresh_language_servers(&mut self, doc_id: DocumentId) {
         self.launch_language_servers(doc_id)
     }
 
     /// Launch a language server for a given document
-    fn launch_language_servers(&mut self, doc_id: DocumentId) -> Option<()> {
+    fn launch_language_servers(&mut self, doc_id: DocumentId) {
         if !self.config().lsp.enable {
-            return None;
+            return;
         }
         // if doc doesn't have a URL it's a scratch buffer, ignore it
-        let doc = self.documents.get_mut(&doc_id)?;
+        let Some(doc) = self.documents.get_mut(&doc_id) else {
-        let doc_url = doc.url()?;
+            return;
+        };
+        let Some(doc_url) = doc.url() else {
+            return;
+        };
         let (lang, path) = (doc.language.clone(), doc.path().cloned());
         let config = doc.config.load();
         let root_dirs = &config.workspace_lsp_roots;
 
-        // try to find language servers based on the language name
+        // store only successfully started language servers
-        let language_servers = lang.as_ref().and_then(|language| {
+        let language_servers = lang.as_ref().map_or_else(HashMap::default, |language| {
             self.language_servers
                 .get(language, path.as_ref(), root_dirs, config.lsp.snippets)
-                .map_err(|e| {
+                .filter_map(|(lang, client)| match client {
+                    Ok(client) => Some((lang, client)),
+                    Err(err) => {
                         log::error!(
-                        "Failed to initialize the language servers for `{}` {{ {} }}",
+                            "Failed to initialize the language servers for `{}` - `{}` {{ {} }}",
                             language.scope(),
-                        e
+                            lang,
-                    )
+                            err
+                        );
+                        None
+                    }
                 })
-                .ok()
+                .collect::<HashMap<_, _>>()
         });
 
-        if let Some(language_servers) = language_servers {
+        if language_servers.is_empty() {
+            return;
+        }
+
         let language_id = doc.language_id().map(ToOwned::to_owned).unwrap_or_default();
 
         // only spawn new language servers if the servers aren't the same
-
         let doc_language_servers_not_in_registry =
             doc.language_servers.iter().filter(|(name, doc_ls)| {
                 language_servers
@@ -1252,8 +1263,6 @@ impl Editor {
 
         doc.language_servers = language_servers;
     }
-        Some(())
-    }
 
     fn _refresh(&mut self) {
         let config = self.config();
@@ -1454,7 +1463,7 @@ impl Editor {
             doc.set_version_control_head(self.diff_providers.get_current_head_name(&path));
 
             let id = self.new_document(doc);
-            let _ = self.launch_language_servers(id);
+            self.launch_language_servers(id);
 
             id
         };