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(#[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 ) -> 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 // First we check whether the adapter can give us a user-installed binary.
562 // If so, we do *not* want to cache that, because each worktree might give us a different
563 // binary:
564 //
565 // worktree 1: user-installed at `.bin/gopls`
566 // worktree 2: user-installed at `~/bin/gopls`
567 // worktree 3: no gopls found in PATH -> fallback to Zed installation
568 //
569 // We only want to cache when we fall back to the global one,
570 // because we don't want to download and overwrite our global one
571 // for each worktree we might have open.
572
573 let user_binary_task = check_user_installed_binary(
574 adapter.clone(),
575 language.clone(),
576 delegate.clone(),
577 &mut cx,
578 );
579 let binary = if let Some(user_binary) = user_binary_task.await {
580 user_binary
581 } else {
582 // If we want to install a binary globally, we need to wait for
583 // the login shell to be set on our process.
584 login_shell_env_loaded.await;
585
586 get_or_install_binary(
587 this,
588 &adapter,
589 language,
590 &delegate,
591 &cx,
592 container_dir,
593 lsp_binary_statuses,
594 )
595 .await?
596 };
597
598 if let Some(task) = adapter.will_start_server(&delegate, &mut cx) {
599 task.await?;
600 }
601
602 lsp::LanguageServer::new(
603 stderr_capture,
604 server_id,
605 binary,
606 &root_path,
607 adapter.code_action_kinds(),
608 cx,
609 )
610 })
611 };
612
613 Some(PendingLanguageServer {
614 server_id,
615 task,
616 container_dir: Some(container_dir),
617 })
618 }
619
620 pub fn language_server_binary_statuses(
621 &self,
622 ) -> mpsc::UnboundedReceiver<(Arc<Language>, LanguageServerBinaryStatus)> {
623 self.lsp_binary_status_tx.subscribe()
624 }
625
626 pub fn delete_server_container(
627 &self,
628 adapter: Arc<CachedLspAdapter>,
629 cx: &mut AppContext,
630 ) -> Task<()> {
631 log::info!("deleting server container");
632
633 let mut lock = self.lsp_binary_paths.lock();
634 lock.remove(&adapter.name);
635
636 let download_dir = self
637 .language_server_download_dir
638 .clone()
639 .expect("language server download directory has not been assigned before deleting server container");
640
641 cx.spawn(|_| async move {
642 let container_dir = download_dir.join(adapter.name.0.as_ref());
643 smol::fs::remove_dir_all(container_dir)
644 .await
645 .context("server container removal")
646 .log_err();
647 })
648 }
649
650 pub fn next_language_server_id(&self) -> LanguageServerId {
651 self.state.write().next_language_server_id()
652 }
653}
654
655#[cfg(any(test, feature = "test-support"))]
656impl Default for LanguageRegistry {
657 fn default() -> Self {
658 Self::test()
659 }
660}
661
662impl LanguageRegistryState {
663 fn next_language_server_id(&mut self) -> LanguageServerId {
664 LanguageServerId(post_inc(&mut self.next_language_server_id))
665 }
666
667 fn add(&mut self, language: Arc<Language>) {
668 if let Some(theme) = self.theme.as_ref() {
669 language.set_theme(theme.syntax());
670 }
671 self.languages.push(language);
672 self.version += 1;
673 *self.subscription.0.borrow_mut() = ();
674 }
675
676 fn reload(&mut self) {
677 self.languages.clear();
678 self.version += 1;
679 self.reload_count += 1;
680 for language in &mut self.available_languages {
681 language.loaded = false;
682 }
683 *self.subscription.0.borrow_mut() = ();
684 }
685
686 fn remove_languages(
687 &mut self,
688 languages_to_remove: &[Arc<str>],
689 grammars_to_remove: &[Arc<str>],
690 ) {
691 if languages_to_remove.is_empty() && grammars_to_remove.is_empty() {
692 return;
693 }
694
695 self.languages
696 .retain(|language| !languages_to_remove.contains(&language.name()));
697 self.available_languages
698 .retain(|language| !languages_to_remove.contains(&language.name));
699 self.grammars
700 .retain(|name, _| !grammars_to_remove.contains(&name));
701 self.version += 1;
702 self.reload_count += 1;
703 *self.subscription.0.borrow_mut() = ();
704 }
705
706 /// Mark the given language as having been loaded, so that the
707 /// language registry won't try to load it again.
708 fn mark_language_loaded(&mut self, id: LanguageId) {
709 for language in &mut self.available_languages {
710 if language.id == id {
711 language.loaded = true;
712 break;
713 }
714 }
715 }
716}
717
718impl LspBinaryStatusSender {
719 fn subscribe(&self) -> mpsc::UnboundedReceiver<(Arc<Language>, LanguageServerBinaryStatus)> {
720 let (tx, rx) = mpsc::unbounded();
721 self.txs.lock().push(tx);
722 rx
723 }
724
725 fn send(&self, language: Arc<Language>, status: LanguageServerBinaryStatus) {
726 let mut txs = self.txs.lock();
727 txs.retain(|tx| {
728 tx.unbounded_send((language.clone(), status.clone()))
729 .is_ok()
730 });
731 }
732}
733
734async fn check_user_installed_binary(
735 adapter: Arc<CachedLspAdapter>,
736 language: Arc<Language>,
737 delegate: Arc<dyn LspAdapterDelegate>,
738 cx: &mut AsyncAppContext,
739) -> Option<LanguageServerBinary> {
740 let Some(task) = adapter.check_if_user_installed(&delegate, cx) else {
741 return None;
742 };
743
744 task.await.and_then(|binary| {
745 log::info!(
746 "found user-installed language server for {}. path: {:?}, arguments: {:?}",
747 language.name(),
748 binary.path,
749 binary.arguments
750 );
751 Some(binary)
752 })
753}
754
755async fn get_or_install_binary(
756 registry: Arc<LanguageRegistry>,
757 adapter: &Arc<CachedLspAdapter>,
758 language: Arc<Language>,
759 delegate: &Arc<dyn LspAdapterDelegate>,
760 cx: &AsyncAppContext,
761 container_dir: Arc<Path>,
762 lsp_binary_statuses: LspBinaryStatusSender,
763) -> Result<LanguageServerBinary> {
764 let entry = registry
765 .lsp_binary_paths
766 .lock()
767 .entry(adapter.name.clone())
768 .or_insert_with(|| {
769 let adapter = adapter.clone();
770 let language = language.clone();
771 let delegate = delegate.clone();
772 cx.spawn(|cx| {
773 get_binary(
774 adapter,
775 language,
776 delegate,
777 container_dir,
778 lsp_binary_statuses,
779 cx,
780 )
781 .map_err(Arc::new)
782 })
783 .shared()
784 })
785 .clone();
786
787 entry.await.map_err(|err| anyhow!("{:?}", err))
788}
789
790async fn get_binary(
791 adapter: Arc<CachedLspAdapter>,
792 language: Arc<Language>,
793 delegate: Arc<dyn LspAdapterDelegate>,
794 container_dir: Arc<Path>,
795 statuses: LspBinaryStatusSender,
796 mut cx: AsyncAppContext,
797) -> Result<LanguageServerBinary> {
798 if !container_dir.exists() {
799 smol::fs::create_dir_all(&container_dir)
800 .await
801 .context("failed to create container directory")?;
802 }
803
804 if let Some(task) = adapter.will_fetch_server(&delegate, &mut cx) {
805 task.await?;
806 }
807
808 let binary = fetch_latest_binary(
809 adapter.clone(),
810 language.clone(),
811 delegate.as_ref(),
812 &container_dir,
813 statuses.clone(),
814 )
815 .await;
816
817 if let Err(error) = binary.as_ref() {
818 if let Some(binary) = adapter
819 .cached_server_binary(container_dir.to_path_buf(), delegate.as_ref())
820 .await
821 {
822 statuses.send(language.clone(), LanguageServerBinaryStatus::Cached);
823 log::info!(
824 "failed to fetch newest version of language server {:?}. falling back to using {:?}",
825 adapter.name,
826 binary.path.display()
827 );
828 return Ok(binary);
829 }
830
831 statuses.send(
832 language.clone(),
833 LanguageServerBinaryStatus::Failed {
834 error: format!("{:?}", error),
835 },
836 );
837 }
838
839 binary
840}
841
842async fn fetch_latest_binary(
843 adapter: Arc<CachedLspAdapter>,
844 language: Arc<Language>,
845 delegate: &dyn LspAdapterDelegate,
846 container_dir: &Path,
847 lsp_binary_statuses_tx: LspBinaryStatusSender,
848) -> Result<LanguageServerBinary> {
849 let container_dir: Arc<Path> = container_dir.into();
850
851 lsp_binary_statuses_tx.send(
852 language.clone(),
853 LanguageServerBinaryStatus::CheckingForUpdate,
854 );
855
856 log::info!(
857 "querying GitHub for latest version of language server {:?}",
858 adapter.name.0
859 );
860 let version_info = adapter.fetch_latest_server_version(delegate).await?;
861 lsp_binary_statuses_tx.send(language.clone(), LanguageServerBinaryStatus::Downloading);
862
863 log::info!(
864 "checking if Zed already installed or fetching version for language server {:?}",
865 adapter.name.0
866 );
867 let binary = adapter
868 .fetch_server_binary(version_info, container_dir.to_path_buf(), delegate)
869 .await?;
870 lsp_binary_statuses_tx.send(language.clone(), LanguageServerBinaryStatus::Downloaded);
871
872 Ok(binary)
873}