1 files changed, 50 insertions, 16 deletions

diff --git a/crates/ide_completion/src/render/function.rs b/crates/ide_completion/src/render/function.rs
index 47e26a5d8..010303182 100644
--- a/crates/ide_completion/src/render/function.rs
+++ b/crates/ide_completion/src/render/function.rs
@@ -2,11 +2,15 @@
 
 use hir::{HasSource, HirDisplay, Type};
 use ide_db::SymbolKind;
+use itertools::Itertools;
 use syntax::ast::Fn;
 
 use crate::{
     item::{CompletionItem, CompletionItemKind, CompletionKind, CompletionRelevance, ImportEdit},
-    render::{builder_ext::Params, RenderContext},
+    render::{
+        builder_ext::Params, compute_exact_name_match, compute_exact_type_match, compute_ref_match,
+        RenderContext,
+    },
 };
 
 pub(crate) fn render_fn<'a>(
@@ -52,30 +56,60 @@ impl<'a> FunctionRender<'a> {
                 self.ctx.is_deprecated(self.func) || self.ctx.is_deprecated_assoc_item(self.func),
             )
             .detail(self.detail())
-            .add_call_parens(self.ctx.completion, self.name, params)
+            .add_call_parens(self.ctx.completion, self.name.clone(), params)
             .add_import(import_to_add);
 
-        let mut relevance = CompletionRelevance::default();
-        if let Some(expected_type) = &self.ctx.completion.expected_type {
-            let ret_ty = self.func.ret_type(self.ctx.db());
+        let ret_type = self.func.ret_type(self.ctx.db());
+        item.set_relevance(CompletionRelevance {
+            exact_type_match: compute_exact_type_match(self.ctx.completion, &ret_type),
+            exact_name_match: compute_exact_name_match(self.ctx.completion, self.name.clone()),
+            ..CompletionRelevance::default()
+        });
 
-            // We don't ever consider a function which returns unit type to be an
-            // exact type match, since nearly always this is not meaningful to the
-            // user.
-            relevance.exact_type_match = &ret_ty == expected_type && !ret_ty.is_unit();
+        if let Some(ref_match) = compute_ref_match(self.ctx.completion, &ret_type) {
+            item.ref_match(ref_match);
         }
-        if let Some(expected_name) = &self.ctx.completion.expected_name {
-            relevance.exact_name_match =
-                expected_name == &self.func.name(self.ctx.db()).to_string();
-        }
-        item.set_relevance(relevance);
 
         item.build()
     }
 
     fn detail(&self) -> String {
-        let ty = self.func.ret_type(self.ctx.db());
-        format!("-> {}", ty.display(self.ctx.db()))
+        let ret_ty = self.func.ret_type(self.ctx.db());
+        let ret = if ret_ty.is_unit() {
+            // Omit the return type if it is the unit type
+            String::new()
+        } else {
+            format!(" {}", self.ty_display())
+        };
+
+        format!("fn({}){}", self.params_display(), ret)
+    }
+
+    fn params_display(&self) -> String {
+        if let Some(self_param) = self.func.self_param(self.ctx.db()) {
+            let params = self
+                .func
+                .assoc_fn_params(self.ctx.db())
+                .into_iter()
+                .skip(1) // skip the self param because we are manually handling that
+                .map(|p| p.ty().display(self.ctx.db()).to_string());
+
+            std::iter::once(self_param.display(self.ctx.db()).to_owned()).chain(params).join(", ")
+        } else {
+            let params = self
+                .func
+                .assoc_fn_params(self.ctx.db())
+                .into_iter()
+                .map(|p| p.ty().display(self.ctx.db()).to_string())
+                .join(", ");
+            params
+        }
+    }
+
+    fn ty_display(&self) -> String {
+        let ret_ty = self.func.ret_type(self.ctx.db());
+
+        format!("-> {}", ret_ty.display(self.ctx.db()))
     }
 
     fn add_arg(&self, arg: &str, ty: &Type) -> String {