mirror of https://github.com/helix-editor/helix
refactor completion and signature help using hooks
Pascal Kuthe
1 year ago
parent
15f88ad7bf
commit
dbfa2a63fa
@ -1,15 +1,40 @@
|
|||||||
use std::sync::Arc;
|
use std::sync::Arc;
|
||||||
|
|
||||||
use arc_swap::ArcSwap;
|
use arc_swap::ArcSwap;
|
||||||
|
use helix_core::RopeSlice;
|
||||||
|
use helix_event::AsyncHook;
|
||||||
|
|
||||||
use crate::config::Config;
|
use crate::config::Config;
|
||||||
use crate::events;
|
use crate::events;
|
||||||
|
use crate::handlers::completion::CompletionHandler;
|
||||||
|
use crate::handlers::signature_help::SignatureHelpHandler;
|
||||||
|
|
||||||
|
pub use completion::trigger_auto_completion;
|
||||||
|
pub use helix_view::handlers::lsp::SignatureHelpInvoked;
|
||||||
|
pub use helix_view::handlers::Handlers;
|
||||||
|
|
||||||
|
fn rope_ends_with(text: &str, rope: RopeSlice<'_>) -> bool {
|
||||||
|
let len = rope.len_bytes();
|
||||||
|
if len < text.len() {
|
||||||
|
return false;
|
||||||
}
|
}
|
||||||
|
rope.get_byte_slice(len - text.len()..)
|
||||||
|
.map_or(false, |end| end == text)
|
||||||
|
}
|
||||||
|
|
||||||
|
mod completion;
|
||||||
|
mod signature_help;
|
||||||
|
|
||||||
pub fn setup(config: Arc<ArcSwap<Config>>) -> Handlers {
|
pub fn setup(config: Arc<ArcSwap<Config>>) -> Handlers {
|
||||||
events::register();
|
events::register();
|
||||||
|
|
||||||
|
let completions = CompletionHandler::new(config).spawn();
|
||||||
|
let signature_hints = SignatureHelpHandler::new().spawn();
|
||||||
let handlers = Handlers {
|
let handlers = Handlers {
|
||||||
|
completions,
|
||||||
|
signature_hints,
|
||||||
};
|
};
|
||||||
|
completion::register_hooks(&handlers);
|
||||||
|
signature_help::register_hooks(&handlers);
|
||||||
handlers
|
handlers
|
||||||
}
|
}
|
||||||
|
|||||||
@ -0,0 +1,465 @@
|
|||||||
|
use std::collections::HashSet;
|
||||||
|
use std::sync::Arc;
|
||||||
|
use std::time::Duration;
|
||||||
|
|
||||||
|
use arc_swap::ArcSwap;
|
||||||
|
use futures_util::stream::FuturesUnordered;
|
||||||
|
use helix_core::chars::char_is_word;
|
||||||
|
use helix_core::syntax::LanguageServerFeature;
|
||||||
|
use helix_event::{
|
||||||
|
cancelable_future, cancelation, register_hook, send_blocking, CancelRx, CancelTx,
|
||||||
|
};
|
||||||
|
use helix_lsp::lsp;
|
||||||
|
use helix_lsp::util::pos_to_lsp_pos;
|
||||||
|
use helix_view::document::{Mode, SavePoint};
|
||||||
|
use helix_view::handlers::lsp::CompletionEvent;
|
||||||
|
use helix_view::{DocumentId, Editor, ViewId};
|
||||||
|
use tokio::sync::mpsc::Sender;
|
||||||
|
use tokio::time::Instant;
|
||||||
|
use tokio_stream::StreamExt;
|
||||||
|
|
||||||
|
use crate::commands;
|
||||||
|
use crate::compositor::Compositor;
|
||||||
|
use crate::config::Config;
|
||||||
|
use crate::events::{OnModeSwitch, PostCommand, PostInsertChar};
|
||||||
|
use crate::handlers::rope_ends_with;
|
||||||
|
use crate::job::{dispatch, dispatch_blocking};
|
||||||
|
use crate::keymap::MappableCommand;
|
||||||
|
use crate::ui::editor::InsertEvent;
|
||||||
|
use crate::ui::lsp::SignatureHelp;
|
||||||
|
use crate::ui::{self, CompletionItem, Popup};
|
||||||
|
|
||||||
|
use super::Handlers;
|
||||||
|
|
||||||
|
#[derive(Debug, PartialEq, Eq, Clone, Copy)]
|
||||||
|
enum TriggerKind {
|
||||||
|
Auto,
|
||||||
|
TriggerChar,
|
||||||
|
Manual,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug, Clone, Copy)]
|
||||||
|
struct Trigger {
|
||||||
|
pos: usize,
|
||||||
|
view: ViewId,
|
||||||
|
doc: DocumentId,
|
||||||
|
kind: TriggerKind,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug)]
|
||||||
|
pub(super) struct CompletionHandler {
|
||||||
|
/// currently active trigger which will cause a
|
||||||
|
/// completion request after the timeout
|
||||||
|
trigger: Option<Trigger>,
|
||||||
|
/// A handle for currently active completion request.
|
||||||
|
/// This can be used to determine whether the current
|
||||||
|
/// request is still active (and new triggers should be
|
||||||
|
/// ignored) and can also be used to abort the current
|
||||||
|
/// request (by dropping the handle)
|
||||||
|
request: Option<CancelTx>,
|
||||||
|
config: Arc<ArcSwap<Config>>,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl CompletionHandler {
|
||||||
|
pub fn new(config: Arc<ArcSwap<Config>>) -> CompletionHandler {
|
||||||
|
Self {
|
||||||
|
config,
|
||||||
|
request: None,
|
||||||
|
trigger: None,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl helix_event::AsyncHook for CompletionHandler {
|
||||||
|
type Event = CompletionEvent;
|
||||||
|
|
||||||
|
fn handle_event(
|
||||||
|
&mut self,
|
||||||
|
event: Self::Event,
|
||||||
|
_old_timeout: Option<Instant>,
|
||||||
|
) -> Option<Instant> {
|
||||||
|
match event {
|
||||||
|
CompletionEvent::AutoTrigger {
|
||||||
|
cursor: trigger_pos,
|
||||||
|
doc,
|
||||||
|
view,
|
||||||
|
} => {
|
||||||
|
// techically it shouldn't be possible to switch views/documents in insert mode
|
||||||
|
// but peoble may create weird keymaps/use the mouse so lets be extra careful
|
||||||
|
if self
|
||||||
|
.trigger
|
||||||
|
.as_ref()
|
||||||
|
.map_or(true, |trigger| trigger.doc != doc || trigger.view != view)
|
||||||
|
{
|
||||||
|
self.trigger = Some(Trigger {
|
||||||
|
pos: trigger_pos,
|
||||||
|
view,
|
||||||
|
doc,
|
||||||
|
kind: TriggerKind::Auto,
|
||||||
|
});
|
||||||
|
}
|
||||||
|
}
|
||||||
|
CompletionEvent::TriggerChar { cursor, doc, view } => {
|
||||||
|
// immediately request completions and drop all auto completion requests
|
||||||
|
self.request = None;
|
||||||
|
self.trigger = Some(Trigger {
|
||||||
|
pos: cursor,
|
||||||
|
view,
|
||||||
|
doc,
|
||||||
|
kind: TriggerKind::TriggerChar,
|
||||||
|
});
|
||||||
|
// stop debouncing immidietly and request the completion
|
||||||
|
self.finish_debounce();
|
||||||
|
return None;
|
||||||
|
}
|
||||||
|
CompletionEvent::ManualTrigger { cursor, doc, view } => {
|
||||||
|
// immediately request completions and drop all auto completion requests
|
||||||
|
self.request = None;
|
||||||
|
self.trigger = Some(Trigger {
|
||||||
|
pos: cursor,
|
||||||
|
view,
|
||||||
|
doc,
|
||||||
|
kind: TriggerKind::Manual,
|
||||||
|
});
|
||||||
|
// stop debouncing immidietly and request the completion
|
||||||
|
self.finish_debounce();
|
||||||
|
return None;
|
||||||
|
}
|
||||||
|
CompletionEvent::Cancel => {
|
||||||
|
self.trigger = None;
|
||||||
|
self.request = None;
|
||||||
|
}
|
||||||
|
CompletionEvent::DeleteText { cursor } => {
|
||||||
|
// if we deleted the original trigger, abort the completion
|
||||||
|
if matches!(self.trigger, Some(Trigger{ pos, .. }) if cursor < pos) {
|
||||||
|
self.trigger = None;
|
||||||
|
self.request = None;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
self.trigger.map(|trigger| {
|
||||||
|
// if the current request was closed forget about it
|
||||||
|
// otherwise immediately restart the completion request
|
||||||
|
let canceled = self.request.take().map_or(false, |req| !req.is_closed());
|
||||||
|
let timeout = if trigger.kind == TriggerKind::Auto && !canceled {
|
||||||
|
self.config.load().editor.completion_timeout
|
||||||
|
} else {
|
||||||
|
// we want almost instant completions for trigger chars
|
||||||
|
// and restarting completion requests. The small timeout here mainly
|
||||||
|
// serves to better handle cases where the completion handler
|
||||||
|
// may fall behind (so multiple events in the channel) and macros
|
||||||
|
Duration::from_millis(5)
|
||||||
|
};
|
||||||
|
Instant::now() + timeout
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
fn finish_debounce(&mut self) {
|
||||||
|
let trigger = self.trigger.take().expect("debounce always has a trigger");
|
||||||
|
let (tx, rx) = cancelation();
|
||||||
|
self.request = Some(tx);
|
||||||
|
dispatch_blocking(move |editor, compositor| {
|
||||||
|
request_completion(trigger, rx, editor, compositor)
|
||||||
|
});
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn request_completion(
|
||||||
|
mut trigger: Trigger,
|
||||||
|
cancel: CancelRx,
|
||||||
|
editor: &mut Editor,
|
||||||
|
compositor: &mut Compositor,
|
||||||
|
) {
|
||||||
|
let (view, doc) = current!(editor);
|
||||||
|
|
||||||
|
if compositor
|
||||||
|
.find::<ui::EditorView>()
|
||||||
|
.unwrap()
|
||||||
|
.completion
|
||||||
|
.is_some()
|
||||||
|
|| editor.mode != Mode::Insert
|
||||||
|
{
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
let text = doc.text();
|
||||||
|
let cursor = doc.selection(view.id).primary().cursor(text.slice(..));
|
||||||
|
if trigger.view != view.id || trigger.doc != doc.id() || cursor < trigger.pos {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
// this looks odd... Why are we not using the trigger position from
|
||||||
|
// the `trigger` here? Won't that mean that the trigger char doesn't get
|
||||||
|
// send to the LS if we type fast enougn? Yes that is true but it's
|
||||||
|
// not actually a problem. The LSP will resolve the completion to the identifier
|
||||||
|
// anyway (in fact sending the later position is necessary to get the right results
|
||||||
|
// from LSPs that provide incomplete completion list). We rely on trigger offset
|
||||||
|
// and primary cursor matching for multi-cursor completions so this is definitely
|
||||||
|
// necessary from our side too.
|
||||||
|
trigger.pos = cursor;
|
||||||
|
let trigger_text = text.slice(..cursor);
|
||||||
|
|
||||||
|
let mut seen_language_servers = HashSet::new();
|
||||||
|
let mut futures: FuturesUnordered<_> = doc
|
||||||
|
.language_servers_with_feature(LanguageServerFeature::Completion)
|
||||||
|
.filter(|ls| seen_language_servers.insert(ls.id()))
|
||||||
|
.map(|ls| {
|
||||||
|
let language_server_id = ls.id();
|
||||||
|
let offset_encoding = ls.offset_encoding();
|
||||||
|
let pos = pos_to_lsp_pos(text, cursor, offset_encoding);
|
||||||
|
let doc_id = doc.identifier();
|
||||||
|
let context = if trigger.kind == TriggerKind::Manual {
|
||||||
|
lsp::CompletionContext {
|
||||||
|
trigger_kind: lsp::CompletionTriggerKind::INVOKED,
|
||||||
|
trigger_character: None,
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
let trigger_char =
|
||||||
|
ls.capabilities()
|
||||||
|
.completion_provider
|
||||||
|
.as_ref()
|
||||||
|
.and_then(|provider| {
|
||||||
|
provider
|
||||||
|
.trigger_characters
|
||||||
|
.as_deref()?
|
||||||
|
.iter()
|
||||||
|
.find(|&trigger| rope_ends_with(trigger, trigger_text))
|
||||||
|
});
|
||||||
|
lsp::CompletionContext {
|
||||||
|
trigger_kind: lsp::CompletionTriggerKind::TRIGGER_CHARACTER,
|
||||||
|
trigger_character: trigger_char.cloned(),
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
let completion_response = ls.completion(doc_id, pos, None, context).unwrap();
|
||||||
|
async move {
|
||||||
|
let json = completion_response.await?;
|
||||||
|
let response: Option<lsp::CompletionResponse> = serde_json::from_value(json)?;
|
||||||
|
let items = match response {
|
||||||
|
Some(lsp::CompletionResponse::Array(items)) => items,
|
||||||
|
// TODO: do something with is_incomplete
|
||||||
|
Some(lsp::CompletionResponse::List(lsp::CompletionList {
|
||||||
|
is_incomplete: _is_incomplete,
|
||||||
|
items,
|
||||||
|
})) => items,
|
||||||
|
None => Vec::new(),
|
||||||
|
}
|
||||||
|
.into_iter()
|
||||||
|
.map(|item| CompletionItem {
|
||||||
|
item,
|
||||||
|
language_server_id,
|
||||||
|
resolved: false,
|
||||||
|
})
|
||||||
|
.collect();
|
||||||
|
anyhow::Ok(items)
|
||||||
|
}
|
||||||
|
})
|
||||||
|
.collect();
|
||||||
|
|
||||||
|
let future = async move {
|
||||||
|
let mut items = Vec::new();
|
||||||
|
while let Some(lsp_items) = futures.next().await {
|
||||||
|
match lsp_items {
|
||||||
|
Ok(mut lsp_items) => items.append(&mut lsp_items),
|
||||||
|
Err(err) => {
|
||||||
|
log::debug!("completion request failed: {err:?}");
|
||||||
|
}
|
||||||
|
};
|
||||||
|
}
|
||||||
|
items
|
||||||
|
};
|
||||||
|
|
||||||
|
let savepoint = doc.savepoint(view);
|
||||||
|
|
||||||
|
let ui = compositor.find::<ui::EditorView>().unwrap();
|
||||||
|
ui.last_insert.1.push(InsertEvent::RequestCompletion);
|
||||||
|
tokio::spawn(async move {
|
||||||
|
let items = cancelable_future(future, cancel).await.unwrap_or_default();
|
||||||
|
if items.is_empty() {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
dispatch(move |editor, compositor| {
|
||||||
|
show_completion(editor, compositor, items, trigger, savepoint)
|
||||||
|
})
|
||||||
|
.await
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
fn show_completion(
|
||||||
|
editor: &mut Editor,
|
||||||
|
compositor: &mut Compositor,
|
||||||
|
items: Vec<CompletionItem>,
|
||||||
|
trigger: Trigger,
|
||||||
|
savepoint: Arc<SavePoint>,
|
||||||
|
) {
|
||||||
|
let (view, doc) = current_ref!(editor);
|
||||||
|
// check if the completion request is stale.
|
||||||
|
//
|
||||||
|
// Completions are completed asynchronously and therefore the user could
|
||||||
|
//switch document/view or leave insert mode. In all of thoise cases the
|
||||||
|
// completion should be discarded
|
||||||
|
if editor.mode != Mode::Insert || view.id != trigger.view || doc.id() != trigger.doc {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
let size = compositor.size();
|
||||||
|
let ui = compositor.find::<ui::EditorView>().unwrap();
|
||||||
|
if ui.completion.is_some() {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
let completion_area = ui.set_completion(editor, savepoint, items, trigger.pos, size);
|
||||||
|
let signature_help_area = compositor
|
||||||
|
.find_id::<Popup<SignatureHelp>>(SignatureHelp::ID)
|
||||||
|
.map(|signature_help| signature_help.area(size, editor));
|
||||||
|
// Delete the signature help popup if they intersect.
|
||||||
|
if matches!((completion_area, signature_help_area),(Some(a), Some(b)) if a.intersects(b)) {
|
||||||
|
compositor.remove(SignatureHelp::ID);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn trigger_auto_completion(
|
||||||
|
tx: &Sender<CompletionEvent>,
|
||||||
|
editor: &Editor,
|
||||||
|
trigger_char_only: bool,
|
||||||
|
) {
|
||||||
|
let config = editor.config.load();
|
||||||
|
if config.auto_completion {
|
||||||
|
let (view, doc): (&helix_view::View, &helix_view::Document) = current_ref!(editor);
|
||||||
|
let mut text = doc.text().slice(..);
|
||||||
|
let cursor = doc.selection(view.id).primary().cursor(text);
|
||||||
|
text = doc.text().slice(..cursor);
|
||||||
|
|
||||||
|
let is_trigger_char = doc
|
||||||
|
.language_servers_with_feature(LanguageServerFeature::Completion)
|
||||||
|
.any(|ls| {
|
||||||
|
matches!(&ls.capabilities().completion_provider, Some(lsp::CompletionOptions {
|
||||||
|
trigger_characters: Some(triggers),
|
||||||
|
..
|
||||||
|
}) if triggers.iter().any(|trigger| rope_ends_with(trigger, text)))
|
||||||
|
});
|
||||||
|
if is_trigger_char {
|
||||||
|
send_blocking(
|
||||||
|
tx,
|
||||||
|
CompletionEvent::TriggerChar {
|
||||||
|
cursor,
|
||||||
|
doc: doc.id(),
|
||||||
|
view: view.id,
|
||||||
|
},
|
||||||
|
);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
let is_auto_trigger = !trigger_char_only
|
||||||
|
&& doc
|
||||||
|
.text()
|
||||||
|
.chars_at(cursor)
|
||||||
|
.reversed()
|
||||||
|
.take(config.completion_trigger_len as usize)
|
||||||
|
.all(char_is_word);
|
||||||
|
|
||||||
|
if is_auto_trigger {
|
||||||
|
send_blocking(
|
||||||
|
tx,
|
||||||
|
CompletionEvent::AutoTrigger {
|
||||||
|
cursor,
|
||||||
|
doc: doc.id(),
|
||||||
|
view: view.id,
|
||||||
|
},
|
||||||
|
);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn update_completions(cx: &mut commands::Context, c: Option<char>) {
|
||||||
|
cx.callback.push(Box::new(move |compositor, cx| {
|
||||||
|
let editor_view = compositor.find::<ui::EditorView>().unwrap();
|
||||||
|
if let Some(completion) = &mut editor_view.completion {
|
||||||
|
completion.update_filter(c);
|
||||||
|
if completion.is_empty() {
|
||||||
|
editor_view.clear_completion(cx.editor);
|
||||||
|
// clearing completions might mean we want to immediately rerequest them (usually
|
||||||
|
// this occurs if typing a trigger char)
|
||||||
|
if c.is_some() {
|
||||||
|
trigger_auto_completion(&cx.editor.handlers.completions, cx.editor, false);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}))
|
||||||
|
}
|
||||||
|
|
||||||
|
fn clear_completions(cx: &mut commands::Context) {
|
||||||
|
cx.callback.push(Box::new(|compositor, cx| {
|
||||||
|
let editor_view = compositor.find::<ui::EditorView>().unwrap();
|
||||||
|
editor_view.clear_completion(cx.editor);
|
||||||
|
}))
|
||||||
|
}
|
||||||
|
|
||||||
|
fn completion_post_command_hook(
|
||||||
|
tx: &Sender<CompletionEvent>,
|
||||||
|
PostCommand { command, cx }: &mut PostCommand<'_, '_>,
|
||||||
|
) -> anyhow::Result<()> {
|
||||||
|
if cx.editor.mode == Mode::Insert {
|
||||||
|
if cx.editor.last_completion.is_some() {
|
||||||
|
match command {
|
||||||
|
MappableCommand::Static {
|
||||||
|
name: "delete_word_forward" | "delete_char_forward" | "completion",
|
||||||
|
..
|
||||||
|
} => (),
|
||||||
|
MappableCommand::Static {
|
||||||
|
name: "delete_char_backward",
|
||||||
|
..
|
||||||
|
} => update_completions(cx, None),
|
||||||
|
_ => clear_completions(cx),
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
let event = match command {
|
||||||
|
MappableCommand::Static {
|
||||||
|
name: "delete_char_backward" | "delete_word_forward" | "delete_char_forward",
|
||||||
|
..
|
||||||
|
} => {
|
||||||
|
let (view, doc) = current!(cx.editor);
|
||||||
|
let primary_cursor = doc
|
||||||
|
.selection(view.id)
|
||||||
|
.primary()
|
||||||
|
.cursor(doc.text().slice(..));
|
||||||
|
CompletionEvent::DeleteText {
|
||||||
|
cursor: primary_cursor,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
// if we cancel completions here it would always cancel the manual request
|
||||||
|
MappableCommand::Static {
|
||||||
|
name: "completion", ..
|
||||||
|
} => return Ok(()),
|
||||||
|
_ => CompletionEvent::Cancel,
|
||||||
|
};
|
||||||
|
send_blocking(tx, event);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
pub(super) fn register_hooks(handlers: &Handlers) {
|
||||||
|
let tx = handlers.completions.clone();
|
||||||
|
register_hook!(move |event: &mut PostCommand<'_, '_>| completion_post_command_hook(&tx, event));
|
||||||
|
|
||||||
|
let tx = handlers.completions.clone();
|
||||||
|
register_hook!(move |event: &mut OnModeSwitch<'_, '_>| {
|
||||||
|
if event.old_mode == Mode::Insert {
|
||||||
|
send_blocking(&tx, CompletionEvent::Cancel);
|
||||||
|
clear_completions(event.cx);
|
||||||
|
} else if event.new_mode == Mode::Insert {
|
||||||
|
trigger_auto_completion(&tx, event.cx.editor, false)
|
||||||
|
}
|
||||||
|
Ok(())
|
||||||
|
});
|
||||||
|
|
||||||
|
let tx = handlers.completions.clone();
|
||||||
|
register_hook!(move |event: &mut PostInsertChar<'_, '_>| {
|
||||||
|
if event.cx.editor.last_completion.is_some() {
|
||||||
|
update_completions(event.cx, Some(event.c))
|
||||||
|
} else {
|
||||||
|
trigger_auto_completion(&tx, event.cx.editor, false);
|
||||||
|
}
|
||||||
|
Ok(())
|
||||||
|
});
|
||||||
|
}
|
||||||
@ -0,0 +1,334 @@
|
|||||||
|
use std::sync::Arc;
|
||||||
|
use std::time::Duration;
|
||||||
|
|
||||||
|
use helix_core::syntax::LanguageServerFeature;
|
||||||
|
use helix_event::{
|
||||||
|
cancelable_future, cancelation, register_hook, send_blocking, CancelRx, CancelTx,
|
||||||
|
};
|
||||||
|
use helix_lsp::lsp;
|
||||||
|
use helix_view::document::Mode;
|
||||||
|
use helix_view::events::{DocumentDidChange, SelectionDidChange};
|
||||||
|
use helix_view::handlers::lsp::{SignatureHelpEvent, SignatureHelpInvoked};
|
||||||
|
use helix_view::Editor;
|
||||||
|
use tokio::sync::mpsc::Sender;
|
||||||
|
use tokio::time::Instant;
|
||||||
|
|
||||||
|
use crate::commands::Open;
|
||||||
|
use crate::compositor::Compositor;
|
||||||
|
use crate::events::{OnModeSwitch, PostInsertChar};
|
||||||
|
use crate::handlers::{rope_ends_with, Handlers};
|
||||||
|
use crate::ui::lsp::SignatureHelp;
|
||||||
|
use crate::ui::Popup;
|
||||||
|
use crate::{job, ui};
|
||||||
|
|
||||||
|
#[derive(Debug)]
|
||||||
|
enum State {
|
||||||
|
Open,
|
||||||
|
Closed,
|
||||||
|
Pending { request: CancelTx },
|
||||||
|
}
|
||||||
|
|
||||||
|
/// debounce timeout in ms, value taken from VSCode
|
||||||
|
/// TODO: make this configurable?
|
||||||
|
const TIMEOUT: u64 = 120;
|
||||||
|
|
||||||
|
#[derive(Debug)]
|
||||||
|
pub(super) struct SignatureHelpHandler {
|
||||||
|
trigger: Option<SignatureHelpInvoked>,
|
||||||
|
state: State,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl SignatureHelpHandler {
|
||||||
|
pub fn new() -> SignatureHelpHandler {
|
||||||
|
SignatureHelpHandler {
|
||||||
|
trigger: None,
|
||||||
|
state: State::Closed,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl helix_event::AsyncHook for SignatureHelpHandler {
|
||||||
|
type Event = SignatureHelpEvent;
|
||||||
|
|
||||||
|
fn handle_event(
|
||||||
|
&mut self,
|
||||||
|
event: Self::Event,
|
||||||
|
timeout: Option<tokio::time::Instant>,
|
||||||
|
) -> Option<Instant> {
|
||||||
|
match event {
|
||||||
|
SignatureHelpEvent::Invoked => {
|
||||||
|
self.trigger = Some(SignatureHelpInvoked::Manual);
|
||||||
|
self.state = State::Closed;
|
||||||
|
self.finish_debounce();
|
||||||
|
return None;
|
||||||
|
}
|
||||||
|
SignatureHelpEvent::Trigger => {}
|
||||||
|
SignatureHelpEvent::ReTrigger => {
|
||||||
|
// don't retrigger if we aren't open/pending yet
|
||||||
|
if matches!(self.state, State::Closed) {
|
||||||
|
return timeout;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
SignatureHelpEvent::Cancel => {
|
||||||
|
self.state = State::Closed;
|
||||||
|
return None;
|
||||||
|
}
|
||||||
|
SignatureHelpEvent::RequestComplete { open } => {
|
||||||
|
// don't cancel rerequest that was already triggered
|
||||||
|
if let State::Pending { request } = &self.state {
|
||||||
|
if !request.is_closed() {
|
||||||
|
return timeout;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
self.state = if open { State::Open } else { State::Closed };
|
||||||
|
return timeout;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if self.trigger.is_none() {
|
||||||
|
self.trigger = Some(SignatureHelpInvoked::Automatic)
|
||||||
|
}
|
||||||
|
Some(Instant::now() + Duration::from_millis(TIMEOUT))
|
||||||
|
}
|
||||||
|
|
||||||
|
fn finish_debounce(&mut self) {
|
||||||
|
let invocation = self.trigger.take().unwrap();
|
||||||
|
let (tx, rx) = cancelation();
|
||||||
|
self.state = State::Pending { request: tx };
|
||||||
|
job::dispatch_blocking(move |editor, _| request_signature_help(editor, invocation, rx))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn request_signature_help(
|
||||||
|
editor: &mut Editor,
|
||||||
|
invoked: SignatureHelpInvoked,
|
||||||
|
cancel: CancelRx,
|
||||||
|
) {
|
||||||
|
let (view, doc) = current!(editor);
|
||||||
|
|
||||||
|
// TODO merge multiple language server signature help into one instead of just taking the first language server that supports it
|
||||||
|
let future = doc
|
||||||
|
.language_servers_with_feature(LanguageServerFeature::SignatureHelp)
|
||||||
|
.find_map(|language_server| {
|
||||||
|
let pos = doc.position(view.id, language_server.offset_encoding());
|
||||||
|
language_server.text_document_signature_help(doc.identifier(), pos, None)
|
||||||
|
});
|
||||||
|
|
||||||
|
let Some(future) = future else {
|
||||||
|
// Do not show the message if signature help was invoked
|
||||||
|
// automatically on backspace, trigger characters, etc.
|
||||||
|
if invoked == SignatureHelpInvoked::Manual {
|
||||||
|
editor
|
||||||
|
.set_error("No configured language server supports signature-help");
|
||||||
|
}
|
||||||
|
return;
|
||||||
|
};
|
||||||
|
|
||||||
|
tokio::spawn(async move {
|
||||||
|
match cancelable_future(future, cancel).await {
|
||||||
|
Some(Ok(res)) => {
|
||||||
|
job::dispatch(move |editor, compositor| {
|
||||||
|
show_signature_help(editor, compositor, invoked, res)
|
||||||
|
})
|
||||||
|
.await
|
||||||
|
}
|
||||||
|
Some(Err(err)) => log::error!("signature help request failed: {err}"),
|
||||||
|
None => (),
|
||||||
|
}
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn show_signature_help(
|
||||||
|
editor: &mut Editor,
|
||||||
|
compositor: &mut Compositor,
|
||||||
|
invoked: SignatureHelpInvoked,
|
||||||
|
response: Option<lsp::SignatureHelp>,
|
||||||
|
) {
|
||||||
|
let config = &editor.config();
|
||||||
|
|
||||||
|
if !(config.lsp.auto_signature_help
|
||||||
|
|| SignatureHelp::visible_popup(compositor).is_some()
|
||||||
|
|| invoked == SignatureHelpInvoked::Manual)
|
||||||
|
{
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
// If the signature help invocation is automatic, don't show it outside of Insert Mode:
|
||||||
|
// it very probably means the server was a little slow to respond and the user has
|
||||||
|
// already moved on to something else, making a signature help popup will just be an
|
||||||
|
// annoyance, see https://github.com/helix-editor/helix/issues/3112
|
||||||
|
// For the most part this should not be needed as the request gets canceled automatically now
|
||||||
|
// but its technically possible for the mode change to just preempt this callback so better safe than sorry
|
||||||
|
if invoked == SignatureHelpInvoked::Automatic && editor.mode != Mode::Insert {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
let response = match response {
|
||||||
|
// According to the spec the response should be None if there
|
||||||
|
// are no signatures, but some servers don't follow this.
|
||||||
|
Some(s) if !s.signatures.is_empty() => s,
|
||||||
|
_ => {
|
||||||
|
send_blocking(
|
||||||
|
&editor.handlers.signature_hints,
|
||||||
|
SignatureHelpEvent::RequestComplete { open: false },
|
||||||
|
);
|
||||||
|
compositor.remove(SignatureHelp::ID);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
send_blocking(
|
||||||
|
&editor.handlers.signature_hints,
|
||||||
|
SignatureHelpEvent::RequestComplete { open: true },
|
||||||
|
);
|
||||||
|
|
||||||
|
let doc = doc!(editor);
|
||||||
|
let language = doc.language_name().unwrap_or("");
|
||||||
|
|
||||||
|
let signature = match response
|
||||||
|
.signatures
|
||||||
|
.get(response.active_signature.unwrap_or(0) as usize)
|
||||||
|
{
|
||||||
|
Some(s) => s,
|
||||||
|
None => return,
|
||||||
|
};
|
||||||
|
let mut contents = SignatureHelp::new(
|
||||||
|
signature.label.clone(),
|
||||||
|
language.to_string(),
|
||||||
|
Arc::clone(&editor.syn_loader),
|
||||||
|
);
|
||||||
|
|
||||||
|
let signature_doc = if config.lsp.display_signature_help_docs {
|
||||||
|
signature.documentation.as_ref().map(|doc| match doc {
|
||||||
|
lsp::Documentation::String(s) => s.clone(),
|
||||||
|
lsp::Documentation::MarkupContent(markup) => markup.value.clone(),
|
||||||
|
})
|
||||||
|
} else {
|
||||||
|
None
|
||||||
|
};
|
||||||
|
|
||||||
|
contents.set_signature_doc(signature_doc);
|
||||||
|
|
||||||
|
let active_param_range = || -> Option<(usize, usize)> {
|
||||||
|
let param_idx = signature
|
||||||
|
.active_parameter
|
||||||
|
.or(response.active_parameter)
|
||||||
|
.unwrap_or(0) as usize;
|
||||||
|
let param = signature.parameters.as_ref()?.get(param_idx)?;
|
||||||
|
match ¶m.label {
|
||||||
|
lsp::ParameterLabel::Simple(string) => {
|
||||||
|
let start = signature.label.find(string.as_str())?;
|
||||||
|
Some((start, start + string.len()))
|
||||||
|
}
|
||||||
|
lsp::ParameterLabel::LabelOffsets([start, end]) => {
|
||||||
|
// LS sends offsets based on utf-16 based string representation
|
||||||
|
// but highlighting in helix is done using byte offset.
|
||||||
|
use helix_core::str_utils::char_to_byte_idx;
|
||||||
|
let from = char_to_byte_idx(&signature.label, *start as usize);
|
||||||
|
let to = char_to_byte_idx(&signature.label, *end as usize);
|
||||||
|
Some((from, to))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
};
|
||||||
|
contents.set_active_param_range(active_param_range());
|
||||||
|
|
||||||
|
let old_popup = compositor.find_id::<Popup<SignatureHelp>>(SignatureHelp::ID);
|
||||||
|
let mut popup = Popup::new(SignatureHelp::ID, contents)
|
||||||
|
.position(old_popup.and_then(|p| p.get_position()))
|
||||||
|
.position_bias(Open::Above)
|
||||||
|
.ignore_escape_key(true);
|
||||||
|
|
||||||
|
// Don't create a popup if it intersects the auto-complete menu.
|
||||||
|
let size = compositor.size();
|
||||||
|
if compositor
|
||||||
|
.find::<ui::EditorView>()
|
||||||
|
.unwrap()
|
||||||
|
.completion
|
||||||
|
.as_mut()
|
||||||
|
.map(|completion| completion.area(size, editor))
|
||||||
|
.filter(|area| area.intersects(popup.area(size, editor)))
|
||||||
|
.is_some()
|
||||||
|
{
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
compositor.replace_or_push(SignatureHelp::ID, popup);
|
||||||
|
}
|
||||||
|
|
||||||
|
fn signature_help_post_insert_char_hook(
|
||||||
|
tx: &Sender<SignatureHelpEvent>,
|
||||||
|
PostInsertChar { cx, .. }: &mut PostInsertChar<'_, '_>,
|
||||||
|
) -> anyhow::Result<()> {
|
||||||
|
if !cx.editor.config().lsp.auto_signature_help {
|
||||||
|
return Ok(());
|
||||||
|
}
|
||||||
|
let (view, doc) = current!(cx.editor);
|
||||||
|
// TODO support multiple language servers (not just the first that is found), likely by merging UI somehow
|
||||||
|
let Some(language_server) = doc
|
||||||
|
.language_servers_with_feature(LanguageServerFeature::SignatureHelp)
|
||||||
|
.next()
|
||||||
|
else {
|
||||||
|
return Ok(());
|
||||||
|
};
|
||||||
|
|
||||||
|
let capabilities = language_server.capabilities();
|
||||||
|
|
||||||
|
if let lsp::ServerCapabilities {
|
||||||
|
signature_help_provider:
|
||||||
|
Some(lsp::SignatureHelpOptions {
|
||||||
|
trigger_characters: Some(triggers),
|
||||||
|
// TODO: retrigger_characters
|
||||||
|
..
|
||||||
|
}),
|
||||||
|
..
|
||||||
|
} = capabilities
|
||||||
|
{
|
||||||
|
let mut text = doc.text().slice(..);
|
||||||
|
let cursor = doc.selection(view.id).primary().cursor(text);
|
||||||
|
text = text.slice(..cursor);
|
||||||
|
if triggers.iter().any(|trigger| rope_ends_with(trigger, text)) {
|
||||||
|
send_blocking(tx, SignatureHelpEvent::Trigger)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
pub(super) fn register_hooks(handlers: &Handlers) {
|
||||||
|
let tx = handlers.signature_hints.clone();
|
||||||
|
register_hook!(move |event: &mut OnModeSwitch<'_, '_>| {
|
||||||
|
match (event.old_mode, event.new_mode) {
|
||||||
|
(Mode::Insert, _) => {
|
||||||
|
send_blocking(&tx, SignatureHelpEvent::Cancel);
|
||||||
|
event.cx.callback.push(Box::new(|compositor, _| {
|
||||||
|
compositor.remove(SignatureHelp::ID);
|
||||||
|
}));
|
||||||
|
}
|
||||||
|
(_, Mode::Insert) => {
|
||||||
|
if event.cx.editor.config().lsp.auto_signature_help {
|
||||||
|
send_blocking(&tx, SignatureHelpEvent::Trigger);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
_ => (),
|
||||||
|
}
|
||||||
|
Ok(())
|
||||||
|
});
|
||||||
|
|
||||||
|
let tx = handlers.signature_hints.clone();
|
||||||
|
register_hook!(
|
||||||
|
move |event: &mut PostInsertChar<'_, '_>| signature_help_post_insert_char_hook(&tx, event)
|
||||||
|
);
|
||||||
|
|
||||||
|
let tx = handlers.signature_hints.clone();
|
||||||
|
register_hook!(move |event: &mut DocumentDidChange<'_>| {
|
||||||
|
if event.doc.config.load().lsp.auto_signature_help {
|
||||||
|
send_blocking(&tx, SignatureHelpEvent::ReTrigger);
|
||||||
|
}
|
||||||
|
Ok(())
|
||||||
|
});
|
||||||
|
|
||||||
|
let tx = handlers.signature_hints.clone();
|
||||||
|
register_hook!(move |event: &mut SelectionDidChange<'_>| {
|
||||||
|
if event.doc.config.load().lsp.auto_signature_help {
|
||||||
|
send_blocking(&tx, SignatureHelpEvent::ReTrigger);
|
||||||
|
}
|
||||||
|
Ok(())
|
||||||
|
});
|
||||||
|
}
|
||||||
@ -1,12 +1,41 @@
|
|||||||
use std::sync::Arc;
|
|
||||||
|
|
||||||
use helix_event::send_blocking;
|
use helix_event::send_blocking;
|
||||||
use tokio::sync::mpsc::Sender;
|
use tokio::sync::mpsc::Sender;
|
||||||
|
|
||||||
use crate::handlers::lsp::SignatureHelpInvoked;
|
use crate::handlers::lsp::SignatureHelpInvoked;
|
||||||
use crate::Editor;
|
use crate::{DocumentId, Editor, ViewId};
|
||||||
|
|
||||||
pub mod dap;
|
pub mod dap;
|
||||||
pub mod lsp;
|
pub mod lsp;
|
||||||
|
|
||||||
pub struct Handlers {}
|
pub struct Handlers {
|
||||||
|
// only public because most of the actual implementation is in helix-term right now :/
|
||||||
|
pub completions: Sender<lsp::CompletionEvent>,
|
||||||
|
pub signature_hints: Sender<lsp::SignatureHelpEvent>,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Handlers {
|
||||||
|
/// Manually trigger completion (c-x)
|
||||||
|
pub fn trigger_completions(&self, trigger_pos: usize, doc: DocumentId, view: ViewId) {
|
||||||
|
send_blocking(
|
||||||
|
&self.completions,
|
||||||
|
lsp::CompletionEvent::ManualTrigger {
|
||||||
|
cursor: trigger_pos,
|
||||||
|
doc,
|
||||||
|
view,
|
||||||
|
},
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn trigger_signature_help(&self, invocation: SignatureHelpInvoked, editor: &Editor) {
|
||||||
|
let event = match invocation {
|
||||||
|
SignatureHelpInvoked::Automatic => {
|
||||||
|
if !editor.config().lsp.auto_signature_help {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
lsp::SignatureHelpEvent::Trigger
|
||||||
|
}
|
||||||
|
SignatureHelpInvoked::Manual => lsp::SignatureHelpEvent::Invoked,
|
||||||
|
};
|
||||||
|
send_blocking(&self.signature_hints, event)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|||||||
Loading…
Reference in New Issue