1mod buffer;
2mod diagnostic_set;
3mod highlight_map;
4pub mod language_settings;
5mod outline;
6pub mod proto;
7mod syntax_map;
8
9#[cfg(test)]
10mod buffer_tests;
11pub mod markdown;
12
13use anyhow::{anyhow, Context, Result};
14use async_trait::async_trait;
15use collections::{HashMap, HashSet};
16use futures::{
17 channel::{mpsc, oneshot},
18 future::{BoxFuture, Shared},
19 FutureExt, TryFutureExt as _,
20};
21use gpui::{AppContext, AsyncAppContext, BackgroundExecutor, Task};
22pub use highlight_map::HighlightMap;
23use lazy_static::lazy_static;
24use lsp::{CodeActionKind, LanguageServerBinary};
25use parking_lot::{Mutex, RwLock};
26use postage::watch;
27use regex::Regex;
28use serde::{de, Deserialize, Deserializer};
29use serde_json::Value;
30use std::{
31 any::Any,
32 borrow::Cow,
33 cell::RefCell,
34 fmt::Debug,
35 hash::Hash,
36 mem,
37 ops::{Not, Range},
38 path::{Path, PathBuf},
39 str,
40 sync::{
41 atomic::{AtomicU64, AtomicUsize, Ordering::SeqCst},
42 Arc,
43 },
44};
45use syntax_map::SyntaxSnapshot;
46use theme::{SyntaxTheme, Theme};
47use tree_sitter::{self, Query};
48use unicase::UniCase;
49use util::{http::HttpClient, paths::PathExt};
50use util::{post_inc, ResultExt, TryFutureExt as _, UnwrapFuture};
51
52pub use buffer::Operation;
53pub use buffer::*;
54pub use diagnostic_set::DiagnosticEntry;
55pub use lsp::LanguageServerId;
56pub use outline::{Outline, OutlineItem};
57pub use syntax_map::{OwnedSyntaxLayerInfo, SyntaxLayerInfo};
58pub use text::LineEnding;
59pub use tree_sitter::{Parser, Tree};
60
61pub fn init(cx: &mut AppContext) {
62 language_settings::init(cx);
63}
64
65#[derive(Clone, Default)]
66struct LspBinaryStatusSender {
67 txs: Arc<Mutex<Vec<mpsc::UnboundedSender<(Arc<Language>, LanguageServerBinaryStatus)>>>>,
68}
69
70impl LspBinaryStatusSender {
71 fn subscribe(&self) -> mpsc::UnboundedReceiver<(Arc<Language>, LanguageServerBinaryStatus)> {
72 let (tx, rx) = mpsc::unbounded();
73 self.txs.lock().push(tx);
74 rx
75 }
76
77 fn send(&self, language: Arc<Language>, status: LanguageServerBinaryStatus) {
78 let mut txs = self.txs.lock();
79 txs.retain(|tx| {
80 tx.unbounded_send((language.clone(), status.clone()))
81 .is_ok()
82 });
83 }
84}
85
86thread_local! {
87 static PARSER: RefCell<Parser> = {
88 RefCell::new(Parser::new())
89 };
90}
91
92lazy_static! {
93 pub static ref NEXT_GRAMMAR_ID: AtomicUsize = Default::default();
94 pub static ref PLAIN_TEXT: Arc<Language> = Arc::new(Language::new(
95 LanguageConfig {
96 name: "Plain Text".into(),
97 ..Default::default()
98 },
99 None,
100 ));
101}
102
103pub trait ToLspPosition {
104 fn to_lsp_position(self) -> lsp::Position;
105}
106
107#[derive(Clone, Debug, PartialEq, Eq, Hash)]
108pub struct LanguageServerName(pub Arc<str>);
109
110/// Represents a Language Server, with certain cached sync properties.
111/// Uses [`LspAdapter`] under the hood, but calls all 'static' methods
112/// once at startup, and caches the results.
113pub struct CachedLspAdapter {
114 pub name: LanguageServerName,
115 pub short_name: &'static str,
116 pub disk_based_diagnostic_sources: Vec<String>,
117 pub disk_based_diagnostics_progress_token: Option<String>,
118 pub language_ids: HashMap<String, String>,
119 pub adapter: Arc<dyn LspAdapter>,
120 pub reinstall_attempt_count: AtomicU64,
121}
122
123impl CachedLspAdapter {
124 pub async fn new(adapter: Arc<dyn LspAdapter>) -> Arc<Self> {
125 let name = adapter.name().await;
126 let short_name = adapter.short_name();
127 let disk_based_diagnostic_sources = adapter.disk_based_diagnostic_sources().await;
128 let disk_based_diagnostics_progress_token =
129 adapter.disk_based_diagnostics_progress_token().await;
130 let language_ids = adapter.language_ids().await;
131
132 Arc::new(CachedLspAdapter {
133 name,
134 short_name,
135 disk_based_diagnostic_sources,
136 disk_based_diagnostics_progress_token,
137 language_ids,
138 adapter,
139 reinstall_attempt_count: AtomicU64::new(0),
140 })
141 }
142
143 pub async fn fetch_latest_server_version(
144 &self,
145 delegate: &dyn LspAdapterDelegate,
146 ) -> Result<Box<dyn 'static + Send + Any>> {
147 self.adapter.fetch_latest_server_version(delegate).await
148 }
149
150 pub fn will_fetch_server(
151 &self,
152 delegate: &Arc<dyn LspAdapterDelegate>,
153 cx: &mut AsyncAppContext,
154 ) -> Option<Task<Result<()>>> {
155 self.adapter.will_fetch_server(delegate, cx)
156 }
157
158 pub fn will_start_server(
159 &self,
160 delegate: &Arc<dyn LspAdapterDelegate>,
161 cx: &mut AsyncAppContext,
162 ) -> Option<Task<Result<()>>> {
163 self.adapter.will_start_server(delegate, cx)
164 }
165
166 pub async fn fetch_server_binary(
167 &self,
168 version: Box<dyn 'static + Send + Any>,
169 container_dir: PathBuf,
170 delegate: &dyn LspAdapterDelegate,
171 ) -> Result<LanguageServerBinary> {
172 self.adapter
173 .fetch_server_binary(version, container_dir, delegate)
174 .await
175 }
176
177 pub async fn cached_server_binary(
178 &self,
179 container_dir: PathBuf,
180 delegate: &dyn LspAdapterDelegate,
181 ) -> Option<LanguageServerBinary> {
182 self.adapter
183 .cached_server_binary(container_dir, delegate)
184 .await
185 }
186
187 pub fn can_be_reinstalled(&self) -> bool {
188 self.adapter.can_be_reinstalled()
189 }
190
191 pub async fn installation_test_binary(
192 &self,
193 container_dir: PathBuf,
194 ) -> Option<LanguageServerBinary> {
195 self.adapter.installation_test_binary(container_dir).await
196 }
197
198 pub fn code_action_kinds(&self) -> Option<Vec<CodeActionKind>> {
199 self.adapter.code_action_kinds()
200 }
201
202 pub fn workspace_configuration(
203 &self,
204 workspace_root: &Path,
205 cx: &mut AppContext,
206 ) -> BoxFuture<'static, Value> {
207 self.adapter.workspace_configuration(workspace_root, cx)
208 }
209
210 pub fn process_diagnostics(&self, params: &mut lsp::PublishDiagnosticsParams) {
211 self.adapter.process_diagnostics(params)
212 }
213
214 pub async fn process_completion(&self, completion_item: &mut lsp::CompletionItem) {
215 self.adapter.process_completion(completion_item).await
216 }
217
218 pub async fn label_for_completion(
219 &self,
220 completion_item: &lsp::CompletionItem,
221 language: &Arc<Language>,
222 ) -> Option<CodeLabel> {
223 self.adapter
224 .label_for_completion(completion_item, language)
225 .await
226 }
227
228 pub async fn label_for_symbol(
229 &self,
230 name: &str,
231 kind: lsp::SymbolKind,
232 language: &Arc<Language>,
233 ) -> Option<CodeLabel> {
234 self.adapter.label_for_symbol(name, kind, language).await
235 }
236
237 pub fn prettier_plugins(&self) -> &[&'static str] {
238 self.adapter.prettier_plugins()
239 }
240}
241
242pub trait LspAdapterDelegate: Send + Sync {
243 fn show_notification(&self, message: &str, cx: &mut AppContext);
244 fn http_client(&self) -> Arc<dyn HttpClient>;
245}
246
247#[async_trait]
248pub trait LspAdapter: 'static + Send + Sync {
249 async fn name(&self) -> LanguageServerName;
250
251 fn short_name(&self) -> &'static str;
252
253 async fn fetch_latest_server_version(
254 &self,
255 delegate: &dyn LspAdapterDelegate,
256 ) -> Result<Box<dyn 'static + Send + Any>>;
257
258 fn will_fetch_server(
259 &self,
260 _: &Arc<dyn LspAdapterDelegate>,
261 _: &mut AsyncAppContext,
262 ) -> Option<Task<Result<()>>> {
263 None
264 }
265
266 fn will_start_server(
267 &self,
268 _: &Arc<dyn LspAdapterDelegate>,
269 _: &mut AsyncAppContext,
270 ) -> Option<Task<Result<()>>> {
271 None
272 }
273
274 async fn fetch_server_binary(
275 &self,
276 version: Box<dyn 'static + Send + Any>,
277 container_dir: PathBuf,
278 delegate: &dyn LspAdapterDelegate,
279 ) -> Result<LanguageServerBinary>;
280
281 async fn cached_server_binary(
282 &self,
283 container_dir: PathBuf,
284 delegate: &dyn LspAdapterDelegate,
285 ) -> Option<LanguageServerBinary>;
286
287 fn can_be_reinstalled(&self) -> bool {
288 true
289 }
290
291 async fn installation_test_binary(
292 &self,
293 container_dir: PathBuf,
294 ) -> Option<LanguageServerBinary>;
295
296 fn process_diagnostics(&self, _: &mut lsp::PublishDiagnosticsParams) {}
297
298 async fn process_completion(&self, _: &mut lsp::CompletionItem) {}
299
300 async fn label_for_completion(
301 &self,
302 _: &lsp::CompletionItem,
303 _: &Arc<Language>,
304 ) -> Option<CodeLabel> {
305 None
306 }
307
308 async fn label_for_symbol(
309 &self,
310 _: &str,
311 _: lsp::SymbolKind,
312 _: &Arc<Language>,
313 ) -> Option<CodeLabel> {
314 None
315 }
316
317 async fn initialization_options(&self) -> Option<Value> {
318 None
319 }
320
321 fn workspace_configuration(&self, _: &Path, _: &mut AppContext) -> BoxFuture<'static, Value> {
322 futures::future::ready(serde_json::json!({})).boxed()
323 }
324
325 fn code_action_kinds(&self) -> Option<Vec<CodeActionKind>> {
326 Some(vec![
327 CodeActionKind::EMPTY,
328 CodeActionKind::QUICKFIX,
329 CodeActionKind::REFACTOR,
330 CodeActionKind::REFACTOR_EXTRACT,
331 CodeActionKind::SOURCE,
332 ])
333 }
334
335 async fn disk_based_diagnostic_sources(&self) -> Vec<String> {
336 Default::default()
337 }
338
339 async fn disk_based_diagnostics_progress_token(&self) -> Option<String> {
340 None
341 }
342
343 async fn language_ids(&self) -> HashMap<String, String> {
344 Default::default()
345 }
346
347 fn prettier_plugins(&self) -> &[&'static str] {
348 &[]
349 }
350}
351
352#[derive(Clone, Debug, PartialEq, Eq)]
353pub struct CodeLabel {
354 pub text: String,
355 pub runs: Vec<(Range<usize>, HighlightId)>,
356 pub filter_range: Range<usize>,
357}
358
359#[derive(Clone, Deserialize)]
360pub struct LanguageConfig {
361 pub name: Arc<str>,
362 pub grammar_name: Option<Arc<str>>,
363 pub path_suffixes: Vec<String>,
364 pub brackets: BracketPairConfig,
365 #[serde(default, deserialize_with = "deserialize_regex")]
366 pub first_line_pattern: Option<Regex>,
367 #[serde(default = "auto_indent_using_last_non_empty_line_default")]
368 pub auto_indent_using_last_non_empty_line: bool,
369 #[serde(default, deserialize_with = "deserialize_regex")]
370 pub increase_indent_pattern: Option<Regex>,
371 #[serde(default, deserialize_with = "deserialize_regex")]
372 pub decrease_indent_pattern: Option<Regex>,
373 #[serde(default)]
374 pub autoclose_before: String,
375 #[serde(default)]
376 pub line_comment: Option<Arc<str>>,
377 #[serde(default)]
378 pub collapsed_placeholder: String,
379 #[serde(default)]
380 pub block_comment: Option<(Arc<str>, Arc<str>)>,
381 #[serde(default)]
382 pub scope_opt_in_language_servers: Vec<String>,
383 #[serde(default)]
384 pub overrides: HashMap<String, LanguageConfigOverride>,
385 #[serde(default)]
386 pub word_characters: HashSet<char>,
387 #[serde(default)]
388 pub prettier_parser_name: Option<String>,
389}
390
391#[derive(Debug, Default)]
392pub struct LanguageQueries {
393 pub highlights: Option<Cow<'static, str>>,
394 pub brackets: Option<Cow<'static, str>>,
395 pub indents: Option<Cow<'static, str>>,
396 pub outline: Option<Cow<'static, str>>,
397 pub embedding: Option<Cow<'static, str>>,
398 pub injections: Option<Cow<'static, str>>,
399 pub overrides: Option<Cow<'static, str>>,
400}
401
402#[derive(Clone, Debug)]
403pub struct LanguageScope {
404 language: Arc<Language>,
405 override_id: Option<u32>,
406}
407
408#[derive(Clone, Deserialize, Default, Debug)]
409pub struct LanguageConfigOverride {
410 #[serde(default)]
411 pub line_comment: Override<Arc<str>>,
412 #[serde(default)]
413 pub block_comment: Override<(Arc<str>, Arc<str>)>,
414 #[serde(skip_deserializing)]
415 pub disabled_bracket_ixs: Vec<u16>,
416 #[serde(default)]
417 pub word_characters: Override<HashSet<char>>,
418 #[serde(default)]
419 pub opt_into_language_servers: Vec<String>,
420}
421
422#[derive(Clone, Deserialize, Debug)]
423#[serde(untagged)]
424pub enum Override<T> {
425 Remove { remove: bool },
426 Set(T),
427}
428
429impl<T> Default for Override<T> {
430 fn default() -> Self {
431 Override::Remove { remove: false }
432 }
433}
434
435impl<T> Override<T> {
436 fn as_option<'a>(this: Option<&'a Self>, original: Option<&'a T>) -> Option<&'a T> {
437 match this {
438 Some(Self::Set(value)) => Some(value),
439 Some(Self::Remove { remove: true }) => None,
440 Some(Self::Remove { remove: false }) | None => original,
441 }
442 }
443}
444
445impl Default for LanguageConfig {
446 fn default() -> Self {
447 Self {
448 name: "".into(),
449 grammar_name: None,
450 path_suffixes: Default::default(),
451 brackets: Default::default(),
452 auto_indent_using_last_non_empty_line: auto_indent_using_last_non_empty_line_default(),
453 first_line_pattern: Default::default(),
454 increase_indent_pattern: Default::default(),
455 decrease_indent_pattern: Default::default(),
456 autoclose_before: Default::default(),
457 line_comment: Default::default(),
458 block_comment: Default::default(),
459 scope_opt_in_language_servers: Default::default(),
460 overrides: Default::default(),
461 collapsed_placeholder: Default::default(),
462 word_characters: Default::default(),
463 prettier_parser_name: None,
464 }
465 }
466}
467
468fn auto_indent_using_last_non_empty_line_default() -> bool {
469 true
470}
471
472fn deserialize_regex<'de, D: Deserializer<'de>>(d: D) -> Result<Option<Regex>, D::Error> {
473 let source = Option::<String>::deserialize(d)?;
474 if let Some(source) = source {
475 Ok(Some(regex::Regex::new(&source).map_err(de::Error::custom)?))
476 } else {
477 Ok(None)
478 }
479}
480
481#[cfg(any(test, feature = "test-support"))]
482pub struct FakeLspAdapter {
483 pub name: &'static str,
484 pub initialization_options: Option<Value>,
485 pub capabilities: lsp::ServerCapabilities,
486 pub initializer: Option<Box<dyn 'static + Send + Sync + Fn(&mut lsp::FakeLanguageServer)>>,
487 pub disk_based_diagnostics_progress_token: Option<String>,
488 pub disk_based_diagnostics_sources: Vec<String>,
489 pub prettier_plugins: Vec<&'static str>,
490}
491
492#[derive(Clone, Debug, Default)]
493pub struct BracketPairConfig {
494 pub pairs: Vec<BracketPair>,
495 pub disabled_scopes_by_bracket_ix: Vec<Vec<String>>,
496}
497
498impl<'de> Deserialize<'de> for BracketPairConfig {
499 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
500 where
501 D: Deserializer<'de>,
502 {
503 #[derive(Deserialize)]
504 pub struct Entry {
505 #[serde(flatten)]
506 pub bracket_pair: BracketPair,
507 #[serde(default)]
508 pub not_in: Vec<String>,
509 }
510
511 let result = Vec::<Entry>::deserialize(deserializer)?;
512 let mut brackets = Vec::with_capacity(result.len());
513 let mut disabled_scopes_by_bracket_ix = Vec::with_capacity(result.len());
514 for entry in result {
515 brackets.push(entry.bracket_pair);
516 disabled_scopes_by_bracket_ix.push(entry.not_in);
517 }
518
519 Ok(BracketPairConfig {
520 pairs: brackets,
521 disabled_scopes_by_bracket_ix,
522 })
523 }
524}
525
526#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
527pub struct BracketPair {
528 pub start: String,
529 pub end: String,
530 pub close: bool,
531 pub newline: bool,
532}
533
534pub struct Language {
535 pub(crate) config: LanguageConfig,
536 pub(crate) grammar: Option<Arc<Grammar>>,
537 pub(crate) adapters: Vec<Arc<CachedLspAdapter>>,
538
539 #[cfg(any(test, feature = "test-support"))]
540 fake_adapter: Option<(
541 mpsc::UnboundedSender<lsp::FakeLanguageServer>,
542 Arc<FakeLspAdapter>,
543 )>,
544}
545
546pub struct Grammar {
547 id: usize,
548 pub ts_language: tree_sitter::Language,
549 pub(crate) error_query: Query,
550 pub(crate) highlights_query: Option<Query>,
551 pub(crate) brackets_config: Option<BracketConfig>,
552 pub(crate) indents_config: Option<IndentConfig>,
553 pub outline_config: Option<OutlineConfig>,
554 pub embedding_config: Option<EmbeddingConfig>,
555 pub(crate) injection_config: Option<InjectionConfig>,
556 pub(crate) override_config: Option<OverrideConfig>,
557 pub(crate) highlight_map: Mutex<HighlightMap>,
558}
559
560struct IndentConfig {
561 query: Query,
562 indent_capture_ix: u32,
563 start_capture_ix: Option<u32>,
564 end_capture_ix: Option<u32>,
565 outdent_capture_ix: Option<u32>,
566}
567
568pub struct OutlineConfig {
569 pub query: Query,
570 pub item_capture_ix: u32,
571 pub name_capture_ix: u32,
572 pub context_capture_ix: Option<u32>,
573 pub extra_context_capture_ix: Option<u32>,
574}
575
576#[derive(Debug)]
577pub struct EmbeddingConfig {
578 pub query: Query,
579 pub item_capture_ix: u32,
580 pub name_capture_ix: Option<u32>,
581 pub context_capture_ix: Option<u32>,
582 pub collapse_capture_ix: Option<u32>,
583 pub keep_capture_ix: Option<u32>,
584}
585
586struct InjectionConfig {
587 query: Query,
588 content_capture_ix: u32,
589 language_capture_ix: Option<u32>,
590 patterns: Vec<InjectionPatternConfig>,
591}
592
593struct OverrideConfig {
594 query: Query,
595 values: HashMap<u32, (String, LanguageConfigOverride)>,
596}
597
598#[derive(Default, Clone)]
599struct InjectionPatternConfig {
600 language: Option<Box<str>>,
601 combined: bool,
602}
603
604struct BracketConfig {
605 query: Query,
606 open_capture_ix: u32,
607 close_capture_ix: u32,
608}
609
610#[derive(Clone)]
611pub enum LanguageServerBinaryStatus {
612 CheckingForUpdate,
613 Downloading,
614 Downloaded,
615 Cached,
616 Failed { error: String },
617}
618
619type AvailableLanguageId = usize;
620
621#[derive(Clone)]
622struct AvailableLanguage {
623 id: AvailableLanguageId,
624 config: LanguageConfig,
625 grammar: AvailableGrammar,
626 lsp_adapters: Vec<Arc<dyn LspAdapter>>,
627 loaded: bool,
628}
629
630#[derive(Clone)]
631enum AvailableGrammar {
632 Native {
633 grammar: tree_sitter::Language,
634 asset_dir: &'static str,
635 get_queries: fn(&str) -> LanguageQueries,
636 },
637 Wasm {
638 _grammar_name: Arc<str>,
639 _path: Arc<Path>,
640 },
641}
642
643pub struct LanguageRegistry {
644 state: RwLock<LanguageRegistryState>,
645 language_server_download_dir: Option<Arc<Path>>,
646 login_shell_env_loaded: Shared<Task<()>>,
647 #[allow(clippy::type_complexity)]
648 lsp_binary_paths: Mutex<
649 HashMap<LanguageServerName, Shared<Task<Result<LanguageServerBinary, Arc<anyhow::Error>>>>>,
650 >,
651 executor: Option<BackgroundExecutor>,
652 lsp_binary_status_tx: LspBinaryStatusSender,
653}
654
655struct LanguageRegistryState {
656 next_language_server_id: usize,
657 languages: Vec<Arc<Language>>,
658 available_languages: Vec<AvailableLanguage>,
659 next_available_language_id: AvailableLanguageId,
660 loading_languages: HashMap<AvailableLanguageId, Vec<oneshot::Sender<Result<Arc<Language>>>>>,
661 subscription: (watch::Sender<()>, watch::Receiver<()>),
662 theme: Option<Arc<Theme>>,
663 version: usize,
664 reload_count: usize,
665}
666
667pub struct PendingLanguageServer {
668 pub server_id: LanguageServerId,
669 pub task: Task<Result<lsp::LanguageServer>>,
670 pub container_dir: Option<Arc<Path>>,
671}
672
673impl LanguageRegistry {
674 pub fn new(login_shell_env_loaded: Task<()>) -> Self {
675 Self {
676 state: RwLock::new(LanguageRegistryState {
677 next_language_server_id: 0,
678 languages: vec![PLAIN_TEXT.clone()],
679 available_languages: Default::default(),
680 next_available_language_id: 0,
681 loading_languages: Default::default(),
682 subscription: watch::channel(),
683 theme: Default::default(),
684 version: 0,
685 reload_count: 0,
686 }),
687 language_server_download_dir: None,
688 login_shell_env_loaded: login_shell_env_loaded.shared(),
689 lsp_binary_paths: Default::default(),
690 executor: None,
691 lsp_binary_status_tx: Default::default(),
692 }
693 }
694
695 #[cfg(any(test, feature = "test-support"))]
696 pub fn test() -> Self {
697 Self::new(Task::ready(()))
698 }
699
700 pub fn set_executor(&mut self, executor: BackgroundExecutor) {
701 self.executor = Some(executor);
702 }
703
704 /// Clear out all of the loaded languages and reload them from scratch.
705 ///
706 /// This is useful in development, when queries have changed.
707 #[cfg(debug_assertions)]
708 pub fn reload(&self) {
709 self.state.write().reload();
710 }
711
712 pub fn register(
713 &self,
714 asset_dir: &'static str,
715 config: LanguageConfig,
716 grammar: tree_sitter::Language,
717 lsp_adapters: Vec<Arc<dyn LspAdapter>>,
718 get_queries: fn(&str) -> LanguageQueries,
719 ) {
720 let state = &mut *self.state.write();
721 state.available_languages.push(AvailableLanguage {
722 id: post_inc(&mut state.next_available_language_id),
723 config,
724 grammar: AvailableGrammar::Native {
725 grammar,
726 get_queries,
727 asset_dir,
728 },
729 lsp_adapters,
730 loaded: false,
731 });
732 }
733
734 pub fn register_wasm(&self, path: Arc<Path>, grammar_name: Arc<str>, config: LanguageConfig) {
735 let state = &mut *self.state.write();
736 state.available_languages.push(AvailableLanguage {
737 id: post_inc(&mut state.next_available_language_id),
738 config,
739 grammar: AvailableGrammar::Wasm {
740 _grammar_name: grammar_name,
741 _path: path,
742 },
743 lsp_adapters: Vec::new(),
744 loaded: false,
745 });
746 }
747
748 pub fn language_names(&self) -> Vec<String> {
749 let state = self.state.read();
750 let mut result = state
751 .available_languages
752 .iter()
753 .filter_map(|l| l.loaded.not().then_some(l.config.name.to_string()))
754 .chain(state.languages.iter().map(|l| l.config.name.to_string()))
755 .collect::<Vec<_>>();
756 result.sort_unstable_by_key(|language_name| language_name.to_lowercase());
757 result
758 }
759
760 pub fn add(&self, language: Arc<Language>) {
761 self.state.write().add(language);
762 }
763
764 pub fn subscribe(&self) -> watch::Receiver<()> {
765 self.state.read().subscription.1.clone()
766 }
767
768 /// The number of times that the registry has been changed,
769 /// by adding languages or reloading.
770 pub fn version(&self) -> usize {
771 self.state.read().version
772 }
773
774 /// The number of times that the registry has been reloaded.
775 pub fn reload_count(&self) -> usize {
776 self.state.read().reload_count
777 }
778
779 pub fn set_theme(&self, theme: Arc<Theme>) {
780 let mut state = self.state.write();
781 state.theme = Some(theme.clone());
782 for language in &state.languages {
783 language.set_theme(&theme.syntax());
784 }
785 }
786
787 pub fn set_language_server_download_dir(&mut self, path: impl Into<Arc<Path>>) {
788 self.language_server_download_dir = Some(path.into());
789 }
790
791 pub fn language_for_name(
792 self: &Arc<Self>,
793 name: &str,
794 ) -> UnwrapFuture<oneshot::Receiver<Result<Arc<Language>>>> {
795 let name = UniCase::new(name);
796 self.get_or_load_language(|config| UniCase::new(config.name.as_ref()) == name)
797 }
798
799 pub fn language_for_name_or_extension(
800 self: &Arc<Self>,
801 string: &str,
802 ) -> UnwrapFuture<oneshot::Receiver<Result<Arc<Language>>>> {
803 let string = UniCase::new(string);
804 self.get_or_load_language(|config| {
805 UniCase::new(config.name.as_ref()) == string
806 || config
807 .path_suffixes
808 .iter()
809 .any(|suffix| UniCase::new(suffix) == string)
810 })
811 }
812
813 pub fn language_for_file(
814 self: &Arc<Self>,
815 path: impl AsRef<Path>,
816 content: Option<&Rope>,
817 ) -> UnwrapFuture<oneshot::Receiver<Result<Arc<Language>>>> {
818 let path = path.as_ref();
819 let filename = path.file_name().and_then(|name| name.to_str());
820 let extension = path.extension_or_hidden_file_name();
821 let path_suffixes = [extension, filename];
822 self.get_or_load_language(|config| {
823 let path_matches = config
824 .path_suffixes
825 .iter()
826 .any(|suffix| path_suffixes.contains(&Some(suffix.as_str())));
827 let content_matches = content.zip(config.first_line_pattern.as_ref()).map_or(
828 false,
829 |(content, pattern)| {
830 let end = content.clip_point(Point::new(0, 256), Bias::Left);
831 let end = content.point_to_offset(end);
832 let text = content.chunks_in_range(0..end).collect::<String>();
833 pattern.is_match(&text)
834 },
835 );
836 path_matches || content_matches
837 })
838 }
839
840 fn get_or_load_language(
841 self: &Arc<Self>,
842 callback: impl Fn(&LanguageConfig) -> bool,
843 ) -> UnwrapFuture<oneshot::Receiver<Result<Arc<Language>>>> {
844 let (tx, rx) = oneshot::channel();
845
846 let mut state = self.state.write();
847 if let Some(language) = state
848 .languages
849 .iter()
850 .find(|language| callback(&language.config))
851 {
852 let _ = tx.send(Ok(language.clone()));
853 } else if let Some(executor) = self.executor.clone() {
854 if let Some(language) = state
855 .available_languages
856 .iter()
857 .find(|l| !l.loaded && callback(&l.config))
858 .cloned()
859 {
860 let txs = state
861 .loading_languages
862 .entry(language.id)
863 .or_insert_with(|| {
864 let this = self.clone();
865 executor
866 .spawn(async move {
867 let id = language.id;
868 let name = language.config.name.clone();
869 let language = async {
870 let (grammar, queries) = match language.grammar {
871 AvailableGrammar::Native {
872 grammar,
873 asset_dir,
874 get_queries,
875 } => (grammar, (get_queries)(asset_dir)),
876 AvailableGrammar::Wasm { .. } => {
877 Err(anyhow!("not supported"))?
878 }
879 };
880 Language::new(language.config, Some(grammar))
881 .with_lsp_adapters(language.lsp_adapters)
882 .await
883 .with_queries(queries)
884 }
885 .await;
886
887 match language {
888 Ok(language) => {
889 let language = Arc::new(language);
890 let mut state = this.state.write();
891
892 state.add(language.clone());
893 state.mark_language_loaded(id);
894 if let Some(mut txs) = state.loading_languages.remove(&id) {
895 for tx in txs.drain(..) {
896 let _ = tx.send(Ok(language.clone()));
897 }
898 }
899 }
900 Err(e) => {
901 log::error!("failed to load language {name}:\n{:?}", e);
902 let mut state = this.state.write();
903 state.mark_language_loaded(id);
904 if let Some(mut txs) = state.loading_languages.remove(&id) {
905 for tx in txs.drain(..) {
906 let _ = tx.send(Err(anyhow!(
907 "failed to load language {}: {}",
908 name,
909 e
910 )));
911 }
912 }
913 }
914 };
915 })
916 .detach();
917
918 Vec::new()
919 });
920 txs.push(tx);
921 } else {
922 let _ = tx.send(Err(anyhow!("language not found")));
923 }
924 } else {
925 let _ = tx.send(Err(anyhow!("executor does not exist")));
926 }
927
928 rx.unwrap()
929 }
930
931 pub fn to_vec(&self) -> Vec<Arc<Language>> {
932 self.state.read().languages.iter().cloned().collect()
933 }
934
935 pub fn create_pending_language_server(
936 self: &Arc<Self>,
937 stderr_capture: Arc<Mutex<Option<String>>>,
938 language: Arc<Language>,
939 adapter: Arc<CachedLspAdapter>,
940 root_path: Arc<Path>,
941 delegate: Arc<dyn LspAdapterDelegate>,
942 cx: &mut AppContext,
943 ) -> Option<PendingLanguageServer> {
944 let server_id = self.state.write().next_language_server_id();
945 log::info!(
946 "starting language server {:?}, path: {root_path:?}, id: {server_id}",
947 adapter.name.0
948 );
949
950 #[cfg(any(test, feature = "test-support"))]
951 if language.fake_adapter.is_some() {
952 let task = cx.spawn(|cx| async move {
953 let (servers_tx, fake_adapter) = language.fake_adapter.as_ref().unwrap();
954 let (server, mut fake_server) = lsp::FakeLanguageServer::new(
955 fake_adapter.name.to_string(),
956 fake_adapter.capabilities.clone(),
957 cx.clone(),
958 );
959
960 if let Some(initializer) = &fake_adapter.initializer {
961 initializer(&mut fake_server);
962 }
963
964 let servers_tx = servers_tx.clone();
965 cx.background_executor()
966 .spawn(async move {
967 if fake_server
968 .try_receive_notification::<lsp::notification::Initialized>()
969 .await
970 .is_some()
971 {
972 servers_tx.unbounded_send(fake_server).ok();
973 }
974 })
975 .detach();
976
977 Ok(server)
978 });
979
980 return Some(PendingLanguageServer {
981 server_id,
982 task,
983 container_dir: None,
984 });
985 }
986
987 let download_dir = self
988 .language_server_download_dir
989 .clone()
990 .ok_or_else(|| anyhow!("language server download directory has not been assigned before starting server"))
991 .log_err()?;
992 let this = self.clone();
993 let language = language.clone();
994 let container_dir: Arc<Path> = Arc::from(download_dir.join(adapter.name.0.as_ref()));
995 let root_path = root_path.clone();
996 let adapter = adapter.clone();
997 let login_shell_env_loaded = self.login_shell_env_loaded.clone();
998 let lsp_binary_statuses = self.lsp_binary_status_tx.clone();
999
1000 let task = {
1001 let container_dir = container_dir.clone();
1002 cx.spawn(move |mut cx| async move {
1003 login_shell_env_loaded.await;
1004
1005 let entry = this
1006 .lsp_binary_paths
1007 .lock()
1008 .entry(adapter.name.clone())
1009 .or_insert_with(|| {
1010 let adapter = adapter.clone();
1011 let language = language.clone();
1012 let delegate = delegate.clone();
1013 cx.spawn(|cx| {
1014 get_binary(
1015 adapter,
1016 language,
1017 delegate,
1018 container_dir,
1019 lsp_binary_statuses,
1020 cx,
1021 )
1022 .map_err(Arc::new)
1023 })
1024 .shared()
1025 })
1026 .clone();
1027
1028 let binary = match entry.await {
1029 Ok(binary) => binary,
1030 Err(err) => anyhow::bail!("{err}"),
1031 };
1032
1033 if let Some(task) = adapter.will_start_server(&delegate, &mut cx) {
1034 task.await?;
1035 }
1036
1037 lsp::LanguageServer::new(
1038 stderr_capture,
1039 server_id,
1040 binary,
1041 &root_path,
1042 adapter.code_action_kinds(),
1043 cx,
1044 )
1045 })
1046 };
1047
1048 Some(PendingLanguageServer {
1049 server_id,
1050 task,
1051 container_dir: Some(container_dir),
1052 })
1053 }
1054
1055 pub fn language_server_binary_statuses(
1056 &self,
1057 ) -> mpsc::UnboundedReceiver<(Arc<Language>, LanguageServerBinaryStatus)> {
1058 self.lsp_binary_status_tx.subscribe()
1059 }
1060
1061 pub fn delete_server_container(
1062 &self,
1063 adapter: Arc<CachedLspAdapter>,
1064 cx: &mut AppContext,
1065 ) -> Task<()> {
1066 log::info!("deleting server container");
1067
1068 let mut lock = self.lsp_binary_paths.lock();
1069 lock.remove(&adapter.name);
1070
1071 let download_dir = self
1072 .language_server_download_dir
1073 .clone()
1074 .expect("language server download directory has not been assigned before deleting server container");
1075
1076 cx.spawn(|_| async move {
1077 let container_dir = download_dir.join(adapter.name.0.as_ref());
1078 smol::fs::remove_dir_all(container_dir)
1079 .await
1080 .context("server container removal")
1081 .log_err();
1082 })
1083 }
1084
1085 pub fn next_language_server_id(&self) -> LanguageServerId {
1086 self.state.write().next_language_server_id()
1087 }
1088}
1089
1090impl LanguageRegistryState {
1091 fn next_language_server_id(&mut self) -> LanguageServerId {
1092 LanguageServerId(post_inc(&mut self.next_language_server_id))
1093 }
1094
1095 fn add(&mut self, language: Arc<Language>) {
1096 if let Some(theme) = self.theme.as_ref() {
1097 language.set_theme(&theme.syntax());
1098 }
1099 self.languages.push(language);
1100 self.version += 1;
1101 *self.subscription.0.borrow_mut() = ();
1102 }
1103
1104 #[cfg(debug_assertions)]
1105 fn reload(&mut self) {
1106 self.languages.clear();
1107 self.version += 1;
1108 self.reload_count += 1;
1109 for language in &mut self.available_languages {
1110 language.loaded = false;
1111 }
1112 *self.subscription.0.borrow_mut() = ();
1113 }
1114
1115 /// Mark the given language a having been loaded, so that the
1116 /// language registry won't try to load it again.
1117 fn mark_language_loaded(&mut self, id: AvailableLanguageId) {
1118 for language in &mut self.available_languages {
1119 if language.id == id {
1120 language.loaded = true;
1121 break;
1122 }
1123 }
1124 }
1125}
1126
1127#[cfg(any(test, feature = "test-support"))]
1128impl Default for LanguageRegistry {
1129 fn default() -> Self {
1130 Self::test()
1131 }
1132}
1133
1134async fn get_binary(
1135 adapter: Arc<CachedLspAdapter>,
1136 language: Arc<Language>,
1137 delegate: Arc<dyn LspAdapterDelegate>,
1138 container_dir: Arc<Path>,
1139 statuses: LspBinaryStatusSender,
1140 mut cx: AsyncAppContext,
1141) -> Result<LanguageServerBinary> {
1142 if !container_dir.exists() {
1143 smol::fs::create_dir_all(&container_dir)
1144 .await
1145 .context("failed to create container directory")?;
1146 }
1147
1148 if let Some(task) = adapter.will_fetch_server(&delegate, &mut cx) {
1149 task.await?;
1150 }
1151
1152 let binary = fetch_latest_binary(
1153 adapter.clone(),
1154 language.clone(),
1155 delegate.as_ref(),
1156 &container_dir,
1157 statuses.clone(),
1158 )
1159 .await;
1160
1161 if let Err(error) = binary.as_ref() {
1162 if let Some(binary) = adapter
1163 .cached_server_binary(container_dir.to_path_buf(), delegate.as_ref())
1164 .await
1165 {
1166 statuses.send(language.clone(), LanguageServerBinaryStatus::Cached);
1167 return Ok(binary);
1168 } else {
1169 statuses.send(
1170 language.clone(),
1171 LanguageServerBinaryStatus::Failed {
1172 error: format!("{:?}", error),
1173 },
1174 );
1175 }
1176 }
1177
1178 binary
1179}
1180
1181async fn fetch_latest_binary(
1182 adapter: Arc<CachedLspAdapter>,
1183 language: Arc<Language>,
1184 delegate: &dyn LspAdapterDelegate,
1185 container_dir: &Path,
1186 lsp_binary_statuses_tx: LspBinaryStatusSender,
1187) -> Result<LanguageServerBinary> {
1188 let container_dir: Arc<Path> = container_dir.into();
1189 lsp_binary_statuses_tx.send(
1190 language.clone(),
1191 LanguageServerBinaryStatus::CheckingForUpdate,
1192 );
1193
1194 let version_info = adapter.fetch_latest_server_version(delegate).await?;
1195 lsp_binary_statuses_tx.send(language.clone(), LanguageServerBinaryStatus::Downloading);
1196
1197 let binary = adapter
1198 .fetch_server_binary(version_info, container_dir.to_path_buf(), delegate)
1199 .await?;
1200 lsp_binary_statuses_tx.send(language.clone(), LanguageServerBinaryStatus::Downloaded);
1201
1202 Ok(binary)
1203}
1204
1205impl Language {
1206 pub fn new(config: LanguageConfig, ts_language: Option<tree_sitter::Language>) -> Self {
1207 Self {
1208 config,
1209 grammar: ts_language.map(|ts_language| {
1210 Arc::new(Grammar {
1211 id: NEXT_GRAMMAR_ID.fetch_add(1, SeqCst),
1212 highlights_query: None,
1213 brackets_config: None,
1214 outline_config: None,
1215 embedding_config: None,
1216 indents_config: None,
1217 injection_config: None,
1218 override_config: None,
1219 error_query: Query::new(&ts_language, "(ERROR) @error").unwrap(),
1220 ts_language,
1221 highlight_map: Default::default(),
1222 })
1223 }),
1224 adapters: Vec::new(),
1225
1226 #[cfg(any(test, feature = "test-support"))]
1227 fake_adapter: None,
1228 }
1229 }
1230
1231 pub fn lsp_adapters(&self) -> &[Arc<CachedLspAdapter>] {
1232 &self.adapters
1233 }
1234
1235 pub fn id(&self) -> Option<usize> {
1236 self.grammar.as_ref().map(|g| g.id)
1237 }
1238
1239 pub fn with_queries(mut self, queries: LanguageQueries) -> Result<Self> {
1240 if let Some(query) = queries.highlights {
1241 self = self
1242 .with_highlights_query(query.as_ref())
1243 .context("Error loading highlights query")?;
1244 }
1245 if let Some(query) = queries.brackets {
1246 self = self
1247 .with_brackets_query(query.as_ref())
1248 .context("Error loading brackets query")?;
1249 }
1250 if let Some(query) = queries.indents {
1251 self = self
1252 .with_indents_query(query.as_ref())
1253 .context("Error loading indents query")?;
1254 }
1255 if let Some(query) = queries.outline {
1256 self = self
1257 .with_outline_query(query.as_ref())
1258 .context("Error loading outline query")?;
1259 }
1260 if let Some(query) = queries.embedding {
1261 self = self
1262 .with_embedding_query(query.as_ref())
1263 .context("Error loading embedding query")?;
1264 }
1265 if let Some(query) = queries.injections {
1266 self = self
1267 .with_injection_query(query.as_ref())
1268 .context("Error loading injection query")?;
1269 }
1270 if let Some(query) = queries.overrides {
1271 self = self
1272 .with_override_query(query.as_ref())
1273 .context("Error loading override query")?;
1274 }
1275 Ok(self)
1276 }
1277
1278 pub fn with_highlights_query(mut self, source: &str) -> Result<Self> {
1279 let grammar = self.grammar_mut();
1280 grammar.highlights_query = Some(Query::new(&grammar.ts_language, source)?);
1281 Ok(self)
1282 }
1283
1284 pub fn with_outline_query(mut self, source: &str) -> Result<Self> {
1285 let grammar = self.grammar_mut();
1286 let query = Query::new(&grammar.ts_language, source)?;
1287 let mut item_capture_ix = None;
1288 let mut name_capture_ix = None;
1289 let mut context_capture_ix = None;
1290 let mut extra_context_capture_ix = None;
1291 get_capture_indices(
1292 &query,
1293 &mut [
1294 ("item", &mut item_capture_ix),
1295 ("name", &mut name_capture_ix),
1296 ("context", &mut context_capture_ix),
1297 ("context.extra", &mut extra_context_capture_ix),
1298 ],
1299 );
1300 if let Some((item_capture_ix, name_capture_ix)) = item_capture_ix.zip(name_capture_ix) {
1301 grammar.outline_config = Some(OutlineConfig {
1302 query,
1303 item_capture_ix,
1304 name_capture_ix,
1305 context_capture_ix,
1306 extra_context_capture_ix,
1307 });
1308 }
1309 Ok(self)
1310 }
1311
1312 pub fn with_embedding_query(mut self, source: &str) -> Result<Self> {
1313 let grammar = self.grammar_mut();
1314 let query = Query::new(&grammar.ts_language, source)?;
1315 let mut item_capture_ix = None;
1316 let mut name_capture_ix = None;
1317 let mut context_capture_ix = None;
1318 let mut collapse_capture_ix = None;
1319 let mut keep_capture_ix = None;
1320 get_capture_indices(
1321 &query,
1322 &mut [
1323 ("item", &mut item_capture_ix),
1324 ("name", &mut name_capture_ix),
1325 ("context", &mut context_capture_ix),
1326 ("keep", &mut keep_capture_ix),
1327 ("collapse", &mut collapse_capture_ix),
1328 ],
1329 );
1330 if let Some(item_capture_ix) = item_capture_ix {
1331 grammar.embedding_config = Some(EmbeddingConfig {
1332 query,
1333 item_capture_ix,
1334 name_capture_ix,
1335 context_capture_ix,
1336 collapse_capture_ix,
1337 keep_capture_ix,
1338 });
1339 }
1340 Ok(self)
1341 }
1342
1343 pub fn with_brackets_query(mut self, source: &str) -> Result<Self> {
1344 let grammar = self.grammar_mut();
1345 let query = Query::new(&grammar.ts_language, source)?;
1346 let mut open_capture_ix = None;
1347 let mut close_capture_ix = None;
1348 get_capture_indices(
1349 &query,
1350 &mut [
1351 ("open", &mut open_capture_ix),
1352 ("close", &mut close_capture_ix),
1353 ],
1354 );
1355 if let Some((open_capture_ix, close_capture_ix)) = open_capture_ix.zip(close_capture_ix) {
1356 grammar.brackets_config = Some(BracketConfig {
1357 query,
1358 open_capture_ix,
1359 close_capture_ix,
1360 });
1361 }
1362 Ok(self)
1363 }
1364
1365 pub fn with_indents_query(mut self, source: &str) -> Result<Self> {
1366 let grammar = self.grammar_mut();
1367 let query = Query::new(&grammar.ts_language, source)?;
1368 let mut indent_capture_ix = None;
1369 let mut start_capture_ix = None;
1370 let mut end_capture_ix = None;
1371 let mut outdent_capture_ix = None;
1372 get_capture_indices(
1373 &query,
1374 &mut [
1375 ("indent", &mut indent_capture_ix),
1376 ("start", &mut start_capture_ix),
1377 ("end", &mut end_capture_ix),
1378 ("outdent", &mut outdent_capture_ix),
1379 ],
1380 );
1381 if let Some(indent_capture_ix) = indent_capture_ix {
1382 grammar.indents_config = Some(IndentConfig {
1383 query,
1384 indent_capture_ix,
1385 start_capture_ix,
1386 end_capture_ix,
1387 outdent_capture_ix,
1388 });
1389 }
1390 Ok(self)
1391 }
1392
1393 pub fn with_injection_query(mut self, source: &str) -> Result<Self> {
1394 let grammar = self.grammar_mut();
1395 let query = Query::new(&grammar.ts_language, source)?;
1396 let mut language_capture_ix = None;
1397 let mut content_capture_ix = None;
1398 get_capture_indices(
1399 &query,
1400 &mut [
1401 ("language", &mut language_capture_ix),
1402 ("content", &mut content_capture_ix),
1403 ],
1404 );
1405 let patterns = (0..query.pattern_count())
1406 .map(|ix| {
1407 let mut config = InjectionPatternConfig::default();
1408 for setting in query.property_settings(ix) {
1409 match setting.key.as_ref() {
1410 "language" => {
1411 config.language = setting.value.clone();
1412 }
1413 "combined" => {
1414 config.combined = true;
1415 }
1416 _ => {}
1417 }
1418 }
1419 config
1420 })
1421 .collect();
1422 if let Some(content_capture_ix) = content_capture_ix {
1423 grammar.injection_config = Some(InjectionConfig {
1424 query,
1425 language_capture_ix,
1426 content_capture_ix,
1427 patterns,
1428 });
1429 }
1430 Ok(self)
1431 }
1432
1433 pub fn with_override_query(mut self, source: &str) -> anyhow::Result<Self> {
1434 let query = Query::new(&self.grammar_mut().ts_language, source)?;
1435
1436 let mut override_configs_by_id = HashMap::default();
1437 for (ix, name) in query.capture_names().iter().enumerate() {
1438 if !name.starts_with('_') {
1439 let value = self.config.overrides.remove(*name).unwrap_or_default();
1440 for server_name in &value.opt_into_language_servers {
1441 if !self
1442 .config
1443 .scope_opt_in_language_servers
1444 .contains(server_name)
1445 {
1446 util::debug_panic!("Server {server_name:?} has been opted-in by scope {name:?} but has not been marked as an opt-in server");
1447 }
1448 }
1449
1450 override_configs_by_id.insert(ix as u32, (name.to_string(), value));
1451 }
1452 }
1453
1454 if !self.config.overrides.is_empty() {
1455 let keys = self.config.overrides.keys().collect::<Vec<_>>();
1456 Err(anyhow!(
1457 "language {:?} has overrides in config not in query: {keys:?}",
1458 self.config.name
1459 ))?;
1460 }
1461
1462 for disabled_scope_name in self
1463 .config
1464 .brackets
1465 .disabled_scopes_by_bracket_ix
1466 .iter()
1467 .flatten()
1468 {
1469 if !override_configs_by_id
1470 .values()
1471 .any(|(scope_name, _)| scope_name == disabled_scope_name)
1472 {
1473 Err(anyhow!(
1474 "language {:?} has overrides in config not in query: {disabled_scope_name:?}",
1475 self.config.name
1476 ))?;
1477 }
1478 }
1479
1480 for (name, override_config) in override_configs_by_id.values_mut() {
1481 override_config.disabled_bracket_ixs = self
1482 .config
1483 .brackets
1484 .disabled_scopes_by_bracket_ix
1485 .iter()
1486 .enumerate()
1487 .filter_map(|(ix, disabled_scope_names)| {
1488 if disabled_scope_names.contains(name) {
1489 Some(ix as u16)
1490 } else {
1491 None
1492 }
1493 })
1494 .collect();
1495 }
1496
1497 self.config.brackets.disabled_scopes_by_bracket_ix.clear();
1498 self.grammar_mut().override_config = Some(OverrideConfig {
1499 query,
1500 values: override_configs_by_id,
1501 });
1502 Ok(self)
1503 }
1504
1505 fn grammar_mut(&mut self) -> &mut Grammar {
1506 Arc::get_mut(self.grammar.as_mut().unwrap()).unwrap()
1507 }
1508
1509 pub async fn with_lsp_adapters(mut self, lsp_adapters: Vec<Arc<dyn LspAdapter>>) -> Self {
1510 for adapter in lsp_adapters {
1511 self.adapters.push(CachedLspAdapter::new(adapter).await);
1512 }
1513 self
1514 }
1515
1516 #[cfg(any(test, feature = "test-support"))]
1517 pub async fn set_fake_lsp_adapter(
1518 &mut self,
1519 fake_lsp_adapter: Arc<FakeLspAdapter>,
1520 ) -> mpsc::UnboundedReceiver<lsp::FakeLanguageServer> {
1521 let (servers_tx, servers_rx) = mpsc::unbounded();
1522 self.fake_adapter = Some((servers_tx, fake_lsp_adapter.clone()));
1523 let adapter = CachedLspAdapter::new(Arc::new(fake_lsp_adapter)).await;
1524 self.adapters = vec![adapter];
1525 servers_rx
1526 }
1527
1528 pub fn name(&self) -> Arc<str> {
1529 self.config.name.clone()
1530 }
1531
1532 pub async fn disk_based_diagnostic_sources(&self) -> &[String] {
1533 match self.adapters.first().as_ref() {
1534 Some(adapter) => &adapter.disk_based_diagnostic_sources,
1535 None => &[],
1536 }
1537 }
1538
1539 pub async fn disk_based_diagnostics_progress_token(&self) -> Option<&str> {
1540 for adapter in &self.adapters {
1541 let token = adapter.disk_based_diagnostics_progress_token.as_deref();
1542 if token.is_some() {
1543 return token;
1544 }
1545 }
1546
1547 None
1548 }
1549
1550 pub async fn process_completion(self: &Arc<Self>, completion: &mut lsp::CompletionItem) {
1551 for adapter in &self.adapters {
1552 adapter.process_completion(completion).await;
1553 }
1554 }
1555
1556 pub async fn label_for_completion(
1557 self: &Arc<Self>,
1558 completion: &lsp::CompletionItem,
1559 ) -> Option<CodeLabel> {
1560 self.adapters
1561 .first()
1562 .as_ref()?
1563 .label_for_completion(completion, self)
1564 .await
1565 }
1566
1567 pub async fn label_for_symbol(
1568 self: &Arc<Self>,
1569 name: &str,
1570 kind: lsp::SymbolKind,
1571 ) -> Option<CodeLabel> {
1572 self.adapters
1573 .first()
1574 .as_ref()?
1575 .label_for_symbol(name, kind, self)
1576 .await
1577 }
1578
1579 pub fn highlight_text<'a>(
1580 self: &'a Arc<Self>,
1581 text: &'a Rope,
1582 range: Range<usize>,
1583 ) -> Vec<(Range<usize>, HighlightId)> {
1584 let mut result = Vec::new();
1585 if let Some(grammar) = &self.grammar {
1586 let tree = grammar.parse_text(text, None);
1587 let captures =
1588 SyntaxSnapshot::single_tree_captures(range.clone(), text, &tree, self, |grammar| {
1589 grammar.highlights_query.as_ref()
1590 });
1591 let highlight_maps = vec![grammar.highlight_map()];
1592 let mut offset = 0;
1593 for chunk in BufferChunks::new(text, range, Some((captures, highlight_maps)), vec![]) {
1594 let end_offset = offset + chunk.text.len();
1595 if let Some(highlight_id) = chunk.syntax_highlight_id {
1596 if !highlight_id.is_default() {
1597 result.push((offset..end_offset, highlight_id));
1598 }
1599 }
1600 offset = end_offset;
1601 }
1602 }
1603 result
1604 }
1605
1606 pub fn path_suffixes(&self) -> &[String] {
1607 &self.config.path_suffixes
1608 }
1609
1610 pub fn should_autoclose_before(&self, c: char) -> bool {
1611 c.is_whitespace() || self.config.autoclose_before.contains(c)
1612 }
1613
1614 pub fn set_theme(&self, theme: &SyntaxTheme) {
1615 if let Some(grammar) = self.grammar.as_ref() {
1616 if let Some(highlights_query) = &grammar.highlights_query {
1617 *grammar.highlight_map.lock() =
1618 HighlightMap::new(highlights_query.capture_names(), theme);
1619 }
1620 }
1621 }
1622
1623 pub fn grammar(&self) -> Option<&Arc<Grammar>> {
1624 self.grammar.as_ref()
1625 }
1626
1627 pub fn default_scope(self: &Arc<Self>) -> LanguageScope {
1628 LanguageScope {
1629 language: self.clone(),
1630 override_id: None,
1631 }
1632 }
1633
1634 pub fn prettier_parser_name(&self) -> Option<&str> {
1635 self.config.prettier_parser_name.as_deref()
1636 }
1637}
1638
1639impl LanguageScope {
1640 pub fn collapsed_placeholder(&self) -> &str {
1641 self.language.config.collapsed_placeholder.as_ref()
1642 }
1643
1644 pub fn line_comment_prefix(&self) -> Option<&Arc<str>> {
1645 Override::as_option(
1646 self.config_override().map(|o| &o.line_comment),
1647 self.language.config.line_comment.as_ref(),
1648 )
1649 }
1650
1651 pub fn block_comment_delimiters(&self) -> Option<(&Arc<str>, &Arc<str>)> {
1652 Override::as_option(
1653 self.config_override().map(|o| &o.block_comment),
1654 self.language.config.block_comment.as_ref(),
1655 )
1656 .map(|e| (&e.0, &e.1))
1657 }
1658
1659 pub fn word_characters(&self) -> Option<&HashSet<char>> {
1660 Override::as_option(
1661 self.config_override().map(|o| &o.word_characters),
1662 Some(&self.language.config.word_characters),
1663 )
1664 }
1665
1666 pub fn brackets(&self) -> impl Iterator<Item = (&BracketPair, bool)> {
1667 let mut disabled_ids = self
1668 .config_override()
1669 .map_or(&[] as _, |o| o.disabled_bracket_ixs.as_slice());
1670 self.language
1671 .config
1672 .brackets
1673 .pairs
1674 .iter()
1675 .enumerate()
1676 .map(move |(ix, bracket)| {
1677 let mut is_enabled = true;
1678 if let Some(next_disabled_ix) = disabled_ids.first() {
1679 if ix == *next_disabled_ix as usize {
1680 disabled_ids = &disabled_ids[1..];
1681 is_enabled = false;
1682 }
1683 }
1684 (bracket, is_enabled)
1685 })
1686 }
1687
1688 pub fn should_autoclose_before(&self, c: char) -> bool {
1689 c.is_whitespace() || self.language.config.autoclose_before.contains(c)
1690 }
1691
1692 pub fn language_allowed(&self, name: &LanguageServerName) -> bool {
1693 let config = &self.language.config;
1694 let opt_in_servers = &config.scope_opt_in_language_servers;
1695 if opt_in_servers.iter().any(|o| *o == *name.0) {
1696 if let Some(over) = self.config_override() {
1697 over.opt_into_language_servers.iter().any(|o| *o == *name.0)
1698 } else {
1699 false
1700 }
1701 } else {
1702 true
1703 }
1704 }
1705
1706 fn config_override(&self) -> Option<&LanguageConfigOverride> {
1707 let id = self.override_id?;
1708 let grammar = self.language.grammar.as_ref()?;
1709 let override_config = grammar.override_config.as_ref()?;
1710 override_config.values.get(&id).map(|e| &e.1)
1711 }
1712}
1713
1714impl Hash for Language {
1715 fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
1716 self.id().hash(state)
1717 }
1718}
1719
1720impl PartialEq for Language {
1721 fn eq(&self, other: &Self) -> bool {
1722 self.id().eq(&other.id())
1723 }
1724}
1725
1726impl Eq for Language {}
1727
1728impl Debug for Language {
1729 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1730 f.debug_struct("Language")
1731 .field("name", &self.config.name)
1732 .finish()
1733 }
1734}
1735
1736impl Grammar {
1737 pub fn id(&self) -> usize {
1738 self.id
1739 }
1740
1741 fn parse_text(&self, text: &Rope, old_tree: Option<Tree>) -> Tree {
1742 PARSER.with(|parser| {
1743 let mut parser = parser.borrow_mut();
1744 parser
1745 .set_language(&self.ts_language)
1746 .expect("incompatible grammar");
1747 let mut chunks = text.chunks_in_range(0..text.len());
1748 parser
1749 .parse_with(
1750 &mut move |offset, _| {
1751 chunks.seek(offset);
1752 chunks.next().unwrap_or("").as_bytes()
1753 },
1754 old_tree.as_ref(),
1755 )
1756 .unwrap()
1757 })
1758 }
1759
1760 pub fn highlight_map(&self) -> HighlightMap {
1761 self.highlight_map.lock().clone()
1762 }
1763
1764 pub fn highlight_id_for_name(&self, name: &str) -> Option<HighlightId> {
1765 let capture_id = self
1766 .highlights_query
1767 .as_ref()?
1768 .capture_index_for_name(name)?;
1769 Some(self.highlight_map.lock().get(capture_id))
1770 }
1771}
1772
1773impl CodeLabel {
1774 pub fn plain(text: String, filter_text: Option<&str>) -> Self {
1775 let mut result = Self {
1776 runs: Vec::new(),
1777 filter_range: 0..text.len(),
1778 text,
1779 };
1780 if let Some(filter_text) = filter_text {
1781 if let Some(ix) = result.text.find(filter_text) {
1782 result.filter_range = ix..ix + filter_text.len();
1783 }
1784 }
1785 result
1786 }
1787}
1788
1789#[cfg(any(test, feature = "test-support"))]
1790impl Default for FakeLspAdapter {
1791 fn default() -> Self {
1792 Self {
1793 name: "the-fake-language-server",
1794 capabilities: lsp::LanguageServer::full_capabilities(),
1795 initializer: None,
1796 disk_based_diagnostics_progress_token: None,
1797 initialization_options: None,
1798 disk_based_diagnostics_sources: Vec::new(),
1799 prettier_plugins: Vec::new(),
1800 }
1801 }
1802}
1803
1804#[cfg(any(test, feature = "test-support"))]
1805#[async_trait]
1806impl LspAdapter for Arc<FakeLspAdapter> {
1807 async fn name(&self) -> LanguageServerName {
1808 LanguageServerName(self.name.into())
1809 }
1810
1811 fn short_name(&self) -> &'static str {
1812 "FakeLspAdapter"
1813 }
1814
1815 async fn fetch_latest_server_version(
1816 &self,
1817 _: &dyn LspAdapterDelegate,
1818 ) -> Result<Box<dyn 'static + Send + Any>> {
1819 unreachable!();
1820 }
1821
1822 async fn fetch_server_binary(
1823 &self,
1824 _: Box<dyn 'static + Send + Any>,
1825 _: PathBuf,
1826 _: &dyn LspAdapterDelegate,
1827 ) -> Result<LanguageServerBinary> {
1828 unreachable!();
1829 }
1830
1831 async fn cached_server_binary(
1832 &self,
1833 _: PathBuf,
1834 _: &dyn LspAdapterDelegate,
1835 ) -> Option<LanguageServerBinary> {
1836 unreachable!();
1837 }
1838
1839 async fn installation_test_binary(&self, _: PathBuf) -> Option<LanguageServerBinary> {
1840 unreachable!();
1841 }
1842
1843 fn process_diagnostics(&self, _: &mut lsp::PublishDiagnosticsParams) {}
1844
1845 async fn disk_based_diagnostic_sources(&self) -> Vec<String> {
1846 self.disk_based_diagnostics_sources.clone()
1847 }
1848
1849 async fn disk_based_diagnostics_progress_token(&self) -> Option<String> {
1850 self.disk_based_diagnostics_progress_token.clone()
1851 }
1852
1853 async fn initialization_options(&self) -> Option<Value> {
1854 self.initialization_options.clone()
1855 }
1856
1857 fn prettier_plugins(&self) -> &[&'static str] {
1858 &self.prettier_plugins
1859 }
1860}
1861
1862fn get_capture_indices(query: &Query, captures: &mut [(&str, &mut Option<u32>)]) {
1863 for (ix, name) in query.capture_names().iter().enumerate() {
1864 for (capture_name, index) in captures.iter_mut() {
1865 if capture_name == name {
1866 **index = Some(ix as u32);
1867 break;
1868 }
1869 }
1870 }
1871}
1872
1873pub fn point_to_lsp(point: PointUtf16) -> lsp::Position {
1874 lsp::Position::new(point.row, point.column)
1875}
1876
1877pub fn point_from_lsp(point: lsp::Position) -> Unclipped<PointUtf16> {
1878 Unclipped(PointUtf16::new(point.line, point.character))
1879}
1880
1881pub fn range_to_lsp(range: Range<PointUtf16>) -> lsp::Range {
1882 lsp::Range {
1883 start: point_to_lsp(range.start),
1884 end: point_to_lsp(range.end),
1885 }
1886}
1887
1888pub fn range_from_lsp(range: lsp::Range) -> Range<Unclipped<PointUtf16>> {
1889 let mut start = point_from_lsp(range.start);
1890 let mut end = point_from_lsp(range.end);
1891 if start > end {
1892 mem::swap(&mut start, &mut end);
1893 }
1894 start..end
1895}
1896
1897#[cfg(test)]
1898mod tests {
1899 use super::*;
1900 use gpui::TestAppContext;
1901
1902 #[gpui::test(iterations = 10)]
1903 async fn test_first_line_pattern(cx: &mut TestAppContext) {
1904 let mut languages = LanguageRegistry::test();
1905
1906 languages.set_executor(cx.executor());
1907 let languages = Arc::new(languages);
1908 languages.register(
1909 "/javascript",
1910 LanguageConfig {
1911 name: "JavaScript".into(),
1912 path_suffixes: vec!["js".into()],
1913 first_line_pattern: Some(Regex::new(r"\bnode\b").unwrap()),
1914 ..Default::default()
1915 },
1916 tree_sitter_typescript::language_tsx(),
1917 vec![],
1918 |_| Default::default(),
1919 );
1920
1921 languages
1922 .language_for_file("the/script", None)
1923 .await
1924 .unwrap_err();
1925 languages
1926 .language_for_file("the/script", Some(&"nothing".into()))
1927 .await
1928 .unwrap_err();
1929 assert_eq!(
1930 languages
1931 .language_for_file("the/script", Some(&"#!/bin/env node".into()))
1932 .await
1933 .unwrap()
1934 .name()
1935 .as_ref(),
1936 "JavaScript"
1937 );
1938 }
1939
1940 #[gpui::test(iterations = 10)]
1941 async fn test_language_loading(cx: &mut TestAppContext) {
1942 let mut languages = LanguageRegistry::test();
1943 languages.set_executor(cx.executor());
1944 let languages = Arc::new(languages);
1945 languages.register(
1946 "/JSON",
1947 LanguageConfig {
1948 name: "JSON".into(),
1949 path_suffixes: vec!["json".into()],
1950 ..Default::default()
1951 },
1952 tree_sitter_json::language(),
1953 vec![],
1954 |_| Default::default(),
1955 );
1956 languages.register(
1957 "/rust",
1958 LanguageConfig {
1959 name: "Rust".into(),
1960 path_suffixes: vec!["rs".into()],
1961 ..Default::default()
1962 },
1963 tree_sitter_rust::language(),
1964 vec![],
1965 |_| Default::default(),
1966 );
1967 assert_eq!(
1968 languages.language_names(),
1969 &[
1970 "JSON".to_string(),
1971 "Plain Text".to_string(),
1972 "Rust".to_string(),
1973 ]
1974 );
1975
1976 let rust1 = languages.language_for_name("Rust");
1977 let rust2 = languages.language_for_name("Rust");
1978
1979 // Ensure language is still listed even if it's being loaded.
1980 assert_eq!(
1981 languages.language_names(),
1982 &[
1983 "JSON".to_string(),
1984 "Plain Text".to_string(),
1985 "Rust".to_string(),
1986 ]
1987 );
1988
1989 let (rust1, rust2) = futures::join!(rust1, rust2);
1990 assert!(Arc::ptr_eq(&rust1.unwrap(), &rust2.unwrap()));
1991
1992 // Ensure language is still listed even after loading it.
1993 assert_eq!(
1994 languages.language_names(),
1995 &[
1996 "JSON".to_string(),
1997 "Plain Text".to_string(),
1998 "Rust".to_string(),
1999 ]
2000 );
2001
2002 // Loading an unknown language returns an error.
2003 assert!(languages.language_for_name("Unknown").await.is_err());
2004 }
2005}