Add code actions on save

* Add code-actions-on-save config
* Match VS Code config to allow future flexibility
* Refactor lsp commands to allow for code reuse
* Attempt code actions for all language servers for the document
* Add lsp specific integration tests
* Update documentation in book
* Canonicalize path argument when retrieving documents by path
* Resolves issue when running lsp integration tests in windows

Author: jpttrssn

.cargo/config.toml

@@ -14,4 +14,5 @@ rustflags = ["--cfg", "tokio_unstable", "-C", "target-feature=-crt-static"]
 [alias]
 xtask = "run --package xtask --"
 integration-test = "test --features integration --profile integration --workspace --test integration"
+integration-test-lsp = "test --features integration-lsp --profile integration --workspace --test integration-lsp -- --test-threads=1"
 

.github/workflows/build.yml

@@ -69,12 +69,25 @@ jobs:
           key: ${{ runner.os }}-${{ runner.arch }}-stable-v${{ env.GRAMMAR_CACHE_VERSION }}-tree-sitter-grammars-${{ hashFiles('languages.toml') }}
           restore-keys: ${{ runner.os }}-${{ runner.arch }}-stable-v${{ env.GRAMMAR_CACHE_VERSION }}-tree-sitter-grammars-
 
+      - name: Install go lsp integration tests
+        uses: actions/setup-go@v5
+        with:
+          go-version: '^1.22.0'
+
+      - name: Install gopls for lsp integration tests
+        run: go install golang.org/x/tools/gopls@latest
+
+
+
       - name: Run cargo test
         run: cargo test --workspace
 
       - name: Run cargo integration-test
         run: cargo integration-test
 
+      - name: Run cargo integration-test-lsp
+        run: cargo integration-test-lsp
+
     strategy:
       matrix:
         os: [ubuntu-latest, macos-latest, windows-latest, ubuntu-24.04-arm]

book/src/languages.md

