080a085 · helix · git.iko.soy

git.iko.soy/helix

on master help sign in

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

080a085woojiq3 years ago

helix-lsp/src/lib.rs+22−18

compare with master

unifiedsplit

@@ -749,36 +749,40 @@ impl Registry {

749 }

750 }

751

752− pub fn get(

752+ pub fn get<'a>(

753− &mut self,

753+ &'a mut self,

754− language_config: &LanguageConfiguration,

754+ language_config: &'a LanguageConfiguration,

755− doc_path: Option<&std::path::PathBuf>,

755+ doc_path: Option<&'a std::path::PathBuf>,

756− root_dirs: &[PathBuf],

756+ root_dirs: &'a [PathBuf],

757 enable_snippets: bool,

758− ) -> Result<HashMap<LanguageServerName, Arc<Client>>> {

758+ ) -> impl Iterator<Item = (LanguageServerName, Result<Arc<Client>>)> + 'a {

759− language_config

760− .language_servers

759+ language_config.language_servers.iter().map(

761− .iter()

762− .map(|LanguageServerFeatures { name, .. }| {

760+ move |LanguageServerFeatures { name, .. }| {

763 if let Some(clients) = self.inner.get(name) {

761 if let Some(clients) = self.inner.get(name) {

764 if let Some((_, client)) = clients.iter().enumerate().find(|(i, client)| {

762 if let Some((_, client)) = clients.iter().enumerate().find(|(i, client)| {

765 client.try_add_doc(&language_config.roots, root_dirs, doc_path, *i == 0)

763 client.try_add_doc(&language_config.roots, root_dirs, doc_path, *i == 0)

766 }) {

764 }) {

767− return Ok((name.to_owned(), client.clone()));

765+ return (name.to_owned(), Ok(client.clone()));

768 }

766 }

769 }

767 }

770− let client = self.start_client(

768+ match self.start_client(

771 name.clone(),

769 name.clone(),

772 language_config,

770 language_config,

773 doc_path,

771 doc_path,

774 root_dirs,

772 root_dirs,

775 enable_snippets,

773 enable_snippets,

776− )?;

774+ ) {

777− let clients = self.inner.entry(name.clone()).or_default();

775+ Ok(client) => {

776+ self.inner

777+ .entry(name.to_owned())

778+ .or_default()

778− clients.push(client.clone());

779+ .push(client.clone());

779− Ok((name.clone(), client))

780+ (name.clone(), Ok(client))

780− })

781+ }

781− .collect()

782+ Err(err) => (name.to_owned(), Err(err)),

783+ }

784+ },

785+ )

782 }

786 }

783

787

