1mod buffer;
2mod diagnostic_set;
3mod highlight_map;
4mod outline;
5pub mod proto;
6#[cfg(test)]
7mod tests;
8
9use anyhow::{anyhow, Context, Result};
10use async_trait::async_trait;
11use client::http::HttpClient;
12use collections::HashMap;
13use futures::{
14 future::{BoxFuture, Shared},
15 FutureExt, TryFutureExt,
16};
17use gpui::{MutableAppContext, Task};
18use highlight_map::HighlightMap;
19use lazy_static::lazy_static;
20use parking_lot::{Mutex, RwLock};
21use regex::Regex;
22use serde::{de, Deserialize, Deserializer};
23use serde_json::Value;
24use std::{
25 any::Any,
26 cell::RefCell,
27 mem,
28 ops::Range,
29 path::{Path, PathBuf},
30 str,
31 sync::Arc,
32};
33use theme::SyntaxTheme;
34use tree_sitter::{self, Query};
35use util::ResultExt;
36
37#[cfg(any(test, feature = "test-support"))]
38use futures::channel::mpsc;
39
40pub use buffer::Operation;
41pub use buffer::*;
42pub use diagnostic_set::DiagnosticEntry;
43pub use outline::{Outline, OutlineItem};
44pub use tree_sitter::{Parser, Tree};
45
46thread_local! {
47 static PARSER: RefCell<Parser> = RefCell::new(Parser::new());
48}
49
50lazy_static! {
51 pub static ref PLAIN_TEXT: Arc<Language> = Arc::new(Language::new(
52 LanguageConfig {
53 name: "Plain Text".into(),
54 ..Default::default()
55 },
56 None,
57 ));
58}
59
60pub trait ToLspPosition {
61 fn to_lsp_position(self) -> lsp::Position;
62}
63
64#[derive(Clone, Debug, PartialEq, Eq, Hash)]
65pub struct LanguageServerName(pub Arc<str>);
66
67/// Represents a Language Server, with certain cached sync properties.
68/// Uses [`LspAdapterTrait`] under the hood, but calls all 'static' methods
69/// once at startup, and caches the results.
70pub struct LspAdapter {
71 pub name: LanguageServerName,
72 pub server_args: Vec<String>,
73 pub initialization_options: Option<Value>,
74 pub disk_based_diagnostic_sources: Vec<String>,
75 pub disk_based_diagnostics_progress_token: Option<String>,
76 pub id_for_language: Option<String>,
77 pub adapter: Box<dyn LspAdapterTrait>,
78}
79
80impl LspAdapter {
81 pub async fn new<T: LspAdapterTrait>(adapter: T) -> Arc<Self> {
82 let adapter = Box::new(adapter);
83 let name = adapter.name().await;
84 let server_args = adapter.server_args().await;
85 let initialization_options = adapter.initialization_options().await;
86 let disk_based_diagnostic_sources = adapter.disk_based_diagnostic_sources().await;
87 let disk_based_diagnostics_progress_token =
88 adapter.disk_based_diagnostics_progress_token().await;
89 let id_for_language = adapter.id_for_language(name.0.as_ref()).await;
90
91 Arc::new(LspAdapter {
92 name,
93 server_args,
94 initialization_options,
95 disk_based_diagnostic_sources,
96 disk_based_diagnostics_progress_token,
97 id_for_language,
98 adapter,
99 })
100 }
101
102 pub async fn fetch_latest_server_version(
103 &self,
104 http: Arc<dyn HttpClient>,
105 ) -> Result<Box<dyn 'static + Send + Any>> {
106 self.adapter.fetch_latest_server_version(http).await
107 }
108
109 pub async fn fetch_server_binary(
110 &self,
111 version: Box<dyn 'static + Send + Any>,
112 http: Arc<dyn HttpClient>,
113 container_dir: PathBuf,
114 ) -> Result<PathBuf> {
115 self.adapter
116 .fetch_server_binary(version, http, container_dir)
117 .await
118 }
119
120 pub async fn cached_server_binary(&self, container_dir: PathBuf) -> Option<PathBuf> {
121 self.adapter.cached_server_binary(container_dir).await
122 }
123
124 pub async fn process_diagnostics(&self, params: &mut lsp::PublishDiagnosticsParams) {
125 self.adapter.process_diagnostics(params).await
126 }
127
128 pub async fn label_for_completion(
129 &self,
130 completion_item: &lsp::CompletionItem,
131 language: &Language,
132 ) -> Option<CodeLabel> {
133 self.adapter
134 .label_for_completion(completion_item, language)
135 .await
136 }
137
138 pub async fn label_for_symbol(
139 &self,
140 name: &str,
141 kind: lsp::SymbolKind,
142 language: &Language,
143 ) -> Option<CodeLabel> {
144 self.adapter.label_for_symbol(name, kind, language).await
145 }
146}
147
148#[async_trait]
149pub trait LspAdapterTrait: 'static + Send + Sync {
150 async fn name(&self) -> LanguageServerName;
151
152 async fn fetch_latest_server_version(
153 &self,
154 http: Arc<dyn HttpClient>,
155 ) -> Result<Box<dyn 'static + Send + Any>>;
156
157 async fn fetch_server_binary(
158 &self,
159 version: Box<dyn 'static + Send + Any>,
160 http: Arc<dyn HttpClient>,
161 container_dir: PathBuf,
162 ) -> Result<PathBuf>;
163
164 async fn cached_server_binary(&self, container_dir: PathBuf) -> Option<PathBuf>;
165
166 async fn process_diagnostics(&self, _: &mut lsp::PublishDiagnosticsParams) {}
167
168 async fn label_for_completion(
169 &self,
170 _: &lsp::CompletionItem,
171 _: &Language,
172 ) -> Option<CodeLabel> {
173 None
174 }
175
176 async fn label_for_symbol(
177 &self,
178 _: &str,
179 _: lsp::SymbolKind,
180 _: &Language,
181 ) -> Option<CodeLabel> {
182 None
183 }
184
185 async fn server_args(&self) -> Vec<String> {
186 Vec::new()
187 }
188
189 async fn initialization_options(&self) -> Option<Value> {
190 None
191 }
192
193 async fn disk_based_diagnostic_sources(&self) -> Vec<String> {
194 Default::default()
195 }
196
197 async fn disk_based_diagnostics_progress_token(&self) -> Option<String> {
198 None
199 }
200
201 async fn id_for_language(&self, _name: &str) -> Option<String> {
202 None
203 }
204}
205
206#[derive(Clone, Debug, PartialEq, Eq)]
207pub struct CodeLabel {
208 pub text: String,
209 pub runs: Vec<(Range<usize>, HighlightId)>,
210 pub filter_range: Range<usize>,
211}
212
213#[derive(Deserialize)]
214pub struct LanguageConfig {
215 pub name: Arc<str>,
216 pub path_suffixes: Vec<String>,
217 pub brackets: Vec<BracketPair>,
218 #[serde(default = "auto_indent_using_last_non_empty_line_default")]
219 pub auto_indent_using_last_non_empty_line: bool,
220 #[serde(default, deserialize_with = "deserialize_regex")]
221 pub increase_indent_pattern: Option<Regex>,
222 #[serde(default, deserialize_with = "deserialize_regex")]
223 pub decrease_indent_pattern: Option<Regex>,
224 #[serde(default)]
225 pub autoclose_before: String,
226 pub line_comment: Option<String>,
227}
228
229impl Default for LanguageConfig {
230 fn default() -> Self {
231 Self {
232 name: "".into(),
233 path_suffixes: Default::default(),
234 brackets: Default::default(),
235 auto_indent_using_last_non_empty_line: auto_indent_using_last_non_empty_line_default(),
236 increase_indent_pattern: Default::default(),
237 decrease_indent_pattern: Default::default(),
238 autoclose_before: Default::default(),
239 line_comment: Default::default(),
240 }
241 }
242}
243
244fn auto_indent_using_last_non_empty_line_default() -> bool {
245 true
246}
247
248fn deserialize_regex<'de, D: Deserializer<'de>>(d: D) -> Result<Option<Regex>, D::Error> {
249 let source = Option::<String>::deserialize(d)?;
250 if let Some(source) = source {
251 Ok(Some(regex::Regex::new(&source).map_err(de::Error::custom)?))
252 } else {
253 Ok(None)
254 }
255}
256
257#[cfg(any(test, feature = "test-support"))]
258pub type FakeLspAdapter = Arc<FakeLspAdapterInner>;
259
260pub struct FakeLspAdapterInner {
261 pub name: &'static str,
262 pub capabilities: lsp::ServerCapabilities,
263 pub initializer: Option<Box<dyn 'static + Send + Sync + Fn(&mut lsp::FakeLanguageServer)>>,
264 pub disk_based_diagnostics_progress_token: Option<String>,
265 pub disk_based_diagnostics_sources: Vec<String>,
266}
267
268#[derive(Clone, Debug, Deserialize)]
269pub struct BracketPair {
270 pub start: String,
271 pub end: String,
272 pub close: bool,
273 pub newline: bool,
274}
275
276pub struct Language {
277 pub(crate) config: LanguageConfig,
278 pub(crate) grammar: Option<Arc<Grammar>>,
279 pub(crate) adapter: Option<Arc<LspAdapter>>,
280
281 #[cfg(any(test, feature = "test-support"))]
282 fake_adapter: Option<(
283 mpsc::UnboundedSender<lsp::FakeLanguageServer>,
284 FakeLspAdapter,
285 )>,
286}
287
288pub struct Grammar {
289 pub(crate) ts_language: tree_sitter::Language,
290 pub(crate) highlights_query: Option<Query>,
291 pub(crate) brackets_query: Option<Query>,
292 pub(crate) indents_query: Option<Query>,
293 pub(crate) outline_query: Option<Query>,
294 pub(crate) highlight_map: Mutex<HighlightMap>,
295}
296
297#[derive(Clone)]
298pub enum LanguageServerBinaryStatus {
299 CheckingForUpdate,
300 Downloading,
301 Downloaded,
302 Cached,
303 Failed { error: String },
304}
305
306pub struct LanguageRegistry {
307 languages: RwLock<Vec<Arc<Language>>>,
308 language_server_download_dir: Option<Arc<Path>>,
309 lsp_binary_statuses_tx: async_broadcast::Sender<(Arc<Language>, LanguageServerBinaryStatus)>,
310 lsp_binary_statuses_rx: async_broadcast::Receiver<(Arc<Language>, LanguageServerBinaryStatus)>,
311 login_shell_env_loaded: Shared<Task<()>>,
312 lsp_binary_paths: Mutex<
313 HashMap<
314 LanguageServerName,
315 Shared<BoxFuture<'static, Result<PathBuf, Arc<anyhow::Error>>>>,
316 >,
317 >,
318}
319
320impl LanguageRegistry {
321 pub fn new(login_shell_env_loaded: Task<()>) -> Self {
322 let (lsp_binary_statuses_tx, lsp_binary_statuses_rx) = async_broadcast::broadcast(16);
323 Self {
324 language_server_download_dir: None,
325 languages: Default::default(),
326 lsp_binary_statuses_tx,
327 lsp_binary_statuses_rx,
328 login_shell_env_loaded: login_shell_env_loaded.shared(),
329 lsp_binary_paths: Default::default(),
330 }
331 }
332
333 #[cfg(any(test, feature = "test-support"))]
334 pub fn test() -> Self {
335 Self::new(Task::ready(()))
336 }
337
338 pub fn add(&self, language: Arc<Language>) {
339 self.languages.write().push(language.clone());
340 }
341
342 pub fn set_theme(&self, theme: &SyntaxTheme) {
343 for language in self.languages.read().iter() {
344 language.set_theme(theme);
345 }
346 }
347
348 pub fn set_language_server_download_dir(&mut self, path: impl Into<Arc<Path>>) {
349 self.language_server_download_dir = Some(path.into());
350 }
351
352 pub fn get_language(&self, name: &str) -> Option<Arc<Language>> {
353 self.languages
354 .read()
355 .iter()
356 .find(|language| language.name().to_lowercase() == name.to_lowercase())
357 .cloned()
358 }
359
360 pub fn to_vec(&self) -> Vec<Arc<Language>> {
361 self.languages.read().iter().cloned().collect()
362 }
363
364 pub fn language_names(&self) -> Vec<String> {
365 self.languages
366 .read()
367 .iter()
368 .map(|language| language.name().to_string())
369 .collect()
370 }
371
372 pub fn select_language(&self, path: impl AsRef<Path>) -> Option<Arc<Language>> {
373 let path = path.as_ref();
374 let filename = path.file_name().and_then(|name| name.to_str());
375 let extension = path.extension().and_then(|name| name.to_str());
376 let path_suffixes = [extension, filename];
377 self.languages
378 .read()
379 .iter()
380 .find(|language| {
381 language
382 .config
383 .path_suffixes
384 .iter()
385 .any(|suffix| dbg!(path_suffixes.contains(&Some(dbg!(suffix.as_str())))))
386 })
387 .cloned()
388 }
389
390 pub fn start_language_server(
391 self: &Arc<Self>,
392 server_id: usize,
393 language: Arc<Language>,
394 root_path: Arc<Path>,
395 http_client: Arc<dyn HttpClient>,
396 cx: &mut MutableAppContext,
397 ) -> Option<Task<Result<lsp::LanguageServer>>> {
398 #[cfg(any(test, feature = "test-support"))]
399 if language.fake_adapter.is_some() {
400 let language = language.clone();
401 return Some(cx.spawn(|cx| async move {
402 let (servers_tx, fake_adapter) = language.fake_adapter.as_ref().unwrap();
403 let (server, mut fake_server) = lsp::LanguageServer::fake(
404 fake_adapter.name.to_string(),
405 fake_adapter.capabilities.clone(),
406 cx.clone(),
407 );
408
409 if let Some(initializer) = &fake_adapter.initializer {
410 initializer(&mut fake_server);
411 }
412
413 let servers_tx = servers_tx.clone();
414 cx.background()
415 .spawn(async move {
416 if fake_server
417 .try_receive_notification::<lsp::notification::Initialized>()
418 .await
419 .is_some()
420 {
421 servers_tx.unbounded_send(fake_server).ok();
422 }
423 })
424 .detach();
425 Ok(server)
426 }));
427 }
428
429 let download_dir = self
430 .language_server_download_dir
431 .clone()
432 .ok_or_else(|| anyhow!("language server download directory has not been assigned"))
433 .log_err()?;
434
435 let this = self.clone();
436 let adapter = language.adapter.clone()?;
437 let lsp_binary_statuses = self.lsp_binary_statuses_tx.clone();
438 let login_shell_env_loaded = self.login_shell_env_loaded.clone();
439 Some(cx.spawn(|cx| async move {
440 login_shell_env_loaded.await;
441 let server_binary_path = this
442 .lsp_binary_paths
443 .lock()
444 .entry(adapter.name.clone())
445 .or_insert_with(|| {
446 get_server_binary_path(
447 adapter.clone(),
448 language.clone(),
449 http_client,
450 download_dir,
451 lsp_binary_statuses,
452 )
453 .map_err(Arc::new)
454 .boxed()
455 .shared()
456 })
457 .clone()
458 .map_err(|e| anyhow!(e));
459
460 let server_binary_path = server_binary_path.await?;
461 let server_args = &adapter.server_args;
462 let server = lsp::LanguageServer::new(
463 server_id,
464 &server_binary_path,
465 &server_args,
466 &root_path,
467 cx,
468 )?;
469 Ok(server)
470 }))
471 }
472
473 pub fn language_server_binary_statuses(
474 &self,
475 ) -> async_broadcast::Receiver<(Arc<Language>, LanguageServerBinaryStatus)> {
476 self.lsp_binary_statuses_rx.clone()
477 }
478}
479
480async fn get_server_binary_path(
481 adapter: Arc<LspAdapter>,
482 language: Arc<Language>,
483 http_client: Arc<dyn HttpClient>,
484 download_dir: Arc<Path>,
485 statuses: async_broadcast::Sender<(Arc<Language>, LanguageServerBinaryStatus)>,
486) -> Result<PathBuf> {
487 let container_dir = download_dir.join(adapter.name.0.as_ref());
488 if !container_dir.exists() {
489 smol::fs::create_dir_all(&container_dir)
490 .await
491 .context("failed to create container directory")?;
492 }
493
494 let path = fetch_latest_server_binary_path(
495 adapter.clone(),
496 language.clone(),
497 http_client,
498 &container_dir,
499 statuses.clone(),
500 )
501 .await;
502 if let Err(error) = path.as_ref() {
503 if let Some(cached_path) = adapter.cached_server_binary(container_dir).await {
504 statuses
505 .broadcast((language.clone(), LanguageServerBinaryStatus::Cached))
506 .await?;
507 return Ok(cached_path);
508 } else {
509 statuses
510 .broadcast((
511 language.clone(),
512 LanguageServerBinaryStatus::Failed {
513 error: format!("{:?}", error),
514 },
515 ))
516 .await?;
517 }
518 }
519 path
520}
521
522async fn fetch_latest_server_binary_path(
523 adapter: Arc<LspAdapter>,
524 language: Arc<Language>,
525 http_client: Arc<dyn HttpClient>,
526 container_dir: &Path,
527 lsp_binary_statuses_tx: async_broadcast::Sender<(Arc<Language>, LanguageServerBinaryStatus)>,
528) -> Result<PathBuf> {
529 let container_dir: Arc<Path> = container_dir.into();
530 lsp_binary_statuses_tx
531 .broadcast((
532 language.clone(),
533 LanguageServerBinaryStatus::CheckingForUpdate,
534 ))
535 .await?;
536 let version_info = adapter
537 .fetch_latest_server_version(http_client.clone())
538 .await?;
539 lsp_binary_statuses_tx
540 .broadcast((language.clone(), LanguageServerBinaryStatus::Downloading))
541 .await?;
542 let path = adapter
543 .fetch_server_binary(version_info, http_client, container_dir.clone())
544 .await?;
545 lsp_binary_statuses_tx
546 .broadcast((language.clone(), LanguageServerBinaryStatus::Downloaded))
547 .await?;
548 Ok(path)
549}
550
551impl Language {
552 pub fn new(config: LanguageConfig, ts_language: Option<tree_sitter::Language>) -> Self {
553 Self {
554 config,
555 grammar: ts_language.map(|ts_language| {
556 Arc::new(Grammar {
557 highlights_query: None,
558 brackets_query: None,
559 indents_query: None,
560 outline_query: None,
561 ts_language,
562 highlight_map: Default::default(),
563 })
564 }),
565 adapter: None,
566
567 #[cfg(any(test, feature = "test-support"))]
568 fake_adapter: None,
569 }
570 }
571
572 pub fn lsp_adapter(&self) -> Option<Arc<LspAdapter>> {
573 self.adapter.clone()
574 }
575
576 pub fn with_highlights_query(mut self, source: &str) -> Result<Self> {
577 let grammar = self.grammar_mut();
578 grammar.highlights_query = Some(Query::new(grammar.ts_language, source)?);
579 Ok(self)
580 }
581
582 pub fn with_brackets_query(mut self, source: &str) -> Result<Self> {
583 let grammar = self.grammar_mut();
584 grammar.brackets_query = Some(Query::new(grammar.ts_language, source)?);
585 Ok(self)
586 }
587
588 pub fn with_indents_query(mut self, source: &str) -> Result<Self> {
589 let grammar = self.grammar_mut();
590 grammar.indents_query = Some(Query::new(grammar.ts_language, source)?);
591 Ok(self)
592 }
593
594 pub fn with_outline_query(mut self, source: &str) -> Result<Self> {
595 let grammar = self.grammar_mut();
596 grammar.outline_query = Some(Query::new(grammar.ts_language, source)?);
597 Ok(self)
598 }
599
600 fn grammar_mut(&mut self) -> &mut Grammar {
601 Arc::get_mut(self.grammar.as_mut().unwrap()).unwrap()
602 }
603
604 pub fn with_lsp_adapter(mut self, lsp_adapter: Arc<LspAdapter>) -> Self {
605 self.adapter = Some(lsp_adapter);
606 self
607 }
608
609 #[cfg(any(test, feature = "test-support"))]
610 pub fn set_fake_lsp_adapter(
611 &mut self,
612 fake_lsp_adapter: FakeLspAdapter,
613 ) -> mpsc::UnboundedReceiver<lsp::FakeLanguageServer> {
614 let (servers_tx, servers_rx) = mpsc::unbounded();
615 self.fake_adapter = Some((servers_tx, fake_lsp_adapter.clone()));
616 let adapter = smol::block_on(LspAdapter::new(fake_lsp_adapter));
617 self.adapter = Some(adapter);
618 servers_rx
619 }
620
621 pub fn name(&self) -> Arc<str> {
622 self.config.name.clone()
623 }
624
625 pub fn line_comment_prefix(&self) -> Option<&str> {
626 self.config.line_comment.as_deref()
627 }
628
629 pub async fn disk_based_diagnostic_sources(&self) -> &[String] {
630 match self.adapter.as_ref() {
631 Some(adapter) => &adapter.disk_based_diagnostic_sources,
632 None => &[],
633 }
634 }
635
636 pub async fn disk_based_diagnostics_progress_token(&self) -> Option<&str> {
637 if let Some(adapter) = self.adapter.as_ref() {
638 adapter.disk_based_diagnostics_progress_token.as_deref()
639 } else {
640 None
641 }
642 }
643
644 pub async fn process_diagnostics(&self, diagnostics: &mut lsp::PublishDiagnosticsParams) {
645 if let Some(processor) = self.adapter.as_ref() {
646 processor.process_diagnostics(diagnostics).await;
647 }
648 }
649
650 pub async fn label_for_completion(
651 &self,
652 completion: &lsp::CompletionItem,
653 ) -> Option<CodeLabel> {
654 self.adapter
655 .as_ref()?
656 .label_for_completion(completion, self)
657 .await
658 }
659
660 pub async fn label_for_symbol(&self, name: &str, kind: lsp::SymbolKind) -> Option<CodeLabel> {
661 self.adapter
662 .as_ref()?
663 .label_for_symbol(name, kind, self)
664 .await
665 }
666
667 pub fn highlight_text<'a>(
668 &'a self,
669 text: &'a Rope,
670 range: Range<usize>,
671 ) -> Vec<(Range<usize>, HighlightId)> {
672 let mut result = Vec::new();
673 if let Some(grammar) = &self.grammar {
674 let tree = grammar.parse_text(text, None);
675 let mut offset = 0;
676 for chunk in BufferChunks::new(text, range, Some(&tree), self.grammar.as_ref(), vec![])
677 {
678 let end_offset = offset + chunk.text.len();
679 if let Some(highlight_id) = chunk.syntax_highlight_id {
680 if !highlight_id.is_default() {
681 result.push((offset..end_offset, highlight_id));
682 }
683 }
684 offset = end_offset;
685 }
686 }
687 result
688 }
689
690 pub fn brackets(&self) -> &[BracketPair] {
691 &self.config.brackets
692 }
693
694 pub fn path_suffixes(&self) -> &[String] {
695 &self.config.path_suffixes
696 }
697
698 pub fn should_autoclose_before(&self, c: char) -> bool {
699 c.is_whitespace() || self.config.autoclose_before.contains(c)
700 }
701
702 pub fn set_theme(&self, theme: &SyntaxTheme) {
703 if let Some(grammar) = self.grammar.as_ref() {
704 if let Some(highlights_query) = &grammar.highlights_query {
705 *grammar.highlight_map.lock() =
706 HighlightMap::new(highlights_query.capture_names(), theme);
707 }
708 }
709 }
710
711 pub fn grammar(&self) -> Option<&Arc<Grammar>> {
712 self.grammar.as_ref()
713 }
714}
715
716impl Grammar {
717 fn parse_text(&self, text: &Rope, old_tree: Option<Tree>) -> Tree {
718 PARSER.with(|parser| {
719 let mut parser = parser.borrow_mut();
720 parser
721 .set_language(self.ts_language)
722 .expect("incompatible grammar");
723 let mut chunks = text.chunks_in_range(0..text.len());
724 parser
725 .parse_with(
726 &mut move |offset, _| {
727 chunks.seek(offset);
728 chunks.next().unwrap_or("").as_bytes()
729 },
730 old_tree.as_ref(),
731 )
732 .unwrap()
733 })
734 }
735
736 pub fn highlight_map(&self) -> HighlightMap {
737 self.highlight_map.lock().clone()
738 }
739
740 pub fn highlight_id_for_name(&self, name: &str) -> Option<HighlightId> {
741 let capture_id = self
742 .highlights_query
743 .as_ref()?
744 .capture_index_for_name(name)?;
745 Some(self.highlight_map.lock().get(capture_id))
746 }
747}
748
749impl CodeLabel {
750 pub fn plain(text: String, filter_text: Option<&str>) -> Self {
751 let mut result = Self {
752 runs: Vec::new(),
753 filter_range: 0..text.len(),
754 text,
755 };
756 if let Some(filter_text) = filter_text {
757 if let Some(ix) = result.text.find(filter_text) {
758 result.filter_range = ix..ix + filter_text.len();
759 }
760 }
761 result
762 }
763}
764
765#[cfg(any(test, feature = "test-support"))]
766impl Default for FakeLspAdapterInner {
767 fn default() -> Self {
768 Self {
769 name: "the-fake-language-server",
770 capabilities: lsp::LanguageServer::full_capabilities(),
771 initializer: None,
772 disk_based_diagnostics_progress_token: None,
773 disk_based_diagnostics_sources: Vec::new(),
774 }
775 }
776}
777
778#[cfg(any(test, feature = "test-support"))]
779#[async_trait]
780impl LspAdapterTrait for FakeLspAdapter {
781 async fn name(&self) -> LanguageServerName {
782 LanguageServerName(self.name.into())
783 }
784
785 async fn fetch_latest_server_version(
786 &self,
787 _: Arc<dyn HttpClient>,
788 ) -> Result<Box<dyn 'static + Send + Any>> {
789 unreachable!();
790 }
791
792 async fn fetch_server_binary(
793 &self,
794 _: Box<dyn 'static + Send + Any>,
795 _: Arc<dyn HttpClient>,
796 _: PathBuf,
797 ) -> Result<PathBuf> {
798 unreachable!();
799 }
800
801 async fn cached_server_binary(&self, _: PathBuf) -> Option<PathBuf> {
802 unreachable!();
803 }
804
805 async fn process_diagnostics(&self, _: &mut lsp::PublishDiagnosticsParams) {}
806
807 async fn disk_based_diagnostic_sources(&self) -> Vec<String> {
808 self.disk_based_diagnostics_sources.clone()
809 }
810
811 async fn disk_based_diagnostics_progress_token(&self) -> Option<String> {
812 self.disk_based_diagnostics_progress_token.clone()
813 }
814}
815
816pub fn point_to_lsp(point: PointUtf16) -> lsp::Position {
817 lsp::Position::new(point.row, point.column)
818}
819
820pub fn point_from_lsp(point: lsp::Position) -> PointUtf16 {
821 PointUtf16::new(point.line, point.character)
822}
823
824pub fn range_to_lsp(range: Range<PointUtf16>) -> lsp::Range {
825 lsp::Range {
826 start: point_to_lsp(range.start),
827 end: point_to_lsp(range.end),
828 }
829}
830
831pub fn range_from_lsp(range: lsp::Range) -> Range<PointUtf16> {
832 let mut start = point_from_lsp(range.start);
833 let mut end = point_from_lsp(range.end);
834 if start > end {
835 mem::swap(&mut start, &mut end);
836 }
837 start..end
838}