feat: always prefer postfix snippets if there's exact textual match

Note that, while we don't currently have a fuzzy-matching score, it
makes sense to special-case postfix templates -- it's very annoying when
`.not()` gets sorted before `.not`. We might want to move this infra to
fuzzy matching, once we have that!

crates/ide_completion/src/completions/postfix.rs

@@ -15,7 +15,7 @@ use crate::{
     context::CompletionContext,
     item::{Builder, CompletionKind},
     patterns::ImmediateLocation,
-    CompletionItem, CompletionItemKind, Completions,
+    CompletionItem, CompletionItemKind, CompletionRelevance, Completions,
 };
 
 pub(crate) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
@@ -299,6 +299,12 @@ fn postfix_snippet(
     };
     let mut item = CompletionItem::new(CompletionKind::Postfix, ctx.source_range(), label);
     item.detail(detail).kind(CompletionItemKind::Snippet).snippet_edit(cap, edit);
+    if ctx.original_token.text() == label {
+        let mut relevance = CompletionRelevance::default();
+        relevance.exact_postfix_snippet_match = true;
+        item.set_relevance(relevance);
+    }
+
     item
 }
 

crates/ide_completion/src/item.rs

@@ -144,6 +144,15 @@ pub struct CompletionRelevance {
     /// }
     /// ```
     pub is_local: bool,
+    /// This is set in cases like these:
+    ///
+    /// ```
+    /// (a > b).not$0
+    /// ```
+    ///
+    /// Basically, we want to guarantee that postfix snippets always takes
+    /// precedence over everything else.
+    pub exact_postfix_snippet_match: bool,
 }
 
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
@@ -194,7 +203,9 @@ impl CompletionRelevance {
         if self.is_local {
             score += 1;
         }
-
+        if self.exact_postfix_snippet_match {
+            score += 100;
+        }
         score
     }
 
@@ -598,6 +609,13 @@ mod tests {
                 exact_name_match: true,
                 type_match: Some(CompletionRelevanceTypeMatch::Exact),
                 is_local: true,
+                ..CompletionRelevance::default()
+            }],
+            vec![CompletionRelevance {
+                exact_name_match: false,
+                type_match: None,
+                is_local: false,
+                exact_postfix_snippet_match: true,
             }],
         ];
 

crates/ide_completion/src/render.rs

@@ -339,32 +339,22 @@ mod tests {
         CompletionKind, CompletionRelevance,
     };
 
+    #[track_caller]
     fn check(ra_fixture: &str, expect: Expect) {
         let actual = do_completion(ra_fixture, CompletionKind::Reference);
         expect.assert_debug_eq(&actual);
     }
 
+    #[track_caller]
     fn check_relevance(ra_fixture: &str, expect: Expect) {
-        fn display_relevance(relevance: CompletionRelevance) -> String {
-            let relevance_factors = vec![
-                (relevance.type_match == Some(CompletionRelevanceTypeMatch::Exact), "type"),
-                (
-                    relevance.type_match == Some(CompletionRelevanceTypeMatch::CouldUnify),
-                    "type_could_unify",
-                ),
-                (relevance.exact_name_match, "name"),
-                (relevance.is_local, "local"),
-            ]
-            .into_iter()
-            .filter_map(|(cond, desc)| if cond { Some(desc) } else { None })
-            .join("+");
-
-            format!("[{}]", relevance_factors)
-        }
+        check_relevance_for_kinds(&[CompletionKind::Reference], ra_fixture, expect)
+    }
 
+    #[track_caller]
+    fn check_relevance_for_kinds(kinds: &[CompletionKind], ra_fixture: &str, expect: Expect) {
         let actual = get_all_items(TEST_CONFIG, ra_fixture)
             .into_iter()
-            .filter(|it| it.completion_kind == CompletionKind::Reference)
+            .filter(|it| kinds.contains(&it.completion_kind))
             .flat_map(|it| {
                 let mut items = vec![];
 
@@ -384,6 +374,24 @@ mod tests {
             .collect::<String>();
 
         expect.assert_eq(&actual);
+
+        fn display_relevance(relevance: CompletionRelevance) -> String {
+            let relevance_factors = vec![
+                (relevance.type_match == Some(CompletionRelevanceTypeMatch::Exact), "type"),
+                (
+                    relevance.type_match == Some(CompletionRelevanceTypeMatch::CouldUnify),
+                    "type_could_unify",
+                ),
+                (relevance.exact_name_match, "name"),
+                (relevance.is_local, "local"),
+                (relevance.exact_postfix_snippet_match, "snippet"),
+            ]
+            .into_iter()
+            .filter_map(|(cond, desc)| if cond { Some(desc) } else { None })
+            .join("+");
+
+            format!("[{}]", relevance_factors)
+        }
     }
 
     #[test]
@@ -528,6 +536,7 @@ fn main() { let _: m::Spam = S$0 }
                                 Exact,
                             ),
                             is_local: false,
+                            exact_postfix_snippet_match: false,
                         },
                         trigger_call_info: true,
                     },
@@ -556,6 +565,7 @@ fn main() { let _: m::Spam = S$0 }
                                 Exact,
                             ),
                             is_local: false,
+                            exact_postfix_snippet_match: false,
                         },
                     },
                     CompletionItem {
@@ -649,6 +659,7 @@ fn foo() { A { the$0 } }
                                 CouldUnify,
                             ),
                             is_local: false,
+                            exact_postfix_snippet_match: false,
                         },
                     },
                 ]
@@ -1339,4 +1350,44 @@ fn foo() {
             "#]],
         );
     }
+
+    #[test]
+    fn postfix_completion_relevance() {
+        check_relevance_for_kinds(
+            &[CompletionKind::Postfix, CompletionKind::Magic],
+            r#"
+mod ops {
+    pub trait Not {
+        type Output;
+        fn not(self) -> Self::Output;
+    }
+
+    impl Not for bool {
+        type Output = bool;
+        fn not(self) -> bool { if self { false } else { true }}
+    }
+}
+
+fn main() {
+    let _: bool = (9 > 2).not$0;
+}
+"#,
+            expect![[r#"
+                sn if []
+                sn while []
+                sn not [snippet]
+                sn ref []
+                sn refm []
+                sn match []
+                sn box []
+                sn ok []
+                sn err []
+                sn some []
+                sn dbg []
+                sn dbgr []
+                sn call []
+                me not() (ops::Not) [type_could_unify]
+            "#]],
+        );
+    }
 }