Use Signature system for defining SHELL_COMPLETER

helix-term/src/commands/typed.rs

@@ -68,13 +68,6 @@ impl CommandCompleter {
             var_args: completer,
         }
     }
-
-    const fn hybrid(completers: &'static [Completer], fallback: Completer) -> Self {
-        Self {
-            positional_args: completers,
-            var_args: fallback,
-        }
-    }
 }
 
 fn quit(cx: &mut compositor::Context, _args: Args, event: PromptEvent) -> anyhow::Result<()> {
@@ -2565,6 +2558,9 @@ fn noop(_cx: &mut compositor::Context, _args: Args, _event: PromptEvent) -> anyh
     Ok(())
 }
 
+// TODO: SHELL_SIGNATURE should specify var args for arguments, so that just completers::filename can be used,
+// but Signature does not yet allow for var args.
+
 /// This command handles all of its input as-is with no quoting or flags.
 const SHELL_SIGNATURE: Signature = Signature {
     positionals: (1, Some(2)),
@@ -2573,10 +2569,10 @@ const SHELL_SIGNATURE: Signature = Signature {
 };
 
 const SHELL_COMPLETER: CommandCompleter = CommandCompleter::positional(&[
-    // Command name (TODO: consider a command completer - Kakoune has prior art)
+    // Command name
-    completers::none,
+    completers::program,
     // Shell argument(s)
-    completers::filename,
+    completers::repeating_filenames,
 ]);
 
 pub const TYPABLE_COMMAND_LIST: &[TypableCommand] = &[

helix-term/src/ui/mod.rs

@@ -371,8 +371,8 @@ fn directory_content(path: &Path) -> Result<Vec<(PathBuf, bool)>, std::io::Error
 pub mod completers {
     use super::Utf8PathBuf;
     use crate::ui::prompt::Completion;
+    use helix_core::command_line::{self, Token, Tokenizer};
     use helix_core::fuzzy::fuzzy_match;
-    use helix_core::shellwords::Shellwords;
     use helix_core::syntax::LanguageServerFeature;
     use helix_view::document::SCRATCH_BUFFER_NAME;
     use helix_view::theme;
@@ -709,19 +709,46 @@ pub mod completers {
             .collect()
     }
 
-    pub fn shell(editor: &Editor, input: &str) -> Vec<Completion> {
+    fn get_last_argument(input: &str) -> Option<Token> {
-        let shellwords = Shellwords::from(input);
+        let tokenizer = Tokenizer::new(input, false);
-        let words = shellwords.words();
+        let last = tokenizer.last()?;
 
-        if words.len() > 1 || shellwords.ends_with_whitespace() {
+        Some(last.unwrap())
-            let offset = words[0].len() + 1;
+    }
-            // Theoretically one could now parse bash completion scripts, but filename should suffice for now.
+
-            let mut completions = filename(editor, &input[offset..]);
+    /// This expects input to be a raw string of arguments, because this is what Signature's raw_after does.
-            for completion in completions.iter_mut() {
+    pub fn repeating_filenames(editor: &Editor, input: &str) -> Vec<Completion> {
-                completion.0.start += offset;
+        let Some(token) = get_last_argument(input) else {
-            }
+            return Vec::new();
-            return completions;
+        };
+
+        let offset = token.content_start;
+
+        // Theoretically one could now parse bash completion scripts, but filename should suffice for now.
+        let mut completions = filename(editor, &input[offset..]);
+        for completion in completions.iter_mut() {
+            completion.0.start += offset;
         }
-        program(editor, input)
+        completions
+    }
+
+    pub fn shell(editor: &Editor, input: &str) -> Vec<Completion> {
+        let (_, _, complete_command) = command_line::split(input);
+
+        if complete_command {
+            return program(editor, input);
+        }
+
+        let Some(token) = get_last_argument(input) else {
+            return Vec::new();
+        };
+
+        let mut completions = repeating_filenames(editor, &token.content);
+
+        for completion in completions.iter_mut() {
+            completion.0.start += token.content_start;
+        }
+
+        completions
     }
 }