Prefer fuzzy score

Cargo.lock

@@ -4215,6 +4215,7 @@ dependencies = [
 name = "fuzzy"
 version = "0.1.0"
 dependencies = [
+ "fuzzy-matcher",
  "gpui",
  "util",
 ]

crates/editor/src/editor.rs

@@ -1105,17 +1105,10 @@ impl CompletionsMenu {
             // us into account when it's obviously a bad match.
 
             #[derive(PartialEq, Eq, PartialOrd, Ord)]
-            enum MatchScore<'a> {
-                Strong {
-                    sort_text: Option<&'a str>,
-                    score: Reverse<OrderedFloat<f64>>,
-                    sort_key: (usize, &'a str),
-                },
-                Weak {
-                    score: Reverse<OrderedFloat<f64>>,
-                    sort_text: Option<&'a str>,
-                    sort_key: (usize, &'a str),
-                },
+            struct MatchScore<'a> {
+                score: Reverse<OrderedFloat<f64>>,
+                sort_text: Option<&'a str>,
+                sort_key: (usize, &'a str),
             }
 
             let completion = &completions[mat.candidate_id];
@@ -1123,18 +1116,10 @@ impl CompletionsMenu {
             let sort_text = completion.lsp_completion.sort_text.as_deref();
             let score = Reverse(OrderedFloat(mat.score));
 
-            if mat.score >= 0.2 {
-                MatchScore::Strong {
-                    sort_text,
-                    score,
-                    sort_key,
-                }
-            } else {
-                MatchScore::Weak {
-                    score,
-                    sort_text,
-                    sort_key,
-                }
+            MatchScore {
+                sort_text,
+                score,
+                sort_key,
             }
         });
 

crates/fuzzy/Cargo.toml

@@ -13,5 +13,6 @@ path = "src/fuzzy.rs"
 doctest = false
 
 [dependencies]
+fuzzy-matcher = "0.3.7"
 gpui.workspace = true
 util.workspace = true

crates/fuzzy/src/strings.rs

@@ -116,7 +116,7 @@ pub async fn match_strings(
     if candidates.is_empty() || max_results == 0 {
         return Default::default();
     }
-
+    let og_query = query;
     if query.is_empty() {
         return candidates
             .iter()
@@ -141,35 +141,28 @@ pub async fn match_strings(
     let mut segment_results = (0..num_cpus)
         .map(|_| Vec::with_capacity(max_results.min(candidates.len())))
         .collect::<Vec<_>>();
-
+    let matcher = fuzzy_matcher::skim::SkimMatcherV2::default().ignore_case();
     executor
         .scoped(|scope| {
             for (segment_idx, results) in segment_results.iter_mut().enumerate() {
                 let cancel_flag = &cancel_flag;
+                let matcher = &matcher;
                 scope.spawn(async move {
                     let segment_start = cmp::min(segment_idx * segment_size, candidates.len());
                     let segment_end = cmp::min(segment_start + segment_size, candidates.len());
-                    let mut matcher = Matcher::new(
-                        query,
-                        lowercase_query,
-                        query_char_bag,
-                        smart_case,
-                        max_results,
-                    );
 
-                    matcher.match_candidates(
-                        &[],
-                        &[],
-                        candidates[segment_start..segment_end].iter(),
-                        results,
-                        cancel_flag,
-                        |candidate, score| StringMatch {
-                            candidate_id: candidate.id,
-                            score,
-                            positions: Vec::new(),
-                            string: candidate.string.to_string(),
-                        },
-                    );
+                    for candidate in &candidates[segment_start..segment_end] {
+                        use fuzzy_matcher::FuzzyMatcher;
+                        let score = matcher.fuzzy_match(&candidate.string, &og_query);
+                        if let Some(score) = score {
+                            results.push(StringMatch {
+                                candidate_id: candidate.id,
+                                score: score as f64,
+                                positions: vec![],
+                                string: candidate.string.to_owned(),
+                            })
+                        }
+                    }
                 });
             }
         })