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 Future, 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};
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(#[allow(dead_code)] 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 ) -> impl Future<Output = Result<Arc<Language>>> {
295 let name = UniCase::new(name);
296 let rx = self.get_or_load_language(|language_name, _| UniCase::new(language_name) == name);
297 async move { rx.await? }
298 }
299
300 pub fn language_for_name_or_extension(
301 self: &Arc<Self>,
302 string: &str,
303 ) -> impl Future<Output = Result<Arc<Language>>> {
304 let string = UniCase::new(string);
305 let rx = self.get_or_load_language(|name, config| {
306 UniCase::new(name) == string
307 || config
308 .path_suffixes
309 .iter()
310 .any(|suffix| UniCase::new(suffix) == string)
311 });
312 async move { rx.await? }
313 }
314
315 pub fn language_for_file(
316 self: &Arc<Self>,
317 path: &Path,
318 content: Option<&Rope>,
319 ) -> impl Future<Output = Result<Arc<Language>>> {
320 let filename = path.file_name().and_then(|name| name.to_str());
321 let extension = path.extension_or_hidden_file_name();
322 let path_suffixes = [extension, filename];
323 let rx = self.get_or_load_language(move |_, config| {
324 let path_matches = config
325 .path_suffixes
326 .iter()
327 .any(|suffix| path_suffixes.contains(&Some(suffix.as_str())));
328 let content_matches = content.zip(config.first_line_pattern.as_ref()).map_or(
329 false,
330 |(content, pattern)| {
331 let end = content.clip_point(Point::new(0, 256), Bias::Left);
332 let end = content.point_to_offset(end);
333 let text = content.chunks_in_range(0..end).collect::<String>();
334 pattern.is_match(&text)
335 },
336 );
337 path_matches || content_matches
338 });
339 async move { rx.await? }
340 }
341
342 fn get_or_load_language(
343 self: &Arc<Self>,
344 callback: impl Fn(&str, &LanguageMatcher) -> bool,
345 ) -> oneshot::Receiver<Result<Arc<Language>>> {
346 let (tx, rx) = oneshot::channel();
347
348 let mut state = self.state.write();
349 if let Some(language) = state
350 .languages
351 .iter()
352 .find(|language| callback(language.config.name.as_ref(), &language.config.matcher))
353 {
354 let _ = tx.send(Ok(language.clone()));
355 } else if let Some(executor) = self.executor.clone() {
356 if let Some(language) = state
357 .available_languages
358 .iter()
359 .rfind(|l| !l.loaded && callback(&l.name, &l.matcher))
360 .cloned()
361 {
362 match state.loading_languages.entry(language.id) {
363 hash_map::Entry::Occupied(mut entry) => entry.get_mut().push(tx),
364 hash_map::Entry::Vacant(entry) => {
365 let this = self.clone();
366 executor
367 .spawn(async move {
368 let id = language.id;
369 let name = language.name.clone();
370 let language = async {
371 let (config, queries) = (language.load)()?;
372
373 let grammar = if let Some(grammar) = config.grammar.clone() {
374 Some(this.get_or_load_grammar(grammar).await?)
375 } else {
376 None
377 };
378
379 Language::new_with_id(id, config, grammar)
380 .with_lsp_adapters(language.lsp_adapters)
381 .await
382 .with_queries(queries)
383 }
384 .await;
385
386 match language {
387 Ok(language) => {
388 let language = Arc::new(language);
389 let mut state = this.state.write();
390
391 state.add(language.clone());
392 state.mark_language_loaded(id);
393 if let Some(mut txs) = state.loading_languages.remove(&id) {
394 for tx in txs.drain(..) {
395 let _ = tx.send(Ok(language.clone()));
396 }
397 }
398 }
399 Err(e) => {
400 log::error!("failed to load language {name}:\n{:?}", e);
401 let mut state = this.state.write();
402 state.mark_language_loaded(id);
403 if let Some(mut txs) = state.loading_languages.remove(&id) {
404 for tx in txs.drain(..) {
405 let _ = tx.send(Err(anyhow!(
406 "failed to load language {}: {}",
407 name,
408 e
409 )));
410 }
411 }
412 }
413 };
414 })
415 .detach();
416 entry.insert(vec![tx]);
417 }
418 }
419 } else {
420 let _ = tx.send(Err(anyhow!("language not found")));
421 }
422 } else {
423 let _ = tx.send(Err(anyhow!("executor does not exist")));
424 }
425
426 rx
427 }
428
429 fn get_or_load_grammar(
430 self: &Arc<Self>,
431 name: Arc<str>,
432 ) -> impl Future<Output = Result<tree_sitter::Language>> {
433 let (tx, rx) = oneshot::channel();
434 let mut state = self.state.write();
435
436 if let Some(grammar) = state.grammars.get_mut(name.as_ref()) {
437 match grammar {
438 AvailableGrammar::Native(grammar) | AvailableGrammar::Loaded(_, grammar) => {
439 tx.send(Ok(grammar.clone())).ok();
440 }
441 AvailableGrammar::Loading(_, txs) => {
442 txs.push(tx);
443 }
444 AvailableGrammar::Unloaded(wasm_path) => {
445 if let Some(executor) = &self.executor {
446 let this = self.clone();
447 executor
448 .spawn({
449 let wasm_path = wasm_path.clone();
450 async move {
451 let wasm_bytes = std::fs::read(&wasm_path)?;
452 let grammar_name = wasm_path
453 .file_stem()
454 .and_then(OsStr::to_str)
455 .ok_or_else(|| anyhow!("invalid grammar filename"))?;
456 let grammar = PARSER.with(|parser| {
457 let mut parser = parser.borrow_mut();
458 let mut store = parser.take_wasm_store().unwrap();
459 let grammar =
460 store.load_language(&grammar_name, &wasm_bytes);
461 parser.set_wasm_store(store).unwrap();
462 grammar
463 })?;
464
465 if let Some(AvailableGrammar::Loading(_, txs)) =
466 this.state.write().grammars.insert(
467 name,
468 AvailableGrammar::Loaded(wasm_path, grammar.clone()),
469 )
470 {
471 for tx in txs {
472 tx.send(Ok(grammar.clone())).ok();
473 }
474 }
475
476 anyhow::Ok(())
477 }
478 })
479 .detach();
480 *grammar = AvailableGrammar::Loading(wasm_path.clone(), vec![tx]);
481 }
482 }
483 }
484 } else {
485 tx.send(Err(anyhow!("no such grammar {}", name))).ok();
486 }
487
488 async move { rx.await? }
489 }
490
491 pub fn to_vec(&self) -> Vec<Arc<Language>> {
492 self.state.read().languages.iter().cloned().collect()
493 }
494
495 pub fn create_pending_language_server(
496 self: &Arc<Self>,
497 stderr_capture: Arc<Mutex<Option<String>>>,
498 language: Arc<Language>,
499 adapter: Arc<CachedLspAdapter>,
500 root_path: Arc<Path>,
501 delegate: Arc<dyn LspAdapterDelegate>,
502 cx: &mut AppContext,
503 ) -> Option<PendingLanguageServer> {
504 let server_id = self.state.write().next_language_server_id();
505 log::info!(
506 "starting language server {:?}, path: {root_path:?}, id: {server_id}",
507 adapter.name.0
508 );
509
510 #[cfg(any(test, feature = "test-support"))]
511 if language.fake_adapter.is_some() {
512 let task = cx.spawn(|cx| async move {
513 let (servers_tx, fake_adapter) = language.fake_adapter.as_ref().unwrap();
514 let (server, mut fake_server) = lsp::FakeLanguageServer::new(
515 fake_adapter.name.to_string(),
516 fake_adapter.capabilities.clone(),
517 cx.clone(),
518 );
519
520 if let Some(initializer) = &fake_adapter.initializer {
521 initializer(&mut fake_server);
522 }
523
524 let servers_tx = servers_tx.clone();
525 cx.background_executor()
526 .spawn(async move {
527 if fake_server
528 .try_receive_notification::<lsp::notification::Initialized>()
529 .await
530 .is_some()
531 {
532 servers_tx.unbounded_send(fake_server).ok();
533 }
534 })
535 .detach();
536
537 Ok(server)
538 });
539
540 return Some(PendingLanguageServer {
541 server_id,
542 task,
543 container_dir: None,
544 });
545 }
546
547 let download_dir = self
548 .language_server_download_dir
549 .clone()
550 .ok_or_else(|| anyhow!("language server download directory has not been assigned before starting server"))
551 .log_err()?;
552 let this = self.clone();
553 let language = language.clone();
554 let container_dir: Arc<Path> = Arc::from(download_dir.join(adapter.name.0.as_ref()));
555 let root_path = root_path.clone();
556 let adapter = adapter.clone();
557 let login_shell_env_loaded = self.login_shell_env_loaded.clone();
558 let lsp_binary_statuses = self.lsp_binary_status_tx.clone();
559
560 let task = {
561 let container_dir = container_dir.clone();
562 cx.spawn(move |mut cx| async move {
563 // First we check whether the adapter can give us a user-installed binary.
564 // If so, we do *not* want to cache that, because each worktree might give us a different
565 // binary:
566 //
567 // worktree 1: user-installed at `.bin/gopls`
568 // worktree 2: user-installed at `~/bin/gopls`
569 // worktree 3: no gopls found in PATH -> fallback to Zed installation
570 //
571 // We only want to cache when we fall back to the global one,
572 // because we don't want to download and overwrite our global one
573 // for each worktree we might have open.
574
575 let user_binary_task = check_user_installed_binary(
576 adapter.clone(),
577 language.clone(),
578 delegate.clone(),
579 &mut cx,
580 );
581 let binary = if let Some(user_binary) = user_binary_task.await {
582 user_binary
583 } else {
584 // If we want to install a binary globally, we need to wait for
585 // the login shell to be set on our process.
586 login_shell_env_loaded.await;
587
588 get_or_install_binary(
589 this,
590 &adapter,
591 language,
592 &delegate,
593 &cx,
594 container_dir,
595 lsp_binary_statuses,
596 )
597 .await?
598 };
599
600 if let Some(task) = adapter.will_start_server(&delegate, &mut cx) {
601 task.await?;
602 }
603
604 lsp::LanguageServer::new(
605 stderr_capture,
606 server_id,
607 binary,
608 &root_path,
609 adapter.code_action_kinds(),
610 cx,
611 )
612 })
613 };
614
615 Some(PendingLanguageServer {
616 server_id,
617 task,
618 container_dir: Some(container_dir),
619 })
620 }
621
622 pub fn language_server_binary_statuses(
623 &self,
624 ) -> mpsc::UnboundedReceiver<(Arc<Language>, LanguageServerBinaryStatus)> {
625 self.lsp_binary_status_tx.subscribe()
626 }
627
628 pub fn delete_server_container(
629 &self,
630 adapter: Arc<CachedLspAdapter>,
631 cx: &mut AppContext,
632 ) -> Task<()> {
633 log::info!("deleting server container");
634
635 let mut lock = self.lsp_binary_paths.lock();
636 lock.remove(&adapter.name);
637
638 let download_dir = self
639 .language_server_download_dir
640 .clone()
641 .expect("language server download directory has not been assigned before deleting server container");
642
643 cx.spawn(|_| async move {
644 let container_dir = download_dir.join(adapter.name.0.as_ref());
645 smol::fs::remove_dir_all(container_dir)
646 .await
647 .context("server container removal")
648 .log_err();
649 })
650 }
651
652 pub fn next_language_server_id(&self) -> LanguageServerId {
653 self.state.write().next_language_server_id()
654 }
655}
656
657#[cfg(any(test, feature = "test-support"))]
658impl Default for LanguageRegistry {
659 fn default() -> Self {
660 Self::test()
661 }
662}
663
664impl LanguageRegistryState {
665 fn next_language_server_id(&mut self) -> LanguageServerId {
666 LanguageServerId(post_inc(&mut self.next_language_server_id))
667 }
668
669 fn add(&mut self, language: Arc<Language>) {
670 if let Some(theme) = self.theme.as_ref() {
671 language.set_theme(theme.syntax());
672 }
673 self.languages.push(language);
674 self.version += 1;
675 *self.subscription.0.borrow_mut() = ();
676 }
677
678 fn reload(&mut self) {
679 self.languages.clear();
680 self.version += 1;
681 self.reload_count += 1;
682 for language in &mut self.available_languages {
683 language.loaded = false;
684 }
685 *self.subscription.0.borrow_mut() = ();
686 }
687
688 fn remove_languages(
689 &mut self,
690 languages_to_remove: &[Arc<str>],
691 grammars_to_remove: &[Arc<str>],
692 ) {
693 if languages_to_remove.is_empty() && grammars_to_remove.is_empty() {
694 return;
695 }
696
697 self.languages
698 .retain(|language| !languages_to_remove.contains(&language.name()));
699 self.available_languages
700 .retain(|language| !languages_to_remove.contains(&language.name));
701 self.grammars
702 .retain(|name, _| !grammars_to_remove.contains(&name));
703 self.version += 1;
704 self.reload_count += 1;
705 *self.subscription.0.borrow_mut() = ();
706 }
707
708 /// Mark the given language as having been loaded, so that the
709 /// language registry won't try to load it again.
710 fn mark_language_loaded(&mut self, id: LanguageId) {
711 for language in &mut self.available_languages {
712 if language.id == id {
713 language.loaded = true;
714 break;
715 }
716 }
717 }
718}
719
720impl LspBinaryStatusSender {
721 fn subscribe(&self) -> mpsc::UnboundedReceiver<(Arc<Language>, LanguageServerBinaryStatus)> {
722 let (tx, rx) = mpsc::unbounded();
723 self.txs.lock().push(tx);
724 rx
725 }
726
727 fn send(&self, language: Arc<Language>, status: LanguageServerBinaryStatus) {
728 let mut txs = self.txs.lock();
729 txs.retain(|tx| {
730 tx.unbounded_send((language.clone(), status.clone()))
731 .is_ok()
732 });
733 }
734}
735
736async fn check_user_installed_binary(
737 adapter: Arc<CachedLspAdapter>,
738 language: Arc<Language>,
739 delegate: Arc<dyn LspAdapterDelegate>,
740 cx: &mut AsyncAppContext,
741) -> Option<LanguageServerBinary> {
742 let Some(task) = adapter.check_if_user_installed(&delegate, cx) else {
743 return None;
744 };
745
746 task.await.and_then(|binary| {
747 log::info!(
748 "found user-installed language server for {}. path: {:?}, arguments: {:?}",
749 language.name(),
750 binary.path,
751 binary.arguments
752 );
753 Some(binary)
754 })
755}
756
757async fn get_or_install_binary(
758 registry: Arc<LanguageRegistry>,
759 adapter: &Arc<CachedLspAdapter>,
760 language: Arc<Language>,
761 delegate: &Arc<dyn LspAdapterDelegate>,
762 cx: &AsyncAppContext,
763 container_dir: Arc<Path>,
764 lsp_binary_statuses: LspBinaryStatusSender,
765) -> Result<LanguageServerBinary> {
766 let entry = registry
767 .lsp_binary_paths
768 .lock()
769 .entry(adapter.name.clone())
770 .or_insert_with(|| {
771 let adapter = adapter.clone();
772 let language = language.clone();
773 let delegate = delegate.clone();
774 cx.spawn(|cx| {
775 get_binary(
776 adapter,
777 language,
778 delegate,
779 container_dir,
780 lsp_binary_statuses,
781 cx,
782 )
783 .map_err(Arc::new)
784 })
785 .shared()
786 })
787 .clone();
788
789 entry.await.map_err(|err| anyhow!("{:?}", err))
790}
791
792async fn get_binary(
793 adapter: Arc<CachedLspAdapter>,
794 language: Arc<Language>,
795 delegate: Arc<dyn LspAdapterDelegate>,
796 container_dir: Arc<Path>,
797 statuses: LspBinaryStatusSender,
798 mut cx: AsyncAppContext,
799) -> Result<LanguageServerBinary> {
800 if !container_dir.exists() {
801 smol::fs::create_dir_all(&container_dir)
802 .await
803 .context("failed to create container directory")?;
804 }
805
806 if let Some(task) = adapter.will_fetch_server(&delegate, &mut cx) {
807 task.await?;
808 }
809
810 let binary = fetch_latest_binary(
811 adapter.clone(),
812 language.clone(),
813 delegate.as_ref(),
814 &container_dir,
815 statuses.clone(),
816 )
817 .await;
818
819 if let Err(error) = binary.as_ref() {
820 if let Some(binary) = adapter
821 .cached_server_binary(container_dir.to_path_buf(), delegate.as_ref())
822 .await
823 {
824 statuses.send(language.clone(), LanguageServerBinaryStatus::Cached);
825 log::info!(
826 "failed to fetch newest version of language server {:?}. falling back to using {:?}",
827 adapter.name,
828 binary.path.display()
829 );
830 return Ok(binary);
831 }
832
833 statuses.send(
834 language.clone(),
835 LanguageServerBinaryStatus::Failed {
836 error: format!("{:?}", error),
837 },
838 );
839 }
840
841 binary
842}
843
844async fn fetch_latest_binary(
845 adapter: Arc<CachedLspAdapter>,
846 language: Arc<Language>,
847 delegate: &dyn LspAdapterDelegate,
848 container_dir: &Path,
849 lsp_binary_statuses_tx: LspBinaryStatusSender,
850) -> Result<LanguageServerBinary> {
851 let container_dir: Arc<Path> = container_dir.into();
852
853 lsp_binary_statuses_tx.send(
854 language.clone(),
855 LanguageServerBinaryStatus::CheckingForUpdate,
856 );
857
858 log::info!(
859 "querying GitHub for latest version of language server {:?}",
860 adapter.name.0
861 );
862 let version_info = adapter.fetch_latest_server_version(delegate).await?;
863 lsp_binary_statuses_tx.send(language.clone(), LanguageServerBinaryStatus::Downloading);
864
865 log::info!(
866 "checking if Zed already installed or fetching version for language server {:?}",
867 adapter.name.0
868 );
869 let binary = adapter
870 .fetch_server_binary(version_info, container_dir.to_path_buf(), delegate)
871 .await?;
872 lsp_binary_statuses_tx.send(language.clone(), LanguageServerBinaryStatus::Downloaded);
873
874 Ok(binary)
875}