editor: Add on-demand completion commands (#3411)

## Description

Editor completions previously opened only as a side effect of typing.
Applications could not request suggestions from a command, menu, or
their own shortcut without editing text.

Add the Editor-only `ShowCompletions` action and `show_completions` API.
There is no default shortcut: hosts choose bindings that fit their
platform and avoid input-method shortcuts such as Ctrl+Space. Hosts can
scope bindings to `Input && mode == editor`; existing `Input` bindings
remain valid.

```rust
window.dispatch_action(Box::new(ShowCompletions), cx);
editor.update(cx, |state, cx| state.show_completions(window, cx));
```

The action addresses the focused Editor; the method focuses the
specified Editor. Suggestions refine against the identifier prefix
before the caret, and an empty prefix still requests suggestions. Prefix
scanning walks backward through the rope instead of copying the whole
preceding document. Manual requests use LSP `INVOKED` with no trigger
character.

Disabled/readonly editors, missing providers, and IME preedit issue no
request. An already-open completion menu keeps its selected item. A new
request cancels the previous overlay request and inline suggestion,
closes code actions, and uses the existing completion lifecycle.
Responses are checked against the current document revision, caret,
focus, editability, and composition state before being applied.

English and Chinese Editor documentation describe the command, API,
host-owned shortcuts, and lifecycle rules.

## Public API

### gpui-base

- `input::ShowCompletions` — Editor action requesting suggestions
without typing; no default keybinding.
- `InputBaseState<EditorMode>::show_completions(&mut self, window: &mut
Window, cx: &mut Context<Self>)` — Request manual completions and focus
the Editor, respecting editability, IME, and an existing completion
menu.

### gpui-component

- `input::ShowCompletions` — Re-export the Base action for applications
using `gpui_kit::component::input`.

## Breaking Changes

None for existing consumers. The public API is additive and existing
`Input` bindings remain supported.

## Validation

- `cargo test -p gpui-kit --features 'test-support component' --test
input` — 179 passed. Covers explicit and empty-prefix requests,
host-configured Editor-only shortcuts, no Ctrl+Space default, menu
selection preservation, IME preedit/commit,
readonly/disabled/missing-provider guards, request replacement,
Escape/caret cancellation, inline suggestion/debounce cancellation,
code-action replacement, and API focus from an application command.
- `cargo clippy -p gpui-base -p gpui-kit --features
'gpui-kit/test-support gpui-kit/component' --all-targets -- --deny
warnings` — passed.
- `cargo fmt --all --check` and `git diff --check` — passed.

The implementation, tests, and documentation revision were generated
with AI assistance. IME coverage uses GPUI's simulated input-handler
protocol; it does not drive native candidate windows or verify OS
shortcut interception.

---------

Co-authored-by: Sola <sola-ryu@users.noreply.github.com>
Co-authored-by: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Co-authored-by: Jason Lee <huacnlee@gmail.com>

Author: 3 people

crates/base/src/input/base/state.rs

@@ -116,6 +116,7 @@ actions!(
         MoveToNextWord,
         Escape,
         ToggleCodeActions,
+        ShowCompletions,
         Search,
         Replace,
         GoToDefinition,

crates/base/src/input/editor/lsp/completions.rs

@@ -9,7 +9,7 @@ use lsp_types::{
 use ropey::Rope;
 use std::{cell::RefCell, ops::Range, rc::Rc, time::Duration};
 
-use crate::input::InputBaseState;
+use crate::input::{InputBaseState, ShowCompletions};
 
 /// Default debounce duration for inline completions.
 const DEFAULT_INLINE_COMPLETION_DEBOUNCE: Duration = Duration::from_millis(300);
@@ -183,6 +183,93 @@ impl InputBaseState<EditorMode> {
             )
             .map(|s| s.trim().to_string())
             .unwrap_or_default();
+        self.request_completions(
+            provider,
+            start_offset,
+            query.clone(),
+            CompletionContext {
+                trigger_kind: lsp_types::CompletionTriggerKind::TRIGGER_CHARACTER,
+                trigger_character: Some(query),
+            },
+            window,
+            cx,
+        );
+    }
+
+    pub(crate) fn on_action_show_completions(
+        &mut self,
+        _: &ShowCompletions,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        self.show_completions(window, cx);
+    }
+
+    /// Request completions at the caret and focus the editor, without editing text.
+    ///
+    /// The current identifier prefix is used to refine the menu. An empty
+    /// prefix still asks the provider for suggestions. There is no default
+    /// keybinding; applications can dispatch [`ShowCompletions`] in the
+    /// `Input && mode == editor` context or call this method from a command.
+    ///
+    /// Disabled/readonly editors, IME preedit, and an already-open completion
+    /// menu are left alone. A new request cancels the previous overlay request
+    /// and inline suggestion, and closes the code-action menu.
+    pub fn show_completions(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        if self.disabled
+            || self.readonly
+            || self.completion_inserting
+            || self.ime_marked_range.is_some()
+            || self.extras.context_menu_content.completion.open
+        {
+            return;
+        }
+        let Some(provider) = self.extras.lsp.completion_provider.clone() else {
+            return;
+        };
+
+        let offset = self.cursor();
+        let word_len: usize = self
+            .text
+            .chars_at(offset)
+            .reversed()
+            .take_while(|ch| ch.is_alphanumeric() || *ch == '_')
+            .map(char::len_utf8)
+            .sum();
+        let start_offset = offset - word_len;
+        let query = self.text.slice(start_offset..offset).to_string();
+
+        self.hide_context_menu(cx);
+        self.clear_inline_completion(cx);
+        self.focus(window, cx);
+
+        self.request_completions(
+            provider,
+            start_offset,
+            query,
+            CompletionContext {
+                trigger_kind: lsp_types::CompletionTriggerKind::INVOKED,
+                trigger_character: None,
+            },
+            window,
+            cx,
+        );
+    }
+
+    /// Record the word a menu is for and ask `provider` about the caret.
+    fn request_completions(
+        &mut self,
+        provider: Rc<dyn CompletionProvider>,
+        start_offset: usize,
+        query: String,
+        completion_context: CompletionContext,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        let new_offset = self.cursor();
+        let revision = self.document_revision;
+        self.extras.context_menu_task = Task::ready(Ok(()));
+        self.extras.context_menu_content.code_action.open = false;
         self.extras
             .context_menu_content
             .completion
@@ -193,11 +280,6 @@ impl InputBaseState<EditorMode> {
             .query
             .clone_from(&query);
 
-        let completion_context = CompletionContext {
-            trigger_kind: lsp_types::CompletionTriggerKind::TRIGGER_CHARACTER,
-            trigger_character: Some(query),
-        };
-
         let provider_responses =
             provider.completions(&self.text, new_offset, completion_context, window, cx);
         self.extras.context_menu_task = cx.spawn_in(window, async move |editor, cx| {
@@ -209,31 +291,21 @@ impl InputBaseState<EditorMode> {
                 }
             }
 
-            if completions.is_empty() {
-                editor.update(cx, |editor, cx| {
-                    editor.extras.context_menu_content.completion.open = false;
-                    editor.extras.context_menu_content.completion.items.clear();
-                    editor.extras.context_menu_content.completion.bump();
-                    cx.notify();
-                })?;
-                return Ok(());
-            }
-
             editor
                 .update_in(cx, |editor, window, cx| {
-                    if !editor.focus_handle.is_focused(window) {
+                    if !editor.focus_handle.is_focused(window)
+                        || editor.document_revision != revision
+                        || editor.cursor() != new_offset
+                        || editor.ime_marked_range.is_some()
+                        || editor.disabled
+                        || editor.readonly
+                    {
                         return;
                     }
 
+                    editor.extras.context_menu_content.completion.open = !completions.is_empty();
                     editor.extras.context_menu_content.completion.items = completions;
-                    editor.extras.context_menu_content.completion.open = !editor
-                        .extras
-                        .context_menu_content
-                        .completion
-                        .items
-                        .is_empty();
                     editor.extras.context_menu_content.completion.bump();
-
                     cx.notify();
                 })
                 .ok();

crates/base/src/input/editor/mod.rs

@@ -186,7 +186,9 @@ impl InputModeKind for EditorMode {
         window: &mut Window,
     ) -> Stateful<Div> {
         element
+            .key_context("Input mode=editor")
             .on_action(window.listener_for(entity, InputBaseState::on_action_toggle_code_actions))
+            .on_action(window.listener_for(entity, InputBaseState::on_action_show_completions))
             .on_action(window.listener_for(entity, InputBaseState::on_action_go_to_definition))
     }
 }

crates/component/src/input/mod.rs

@@ -34,8 +34,8 @@ pub use gpui_base::input::{
     MoveUp, Outdent, OutdentInline, Paste, Point, RangeDecoration, RangeDecorationCollection,
     RangeDecorationStyle, Redo, Replace, Rope, RopeExt, RopeLines, Search, SelectAll, SelectToEnd,
     SelectToEndOfLine, SelectToNextWordEnd, SelectToPreviousWordStart, SelectToStart,
-    SelectToStartOfLine, Selection, ShowCharacterPalette, ShowDocumentHandler, TabSize,
-    TextDecoration, TextDecorationCollection, TextareaState, ToggleCodeActions, Undo,
+    SelectToStartOfLine, Selection, ShowCharacterPalette, ShowCompletions, ShowDocumentHandler,
+    TabSize, TextDecoration, TextDecorationCollection, TextareaState, ToggleCodeActions, Undo,
     WrappingIndent,
 };
 pub use gpui_base::input::{EditorMode, InputMode, InputModeKind, TextareaMode};