fix: pass exising test cases

Author: blindFS

crates/nu-cli/src/completions/base.rs

@@ -20,7 +20,7 @@ pub trait Completer {
     ) -> Vec<SemanticSuggestion>;
 }
 
-#[derive(Clone, Debug, Default, PartialEq)]
+#[derive(Debug, Default, PartialEq)]
 pub struct SemanticSuggestion {
     pub suggestion: Suggestion,
     pub kind: Option<SuggestionKind>,

crates/nu-cli/src/completions/command_completions.rs

@@ -126,7 +126,7 @@ impl Completer for CommandCompletion {
             );
         }
 
-        let external_suggs = if self.find_externals {
+        let mut external_suggs = if self.find_externals {
             self.external_command_completion(
                 working_set,
                 sugg_span,
@@ -137,10 +137,15 @@ impl Completer for CommandCompletion {
             HashMap::new()
         };
 
-        internal_suggs
-            .values()
-            .chain(external_suggs.values())
-            .cloned()
-            .collect()
+        let mut res = Vec::new();
+        for cmd_name in matcher.results() {
+            if let Some(sugg) = internal_suggs
+                .remove(&cmd_name)
+                .or_else(|| external_suggs.remove(&cmd_name))
+            {
+                res.push(sugg);
+            }
+        }
+        res
     }
 }

crates/nu-cli/src/completions/completer.rs

@@ -75,6 +75,27 @@ fn strip_placeholder<'a>(working_set: &'a StateWorkingSet, span: &Span) -> (Span
     (new_span, prefix)
 }
 
