diff --git a/helix-core/src/syntax.rs b/helix-core/src/syntax.rs
index 7c50a579..3614e2d3 100644
--- a/helix-core/src/syntax.rs
+++ b/helix-core/src/syntax.rs
@@ -332,6 +332,7 @@ pub enum LanguageServerFeature {
WorkspaceSymbols,
// Symbols, use bitflags, see above?
Diagnostics,
+ PullDiagnostics,
RenameSymbol,
InlayHints,
}
@@ -355,6 +356,7 @@ impl Display for LanguageServerFeature {
DocumentSymbols => "document-symbols",
WorkspaceSymbols => "workspace-symbols",
Diagnostics => "diagnostics",
+ PullDiagnostics => "pull-diagnostics",
RenameSymbol => "rename-symbol",
InlayHints => "inlay-hints",
};
diff --git a/helix-lsp/src/client.rs b/helix-lsp/src/client.rs
index bf8a8695..7d92d55f 100644
--- a/helix-lsp/src/client.rs
+++ b/helix-lsp/src/client.rs
@@ -348,6 +348,7 @@ impl Client {
Some(OneOf::Left(true) | OneOf::Right(_))
),
LanguageServerFeature::Diagnostics => true, // there's no extra server capability
+ LanguageServerFeature::PullDiagnostics => capabilities.diagnostic_provider.is_some(),
LanguageServerFeature::RenameSymbol => matches!(
capabilities.rename_provider,
Some(OneOf::Left(true)) | Some(OneOf::Right(_))
@@ -581,6 +582,9 @@ impl Client {
did_rename: Some(true),
..Default::default()
}),
+ diagnostic: Some(lsp::DiagnosticWorkspaceClientCapabilities {
+ refresh_support: Some(true),
+ }),
..Default::default()
}),
text_document: Some(lsp::TextDocumentClientCapabilities {
@@ -658,6 +662,10 @@ impl Client {
}),
..Default::default()
}),
+ diagnostic: Some(lsp::DiagnosticClientCapabilities {
+ dynamic_registration: Some(false),
+ related_document_support: Some(true),
+ }),
publish_diagnostics: Some(lsp::PublishDiagnosticsClientCapabilities {
version_support: Some(true),
tag_support: Some(lsp::TagSupport {
@@ -1224,6 +1232,32 @@ impl Client {
})
}
+ pub fn text_document_diagnostic(
+ &self,
+ text_document: lsp::TextDocumentIdentifier,
+ previous_result_id: Option<String>,
+ ) -> Option<impl Future<Output = Result<Value>>> {
+ let capabilities = self.capabilities();
+
+ // Return early if the server does not support pull diagnostic.
+ let identifier = match capabilities.diagnostic_provider.as_ref()? {
+ lsp::DiagnosticServerCapabilities::Options(cap) => cap.identifier.clone(),
+ lsp::DiagnosticServerCapabilities::RegistrationOptions(cap) => {
+ cap.diagnostic_options.identifier.clone()
+ }
+ };
+
+ let params = lsp::DocumentDiagnosticParams {
+ text_document,
+ identifier,
+ previous_result_id,
+ work_done_progress_params: lsp::WorkDoneProgressParams::default(),
+ partial_result_params: lsp::PartialResultParams::default(),
+ };
+
+ Some(self.call::<lsp::request::DocumentDiagnosticRequest>(params))
+ }
+
pub fn text_document_document_highlight(
&self,
text_document: lsp::TextDocumentIdentifier,
diff --git a/helix-lsp/src/lib.rs b/helix-lsp/src/lib.rs
index ba41cbc5..b9a9ee4d 100644
--- a/helix-lsp/src/lib.rs
+++ b/helix-lsp/src/lib.rs
@@ -463,6 +463,7 @@ pub enum MethodCall {
RegisterCapability(lsp::RegistrationParams),
UnregisterCapability(lsp::UnregistrationParams),
ShowDocument(lsp::ShowDocumentParams),
+ WorkspaceDiagnosticRefresh,
}
impl MethodCall {
@@ -494,6 +495,7 @@ impl MethodCall {
let params: lsp::ShowDocumentParams = params.parse()?;
Self::ShowDocument(params)
}
+ lsp::request::WorkspaceDiagnosticRefresh::METHOD => Self::WorkspaceDiagnosticRefresh,
_ => {
return Err(Error::Unhandled);
}
diff --git a/helix-term/src/application.rs b/helix-term/src/application.rs
index cb270b86..f80cffd4 100644
--- a/helix-term/src/application.rs
+++ b/helix-term/src/application.rs
@@ -725,6 +725,15 @@ impl Application {
doc.text(),
language_id,
);
+
+ if language_server
+ .supports_feature(syntax::LanguageServerFeature::PullDiagnostics)
+ {
+ handlers::diagnostics::pull_diagnostics_for_document(
+ doc,
+ language_server,
+ );
+ }
}
}
Notification::PublishDiagnostics(params) => {
@@ -745,6 +754,7 @@ impl Application {
uri,
params.version,
params.diagnostics,
+ None,
);
}
Notification::ShowMessage(params) => {
@@ -1020,6 +1030,16 @@ impl Application {
let result = self.handle_show_document(params, offset_encoding);
Ok(json!(result))
}
+ Ok(MethodCall::WorkspaceDiagnosticRefresh) => {
+ for document in self.editor.documents() {
+ let language_server = language_server!();
+ handlers::diagnostics::pull_diagnostics_for_document(
+ document,
+ language_server,
+ );
+ }
+ Ok(serde_json::Value::Null)
+ }
};
let language_server = language_server!();
diff --git a/helix-term/src/commands.rs b/helix-term/src/commands.rs
index a197792e..5b542abf 100644
--- a/helix-term/src/commands.rs
+++ b/helix-term/src/commands.rs
@@ -917,6 +917,10 @@ fn goto_buffer(editor: &mut Editor, direction: Direction, count: usize) {
let id = *id;
+ if let Some(doc) = editor.document(id) {
+ helix_event::dispatch(helix_view::events::DocumentDidOpen { doc });
+ };
+
editor.switch(id, Action::Replace);
}
diff --git a/helix-term/src/events.rs b/helix-term/src/events.rs
index 15d81152..9d06627c 100644
--- a/helix-term/src/events.rs
+++ b/helix-term/src/events.rs
@@ -1,7 +1,7 @@
use helix_event::{events, register_event};
use helix_view::document::Mode;
use helix_view::events::{
- DiagnosticsDidChange, DocumentDidChange, DocumentFocusLost, SelectionDidChange,
+ DiagnosticsDidChange, DocumentDidChange, DocumentDidOpen, DocumentFocusLost, SelectionDidChange,
};
use crate::commands;
@@ -18,6 +18,7 @@ pub fn register() {
register_event::<PostInsertChar>();
register_event::<PostCommand>();
register_event::<DocumentDidChange>();
+ register_event::<DocumentDidOpen>();
register_event::<DocumentFocusLost>();
register_event::<SelectionDidChange>();
register_event::<DiagnosticsDidChange>();
diff --git a/helix-term/src/handlers.rs b/helix-term/src/handlers.rs
index b580e678..034c5067 100644
--- a/helix-term/src/handlers.rs
+++ b/helix-term/src/handlers.rs
@@ -6,13 +6,14 @@ use helix_event::AsyncHook;
use crate::config::Config;
use crate::events;
use crate::handlers::auto_save::AutoSaveHandler;
+use crate::handlers::diagnostics::PullDiagnosticsHandler;
use crate::handlers::signature_help::SignatureHelpHandler;
pub use helix_view::handlers::Handlers;
mod auto_save;
pub mod completion;
-mod diagnostics;
+pub mod diagnostics;
mod signature_help;
mod snippet;
@@ -22,11 +23,13 @@ pub fn setup(config: Arc<ArcSwap<Config>>) -> Handlers {
let event_tx = completion::CompletionHandler::new(config).spawn();
let signature_hints = SignatureHelpHandler::new().spawn();
let auto_save = AutoSaveHandler::new().spawn();
+ let pull_diagnostics = PullDiagnosticsHandler::new().spawn();
let handlers = Handlers {
completions: helix_view::handlers::completion::CompletionHandler::new(event_tx),
signature_hints,
auto_save,
+ pull_diagnostics,
};
completion::register_hooks(&handlers);
diff --git a/helix-term/src/handlers/diagnostics.rs b/helix-term/src/handlers/diagnostics.rs
index 3e44d416..c8566cfa 100644
--- a/helix-term/src/handlers/diagnostics.rs
+++ b/helix-term/src/handlers/diagnostics.rs
@@ -1,12 +1,22 @@
+use std::collections::{HashMap, HashSet};
+use std::time::Duration;
+
+use helix_core::syntax::LanguageServerFeature;
+use helix_core::Uri;
use helix_event::{register_hook, send_blocking};
+use helix_lsp::{lsp, LanguageServerId};
use helix_view::document::Mode;
-use helix_view::events::DiagnosticsDidChange;
+use helix_view::events::{DiagnosticsDidChange, DocumentDidChange, DocumentDidOpen};
use helix_view::handlers::diagnostics::DiagnosticEvent;
+use helix_view::handlers::lsp::PullDiagnosticsEvent;
use helix_view::handlers::Handlers;
+use helix_view::{DocumentId, Editor};
+use tokio::time::Instant;
use crate::events::OnModeSwitch;
+use crate::job;
-pub(super) fn register_hooks(_handlers: &Handlers) {
+pub(super) fn register_hooks(handlers: &Handlers) {
register_hook!(move |event: &mut DiagnosticsDidChange<'_>| {
if event.editor.mode != Mode::Insert {
for (view, _) in event.editor.tree.views_mut() {
@@ -21,4 +31,194 @@ pub(super) fn register_hooks(_handlers: &Handlers) {
}
Ok(())
});
+
+ let tx = handlers.pull_diagnostics.clone();
+ register_hook!(move |event: &mut DocumentDidChange<'_>| {
+ if event
+ .doc
+ .has_language_server_with_feature(LanguageServerFeature::PullDiagnostics)
+ {
+ let document_id = event.doc.id();
+ send_blocking(&tx, PullDiagnosticsEvent { document_id });
+ }
+ Ok(())
+ });
+
+ register_hook!(move |event: &mut DocumentDidOpen<'_>| {
+ if event
+ .doc
+ .has_language_server_with_feature(LanguageServerFeature::PullDiagnostics)
+ {
+ let document_id = event.doc.id();
+ job::dispatch_blocking(move |editor, _| {
+ let Some(doc) = editor.document(document_id) else {
+ return;
+ };
+
+ let language_servers =
+ doc.language_servers_with_feature(LanguageServerFeature::PullDiagnostics);
+
+ for language_server in language_servers {
+ pull_diagnostics_for_document(doc, language_server);
+ }
+ })
+ }
+
+ Ok(())
+ });
+}
+
+#[derive(Debug)]
+pub(super) struct PullDiagnosticsHandler {
+ document_ids: HashSet<DocumentId>,
+}
+
+impl PullDiagnosticsHandler {
+ pub fn new() -> PullDiagnosticsHandler {
+ PullDiagnosticsHandler {
+ document_ids: [].into(),
+ }
+ }
+}
+
+impl helix_event::AsyncHook for PullDiagnosticsHandler {
+ type Event = PullDiagnosticsEvent;
+
+ fn handle_event(
+ &mut self,
+ event: Self::Event,
+ existing_debounce: Option<tokio::time::Instant>,
+ ) -> Option<tokio::time::Instant> {
+ if existing_debounce.is_none() {
+ dispatch_pull_diagnostic_for_document(event.document_id);
+ }
+
+ self.document_ids.insert(event.document_id);
+ Some(Instant::now() + Duration::from_millis(500))
+ }
+
+ fn finish_debounce(&mut self) {
+ for document_id in self.document_ids.clone() {
+ dispatch_pull_diagnostic_for_document(document_id);
+ }
+ }
+}
+
+fn dispatch_pull_diagnostic_for_document(document_id: DocumentId) {
+ job::dispatch_blocking(move |editor, _| {
+ let Some(doc) = editor.document(document_id) else {
+ return;
+ };
+
+ let language_servers =
+ doc.language_servers_with_feature(LanguageServerFeature::PullDiagnostics);
+
+ for language_server in language_servers {
+ pull_diagnostics_for_document(doc, language_server);
+ }
+ })
+}
+
+pub fn pull_diagnostics_for_document(
+ doc: &helix_view::Document,
+ language_server: &helix_lsp::Client,
+) {
+ let Some(future) = language_server
+ .text_document_diagnostic(doc.identifier(), doc.previous_diagnostic_id.clone())
+ else {
+ return;
+ };
+
+ let Some(uri) = doc.uri() else {
+ return;
+ };
+
+ let server_id = language_server.id();
+ let document_id = doc.id();
+
+ tokio::spawn(async move {
+ match future.await {
+ Ok(res) => {
+ job::dispatch(move |editor, _| {
+ let response = match serde_json::from_value(res) {
+ Ok(result) => result,
+ Err(_) => return,
+ };
+
+ handle_pull_diagnostics_response(editor, response, server_id, uri, document_id)
+ })
+ .await
+ }
+ Err(err) => log::error!("Pull diagnostic request failed: {err}"),
+ }
+ });
+}
+
+fn handle_pull_diagnostics_response(
+ editor: &mut Editor,
+ response: lsp::DocumentDiagnosticReport,
+ server_id: LanguageServerId,
+ uri: Uri,
+ document_id: DocumentId,
+) {
+ let Some(doc) = editor.document_mut(document_id) else {
+ return;
+ };
+
+ match response {
+ lsp::DocumentDiagnosticReport::Full(report) => {
+ // Diagnostic for requested file
+ editor.handle_lsp_diagnostics(
+ server_id,
+ uri,
+ None,
+ report.full_document_diagnostic_report.items,
+ report.full_document_diagnostic_report.result_id,
+ );
+
+ // Diagnostic for related files
+ handle_document_diagnostic_report_kind(
+ editor,
+ document_id,
+ report.related_documents,
+ server_id,
+ );
+ }
+ lsp::DocumentDiagnosticReport::Unchanged(report) => {
+ doc.previous_diagnostic_id =
+ Some(report.unchanged_document_diagnostic_report.result_id);
+
+ handle_document_diagnostic_report_kind(
+ editor,
+ document_id,
+ report.related_documents,
+ server_id,
+ );
+ }
+ }
+}
+
+fn handle_document_diagnostic_report_kind(
+ editor: &mut Editor,
+ document_id: DocumentId,
+ report: Option<HashMap<lsp::Url, lsp::DocumentDiagnosticReportKind>>,
+ server_id: LanguageServerId,
+) {
+ for (url, report) in report.into_iter().flatten() {
+ match report {
+ lsp::DocumentDiagnosticReportKind::Full(report) => {
+ let Ok(uri) = Uri::try_from(url) else {
+ return;
+ };
+
+ editor.handle_lsp_diagnostics(server_id, uri, None, report.items, report.result_id);
+ }
+ lsp::DocumentDiagnosticReportKind::Unchanged(report) => {
+ let Some(doc) = editor.document_mut(document_id) else {
+ return;
+ };
+ doc.previous_diagnostic_id = Some(report.result_id);
+ }
+ }
+ }
}
diff --git a/helix-view/src/document.rs b/helix-view/src/document.rs
index 06a708f0..8f90aba4 100644
--- a/helix-view/src/document.rs
+++ b/helix-view/src/document.rs
@@ -196,6 +196,8 @@ pub struct Document {
pub focused_at: std::time::Instant,
pub readonly: bool,
+
+ pub previous_diagnostic_id: Option<String>,
}
/// Inlay hints for a single `(Document, View)` combo.
@@ -698,6 +700,7 @@ impl Document {
focused_at: std::time::Instant::now(),
readonly: false,
jump_labels: HashMap::new(),
+ previous_diagnostic_id: None,
}
}
@@ -2174,6 +2177,10 @@ impl Document {
pub fn reset_all_inlay_hints(&mut self) {
self.inlay_hints = Default::default();
}
+
+ pub fn has_language_server_with_feature(&self, feature: LanguageServerFeature) -> bool {
+ self.language_servers_with_feature(feature).next().is_some()
+ }
}
#[derive(Debug, Default)]
diff --git a/helix-view/src/editor.rs b/helix-view/src/editor.rs
index cdc48a54..6581dd35 100644
--- a/helix-view/src/editor.rs
+++ b/helix-view/src/editor.rs
@@ -4,7 +4,7 @@ use crate::{
document::{
DocumentOpenError, DocumentSavedEventFuture, DocumentSavedEventResult, Mode, SavePoint,
},
- events::DocumentFocusLost,
+ events::{DocumentDidOpen, DocumentFocusLost},
graphics::{CursorKind, Rect},
handlers::Handlers,
info::Info,
@@ -1778,6 +1778,11 @@ impl Editor {
};
self.switch(id, action);
+
+ if let Some(doc) = self.document_mut(id) {
+ helix_event::dispatch(DocumentDidOpen { doc });
+ };
+
Ok(id)
}
diff --git a/helix-view/src/events.rs b/helix-view/src/events.rs
index eb97268c..cb3ed90c 100644
--- a/helix-view/src/events.rs
+++ b/helix-view/src/events.rs
@@ -11,6 +11,7 @@ events! {
changes: &'a ChangeSet,
ghost_transaction: bool
}
+ DocumentDidOpen<'a> { doc: &'a Document}
SelectionDidChange<'a> { doc: &'a mut Document, view: ViewId }
DiagnosticsDidChange<'a> { editor: &'a mut Editor, doc: DocumentId }
// called **after** a document loses focus (but not when its closed)
diff --git a/helix-view/src/handlers.rs b/helix-view/src/handlers.rs
index a26c4ddb..bb2221a9 100644
--- a/helix-view/src/handlers.rs
+++ b/helix-view/src/handlers.rs
@@ -21,6 +21,7 @@ pub struct Handlers {
pub completions: CompletionHandler,
pub signature_hints: Sender<lsp::SignatureHelpEvent>,
pub auto_save: Sender<AutoSaveEvent>,
+ pub pull_diagnostics: Sender<lsp::PullDiagnosticsEvent>,
}
impl Handlers {
diff --git a/helix-view/src/handlers/lsp.rs b/helix-view/src/handlers/lsp.rs
index dc2e1755..60d50f9e 100644
--- a/helix-view/src/handlers/lsp.rs
+++ b/helix-view/src/handlers/lsp.rs
@@ -3,7 +3,7 @@ use std::fmt::Display;
use crate::editor::Action;
use crate::events::DiagnosticsDidChange;
-use crate::Editor;
+use crate::{DocumentId, Editor};
use helix_core::Uri;
use helix_lsp::util::generate_transaction_from_edits;
use helix_lsp::{lsp, LanguageServerId, OffsetEncoding};
@@ -22,6 +22,10 @@ pub enum SignatureHelpEvent {
RequestComplete { open: bool },
}
+pub struct PullDiagnosticsEvent {
+ pub document_id: DocumentId,
+}
+
#[derive(Debug)]
pub struct ApplyEditError {
pub kind: ApplyEditErrorKind,
@@ -280,6 +284,7 @@ impl Editor {
uri: Uri,
version: Option<i32>,
mut diagnostics: Vec<lsp::Diagnostic>,
+ report_id: Option<String>,
) {
let doc = self
.documents
@@ -357,6 +362,10 @@ impl Editor {
);
doc.replace_diagnostics(diagnostics, &unchanged_diag_sources, Some(server_id));
+ if report_id.is_some() {
+ doc.previous_diagnostic_id = report_id;
+ }
+
let doc = doc.id();
helix_event::dispatch(DiagnosticsDidChange { editor: self, doc });
}