8cb7cdf · helix · git.iko.soy

git.iko.soy/helix

discard stale completion requests

Completion requests are computed asynchronously to avoid common micro freezes while editing. This means that once a completion request completes, the state of the editor might have changed. Currently, there is a check to ensure we are still in insert mode. However, we also need to ensure that the view and document hasn't changed to avoid accidentally using a savepoint with the wrong view/document. Furthermore, the editor might request a new completion while the previous completion request hasn't complemented yet. This can lead to weird flickering or an outdated completion request replacing a newer completion that has already completed (the LSP server is not required to process completion requests in order). This change also needed to ensure determinism/linear ordering so that completion popup always correspond to the last completion request.

commit8cb7cdfd7a01b9cb50b9142e9a5d133bd1e23256 authorPascal Kuthe <pascal.kuthe@semimod.de> dateThu 2 Mar 2023, 23:12 (4 years ago) parente8898fd

3 files changed+40−3

compare with master

unifiedsplit

helix-term/src/commands.rs+29−2 helix-term/src/ui/editor.rs+1 helix-view/src/editor.rs+10−1

helix-term/src/commands.rs+29−2

@@ -5,6 +5,7 @@ pub(crate) mod typed;

55pub use dap::*;

66use helix_vcs::Hunk;

77pub use lsp::*;

8+use tokio::sync::oneshot;

89use tui::widgets::Row;

910pub use typed::*;

1011

@@ -4171,6 +4172,24 @@ pub fn completion(cx: &mut Context) {

41714172 None => return,

41724173 };

41734174

4175+ // setup a chanel that allows the request to be canceled

4176+ let (tx, rx) = oneshot::channel();

4177+ // set completion_request so that this request can be canceled

4178+ // by setting completion_request, the old channel stored there is dropped

4179+ // and the associated request is automatically dropped

4180+ cx.editor.completion_request_handle = Some(tx);

4181+ let future = async move {

4182+ tokio::select! {

4183+ biased;

4184+ _ = rx => {

4185+ Ok(serde_json::Value::Null)

4186+ }

4187+ res = future => {

4188+ res

4189+ }

4190+ }

4191+ };

4192+

41744193 let trigger_offset = cursor;

41754194

41764195 // TODO: trigger_offset should be the cursor offset but we also need a starting offset from where we want to apply

@@ -4183,11 +4202,19 @@ pub fn completion(cx: &mut Context) {

41834202 let start_offset = cursor.saturating_sub(offset);

41844203 let savepoint = doc.savepoint(view);

41854204

4205+ let trigger_doc = doc.id();

4206+ let trigger_view = view.id;

4207+

41864208 cx.callback(

41874209 future,

41884210 move |editor, compositor, response: Option<lsp::CompletionResponse>| {

4189− if editor.mode != Mode::Insert {

4190− // we're not in insert mode anymore

4211+ let (view, doc) = current_ref!(editor);

4212+ // check if the completion request is stale.

4213+ //

4214+ // Completions are completed asynchrounsly and therefore the user could

4215+ //switch document/view or leave insert mode. In all of thoise cases the

4216+ // completion should be discarded

4217+ if editor.mode != Mode::Insert || view.id != trigger_view || doc.id() != trigger_doc {

41914218 return;

41924219 }

41934220

helix-term/src/ui/editor.rs+1

@@ -820,6 +820,7 @@ impl EditorView {

820820 (Mode::Insert, Mode::Normal) => {

821821 // if exiting insert mode, remove completion

822822 self.completion = None;

823+ cxt.editor.completion_request_handle = None;

823824

824825 // TODO: Use an on_mode_change hook to remove signature help

825826 cxt.jobs.callback(async {

helix-view/src/editor.rs+10−1

@@ -31,7 +31,7 @@ use std::{

3131use tokio::{

3232 sync::{

3333 mpsc::{unbounded_channel, UnboundedReceiver, UnboundedSender},

34− Notify, RwLock,

34+ oneshot, Notify, RwLock,

3535 },

3636 time::{sleep, Duration, Instant, Sleep},

3737};

@@ -852,6 +852,14 @@ pub struct Editor {

852852 /// avoid calculating the cursor position multiple

853853 /// times during rendering and should not be set by other functions.

854854 pub cursor_cache: Cell<Option<Option<Position>>>,

855+ /// When a new completion request is sent to the server old

856+ /// unifinished request must be dropped. Each completion

857+ /// request is associated with a channel that cancels

858+ /// when the channel is dropped. That channel is stored

859+ /// here. When a new completion request is sent this

860+ /// field is set and any old requests are automatically

861+ /// canceled as a result

862+ pub completion_request_handle: Option<oneshot::Sender<()>>,

855863}

856864

857865pub type RedrawHandle = (Arc<Notify>, Arc<RwLock<()>>);

@@ -950,6 +958,7 @@ impl Editor {

950958 redraw_handle: Default::default(),

951959 needs_redraw: false,

952960 cursor_cache: Cell::new(None),

961+ completion_request_handle: None,

953962 }

954963 }

955964