Allow textDocument/didChange notification to be synchronous

jpttrssn · junglerobba · junglerobba · commit 99a1e50d6636 · 2026-01-21T09:42:21.000+01:00
Co-authored-by: junglerobba &lt;junglerobba@jngl.one&gt;
diff --git a/helix-lsp/src/client.rs b/helix-lsp/src/client.rs
@@ -12,6 +12,7 @@ use crate::lsp::{
 };
 use helix_core::{find_workspace, syntax::config::LanguageServerFeature, ChangeSet, Rope};
 use helix_loader::VERSION_AND_GIT_HASH;
+use helix_lsp_types::TextDocumentContentChangeEvent;
 use helix_stdx::path;
 use parking_lot::Mutex;
 use serde::Deserialize;
@@ -517,6 +518,27 @@ impl Client {
         }
     }
 
+    pub fn notify_sync<R: lsp::notification::Notification>(&self, params: R::Params) -> Result<()>
+    where
+        R::Params: serde::Serialize,
+    {
+        let server_tx = self.server_tx.clone();
+
+        let params = serde_json::to_value(params)?;
+
+        let notification = jsonrpc::Notification {
+            jsonrpc: Some(jsonrpc::Version::V2),
+            method: R::METHOD.to_string(),
+            params: Self::value_into_params(params),
+        };
+
+        server_tx
+            .send(Payload::Notification(notification))
+            .map_err(|e| Error::Other(e.into()))?;
+
+        Ok(())
+    }
+
     /// Reply to a language server RPC call.
     pub fn reply(
         &self,
@@ -960,6 +982,51 @@ impl Client {
         new_text: &Rope,
         changes: &ChangeSet,
     ) -> Option<()> {
+        if let Some(content_changes) =
+            self.text_document_did_change_impl(old_text, new_text, changes)
+        {
+            return {
+                self.notify::<lsp::notification::DidChangeTextDocument>(
+                    lsp::DidChangeTextDocumentParams {
+                        text_document,
+                        content_changes,
+                    },
+                );
+                Some(())
+            };
+        }
+        None
+    }
+
+    /// Will send textDocument/didChange notification synchronously
+    pub fn text_document_did_change_sync(
+        &self,
+        text_document: lsp::VersionedTextDocumentIdentifier,
+        old_text: &Rope,
+        new_text: &Rope,
+        changes: &ChangeSet,
+    ) -> Option<Result<()>> {
+        if let Some(content_changes) =
+            self.text_document_did_change_impl(old_text, new_text, changes)
+        {
+            return Some(
+                self.notify_sync::<lsp::notification::DidChangeTextDocument>(
+                    lsp::DidChangeTextDocumentParams {
+                        text_document,
+                        content_changes,
+                    },
+                ),
+            );
+        }
+        None
+    }
+
+    pub fn text_document_did_change_impl(
+        &self,
+        old_text: &Rope,
+        new_text: &Rope,
+        changes: &ChangeSet,
+    ) -> Option<Vec<TextDocumentContentChangeEvent>> {
         let capabilities = self.capabilities.get().unwrap();
 
         // Return early if the server does not support document sync.
@@ -991,11 +1058,7 @@ impl Client {
             kind => unimplemented!("{:?}", kind),
         };
 
-        self.notify::<lsp::notification::DidChangeTextDocument>(lsp::DidChangeTextDocumentParams {
-            text_document,
-            content_changes: changes,
-        });
-        Some(())
+        Some(changes)
     }
 
     pub fn text_document_did_close(&self, text_document: lsp::TextDocumentIdentifier) {
diff --git a/helix-term/src/handlers/diagnostics.rs b/helix-term/src/handlers/diagnostics.rs
@@ -44,7 +44,7 @@ pub(super) fn register_hooks(handlers: &Handlers) {
         if event
             .doc
             .has_language_server_with_feature(LanguageServerFeature::PullDiagnostics)
-            && !event.ghost_transaction
+            && event.emit_lsp_notification.is_some()
         {
             // Cancel the ongoing request, if present.
             event.doc.pull_diagnostic_controller.cancel();
diff --git a/helix-term/src/handlers/document_colors.rs b/helix-term/src/handlers/document_colors.rs
@@ -174,7 +174,7 @@ pub(super) fn register_hooks(handlers: &Handlers) {
         // Avoid re-requesting document colors if the change is a ghost transaction (completion)
         // because the language server will not know about the updates to the document and will
         // give out-of-date locations.
-        if !event.ghost_transaction {
+        if event.emit_lsp_notification.is_some() {
             // Cancel the ongoing request, if present.
             event.doc.color_swatch_controller.cancel();
             helix_event::send_blocking(&tx, DocumentColorsEvent(event.doc.id()));
diff --git a/helix-term/src/handlers/signature_help.rs b/helix-term/src/handlers/signature_help.rs
@@ -353,7 +353,8 @@ pub(super) fn register_hooks(handlers: &Handlers) {
 
     let tx = handlers.signature_hints.clone();
     register_hook!(move |event: &mut DocumentDidChange<'_>| {
-        if event.doc.config.load().lsp.auto_signature_help && !event.ghost_transaction {
+        if event.doc.config.load().lsp.auto_signature_help && event.emit_lsp_notification.is_some()
+        {
             send_blocking(&tx, SignatureHelpEvent::ReTrigger);
         }
         Ok(())
diff --git a/helix-term/src/ui/completion.rs b/helix-term/src/ui/completion.rs
@@ -178,7 +178,7 @@ impl Completion {
                     let item = item.unwrap();
                     let context = &editor.handlers.completions.active_completions[&item.provider()];
                     // if more text was entered, remove it
-                    doc.restore(view, &context.savepoint, false);
+                    doc.restore(view, &context.savepoint, None);
                     // always present here
 
                     match item {
@@ -203,13 +203,17 @@ impl Completion {
                     if let Some(CompleteAction::Selected { savepoint }) =
                         editor.last_completion.take()
                     {
-                        doc.restore(view, &savepoint, false);
+                        doc.restore(view, &savepoint, None);
                     }
 
                     let item = item.unwrap();
                     let context = &editor.handlers.completions.active_completions[&item.provider()];
                     // if more text was entered, remove it
-                    doc.restore(view, &context.savepoint, true);
+                    doc.restore(
+                        view,
+                        &context.savepoint,
+                        Some(helix_view::document::EmitLspNotification::Async),
+                    );
                     // save an undo checkpoint before the completion
                     doc.append_changes_to_history(view);
 
diff --git a/helix-term/src/ui/editor.rs b/helix-term/src/ui/editor.rs
@@ -976,7 +976,11 @@ impl EditorView {
                                 let (view, doc) = current!(cxt.editor);
 
                                 if let Some(last_savepoint) = last_savepoint.as_deref() {
-                                    doc.restore(view, last_savepoint, true);
+                                    doc.restore(
+                                        view,
+                                        last_savepoint,
+                                        Some(helix_view::document::EmitLspNotification::Async),
+                                    );
                                 }
 
                                 let text = doc.text().slice(..);
@@ -1082,7 +1086,7 @@ impl EditorView {
                 }
                 CompleteAction::Selected { savepoint } => {
                     let (view, doc) = current!(editor);
-                    doc.restore(view, &savepoint, false);
+                    doc.restore(view, &savepoint, None);
                 }
             }
         }
diff --git a/helix-view/src/document.rs b/helix-view/src/document.rs
@@ -138,6 +138,12 @@ pub enum DocumentOpenError {
     IoError(#[from] io::Error),
 }
 
+#[derive(Debug)]
+pub enum EmitLspNotification {
+    Async,
+    Sync,
+}
+
 pub struct Document {
     pub(crate) id: DocumentId,
     text: Rope,
@@ -1381,7 +1387,7 @@ impl Document {
         &mut self,
         transaction: &Transaction,
         view_id: ViewId,
-        emit_lsp_notification: bool,
+        emit_lsp_notification: Option<EmitLspNotification>,
     ) -> bool {
         use helix_core::Assoc;
 
@@ -1530,7 +1536,7 @@ impl Document {
             view: view_id,
             old_text: &old_doc,
             changes,
-            ghost_transaction: !emit_lsp_notification,
+            emit_lsp_notification,
         });
 
         // if specified, the current selection should instead be replaced by transaction.selection
@@ -1552,7 +1558,7 @@ impl Document {
         &mut self,
         transaction: &Transaction,
         view_id: ViewId,
-        emit_lsp_notification: bool,
+        emit_lsp_notification: Option<EmitLspNotification>,
     ) -> bool {
         // store the state just before any changes are made. This allows us to undo to the
         // state just before a transaction was applied.
@@ -1575,14 +1581,20 @@ impl Document {
     }
     /// Apply a [`Transaction`] to the [`Document`] to change its text.
     pub fn apply(&mut self, transaction: &Transaction, view_id: ViewId) -> bool {
-        self.apply_inner(transaction, view_id, true)
+        self.apply_inner(transaction, view_id, Some(EmitLspNotification::Async))
+    }
+
+    /// Apply a [`Transaction`] to the [`Document`] to change its text and
+    /// emit the lsp notifcation synchronously
+    pub fn apply_sync_notification(&mut self, transaction: &Transaction, view_id: ViewId) -> bool {
+        self.apply_inner(transaction, view_id, Some(EmitLspNotification::Sync))
     }
 
     /// Apply a [`Transaction`] to the [`Document`] to change its text
     /// without notifying the language servers. This is useful for temporary transactions
     /// that must not influence the server.
     pub fn apply_temporary(&mut self, transaction: &Transaction, view_id: ViewId) -> bool {
-        self.apply_inner(transaction, view_id, false)
+        self.apply_inner(transaction, view_id, None)
     }
 
     fn undo_redo_impl(&mut self, view: &mut View, undo: bool) -> bool {
@@ -1594,7 +1606,7 @@ impl Document {
         let mut history = self.history.take();
         let txn = if undo { history.undo() } else { history.redo() };
         let success = if let Some(txn) = txn {
-            self.apply_impl(txn, view.id, true)
+            self.apply_impl(txn, view.id, Some(EmitLspNotification::Async))
         } else {
             false
         };
@@ -1650,7 +1662,12 @@ impl Document {
         savepoint
     }
 
-    pub fn restore(&mut self, view: &mut View, savepoint: &SavePoint, emit_lsp_notification: bool) {
+    pub fn restore(
+        &mut self,
+        view: &mut View,
+        savepoint: &SavePoint,
+        emit_lsp_notification: Option<EmitLspNotification>,
+    ) {
         assert_eq!(
             savepoint.view, view.id,
             "Savepoint must not be used with a different view!"
@@ -1683,7 +1700,7 @@ impl Document {
         };
         let mut success = false;
         for txn in txns {
-            if self.apply_impl(&txn, view.id, true) {
+            if self.apply_impl(&txn, view.id, Some(EmitLspNotification::Async)) {
                 success = true;
             }
         }
diff --git a/helix-view/src/events.rs b/helix-view/src/events.rs
@@ -2,7 +2,7 @@ use helix_core::{ChangeSet, Rope};
 use helix_event::events;
 use helix_lsp::LanguageServerId;
 
-use crate::{editor::Config, Document, DocumentId, Editor, ViewId};
+use crate::{document::EmitLspNotification, editor::Config, Document, DocumentId, Editor, ViewId};
 
 events! {
     DocumentDidOpen<'a> {
@@ -14,7 +14,7 @@ events! {
         view: ViewId,
         old_text: &'a Rope,
         changes: &'a ChangeSet,
-        ghost_transaction: bool
+        emit_lsp_notification: Option<EmitLspNotification>
     }
     DocumentDidClose<'a> {
         editor: &'a mut Editor,
diff --git a/helix-view/src/handlers/lsp.rs b/helix-view/src/handlers/lsp.rs
diff --git a/helix-view/src/handlers/word_index.rs b/helix-view/src/handlers/word_index.rs

Original file line number	Diff line number	Diff line change
`@@ -44,7 +44,7 @@ pub(super) fn register_hooks(handlers: &Handlers) {`
`44`	`44`	`if event`
`45`	`45`	`.doc`
`46`	`46`	`.has_language_server_with_feature(LanguageServerFeature::PullDiagnostics)`
`47`		`- && !event.ghost_transaction`
	`47`	`+ && event.emit_lsp_notification.is_some()`
`48`	`48`	`{`
`49`	`49`	`// Cancel the ongoing request, if present.`
`50`	`50`	`event.doc.pull_diagnostic_controller.cancel();`
Original file line number	Diff line number	Diff line change
`@@ -353,7 +353,8 @@ pub(super) fn register_hooks(handlers: &Handlers) {`
`353`	`353`
`354`	`354`	`let tx = handlers.signature_hints.clone();`
`355`	`355`	`register_hook!(move \|event: &mut DocumentDidChange<'_>\| {`
`356`		`- if event.doc.config.load().lsp.auto_signature_help && !event.ghost_transaction {`
	`356`	`+ if event.doc.config.load().lsp.auto_signature_help && event.emit_lsp_notification.is_some()`
	`357`	`+ {`
`357`	`358`	`send_blocking(&tx, SignatureHelpEvent::ReTrigger);`
`358`	`359`	`}`
`359`	`360`	`Ok(())`
Original file line number	Diff line number	Diff line change
`@@ -976,7 +976,11 @@ impl EditorView {`
`976`	`976`	`let (view, doc) = current!(cxt.editor);`
`977`	`977`
`978`	`978`	`if let Some(last_savepoint) = last_savepoint.as_deref() {`
`979`		`- doc.restore(view, last_savepoint, true);`
	`979`	`+ doc.restore(`
	`980`	`+ view,`
	`981`	`+ last_savepoint,`
	`982`	`+ Some(helix_view::document::EmitLspNotification::Async),`
	`983`	`+ );`
`980`	`984`	`}`
`981`	`985`
`982`	`986`	`let text = doc.text().slice(..);`
`@@ -1082,7 +1086,7 @@ impl EditorView {`
`1082`	`1086`	`}`
`1083`	`1087`	`CompleteAction::Selected { savepoint } => {`
`1084`	`1088`	`let (view, doc) = current!(editor);`
`1085`		`- doc.restore(view, &savepoint, false);`
	`1089`	`+ doc.restore(view, &savepoint, None);`
`1086`	`1090`	`}`
`1087`	`1091`	`}`
`1088`	`1092`	`}`