Rewrite snapshot checks

Author: mcrakhman

crates/ra_ide/src/completion/complete_keyword.rs

@@ -61,7 +61,6 @@ fn add_keyword(
 
 pub(super) fn complete_expr_keyword(acc: &mut Completions, ctx: &CompletionContext) {
     add_keyword(ctx, acc, "fn", "fn $0() {}", ctx.is_new_item || ctx.block_expr_parent);
-    add_keyword(ctx, acc, "type", "type ", ctx.is_new_item || ctx.block_expr_parent);
     add_keyword(ctx, acc, "use", "fn $0() {}", ctx.is_new_item || ctx.block_expr_parent);
     add_keyword(ctx, acc, "impl", "impl $0 {}", ctx.is_new_item);
     add_keyword(ctx, acc, "trait", "impl $0 {}", ctx.is_new_item);
@@ -111,145 +110,49 @@ fn complete_return(
 
 #[cfg(test)]
 mod tests {
-    use crate::{
-        completion::{
-            test_utils::{do_completion, do_completion_with_position},
-            CompletionItem, CompletionKind,
-        },
-        CompletionItemKind,
+    use crate::completion::{
+        test_utils::{do_completion, get_completions},
+        CompletionItem, CompletionKind,
     };
     use insta::assert_debug_snapshot;
 
     fn do_keyword_completion(code: &str) -> Vec<CompletionItem> {
         do_completion(code, CompletionKind::Keyword)
     }
 
-    fn get_completion_text_and_assert_positions(code: &str) -> Vec<(String, String)> {
-        let (position, completion_items) =
-            do_completion_with_position(code, CompletionKind::Keyword);
-        let mut returned_keywords = Vec::<(String, String)>::new();
-
-        for item in completion_items {
-            assert!(item.text_edit().len() == 1);
-            assert!(item.kind() == Some(CompletionItemKind::Keyword));
-            let atom = item.text_edit().iter().next().unwrap().clone();
-            assert!(atom.delete.start() == position.offset);
-            assert!(atom.delete.end() == position.offset);
-            let pair = (item.label().to_string(), atom.insert);
-            returned_keywords.push(pair);
-        }
-        returned_keywords.sort();
-        returned_keywords
-    }
-
-    #[test]
-    fn completes_keywords_in_use_stmt_new_approach() {
-        assert_debug_snapshot!(
-            get_completion_text_and_assert_positions(r"
-            use <|>
-            "),
-            @r###"
-        [
-            (
-                "crate",
-                "crate::",
-            ),
-            (
-                "self",
-                "self",
-            ),
-            (
-                "super",
-                "super::",
-            ),
-        ]
-        "###
-        );
+    fn get_keyword_completions(code: &str) -> Vec<String> {
+        get_completions(code, CompletionKind::Keyword)
     }
 
     #[test]
     fn completes_keywords_in_use_stmt() {
         assert_debug_snapshot!(
-            do_keyword_completion(
-                r"
-                use <|>
-                ",
-            ),
+            get_keyword_completions(r"use <|>"),
             @r###"
         [
-            CompletionItem {
-                label: "crate",
-                source_range: 21..21,
-                delete: 21..21,
-                insert: "crate::",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "self",
-                source_range: 21..21,
-                delete: 21..21,
-                insert: "self",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "super",
-                source_range: 21..21,
-                delete: 21..21,
-                insert: "super::",
-                kind: Keyword,
-            },
+            "kw crate",
+            "kw self",
+            "kw super",
         ]
         "###
         );
 
         assert_debug_snapshot!(
-            do_keyword_completion(
-                r"
-                use a::<|>
-                ",
-            ),
+            get_keyword_completions(r"use a::<|>"),
             @r###"
         [
-            CompletionItem {
-                label: "self",
-                source_range: 24..24,
-                delete: 24..24,
-                insert: "self",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "super",
-                source_range: 24..24,
-                delete: 24..24,
-                insert: "super::",
-                kind: Keyword,
-            },
+            "kw self",
+            "kw super",
         ]
         "###
         );
 
         assert_debug_snapshot!(
-            do_keyword_completion(
-                r"
-                use a::{b, <|>}
-                ",
-            ),
+            get_keyword_completions(r"use a::{b, <|>}"),
             @r###"
         [
-            CompletionItem {
-                label: "self",
-                source_range: 28..28,
-                delete: 28..28,
-                insert: "self",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "super",
-                source_range: 28..28,
-                delete: 28..28,
-                insert: "super::",
-                kind: Keyword,
-            },
+            "kw self",
+            "kw super",
         ]
         "###
         );
@@ -258,50 +161,22 @@ mod tests {
     #[test]
     fn completes_various_keywords_in_function() {
         assert_debug_snapshot!(
-            do_keyword_completion(
-                r"
-                fn quux() {
-                    <|>
-                }
-                ",
-            ),
+            get_keyword_completions(r"fn quux() { <|> }"),
             @r###"
         [
-            CompletionItem {
-                label: "if",
-                source_range: 49..49,
-                delete: 49..49,
-                insert: "if $0 {}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "loop",
-                source_range: 49..49,
-                delete: 49..49,
-                insert: "loop {$0}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "match",
-                source_range: 49..49,
-                delete: 49..49,
-                insert: "match $0 {}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "return",
-                source_range: 49..49,
-                delete: 49..49,
-                insert: "return;",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "while",
-                source_range: 49..49,
-                delete: 49..49,
-                insert: "while $0 {}",
-                kind: Keyword,
-            },
+            "kw const",
+            "kw extern",
+            "kw fn",
+            "kw let",
+            "kw loop",
+            "kw match",
+            "kw mod",
+            "kw return",
+            "kw static",
+            "kw type",
+            "kw unsafe",
+            "kw use",
+            "kw while",
         ]
         "###
         );

crates/ra_ide/src/completion/completion_item.rs

@@ -125,6 +125,32 @@ pub enum CompletionItemKind {
     Attribute,
 }
 
+impl CompletionItemKind {
+    pub fn tag(&self) -> String {
+        let tag = match self {
+            CompletionItemKind::Snippet => "sn",
+            CompletionItemKind::Keyword => "kw",
+            CompletionItemKind::Module => "md",
+            CompletionItemKind::Function => "fn",
+            CompletionItemKind::BuiltinType => "bt",
+            CompletionItemKind::Struct => "st",
+            CompletionItemKind::Enum => "en",
+            CompletionItemKind::EnumVariant => "ev",
+            CompletionItemKind::Binding => "bn",
+            CompletionItemKind::Field => "fd",
+            CompletionItemKind::Static => "sc",
+            CompletionItemKind::Const => "ct",
+            CompletionItemKind::Trait => "tt",
+            CompletionItemKind::TypeAlias => "ta",
+            CompletionItemKind::Method => "me",
+            CompletionItemKind::TypeParam => "tp",
+            CompletionItemKind::Macro => "ma",
+            CompletionItemKind::Attribute => "at",
+        };
+        tag.to_owned()
+    }
+}
+
 #[derive(Debug, PartialEq, Eq, Copy, Clone)]
 pub(crate) enum CompletionKind {
     /// Parser-based keyword completion.

crates/ra_ide/src/completion/patterns.rs

@@ -121,115 +121,51 @@ mod tests {
 
     #[test]
     fn test_unsafe_is_prev() {
-        check_pattern_is_applicable(
-            r"
-        unsafe i<|>
-        ",
-            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,
-        );
+        check_pattern_is_applicable(r"if l<|>", if_is_prev);
     }
 
     #[test]
     fn test_inside_trait() {
-        check_pattern_is_applicable(
-            r"
-        trait A {
-            fn<|>
-        }
-        ",
-            inside_trait,
-        );
+        check_pattern_is_applicable(r"trait A { fn<|> }", inside_trait);
     }
 
     #[test]
     fn test_has_trait_as_prev_sibling() {
-        check_pattern_is_applicable(
-            r"
-        trait A w<|> {
-        }
-        ",
-            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,
-        );
+        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,
-        );
+        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(&<|>) {
-            let a = 2;
-        }
-        ",
-            has_ref_pat_parent,
-        );
+        check_pattern_is_applicable(r"fn my_fn(&<|>) {}", has_ref_pat_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_fn() { let &<|> }", has_ref_pat_parent);
     }
 
     #[test]
     fn test_has_bind_pat_parent_in_func_parameters() {
-        check_pattern_is_applicable(
-            r"
-        fn my_fn(m<|>) {
-        }
-        ",
-            has_bind_pat_parent,
-        );
+        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,
-        );
+        check_pattern_is_applicable(r"fn my_fn() { let m<|> }", has_bind_pat_parent);
     }
 }