1 files changed, 47 insertions, 14 deletions

diff --git a/crates/ra_ide/src/completion/patterns.rs b/crates/ra_ide/src/completion/patterns.rs
index bc39689ab..bc37196d5 100644
--- a/crates/ra_ide/src/completion/patterns.rs
+++ b/crates/ra_ide/src/completion/patterns.rs
@@ -6,16 +6,42 @@ use ra_syntax::{
     SyntaxNode, SyntaxToken,
 };
 
-pub(crate) fn inside_trait(element: SyntaxElement) -> bool {
-    element.ancestors().find(|it| it.kind() == TRAIT_DEF).is_some()
+pub(crate) fn has_trait_parent(element: SyntaxElement) -> bool {
+    not_same_range_ancestor(element)
+        .filter(|it| it.kind() == ITEM_LIST)
+        .and_then(|it| it.parent())
+        .filter(|it| it.kind() == TRAIT_DEF)
+        .is_some()
+}
+
+pub(crate) fn has_impl_parent(element: SyntaxElement) -> bool {
+    not_same_range_ancestor(element)
+        .filter(|it| it.kind() == ITEM_LIST)
+        .and_then(|it| it.parent())
+        .filter(|it| it.kind() == IMPL_DEF)
+        .is_some()
+}
+
+pub(crate) fn has_block_expr_parent(element: SyntaxElement) -> bool {
+    not_same_range_ancestor(element).filter(|it| it.kind() == BLOCK_EXPR).is_some()
 }
 
 pub(crate) fn has_bind_pat_parent(element: SyntaxElement) -> bool {
     element.ancestors().find(|it| it.kind() == BIND_PAT).is_some()
 }
 
-pub(crate) fn has_ref_pat_parent(element: SyntaxElement) -> bool {
-    element.ancestors().find(|it| it.kind() == REF_PAT).is_some()
+pub(crate) fn has_ref_parent(element: SyntaxElement) -> bool {
+    not_same_range_ancestor(element)
+        .filter(|it| it.kind() == REF_PAT || it.kind() == REF_EXPR)
+        .is_some()
+}
+
+pub(crate) fn is_match_arm(element: SyntaxElement) -> bool {
+    not_same_range_ancestor(element.clone()).filter(|it| it.kind() == MATCH_ARM).is_some()
+        && previous_sibling_or_ancestor_sibling(element)
+            .and_then(|it| it.into_token())
+            .filter(|it| it.kind() == FAT_ARROW)
+            .is_some()
 }
 
 pub(crate) fn unsafe_is_prev(element: SyntaxElement) -> bool {
@@ -34,10 +60,6 @@ pub(crate) fn if_is_prev(element: SyntaxElement) -> bool {
         .is_some()
 }
 
-pub(crate) fn has_block_expr_parent(element: SyntaxElement) -> bool {
-    not_same_range_ancestor(element).filter(|it| it.kind() == BLOCK_EXPR).is_some()
-}
-
 pub(crate) fn has_trait_as_prev_sibling(element: SyntaxElement) -> bool {
     previous_sibling_or_ancestor_sibling(element).filter(|it| it.kind() == TRAIT_DEF).is_some()
 }
@@ -114,8 +136,9 @@ fn previous_sibling_or_ancestor_sibling(element: SyntaxElement) -> Option<Syntax
 #[cfg(test)]
 mod tests {
     use super::{
-        has_bind_pat_parent, has_block_expr_parent, has_impl_as_prev_sibling, has_ref_pat_parent,
-        has_trait_as_prev_sibling, if_is_prev, inside_trait, unsafe_is_prev,
+        has_bind_pat_parent, has_block_expr_parent, has_impl_as_prev_sibling, has_impl_parent,
+        has_ref_parent, has_trait_as_prev_sibling, has_trait_parent, if_is_prev, is_match_arm,
+        unsafe_is_prev,
     };
     use crate::completion::test_utils::check_pattern_is_applicable;
 
@@ -130,8 +153,13 @@ mod tests {
     }
 
     #[test]
-    fn test_inside_trait() {
-        check_pattern_is_applicable(r"trait A { fn<|> }", inside_trait);
+    fn test_has_trait_parent() {
+        check_pattern_is_applicable(r"trait A { f<|> }", has_trait_parent);
+    }
+
+    #[test]
+    fn test_has_impl_parent() {
+        check_pattern_is_applicable(r"impl A { f<|> }", has_impl_parent);
     }
 
     #[test]
@@ -151,12 +179,12 @@ mod tests {
 
     #[test]
     fn test_has_ref_pat_parent_in_func_parameters() {
-        check_pattern_is_applicable(r"fn my_fn(&<|>) {}", has_ref_pat_parent);
+        check_pattern_is_applicable(r"fn my_fn(&m<|>) {}", has_ref_parent);
     }
 
     #[test]
     fn test_has_ref_pat_parent_in_let_statement() {
-        check_pattern_is_applicable(r"fn my_fn() { let &<|> }", has_ref_pat_parent);
+        check_pattern_is_applicable(r"fn my() { let &m<|> }", has_ref_parent);
     }
 
     #[test]
@@ -168,4 +196,9 @@ mod tests {
     fn test_has_bind_pat_parent_in_let_statement() {
         check_pattern_is_applicable(r"fn my_fn() { let m<|> }", has_bind_pat_parent);
     }
+
+    #[test]
+    fn test_is_match_arm() {
+        check_pattern_is_applicable(r"fn my_fn() { match () { () => m<|> } }", is_match_arm);
+    }
 }