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