5 files changed, 447 insertions, 581 deletions

diff --git a/crates/ra_ide/src/completion/complete_keyword.rs b/crates/ra_ide/src/completion/complete_keyword.rs
index e599cc3d1..34d061f5a 100644
--- a/crates/ra_ide/src/completion/complete_keyword.rs
+++ b/crates/ra_ide/src/completion/complete_keyword.rs
@@ -174,289 +174,289 @@ fn complete_return(
 
 #[cfg(test)]
 mod tests {
-    use crate::completion::{test_utils::completion_list, CompletionKind};
-    use insta::assert_snapshot;
+    use expect::{expect, Expect};
 
-    fn get_keyword_completions(code: &str) -> String {
-        completion_list(code, CompletionKind::Keyword)
+    use crate::completion::{
+        test_utils::{check_edit, completion_list},
+        CompletionKind,
+    };
+
+    fn check(ra_fixture: &str, expect: Expect) {
+        let actual = completion_list(ra_fixture, CompletionKind::Keyword);
+        expect.assert_eq(&actual)
     }
 
     #[test]
     fn test_keywords_in_use_stmt() {
-        assert_snapshot!(
-            get_keyword_completions(r"use <|>"),
-            @r###"
-            kw crate::
-            kw self
-            kw super::
-        "###
+        check(
+            r"use <|>",
+            expect![[r#"
+                kw crate::
+                kw self
+                kw super::
+            "#]],
         );
 
-        assert_snapshot!(
-            get_keyword_completions(r"use a::<|>"),
-            @r###"
+        check(
+            r"use a::<|>",
+            expect![[r#"
             kw self
             kw super::
-        "###
+        "#]],
         );
 
-        assert_snapshot!(
-            get_keyword_completions(r"use a::{b, <|>}"),
-            @r###"
+        check(
+            r"use a::{b, <|>}",
+            expect![[r#"
             kw self
             kw super::
-        "###
+        "#]],
         );
     }
 
     #[test]
     fn test_keywords_at_source_file_level() {
-        assert_snapshot!(
-            get_keyword_completions(r"m<|>"),
-            @r###"
-            kw const
-            kw enum
-            kw extern
-            kw fn
-            kw impl
-            kw mod
-            kw pub
-            kw static
-            kw struct
-            kw trait
-            kw type
-            kw union
-            kw unsafe
-            kw use
-        "###
+        check(
+            r"m<|>",
+            expect![[r#"
+                kw const
+                kw enum
+                kw extern
+                kw fn
+                kw impl
+                kw mod
+                kw pub
+                kw static
+                kw struct
+                kw trait
+                kw type
+                kw union
+                kw unsafe
+                kw use
+            "#]],
         );
     }
 
     #[test]
     fn test_keywords_in_function() {
-        assert_snapshot!(
-            get_keyword_completions(r"fn quux() { <|> }"),
-            @r###"
-            kw const
-            kw extern
-            kw fn
-            kw if
-            kw if let
-            kw impl
-            kw let
-            kw loop
-            kw match
-            kw mod
-            kw return
-            kw static
-            kw trait
-            kw type
-            kw unsafe
-            kw use
-            kw while
-        "###
+        check(
+            r"fn quux() { <|> }",
+            expect![[r#"
+                kw const
+                kw extern
+                kw fn
+                kw if
+                kw if let
+                kw impl
+                kw let
+                kw loop
+                kw match
+                kw mod
+                kw return
+                kw static
+                kw trait
+                kw type
+                kw unsafe
+                kw use
+                kw while
+            "#]],
         );
     }
 
     #[test]
     fn test_keywords_inside_block() {
-        assert_snapshot!(
-            get_keyword_completions(r"fn quux() { if true { <|> } }"),
-            @r###"
-            kw const
-            kw extern
-            kw fn
-            kw if
-            kw if let
-            kw impl
-            kw let
-            kw loop
-            kw match
-            kw mod
-            kw return
-            kw static
-            kw trait
-            kw type
-            kw unsafe
-            kw use
-            kw while
-        "###
+        check(
+            r"fn quux() { if true { <|> } }",
+            expect![[r#"
+                kw const
+                kw extern
+                kw fn
+                kw if
+                kw if let
+                kw impl
+                kw let
+                kw loop
+                kw match
+                kw mod
+                kw return
+                kw static
+                kw trait
+                kw type
+                kw unsafe
+                kw use
+                kw while
+            "#]],
         );
     }
 
     #[test]
     fn test_keywords_after_if() {
-        assert_snapshot!(
-            get_keyword_completions(
-                r"
-                fn quux() {
-                    if true {
-                        ()
-                    } <|>
-                }
-                ",
-            ),
-            @r###"
-            kw const
-            kw else
-            kw else if
-            kw extern
-            kw fn
-            kw if
-            kw if let
-            kw impl
-            kw let
-            kw loop
-            kw match
-            kw mod
-            kw return
-            kw static
-            kw trait
-            kw type
-            kw unsafe
-            kw use
-            kw while
-        "###
+        check(
+            r#"fn quux() { if true { () } <|> }"#,
+            expect![[r#"
+                kw const
+                kw else
+                kw else if
+                kw extern
+                kw fn
+                kw if
+                kw if let
+                kw impl
+                kw let
+                kw loop
+                kw match
+                kw mod
+                kw return
+                kw static
+                kw trait
+                kw type
+                kw unsafe
+                kw use
+                kw while
+            "#]],
+        );
+        check_edit(
+            "else",
+            r#"fn quux() { if true { () } <|> }"#,
+            r#"fn quux() { if true { () } else {$0} }"#,
         );
     }
 
     #[test]
     fn test_keywords_in_match_arm() {
-        assert_snapshot!(
-            get_keyword_completions(
-                r"
-                fn quux() -> i32 {
-                    match () {
-                        () => <|>
-                    }
-                }
-                ",
-            ),
-            @r###"
-            kw if
-            kw if let
-            kw loop
-            kw match
-            kw return
-            kw unsafe
-        "###
+        check(
+            r#"
+fn quux() -> i32 {
+    match () {
+        () => <|>
+    }
+}
+"#,
+            expect![[r#"
+                kw if
+                kw if let
+                kw loop
+                kw match
+                kw return
+                kw unsafe
+            "#]],
         );
     }
 
     #[test]
     fn test_keywords_in_trait_def() {
-        assert_snapshot!(
-            get_keyword_completions(r"trait My { <|> }"),
-            @r###"
-            kw const
-            kw fn
-            kw type
-            kw unsafe
-        "###
+        check(
+            r"trait My { <|> }",
+            expect![[r#"
+                kw const
+                kw fn
+                kw type
+                kw unsafe
+            "#]],
         );
     }
 
     #[test]
     fn test_keywords_in_impl_def() {
-        assert_snapshot!(
-            get_keyword_completions(r"impl My { <|> }"),
-            @r###"
-            kw const
-            kw fn
-            kw pub
-            kw type
-            kw unsafe
-        "###
+        check(
+            r"impl My { <|> }",
+            expect![[r#"
+                kw const
+                kw fn
+                kw pub
+                kw type
+                kw unsafe
+            "#]],
         );
     }
 
     #[test]
     fn test_keywords_in_loop() {
-        assert_snapshot!(
-            get_keyword_completions(r"fn my() { loop { <|> } }"),
-            @r###"
-            kw break
-            kw const
-            kw continue
-            kw extern
-            kw fn
-            kw if
-            kw if let
-            kw impl
-            kw let
-            kw loop
-            kw match
-            kw mod
-            kw return
-            kw static
-            kw trait
-            kw type
-            kw unsafe
-            kw use
-            kw while
-        "###
+        check(
+            r"fn my() { loop { <|> } }",
+            expect![[r#"
+                kw break
+                kw const
+                kw continue
+                kw extern
+                kw fn
+                kw if
+                kw if let
+                kw impl
+                kw let
+                kw loop
+                kw match
+                kw mod
+                kw return
+                kw static
+                kw trait
+                kw type
+                kw unsafe
+                kw use
+                kw while
+            "#]],
         );
     }
 
     #[test]
     fn test_keywords_after_unsafe_in_item_list() {
-        assert_snapshot!(
-            get_keyword_completions(r"unsafe <|>"),
-            @r###"
-            kw fn
-            kw impl
-            kw trait
-        "###
+        check(
+            r"unsafe <|>",
+            expect![[r#"
+                kw fn
+                kw impl
+                kw trait
+            "#]],
         );
     }
 
     #[test]
     fn test_keywords_after_unsafe_in_block_expr() {
-        assert_snapshot!(
-            get_keyword_completions(r"fn my_fn() { unsafe <|> }"),
-            @r###"
-            kw fn
-            kw impl
-            kw trait
-        "###
+        check(
+            r"fn my_fn() { unsafe <|> }",
+            expect![[r#"
+                kw fn
+                kw impl
+                kw trait
+            "#]],
         );
     }
 
     #[test]
     fn test_mut_in_ref_and_in_fn_parameters_list() {
-        assert_snapshot!(
-            get_keyword_completions(r"fn my_fn(&<|>) {}"),
-            @r###"
-            kw mut
-        "###
+        check(
+            r"fn my_fn(&<|>) {}",
+            expect![[r#"
+                kw mut
+            "#]],
         );
-        assert_snapshot!(
-            get_keyword_completions(r"fn my_fn(<|>) {}"),
-            @r###"
-            kw mut
-        "###
+        check(
+            r"fn my_fn(<|>) {}",
+            expect![[r#"
+                kw mut
+            "#]],
         );
-        assert_snapshot!(
-            get_keyword_completions(r"fn my_fn() { let &<|> }"),
-            @r###"
-            kw mut
-        "###
+        check(
+            r"fn my_fn() { let &<|> }",
+            expect![[r#"
+                kw mut
+            "#]],
         );
     }
 
     #[test]
     fn test_where_keyword() {
-        assert_snapshot!(
-            get_keyword_completions(r"trait A <|>"),
-            @r###"
-            kw where
-        "###
+        check(
+            r"trait A <|>",
+            expect![[r#"
+                kw where
+            "#]],
         );
-        assert_snapshot!(
-            get_keyword_completions(r"impl A <|>"),
-            @r###"
-            kw where
-        "###
+        check(
+            r"impl A <|>",
+            expect![[r#"
+                kw where
+            "#]],
         );
     }
 }
diff --git a/crates/ra_ide/src/completion/complete_record.rs b/crates/ra_ide/src/completion/complete_record.rs
index 13eb2f79f..74b94594d 100644
--- a/crates/ra_ide/src/completion/complete_record.rs
+++ b/crates/ra_ide/src/completion/complete_record.rs
@@ -18,389 +18,209 @@ pub(super) fn complete_record(acc: &mut Completions, ctx: &CompletionContext) ->
 
 #[cfg(test)]
 mod tests {
-    mod record_pat_tests {
-        use insta::assert_debug_snapshot;
+    use expect::{expect, Expect};
 
-        use crate::completion::{test_utils::do_completion, CompletionItem, CompletionKind};
+    use crate::completion::{test_utils::completion_list, CompletionKind};
 
-        fn complete(code: &str) -> Vec<CompletionItem> {
-            do_completion(code, CompletionKind::Reference)
-        }
-
-        #[test]
-        fn test_record_pattern_field() {
-            let completions = complete(
-                r"
-            struct S { foo: u32 }
-
-            fn process(f: S) {
-                match f {
-                    S { f<|>: 92 } => (),
-                }
-            }
-            ",
-            );
-            assert_debug_snapshot!(completions, @r###"
-            [
-                CompletionItem {
-                    label: "foo",
-                    source_range: 68..69,
-                    delete: 68..69,
-                    insert: "foo",
-                    kind: Field,
-                    detail: "u32",
-                },
-            ]
-            "###);
-        }
-
-        #[test]
-        fn test_record_pattern_enum_variant() {
-            let completions = complete(
-                r"
-            enum E {
-                S { foo: u32, bar: () }
-            }
-
-            fn process(e: E) {
-                match e {
-                    E::S { <|> } => (),
-                }
-            }
-            ",
-            );
-            assert_debug_snapshot!(completions, @r###"
-            [
-                CompletionItem {
-                    label: "bar",
-                    source_range: 88..88,
-                    delete: 88..88,
-                    insert: "bar",
-                    kind: Field,
-                    detail: "()",
-                },
-                CompletionItem {
-                    label: "foo",
-                    source_range: 88..88,
-                    delete: 88..88,
-                    insert: "foo",
-                    kind: Field,
-                    detail: "u32",
-                },
-            ]
-            "###);
-        }
+    fn check(ra_fixture: &str, expect: Expect) {
+        let actual = completion_list(ra_fixture, CompletionKind::Reference);
+        expect.assert_eq(&actual);
+    }
 
-        #[test]
-        fn test_record_pattern_field_in_simple_macro() {
-            let completions = complete(
-                r"
-            macro_rules! m { ($e:expr) => { $e } }
-            struct S { foo: u32 }
+    #[test]
+    fn test_record_pattern_field() {
+        check(
+            r#"
+struct S { foo: u32 }
 
-            fn process(f: S) {
-                m!(match f {
-                    S { f<|>: 92 } => (),
-                })
-            }
-            ",
-            );
-            assert_debug_snapshot!(completions, @r###"
-            [
-                CompletionItem {
-                    label: "foo",
-                    source_range: 110..111,
-                    delete: 110..111,
-                    insert: "foo",
-                    kind: Field,
-                    detail: "u32",
-                },
-            ]
-            "###);
-        }
+fn process(f: S) {
+    match f {
+        S { f<|>: 92 } => (),
+    }
+}
+"#,
+            expect![[r#"
+                fd foo u32
+            "#]],
+        );
+    }
 
-        #[test]
-        fn only_missing_fields_are_completed_in_destruct_pats() {
-            let completions = complete(
-                r"
-            struct S {
-                foo1: u32,
-                foo2: u32,
-                bar: u32,
-                baz: u32,
-            }
+    #[test]
+    fn test_record_pattern_enum_variant() {
+        check(
+            r#"
+enum E { S { foo: u32, bar: () } }
 
-            fn main() {
-                let s = S {
-                    foo1: 1,
-                    foo2: 2,
-                    bar: 3,
-                    baz: 4,
-                };
-                if let S { foo1, foo2: a, <|> } = s {}
-            }
-            ",
-            );
-            assert_debug_snapshot!(completions, @r###"
-            [
-                CompletionItem {
-                    label: "bar",
-                    source_range: 203..203,
-                    delete: 203..203,
-                    insert: "bar",
-                    kind: Field,
-                    detail: "u32",
-                },
-                CompletionItem {
-                    label: "baz",
-                    source_range: 203..203,
-                    delete: 203..203,
-                    insert: "baz",
-                    kind: Field,
-                    detail: "u32",
-                },
-            ]
-            "###);
-        }
+fn process(e: E) {
+    match e {
+        E::S { <|> } => (),
+    }
+}
+"#,
+            expect![[r#"
+                fd bar ()
+                fd foo u32
+            "#]],
+        );
     }
 
-    mod record_lit_tests {
-        use insta::assert_debug_snapshot;
-
-        use crate::completion::{test_utils::do_completion, CompletionItem, CompletionKind};
+    #[test]
+    fn test_record_pattern_field_in_simple_macro() {
+        check(
+            r"
+macro_rules! m { ($e:expr) => { $e } }
+struct S { foo: u32 }
+
+fn process(f: S) {
+    m!(match f {
+        S { f<|>: 92 } => (),
+    })
+}
+",
+            expect![[r#"
+                fd foo u32
+            "#]],
+        );
+    }
 
-        fn complete(code: &str) -> Vec<CompletionItem> {
-            do_completion(code, CompletionKind::Reference)
-        }
+    #[test]
+    fn only_missing_fields_are_completed_in_destruct_pats() {
+        check(
+            r#"
+struct S {
+    foo1: u32, foo2: u32,
+    bar: u32, baz: u32,
+}
 
-        #[test]
-        fn test_record_literal_deprecated_field() {
-            let completions = complete(
-                r"
-            struct A {
-                #[deprecated]
-                the_field: u32,
-            }
-            fn foo() {
-               A { the<|> }
-            }
-            ",
-            );
-            assert_debug_snapshot!(completions, @r###"
-            [
-                CompletionItem {
-                    label: "the_field",
-                    source_range: 69..72,
-                    delete: 69..72,
-                    insert: "the_field",
-                    kind: Field,
-                    detail: "u32",
-                    deprecated: true,
-                },
-            ]
-            "###);
-        }
+fn main() {
+    let s = S {
+        foo1: 1, foo2: 2,
+        bar: 3, baz: 4,
+    };
+    if let S { foo1, foo2: a, <|> } = s {}
+}
+"#,
+            expect![[r#"
+                fd bar u32
+                fd baz u32
+            "#]],
+        );
+    }
 
-        #[test]
-        fn test_record_literal_field() {
-            let completions = complete(
-                r"
-            struct A { the_field: u32 }
-            fn foo() {
-               A { the<|> }
-            }
-            ",
-            );
-            assert_debug_snapshot!(completions, @r###"
-            [
-                CompletionItem {
-                    label: "the_field",
-                    source_range: 46..49,
-                    delete: 46..49,
-                    insert: "the_field",
-                    kind: Field,
-                    detail: "u32",
-                },
-            ]
-            "###);
-        }
+    #[test]
+    fn test_record_literal_field() {
+        check(
+            r#"
+struct A { the_field: u32 }
+fn foo() {
+   A { the<|> }
+}
+"#,
+            expect![[r#"
+                fd the_field u32
+            "#]],
+        );
+    }
 
-        #[test]
-        fn test_record_literal_enum_variant() {
-            let completions = complete(
-                r"
-            enum E {
-                A { a: u32 }
-            }
-            fn foo() {
-                let _ = E::A { <|> }
-            }
-            ",
-            );
-            assert_debug_snapshot!(completions, @r###"
-            [
-                CompletionItem {
-                    label: "a",
-                    source_range: 58..58,
-                    delete: 58..58,
-                    insert: "a",
-                    kind: Field,
-                    detail: "u32",
-                },
-            ]
-            "###);
-        }
+    #[test]
+    fn test_record_literal_enum_variant() {
+        check(
+            r#"
+enum E { A { a: u32 } }
+fn foo() {
+    let _ = E::A { <|> }
+}
+"#,
+            expect![[r#"
+                fd a u32
+            "#]],
+        );
+    }
 
-        #[test]
-        fn test_record_literal_two_structs() {
-            let completions = complete(
-                r"
-            struct A { a: u32 }
-            struct B { b: u32 }
+    #[test]
+    fn test_record_literal_two_structs() {
+        check(
+            r#"
+struct A { a: u32 }
+struct B { b: u32 }
 
-            fn foo() {
-               let _: A = B { <|> }
-            }
-            ",
-            );
-            assert_debug_snapshot!(completions, @r###"
-            [
-                CompletionItem {
-                    label: "b",
-                    source_range: 70..70,
-                    delete: 70..70,
-                    insert: "b",
-                    kind: Field,
-                    detail: "u32",
-                },
-            ]
-            "###);
-        }
+fn foo() {
+   let _: A = B { <|> }
+}
+"#,
+            expect![[r#"
+                fd b u32
+            "#]],
+        );
+    }
 
-        #[test]
-        fn test_record_literal_generic_struct() {
-            let completions = complete(
-                r"
-            struct A<T> { a: T }
+    #[test]
+    fn test_record_literal_generic_struct() {
+        check(
+            r#"
+struct A<T> { a: T }
 
-            fn foo() {
-               let _: A<u32> = A { <|> }
-            }
-            ",
-            );
-            assert_debug_snapshot!(completions, @r###"
-            [
-                CompletionItem {
-                    label: "a",
-                    source_range: 56..56,
-                    delete: 56..56,
-                    insert: "a",
-                    kind: Field,
-                    detail: "u32",
-                },
-            ]
-            "###);
-        }
+fn foo() {
+   let _: A<u32> = A { <|> }
+}
+"#,
+            expect![[r#"
+                fd a u32
+            "#]],
+        );
+    }
 
-        #[test]
-        fn test_record_literal_field_in_simple_macro() {
-            let completions = complete(
-                r"
-            macro_rules! m { ($e:expr) => { $e } }
-            struct A { the_field: u32 }
-            fn foo() {
-               m!(A { the<|> })
-            }
-            ",
-            );
-            assert_debug_snapshot!(completions, @r###"
-            [
-                CompletionItem {
-                    label: "the_field",
-                    source_range: 88..91,
-                    delete: 88..91,
-                    insert: "the_field",
-                    kind: Field,
-                    detail: "u32",
-                },
-            ]
-            "###);
-        }
+    #[test]
+    fn test_record_literal_field_in_simple_macro() {
+        check(
+            r#"
+macro_rules! m { ($e:expr) => { $e } }
+struct A { the_field: u32 }
+fn foo() {
+   m!(A { the<|> })
+}
+"#,
+            expect![[r#"
+                fd the_field u32
+            "#]],
+        );
+    }
 
-        #[test]
-        fn only_missing_fields_are_completed() {
-            let completions = complete(
-                r"
-            struct S {
-                foo1: u32,
-                foo2: u32,
-                bar: u32,
-                baz: u32,
-            }
+    #[test]
+    fn only_missing_fields_are_completed() {
+        check(
+            r#"
+struct S {
+    foo1: u32, foo2: u32,
+    bar: u32, baz: u32,
+}
 
-            fn main() {
-                let foo1 = 1;
-                let s = S {
-                    foo1,
-                    foo2: 5,
-                    <|>
-                }
-            }
-            ",
-            );
-            assert_debug_snapshot!(completions, @r###"
-            [
-                CompletionItem {
-                    label: "bar",
-                    source_range: 157..157,
-                    delete: 157..157,
-                    insert: "bar",
-                    kind: Field,
-                    detail: "u32",
-                },
-                CompletionItem {
-                    label: "baz",
-                    source_range: 157..157,
-                    delete: 157..157,
-                    insert: "baz",
-                    kind: Field,
-                    detail: "u32",
-                },
-            ]
-            "###);
-        }
+fn main() {
+    let foo1 = 1;
+    let s = S { foo1, foo2: 5, <|> }
+}
+"#,
+            expect![[r#"
+                fd bar u32
+                fd baz u32
+            "#]],
+        );
+    }
 
-        #[test]
-        fn completes_functional_update() {
-            let completions = complete(
-                r"
-            struct S {
-                foo1: u32,
-                foo2: u32,
-            }
+    #[test]
+    fn completes_functional_update() {
+        check(
+            r#"
+struct S { foo1: u32, foo2: u32 }
 
-            fn main() {
-                let foo1 = 1;
-                let s = S {
-                    foo1,
-                    <|>
-                    .. loop {}
-                }
-            }
-            ",
-            );
-            assert_debug_snapshot!(completions, @r###"
-            [
-                CompletionItem {
-                    label: "foo2",
-                    source_range: 112..112,
-                    delete: 112..112,
-                    insert: "foo2",
-                    kind: Field,
-                    detail: "u32",
-                },
-            ]
-            "###);
-        }
+fn main() {
+    let foo1 = 1;
+    let s = S { foo1, <|> .. loop {} }
+}
+"#,
+            expect![[r#"
+                fd foo2 u32
+            "#]],
+        );
     }
 }
diff --git a/crates/ra_ide/src/completion/completion_item.rs b/crates/ra_ide/src/completion/completion_item.rs
index 98348b349..4db371d57 100644
--- a/crates/ra_ide/src/completion/completion_item.rs
+++ b/crates/ra_ide/src/completion/completion_item.rs
@@ -129,24 +129,24 @@ impl CompletionItemKind {
     #[cfg(test)]
     pub(crate) fn tag(&self) -> &'static str {
         match self {
-            CompletionItemKind::Snippet => "sn",
-            CompletionItemKind::Keyword => "kw",
-            CompletionItemKind::Module => "md",
-            CompletionItemKind::Function => "fn",
+            CompletionItemKind::Attribute => "at",
+            CompletionItemKind::Binding => "bn",
             CompletionItemKind::BuiltinType => "bt",
-            CompletionItemKind::Struct => "st",
+            CompletionItemKind::Const => "ct",
             CompletionItemKind::Enum => "en",
             CompletionItemKind::EnumVariant => "ev",
-            CompletionItemKind::Binding => "bn",
             CompletionItemKind::Field => "fd",
+            CompletionItemKind::Function => "fn",
+            CompletionItemKind::Keyword => "kw",
+            CompletionItemKind::Macro => "ma",
+            CompletionItemKind::Method => "me",
+            CompletionItemKind::Module => "md",
+            CompletionItemKind::Snippet => "sn",
             CompletionItemKind::Static => "sc",
-            CompletionItemKind::Const => "ct",
+            CompletionItemKind::Struct => "st",
             CompletionItemKind::Trait => "tt",
             CompletionItemKind::TypeAlias => "ta",
-            CompletionItemKind::Method => "me",
             CompletionItemKind::TypeParam => "tp",
-            CompletionItemKind::Macro => "ma",
-            CompletionItemKind::Attribute => "at",
         }
     }
 }
diff --git a/crates/ra_ide/src/completion/presentation.rs b/crates/ra_ide/src/completion/presentation.rs
index b18279746..bd274bd74 100644
--- a/crates/ra_ide/src/completion/presentation.rs
+++ b/crates/ra_ide/src/completion/presentation.rs
@@ -606,6 +606,31 @@ mod tests {
         ]
         "###
         );
+
+        assert_debug_snapshot!(do_reference_completion(
+            r#"
+struct A {
+    #[deprecated]
+    the_field: u32,
+}
+fn foo() {
+   A { the<|> }
+}
+"#,
+        ),
+        @r###"
+        [
+            CompletionItem {
+                label: "the_field",
+                source_range: 69..72,
+                delete: 69..72,
+                insert: "the_field",
+                kind: Field,
+                detail: "u32",
+                deprecated: true,
+            },
+        ]
+        "###);
     }
 
     #[test]
diff --git a/crates/ra_ide/src/completion/test_utils.rs b/crates/ra_ide/src/completion/test_utils.rs
index 5c01654cc..9c036eac7 100644
--- a/crates/ra_ide/src/completion/test_utils.rs
+++ b/crates/ra_ide/src/completion/test_utils.rs
@@ -1,7 +1,10 @@
 //! Runs completion for testing purposes.
 
 use hir::Semantics;
+use itertools::Itertools;
 use ra_syntax::{AstNode, NodeOrToken, SyntaxElement};
+use stdx::format_to;
+use test_utils::assert_eq_text;
 
 use crate::{
     completion::{completion_item::CompletionKind, CompletionConfig},
@@ -42,10 +45,28 @@ pub(crate) fn completion_list_with_options(
     kind_completions.sort_by_key(|c| c.label().to_owned());
     kind_completions
         .into_iter()
-        .map(|it| format!("{} {}\n", it.kind().unwrap().tag(), it.label()))
+        .map(|it| {
+            let mut buf = format!("{} {}", it.kind().unwrap().tag(), it.label());
+            if let Some(detail) = it.detail() {
+                format_to!(buf, " {}", detail);
+            }
+            format_to!(buf, "\n");
+            buf
+        })
         .collect()
 }
 
+pub(crate) fn check_edit(what: &str, ra_fixture_before: &str, ra_fixture_after: &str) {
+    let (analysis, position) = analysis_and_position(ra_fixture_before);
+    let completions: Vec<CompletionItem> =
+        analysis.completions(&CompletionConfig::default(), position).unwrap().unwrap().into();
+    let (completion,) =
+        completions.into_iter().filter(|it| it.label() == what).collect_tuple().unwrap();
+    let mut actual = analysis.file_text(position.file_id).unwrap().to_string();
+    completion.text_edit().apply(&mut actual);
+    assert_eq_text!(ra_fixture_after, &actual)
+}
+
 pub(crate) fn check_pattern_is_applicable(code: &str, check: fn(SyntaxElement) -> bool) {
     let (analysis, pos) = analysis_and_position(code);
     analysis