chore: cleanup

Author: matoous

helix-term/src/application.rs

@@ -1112,8 +1112,8 @@ impl Application {
                             .editor
                             .documents
                             .values()
-                            .filter(|x| x.supports_language_server(language_server))
-                            .map(|x| x.id())
+                            .filter(|doc| doc.supports_language_server(language_server))
+                            .map(|doc| doc.id())
                             .collect();
 
                         for document in documents {
@@ -1132,8 +1132,8 @@ impl Application {
                             .editor
                             .documents
                             .values()
-                            .filter(|x| x.supports_language_server(language_server))
-                            .map(|x| x.id())
+                            .filter(|doc| doc.supports_language_server(language_server))
+                            .map(|doc| doc.id())
                             .collect();
 
                         for document in documents {

helix-term/src/commands/lsp.rs

@@ -1470,26 +1470,27 @@ impl ui::menu::Item for lsp::CodeLens {
 }
 
 pub fn show_code_lenses_under_cursor(cx: &mut Context) {
-    let (_view, doc) = current!(cx.editor);
+    let (view, doc) = current!(cx.editor);
     let doc_id = doc.id();
     let language_server =
         language_server_with_feature!(cx.editor, doc, LanguageServerFeature::DocumentHighlight);
     let language_server_id = language_server.id();
+    let offset_encoding = language_server.offset_encoding();
+    let pos = doc.position(view.id, offset_encoding);
 
-    // TODO(matoous): this needs to support multiple language servers and resolving the code lens
-    // via the right one
+    // TODO(matoous): this should eventually support multiple language servers
     let mut futures: FuturesOrdered<_> = doc
         .code_lenses()
         .iter()
+        .filter(|c| c.line == pos.line as usize)
         .filter_map(|c| {
-            if c.command.is_some() {
-                let cloned = c.clone();
-                Some(Either::Left(ready(Ok(cloned))))
+            if c.lens.command.is_some() {
+                Some(Either::Left(ready(Ok(c.lens.clone()))))
             } else {
                 // Safety: the command is empty only if the code lens is unresolved and we assume
                 // that if the code lens is unresolved the language server support resolution.
                 language_server
-                    .resolve_code_lens(c.clone())
+                    .resolve_code_lens(c.lens.clone())
                     .map(Either::Right)
             }
         })

helix-term/src/handlers/code_lenses.rs

@@ -1,6 +1,5 @@
 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::{
@@ -12,7 +11,6 @@ use tokio::time::Instant;
 
 use crate::job;
 
-// TODO(matoous): use to update code lenses positions on document changes
 #[derive(Default)]
 #[allow(dead_code)]
 pub(super) struct DocumentCodeLensesHandler {
@@ -44,6 +42,10 @@ impl helix_event::AsyncHook for DocumentCodeLensesHandler {
     }
 }
 
+/// Requests code lenses for a specific document.
+///
+/// NOTE: currently supports only a single language server, the first one supporting
+/// code lenses is used.
 pub fn request_document_code_lenses(editor: &mut Editor, doc_id: DocumentId) {
     if !editor.config().lsp.display_code_lenses {
         return;
@@ -53,77 +55,69 @@ pub fn request_document_code_lenses(editor: &mut Editor, doc_id: DocumentId) {
         return;
     };
 
-    let cancel = doc.color_swatch_controller.restart();
+    let cancel = doc.code_lenses_controller.restart();
 
-    let mut seen_language_servers = HashSet::new();
-    let mut futures: FuturesOrdered<_> = doc
+    let language_server = 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();
+        .next();
+    let language_server = match language_server {
+        Some(language_server) => language_server,
+        None => {
+            editor.set_error(format!(
+                "No configured language server supports {}",
+                LanguageServerFeature::CodeLens
+            ));
+            return;
+        }
+    };
 
-    if futures.is_empty() {
-        return;
-    }
+    let text = doc.text().clone();
+    let offset_encoding = language_server.offset_encoding();
+    let future = language_server.code_lens(doc.identifier()).unwrap();
 
     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,
+        let lenses: Vec<_> = match cancelable_future(future, &cancel).await {
+            Some(Ok(Some(items))) => items
+                .into_iter()
+                .filter_map(|lens| {
+                    let _pos =
+                        helix_lsp::util::lsp_pos_to_pos(&text, lens.range.start, offset_encoding)?;
+                    Some(lens)
+                })
+                .collect(),
+            Some(Ok(None)) => Vec::new(),
+            Some(Err(err)) => {
+                log::error!("document color request failed: {err}");
+                return;
             }
-        }
+            None => return,
+        };
+
         job::dispatch(move |editor, _| {
             let Some(doc) = editor.documents.get_mut(&doc_id) else {
                 return;
             };
 
-            if code_lenses.is_empty() {
+            if lenses.is_empty() {
                 doc.code_lenses.clear();
                 return;
             }
 
-            doc.code_lenses = code_lenses;
+            doc.set_code_lenses(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
+        // when a document is initially opened, request code lenses 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
+        // TODO(matoous): use to update code lenses positions on document changes
         Ok(())
     });
 
@@ -138,7 +132,7 @@ pub(super) fn register_hooks(_handlers: &Handlers) {
     });
 
     register_hook!(move |event: &mut LanguageServerExited<'_>| {
-        // Clear and re-request all color swatches when a server exits.
+        // Clear and re-request all code lenses when a server exits.
         for doc in event.editor.documents_mut() {
             if doc.supports_language_server(event.server_id) {
                 doc.code_lenses.clear();

helix-view/src/document.rs

@@ -208,19 +208,26 @@ pub struct Document {
 
     /// Annotations for LSP document color swatches
     pub color_swatches: Option<DocumentColorSwatches>,
-    pub code_lenses: Vec<lsp::CodeLens>,
+    pub code_lenses: Vec<CodeLens>,
 
     // NOTE: ideally this would live on the handler for color swatches. This is blocked on a
     // large refactor that would make `&mut Editor` available on the `DocumentDidChange` event.
     pub color_swatch_controller: TaskController,
     pub pull_diagnostic_controller: TaskController,
+    pub code_lenses_controller: TaskController,
 
     // NOTE: this field should eventually go away - we should use the Editor's syn_loader instead
     // of storing a copy on every doc. Then we can remove the surrounding `Arc` and use the
     // `ArcSwap` directly.
     syn_loader: Arc<ArcSwap<syntax::Loader>>,
 }
 
+#[derive(Debug, Clone)]
+pub struct CodeLens {
+    pub line: usize,
+    pub lens: lsp::CodeLens,
+}
+
 #[derive(Debug, Clone, Default)]
 pub struct DocumentColorSwatches {
     pub color_swatches: Vec<InlineAnnotation>,
@@ -734,9 +741,10 @@ impl Document {
             jump_labels: HashMap::new(),
             color_swatches: None,
             color_swatch_controller: TaskController::new(),
+            pull_diagnostic_controller: TaskController::new(),
+            code_lenses_controller: TaskController::new(),
             syn_loader,
             previous_diagnostic_id: None,
-            pull_diagnostic_controller: TaskController::new(),
         }
     }
 
@@ -2171,12 +2179,18 @@ impl Document {
     }
 
     #[inline]
-    pub fn code_lenses(&self) -> &[lsp::CodeLens] {
+    pub fn code_lenses(&self) -> &[CodeLens] {
         &self.code_lenses
     }
 
     pub fn set_code_lenses(&mut self, lenses: Vec<lsp::CodeLens>) {
-        self.code_lenses = lenses;
+        self.code_lenses = lenses
+            .into_iter()
+            .map(|l| CodeLens {
+                line: l.range.start.line as usize,
+                lens: l,
+            })
+            .collect();
     }
 
     /// Get the document's auto pairs. If the document has a recognized

helix-view/src/editor.rs

@@ -1150,7 +1150,6 @@ pub struct Breakpoint {
 use futures_util::stream::{Flatten, Once};
 
 type Diagnostics = BTreeMap<Uri, Vec<(lsp::Diagnostic, DiagnosticProvider)>>;
-type CodeLenses = BTreeMap<Uri, Vec<lsp::CodeLens>>;
 
 pub struct Editor {
     /// Current editing mode.
@@ -1172,7 +1171,6 @@ pub struct Editor {
     pub macro_replaying: Vec<char>,
     pub language_servers: helix_lsp::Registry,
     pub diagnostics: Diagnostics,
-    pub code_lenses: CodeLenses,
     pub diff_providers: DiffProviderRegistry,
 
     pub debug_adapters: dap::registry::Registry,
@@ -1319,7 +1317,6 @@ impl Editor {
             theme: theme_loader.default(),
             language_servers,
             diagnostics: Diagnostics::new(),
-            code_lenses: CodeLenses::new(),
             diff_providers: DiffProviderRegistry::default(),
             debug_adapters: dap::registry::Registry::new(),
             breakpoints: HashMap::new(),

helix-view/src/gutter.rs

@@ -102,7 +102,7 @@ pub fn lens<'doc>(
             if !first_visual_line {
                 return None;
             }
-            if lenses.iter().any(|l| l.range.start.line as usize == line) {
+            if lenses.iter().any(|l| l.line == line) {
                 write!(out, "▶").ok();
                 Some(info)
             } else {