1use feature_flags::{Debugger, FeatureFlagAppExt as _};
2use fuzzy::{StringMatch, StringMatchCandidate};
3use gpui::{
4 AnyElement, BackgroundExecutor, Entity, Focusable, FontWeight, ListSizingBehavior,
5 ScrollStrategy, SharedString, Size, StrikethroughStyle, StyledText, UniformListScrollHandle,
6 div, px, uniform_list,
7};
8use language::Buffer;
9use language::CodeLabel;
10use markdown::{Markdown, MarkdownElement};
11use multi_buffer::{Anchor, ExcerptId};
12use ordered_float::OrderedFloat;
13use project::CompletionSource;
14use project::lsp_store::CompletionDocumentation;
15use project::{CodeAction, Completion, TaskSourceKind};
16
17use std::{
18 cell::RefCell,
19 cmp::{Reverse, min},
20 iter,
21 ops::Range,
22 rc::Rc,
23};
24use task::ResolvedTask;
25use ui::{Color, IntoElement, ListItem, Pixels, Popover, Styled, prelude::*};
26use util::ResultExt;
27
28use crate::hover_popover::{hover_markdown_style, open_markdown_url};
29use crate::{
30 CodeActionProvider, CompletionId, CompletionItemKind, CompletionProvider, DisplayRow, Editor,
31 EditorStyle, ResolvedTasks,
32 actions::{ConfirmCodeAction, ConfirmCompletion},
33 split_words, styled_runs_for_code_label,
34};
35
36pub const MENU_GAP: Pixels = px(4.);
37pub const MENU_ASIDE_X_PADDING: Pixels = px(16.);
38pub const MENU_ASIDE_MIN_WIDTH: Pixels = px(260.);
39pub const MENU_ASIDE_MAX_WIDTH: Pixels = px(500.);
40
41pub enum CodeContextMenu {
42 Completions(CompletionsMenu),
43 CodeActions(CodeActionsMenu),
44}
45
46impl CodeContextMenu {
47 pub fn select_first(
48 &mut self,
49 provider: Option<&dyn CompletionProvider>,
50 cx: &mut Context<Editor>,
51 ) -> bool {
52 if self.visible() {
53 match self {
54 CodeContextMenu::Completions(menu) => menu.select_first(provider, cx),
55 CodeContextMenu::CodeActions(menu) => menu.select_first(cx),
56 }
57 true
58 } else {
59 false
60 }
61 }
62
63 pub fn select_prev(
64 &mut self,
65 provider: Option<&dyn CompletionProvider>,
66 cx: &mut Context<Editor>,
67 ) -> bool {
68 if self.visible() {
69 match self {
70 CodeContextMenu::Completions(menu) => menu.select_prev(provider, cx),
71 CodeContextMenu::CodeActions(menu) => menu.select_prev(cx),
72 }
73 true
74 } else {
75 false
76 }
77 }
78
79 pub fn select_next(
80 &mut self,
81 provider: Option<&dyn CompletionProvider>,
82 cx: &mut Context<Editor>,
83 ) -> bool {
84 if self.visible() {
85 match self {
86 CodeContextMenu::Completions(menu) => menu.select_next(provider, cx),
87 CodeContextMenu::CodeActions(menu) => menu.select_next(cx),
88 }
89 true
90 } else {
91 false
92 }
93 }
94
95 pub fn select_last(
96 &mut self,
97 provider: Option<&dyn CompletionProvider>,
98 cx: &mut Context<Editor>,
99 ) -> bool {
100 if self.visible() {
101 match self {
102 CodeContextMenu::Completions(menu) => menu.select_last(provider, cx),
103 CodeContextMenu::CodeActions(menu) => menu.select_last(cx),
104 }
105 true
106 } else {
107 false
108 }
109 }
110
111 pub fn visible(&self) -> bool {
112 match self {
113 CodeContextMenu::Completions(menu) => menu.visible(),
114 CodeContextMenu::CodeActions(menu) => menu.visible(),
115 }
116 }
117
118 pub fn origin(&self) -> ContextMenuOrigin {
119 match self {
120 CodeContextMenu::Completions(menu) => menu.origin(),
121 CodeContextMenu::CodeActions(menu) => menu.origin(),
122 }
123 }
124
125 pub fn render(
126 &self,
127 style: &EditorStyle,
128 max_height_in_lines: u32,
129 window: &mut Window,
130 cx: &mut Context<Editor>,
131 ) -> AnyElement {
132 match self {
133 CodeContextMenu::Completions(menu) => {
134 menu.render(style, max_height_in_lines, window, cx)
135 }
136 CodeContextMenu::CodeActions(menu) => {
137 menu.render(style, max_height_in_lines, window, cx)
138 }
139 }
140 }
141
142 pub fn render_aside(
143 &mut self,
144 editor: &Editor,
145 max_size: Size<Pixels>,
146 window: &mut Window,
147 cx: &mut Context<Editor>,
148 ) -> Option<AnyElement> {
149 match self {
150 CodeContextMenu::Completions(menu) => menu.render_aside(editor, max_size, window, cx),
151 CodeContextMenu::CodeActions(_) => None,
152 }
153 }
154
155 pub fn focused(&self, window: &mut Window, cx: &mut Context<Editor>) -> bool {
156 match self {
157 CodeContextMenu::Completions(completions_menu) => completions_menu
158 .markdown_element
159 .as_ref()
160 .is_some_and(|markdown| markdown.focus_handle(cx).contains_focused(window, cx)),
161 CodeContextMenu::CodeActions(_) => false,
162 }
163 }
164}
165
166pub enum ContextMenuOrigin {
167 Cursor,
168 GutterIndicator(DisplayRow),
169}
170
171#[derive(Clone, Debug)]
172pub struct CompletionsMenu {
173 pub id: CompletionId,
174 sort_completions: bool,
175 pub initial_position: Anchor,
176 pub buffer: Entity<Buffer>,
177 pub completions: Rc<RefCell<Box<[Completion]>>>,
178 match_candidates: Rc<[StringMatchCandidate]>,
179 pub entries: Rc<RefCell<Vec<StringMatch>>>,
180 pub selected_item: usize,
181 scroll_handle: UniformListScrollHandle,
182 resolve_completions: bool,
183 show_completion_documentation: bool,
184 pub(super) ignore_completion_provider: bool,
185 last_rendered_range: Rc<RefCell<Option<Range<usize>>>>,
186 markdown_element: Option<Entity<Markdown>>,
187}
188
189impl CompletionsMenu {
190 pub fn new(
191 id: CompletionId,
192 sort_completions: bool,
193 show_completion_documentation: bool,
194 ignore_completion_provider: bool,
195 initial_position: Anchor,
196 buffer: Entity<Buffer>,
197 completions: Box<[Completion]>,
198 ) -> Self {
199 let match_candidates = completions
200 .iter()
201 .enumerate()
202 .map(|(id, completion)| StringMatchCandidate::new(id, &completion.label.filter_text()))
203 .collect();
204
205 Self {
206 id,
207 sort_completions,
208 initial_position,
209 buffer,
210 show_completion_documentation,
211 ignore_completion_provider,
212 completions: RefCell::new(completions).into(),
213 match_candidates,
214 entries: RefCell::new(Vec::new()).into(),
215 selected_item: 0,
216 scroll_handle: UniformListScrollHandle::new(),
217 resolve_completions: true,
218 last_rendered_range: RefCell::new(None).into(),
219 markdown_element: None,
220 }
221 }
222
223 pub fn new_snippet_choices(
224 id: CompletionId,
225 sort_completions: bool,
226 choices: &Vec<String>,
227 selection: Range<Anchor>,
228 buffer: Entity<Buffer>,
229 ) -> Self {
230 let completions = choices
231 .iter()
232 .map(|choice| Completion {
233 replace_range: selection.start.text_anchor..selection.end.text_anchor,
234 new_text: choice.to_string(),
235 label: CodeLabel {
236 text: choice.to_string(),
237 runs: Default::default(),
238 filter_range: Default::default(),
239 },
240 icon_path: None,
241 documentation: None,
242 confirm: None,
243 insert_text_mode: None,
244 source: CompletionSource::Custom,
245 })
246 .collect();
247
248 let match_candidates = choices
249 .iter()
250 .enumerate()
251 .map(|(id, completion)| StringMatchCandidate::new(id, &completion))
252 .collect();
253 let entries = choices
254 .iter()
255 .enumerate()
256 .map(|(id, completion)| StringMatch {
257 candidate_id: id,
258 score: 1.,
259 positions: vec![],
260 string: completion.clone(),
261 })
262 .collect::<Vec<_>>();
263 Self {
264 id,
265 sort_completions,
266 initial_position: selection.start,
267 buffer,
268 completions: RefCell::new(completions).into(),
269 match_candidates,
270 entries: RefCell::new(entries).into(),
271 selected_item: 0,
272 scroll_handle: UniformListScrollHandle::new(),
273 resolve_completions: false,
274 show_completion_documentation: false,
275 ignore_completion_provider: false,
276 last_rendered_range: RefCell::new(None).into(),
277 markdown_element: None,
278 }
279 }
280
281 fn select_first(
282 &mut self,
283 provider: Option<&dyn CompletionProvider>,
284 cx: &mut Context<Editor>,
285 ) {
286 let index = if self.scroll_handle.y_flipped() {
287 self.entries.borrow().len() - 1
288 } else {
289 0
290 };
291 self.update_selection_index(index, provider, cx);
292 }
293
294 fn select_last(&mut self, provider: Option<&dyn CompletionProvider>, cx: &mut Context<Editor>) {
295 let index = if self.scroll_handle.y_flipped() {
296 0
297 } else {
298 self.entries.borrow().len() - 1
299 };
300 self.update_selection_index(index, provider, cx);
301 }
302
303 fn select_prev(&mut self, provider: Option<&dyn CompletionProvider>, cx: &mut Context<Editor>) {
304 let index = if self.scroll_handle.y_flipped() {
305 self.next_match_index()
306 } else {
307 self.prev_match_index()
308 };
309 self.update_selection_index(index, provider, cx);
310 }
311
312 fn select_next(&mut self, provider: Option<&dyn CompletionProvider>, cx: &mut Context<Editor>) {
313 let index = if self.scroll_handle.y_flipped() {
314 self.prev_match_index()
315 } else {
316 self.next_match_index()
317 };
318 self.update_selection_index(index, provider, cx);
319 }
320
321 fn update_selection_index(
322 &mut self,
323 match_index: usize,
324 provider: Option<&dyn CompletionProvider>,
325 cx: &mut Context<Editor>,
326 ) {
327 if self.selected_item != match_index {
328 self.selected_item = match_index;
329 self.scroll_handle
330 .scroll_to_item(self.selected_item, ScrollStrategy::Top);
331 self.resolve_visible_completions(provider, cx);
332 cx.notify();
333 }
334 }
335
336 fn prev_match_index(&self) -> usize {
337 if self.selected_item > 0 {
338 self.selected_item - 1
339 } else {
340 self.entries.borrow().len() - 1
341 }
342 }
343
344 fn next_match_index(&self) -> usize {
345 if self.selected_item + 1 < self.entries.borrow().len() {
346 self.selected_item + 1
347 } else {
348 0
349 }
350 }
351
352 pub fn resolve_visible_completions(
353 &mut self,
354 provider: Option<&dyn CompletionProvider>,
355 cx: &mut Context<Editor>,
356 ) {
357 if !self.resolve_completions {
358 return;
359 }
360 let Some(provider) = provider else {
361 return;
362 };
363
364 // Attempt to resolve completions for every item that will be displayed. This matters
365 // because single line documentation may be displayed inline with the completion.
366 //
367 // When navigating to the very beginning or end of completions, `last_rendered_range` may
368 // have no overlap with the completions that will be displayed, so instead use a range based
369 // on the last rendered count.
370 const APPROXIMATE_VISIBLE_COUNT: usize = 12;
371 let last_rendered_range = self.last_rendered_range.borrow().clone();
372 let visible_count = last_rendered_range
373 .clone()
374 .map_or(APPROXIMATE_VISIBLE_COUNT, |range| range.count());
375 let entries = self.entries.borrow();
376 let entry_range = if self.selected_item == 0 {
377 0..min(visible_count, entries.len())
378 } else if self.selected_item == entries.len() - 1 {
379 entries.len().saturating_sub(visible_count)..entries.len()
380 } else {
381 last_rendered_range.map_or(0..0, |range| {
382 min(range.start, entries.len())..min(range.end, entries.len())
383 })
384 };
385
386 // Expand the range to resolve more completions than are predicted to be visible, to reduce
387 // jank on navigation.
388 const EXTRA_TO_RESOLVE: usize = 4;
389 let entry_indices = util::iterate_expanded_and_wrapped_usize_range(
390 entry_range.clone(),
391 EXTRA_TO_RESOLVE,
392 EXTRA_TO_RESOLVE,
393 entries.len(),
394 );
395
396 // Avoid work by sometimes filtering out completions that already have documentation.
397 // This filtering doesn't happen if the completions are currently being updated.
398 let completions = self.completions.borrow();
399 let candidate_ids = entry_indices
400 .map(|i| entries[i].candidate_id)
401 .filter(|i| completions[*i].documentation.is_none());
402
403 // Current selection is always resolved even if it already has documentation, to handle
404 // out-of-spec language servers that return more results later.
405 let selected_candidate_id = entries[self.selected_item].candidate_id;
406 let candidate_ids = iter::once(selected_candidate_id)
407 .chain(candidate_ids.filter(|id| *id != selected_candidate_id))
408 .collect::<Vec<usize>>();
409 drop(entries);
410
411 if candidate_ids.is_empty() {
412 return;
413 }
414
415 let resolve_task = provider.resolve_completions(
416 self.buffer.clone(),
417 candidate_ids,
418 self.completions.clone(),
419 cx,
420 );
421
422 cx.spawn(async move |editor, cx| {
423 if let Some(true) = resolve_task.await.log_err() {
424 editor.update(cx, |_, cx| cx.notify()).ok();
425 }
426 })
427 .detach();
428 }
429
430 pub fn visible(&self) -> bool {
431 !self.entries.borrow().is_empty()
432 }
433
434 fn origin(&self) -> ContextMenuOrigin {
435 ContextMenuOrigin::Cursor
436 }
437
438 fn render(
439 &self,
440 style: &EditorStyle,
441 max_height_in_lines: u32,
442 window: &mut Window,
443 cx: &mut Context<Editor>,
444 ) -> AnyElement {
445 let completions = self.completions.borrow_mut();
446 let show_completion_documentation = self.show_completion_documentation;
447 let widest_completion_ix = self
448 .entries
449 .borrow()
450 .iter()
451 .enumerate()
452 .max_by_key(|(_, mat)| {
453 let completion = &completions[mat.candidate_id];
454 let documentation = &completion.documentation;
455
456 let mut len = completion.label.text.chars().count();
457 if let Some(CompletionDocumentation::SingleLine(text)) = documentation {
458 if show_completion_documentation {
459 len += text.chars().count();
460 }
461 }
462
463 len
464 })
465 .map(|(ix, _)| ix);
466 drop(completions);
467
468 let selected_item = self.selected_item;
469 let completions = self.completions.clone();
470 let entries = self.entries.clone();
471 let last_rendered_range = self.last_rendered_range.clone();
472 let style = style.clone();
473 let list = uniform_list(
474 cx.entity().clone(),
475 "completions",
476 self.entries.borrow().len(),
477 move |_editor, range, _window, cx| {
478 last_rendered_range.borrow_mut().replace(range.clone());
479 let start_ix = range.start;
480 let completions_guard = completions.borrow_mut();
481
482 entries.borrow()[range]
483 .iter()
484 .enumerate()
485 .map(|(ix, mat)| {
486 let item_ix = start_ix + ix;
487 let completion = &completions_guard[mat.candidate_id];
488 let documentation = if show_completion_documentation {
489 &completion.documentation
490 } else {
491 &None
492 };
493
494 let filter_start = completion.label.filter_range.start;
495 let highlights = gpui::combine_highlights(
496 mat.ranges().map(|range| {
497 (
498 filter_start + range.start..filter_start + range.end,
499 FontWeight::BOLD.into(),
500 )
501 }),
502 styled_runs_for_code_label(&completion.label, &style.syntax).map(
503 |(range, mut highlight)| {
504 // Ignore font weight for syntax highlighting, as we'll use it
505 // for fuzzy matches.
506 highlight.font_weight = None;
507 if completion
508 .source
509 .lsp_completion(false)
510 .and_then(|lsp_completion| lsp_completion.deprecated)
511 .unwrap_or(false)
512 {
513 highlight.strikethrough = Some(StrikethroughStyle {
514 thickness: 1.0.into(),
515 ..Default::default()
516 });
517 highlight.color = Some(cx.theme().colors().text_muted);
518 }
519
520 (range, highlight)
521 },
522 ),
523 );
524
525 let completion_label = StyledText::new(completion.label.text.clone())
526 .with_default_highlights(&style.text, highlights);
527 let documentation_label = if let Some(
528 CompletionDocumentation::SingleLine(text),
529 ) = documentation
530 {
531 if text.trim().is_empty() {
532 None
533 } else {
534 Some(
535 Label::new(text.clone())
536 .ml_4()
537 .size(LabelSize::Small)
538 .color(Color::Muted),
539 )
540 }
541 } else {
542 None
543 };
544
545 let start_slot = completion
546 .color()
547 .map(|color| {
548 div()
549 .flex_shrink_0()
550 .size_3p5()
551 .rounded_xs()
552 .bg(color)
553 .into_any_element()
554 })
555 .or_else(|| {
556 completion.icon_path.as_ref().map(|path| {
557 Icon::from_path(path)
558 .size(IconSize::XSmall)
559 .color(Color::Muted)
560 .into_any_element()
561 })
562 });
563
564 div().min_w(px(280.)).max_w(px(540.)).child(
565 ListItem::new(mat.candidate_id)
566 .inset(true)
567 .toggle_state(item_ix == selected_item)
568 .on_click(cx.listener(move |editor, _event, window, cx| {
569 cx.stop_propagation();
570 if let Some(task) = editor.confirm_completion(
571 &ConfirmCompletion {
572 item_ix: Some(item_ix),
573 },
574 window,
575 cx,
576 ) {
577 task.detach_and_log_err(cx)
578 }
579 }))
580 .start_slot::<AnyElement>(start_slot)
581 .child(h_flex().overflow_hidden().child(completion_label))
582 .end_slot::<Label>(documentation_label),
583 )
584 })
585 .collect()
586 },
587 )
588 .occlude()
589 .max_h(max_height_in_lines as f32 * window.line_height())
590 .track_scroll(self.scroll_handle.clone())
591 .with_width_from_item(widest_completion_ix)
592 .with_sizing_behavior(ListSizingBehavior::Infer);
593
594 Popover::new().child(list).into_any_element()
595 }
596
597 fn render_aside(
598 &mut self,
599 editor: &Editor,
600 max_size: Size<Pixels>,
601 window: &mut Window,
602 cx: &mut Context<Editor>,
603 ) -> Option<AnyElement> {
604 if !self.show_completion_documentation {
605 return None;
606 }
607
608 let mat = &self.entries.borrow()[self.selected_item];
609 let multiline_docs = match self.completions.borrow_mut()[mat.candidate_id]
610 .documentation
611 .as_ref()?
612 {
613 CompletionDocumentation::MultiLinePlainText(text) => div().child(text.clone()),
614 CompletionDocumentation::MultiLineMarkdown(parsed) if !parsed.is_empty() => {
615 let markdown = self.markdown_element.get_or_insert_with(|| {
616 cx.new(|cx| {
617 let languages = editor
618 .workspace
619 .as_ref()
620 .and_then(|(workspace, _)| workspace.upgrade())
621 .map(|workspace| workspace.read(cx).app_state().languages.clone());
622 let language = editor
623 .language_at(self.initial_position, cx)
624 .map(|l| l.name().to_proto());
625 Markdown::new(SharedString::default(), languages, language, cx)
626 })
627 });
628 markdown.update(cx, |markdown, cx| {
629 markdown.reset(parsed.clone(), cx);
630 });
631 div().child(
632 MarkdownElement::new(markdown.clone(), hover_markdown_style(window, cx))
633 .code_block_renderer(markdown::CodeBlockRenderer::Default {
634 copy_button: false,
635 border: false,
636 })
637 .on_url_click(open_markdown_url),
638 )
639 }
640 CompletionDocumentation::MultiLineMarkdown(_) => return None,
641 CompletionDocumentation::SingleLine(_) => return None,
642 CompletionDocumentation::Undocumented => return None,
643 };
644
645 Some(
646 Popover::new()
647 .child(
648 multiline_docs
649 .id("multiline_docs")
650 .px(MENU_ASIDE_X_PADDING / 2.)
651 .max_w(max_size.width)
652 .max_h(max_size.height)
653 .overflow_y_scroll()
654 .occlude(),
655 )
656 .into_any_element(),
657 )
658 }
659
660 pub fn sort_matches(matches: &mut Vec<SortableMatch<'_>>, query: Option<&str>) {
661 #[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
662 enum MatchTier<'a> {
663 WordStartMatch {
664 sort_score_int: Reverse<i32>,
665 sort_snippet: Reverse<i32>,
666 sort_text: Option<&'a str>,
667 sort_key: (usize, &'a str),
668 },
669 OtherMatch {
670 sort_score: Reverse<OrderedFloat<f64>>,
671 },
672 }
673
674 // Our goal here is to intelligently sort completion suggestions. We want to
675 // balance the raw fuzzy match score with hints from the language server
676 //
677 // We first primary sort using fuzzy score by putting matches into two buckets
678 // strong one and weak one. Among these buckets matches are then compared by
679 // various criteria like snippet, LSP hints, kind, label text etc.
680 //
681 const FUZZY_THRESHOLD: f64 = 0.1317;
682
683 let query_start_lower = query
684 .and_then(|q| q.chars().next())
685 .and_then(|c| c.to_lowercase().next());
686
687 matches.sort_unstable_by_key(|mat| {
688 let score = mat.string_match.score;
689
690 let is_other_match = query_start_lower
691 .map(|query_char| {
692 !split_words(&mat.string_match.string).any(|word| {
693 word.chars()
694 .next()
695 .and_then(|c| c.to_lowercase().next())
696 .map_or(false, |word_char| word_char == query_char)
697 })
698 })
699 .unwrap_or(false);
700
701 if is_other_match {
702 let sort_score = Reverse(OrderedFloat(score));
703 MatchTier::OtherMatch { sort_score }
704 } else {
705 let sort_score_int = Reverse(if score >= FUZZY_THRESHOLD { 1 } else { 0 });
706 let sort_snippet = Reverse(if mat.is_snippet { 1 } else { 0 });
707 MatchTier::WordStartMatch {
708 sort_score_int,
709 sort_snippet,
710 sort_text: mat.sort_text,
711 sort_key: mat.sort_key,
712 }
713 }
714 });
715 }
716
717 pub async fn filter(&mut self, query: Option<&str>, executor: BackgroundExecutor) {
718 let mut matches = if let Some(query) = query {
719 fuzzy::match_strings(
720 &self.match_candidates,
721 query,
722 query.chars().any(|c| c.is_uppercase()),
723 100,
724 &Default::default(),
725 executor,
726 )
727 .await
728 } else {
729 self.match_candidates
730 .iter()
731 .enumerate()
732 .map(|(candidate_id, candidate)| StringMatch {
733 candidate_id,
734 score: Default::default(),
735 positions: Default::default(),
736 string: candidate.string.clone(),
737 })
738 .collect()
739 };
740
741 if self.sort_completions {
742 let completions = self.completions.borrow();
743
744 let mut sortable_items: Vec<SortableMatch<'_>> = matches
745 .into_iter()
746 .map(|string_match| {
747 let completion = &completions[string_match.candidate_id];
748
749 let is_snippet = matches!(
750 &completion.source,
751 CompletionSource::Lsp { lsp_completion, .. }
752 if lsp_completion.kind == Some(CompletionItemKind::SNIPPET)
753 );
754
755 let sort_text =
756 if let CompletionSource::Lsp { lsp_completion, .. } = &completion.source {
757 lsp_completion.sort_text.as_deref()
758 } else {
759 None
760 };
761
762 let sort_key = completion.sort_key();
763
764 SortableMatch {
765 string_match,
766 is_snippet,
767 sort_text,
768 sort_key,
769 }
770 })
771 .collect();
772
773 Self::sort_matches(&mut sortable_items, query);
774
775 matches = sortable_items
776 .into_iter()
777 .map(|sortable| sortable.string_match)
778 .collect();
779 }
780
781 *self.entries.borrow_mut() = matches;
782 self.selected_item = 0;
783 // This keeps the display consistent when y_flipped.
784 self.scroll_handle.scroll_to_item(0, ScrollStrategy::Top);
785 }
786}
787
788#[derive(Debug)]
789pub struct SortableMatch<'a> {
790 pub string_match: StringMatch,
791 pub is_snippet: bool,
792 pub sort_text: Option<&'a str>,
793 pub sort_key: (usize, &'a str),
794}
795
796#[derive(Clone)]
797pub struct AvailableCodeAction {
798 pub excerpt_id: ExcerptId,
799 pub action: CodeAction,
800 pub provider: Rc<dyn CodeActionProvider>,
801}
802
803#[derive(Clone)]
804pub struct CodeActionContents {
805 tasks: Option<Rc<ResolvedTasks>>,
806 actions: Option<Rc<[AvailableCodeAction]>>,
807}
808
809impl CodeActionContents {
810 pub fn new(
811 mut tasks: Option<ResolvedTasks>,
812 actions: Option<Rc<[AvailableCodeAction]>>,
813 cx: &App,
814 ) -> Self {
815 if !cx.has_flag::<Debugger>() {
816 if let Some(tasks) = &mut tasks {
817 tasks
818 .templates
819 .retain(|(_, task)| !matches!(task.task_type(), task::TaskType::Debug(_)));
820 }
821 }
822
823 Self {
824 tasks: tasks.map(Rc::new),
825 actions,
826 }
827 }
828
829 pub fn tasks(&self) -> Option<&ResolvedTasks> {
830 self.tasks.as_deref()
831 }
832
833 fn len(&self) -> usize {
834 match (&self.tasks, &self.actions) {
835 (Some(tasks), Some(actions)) => actions.len() + tasks.templates.len(),
836 (Some(tasks), None) => tasks.templates.len(),
837 (None, Some(actions)) => actions.len(),
838 (None, None) => 0,
839 }
840 }
841
842 fn is_empty(&self) -> bool {
843 match (&self.tasks, &self.actions) {
844 (Some(tasks), Some(actions)) => actions.is_empty() && tasks.templates.is_empty(),
845 (Some(tasks), None) => tasks.templates.is_empty(),
846 (None, Some(actions)) => actions.is_empty(),
847 (None, None) => true,
848 }
849 }
850
851 fn iter(&self) -> impl Iterator<Item = CodeActionsItem> + '_ {
852 self.tasks
853 .iter()
854 .flat_map(|tasks| {
855 tasks
856 .templates
857 .iter()
858 .map(|(kind, task)| CodeActionsItem::Task(kind.clone(), task.clone()))
859 })
860 .chain(self.actions.iter().flat_map(|actions| {
861 actions.iter().map(|available| CodeActionsItem::CodeAction {
862 excerpt_id: available.excerpt_id,
863 action: available.action.clone(),
864 provider: available.provider.clone(),
865 })
866 }))
867 }
868
869 pub fn get(&self, index: usize) -> Option<CodeActionsItem> {
870 match (&self.tasks, &self.actions) {
871 (Some(tasks), Some(actions)) => {
872 if index < tasks.templates.len() {
873 tasks
874 .templates
875 .get(index)
876 .cloned()
877 .map(|(kind, task)| CodeActionsItem::Task(kind, task))
878 } else {
879 actions.get(index - tasks.templates.len()).map(|available| {
880 CodeActionsItem::CodeAction {
881 excerpt_id: available.excerpt_id,
882 action: available.action.clone(),
883 provider: available.provider.clone(),
884 }
885 })
886 }
887 }
888 (Some(tasks), None) => tasks
889 .templates
890 .get(index)
891 .cloned()
892 .map(|(kind, task)| CodeActionsItem::Task(kind, task)),
893 (None, Some(actions)) => {
894 actions
895 .get(index)
896 .map(|available| CodeActionsItem::CodeAction {
897 excerpt_id: available.excerpt_id,
898 action: available.action.clone(),
899 provider: available.provider.clone(),
900 })
901 }
902 (None, None) => None,
903 }
904 }
905}
906
907#[allow(clippy::large_enum_variant)]
908#[derive(Clone)]
909pub enum CodeActionsItem {
910 Task(TaskSourceKind, ResolvedTask),
911 CodeAction {
912 excerpt_id: ExcerptId,
913 action: CodeAction,
914 provider: Rc<dyn CodeActionProvider>,
915 },
916}
917
918impl CodeActionsItem {
919 fn as_task(&self) -> Option<&ResolvedTask> {
920 let Self::Task(_, task) = self else {
921 return None;
922 };
923 Some(task)
924 }
925
926 fn as_code_action(&self) -> Option<&CodeAction> {
927 let Self::CodeAction { action, .. } = self else {
928 return None;
929 };
930 Some(action)
931 }
932
933 pub fn label(&self) -> String {
934 match self {
935 Self::CodeAction { action, .. } => action.lsp_action.title().to_owned(),
936 Self::Task(_, task) => task.resolved_label.clone(),
937 }
938 }
939}
940
941pub struct CodeActionsMenu {
942 pub actions: CodeActionContents,
943 pub buffer: Entity<Buffer>,
944 pub selected_item: usize,
945 pub scroll_handle: UniformListScrollHandle,
946 pub deployed_from_indicator: Option<DisplayRow>,
947}
948
949impl CodeActionsMenu {
950 fn select_first(&mut self, cx: &mut Context<Editor>) {
951 self.selected_item = if self.scroll_handle.y_flipped() {
952 self.actions.len() - 1
953 } else {
954 0
955 };
956 self.scroll_handle
957 .scroll_to_item(self.selected_item, ScrollStrategy::Top);
958 cx.notify()
959 }
960
961 fn select_last(&mut self, cx: &mut Context<Editor>) {
962 self.selected_item = if self.scroll_handle.y_flipped() {
963 0
964 } else {
965 self.actions.len() - 1
966 };
967 self.scroll_handle
968 .scroll_to_item(self.selected_item, ScrollStrategy::Top);
969 cx.notify()
970 }
971
972 fn select_prev(&mut self, cx: &mut Context<Editor>) {
973 self.selected_item = if self.scroll_handle.y_flipped() {
974 self.next_match_index()
975 } else {
976 self.prev_match_index()
977 };
978 self.scroll_handle
979 .scroll_to_item(self.selected_item, ScrollStrategy::Top);
980 cx.notify();
981 }
982
983 fn select_next(&mut self, cx: &mut Context<Editor>) {
984 self.selected_item = if self.scroll_handle.y_flipped() {
985 self.prev_match_index()
986 } else {
987 self.next_match_index()
988 };
989 self.scroll_handle
990 .scroll_to_item(self.selected_item, ScrollStrategy::Top);
991 cx.notify();
992 }
993
994 fn prev_match_index(&self) -> usize {
995 if self.selected_item > 0 {
996 self.selected_item - 1
997 } else {
998 self.actions.len() - 1
999 }
1000 }
1001
1002 fn next_match_index(&self) -> usize {
1003 if self.selected_item + 1 < self.actions.len() {
1004 self.selected_item + 1
1005 } else {
1006 0
1007 }
1008 }
1009
1010 fn visible(&self) -> bool {
1011 !self.actions.is_empty()
1012 }
1013
1014 fn origin(&self) -> ContextMenuOrigin {
1015 if let Some(row) = self.deployed_from_indicator {
1016 ContextMenuOrigin::GutterIndicator(row)
1017 } else {
1018 ContextMenuOrigin::Cursor
1019 }
1020 }
1021
1022 fn render(
1023 &self,
1024 _style: &EditorStyle,
1025 max_height_in_lines: u32,
1026 window: &mut Window,
1027 cx: &mut Context<Editor>,
1028 ) -> AnyElement {
1029 let actions = self.actions.clone();
1030 let selected_item = self.selected_item;
1031 let list = uniform_list(
1032 cx.entity().clone(),
1033 "code_actions_menu",
1034 self.actions.len(),
1035 move |_this, range, _, cx| {
1036 actions
1037 .iter()
1038 .skip(range.start)
1039 .take(range.end - range.start)
1040 .enumerate()
1041 .map(|(ix, action)| {
1042 let item_ix = range.start + ix;
1043 let selected = item_ix == selected_item;
1044 let colors = cx.theme().colors();
1045 div().min_w(px(220.)).max_w(px(540.)).child(
1046 ListItem::new(item_ix)
1047 .inset(true)
1048 .toggle_state(selected)
1049 .when_some(action.as_code_action(), |this, action| {
1050 this.on_click(cx.listener(move |editor, _, window, cx| {
1051 cx.stop_propagation();
1052 if let Some(task) = editor.confirm_code_action(
1053 &ConfirmCodeAction {
1054 item_ix: Some(item_ix),
1055 },
1056 window,
1057 cx,
1058 ) {
1059 task.detach_and_log_err(cx)
1060 }
1061 }))
1062 .child(
1063 h_flex()
1064 .overflow_hidden()
1065 .child(
1066 // TASK: It would be good to make lsp_action.title a SharedString to avoid allocating here.
1067 action.lsp_action.title().replace("\n", ""),
1068 )
1069 .when(selected, |this| {
1070 this.text_color(colors.text_accent)
1071 }),
1072 )
1073 })
1074 .when_some(action.as_task(), |this, task| {
1075 this.on_click(cx.listener(move |editor, _, window, cx| {
1076 cx.stop_propagation();
1077 if let Some(task) = editor.confirm_code_action(
1078 &ConfirmCodeAction {
1079 item_ix: Some(item_ix),
1080 },
1081 window,
1082 cx,
1083 ) {
1084 task.detach_and_log_err(cx)
1085 }
1086 }))
1087 .child(
1088 h_flex()
1089 .overflow_hidden()
1090 .child(task.resolved_label.replace("\n", ""))
1091 .when(selected, |this| {
1092 this.text_color(colors.text_accent)
1093 }),
1094 )
1095 }),
1096 )
1097 })
1098 .collect()
1099 },
1100 )
1101 .occlude()
1102 .max_h(max_height_in_lines as f32 * window.line_height())
1103 .track_scroll(self.scroll_handle.clone())
1104 .with_width_from_item(
1105 self.actions
1106 .iter()
1107 .enumerate()
1108 .max_by_key(|(_, action)| match action {
1109 CodeActionsItem::Task(_, task) => task.resolved_label.chars().count(),
1110 CodeActionsItem::CodeAction { action, .. } => {
1111 action.lsp_action.title().chars().count()
1112 }
1113 })
1114 .map(|(ix, _)| ix),
1115 )
1116 .with_sizing_behavior(ListSizingBehavior::Infer);
1117
1118 Popover::new().child(list).into_any_element()
1119 }
1120}