tenant.openagents/omega

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