feat(lsp): code lens under cursor picker

matoous · matoous · commit 867e02731aa4 · 2022-12-10T15:21:58.000+01:00
diff --git a/book/src/configuration.md b/book/src/configuration.md
@@ -112,11 +112,12 @@ The following statusline elements can be configured:
 
 ### `[editor.lsp]` Section
 
-| Key                   | Description                                                 | Default |
-| ---                   | -----------                                                 | ------- |
-| `display-messages`    | Display LSP progress messages below statusline[^1]          | `false` |
-| `auto-signature-help` | Enable automatic popup of signature help (parameter hints)  | `true`  |
-| `display-signature-help-docs` | Display docs under signature help popup             | `true`  |
+| Key                           | Description                                                | Default |
+| ---                           | -----------                                                | ------- |
+| `display-messages`            | Display LSP progress messages below statusline[^1]         | `false` |
+| `auto-signature-help`         | Enable automatic popup of signature help (parameter hints) | `true`  |
+| `display-signature-help-docs` | Display docs under signature help popup                    | `true`  |
+| `code-lens`                   | Enable code lens                                           | `true`  |
 
 [^1]: By default, a progress spinner is shown in the statusline beside the file path.
 
diff --git a/helix-lsp/src/client.rs b/helix-lsp/src/client.rs
@@ -1105,4 +1105,27 @@ impl Client {
 
         Some(self.call::<lsp::request::CodeLensRequest>(params))
     }
+
+    pub fn code_lens_resolve(
+        &self,
+        code_lens: lsp::CodeLens,
+    ) -> Option<impl Future<Output = Result<Option<lsp::CodeLens>>>> {
+        let capabilities = self.capabilities.get().unwrap();
+
+        // Return early if the server does not support resolving code lens.
+        match capabilities.code_lens_provider {
+            Some(lsp::CodeLensOptions {
+                resolve_provider: Some(true),
+                ..
+            }) => (),
+            _ => return None,
+        }
+
+        let request = self.call::<lsp::request::CodeLensResolve>(code_lens);
+        Some(async move {
+            let json = request.await?;
+            let response: Option<lsp::CodeLens> = serde_json::from_value(json)?;
+            Ok(response)
+        })
+    }
 }
diff --git a/helix-term/src/commands.rs b/helix-term/src/commands.rs
@@ -348,6 +348,7 @@ impl MappableCommand {
         paste_after, "Paste after selection",
         paste_before, "Paste before selection",
         paste_clipboard_after, "Paste clipboard after selections",
+        code_lens_under_cursor, "Show code lenses under cursor",
         code_lenses_picker, "Show code lense picker",
         paste_clipboard_before, "Paste clipboard before selections",
         paste_primary_clipboard_after, "Paste primary clipboard after selections",
diff --git a/helix-term/src/commands/lsp.rs b/helix-term/src/commands/lsp.rs
@@ -1269,6 +1269,82 @@ impl ui::menu::Item for lsp::CodeLens {
     }
 }
 
