1use std::ops::Range;
2use std::path::{Path, PathBuf};
3use std::sync::Arc;
4
5use anyhow::{Context as _, Result};
6use async_trait::async_trait;
7use collections::{HashMap, HashSet};
8use extension::{Extension, ExtensionLanguageServerProxy, WorktreeDelegate};
9use futures::{FutureExt, future::join_all, lock::OwnedMutexGuard};
10use gpui::{App, AppContext, AsyncApp, Task};
11use language::{
12 BinaryStatus, CodeLabel, DynLspInstaller, HighlightId, Language, LanguageName,
13 LanguageServerBinaryLocations, LspAdapter, LspAdapterDelegate, Toolchain,
14};
15use lsp::{
16 CodeActionKind, LanguageServerBinary, LanguageServerBinaryOptions, LanguageServerName,
17 LanguageServerSelector, Uri,
18};
19use serde::Serialize;
20use serde_json::Value;
21use util::{ResultExt, fs::make_file_executable, maybe, rel_path::RelPath};
22
23use crate::{LanguageServerRegistryProxy, LspAccess};
24
25/// An adapter that allows an [`LspAdapterDelegate`] to be used as a [`WorktreeDelegate`].
26struct WorktreeDelegateAdapter(pub Arc<dyn LspAdapterDelegate>);
27
28#[async_trait]
29impl WorktreeDelegate for WorktreeDelegateAdapter {
30 fn id(&self) -> u64 {
31 self.0.worktree_id().to_proto()
32 }
33
34 fn root_path(&self) -> String {
35 self.0.worktree_root_path().to_string_lossy().into_owned()
36 }
37
38 async fn read_text_file(&self, path: &RelPath) -> Result<String> {
39 self.0.read_text_file(path).await
40 }
41
42 async fn which(&self, binary_name: String) -> Option<String> {
43 self.0
44 .which(binary_name.as_ref())
45 .await
46 .map(|path| path.to_string_lossy().into_owned())
47 }
48
49 async fn shell_env(&self) -> Vec<(String, String)> {
50 self.0.shell_env().await.into_iter().collect()
51 }
52}
53
54impl ExtensionLanguageServerProxy for LanguageServerRegistryProxy {
55 fn register_language_server(
56 &self,
57 extension: Arc<dyn Extension>,
58 language_server_id: LanguageServerName,
59 language: LanguageName,
60 ) {
61 self.language_registry.register_lsp_adapter(
62 language.clone(),
63 Arc::new(ExtensionLspAdapter::new(
64 extension,
65 language_server_id,
66 language,
67 )),
68 );
69 }
70
71 fn remove_language_server(
72 &self,
73 language: &LanguageName,
74 language_server_name: &LanguageServerName,
75 cx: &mut App,
76 ) -> Task<Result<()>> {
77 self.language_registry
78 .remove_lsp_adapter(language, language_server_name);
79
80 let mut tasks = Vec::new();
81 match &self.lsp_access {
82 LspAccess::ViaLspStore(lsp_store) => lsp_store.update(cx, |lsp_store, cx| {
83 let stop_task = lsp_store.stop_language_servers_for_buffers(
84 Vec::new(),
85 HashSet::from_iter([LanguageServerSelector::Name(
86 language_server_name.clone(),
87 )]),
88 cx,
89 );
90 tasks.push(stop_task);
91 }),
92 LspAccess::ViaWorkspaces(lsp_store_provider) => {
93 if let Ok(lsp_stores) = lsp_store_provider(cx) {
94 for lsp_store in lsp_stores {
95 lsp_store.update(cx, |lsp_store, cx| {
96 let stop_task = lsp_store.stop_language_servers_for_buffers(
97 Vec::new(),
98 HashSet::from_iter([LanguageServerSelector::Name(
99 language_server_name.clone(),
100 )]),
101 cx,
102 );
103 tasks.push(stop_task);
104 });
105 }
106 }
107 }
108 LspAccess::Noop => {}
109 }
110
111 cx.background_spawn(async move {
112 let results = join_all(tasks).await;
113 for result in results {
114 result?;
115 }
116 Ok(())
117 })
118 }
119
120 fn update_language_server_status(
121 &self,
122 language_server_id: LanguageServerName,
123 status: BinaryStatus,
124 ) {
125 log::debug!(
126 "updating binary status for {} to {:?}",
127 language_server_id,
128 status
129 );
130 self.language_registry
131 .update_lsp_binary_status(language_server_id, status);
132 }
133}
134
135struct ExtensionLspAdapter {
136 extension: Arc<dyn Extension>,
137 language_server_id: LanguageServerName,
138 language_name: LanguageName,
139}
140
141impl ExtensionLspAdapter {
142 fn new(
143 extension: Arc<dyn Extension>,
144 language_server_id: LanguageServerName,
145 language_name: LanguageName,
146 ) -> Self {
147 Self {
148 extension,
149 language_server_id,
150 language_name,
151 }
152 }
153}
154
155#[async_trait(?Send)]
156impl DynLspInstaller for ExtensionLspAdapter {
157 fn get_language_server_command(
158 self: Arc<Self>,
159 delegate: Arc<dyn LspAdapterDelegate>,
160 _: Option<Toolchain>,
161 _: LanguageServerBinaryOptions,
162 _: OwnedMutexGuard<Option<(bool, LanguageServerBinary)>>,
163 _: AsyncApp,
164 ) -> LanguageServerBinaryLocations {
165 async move {
166 let ret = maybe!(async move {
167 let delegate = Arc::new(WorktreeDelegateAdapter(delegate.clone())) as _;
168 let command = self
169 .extension
170 .language_server_command(
171 self.language_server_id.clone(),
172 self.language_name.clone(),
173 delegate,
174 )
175 .await?;
176
177 // on windows, extensions might produce weird paths
178 // that start with a leading slash due to WASI
179 // requiring that for PWD and friends so account for
180 // that here and try to transform those paths back
181 // to windows paths
182 //
183 // if we don't do this, std will interpret the path as relative,
184 // which changes join behavior
185 let command_path: &Path = if cfg!(windows)
186 && let Some(command) = command.command.to_str()
187 {
188 let mut chars = command.chars();
189 if chars.next().is_some_and(|c| c == '/')
190 && chars.next().is_some_and(|c| c.is_ascii_alphabetic())
191 && chars.next().is_some_and(|c| c == ':')
192 && chars.next().is_some_and(|c| c == '\\' || c == '/')
193 {
194 // looks like a windows path with a leading slash, so strip it
195 command.strip_prefix('/').unwrap().as_ref()
196 } else {
197 command.as_ref()
198 }
199 } else {
200 command.command.as_ref()
201 };
202 let path = self.extension.path_from_extension(command_path);
203
204 // TODO: This should now be done via the `zed::make_file_executable` function in
205 // Zed extension API, but we're leaving these existing usages in place temporarily
206 // to avoid any compatibility issues between Zed and the extension versions.
207 //
208 // We can remove once the following extension versions no longer see any use:
209 // - toml@0.0.2
210 // - zig@0.0.1
211 if ["toml", "zig"].contains(&self.extension.manifest().id.as_ref())
212 && path.starts_with(&self.extension.work_dir())
213 {
214 make_file_executable(&path)
215 .await
216 .context("failed to set file permissions")?;
217 }
218
219 Ok(LanguageServerBinary {
220 path,
221 arguments: command
222 .args
223 .into_iter()
224 .map(|arg| {
225 // on windows, extensions might produce weird paths
226 // that start with a leading slash due to WASI
227 // requiring that for PWD and friends so account for
228 // that here and try to transform those paths back
229 // to windows paths
230 if cfg!(windows) {
231 let mut chars = arg.chars();
232 if chars.next().is_some_and(|c| c == '/')
233 && chars.next().is_some_and(|c| c.is_ascii_alphabetic())
234 && chars.next().is_some_and(|c| c == ':')
235 && chars.next().is_some_and(|c| c == '\\' || c == '/')
236 {
237 // looks like a windows path with a leading slash, so strip it
238 arg.strip_prefix('/').unwrap().into()
239 } else {
240 arg.into()
241 }
242 } else {
243 arg.into()
244 }
245 })
246 .collect(),
247 env: Some(command.env.into_iter().collect()),
248 })
249 })
250 .await;
251 (ret, None)
252 }
253 .boxed_local()
254 }
255
256 async fn try_fetch_server_binary(
257 &self,
258 _: &Arc<dyn LspAdapterDelegate>,
259 _: PathBuf,
260 _: bool,
261 _: &mut AsyncApp,
262 ) -> Result<LanguageServerBinary> {
263 unreachable!("get_language_server_command is overridden")
264 }
265}
266
267#[async_trait(?Send)]
268impl LspAdapter for ExtensionLspAdapter {
269 fn name(&self) -> LanguageServerName {
270 self.language_server_id.clone()
271 }
272
273 fn code_action_kinds(&self) -> Option<Vec<CodeActionKind>> {
274 let code_action_kinds = self
275 .extension
276 .manifest()
277 .language_servers
278 .get(&self.language_server_id)
279 .and_then(|server| server.code_action_kinds.clone());
280
281 code_action_kinds.or(Some(vec![
282 CodeActionKind::EMPTY,
283 CodeActionKind::QUICKFIX,
284 CodeActionKind::REFACTOR,
285 CodeActionKind::REFACTOR_EXTRACT,
286 CodeActionKind::SOURCE,
287 ]))
288 }
289
290 fn language_ids(&self) -> HashMap<LanguageName, String> {
291 // TODO: The language IDs can be provided via the language server options
292 // in `extension.toml now but we're leaving these existing usages in place temporarily
293 // to avoid any compatibility issues between Zed and the extension versions.
294 //
295 // We can remove once the following extension versions no longer see any use:
296 // - php@0.0.1
297 if self.extension.manifest().id.as_ref() == "php" {
298 return HashMap::from_iter([(LanguageName::new_static("PHP"), "php".into())]);
299 }
300
301 self.extension
302 .manifest()
303 .language_servers
304 .get(&self.language_server_id)
305 .map(|server| server.language_ids.clone())
306 .unwrap_or_default()
307 }
308
309 async fn initialization_options(
310 self: Arc<Self>,
311 delegate: &Arc<dyn LspAdapterDelegate>,
312 _: &mut AsyncApp,
313 ) -> Result<Option<serde_json::Value>> {
314 let delegate = Arc::new(WorktreeDelegateAdapter(delegate.clone())) as _;
315 let json_options = self
316 .extension
317 .language_server_initialization_options(
318 self.language_server_id.clone(),
319 self.language_name.clone(),
320 delegate,
321 )
322 .await?;
323 Ok(if let Some(json_options) = json_options {
324 serde_json::from_str(&json_options).with_context(|| {
325 format!("failed to parse initialization_options from extension: {json_options}")
326 })?
327 } else {
328 None
329 })
330 }
331
332 async fn workspace_configuration(
333 self: Arc<Self>,
334 delegate: &Arc<dyn LspAdapterDelegate>,
335 _: Option<Toolchain>,
336 _: Option<Uri>,
337 _cx: &mut AsyncApp,
338 ) -> Result<Value> {
339 let delegate = Arc::new(WorktreeDelegateAdapter(delegate.clone())) as _;
340 let json_options: Option<String> = self
341 .extension
342 .language_server_workspace_configuration(self.language_server_id.clone(), delegate)
343 .await?;
344 Ok(if let Some(json_options) = json_options {
345 serde_json::from_str(&json_options).with_context(|| {
346 format!("failed to parse workspace_configuration from extension: {json_options}")
347 })?
348 } else {
349 serde_json::json!({})
350 })
351 }
352
353 async fn initialization_options_schema(
354 self: Arc<Self>,
355 delegate: &Arc<dyn LspAdapterDelegate>,
356 _cached_binary: OwnedMutexGuard<Option<(bool, LanguageServerBinary)>>,
357 _cx: &mut AsyncApp,
358 ) -> Option<serde_json::Value> {
359 let delegate = Arc::new(WorktreeDelegateAdapter(delegate.clone())) as _;
360 let json_schema: Option<String> = self
361 .extension
362 .language_server_initialization_options_schema(
363 self.language_server_id.clone(),
364 delegate,
365 )
366 .await
367 .ok()
368 .flatten();
369 json_schema.and_then(|s| serde_json::from_str(&s).ok())
370 }
371
372 async fn settings_schema(
373 self: Arc<Self>,
374 delegate: &Arc<dyn LspAdapterDelegate>,
375 _cached_binary: OwnedMutexGuard<Option<(bool, LanguageServerBinary)>>,
376 _cx: &mut AsyncApp,
377 ) -> Option<serde_json::Value> {
378 let delegate = Arc::new(WorktreeDelegateAdapter(delegate.clone())) as _;
379 let json_schema: Option<String> = self
380 .extension
381 .language_server_workspace_configuration_schema(
382 self.language_server_id.clone(),
383 delegate,
384 )
385 .await
386 .ok()
387 .flatten();
388 json_schema.and_then(|s| serde_json::from_str(&s).ok())
389 }
390
391 async fn additional_initialization_options(
392 self: Arc<Self>,
393 target_language_server_id: LanguageServerName,
394 delegate: &Arc<dyn LspAdapterDelegate>,
395 ) -> Result<Option<serde_json::Value>> {
396 let delegate = Arc::new(WorktreeDelegateAdapter(delegate.clone())) as _;
397 let json_options: Option<String> = self
398 .extension
399 .language_server_additional_initialization_options(
400 self.language_server_id.clone(),
401 target_language_server_id.clone(),
402 delegate,
403 )
404 .await?;
405 Ok(if let Some(json_options) = json_options {
406 serde_json::from_str(&json_options).with_context(|| {
407 format!(
408 "failed to parse additional_initialization_options from extension: {json_options}"
409 )
410 })?
411 } else {
412 None
413 })
414 }
415
416 async fn additional_workspace_configuration(
417 self: Arc<Self>,
418 target_language_server_id: LanguageServerName,
419
420 delegate: &Arc<dyn LspAdapterDelegate>,
421
422 _cx: &mut AsyncApp,
423 ) -> Result<Option<serde_json::Value>> {
424 let delegate = Arc::new(WorktreeDelegateAdapter(delegate.clone())) as _;
425 let json_options: Option<String> = self
426 .extension
427 .language_server_additional_workspace_configuration(
428 self.language_server_id.clone(),
429 target_language_server_id.clone(),
430 delegate,
431 )
432 .await?;
433 Ok(if let Some(json_options) = json_options {
434 serde_json::from_str(&json_options).with_context(|| {
435 format!("failed to parse additional_workspace_configuration from extension: {json_options}")
436 })?
437 } else {
438 None
439 })
440 }
441
442 async fn labels_for_completions(
443 self: Arc<Self>,
444 completions: &[lsp::CompletionItem],
445 language: &Arc<Language>,
446 ) -> Result<Vec<Option<CodeLabel>>> {
447 let completions = completions
448 .iter()
449 .cloned()
450 .map(lsp_completion_to_extension)
451 .collect::<Vec<_>>();
452
453 let labels = self
454 .extension
455 .labels_for_completions(self.language_server_id.clone(), completions)
456 .await?;
457
458 Ok(labels_from_extension(labels, language))
459 }
460
461 async fn labels_for_symbols(
462 self: Arc<Self>,
463 symbols: &[language::Symbol],
464 language: &Arc<Language>,
465 ) -> Result<Vec<Option<CodeLabel>>> {
466 let symbols = symbols
467 .iter()
468 .cloned()
469 .map(
470 |language::Symbol {
471 name,
472 kind,
473 container_name,
474 }| extension::Symbol {
475 name,
476 kind: lsp_symbol_kind_to_extension(kind),
477 container_name,
478 },
479 )
480 .collect::<Vec<_>>();
481
482 let labels = self
483 .extension
484 .labels_for_symbols(self.language_server_id.clone(), symbols)
485 .await?;
486
487 Ok(labels_from_extension(labels, language))
488 }
489
490 fn is_extension(&self) -> bool {
491 true
492 }
493}
494
495fn labels_from_extension(
496 labels: Vec<Option<extension::CodeLabel>>,
497 language: &Arc<Language>,
498) -> Vec<Option<CodeLabel>> {
499 labels
500 .into_iter()
501 .map(|label| {
502 let label = label?;
503 let runs = if label.code.is_empty() {
504 Vec::new()
505 } else {
506 language.highlight_text(&label.code.as_str().into(), 0..label.code.len())
507 };
508 build_code_label(&label, &runs, language)
509 })
510 .collect()
511}
512
513fn build_code_label(
514 label: &extension::CodeLabel,
515 parsed_runs: &[(Range<usize>, HighlightId)],
516 language: &Arc<Language>,
517) -> Option<CodeLabel> {
518 let mut text = String::new();
519 let mut runs = vec![];
520
521 for span in &label.spans {
522 match span {
523 extension::CodeLabelSpan::CodeRange(range) => {
524 let code_span = &label.code.get(range.clone())?;
525 let mut input_ix = range.start;
526 let mut output_ix = text.len();
527 for (run_range, id) in parsed_runs {
528 if run_range.start >= range.end {
529 break;
530 }
531 if run_range.end <= input_ix {
532 continue;
533 }
534
535 if run_range.start > input_ix {
536 let len = run_range.start - input_ix;
537 output_ix += len;
538 input_ix += len;
539 }
540
541 let len = range.end.min(run_range.end) - input_ix;
542 runs.push((output_ix..output_ix + len, *id));
543 output_ix += len;
544 input_ix += len;
545 }
546
547 text.push_str(code_span);
548 }
549 extension::CodeLabelSpan::Literal(span) => {
550 if let Some(highlight_id) = language
551 .grammar()
552 .zip(span.highlight_name.as_ref())
553 .and_then(|(grammar, highlight_name)| {
554 grammar.highlight_id_for_name(highlight_name)
555 })
556 {
557 let ix = text.len();
558 runs.push((ix..ix + span.text.len(), highlight_id));
559 }
560 text.push_str(&span.text);
561 }
562 }
563 }
564
565 let filter_range = label.filter_range.clone();
566 text.get(filter_range.clone())?;
567 Some(CodeLabel::new(text, filter_range, runs))
568}
569
570fn lsp_completion_to_extension(value: lsp::CompletionItem) -> extension::Completion {
571 extension::Completion {
572 label: value.label,
573 label_details: value
574 .label_details
575 .map(lsp_completion_item_label_details_to_extension),
576 detail: value.detail,
577 kind: value.kind.map(lsp_completion_item_kind_to_extension),
578 insert_text_format: value
579 .insert_text_format
580 .map(lsp_insert_text_format_to_extension),
581 }
582}
583
584fn lsp_completion_item_label_details_to_extension(
585 value: lsp::CompletionItemLabelDetails,
586) -> extension::CompletionLabelDetails {
587 extension::CompletionLabelDetails {
588 detail: value.detail,
589 description: value.description,
590 }
591}
592
593fn lsp_completion_item_kind_to_extension(
594 value: lsp::CompletionItemKind,
595) -> extension::CompletionKind {
596 match value {
597 lsp::CompletionItemKind::TEXT => extension::CompletionKind::Text,
598 lsp::CompletionItemKind::METHOD => extension::CompletionKind::Method,
599 lsp::CompletionItemKind::FUNCTION => extension::CompletionKind::Function,
600 lsp::CompletionItemKind::CONSTRUCTOR => extension::CompletionKind::Constructor,
601 lsp::CompletionItemKind::FIELD => extension::CompletionKind::Field,
602 lsp::CompletionItemKind::VARIABLE => extension::CompletionKind::Variable,
603 lsp::CompletionItemKind::CLASS => extension::CompletionKind::Class,
604 lsp::CompletionItemKind::INTERFACE => extension::CompletionKind::Interface,
605 lsp::CompletionItemKind::MODULE => extension::CompletionKind::Module,
606 lsp::CompletionItemKind::PROPERTY => extension::CompletionKind::Property,
607 lsp::CompletionItemKind::UNIT => extension::CompletionKind::Unit,
608 lsp::CompletionItemKind::VALUE => extension::CompletionKind::Value,
609 lsp::CompletionItemKind::ENUM => extension::CompletionKind::Enum,
610 lsp::CompletionItemKind::KEYWORD => extension::CompletionKind::Keyword,
611 lsp::CompletionItemKind::SNIPPET => extension::CompletionKind::Snippet,
612 lsp::CompletionItemKind::COLOR => extension::CompletionKind::Color,
613 lsp::CompletionItemKind::FILE => extension::CompletionKind::File,
614 lsp::CompletionItemKind::REFERENCE => extension::CompletionKind::Reference,
615 lsp::CompletionItemKind::FOLDER => extension::CompletionKind::Folder,
616 lsp::CompletionItemKind::ENUM_MEMBER => extension::CompletionKind::EnumMember,
617 lsp::CompletionItemKind::CONSTANT => extension::CompletionKind::Constant,
618 lsp::CompletionItemKind::STRUCT => extension::CompletionKind::Struct,
619 lsp::CompletionItemKind::EVENT => extension::CompletionKind::Event,
620 lsp::CompletionItemKind::OPERATOR => extension::CompletionKind::Operator,
621 lsp::CompletionItemKind::TYPE_PARAMETER => extension::CompletionKind::TypeParameter,
622 _ => extension::CompletionKind::Other(extract_int(value)),
623 }
624}
625
626fn lsp_insert_text_format_to_extension(
627 value: lsp::InsertTextFormat,
628) -> extension::InsertTextFormat {
629 match value {
630 lsp::InsertTextFormat::PLAIN_TEXT => extension::InsertTextFormat::PlainText,
631 lsp::InsertTextFormat::SNIPPET => extension::InsertTextFormat::Snippet,
632 _ => extension::InsertTextFormat::Other(extract_int(value)),
633 }
634}
635
636fn lsp_symbol_kind_to_extension(value: lsp::SymbolKind) -> extension::SymbolKind {
637 match value {
638 lsp::SymbolKind::FILE => extension::SymbolKind::File,
639 lsp::SymbolKind::MODULE => extension::SymbolKind::Module,
640 lsp::SymbolKind::NAMESPACE => extension::SymbolKind::Namespace,
641 lsp::SymbolKind::PACKAGE => extension::SymbolKind::Package,
642 lsp::SymbolKind::CLASS => extension::SymbolKind::Class,
643 lsp::SymbolKind::METHOD => extension::SymbolKind::Method,
644 lsp::SymbolKind::PROPERTY => extension::SymbolKind::Property,
645 lsp::SymbolKind::FIELD => extension::SymbolKind::Field,
646 lsp::SymbolKind::CONSTRUCTOR => extension::SymbolKind::Constructor,
647 lsp::SymbolKind::ENUM => extension::SymbolKind::Enum,
648 lsp::SymbolKind::INTERFACE => extension::SymbolKind::Interface,
649 lsp::SymbolKind::FUNCTION => extension::SymbolKind::Function,
650 lsp::SymbolKind::VARIABLE => extension::SymbolKind::Variable,
651 lsp::SymbolKind::CONSTANT => extension::SymbolKind::Constant,
652 lsp::SymbolKind::STRING => extension::SymbolKind::String,
653 lsp::SymbolKind::NUMBER => extension::SymbolKind::Number,
654 lsp::SymbolKind::BOOLEAN => extension::SymbolKind::Boolean,
655 lsp::SymbolKind::ARRAY => extension::SymbolKind::Array,
656 lsp::SymbolKind::OBJECT => extension::SymbolKind::Object,
657 lsp::SymbolKind::KEY => extension::SymbolKind::Key,
658 lsp::SymbolKind::NULL => extension::SymbolKind::Null,
659 lsp::SymbolKind::ENUM_MEMBER => extension::SymbolKind::EnumMember,
660 lsp::SymbolKind::STRUCT => extension::SymbolKind::Struct,
661 lsp::SymbolKind::EVENT => extension::SymbolKind::Event,
662 lsp::SymbolKind::OPERATOR => extension::SymbolKind::Operator,
663 lsp::SymbolKind::TYPE_PARAMETER => extension::SymbolKind::TypeParameter,
664 _ => extension::SymbolKind::Other(extract_int(value)),
665 }
666}
667
668fn extract_int<T: Serialize>(value: T) -> i32 {
669 maybe!({
670 let kind = serde_json::to_value(&value)?;
671 serde_json::from_value(kind)
672 })
673 .log_err()
674 .unwrap_or(-1)
675}
676
677#[test]
678fn test_build_code_label() {
679 use util::test::marked_text_ranges;
680
681 let (code, code_ranges) = marked_text_ranges(
682 "«const» «a»: «fn»(«Bcd»(«Efgh»)) -> «Ijklm» = pqrs.tuv",
683 false,
684 );
685 let code_runs = code_ranges
686 .into_iter()
687 .map(|range| (range, HighlightId::new(0)))
688 .collect::<Vec<_>>();
689
690 let label = build_code_label(
691 &extension::CodeLabel {
692 spans: vec![
693 extension::CodeLabelSpan::CodeRange(code.find("pqrs").unwrap()..code.len()),
694 extension::CodeLabelSpan::CodeRange(
695 code.find(": fn").unwrap()..code.find(" = ").unwrap(),
696 ),
697 ],
698 filter_range: 0.."pqrs.tuv".len(),
699 code,
700 },
701 &code_runs,
702 &language::PLAIN_TEXT,
703 )
704 .unwrap();
705
706 let (label_text, label_ranges) =
707 marked_text_ranges("pqrs.tuv: «fn»(«Bcd»(«Efgh»)) -> «Ijklm»", false);
708 let label_runs = label_ranges
709 .into_iter()
710 .map(|range| (range, HighlightId::new(0)))
711 .collect::<Vec<_>>();
712
713 assert_eq!(
714 label,
715 CodeLabel::new(label_text, label.filter_range.clone(), label_runs)
716 )
717}
718
719#[test]
720fn test_build_code_label_with_invalid_ranges() {
721 use util::test::marked_text_ranges;
722
723 let (code, code_ranges) = marked_text_ranges("const «a»: «B» = '🏀'", false);
724 let code_runs = code_ranges
725 .into_iter()
726 .map(|range| (range, HighlightId::new(0)))
727 .collect::<Vec<_>>();
728
729 // A span uses a code range that is invalid because it starts inside of
730 // a multi-byte character.
731 let label = build_code_label(
732 &extension::CodeLabel {
733 spans: vec![
734 extension::CodeLabelSpan::CodeRange(
735 code.find('B').unwrap()..code.find(" = ").unwrap(),
736 ),
737 extension::CodeLabelSpan::CodeRange((code.find('🏀').unwrap() + 1)..code.len()),
738 ],
739 filter_range: 0.."B".len(),
740 code,
741 },
742 &code_runs,
743 &language::PLAIN_TEXT,
744 );
745 assert!(label.is_none());
746
747 // Filter range extends beyond actual text
748 let label = build_code_label(
749 &extension::CodeLabel {
750 spans: vec![extension::CodeLabelSpan::Literal(
751 extension::CodeLabelSpanLiteral {
752 text: "abc".into(),
753 highlight_name: Some("type".into()),
754 },
755 )],
756 filter_range: 0..5,
757 code: String::new(),
758 },
759 &code_runs,
760 &language::PLAIN_TEXT,
761 );
762 assert!(label.is_none());
763}