feat: code lenses handler

Request code lenses on newly opened documents,
when a language server is started, etc.

Author: matoous

helix-term/src/commands/lsp.rs

@@ -15,7 +15,7 @@ use super::{align_view, push_jump, Align, Context, Editor};
 
 use helix_core::{
     diagnostic::DiagnosticProvider, syntax::config::LanguageServerFeature,
-    text_annotations::InlineAnnotation, CodeLens, Selection, Uri,
+    text_annotations::InlineAnnotation, Selection, Uri,
 };
 use helix_stdx::path;
 use helix_view::{

helix-term/src/handlers.rs

@@ -15,6 +15,7 @@ pub use helix_view::handlers::{word_index, Handlers};
 use self::document_colors::DocumentColorsHandler;
 
 mod auto_save;
+mod code_lenses;
 pub mod completion;
 pub mod diagnostics;
 mod document_colors;
@@ -50,6 +51,7 @@ pub fn setup(config: Arc<ArcSwap<Config>>) -> Handlers {
     diagnostics::register_hooks(&handlers);
     snippet::register_hooks(&handlers);
     document_colors::register_hooks(&handlers);
+    code_lenses::register_hooks(&handlers);
     prompt::register_hooks(&handlers);
     handlers
 }

helix-term/src/handlers/code_lenses.rs

@@ -0,0 +1,151 @@
+use std::{collections::HashSet, time::Duration};
+
+use futures_util::{stream::FuturesOrdered, StreamExt};
+use helix_core::syntax::config::LanguageServerFeature;
+use helix_event::{cancelable_future, register_hook};
+use helix_view::{
+    events::{DocumentDidChange, DocumentDidOpen, LanguageServerExited, LanguageServerInitialized},
+    handlers::{lsp::CodeLensesEvent, Handlers},
+    DocumentId, Editor,
+};
+use tokio::time::Instant;
+
+use crate::job;
+
+#[derive(Default)]
+pub(super) struct DocumentCodeLensesHandler {
+    docs: HashSet<DocumentId>,
+}
+
+const DOCUMENT_CHANGE_DEBOUNCE: Duration = Duration::from_millis(250);
+
+impl helix_event::AsyncHook for DocumentCodeLensesHandler {
+    type Event = CodeLensesEvent;
+
+    fn handle_event(&mut self, event: Self::Event, _timeout: Option<Instant>) -> Option<Instant> {
+        let CodeLensesEvent(doc_id) = event;
+        self.docs.insert(doc_id);
+        Some(Instant::now() + DOCUMENT_CHANGE_DEBOUNCE)
+    }
+
+    fn finish_debounce(&mut self) {
+        let docs = std::mem::take(&mut self.docs);
+
+        job::dispatch_blocking(move |editor, _compositor| {
+            for doc in docs {
+                request_document_code_lenses(editor, doc);
+            }
+        });
+    }
+}
+
+fn request_document_code_lenses(editor: &mut Editor, doc_id: DocumentId) {
+    if !editor.config().lsp.display_code_lenses {
+        return;
+    }
+
+    let Some(doc) = editor.document_mut(doc_id) else {
+        return;
+    };
+
+    let cancel = doc.color_swatch_controller.restart();
+
+    let mut seen_language_servers = HashSet::new();
+    let mut futures: FuturesOrdered<_> = doc
+        .language_servers_with_feature(LanguageServerFeature::CodeLens)
+        .filter(|ls| seen_language_servers.insert(ls.id()))
+        .map(|language_server| {
+            let text = doc.text().clone();
+            let offset_encoding = language_server.offset_encoding();
+            let future = language_server.code_lens(doc.identifier()).unwrap();
+
+            async move {
+                let lenses: Vec<_> = future
+                    .await?
+                    .unwrap_or_default()
+                    .into_iter()
+                    .filter_map(|lens| {
+                        let _pos = helix_lsp::util::lsp_pos_to_pos(
+                            &text,
+                            lens.range.start,
+                            offset_encoding,
+                        )?;
+                        Some(lens)
+                    })
+                    .collect();
+                anyhow::Ok(lenses)
+            }
+        })
+        .collect();
+
+    if futures.is_empty() {
+        return;
+    }
+
+    tokio::spawn(async move {
+        let mut code_lenses = Vec::new();
+        loop {
+            match cancelable_future(futures.next(), &cancel).await {
+                Some(Some(Ok(items))) => code_lenses.extend(items),
+                Some(Some(Err(err))) => log::error!("document color request failed: {err}"),
+                Some(None) => break,
+                // The request was cancelled.
+                None => return,
+            }
+        }
+        job::dispatch(move |editor, _| {
+            let Some(doc) = editor.documents.get_mut(&doc_id) else {
+                return;
+            };
+
+            if code_lenses.is_empty() {
+                doc.code_lenses.clear();
+                return;
+            }
+
+            doc.code_lenses = code_lenses;
+        })
+        .await;
+    });
+}
+
+pub(super) fn register_hooks(_handlers: &Handlers) {
+    register_hook!(move |event: &mut DocumentDidOpen<'_>| {
+        // when a document is initially opened, request colors for it
+        request_document_code_lenses(event.editor, event.doc);
+
+        Ok(())
+    });
+
+    register_hook!(move |_event: &mut DocumentDidChange<'_>| {
+        // TODO: update code lenses positions, same as with e.g. document colors
+        Ok(())
+    });
+
+    register_hook!(move |event: &mut LanguageServerInitialized<'_>| {
+        let doc_ids: Vec<_> = event.editor.documents().map(|doc| doc.id()).collect();
+
+        for doc_id in doc_ids {
+            request_document_code_lenses(event.editor, doc_id);
+        }
+
+        Ok(())
+    });
+
+    register_hook!(move |event: &mut LanguageServerExited<'_>| {
+        // Clear and re-request all color swatches when a server exits.
+        for doc in event.editor.documents_mut() {
+            if doc.supports_language_server(event.server_id) {
+                doc.code_lenses.clear();
+            }
+        }
+
+        let doc_ids: Vec<_> = event.editor.documents().map(|doc| doc.id()).collect();
+
+        for doc_id in doc_ids {
+            request_document_code_lenses(event.editor, doc_id);
+        }
+
+        Ok(())
+    });
+}