+pub fn code_lens_under_cursor(cx: &mut Context) {
+    let (view, doc) = current!(cx.editor);
+
+    let language_server = match doc.language_server() {
+        Some(language_server) => language_server,
+        None => return,
+    };
+
+    let offset_encoding = language_server.offset_encoding();
+    let pos = doc.position(view.id, offset_encoding);
+    let url = doc.url();
+
+    if url.is_none() {
+        return;
+    };
+
+    if let Some(lenses) = cx.editor.code_lenses.get(&url.unwrap()) {
+        let lenses: Vec<lsp::CodeLens> = lenses
+            .iter()
+            .filter(|cl| {
+                // TODO: fix the check
+                cl.range.start.line == pos.line
+            })
+            .map(|cl| {
+                if cl.command.is_none() {
+                    if let Some(req) = language_server.code_lens_resolve(cl.clone()) {
+                        if let Some(code_lens) = block_on(req).ok().unwrap() {
+                            log::info!("code_lense: resolved {:?} into {:?}", cl, code_lens);
+                            return code_lens;
+                        }
+                    }
+                }
+                cl.clone()
+            })
+            .collect();
+
+        if lenses.is_empty() {
+            cx.editor.set_status("No code lens available");
+            return;
+        }
+
+        let mut picker = ui::Menu::new(lenses, (), move |editor, code_lens, event| {
+            let doc = doc!(editor);
+
+            if event != PromptEvent::Validate {
+                return;
+            }
+
+            if let Some(language_server) = doc.language_server() {
+                let lens = code_lens.unwrap().clone();
+                if let Some(cmd) = lens.command {
+                    let future = match language_server.command(cmd) {
+                        Some(future) => future,
+                        None => {
+                            editor.set_error("Language server does not support executing commands");
+                            return;
+                        }
+                    };
+
+                    tokio::spawn(async move {
+                        let res = future.await;
+
+                        if let Err(e) = res {
+                            log::error!("execute LSP command: {}", e);
+                        }
+                    });
+                }
+            }
+        });
+        picker.move_down(); // pre-select the first item
+
+        let popup = Popup::new("code-lens", picker).with_scrollbar(false);
+        cx.push_layer(Box::new(popup));
+    };
+}
+
 pub fn code_lenses_picker(cx: &mut Context) {
     let doc = doc!(cx.editor);
 
@@ -1281,7 +1357,7 @@ pub fn code_lenses_picker(cx: &mut Context) {
         Some(future) => future,
         None => {
             cx.editor
-                .set_error("Language server does not support code lense");
+                .set_error("Language server does not support code lens");
             return;
         }
     };
@@ -1291,6 +1367,11 @@ pub fn code_lenses_picker(cx: &mut Context) {
         request,
         move |editor, compositor, lenses: Option<Vec<lsp::CodeLens>>| {
             if let Some(lenses) = lenses {
+                let doc = doc_mut!(editor, &doc_id);
+                if let Some(current_url) = doc.url() {
+                    editor.code_lenses.insert(current_url, lenses.clone());
+                    doc.set_code_lens(lenses.clone());
+                };
                 log::error!("lenses got: {:?}", lenses);
                 let picker = FilePicker::new(
                     lenses,
@@ -1327,7 +1408,7 @@ pub fn code_lenses_picker(cx: &mut Context) {
                 );
                 compositor.push(Box::new(overlayed(picker)));
             } else {
-                editor.set_status("no lense found");
+                editor.set_status("no lens found");
             }
         },
     )
diff --git a/helix-term/src/keymap/default.rs b/helix-term/src/keymap/default.rs
@@ -217,7 +217,7 @@ pub fn default() -> HashMap<Mode, Keymap> {
             "D" => workspace_diagnostics_picker,
             "a" => code_action,
             "'" => last_picker,
-            // "l" => execute_lense_under_cursor,
+            "l" => code_lens_under_cursor,
             "L" => code_lenses_picker,
             "g" => { "Debug (experimental)" sticky=true
                 "l" => dap_launch,
diff --git a/helix-term/src/ui/editor.rs b/helix-term/src/ui/editor.rs
@@ -16,6 +16,7 @@ use helix_core::{
     unicode::width::UnicodeWidthStr,
     visual_coords_at_pos, LineEnding, Position, Range, Selection, Transaction,
 };
+use helix_lsp::util::lsp_pos_to_pos;
 use helix_view::{
     apply_transaction,
     document::{Mode, SCRATCH_BUFFER_NAME},
@@ -134,6 +135,9 @@ impl EditorView {
             }
             highlights = Box::new(syntax::merge(highlights, diagnostic));
         }
+        if let Some(spans) = EditorView::doc_code_lens_highlights(doc, theme) {
+            highlights = Box::new(helix_core::syntax::merge(highlights, spans));
+        }
         let highlights: Box<dyn Iterator<Item = HighlightEvent>> = if is_focused {
             Box::new(syntax::merge(
                 highlights,
@@ -265,6 +269,39 @@ impl EditorView {
         }
     }
 
+    pub fn doc_code_lens_highlights(
+        doc: &Document,
+        theme: &Theme,
+    ) -> Option<Vec<(usize, std::ops::Range<usize>)>> {
+        let idx = theme
+            .find_scope_index("code_lens")
+            // get one of the themes below as fallback values
+            .or_else(|| theme.find_scope_index("diagnostic"))
+            .or_else(|| theme.find_scope_index("ui.cursor"))
+            .or_else(|| theme.find_scope_index("ui.selection"))
+            .expect(
+                "at least one of the following scopes must be defined in the theme: `diagnostic`, `ui.cursor`, or `ui.selection`",
+            );
+        if let Some(ls) = doc.language_server() {
+            return Some(
+                doc.code_lens()
+                    .iter()
+                    .map(|l| {
+                        // TODO: optimize
+                        let start = lsp_pos_to_pos(doc.text(), l.range.start, ls.offset_encoding())
+                            .unwrap();
+                        let end =
+                            lsp_pos_to_pos(doc.text(), l.range.end, ls.offset_encoding()).unwrap();
+
+                        (idx, start..end)
+                    })
+                    .collect(),
+            );
+        }
+
+        None
+    }
+
     /// Get highlight spans for document diagnostics
     pub fn doc_diagnostics_highlights(
         doc: &Document,
diff --git a/helix-term/src/ui/picker.rs b/helix-term/src/ui/picker.rs
@@ -288,6 +288,9 @@ impl<T: Item + 'static> Component for FilePicker<T> {
                 }
                 highlights = Box::new(helix_core::syntax::merge(highlights, spans));
             }
+            if let Some(spans) = EditorView::doc_code_lens_highlights(doc, &cx.editor.theme) {
+                highlights = Box::new(helix_core::syntax::merge(highlights, spans));
+            }
             EditorView::render_text_highlights(
                 doc,
                 offset,
diff --git a/helix-view/src/document.rs b/helix-view/src/document.rs
@@ -135,6 +135,7 @@ pub struct Document {
     pub(crate) modified_since_accessed: bool,
 
     diagnostics: Vec<Diagnostic>,
+    code_lens: Vec<helix_lsp::lsp::CodeLens>,
     language_server: Option<Arc<helix_lsp::Client>>,
 
     diff_handle: Option<DiffHandle>,
@@ -370,6 +371,7 @@ impl Document {
             changes,
             old_state,
             diagnostics: Vec::new(),
+            code_lens: Vec::new(),
             version: 0,
             history: Cell::new(History::default()),
             savepoint: None,
@@ -1163,6 +1165,15 @@ impl Document {
         )
     }
 
+    #[inline]
+    pub fn code_lens(&self) -> &[lsp::CodeLens] {
+        &self.code_lens
+    }
+
+    pub fn set_code_lens(&mut self, code_lens: Vec<lsp::CodeLens>) {
+        self.code_lens = code_lens;
+    }
+
     #[inline]
     pub fn diagnostics(&self) -> &[Diagnostic] {
         &self.diagnostics
diff --git a/helix-view/src/editor.rs b/helix-view/src/editor.rs
@@ -242,6 +242,8 @@ pub struct LspConfig {
     pub auto_signature_help: bool,
     /// Display docs under signature help popup
     pub display_signature_help_docs: bool,
+    /// Enable code lense.
+    pub code_lens: bool,
 }
 
 impl Default for LspConfig {
@@ -250,6 +252,7 @@ impl Default for LspConfig {
             display_messages: false,
             auto_signature_help: true,
             display_signature_help_docs: true,
+            code_lens: false,
         }
     }
 }
@@ -690,6 +693,7 @@ pub struct Editor {
     pub macro_replaying: Vec<char>,
     pub language_servers: helix_lsp::Registry,
     pub diagnostics: BTreeMap<lsp::Url, Vec<lsp::Diagnostic>>,
+    pub code_lenses: BTreeMap<lsp::Url, Vec<lsp::CodeLens>>,
     pub diff_providers: DiffProviderRegistry,
 
     pub debugger: Option<dap::Client>,
@@ -802,6 +806,7 @@ impl Editor {
             theme: theme_loader.default(),
             language_servers: helix_lsp::Registry::new(),
             diagnostics: BTreeMap::new(),
+            code_lenses: BTreeMap::new(),
             diff_providers: DiffProviderRegistry::default(),
             debugger: None,
             debugger_events: SelectAll::new(),
diff --git a/languages.toml b/languages.toml
@@ -12,6 +12,9 @@ comment-token = "//"
 language-server = { command = "rust-analyzer" }
 indent = { tab-width = 4, unit = "    " }
 
+[language.config]
+checkOnSave = { command = "clippy" }
+
 [language.auto-pairs]
 '(' = ')'
 '{' = '}'
diff --git a/runtime/themes/fleet_dark.toml b/runtime/themes/fleet_dark.toml
@@ -95,6 +95,7 @@
 "diagnostic.info" = { underline = { color = "blue_accent", style = "line" } }
 "diagnostic.warning" = { underline = { color = "yellow_accent", style = "line" } }
 "diagnostic.error" = { underline = { color = "red_error", style = "line" } }
+"code_lens" = { underline = { color = "green", style = "line" } }
 
 [palette]
 background = "#181818"
diff --git a/theme.toml b/theme.toml
@@ -77,6 +77,8 @@ label = "honey"
 "diagnostic.warning" = { underline = { color = "lightning", style = "curl" } }
 "diagnostic.error" = { underline = { color = "apricot", style = "curl" } }
 
+"code_lens" = { modifiers = ["underline"] }
+
 warning = "lightning"
 error = "apricot"
 info = "delta"

Original file line number	Diff line number	Diff line change
`@@ -288,6 +288,9 @@ impl<T: Item + 'static> Component for FilePicker<T> {`
`288`	`288`	`}`
`289`	`289`	`highlights = Box::new(helix_core::syntax::merge(highlights, spans));`
`290`	`290`	`}`
	`291`	`+ if let Some(spans) = EditorView::doc_code_lens_highlights(doc, &cx.editor.theme) {`
	`292`	`+ highlights = Box::new(helix_core::syntax::merge(highlights, spans));`
	`293`	`+ }`
`291`	`294`	`EditorView::render_text_highlights(`
`292`	`295`	`doc,`
`293`	`296`	`offset,`