784 pub fn iter_clients(&self) -> impl Iterator<Item = &Arc<Client>> {

788 pub fn iter_clients(&self) -> impl Iterator<Item = &Arc<Client>> {

helix-view/src/editor.rs+52−43

@@ -1188,71 +1188,80 @@ impl Editor {

1188 }

1189

1190 /// Refreshes the language server for a given document

1191− pub fn refresh_language_servers(&mut self, doc_id: DocumentId) -> Option<()> {

1191+ pub fn refresh_language_servers(&mut self, doc_id: DocumentId) {

1192 self.launch_language_servers(doc_id)

1193 }

1194

1195 /// Launch a language server for a given document

1196− fn launch_language_servers(&mut self, doc_id: DocumentId) -> Option<()> {

1196+ fn launch_language_servers(&mut self, doc_id: DocumentId) {

1197 if !self.config().lsp.enable {

1198− return None;

1198+ return;

1199 }

1200 // if doc doesn't have a URL it's a scratch buffer, ignore it

1201− let doc = self.documents.get_mut(&doc_id)?;

1201+ let Some(doc) = self.documents.get_mut(&doc_id) else {

1202+ return;

1203+ };

1202− let doc_url = doc.url()?;

1204+ let Some(doc_url) = doc.url() else {

1205+ return;

1206+ };

1203 let (lang, path) = (doc.language.clone(), doc.path().cloned());

1207 let (lang, path) = (doc.language.clone(), doc.path().cloned());

1204 let config = doc.config.load();

1208 let config = doc.config.load();

1205 let root_dirs = &config.workspace_lsp_roots;

1209 let root_dirs = &config.workspace_lsp_roots;

1206

1210

1207− // try to find language servers based on the language name

1211+ // store only successfully started language servers

1208− let language_servers = lang.as_ref().and_then(|language| {

1212+ let language_servers = lang.as_ref().map_or_else(HashMap::default, |language| {

1209 self.language_servers

1213 self.language_servers

1210 .get(language, path.as_ref(), root_dirs, config.lsp.snippets)

1214 .get(language, path.as_ref(), root_dirs, config.lsp.snippets)

1211− .map_err(|e| {

1215+ .filter_map(|(lang, client)| match client {

1216+ Ok(client) => Some((lang, client)),

1217+ Err(err) => {

1212− log::error!(

1218+ log::error!(

1213− "Failed to initialize the language servers for `{}` {{ {} }}",

1219+ "Failed to initialize the language servers for `{}` - `{}` {{ {} }}",

1214− language.scope(),

1220+ language.scope(),

1215− e

1221+ lang,

1216− )

1222+ err

1223+ );

1224+ None

1225+ }

1217 })

1226 })

1218− .ok()

1227+ .collect::<HashMap<_, _>>()

1219 });

1228 });

1220

1229

1221− if let Some(language_servers) = language_servers {

1230+ if language_servers.is_empty() {

1222− let language_id = doc.language_id().map(ToOwned::to_owned).unwrap_or_default();

1231+ return;

1223−

1224− // only spawn new language servers if the servers aren't the same

1225−

1226− let doc_language_servers_not_in_registry =

1227− doc.language_servers.iter().filter(|(name, doc_ls)| {

1228− language_servers

1229− .get(*name)

1230− .map_or(true, |ls| ls.id() != doc_ls.id())

1231− });

1232+ }

1232

1233

1233− for (_, language_server) in doc_language_servers_not_in_registry {

1234+ let language_id = doc.language_id().map(ToOwned::to_owned).unwrap_or_default();

1234− tokio::spawn(language_server.text_document_did_close(doc.identifier()));

1235− }

1236

1235

1236+ // only spawn new language servers if the servers aren't the same

1237+ let doc_language_servers_not_in_registry =

1237− let language_servers_not_in_doc = language_servers.iter().filter(|(name, ls)| {

1238+ doc.language_servers.iter().filter(|(name, doc_ls)| {

1238− doc.language_servers

1239+ language_servers

1239 .get(*name)

1240 .get(*name)

1240− .map_or(true, |doc_ls| ls.id() != doc_ls.id())

1241+ .map_or(true, |ls| ls.id() != doc_ls.id())

1241 });

1242 });

1242

1243

1243− for (_, language_server) in language_servers_not_in_doc {

1244+ for (_, language_server) in doc_language_servers_not_in_registry {

1244− // TODO: this now races with on_init code if the init happens too quickly

1245− tokio::spawn(language_server.text_document_did_open(

1245+ tokio::spawn(language_server.text_document_did_close(doc.identifier()));

1246− doc_url.clone(),

1246+ }

1247− doc.version(),

1247+

1248− doc.text(),

1248+ let language_servers_not_in_doc = language_servers.iter().filter(|(name, ls)| {

1249− language_id.clone(),

1249+ doc.language_servers

1250− ));

1250+ .get(*name)

1251+ .map_or(true, |doc_ls| ls.id() != doc_ls.id())

1251− }

1252+ });

1252

1253

1253− doc.language_servers = language_servers;

1254+ for (_, language_server) in language_servers_not_in_doc {

1255+ // TODO: this now races with on_init code if the init happens too quickly

1256+ tokio::spawn(language_server.text_document_did_open(

1257+ doc_url.clone(),

1258+ doc.version(),

1259+ doc.text(),

1260+ language_id.clone(),

1261+ ));

1254 }

1262 }

1255− Some(())

1263+

1264+ doc.language_servers = language_servers;

1256 }

1265 }

1257

1266

1258 fn _refresh(&mut self) {

1267 fn _refresh(&mut self) {

@@ -1454,7 +1463,7 @@ impl Editor {

1454 doc.set_version_control_head(self.diff_providers.get_current_head_name(&path));

1463 doc.set_version_control_head(self.diff_providers.get_current_head_name(&path));

1455

1464

1456 let id = self.new_document(doc);

1465 let id = self.new_document(doc);

1457− let _ = self.launch_language_servers(id);

1466+ self.launch_language_servers(id);

1458

1467

1459 id

1468 id

1460 };

1469 };