1 files changed, 50 insertions, 80 deletions

diff --git a/crates/ra_ide/src/completion/patterns.rs b/crates/ra_ide/src/completion/patterns.rs
index fdcd3faa5..b2fe13280 100644
--- a/crates/ra_ide/src/completion/patterns.rs
+++ b/crates/ra_ide/src/completion/patterns.rs
@@ -8,6 +8,9 @@ use ra_syntax::{
     SyntaxNode, SyntaxToken,
 };
 
+#[cfg(test)]
+use crate::completion::test_utils::check_pattern_is_applicable;
+
 pub(crate) fn has_trait_parent(element: SyntaxElement) -> bool {
     not_same_range_ancestor(element)
         .filter(|it| it.kind() == ITEM_LIST)
@@ -15,6 +18,10 @@ pub(crate) fn has_trait_parent(element: SyntaxElement) -> bool {
         .filter(|it| it.kind() == TRAIT_DEF)
         .is_some()
 }
+#[test]
+fn test_has_trait_parent() {
+    check_pattern_is_applicable(r"trait A { f<|> }", has_trait_parent);
+}
 
 pub(crate) fn has_impl_parent(element: SyntaxElement) -> bool {
     not_same_range_ancestor(element)
@@ -23,20 +30,38 @@ pub(crate) fn has_impl_parent(element: SyntaxElement) -> bool {
         .filter(|it| it.kind() == IMPL_DEF)
         .is_some()
 }
+#[test]
+fn test_has_impl_parent() {
+    check_pattern_is_applicable(r"impl A { f<|> }", has_impl_parent);
+}
 
 pub(crate) fn has_block_expr_parent(element: SyntaxElement) -> bool {
     not_same_range_ancestor(element).filter(|it| it.kind() == BLOCK_EXPR).is_some()
 }
+#[test]
+fn test_has_block_expr_parent() {
+    check_pattern_is_applicable(r"fn my_fn() { let a = 2; f<|> }", has_block_expr_parent);
+}
 
 pub(crate) fn has_bind_pat_parent(element: SyntaxElement) -> bool {
     element.ancestors().find(|it| it.kind() == BIND_PAT).is_some()
 }
+#[test]
+fn test_has_bind_pat_parent() {
+    check_pattern_is_applicable(r"fn my_fn(m<|>) {}", has_bind_pat_parent);
+    check_pattern_is_applicable(r"fn my_fn() { let m<|> }", has_bind_pat_parent);
+}
 
 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()
 }
+#[test]
+fn test_has_ref_parent() {
+    check_pattern_is_applicable(r"fn my_fn(&m<|>) {}", has_ref_parent);
+    check_pattern_is_applicable(r"fn my() { let &m<|> }", has_ref_parent);
+}
 
 pub(crate) fn has_item_list_or_source_file_parent(element: SyntaxElement) -> bool {
     let ancestor = not_same_range_ancestor(element);
@@ -45,6 +70,11 @@ pub(crate) fn has_item_list_or_source_file_parent(element: SyntaxElement) -> boo
     }
     ancestor.filter(|it| it.kind() == SOURCE_FILE || it.kind() == ITEM_LIST).is_some()
 }
+#[test]
+fn test_has_item_list_or_source_file_parent() {
+    check_pattern_is_applicable(r"i<|>", has_item_list_or_source_file_parent);
+    check_pattern_is_applicable(r"impl { f<|> }", has_item_list_or_source_file_parent);
+}
 
 pub(crate) fn is_match_arm(element: SyntaxElement) -> bool {
     not_same_range_ancestor(element.clone()).filter(|it| it.kind() == MATCH_ARM).is_some()
@@ -53,6 +83,10 @@ pub(crate) fn is_match_arm(element: SyntaxElement) -> bool {
             .filter(|it| it.kind() == FAT_ARROW)
             .is_some()
 }
+#[test]
+fn test_is_match_arm() {
+    check_pattern_is_applicable(r"fn my_fn() { match () { () => m<|> } }", is_match_arm);
+}
 
 pub(crate) fn unsafe_is_prev(element: SyntaxElement) -> bool {
     element
@@ -61,6 +95,10 @@ pub(crate) fn unsafe_is_prev(element: SyntaxElement) -> bool {
         .filter(|it| it.kind() == UNSAFE_KW)
         .is_some()
 }
+#[test]
+fn test_unsafe_is_prev() {
+    check_pattern_is_applicable(r"unsafe i<|>", unsafe_is_prev);
+}
 
 pub(crate) fn if_is_prev(element: SyntaxElement) -> bool {
     element
@@ -69,14 +107,26 @@ pub(crate) fn if_is_prev(element: SyntaxElement) -> bool {
         .filter(|it| it.kind() == IF_KW)
         .is_some()
 }
+#[test]
+fn test_if_is_prev() {
+    check_pattern_is_applicable(r"if l<|>", if_is_prev);
+}
 
 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()
 }
+#[test]
+fn test_has_trait_as_prev_sibling() {
+    check_pattern_is_applicable(r"trait A w<|> {}", has_trait_as_prev_sibling);
+}
 
 pub(crate) fn has_impl_as_prev_sibling(element: SyntaxElement) -> bool {
     previous_sibling_or_ancestor_sibling(element).filter(|it| it.kind() == IMPL_DEF).is_some()
 }
+#[test]
+fn test_has_impl_as_prev_sibling() {
+    check_pattern_is_applicable(r"impl A w<|> {}", has_impl_as_prev_sibling);
+}
 
 pub(crate) fn is_in_loop_body(element: SyntaxElement) -> bool {
     let leaf = match element {
@@ -142,83 +192,3 @@ fn previous_sibling_or_ancestor_sibling(element: SyntaxElement) -> Option<Syntax
         non_trivia_sibling(NodeOrToken::Node(prev_sibling_node), Direction::Prev)
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::{
-        has_bind_pat_parent, has_block_expr_parent, has_impl_as_prev_sibling, has_impl_parent,
-        has_item_list_or_source_file_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;
-
-    #[test]
-    fn test_unsafe_is_prev() {
-        check_pattern_is_applicable(r"unsafe i<|>", unsafe_is_prev);
-    }
-
-    #[test]
-    fn test_if_is_prev() {
-        check_pattern_is_applicable(r"if l<|>", if_is_prev);
-    }
-
-    #[test]
-    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]
-    fn test_has_trait_as_prev_sibling() {
-        check_pattern_is_applicable(r"trait A w<|> {}", has_trait_as_prev_sibling);
-    }
-
-    #[test]
-    fn test_has_impl_as_prev_sibling() {
-        check_pattern_is_applicable(r"impl A w<|> {}", has_impl_as_prev_sibling);
-    }
-
-    #[test]
-    fn test_parent_block_expr() {
-        check_pattern_is_applicable(r"fn my_fn() { let a = 2; f<|> }", has_block_expr_parent);
-    }
-
-    #[test]
-    fn test_has_ref_pat_parent_in_func_parameters() {
-        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() { let &m<|> }", has_ref_parent);
-    }
-
-    #[test]
-    fn test_has_bind_pat_parent_in_func_parameters() {
-        check_pattern_is_applicable(r"fn my_fn(m<|>) {}", has_bind_pat_parent);
-    }
-
-    #[test]
-    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);
-    }
-
-    #[test]
-    fn test_has_source_file_parent() {
-        check_pattern_is_applicable(r"i<|>", has_item_list_or_source_file_parent);
-    }
-
-    #[test]
-    fn test_has_item_list_parent() {
-        check_pattern_is_applicable(r"impl { f<|> }", has_item_list_or_source_file_parent);
-    }
-}