1use fuzzy::{StringMatch, StringMatchCandidate};
2use gpui::{
3 AnyElement, BackgroundExecutor, Entity, Focusable, FontWeight, ListSizingBehavior,
4 ScrollStrategy, SharedString, Size, StrikethroughStyle, StyledText, UniformListScrollHandle,
5 div, px, uniform_list,
6};
7use language::Buffer;
8use language::CodeLabel;
9use markdown::Markdown;
10use multi_buffer::{Anchor, ExcerptId};
11use ordered_float::OrderedFloat;
12use project::CompletionSource;
13use project::lsp_store::CompletionDocumentation;
14use project::{CodeAction, Completion, TaskSourceKind};
15
16use std::{
17 cell::RefCell,
18 cmp::{Reverse, min},
19 iter,
20 ops::Range,
21 rc::Rc,
22};
23use task::ResolvedTask;
24use ui::{Color, IntoElement, ListItem, Pixels, Popover, Styled, prelude::*};
25use util::ResultExt;
26
27use crate::hover_popover::{hover_markdown_style, open_markdown_url};
28use crate::{
29 CodeActionProvider, CompletionId, CompletionProvider, DisplayRow, Editor, EditorStyle,
30 ResolvedTasks,
31 actions::{ConfirmCodeAction, ConfirmCompletion},
32 split_words, styled_runs_for_code_label,
33};
34
35pub const MENU_GAP: Pixels = px(4.);
36pub const MENU_ASIDE_X_PADDING: Pixels = px(16.);
37pub const MENU_ASIDE_MIN_WIDTH: Pixels = px(260.);
38pub const MENU_ASIDE_MAX_WIDTH: Pixels = px(500.);
39
40pub enum CodeContextMenu {
41 Completions(CompletionsMenu),
42 CodeActions(CodeActionsMenu),
43}
44
45impl CodeContextMenu {
46 pub fn select_first(
47 &mut self,
48 provider: Option<&dyn CompletionProvider>,
49 cx: &mut Context<Editor>,
50 ) -> bool {
51 if self.visible() {
52 match self {
53 CodeContextMenu::Completions(menu) => menu.select_first(provider, cx),
54 CodeContextMenu::CodeActions(menu) => menu.select_first(cx),
55 }
56 true
57 } else {
58 false
59 }
60 }
61
62 pub fn select_prev(
63 &mut self,
64 provider: Option<&dyn CompletionProvider>,
65 cx: &mut Context<Editor>,
66 ) -> bool {
67 if self.visible() {
68 match self {
69 CodeContextMenu::Completions(menu) => menu.select_prev(provider, cx),
70 CodeContextMenu::CodeActions(menu) => menu.select_prev(cx),
71 }
72 true
73 } else {
74 false
75 }
76 }
77
78 pub fn select_next(
79 &mut self,
80 provider: Option<&dyn CompletionProvider>,
81 cx: &mut Context<Editor>,
82 ) -> bool {
83 if self.visible() {
84 match self {
85 CodeContextMenu::Completions(menu) => menu.select_next(provider, cx),
86 CodeContextMenu::CodeActions(menu) => menu.select_next(cx),
87 }
88 true
89 } else {
90 false
91 }
92 }
93
94 pub fn select_last(
95 &mut self,
96 provider: Option<&dyn CompletionProvider>,
97 cx: &mut Context<Editor>,
98 ) -> bool {
99 if self.visible() {
100 match self {
101 CodeContextMenu::Completions(menu) => menu.select_last(provider, cx),
102 CodeContextMenu::CodeActions(menu) => menu.select_last(cx),
103 }
104 true
105 } else {
106 false
107 }
108 }
109
110 pub fn visible(&self) -> bool {
111 match self {
112 CodeContextMenu::Completions(menu) => menu.visible(),
113 CodeContextMenu::CodeActions(menu) => menu.visible(),
114 }
115 }
116
117 pub fn origin(&self) -> ContextMenuOrigin {
118 match self {
119 CodeContextMenu::Completions(menu) => menu.origin(),
120 CodeContextMenu::CodeActions(menu) => menu.origin(),
121 }
122 }
123
124 pub fn render(
125 &self,
126 style: &EditorStyle,
127 max_height_in_lines: u32,
128 y_flipped: bool,
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, y_flipped, window, cx)
135 }
136 CodeContextMenu::CodeActions(menu) => {
137 menu.render(style, max_height_in_lines, y_flipped, 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 old_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 source: CompletionSource::Custom,
244 })
245 .collect();
246
247 let match_candidates = choices
248 .iter()
249 .enumerate()
250 .map(|(id, completion)| StringMatchCandidate::new(id, &completion))
251 .collect();
252 let entries = choices
253 .iter()
254 .enumerate()
255 .map(|(id, completion)| StringMatch {
256 candidate_id: id,
257 score: 1.,
258 positions: vec![],
259 string: completion.clone(),
260 })
261 .collect::<Vec<_>>();
262 Self {
263 id,
264 sort_completions,
265 initial_position: selection.start,
266 buffer,
267 completions: RefCell::new(completions).into(),
268 match_candidates,
269 entries: RefCell::new(entries).into(),
270 selected_item: 0,
271 scroll_handle: UniformListScrollHandle::new(),
272 resolve_completions: false,
273 show_completion_documentation: false,
274 ignore_completion_provider: false,
275 last_rendered_range: RefCell::new(None).into(),
276 markdown_element: None,
277 }
278 }
279
280 fn select_first(
281 &mut self,
282 provider: Option<&dyn CompletionProvider>,
283 cx: &mut Context<Editor>,
284 ) {
285 let index = if self.scroll_handle.y_flipped() {
286 self.entries.borrow().len() - 1
287 } else {
288 0
289 };
290 self.update_selection_index(index, provider, cx);
291 }
292
293 fn select_last(&mut self, provider: Option<&dyn CompletionProvider>, cx: &mut Context<Editor>) {
294 let index = if self.scroll_handle.y_flipped() {
295 0
296 } else {
297 self.entries.borrow().len() - 1
298 };
299 self.update_selection_index(index, provider, cx);
300 }
301
302 fn select_prev(&mut self, provider: Option<&dyn CompletionProvider>, cx: &mut Context<Editor>) {
303 let index = if self.scroll_handle.y_flipped() {
304 self.next_match_index()
305 } else {
306 self.prev_match_index()
307 };
308 self.update_selection_index(index, provider, cx);
309 }
310
311 fn select_next(&mut self, provider: Option<&dyn CompletionProvider>, cx: &mut Context<Editor>) {
312 let index = if self.scroll_handle.y_flipped() {
313 self.prev_match_index()
314 } else {
315 self.next_match_index()
316 };
317 self.update_selection_index(index, provider, cx);
318 }
319
320 fn update_selection_index(
321 &mut self,
322 match_index: usize,
323 provider: Option<&dyn CompletionProvider>,
324 cx: &mut Context<Editor>,
325 ) {
326 if self.selected_item != match_index {
327 self.selected_item = match_index;
328 self.scroll_handle
329 .scroll_to_item(self.selected_item, ScrollStrategy::Top);
330 self.resolve_visible_completions(provider, cx);
331 cx.notify();
332 }
333 }
334
335 fn prev_match_index(&self) -> usize {
336 if self.selected_item > 0 {
337 self.selected_item - 1
338 } else {
339 self.entries.borrow().len() - 1
340 }
341 }
342
343 fn next_match_index(&self) -> usize {
344 if self.selected_item + 1 < self.entries.borrow().len() {
345 self.selected_item + 1
346 } else {
347 0
348 }
349 }
350
351 pub fn resolve_visible_completions(
352 &mut self,
353 provider: Option<&dyn CompletionProvider>,
354 cx: &mut Context<Editor>,
355 ) {
356 if !self.resolve_completions {
357 return;
358 }
359 let Some(provider) = provider else {
360 return;
361 };
362
363 // Attempt to resolve completions for every item that will be displayed. This matters
364 // because single line documentation may be displayed inline with the completion.
365 //
366 // When navigating to the very beginning or end of completions, `last_rendered_range` may
367 // have no overlap with the completions that will be displayed, so instead use a range based
368 // on the last rendered count.
369 const APPROXIMATE_VISIBLE_COUNT: usize = 12;
370 let last_rendered_range = self.last_rendered_range.borrow().clone();
371 let visible_count = last_rendered_range
372 .clone()
373 .map_or(APPROXIMATE_VISIBLE_COUNT, |range| range.count());
374 let entries = self.entries.borrow();
375 let entry_range = if self.selected_item == 0 {
376 0..min(visible_count, entries.len())
377 } else if self.selected_item == entries.len() - 1 {
378 entries.len().saturating_sub(visible_count)..entries.len()
379 } else {
380 last_rendered_range.map_or(0..0, |range| {
381 min(range.start, entries.len())..min(range.end, entries.len())
382 })
383 };
384
385 // Expand the range to resolve more completions than are predicted to be visible, to reduce
386 // jank on navigation.
387 const EXTRA_TO_RESOLVE: usize = 4;
388 let entry_indices = util::iterate_expanded_and_wrapped_usize_range(
389 entry_range.clone(),
390 EXTRA_TO_RESOLVE,
391 EXTRA_TO_RESOLVE,
392 entries.len(),
393 );
394
395 // Avoid work by sometimes filtering out completions that already have documentation.
396 // This filtering doesn't happen if the completions are currently being updated.
397 let completions = self.completions.borrow();
398 let candidate_ids = entry_indices
399 .map(|i| entries[i].candidate_id)
400 .filter(|i| completions[*i].documentation.is_none());
401
402 // Current selection is always resolved even if it already has documentation, to handle
403 // out-of-spec language servers that return more results later.
404 let selected_candidate_id = entries[self.selected_item].candidate_id;
405 let candidate_ids = iter::once(selected_candidate_id)
406 .chain(candidate_ids.filter(|id| *id != selected_candidate_id))
407 .collect::<Vec<usize>>();
408 drop(entries);
409
410 if candidate_ids.is_empty() {
411 return;
412 }
413
414 let resolve_task = provider.resolve_completions(
415 self.buffer.clone(),
416 candidate_ids,
417 self.completions.clone(),
418 cx,
419 );
420
421 cx.spawn(async move |editor, cx| {
422 if let Some(true) = resolve_task.await.log_err() {
423 editor.update(cx, |_, cx| cx.notify()).ok();
424 }
425 })
426 .detach();
427 }
428
429 pub fn visible(&self) -> bool {
430 !self.entries.borrow().is_empty()
431 }
432
433 fn origin(&self) -> ContextMenuOrigin {
434 ContextMenuOrigin::Cursor
435 }
436
437 fn render(
438 &self,
439 style: &EditorStyle,
440 max_height_in_lines: u32,
441 y_flipped: bool,
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 .y_flipped(y_flipped)
592 .with_width_from_item(widest_completion_ix)
593 .with_sizing_behavior(ListSizingBehavior::Infer);
594
595 Popover::new().child(list).into_any_element()
596 }
597
598 fn render_aside(
599 &mut self,
600 editor: &Editor,
601 max_size: Size<Pixels>,
602 window: &mut Window,
603 cx: &mut Context<Editor>,
604 ) -> Option<AnyElement> {
605 if !self.show_completion_documentation {
606 return None;
607 }
608
609 let mat = &self.entries.borrow()[self.selected_item];
610 let multiline_docs = match self.completions.borrow_mut()[mat.candidate_id]
611 .documentation
612 .as_ref()?
613 {
614 CompletionDocumentation::MultiLinePlainText(text) => div().child(text.clone()),
615 CompletionDocumentation::MultiLineMarkdown(parsed) if !parsed.is_empty() => {
616 let markdown = self.markdown_element.get_or_insert_with(|| {
617 cx.new(|cx| {
618 let languages = editor
619 .workspace
620 .as_ref()
621 .and_then(|(workspace, _)| workspace.upgrade())
622 .map(|workspace| workspace.read(cx).app_state().languages.clone());
623 let language = editor
624 .language_at(self.initial_position, cx)
625 .map(|l| l.name().to_proto());
626 Markdown::new(
627 SharedString::default(),
628 hover_markdown_style(window, cx),
629 languages,
630 language,
631 cx,
632 )
633 .copy_code_block_buttons(false)
634 .open_url(open_markdown_url)
635 })
636 });
637 markdown.update(cx, |markdown, cx| {
638 markdown.reset(parsed.clone(), cx);
639 });
640 div().child(markdown.clone())
641 }
642 CompletionDocumentation::MultiLineMarkdown(_) => return None,
643 CompletionDocumentation::SingleLine(_) => return None,
644 CompletionDocumentation::Undocumented => return None,
645 };
646
647 Some(
648 Popover::new()
649 .child(
650 multiline_docs
651 .id("multiline_docs")
652 .px(MENU_ASIDE_X_PADDING / 2.)
653 .max_w(max_size.width)
654 .max_h(max_size.height)
655 .overflow_y_scroll()
656 .occlude(),
657 )
658 .into_any_element(),
659 )
660 }
661
662 pub async fn filter(&mut self, query: Option<&str>, executor: BackgroundExecutor) {
663 let mut matches = if let Some(query) = query {
664 fuzzy::match_strings(
665 &self.match_candidates,
666 query,
667 query.chars().any(|c| c.is_uppercase()),
668 100,
669 &Default::default(),
670 executor,
671 )
672 .await
673 } else {
674 self.match_candidates
675 .iter()
676 .enumerate()
677 .map(|(candidate_id, candidate)| StringMatch {
678 candidate_id,
679 score: Default::default(),
680 positions: Default::default(),
681 string: candidate.string.clone(),
682 })
683 .collect()
684 };
685
686 let mut additional_matches = Vec::new();
687 // Deprioritize all candidates where the query's start does not match the start of any word in the candidate
688 if let Some(query) = query {
689 if let Some(query_start) = query.chars().next() {
690 let (primary, secondary) = matches.into_iter().partition(|string_match| {
691 split_words(&string_match.string).any(|word| {
692 // Check that the first codepoint of the word as lowercase matches the first
693 // codepoint of the query as lowercase
694 word.chars()
695 .flat_map(|codepoint| codepoint.to_lowercase())
696 .zip(query_start.to_lowercase())
697 .all(|(word_cp, query_cp)| word_cp == query_cp)
698 })
699 });
700 matches = primary;
701 additional_matches = secondary;
702 }
703 }
704
705 let completions = self.completions.borrow_mut();
706 if self.sort_completions {
707 matches.sort_unstable_by_key(|mat| {
708 // We do want to strike a balance here between what the language server tells us
709 // to sort by (the sort_text) and what are "obvious" good matches (i.e. when you type
710 // `Creat` and there is a local variable called `CreateComponent`).
711 // So what we do is: we bucket all matches into two buckets
712 // - Strong matches
713 // - Weak matches
714 // Strong matches are the ones with a high fuzzy-matcher score (the "obvious" matches)
715 // and the Weak matches are the rest.
716 //
717 // For the strong matches, we sort by our fuzzy-finder score first and for the weak
718 // matches, we prefer language-server sort_text first.
719 //
720 // The thinking behind that: we want to show strong matches first in order of relevance(fuzzy score).
721 // Rest of the matches(weak) can be sorted as language-server expects.
722
723 #[derive(PartialEq, Eq, PartialOrd, Ord)]
724 enum MatchScore<'a> {
725 Strong {
726 score: Reverse<OrderedFloat<f64>>,
727 sort_text: Option<&'a str>,
728 sort_key: (usize, &'a str),
729 },
730 Weak {
731 sort_text: Option<&'a str>,
732 score: Reverse<OrderedFloat<f64>>,
733 sort_key: (usize, &'a str),
734 },
735 }
736
737 let completion = &completions[mat.candidate_id];
738 let sort_key = completion.sort_key();
739 let sort_text =
740 if let CompletionSource::Lsp { lsp_completion, .. } = &completion.source {
741 lsp_completion.sort_text.as_deref()
742 } else {
743 None
744 };
745 let score = Reverse(OrderedFloat(mat.score));
746
747 if mat.score >= 0.2 {
748 MatchScore::Strong {
749 score,
750 sort_text,
751 sort_key,
752 }
753 } else {
754 MatchScore::Weak {
755 sort_text,
756 score,
757 sort_key,
758 }
759 }
760 });
761 }
762 drop(completions);
763
764 matches.extend(additional_matches);
765
766 *self.entries.borrow_mut() = matches;
767 self.selected_item = 0;
768 // This keeps the display consistent when y_flipped.
769 self.scroll_handle.scroll_to_item(0, ScrollStrategy::Top);
770 }
771}
772
773#[derive(Clone)]
774pub struct AvailableCodeAction {
775 pub excerpt_id: ExcerptId,
776 pub action: CodeAction,
777 pub provider: Rc<dyn CodeActionProvider>,
778}
779
780#[derive(Clone)]
781pub struct CodeActionContents {
782 pub tasks: Option<Rc<ResolvedTasks>>,
783 pub actions: Option<Rc<[AvailableCodeAction]>>,
784}
785
786impl CodeActionContents {
787 fn len(&self) -> usize {
788 match (&self.tasks, &self.actions) {
789 (Some(tasks), Some(actions)) => actions.len() + tasks.templates.len(),
790 (Some(tasks), None) => tasks.templates.len(),
791 (None, Some(actions)) => actions.len(),
792 (None, None) => 0,
793 }
794 }
795
796 fn is_empty(&self) -> bool {
797 match (&self.tasks, &self.actions) {
798 (Some(tasks), Some(actions)) => actions.is_empty() && tasks.templates.is_empty(),
799 (Some(tasks), None) => tasks.templates.is_empty(),
800 (None, Some(actions)) => actions.is_empty(),
801 (None, None) => true,
802 }
803 }
804
805 fn iter(&self) -> impl Iterator<Item = CodeActionsItem> + '_ {
806 self.tasks
807 .iter()
808 .flat_map(|tasks| {
809 tasks
810 .templates
811 .iter()
812 .map(|(kind, task)| CodeActionsItem::Task(kind.clone(), task.clone()))
813 })
814 .chain(self.actions.iter().flat_map(|actions| {
815 actions.iter().map(|available| CodeActionsItem::CodeAction {
816 excerpt_id: available.excerpt_id,
817 action: available.action.clone(),
818 provider: available.provider.clone(),
819 })
820 }))
821 }
822
823 pub fn get(&self, index: usize) -> Option<CodeActionsItem> {
824 match (&self.tasks, &self.actions) {
825 (Some(tasks), Some(actions)) => {
826 if index < tasks.templates.len() {
827 tasks
828 .templates
829 .get(index)
830 .cloned()
831 .map(|(kind, task)| CodeActionsItem::Task(kind, task))
832 } else {
833 actions.get(index - tasks.templates.len()).map(|available| {
834 CodeActionsItem::CodeAction {
835 excerpt_id: available.excerpt_id,
836 action: available.action.clone(),
837 provider: available.provider.clone(),
838 }
839 })
840 }
841 }
842 (Some(tasks), None) => tasks
843 .templates
844 .get(index)
845 .cloned()
846 .map(|(kind, task)| CodeActionsItem::Task(kind, task)),
847 (None, Some(actions)) => {
848 actions
849 .get(index)
850 .map(|available| CodeActionsItem::CodeAction {
851 excerpt_id: available.excerpt_id,
852 action: available.action.clone(),
853 provider: available.provider.clone(),
854 })
855 }
856 (None, None) => None,
857 }
858 }
859}
860
861#[allow(clippy::large_enum_variant)]
862#[derive(Clone)]
863pub enum CodeActionsItem {
864 Task(TaskSourceKind, ResolvedTask),
865 CodeAction {
866 excerpt_id: ExcerptId,
867 action: CodeAction,
868 provider: Rc<dyn CodeActionProvider>,
869 },
870}
871
872impl CodeActionsItem {
873 fn as_task(&self) -> Option<&ResolvedTask> {
874 let Self::Task(_, task) = self else {
875 return None;
876 };
877 Some(task)
878 }
879
880 fn as_code_action(&self) -> Option<&CodeAction> {
881 let Self::CodeAction { action, .. } = self else {
882 return None;
883 };
884 Some(action)
885 }
886
887 pub fn label(&self) -> String {
888 match self {
889 Self::CodeAction { action, .. } => action.lsp_action.title().to_owned(),
890 Self::Task(_, task) => task.resolved_label.clone(),
891 }
892 }
893}
894
895pub struct CodeActionsMenu {
896 pub actions: CodeActionContents,
897 pub buffer: Entity<Buffer>,
898 pub selected_item: usize,
899 pub scroll_handle: UniformListScrollHandle,
900 pub deployed_from_indicator: Option<DisplayRow>,
901}
902
903impl CodeActionsMenu {
904 fn select_first(&mut self, cx: &mut Context<Editor>) {
905 self.selected_item = if self.scroll_handle.y_flipped() {
906 self.actions.len() - 1
907 } else {
908 0
909 };
910 self.scroll_handle
911 .scroll_to_item(self.selected_item, ScrollStrategy::Top);
912 cx.notify()
913 }
914
915 fn select_last(&mut self, cx: &mut Context<Editor>) {
916 self.selected_item = if self.scroll_handle.y_flipped() {
917 0
918 } else {
919 self.actions.len() - 1
920 };
921 self.scroll_handle
922 .scroll_to_item(self.selected_item, ScrollStrategy::Top);
923 cx.notify()
924 }
925
926 fn select_prev(&mut self, cx: &mut Context<Editor>) {
927 self.selected_item = if self.scroll_handle.y_flipped() {
928 self.next_match_index()
929 } else {
930 self.prev_match_index()
931 };
932 self.scroll_handle
933 .scroll_to_item(self.selected_item, ScrollStrategy::Top);
934 cx.notify();
935 }
936
937 fn select_next(&mut self, cx: &mut Context<Editor>) {
938 self.selected_item = if self.scroll_handle.y_flipped() {
939 self.prev_match_index()
940 } else {
941 self.next_match_index()
942 };
943 self.scroll_handle
944 .scroll_to_item(self.selected_item, ScrollStrategy::Top);
945 cx.notify();
946 }
947
948 fn prev_match_index(&self) -> usize {
949 if self.selected_item > 0 {
950 self.selected_item - 1
951 } else {
952 self.actions.len() - 1
953 }
954 }
955
956 fn next_match_index(&self) -> usize {
957 if self.selected_item + 1 < self.actions.len() {
958 self.selected_item + 1
959 } else {
960 0
961 }
962 }
963
964 fn visible(&self) -> bool {
965 !self.actions.is_empty()
966 }
967
968 fn origin(&self) -> ContextMenuOrigin {
969 if let Some(row) = self.deployed_from_indicator {
970 ContextMenuOrigin::GutterIndicator(row)
971 } else {
972 ContextMenuOrigin::Cursor
973 }
974 }
975
976 fn render(
977 &self,
978 _style: &EditorStyle,
979 max_height_in_lines: u32,
980 y_flipped: bool,
981 window: &mut Window,
982 cx: &mut Context<Editor>,
983 ) -> AnyElement {
984 let actions = self.actions.clone();
985 let selected_item = self.selected_item;
986 let list = uniform_list(
987 cx.entity().clone(),
988 "code_actions_menu",
989 self.actions.len(),
990 move |_this, range, _, cx| {
991 actions
992 .iter()
993 .skip(range.start)
994 .take(range.end - range.start)
995 .enumerate()
996 .map(|(ix, action)| {
997 let item_ix = range.start + ix;
998 let selected = item_ix == selected_item;
999 let colors = cx.theme().colors();
1000 div().min_w(px(220.)).max_w(px(540.)).child(
1001 ListItem::new(item_ix)
1002 .inset(true)
1003 .toggle_state(selected)
1004 .when_some(action.as_code_action(), |this, action| {
1005 this.on_click(cx.listener(move |editor, _, window, cx| {
1006 cx.stop_propagation();
1007 if let Some(task) = editor.confirm_code_action(
1008 &ConfirmCodeAction {
1009 item_ix: Some(item_ix),
1010 },
1011 window,
1012 cx,
1013 ) {
1014 task.detach_and_log_err(cx)
1015 }
1016 }))
1017 .child(
1018 h_flex()
1019 .overflow_hidden()
1020 .child(
1021 // TASK: It would be good to make lsp_action.title a SharedString to avoid allocating here.
1022 action.lsp_action.title().replace("\n", ""),
1023 )
1024 .when(selected, |this| {
1025 this.text_color(colors.text_accent)
1026 }),
1027 )
1028 })
1029 .when_some(action.as_task(), |this, task| {
1030 this.on_click(cx.listener(move |editor, _, window, cx| {
1031 cx.stop_propagation();
1032 if let Some(task) = editor.confirm_code_action(
1033 &ConfirmCodeAction {
1034 item_ix: Some(item_ix),
1035 },
1036 window,
1037 cx,
1038 ) {
1039 task.detach_and_log_err(cx)
1040 }
1041 }))
1042 .child(
1043 h_flex()
1044 .overflow_hidden()
1045 .child(task.resolved_label.replace("\n", ""))
1046 .when(selected, |this| {
1047 this.text_color(colors.text_accent)
1048 }),
1049 )
1050 }),
1051 )
1052 })
1053 .collect()
1054 },
1055 )
1056 .occlude()
1057 .max_h(max_height_in_lines as f32 * window.line_height())
1058 .track_scroll(self.scroll_handle.clone())
1059 .y_flipped(y_flipped)
1060 .with_width_from_item(
1061 self.actions
1062 .iter()
1063 .enumerate()
1064 .max_by_key(|(_, action)| match action {
1065 CodeActionsItem::Task(_, task) => task.resolved_label.chars().count(),
1066 CodeActionsItem::CodeAction { action, .. } => {
1067 action.lsp_action.title().chars().count()
1068 }
1069 })
1070 .map(|(ix, _)| ix),
1071 )
1072 .with_sizing_behavior(ListSizingBehavior::Infer);
1073
1074 Popover::new().child(list).into_any_element()
1075 }
1076}