Refactor completion relevance calculation

Author: mustakimali

crates/ide-completion/src/completions.rs

@@ -694,10 +694,6 @@ pub(super) fn complete_name_ref(
                     dot::complete_undotted_self(acc, ctx, path_ctx, expr_ctx);
                     item_list::complete_item_list_in_expr(acc, ctx, path_ctx, expr_ctx);
                     snippet::complete_expr_snippet(acc, ctx, path_ctx, expr_ctx);
-
-                    if matches!(ctx.token.kind(), syntax::SyntaxKind::COLON2) {
-                        bump_relevance_for_new_like_fns(acc);
-                    }
                 }
                 PathKind::Type { location } => {
                     r#type::complete_type_path(acc, ctx, path_ctx, location);
@@ -771,37 +767,3 @@ fn complete_patterns(
     pattern::complete_pattern(acc, ctx, pattern_ctx);
     record::complete_record_pattern_fields(acc, ctx, pattern_ctx);
 }
-
-/// Sort the suggestions with `new` like functions first.
-/// That means:
-/// fn with no param that returns itself
-/// fn with param that returns itself
-pub(crate) fn bump_relevance_for_new_like_fns(acc: &mut Completions) {
-    // ToDo: Ensure these fn returns Self
-    fn maybe_new(item: &CompletionItem) -> bool {
-        item.detail.as_ref().map(|d| d.starts_with("fn() -> ")).unwrap_or_default()
-    }
-    fn maybe_new_with_args(item: &CompletionItem) -> bool {
-        item.detail
-            .as_ref()
-            .map(|d| d.starts_with("fn(") && d.contains("->") && !d.contains("&self"))
-            .unwrap_or_default()
-    }
-
-    fn maybe_builder(item: &CompletionItem) -> bool {
-        item.detail
-            .as_ref()
-            .map(|d| d.starts_with("fn() -> ") && d.contains("Builder"))
-            .unwrap_or_default()
-    }
-
-    for item in acc.buf.iter_mut() {
-        if maybe_new(&item) {
-            item.bump_relevance_by(30);
-        } else if maybe_builder(&item) {
-            item.bump_relevance_by(20);
-        } else if maybe_new_with_args(&item) {
-            item.bump_relevance_by(10);
-        }
-    }
-}

crates/ide-completion/src/render.rs

@@ -17,7 +17,7 @@ use ide_db::{
     imports::import_assets::LocatedImport,
     RootDatabase, SnippetCap, SymbolKind,
 };
-use syntax::{AstNode, SmolStr, SyntaxKind, TextRange};
+use syntax::{AstNode, SmolStr, SyntaxKind, SyntaxToken, TextRange};
 use text_edit::TextEdit;
 
 use crate::{
@@ -72,6 +72,10 @@ impl<'a> RenderContext<'a> {
         self.completion.db
     }
 
+    fn token(&self) -> &SyntaxToken {
+        &self.completion.token
+    }
+
     fn source_range(&self) -> TextRange {
         self.completion.source_range()
     }
@@ -2033,33 +2037,6 @@ fn test() {
                 me foo(…) [type_could_unify]
             "#]],
         );
-
-        check_relevance(
-            r#"
-struct A;
-struct ABuilder;
-impl A {
-    fn foo(&self) {}
-    fn new_1(input: u32) -> A { A }
-    fn new_2() -> Self { A }
-    fn aaaabuilder() -> ABuilder { A }
-    fn test() {
-        Self::$0;
-    }
-}
-"#,
-            // preference:
-            // fn with no param that returns itself
-            // builder like fn
-            // fn with param that returns itself
-            expect![[r#"
-                fn new_2() []
-                fn aaaabuilder() []
-                fn new_1(…) []
-                me foo(…) []
-                fn test() []
-            "#]],
-        );
     }
 
     #[test]

crates/ide-completion/src/render/function.rs

@@ -105,6 +105,7 @@ fn render(
         },
         exact_name_match: compute_exact_name_match(completion, &call),
         is_op_method,
+        bonus_score: calculate_bonus(&ctx, func, db),
         ..ctx.completion_relevance()
     });
 
@@ -153,6 +154,33 @@ fn render(
     item
 }
 
+/// When typing `::` of a type, the preferred orderer is:
+/// * Constructors: new like functions to be able to create the type,
+/// * Constructors that take args: Any other function that creates Self
+/// * Builder Methods: any builder methods available
+/// * Regular methods
+fn calculate_bonus(ctx: &RenderContext<'_>, func: hir::Function, db: &dyn HirDatabase) -> u32 {
+    if ctx.token().kind() != syntax::SyntaxKind::COLON2 || func.self_param(db).is_some() {
+        return 0;
+    }
+
+    let mut bonus = 0;
+
+    let has_args = !func.assoc_fn_params(db).is_empty();
+    let ret_type = func.ret_type(db);
+    if !has_args && !ret_type.is_unit() {
+        // fn() -> A
+        bonus += 30;
+    } else if has_args && !ret_type.is_unit() {
+        // fn(..) -> A
+        bonus += 20;
+    } else if !has_args && ret_type.display(db).to_string().ends_with("Builder") {
+        // -> [..]Builder
+        bonus += 10;
+    }
+    bonus
+}
+
 pub(super) fn add_call_parens<'b>(
     builder: &'b mut Builder,
     ctx: &CompletionContext<'_>,
@@ -213,6 +241,7 @@ pub(super) fn add_call_parens<'b>(
 
         (snippet, "(…)")
     };
+
     builder.label(SmolStr::from_iter([&name, label_suffix])).insert_snippet(cap, snippet)
 }
 
@@ -256,6 +285,7 @@ fn detail(db: &dyn HirDatabase, func: hir::Function) -> String {
     if !ret_ty.is_unit() {
         format_to!(detail, " -> {}", ret_ty.display(db));
     }
+
     detail
 }