chore: tidy up

Author: mustakimali

crates/ide-completion/src/render.rs

@@ -2045,7 +2045,7 @@ fn main() {
     }
 
     #[test]
-    fn colon_complete_preferred_order_relevances() {
+    fn associated_fn_relevanes() {
         check_relevance(
             r#"
 struct AStruct;
@@ -2081,29 +2081,36 @@ fn test() {
             "#]],
         );
 
-        //         // Generic
-        //         check_relevance(
-        //             r#"
-        // struct A<T>{item: T}
-        // struct ABuilder;
-        // impl A {
-        //     fn foo(&self) {}
-        //     fn new_1<T>(input: u32, l: T) -> A<T> { A }
-        //     fn new_2<T>() -> Self { A { item: <_>::default()} }
-        //     fn aaaabuilder<T>() -> ABuilder<T> { A }
-        // }
-
-        // fn test() {
-        //     let a = A::$0;
-        // }
-        // "#,
-        //             expect![[r#"
-        //                 fn new_2() [type_could_unify]
-        //                 fn aaaabuilder() [type_could_unify]
-        //                 fn new_1(…) [type_could_unify]
-        //                 me foo(…) [type_could_unify]
-        //             "#]],
-        //         );
+        // Generic
+        check_relevance(
+            r#"
+struct AStruct<T: Default>(T);
+struct AStructBuilder;
+struct Res<T>(T);
+
+impl<T: Default> AStruct<T> {
+    fn fn_no_ret(&self) {}
+    fn fn_ctr_with_args(input: T) -> AStruct<T> { AStruct(input) }
+    fn fn_direct_ctr() -> Self { AStruct(<_>::default()) }
+    fn fn_ctr() -> Res<Self> { Res(Self::fn_direct_ctr()) }
+    fn fn_other() -> Res<u32> { Res(0) }
+    fn fn_builder() -> AStructBuilder { AStructBuilder }
+}
+
+fn test() {
+    //let a : Res<AStruct<u32>> = self::AStruct::fn_ctr();
+    let a = self::AStruct::<u32>::$0;
+}
+        "#,
+            expect![[r#"
+                fn fn_direct_ctr() [type_could_unify]
+                fn fn_ctr_with_args(…) [type_could_unify]
+                fn fn_builder() [type_could_unify]
+                fn fn_ctr() [type_could_unify]
+                fn fn_other() [type_could_unify]
+                me fn_no_ret(…) [type_could_unify]
+            "#]],
+        );
     }
 
     #[test]

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

@@ -173,20 +173,25 @@ fn compute_associated_fn(
         return None;
     }
 
+    let has_args = !func.assoc_fn_params(db).is_empty();
     let ret_type = func.ret_type(db);
     let ret_unit_type = ret_type.is_unit();
-    let self_ty = match func_kind {
+    let self_type = match func_kind {
         FuncKind::Function(PathCompletionCtx {
             qualified: Qualified::With { path, .. }, ..
-        }) => path.segment().map(|s| s.to_string()),
+        }) => path.segment().and_then(|ps| ps.name_ref()).map(|n| n.to_string()),
         _ => None,
-    };
-    let (returns_self, returns_self_wrapped) = self_ty
-        .map(|self_ty| {
+    }; // self type without any generic args
+    let (returns_self, returns_self_wrapped) = self_type
+        .map(|self_type| {
             let ret_ty = ret_type.display(db).to_string();
-            let ret_self_wrapped = ret_ty.contains(&format!("<{self_ty}>"));
 
-            (ret_ty == self_ty || ret_self_wrapped, ret_self_wrapped)
+            // the second checks are needed when Self has generic args
+            let ret_self_only = ret_ty == self_type || ret_ty.starts_with(&format!("{self_type}<"));
+            let ret_self_wrapped = ret_ty.ends_with(&format!("<{self_type}>"))
+                || ret_ty.contains(&format!("<{self_type}<"));
+
+            (ret_self_only || ret_self_wrapped, ret_self_wrapped)
         })
         .unwrap_or_else(|| (false, false));
 
@@ -195,22 +200,22 @@ fn compute_associated_fn(
         && ctx.completion.expected_type.as_ref() == Some(&ret_type)
     {
         // impl Foo { fn baz(&self) -> u32 { 0 } }
-        // let _: u32 = foo.$0; // baz is preffered as it returns expected u32
+        // let _: u32 = foo.$0; // baz is preferred as it returns expected u32
         CompletionRelevanceAssociatedFnType::ReturnsExpectedType
     } else if ret_type.display(db).to_string().ends_with("Builder") {
         // -> [..]Builder
         CompletionRelevanceAssociatedFnType::Builder
     } else if returns_self_wrapped {
-        // fn() -> Result<A>
+        // fn([..]) -> Result<A>
         CompletionRelevanceAssociatedFnType::Constructor
     } else if returns_self {
-        // fn() -> A
+        // fn([..]) -> A
         CompletionRelevanceAssociatedFnType::DirectConstructor
     } else {
         CompletionRelevanceAssociatedFnType::Other
     };
 
-    Some(CompletionRelevanceAssociatedFn { ty, has_args: !func.assoc_fn_params(db).is_empty() })
+    Some(CompletionRelevanceAssociatedFn { ty, has_args })
 }
 
 pub(super) fn add_call_parens<'b>(