57 files changed, 9393 insertions, 13716 deletions

diff --git a/crates/ra_ide/src/call_hierarchy.rs b/crates/ra_ide/src/call_hierarchy.rs
index 1e3a31602..1fcaf4a32 100644
--- a/crates/ra_ide/src/call_hierarchy.rs
+++ b/crates/ra_ide/src/call_hierarchy.rs
@@ -39,10 +39,11 @@ pub(crate) fn call_hierarchy(
 
 pub(crate) fn incoming_calls(db: &RootDatabase, position: FilePosition) -> Option<Vec<CallItem>> {
     let sema = Semantics::new(db);
+
     // 1. Find all refs
     // 2. Loop through refs and determine unique fndef. This will become our `from: CallHierarchyItem,` in the reply.
     // 3. Add ranges relative to the start of the fndef.
-    let refs = references::find_all_refs(db, position, None)?;
+    let refs = references::find_all_refs(&sema, position, None)?;
 
     let mut calls = CallLocations::default();
 
@@ -58,7 +59,7 @@ pub(crate) fn incoming_calls(db: &RootDatabase, position: FilePosition) -> Optio
         if let Some(nav) = syntax.ancestors().find_map(|node| {
             match_ast! {
                 match node {
-                    ast::FnDef(it) => {
+                    ast::Fn(it) => {
                         let def = sema.to_def(&it)?;
                         Some(def.to_nav(sema.db))
                     },
@@ -94,9 +95,9 @@ pub(crate) fn outgoing_calls(db: &RootDatabase, position: FilePosition) -> Optio
             if let Some(func_target) = match &call_node {
                 FnCallNode::CallExpr(expr) => {
                     //FIXME: Type::as_callable is broken
-                    let callable_def = sema.type_of_expr(&expr.expr()?)?.as_callable()?;
-                    match callable_def {
-                        hir::CallableDef::FunctionId(it) => {
+                    let callable = sema.type_of_expr(&expr.expr()?)?.as_callable(db)?;
+                    match callable.kind() {
+                        hir::CallableKind::Function(it) => {
                             let fn_def: hir::Function = it.into();
                             let nav = fn_def.to_nav(db);
                             Some(nav)
@@ -108,10 +109,6 @@ pub(crate) fn outgoing_calls(db: &RootDatabase, position: FilePosition) -> Optio
                     let function = sema.resolve_method_call(&expr)?;
                     Some(function.to_nav(db))
                 }
-                FnCallNode::MacroCallExpr(macro_call) => {
-                    let macro_def = sema.resolve_macro_call(&macro_call)?;
-                    Some(macro_def.to_nav(db))
-                }
             } {
                 Some((func_target, name_ref.syntax().text_range()))
             } else {
@@ -157,7 +154,8 @@ mod tests {
         let nav = navs.pop().unwrap();
         nav.assert_match(expected);
 
-        let item_pos = FilePosition { file_id: nav.file_id(), offset: nav.range().start() };
+        let item_pos =
+            FilePosition { file_id: nav.file_id, offset: nav.focus_or_full_range().start() };
         let incoming_calls = analysis.incoming_calls(item_pos).unwrap().unwrap();
         assert_eq!(incoming_calls.len(), expected_incoming.len());
 
@@ -183,8 +181,8 @@ fn caller() {
     call<|>ee();
 }
 "#,
-            "callee FN_DEF FileId(1) 0..14 3..9",
-            &["caller FN_DEF FileId(1) 15..44 18..24 : [33..39]"],
+            "callee FN FileId(1) 0..14 3..9",
+            &["caller FN FileId(1) 15..44 18..24 : [33..39]"],
             &[],
         );
     }
@@ -199,8 +197,8 @@ fn caller() {
     callee();
 }
 "#,
-            "callee FN_DEF FileId(1) 0..14 3..9",
-            &["caller FN_DEF FileId(1) 15..44 18..24 : [33..39]"],
+            "callee FN FileId(1) 0..14 3..9",
+            &["caller FN FileId(1) 15..44 18..24 : [33..39]"],
             &[],
         );
     }
@@ -216,8 +214,8 @@ fn caller() {
     callee();
 }
 "#,
-            "callee FN_DEF FileId(1) 0..14 3..9",
-            &["caller FN_DEF FileId(1) 15..58 18..24 : [33..39, 47..53]"],
+            "callee FN FileId(1) 0..14 3..9",
+            &["caller FN FileId(1) 15..58 18..24 : [33..39, 47..53]"],
             &[],
         );
     }
@@ -236,10 +234,10 @@ fn caller2() {
     callee();
 }
 "#,
-            "callee FN_DEF FileId(1) 0..14 3..9",
+            "callee FN FileId(1) 0..14 3..9",
             &[
-                "caller1 FN_DEF FileId(1) 15..45 18..25 : [34..40]",
-                "caller2 FN_DEF FileId(1) 47..77 50..57 : [66..72]",
+                "caller1 FN FileId(1) 15..45 18..25 : [34..40]",
+                "caller2 FN FileId(1) 47..77 50..57 : [66..72]",
             ],
             &[],
         );
@@ -265,10 +263,10 @@ mod tests {
     }
 }
 "#,
-            "callee FN_DEF FileId(1) 0..14 3..9",
+            "callee FN FileId(1) 0..14 3..9",
             &[
-                "caller1 FN_DEF FileId(1) 15..45 18..25 : [34..40]",
-                "test_caller FN_DEF FileId(1) 95..149 110..121 : [134..140]",
+                "caller1 FN FileId(1) 15..45 18..25 : [34..40]",
+                "test_caller FN FileId(1) 95..149 110..121 : [134..140]",
             ],
             &[],
         );
@@ -289,8 +287,8 @@ fn caller() {
 //- /foo/mod.rs
 pub fn callee() {}
 "#,
-            "callee FN_DEF FileId(2) 0..18 7..13",
-            &["caller FN_DEF FileId(1) 27..56 30..36 : [45..51]"],
+            "callee FN FileId(2) 0..18 7..13",
+            &["caller FN FileId(1) 27..56 30..36 : [45..51]"],
             &[],
         );
     }
@@ -306,9 +304,9 @@ fn call<|>er() {
     callee();
 }
 "#,
-            "caller FN_DEF FileId(1) 15..58 18..24",
+            "caller FN FileId(1) 15..58 18..24",
             &[],
-            &["callee FN_DEF FileId(1) 0..14 3..9 : [33..39, 47..53]"],
+            &["callee FN FileId(1) 0..14 3..9 : [33..39, 47..53]"],
         );
     }
 
@@ -327,9 +325,9 @@ fn call<|>er() {
 //- /foo/mod.rs
 pub fn callee() {}
 "#,
-            "caller FN_DEF FileId(1) 27..56 30..36",
+            "caller FN FileId(1) 27..56 30..36",
             &[],
-            &["callee FN_DEF FileId(2) 0..18 7..13 : [45..51]"],
+            &["callee FN FileId(2) 0..18 7..13 : [45..51]"],
         );
     }
 
@@ -350,9 +348,46 @@ fn caller3() {
 
 }
 "#,
-            "caller2 FN_DEF FileId(1) 33..64 36..43",
-            &["caller1 FN_DEF FileId(1) 0..31 3..10 : [19..26]"],
-            &["caller3 FN_DEF FileId(1) 66..83 69..76 : [52..59]"],
+            "caller2 FN FileId(1) 33..64 36..43",
+            &["caller1 FN FileId(1) 0..31 3..10 : [19..26]"],
+            &["caller3 FN FileId(1) 66..83 69..76 : [52..59]"],
+        );
+    }
+
+    #[test]
+    fn test_call_hierarchy_issue_5103() {
+        check_hierarchy(
+            r#"
+fn a() {
+    b()
+}
+
+fn b() {}
+
+fn main() {
+    a<|>()
+}
+"#,
+            "a FN FileId(1) 0..18 3..4",
+            &["main FN FileId(1) 31..52 34..38 : [47..48]"],
+            &["b FN FileId(1) 20..29 23..24 : [13..14]"],
+        );
+
+        check_hierarchy(
+            r#"
+fn a() {
+    b<|>()
+}
+
+fn b() {}
+
+fn main() {
+    a()
+}
+"#,
+            "b FN FileId(1) 20..29 23..24",
+            &["a FN FileId(1) 0..18 3..4 : [13..14]"],
+            &[],
         );
     }
 }
diff --git a/crates/ra_ide/src/call_info.rs b/crates/ra_ide/src/call_info.rs
index a6bdf1c9d..ff602202f 100644
--- a/crates/ra_ide/src/call_info.rs
+++ b/crates/ra_ide/src/call_info.rs
@@ -1,13 +1,43 @@
 //! FIXME: write short doc here
-use hir::Semantics;
+use either::Either;
+use hir::{Docs, HirDisplay, Semantics, Type};
 use ra_ide_db::RootDatabase;
 use ra_syntax::{
     ast::{self, ArgListOwner},
-    match_ast, AstNode, SyntaxNode, SyntaxToken,
+    match_ast, AstNode, SyntaxNode, SyntaxToken, TextRange, TextSize,
 };
+use stdx::format_to;
 use test_utils::mark;
 
-use crate::{CallInfo, FilePosition, FunctionSignature};
+use crate::FilePosition;
+
+/// Contains information about a call site. Specifically the
+/// `FunctionSignature`and current parameter.
+#[derive(Debug)]
+pub struct CallInfo {
+    pub doc: Option<String>,
+    pub signature: String,
+    pub active_parameter: Option<usize>,
+    parameters: Vec<TextRange>,
+}
+
+impl CallInfo {
+    pub fn parameter_labels(&self) -> impl Iterator<Item = &str> + '_ {
+        self.parameters.iter().map(move |&it| &self.signature[it])
+    }
+    pub fn parameter_ranges(&self) -> &[TextRange] {
+        &self.parameters
+    }
+    fn push_param(&mut self, param: &str) {
+        if !self.signature.ends_with('(') {
+            self.signature.push_str(", ");
+        }
+        let start = TextSize::of(&self.signature);
+        self.signature.push_str(param);
+        let end = TextSize::of(&self.signature);
+        self.parameters.push(TextRange::new(start, end))
+    }
+}
 
 /// Computes parameter information for the given call expression.
 pub(crate) fn call_info(db: &RootDatabase, position: FilePosition) -> Option<CallInfo> {
@@ -16,106 +46,135 @@ pub(crate) fn call_info(db: &RootDatabase, position: FilePosition) -> Option<Cal
     let file = file.syntax();
     let token = file.token_at_offset(position.offset).next()?;
     let token = sema.descend_into_macros(token);
-    call_info_for_token(&sema, token)
-}
 
-#[derive(Debug)]
-pub(crate) struct ActiveParameter {
-    /// FIXME: should be `Type` and `Name
-    pub(crate) ty: String,
-    pub(crate) name: String,
-}
+    let (callable, active_parameter) = call_info_impl(&sema, token)?;
 
