1use crate::{
2 CachedLspAdapter, Language, LanguageConfig, LanguageId, LanguageMatcher, LanguageServerName,
3 LspAdapter, LspAdapterDelegate, PARSER, PLAIN_TEXT,
4};
5use anyhow::{anyhow, Context as _, Result};
6use collections::{hash_map, HashMap};
7use futures::{
8 channel::{mpsc, oneshot},
9 future::Shared,
10 FutureExt as _, TryFutureExt as _,
11};
12use gpui::{AppContext, AsyncAppContext, BackgroundExecutor, Task};
13use lsp::{LanguageServerBinary, LanguageServerId};
14use parking_lot::{Mutex, RwLock};
15use postage::watch;
16use std::{
17 borrow::Cow,
18 ffi::OsStr,
19 ops::Not,
20 path::{Path, PathBuf},
21 sync::Arc,
22};
23use sum_tree::Bias;
24use text::{Point, Rope};
25use theme::Theme;
26use unicase::UniCase;
27use util::{paths::PathExt, post_inc, ResultExt, TryFutureExt as _, UnwrapFuture};
28
29pub struct LanguageRegistry {
30 state: RwLock<LanguageRegistryState>,
31 language_server_download_dir: Option<Arc<Path>>,
32 login_shell_env_loaded: Shared<Task<()>>,
33 #[allow(clippy::type_complexity)]
34 lsp_binary_paths: Mutex<
35 HashMap<LanguageServerName, Shared<Task<Result<LanguageServerBinary, Arc<anyhow::Error>>>>>,
36 >,
37 executor: Option<BackgroundExecutor>,
38 lsp_binary_status_tx: LspBinaryStatusSender,
39}
40
41struct LanguageRegistryState {
42 next_language_server_id: usize,
43 languages: Vec<Arc<Language>>,
44 available_languages: Vec<AvailableLanguage>,
45 grammars: HashMap<Arc<str>, AvailableGrammar>,
46 loading_languages: HashMap<LanguageId, Vec<oneshot::Sender<Result<Arc<Language>>>>>,
47 subscription: (watch::Sender<()>, watch::Receiver<()>),
48 theme: Option<Arc<Theme>>,
49 version: usize,
50 reload_count: usize,
51}
52
53#[derive(Clone)]
54pub enum LanguageServerBinaryStatus {
55 CheckingForUpdate,
56 Downloading,
57 Downloaded,
58 Cached,
59 Failed { error: String },
60}
61
62pub struct PendingLanguageServer {
63 pub server_id: LanguageServerId,
64 pub task: Task<Result<lsp::LanguageServer>>,
65 pub container_dir: Option<Arc<Path>>,
66}
67
68#[derive(Clone)]
69struct AvailableLanguage {
70 id: LanguageId,
71 name: Arc<str>,
72 grammar: Option<Arc<str>>,
73 matcher: LanguageMatcher,
74 load: Arc<dyn Fn() -> Result<(LanguageConfig, LanguageQueries)> + 'static + Send + Sync>,
75 lsp_adapters: Vec<Arc<dyn LspAdapter>>,
76 loaded: bool,
77}
78
79enum AvailableGrammar {
80 Native(tree_sitter::Language),
81 Loaded(PathBuf, tree_sitter::Language),
82 Loading(PathBuf, Vec<oneshot::Sender<Result<tree_sitter::Language>>>),
83 Unloaded(PathBuf),
84}
85
86pub const QUERY_FILENAME_PREFIXES: &[(
87 &str,
88 fn(&mut LanguageQueries) -> &mut Option<Cow<'static, str>>,
89)] = &[
90 ("highlights", |q| &mut q.highlights),
91 ("brackets", |q| &mut q.brackets),
92 ("outline", |q| &mut q.outline),
93 ("indents", |q| &mut q.indents),
94 ("embedding", |q| &mut q.embedding),
95 ("injections", |q| &mut q.injections),
96 ("overrides", |q| &mut q.overrides),
97 ("redactions", |q| &mut q.redactions),
98];
99
100/// Tree-sitter language queries for a given language.
101#[derive(Debug, Default)]
102pub struct LanguageQueries {
103 pub highlights: Option<Cow<'static, str>>,
104 pub brackets: Option<Cow<'static, str>>,
105 pub indents: Option<Cow<'static, str>>,
106 pub outline: Option<Cow<'static, str>>,
107 pub embedding: Option<Cow<'static, str>>,
108 pub injections: Option<Cow<'static, str>>,
109 pub overrides: Option<Cow<'static, str>>,
110 pub redactions: Option<Cow<'static, str>>,
111}
112
113#[derive(Clone, Default)]
114struct LspBinaryStatusSender {
115 txs: Arc<Mutex<Vec<mpsc::UnboundedSender<(Arc<Language>, LanguageServerBinaryStatus)>>>>,
116}
117
118impl LanguageRegistry {
119 pub fn new(login_shell_env_loaded: Task<()>) -> Self {
120 Self {
121 state: RwLock::new(LanguageRegistryState {
122 next_language_server_id: 0,
123 languages: vec![PLAIN_TEXT.clone()],
124 available_languages: Default::default(),
125 grammars: Default::default(),
126 loading_languages: Default::default(),
127 subscription: watch::channel(),
128 theme: Default::default(),
129 version: 0,
130 reload_count: 0,
131 }),
132 language_server_download_dir: None,
133 login_shell_env_loaded: login_shell_env_loaded.shared(),
134 lsp_binary_paths: Default::default(),
135 executor: None,
136 lsp_binary_status_tx: Default::default(),
137 }
138 }
139
140 #[cfg(any(test, feature = "test-support"))]
141 pub fn test() -> Self {
142 Self::new(Task::ready(()))
143 }
144
145 pub fn set_executor(&mut self, executor: BackgroundExecutor) {
146 self.executor = Some(executor);
147 }
148
149 /// Clears out all of the loaded languages and reload them from scratch.
150 pub fn reload(&self) {
151 self.state.write().reload();
152 }
153
154 /// Removes the specified languages and grammars from the registry.
155 pub fn remove_languages(
156 &self,
157 languages_to_remove: &[Arc<str>],
158 grammars_to_remove: &[Arc<str>],
159 ) {
160 self.state
161 .write()
162 .remove_languages(languages_to_remove, grammars_to_remove)
163 }
164
165 #[cfg(any(feature = "test-support", test))]
166 pub fn register_test_language(&self, config: LanguageConfig) {
167 self.register_language(
168 config.name.clone(),
169 config.grammar.clone(),
170 config.matcher.clone(),
171 vec![],
172 move || Ok((config.clone(), Default::default())),
173 )
174 }
175
176 /// Adds a language to the registry, which can be loaded if needed.
177 pub fn register_language(
178 &self,
179 name: Arc<str>,
180 grammar_name: Option<Arc<str>>,
181 matcher: LanguageMatcher,
182 lsp_adapters: Vec<Arc<dyn LspAdapter>>,
183 load: impl Fn() -> Result<(LanguageConfig, LanguageQueries)> + 'static + Send + Sync,
184 ) {
185 let load = Arc::new(load);
186 let state = &mut *self.state.write();
187
188 for existing_language in &mut state.available_languages {
189 if existing_language.name == name {
190 existing_language.grammar = grammar_name;
191 existing_language.matcher = matcher;
192 existing_language.lsp_adapters = lsp_adapters;
193 existing_language.load = load;
194 return;
195 }
196 }
197
198 state.available_languages.push(AvailableLanguage {
199 id: LanguageId::new(),
200 name,
201 grammar: grammar_name,
202 matcher,
203 load,
204 lsp_adapters,
205 loaded: false,
206 });
207 state.version += 1;
208 state.reload_count += 1;
209 *state.subscription.0.borrow_mut() = ();
210 }
211
212 /// Adds grammars to the registry. Language configurations reference a grammar by name. The
213 /// grammar controls how the source code is parsed.
214 pub fn register_native_grammars(
215 &self,
216 grammars: impl IntoIterator<Item = (impl Into<Arc<str>>, tree_sitter::Language)>,
217 ) {
218 self.state.write().grammars.extend(
219 grammars
220 .into_iter()
221 .map(|(name, grammar)| (name.into(), AvailableGrammar::Native(grammar))),
222 );
223 }
224
225 /// Adds paths to WASM grammar files, which can be loaded if needed.
226 pub fn register_wasm_grammars(
227 &self,
228 grammars: impl IntoIterator<Item = (impl Into<Arc<str>>, PathBuf)>,
229 ) {
230 let mut state = self.state.write();
231 state.grammars.extend(
232 grammars
233 .into_iter()
234 .map(|(name, path)| (name.into(), AvailableGrammar::Unloaded(path))),
235 );
236 state.version += 1;
237 state.reload_count += 1;
238 *state.subscription.0.borrow_mut() = ();
239 }
240
241 pub fn language_names(&self) -> Vec<String> {
242 let state = self.state.read();
243 let mut result = state
244 .available_languages
245 .iter()
246 .filter_map(|l| l.loaded.not().then_some(l.name.to_string()))
247 .chain(state.languages.iter().map(|l| l.config.name.to_string()))
248 .collect::<Vec<_>>();
249 result.sort_unstable_by_key(|language_name| language_name.to_lowercase());
250 result
251 }
252
253 pub fn grammar_names(&self) -> Vec<Arc<str>> {
254 let state = self.state.read();
255 let mut result = state.grammars.keys().cloned().collect::<Vec<_>>();
256 result.sort_unstable_by_key(|grammar_name| grammar_name.to_lowercase());
257 result
258 }
259
260 pub fn add(&self, language: Arc<Language>) {
261 self.state.write().add(language);
262 }
263
264 pub fn subscribe(&self) -> watch::Receiver<()> {
265 self.state.read().subscription.1.clone()
266 }
267
268 /// Returns the number of times that the registry has been changed,
269 /// by adding languages or reloading.
270 pub fn version(&self) -> usize {
271 self.state.read().version
272 }
273
274 /// Returns the number of times that the registry has been reloaded.
275 pub fn reload_count(&self) -> usize {
276 self.state.read().reload_count
277 }
278
279 pub fn set_theme(&self, theme: Arc<Theme>) {
280 let mut state = self.state.write();
281 state.theme = Some(theme.clone());
282 for language in &state.languages {
283 language.set_theme(theme.syntax());
284 }
285 }
286
287 pub fn set_language_server_download_dir(&mut self, path: impl Into<Arc<Path>>) {
288 self.language_server_download_dir = Some(path.into());
289 }
290
291 pub fn language_for_name(
292 self: &Arc<Self>,
293 name: &str,
294 ) -> UnwrapFuture<oneshot::Receiver<Result<Arc<Language>>>> {
295 let name = UniCase::new(name);
296 self.get_or_load_language(|language_name, _| UniCase::new(language_name) == name)
297 }
298
299 pub fn language_for_name_or_extension(
300 self: &Arc<Self>,
301 string: &str,
302 ) -> UnwrapFuture<oneshot::Receiver<Result<Arc<Language>>>> {
303 let string = UniCase::new(string);
304 self.get_or_load_language(|name, config| {
305 UniCase::new(name) == string
306 || config
307 .path_suffixes
308 .iter()
309 .any(|suffix| UniCase::new(suffix) == string)
310 })
311 }
312
313 pub fn language_for_file(
314 self: &Arc<Self>,
315 path: impl AsRef<Path>,
316 content: Option<&Rope>,
317 ) -> UnwrapFuture<oneshot::Receiver<Result<Arc<Language>>>> {
318 let path = path.as_ref();
319 let filename = path.file_name().and_then(|name| name.to_str());
320 let extension = path.extension_or_hidden_file_name();
321 let path_suffixes = [extension, filename];
322 self.get_or_load_language(|_, config| {
323 let path_matches = config
324 .path_suffixes
325 .iter()
326 .any(|suffix| path_suffixes.contains(&Some(suffix.as_str())));
327 let content_matches = content.zip(config.first_line_pattern.as_ref()).map_or(
328 false,
329 |(content, pattern)| {
330 let end = content.clip_point(Point::new(0, 256), Bias::Left);
331 let end = content.point_to_offset(end);
332 let text = content.chunks_in_range(0..end).collect::<String>();
333 pattern.is_match(&text)
334 },
335 );
336 path_matches || content_matches
337 })
338 }
339
340 fn get_or_load_language(
341 self: &Arc<Self>,
342 callback: impl Fn(&str, &LanguageMatcher) -> bool,
343 ) -> UnwrapFuture<oneshot::Receiver<Result<Arc<Language>>>> {
344 let (tx, rx) = oneshot::channel();
345
346 let mut state = self.state.write();
347 if let Some(language) = state
348 .languages
349 .iter()
350 .find(|language| callback(language.config.name.as_ref(), &language.config.matcher))
351 {
352 let _ = tx.send(Ok(language.clone()));
353 } else if let Some(executor) = self.executor.clone() {
354 if let Some(language) = state
355 .available_languages
356 .iter()
357 .rfind(|l| !l.loaded && callback(&l.name, &l.matcher))
358 .cloned()
359 {
360 match state.loading_languages.entry(language.id) {
361 hash_map::Entry::Occupied(mut entry) => entry.get_mut().push(tx),
362 hash_map::Entry::Vacant(entry) => {
363 let this = self.clone();
364 executor
365 .spawn(async move {
366 let id = language.id;
367 let name = language.name.clone();
368 let language = async {
369 let (config, queries) = (language.load)()?;
370
371 let grammar = if let Some(grammar) = config.grammar.clone() {
372 Some(this.get_or_load_grammar(grammar).await?)
373 } else {
374 None
375 };
376
377 Language::new_with_id(id, config, grammar)
378 .with_lsp_adapters(language.lsp_adapters)
379 .await
380 .with_queries(queries)
381 }
382 .await;
383
384 match language {
385 Ok(language) => {
386 let language = Arc::new(language);
387 let mut state = this.state.write();
388
389 state.add(language.clone());
390 state.mark_language_loaded(id);
391 if let Some(mut txs) = state.loading_languages.remove(&id) {
392 for tx in txs.drain(..) {
393 let _ = tx.send(Ok(language.clone()));
394 }
395 }
396 }
397 Err(e) => {
398 log::error!("failed to load language {name}:\n{:?}", e);
399 let mut state = this.state.write();
400 state.mark_language_loaded(id);
401 if let Some(mut txs) = state.loading_languages.remove(&id) {
402 for tx in txs.drain(..) {
403 let _ = tx.send(Err(anyhow!(
404 "failed to load language {}: {}",
405 name,
406 e
407 )));
408 }
409 }
410 }
411 };
412 })
413 .detach();
414 entry.insert(vec![tx]);
415 }
416 }
417 } else {
418 let _ = tx.send(Err(anyhow!("language not found")));
419 }
420 } else {
421 let _ = tx.send(Err(anyhow!("executor does not exist")));
422 }
423
424 rx.unwrap()
425 }
426
427 fn get_or_load_grammar(
428 self: &Arc<Self>,
429 name: Arc<str>,
430 ) -> UnwrapFuture<oneshot::Receiver<Result<tree_sitter::Language>>> {
431 let (tx, rx) = oneshot::channel();
432 let mut state = self.state.write();
433
434 if let Some(grammar) = state.grammars.get_mut(name.as_ref()) {
435 match grammar {
436 AvailableGrammar::Native(grammar) | AvailableGrammar::Loaded(_, grammar) => {
437 tx.send(Ok(grammar.clone())).ok();
438 }
439 AvailableGrammar::Loading(_, txs) => {
440 txs.push(tx);
441 }
442 AvailableGrammar::Unloaded(wasm_path) => {
443 if let Some(executor) = &self.executor {
444 let this = self.clone();
445 executor
446 .spawn({
447 let wasm_path = wasm_path.clone();
448 async move {
449 let wasm_bytes = std::fs::read(&wasm_path)?;
450 let grammar_name = wasm_path
451 .file_stem()
452 .and_then(OsStr::to_str)
453 .ok_or_else(|| anyhow!("invalid grammar filename"))?;
454 let grammar = PARSER.with(|parser| {
455 let mut parser = parser.borrow_mut();
456 let mut store = parser.take_wasm_store().unwrap();
457 let grammar =
458 store.load_language(&grammar_name, &wasm_bytes);
459 parser.set_wasm_store(store).unwrap();
460 grammar
461 })?;
462
463 if let Some(AvailableGrammar::Loading(_, txs)) =
464 this.state.write().grammars.insert(
465 name,
466 AvailableGrammar::Loaded(wasm_path, grammar.clone()),
467 )
468 {
469 for tx in txs {
470 tx.send(Ok(grammar.clone())).ok();
471 }
472 }
473
474 anyhow::Ok(())
475 }
476 })
477 .detach();
478 *grammar = AvailableGrammar::Loading(wasm_path.clone(), vec![tx]);
479 }
480 }
481 }
482 } else {
483 tx.send(Err(anyhow!("no such grammar {}", name))).ok();
484 }
485
486 rx.unwrap()
487 }
488
489 pub fn to_vec(&self) -> Vec<Arc<Language>> {
490 self.state.read().languages.iter().cloned().collect()
491 }
492
493 pub fn create_pending_language_server(
494 self: &Arc<Self>,
495 stderr_capture: Arc<Mutex<Option<String>>>,
496 language: Arc<Language>,
497 adapter: Arc<CachedLspAdapter>,
498 root_path: Arc<Path>,
499 delegate: Arc<dyn LspAdapterDelegate>,
500 cx: &mut AppContext,
501 ) -> Option<PendingLanguageServer> {
502 let server_id = self.state.write().next_language_server_id();
503 log::info!(
504 "starting language server {:?}, path: {root_path:?}, id: {server_id}",
505 adapter.name.0
506 );
507
508 #[cfg(any(test, feature = "test-support"))]
509 if language.fake_adapter.is_some() {
510 let task = cx.spawn(|cx| async move {
511 let (servers_tx, fake_adapter) = language.fake_adapter.as_ref().unwrap();
512 let (server, mut fake_server) = lsp::FakeLanguageServer::new(
513 fake_adapter.name.to_string(),
514 fake_adapter.capabilities.clone(),
515 cx.clone(),
516 );
517
518 if let Some(initializer) = &fake_adapter.initializer {
519 initializer(&mut fake_server);
520 }
521
522 let servers_tx = servers_tx.clone();
523 cx.background_executor()
524 .spawn(async move {
525 if fake_server
526 .try_receive_notification::<lsp::notification::Initialized>()
527 .await
528 .is_some()
529 {
530 servers_tx.unbounded_send(fake_server).ok();
531 }
532 })
533 .detach();
534
535 Ok(server)
536 });
537
538 return Some(PendingLanguageServer {
539 server_id,
540 task,
541 container_dir: None,
542 });
543 }
544
545 let download_dir = self
546 .language_server_download_dir
547 .clone()
548 .ok_or_else(|| anyhow!("language server download directory has not been assigned before starting server"))
549 .log_err()?;
550 let this = self.clone();
551 let language = language.clone();
552 let container_dir: Arc<Path> = Arc::from(download_dir.join(adapter.name.0.as_ref()));
553 let root_path = root_path.clone();
554 let adapter = adapter.clone();
555 let login_shell_env_loaded = self.login_shell_env_loaded.clone();
556 let lsp_binary_statuses = self.lsp_binary_status_tx.clone();
557
558 let task = {
559 let container_dir = container_dir.clone();
560 cx.spawn(move |mut cx| async move {
561 login_shell_env_loaded.await;
562
563 let entry = this
564 .lsp_binary_paths
565 .lock()
566 .entry(adapter.name.clone())
567 .or_insert_with(|| {
568 let adapter = adapter.clone();
569 let language = language.clone();
570 let delegate = delegate.clone();
571 cx.spawn(|cx| {
572 get_binary(
573 adapter,
574 language,
575 delegate,
576 container_dir,
577 lsp_binary_statuses,
578 cx,
579 )
580 .map_err(Arc::new)
581 })
582 .shared()
583 })
584 .clone();
585
586 let binary = match entry.await {
587 Ok(binary) => binary,
588 Err(err) => anyhow::bail!("{err}"),
589 };
590
591 if let Some(task) = adapter.will_start_server(&delegate, &mut cx) {
592 task.await?;
593 }
594
595 lsp::LanguageServer::new(
596 stderr_capture,
597 server_id,
598 binary,
599 &root_path,
600 adapter.code_action_kinds(),
601 cx,
602 )
603 })
604 };
605
606 Some(PendingLanguageServer {
607 server_id,
608 task,
609 container_dir: Some(container_dir),
610 })
611 }
612
613 pub fn language_server_binary_statuses(
614 &self,
615 ) -> mpsc::UnboundedReceiver<(Arc<Language>, LanguageServerBinaryStatus)> {
616 self.lsp_binary_status_tx.subscribe()
617 }
618
619 pub fn delete_server_container(
620 &self,
621 adapter: Arc<CachedLspAdapter>,
622 cx: &mut AppContext,
623 ) -> Task<()> {
624 log::info!("deleting server container");
625
626 let mut lock = self.lsp_binary_paths.lock();
627 lock.remove(&adapter.name);
628
629 let download_dir = self
630 .language_server_download_dir
631 .clone()
632 .expect("language server download directory has not been assigned before deleting server container");
633
634 cx.spawn(|_| async move {
635 let container_dir = download_dir.join(adapter.name.0.as_ref());
636 smol::fs::remove_dir_all(container_dir)
637 .await
638 .context("server container removal")
639 .log_err();
640 })
641 }
642
643 pub fn next_language_server_id(&self) -> LanguageServerId {
644 self.state.write().next_language_server_id()
645 }
646}
647
648#[cfg(any(test, feature = "test-support"))]
649impl Default for LanguageRegistry {
650 fn default() -> Self {
651 Self::test()
652 }
653}
654
655impl LanguageRegistryState {
656 fn next_language_server_id(&mut self) -> LanguageServerId {
657 LanguageServerId(post_inc(&mut self.next_language_server_id))
658 }
659
660 fn add(&mut self, language: Arc<Language>) {
661 if let Some(theme) = self.theme.as_ref() {
662 language.set_theme(theme.syntax());
663 }
664 self.languages.push(language);
665 self.version += 1;
666 *self.subscription.0.borrow_mut() = ();
667 }
668
669 fn reload(&mut self) {
670 self.languages.clear();
671 self.version += 1;
672 self.reload_count += 1;
673 for language in &mut self.available_languages {
674 language.loaded = false;
675 }
676 *self.subscription.0.borrow_mut() = ();
677 }
678
679 fn remove_languages(
680 &mut self,
681 languages_to_remove: &[Arc<str>],
682 grammars_to_remove: &[Arc<str>],
683 ) {
684 if languages_to_remove.is_empty() && grammars_to_remove.is_empty() {
685 return;
686 }
687
688 self.languages
689 .retain(|language| !languages_to_remove.contains(&language.name()));
690 self.available_languages
691 .retain(|language| !languages_to_remove.contains(&language.name));
692 self.grammars
693 .retain(|name, _| !grammars_to_remove.contains(&name));
694 self.version += 1;
695 self.reload_count += 1;
696 *self.subscription.0.borrow_mut() = ();
697 }
698
699 /// Mark the given language as having been loaded, so that the
700 /// language registry won't try to load it again.
701 fn mark_language_loaded(&mut self, id: LanguageId) {
702 for language in &mut self.available_languages {
703 if language.id == id {
704 language.loaded = true;
705 break;
706 }
707 }
708 }
709}
710
711impl LspBinaryStatusSender {
712 fn subscribe(&self) -> mpsc::UnboundedReceiver<(Arc<Language>, LanguageServerBinaryStatus)> {
713 let (tx, rx) = mpsc::unbounded();
714 self.txs.lock().push(tx);
715 rx
716 }
717
718 fn send(&self, language: Arc<Language>, status: LanguageServerBinaryStatus) {
719 let mut txs = self.txs.lock();
720 txs.retain(|tx| {
721 tx.unbounded_send((language.clone(), status.clone()))
722 .is_ok()
723 });
724 }
725}
726
727async fn get_binary(
728 adapter: Arc<CachedLspAdapter>,
729 language: Arc<Language>,
730 delegate: Arc<dyn LspAdapterDelegate>,
731 container_dir: Arc<Path>,
732 statuses: LspBinaryStatusSender,
733 mut cx: AsyncAppContext,
734) -> Result<LanguageServerBinary> {
735 if !container_dir.exists() {
736 smol::fs::create_dir_all(&container_dir)
737 .await
738 .context("failed to create container directory")?;
739 }
740
741 if let Some(task) = adapter.will_fetch_server(&delegate, &mut cx) {
742 task.await?;
743 }
744
745 let binary = fetch_latest_binary(
746 adapter.clone(),
747 language.clone(),
748 delegate.as_ref(),
749 &container_dir,
750 statuses.clone(),
751 )
752 .await;
753
754 if let Err(error) = binary.as_ref() {
755 if let Some(binary) = adapter
756 .cached_server_binary(container_dir.to_path_buf(), delegate.as_ref())
757 .await
758 {
759 statuses.send(language.clone(), LanguageServerBinaryStatus::Cached);
760 return Ok(binary);
761 } else {
762 statuses.send(
763 language.clone(),
764 LanguageServerBinaryStatus::Failed {
765 error: format!("{:?}", error),
766 },
767 );
768 }
769 }
770
771 binary
772}
773
774async fn fetch_latest_binary(
775 adapter: Arc<CachedLspAdapter>,
776 language: Arc<Language>,
777 delegate: &dyn LspAdapterDelegate,
778 container_dir: &Path,
779 lsp_binary_statuses_tx: LspBinaryStatusSender,
780) -> Result<LanguageServerBinary> {
781 let container_dir: Arc<Path> = container_dir.into();
782 lsp_binary_statuses_tx.send(
783 language.clone(),
784 LanguageServerBinaryStatus::CheckingForUpdate,
785 );
786
787 let version_info = adapter.fetch_latest_server_version(delegate).await?;
788 lsp_binary_statuses_tx.send(language.clone(), LanguageServerBinaryStatus::Downloading);
789
790 let binary = adapter
791 .fetch_server_binary(version_info, container_dir.to_path_buf(), delegate)
792 .await?;
793 lsp_binary_statuses_tx.send(language.clone(), LanguageServerBinaryStatus::Downloaded);
794
795 Ok(binary)
796}