3 files changed, 217 insertions, 45 deletions

diff --git a/crates/ide_completion/src/completions/postfix/format_like.rs b/crates/ide_completion/src/completions/postfix/format_like.rs
index 3afc63021..cee4eec10 100644
--- a/crates/ide_completion/src/completions/postfix/format_like.rs
+++ b/crates/ide_completion/src/completions/postfix/format_like.rs
@@ -59,7 +59,7 @@ pub(crate) fn add_format_like_completions(
 /// Checks whether provided item is a string literal.
 fn string_literal_contents(item: &ast::String) -> Option<String> {
     let item = item.text();
-    if item.len() >= 2 && item.starts_with("\"") && item.ends_with("\"") {
+    if item.len() >= 2 && item.starts_with('\"') && item.ends_with('\"') {
         return Some(item[1..item.len() - 1].to_owned());
     }
 
diff --git a/crates/ide_completion/src/item.rs b/crates/ide_completion/src/item.rs
index 3febab32b..9a4b5217a 100644
--- a/crates/ide_completion/src/item.rs
+++ b/crates/ide_completion/src/item.rs
@@ -144,6 +144,21 @@ pub struct CompletionRelevance {
     /// }
     /// ```
     pub exact_type_match: bool,
+    /// This is set in cases like these:
+    ///
+    /// ```
+    /// fn foo(bar: u32) {
+    ///     $0 // `bar` is local
+    /// }
+    /// ```
+    ///
+    /// ```
+    /// fn foo() {
+    ///     let bar = 0;
+    ///     $0 // `bar` is local
+    /// }
+    /// ```
+    pub is_local: bool,
 }
 
 impl CompletionRelevance {
@@ -163,6 +178,9 @@ impl CompletionRelevance {
             score += 1;
         }
         if self.exact_type_match {
+            score += 3;
+        }
+        if self.is_local {
             score += 1;
         }
 
@@ -551,9 +569,24 @@ mod tests {
             vec![CompletionRelevance::default()],
             vec![
                 CompletionRelevance { exact_name_match: true, ..CompletionRelevance::default() },
-                CompletionRelevance { exact_type_match: true, ..CompletionRelevance::default() },
+                CompletionRelevance { is_local: true, ..CompletionRelevance::default() },
             ],
-            vec![CompletionRelevance { exact_name_match: true, exact_type_match: true }],
+            vec![CompletionRelevance {
+                exact_name_match: true,
+                is_local: true,
+                ..CompletionRelevance::default()
+            }],
+            vec![CompletionRelevance { exact_type_match: true, ..CompletionRelevance::default() }],
+            vec![CompletionRelevance {
+                exact_name_match: true,
+                exact_type_match: true,
+                ..CompletionRelevance::default()
+            }],
+            vec![CompletionRelevance {
+                exact_name_match: true,
+                exact_type_match: true,
+                is_local: true,
+            }],
         ];
 
         check_relevance_score_ordered(expected_relevance_order);
diff --git a/crates/ide_completion/src/render.rs b/crates/ide_completion/src/render.rs
index db31896e5..905f0b197 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},
@@ -155,9 +157,7 @@ impl<'a> Render<'a> {
             .set_documentation(field.docs(self.ctx.db()))
             .set_deprecated(is_deprecated);
 
-        if let Some(relevance) = compute_relevance(&self.ctx, &ty, &name.to_string()) {
-            item.set_relevance(relevance);
-        }
+        item.set_relevance(compute_relevance(&self.ctx, &ty, &name.to_string()));
 
         item.build()
     }
@@ -251,19 +251,23 @@ impl<'a> Render<'a> {
 
         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.set_relevance(relevance);
-            }
+
+            let mut relevance = compute_relevance(&self.ctx, &ty, &local_name);
+            relevance.is_local = true;
+            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.ref_match(mutability);
+                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);
+                        }
                     }
                 }
             }
@@ -322,19 +326,25 @@ impl<'a> Render<'a> {
     }
 }
 
-fn compute_relevance(ctx: &RenderContext, ty: &Type, name: &str) -> Option<CompletionRelevance> {
-    let (expected_name, expected_type) = ctx.expected_name_and_type()?;
+fn compute_relevance(ctx: &RenderContext, ty: &Type, name: &str) -> CompletionRelevance {
     let mut res = CompletionRelevance::default();
-    res.exact_type_match = ty == &expected_type;
-    res.exact_name_match = name == &expected_name;
-    Some(res)
+
+    if let Some((expected_name, expected_type)) = ctx.expected_name_and_type() {
+        res.exact_type_match = ty == &expected_type;
+        res.exact_name_match = name == &expected_name;
+    }
+
+    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},
@@ -347,28 +357,40 @@ mod tests {
     }
 
     fn check_relevance(ra_fixture: &str, expect: Expect) {
-        fn display_relevance(relevance: CompletionRelevance) -> &'static str {
-            match relevance {
-                CompletionRelevance { exact_type_match: true, exact_name_match: true } => {
-                    "[type+name]"
-                }
-                CompletionRelevance { exact_type_match: true, exact_name_match: false } => "[type]",
-                CompletionRelevance { exact_type_match: false, exact_name_match: true } => "[name]",
-                CompletionRelevance { 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);
     }
 
@@ -838,9 +860,9 @@ fn test(bar: u32) { }
 fn foo(s: S) { test(s.$0) }
 "#,
             expect![[r#"
+                fd foo []
                 fd bar [type+name]
                 fd baz [type]
-                fd foo []
             "#]],
         );
     }
@@ -855,9 +877,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 []
             "#]],
         )
     }
@@ -885,9 +907,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 []
             "#]],
         );
     }
@@ -900,7 +922,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(…) []
             "#]],
@@ -915,9 +937,9 @@ struct Foo;
 fn f(foo: &Foo) { f(foo, w$0) }
 "#,
             expect![[r#"
+                lc foo [local]
                 st Foo []
                 fn f(…) []
-                lc foo []
             "#]],
         );
     }
@@ -980,6 +1002,7 @@ fn main() {
                         relevance: CompletionRelevance {
                             exact_name_match: true,
                             exact_type_match: false,
+                            is_local: true,
                         },
                         ref_match: "&mut ",
                     },
@@ -987,4 +1010,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(…) []
+            "#]],
+        );
+    }
 }