Refactor completion relevance scoring (pr suggestions)

Author: mustakimali

crates/ide-completion/src/item.rs

@@ -219,8 +219,6 @@ pub struct CompletionRelevanceFn {
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub enum CompletionRelevanceFnType {
     Other,
-    /// Returns a type that is expected in this context
-    ReturnsExpectedType,
     /// Returns the Self type of the impl/trait
     DirectConstructor,
     /// Returns something that indirectly constructs the `Self` type of the impl/trait e.g. `Result<Self, ()>`, `Option<Self>`
@@ -253,7 +251,7 @@ impl CompletionRelevance {
             postfix_match,
             is_definite,
             is_item_from_notable_trait,
-            function: associated_fn,
+            function,
         } = self;
 
         // lower rank private things
@@ -299,23 +297,29 @@ impl CompletionRelevance {
             score += 10;
         }
 
-        score += associated_fn
+        score += function
             .map(|asf| {
-                let mut score = match asf.ty {
-                    CompletionRelevanceFnType::ReturnsExpectedType => 20,
+                let mut fn_score = match asf.ty {
                     CompletionRelevanceFnType::DirectConstructor => 15,
                     CompletionRelevanceFnType::Builder => 10,
                     CompletionRelevanceFnType::Constructor => 5,
                     CompletionRelevanceFnType::Other => 0,
                 };
 
-                // Prefer functions with no arguments, then functions with self arguments
-                if score > 0 {
-                    score += if !asf.has_args { 2 } else { 0 };
-                    score -= if asf.has_self_arg { score - 1 } else { 0 };
+                // When a fn is bumped due to return type:
+                // Bump Constructor or Builder methods with no arguments,
+                // over them tha with self arguments
+                if fn_score > 0 {
+                    if !asf.has_args {
+                        // bump associated functions
+                        fn_score += 1;
+                    } else if asf.has_self_arg {
+                        // downgrade methods (below Constructor)
+                        fn_score = 1;
+                    }
                 }
 
-                score
+                fn_score
             })
             .unwrap_or_default();
 

crates/ide-completion/src/render.rs

@@ -2085,48 +2085,6 @@ fn test() {
             "#]],
         );
 
-        // Expected 1
-        check_relevance(
-            r#"
-struct Random;
-
-impl Random {
-    fn get_i32(&self) -> i32 {}
-    fn get_string(&self) -> String {}
-}
-
-fn test() {
-    let r = Random;
-    let name: String = r.$0;
-}
-"#,
-            expect![[r#"
-                me get_string() [type]
-                me get_i32() [type_could_unify]
-            "#]],
-        );
-
-        // Expected 2
-        check_relevance(
-            r#"
-struct Random;
-
-impl Random {
-    fn get_i32(&self) -> i32 {}
-    fn get_string(&self) -> String {}
-}
-
-fn age() -> i32 {
-    let r = Random;
-    r.$0
-}
-"#,
-            expect![[r#"
-                me get_i32() [type]
-                me get_string() [type_could_unify]
-            "#]],
-        );
-
         // Generic 1
         check_relevance(
             r#"

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

@@ -173,10 +173,9 @@ fn compute_associated_fn(
         return None;
     }
 
-    let has_args = !func.assoc_fn_params(db).is_empty();
+    let has_args = func.num_params(db) > 0;
     let ret_type = func.ret_type(db);
     let has_self_arg = func.self_param(db).is_some();
-    let ret_unit_type = ret_type.is_unit();
     let self_type = match func_kind {
         FuncKind::Function(PathCompletionCtx {
             qualified: Qualified::With { path, .. }, ..
@@ -196,14 +195,11 @@ fn compute_associated_fn(
         })
         .unwrap_or_else(|| (false, false));
 
-    let ty = if !returns_self
-        && !ret_unit_type
-        && ctx.completion.expected_type.as_ref() == Some(&ret_type)
+    let ty = if ret_type
+        .as_adt()
+        .and_then(|adt| adt.name(db).as_str().map(|name| name.ends_with("Builder")))
+        .unwrap_or(false)
     {
-        // impl Foo { fn baz(&self) -> u32 { 0 } }
-        // let _: u32 = foo.$0; // baz is preferred as it returns expected u32
-        CompletionRelevanceFnType::ReturnsExpectedType
-    } else if ret_type.display(db).to_string().ends_with("Builder") {
         // fn([..]) -> [..]Builder
         CompletionRelevanceFnType::Builder
     } else if returns_self_wrapped {