1 files changed, 269 insertions, 86 deletions

diff --git a/crates/ide_completion/src/render.rs b/crates/ide_completion/src/render.rs
index 8c8b149a1..2514dda7c 100644
--- a/crates/ide_completion/src/render.rs
+++ b/crates/ide_completion/src/render.rs
@@ -10,8 +10,10 @@ pub(crate) mod type_alias;
 
 mod builder_ext;
 
+use base_db::Upcast;
 use hir::{
-    AsAssocItem, Documentation, HasAttrs, HirDisplay, ModuleDef, Mutability, ScopeDef, Type,
+    db::HirDatabase, AsAssocItem, Documentation, HasAttrs, HirDisplay, ModuleDef, Mutability,
+    ScopeDef, Type,
 };
 use ide_db::{
     helpers::{item_name, SnippetCap},
@@ -20,7 +22,7 @@ use ide_db::{
 use syntax::TextRange;
 
 use crate::{
-    item::{ImportEdit, Relevance},
+    item::{CompletionRelevance, ImportEdit},
     CompletionContext, CompletionItem, CompletionItemKind, CompletionKind,
 };
 
@@ -116,19 +118,6 @@ impl<'a> RenderContext<'a> {
     fn docs(&self, node: impl HasAttrs) -> Option<Documentation> {
         node.docs(self.db())
     }
-
-    fn expected_name_and_type(&self) -> Option<(String, Type)> {
-        if let Some(record_field) = &self.completion.record_field_syntax {
-            cov_mark::hit!(record_field_type_match);
-            let (struct_field, _local) = self.completion.sema.resolve_record_field(record_field)?;
-            Some((struct_field.name(self.db()).to_string(), struct_field.signature_ty(self.db())))
-        } else if let Some(active_parameter) = &self.completion.active_parameter {
-            cov_mark::hit!(active_param_type_match);
-            Some((active_parameter.name.clone(), active_parameter.ty.clone()))
-        } else {
-            None
-        }
-    }
 }
 
 /// Generic renderer for completion items.
@@ -149,24 +138,27 @@ impl<'a> Render<'a> {
             CompletionKind::Reference,
             self.ctx.source_range(),
             name.to_string(),
-        )
-        .kind(SymbolKind::Field)
-        .detail(ty.display(self.ctx.db()).to_string())
-        .set_documentation(field.docs(self.ctx.db()))
-        .set_deprecated(is_deprecated);
+        );
+        item.kind(SymbolKind::Field)
+            .detail(ty.display(self.ctx.db()).to_string())
+            .set_documentation(field.docs(self.ctx.db()))
+            .set_deprecated(is_deprecated);
 
-        if let Some(relevance) = compute_relevance(&self.ctx, &ty, &name.to_string()) {
-            item = item.set_relevance(relevance);
-        }
+        item.set_relevance(compute_relevance(&self.ctx, &ty, &name.to_string()));
 
         item.build()
     }
 
     fn add_tuple_field(&mut self, field: usize, ty: &Type) -> CompletionItem {
-        CompletionItem::new(CompletionKind::Reference, self.ctx.source_range(), field.to_string())
-            .kind(SymbolKind::Field)
-            .detail(ty.display(self.ctx.db()).to_string())
-            .build()
+        let mut item = CompletionItem::new(
+            CompletionKind::Reference,
+            self.ctx.source_range(),
+            field.to_string(),
+        );
+
+        item.kind(SymbolKind::Field).detail(ty.display(self.ctx.db()).to_string());
+
+        item.build()
     }
 
     fn render_resolution(
@@ -225,15 +217,13 @@ impl<'a> Render<'a> {
                 CompletionItemKind::SymbolKind(SymbolKind::SelfParam)
             }
             ScopeDef::Unknown => {
-                let item = CompletionItem::new(
+                let mut item = CompletionItem::new(
                     CompletionKind::Reference,
                     self.ctx.source_range(),
                     local_name,
-                )
-                .kind(CompletionItemKind::UnresolvedReference)
-                .add_import(import_to_add)
-                .build();
-                return Some(item);
+                );
+                item.kind(CompletionItemKind::UnresolvedReference).add_import(import_to_add);
+                return Some(item.build());
             }
         };
 