+/// Given a span with noise,
+/// 1. Call `rsplit` to get the last token
+/// 2. Strip the last placeholder from the token
+fn strip_placeholder_with_rsplit<'a>(
+    working_set: &'a StateWorkingSet,
+    span: &Span,
+    predicate: impl FnMut(&u8) -> bool,
+) -> (Span, &'a [u8]) {
+    let flag_equals_str = working_set.get_span_contents(*span);
+    let mut true_prefix = flag_equals_str
+        .rsplit(predicate)
+        .next()
+        .unwrap_or(flag_equals_str);
+    let true_start = span.end.saturating_sub(true_prefix.len());
+    if !true_prefix.is_empty() {
+        true_prefix = &true_prefix[..true_prefix.len() - 1];
+    }
+    let true_end = true_start + true_prefix.len();
+    (Span::new(true_start, true_end), true_prefix)
+}
+
 #[derive(Clone)]
 pub struct NuCompleter {
     engine_state: Arc<EngineState>,
@@ -267,6 +288,8 @@ impl NuCompleter {
             return vec![];
         };
 
+        let mut suggestions: Vec<SemanticSuggestion> = vec![];
+
         match &element_expression.expr {
             Expr::Var(_) => {
                 return self.variable_names_completion_helper(
@@ -314,36 +337,33 @@ impl NuCompleter {
                     }
                 }
             }
+            // NOTE: user defined internal commands can have any length
+            // e.g. `def "foo -f --ff bar"`, complete by line text
+            // instead of relying on the parsing result in that case
+            Expr::Call(_) | Expr::ExternalCall(_, _) => {
+                suggestions.extend(self.command_completion_helper(
+                    &working_set,
+                    element_expression.span,
+                    fake_offset,
+                    true,
+                ))
+            }
+            _ => (),
+        }
+
+        // unfinished argument completion for commands
+        match &element_expression.expr {
             Expr::Call(call) => {
-                // at command head, e.g. `l<tab>`
-                // still not sure user want internal or external
-                // complete both internal and external commands
-                if call.head.contains(pos) {
-                    return self.command_completion_helper(
-                        &working_set,
-                        call.head,
-                        fake_offset,
-                        true,
-                    );
-                }
-                for (i, arg) in call.arguments.iter().enumerate() {
+                for arg in call.arguments.iter() {
                     let span = arg.span();
                     if span.contains(pos) {
                         // if customized completion specified, it has highest priority
                         if let Some(decl_id) = arg.expr().and_then(|e| e.custom_completion) {
                             // for `--foo <tab>` and `--foo=<tab>`, the arg span should be trimmed
                             let (new_span, prefix) = if matches!(arg, Argument::Named(_)) {
-                                let flag_equals_str = working_set.get_span_contents(span);
-                                let mut true_prefix = flag_equals_str
-                                    .rsplit(|c| *c == b'=' || *c == b' ')
-                                    .next()
-                                    .unwrap_or(flag_equals_str);
-                                let true_start = span.end.saturating_sub(true_prefix.len());
-                                if !true_prefix.is_empty() {
-                                    true_prefix = &true_prefix[..true_prefix.len() - 1];
-                                }
-                                let true_end = true_start + true_prefix.len();
-                                (Span::new(true_start, true_end), true_prefix)
+                                strip_placeholder_with_rsplit(&working_set, &span, |b| {
+                                    *b == b'=' || *b == b' '
+                                })
                             } else {
                                 strip_placeholder(&working_set, &span)
                             };
@@ -355,14 +375,15 @@ impl NuCompleter {
                                 FileCompletion::new(),
                             );
 
-                            return self.process_completion(
+                            suggestions.extend(self.process_completion(
                                 &mut completer,
                                 &working_set,
                                 prefix,
                                 new_span,
                                 fake_offset,
                                 pos,
-                            );
+                            ));
+                            break;
                         }
                         // complete module file/directory
                         // TODO: if module file already specified,
@@ -374,7 +395,7 @@ impl NuCompleter {
                             || command_head == b"source-env"
                         {
                             let mut completer = DotNuCompletion::new();
-                            let (new_span, prefix) = strip_placeholder(&working_set, &call.head);
+                            let (new_span, prefix) = strip_placeholder(&working_set, &span);
                             return self.process_completion(
                                 &mut completer,
                                 &working_set,
@@ -384,89 +405,55 @@ impl NuCompleter {
                                 pos,
                             );
                         }
-                        // if at the first arguments, e.g. `help co<tab>`
-                        // still need to complete internal commands if any
-                        if i == 0 {
-                            let subcommands = self.command_completion_helper(
-                                &working_set,
-                                call.head.merge(span),
-                                offset,
-                                false,
-                            );
-                            if !subcommands.is_empty() {
-                                return subcommands;
-                            }
-                        }
                         // normal arguments completion
-                        match arg {
+                        suggestions.extend(match arg {
                             // flags
                             Argument::Named(_) => {
                                 let mut flag_completions = FlagCompletion {
                                     decl_id: call.decl_id,
                                 };
                                 let (new_span, prefix) = strip_placeholder(&working_set, &span);
-                                return self.process_completion(
+                                self.process_completion(
                                     &mut flag_completions,
                                     &working_set,
                                     prefix,
                                     new_span,
                                     fake_offset,
                                     pos,
-                                );
+                                )
                             }
                             // complete according to expression type
-                            Argument::Positional(expr) => {
-                                return self.argument_completion_helper(
-                                    expr,
-                                    &working_set,
-                                    span,
-                                    fake_offset,
-                                );
-                            }
+                            Argument::Positional(expr) => self.argument_completion_helper(
+                                expr,
+                                &working_set,
+                                span,
+                                fake_offset,
+                            ),
                             Argument::Unknown(_) => {
                                 let (new_span, prefix) = strip_placeholder(&working_set, &span);
                                 if prefix.starts_with(b"-") {
                                     let mut flag_completions = FlagCompletion {
                                         decl_id: call.decl_id,
                                     };
-                                    return self.process_completion(
+                                    self.process_completion(
                                         &mut flag_completions,
                                         &working_set,
                                         prefix,
                                         new_span,
                                         fake_offset,
                                         pos,
-                                    );
+                                    )
                                 } else {
-                                    let mut completer = FileCompletion::new();
-                                    return self.process_completion(
-                                        &mut completer,
-                                        &working_set,
-                                        prefix,
-                                        new_span,
-                                        offset,
-                                        0,
-                                    );
+                                    vec![]
                                 }
                             }
-                            _ => (),
-                        };
+                            _ => vec![],
+                        });
                         break;
                     }
                 }
             }
             Expr::ExternalCall(head, arguments) => {
-                // at command head, e.g. `l<tab>`
-                // still not sure user want internal or external
-                // complete both internal and external commands
-                if head.span.contains(pos) {
-                    return self.command_completion_helper(
-                        &working_set,
-                        head.span,
-                        fake_offset,
-                        true,
-                    );
-                }
                 for (i, arg) in arguments.iter().enumerate() {
                     let span = arg.expr().span;
                     if span.contains(pos) {
@@ -504,19 +491,8 @@ impl NuCompleter {
                                 fake_offset,
                                 Span::new(span.start, span.end.saturating_sub(1)),
                             ) {
-                                return external_result;
-                            } else {
-                                // fallback to file completion
-                                let mut file_completer = FileCompletion::new();
-                                let (new_span, prefix) = strip_placeholder(&working_set, &span);
-                                return self.process_completion(
-                                    &mut file_completer,
-                                    &working_set,
-                                    prefix,
-                                    new_span,
-                                    fake_offset,
-                                    pos,
-                                );
+                                suggestions.extend(external_result);
+                                return suggestions;
                             }
                         }
                         break;
@@ -526,7 +502,22 @@ impl NuCompleter {
             _ => (),
         }
 
-        vec![]
+        if suggestions.is_empty() {
+            let mut file_completions = FileCompletion::new();
+            let (new_span, prefix) =
+                strip_placeholder_with_rsplit(&working_set, &element_expression.span, |c| {
+                    *c == b' '
+                });
+            suggestions.extend(self.process_completion(
+                &mut file_completions,
+                &working_set,
+                prefix,
+                new_span,
+                fake_offset,
+                pos,
+            ));
+        }
+        suggestions
     }
 }