Add code actions on save

Author: jpttrssn

book/src/languages.md

@@ -65,6 +65,7 @@ These configuration keys are available:
 | `formatter`           | The formatter for the language, it will take precedence over the lsp when defined. The formatter must be able to take the original file as input from stdin and write the formatted file to stdout |
 | `text-width`          |  Maximum line length. Used for the `:reflow` command and soft-wrapping if `soft-wrap.wrap_at_text_width` is set, defaults to `editor.text-width`   |
 | `workspace-lsp-roots`     | Directories relative to the workspace root that are treated as LSP roots. Should only be set in `.helix/config.toml`. Overwrites the setting of the same name in `config.toml` if set. |
+| `code-actions-on-save`    | List of LSP code actions to be run in order on save, for example `["source.organizeImports"]` |
 
 ### File-type detection and the `file-types` key
 

helix-core/src/syntax.rs

@@ -84,6 +84,8 @@ pub struct LanguageConfiguration {
     pub comment_token: Option<String>,
     pub text_width: Option<usize>,
     pub soft_wrap: Option<SoftWrap>,
+    #[serde(default)]
+    pub code_actions_on_save: Vec<String>, // List of LSP code actions to be run in order upon saving
 
     #[serde(default, skip_serializing, deserialize_with = "deserialize_lsp_config")]
     pub config: Option<serde_json::Value>,

helix-term/src/commands.rs

@@ -2745,6 +2745,22 @@ async fn make_format_callback(
     Ok(call)
 }
 
+async fn make_code_actions_on_save_callback(
+    future: impl Future<Output = Result<Vec<helix_lsp::lsp::CodeActionOrCommand>, anyhow::Error>>
+        + Send
+        + 'static,
+) -> anyhow::Result<job::Callback> {
+    let code_actions = future.await?;
+    let call: job::Callback = Callback::Editor(Box::new(move |editor: &mut Editor| {
+        log::debug!("Applying code actions on save {:?}", code_actions);
+        code_actions
+            .iter()
+            .map(|code_action| apply_code_action(editor, code_action))
+            .collect()
+    }));
+    Ok(call)
+}
+
 #[derive(PartialEq, Eq)]
 pub enum Open {
     Below,

helix-term/src/commands/lsp.rs

@@ -1,11 +1,8 @@
 use futures_util::FutureExt;
 use helix_lsp::{
     block_on,
-    lsp::{
-        self, CodeAction, CodeActionOrCommand, CodeActionTriggerKind, DiagnosticSeverity,
-        NumberOrString,
-    },
-    util::{diagnostic_to_lsp_diagnostic, lsp_range_to_range, range_to_lsp_range},
+    lsp::{self, CodeAction, CodeActionOrCommand, DiagnosticSeverity, NumberOrString},
+    util::lsp_range_to_range,
     OffsetEncoding,
 };
 use tui::{
@@ -544,31 +541,9 @@ fn action_fixes_diagnostics(action: &CodeActionOrCommand) -> bool {
 pub fn code_action(cx: &mut Context) {
     let (view, doc) = current!(cx.editor);
 
-    let language_server = language_server!(cx.editor, doc);
-
     let selection_range = doc.selection(view.id).primary();
-    let offset_encoding = language_server.offset_encoding();
 
-    let range = range_to_lsp_range(doc.text(), selection_range, offset_encoding);
-
-    let future = match language_server.code_actions(
-        doc.identifier(),
-        range,
-        // Filter and convert overlapping diagnostics
-        lsp::CodeActionContext {
-            diagnostics: doc
-                .diagnostics()
-                .iter()
-                .filter(|&diag| {
-                    selection_range
-                        .overlaps(&helix_core::Range::new(diag.range.start, diag.range.end))
-                })
-                .map(|diag| diagnostic_to_lsp_diagnostic(doc.text(), diag, offset_encoding))
-                .collect(),
-            only: None,
-            trigger_kind: Some(CodeActionTriggerKind::INVOKED),
-        },
-    ) {
+    let future = match doc.code_actions(selection_range) {
         Some(future) => future,
         None => {
             cx.editor
@@ -642,25 +617,7 @@ pub fn code_action(cx: &mut Context) {
                 // always present here
                 let code_action = code_action.unwrap();
 
-                match code_action {
-                    lsp::CodeActionOrCommand::Command(command) => {
-                        log::debug!("code action command: {:?}", command);
-                        execute_lsp_command(editor, command.clone());
-                    }
-                    lsp::CodeActionOrCommand::CodeAction(code_action) => {
-                        log::debug!("code action: {:?}", code_action);
-                        if let Some(ref workspace_edit) = code_action.edit {
-                            log::debug!("edit: {:?}", workspace_edit);
-                            let _ = apply_workspace_edit(editor, offset_encoding, workspace_edit);
-                        }
-
-                        // if code action provides both edit and command first the edit
-                        // should be applied and then the command
-                        if let Some(command) = &code_action.command {
-                            execute_lsp_command(editor, command.clone());
-                        }
-                    }
-                }
+                apply_code_action(editor, code_action);
             });
             picker.move_down(); // pre-select the first item
 
@@ -670,6 +627,34 @@ pub fn code_action(cx: &mut Context) {
     )
 }
 
+pub fn apply_code_action(editor: &mut Editor, code_action: &CodeActionOrCommand) {
+    let (_view, doc) = current!(editor);
+
+    let language_server = language_server!(editor, doc);
+
+    let offset_encoding = language_server.offset_encoding();
+
+    match code_action {
+        lsp::CodeActionOrCommand::Command(command) => {
+            log::debug!("code action command: {:?}", command);
+            execute_lsp_command(editor, command.clone());
+        }
+        lsp::CodeActionOrCommand::CodeAction(code_action) => {
+            log::debug!("code action: {:?}", code_action);
+            if let Some(ref workspace_edit) = code_action.edit {
+                log::debug!("edit: {:?}", workspace_edit);
+                let _ = apply_workspace_edit(editor, offset_encoding, workspace_edit);
+            }
+
+            // if code action provides both edit and command first the edit
+            // should be applied and then the command
+            if let Some(command) = &code_action.command {
+                execute_lsp_command(editor, command.clone());
+            }
+        }
+    }
+}
+
 impl ui::menu::Item for lsp::Command {
     type Data = ();
     fn format(&self, _data: &Self::Data) -> Row {

helix-term/src/commands/typed.rs

@@ -334,6 +334,11 @@ fn write_impl(
     let (view, doc) = current!(cx.editor);
     let path = path.map(AsRef::as_ref);
 
+    if let Some(future) = doc.code_actions_on_save() {
+        let callback = make_code_actions_on_save_callback(future);
+        jobs.add(Job::with_callback(callback).wait_before_exiting());
+    }
+
     let fmt = if editor_auto_fmt {
         doc.auto_format().map(|fmt| {
             let callback = make_format_callback(
@@ -647,6 +652,11 @@ pub fn write_all_impl(
                 return None;
             }
 
+            if let Some(future) = doc.code_actions_on_save() {
+                let callback = make_code_actions_on_save_callback(future);
+                jobs.add(Job::with_callback(callback).wait_before_exiting());
+            }
+
             // Look for a view to apply the formatting change to. If the document
             // is in the current view, just use that. Otherwise, since we don't
             // have any other metric available for better selection, just pick

helix-view/src/document.rs

@@ -8,6 +8,7 @@ use helix_core::doc_formatter::TextFormat;
 use helix_core::syntax::Highlight;
 use helix_core::text_annotations::{InlineAnnotation, TextAnnotations};
 use helix_core::Range;
+use helix_lsp::util::{diagnostic_to_lsp_diagnostic, range_to_lsp_range};
 use helix_vcs::{DiffHandle, DiffProviderRegistry};
 
 use ::parking_lot::Mutex;
@@ -457,7 +458,7 @@ where
     *mut_ref = f(mem::take(mut_ref));
 }
 
-use helix_lsp::lsp;
+use helix_lsp::lsp::{self, CodeActionTriggerKind};
 use url::Url;
 
 impl Document {
@@ -633,6 +634,88 @@ impl Document {
         Some(fut.boxed())
     }
 
+    pub fn code_actions_on_save(
+        &self,
+    ) -> Option<BoxFuture<'static, Result<Vec<helix_lsp::lsp::CodeActionOrCommand>, anyhow::Error>>>
+    {
+        let code_actions_on_save = self
+            .language_config()
+            .map(|c| c.code_actions_on_save.clone())?;
+
+        if code_actions_on_save.is_empty() {
+            return None;
+        }
+
+        let request = self.code_actions(self.full_range())?;
+
+        let fut = async move {
+            log::debug!("Configured code actions on save {:?}", code_actions_on_save);
+            let json = request.await?;
+            let response: Option<helix_lsp::lsp::CodeActionResponse> =
+                serde_json::from_value(json)?;
+            let mut code_actions = match response {
+                Some(value) => value,
+                None => helix_lsp::lsp::CodeActionResponse::default(),
+            };
+            log::debug!("Available code actions {:?}", code_actions);
+            code_actions.retain(|action| {
+                matches!(
+                    action,
+                    helix_lsp::lsp::CodeActionOrCommand::CodeAction(x) if x.disabled.is_none() &&
+                        code_actions_on_save.iter().any(|a| match &x.kind {
+                            Some(kind) => kind.as_str() == a,
+                            None => false
+                    })
+                )
+            });
+            if code_actions.len() < code_actions_on_save.len() {
+                code_actions_on_save.iter().for_each(|configured_action| {
+                    if !code_actions.iter().any(|action| match action {
+                        helix_lsp::lsp::CodeActionOrCommand::CodeAction(x) => match &x.kind {
+                            Some(kind) => kind.as_str() == configured_action,
+                            None => false,
+                        },
+                        _ => false,
+                    }) {
+                        log::error!(
+                            "Configured code action on save is invalid {:?}",
+                            configured_action
+                        );
+                    }
+                })
+            }
+            Ok(code_actions)
+        };
+        Some(fut.boxed())
+    }
+
+    pub fn code_actions(
+        &self,
+        range: Range,
+    ) -> Option<impl Future<Output = Result<serde_json::Value, helix_lsp::Error>>> {
+        let language_server = self.language_server()?;
+        let offset_encoding = language_server.offset_encoding();
+        let lsp_range = range_to_lsp_range(self.text(), range, offset_encoding);
+
+        language_server.code_actions(
+            self.identifier(),
+            lsp_range,
+            // Filter and convert overlapping diagnostics
+            lsp::CodeActionContext {
+                diagnostics: self
+                    .diagnostics()
+                    .iter()
+                    .filter(|&diag| {
+                        range.overlaps(&helix_core::Range::new(diag.range.start, diag.range.end))
+                    })
+                    .map(|diag| diagnostic_to_lsp_diagnostic(self.text(), diag, offset_encoding))
+                    .collect(),
+                only: None,
+                trigger_kind: Some(CodeActionTriggerKind::INVOKED),
+            },
+        )
+    }
+
     pub fn save<P: Into<PathBuf>>(
         &mut self,
         path: Option<P>,
@@ -1331,6 +1414,11 @@ impl Document {
         &self.text
     }
 
+    #[inline]
+    pub fn full_range(&self) -> Range {
+        Range::new(0, self.text.len_chars())
+    }
+
     #[inline]
     pub fn selection(&self, view_id: ViewId) -> &Selection {
         &self.selections[&view_id]