@@ -75,6 +75,7 @@ These configuration keys are available:
 | `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. |
 | `persistent-diagnostic-sources` | An array of LSP diagnostic sources assumed unchanged when the language server resends the same set of diagnostics. Helix can track the position for these diagnostics internally instead. Useful for diagnostics that are recomputed on save.
 | `rainbow-brackets` | Overrides the `editor.rainbow-brackets` config key for the language |
+| `code-actions-on-save`    | List of LSP code actions to be run in order on save, for example `[{ code-action = "source.organizeImports", enabled = true }]` |
 
 ### File-type detection and the `file-types` key
 

docs/CONTRIBUTING.md

@@ -59,6 +59,14 @@ Contributors using MacOS might encounter `Too many open files (os error 24)`
 failures while running integration tests. This can be resolved by increasing
 the default value (e.g. to `10240` from `256`) by running `ulimit -n 10240`.
 
+### Language Server tests
+
+There are integration tests specific for language server integration that can be
+run with `cargo integration-test-lsp` and have additional dependencies.
+
+* [go](https://go.dev)
+* [gopls](https://pkg.go.dev/golang.org/x/tools/gopls)
+
 ## Minimum Stable Rust Version (MSRV) Policy
 
 Helix keeps an intentionally low MSRV for the sake of easy building and packaging

helix-core/src/syntax/config.rs

@@ -56,6 +56,9 @@ pub struct LanguageConfiguration {
     #[serde(default)]
     pub auto_format: bool,
 
+    #[serde(default)]
+    pub code_actions_on_save: Option<Vec<CodeActionsOnSave>>,
+
     #[serde(skip_serializing_if = "Option::is_none")]
     pub formatter: Option<FormatterConfiguration>,
 
@@ -433,6 +436,13 @@ pub struct AdvancedCompletion {
     pub default: Option<String>,
 }
 
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "kebab-case")]
+pub struct CodeActionsOnSave {
+    pub code_action: String,
+    pub enabled: bool,
+}
+
 #[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize)]
 #[serde(rename_all = "kebab-case", untagged)]
 pub enum DebugConfigCompletion {

helix-term/Cargo.toml

@@ -34,6 +34,7 @@ assets = [
 default = ["git"]
 unicode-lines = ["helix-core/unicode-lines", "helix-view/unicode-lines"]
 integration = ["helix-event/integration_test"]
+integration-lsp = ["integration"]
 git = ["helix-vcs/git"]
 
 [[bin]]

helix-term/src/commands/lsp.rs

@@ -2,8 +2,8 @@ use futures_util::{stream::FuturesOrdered, FutureExt};
 use helix_lsp::{
     block_on,
     lsp::{
-        self, CodeAction, CodeActionOrCommand, CodeActionTriggerKind, DiagnosticSeverity,
-        NumberOrString,
+        self, CodeAction, CodeActionKind, CodeActionOrCommand, CodeActionTriggerKind,
+        DiagnosticSeverity, NumberOrString,
     },
     util::{diagnostic_to_lsp_diagnostic, lsp_range_to_range, range_to_lsp_range},
     Client, LanguageServerId, OffsetEncoding,
@@ -23,7 +23,7 @@ use helix_view::{
     editor::Action,
     handlers::lsp::SignatureHelpInvoked,
     theme::Style,
-    Document, View,
+    Document, DocumentId, View,
 };
 
 use crate::{
@@ -587,6 +587,11 @@ struct CodeActionOrCommandItem {
     language_server_id: LanguageServerId,
 }
 
+struct CodeActionItem {
+    lsp_item: lsp::CodeAction,
+    language_server_id: LanguageServerId,
+}
+
 impl ui::menu::Item for CodeActionOrCommandItem {
     type Data = ();
     fn format(&self, _data: &Self::Data) -> Row<'_> {
@@ -659,34 +664,8 @@ pub fn code_action(cx: &mut Context) {
 
     let selection_range = doc.selection(view.id).primary();
 
-    let mut seen_language_servers = HashSet::new();
-
-    let mut futures: FuturesOrdered<_> = doc
-        .language_servers_with_feature(LanguageServerFeature::CodeAction)
-        .filter(|ls| seen_language_servers.insert(ls.id()))
-        // TODO this should probably already been filtered in something like "language_servers_with_feature"
-        .filter_map(|language_server| {
-            let offset_encoding = language_server.offset_encoding();
-            let language_server_id = language_server.id();
-            let range = range_to_lsp_range(doc.text(), selection_range, offset_encoding);
-            // Filter and convert overlapping diagnostics
-            let code_action_context = 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 code_action_request =
-                language_server.code_actions(doc.identifier(), range, code_action_context)?;
-            Some((code_action_request, language_server_id))
-        })
+    let mut futures: FuturesOrdered<_> = code_actions_for_range(doc, selection_range, None)
+        .into_iter()
         .map(|(request, ls_id)| async move {
             let Some(mut actions) = request.await? else {
                 return anyhow::Ok(Vec::new());
@@ -788,19 +767,12 @@ pub fn code_action(cx: &mut Context) {
                     }
                     lsp::CodeActionOrCommand::CodeAction(code_action) => {
                         log::debug!("code action: {:?}", code_action);
-                        // we support lsp "codeAction/resolve" for `edit` and `command` fields
-                        let mut resolved_code_action = None;
-                        if code_action.edit.is_none() || code_action.command.is_none() {
-                            if let Some(future) = language_server.resolve_code_action(code_action) {
-                                if let Ok(code_action) = helix_lsp::block_on(future) {
-                                    resolved_code_action = Some(code_action);
-                                }
-                            }
-                        }
                         let resolved_code_action =
-                            resolved_code_action.as_ref().unwrap_or(code_action);
+                            resolve_code_action(code_action, language_server);
 
-                        if let Some(ref workspace_edit) = resolved_code_action.edit {
+                        if let Some(ref workspace_edit) =
+                            resolved_code_action.as_ref().unwrap_or(code_action).edit
+                        {
                             let _ = editor.apply_workspace_edit(offset_encoding, workspace_edit);
                         }
 
@@ -825,6 +797,156 @@ pub fn code_action(cx: &mut Context) {
     });
 }
 
+pub fn code_actions_for_range(
+    doc: &Document,
+    range: helix_core::Range,
+    only: Option<Vec<CodeActionKind>>,
+) -> Vec<(
+    impl Future<Output = Result<Option<Vec<CodeActionOrCommand>>, helix_lsp::Error>>,
+    LanguageServerId,
+)> {
+    let mut seen_language_servers = HashSet::new();
+
+    doc.language_servers_with_feature(LanguageServerFeature::CodeAction)
+        .filter(|ls| seen_language_servers.insert(ls.id()))
+        // TODO this should probably already been filtered in something like "language_servers_with_feature"
+        .filter_map(|language_server| {
+            let offset_encoding = language_server.offset_encoding();
+            let language_server_id = language_server.id();
+            let lsp_range = range_to_lsp_range(doc.text(), range, offset_encoding);
+            // Filter and convert overlapping diagnostics
+            let code_action_context = lsp::CodeActionContext {
+                diagnostics: doc
+                    .diagnostics()
+                    .iter()
+                    .filter(|&diag| {
+                        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: only.clone(),
+                trigger_kind: Some(CodeActionTriggerKind::INVOKED),
+            };
+            let code_action_request =
+                language_server.code_actions(doc.identifier(), lsp_range, code_action_context)?;
+            Some((code_action_request, language_server_id))
+        })
+        .collect::<Vec<_>>()
+}
+
+/// Will apply the code actions on save from the language config for each language server
+pub fn code_actions_on_save(cx: &mut compositor::Context, doc_id: &DocumentId) {
+    let doc = doc!(cx.editor, doc_id);
+
+    let code_actions_on_save_cfg = doc
+        .language_config()
+        .and_then(|c| c.code_actions_on_save.clone());
+
+    if let Some(code_actions_on_save_cfg) = code_actions_on_save_cfg {
+        for code_action_kind in code_actions_on_save_cfg.into_iter().filter_map(|action| {
+            action
+                .enabled
+                .then_some(CodeActionKind::from(action.code_action))
+        }) {
+            log::debug!("Attempting code action on save {:?}", code_action_kind);
+            let doc = doc!(cx.editor, doc_id);
+            let full_range = helix_core::Range::new(0, doc.text().len_chars());
+            let code_actions: Vec<CodeActionItem> =
+                code_actions_for_range(doc, full_range, Some(vec![code_action_kind.clone()]))
+                    .into_iter()
+                    .filter_map(|(future, language_server_id)| {
+                        if let Ok(Some(mut actions)) = helix_lsp::block_on(future) {
+                            // Retain only enabled code actions that do not have commands.
+                            //
+                            // Commands are deprecated and are not supported because they apply
+                            // workspace edits asynchronously and there is currently no mechanism
+                            // to handle waiting for the workspace edits to be applied before moving
+                            // on to the next code action (or auto-format).
+                            actions.retain(|action| {
+                                matches!(
+                                    action,
+                                    CodeActionOrCommand::CodeAction(CodeAction {
+                                        disabled: None,
+                                        command: None,
+                                        ..
+                                    })
+                                )
+                            });
+
+                            // Use the first matching code action
+                            if let Some(lsp_item) = actions.first() {
+                                return match lsp_item {
+                                    CodeActionOrCommand::CodeAction(code_action) => {
+                                        Some(CodeActionItem {
+                                            lsp_item: code_action.clone(),
+                                            language_server_id,
+                                        })
+                                    }
+                                    _ => None,
+                                };
+                            }
+                        }
+                        None
+                    })
+                    .collect();
+
+            if code_actions.is_empty() {
+                log::debug!("Code action on save not found {:?}", code_action_kind);
+                cx.editor
+                    .set_error(format!("Code Action not found: {:?}", code_action_kind));
+            }
+
+            for code_action in code_actions {
+                log::debug!(
+                    "Applying code action on save {:?} for language server {:?}",
+                    code_action.lsp_item,
+                    code_action.language_server_id
+                );
+                let Some(language_server) = cx
+                    .editor
+                    .language_server_by_id(code_action.language_server_id)
+                else {
+                    log::error!(
+                        "Language server disappeared {:?}",
+                        code_action.language_server_id
+                    );
+                    continue;
+                };
+
+                let offset_encoding = language_server.offset_encoding();
+
+                let resolved_code_action =
+                    resolve_code_action(&code_action.lsp_item, language_server);
+
+                if let Some(ref workspace_edit) = resolved_code_action
+                    .as_ref()
+                    .unwrap_or(&code_action.lsp_item)
+                    .edit
+                {
+                    let _ = cx
+                        .editor
+                        .apply_workspace_edit_sync(offset_encoding, workspace_edit);
+                }
+            }
+        }
+    }
+}
+
+pub fn resolve_code_action(
+    code_action: &CodeAction,
+    language_server: &Client,
+) -> Option<CodeAction> {
+    let mut resolved_code_action = None;
+    if code_action.edit.is_none() || code_action.command.is_none() {
+        if let Some(future) = language_server.resolve_code_action(code_action) {
+            if let Ok(code_action) = helix_lsp::block_on(future) {
+                resolved_code_action = Some(code_action);
+            }
+        }
+    }
+    resolved_code_action
+}
+
 #[derive(Debug)]
 pub struct ApplyEditError {
     pub kind: ApplyEditErrorKind,