-impl ActiveParameter {
-    pub(crate) fn at(db: &RootDatabase, position: FilePosition) -> Option<Self> {
-        call_info(db, position)?.into_active_parameter()
+    let mut res =
+        CallInfo { doc: None, signature: String::new(), parameters: vec![], active_parameter };
+
+    match callable.kind() {
+        hir::CallableKind::Function(func) => {
+            res.doc = func.docs(db).map(|it| it.as_str().to_string());
+            format_to!(res.signature, "fn {}", func.name(db));
+        }
+        hir::CallableKind::TupleStruct(strukt) => {
+            res.doc = strukt.docs(db).map(|it| it.as_str().to_string());
+            format_to!(res.signature, "struct {}", strukt.name(db));
+        }
+        hir::CallableKind::TupleEnumVariant(variant) => {
+            res.doc = variant.docs(db).map(|it| it.as_str().to_string());
+            format_to!(
+                res.signature,
+                "enum {}::{}",
+                variant.parent_enum(db).name(db),
+                variant.name(db)
+            );
+        }
+        hir::CallableKind::Closure => (),
     }
 
-    pub(crate) fn at_token(sema: &Semantics<RootDatabase>, token: SyntaxToken) -> Option<Self> {
-        call_info_for_token(sema, token)?.into_active_parameter()
+    res.signature.push('(');
+    {
+        if let Some(self_param) = callable.receiver_param(db) {
+            format_to!(res.signature, "{}", self_param)
+        }
+        let mut buf = String::new();
+        for (pat, ty) in callable.params(db) {
+            buf.clear();
+            if let Some(pat) = pat {
+                match pat {
+                    Either::Left(_self) => format_to!(buf, "self: "),
+                    Either::Right(pat) => format_to!(buf, "{}: ", pat),
+                }
+            }
+            format_to!(buf, "{}", ty.display(db));
+            res.push_param(&buf);
+        }
     }
+    res.signature.push(')');
+
+    match callable.kind() {
+        hir::CallableKind::Function(_) | hir::CallableKind::Closure => {
+            let ret_type = callable.return_type();
+            if !ret_type.is_unit() {
+                format_to!(res.signature, " -> {}", ret_type.display(db));
+            }
+        }
+        hir::CallableKind::TupleStruct(_) | hir::CallableKind::TupleEnumVariant(_) => {}
+    }
+    Some(res)
 }
 
-fn call_info_for_token(sema: &Semantics<RootDatabase>, token: SyntaxToken) -> Option<CallInfo> {
+fn call_info_impl(
+    sema: &Semantics<RootDatabase>,
+    token: SyntaxToken,
+) -> Option<(hir::Callable, Option<usize>)> {
     // Find the calling expression and it's NameRef
     let calling_node = FnCallNode::with_node(&token.parent())?;
 
-    let (mut call_info, has_self) = match &calling_node {
-        FnCallNode::CallExpr(call) => {
-            //FIXME: Type::as_callable is broken
-            let callable_def = sema.type_of_expr(&call.expr()?)?.as_callable()?;
-            match callable_def {
-                hir::CallableDef::FunctionId(it) => {
-                    let fn_def = it.into();
-                    (CallInfo::with_fn(sema.db, fn_def), fn_def.has_self_param(sema.db))
-                }
-                hir::CallableDef::StructId(it) => {
-                    (CallInfo::with_struct(sema.db, it.into())?, false)
-                }
-                hir::CallableDef::EnumVariantId(it) => {
-                    (CallInfo::with_enum_variant(sema.db, it.into())?, false)
-                }
-            }
-        }
-        FnCallNode::MethodCallExpr(method_call) => {
-            let function = sema.resolve_method_call(&method_call)?;
-            (CallInfo::with_fn(sema.db, function), function.has_self_param(sema.db))
-        }
-        FnCallNode::MacroCallExpr(macro_call) => {
-            let macro_def = sema.resolve_macro_call(&macro_call)?;
-            (CallInfo::with_macro(sema.db, macro_def)?, false)
+    let callable = match &calling_node {
+        FnCallNode::CallExpr(call) => sema.type_of_expr(&call.expr()?)?.as_callable(sema.db)?,
+        FnCallNode::MethodCallExpr(call) => sema.resolve_method_call_as_callable(call)?,
+    };
+    let active_param = if let Some(arg_list) = calling_node.arg_list() {
+        // Number of arguments specified at the call site
+        let num_args_at_callsite = arg_list.args().count();
+
+        let arg_list_range = arg_list.syntax().text_range();
+        if !arg_list_range.contains_inclusive(token.text_range().start()) {
+            mark::hit!(call_info_bad_offset);
+            return None;
         }
+        let param = std::cmp::min(
+            num_args_at_callsite,
+            arg_list
+                .args()
+                .take_while(|arg| arg.syntax().text_range().end() <= token.text_range().start())
+                .count(),
+        );
+
+        Some(param)
+    } else {
+        None
     };
+    Some((callable, active_param))
+}
 
-    // If we have a calling expression let's find which argument we are on
-    let num_params = call_info.parameters().len();
+#[derive(Debug)]
+pub(crate) struct ActiveParameter {
+    pub(crate) ty: Type,
+    pub(crate) name: String,
+}
 
-    match num_params {
-        0 => (),
-        1 => {
-            if !has_self {
-                call_info.active_parameter = Some(0);
-            }
-        }
-        _ => {
-            if let Some(arg_list) = calling_node.arg_list() {
-                // Number of arguments specified at the call site
-                let num_args_at_callsite = arg_list.args().count();
-
-                let arg_list_range = arg_list.syntax().text_range();
-                if !arg_list_range.contains_inclusive(token.text_range().start()) {
-                    mark::hit!(call_info_bad_offset);
-                    return None;
-                }
+impl ActiveParameter {
+    pub(crate) fn at(db: &RootDatabase, position: FilePosition) -> Option<Self> {
+        let sema = Semantics::new(db);
+        let file = sema.parse(position.file_id);
+        let file = file.syntax();
+        let token = file.token_at_offset(position.offset).next()?;
+        let token = sema.descend_into_macros(token);
+        Self::at_token(&sema, token)
+    }
 
-                let mut param = std::cmp::min(
-                    num_args_at_callsite,
-                    arg_list
-                        .args()
-                        .take_while(|arg| {
-                            arg.syntax().text_range().end() < token.text_range().start()
-                        })
-                        .count(),
-                );
-
-                // If we are in a method account for `self`
-                if has_self {
-                    param += 1;
-                }
+    pub(crate) fn at_token(sema: &Semantics<RootDatabase>, token: SyntaxToken) -> Option<Self> {
+        let (signature, active_parameter) = call_info_impl(&sema, token)?;
 
-                call_info.active_parameter = Some(param);
-            }
+        let idx = active_parameter?;
+        let mut params = signature.params(sema.db);
+        if !(idx < params.len()) {
+            mark::hit!(too_many_arguments);
+            return None;
         }
+        let (pat, ty) = params.swap_remove(idx);
+        let name = pat?.to_string();
+        Some(ActiveParameter { ty, name })
     }
-
-    Some(call_info)
 }
 
 #[derive(Debug)]
 pub(crate) enum FnCallNode {
     CallExpr(ast::CallExpr),
     MethodCallExpr(ast::MethodCallExpr),
-    MacroCallExpr(ast::MacroCall),
 }
 
 impl FnCallNode {
@@ -131,7 +190,6 @@ impl FnCallNode {
                         }
                         Some(FnCallNode::MethodCallExpr(it))
                     },
-                    ast::MacroCall(it) => Some(FnCallNode::MacroCallExpr(it)),
                     _ => None,
                 }
             }
@@ -143,7 +201,6 @@ impl FnCallNode {
             match node {
                 ast::CallExpr(it) => Some(FnCallNode::CallExpr(it)),
                 ast::MethodCallExpr(it) => Some(FnCallNode::MethodCallExpr(it)),
-                ast::MacroCall(it) => Some(FnCallNode::MacroCallExpr(it)),
                 _ => None,
             }
         }
@@ -159,8 +216,6 @@ impl FnCallNode {
             FnCallNode::MethodCallExpr(call_expr) => {
                 call_expr.syntax().children().filter_map(ast::NameRef::cast).next()
             }
-
-            FnCallNode::MacroCallExpr(call_expr) => call_expr.path()?.segment()?.name_ref(),
         }
     }
 
@@ -168,214 +223,209 @@ impl FnCallNode {
         match self {
             FnCallNode::CallExpr(expr) => expr.arg_list(),
             FnCallNode::MethodCallExpr(expr) => expr.arg_list(),
-            FnCallNode::MacroCallExpr(_) => None,
         }
     }
 }
 
-impl CallInfo {
-    fn into_active_parameter(self) -> Option<ActiveParameter> {
-        let idx = self.active_parameter?;
-        let ty = self.signature.parameter_types.get(idx)?.clone();
-        let name = self.signature.parameter_names.get(idx)?.clone();
-        let res = ActiveParameter { ty, name };
-        Some(res)
-    }
-
-    fn with_fn(db: &RootDatabase, function: hir::Function) -> Self {
-        let signature = FunctionSignature::from_hir(db, function);
-
-        CallInfo { signature, active_parameter: None }
-    }
-
-    fn with_struct(db: &RootDatabase, st: hir::Struct) -> Option<Self> {
-        let signature = FunctionSignature::from_struct(db, st)?;
-
-        Some(CallInfo { signature, active_parameter: None })
-    }
-
-    fn with_enum_variant(db: &RootDatabase, variant: hir::EnumVariant) -> Option<Self> {
-        let signature = FunctionSignature::from_enum_variant(db, variant)?;
-
-        Some(CallInfo { signature, active_parameter: None })
-    }
-
-    fn with_macro(db: &RootDatabase, macro_def: hir::MacroDef) -> Option<Self> {
-        let signature = FunctionSignature::from_macro(db, macro_def)?;
-
-        Some(CallInfo { signature, active_parameter: None })
-    }
-
-    fn parameters(&self) -> &[String] {
-        &self.signature.parameters
-    }
-}
-
 #[cfg(test)]
 mod tests {
+    use expect::{expect, Expect};
     use test_utils::mark;
 
     use crate::mock_analysis::analysis_and_position;
 
-    use super::*;
-
-    // These are only used when testing
-    impl CallInfo {
-        fn doc(&self) -> Option<hir::Documentation> {
-            self.signature.doc.clone()
-        }
-
-        fn label(&self) -> String {
-            self.signature.to_string()
-        }
-    }
-
-    fn call_info_helper(text: &str) -> Option<CallInfo> {
-        let (analysis, position) = analysis_and_position(text);
-        analysis.call_info(position).unwrap()
-    }
-
-    fn call_info(text: &str) -> CallInfo {
-        let info = call_info_helper(text);
-        assert!(info.is_some());
-        info.unwrap()
-    }
-
-    fn no_call_info(text: &str) {
-        let info = call_info_helper(text);
-        assert!(info.is_none());
+    fn check(ra_fixture: &str, expect: Expect) {
+        let (analysis, position) = analysis_and_position(ra_fixture);
+        let call_info = analysis.call_info(position).unwrap();
+        let actual = match call_info {
+            Some(call_info) => {
+                let docs = match &call_info.doc {
+                    None => "".to_string(),
+                    Some(docs) => format!("{}\n------\n", docs.as_str()),
+                };
+                let params = call_info
+                    .parameter_labels()
+                    .enumerate()
+                    .map(|(i, param)| {
+                        if Some(i) == call_info.active_parameter {
+                            format!("<{}>", param)
+                        } else {
+                            param.to_string()
+                        }
+                    })
+                    .collect::<Vec<_>>()
+                    .join(", ");
+                format!("{}{}\n({})\n", docs, call_info.signature, params)
+            }
+            None => String::new(),
+        };
+        expect.assert_eq(&actual);
     }
 
     #[test]
-    fn test_fn_signature_two_args_firstx() {
-        let info = call_info(
-            r#"fn foo(x: u32, y: u32) -> u32 {x + y}
-fn bar() { foo(<|>3, ); }"#,
+    fn test_fn_signature_two_args() {
+        check(
+            r#"
+fn foo(x: u32, y: u32) -> u32 {x + y}
+fn bar() { foo(<|>3, ); }
+"#,
+            expect![[r#"
+                fn foo(x: u32, y: u32) -> u32
+                (<x: u32>, y: u32)
+            "#]],
         );
-
-        assert_eq!(info.parameters(), ["x: u32", "y: u32"]);
-        assert_eq!(info.active_parameter, Some(0));
-    }
-
-    #[test]
-    fn test_fn_signature_two_args_second() {
-        let info = call_info(
-            r#"fn foo(x: u32, y: u32) -> u32 {x + y}
-fn bar() { foo(3, <|>); }"#,
+        check(
+            r#"
+fn foo(x: u32, y: u32) -> u32 {x + y}
+fn bar() { foo(3<|>, ); }
+"#,
+            expect![[r#"
+                fn foo(x: u32, y: u32) -> u32
+                (<x: u32>, y: u32)
+            "#]],
+        );
+        check(
+            r#"
+fn foo(x: u32, y: u32) -> u32 {x + y}
+fn bar() { foo(3,<|> ); }
+"#,
+            expect![[r#"
+                fn foo(x: u32, y: u32) -> u32
+                (x: u32, <y: u32>)
+            "#]],
+        );
+        check(
+            r#"
+fn foo(x: u32, y: u32) -> u32 {x + y}
+fn bar() { foo(3, <|>); }
+"#,
+            expect![[r#"
+                fn foo(x: u32, y: u32) -> u32
+                (x: u32, <y: u32>)
+            "#]],
         );
-
-        assert_eq!(info.parameters(), ["x: u32", "y: u32"]);
-        assert_eq!(info.active_parameter, Some(1));
     }
 
     #[test]
     fn test_fn_signature_two_args_empty() {
-        let info = call_info(
-            r#"fn foo(x: u32, y: u32) -> u32 {x + y}
-fn bar() { foo(<|>); }"#,
+        check(
+            r#"
+fn foo(x: u32, y: u32) -> u32 {x + y}
+fn bar() { foo(<|>); }
+"#,
+            expect![[r#"
+                fn foo(x: u32, y: u32) -> u32
+                (<x: u32>, y: u32)
+            "#]],
         );
-
-        assert_eq!(info.parameters(), ["x: u32", "y: u32"]);
-        assert_eq!(info.active_parameter, Some(0));
     }
 
     #[test]
     fn test_fn_signature_two_args_first_generics() {
-        let info = call_info(
-            r#"fn foo<T, U: Copy + Display>(x: T, y: U) -> u32 where T: Copy + Display, U: Debug {x + y}
-fn bar() { foo(<|>3, ); }"#,
-        );
-
-        assert_eq!(info.parameters(), ["x: T", "y: U"]);
-        assert_eq!(
-            info.label(),
+        check(
             r#"
 fn foo<T, U: Copy + Display>(x: T, y: U) -> u32
-where T: Copy + Display,
-      U: Debug
-    "#
-            .trim()
+    where T: Copy + Display, U: Debug
+{ x + y }
+
+fn bar() { foo(<|>3, ); }
+"#,
+            expect![[r#"
+                fn foo(x: i32, y: {unknown}) -> u32
+                (<x: i32>, y: {unknown})
+            "#]],
         );
-        assert_eq!(info.active_parameter, Some(0));
     }
 
     #[test]
     fn test_fn_signature_no_params() {
-        let info = call_info(
-            r#"fn foo<T>() -> T where T: Copy + Display {}
-fn bar() { foo(<|>); }"#,
-        );
-
-        assert!(info.parameters().is_empty());
-        assert_eq!(
-            info.label(),
+        check(
             r#"
-fn foo<T>() -> T
-where T: Copy + Display
-    "#
-            .trim()
+fn foo<T>() -> T where T: Copy + Display {}
+fn bar() { foo(<|>); }
+"#,
+            expect![[r#"
+                fn foo() -> {unknown}
+                ()
+            "#]],
         );
-        assert!(info.active_parameter.is_none());
     }
 
     #[test]
     fn test_fn_signature_for_impl() {
-        let info = call_info(
-            r#"struct F; impl F { pub fn new() { F{}} }
-fn bar() {let _ : F = F::new(<|>);}"#,
+        check(
+            r#"
+struct F;
+impl F { pub fn new() { } }
+fn bar() {
+    let _ : F = F::new(<|>);
+}
+"#,
+            expect![[r#"
+                fn new()
+                ()
+            "#]],
         );
-
-        assert!(info.parameters().is_empty());
-        assert_eq!(info.active_parameter, None);
     }
 
     #[test]
     fn test_fn_signature_for_method_self() {
-        let info = call_info(
-            r#"struct F;
-impl F {
-    pub fn new() -> F{
-        F{}
-    }
-
-    pub fn do_it(&self) {}
-}
+        check(
+            r#"
+struct S;
+impl S { pub fn do_it(&self) {} }
 
 fn bar() {
-    let f : F = F::new();
-    f.do_it(<|>);
-}"#,
+    let s: S = S;
+    s.do_it(<|>);
+}
+"#,
+            expect![[r#"
+                fn do_it(&self)
+                ()
+            "#]],
         );
-
-        assert_eq!(info.parameters(), ["&self"]);
-        assert_eq!(info.active_parameter, None);
     }
 
     #[test]
     fn test_fn_signature_for_method_with_arg() {
-        let info = call_info(
-            r#"struct F;
-impl F {
-    pub fn new() -> F{
-        F{}
+        check(
+            r#"
+struct S;
+impl S {
+    fn foo(&self, x: i32) {}
+}
+
+fn main() { S.foo(<|>); }
+"#,
+            expect![[r#"
+                fn foo(&self, x: i32)
+                (<x: i32>)
+            "#]],
+        );
     }
 
-    pub fn do_it(&self, x: i32) {}
+    #[test]
+    fn test_fn_signature_for_method_with_arg_as_assoc_fn() {
+        check(
+            r#"
+struct S;
+impl S {
+    fn foo(&self, x: i32) {}
 }
 
-fn bar() {
-    let f : F = F::new();
-    f.do_it(<|>);
-}"#,
+fn main() { S::foo(<|>); }
+"#,
+            expect![[r#"
+                fn foo(self: &S, x: i32)
+                (<self: &S>, x: i32)
+            "#]],
         );
-
-        assert_eq!(info.parameters(), ["&self", "x: i32"]);
-        assert_eq!(info.active_parameter, Some(1));
     }
 
     #[test]
     fn test_fn_signature_with_docs_simple() {
-        let info = call_info(
+        check(
             r#"
 /// test
 // non-doc-comment
@@ -387,17 +437,18 @@ fn bar() {
     let _ = foo(<|>);
 }
 "#,
+            expect![[r#"
+                test
+                ------
+                fn foo(j: u32) -> u32
+                (<j: u32>)
+            "#]],
         );
-
-        assert_eq!(info.parameters(), ["j: u32"]);
-        assert_eq!(info.active_parameter, Some(0));
-        assert_eq!(info.label(), "fn foo(j: u32) -> u32");
-        assert_eq!(info.doc().map(|it| it.into()), Some("test".to_string()));
     }
 
     #[test]
     fn test_fn_signature_with_docs() {
-        let info = call_info(
+        check(
             r#"
 /// Adds one to the number given.
 ///
@@ -415,31 +466,26 @@ pub fn add_one(x: i32) -> i32 {
 pub fn do() {
     add_one(<|>
 }"#,
-        );
-
-        assert_eq!(info.parameters(), ["x: i32"]);
-        assert_eq!(info.active_parameter, Some(0));
-        assert_eq!(info.label(), "pub fn add_one(x: i32) -> i32");
-        assert_eq!(
-            info.doc().map(|it| it.into()),
-            Some(
-                r#"Adds one to the number given.
+            expect![[r##"
+                Adds one to the number given.
 
-# Examples
+                # Examples
 
-```
-let five = 5;
+                ```
+                let five = 5;
 
-assert_eq!(6, my_crate::add_one(5));
-```"#
-                    .to_string()
-            )
+                assert_eq!(6, my_crate::add_one(5));
+                ```
+                ------
+                fn add_one(x: i32) -> i32
+                (<x: i32>)
+            "##]],
         );
     }
 
     #[test]
     fn test_fn_signature_with_docs_impl() {
-        let info = call_info(
+        check(
             r#"
 struct addr;
 impl addr {
@@ -460,32 +506,28 @@ impl addr {
 pub fn do_it() {
     addr {};
     addr::add_one(<|>);
-}"#,
-        );
-
-        assert_eq!(info.parameters(), ["x: i32"]);
-        assert_eq!(info.active_parameter, Some(0));
-        assert_eq!(info.label(), "pub fn add_one(x: i32) -> i32");
-        assert_eq!(
-            info.doc().map(|it| it.into()),
-            Some(
-                r#"Adds one to the number given.
+}
+"#,
+            expect![[r##"
+                Adds one to the number given.
 
-# Examples
+                # Examples
 
-```
-let five = 5;
+                ```
+                let five = 5;
 
-assert_eq!(6, my_crate::add_one(5));
-```"#
-                    .to_string()
-            )
+                assert_eq!(6, my_crate::add_one(5));
+                ```
+                ------
+                fn add_one(x: i32) -> i32
+                (<x: i32>)
+            "##]],
         );
     }
 
     #[test]
     fn test_fn_signature_with_docs_from_actix() {
-        let info = call_info(
+        check(
             r#"
 struct WriteHandler<E>;
 
@@ -509,101 +551,89 @@ impl<E> WriteHandler<E> {
 pub fn foo(mut r: WriteHandler<()>) {
     r.finished(<|>);
 }
-
 "#,
-        );
-
-        assert_eq!(info.label(), "fn finished(&mut self, ctx: &mut Self::Context)".to_string());
-        assert_eq!(info.parameters(), ["&mut self", "ctx: &mut Self::Context"]);
-        assert_eq!(info.active_parameter, Some(1));
-        assert_eq!(
-            info.doc().map(|it| it.into()),
-            Some(
-                r#"Method is called when writer finishes.
-
-By default this method stops actor's `Context`."#
-                    .to_string()
-            )
+            expect![[r#"
+                Method is called when writer finishes.
+
+                By default this method stops actor's `Context`.
+                ------
+                fn finished(&mut self, ctx: &mut {unknown})
+                (<ctx: &mut {unknown}>)
+            "#]],
         );
     }
 
     #[test]
     fn call_info_bad_offset() {
         mark::check!(call_info_bad_offset);
-        let (analysis, position) = analysis_and_position(
-            r#"fn foo(x: u32, y: u32) -> u32 {x + y}
-               fn bar() { foo <|> (3, ); }"#,
+        check(
+            r#"
+fn foo(x: u32, y: u32) -> u32 {x + y}
+fn bar() { foo <|> (3, ); }
+"#,
+            expect![[""]],
         );
-        let call_info = analysis.call_info(position).unwrap();
-        assert!(call_info.is_none());
     }
 
     #[test]
-    fn test_nested_method_in_lamba() {
-        let info = call_info(
-            r#"struct Foo;
-
-impl Foo {
-    fn bar(&self, _: u32) { }
-}
+    fn test_nested_method_in_lambda() {
+        check(
+            r#"
+struct Foo;
+impl Foo { fn bar(&self, _: u32) { } }
 
 fn bar(_: u32) { }
 
 fn main() {
     let foo = Foo;
     std::thread::spawn(move || foo.bar(<|>));
-}"#,
+}
+"#,
+            expect![[r#"
+                fn bar(&self, _: u32)
+                (<_: u32>)
+            "#]],
         );
-
-        assert_eq!(info.parameters(), ["&self", "_: u32"]);
-        assert_eq!(info.active_parameter, Some(1));
-        assert_eq!(info.label(), "fn bar(&self, _: u32)");
     }
 
     #[test]
     fn works_for_tuple_structs() {
-        let info = call_info(
+        check(
             r#"
 /// A cool tuple struct
-struct TS(u32, i32);
+struct S(u32, i32);
 fn main() {
-    let s = TS(0, <|>);
-}"#,
+    let s = S(0, <|>);
+}
+"#,
+            expect![[r#"
+                A cool tuple struct
+                ------
+                struct S(u32, i32)
+                (u32, <i32>)
+            "#]],
         );
-
-        assert_eq!(info.label(), "struct TS(u32, i32) -> TS");
-        assert_eq!(info.doc().map(|it| it.into()), Some("A cool tuple struct".to_string()));
-        assert_eq!(info.active_parameter, Some(1));
     }
 
     #[test]
     fn generic_struct() {
-        let info = call_info(
+        check(
             r#"
-struct TS<T>(T);
+struct S<T>(T);
 fn main() {
-    let s = TS(<|>);
-}"#,
-        );
-
-        assert_eq!(info.label(), "struct TS<T>(T) -> TS");
-        assert_eq!(info.active_parameter, Some(0));
-    }
-
-    #[test]
-    fn cant_call_named_structs() {
-        no_call_info(
-            r#"
-struct TS { x: u32, y: i32 }
-fn main() {
-    let s = TS(<|>);
-}"#,
+    let s = S(<|>);
+}
+"#,
+            expect![[r#"
+                struct S({unknown})
+                (<{unknown}>)
+            "#]],
         );
     }
 
     #[test]
     fn works_for_enum_variants() {
-        let info = call_info(
+        check(
             r#"
 enum E {
     /// A Variant
@@ -617,17 +647,32 @@ enum E {
 fn main() {
     let a = E::A(<|>);
 }
-            "#,
+"#,
+            expect![[r#"
+                A Variant
+                ------
+                enum E::A(i32)
+                (<i32>)
+            "#]],
         );
+    }
 
-        assert_eq!(info.label(), "E::A(0: i32)");
-        assert_eq!(info.doc().map(|it| it.into()), Some("A Variant".to_string()));
-        assert_eq!(info.active_parameter, Some(0));
+    #[test]
+    fn cant_call_struct_record() {
+        check(
+            r#"
+struct S { x: u32, y: i32 }
+fn main() {
+    let s = S(<|>);
+}
+"#,
+            expect![[""]],
+        );
     }
 
     #[test]
-    fn cant_call_enum_records() {
-        no_call_info(
+    fn cant_call_enum_record() {
+        check(
             r#"
 enum E {
     /// A Variant
@@ -641,47 +686,57 @@ enum E {
 fn main() {
     let a = E::C(<|>);
 }
-            "#,
+"#,
+            expect![[""]],
         );
     }
 
     #[test]
-    fn fn_signature_for_macro() {
-        let info = call_info(
+    fn fn_signature_for_call_in_macro() {
+        check(
             r#"
-/// empty macro
-macro_rules! foo {
-    () => {}
+macro_rules! id { ($($tt:tt)*) => { $($tt)* } }
+fn foo() { }
+id! {
+    fn bar() { foo(<|>); }
 }
+"#,
+            expect![[r#"
+                fn foo()
+                ()
+            "#]],
+        );
+    }
 
-fn f() {
-    foo!(<|>);
+    #[test]
+    fn call_info_for_lambdas() {
+        check(
+            r#"
+struct S;
+fn foo(s: S) -> i32 { 92 }
+fn main() {
+    (|s| foo(s))(<|>)
 }
         "#,
-        );
-
-        assert_eq!(info.label(), "foo!()");
-        assert_eq!(info.doc().map(|it| it.into()), Some("empty macro".to_string()));
+            expect![[r#"
+                (S) -> i32
+                (<S>)
+            "#]],
+        )
     }
 
     #[test]
-    fn fn_signature_for_call_in_macro() {
-        let info = call_info(
+    fn call_info_for_fn_ptr() {
+        check(
             r#"
-            macro_rules! id {
-                ($($tt:tt)*) => { $($tt)* }
-            }
-            fn foo() {
-
-            }
-            id! {
-                fn bar() {
-                    foo(<|>);
-                }
-            }
-            "#,
-        );
-
-        assert_eq!(info.label(), "fn foo()");
+fn main(f: fn(i32, f64) -> char) {
+    f(0, <|>)
+}
+        "#,
+            expect![[r#"
+                (i32, f64) -> char
+                (i32, <f64>)
+            "#]],
+        )
     }
 }
diff --git a/crates/ra_ide/src/completion.rs b/crates/ra_ide/src/completion.rs
index e1fcf379d..68ac05e4c 100644
--- a/crates/ra_ide/src/completion.rs
+++ b/crates/ra_ide/src/completion.rs
@@ -2,6 +2,9 @@ mod completion_config;
 mod completion_item;
 mod completion_context;
 mod presentation;
+mod patterns;
+#[cfg(test)]
+mod test_utils;
 
 mod complete_attribute;
 mod complete_dot;
@@ -15,9 +18,6 @@ mod complete_unqualified_path;
 mod complete_postfix;
 mod complete_macro_in_item_position;
 mod complete_trait_impl;
-mod patterns;
-#[cfg(test)]
-mod test_utils;
 
 use ra_ide_db::RootDatabase;
 
@@ -63,11 +63,11 @@ pub use crate::completion::{
 // There also snippet completions:
 //
 // .Expressions
-// - `pd` -> `println!("{:?}")`
-// - `ppd` -> `println!("{:#?}")`
+// - `pd` -> `eprintln!(" = {:?}", );`
+// - `ppd` -> `eprintln!(" = {:#?}", );`
 //
 // .Items
-// - `tfn` -> `#[test] fn f(){}`
+// - `tfn` -> `#[test] fn feature(){}`
 // - `tmod` ->
 // ```rust
 // #[cfg(test)]
@@ -75,7 +75,7 @@ pub use crate::completion::{
 //     use super::*;
 //
 //     #[test]
-//     fn test_fn() {}
+//     fn test_name() {}
 // }
 // ```
 
@@ -137,8 +137,8 @@ mod tests {
         documentation: &'a str,
     }
 
-    fn check_detail_and_documentation(fixture: &str, expected: DetailAndDocumentation) {
-        let (analysis, position) = analysis_and_position(fixture);
+    fn check_detail_and_documentation(ra_fixture: &str, expected: DetailAndDocumentation) {
+        let (analysis, position) = analysis_and_position(ra_fixture);
         let config = CompletionConfig::default();
         let completions = analysis.completions(&config, position).unwrap().unwrap();
         for item in completions {
diff --git a/crates/ra_ide/src/completion/complete_attribute.rs b/crates/ra_ide/src/completion/complete_attribute.rs
index 6beeca457..2faaae974 100644
--- a/crates/ra_ide/src/completion/complete_attribute.rs
+++ b/crates/ra_ide/src/completion/complete_attribute.rs
@@ -13,14 +13,18 @@ use crate::completion::{
 
 pub(super) fn complete_attribute(acc: &mut Completions, ctx: &CompletionContext) -> Option<()> {
     let attribute = ctx.attribute_under_caret.as_ref()?;
-
-    match (attribute.path(), attribute.input()) {
-        (Some(path), Some(ast::AttrInput::TokenTree(token_tree)))
-            if path.to_string() == "derive" =>
-        {
+    match (attribute.path(), attribute.token_tree()) {
+        (Some(path), Some(token_tree)) if path.to_string() == "derive" => {
             complete_derive(acc, ctx, token_tree)
         }
-        (_, Some(ast::AttrInput::TokenTree(_token_tree))) => {}
+        (Some(path), Some(token_tree))
+            if ["allow", "warn", "deny", "forbid"]
+                .iter()
+                .any(|lint_level| lint_level == &path.to_string()) =>
+        {
+            complete_lint(acc, ctx, token_tree)
+        }
+        (_, Some(_token_tree)) => {}
         _ => complete_attribute_start(acc, ctx, attribute),
     }
     Some(())
@@ -46,7 +50,7 @@ fn complete_attribute_start(acc: &mut Completions, ctx: &CompletionContext, attr
             _ => {}
         }
 
-        if attribute.kind() == ast::AttrKind::Inner || !attr_completion.should_be_inner {
+        if attribute.kind() == ast::AttrKind::Inner || !attr_completion.prefer_inner {
             acc.add(item);
         }
     }
@@ -56,163 +60,76 @@ struct AttrCompletion {
     label: &'static str,
     lookup: Option<&'static str>,
     snippet: Option<&'static str>,
-    should_be_inner: bool,
+    prefer_inner: bool,
+}
+
+impl AttrCompletion {
+    const fn prefer_inner(self) -> AttrCompletion {
+        AttrCompletion { prefer_inner: true, ..self }
+    }
+}
+
+const fn attr(
+    label: &'static str,
+    lookup: Option<&'static str>,
+    snippet: Option<&'static str>,
+) -> AttrCompletion {
+    AttrCompletion { label, lookup, snippet, prefer_inner: false }
 }
 
 const ATTRIBUTES: &[AttrCompletion] = &[
-    AttrCompletion {
-        label: "allow(…)",
-        snippet: Some("allow(${0:lint})"),
-        should_be_inner: false,
-        lookup: Some("allow"),
-    },
-    AttrCompletion {
-        label: "cfg_attr(…)",
-        snippet: Some("cfg_attr(${1:predicate}, ${0:attr})"),
-        should_be_inner: false,
-        lookup: Some("cfg_attr"),
-    },
-    AttrCompletion {
-        label: "cfg(…)",
-        snippet: Some("cfg(${0:predicate})"),
-        should_be_inner: false,
-        lookup: Some("cfg"),
-    },
-    AttrCompletion {
-        label: "deny(…)",
-        snippet: Some("deny(${0:lint})"),
-        should_be_inner: false,
-        lookup: Some("deny"),
-    },
-    AttrCompletion {
-        label: r#"deprecated = "…""#,
-        snippet: Some(r#"deprecated = "${0:reason}""#),
-        should_be_inner: false,
-        lookup: Some("deprecated"),
-    },
-    AttrCompletion {
-        label: "derive(…)",
-        snippet: Some(r#"derive(${0:Debug})"#),
-        should_be_inner: false,
-        lookup: Some("derive"),
-    },
-    AttrCompletion {
-        label: r#"doc = "…""#,
-        snippet: Some(r#"doc = "${0:docs}""#),
-        should_be_inner: false,
-        lookup: Some("doc"),
-    },
-    AttrCompletion {
-        label: "feature(…)",
-        snippet: Some("feature(${0:flag})"),
-        should_be_inner: true,
-        lookup: Some("feature"),
-    },
-    AttrCompletion {
-        label: "forbid(…)",
-        snippet: Some("forbid(${0:lint})"),
-        should_be_inner: false,
-        lookup: Some("forbid"),
-    },
+    attr("allow(…)", Some("allow"), Some("allow(${0:lint})")),
+    attr("cfg_attr(…)", Some("cfg_attr"), Some("cfg_attr(${1:predicate}, ${0:attr})")),
+    attr("cfg(…)", Some("cfg"), Some("cfg(${0:predicate})")),
+    attr("deny(…)", Some("deny"), Some("deny(${0:lint})")),
+    attr(r#"deprecated = "…""#, Some("deprecated"), Some(r#"deprecated = "${0:reason}""#)),
+    attr("derive(…)", Some("derive"), Some(r#"derive(${0:Debug})"#)),
+    attr(r#"doc = "…""#, Some("doc"), Some(r#"doc = "${0:docs}""#)),
+    attr("feature(…)", Some("feature"), Some("feature(${0:flag})")).prefer_inner(),
+    attr("forbid(…)", Some("forbid"), Some("forbid(${0:lint})")),
     // FIXME: resolve through macro resolution?
-    AttrCompletion {
-        label: "global_allocator",
-        snippet: None,
-        should_be_inner: true,
-        lookup: None,
-    },
-    AttrCompletion {
-        label: "ignore(…)",
-        snippet: Some("ignore(${0:lint})"),
-        should_be_inner: false,
-        lookup: Some("ignore"),
-    },
-    AttrCompletion {
-        label: "inline(…)",
-        snippet: Some("inline(${0:lint})"),
-        should_be_inner: false,
-        lookup: Some("inline"),
-    },
-    AttrCompletion {
-        label: r#"link_name = "…""#,
-        snippet: Some(r#"link_name = "${0:symbol_name}""#),
-        should_be_inner: false,
-        lookup: Some("link_name"),
-    },
-    AttrCompletion { label: "link", snippet: None, should_be_inner: false, lookup: None },
-    AttrCompletion { label: "macro_export", snippet: None, should_be_inner: false, lookup: None },
-    AttrCompletion { label: "macro_use", snippet: None, should_be_inner: false, lookup: None },
-    AttrCompletion {
-        label: r#"must_use = "…""#,
-        snippet: Some(r#"must_use = "${0:reason}""#),
-        should_be_inner: false,
-        lookup: Some("must_use"),
-    },
-    AttrCompletion { label: "no_mangle", snippet: None, should_be_inner: false, lookup: None },
-    AttrCompletion { label: "no_std", snippet: None, should_be_inner: true, lookup: None },
-    AttrCompletion { label: "non_exhaustive", snippet: None, should_be_inner: false, lookup: None },
-    AttrCompletion { label: "panic_handler", snippet: None, should_be_inner: true, lookup: None },
-    AttrCompletion {
-        label: "path = \"…\"",
-        snippet: Some("path =\"${0:path}\""),
-        should_be_inner: false,
-        lookup: Some("path"),
-    },
-    AttrCompletion { label: "proc_macro", snippet: None, should_be_inner: false, lookup: None },
-    AttrCompletion {
-        label: "proc_macro_attribute",
-        snippet: None,
-        should_be_inner: false,
-        lookup: None,
-    },
-    AttrCompletion {
-        label: "proc_macro_derive(…)",
-        snippet: Some("proc_macro_derive(${0:Trait})"),
-        should_be_inner: false,
-        lookup: Some("proc_macro_derive"),
-    },
-    AttrCompletion {
-        label: "recursion_limit = …",
-        snippet: Some("recursion_limit = ${0:128}"),
-        should_be_inner: true,
-        lookup: Some("recursion_limit"),
-    },
-    AttrCompletion {
-        label: "repr(…)",
-        snippet: Some("repr(${0:C})"),
-        should_be_inner: false,
-        lookup: Some("repr"),
-    },
-    AttrCompletion {
-        label: "should_panic(…)",
-        snippet: Some(r#"should_panic(expected = "${0:reason}")"#),
-        should_be_inner: false,
-        lookup: Some("should_panic"),
-    },
-    AttrCompletion {
-        label: r#"target_feature = "…""#,
-        snippet: Some("target_feature = \"${0:feature}\""),
-        should_be_inner: false,
-        lookup: Some("target_feature"),
-    },
-    AttrCompletion { label: "test", snippet: None, should_be_inner: false, lookup: None },
-    AttrCompletion { label: "used", snippet: None, should_be_inner: false, lookup: None },
-    AttrCompletion {
-        label: "warn(…)",
-        snippet: Some("warn(${0:lint})"),
-        should_be_inner: false,
-        lookup: Some("warn"),
-    },
-    AttrCompletion {
-        label: r#"windows_subsystem = "…""#,
-        snippet: Some(r#"windows_subsystem = "${0:subsystem}""#),
-        should_be_inner: true,
-        lookup: Some("windows_subsystem"),
-    },
+    attr("global_allocator", None, None).prefer_inner(),
+    attr(r#"ignore = "…""#, Some("ignore"), Some(r#"ignore = "${0:reason}""#)),
+    attr("inline(…)", Some("inline"), Some("inline(${0:lint})")),
+    attr(r#"link_name = "…""#, Some("link_name"), Some(r#"link_name = "${0:symbol_name}""#)),
+    attr("link", None, None),
+    attr("macro_export", None, None),
+    attr("macro_use", None, None),
+    attr(r#"must_use = "…""#, Some("must_use"), Some(r#"must_use = "${0:reason}""#)),
+    attr("no_mangle", None, None),
+    attr("no_std", None, None).prefer_inner(),
+    attr("non_exhaustive", None, None),
+    attr("panic_handler", None, None).prefer_inner(),
+    attr("path = \"…\"", Some("path"), Some("path =\"${0:path}\"")),
+    attr("proc_macro", None, None),
+    attr("proc_macro_attribute", None, None),
+    attr("proc_macro_derive(…)", Some("proc_macro_derive"), Some("proc_macro_derive(${0:Trait})")),
+    attr("recursion_limit = …", Some("recursion_limit"), Some("recursion_limit = ${0:128}"))
+        .prefer_inner(),
+    attr("repr(…)", Some("repr"), Some("repr(${0:C})")),
+    attr(
+        "should_panic(…)",
+        Some("should_panic"),
+        Some(r#"should_panic(expected = "${0:reason}")"#),
+    ),
+    attr(
+        r#"target_feature = "…""#,
+        Some("target_feature"),
+        Some("target_feature = \"${0:feature}\""),
+    ),
+    attr("test", None, None),
+    attr("used", None, None),
+    attr("warn(…)", Some("warn"), Some("warn(${0:lint})")),
+    attr(
+        r#"windows_subsystem = "…""#,
+        Some("windows_subsystem"),
+        Some(r#"windows_subsystem = "${0:subsystem}""#),
+    )
+    .prefer_inner(),
 ];
 
 fn complete_derive(acc: &mut Completions, ctx: &CompletionContext, derive_input: ast::TokenTree) {
-    if let Ok(existing_derives) = parse_derive_input(derive_input) {
+    if let Ok(existing_derives) = parse_comma_sep_input(derive_input) {
         for derive_completion in DEFAULT_DERIVE_COMPLETIONS
             .into_iter()
             .filter(|completion| !existing_derives.contains(completion.label))
@@ -245,7 +162,26 @@ fn complete_derive(acc: &mut Completions, ctx: &CompletionContext, derive_input:
     }
 }
 
-fn parse_derive_input(derive_input: ast::TokenTree) -> Result<FxHashSet<String>, ()> {
+fn complete_lint(acc: &mut Completions, ctx: &CompletionContext, derive_input: ast::TokenTree) {
+    if let Ok(existing_lints) = parse_comma_sep_input(derive_input) {
+        for lint_completion in DEFAULT_LINT_COMPLETIONS
+            .into_iter()
+            .filter(|completion| !existing_lints.contains(completion.label))
+        {
+            acc.add(
+                CompletionItem::new(
+                    CompletionKind::Attribute,
+                    ctx.source_range(),
+                    lint_completion.label,
+                )
+                .kind(CompletionItemKind::Attribute)
+                .detail(lint_completion.description),
+            );
+        }
+    }
+}
+
+fn parse_comma_sep_input(derive_input: ast::TokenTree) -> Result<FxHashSet<String>, ()> {
     match (derive_input.left_delimiter_token(), derive_input.right_delimiter_token()) {
         (Some(left_paren), Some(right_paren))
             if left_paren.kind() == SyntaxKind::L_PAREN
@@ -282,7 +218,7 @@ fn parse_derive_input(derive_input: ast::TokenTree) -> Result<FxHashSet<String>,
 
 fn get_derive_names_in_scope(ctx: &CompletionContext) -> FxHashSet<String> {
     let mut result = FxHashSet::default();
-    ctx.scope().process_all_names(&mut |name, scope_def| {
+    ctx.scope.process_all_names(&mut |name, scope_def| {
         if let hir::ScopeDef::MacroDef(mac) = scope_def {
             if mac.is_derive_macro() {
                 result.insert(name.to_string());
@@ -299,6 +235,7 @@ struct DeriveCompletion {
 
 /// Standard Rust derives and the information about their dependencies
 /// (the dependencies are needed so that the main derive don't break the compilation when added)
+#[rustfmt::skip]
 const DEFAULT_DERIVE_COMPLETIONS: &[DeriveCompletion] = &[
     DeriveCompletion { label: "Clone", dependencies: &[] },
     DeriveCompletion { label: "Copy", dependencies: &["Clone"] },
@@ -311,679 +248,397 @@ const DEFAULT_DERIVE_COMPLETIONS: &[DeriveCompletion] = &[
     DeriveCompletion { label: "Ord", dependencies: &["PartialOrd", "Eq", "PartialEq"] },
 ];
 
+struct LintCompletion {
+    label: &'static str,
+    description: &'static str,
+}
+
+#[rustfmt::skip]
+const DEFAULT_LINT_COMPLETIONS: &[LintCompletion] = &[
+    LintCompletion { label: "absolute_paths_not_starting_with_crate", description: r#"fully qualified paths that start with a module name instead of `crate`, `self`, or an extern crate name"# },
+    LintCompletion { label: "anonymous_parameters", description: r#"detects anonymous parameters"# },
+    LintCompletion { label: "box_pointers", description: r#"use of owned (Box type) heap memory"# },
+    LintCompletion { label: "deprecated_in_future", description: r#"detects use of items that will be deprecated in a future version"# },
+    LintCompletion { label: "elided_lifetimes_in_paths", description: r#"hidden lifetime parameters in types are deprecated"# },
+    LintCompletion { label: "explicit_outlives_requirements", description: r#"outlives requirements can be inferred"# },
+    LintCompletion { label: "indirect_structural_match", description: r#"pattern with const indirectly referencing non-structural-match type"# },
+    LintCompletion { label: "keyword_idents", description: r#"detects edition keywords being used as an identifier"# },
+    LintCompletion { label: "macro_use_extern_crate", description: r#"the `#[macro_use]` attribute is now deprecated in favor of using macros via the module system"# },
+    LintCompletion { label: "meta_variable_misuse", description: r#"possible meta-variable misuse at macro definition"# },
+    LintCompletion { label: "missing_copy_implementations", description: r#"detects potentially-forgotten implementations of `Copy`"# },
+    LintCompletion { label: "missing_crate_level_docs", description: r#"detects crates with no crate-level documentation"# },
+    LintCompletion { label: "missing_debug_implementations", description: r#"detects missing implementations of Debug"# },
+    LintCompletion { label: "missing_docs", description: r#"detects missing documentation for public members"# },
+    LintCompletion { label: "missing_doc_code_examples", description: r#"detects publicly-exported items without code samples in their documentation"# },
+    LintCompletion { label: "non_ascii_idents", description: r#"detects non-ASCII identifiers"# },
+    LintCompletion { label: "private_doc_tests", description: r#"detects code samples in docs of private items not documented by rustdoc"# },
+    LintCompletion { label: "single_use_lifetimes", description: r#"detects lifetime parameters that are only used once"# },
+    LintCompletion { label: "trivial_casts", description: r#"detects trivial casts which could be removed"# },
+    LintCompletion { label: "trivial_numeric_casts", description: r#"detects trivial casts of numeric types which could be removed"# },
+    LintCompletion { label: "unaligned_references", description: r#"detects unaligned references to fields of packed structs"# },
+    LintCompletion { label: "unreachable_pub", description: r#"`pub` items not reachable from crate root"# },
+    LintCompletion { label: "unsafe_code", description: r#"usage of `unsafe` code"# },
+    LintCompletion { label: "unsafe_op_in_unsafe_fn", description: r#"unsafe operations in unsafe functions without an explicit unsafe block are deprecated"# },
+    LintCompletion { label: "unstable_features", description: r#"enabling unstable features (deprecated. do not use)"# },
+    LintCompletion { label: "unused_crate_dependencies", description: r#"crate dependencies that are never used"# },
+    LintCompletion { label: "unused_extern_crates", description: r#"extern crates that are never used"# },
+    LintCompletion { label: "unused_import_braces", description: r#"unnecessary braces around an imported item"# },
+    LintCompletion { label: "unused_lifetimes", description: r#"detects lifetime parameters that are never used"# },
+    LintCompletion { label: "unused_qualifications", description: r#"detects unnecessarily qualified names"# },
+    LintCompletion { label: "unused_results", description: r#"unused result of an expression in a statement"# },
+    LintCompletion { label: "variant_size_differences", description: r#"detects enums with widely varying variant sizes"# },
+    LintCompletion { label: "array_into_iter", description: r#"detects calling `into_iter` on arrays"# },
+    LintCompletion { label: "asm_sub_register", description: r#"using only a subset of a register for inline asm inputs"# },
+    LintCompletion { label: "bare_trait_objects", description: r#"suggest using `dyn Trait` for trait objects"# },
+    LintCompletion { label: "bindings_with_variant_name", description: r#"detects pattern bindings with the same name as one of the matched variants"# },
+    LintCompletion { label: "cenum_impl_drop_cast", description: r#"a C-like enum implementing Drop is cast"# },
+    LintCompletion { label: "clashing_extern_declarations", description: r#"detects when an extern fn has been declared with the same name but different types"# },
+    LintCompletion { label: "coherence_leak_check", description: r#"distinct impls distinguished only by the leak-check code"# },
+    LintCompletion { label: "confusable_idents", description: r#"detects visually confusable pairs between identifiers"# },
+    LintCompletion { label: "dead_code", description: r#"detect unused, unexported items"# },
+    LintCompletion { label: "deprecated", description: r#"detects use of deprecated items"# },
+    LintCompletion { label: "ellipsis_inclusive_range_patterns", description: r#"`...` range patterns are deprecated"# },
+    LintCompletion { label: "exported_private_dependencies", description: r#"public interface leaks type from a private dependency"# },
+    LintCompletion { label: "illegal_floating_point_literal_pattern", description: r#"floating-point literals cannot be used in patterns"# },
+    LintCompletion { label: "improper_ctypes", description: r#"proper use of libc types in foreign modules"# },
+    LintCompletion { label: "improper_ctypes_definitions", description: r#"proper use of libc types in foreign item definitions"# },
+    LintCompletion { label: "incomplete_features", description: r#"incomplete features that may function improperly in some or all cases"# },
+    LintCompletion { label: "inline_no_sanitize", description: r#"detects incompatible use of `#[inline(always)]` and `#[no_sanitize(...)]`"# },
+    LintCompletion { label: "intra_doc_link_resolution_failure", description: r#"failures in resolving intra-doc link targets"# },
+    LintCompletion { label: "invalid_codeblock_attributes", description: r#"codeblock attribute looks a lot like a known one"# },
+    LintCompletion { label: "invalid_value", description: r#"an invalid value is being created (such as a NULL reference)"# },
+    LintCompletion { label: "irrefutable_let_patterns", description: r#"detects irrefutable patterns in if-let and while-let statements"# },
+    LintCompletion { label: "late_bound_lifetime_arguments", description: r#"detects generic lifetime arguments in path segments with late bound lifetime parameters"# },
+    LintCompletion { label: "mixed_script_confusables", description: r#"detects Unicode scripts whose mixed script confusables codepoints are solely used"# },
+    LintCompletion { label: "mutable_borrow_reservation_conflict", description: r#"reservation of a two-phased borrow conflicts with other shared borrows"# },
+    LintCompletion { label: "non_camel_case_types", description: r#"types, variants, traits and type parameters should have camel case names"# },
+    LintCompletion { label: "non_shorthand_field_patterns", description: r#"using `Struct { x: x }` instead of `Struct { x }` in a pattern"# },
+    LintCompletion { label: "non_snake_case", description: r#"variables, methods, functions, lifetime parameters and modules should have snake case names"# },
+    LintCompletion { label: "non_upper_case_globals", description: r#"static constants should have uppercase identifiers"# },
+    LintCompletion { label: "no_mangle_generic_items", description: r#"generic items must be mangled"# },
+    LintCompletion { label: "overlapping_patterns", description: r#"detects overlapping patterns"# },
+    LintCompletion { label: "path_statements", description: r#"path statements with no effect"# },
+    LintCompletion { label: "private_in_public", description: r#"detect private items in public interfaces not caught by the old implementation"# },
+    LintCompletion { label: "proc_macro_derive_resolution_fallback", description: r#"detects proc macro derives using inaccessible names from parent modules"# },
+    LintCompletion { label: "redundant_semicolons", description: r#"detects unnecessary trailing semicolons"# },
+    LintCompletion { label: "renamed_and_removed_lints", description: r#"lints that have been renamed or removed"# },
+    LintCompletion { label: "safe_packed_borrows", description: r#"safe borrows of fields of packed structs were erroneously allowed"# },
+    LintCompletion { label: "stable_features", description: r#"stable features found in `#[feature]` directive"# },
+    LintCompletion { label: "trivial_bounds", description: r#"these bounds don't depend on an type parameters"# },
+    LintCompletion { label: "type_alias_bounds", description: r#"bounds in type aliases are not enforced"# },
+    LintCompletion { label: "tyvar_behind_raw_pointer", description: r#"raw pointer to an inference variable"# },
+    LintCompletion { label: "uncommon_codepoints", description: r#"detects uncommon Unicode codepoints in identifiers"# },
+    LintCompletion { label: "unconditional_recursion", description: r#"functions that cannot return without calling themselves"# },
+    LintCompletion { label: "unknown_lints", description: r#"unrecognized lint attribute"# },
+    LintCompletion { label: "unnameable_test_items", description: r#"detects an item that cannot be named being marked as `#[test_case]`"# },
+    LintCompletion { label: "unreachable_code", description: r#"detects unreachable code paths"# },
+    LintCompletion { label: "unreachable_patterns", description: r#"detects unreachable patterns"# },
+    LintCompletion { label: "unstable_name_collisions", description: r#"detects name collision with an existing but unstable method"# },
+    LintCompletion { label: "unused_allocation", description: r#"detects unnecessary allocations that can be eliminated"# },
+    LintCompletion { label: "unused_assignments", description: r#"detect assignments that will never be read"# },
+    LintCompletion { label: "unused_attributes", description: r#"detects attributes that were not used by the compiler"# },
+    LintCompletion { label: "unused_braces", description: r#"unnecessary braces around an expression"# },
+    LintCompletion { label: "unused_comparisons", description: r#"comparisons made useless by limits of the types involved"# },
+    LintCompletion { label: "unused_doc_comments", description: r#"detects doc comments that aren't used by rustdoc"# },
+    LintCompletion { label: "unused_features", description: r#"unused features found in crate-level `#[feature]` directives"# },
+    LintCompletion { label: "unused_imports", description: r#"imports that are never used"# },
+    LintCompletion { label: "unused_labels", description: r#"detects labels that are never used"# },
+    LintCompletion { label: "unused_macros", description: r#"detects macros that were not used"# },
+    LintCompletion { label: "unused_must_use", description: r#"unused result of a type flagged as `#[must_use]`"# },
+    LintCompletion { label: "unused_mut", description: r#"detect mut variables which don't need to be mutable"# },
+    LintCompletion { label: "unused_parens", description: r#"`if`, `match`, `while` and `return` do not need parentheses"# },
+    LintCompletion { label: "unused_unsafe", description: r#"unnecessary use of an `unsafe` block"# },
+    LintCompletion { label: "unused_variables", description: r#"detect variables which are not used in any way"# },
+    LintCompletion { label: "warnings", description: r#"mass-change the level for lints which produce warnings"# },
+    LintCompletion { label: "where_clauses_object_safety", description: r#"checks the object safety of where clauses"# },
+    LintCompletion { label: "while_true", description: r#"suggest using `loop { }` instead of `while true { }`"# },
+    LintCompletion { label: "ambiguous_associated_items", description: r#"ambiguous associated items"# },
+    LintCompletion { label: "arithmetic_overflow", description: r#"arithmetic operation overflows"# },
+    LintCompletion { label: "conflicting_repr_hints", description: r#"conflicts between `#[repr(..)]` hints that were previously accepted and used in practice"# },
+    LintCompletion { label: "const_err", description: r#"constant evaluation detected erroneous expression"# },
+    LintCompletion { label: "ill_formed_attribute_input", description: r#"ill-formed attribute inputs that were previously accepted and used in practice"# },
+    LintCompletion { label: "incomplete_include", description: r#"trailing content in included file"# },
+    LintCompletion { label: "invalid_type_param_default", description: r#"type parameter default erroneously allowed in invalid location"# },
+    LintCompletion { label: "macro_expanded_macro_exports_accessed_by_absolute_paths", description: r#"macro-expanded `macro_export` macros from the current crate cannot be referred to by absolute paths"# },
+    LintCompletion { label: "missing_fragment_specifier", description: r#"detects missing fragment specifiers in unused `macro_rules!` patterns"# },
+    LintCompletion { label: "mutable_transmutes", description: r#"mutating transmuted &mut T from &T may cause undefined behavior"# },
+    LintCompletion { label: "no_mangle_const_items", description: r#"const items will not have their symbols exported"# },
+    LintCompletion { label: "order_dependent_trait_objects", description: r#"trait-object types were treated as different depending on marker-trait order"# },
+    LintCompletion { label: "overflowing_literals", description: r#"literal out of range for its type"# },
+    LintCompletion { label: "patterns_in_fns_without_body", description: r#"patterns in functions without body were erroneously allowed"# },
+    LintCompletion { label: "pub_use_of_private_extern_crate", description: r#"detect public re-exports of private extern crates"# },
+    LintCompletion { label: "soft_unstable", description: r#"a feature gate that doesn't break dependent crates"# },
+    LintCompletion { label: "unconditional_panic", description: r#"operation will cause a panic at runtime"# },
+    LintCompletion { label: "unknown_crate_types", description: r#"unknown crate type found in `#[crate_type]` directive"# },
+];
+
 #[cfg(test)]
 mod tests {
-    use crate::completion::{test_utils::do_completion, CompletionItem, CompletionKind};
-    use insta::assert_debug_snapshot;
+    use expect::{expect, Expect};
 
-    fn do_attr_completion(code: &str) -> Vec<CompletionItem> {
-        do_completion(code, CompletionKind::Attribute)
+    use crate::completion::{test_utils::completion_list, CompletionKind};
+
+    fn check(ra_fixture: &str, expect: Expect) {
+        let actual = completion_list(ra_fixture, CompletionKind::Attribute);
+        expect.assert_eq(&actual);
     }
 
     #[test]
     fn empty_derive_completion() {
-        assert_debug_snapshot!(
-            do_attr_completion(
-                    r"
-                    #[derive(<|>)]
-                    struct Test {}
-                    ",
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "Clone",
-                source_range: 9..9,
-                delete: 9..9,
-                insert: "Clone",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "Copy, Clone",
-                source_range: 9..9,
-                delete: 9..9,
-                insert: "Copy, Clone",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "Debug",
-                source_range: 9..9,
-                delete: 9..9,
-                insert: "Debug",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "Default",
-                source_range: 9..9,
-                delete: 9..9,
-                insert: "Default",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "Eq, PartialEq",
-                source_range: 9..9,
-                delete: 9..9,
-                insert: "Eq, PartialEq",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "Hash",
-                source_range: 9..9,
-                delete: 9..9,
-                insert: "Hash",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "Ord, PartialOrd, Eq, PartialEq",
-                source_range: 9..9,
-                delete: 9..9,
-                insert: "Ord, PartialOrd, Eq, PartialEq",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "PartialEq",
-                source_range: 9..9,
-                delete: 9..9,
-                insert: "PartialEq",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "PartialOrd, PartialEq",
-                source_range: 9..9,
-                delete: 9..9,
-                insert: "PartialOrd, PartialEq",
-                kind: Attribute,
-            },
-        ]
-        "###
+        check(
+            r#"
+#[derive(<|>)]
+struct Test {}
+        "#,
+            expect![[r#"
+                at Clone
+                at Copy, Clone
+                at Debug
+                at Default
+                at Eq, PartialEq
+                at Hash
+                at Ord, PartialOrd, Eq, PartialEq
+                at PartialEq
+                at PartialOrd, PartialEq
+            "#]],
         );
     }
 
     #[test]
+    fn empty_lint_completion() {
+        check(
+            r#"#[allow(<|>)]"#,
+            expect![[r#"
+                at absolute_paths_not_starting_with_crate fully qualified paths that start with a module name instead of `crate`, `self`, or an extern crate name
+                at ambiguous_associated_items ambiguous associated items
+                at anonymous_parameters detects anonymous parameters
+                at arithmetic_overflow arithmetic operation overflows
+                at array_into_iter  detects calling `into_iter` on arrays
+                at asm_sub_register using only a subset of a register for inline asm inputs
+                at bare_trait_objects suggest using `dyn Trait` for trait objects
+                at bindings_with_variant_name detects pattern bindings with the same name as one of the matched variants
+                at box_pointers     use of owned (Box type) heap memory
+                at cenum_impl_drop_cast a C-like enum implementing Drop is cast
+                at clashing_extern_declarations detects when an extern fn has been declared with the same name but different types
+                at coherence_leak_check distinct impls distinguished only by the leak-check code
+                at conflicting_repr_hints conflicts between `#[repr(..)]` hints that were previously accepted and used in practice
+                at confusable_idents detects visually confusable pairs between identifiers
+                at const_err        constant evaluation detected erroneous expression
+                at dead_code        detect unused, unexported items
+                at deprecated       detects use of deprecated items
+                at deprecated_in_future detects use of items that will be deprecated in a future version
+                at elided_lifetimes_in_paths hidden lifetime parameters in types are deprecated
+                at ellipsis_inclusive_range_patterns `...` range patterns are deprecated
+                at explicit_outlives_requirements outlives requirements can be inferred
+                at exported_private_dependencies public interface leaks type from a private dependency
+                at ill_formed_attribute_input ill-formed attribute inputs that were previously accepted and used in practice
+                at illegal_floating_point_literal_pattern floating-point literals cannot be used in patterns
+                at improper_ctypes  proper use of libc types in foreign modules
+                at improper_ctypes_definitions proper use of libc types in foreign item definitions
+                at incomplete_features incomplete features that may function improperly in some or all cases
+                at incomplete_include trailing content in included file
+                at indirect_structural_match pattern with const indirectly referencing non-structural-match type
+                at inline_no_sanitize detects incompatible use of `#[inline(always)]` and `#[no_sanitize(...)]`
+                at intra_doc_link_resolution_failure failures in resolving intra-doc link targets
+                at invalid_codeblock_attributes codeblock attribute looks a lot like a known one
+                at invalid_type_param_default type parameter default erroneously allowed in invalid location
+                at invalid_value    an invalid value is being created (such as a NULL reference)
+                at irrefutable_let_patterns detects irrefutable patterns in if-let and while-let statements
+                at keyword_idents   detects edition keywords being used as an identifier
+                at late_bound_lifetime_arguments detects generic lifetime arguments in path segments with late bound lifetime parameters
+                at macro_expanded_macro_exports_accessed_by_absolute_paths macro-expanded `macro_export` macros from the current crate cannot be referred to by absolute paths
+                at macro_use_extern_crate the `#[macro_use]` attribute is now deprecated in favor of using macros via the module system
+                at meta_variable_misuse possible meta-variable misuse at macro definition
+                at missing_copy_implementations detects potentially-forgotten implementations of `Copy`
+                at missing_crate_level_docs detects crates with no crate-level documentation
+                at missing_debug_implementations detects missing implementations of Debug
+                at missing_doc_code_examples detects publicly-exported items without code samples in their documentation
+                at missing_docs     detects missing documentation for public members
+                at missing_fragment_specifier detects missing fragment specifiers in unused `macro_rules!` patterns
+                at mixed_script_confusables detects Unicode scripts whose mixed script confusables codepoints are solely used
+                at mutable_borrow_reservation_conflict reservation of a two-phased borrow conflicts with other shared borrows
+                at mutable_transmutes mutating transmuted &mut T from &T may cause undefined behavior
+                at no_mangle_const_items const items will not have their symbols exported
+                at no_mangle_generic_items generic items must be mangled
+                at non_ascii_idents detects non-ASCII identifiers
+                at non_camel_case_types types, variants, traits and type parameters should have camel case names
+                at non_shorthand_field_patterns using `Struct { x: x }` instead of `Struct { x }` in a pattern
+                at non_snake_case   variables, methods, functions, lifetime parameters and modules should have snake case names
+                at non_upper_case_globals static constants should have uppercase identifiers
+                at order_dependent_trait_objects trait-object types were treated as different depending on marker-trait order
+                at overflowing_literals literal out of range for its type
+                at overlapping_patterns detects overlapping patterns
+                at path_statements  path statements with no effect
+                at patterns_in_fns_without_body patterns in functions without body were erroneously allowed
+                at private_doc_tests detects code samples in docs of private items not documented by rustdoc
+                at private_in_public detect private items in public interfaces not caught by the old implementation
+                at proc_macro_derive_resolution_fallback detects proc macro derives using inaccessible names from parent modules
+                at pub_use_of_private_extern_crate detect public re-exports of private extern crates
+                at redundant_semicolons detects unnecessary trailing semicolons
+                at renamed_and_removed_lints lints that have been renamed or removed
+                at safe_packed_borrows safe borrows of fields of packed structs were erroneously allowed
+                at single_use_lifetimes detects lifetime parameters that are only used once
+                at soft_unstable    a feature gate that doesn't break dependent crates
+                at stable_features  stable features found in `#[feature]` directive
+                at trivial_bounds   these bounds don't depend on an type parameters
+                at trivial_casts    detects trivial casts which could be removed
+                at trivial_numeric_casts detects trivial casts of numeric types which could be removed
+                at type_alias_bounds bounds in type aliases are not enforced
+                at tyvar_behind_raw_pointer raw pointer to an inference variable
+                at unaligned_references detects unaligned references to fields of packed structs
+                at uncommon_codepoints detects uncommon Unicode codepoints in identifiers
+                at unconditional_panic operation will cause a panic at runtime
+                at unconditional_recursion functions that cannot return without calling themselves
+                at unknown_crate_types unknown crate type found in `#[crate_type]` directive
+                at unknown_lints    unrecognized lint attribute
+                at unnameable_test_items detects an item that cannot be named being marked as `#[test_case]`
+                at unreachable_code detects unreachable code paths
+                at unreachable_patterns detects unreachable patterns
+                at unreachable_pub  `pub` items not reachable from crate root
+                at unsafe_code      usage of `unsafe` code
+                at unsafe_op_in_unsafe_fn unsafe operations in unsafe functions without an explicit unsafe block are deprecated
+                at unstable_features enabling unstable features (deprecated. do not use)
+                at unstable_name_collisions detects name collision with an existing but unstable method
+                at unused_allocation detects unnecessary allocations that can be eliminated
+                at unused_assignments detect assignments that will never be read
+                at unused_attributes detects attributes that were not used by the compiler
+                at unused_braces    unnecessary braces around an expression
+                at unused_comparisons comparisons made useless by limits of the types involved
+                at unused_crate_dependencies crate dependencies that are never used
+                at unused_doc_comments detects doc comments that aren't used by rustdoc
+                at unused_extern_crates extern crates that are never used
+                at unused_features  unused features found in crate-level `#[feature]` directives
+                at unused_import_braces unnecessary braces around an imported item
+                at unused_imports   imports that are never used
+                at unused_labels    detects labels that are never used
+                at unused_lifetimes detects lifetime parameters that are never used
+                at unused_macros    detects macros that were not used
+                at unused_must_use  unused result of a type flagged as `#[must_use]`
+                at unused_mut       detect mut variables which don't need to be mutable
+                at unused_parens    `if`, `match`, `while` and `return` do not need parentheses
+                at unused_qualifications detects unnecessarily qualified names
+                at unused_results   unused result of an expression in a statement
+                at unused_unsafe    unnecessary use of an `unsafe` block
+                at unused_variables detect variables which are not used in any way
+                at variant_size_differences detects enums with widely varying variant sizes
+                at warnings         mass-change the level for lints which produce warnings
+                at where_clauses_object_safety checks the object safety of where clauses
+                at while_true       suggest using `loop { }` instead of `while true { }`
+        "#]],
+        )
+    }
+
+    #[test]
     fn no_completion_for_incorrect_derive() {
-        assert_debug_snapshot!(
-            do_attr_completion(
-                r"
-                    #[derive{<|>)]
-                    struct Test {}
-                    ",
-            ),
-            @"[]"
-        );
+        check(
+            r#"
+#[derive{<|>)]
+struct Test {}
+"#,
+            expect![[r#""#]],
+        )
     }
 
     #[test]
     fn derive_with_input_completion() {
-        assert_debug_snapshot!(
-            do_attr_completion(
-                    r"
-                    #[derive(serde::Serialize, PartialEq, <|>)]
-                    struct Test {}
-                    ",
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "Clone",
-                source_range: 38..38,
-                delete: 38..38,
-                insert: "Clone",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "Copy, Clone",
-                source_range: 38..38,
-                delete: 38..38,
-                insert: "Copy, Clone",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "Debug",
-                source_range: 38..38,
-                delete: 38..38,
-                insert: "Debug",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "Default",
-                source_range: 38..38,
-                delete: 38..38,
-                insert: "Default",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "Eq",
-                source_range: 38..38,
-                delete: 38..38,
-                insert: "Eq",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "Hash",
-                source_range: 38..38,
-                delete: 38..38,
-                insert: "Hash",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "Ord, PartialOrd, Eq",
-                source_range: 38..38,
-                delete: 38..38,
-                insert: "Ord, PartialOrd, Eq",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "PartialOrd",
-                source_range: 38..38,
-                delete: 38..38,
-                insert: "PartialOrd",
-                kind: Attribute,
-            },
-        ]
-        "###
-        );
+        check(
+            r#"
+#[derive(serde::Serialize, PartialEq, <|>)]
+struct Test {}
+"#,
+            expect![[r#"
+                at Clone
+                at Copy, Clone
+                at Debug
+                at Default
+                at Eq
+                at Hash
+                at Ord, PartialOrd, Eq
+                at PartialOrd
+            "#]],
+        )
     }
 
     #[test]
     fn test_attribute_completion() {
-        assert_debug_snapshot!(
-        do_attr_completion(
-                r"
-                #[<|>]
-                ",
-        ),
-            @r###"
-        [
-            CompletionItem {
-                label: "allow(…)",
-                source_range: 2..2,
-                delete: 2..2,
-                insert: "allow(${0:lint})",
-                kind: Attribute,
-                lookup: "allow",
-            },
-            CompletionItem {
-                label: "cfg(…)",
-                source_range: 2..2,
-                delete: 2..2,
-                insert: "cfg(${0:predicate})",
-                kind: Attribute,
-                lookup: "cfg",
-            },
-            CompletionItem {
-                label: "cfg_attr(…)",
-                source_range: 2..2,
-                delete: 2..2,
-                insert: "cfg_attr(${1:predicate}, ${0:attr})",
-                kind: Attribute,
-                lookup: "cfg_attr",
-            },
-            CompletionItem {
-                label: "deny(…)",
-                source_range: 2..2,
-                delete: 2..2,
-                insert: "deny(${0:lint})",
-                kind: Attribute,
-                lookup: "deny",
-            },
-            CompletionItem {
-                label: "deprecated = \"…\"",
-                source_range: 2..2,
-                delete: 2..2,
-                insert: "deprecated = \"${0:reason}\"",
-                kind: Attribute,
-                lookup: "deprecated",
-            },
-            CompletionItem {
-                label: "derive(…)",
-                source_range: 2..2,
-                delete: 2..2,
-                insert: "derive(${0:Debug})",
-                kind: Attribute,
-                lookup: "derive",
-            },
-            CompletionItem {
-                label: "doc = \"…\"",
-                source_range: 2..2,
-                delete: 2..2,
-                insert: "doc = \"${0:docs}\"",
-                kind: Attribute,
-                lookup: "doc",
-            },
-            CompletionItem {
-                label: "forbid(…)",
-                source_range: 2..2,
-                delete: 2..2,
-                insert: "forbid(${0:lint})",
-                kind: Attribute,
-                lookup: "forbid",
-            },
-            CompletionItem {
-                label: "ignore(…)",
-                source_range: 2..2,
-                delete: 2..2,
-                insert: "ignore(${0:lint})",
-                kind: Attribute,
-                lookup: "ignore",
-            },
-            CompletionItem {
-                label: "inline(…)",
-                source_range: 2..2,
-                delete: 2..2,
-                insert: "inline(${0:lint})",
-                kind: Attribute,
-                lookup: "inline",
-            },
-            CompletionItem {
-                label: "link",
-                source_range: 2..2,
-                delete: 2..2,
-                insert: "link",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "link_name = \"…\"",
-                source_range: 2..2,
-                delete: 2..2,
-                insert: "link_name = \"${0:symbol_name}\"",
-                kind: Attribute,
-                lookup: "link_name",
-            },
-            CompletionItem {
-                label: "macro_export",
-                source_range: 2..2,
-                delete: 2..2,
-                insert: "macro_export",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "macro_use",
-                source_range: 2..2,
-                delete: 2..2,
-                insert: "macro_use",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "must_use = \"…\"",
-                source_range: 2..2,
-                delete: 2..2,
-                insert: "must_use = \"${0:reason}\"",
-                kind: Attribute,
-                lookup: "must_use",
-            },
-            CompletionItem {
-                label: "no_mangle",
-                source_range: 2..2,
-                delete: 2..2,
-                insert: "no_mangle",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "non_exhaustive",
-                source_range: 2..2,
-                delete: 2..2,
-                insert: "non_exhaustive",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "path = \"…\"",
-                source_range: 2..2,
-                delete: 2..2,
-                insert: "path =\"${0:path}\"",
-                kind: Attribute,
-                lookup: "path",
-            },
-            CompletionItem {
-                label: "proc_macro",
-                source_range: 2..2,
-                delete: 2..2,
-                insert: "proc_macro",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "proc_macro_attribute",
-                source_range: 2..2,
-                delete: 2..2,
-                insert: "proc_macro_attribute",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "proc_macro_derive(…)",
-                source_range: 2..2,
-                delete: 2..2,
-                insert: "proc_macro_derive(${0:Trait})",
-                kind: Attribute,
-                lookup: "proc_macro_derive",
-            },
-            CompletionItem {
-                label: "repr(…)",
-                source_range: 2..2,
-                delete: 2..2,
-                insert: "repr(${0:C})",
-                kind: Attribute,
-                lookup: "repr",
-            },
-            CompletionItem {
-                label: "should_panic(…)",
-                source_range: 2..2,
-                delete: 2..2,
-                insert: "should_panic(expected = \"${0:reason}\")",
-                kind: Attribute,
-                lookup: "should_panic",
-            },
-            CompletionItem {
-                label: "target_feature = \"…\"",
-                source_range: 2..2,
-                delete: 2..2,
-                insert: "target_feature = \"${0:feature}\"",
-                kind: Attribute,
-                lookup: "target_feature",
-            },
-            CompletionItem {
-                label: "test",
-                source_range: 2..2,
-                delete: 2..2,
-                insert: "test",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "used",
-                source_range: 2..2,
-                delete: 2..2,
-                insert: "used",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "warn(…)",
-                source_range: 2..2,
-                delete: 2..2,
-                insert: "warn(${0:lint})",
-                kind: Attribute,
-                lookup: "warn",
-            },
-        ]
-        "###
-        );
+        check(
+            r#"#[<|>]"#,
+            expect![[r#"
+                at allow(…)
+                at cfg(…)
+                at cfg_attr(…)
+                at deny(…)
+                at deprecated = "…"
+                at derive(…)
+                at doc = "…"
+                at forbid(…)
+                at ignore = "…"
+                at inline(…)
+                at link
+                at link_name = "…"
+                at macro_export
+                at macro_use
+                at must_use = "…"
+                at no_mangle
+                at non_exhaustive
+                at path = "…"
+                at proc_macro
+                at proc_macro_attribute
+                at proc_macro_derive(…)
+                at repr(…)
+                at should_panic(…)
+                at target_feature = "…"
+                at test
+                at used
+                at warn(…)
+            "#]],
+        )
     }
 
     #[test]
     fn test_attribute_completion_inside_nested_attr() {
-        assert_debug_snapshot!(
-        do_attr_completion(
-                r"
-                #[allow(<|>)]
-                ",
-        ),
-            @r###"
-        []
-        "###
-        );
+        check(r#"#[cfg(<|>)]"#, expect![[]])
     }
 
     #[test]
     fn test_inner_attribute_completion() {
-        assert_debug_snapshot!(
-        do_attr_completion(
-                r"
-                #![<|>]
-                ",
-        ),
-            @r###"
-        [
-            CompletionItem {
-                label: "allow(…)",
-                source_range: 3..3,
-                delete: 3..3,
-                insert: "allow(${0:lint})",
-                kind: Attribute,
-                lookup: "allow",
-            },
-            CompletionItem {
-                label: "cfg(…)",
-                source_range: 3..3,
-                delete: 3..3,
-                insert: "cfg(${0:predicate})",
-                kind: Attribute,
-                lookup: "cfg",
-            },
-            CompletionItem {
-                label: "cfg_attr(…)",
-                source_range: 3..3,
-                delete: 3..3,
-                insert: "cfg_attr(${1:predicate}, ${0:attr})",
-                kind: Attribute,
-                lookup: "cfg_attr",
-            },
-            CompletionItem {
-                label: "deny(…)",
-                source_range: 3..3,
-                delete: 3..3,
-                insert: "deny(${0:lint})",
-                kind: Attribute,
-                lookup: "deny",
-            },
-            CompletionItem {
-                label: "deprecated = \"…\"",
-                source_range: 3..3,
-                delete: 3..3,
-                insert: "deprecated = \"${0:reason}\"",
-                kind: Attribute,
-                lookup: "deprecated",
-            },
-            CompletionItem {
-                label: "derive(…)",
-                source_range: 3..3,
-                delete: 3..3,
-                insert: "derive(${0:Debug})",
-                kind: Attribute,
-                lookup: "derive",
-            },
-            CompletionItem {
-                label: "doc = \"…\"",
-                source_range: 3..3,
-                delete: 3..3,
-                insert: "doc = \"${0:docs}\"",
-                kind: Attribute,
-                lookup: "doc",
-            },
-            CompletionItem {
-                label: "feature(…)",
-                source_range: 3..3,
-                delete: 3..3,
-                insert: "feature(${0:flag})",
-                kind: Attribute,
-                lookup: "feature",
-            },
-            CompletionItem {
-                label: "forbid(…)",
-                source_range: 3..3,
-                delete: 3..3,
-                insert: "forbid(${0:lint})",
-                kind: Attribute,
-                lookup: "forbid",
-            },
-            CompletionItem {
-                label: "global_allocator",
-                source_range: 3..3,
-                delete: 3..3,
-                insert: "global_allocator",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "ignore(…)",
-                source_range: 3..3,
-                delete: 3..3,
-                insert: "ignore(${0:lint})",
-                kind: Attribute,
-                lookup: "ignore",
-            },
-            CompletionItem {
-                label: "inline(…)",
-                source_range: 3..3,
-                delete: 3..3,
-                insert: "inline(${0:lint})",
-                kind: Attribute,
-                lookup: "inline",
-            },
-            CompletionItem {
-                label: "link",
-                source_range: 3..3,
-                delete: 3..3,
-                insert: "link",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "link_name = \"…\"",
-                source_range: 3..3,
-                delete: 3..3,
-                insert: "link_name = \"${0:symbol_name}\"",
-                kind: Attribute,
-                lookup: "link_name",
-            },
-            CompletionItem {
-                label: "macro_export",
-                source_range: 3..3,
-                delete: 3..3,
-                insert: "macro_export",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "macro_use",
-                source_range: 3..3,
-                delete: 3..3,
-                insert: "macro_use",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "must_use = \"…\"",
-                source_range: 3..3,
-                delete: 3..3,
-                insert: "must_use = \"${0:reason}\"",
-                kind: Attribute,
-                lookup: "must_use",
-            },
-            CompletionItem {
-                label: "no_mangle",
-                source_range: 3..3,
-                delete: 3..3,
-                insert: "no_mangle",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "no_std",
-                source_range: 3..3,
-                delete: 3..3,
-                insert: "no_std",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "non_exhaustive",
-                source_range: 3..3,
-                delete: 3..3,
-                insert: "non_exhaustive",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "panic_handler",
-                source_range: 3..3,
-                delete: 3..3,
-                insert: "panic_handler",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "path = \"…\"",
-                source_range: 3..3,
-                delete: 3..3,
-                insert: "path =\"${0:path}\"",
-                kind: Attribute,
-                lookup: "path",
-            },
-            CompletionItem {
-                label: "proc_macro",
-                source_range: 3..3,
-                delete: 3..3,
-                insert: "proc_macro",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "proc_macro_attribute",
-                source_range: 3..3,
-                delete: 3..3,
-                insert: "proc_macro_attribute",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "proc_macro_derive(…)",
-                source_range: 3..3,
-                delete: 3..3,
-                insert: "proc_macro_derive(${0:Trait})",
-                kind: Attribute,
-                lookup: "proc_macro_derive",
-            },
-            CompletionItem {
-                label: "recursion_limit = …",
-                source_range: 3..3,
-                delete: 3..3,
-                insert: "recursion_limit = ${0:128}",
-                kind: Attribute,
-                lookup: "recursion_limit",
-            },
-            CompletionItem {
-                label: "repr(…)",
-                source_range: 3..3,
-                delete: 3..3,
-                insert: "repr(${0:C})",
-                kind: Attribute,
-                lookup: "repr",
-            },
-            CompletionItem {
-                label: "should_panic(…)",
-                source_range: 3..3,
-                delete: 3..3,
-                insert: "should_panic(expected = \"${0:reason}\")",
-                kind: Attribute,
-                lookup: "should_panic",
-            },
-            CompletionItem {
-                label: "target_feature = \"…\"",
-                source_range: 3..3,
-                delete: 3..3,
-                insert: "target_feature = \"${0:feature}\"",
-                kind: Attribute,
-                lookup: "target_feature",
-            },
-            CompletionItem {
-                label: "test",
-                source_range: 3..3,
-                delete: 3..3,
-                insert: "test",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "used",
-                source_range: 3..3,
-                delete: 3..3,
-                insert: "used",
-                kind: Attribute,
-            },
-            CompletionItem {
-                label: "warn(…)",
-                source_range: 3..3,
-                delete: 3..3,
-                insert: "warn(${0:lint})",
-                kind: Attribute,
-                lookup: "warn",
-            },
-            CompletionItem {
-                label: "windows_subsystem = \"…\"",
-                source_range: 3..3,
-                delete: 3..3,
-                insert: "windows_subsystem = \"${0:subsystem}\"",
-                kind: Attribute,
-                lookup: "windows_subsystem",
-            },
-        ]
-        "###
+        check(
+            r"#![<|>]",
+            expect![[r#"
+                at allow(…)
+                at cfg(…)
+                at cfg_attr(…)
+                at deny(…)
+                at deprecated = "…"
+                at derive(…)
+                at doc = "…"
+                at feature(…)
+                at forbid(…)
+                at global_allocator
+                at ignore = "…"
+                at inline(…)
+                at link
+                at link_name = "…"
+                at macro_export
+                at macro_use
+                at must_use = "…"
+                at no_mangle
+                at no_std
+                at non_exhaustive
+                at panic_handler
+                at path = "…"
+                at proc_macro
+                at proc_macro_attribute
+                at proc_macro_derive(…)
+                at recursion_limit = …
+                at repr(…)
+                at should_panic(…)
+                at target_feature = "…"
+                at test
+                at used
+                at warn(…)
+                at windows_subsystem = "…"
+            "#]],
         );
     }
 }
diff --git a/crates/ra_ide/src/completion/complete_dot.rs b/crates/ra_ide/src/completion/complete_dot.rs
index ee4e24fca..532665285 100644
--- a/crates/ra_ide/src/completion/complete_dot.rs
+++ b/crates/ra_ide/src/completion/complete_dot.rs
@@ -1,17 +1,12 @@
-//! FIXME: write short doc here
+//! Completes references after dot (fields and method calls).
 
 use hir::{HasVisibility, Type};
-
-use crate::{
-    completion::{
-        completion_context::CompletionContext,
-        completion_item::{CompletionKind, Completions},
-    },
-    CompletionItem,
-};
 use rustc_hash::FxHashSet;
+use test_utils::mark;
 
-/// Complete dot accesses, i.e. fields or methods (and .await syntax).
+use crate::completion::{completion_context::CompletionContext, completion_item::Completions};
+
+/// Complete dot accesses, i.e. fields or methods.
 pub(super) fn complete_dot(acc: &mut Completions, ctx: &CompletionContext) {
     let dot_receiver = match &ctx.dot_receiver {
         Some(expr) => expr,
@@ -23,24 +18,18 @@ pub(super) fn complete_dot(acc: &mut Completions, ctx: &CompletionContext) {
         _ => return,
     };
 
-    if !ctx.is_call {
+    if ctx.is_call {
+        mark::hit!(test_no_struct_field_completion_for_method_call);
+    } else {
         complete_fields(acc, ctx, &receiver_ty);
     }
     complete_methods(acc, ctx, &receiver_ty);
-
-    // Suggest .await syntax for types that implement Future trait
-    if receiver_ty.impls_future(ctx.db) {
-        CompletionItem::new(CompletionKind::Keyword, ctx.source_range(), "await")
-            .detail("expr.await")
-            .insert_text("await")
-            .add_to(acc);
-    }
 }
 
 fn complete_fields(acc: &mut Completions, ctx: &CompletionContext, receiver: &Type) {
     for receiver in receiver.autoderef(ctx.db) {
         for (field, ty) in receiver.fields(ctx.db) {
-            if ctx.scope().module().map_or(false, |m| !field.is_visible_from(ctx.db, m)) {
+            if ctx.scope.module().map_or(false, |m| !field.is_visible_from(ctx.db, m)) {
                 // Skip private field. FIXME: If the definition location of the
                 // field is editable, we should show the completion
                 continue;
@@ -57,10 +46,10 @@ fn complete_fields(acc: &mut Completions, ctx: &CompletionContext, receiver: &Ty
 fn complete_methods(acc: &mut Completions, ctx: &CompletionContext, receiver: &Type) {
     if let Some(krate) = ctx.krate {
         let mut seen_methods = FxHashSet::default();
-        let traits_in_scope = ctx.scope().traits_in_scope();
+        let traits_in_scope = ctx.scope.traits_in_scope();
         receiver.iterate_method_candidates(ctx.db, krate, &traits_in_scope, None, |_ty, func| {
             if func.has_self_param(ctx.db)
-                && ctx.scope().module().map_or(true, |m| func.is_visible_from(ctx.db, m))
+                && ctx.scope.module().map_or(true, |m| func.is_visible_from(ctx.db, m))
                 && seen_methods.insert(func.name(ctx.db))
             {
                 acc.add_function(ctx, func, None);
@@ -72,801 +61,356 @@ fn complete_methods(acc: &mut Completions, ctx: &CompletionContext, receiver: &T
 
 #[cfg(test)]
 mod tests {
-    use crate::completion::{test_utils::do_completion, CompletionItem, CompletionKind};
-    use insta::assert_debug_snapshot;
+    use expect::{expect, Expect};
+    use test_utils::mark;
+
+    use crate::completion::{test_utils::completion_list, CompletionKind};
 
-    fn do_ref_completion(code: &str) -> Vec<CompletionItem> {
-        do_completion(code, CompletionKind::Reference)
+    fn check(ra_fixture: &str, expect: Expect) {
+        let actual = completion_list(ra_fixture, CompletionKind::Reference);
+        expect.assert_eq(&actual);
     }
 
     #[test]
-    fn test_struct_field_completion() {
-        assert_debug_snapshot!(
-        do_ref_completion(
-                r"
-                struct A { the_field: u32 }
-                fn foo(a: A) {
-                a.<|>
-                }
-                ",
-        ),
-            @r###"
-        [
-            CompletionItem {
-                label: "the_field",
-                source_range: 45..45,
-                delete: 45..45,
-                insert: "the_field",
-                kind: Field,
-                detail: "u32",
-            },
-        ]
-        "###
+    fn test_struct_field_and_method_completion() {
+        check(
+            r#"
+struct S { foo: u32 }
+impl S {
+    fn bar(&self) {}
+}
+fn foo(s: S) { s.<|> }
+"#,
+            expect![[r#"
+                me bar() fn bar(&self)
+                fd foo   u32
+            "#]],
         );
     }
 
     #[test]
     fn test_struct_field_completion_self() {
-        assert_debug_snapshot!(
-        do_ref_completion(
-            r"
-            struct A {
-                /// This is the_field
-                the_field: (u32,)
-            }
-            impl A {
-                fn foo(self) {
-                    self.<|>
-                }
-            }
-            ",
-        ),
-        @r###"
-        [
-            CompletionItem {
-                label: "foo()",
-                source_range: 102..102,
-                delete: 102..102,
-                insert: "foo()$0",
-                kind: Method,
-                lookup: "foo",
-                detail: "fn foo(self)",
-            },
-            CompletionItem {
-                label: "the_field",
-                source_range: 102..102,
-                delete: 102..102,
-                insert: "the_field",
-                kind: Field,
-                detail: "(u32,)",
-                documentation: Documentation(
-                    "This is the_field",
-                ),
-            },
-        ]
-        "###
-        );
+        check(
+            r#"
+struct S { the_field: (u32,) }
+impl S {
+    fn foo(self) { self.<|> }
+}
+"#,
+            expect![[r#"
+                me foo()     fn foo(self)
+                fd the_field (u32,)
+            "#]],
+        )
     }
 
     #[test]
     fn test_struct_field_completion_autoderef() {
-        assert_debug_snapshot!(
-        do_ref_completion(
-            r"
-            struct A { the_field: (u32, i32) }
-            impl A {
-                fn foo(&self) {
-                    self.<|>
-                }
-            }
-            ",
-        ),
-        @r###"
-        [
-            CompletionItem {
-                label: "foo()",
-                source_range: 77..77,
-                delete: 77..77,
-                insert: "foo()$0",
-                kind: Method,
-                lookup: "foo",
-                detail: "fn foo(&self)",
-            },
-            CompletionItem {
-                label: "the_field",
-                source_range: 77..77,
-                delete: 77..77,
-                insert: "the_field",
-                kind: Field,
-                detail: "(u32, i32)",
-            },
-        ]
-        "###
-        );
+        check(
+            r#"
+struct A { the_field: (u32, i32) }
+impl A {
+    fn foo(&self) { self.<|> }
+}
+"#,
+            expect![[r#"
+                me foo()     fn foo(&self)
+                fd the_field (u32, i32)
+            "#]],
+        )
     }
 
     #[test]
     fn test_no_struct_field_completion_for_method_call() {
-        assert_debug_snapshot!(
-        do_ref_completion(
-            r"
-            struct A { the_field: u32 }
-            fn foo(a: A) {
-               a.<|>()
-            }
-            ",
-        ),
-        @"[]"
+        mark::check!(test_no_struct_field_completion_for_method_call);
+        check(
+            r#"
+struct A { the_field: u32 }
+fn foo(a: A) { a.<|>() }
+"#,
+            expect![[""]],
         );
     }
 
     #[test]
-    fn test_struct_field_visibility_private() {
-        assert_debug_snapshot!(
-            do_ref_completion(
-                r"
-            mod inner {
-                struct A {
-                    private_field: u32,
-                    pub pub_field: u32,
-                    pub(crate) crate_field: u32,
-                    pub(super) super_field: u32,
-                }
-            }
-            fn foo(a: inner::A) {
-               a.<|>
-            }
-            ",
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "crate_field",
-                source_range: 192..192,
-                delete: 192..192,
-                insert: "crate_field",
-                kind: Field,
-                detail: "u32",
-            },
-            CompletionItem {
-                label: "pub_field",
-                source_range: 192..192,
-                delete: 192..192,
-                insert: "pub_field",
-                kind: Field,
-                detail: "u32",
-            },
-            CompletionItem {
-                label: "super_field",
-                source_range: 192..192,
-                delete: 192..192,
-                insert: "super_field",
-                kind: Field,
-                detail: "u32",
-            },
-        ]
-        "###
-        );
+    fn test_visibility_filtering() {
+        check(
+            r#"
+mod inner {
+    pub struct A {
+        private_field: u32,
+        pub pub_field: u32,
+        pub(crate) crate_field: u32,
+        pub(super) super_field: u32,
     }
-
-    #[test]
-    fn test_union_field_completion() {
-        assert_debug_snapshot!(
-            do_ref_completion(
-                r"
-            union Un {
-                field: u8,
-                other: u16,
-            }
-
-            fn foo(u: Un) {
-                u.<|>
-            }
-            ",
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "field",
-                source_range: 67..67,
-                delete: 67..67,
-                insert: "field",
-                kind: Field,
-                detail: "u8",
-            },
-            CompletionItem {
-                label: "other",
-                source_range: 67..67,
-                delete: 67..67,
-                insert: "other",
-                kind: Field,
-                detail: "u16",
-            },
-        ]
-        "###
+}
+fn foo(a: inner::A) { a.<|> }
+"#,
+            expect![[r#"
+                fd crate_field u32
+                fd pub_field   u32
+                fd super_field u32
+            "#]],
         );
-    }
 
-    #[test]
-    fn test_method_completion() {
-        assert_debug_snapshot!(
-        do_ref_completion(
-            r"
-            struct A {}
-            impl A {
-                fn the_method(&self) {}
-            }
-            fn foo(a: A) {
-               a.<|>
-            }
-            ",
-        ),
-        @r###"
-        [
-            CompletionItem {
-                label: "the_method()",
-                source_range: 71..71,
-                delete: 71..71,
-                insert: "the_method()$0",
-                kind: Method,
-                lookup: "the_method",
-                detail: "fn the_method(&self)",
-            },
-        ]
-        "###
+        check(
+            r#"
+struct A {}
+mod m {
+    impl super::A {
+        fn private_method(&self) {}
+        pub(super) fn the_method(&self) {}
+    }
+}
+fn foo(a: A) { a.<|> }
+"#,
+            expect![[r#"
+                me the_method() pub(super) fn the_method(&self)
+            "#]],
         );
     }
 
     #[test]
-    fn test_method_completion_only_fitting_impls() {
-        assert_debug_snapshot!(
-            do_ref_completion(
-                r"
-            struct A<T> {}
-            impl A<u32> {
-                fn the_method(&self) {}
-            }
-            impl A<i32> {
-                fn the_other_method(&self) {}
-            }
-            fn foo(a: A<u32>) {
-               a.<|>
-            }
-            ",
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "the_method()",
-                source_range: 134..134,
-                delete: 134..134,
-                insert: "the_method()$0",
-                kind: Method,
-                lookup: "the_method",
-                detail: "fn the_method(&self)",
-            },
-        ]
-        "###
+    fn test_union_field_completion() {
+        check(
+            r#"
+union U { field: u8, other: u16 }
+fn foo(u: U) { u.<|> }
+"#,
+            expect![[r#"
+                fd field u8
+                fd other u16
+            "#]],
         );
     }
 
     #[test]
-    fn test_method_completion_private() {
-        assert_debug_snapshot!(
-            do_ref_completion(
-                r"
-            struct A {}
-            mod m {
-                impl super::A {
-                    fn private_method(&self) {}
-                    pub(super) fn the_method(&self) {}
-                }
-            }
-            fn foo(a: A) {
-               a.<|>
-            }
-            ",
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "the_method()",
-                source_range: 147..147,
-                delete: 147..147,
-                insert: "the_method()$0",
-                kind: Method,
-                lookup: "the_method",
-                detail: "pub(super) fn the_method(&self)",
-            },
-        ]
-        "###
-        );
+    fn test_method_completion_only_fitting_impls() {
+        check(
+            r#"
+struct A<T> {}
+impl A<u32> {
+    fn the_method(&self) {}
+}
+impl A<i32> {
+    fn the_other_method(&self) {}
+}
+fn foo(a: A<u32>) { a.<|> }
+"#,
+            expect![[r#"
+                me the_method() fn the_method(&self)
+            "#]],
+        )
     }
 
     #[test]
     fn test_trait_method_completion() {
-        assert_debug_snapshot!(
-            do_ref_completion(
-                r"
-            struct A {}
-            trait Trait { fn the_method(&self); }
-            impl Trait for A {}
-            fn foo(a: A) {
-               a.<|>
-            }
-            ",
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "the_method()",
-                source_range: 90..90,
-                delete: 90..90,
-                insert: "the_method()$0",
-                kind: Method,
-                lookup: "the_method",
-                detail: "fn the_method(&self)",
-            },
-        ]
-        "###
+        check(
+            r#"
+struct A {}
+trait Trait { fn the_method(&self); }
+impl Trait for A {}
+fn foo(a: A) { a.<|> }
+"#,
+            expect![[r#"
+                me the_method() fn the_method(&self)
+            "#]],
         );
     }
 
     #[test]
     fn test_trait_method_completion_deduplicated() {
-        assert_debug_snapshot!(
-            do_ref_completion(
-                r"
-            struct A {}
-            trait Trait { fn the_method(&self); }
-            impl<T> Trait for T {}
-            fn foo(a: &A) {
-               a.<|>
-            }
-            ",
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "the_method()",
-                source_range: 94..94,
-                delete: 94..94,
-                insert: "the_method()$0",
-                kind: Method,
-                lookup: "the_method",
-                detail: "fn the_method(&self)",
-            },
-        ]
-        "###
+        check(
+            r"
+struct A {}
+trait Trait { fn the_method(&self); }
+impl<T> Trait for T {}
+fn foo(a: &A) { a.<|> }
+",
+            expect![[r#"
+                me the_method() fn the_method(&self)
+            "#]],
         );
     }
 
     #[test]
     fn completes_trait_method_from_other_module() {
-        assert_debug_snapshot!(
-            do_ref_completion(
-                r"
-            struct A {}
-            mod m {
-                pub trait Trait { fn the_method(&self); }
-            }
-            use m::Trait;
-            impl Trait for A {}
-            fn foo(a: A) {
-               a.<|>
-            }
-            ",
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "the_method()",
-                source_range: 122..122,
-                delete: 122..122,
-                insert: "the_method()$0",
-                kind: Method,
-                lookup: "the_method",
-                detail: "fn the_method(&self)",
-            },
-        ]
-        "###
-        );
-    }
-
-    #[test]
-    fn test_no_non_self_method() {
-        assert_debug_snapshot!(
-        do_ref_completion(
+        check(
             r"
-            struct A {}
-            impl A {
-                fn the_method() {}
-            }
-            fn foo(a: A) {
-               a.<|>
-            }
-            ",
-        ),
-        @"[]"
+struct A {}
+mod m {
+    pub trait Trait { fn the_method(&self); }
+}
+use m::Trait;
+impl Trait for A {}
+fn foo(a: A) { a.<|> }
+",
+            expect![[r#"
+                me the_method() fn the_method(&self)
+            "#]],
         );
     }
 
     #[test]
-    fn test_method_attr_filtering() {
-        assert_debug_snapshot!(
-        do_ref_completion(
-            r"
-            struct A {}
-            impl A {
-                #[inline]
-                fn the_method(&self) {
-                    let x = 1;
-                    let y = 2;
-                }
-            }
-            fn foo(a: A) {
-               a.<|>
-            }
-            ",
-        ),
-        @r###"
-        [
-            CompletionItem {
-                label: "the_method()",
-                source_range: 128..128,
-                delete: 128..128,
-                insert: "the_method()$0",
-                kind: Method,
-                lookup: "the_method",
-                detail: "fn the_method(&self)",
-            },
-        ]
-        "###
+    fn test_no_non_self_method() {
+        check(
+            r#"
+struct A {}
+impl A {
+    fn the_method() {}
+}
+fn foo(a: A) {
+   a.<|>
+}
+"#,
+            expect![[""]],
         );
     }
 
     #[test]
     fn test_tuple_field_completion() {
-        assert_debug_snapshot!(
-        do_ref_completion(
-            r"
-            fn foo() {
-               let b = (0, 3.14);
-               b.<|>
-            }
-            ",
-        ),
-        @r###"
-        [
-            CompletionItem {
-                label: "0",
-                source_range: 38..38,
-                delete: 38..38,
-                insert: "0",
-                kind: Field,
-                detail: "i32",
-            },
-            CompletionItem {
-                label: "1",
-                source_range: 38..38,
-                delete: 38..38,
-                insert: "1",
-                kind: Field,
-                detail: "f64",
-            },
-        ]
-        "###
-        );
+        check(
+            r#"
+fn foo() {
+   let b = (0, 3.14);
+   b.<|>
+}
+"#,
+            expect![[r#"
+                fd 0 i32
+                fd 1 f64
+            "#]],
+        )
     }
 
     #[test]
     fn test_tuple_field_inference() {
-        assert_debug_snapshot!(
-        do_ref_completion(
-            r"
-            pub struct S;
-            impl S {
-                pub fn blah(&self) {}
-            }
+        check(
+            r#"
+pub struct S;
+impl S { pub fn blah(&self) {} }
 
-            struct T(S);
+struct T(S);
 
-            impl T {
-                fn foo(&self) {
-                    // FIXME: This doesn't work without the trailing `a` as `0.` is a float
-                    self.0.a<|>
-                }
-            }
-            ",
-        ),
-        @r###"
-        [
-            CompletionItem {
-                label: "blah()",
-                source_range: 190..191,
-                delete: 190..191,
-                insert: "blah()$0",
-                kind: Method,
-                lookup: "blah",
-                detail: "pub fn blah(&self)",
-            },
-        ]
-        "###
-        );
+impl T {
+    fn foo(&self) {
+        // FIXME: This doesn't work without the trailing `a` as `0.` is a float
+        self.0.a<|>
     }
-
-    #[test]
-    fn test_completion_works_in_consts() {
-        assert_debug_snapshot!(
-        do_ref_completion(
-            r"
-            struct A { the_field: u32 }
-            const X: u32 = {
-                A { the_field: 92 }.<|>
-            };
-            ",
-        ),
-        @r###"
-        [
-            CompletionItem {
-                label: "the_field",
-                source_range: 69..69,
-                delete: 69..69,
-                insert: "the_field",
-                kind: Field,
-                detail: "u32",
-            },
-        ]
-        "###
+}
+"#,
+            expect![[r#"
+                me blah() pub fn blah(&self)
+            "#]],
         );
     }
 
     #[test]
-    fn test_completion_await_impls_future() {
-        assert_debug_snapshot!(
-        do_completion(
-            r###"
-            //- /main.rs
-            use std::future::*;
-            struct A {}
-            impl Future for A {}
-            fn foo(a: A) {
-                a.<|>
-            }
-
-            //- /std/lib.rs
-            pub mod future {
-                #[lang = "future_trait"]
-                pub trait Future {}
-            }
-            "###, CompletionKind::Keyword),
-        @r###"
-        [
-            CompletionItem {
-                label: "await",
-                source_range: 74..74,
-                delete: 74..74,
-                insert: "await",
-                detail: "expr.await",
-            },
-        ]
-        "###
-        )
-    }
-
-    #[test]
-    fn test_super_super_completion() {
-        assert_debug_snapshot!(
-        do_ref_completion(
-                r"
-                mod a {
-                    const A: usize = 0;
-
-                    mod b {
-                        const B: usize = 0;
-
-                        mod c {
-                            use super::super::<|>
-                        }
-                    }
-                }
-                ",
-        ),
-            @r###"
-        [
-            CompletionItem {
-                label: "A",
-                source_range: 120..120,
-                delete: 120..120,
-                insert: "A",
-                kind: Const,
-            },
-            CompletionItem {
-                label: "b",
-                source_range: 120..120,
-                delete: 120..120,
-                insert: "b",
-                kind: Module,
-            },
-        ]
-        "###
+    fn test_completion_works_in_consts() {
+        check(
+            r#"
+struct A { the_field: u32 }
+const X: u32 = {
+    A { the_field: 92 }.<|>
+};
+"#,
+            expect![[r#"
+                fd the_field u32
+            "#]],
         );
     }
 
     #[test]
     fn works_in_simple_macro_1() {
-        assert_debug_snapshot!(
-            do_ref_completion(
-                r"
-                macro_rules! m { ($e:expr) => { $e } }
-                struct A { the_field: u32 }
-                fn foo(a: A) {
-                    m!(a.x<|>)
-                }
-                ",
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "the_field",
-                source_range: 91..92,
-                delete: 91..92,
-                insert: "the_field",
-                kind: Field,
-                detail: "u32",
-            },
-        ]
-        "###
-        );
-    }
-
-    #[test]
-    fn works_in_simple_macro_recursive() {
-        assert_debug_snapshot!(
-            do_ref_completion(
-                r"
-                macro_rules! m { ($e:expr) => { $e } }
-                struct A { the_field: u32 }
-                fn foo(a: A) {
-                    m!(a.x<|>)
-                }
-                ",
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "the_field",
-                source_range: 91..92,
-                delete: 91..92,
-                insert: "the_field",
-                kind: Field,
-                detail: "u32",
-            },
-        ]
-        "###
+        check(
+            r#"
+macro_rules! m { ($e:expr) => { $e } }
+struct A { the_field: u32 }
+fn foo(a: A) {
+    m!(a.x<|>)
+}
+"#,
+            expect![[r#"
+                fd the_field u32
+            "#]],
         );
     }
 
     #[test]
     fn works_in_simple_macro_2() {
         // this doesn't work yet because the macro doesn't expand without the token -- maybe it can be fixed with better recovery
-        assert_debug_snapshot!(
-            do_ref_completion(
-                r"
-                macro_rules! m { ($e:expr) => { $e } }
-                struct A { the_field: u32 }
-                fn foo(a: A) {
-                    m!(a.<|>)
-                }
-                ",
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "the_field",
-                source_range: 91..91,
-                delete: 91..91,
-                insert: "the_field",
-                kind: Field,
-                detail: "u32",
-            },
-        ]
-        "###
+        check(
+            r#"
+macro_rules! m { ($e:expr) => { $e } }
+struct A { the_field: u32 }
+fn foo(a: A) {
+    m!(a.<|>)
+}
+"#,
+            expect![[r#"
+                fd the_field u32
+            "#]],
         );
     }
 
     #[test]
     fn works_in_simple_macro_recursive_1() {
-        assert_debug_snapshot!(
-            do_ref_completion(
-                r"
-                macro_rules! m { ($e:expr) => { $e } }
-                struct A { the_field: u32 }
-                fn foo(a: A) {
-                    m!(m!(m!(a.x<|>)))
-                }
-                ",
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "the_field",
-                source_range: 97..98,
-                delete: 97..98,
-                insert: "the_field",
-                kind: Field,
-                detail: "u32",
-            },
-        ]
-        "###
+        check(
+            r#"
+macro_rules! m { ($e:expr) => { $e } }
+struct A { the_field: u32 }
+fn foo(a: A) {
+    m!(m!(m!(a.x<|>)))
+}
+"#,
+            expect![[r#"
+                fd the_field u32
+            "#]],
         );
     }
 
     #[test]
     fn macro_expansion_resilient() {
-        assert_debug_snapshot!(
-            do_ref_completion(
-                r"
-                macro_rules! dbg {
-                    () => {};
-                    ($val:expr) => {
-                        match $val { tmp => { tmp } }
-                    };
-                    // Trailing comma with single argument is ignored
-                    ($val:expr,) => { $crate::dbg!($val) };
-                    ($($val:expr),+ $(,)?) => {
-                        ($($crate::dbg!($val)),+,)
-                    };
-                }
-                struct A { the_field: u32 }
-                fn foo(a: A) {
-                    dbg!(a.<|>)
-                }
-                ",
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "the_field",
-                source_range: 327..327,
-                delete: 327..327,
-                insert: "the_field",
-                kind: Field,
-                detail: "u32",
-            },
-        ]
-        "###
+        check(
+            r#"
+macro_rules! dbg {
+    () => {};
+    ($val:expr) => {
+        match $val { tmp => { tmp } }
+    };
+    // Trailing comma with single argument is ignored
+    ($val:expr,) => { $crate::dbg!($val) };
+    ($($val:expr),+ $(,)?) => {
+        ($($crate::dbg!($val)),+,)
+    };
+}
+struct A { the_field: u32 }
+fn foo(a: A) {
+    dbg!(a.<|>)
+}
+"#,
+            expect![[r#"
+                fd the_field u32
+            "#]],
         );
     }
 
     #[test]
-    fn test_method_completion_3547() {
-        assert_debug_snapshot!(
-            do_ref_completion(
-                r"
-            struct HashSet<T> {}
-            impl<T> HashSet<T> {
-                pub fn the_method(&self) {}
-            }
-            fn foo() {
-                let s: HashSet<_>;
-                s.<|>
-            }
-            ",
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "the_method()",
-                source_range: 116..116,
-                delete: 116..116,
-                insert: "the_method()$0",
-                kind: Method,
-                lookup: "the_method",
-                detail: "pub fn the_method(&self)",
-            },
-        ]
-        "###
+    fn test_method_completion_issue_3547() {
+        check(
+            r#"
+struct HashSet<T> {}
+impl<T> HashSet<T> {
+    pub fn the_method(&self) {}
+}
+fn foo() {
+    let s: HashSet<_>;
+    s.<|>
+}
+"#,
+            expect![[r#"
+                me the_method() pub fn the_method(&self)
+            "#]],
         );
     }
 }
diff --git a/crates/ra_ide/src/completion/complete_fn_param.rs b/crates/ra_ide/src/completion/complete_fn_param.rs
index f5573ddf7..406334257 100644
--- a/crates/ra_ide/src/completion/complete_fn_param.rs
+++ b/crates/ra_ide/src/completion/complete_fn_param.rs
@@ -1,4 +1,4 @@
-//! FIXME: write short doc here
+//! See `complete_fn_param`.
 
 use ra_syntax::{
     ast::{self, ModuleItemOwner},
@@ -18,35 +18,47 @@ pub(super) fn complete_fn_param(acc: &mut Completions, ctx: &CompletionContext)
     }
 
     let mut params = FxHashMap::default();
+
+    let me = ctx.token.ancestors().find_map(ast::Fn::cast);
+    let mut process_fn = |func: ast::Fn| {
+        if Some(&func) == me.as_ref() {
+            return;
+        }
+        func.param_list().into_iter().flat_map(|it| it.params()).for_each(|param| {
+            let text = param.syntax().text().to_string();
+            params.entry(text).or_insert(param);
+        })
+    };
+
     for node in ctx.token.parent().ancestors() {
-        let items = match_ast! {
+        match_ast! {
             match node {
-                ast::SourceFile(it) => it.items(),
-                ast::ItemList(it) => it.items(),
+                ast::SourceFile(it) => it.items().filter_map(|item| match item {
+                    ast::Item::Fn(it) => Some(it),
+                    _ => None,
+                }).for_each(&mut process_fn),
+                ast::ItemList(it) => it.items().filter_map(|item| match item {
+                    ast::Item::Fn(it) => Some(it),
+                    _ => None,
+                }).for_each(&mut process_fn),
+                ast::AssocItemList(it) => it.assoc_items().filter_map(|item| match item {
+                    ast::AssocItem::Fn(it) => Some(it),
+                    _ => None,
+                }).for_each(&mut process_fn),
                 _ => continue,
             }
         };
-        for item in items {
-            if let ast::ModuleItem::FnDef(func) = item {
-                func.param_list().into_iter().flat_map(|it| it.params()).for_each(|param| {
-                    let text = param.syntax().text().to_string();
-                    params.entry(text).or_insert((0, param)).0 += 1;
-                })
-            }
-        }
     }
+
     params
         .into_iter()
-        .filter_map(|(label, (count, param))| {
+        .filter_map(|(label, param)| {
             let lookup = param.pat()?.syntax().text().to_string();
-            if count < 2 {
-                None
-            } else {
-                Some((label, lookup))
-            }
+            Some((label, lookup))
         })
         .for_each(|(label, lookup)| {
             CompletionItem::new(CompletionKind::Magic, ctx.source_range(), label)
+                .kind(crate::CompletionItemKind::Binding)
                 .lookup_by(lookup)
                 .add_to(acc)
         });
@@ -54,85 +66,70 @@ pub(super) fn complete_fn_param(acc: &mut Completions, ctx: &CompletionContext)
 
 #[cfg(test)]
 mod tests {
-    use crate::completion::{test_utils::do_completion, CompletionItem, CompletionKind};
-    use insta::assert_debug_snapshot;
+    use expect::{expect, Expect};
+
+    use crate::completion::{test_utils::completion_list, CompletionKind};
 
-    fn do_magic_completion(code: &str) -> Vec<CompletionItem> {
-        do_completion(code, CompletionKind::Magic)
+    fn check(ra_fixture: &str, expect: Expect) {
+        let actual = completion_list(ra_fixture, CompletionKind::Magic);
+        expect.assert_eq(&actual);
     }
 
     #[test]
     fn test_param_completion_last_param() {
-        assert_debug_snapshot!(
-        do_magic_completion(
-                r"
-                fn foo(file_id: FileId) {}
-                fn bar(file_id: FileId) {}
-                fn baz(file<|>) {}
-                ",
-        ),
-            @r###"
-        [
-            CompletionItem {
-                label: "file_id: FileId",
-                source_range: 61..65,
-                delete: 61..65,
-                insert: "file_id: FileId",
-                lookup: "file_id",
-            },
-        ]
-        "###
+        check(
+            r#"
+fn foo(file_id: FileId) {}
+fn bar(file_id: FileId) {}
+fn baz(file<|>) {}
+"#,
+            expect![[r#"
+                bn file_id: FileId
+            "#]],
         );
     }
 
     #[test]
     fn test_param_completion_nth_param() {
-        assert_debug_snapshot!(
-        do_magic_completion(
-                r"
-                fn foo(file_id: FileId) {}
-                fn bar(file_id: FileId) {}
-                fn baz(file<|>, x: i32) {}
-                ",
-        ),
-            @r###"
-        [
-            CompletionItem {
-                label: "file_id: FileId",
-                source_range: 61..65,
-                delete: 61..65,
-                insert: "file_id: FileId",
-                lookup: "file_id",
-            },
-        ]
-        "###
+        check(
+            r#"
+fn foo(file_id: FileId) {}
+fn baz(file<|>, x: i32) {}
+"#,
+            expect![[r#"
+                bn file_id: FileId
+            "#]],
         );
     }
 
     #[test]
     fn test_param_completion_trait_param() {
-        assert_debug_snapshot!(
-        do_magic_completion(
-                r"
-                pub(crate) trait SourceRoot {
-                    pub fn contains(&self, file_id: FileId) -> bool;
-                    pub fn module_map(&self) -> &ModuleMap;
-                    pub fn lines(&self, file_id: FileId) -> &LineIndex;
-                    pub fn syntax(&self, file<|>)
-                }
-                ",
-        ),
-            @r###"
-        [
-            CompletionItem {
-                label: "file_id: FileId",
-                source_range: 208..212,
-                delete: 208..212,
-                insert: "file_id: FileId",
-                lookup: "file_id",
-            },
-        ]
-        "###
+        check(
+            r#"
+pub(crate) trait SourceRoot {
+    pub fn contains(&self, file_id: FileId) -> bool;
+    pub fn module_map(&self) -> &ModuleMap;
+    pub fn lines(&self, file_id: FileId) -> &LineIndex;
+    pub fn syntax(&self, file<|>)
+}
+"#,
+            expect![[r#"
+                bn file_id: FileId
+            "#]],
         );
     }
+
+    #[test]
+    fn completes_param_in_inner_function() {
+        check(
+            r#"
+fn outer(text: String) {
+    fn inner(<|>)
+}
+"#,
+            expect![[r#"
+                bn text: String
+            "#]],
+        )
+    }
 }
diff --git a/crates/ra_ide/src/completion/complete_keyword.rs b/crates/ra_ide/src/completion/complete_keyword.rs
index 3b174f916..b62064797 100644
--- a/crates/ra_ide/src/completion/complete_keyword.rs
+++ b/crates/ra_ide/src/completion/complete_keyword.rs
@@ -1,6 +1,7 @@
 //! FIXME: write short doc here
 
-use ra_syntax::ast;
+use ra_syntax::{ast, SyntaxKind};
+use test_utils::mark;
 
 use crate::completion::{
     CompletionContext, CompletionItem, CompletionItemKind, CompletionKind, Completions,
@@ -34,9 +35,27 @@ pub(super) fn complete_use_tree_keyword(acc: &mut Completions, ctx: &CompletionC
         }
         _ => {}
     }
+
+    // Suggest .await syntax for types that implement Future trait
+    if let Some(receiver) = &ctx.dot_receiver {
+        if let Some(ty) = ctx.sema.type_of_expr(receiver) {
+            if ty.impls_future(ctx.db) {
+                CompletionItem::new(CompletionKind::Keyword, ctx.source_range(), "await")
+                    .kind(CompletionItemKind::Keyword)
+                    .detail("expr.await")
+                    .insert_text("await")
+                    .add_to(acc);
+            }
+        };
+    }
 }
 
 pub(super) fn complete_expr_keyword(acc: &mut Completions, ctx: &CompletionContext) {
+    if ctx.token.kind() == SyntaxKind::COMMENT {
+        mark::hit!(no_keyword_completion_in_comments);
+        return;
+    }
+
     let has_trait_or_impl_parent = ctx.has_impl_parent || ctx.has_trait_parent;
     if ctx.trait_as_prev_sibling || ctx.impl_as_prev_sibling {
         add_keyword(ctx, acc, "where", "where ");
@@ -47,73 +66,67 @@ pub(super) fn complete_expr_keyword(acc: &mut Completions, ctx: &CompletionConte
             add_keyword(ctx, acc, "fn", "fn $0() {}")
         }
 
-        if (ctx.has_item_list_or_source_file_parent && !has_trait_or_impl_parent)
-            || ctx.block_expr_parent
-        {
+        if (ctx.has_item_list_or_source_file_parent) || ctx.block_expr_parent {
             add_keyword(ctx, acc, "trait", "trait $0 {}");
             add_keyword(ctx, acc, "impl", "impl $0 {}");
         }
 
         return;
     }
-    if ctx.has_item_list_or_source_file_parent || ctx.block_expr_parent {
+    if ctx.has_item_list_or_source_file_parent || has_trait_or_impl_parent || ctx.block_expr_parent
+    {
         add_keyword(ctx, acc, "fn", "fn $0() {}");
     }
-    if (ctx.has_item_list_or_source_file_parent && !has_trait_or_impl_parent)
-        || ctx.block_expr_parent
-    {
+    if (ctx.has_item_list_or_source_file_parent) || ctx.block_expr_parent {
         add_keyword(ctx, acc, "use", "use ");
         add_keyword(ctx, acc, "impl", "impl $0 {}");
         add_keyword(ctx, acc, "trait", "trait $0 {}");
     }
 
-    if ctx.has_item_list_or_source_file_parent && !has_trait_or_impl_parent {
+    if ctx.has_item_list_or_source_file_parent {
         add_keyword(ctx, acc, "enum", "enum $0 {}");
-        add_keyword(ctx, acc, "struct", "struct $0 {}");
+        add_keyword(ctx, acc, "struct", "struct $0");
         add_keyword(ctx, acc, "union", "union $0 {}");
     }
 
-    if ctx.block_expr_parent || ctx.is_match_arm {
+    if ctx.is_expr {
         add_keyword(ctx, acc, "match", "match $0 {}");
-        add_keyword(ctx, acc, "loop", "loop {$0}");
-    }
-    if ctx.block_expr_parent {
         add_keyword(ctx, acc, "while", "while $0 {}");
+        add_keyword(ctx, acc, "loop", "loop {$0}");
+        add_keyword(ctx, acc, "if", "if ");
+        add_keyword(ctx, acc, "if let", "if let ");
     }
+
     if ctx.if_is_prev || ctx.block_expr_parent {
         add_keyword(ctx, acc, "let", "let ");
     }
-    if ctx.if_is_prev || ctx.block_expr_parent || ctx.is_match_arm {
-        add_keyword(ctx, acc, "if", "if ");
-        add_keyword(ctx, acc, "if let", "if let ");
-    }
+
     if ctx.after_if {
         add_keyword(ctx, acc, "else", "else {$0}");
         add_keyword(ctx, acc, "else if", "else if $0 {}");
     }
-    if (ctx.has_item_list_or_source_file_parent && !has_trait_or_impl_parent)
-        || ctx.block_expr_parent
-    {
+    if (ctx.has_item_list_or_source_file_parent) || ctx.block_expr_parent {
         add_keyword(ctx, acc, "mod", "mod $0 {}");
     }
     if ctx.bind_pat_parent || ctx.ref_pat_parent {
         add_keyword(ctx, acc, "mut", "mut ");
     }
-    if ctx.has_item_list_or_source_file_parent || ctx.block_expr_parent {
+    if ctx.has_item_list_or_source_file_parent || has_trait_or_impl_parent || ctx.block_expr_parent
+    {
         add_keyword(ctx, acc, "const", "const ");
         add_keyword(ctx, acc, "type", "type ");
     }
-    if (ctx.has_item_list_or_source_file_parent && !has_trait_or_impl_parent)
-        || ctx.block_expr_parent
-    {
+    if (ctx.has_item_list_or_source_file_parent) || ctx.block_expr_parent {
         add_keyword(ctx, acc, "static", "static ");
     };
-    if (ctx.has_item_list_or_source_file_parent && !has_trait_or_impl_parent)
-        || ctx.block_expr_parent
-    {
+    if (ctx.has_item_list_or_source_file_parent) || ctx.block_expr_parent {
         add_keyword(ctx, acc, "extern", "extern ");
     }
-    if ctx.has_item_list_or_source_file_parent || ctx.block_expr_parent || ctx.is_match_arm {
+    if ctx.has_item_list_or_source_file_parent
+        || has_trait_or_impl_parent
+        || ctx.block_expr_parent
+        || ctx.is_match_arm
+    {
         add_keyword(ctx, acc, "unsafe", "unsafe ");
     }
     if ctx.in_loop_body {
@@ -125,7 +138,7 @@ pub(super) fn complete_expr_keyword(acc: &mut Completions, ctx: &CompletionConte
             add_keyword(ctx, acc, "break", "break");
         }
     }
-    if ctx.has_item_list_or_source_file_parent && !ctx.has_trait_parent {
+    if ctx.has_item_list_or_source_file_parent || ctx.has_impl_parent {
         add_keyword(ctx, acc, "pub", "pub ")
     }
 
@@ -156,7 +169,7 @@ fn add_keyword(ctx: &CompletionContext, acc: &mut Completions, kw: &str, snippet
 
 fn complete_return(
     ctx: &CompletionContext,
-    fn_def: &ast::FnDef,
+    fn_def: &ast::Fn,
     can_be_stmt: bool,
 ) -> Option<CompletionItem> {
     let snip = match (can_be_stmt, fn_def.ret_type().is_some()) {
@@ -170,289 +183,354 @@ fn complete_return(
 
 #[cfg(test)]
 mod tests {
-    use crate::completion::{test_utils::completion_list, CompletionKind};
-    use insta::assert_snapshot;
+    use expect::{expect, Expect};
+
+    use crate::completion::{
+        test_utils::{check_edit, completion_list},
+        CompletionKind,
+    };
+    use test_utils::mark;
 
-    fn get_keyword_completions(code: &str) -> String {
-        completion_list(code, CompletionKind::Keyword)
+    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###"
-            kw self
-            kw super::
-        "###
+        check(
+            r"use a::<|>",
+            expect![[r#"
+                kw self
+                kw super::
+            "#]],
         );
 
-        assert_snapshot!(
-            get_keyword_completions(r"use a::{b, <|>}"),
-            @r###"
-            kw self
-            kw super::
-        "###
+        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
+                kw while
+            "#]],
         );
     }
 
     #[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
+            "#]],
         );
     }
+
+    #[test]
+    fn no_keyword_completion_in_comments() {
+        mark::check!(no_keyword_completion_in_comments);
+        check(
+            r#"
+fn test() {
+    let x = 2; // A comment<|>
+}
+"#,
+            expect![[""]],
+        );
+        check(
+            r#"
+/*
+Some multi-line comment<|>
+*/
+"#,
+            expect![[""]],
+        );
+        check(
+            r#"
+/// Some doc comment
+/// let test<|> = 1
+"#,
+            expect![[""]],
+        );
+    }
+
+    #[test]
+    fn test_completion_await_impls_future() {
+        check(
+            r#"
+//- /main.rs
+use std::future::*;
+struct A {}
+impl Future for A {}
+fn foo(a: A) { a.<|> }
+
+//- /std/lib.rs
+pub mod future {
+    #[lang = "future_trait"]
+    pub trait Future {}
+}
+"#,
+            expect![[r#"
+                kw await expr.await
+            "#]],
+        )
+    }
+
+    #[test]
+    fn after_let() {
+        check(
+            r#"fn main() { let _ = <|> }"#,
+            expect![[r#"
+                kw if
+                kw if let
+                kw loop
+                kw match
+                kw return
+                kw while
+            "#]],
+        )
+    }
 }
diff --git a/crates/ra_ide/src/completion/complete_macro_in_item_position.rs b/crates/ra_ide/src/completion/complete_macro_in_item_position.rs
index 4c33f41d4..0447f0511 100644
--- a/crates/ra_ide/src/completion/complete_macro_in_item_position.rs
+++ b/crates/ra_ide/src/completion/complete_macro_in_item_position.rs
@@ -5,7 +5,7 @@ use crate::completion::{CompletionContext, Completions};
 pub(super) fn complete_macro_in_item_position(acc: &mut Completions, ctx: &CompletionContext) {
     // Show only macros in top level.
     if ctx.is_new_item {
-        ctx.scope().process_all_names(&mut |name, res| {
+        ctx.scope.process_all_names(&mut |name, res| {
             if let hir::ScopeDef::MacroDef(mac) = res {
                 acc.add_macro(ctx, Some(name.to_string()), mac);
             }
@@ -15,130 +15,27 @@ pub(super) fn complete_macro_in_item_position(acc: &mut Completions, ctx: &Compl
 
 #[cfg(test)]
 mod 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 do_reference_completion(code: &str) -> Vec<CompletionItem> {
-        do_completion(code, CompletionKind::Reference)
+    fn check(ra_fixture: &str, expect: Expect) {
+        let actual = completion_list(ra_fixture, CompletionKind::Reference);
+        expect.assert_eq(&actual)
     }
 
     #[test]
     fn completes_macros_as_item() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                "
-                //- /main.rs
-                macro_rules! foo {
-                    () => {}
-                }
-
-                fn foo() {}
-
-                <|>
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "foo!(…)",
-                source_range: 48..48,
-                delete: 48..48,
-                insert: "foo!($0)",
-                kind: Macro,
-                detail: "macro_rules! foo",
-            },
-        ]
-        "###
-        );
-    }
-
-    #[test]
-    fn completes_vec_macros_with_square_brackets() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                "
-                //- /main.rs
-                /// Creates a [`Vec`] containing the arguments.
-                ///
-                /// - Create a [`Vec`] containing a given list of elements:
-                ///
-                /// ```
-                /// let v = vec![1, 2, 3];
-                /// assert_eq!(v[0], 1);
-                /// assert_eq!(v[1], 2);
-                /// assert_eq!(v[2], 3);
-                /// ```
-                macro_rules! vec {
-                    () => {}
-                }
-
-                fn foo() {}
-
-                <|>
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "vec![…]",
-                source_range: 282..282,
-                delete: 282..282,
-                insert: "vec![$0]",
-                kind: Macro,
-                detail: "macro_rules! vec",
-                documentation: Documentation(
-                    "Creates a [`Vec`] containing the arguments.\n\n- Create a [`Vec`] containing a given list of elements:\n\n```\nlet v = vec![1, 2, 3];\nassert_eq!(v[0], 1);\nassert_eq!(v[1], 2);\nassert_eq!(v[2], 3);\n```",
-                ),
-            },
-        ]
-        "###
-        );
-    }
-
-    #[test]
-    fn completes_macros_braces_guessing() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                "
-                //- /main.rs
-                /// Foo
-                ///
-                /// Not call `fooo!()` `fooo!()`, or `_foo![]` `_foo![]`.
-                /// Call as `let _=foo!  { hello world };`
-                macro_rules! foo {
-                    () => {}
-                }
-
-                fn main() {
-                    <|>
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "foo! {…}",
-                source_range: 164..164,
-                delete: 164..164,
-                insert: "foo! {$0}",
-                kind: Macro,
-                detail: "macro_rules! foo",
-                documentation: Documentation(
-                    "Foo\n\nNot call `fooo!()` `fooo!()`, or `_foo![]` `_foo![]`.\nCall as `let _=foo!  { hello world };`",
-                ),
-            },
-            CompletionItem {
-                label: "main()",
-                source_range: 164..164,
-                delete: 164..164,
-                insert: "main()$0",
-                kind: Function,
-                lookup: "main",
-                detail: "fn main()",
-            },
-        ]
-        "###
-        );
+        check(
+            r#"
+macro_rules! foo { () => {} }
+fn foo() {}
+
+<|>
+"#,
+            expect![[r#"
+                ma foo!(…) macro_rules! foo
+            "#]],
+        )
     }
 }
diff --git a/crates/ra_ide/src/completion/complete_pattern.rs b/crates/ra_ide/src/completion/complete_pattern.rs
index 367e2bbce..aceb77cb5 100644
--- a/crates/ra_ide/src/completion/complete_pattern.rs
+++ b/crates/ra_ide/src/completion/complete_pattern.rs
@@ -13,7 +13,7 @@ pub(super) fn complete_pattern(acc: &mut Completions, ctx: &CompletionContext) {
 
     // FIXME: ideally, we should look at the type we are matching against and
     // suggest variants + auto-imports
-    ctx.scope().process_all_names(&mut |name, res| {
+    ctx.scope.process_all_names(&mut |name, res| {
         match &res {
             hir::ScopeDef::ModuleDef(def) => match def {
                 hir::ModuleDef::Adt(hir::Adt::Enum(..))
@@ -33,106 +33,56 @@ pub(super) fn complete_pattern(acc: &mut Completions, ctx: &CompletionContext) {
 
 #[cfg(test)]
 mod tests {
-    use crate::completion::{test_utils::do_completion, CompletionItem, CompletionKind};
-    use insta::assert_debug_snapshot;
+    use expect::{expect, Expect};
 
-    fn complete(code: &str) -> Vec<CompletionItem> {
-        do_completion(code, CompletionKind::Reference)
+    use crate::completion::{test_utils::completion_list, CompletionKind};
+
+    fn check(ra_fixture: &str, expect: Expect) {
+        let actual = completion_list(ra_fixture, CompletionKind::Reference);
+        expect.assert_eq(&actual)
     }
 
     #[test]
     fn completes_enum_variants_and_modules() {
-        let completions = complete(
-            r"
-            enum E { X }
-            use self::E::X;
-            const Z: E = E::X;
-            mod m {}
+        check(
+            r#"
+enum E { X }
+use self::E::X;
+const Z: E = E::X;
+mod m {}
 
-            static FOO: E = E::X;
-            struct Bar { f: u32 }
+static FOO: E = E::X;
+struct Bar { f: u32 }
 
-            fn foo() {
-               match E::X {
-                   <|>
-               }
-            }
-            ",
+fn foo() {
+   match E::X { <|> }
+}
+"#,
+            expect![[r#"
+                st Bar
+                en E
+                ev X   ()
+                ct Z
+                md m
+            "#]],
         );
-        assert_debug_snapshot!(completions, @r###"
-        [
-            CompletionItem {
-                label: "Bar",
-                source_range: 137..137,
-                delete: 137..137,
-                insert: "Bar",
-                kind: Struct,
-            },
-            CompletionItem {
-                label: "E",
-                source_range: 137..137,
-                delete: 137..137,
-                insert: "E",
-                kind: Enum,
-            },
-            CompletionItem {
-                label: "X",
-                source_range: 137..137,
-                delete: 137..137,
-                insert: "X",
-                kind: EnumVariant,
-                detail: "()",
-            },
-            CompletionItem {
-                label: "Z",
-                source_range: 137..137,
-                delete: 137..137,
-                insert: "Z",
-                kind: Const,
-            },
-            CompletionItem {
-                label: "m",
-                source_range: 137..137,
-                delete: 137..137,
-                insert: "m",
-                kind: Module,
-            },
-        ]
-        "###);
     }
 
     #[test]
     fn completes_in_simple_macro_call() {
-        let completions = complete(
-            r"
-            macro_rules! m { ($e:expr) => { $e } }
-            enum E { X }
+        check(
+            r#"
+macro_rules! m { ($e:expr) => { $e } }
+enum E { X }
 
-            fn foo() {
-               m!(match E::X {
-                   <|>
-               })
-            }
-            ",
+fn foo() {
+   m!(match E::X { <|> })
+}
+"#,
+            expect![[r#"
+                en E
+                ma m!(…) macro_rules! m
+            "#]],
         );
-        assert_debug_snapshot!(completions, @r###"
-        [
-            CompletionItem {
-                label: "E",
-                source_range: 90..90,
-                delete: 90..90,
-                insert: "E",
-                kind: Enum,
-            },
-            CompletionItem {
-                label: "m!(…)",
-                source_range: 90..90,
-                delete: 90..90,
-                insert: "m!($0)",
-                kind: Macro,
-                detail: "macro_rules! m",
-            },
-        ]
-        "###);
     }
 }
diff --git a/crates/ra_ide/src/completion/complete_postfix.rs b/crates/ra_ide/src/completion/complete_postfix.rs
index 3bd64804f..8735b9010 100644
--- a/crates/ra_ide/src/completion/complete_postfix.rs
+++ b/crates/ra_ide/src/completion/complete_postfix.rs
@@ -8,14 +8,13 @@ use ra_text_edit::TextEdit;
 
 use crate::{
     completion::{
+        completion_config::SnippetCap,
         completion_context::CompletionContext,
         completion_item::{Builder, CompletionKind, Completions},
     },
-    CompletionItem,
+    CompletionItem, CompletionItemKind,
 };
 
-use super::completion_config::SnippetCap;
-
 pub(super) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
     if !ctx.config.enable_postfix_completions {
         return;
@@ -103,10 +102,9 @@ pub(super) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
             &format!("while {} {{\n    $0\n}}", receiver_text),
         )
         .add_to(acc);
+        postfix_snippet(ctx, cap, &dot_receiver, "not", "!expr", &format!("!{}", receiver_text))
+            .add_to(acc);
     }
-    // !&&&42 is a compiler error, ergo process it before considering the references
-    postfix_snippet(ctx, cap, &dot_receiver, "not", "!expr", &format!("!{}", receiver_text))
-        .add_to(acc);
 
     postfix_snippet(ctx, cap, &dot_receiver, "ref", "&expr", &format!("&{}", receiver_text))
         .add_to(acc);
@@ -125,33 +123,35 @@ pub(super) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
     let dot_receiver = include_references(dot_receiver);
     let receiver_text =
         get_receiver_text(&dot_receiver, ctx.dot_receiver_is_ambiguous_float_literal);
+
     match try_enum {
-        Some(try_enum) => {
-            match try_enum {
-                TryEnum::Result => {
-                    postfix_snippet(
+        Some(try_enum) => match try_enum {
+            TryEnum::Result => {
+                postfix_snippet(
                     ctx,
                     cap,
                     &dot_receiver,
                     "match",
                     "match expr {}",
-                    &format!("match {} {{\n    Ok(${{1:_}}) => {{$2\\}},\n    Err(${{3:_}}) => {{$0\\}},\n}}", receiver_text),
+                    &format!("match {} {{\n    Ok(${{1:_}}) => {{$2}},\n    Err(${{3:_}}) => {{$0}},\n}}", receiver_text),
                 )
                 .add_to(acc);
-                }
-                TryEnum::Option => {
-                    postfix_snippet(
+            }
+            TryEnum::Option => {
+                postfix_snippet(
                     ctx,
                     cap,
                     &dot_receiver,
                     "match",
                     "match expr {}",
-                    &format!("match {} {{\n    Some(${{1:_}}) => {{$2\\}},\n    None => {{$0\\}},\n}}", receiver_text),
+                    &format!(
+                        "match {} {{\n    Some(${{1:_}}) => {{$2}},\n    None => {{$0}},\n}}",
+                        receiver_text
+                    ),
                 )
                 .add_to(acc);
-                }
             }
-        }
+        },
         None => {
             postfix_snippet(
                 ctx,
@@ -159,7 +159,7 @@ pub(super) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
                 &dot_receiver,
                 "match",
                 "match expr {}",
-                &format!("match {} {{\n    ${{1:_}} => {{$0\\}},\n}}", receiver_text),
+                &format!("match {} {{\n    ${{1:_}} => {{$0}},\n}}", receiver_text),
             )
             .add_to(acc);
         }
@@ -232,536 +232,147 @@ fn postfix_snippet(
     };
     CompletionItem::new(CompletionKind::Postfix, ctx.source_range(), label)
         .detail(detail)
+        .kind(CompletionItemKind::Snippet)
         .snippet_edit(cap, edit)
 }
 
 #[cfg(test)]
 mod tests {
-    use insta::assert_debug_snapshot;
+    use expect::{expect, Expect};
 
-    use crate::completion::{test_utils::do_completion, CompletionItem, CompletionKind};
+    use crate::completion::{
+        test_utils::{check_edit, completion_list},
+        CompletionKind,
+    };
 
-    fn do_postfix_completion(code: &str) -> Vec<CompletionItem> {
-        do_completion(code, CompletionKind::Postfix)
+    fn check(ra_fixture: &str, expect: Expect) {
+        let actual = completion_list(ra_fixture, CompletionKind::Postfix);
+        expect.assert_eq(&actual)
     }
 
     #[test]
     fn postfix_completion_works_for_trivial_path_expression() {
-        assert_debug_snapshot!(
-            do_postfix_completion(
-                r#"
-                fn main() {
-                    let bar = true;
-                    bar.<|>
-                }
-                "#,
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "box",
-                source_range: 40..40,
-                delete: 36..40,
-                insert: "Box::new(bar)",
-                detail: "Box::new(expr)",
-            },
-            CompletionItem {
-                label: "call",
-                source_range: 40..40,
-                delete: 36..40,
-                insert: "${1}(bar)",
-                detail: "function(expr)",
-            },
-            CompletionItem {
-                label: "dbg",
-                source_range: 40..40,
-                delete: 36..40,
-                insert: "dbg!(bar)",
-                detail: "dbg!(expr)",
-            },
-            CompletionItem {
-                label: "if",
-                source_range: 40..40,
-                delete: 36..40,
-                insert: "if bar {\n    $0\n}",
-                detail: "if expr {}",
-            },
-            CompletionItem {
-                label: "match",
-                source_range: 40..40,
-                delete: 36..40,
-                insert: "match bar {\n    ${1:_} => {$0\\},\n}",
-                detail: "match expr {}",
-            },
-            CompletionItem {
-                label: "not",
-                source_range: 40..40,
-                delete: 36..40,
-                insert: "!bar",
-                detail: "!expr",
-            },
-            CompletionItem {
-                label: "ref",
-                source_range: 40..40,
-                delete: 36..40,
-                insert: "&bar",
-                detail: "&expr",
-            },
-            CompletionItem {
-                label: "refm",
-                source_range: 40..40,
-                delete: 36..40,
-                insert: "&mut bar",
-                detail: "&mut expr",
-            },
-            CompletionItem {
-                label: "while",
-                source_range: 40..40,
-                delete: 36..40,
-                insert: "while bar {\n    $0\n}",
-                detail: "while expr {}",
-            },
-        ]
-        "###
+        check(
+            r#"
+fn main() {
+    let bar = true;
+    bar.<|>
+}
+"#,
+            expect![[r#"
+                sn box   Box::new(expr)
+                sn call  function(expr)
+                sn dbg   dbg!(expr)
+                sn if    if expr {}
+                sn match match expr {}
+                sn not   !expr
+                sn ref   &expr
+                sn refm  &mut expr
+                sn while while expr {}
+            "#]],
         );
     }
 
     #[test]
-    fn postfix_completion_works_for_option() {
-        assert_debug_snapshot!(
-            do_postfix_completion(
-                r#"
-                enum Option<T> {
-                    Some(T),
-                    None,
-                }
-
-                fn main() {
-                    let bar = Option::Some(true);
-                    bar.<|>
-                }
-                "#,
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "box",
-                source_range: 97..97,
-                delete: 93..97,
-                insert: "Box::new(bar)",
-                detail: "Box::new(expr)",
-            },
-            CompletionItem {
-                label: "call",
-                source_range: 97..97,
-                delete: 93..97,
-                insert: "${1}(bar)",
-                detail: "function(expr)",
-            },
-            CompletionItem {
-                label: "dbg",
-                source_range: 97..97,
-                delete: 93..97,
-                insert: "dbg!(bar)",
-                detail: "dbg!(expr)",
-            },
-            CompletionItem {
-                label: "ifl",
-                source_range: 97..97,
-                delete: 93..97,
-                insert: "if let Some($1) = bar {\n    $0\n}",
-                detail: "if let Some {}",
-            },
-            CompletionItem {
-                label: "match",
-                source_range: 97..97,
-                delete: 93..97,
-                insert: "match bar {\n    Some(${1:_}) => {$2\\},\n    None => {$0\\},\n}",
-                detail: "match expr {}",
-            },
-            CompletionItem {
-                label: "not",
-                source_range: 97..97,
-                delete: 93..97,
-                insert: "!bar",
-                detail: "!expr",
-            },
-            CompletionItem {
-                label: "ref",
-                source_range: 97..97,
-                delete: 93..97,
-                insert: "&bar",
-                detail: "&expr",
-            },
-            CompletionItem {
-                label: "refm",
-                source_range: 97..97,
-                delete: 93..97,
-                insert: "&mut bar",
-                detail: "&mut expr",
-            },
-            CompletionItem {
-                label: "while",
-                source_range: 97..97,
-                delete: 93..97,
-                insert: "while let Some($1) = bar {\n    $0\n}",
-                detail: "while let Some {}",
-            },
-        ]
-        "###
-        );
+    fn postfix_type_filtering() {
+        check(
+            r#"
+fn main() {
+    let bar: u8 = 12;
+    bar.<|>
+}
+"#,
+            expect![[r#"
+                sn box   Box::new(expr)
+                sn call  function(expr)
+                sn dbg   dbg!(expr)
+                sn match match expr {}
+                sn ref   &expr
+                sn refm  &mut expr
+            "#]],
+        )
     }
 
     #[test]
-    fn postfix_completion_works_for_result() {
-        assert_debug_snapshot!(
-            do_postfix_completion(
-                r#"
-                enum Result<T, E> {
-                    Ok(T),
-                    Err(E),
-                }
+    fn option_iflet() {
+        check_edit(
+            "ifl",
+            r#"
+enum Option<T> { Some(T), None }
+
+fn main() {
+    let bar = Option::Some(true);
+    bar.<|>
+}
+"#,
+            r#"
+enum Option<T> { Some(T), None }
 
-                fn main() {
-                    let bar = Result::Ok(true);
-                    bar.<|>
-                }
-                "#,
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "box",
-                source_range: 98..98,
-                delete: 94..98,
-                insert: "Box::new(bar)",
-                detail: "Box::new(expr)",
-            },
-            CompletionItem {
-                label: "call",
-                source_range: 98..98,
-                delete: 94..98,
-                insert: "${1}(bar)",
-                detail: "function(expr)",
-            },
-            CompletionItem {
-                label: "dbg",
-                source_range: 98..98,
-                delete: 94..98,
-                insert: "dbg!(bar)",
-                detail: "dbg!(expr)",
-            },
-            CompletionItem {
-                label: "ifl",
-                source_range: 98..98,
-                delete: 94..98,
-                insert: "if let Ok($1) = bar {\n    $0\n}",
-                detail: "if let Ok {}",
-            },
-            CompletionItem {
-                label: "match",
-                source_range: 98..98,
-                delete: 94..98,
-                insert: "match bar {\n    Ok(${1:_}) => {$2\\},\n    Err(${3:_}) => {$0\\},\n}",
-                detail: "match expr {}",
-            },
-            CompletionItem {
-                label: "not",
-                source_range: 98..98,
-                delete: 94..98,
-                insert: "!bar",
-                detail: "!expr",
-            },
-            CompletionItem {
-                label: "ref",
-                source_range: 98..98,
-                delete: 94..98,
-                insert: "&bar",
-                detail: "&expr",
-            },
-            CompletionItem {
-                label: "refm",
-                source_range: 98..98,
-                delete: 94..98,
-                insert: "&mut bar",
-                detail: "&mut expr",
-            },
-            CompletionItem {
-                label: "while",
-                source_range: 98..98,
-                delete: 94..98,
-                insert: "while let Ok($1) = bar {\n    $0\n}",
-                detail: "while let Ok {}",
-            },
-        ]
-        "###
+fn main() {
+    let bar = Option::Some(true);
+    if let Some($1) = bar {
+    $0
+}
+}
+"#,
         );
     }
 
     #[test]
-    fn some_postfix_completions_ignored() {
-        assert_debug_snapshot!(
-            do_postfix_completion(
-                r#"
-                fn main() {
-                    let bar: u8 = 12;
-                    bar.<|>
-                }
-                "#,
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "box",
-                source_range: 42..42,
-                delete: 38..42,
-                insert: "Box::new(bar)",
-                detail: "Box::new(expr)",
-            },
-            CompletionItem {
-                label: "call",
-                source_range: 42..42,
-                delete: 38..42,
-                insert: "${1}(bar)",
-                detail: "function(expr)",
-            },
-            CompletionItem {
-                label: "dbg",
-                source_range: 42..42,
-                delete: 38..42,
-                insert: "dbg!(bar)",
-                detail: "dbg!(expr)",
-            },
-            CompletionItem {
-                label: "match",
-                source_range: 42..42,
-                delete: 38..42,
-                insert: "match bar {\n    ${1:_} => {$0\\},\n}",
-                detail: "match expr {}",
-            },
-            CompletionItem {
-                label: "not",
-                source_range: 42..42,
-                delete: 38..42,
-                insert: "!bar",
-                detail: "!expr",
-            },
-            CompletionItem {
-                label: "ref",
-                source_range: 42..42,
-                delete: 38..42,
-                insert: "&bar",
-                detail: "&expr",
-            },
-            CompletionItem {
-                label: "refm",
-                source_range: 42..42,
-                delete: 38..42,
-                insert: "&mut bar",
-                detail: "&mut expr",
-            },
-        ]
-        "###
+    fn result_match() {
+        check_edit(
+            "match",
+            r#"
+enum Result<T, E> { Ok(T), Err(E) }
+
+fn main() {
+    let bar = Result::Ok(true);
+    bar.<|>
+}
+"#,
+            r#"
+enum Result<T, E> { Ok(T), Err(E) }
+
+fn main() {
+    let bar = Result::Ok(true);
+    match bar {
+    Ok(${1:_}) => {$2},
+    Err(${3:_}) => {$0},
+}
+}
+"#,
         );
     }
 
     #[test]
     fn postfix_completion_works_for_ambiguous_float_literal() {
-        assert_debug_snapshot!(
-            do_postfix_completion(
-                r#"
-                fn main() {
-                    42.<|>
-                }
-                "#,
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "box",
-                source_range: 19..19,
-                delete: 16..19,
-                insert: "Box::new(42)",
-                detail: "Box::new(expr)",
-            },
-            CompletionItem {
-                label: "call",
-                source_range: 19..19,
-                delete: 16..19,
-                insert: "${1}(42)",
-                detail: "function(expr)",
-            },
-            CompletionItem {
-                label: "dbg",
-                source_range: 19..19,
-                delete: 16..19,
-                insert: "dbg!(42)",
-                detail: "dbg!(expr)",
-            },
-            CompletionItem {
-                label: "match",
-                source_range: 19..19,
-                delete: 16..19,
-                insert: "match 42 {\n    ${1:_} => {$0\\},\n}",
-                detail: "match expr {}",
-            },
-            CompletionItem {
-                label: "not",
-                source_range: 19..19,
-                delete: 16..19,
-                insert: "!42",
-                detail: "!expr",
-            },
-            CompletionItem {
-                label: "ref",
-                source_range: 19..19,
-                delete: 16..19,
-                insert: "&42",
-                detail: "&expr",
-            },
-            CompletionItem {
-                label: "refm",
-                source_range: 19..19,
-                delete: 16..19,
-                insert: "&mut 42",
-                detail: "&mut expr",
-            },
-        ]
-        "###
-        );
+        check_edit("refm", r#"fn main() { 42.<|> }"#, r#"fn main() { &mut 42 }"#)
     }
 
     #[test]
     fn works_in_simple_macro() {
-        assert_debug_snapshot!(
-            do_postfix_completion(
-                r#"
-                macro_rules! m { ($e:expr) => { $e } }
-                fn main() {
-                    let bar: u8 = 12;
-                    m!(bar.b<|>)
-                }
-                "#,
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "box",
-                source_range: 84..85,
-                delete: 80..85,
-                insert: "Box::new(bar)",
-                detail: "Box::new(expr)",
-            },
-            CompletionItem {
-                label: "call",
-                source_range: 84..85,
-                delete: 80..85,
-                insert: "${1}(bar)",
-                detail: "function(expr)",
-            },
-            CompletionItem {
-                label: "dbg",
-                source_range: 84..85,
-                delete: 80..85,
-                insert: "dbg!(bar)",
-                detail: "dbg!(expr)",
-            },
-            CompletionItem {
-                label: "match",
-                source_range: 84..85,
-                delete: 80..85,
-                insert: "match bar {\n    ${1:_} => {$0\\},\n}",
-                detail: "match expr {}",
-            },
-            CompletionItem {
-                label: "not",
-                source_range: 84..85,
-                delete: 80..85,
-                insert: "!bar",
-                detail: "!expr",
-            },
-            CompletionItem {
-                label: "ref",
-                source_range: 84..85,
-                delete: 80..85,
-                insert: "&bar",
-                detail: "&expr",
-            },
-            CompletionItem {
-                label: "refm",
-                source_range: 84..85,
-                delete: 80..85,
-                insert: "&mut bar",
-                detail: "&mut expr",
-            },
-        ]
-        "###
+        check_edit(
+            "dbg",
+            r#"
+macro_rules! m { ($e:expr) => { $e } }
+fn main() {
+    let bar: u8 = 12;
+    m!(bar.d<|>)
+}
+"#,
+            r#"
+macro_rules! m { ($e:expr) => { $e } }
+fn main() {
+    let bar: u8 = 12;
+    m!(dbg!(bar))
+}
+"#,
         );
     }
 
     #[test]
     fn postfix_completion_for_references() {
-        assert_debug_snapshot!(
-            do_postfix_completion(
-                r#"
-                fn main() {
-                    &&&&42.<|>
-                }
-                "#,
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "box",
-                source_range: 23..23,
-                delete: 16..23,
-                insert: "Box::new(&&&&42)",
-                detail: "Box::new(expr)",
-            },
-            CompletionItem {
-                label: "call",
-                source_range: 23..23,
-                delete: 16..23,
-                insert: "${1}(&&&&42)",
-                detail: "function(expr)",
-            },
-            CompletionItem {
-                label: "dbg",
-                source_range: 23..23,
-                delete: 16..23,
-                insert: "dbg!(&&&&42)",
-                detail: "dbg!(expr)",
-            },
-            CompletionItem {
-                label: "match",
-                source_range: 23..23,
-                delete: 16..23,
-                insert: "match &&&&42 {\n    ${1:_} => {$0\\},\n}",
-                detail: "match expr {}",
-            },
-            CompletionItem {
-                label: "not",
-                source_range: 23..23,
-                delete: 20..23,
-                insert: "!42",
-                detail: "!expr",
-            },
-            CompletionItem {
-                label: "ref",
-                source_range: 23..23,
-                delete: 20..23,
-                insert: "&42",
-                detail: "&expr",
-            },
-            CompletionItem {
-                label: "refm",
-                source_range: 23..23,
-                delete: 20..23,
-                insert: "&mut 42",
-                detail: "&mut expr",
-            },
-        ]
-        "###
-        );
+        check_edit("dbg", r#"fn main() { &&42.<|> }"#, r#"fn main() { dbg!(&&42) }"#);
+        check_edit("refm", r#"fn main() { &&42.<|> }"#, r#"fn main() { &&&mut 42 }"#);
     }
 }
diff --git a/crates/ra_ide/src/completion/complete_qualified_path.rs b/crates/ra_ide/src/completion/complete_qualified_path.rs
index f133ce3ce..b08f5b9b4 100644
--- a/crates/ra_ide/src/completion/complete_qualified_path.rs
+++ b/crates/ra_ide/src/completion/complete_qualified_path.rs
@@ -17,21 +17,20 @@ pub(super) fn complete_qualified_path(acc: &mut Completions, ctx: &CompletionCon
         return;
     }
 
-    let scope = ctx.scope();
-    let context_module = scope.module();
+    let context_module = ctx.scope.module();
 
-    let res = match scope.resolve_hir_path_qualifier(&path) {
+    let resolution = match ctx.scope.resolve_hir_path_qualifier(&path) {
         Some(res) => res,
         None => return,
     };
 
     // Add associated types on type parameters and `Self`.
-    res.assoc_type_shorthand_candidates(ctx.db, |alias| {
+    resolution.assoc_type_shorthand_candidates(ctx.db, |alias| {
         acc.add_type_alias(ctx, alias);
         None::<()>
     });
 
-    match res {
+    match resolution {
         PathResolution::Def(hir::ModuleDef::Module(module)) => {
             let module_scope = module.scope(ctx.db, context_module);
             for (name, def) in module_scope {
@@ -68,7 +67,7 @@ pub(super) fn complete_qualified_path(acc: &mut Completions, ctx: &CompletionCon
 
             let krate = ctx.krate;
             if let Some(krate) = krate {
-                let traits_in_scope = ctx.scope().traits_in_scope();
+                let traits_in_scope = ctx.scope.traits_in_scope();
                 ty.iterate_path_candidates(ctx.db, krate, &traits_in_scope, None, |_ty, item| {
                     if context_module.map_or(false, |m| !item.is_visible_from(ctx.db, m)) {
                         return None;
@@ -113,13 +112,13 @@ pub(super) fn complete_qualified_path(acc: &mut Completions, ctx: &CompletionCon
         }
         PathResolution::TypeParam(_) | PathResolution::SelfType(_) => {
             if let Some(krate) = ctx.krate {
-                let ty = match res {
+                let ty = match resolution {
                     PathResolution::TypeParam(param) => param.ty(ctx.db),
                     PathResolution::SelfType(impl_def) => impl_def.target_ty(ctx.db),
                     _ => return,
                 };
 
-                let traits_in_scope = ctx.scope().traits_in_scope();
+                let traits_in_scope = ctx.scope.traits_in_scope();
                 let mut seen = FxHashSet::default();
                 ty.iterate_path_candidates(ctx.db, krate, &traits_in_scope, None, |_ty, item| {
                     if context_module.map_or(false, |m| !item.is_visible_from(ctx.db, m)) {
@@ -147,1229 +146,588 @@ pub(super) fn complete_qualified_path(acc: &mut Completions, ctx: &CompletionCon
 
 #[cfg(test)]
 mod tests {
+    use expect::{expect, Expect};
     use test_utils::mark;
 
-    use crate::completion::{test_utils::do_completion, CompletionItem, CompletionKind};
-    use insta::assert_debug_snapshot;
+    use crate::completion::{
+        test_utils::{check_edit, completion_list},
+        CompletionKind,
+    };
+
+    fn check(ra_fixture: &str, expect: Expect) {
+        let actual = completion_list(ra_fixture, CompletionKind::Reference);
+        expect.assert_eq(&actual);
+    }
 
-    fn do_reference_completion(code: &str) -> Vec<CompletionItem> {
-        do_completion(code, CompletionKind::Reference)
+    fn check_builtin(ra_fixture: &str, expect: Expect) {
+        let actual = completion_list(ra_fixture, CompletionKind::BuiltinType);
+        expect.assert_eq(&actual);
     }
 
     #[test]
     fn dont_complete_current_use() {
         mark::check!(dont_complete_current_use);
-        let completions = do_completion(r"use self::foo<|>;", CompletionKind::Reference);
-        assert!(completions.is_empty());
+        check(r#"use self::foo<|>;"#, expect![[""]]);
     }
 
     #[test]
     fn dont_complete_current_use_in_braces_with_glob() {
-        let completions = do_completion(
-            r"
-            mod foo { pub struct S; }
-            use self::{foo::*, bar<|>};
-            ",
-            CompletionKind::Reference,
+        check(
+            r#"
+mod foo { pub struct S; }
+use self::{foo::*, bar<|>};
+"#,
+            expect![[r#"
+                st S
+                md foo
+            "#]],
         );
-        assert_eq!(completions.len(), 2);
     }
 
     #[test]
     fn dont_complete_primitive_in_use() {
-        let completions = do_completion(r"use self::<|>;", CompletionKind::BuiltinType);
-        assert!(completions.is_empty());
+        check_builtin(r#"use self::<|>;"#, expect![[""]]);
     }
 
     #[test]
     fn dont_complete_primitive_in_module_scope() {
-        let completions = do_completion(r"fn foo() { self::<|> }", CompletionKind::BuiltinType);
-        assert!(completions.is_empty());
+        check_builtin(r#"fn foo() { self::<|> }"#, expect![[""]]);
     }
 
     #[test]
     fn completes_primitives() {
-        let completions =
-            do_completion(r"fn main() { let _: <|> = 92; }", CompletionKind::BuiltinType);
-        assert_eq!(completions.len(), 17);
-    }
-
-    #[test]
-    fn completes_mod_with_docs() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                r"
-                use self::my<|>;
-
-                /// Some simple
-                /// docs describing `mod my`.
-                mod my {
-                    struct Bar;
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "my",
-                source_range: 10..12,
-                delete: 10..12,
-                insert: "my",
-                kind: Module,
-                documentation: Documentation(
-                    "Some simple\ndocs describing `mod my`.",
-                ),
-            },
-        ]
-        "###
+        check_builtin(
+            r#"fn main() { let _: <|> = 92; }"#,
+            expect![[r#"
+                bt bool
+                bt char
+                bt f32
+                bt f64
+                bt i128
+                bt i16
+                bt i32
+                bt i64
+                bt i8
+                bt isize
+                bt str
+                bt u128
+                bt u16
+                bt u32
+                bt u64
+                bt u8
+                bt usize
+            "#]],
         );
     }
 
     #[test]
     fn completes_mod_with_same_name_as_function() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                r"
-                use self::my::<|>;
-
-                mod my {
-                    pub struct Bar;
-                }
-
-                fn my() {}
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "Bar",
-                source_range: 14..14,
-                delete: 14..14,
-                insert: "Bar",
-                kind: Struct,
-            },
-        ]
-        "###
+        check(
+            r#"
+use self::my::<|>;
+
+mod my { pub struct Bar; }
+fn my() {}
+"#,
+            expect![[r#"
+                st Bar
+            "#]],
         );
     }
 
     #[test]
-    fn path_visibility() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                r"
-                use self::my::<|>;
-
-                mod my {
-                    struct Bar;
-                    pub struct Foo;
-                    pub use Bar as PublicBar;
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "Foo",
-                source_range: 14..14,
-                delete: 14..14,
-                insert: "Foo",
-                kind: Struct,
-            },
-            CompletionItem {
-                label: "PublicBar",
-                source_range: 14..14,
-                delete: 14..14,
-                insert: "PublicBar",
-                kind: Struct,
-            },
-        ]
-        "###
+    fn filters_visibility() {
+        check(
+            r#"
+use self::my::<|>;
+
+mod my {
+    struct Bar;
+    pub struct Foo;
+    pub use Bar as PublicBar;
+}
+"#,
+            expect![[r#"
+                st Foo
+                st PublicBar
+            "#]],
         );
     }
 
     #[test]
     fn completes_use_item_starting_with_self() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                r"
-                use self::m::<|>;
+        check(
+            r#"
+use self::m::<|>;
 
-                mod m {
-                    pub struct Bar;
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "Bar",
-                source_range: 13..13,
-                delete: 13..13,
-                insert: "Bar",
-                kind: Struct,
-            },
-        ]
-        "###
+mod m { pub struct Bar; }
+"#,
+            expect![[r#"
+                st Bar
+            "#]],
         );
     }
 
     #[test]
     fn completes_use_item_starting_with_crate() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                "
-                //- /lib.rs
-                mod foo;
-                struct Spam;
-                //- /foo.rs
-                use crate::Sp<|>
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "Spam",
-                source_range: 11..13,
-                delete: 11..13,
-                insert: "Spam",
-                kind: Struct,
-            },
-            CompletionItem {
-                label: "foo",
-                source_range: 11..13,
-                delete: 11..13,
-                insert: "foo",
-                kind: Module,
-            },
-        ]
-        "###
+        check(
+            r#"
+//- /lib.rs
+mod foo;
+struct Spam;
+//- /foo.rs
+use crate::Sp<|>
+"#,
+            expect![[r#"
+                st Spam
+                md foo
+            "#]],
         );
     }
 
     #[test]
     fn completes_nested_use_tree() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                "
-                //- /lib.rs
-                mod foo;
-                struct Spam;
-                //- /foo.rs
-                use crate::{Sp<|>};
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "Spam",
-                source_range: 12..14,
-                delete: 12..14,
-                insert: "Spam",
-                kind: Struct,
-            },
-            CompletionItem {
-                label: "foo",
-                source_range: 12..14,
-                delete: 12..14,
-                insert: "foo",
-                kind: Module,
-            },
-        ]
-        "###
+        check(
+            r#"
+//- /lib.rs
+mod foo;
+struct Spam;
+//- /foo.rs
+use crate::{Sp<|>};
+"#,
+            expect![[r#"
+                st Spam
+                md foo
+            "#]],
         );
     }
 
     #[test]
     fn completes_deeply_nested_use_tree() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                "
-                //- /lib.rs
-                mod foo;
-                pub mod bar {
-                    pub mod baz {
-                        pub struct Spam;
-                    }
-                }
-                //- /foo.rs
-                use crate::{bar::{baz::Sp<|>}};
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "Spam",
-                source_range: 23..25,
-                delete: 23..25,
-                insert: "Spam",
-                kind: Struct,
-            },
-        ]
-        "###
-        );
-    }
-
-    #[test]
-    fn completes_enum_variant() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                "
-                //- /lib.rs
-                /// An enum
-                enum E {
-                    /// Foo Variant
-                    Foo,
-                    /// Bar Variant with i32
-                    Bar(i32)
-                }
-                fn foo() { let _ = E::<|> }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "Bar(…)",
-                source_range: 116..116,
-                delete: 116..116,
-                insert: "Bar($0)",
-                kind: EnumVariant,
-                lookup: "Bar",
-                detail: "(i32)",
-                documentation: Documentation(
-                    "Bar Variant with i32",
-                ),
-                trigger_call_info: true,
-            },
-            CompletionItem {
-                label: "Foo",
-                source_range: 116..116,
-                delete: 116..116,
-                insert: "Foo",
-                kind: EnumVariant,
-                detail: "()",
-                documentation: Documentation(
-                    "Foo Variant",
-                ),
-            },
-        ]
-        "###
-        );
-    }
-
-    #[test]
-    fn completes_enum_variant_with_details() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                "
-                //- /lib.rs
-                struct S { field: u32 }
-                /// An enum
-                enum E {
-                    /// Foo Variant (empty)
-                    Foo,
-                    /// Bar Variant with i32 and u32
-                    Bar(i32, u32),
-                    ///
-                    S(S),
-                }
-                fn foo() { let _ = E::<|> }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "Bar(…)",
-                source_range: 180..180,
-                delete: 180..180,
-                insert: "Bar($0)",
-                kind: EnumVariant,
-                lookup: "Bar",
-                detail: "(i32, u32)",
-                documentation: Documentation(
-                    "Bar Variant with i32 and u32",
-                ),
-                trigger_call_info: true,
-            },
-            CompletionItem {
-                label: "Foo",
-                source_range: 180..180,
-                delete: 180..180,
-                insert: "Foo",
-                kind: EnumVariant,
-                detail: "()",
-                documentation: Documentation(
-                    "Foo Variant (empty)",
-                ),
-            },
-            CompletionItem {
-                label: "S(…)",
-                source_range: 180..180,
-                delete: 180..180,
-                insert: "S($0)",
-                kind: EnumVariant,
-                lookup: "S",
-                detail: "(S)",
-                documentation: Documentation(
-                    "",
-                ),
-                trigger_call_info: true,
-            },
-        ]
-        "###
-        );
+        check(
+            r#"
+//- /lib.rs
+mod foo;
+pub mod bar {
+    pub mod baz {
+        pub struct Spam;
     }
-
-    #[test]
-    fn completes_struct_associated_method() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                "
-                //- /lib.rs
-                /// A Struct
-                struct S;
-
-                impl S {
-                    /// An associated method
-                    fn m() { }
-                }
-
-                fn foo() { let _ = S::<|> }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "m()",
-                source_range: 102..102,
-                delete: 102..102,
-                insert: "m()$0",
-                kind: Function,
-                lookup: "m",
-                detail: "fn m()",
-                documentation: Documentation(
-                    "An associated method",
-                ),
-            },
-        ]
-        "###
+}
+//- /foo.rs
+use crate::{bar::{baz::Sp<|>}};
+"#,
+            expect![[r#"
+                st Spam
+            "#]],
         );
     }
 
     #[test]
-    fn completes_struct_associated_method_with_self() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                "
-                //- /lib.rs
-                /// A Struct
-                struct S;
-
-                impl S {
-                    /// An associated method
-                    fn m(&self) { }
-                }
-
-                fn foo() { let _ = S::<|> }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "m()",
-                source_range: 107..107,
-                delete: 107..107,
-                insert: "m()$0",
-                kind: Method,
-                lookup: "m",
-                detail: "fn m(&self)",
-                documentation: Documentation(
-                    "An associated method",
-                ),
-            },
-        ]
-        "###
+    fn completes_enum_variant() {
+        check(
+            r#"
+enum E { Foo, Bar(i32) }
+fn foo() { let _ = E::<|> }
+"#,
+            expect![[r#"
+                ev Bar(…) (i32)
+                ev Foo    ()
+            "#]],
         );
     }
 
     #[test]
-    fn completes_struct_associated_const() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                "
-                //- /lib.rs
-                /// A Struct
-                struct S;
-
-                impl S {
-                    /// An associated const
-                    const C: i32 = 42;
-                }
+    fn completes_struct_associated_items() {
+        check(
+            r#"
+//- /lib.rs
+struct S;
+
+impl S {
+    fn a() {}
+    fn b(&self) {}
+    const C: i32 = 42;
+    type T = i32;
+}
 
-                fn foo() { let _ = S::<|> }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "C",
-                source_range: 109..109,
-                delete: 109..109,
-                insert: "C",
-                kind: Const,
-                detail: "const C: i32 = 42;",
-                documentation: Documentation(
-                    "An associated const",
-                ),
-            },
-        ]
-        "###
+fn foo() { let _ = S::<|> }
+"#,
+            expect![[r#"
+                ct C   const C: i32 = 42;
+                ta T   type T = i32;
+                fn a() fn a()
+                me b() fn b(&self)
+            "#]],
         );
     }
 
     #[test]
-    fn completes_struct_associated_type() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                "
-                //- /lib.rs
-                /// A Struct
-                struct S;
-
-                impl S {
-                    /// An associated type
-                    type T = i32;
-                }
+    fn associated_item_visibility() {
+        check(
+            r#"
+struct S;
 
-                fn foo() { let _ = S::<|> }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "T",
-                source_range: 103..103,
-                delete: 103..103,
-                insert: "T",
-                kind: TypeAlias,
-                detail: "type T = i32;",
-                documentation: Documentation(
-                    "An associated type",
-                ),
-            },
-        ]
-        "###
-        );
+mod m {
+    impl super::S {
+        pub(super) fn public_method() { }
+        fn private_method() { }
+        pub(super) type PublicType = u32;
+        type PrivateType = u32;
+        pub(super) const PUBLIC_CONST: u32 = 1;
+        const PRIVATE_CONST: u32 = 1;
     }
+}
 
-    #[test]
-    fn associated_item_visibility() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                "
-                //- /lib.rs
-                struct S;
-
-                mod m {
-                    impl super::S {
-                        pub(super) fn public_method() { }
-                        fn private_method() { }
-                        pub(super) type PublicType = u32;
-                        type PrivateType = u32;
-                        pub(super) const PUBLIC_CONST: u32 = 1;
-                        const PRIVATE_CONST: u32 = 1;
-                    }
-                }
-
-                fn foo() { let _ = S::<|> }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "PUBLIC_CONST",
-                source_range: 304..304,
-                delete: 304..304,
-                insert: "PUBLIC_CONST",
-                kind: Const,
-                detail: "pub(super) const PUBLIC_CONST: u32 = 1;",
-            },
-            CompletionItem {
-                label: "PublicType",
-                source_range: 304..304,
-                delete: 304..304,
-                insert: "PublicType",
-                kind: TypeAlias,
-                detail: "pub(super) type PublicType = u32;",
-            },
-            CompletionItem {
-                label: "public_method()",
-                source_range: 304..304,
-                delete: 304..304,
-                insert: "public_method()$0",
-                kind: Function,
-                lookup: "public_method",
-                detail: "pub(super) fn public_method()",
-            },
-        ]
-        "###
+fn foo() { let _ = S::<|> }
+"#,
+            expect![[r#"
+                ct PUBLIC_CONST    pub(super) const PUBLIC_CONST: u32 = 1;
+                ta PublicType      pub(super) type PublicType = u32;
+                fn public_method() pub(super) fn public_method()
+            "#]],
         );
     }
 
     #[test]
     fn completes_enum_associated_method() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                "
-                //- /lib.rs
-                /// An enum
-                enum S {};
-
-                impl S {
-                    /// An associated method
-                    fn m() { }
-                }
-
-                fn foo() { let _ = S::<|> }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "m()",
-                source_range: 102..102,
-                delete: 102..102,
-                insert: "m()$0",
-                kind: Function,
-                lookup: "m",
-                detail: "fn m()",
-                documentation: Documentation(
-                    "An associated method",
-                ),
-            },
-        ]
-        "###
+        check(
+            r#"
+enum E {};
+impl E { fn m() { } }
+
+fn foo() { let _ = E::<|> }
+        "#,
+            expect![[r#"
+                fn m() fn m()
+            "#]],
         );
     }
 
     #[test]
     fn completes_union_associated_method() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                "
-                //- /lib.rs
-                /// A union
-                union U {};
-
-                impl U {
-                    /// An associated method
-                    fn m() { }
-                }
-
-                fn foo() { let _ = U::<|> }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "m()",
-                source_range: 103..103,
-                delete: 103..103,
-                insert: "m()$0",
-                kind: Function,
-                lookup: "m",
-                detail: "fn m()",
-                documentation: Documentation(
-                    "An associated method",
-                ),
-            },
-        ]
-        "###
+        check(
+            r#"
+union U {};
+impl U { fn m() { } }
+
+fn foo() { let _ = U::<|> }
+"#,
+            expect![[r#"
+                fn m() fn m()
+            "#]],
         );
     }
 
     #[test]
     fn completes_use_paths_across_crates() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                "
-                //- /main.rs
-                use foo::<|>;
-
-                //- /foo/lib.rs
-                pub mod bar {
-                    pub struct S;
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "bar",
-                source_range: 9..9,
-                delete: 9..9,
-                insert: "bar",
-                kind: Module,
-            },
-        ]
-        "###
+        check(
+            r#"
+//- /main.rs
+use foo::<|>;
+
+//- /foo/lib.rs
+pub mod bar { pub struct S; }
+"#,
+            expect![[r#"
+                md bar
+            "#]],
         );
     }
 
     #[test]
     fn completes_trait_associated_method_1() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                "
-                //- /lib.rs
-                trait Trait {
-                  /// A trait method
-                  fn m();
-                }
+        check(
+            r#"
+trait Trait { fn m(); }
 
-                fn foo() { let _ = Trait::<|> }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "m()",
-                source_range: 74..74,
-                delete: 74..74,
-                insert: "m()$0",
-                kind: Function,
-                lookup: "m",
-                detail: "fn m()",
-                documentation: Documentation(
-                    "A trait method",
-                ),
-            },
-        ]
-        "###
+fn foo() { let _ = Trait::<|> }
+"#,
+            expect![[r#"
+                fn m() fn m()
+            "#]],
         );
     }
 
     #[test]
     fn completes_trait_associated_method_2() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                "
-                //- /lib.rs
-                trait Trait {
-                  /// A trait method
-                  fn m();
-                }
+        check(
+            r#"
+trait Trait { fn m(); }
+
+struct S;
+impl Trait for S {}
 
-                struct S;
-                impl Trait for S {}
-
-                fn foo() { let _ = S::<|> }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "m()",
-                source_range: 101..101,
-                delete: 101..101,
-                insert: "m()$0",
-                kind: Function,
-                lookup: "m",
-                detail: "fn m()",
-                documentation: Documentation(
-                    "A trait method",
-                ),
-            },
-        ]
-        "###
+fn foo() { let _ = S::<|> }
+"#,
+            expect![[r#"
+                fn m() fn m()
+            "#]],
         );
     }
 
     #[test]
     fn completes_trait_associated_method_3() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                "
-                //- /lib.rs
-                trait Trait {
-                  /// A trait method
-                  fn m();
-                }
+        check(
+            r#"
+trait Trait { fn m(); }
 
-                struct S;
-                impl Trait for S {}
-
-                fn foo() { let _ = <S as Trait>::<|> }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "m()",
-                source_range: 112..112,
-                delete: 112..112,
-                insert: "m()$0",
-                kind: Function,
-                lookup: "m",
-                detail: "fn m()",
-                documentation: Documentation(
-                    "A trait method",
-                ),
-            },
-        ]
-        "###
+struct S;
+impl Trait for S {}
+
+fn foo() { let _ = <S as Trait>::<|> }
+"#,
+            expect![[r#"
+                fn m() fn m()
+            "#]],
         );
     }
 
     #[test]
     fn completes_ty_param_assoc_ty() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                "
-                //- /lib.rs
-                trait Super {
-                    type Ty;
-                    const CONST: u8;
-                    fn func() {}
-                    fn method(&self) {}
-                }
+        check(
+            r#"
+trait Super {
+    type Ty;
+    const CONST: u8;
+    fn func() {}
+    fn method(&self) {}
+}
 
-                trait Sub: Super {
-                    type SubTy;
-                    const C2: ();
-                    fn subfunc() {}
-                    fn submethod(&self) {}
-                }
+trait Sub: Super {
+    type SubTy;
+    const C2: ();
+    fn subfunc() {}
+    fn submethod(&self) {}
+}
 
-                fn foo<T: Sub>() {
-                    T::<|>
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "C2",
-                source_range: 221..221,
-                delete: 221..221,
-                insert: "C2",
-                kind: Const,
-                detail: "const C2: ();",
-            },
-            CompletionItem {
-                label: "CONST",
-                source_range: 221..221,
-                delete: 221..221,
-                insert: "CONST",
-                kind: Const,
-                detail: "const CONST: u8;",
-            },
-            CompletionItem {
-                label: "SubTy",
-                source_range: 221..221,
-                delete: 221..221,
-                insert: "SubTy",
-                kind: TypeAlias,
-                detail: "type SubTy;",
-            },
-            CompletionItem {
-                label: "Ty",
-                source_range: 221..221,
-                delete: 221..221,
-                insert: "Ty",
-                kind: TypeAlias,
-                detail: "type Ty;",
-            },
-            CompletionItem {
-                label: "func()",
-                source_range: 221..221,
-                delete: 221..221,
-                insert: "func()$0",
-                kind: Function,
-                lookup: "func",
-                detail: "fn func()",
-            },
-            CompletionItem {
-                label: "method()",
-                source_range: 221..221,
-                delete: 221..221,
-                insert: "method()$0",
-                kind: Method,
-                lookup: "method",
-                detail: "fn method(&self)",
-            },
-            CompletionItem {
-                label: "subfunc()",
-                source_range: 221..221,
-                delete: 221..221,
-                insert: "subfunc()$0",
-                kind: Function,
-                lookup: "subfunc",
-                detail: "fn subfunc()",
-            },
-            CompletionItem {
-                label: "submethod()",
-                source_range: 221..221,
-                delete: 221..221,
-                insert: "submethod()$0",
-                kind: Method,
-                lookup: "submethod",
-                detail: "fn submethod(&self)",
-            },
-        ]
-        "###
+fn foo<T: Sub>() { T::<|> }
+"#,
+            expect![[r#"
+                ct C2          const C2: ();
+                ct CONST       const CONST: u8;
+                ta SubTy       type SubTy;
+                ta Ty          type Ty;
+                fn func()      fn func()
+                me method()    fn method(&self)
+                fn subfunc()   fn subfunc()
+                me submethod() fn submethod(&self)
+            "#]],
         );
     }
 
     #[test]
     fn completes_self_param_assoc_ty() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                "
-                //- /lib.rs
-                trait Super {
-                    type Ty;
-                    const CONST: u8 = 0;
-                    fn func() {}
-                    fn method(&self) {}
-                }
+        check(
+            r#"
+trait Super {
+    type Ty;
+    const CONST: u8 = 0;
+    fn func() {}
+    fn method(&self) {}
+}
 
-                trait Sub: Super {
-                    type SubTy;
-                    const C2: () = ();
-                    fn subfunc() {}
-                    fn submethod(&self) {}
-                }
+trait Sub: Super {
+    type SubTy;
+    const C2: () = ();
+    fn subfunc() {}
+    fn submethod(&self) {}
+}
 
-                struct Wrap<T>(T);
-                impl<T> Super for Wrap<T> {}
-                impl<T> Sub for Wrap<T> {
-                    fn subfunc() {
-                        // Should be able to assume `Self: Sub + Super`
-                        Self::<|>
-                    }
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "C2",
-                source_range: 367..367,
-                delete: 367..367,
-                insert: "C2",
-                kind: Const,
-                detail: "const C2: () = ();",
-            },
-            CompletionItem {
-                label: "CONST",
-                source_range: 367..367,
-                delete: 367..367,
-                insert: "CONST",
-                kind: Const,
-                detail: "const CONST: u8 = 0;",
-            },
-            CompletionItem {
-                label: "SubTy",
-                source_range: 367..367,
-                delete: 367..367,
-                insert: "SubTy",
-                kind: TypeAlias,
-                detail: "type SubTy;",
-            },
-            CompletionItem {
-                label: "Ty",
-                source_range: 367..367,
-                delete: 367..367,
-                insert: "Ty",
-                kind: TypeAlias,
-                detail: "type Ty;",
-            },
-            CompletionItem {
-                label: "func()",
-                source_range: 367..367,
-                delete: 367..367,
-                insert: "func()$0",
-                kind: Function,
-                lookup: "func",
-                detail: "fn func()",
-            },
-            CompletionItem {
-                label: "method()",
-                source_range: 367..367,
-                delete: 367..367,
-                insert: "method()$0",
-                kind: Method,
-                lookup: "method",
-                detail: "fn method(&self)",
-            },
-            CompletionItem {
-                label: "subfunc()",
-                source_range: 367..367,
-                delete: 367..367,
-                insert: "subfunc()$0",
-                kind: Function,
-                lookup: "subfunc",
-                detail: "fn subfunc()",
-            },
-            CompletionItem {
-                label: "submethod()",
-                source_range: 367..367,
-                delete: 367..367,
-                insert: "submethod()$0",
-                kind: Method,
-                lookup: "submethod",
-                detail: "fn submethod(&self)",
-            },
-        ]
-        "###
+struct Wrap<T>(T);
+impl<T> Super for Wrap<T> {}
+impl<T> Sub for Wrap<T> {
+    fn subfunc() {
+        // Should be able to assume `Self: Sub + Super`
+        Self::<|>
+    }
+}
+"#,
+            expect![[r#"
+                ct C2          const C2: () = ();
+                ct CONST       const CONST: u8 = 0;
+                ta SubTy       type SubTy;
+                ta Ty          type Ty;
+                fn func()      fn func()
+                me method()    fn method(&self)
+                fn subfunc()   fn subfunc()
+                me submethod() fn submethod(&self)
+            "#]],
         );
     }
 
     #[test]
     fn completes_type_alias() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                "
-                struct S;
-                impl S { fn foo() {} }
-                type T = S;
-                impl T { fn bar() {} }
-
-                fn main() {
-                    T::<|>;
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "bar()",
-                source_range: 88..88,
-                delete: 88..88,
-                insert: "bar()$0",
-                kind: Function,
-                lookup: "bar",
-                detail: "fn bar()",
-            },
-            CompletionItem {
-                label: "foo()",
-                source_range: 88..88,
-                delete: 88..88,
-                insert: "foo()$0",
-                kind: Function,
-                lookup: "foo",
-                detail: "fn foo()",
-            },
-        ]
-        "###
+        check(
+            r#"
+struct S;
+impl S { fn foo() {} }
+type T = S;
+impl T { fn bar() {} }
+
+fn main() { T::<|>; }
+"#,
+            expect![[r#"
+                fn bar() fn bar()
+                fn foo() fn foo()
+            "#]],
         );
     }
 
     #[test]
     fn completes_qualified_macros() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                "
-                #[macro_export]
-                macro_rules! foo {
-                    () => {}
-                }
+        check(
+            r#"
+#[macro_export]
+macro_rules! foo { () => {} }
+
+fn main() { let _ = crate::<|> }
+        "#,
+            expect![[r##"
+                ma foo!(…) #[macro_export]
+                macro_rules! foo
+                fn main()  fn main()
+            "##]],
+        );
+    }
 
-                fn main() {
-                    let _ = crate::<|>
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "foo!(…)",
-                source_range: 82..82,
-                delete: 82..82,
-                insert: "foo!($0)",
-                kind: Macro,
-                detail: "#[macro_export]\nmacro_rules! foo",
-            },
-            CompletionItem {
-                label: "main()",
-                source_range: 82..82,
-                delete: 82..82,
-                insert: "main()$0",
-                kind: Function,
-                lookup: "main",
-                detail: "fn main()",
-            },
-        ]
-        "###
+    #[test]
+    fn test_super_super_completion() {
+        check(
+            r#"
+mod a {
+    const A: usize = 0;
+    mod b {
+        const B: usize = 0;
+        mod c { use super::super::<|> }
+    }
+}
+"#,
+            expect![[r#"
+                ct A
+                md b
+            "#]],
         );
     }
 
     #[test]
     fn completes_reexported_items_under_correct_name() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                r"
-                fn foo() {
-                    self::m::<|>
-                }
+        check(
+            r#"
+fn foo() { self::m::<|> }
 
-                mod m {
-                    pub use super::p::wrong_fn as right_fn;
-                    pub use super::p::WRONG_CONST as RIGHT_CONST;
-                    pub use super::p::WrongType as RightType;
-                }
-                mod p {
-                    fn wrong_fn() {}
-                    const WRONG_CONST: u32 = 1;
-                    struct WrongType {};
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "RIGHT_CONST",
-                source_range: 24..24,
-                delete: 24..24,
-                insert: "RIGHT_CONST",
-                kind: Const,
-            },
-            CompletionItem {
-                label: "RightType",
-                source_range: 24..24,
-                delete: 24..24,
-                insert: "RightType",
-                kind: Struct,
-            },
-            CompletionItem {
-                label: "right_fn()",
-                source_range: 24..24,
-                delete: 24..24,
-                insert: "right_fn()$0",
-                kind: Function,
-                lookup: "right_fn",
-                detail: "fn wrong_fn()",
-            },
-        ]
-        "###
+mod m {
+    pub use super::p::wrong_fn as right_fn;
+    pub use super::p::WRONG_CONST as RIGHT_CONST;
+    pub use super::p::WrongType as RightType;
+}
+mod p {
+    fn wrong_fn() {}
+    const WRONG_CONST: u32 = 1;
+    struct WrongType {};
+}
+"#,
+            expect![[r#"
+                ct RIGHT_CONST
+                st RightType
+                fn right_fn()  fn wrong_fn()
+            "#]],
+        );
+
+        check_edit(
+            "RightType",
+            r#"
+fn foo() { self::m::<|> }
+
+mod m {
+    pub use super::p::wrong_fn as right_fn;
+    pub use super::p::WRONG_CONST as RIGHT_CONST;
+    pub use super::p::WrongType as RightType;
+}
+mod p {
+    fn wrong_fn() {}
+    const WRONG_CONST: u32 = 1;
+    struct WrongType {};
+}
+"#,
+            r#"
+fn foo() { self::m::RightType }
+
+mod m {
+    pub use super::p::wrong_fn as right_fn;
+    pub use super::p::WRONG_CONST as RIGHT_CONST;
+    pub use super::p::WrongType as RightType;
+}
+mod p {
+    fn wrong_fn() {}
+    const WRONG_CONST: u32 = 1;
+    struct WrongType {};
+}
+"#,
         );
     }
 
     #[test]
     fn completes_in_simple_macro_call() {
-        let completions = do_reference_completion(
+        check(
             r#"
-                macro_rules! m { ($e:expr) => { $e } }
-                fn main() { m!(self::f<|>); }
-                fn foo() {}
-            "#,
+macro_rules! m { ($e:expr) => { $e } }
+fn main() { m!(self::f<|>); }
+fn foo() {}
+"#,
+            expect![[r#"
+                fn foo()  fn foo()
+                fn main() fn main()
+            "#]],
         );
-        assert_debug_snapshot!(completions, @r###"
-        [
-            CompletionItem {
-                label: "foo()",
-                source_range: 60..61,
-                delete: 60..61,
-                insert: "foo()$0",
-                kind: Function,
-                lookup: "foo",
-                detail: "fn foo()",
-            },
-            CompletionItem {
-                label: "main()",
-                source_range: 60..61,
-                delete: 60..61,
-                insert: "main()$0",
-                kind: Function,
-                lookup: "main",
-                detail: "fn main()",
-            },
-        ]
-        "###);
     }
 
     #[test]
     fn function_mod_share_name() {
-        assert_debug_snapshot!(
-        do_reference_completion(
-                r"
-                fn foo() {
-                    self::m::<|>
-                }
+        check(
+            r#"
+fn foo() { self::m::<|> }
 
-                mod m {
-                    pub mod z {}
-                    pub fn z() {}
-                }
-                ",
-        ),
-            @r###"
-        [
-            CompletionItem {
-                label: "z",
-                source_range: 24..24,
-                delete: 24..24,
-                insert: "z",
-                kind: Module,
-            },
-            CompletionItem {
-                label: "z()",
-                source_range: 24..24,
-                delete: 24..24,
-                insert: "z()$0",
-                kind: Function,
-                lookup: "z",
-                detail: "pub fn z()",
-            },
-        ]
-        "###
+mod m {
+    pub mod z {}
+    pub fn z() {}
+}
+"#,
+            expect![[r#"
+                md z
+                fn z() pub fn z()
+            "#]],
         );
     }
 
     #[test]
     fn completes_hashmap_new() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                r"
-                struct RandomState;
-                struct HashMap<K, V, S = RandomState> {}
-
-                impl<K, V> HashMap<K, V, RandomState> {
-                    pub fn new() -> HashMap<K, V, RandomState> { }
-                }
-                fn foo() {
-                    HashMap::<|>
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "new()",
-                source_range: 179..179,
-                delete: 179..179,
-                insert: "new()$0",
-                kind: Function,
-                lookup: "new",
-                detail: "pub fn new() -> HashMap<K, V, RandomState>",
-            },
-        ]
-        "###
+        check(
+            r#"
+struct RandomState;
+struct HashMap<K, V, S = RandomState> {}
+
+impl<K, V> HashMap<K, V, RandomState> {
+    pub fn new() -> HashMap<K, V, RandomState> { }
+}
+fn foo() {
+    HashMap::<|>
+}
+"#,
+            expect![[r#"
+                fn new() pub fn new() -> HashMap<K, V, RandomState>
+            "#]],
         );
     }
 
     #[test]
     fn dont_complete_attr() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                r"
-                mod foo { pub struct Foo; }
-                #[foo::<|>]
-                fn f() {}
-                "
-            ),
-            @r###"[]"###
-        )
+        check(
+            r#"
+mod foo { pub struct Foo; }
+#[foo::<|>]
+fn f() {}
+"#,
+            expect![[""]],
+        );
     }
 }
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/complete_snippet.rs b/crates/ra_ide/src/completion/complete_snippet.rs
index 52aaa70f0..28d8f7876 100644
--- a/crates/ra_ide/src/completion/complete_snippet.rs
+++ b/crates/ra_ide/src/completion/complete_snippet.rs
@@ -70,95 +70,47 @@ fn ${1:feature}() {
 
 #[cfg(test)]
 mod tests {
-    use crate::completion::{test_utils::do_completion, CompletionItem, CompletionKind};
-    use insta::assert_debug_snapshot;
+    use expect::{expect, Expect};
 
-    fn do_snippet_completion(code: &str) -> Vec<CompletionItem> {
-        do_completion(code, CompletionKind::Snippet)
+    use crate::completion::{test_utils::completion_list, CompletionKind};
+
+    fn check(ra_fixture: &str, expect: Expect) {
+        let actual = completion_list(ra_fixture, CompletionKind::Snippet);
+        expect.assert_eq(&actual)
     }
 
     #[test]
     fn completes_snippets_in_expressions() {
-        assert_debug_snapshot!(
-                    do_snippet_completion(r"fn foo(x: i32) { <|> }"),
-        @r###"
-        [
-            CompletionItem {
-                label: "pd",
-                source_range: 17..17,
-                delete: 17..17,
-                insert: "eprintln!(\"$0 = {:?}\", $0);",
-                kind: Snippet,
-            },
-            CompletionItem {
-                label: "ppd",
-                source_range: 17..17,
-                delete: 17..17,
-                insert: "eprintln!(\"$0 = {:#?}\", $0);",
-                kind: Snippet,
-            },
-        ]
-        "###
-                );
+        check(
+            r#"fn foo(x: i32) { <|> }"#,
+            expect![[r#"
+                sn pd
+                sn ppd
+            "#]],
+        );
     }
 
     #[test]
     fn should_not_complete_snippets_in_path() {
-        assert_debug_snapshot!(
-                    do_snippet_completion(r"fn foo(x: i32) { ::foo<|> }"),
-        @"[]"
-                );
-        assert_debug_snapshot!(
-                    do_snippet_completion(r"fn foo(x: i32) { ::<|> }"),
-        @"[]"
-                );
+        check(r#"fn foo(x: i32) { ::foo<|> }"#, expect![[""]]);
+        check(r#"fn foo(x: i32) { ::<|> }"#, expect![[""]]);
     }
 
     #[test]
     fn completes_snippets_in_items() {
-        assert_debug_snapshot!(
-            do_snippet_completion(
-                r"
-                #[cfg(test)]
-                mod tests {
-                    <|>
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "Test function",
-                source_range: 29..29,
-                delete: 29..29,
-                insert: "#[test]\nfn ${1:feature}() {\n    $0\n}",
-                kind: Snippet,
-                lookup: "tfn",
-            },
-            CompletionItem {
-                label: "Test module",
-                source_range: 29..29,
-                delete: 29..29,
-                insert: "#[cfg(test)]\nmod tests {\n    use super::*;\n\n    #[test]\n    fn ${1:test_name}() {\n        $0\n    }\n}",
-                kind: Snippet,
-                lookup: "tmod",
-            },
-            CompletionItem {
-                label: "macro_rules",
-                source_range: 29..29,
-                delete: 29..29,
-                insert: "macro_rules! $1 {\n\t($2) => {\n\t\t$0\n\t};\n}",
-                kind: Snippet,
-            },
-            CompletionItem {
-                label: "pub(crate)",
-                source_range: 29..29,
-                delete: 29..29,
-                insert: "pub(crate) $0",
-                kind: Snippet,
-            },
-        ]
-        "###
-        );
+        check(
+            r#"
+#[cfg(test)]
+mod tests {
+    <|>
+}
+"#,
+            expect![[r#"
+                sn Test function
+                sn Test module
+                sn macro_rules
+                sn pub(crate)
+            "#]],
+        )
     }
 }
diff --git a/crates/ra_ide/src/completion/complete_trait_impl.rs b/crates/ra_ide/src/completion/complete_trait_impl.rs
index 23e42928d..d9a0ef167 100644
--- a/crates/ra_ide/src/completion/complete_trait_impl.rs
+++ b/crates/ra_ide/src/completion/complete_trait_impl.rs
@@ -2,8 +2,8 @@
 //!
 //! This module adds the completion items related to implementing associated
 //! items within a `impl Trait for Struct` block. The current context node
-//! must be within either a `FN_DEF`, `TYPE_ALIAS_DEF`, or `CONST_DEF` node
-//! and an direct child of an `IMPL_DEF`.
+//! must be within either a `FN`, `TYPE_ALIAS`, or `CONST` node
+//! and an direct child of an `IMPL`.
 //!
 //! # Examples
 //!
@@ -34,7 +34,7 @@
 use hir::{self, Docs, HasSource};
 use ra_assists::utils::get_missing_assoc_items;
 use ra_syntax::{
-    ast::{self, edit, ImplDef},
+    ast::{self, edit, Impl},
     AstNode, SyntaxKind, SyntaxNode, TextRange, T,
 };
 use ra_text_edit::TextEdit;
@@ -43,7 +43,7 @@ use crate::{
     completion::{
         CompletionContext, CompletionItem, CompletionItemKind, CompletionKind, Completions,
     },
-    display::FunctionSignature,
+    display::function_declaration,
 };
 
 pub(crate) fn complete_trait_impl(acc: &mut Completions, ctx: &CompletionContext) {
@@ -63,7 +63,7 @@ pub(crate) fn complete_trait_impl(acc: &mut Completions, ctx: &CompletionContext
                     }
                 }),
 
-            SyntaxKind::FN_DEF => {
+            SyntaxKind::FN => {
                 for missing_fn in get_missing_assoc_items(&ctx.sema, &impl_def)
                     .into_iter()
                     .filter_map(|item| match item {
@@ -75,7 +75,7 @@ pub(crate) fn complete_trait_impl(acc: &mut Completions, ctx: &CompletionContext
                 }
             }
 
-            SyntaxKind::TYPE_ALIAS_DEF => {
+            SyntaxKind::TYPE_ALIAS => {
                 for missing_fn in get_missing_assoc_items(&ctx.sema, &impl_def)
                     .into_iter()
                     .filter_map(|item| match item {
@@ -87,7 +87,7 @@ pub(crate) fn complete_trait_impl(acc: &mut Completions, ctx: &CompletionContext
                 }
             }
 
-            SyntaxKind::CONST_DEF => {
+            SyntaxKind::CONST => {
                 for missing_fn in get_missing_assoc_items(&ctx.sema, &impl_def)
                     .into_iter()
                     .filter_map(|item| match item {
@@ -104,18 +104,17 @@ pub(crate) fn complete_trait_impl(acc: &mut Completions, ctx: &CompletionContext
     }
 }
 
-fn completion_match(ctx: &CompletionContext) -> Option<(SyntaxNode, ImplDef)> {
+fn completion_match(ctx: &CompletionContext) -> Option<(SyntaxNode, Impl)> {
     let (trigger, impl_def_offset) = ctx.token.ancestors().find_map(|p| match p.kind() {
-        SyntaxKind::FN_DEF
-        | SyntaxKind::TYPE_ALIAS_DEF
-        | SyntaxKind::CONST_DEF
-        | SyntaxKind::BLOCK_EXPR => Some((p, 2)),
+        SyntaxKind::FN | SyntaxKind::TYPE_ALIAS | SyntaxKind::CONST | SyntaxKind::BLOCK_EXPR => {
+            Some((p, 2))
+        }
         SyntaxKind::NAME_REF => Some((p, 5)),
         _ => None,
     })?;
     let impl_def = (0..impl_def_offset - 1)
         .try_fold(trigger.parent()?, |t, _| t.parent())
-        .and_then(ast::ImplDef::cast)?;
+        .and_then(ast::Impl::cast)?;
     Some((trigger, impl_def))
 }
 
@@ -125,8 +124,6 @@ fn add_function_impl(
     ctx: &CompletionContext,
     func: hir::Function,
 ) {
-    let signature = FunctionSignature::from_hir(ctx.db, func);
-
     let fn_name = func.name(ctx.db).to_string();
 
     let label = if !func.params(ctx.db).is_empty() {
@@ -146,13 +143,14 @@ fn add_function_impl(
     };
     let range = TextRange::new(fn_def_node.text_range().start(), ctx.source_range().end());
 
+    let function_decl = function_declaration(&func.source(ctx.db).value);
     match ctx.config.snippet_cap {
         Some(cap) => {
-            let snippet = format!("{} {{\n    $0\n}}", signature);
+            let snippet = format!("{} {{\n    $0\n}}", function_decl);
             builder.snippet_edit(cap, TextEdit::replace(range, snippet))
         }
         None => {
-            let header = format!("{} {{", signature);
+            let header = format!("{} {{", function_decl);
             builder.text_edit(TextEdit::replace(range, header))
         }
     }
@@ -202,7 +200,7 @@ fn add_const_impl(
     }
 }
 
-fn make_const_compl_syntax(const_: &ast::ConstDef) -> String {
+fn make_const_compl_syntax(const_: &ast::Const) -> String {
     let const_ = edit::remove_attrs_and_docs(const_);
 
     let const_start = const_.syntax().text_range().start();
@@ -227,330 +225,264 @@ fn make_const_compl_syntax(const_: &ast::ConstDef) -> String {
 
 #[cfg(test)]
 mod tests {
-    use insta::assert_debug_snapshot;
+    use expect::{expect, Expect};
 
-    use crate::completion::{test_utils::do_completion, CompletionItem, CompletionKind};
+    use crate::completion::{
+        test_utils::{check_edit, completion_list},
+        CompletionKind,
+    };
 
-    fn complete(code: &str) -> Vec<CompletionItem> {
-        do_completion(code, CompletionKind::Magic)
+    fn check(ra_fixture: &str, expect: Expect) {
+        let actual = completion_list(ra_fixture, CompletionKind::Magic);
+        expect.assert_eq(&actual)
     }
 
     #[test]
     fn name_ref_function_type_const() {
-        let completions = complete(
-            r"
-            trait Test {
-                type TestType;
-                const TEST_CONST: u16;
-                fn test();
-            }
-
-            struct T1;
+        check(
+            r#"
+trait Test {
+    type TestType;
+    const TEST_CONST: u16;
+    fn test();
+}
+struct T;
 
-            impl Test for T1 {
-                t<|>
-            }
-            ",
+impl Test for T {
+    t<|>
+}
+"#,
+            expect![["
+ct const TEST_CONST: u16 = \n\
+fn fn test()
+ta type TestType = \n\
+            "]],
         );
-        assert_debug_snapshot!(completions, @r###"
-        [
-            CompletionItem {
-                label: "const TEST_CONST: u16 = ",
-                source_range: 112..113,
-                delete: 112..113,
-                insert: "const TEST_CONST: u16 = ",
-                kind: Const,
-                lookup: "TEST_CONST",
-            },
-            CompletionItem {
-                label: "fn test()",
-                source_range: 112..113,
-                delete: 112..113,
-                insert: "fn test() {\n    $0\n}",
-                kind: Function,
-                lookup: "test",
-            },
-            CompletionItem {
-                label: "type TestType = ",
-                source_range: 112..113,
-                delete: 112..113,
-                insert: "type TestType = ",
-                kind: TypeAlias,
-                lookup: "TestType",
-            },
-        ]
-        "###);
     }
 
     #[test]
     fn no_nested_fn_completions() {
-        let completions = complete(
+        check(
             r"
-            trait Test {
-                fn test();
-                fn test2();
-            }
-
-            struct T1;
+trait Test {
+    fn test();
+    fn test2();
+}
+struct T;
 
-            impl Test for T1 {
-                fn test() {
-                    t<|>
-                }
-            }
-            ",
+impl Test for T {
+    fn test() {
+        t<|>
+    }
+}
+",
+            expect![[""]],
         );
-        assert_debug_snapshot!(completions, @r###"[]"###);
     }
 
     #[test]
     fn name_ref_single_function() {
-        let completions = complete(
-            r"
-            trait Test {
-                fn test();
-            }
+        check_edit(
+            "test",
+            r#"
+trait Test {
+    fn test();
+}
+struct T;
 
-            struct T1;
+impl Test for T {
+    t<|>
+}
+"#,
+            r#"
+trait Test {
+    fn test();
+}
+struct T;
 
-            impl Test for T1 {
-                t<|>
-            }
-            ",
+impl Test for T {
+    fn test() {
+    $0
+}
+}
+"#,
         );
-        assert_debug_snapshot!(completions, @r###"
-        [
-            CompletionItem {
-                label: "fn test()",
-                source_range: 66..67,
-                delete: 66..67,
-                insert: "fn test() {\n    $0\n}",
-                kind: Function,
-                lookup: "test",
-            },
-        ]
-        "###);
     }
 
     #[test]
     fn single_function() {
-        let completions = complete(
-            r"
-            trait Test {
-                fn foo();
-            }
+        check_edit(
+            "test",
+            r#"
+trait Test {
+    fn test();
+}
+struct T;
 
-            struct T1;
+impl Test for T {
+    fn t<|>
+}
+"#,
+            r#"
+trait Test {
+    fn test();
+}
+struct T;
 
-            impl Test for T1 {
-                fn f<|>
-            }
-            ",
+impl Test for T {
+    fn test() {
+    $0
+}
+}
+"#,
         );
-        assert_debug_snapshot!(completions, @r###"
-        [
-            CompletionItem {
-                label: "fn foo()",
-                source_range: 68..69,
-                delete: 65..69,
-                insert: "fn foo() {\n    $0\n}",
-                kind: Function,
-                lookup: "foo",
-            },
-        ]
-        "###);
     }
 
     #[test]
     fn hide_implemented_fn() {
-        let completions = complete(
-            r"
-            trait Test {
-                fn foo();
-                fn foo_bar();
-            }
-
-            struct T1;
-
-            impl Test for T1 {
-                fn foo() {}
-
-                fn f<|>
-            }
-            ",
-        );
-        assert_debug_snapshot!(completions, @r###"
-        [
-            CompletionItem {
-                label: "fn foo_bar()",
-                source_range: 103..104,
-                delete: 100..104,
-                insert: "fn foo_bar() {\n    $0\n}",
-                kind: Function,
-                lookup: "foo_bar",
-            },
-        ]
-        "###);
-    }
-
-    #[test]
-    fn completes_only_on_top_level() {
-        let completions = complete(
-            r"
-            trait Test {
-                fn foo();
-
-                fn foo_bar();
-            }
-
-            struct T1;
+        check(
+            r#"
+trait Test {
+    fn foo();
+    fn foo_bar();
+}
+struct T;
 
-            impl Test for T1 {
-                fn foo() {
-                    <|>
-                }
-            }
-            ",
+impl Test for T {
+    fn foo() {}
+    fn f<|>
+}
+"#,
+            expect![[r#"
+                fn fn foo_bar()
+            "#]],
         );
-        assert_debug_snapshot!(completions, @r###"[]"###);
     }
 
     #[test]
     fn generic_fn() {
-        let completions = complete(
-            r"
-            trait Test {
-                fn foo<T>();
-            }
+        check_edit(
+            "foo",
+            r#"
+trait Test {
+    fn foo<T>();
+}
+struct T;
 
-            struct T1;
+impl Test for T {
+    fn f<|>
+}
+"#,
+            r#"
+trait Test {
+    fn foo<T>();
+}
+struct T;
 
-            impl Test for T1 {
-                fn f<|>
-            }
-            ",
+impl Test for T {
+    fn foo<T>() {
+    $0
+}
+}
+"#,
         );
-        assert_debug_snapshot!(completions, @r###"
-        [
-            CompletionItem {
-                label: "fn foo()",
-                source_range: 71..72,
-                delete: 68..72,
-                insert: "fn foo<T>() {\n    $0\n}",
-                kind: Function,
-                lookup: "foo",
-            },
-        ]
-        "###);
-    }
-
-    #[test]
-    fn generic_constrait_fn() {
-        let completions = complete(
-            r"
-            trait Test {
-                fn foo<T>() where T: Into<String>;
-            }
+        check_edit(
+            "foo",
+            r#"
+trait Test {
+    fn foo<T>() where T: Into<String>;
+}
+struct T;
 
-            struct T1;
+impl Test for T {
+    fn f<|>
+}
+"#,
+            r#"
+trait Test {
+    fn foo<T>() where T: Into<String>;
+}
+struct T;
 
-            impl Test for T1 {
-                fn f<|>
-            }
-            ",
+impl Test for T {
+    fn foo<T>()
+where T: Into<String> {
+    $0
+}
+}
+"#,
         );
-        assert_debug_snapshot!(completions, @r###"
-        [
-            CompletionItem {
-                label: "fn foo()",
-                source_range: 93..94,
-                delete: 90..94,
-                insert: "fn foo<T>()\nwhere T: Into<String> {\n    $0\n}",
-                kind: Function,
-                lookup: "foo",
-            },
-        ]
-        "###);
     }
 
     #[test]
     fn associated_type() {
-        let completions = complete(
-            r"
-            trait Test {
-                type SomeType;
-            }
+        check_edit(
+            "SomeType",
+            r#"
+trait Test {
+    type SomeType;
+}
 
-            impl Test for () {
-                type S<|>
-            }
-            ",
+impl Test for () {
+    type S<|>
+}
+"#,
+            "
+trait Test {
+    type SomeType;
+}
+
+impl Test for () {
+    type SomeType = \n\
+}
+",
         );
-        assert_debug_snapshot!(completions, @r###"
-        [
-            CompletionItem {
-                label: "type SomeType = ",
-                source_range: 63..64,
-                delete: 58..64,
-                insert: "type SomeType = ",
-                kind: TypeAlias,
-                lookup: "SomeType",
-            },
-        ]
-        "###);
     }
 
     #[test]
     fn associated_const() {
-        let completions = complete(
-            r"
-            trait Test {
-                const SOME_CONST: u16;
-            }
+        check_edit(
+            "SOME_CONST",
+            r#"
+trait Test {
+    const SOME_CONST: u16;
+}
 
-            impl Test for () {
-                const S<|>
-            }
-            ",
+impl Test for () {
+    const S<|>
+}
+"#,
+            "
+trait Test {
+    const SOME_CONST: u16;
+}
+
+impl Test for () {
+    const SOME_CONST: u16 = \n\
+}
+",
         );
-        assert_debug_snapshot!(completions, @r###"
-        [
-            CompletionItem {
-                label: "const SOME_CONST: u16 = ",
-                source_range: 72..73,
-                delete: 66..73,
-                insert: "const SOME_CONST: u16 = ",
-                kind: Const,
-                lookup: "SOME_CONST",
-            },
-        ]
-        "###);
-    }
 
-    #[test]
-    fn associated_const_with_default() {
-        let completions = complete(
-            r"
-            trait Test {
-                const SOME_CONST: u16 = 42;
-            }
+        check_edit(
+            "SOME_CONST",
+            r#"
+trait Test {
+    const SOME_CONST: u16 = 92;
+}
 
-            impl Test for () {
-                const S<|>
-            }
-            ",
+impl Test for () {
+    const S<|>
+}
+"#,
+            "
+trait Test {
+    const SOME_CONST: u16 = 92;
+}
+
+impl Test for () {
+    const SOME_CONST: u16 = \n\
+}
+",
         );
-        assert_debug_snapshot!(completions, @r###"
-        [
-            CompletionItem {
-                label: "const SOME_CONST: u16 = ",
-                source_range: 77..78,
-                delete: 71..78,
-                insert: "const SOME_CONST: u16 = ",
-                kind: Const,
-                lookup: "SOME_CONST",
-            },
-        ]
-        "###);
     }
 }
diff --git a/crates/ra_ide/src/completion/complete_unqualified_path.rs b/crates/ra_ide/src/completion/complete_unqualified_path.rs
index a0a04bb58..bd9551f35 100644
--- a/crates/ra_ide/src/completion/complete_unqualified_path.rs
+++ b/crates/ra_ide/src/completion/complete_unqualified_path.rs
@@ -1,11 +1,10 @@
 //! Completion of names from the current scope, e.g. locals and imported items.
 
-use hir::ScopeDef;
+use hir::{Adt, ModuleDef, ScopeDef, Type};
+use ra_syntax::AstNode;
 use test_utils::mark;
 
 use crate::completion::{CompletionContext, Completions};
-use hir::{Adt, ModuleDef, Type};
-use ra_syntax::AstNode;
 
 pub(super) fn complete_unqualified_path(acc: &mut Completions, ctx: &CompletionContext) {
     if !(ctx.is_trivial_path || ctx.is_pat_binding_or_const) {
@@ -26,7 +25,7 @@ pub(super) fn complete_unqualified_path(acc: &mut Completions, ctx: &CompletionC
         return;
     }
 
-    ctx.scope().process_all_names(&mut |name, res| {
+    ctx.scope.process_all_names(&mut |name, res| {
         if ctx.use_item_syntax.is_some() {
             if let (ScopeDef::Unknown, Some(name_ref)) = (&res, &ctx.name_ref_syntax) {
                 if name_ref.syntax().text() == name.to_string().as_str() {
@@ -43,7 +42,7 @@ fn complete_enum_variants(acc: &mut Completions, ctx: &CompletionContext, ty: &T
     if let Some(Adt::Enum(enum_data)) = ty.as_adt() {
         let variants = enum_data.variants(ctx.db);
 
-        let module = if let Some(module) = ctx.scope().module() {
+        let module = if let Some(module) = ctx.scope.module() {
             // Compute path from the completion site if available.
             module
         } else {
@@ -65,1361 +64,595 @@ fn complete_enum_variants(acc: &mut Completions, ctx: &CompletionContext, ty: &T
 
 #[cfg(test)]
 mod tests {
-    use insta::assert_debug_snapshot;
+    use expect::{expect, Expect};
     use test_utils::mark;
 
-    use crate::completion::{test_utils::do_completion, CompletionItem, CompletionKind};
+    use crate::completion::{
+        test_utils::{check_edit, completion_list},
+        CompletionKind,
+    };
 
-    fn do_reference_completion(ra_fixture: &str) -> Vec<CompletionItem> {
-        do_completion(ra_fixture, CompletionKind::Reference)
+    fn check(ra_fixture: &str, expect: Expect) {
+        let actual = completion_list(ra_fixture, CompletionKind::Reference);
+        expect.assert_eq(&actual)
     }
 
     #[test]
     fn self_fulfilling_completion() {
         mark::check!(self_fulfilling_completion);
-        assert_debug_snapshot!(
-            do_reference_completion(
-                r#"
-                use foo<|>
-                use std::collections;
-                "#,
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "collections",
-                source_range: 4..7,
-                delete: 4..7,
-                insert: "collections",
-            },
-        ]
-        "###
+        check(
+            r#"
+use foo<|>
+use std::collections;
+"#,
+            expect![[r#"
+                ?? collections
+            "#]],
         );
     }
 
     #[test]
     fn bind_pat_and_path_ignore_at() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                r"
-                enum Enum {
-                    A,
-                    B,
-                }
-                fn quux(x: Option<Enum>) {
-                    match x {
-                        None => (),
-                        Some(en<|> @ Enum::A) => (),
-                    }
-                }
-                "
-            ),
-            @"[]"
+        check(
+            r#"
+enum Enum { A, B }
+fn quux(x: Option<Enum>) {
+    match x {
+        None => (),
+        Some(en<|> @ Enum::A) => (),
+    }
+}
+"#,
+            expect![[""]],
         );
     }
 
     #[test]
     fn bind_pat_and_path_ignore_ref() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                r"
-                enum Enum {
-                    A,
-                    B,
-                }
-                fn quux(x: Option<Enum>) {
-                    match x {
-                        None => (),
-                        Some(ref en<|>) => (),
-                    }
-                }
-                "
-            ),
-            @r###"[]"###
+        check(
+            r#"
+enum Enum { A, B }
+fn quux(x: Option<Enum>) {
+    match x {
+        None => (),
+        Some(ref en<|>) => (),
+    }
+}
+"#,
+            expect![[""]],
         );
     }
 
     #[test]
     fn bind_pat_and_path() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                r"
-                enum Enum {
-                    A,
-                    B,
-                }
-                fn quux(x: Option<Enum>) {
-                    match x {
-                        None => (),
-                        Some(En<|>) => (),
-                    }
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "Enum",
-                source_range: 102..104,
-                delete: 102..104,
-                insert: "Enum",
-                kind: Enum,
-            },
-        ]
-        "###
+        check(
+            r#"
+enum Enum { A, B }
+fn quux(x: Option<Enum>) {
+    match x {
+        None => (),
+        Some(En<|>) => (),
+    }
+}
+"#,
+            expect![[r#"
+                en Enum
+            "#]],
         );
     }
 
     #[test]
     fn completes_bindings_from_let() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                r"
-                fn quux(x: i32) {
-                    let y = 92;
-                    1 + <|>;
-                    let z = ();
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "quux(…)",
-                source_range: 42..42,
-                delete: 42..42,
-                insert: "quux(${1:x})$0",
-                kind: Function,
-                lookup: "quux",
-                detail: "fn quux(x: i32)",
-                trigger_call_info: true,
-            },
-            CompletionItem {
-                label: "x",
-                source_range: 42..42,
-                delete: 42..42,
-                insert: "x",
-                kind: Binding,
-                detail: "i32",
-            },
-            CompletionItem {
-                label: "y",
-                source_range: 42..42,
-                delete: 42..42,
-                insert: "y",
-                kind: Binding,
-                detail: "i32",
-            },
-        ]
-        "###
+        check(
+            r#"
+fn quux(x: i32) {
+    let y = 92;
+    1 + <|>;
+    let z = ();
+}
+"#,
+            expect![[r#"
+                fn quux(…) fn quux(x: i32)
+                bn x       i32
+                bn y       i32
+            "#]],
         );
     }
 
     #[test]
     fn completes_bindings_from_if_let() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                r"
-                fn quux() {
-                    if let Some(x) = foo() {
-                        let y = 92;
-                    };
-                    if let Some(a) = bar() {
-                        let b = 62;
-                        1 + <|>
-                    }
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "a",
-                source_range: 129..129,
-                delete: 129..129,
-                insert: "a",
-                kind: Binding,
-            },
-            CompletionItem {
-                label: "b",
-                source_range: 129..129,
-                delete: 129..129,
-                insert: "b",
-                kind: Binding,
-                detail: "i32",
-            },
-            CompletionItem {
-                label: "quux()",
-                source_range: 129..129,
-                delete: 129..129,
-                insert: "quux()$0",
-                kind: Function,
-                lookup: "quux",
-                detail: "fn quux()",
-            },
-        ]
-        "###
+        check(
+            r#"
+fn quux() {
+    if let Some(x) = foo() {
+        let y = 92;
+    };
+    if let Some(a) = bar() {
+        let b = 62;
+        1 + <|>
+    }
+}
+"#,
+            expect![[r#"
+                bn a
+                bn b      i32
+                fn quux() fn quux()
+            "#]],
         );
     }
 
     #[test]
     fn completes_bindings_from_for() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                r"
-                fn quux() {
-                    for x in &[1, 2, 3] {
-                        <|>
-                    }
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "quux()",
-                source_range: 46..46,
-                delete: 46..46,
-                insert: "quux()$0",
-                kind: Function,
-                lookup: "quux",
-                detail: "fn quux()",
-            },
-            CompletionItem {
-                label: "x",
-                source_range: 46..46,
-                delete: 46..46,
-                insert: "x",
-                kind: Binding,
-            },
-        ]
-        "###
+        check(
+            r#"
+fn quux() {
+    for x in &[1, 2, 3] { <|> }
+}
+"#,
+            expect![[r#"
+                fn quux() fn quux()
+                bn x
+            "#]],
         );
     }
 
     #[test]
-    fn completes_bindings_from_for_with_in_prefix() {
-        mark::check!(completes_bindings_from_for_with_in_prefix);
-        assert_debug_snapshot!(
-            do_reference_completion(
-                r"
-                fn test() {
-                    for index in &[1, 2, 3] {
-                        let t = in<|>
-                    }
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "index",
-                source_range: 58..58,
-                delete: 58..58,
-                insert: "index",
-                kind: Binding,
-            },
-            CompletionItem {
-                label: "test()",
-                source_range: 58..58,
-                delete: 58..58,
-                insert: "test()$0",
-                kind: Function,
-                lookup: "test",
-                detail: "fn test()",
-            },
-        ]
-        "###
-        );
+    fn completes_if_prefix_is_keyword() {
+        mark::check!(completes_if_prefix_is_keyword);
+        check_edit(
+            "wherewolf",
+            r#"
+fn main() {
+    let wherewolf = 92;
+    drop(where<|>)
+}
+"#,
+            r#"
+fn main() {
+    let wherewolf = 92;
+    drop(wherewolf)
+}
+"#,
+        )
     }
 
     #[test]
     fn completes_generic_params() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                r"
-                fn quux<T>() {
-                    <|>
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "T",
-                source_range: 19..19,
-                delete: 19..19,
-                insert: "T",
-                kind: TypeParam,
-            },
-            CompletionItem {
-                label: "quux()",
-                source_range: 19..19,
-                delete: 19..19,
-                insert: "quux()$0",
-                kind: Function,
-                lookup: "quux",
-                detail: "fn quux<T>()",
-            },
-        ]
-        "###
+        check(
+            r#"fn quux<T>() { <|> }"#,
+            expect![[r#"
+                tp T
+                fn quux() fn quux<T>()
+            "#]],
         );
     }
 
     #[test]
     fn completes_generic_params_in_struct() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                r"
-                struct X<T> {
-                    x: <|>
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "Self",
-                source_range: 21..21,
-                delete: 21..21,
-                insert: "Self",
-                kind: TypeParam,
-            },
-            CompletionItem {
-                label: "T",
-                source_range: 21..21,
-                delete: 21..21,
-                insert: "T",
-                kind: TypeParam,
-            },
-            CompletionItem {
-                label: "X<…>",
-                source_range: 21..21,
-                delete: 21..21,
-                insert: "X<$0>",
-                kind: Struct,
-                lookup: "X",
-            },
-        ]
-        "###
+        check(
+            r#"struct S<T> { x: <|>}"#,
+            expect![[r#"
+                st S<…>
+                tp Self
+                tp T
+            "#]],
         );
     }
 
     #[test]
     fn completes_self_in_enum() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                r"
-                enum X {
-                    Y(<|>)
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "Self",
-                source_range: 15..15,
-                delete: 15..15,
-                insert: "Self",
-                kind: TypeParam,
-            },
-            CompletionItem {
-                label: "X",
-                source_range: 15..15,
-                delete: 15..15,
-                insert: "X",
-                kind: Enum,
-            },
-        ]
-        "###
+        check(
+            r#"enum X { Y(<|>) }"#,
+            expect![[r#"
+                tp Self
+                en X
+            "#]],
         );
     }
 
     #[test]
     fn completes_module_items() {
-        assert_debug_snapshot!(
-        do_reference_completion(
-            r"
-                struct Foo;
-                enum Baz {}
-                fn quux() {
-                    <|>
-                }
-                "
-        ),
-        @r###"
-        [
-            CompletionItem {
-                label: "Baz",
-                source_range: 40..40,
-                delete: 40..40,
-                insert: "Baz",
-                kind: Enum,
-            },
-            CompletionItem {
-                label: "Foo",
-                source_range: 40..40,
-                delete: 40..40,
-                insert: "Foo",
-                kind: Struct,
-            },
-            CompletionItem {
-                label: "quux()",
-                source_range: 40..40,
-                delete: 40..40,
-                insert: "quux()$0",
-                kind: Function,
-                lookup: "quux",
-                detail: "fn quux()",
-            },
-        ]
-        "###
-            );
+        check(
+            r#"
+struct S;
+enum E {}
+fn quux() { <|> }
+"#,
+            expect![[r#"
+                en E
+                st S
+                fn quux() fn quux()
+            "#]],
+        );
     }
 
     #[test]
     fn completes_extern_prelude() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                r"
-                //- /lib.rs
-                use <|>;
-
-                //- /other_crate/lib.rs
-                // nothing here
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "other_crate",
-                source_range: 4..4,
-                delete: 4..4,
-                insert: "other_crate",
-                kind: Module,
-            },
-        ]
-        "###
+        check(
+            r#"
+//- /lib.rs
+use <|>;
+
+//- /other_crate/lib.rs
+// nothing here
+"#,
+            expect![[r#"
+                md other_crate
+            "#]],
         );
     }
 
     #[test]
     fn completes_module_items_in_nested_modules() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                r"
-                struct Foo;
-                mod m {
-                    struct Bar;
-                    fn quux() { <|> }
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "Bar",
-                source_range: 52..52,
-                delete: 52..52,
-                insert: "Bar",
-                kind: Struct,
-            },
-            CompletionItem {
-                label: "quux()",
-                source_range: 52..52,
-                delete: 52..52,
-                insert: "quux()$0",
-                kind: Function,
-                lookup: "quux",
-                detail: "fn quux()",
-            },
-        ]
-        "###
+        check(
+            r#"
+struct Foo;
+mod m {
+    struct Bar;
+    fn quux() { <|> }
+}
+"#,
+            expect![[r#"
+                st Bar
+                fn quux() fn quux()
+            "#]],
         );
     }
 
     #[test]
     fn completes_return_type() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                r"
-                struct Foo;
-                fn x() -> <|>
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "Foo",
-                source_range: 22..22,
-                delete: 22..22,
-                insert: "Foo",
-                kind: Struct,
-            },
-            CompletionItem {
-                label: "x()",
-                source_range: 22..22,
-                delete: 22..22,
-                insert: "x()$0",
-                kind: Function,
-                lookup: "x",
-                detail: "fn x()",
-            },
-        ]
-        "###
+        check(
+            r#"
+struct Foo;
+fn x() -> <|>
+"#,
+            expect![[r#"
+                st Foo
+                fn x() fn x()
+            "#]],
         );
     }
 
     #[test]
     fn dont_show_both_completions_for_shadowing() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                r"
-                fn foo() {
-                    let bar = 92;
-                    {
-                        let bar = 62;
-                        <|>
-                    }
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "bar",
-                source_range: 65..65,
-                delete: 65..65,
-                insert: "bar",
-                kind: Binding,
-                detail: "i32",
-            },
-            CompletionItem {
-                label: "foo()",
-                source_range: 65..65,
-                delete: 65..65,
-                insert: "foo()$0",
-                kind: Function,
-                lookup: "foo",
-                detail: "fn foo()",
-            },
-        ]
-        "###
+        check(
+            r#"
+fn foo() {
+    let bar = 92;
+    {
+        let bar = 62;
+        drop(<|>)
+    }
+}
+"#,
+            // FIXME: should be only one bar here
+            expect![[r#"
+                bn bar   i32
+                bn bar   i32
+                fn foo() fn foo()
+            "#]],
         );
     }
 
     #[test]
     fn completes_self_in_methods() {
-        assert_debug_snapshot!(
-            do_reference_completion(r"impl S { fn foo(&self) { <|> } }"),
-            @r###"
-        [
-            CompletionItem {
-                label: "Self",
-                source_range: 25..25,
-                delete: 25..25,
-                insert: "Self",
-                kind: TypeParam,
-            },
-            CompletionItem {
-                label: "self",
-                source_range: 25..25,
-                delete: 25..25,
-                insert: "self",
-                kind: Binding,
-                detail: "&{unknown}",
-            },
-        ]
-        "###
+        check(
+            r#"impl S { fn foo(&self) { <|> } }"#,
+            expect![[r#"
+                tp Self
+                bn self &{unknown}
+            "#]],
         );
     }
 
     #[test]
     fn completes_prelude() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                "
-                //- /main.rs
-                fn foo() { let x: <|> }
-
-                //- /std/lib.rs
-                #[prelude_import]
-                use prelude::*;
-
-                mod prelude {
-                    struct Option;
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "Option",
-                source_range: 18..18,
-                delete: 18..18,
-                insert: "Option",
-                kind: Struct,
-            },
-            CompletionItem {
-                label: "foo()",
-                source_range: 18..18,
-                delete: 18..18,
-                insert: "foo()$0",
-                kind: Function,
-                lookup: "foo",
-                detail: "fn foo()",
-            },
-            CompletionItem {
-                label: "std",
-                source_range: 18..18,
-                delete: 18..18,
-                insert: "std",
-                kind: Module,
-            },
-        ]
-        "###
+        check(
+            r#"
+//- /main.rs
+fn foo() { let x: <|> }
+
+//- /std/lib.rs
+#[prelude_import]
+use prelude::*;
+
+mod prelude { struct Option; }
+"#,
+            expect![[r#"
+                st Option
+                fn foo()  fn foo()
+                md std
+            "#]],
         );
     }
 
     #[test]
     fn completes_std_prelude_if_core_is_defined() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                "
-                //- /main.rs
-                fn foo() { let x: <|> }
-
-                //- /core/lib.rs
-                #[prelude_import]
-                use prelude::*;
-
-                mod prelude {
-                    struct Option;
-                }
-
-                //- /std/lib.rs
-                #[prelude_import]
-                use prelude::*;
-
-                mod prelude {
-                    struct String;
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "String",
-                source_range: 18..18,
-                delete: 18..18,
-                insert: "String",
-                kind: Struct,
-            },
-            CompletionItem {
-                label: "core",
-                source_range: 18..18,
-                delete: 18..18,
-                insert: "core",
-                kind: Module,
-            },
-            CompletionItem {
-                label: "foo()",
-                source_range: 18..18,
-                delete: 18..18,
-                insert: "foo()$0",
-                kind: Function,
-                lookup: "foo",
-                detail: "fn foo()",
-            },
-            CompletionItem {
-                label: "std",
-                source_range: 18..18,
-                delete: 18..18,
-                insert: "std",
-                kind: Module,
-            },
-        ]
-        "###
+        check(
+            r#"
+//- /main.rs
+fn foo() { let x: <|> }
+
+//- /core/lib.rs
+#[prelude_import]
+use prelude::*;
+
+mod prelude { struct Option; }
+
+//- /std/lib.rs
+#[prelude_import]
+use prelude::*;
+
+mod prelude { struct String; }
+"#,
+            expect![[r#"
+                st String
+                md core
+                fn foo()  fn foo()
+                md std
+            "#]],
         );
     }
 
     #[test]
     fn completes_macros_as_value() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                "
-                //- /main.rs
-                macro_rules! foo {
-                    () => {}
-                }
+        check(
+            r#"
+macro_rules! foo { () => {} }
 
-                #[macro_use]
-                mod m1 {
-                    macro_rules! bar {
-                        () => {}
-                    }
-                }
+#[macro_use]
+mod m1 {
+    macro_rules! bar { () => {} }
+}
 
-                mod m2 {
-                    macro_rules! nope {
-                        () => {}
-                    }
+mod m2 {
+    macro_rules! nope { () => {} }
 
-                    #[macro_export]
-                    macro_rules! baz {
-                        () => {}
-                    }
-                }
+    #[macro_export]
+    macro_rules! baz { () => {} }
+}
 
-                fn main() {
-                    let v = <|>
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "bar!(…)",
-                source_range: 256..256,
-                delete: 256..256,
-                insert: "bar!($0)",
-                kind: Macro,
-                detail: "macro_rules! bar",
-            },
-            CompletionItem {
-                label: "baz!(…)",
-                source_range: 256..256,
-                delete: 256..256,
-                insert: "baz!($0)",
-                kind: Macro,
-                detail: "#[macro_export]\nmacro_rules! baz",
-            },
-            CompletionItem {
-                label: "foo!(…)",
-                source_range: 256..256,
-                delete: 256..256,
-                insert: "foo!($0)",
-                kind: Macro,
-                detail: "macro_rules! foo",
-            },
-            CompletionItem {
-                label: "m1",
-                source_range: 256..256,
-                delete: 256..256,
-                insert: "m1",
-                kind: Module,
-            },
-            CompletionItem {
-                label: "m2",
-                source_range: 256..256,
-                delete: 256..256,
-                insert: "m2",
-                kind: Module,
-            },
-            CompletionItem {
-                label: "main()",
-                source_range: 256..256,
-                delete: 256..256,
-                insert: "main()$0",
-                kind: Function,
-                lookup: "main",
-                detail: "fn main()",
-            },
-        ]
-        "###
+fn main() { let v = <|> }
+"#,
+            expect![[r##"
+                ma bar!(…) macro_rules! bar
+                ma baz!(…) #[macro_export]
+                macro_rules! baz
+                ma foo!(…) macro_rules! foo
+                md m1
+                md m2
+                fn main()  fn main()
+            "##]],
         );
     }
 
     #[test]
     fn completes_both_macro_and_value() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                "
-                //- /main.rs
-                macro_rules! foo {
-                    () => {}
-                }
-
-                fn foo() {
-                    <|>
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "foo!(…)",
-                source_range: 50..50,
-                delete: 50..50,
-                insert: "foo!($0)",
-                kind: Macro,
-                detail: "macro_rules! foo",
-            },
-            CompletionItem {
-                label: "foo()",
-                source_range: 50..50,
-                delete: 50..50,
-                insert: "foo()$0",
-                kind: Function,
-                lookup: "foo",
-                detail: "fn foo()",
-            },
-        ]
-        "###
+        check(
+            r#"
+macro_rules! foo { () => {} }
+fn foo() { <|> }
+"#,
+            expect![[r#"
+                ma foo!(…) macro_rules! foo
+                fn foo()   fn foo()
+            "#]],
         );
     }
 
     #[test]
     fn completes_macros_as_type() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                "
-                //- /main.rs
-                macro_rules! foo {
-                    () => {}
-                }
-
-                fn main() {
-                    let x: <|>
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "foo!(…)",
-                source_range: 58..58,
-                delete: 58..58,
-                insert: "foo!($0)",
-                kind: Macro,
-                detail: "macro_rules! foo",
-            },
-            CompletionItem {
-                label: "main()",
-                source_range: 58..58,
-                delete: 58..58,
-                insert: "main()$0",
-                kind: Function,
-                lookup: "main",
-                detail: "fn main()",
-            },
-        ]
-        "###
+        check(
+            r#"
+macro_rules! foo { () => {} }
+fn main() { let x: <|> }
+"#,
+            expect![[r#"
+                ma foo!(…) macro_rules! foo
+                fn main()  fn main()
+            "#]],
         );
     }
 
     #[test]
     fn completes_macros_as_stmt() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                "
-                //- /main.rs
-                macro_rules! foo {
-                    () => {}
-                }
-
-                fn main() {
-                    <|>
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "foo!(…)",
-                source_range: 51..51,
-                delete: 51..51,
-                insert: "foo!($0)",
-                kind: Macro,
-                detail: "macro_rules! foo",
-            },
-            CompletionItem {
-                label: "main()",
-                source_range: 51..51,
-                delete: 51..51,
-                insert: "main()$0",
-                kind: Function,
-                lookup: "main",
-                detail: "fn main()",
-            },
-        ]
-        "###
+        check(
+            r#"
+macro_rules! foo { () => {} }
+fn main() { <|> }
+"#,
+            expect![[r#"
+                ma foo!(…) macro_rules! foo
+                fn main()  fn main()
+            "#]],
         );
     }
 
     #[test]
     fn completes_local_item() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                "
-                //- /main.rs
-                fn main() {
-                    return f<|>;
-                    fn frobnicate() {}
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "frobnicate()",
-                source_range: 23..24,
-                delete: 23..24,
-                insert: "frobnicate()$0",
-                kind: Function,
-                lookup: "frobnicate",
-                detail: "fn frobnicate()",
-            },
-            CompletionItem {
-                label: "main()",
-                source_range: 23..24,
-                delete: 23..24,
-                insert: "main()$0",
-                kind: Function,
-                lookup: "main",
-                detail: "fn main()",
-            },
-        ]
-        "###
-        )
+        check(
+            r#"
+fn main() {
+    return f<|>;
+    fn frobnicate() {}
+}
+"#,
+            expect![[r#"
+                fn frobnicate() fn frobnicate()
+                fn main()       fn main()
+            "#]],
+        );
     }
 
     #[test]
     fn completes_in_simple_macro_1() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                r"
-                macro_rules! m { ($e:expr) => { $e } }
-                fn quux(x: i32) {
-                    let y = 92;
-                    m!(<|>);
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "m!(…)",
-                source_range: 80..80,
-                delete: 80..80,
-                insert: "m!($0)",
-                kind: Macro,
-                detail: "macro_rules! m",
-            },
-            CompletionItem {
-                label: "quux(…)",
-                source_range: 80..80,
-                delete: 80..80,
-                insert: "quux(${1:x})$0",
-                kind: Function,
-                lookup: "quux",
-                detail: "fn quux(x: i32)",
-                trigger_call_info: true,
-            },
-            CompletionItem {
-                label: "x",
-                source_range: 80..80,
-                delete: 80..80,
-                insert: "x",
-                kind: Binding,
-                detail: "i32",
-            },
-            CompletionItem {
-                label: "y",
-                source_range: 80..80,
-                delete: 80..80,
-                insert: "y",
-                kind: Binding,
-                detail: "i32",
-            },
-        ]
-        "###
+        check(
+            r#"
+macro_rules! m { ($e:expr) => { $e } }
+fn quux(x: i32) {
+    let y = 92;
+    m!(<|>);
+}
+"#,
+            expect![[r#"
+                ma m!(…)   macro_rules! m
+                fn quux(…) fn quux(x: i32)
+                bn x       i32
+                bn y       i32
+            "#]],
         );
     }
 
     #[test]
     fn completes_in_simple_macro_2() {
-        assert_debug_snapshot!(
-            do_reference_completion(
-                r"
-                macro_rules! m { ($e:expr) => { $e } }
-                fn quux(x: i32) {
-                    let y = 92;
-                    m!(x<|>);
-                }
-                "
-            ),
-            @r###"
-        [
-            CompletionItem {
-                label: "m!(…)",
-                source_range: 80..81,
-                delete: 80..81,
-                insert: "m!($0)",
-                kind: Macro,
-                detail: "macro_rules! m",
-            },
-            CompletionItem {
-                label: "quux(…)",
-                source_range: 80..81,
-                delete: 80..81,
-                insert: "quux(${1:x})$0",
-                kind: Function,
-                lookup: "quux",
-                detail: "fn quux(x: i32)",
-                trigger_call_info: true,
-            },
-            CompletionItem {
-                label: "x",
-                source_range: 80..81,
-                delete: 80..81,
-                insert: "x",
-                kind: Binding,
-                detail: "i32",
-            },
-            CompletionItem {
-                label: "y",
-                source_range: 80..81,
-                delete: 80..81,
-                insert: "y",
-                kind: Binding,
-                detail: "i32",
-            },
-        ]
-        "###
+        check(
+            r"
+macro_rules! m { ($e:expr) => { $e } }
+fn quux(x: i32) {
+    let y = 92;
+    m!(x<|>);
+}
+",
+            expect![[r#"
+                ma m!(…)   macro_rules! m
+                fn quux(…) fn quux(x: i32)
+                bn x       i32
+                bn y       i32
+            "#]],
         );
     }