Extract InlineCompletionProvider to its own crate (#20935)

This PR extracts the `InlineCompletionProvider` trait and its related
types out of `editor` and into a new `inline_completion` crate.

By doing so we're able to remove a dependency on `editor` from the
`copilot` and `supermaven` crates.

We did have to move `editor::Direction` into the `inline_completion`
crate, as it is referenced by the `InlineCompletionProvider`. This
should find a better home, at some point.

Release Notes:

- N/A

crates/inline_completion/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "inline_completion"
+version = "0.1.0"
+edition = "2021"
+publish = false
+license = "GPL-3.0-or-later"
+
+[lints]
+workspace = true
+
+[lib]
+path = "src/inline_completion.rs"
+
+[dependencies]
+gpui.workspace = true
+language.workspace = true
+project.workspace = true
+text.workspace = true

crates/inline_completion/LICENSE-GPL

@@ -0,0 +1 @@
+../../LICENSE-GPL

crates/inline_completion/src/inline_completion.rs

@@ -0,0 +1,146 @@
+use gpui::{AppContext, Model, ModelContext};
+use language::Buffer;
+use std::ops::Range;
+use text::{Anchor, Rope};
+
+// TODO: Find a better home for `Direction`.
+//
+// This should live in an ancestor crate of `editor` and `inline_completion`,
+// but at time of writing there isn't an obvious spot.
+#[derive(Copy, Clone, PartialEq, Eq)]
+pub enum Direction {
+    Prev,
+    Next,
+}
+
+pub enum InlayProposal {
+    Hint(Anchor, project::InlayHint),
+    Suggestion(Anchor, Rope),
+}
+
+pub struct CompletionProposal {
+    pub inlays: Vec<InlayProposal>,
+    pub text: Rope,
+    pub delete_range: Option<Range<Anchor>>,
+}
+
+pub trait InlineCompletionProvider: 'static + Sized {
+    fn name() -> &'static str;
+    fn is_enabled(
+        &self,
+        buffer: &Model<Buffer>,
+        cursor_position: language::Anchor,
+        cx: &AppContext,
+    ) -> bool;
+    fn refresh(
+        &mut self,
+        buffer: Model<Buffer>,
+        cursor_position: language::Anchor,
+        debounce: bool,
+        cx: &mut ModelContext<Self>,
+    );
+    fn cycle(
+        &mut self,
+        buffer: Model<Buffer>,
+        cursor_position: language::Anchor,
+        direction: Direction,
+        cx: &mut ModelContext<Self>,
+    );
+    fn accept(&mut self, cx: &mut ModelContext<Self>);
+    fn discard(&mut self, should_report_inline_completion_event: bool, cx: &mut ModelContext<Self>);
+    fn active_completion_text<'a>(
+        &'a self,
+        buffer: &Model<Buffer>,
+        cursor_position: language::Anchor,
+        cx: &'a AppContext,
+    ) -> Option<CompletionProposal>;
+}
+
+pub trait InlineCompletionProviderHandle {
+    fn is_enabled(
+        &self,
+        buffer: &Model<Buffer>,
+        cursor_position: language::Anchor,
+        cx: &AppContext,
+    ) -> bool;
+    fn refresh(
+        &self,
+        buffer: Model<Buffer>,
+        cursor_position: language::Anchor,
+        debounce: bool,
+        cx: &mut AppContext,
+    );
+    fn cycle(
+        &self,
+        buffer: Model<Buffer>,
+        cursor_position: language::Anchor,
+        direction: Direction,
+        cx: &mut AppContext,
+    );
+    fn accept(&self, cx: &mut AppContext);
+    fn discard(&self, should_report_inline_completion_event: bool, cx: &mut AppContext);
+    fn active_completion_text<'a>(
+        &'a self,
+        buffer: &Model<Buffer>,
+        cursor_position: language::Anchor,
+        cx: &'a AppContext,
+    ) -> Option<CompletionProposal>;
+}
+
+impl<T> InlineCompletionProviderHandle for Model<T>
+where
+    T: InlineCompletionProvider,
+{
+    fn is_enabled(
+        &self,
+        buffer: &Model<Buffer>,
+        cursor_position: language::Anchor,
+        cx: &AppContext,
+    ) -> bool {
+        self.read(cx).is_enabled(buffer, cursor_position, cx)
+    }
+
+    fn refresh(
+        &self,
+        buffer: Model<Buffer>,
+        cursor_position: language::Anchor,
+        debounce: bool,
+        cx: &mut AppContext,
+    ) {
+        self.update(cx, |this, cx| {
+            this.refresh(buffer, cursor_position, debounce, cx)
+        })
+    }
+
+    fn cycle(
+        &self,
+        buffer: Model<Buffer>,
+        cursor_position: language::Anchor,
+        direction: Direction,
+        cx: &mut AppContext,
+    ) {
+        self.update(cx, |this, cx| {
+            this.cycle(buffer, cursor_position, direction, cx)
+        })
+    }
+
+    fn accept(&self, cx: &mut AppContext) {
+        self.update(cx, |this, cx| this.accept(cx))
+    }
+
+    fn discard(&self, should_report_inline_completion_event: bool, cx: &mut AppContext) {
+        self.update(cx, |this, cx| {
+            this.discard(should_report_inline_completion_event, cx)
+        })
+    }
+
+    fn active_completion_text<'a>(
+        &'a self,
+        buffer: &Model<Buffer>,
+        cursor_position: language::Anchor,
+        cx: &'a AppContext,
+    ) -> Option<CompletionProposal> {
+        self.read(cx)
+            .active_completion_text(buffer, cursor_position, cx)
+    }
+}