Set match_indices for fuzzy-matched suggestions

ysthakur · ysthakur · commit 1a090d14da88 · 2025-10-20T00:17:57.000-04:00
diff --git a/crates/nu-cli/src/completions/attribute_completions.rs b/crates/nu-cli/src/completions/attribute_completions.rs
@@ -44,7 +44,7 @@ impl Completer for AttributeCompletion {
             });
         }
 
-        matcher.results()
+        matcher.suggestion_results()
     }
 }
 
@@ -80,6 +80,6 @@ impl Completer for AttributableCompletion {
             });
         }
 
-        matcher.results()
+        matcher.suggestion_results()
     }
 }
diff --git a/crates/nu-cli/src/completions/cell_path_completions.rs b/crates/nu-cli/src/completions/cell_path_completions.rs
@@ -72,7 +72,7 @@ impl Completer for CellPathCompletion<'_> {
         for suggestion in get_suggestions_by_value(&value, current_span) {
             matcher.add_semantic_suggestion(suggestion);
         }
-        matcher.results()
+        matcher.suggestion_results()
     }
 }
 
diff --git a/crates/nu-cli/src/completions/command_completions.rs b/crates/nu-cli/src/completions/command_completions.rs
@@ -146,11 +146,12 @@ impl Completer for CommandCompletion {
         };
 
         let mut res = Vec::new();
