Merge 7a484efb8f into 2301430e37

helix-term/src/commands/typed.rs

@@ -1368,37 +1368,51 @@ fn lsp_workspace_command(
     if event != PromptEvent::Validate {
         return Ok(());
     }
+
+    struct LsIdCommand(usize, helix_lsp::lsp::Command);
+
+    impl ui::menu::Item for LsIdCommand {
+        type Data = ();
+
+        fn format(&self, _data: &Self::Data) -> Row {
+            self.1.title.as_str().into()
+        }
+    }
+
     let doc = doc!(cx.editor);
-    let Some((language_server_id, options)) = doc
+    let ls_id_commands = doc
         .language_servers_with_feature(LanguageServerFeature::WorkspaceCommand)
-        .find_map(|ls| {
+        .flat_map(|ls| {
             ls.capabilities()
                 .execute_command_provider
-                .as_ref()
+                .iter()
-                .map(|options| (ls.id(), options))
+                .flat_map(|options| options.commands.iter())
-        })
+                .map(|command| (ls.id(), command))
-    else {
+        });
-        cx.editor
-            .set_status("No active language servers for this document support workspace commands");
-        return Ok(());
-    };
 
     if args.is_empty() {
-        let commands = options
+        let commands = ls_id_commands
-            .commands
+            .map(|(ls_id, command)| {
-            .iter()
+                LsIdCommand(
-            .map(|command| helix_lsp::lsp::Command {
+                    ls_id,
-                title: command.clone(),
+                    helix_lsp::lsp::Command {
-                command: command.clone(),
+                        title: command.clone(),
-                arguments: None,
+                        command: command.clone(),
+                        arguments: None,
+                    },
+                )
             })
             .collect::<Vec<_>>();
         let callback = async move {
             let call: job::Callback = Callback::EditorCompositor(Box::new(
                 move |_editor: &mut Editor, compositor: &mut Compositor| {
-                    let picker = ui::Picker::new(commands, (), move |cx, command, _action| {
+                    let picker = ui::Picker::new(
-                        execute_lsp_command(cx.editor, language_server_id, command.clone());
+                        commands,
-                    });
+                        (),
+                        move |cx, LsIdCommand(ls_id, command), _action| {
+                            execute_lsp_command(cx.editor, *ls_id, command.clone());
+                        },
+                    );
                     compositor.push(Box::new(overlaid(picker)))
                 },
             ));
@@ -1407,21 +1421,32 @@ fn lsp_workspace_command(
         cx.jobs.callback(callback);
     } else {
         let command = args.join(" ");
-        if options.commands.iter().any(|c| c == &command) {
+        let matches: Vec<_> = ls_id_commands
-            execute_lsp_command(
+            .filter(|(_ls_id, c)| *c == &command)
-                cx.editor,
+            .collect();
-                language_server_id,
+
-                helix_lsp::lsp::Command {
+        match matches.as_slice() {
-                    title: command.clone(),
+            [(ls_id, _command)] => {
-                    arguments: None,
+                execute_lsp_command(
-                    command,
+                    cx.editor,
-                },
+                    *ls_id,
-            );
+                    helix_lsp::lsp::Command {
-        } else {
+                        title: command.clone(),
-            cx.editor.set_status(format!(
+                        arguments: None,
-                "`{command}` is not supported for this language server"
+                        command,
-            ));
+                    },
-            return Ok(());
+                );
+            }
+            [] => {
+                cx.editor.set_status(format!(
+                    "`{command}` is not supported for any language server"
+                ));
+            }
+            _ => {
+                cx.editor.set_status(format!(
+                    "`{command}` supported by multiple language servers"
+                ));
+            }
         }
     }
     Ok(())

helix-term/src/ui/mod.rs

@@ -364,14 +364,16 @@ pub mod completers {
     }
 
     pub fn lsp_workspace_command(editor: &Editor, input: &str) -> Vec<Completion> {
-        let Some(options) = doc!(editor)
+        let commands = doc!(editor)
             .language_servers_with_feature(LanguageServerFeature::WorkspaceCommand)
-            .find_map(|ls| ls.capabilities().execute_command_provider.as_ref())
+            .flat_map(|ls| {
-        else {
+                ls.capabilities()
-            return vec![];
+                    .execute_command_provider
-        };
+                    .iter()
-
+                    .flat_map(|options| options.commands.iter())
-        fuzzy_match(input, &options.commands, false)
+            });
+
+        fuzzy_match(input, commands, false)
             .into_iter()
             .map(|(name, _)| ((0..), name.to_owned().into()))
             .collect()