helix-view/src/document.rs

@@ -40,8 +40,7 @@ use helix_core::{
     indent::{auto_detect_indent_style, IndentStyle},
     line_ending::auto_detect_line_ending,
     syntax::{self, config::LanguageConfiguration},
-    ChangeSet, CodeLens, Diagnostic, LineEnding, Range, Rope, RopeBuilder, Selection, Syntax,
-    Transaction,
+    ChangeSet, Diagnostic, LineEnding, Range, Rope, RopeBuilder, Selection, Syntax, Transaction,
 };
 
 use crate::{

helix-view/src/editor.rs

@@ -527,6 +527,8 @@ pub struct LspConfig {
     pub inlay_hints_length_limit: Option<NonZeroU8>,
     /// Display document color swatches
     pub display_color_swatches: bool,
+    /// Display document color swatches
+    pub display_code_lenses: bool,
     /// Whether to enable snippet support
     pub snippets: bool,
     /// Whether to include declaration in the goto reference query
@@ -546,6 +548,7 @@ impl Default for LspConfig {
             snippets: true,
             goto_reference_include_declaration: true,
             display_color_swatches: true,
+            display_code_lenses: true,
         }
     }
 }

helix-view/src/handlers/lsp.rs

@@ -17,6 +17,8 @@ use super::Handlers;
 
 pub struct DocumentColorsEvent(pub DocumentId);
 
+pub struct CodeLensesEvent(pub DocumentId);
+
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]
 pub enum SignatureHelpInvoked {
     Automatic,