-        for cmd_name in matcher.results() {
-            if let Some(sugg) = internal_suggs
+        for (cmd_name, indices) in matcher.results() {
+            if let Some(mut sugg) = internal_suggs
                 .remove(&cmd_name)
                 .or_else(|| external_suggs.remove(&cmd_name))
             {
+                sugg.suggestion.match_indices = indices;
                 res.push(sugg);
             }
         }
diff --git a/crates/nu-cli/src/completions/completion_common.rs b/crates/nu-cli/src/completions/completion_common.rs
@@ -123,7 +123,7 @@ fn complete_rec(
 
     if has_more {
         let mut completions = vec![];
-        for built in matcher.results() {
+        for (built, _) in matcher.results() {
             completions.extend(complete_rec(
                 &partial[1..],
                 &[built],
@@ -135,7 +135,11 @@ fn complete_rec(
         }
         completions
     } else {
-        matcher.results()
+        matcher
+            .results()
+            .into_iter()
+            .map(|(built, _)| built)
+            .collect()
     }
 }
 
diff --git a/crates/nu-cli/src/completions/completion_options.rs b/crates/nu-cli/src/completions/completion_options.rs
@@ -48,8 +48,8 @@ enum State<T> {
     Fuzzy {
         matcher: Matcher,
         atom: Atom,
-        /// Holds (haystack, item, score)
-        items: Vec<(String, T, u16)>,
+        /// Holds (haystack, item, score, match_indices)
+        items: Vec<(String, T, u16, Vec<usize>)>,
     },
 }
 
@@ -161,7 +161,13 @@ impl<T> NuMatcher<'_, T> {
                     return false;
                 };
                 if let Some(item) = item {
-                    items.push((haystack.to_string(), item, score));
+                    let indices = indices
+                        .iter()
+                        .map(|i| {
+                            usize::try_from(*i).expect("should be on at least a 32-bit system")
+                        })
+                        .collect();
+                    items.push((haystack.to_string(), item, score, indices));
                 }
                 true
             }
@@ -180,10 +186,9 @@ impl<T> NuMatcher<'_, T> {
         self.matches_aux(haystack, None)
     }
 
-    /// Get all the items that matched (sorted)
-    pub fn results(self) -> Vec<T> {
-        match self.state {
-            State::Prefix { mut items, .. } | State::Substring { mut items, .. } => {
+    fn sort(&mut self) {
+        match &mut self.state {
+            State::Prefix { items, .. } | State::Substring { items, .. } => {
                 items.sort_by(|(haystack1, _), (haystack2, _)| {
                     let cmp_sensitive = haystack1.cmp(haystack2);
                     if self.options.case_sensitive {
@@ -195,26 +200,33 @@ impl<T> NuMatcher<'_, T> {
                             .then(cmp_sensitive)
                     }
                 });
-                items.into_iter().map(|(_, item)| item).collect::<Vec<_>>()
             }
-            State::Fuzzy { mut items, .. } => {
-                match self.options.sort {
-                    CompletionSort::Alphabetical => {
-                        items.sort_by(|(haystack1, _, _), (haystack2, _, _)| {
-                            haystack1.cmp(haystack2)
-                        });
-                    }
-                    CompletionSort::Smart => {
-                        items.sort_by(|(haystack1, _, score1), (haystack2, _, score2)| {
-                            score2.cmp(score1).then(haystack1.cmp(haystack2))
-                        });
-                    }
+            State::Fuzzy { items, .. } => match self.options.sort {
+                CompletionSort::Alphabetical => {
+                    items.sort_by(|(haystack1, _, _, _), (haystack2, _, _, _)| {
+                        haystack1.cmp(haystack2)
+                    });
                 }
-                items
-                    .into_iter()
-                    .map(|(_, item, _)| item)
-                    .collect::<Vec<_>>()
-            }
+                CompletionSort::Smart => {
+                    items.sort_by(|(haystack1, _, score1, _), (haystack2, _, score2, _)| {
+                        score2.cmp(score1).then(haystack1.cmp(haystack2))
+                    });
+                }
+            },
+        }
+    }
+
+    pub fn results(mut self) -> Vec<(T, Option<Vec<usize>>)> {
+        self.sort();
+        match self.state {
+            State::Prefix { items, .. } | State::Substring { items, .. } => items
+                .into_iter()
+                .map(|(_, item)| (item, None))
+                .collect::<Vec<_>>(),
+            State::Fuzzy { items, .. } => items
+                .into_iter()
+                .map(|(_, item, _, indices)| (item, Some(indices)))
+                .collect::<Vec<_>>(),
         }
     }
 }
@@ -224,6 +236,17 @@ impl NuMatcher<'_, SemanticSuggestion> {
         let value = sugg.suggestion.value.to_string();
         self.add(value, sugg)
     }
+
+    /// Get all the items that matched (sorted)
+    pub fn suggestion_results(self) -> Vec<SemanticSuggestion> {
+        self.results()
+            .into_iter()
+            .map(|(mut sugg, indices)| {
+                sugg.suggestion.match_indices = indices;
+                sugg
+            })
+            .collect()
+    }
 }
 
 impl From<CompletionAlgorithm> for MatchAlgorithm {
@@ -311,10 +334,11 @@ mod test {
         };
         let mut matcher = NuMatcher::new(needle, &options);
         matcher.add(haystack, haystack);
+        let results: Vec<_> = matcher.results().iter().map(|r| r.0).collect();
         if should_match {
-            assert_eq!(vec![haystack], matcher.results());
+            assert_eq!(vec![haystack], results);
         } else {
-            assert_ne!(vec![haystack], matcher.results());
+            assert_ne!(vec![haystack], results);
         }
     }
 
@@ -329,7 +353,14 @@ mod test {
             matcher.add(item, item);
         }
         // Sort by score, then in alphabetical order
-        assert_eq!(vec!["fob", "foo bar", "foo/bar"], matcher.results());
+        assert_eq!(
+            vec![
+                ("fob", Some(vec![0, 1, 2])),
+                ("foo bar", Some(vec![0, 1, 4])),
+                ("foo/bar", Some(vec![0, 1, 4]))
+            ],
+            matcher.results()
+        );
     }
 
     #[test]
@@ -347,6 +378,12 @@ mod test {
             matcher.add(item, item);
         }
         // Make sure the spaces are respected
-        assert_eq!(vec!["'i love spaces' so much"], matcher.results());
+        assert_eq!(
+            vec![(
+                "'i love spaces' so much",
+                Some(vec![0, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15])
+            )],
+            matcher.results()
+        );
     }
 }