@@ -242,25 +232,29 @@ impl<'a> Render<'a> {
         if let ScopeDef::Local(local) = resolution {
             let ty = local.ty(self.ctx.db());
             if !ty.is_unknown() {
-                item = item.detail(ty.display(self.ctx.db()).to_string());
+                item.detail(ty.display(self.ctx.db()).to_string());
             }
         };
 
         if let ScopeDef::Local(local) = resolution {
             let ty = local.ty(self.ctx.db());
-            if let Some(relevance) = compute_relevance(&self.ctx, &ty, &local_name) {
-                item = item.set_relevance(relevance)
-            }
-            if let Some((_expected_name, expected_type)) = self.ctx.expected_name_and_type() {
-                if let Some(ty_without_ref) = expected_type.remove_ref() {
-                    if ty_without_ref == ty {
-                        cov_mark::hit!(suggest_ref);
-                        let mutability = if expected_type.is_mutable_reference() {
-                            Mutability::Mut
-                        } else {
-                            Mutability::Shared
-                        };
-                        item = item.ref_match(mutability)
+
+            let mut relevance = compute_relevance(&self.ctx, &ty, &local_name);
+            relevance.is_local = true;
+            item.set_relevance(relevance);
+
+            if let Some(expected_type) = self.ctx.completion.expected_type.as_ref() {
+                if &ty != expected_type {
+                    if let Some(ty_without_ref) = expected_type.remove_ref() {
+                        if relevance_type_match(self.ctx.db().upcast(), &ty, &ty_without_ref) {
+                            cov_mark::hit!(suggest_ref);
+                            let mutability = if expected_type.is_mutable_reference() {
+                                Mutability::Mut
+                            } else {
+                                Mutability::Shared
+                            };
+                            item.ref_match(mutability);
+                        }
                     }
                 }
             }
@@ -281,21 +275,17 @@ impl<'a> Render<'a> {
                 };
                 if has_non_default_type_params {
                     cov_mark::hit!(inserts_angle_brackets_for_generics);
-                    item = item
-                        .lookup_by(local_name.clone())
+                    item.lookup_by(local_name.clone())
                         .label(format!("{}<…>", local_name))
                         .insert_snippet(cap, format!("{}<$0>", local_name));
                 }
             }
         }
-
-        Some(
-            item.kind(kind)
-                .add_import(import_to_add)
-                .set_documentation(self.docs(resolution))
-                .set_deprecated(self.is_deprecated(resolution))
-                .build(),
-        )
+        item.kind(kind)
+            .add_import(import_to_add)
+            .set_documentation(self.docs(resolution))
+            .set_deprecated(self.is_deprecated(resolution));
+        Some(item.build())
     }
 
     fn docs(&self, resolution: &ScopeDef) -> Option<Documentation> {
@@ -323,23 +313,27 @@ impl<'a> Render<'a> {
     }
 }
 
-fn compute_relevance(ctx: &RenderContext, ty: &Type, name: &str) -> Option<Relevance> {
-    let (expected_name, expected_type) = ctx.expected_name_and_type()?;
-    let mut res = Relevance::default();
-    res.exact_type_match = ty == &expected_type;
-    res.exact_name_match = name == &expected_name;
-    Some(res)
+fn compute_relevance(ctx: &RenderContext, ty: &Type, name: &str) -> CompletionRelevance {
+    let mut res = CompletionRelevance::default();
+
+    res.exact_type_match = Some(ty) == ctx.completion.expected_type.as_ref();
+    res.exact_name_match = Some(name) == ctx.completion.expected_name.as_deref();
+
+    res
+}
+
+fn relevance_type_match(db: &dyn HirDatabase, ty: &Type, expected_type: &Type) -> bool {
+    ty == expected_type || ty.autoderef(db).any(|deref_ty| &deref_ty == expected_type)
 }
 
 #[cfg(test)]
 mod tests {
-    use std::cmp::Reverse;
-
     use expect_test::{expect, Expect};
+    use itertools::Itertools;
 
     use crate::{
         test_utils::{check_edit, do_completion, get_all_items, TEST_CONFIG},
-        CompletionKind, Relevance,
+        CompletionKind, CompletionRelevance,
     };
 
     fn check(ra_fixture: &str, expect: Expect) {
@@ -348,26 +342,40 @@ mod tests {
     }
 
     fn check_relevance(ra_fixture: &str, expect: Expect) {
-        fn display_relevance(relevance: Relevance) -> &'static str {
-            match relevance {
-                Relevance { exact_type_match: true, exact_name_match: true } => "[type+name]",
-                Relevance { exact_type_match: true, exact_name_match: false } => "[type]",
-                Relevance { exact_type_match: false, exact_name_match: true } => "[name]",
-                Relevance { exact_type_match: false, exact_name_match: false } => "[]",
-            }
+        fn display_relevance(relevance: CompletionRelevance) -> String {
+            let relevance_factors = vec![
+                (relevance.exact_type_match, "type"),
+                (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)
         }
 
-        let mut completions = get_all_items(TEST_CONFIG, ra_fixture);
-        completions.sort_by_key(|it| (Reverse(it.relevance()), it.label().to_string()));
-        let actual = completions
+        let actual = get_all_items(TEST_CONFIG, ra_fixture)
             .into_iter()
             .filter(|it| it.completion_kind == CompletionKind::Reference)
-            .map(|it| {
+            .flat_map(|it| {
+                let mut items = vec![];
+
                 let tag = it.kind().unwrap().tag();
                 let relevance = display_relevance(it.relevance());
-                format!("{} {} {}\n", tag, it.label(), relevance)
+                items.push(format!("{} {} {}\n", tag, it.label(), relevance));
+
+                if let Some((mutability, relevance)) = it.ref_match() {
+                    let label = format!("&{}{}", mutability.as_keyword_for_ref(), it.label());
+                    let relevance = display_relevance(relevance);
+
+                    items.push(format!("{} {} {}\n", tag, label, relevance));
+                }
+
+                items
             })
             .collect::<String>();
+
         expect.assert_eq(&actual);
     }
 
@@ -829,7 +837,6 @@ fn foo(xs: Vec<i128>)
 
     #[test]
     fn active_param_relevance() {
-        cov_mark::check!(active_param_type_match);
         check_relevance(
             r#"
 struct S { foo: i64, bar: u32, baz: u32 }
@@ -837,16 +844,15 @@ fn test(bar: u32) { }
 fn foo(s: S) { test(s.$0) }
 "#,
             expect![[r#"
+                fd foo []
                 fd bar [type+name]
                 fd baz [type]
-                fd foo []
             "#]],
         );
     }
 
     #[test]
     fn record_field_relevances() {
-        cov_mark::check!(record_field_type_match);
         check_relevance(
             r#"
 struct A { foo: i64, bar: u32, baz: u32 }
@@ -854,9 +860,9 @@ struct B { x: (), y: f32, bar: u32 }
 fn foo(a: A) { B { bar: a.$0 }; }
 "#,
             expect![[r#"
+                fd foo []
                 fd bar [type+name]
                 fd baz [type]
-                fd foo []
             "#]],
         )
     }
@@ -884,9 +890,9 @@ fn f(foo: i64) {  }
 fn foo(a: A) { f(B { bar: a.$0 }); }
 "#,
             expect![[r#"
+                fd foo []
                 fd bar [type+name]
                 fd baz [type]
-                fd foo []
             "#]],
         );
     }
@@ -899,7 +905,7 @@ struct WorldSnapshot { _f: () };
 fn go(world: &WorldSnapshot) { go(w$0) }
 "#,
             expect![[r#"
-                lc world [type+name]
+                lc world [type+name+local]
                 st WorldSnapshot []
                 fn go(…) []
             "#]],
@@ -914,9 +920,69 @@ struct Foo;
 fn f(foo: &Foo) { f(foo, w$0) }
 "#,
             expect![[r#"
+                lc foo [local]
                 st Foo []
                 fn f(…) []
-                lc foo []
+            "#]],
+        );
+    }
+
+    #[test]
+    fn score_fn_type_and_name_match() {
+        check_relevance(
+            r#"
+struct A { bar: u8 }
+fn baz() -> u8 { 0 }
+fn bar() -> u8 { 0 }
+fn f() { A { bar: b$0 }; }
+"#,
+            expect![[r#"
+                fn baz() [type]
+                st A []
+                fn bar() [type+name]
+                fn f() []
+            "#]],
+        );
+    }
+
+    #[test]
+    fn score_method_type_and_name_match() {
+        check_relevance(
+            r#"
+fn baz(aaa: u32){}
+struct Foo;
+impl Foo {
+fn aaa(&self) -> u32 { 0 }
+fn bbb(&self) -> u32 { 0 }
+fn ccc(&self) -> u64 { 0 }
+}
+fn f() {
+    baz(Foo.$0
+}
+"#,
+            expect![[r#"
+                me aaa() [type+name]
+                me bbb() [type]
+                me ccc() []
+            "#]],
+        );
+    }
+
+    #[test]
+    fn score_method_name_match_only() {
+        check_relevance(
+            r#"
+fn baz(aaa: u32){}
+struct Foo;
+impl Foo {
+fn aaa(&self) -> u64 { 0 }
+}
+fn f() {
+    baz(Foo.$0
+}
+"#,
+            expect![[r#"
+                me aaa() [name]
             "#]],
         );
     }
@@ -976,9 +1042,10 @@ fn main() {
                             Local,
                         ),
                         detail: "S",
-                        relevance: Relevance {
+                        relevance: CompletionRelevance {
                             exact_name_match: true,
                             exact_type_match: false,
+                            is_local: true,
                         },
                         ref_match: "&mut ",
                     },
@@ -986,4 +1053,120 @@ fn main() {
             "#]],
         )
     }
+
+    #[test]
+    fn suggest_deref() {
+        check_relevance(
+            r#"
+#[lang = "deref"]
+trait Deref {
+    type Target;
+    fn deref(&self) -> &Self::Target;
+}
+
+struct S;
+struct T(S);
+
+impl Deref for T {
+    type Target = S;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+fn foo(s: &S) {}
+
+fn main() {
+    let t = T(S);
+    let m = 123;
+
+    foo($0);
+}
+            "#,
+            expect![[r#"
+                lc m [local]
+                lc t [local]
+                lc &t [type+local]
+                st T []
+                st S []
+                fn main() []
+                tt Deref []
+                fn foo(…) []
+            "#]],
+        )
+    }
+
+    #[test]
+    fn suggest_deref_mut() {
+        check_relevance(
+            r#"
+#[lang = "deref"]
+trait Deref {
+    type Target;
+    fn deref(&self) -> &Self::Target;
+}
+
+#[lang = "deref_mut"]
+pub trait DerefMut: Deref {
+    fn deref_mut(&mut self) -> &mut Self::Target;
+}
+
+struct S;
+struct T(S);
+
+impl Deref for T {
+    type Target = S;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl DerefMut for T {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+fn foo(s: &mut S) {}
+
+fn main() {
+    let t = T(S);
+    let m = 123;
+
+    foo($0);
+}
+            "#,
+            expect![[r#"
+                lc m [local]
+                lc t [local]
+                lc &mut t [type+local]
+                tt DerefMut []
+                tt Deref []
+                fn foo(…) []
+                st T []
+                st S []
+                fn main() []
+            "#]],
+        )
+    }
+
+    #[test]
+    fn locals() {
+        check_relevance(
+            r#"
+fn foo(bar: u32) {
+    let baz = 0;
+
+    f$0
+}
+"#,
+            expect![[r#"
+                lc baz [local]
+                lc bar [local]
+                fn foo(…) []
+            "#]],
+        );
+    }
 }