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