diff --git a/crates/nu-cli/src/completions/custom_completions.rs b/crates/nu-cli/src/completions/custom_completions.rs
@@ -158,7 +158,7 @@ impl<T: Completer> Completer for CustomCompletion<T> {
             for sugg in suggestions {
                 matcher.add_semantic_suggestion(sugg);
             }
-            matcher.results()
+            matcher.suggestion_results()
         } else {
             suggestions
                 .into_iter()
diff --git a/crates/nu-cli/src/completions/dotnu_completions.rs b/crates/nu-cli/src/completions/dotnu_completions.rs
@@ -87,7 +87,13 @@ impl Completer for DotNuCompletion {
                     );
                 }
             }
-            completions.extend(matcher.results());
+            completions.extend(
+                matcher
+                    .results()
+                    .into_iter()
+                    .map(|(s, _)| s)
+                    .collect::<Vec<_>>(),
+            );
         }
 
         // Fetch the files
diff --git a/crates/nu-cli/src/completions/flag_completions.rs b/crates/nu-cli/src/completions/flag_completions.rs
@@ -53,6 +53,6 @@ impl Completer for FlagCompletion {
             }
             add_suggestion(format!("--{}", named.long), named.desc.clone());
         }
-        matcher.results()
+        matcher.suggestion_results()
     }
 }
diff --git a/crates/nu-cli/src/completions/operator_completions.rs b/crates/nu-cli/src/completions/operator_completions.rs
@@ -274,6 +274,6 @@ impl Completer for OperatorCompletion<'_> {
                 kind: Some(SuggestionKind::Operator),
             });
         }
-        matcher.results()
+        matcher.suggestion_results()
     }
 }
diff --git a/crates/nu-cli/src/completions/static_completions.rs b/crates/nu-cli/src/completions/static_completions.rs
@@ -59,6 +59,6 @@ impl Completer for StaticCompletion {
             }
         }
 
-        matcher.results()
+        matcher.suggestion_results()
     }
 }
diff --git a/crates/nu-cli/src/completions/variable_completions.rs b/crates/nu-cli/src/completions/variable_completions.rs
@@ -70,6 +70,6 @@ impl Completer for VariableCompletion {
             });
         }
 
-        matcher.results()
+        matcher.suggestion_results()
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -44,7 +44,7 @@ impl Completer for AttributeCompletion {`
`44`	`44`	`});`
`45`	`45`	`}`
`46`	`46`
`47`		`- matcher.results()`
	`47`	`+ matcher.suggestion_results()`
`48`	`48`	`}`
`49`	`49`	`}`
`50`	`50`
`@@ -80,6 +80,6 @@ impl Completer for AttributableCompletion {`
`80`	`80`	`});`
`81`	`81`	`}`
`82`	`82`
`83`		`- matcher.results()`
	`83`	`+ matcher.suggestion_results()`
`84`	`84`	`}`
`85`	`85`	`}`
Original file line number	Diff line number	Diff line change
`@@ -72,7 +72,7 @@ impl Completer for CellPathCompletion<'_> {`
`72`	`72`	`for suggestion in get_suggestions_by_value(&value, current_span) {`
`73`	`73`	`matcher.add_semantic_suggestion(suggestion);`
`74`	`74`	`}`
`75`		`- matcher.results()`
	`75`	`+ matcher.suggestion_results()`
`76`	`76`	`}`
`77`	`77`	`}`
`78`	`78`
Original file line number	Diff line number	Diff line change
`@@ -146,11 +146,12 @@ impl Completer for CommandCompletion {`
`146`	`146`	`};`
`147`	`147`
`148`	`148`	`let mut res = Vec::new();`
`149`		`- for cmd_name in matcher.results() {`
`150`		`- if let Some(sugg) = internal_suggs`
	`149`	`+ for (cmd_name, indices) in matcher.results() {`
	`150`	`+ if let Some(mut sugg) = internal_suggs`
