+use std::{borrow::Cow, collections::HashSet, fmt, future::Future};

+

+use futures_util::{stream::FuturesOrdered, FutureExt as _};

+use helix_core::syntax::config::LanguageServerFeature;

+use helix_lsp::{lsp, util::range_to_lsp_range, LanguageServerId};

+use tokio_stream::StreamExt as _;

+

+use crate::Editor;

+

+/// A generic action against the editor.

+///

+/// This corresponds to the LSP code action feature. LSP code actions are implemented in terms of

+/// `Action` but `Action` is generic and may be used for internal actions as well.

+pub struct Action {

+ title: Cow<'static, str>,

+ priority: u8,

+ action: Box<dyn Fn(&mut Editor) + Send + Sync + 'static>,

+}

+

+impl fmt::Debug for Action {

+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

+ f.debug_struct("CodeAction")

+ .field("title", &self.title)

+ .field("priority", &self.priority)

+ .finish_non_exhaustive()

+ }

+}

+

+impl Action {

+ pub fn new<T: Into<Cow<'static, str>>, F: Fn(&mut Editor) + Send + Sync + 'static>(

+ title: T,

+ priority: u8,

+ action: F,

+ ) -> Self {

+ Self {

+ title: title.into(),

+ priority,

+ action: Box::new(action),

+ }

+ }

+

+ pub fn title(&self) -> &str {

+ &self.title

+ }

+

+ pub fn execute(&self, editor: &mut Editor) {

+ (self.action)(editor);

+ }

+

+ fn lsp(server_id: LanguageServerId, action: lsp::CodeActionOrCommand) -> Self {

+ let title = match &action {

+ lsp::CodeActionOrCommand::CodeAction(action) => action.title.clone(),

+ lsp::CodeActionOrCommand::Command(command) => command.title.clone(),

+ };

+ let priority = lsp_code_action_priority(&action);

+

+ Self::new(title, priority, move |editor| {

+ let Some(language_server) = editor.language_server_by_id(server_id) else {

+ editor.set_error("Language Server disappeared");

+ return;

+ };

+ let offset_encoding = language_server.offset_encoding();

+ match &action {

+ lsp::CodeActionOrCommand::Command(command) => {

+ log::debug!("code action command: {:?}", command);

+ editor.execute_lsp_command(command.clone(), server_id);

+ }

+ lsp::CodeActionOrCommand::CodeAction(code_action) => {

+ log::debug!("code action: {:?}", code_action);

+ // we support lsp "codeAction/resolve" for `edit` and `command` fields

+ let code_action = if code_action.edit.is_none() || code_action.command.is_none()

+ {

+ language_server

+ .resolve_code_action(code_action)

+ .and_then(|future| helix_lsp::block_on(future).ok())

+ .unwrap_or(code_action.clone())

+ } else {

+ code_action.clone()

+ };

+

+ if let Some(ref workspace_edit) = code_action.edit {

+ let _ = editor.apply_workspace_edit(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 {

+ editor.execute_lsp_command(command, server_id);

+ }

+ }

+ }

+ })

+ }

+}

+

+/// Computes a priority score for LSP code actions.

+///

+/// This roughly matches how VSCode should behave: <https://github.com/microsoft/vscode/blob/eaec601dd69aeb4abb63b9601a6f44308c8d8c6e/src/vs/editor/contrib/codeAction/browser/codeActionWidget.ts>.

+/// The scoring is basically equivalent to comparing code actions by:

+/// `(category, fixes_diagnostic, is_preferred)`. First code actions are sorted by the category

+/// declared on the `kind` field (if present), then whether the action fixes a diagnostic and then

+/// whether it is marked as `is_preferred`.

+fn lsp_code_action_priority(action: &lsp::CodeActionOrCommand) -> u8 {

+ // The `kind` field is defined as open ended in the LSP spec - any value may be used. In

+ // practice a closed set of common values (mostly suggested in the LSP spec) are used.

+ // VSCode displays these components as menu headers. We don't do the same but we aim to sort

+ // the code actions in the same way.

+ let category = if let lsp::CodeActionOrCommand::CodeAction(lsp::CodeAction {

+ kind: Some(kind),

+ ..

+ }) = action

+ {

+ let mut components = kind.as_str().split('.');

+ match components.next() {

+ Some("quickfix") => 7,

+ Some("refactor") => match components.next() {

+ Some("extract") => 6,

+ Some("inline") => 5,

+ Some("rewrite") => 4,

+ Some("move") => 3,

+ Some("surround") => 2,

+ _ => 1,

+ },

+ Some("source") => 1,

+ _ => 0,

+ }

+ } else {

+ 0

+ };

+ let fixes_diagnostic = matches!(

+ action,

+ lsp::CodeActionOrCommand::CodeAction(lsp::CodeAction {

+ diagnostics: Some(diagnostics),

+ ..

+ }) if !diagnostics.is_empty()

+ );

+ let is_preferred = matches!(

+ action,

+ lsp::CodeActionOrCommand::CodeAction(lsp::CodeAction {

+ is_preferred: Some(true),

+ ..

+ })

+ );

+

+ // The constants here weigh the three criteria so that their scores can't overlap:

+ // two code actions in the same category should be sorted closer than code actions in

+ // separate categories. `fixes_diagnostic` and `is_preferred` break ties.

+ let mut priority = category * 4;

+ if fixes_diagnostic {

+ priority += 2;

+ }

+ if is_preferred {

+ priority += 1;

+ }

+ priority

+}

+

+impl Editor {

+ /// Finds the available actions given the current selection range.

+ pub fn actions(&self) -> Option<impl Future<Output = Vec<Action>>> {

+ let (view, doc) = current_ref!(self);

+ let selection = 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()))

+ .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, offset_encoding);

+ // Filter and convert overlapping diagnostics

+ let context = lsp::CodeActionContext {

+ diagnostics: doc

+ .diagnostics()

+ .iter()

+ .filter(|&diag| {

+ diag.inner.provider.language_server_id() == Some(language_server_id)

+ && selection.overlaps(&helix_core::Range::new(

+ diag.range.start,

+ diag.range.end,

+ ))

+ })

+ .map(|diag| diag.inner.to_lsp_diagnostic(doc.text(), offset_encoding))

+ .collect(),

+ only: None,

+ trigger_kind: Some(lsp::CodeActionTriggerKind::INVOKED),

+ };

+ let future = language_server

+ .code_actions(doc.identifier(), range, context)

+ .unwrap();

+ async move {

+ let Some(actions) = future.await? else {

+ return anyhow::Ok(Vec::new());

+ };

+

+ let actions: Vec<_> = actions

+ .into_iter()

+ .filter(|action| {

+ // remove disabled code actions

+ matches!(

+ action,

+ lsp::CodeActionOrCommand::Command(_)

+ | lsp::CodeActionOrCommand::CodeAction(lsp::CodeAction {

+ disabled: None,

+ ..

+ })

+ )

+ })

+ .map(move |action| Action::lsp(language_server_id, action))

+ .collect();

+

+ Ok(actions)

+ }

+ .boxed()

+ })

+ .chain(self.spelling_actions())

+ .collect();

+

+ if futures.is_empty() {

+ return None;

+ }

+

+ Some(async move {

+ let mut actions = Vec::new();

+ while let Some(response) = futures.next().await {

+ match response {

+ Ok(mut items) => actions.append(&mut items),

+ Err(err) => log::error!("Error requesting code actions: {err}"),

+ }

+ }

+ actions.sort_by_key(|action| std::cmp::Reverse(action.priority));

+ actions

+ })

+ }

+}