1use crate::Direction;
  2use gpui::{AppContext, Model, ModelContext};
  3use language::Buffer;
  4use std::ops::Range;
  5
  6pub trait InlineCompletionProvider: 'static + Sized {
  7    fn name() -> &'static str;
  8    fn is_enabled(
  9        &self,
 10        buffer: &Model<Buffer>,
 11        cursor_position: language::Anchor,
 12        cx: &AppContext,
 13    ) -> bool;
 14    fn refresh(
 15        &mut self,
 16        buffer: Model<Buffer>,
 17        cursor_position: language::Anchor,
 18        debounce: bool,
 19        cx: &mut ModelContext<Self>,
 20    );
 21    fn cycle(
 22        &mut self,
 23        buffer: Model<Buffer>,
 24        cursor_position: language::Anchor,
 25        direction: Direction,
 26        cx: &mut ModelContext<Self>,
 27    );
 28    fn accept(&mut self, cx: &mut ModelContext<Self>);
 29    fn discard(&mut self, should_report_inline_completion_event: bool, cx: &mut ModelContext<Self>);
 30    fn active_completion_text<'a>(
 31        &'a self,
 32        buffer: &Model<Buffer>,
 33        cursor_position: language::Anchor,
 34        cx: &'a AppContext,
 35    ) -> Option<(&'a str, Option<Range<language::Anchor>>)>;
 36}
 37
 38pub trait InlineCompletionProviderHandle {
 39    fn is_enabled(
 40        &self,
 41        buffer: &Model<Buffer>,
 42        cursor_position: language::Anchor,
 43        cx: &AppContext,
 44    ) -> bool;
 45    fn refresh(
 46        &self,
 47        buffer: Model<Buffer>,
 48        cursor_position: language::Anchor,
 49        debounce: bool,
 50        cx: &mut AppContext,
 51    );
 52    fn cycle(
 53        &self,
 54        buffer: Model<Buffer>,
 55        cursor_position: language::Anchor,
 56        direction: Direction,
 57        cx: &mut AppContext,
 58    );
 59    fn accept(&self, cx: &mut AppContext);
 60    fn discard(&self, should_report_inline_completion_event: bool, cx: &mut AppContext);
 61    fn active_completion_text<'a>(
 62        &'a self,
 63        buffer: &Model<Buffer>,
 64        cursor_position: language::Anchor,
 65        cx: &'a AppContext,
 66    ) -> Option<(&'a str, Option<Range<language::Anchor>>)>;
 67}
 68
 69impl<T> InlineCompletionProviderHandle for Model<T>
 70where
 71    T: InlineCompletionProvider,
 72{
 73    fn is_enabled(
 74        &self,
 75        buffer: &Model<Buffer>,
 76        cursor_position: language::Anchor,
 77        cx: &AppContext,
 78    ) -> bool {
 79        self.read(cx).is_enabled(buffer, cursor_position, cx)
 80    }
 81
 82    fn refresh(
 83        &self,
 84        buffer: Model<Buffer>,
 85        cursor_position: language::Anchor,
 86        debounce: bool,
 87        cx: &mut AppContext,
 88    ) {
 89        self.update(cx, |this, cx| {
 90            this.refresh(buffer, cursor_position, debounce, cx)
 91        })
 92    }
 93
 94    fn cycle(
 95        &self,
 96        buffer: Model<Buffer>,
 97        cursor_position: language::Anchor,
 98        direction: Direction,
 99        cx: &mut AppContext,
100    ) {
101        self.update(cx, |this, cx| {
102            this.cycle(buffer, cursor_position, direction, cx)
103        })
104    }
105
106    fn accept(&self, cx: &mut AppContext) {
107        self.update(cx, |this, cx| this.accept(cx))
108    }
109
110    fn discard(&self, should_report_inline_completion_event: bool, cx: &mut AppContext) {
111        self.update(cx, |this, cx| {
112            this.discard(should_report_inline_completion_event, cx)
113        })
114    }
115
116    fn active_completion_text<'a>(
117        &'a self,
118        buffer: &Model<Buffer>,
119        cursor_position: language::Anchor,
120        cx: &'a AppContext,
121    ) -> Option<(&'a str, Option<Range<language::Anchor>>)> {
122        self.read(cx)
123            .active_completion_text(buffer, cursor_position, cx)
124    }
125}