`151`	`151`	`.remove(&cmd_name)`
`152`	`152`	`.or_else(\|\| external_suggs.remove(&cmd_name))`
`153`	`153`	`{`
	`154`	`+ sugg.suggestion.match_indices = indices;`
`154`	`155`	`res.push(sugg);`
`155`	`156`	`}`
`156`	`157`	`}`
Original file line number	Diff line number	Diff line change
`@@ -123,7 +123,7 @@ fn complete_rec(`
`123`	`123`
`124`	`124`	`if has_more {`
`125`	`125`	`let mut completions = vec![];`
`126`		`- for built in matcher.results() {`
	`126`	`+ for (built, _) in matcher.results() {`
`127`	`127`	`completions.extend(complete_rec(`
`128`	`128`	`&partial[1..],`
`129`	`129`	`&[built],`
`@@ -135,7 +135,11 @@ fn complete_rec(`
`135`	`135`	`}`
`136`	`136`	`completions`
`137`	`137`	`} else {`
`138`		`- matcher.results()`
	`138`	`+ matcher`
	`139`	`+ .results()`
	`140`	`+ .into_iter()`
	`141`	`+ .map(\|(built, _)\| built)`
	`142`	`+ .collect()`
`139`	`143`	`}`
`140`	`144`	`}`
`141`	`145`
Original file line number	Diff line number	Diff line change
`@@ -158,7 +158,7 @@ impl<T: Completer> Completer for CustomCompletion<T> {`
`158`	`158`	`for sugg in suggestions {`
`159`	`159`	`matcher.add_semantic_suggestion(sugg);`
`160`	`160`	`}`
`161`		`- matcher.results()`
	`161`	`+ matcher.suggestion_results()`
`162`	`162`	`} else {`
`163`	`163`	`suggestions`
`164`	`164`	`.into_iter()`
Original file line number	Diff line number	Diff line change
`@@ -87,7 +87,13 @@ impl Completer for DotNuCompletion {`
`87`	`87`	`);`
`88`	`88`	`}`
`89`	`89`	`}`
`90`		`- completions.extend(matcher.results());`
	`90`	`+ completions.extend(`
	`91`	`+ matcher`
	`92`	`+ .results()`
	`93`	`+ .into_iter()`
	`94`	`+ .map(\|(s, _)\| s)`
	`95`	`+ .collect::<Vec<_>>(),`
	`96`	`+ );`
`91`	`97`	`}`
`92`	`98`
`93`	`99`	`// Fetch the files`
Original file line number	Diff line number	Diff line change
`@@ -53,6 +53,6 @@ impl Completer for FlagCompletion {`
`53`	`53`	`}`
`54`	`54`	`add_suggestion(format!("--{}", named.long), named.desc.clone());`
`55`	`55`	`}`
`56`		`- matcher.results()`
	`56`	`+ matcher.suggestion_results()`
`57`	`57`	`}`
`58`	`58`	`}`
Original file line number	Diff line number	Diff line change
`@@ -274,6 +274,6 @@ impl Completer for OperatorCompletion<'_> {`
`274`	`274`	`kind: Some(SuggestionKind::Operator),`
`275`	`275`	`});`
`276`	`276`	`}`
`277`		`- matcher.results()`
	`277`	`+ matcher.suggestion_results()`
`278`	`278`	`}`
`279`	`279`	`}`
Original file line number	Diff line number	Diff line change
`@@ -59,6 +59,6 @@ impl Completer for StaticCompletion {`
`59`	`59`	`}`
`60`	`60`	`}`
`61`	`61`
`62`		`- matcher.results()`
	`62`	`+ matcher.suggestion_results()`
`63`	`63`	`}`
`64`	`64`	`}`