61 files changed, 0 insertions, 23929 deletions
diff --git a/crates/ra_ide/Cargo.toml b/crates/ra_ide/Cargo.toml
deleted file mode 100644
index f4181c4eb..000000000
--- a/crates/ra_ide/Cargo.toml
+++ /dev/null
@@ -1,40 +0,0 @@
-[package]
-edition = "2018"
-name = "ra_ide"
-version = "0.1.0"
-authors = ["rust-analyzer developers"]
-license = "MIT OR Apache-2.0"
-[lib]
-doctest = false
-[features]
-wasm = []
-[dependencies]
-either = "1.5.3"
-indexmap = "1.3.2"
-itertools = "0.9.0"
-log = "0.4.8"
-rustc-hash = "1.1.0"
-oorandom = "11.1.2"
-stdx = { path = "../stdx" }
-ra_syntax = { path = "../ra_syntax" }
-ra_text_edit = { path = "../ra_text_edit" }
-ra_db = { path = "../ra_db" }
-ra_ide_db = { path = "../ra_ide_db" }
-ra_cfg = { path = "../ra_cfg" }
-ra_fmt = { path = "../ra_fmt" }
-ra_prof = { path = "../ra_prof" }
-test_utils = { path = "../test_utils" }
-ra_assists = { path = "../ra_assists" }
-ra_ssr = { path = "../ra_ssr" }
-# ra_ide should depend only on the top-level `hir` package. if you need
-# something from some `hir_xxx` subpackage, reexport the API via `hir`.
-hir = { path = "../ra_hir", package = "ra_hir" }
-[dev-dependencies]
-expect = { path = "../expect" }
diff --git a/crates/ra_ide/src/call_hierarchy.rs b/crates/ra_ide/src/call_hierarchy.rs
deleted file mode 100644
index 1fcaf4a32..000000000
--- a/crates/ra_ide/src/call_hierarchy.rs
+++ /dev/null
@@ -1,393 +0,0 @@
-//! Entry point for call-hierarchy
-use indexmap::IndexMap;
-use hir::Semantics;
-use ra_ide_db::RootDatabase;
-use ra_syntax::{ast, match_ast, AstNode, TextRange};
-use crate::{
-    call_info::FnCallNode, display::ToNav, goto_definition, references, FilePosition,
-    NavigationTarget, RangeInfo,
-};
-#[derive(Debug, Clone)]
-pub struct CallItem {
-    pub target: NavigationTarget,
-    pub ranges: Vec<TextRange>,
-}
-impl CallItem {
-    #[cfg(test)]
-    pub(crate) fn assert_match(&self, expected: &str) {
-        let actual = self.debug_render();
-        test_utils::assert_eq_text!(expected.trim(), actual.trim(),);
-    }
-    #[cfg(test)]
-    pub(crate) fn debug_render(&self) -> String {
-        format!("{} : {:?}", self.target.debug_render(), self.ranges)
-    }
-}
-pub(crate) fn call_hierarchy(
-    db: &RootDatabase,
-    position: FilePosition,
-) -> Option<RangeInfo<Vec<NavigationTarget>>> {
-    goto_definition::goto_definition(db, position)
-}
-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(&sema, position, None)?;
-    let mut calls = CallLocations::default();
-    for reference in refs.info.references() {
-        let file_id = reference.file_range.file_id;
-        let file = sema.parse(file_id);
-        let file = file.syntax();
-        let token = file.token_at_offset(reference.file_range.range.start()).next()?;
-        let token = sema.descend_into_macros(token);
-        let syntax = token.parent();
-        // This target is the containing function
-        if let Some(nav) = syntax.ancestors().find_map(|node| {
-            match_ast! {
-                match node {
-                    ast::Fn(it) => {
-                        let def = sema.to_def(&it)?;
-                        Some(def.to_nav(sema.db))
-                    },
-                    _ => None,
-                }
-            }
-        }) {
-            let relative_range = reference.file_range.range;
-            calls.add(&nav, relative_range);
-        }
-    }
-    Some(calls.into_items())
-}
-pub(crate) fn outgoing_calls(db: &RootDatabase, position: FilePosition) -> Option<Vec<CallItem>> {
-    let sema = Semantics::new(db);
-    let file_id = position.file_id;
-    let file = sema.parse(file_id);
-    let file = file.syntax();
-    let token = file.token_at_offset(position.offset).next()?;
-    let token = sema.descend_into_macros(token);
-    let syntax = token.parent();
-    let mut calls = CallLocations::default();
-    syntax
-        .descendants()
-        .filter_map(|node| FnCallNode::with_node_exact(&node))
-        .filter_map(|call_node| {
-            let name_ref = call_node.name_ref()?;
-            if let Some(func_target) = match &call_node {
-                FnCallNode::CallExpr(expr) => {
-                    //FIXME: Type::as_callable is broken
-                    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)
-                        }
-                        _ => None,
-                    }
-                }
-                FnCallNode::MethodCallExpr(expr) => {
-                    let function = sema.resolve_method_call(&expr)?;
-                    Some(function.to_nav(db))
-                }
-            } {
-                Some((func_target, name_ref.syntax().text_range()))
-            } else {
-                None
-            }
-        })
-        .for_each(|(nav, range)| calls.add(&nav, range));
-    Some(calls.into_items())
-}
-#[derive(Default)]
-struct CallLocations {
-    funcs: IndexMap<NavigationTarget, Vec<TextRange>>,
-}
-impl CallLocations {
-    fn add(&mut self, target: &NavigationTarget, range: TextRange) {
-        self.funcs.entry(target.clone()).or_default().push(range);
-    }
-    fn into_items(self) -> Vec<CallItem> {
-        self.funcs.into_iter().map(|(target, ranges)| CallItem { target, ranges }).collect()
-    }
-}
-#[cfg(test)]
-mod tests {
-    use ra_db::FilePosition;
-    use crate::mock_analysis::analysis_and_position;
-    fn check_hierarchy(
-        ra_fixture: &str,
-        expected: &str,
-        expected_incoming: &[&str],
-        expected_outgoing: &[&str],
-    ) {
-        let (analysis, pos) = analysis_and_position(ra_fixture);
-        let mut navs = analysis.call_hierarchy(pos).unwrap().unwrap().info;
-        assert_eq!(navs.len(), 1);
-        let nav = navs.pop().unwrap();
-        nav.assert_match(expected);
-        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());
-        for call in 0..incoming_calls.len() {
-            incoming_calls[call].assert_match(expected_incoming[call]);
-        }
-        let outgoing_calls = analysis.outgoing_calls(item_pos).unwrap().unwrap();
-        assert_eq!(outgoing_calls.len(), expected_outgoing.len());
-        for call in 0..outgoing_calls.len() {
-            outgoing_calls[call].assert_match(expected_outgoing[call]);
-        }
-    }
-    #[test]
-    fn test_call_hierarchy_on_ref() {
-        check_hierarchy(
-            r#"
-//- /lib.rs
-fn callee() {}
-fn caller() {
-    call<|>ee();
-}
-"#,
-            "callee FN FileId(1) 0..14 3..9",
-            &["caller FN FileId(1) 15..44 18..24 : [33..39]"],
-            &[],
-        );
-    }
-    #[test]
-    fn test_call_hierarchy_on_def() {
-        check_hierarchy(
-            r#"
-//- /lib.rs
-fn call<|>ee() {}
-fn caller() {
-    callee();
-}
-"#,
-            "callee FN FileId(1) 0..14 3..9",
-            &["caller FN FileId(1) 15..44 18..24 : [33..39]"],
-            &[],
-        );
-    }
-    #[test]
-    fn test_call_hierarchy_in_same_fn() {
-        check_hierarchy(
-            r#"
-//- /lib.rs
-fn callee() {}
-fn caller() {
-    call<|>ee();
-    callee();
-}
-"#,
-            "callee FN FileId(1) 0..14 3..9",
-            &["caller FN FileId(1) 15..58 18..24 : [33..39, 47..53]"],
-            &[],
-        );
-    }
-    #[test]
-    fn test_call_hierarchy_in_different_fn() {
-        check_hierarchy(
-            r#"
-//- /lib.rs
-fn callee() {}
-fn caller1() {
-    call<|>ee();
-}
-fn caller2() {
-    callee();
-}
-"#,
-            "callee FN FileId(1) 0..14 3..9",
-            &[
-                "caller1 FN FileId(1) 15..45 18..25 : [34..40]",
-                "caller2 FN FileId(1) 47..77 50..57 : [66..72]",
-            ],
-            &[],
-        );
-    }
-    #[test]
-    fn test_call_hierarchy_in_tests_mod() {
-        check_hierarchy(
-            r#"
-//- /lib.rs cfg:test
-fn callee() {}
-fn caller1() {
-    call<|>ee();
-}
-#[cfg(test)]
-mod tests {
-    use super::*;
-    #[test]
-    fn test_caller() {
-        callee();
-    }
-}
-"#,
-            "callee FN FileId(1) 0..14 3..9",
-            &[
-                "caller1 FN FileId(1) 15..45 18..25 : [34..40]",
-                "test_caller FN FileId(1) 95..149 110..121 : [134..140]",
-            ],
-            &[],
-        );
-    }
-    #[test]
-    fn test_call_hierarchy_in_different_files() {
-        check_hierarchy(
-            r#"
-//- /lib.rs
-mod foo;
-use foo::callee;
-fn caller() {
-    call<|>ee();
-}
-//- /foo/mod.rs
-pub fn callee() {}
-"#,
-            "callee FN FileId(2) 0..18 7..13",
-            &["caller FN FileId(1) 27..56 30..36 : [45..51]"],
-            &[],
-        );
-    }
-    #[test]
-    fn test_call_hierarchy_outgoing() {
-        check_hierarchy(
-            r#"
-//- /lib.rs
-fn callee() {}
-fn call<|>er() {
-    callee();
-    callee();
-}
-"#,
-            "caller FN FileId(1) 15..58 18..24",
-            &[],
-            &["callee FN FileId(1) 0..14 3..9 : [33..39, 47..53]"],
-        );
-    }
-    #[test]
-    fn test_call_hierarchy_outgoing_in_different_files() {
-        check_hierarchy(
-            r#"
-//- /lib.rs
-mod foo;
-use foo::callee;
-fn call<|>er() {
-    callee();
-}
-//- /foo/mod.rs
-pub fn callee() {}
-"#,
-            "caller FN FileId(1) 27..56 30..36",
-            &[],
-            &["callee FN FileId(2) 0..18 7..13 : [45..51]"],
-        );
-    }
-    #[test]
-    fn test_call_hierarchy_incoming_outgoing() {
-        check_hierarchy(
-            r#"
-//- /lib.rs
-fn caller1() {
-    call<|>er2();
-}
-fn caller2() {
-    caller3();
-}
-fn caller3() {
-}
-"#,
-            "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
deleted file mode 100644
index ff602202f..000000000
--- a/crates/ra_ide/src/call_info.rs
+++ /dev/null
@@ -1,742 +0,0 @@
-//! FIXME: write short doc here
-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, TextRange, TextSize,
-};
-use stdx::format_to;
-use test_utils::mark;
-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> {
-    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);
-    let (callable, active_parameter) = call_info_impl(&sema, token)?;
-    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 => (),
-    }
-    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_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 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))
-}
-#[derive(Debug)]
-pub(crate) struct ActiveParameter {
-    pub(crate) ty: Type,
-    pub(crate) name: String,
-}
-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)
-    }
-    pub(crate) fn at_token(sema: &Semantics<RootDatabase>, token: SyntaxToken) -> Option<Self> {
-        let (signature, active_parameter) = call_info_impl(&sema, token)?;
-        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 })
-    }
-}
-#[derive(Debug)]
-pub(crate) enum FnCallNode {
-    CallExpr(ast::CallExpr),
-    MethodCallExpr(ast::MethodCallExpr),
-}
-impl FnCallNode {
-    fn with_node(syntax: &SyntaxNode) -> Option<FnCallNode> {
-        syntax.ancestors().find_map(|node| {
-            match_ast! {
-                match node {
-                    ast::CallExpr(it) => Some(FnCallNode::CallExpr(it)),
-                    ast::MethodCallExpr(it) => {
-                        let arg_list = it.arg_list()?;
-                        if !arg_list.syntax().text_range().contains_range(syntax.text_range()) {
-                            return None;
-                        }
-                        Some(FnCallNode::MethodCallExpr(it))
-                    },
-                    _ => None,
-                }
-            }
-        })
-    }
-    pub(crate) fn with_node_exact(node: &SyntaxNode) -> Option<FnCallNode> {
-        match_ast! {
-            match node {
-                ast::CallExpr(it) => Some(FnCallNode::CallExpr(it)),
-                ast::MethodCallExpr(it) => Some(FnCallNode::MethodCallExpr(it)),
-                _ => None,
-            }
-        }
-    }
-    pub(crate) fn name_ref(&self) -> Option<ast::NameRef> {
-        match self {
-            FnCallNode::CallExpr(call_expr) => Some(match call_expr.expr()? {
-                ast::Expr::PathExpr(path_expr) => path_expr.path()?.segment()?.name_ref()?,
-                _ => return None,
-            }),
-            FnCallNode::MethodCallExpr(call_expr) => {
-                call_expr.syntax().children().filter_map(ast::NameRef::cast).next()
-            }
-        }
-    }
-    fn arg_list(&self) -> Option<ast::ArgList> {
-        match self {
-            FnCallNode::CallExpr(expr) => expr.arg_list(),
-            FnCallNode::MethodCallExpr(expr) => expr.arg_list(),
-        }
-    }
-}
-#[cfg(test)]
-mod tests {
-    use expect::{expect, Expect};
-    use test_utils::mark;
-    use crate::mock_analysis::analysis_and_position;
-    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() {
-        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>)
-            "#]],
-        );
-        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>)
-            "#]],
-        );
-    }
-    #[test]
-    fn test_fn_signature_two_args_empty() {
-        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)
-            "#]],
-        );
-    }
-    #[test]
-    fn test_fn_signature_two_args_first_generics() {
-        check(
-            r#"
-fn foo<T, U: Copy + Display>(x: T, y: U) -> u32
-    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})
-            "#]],
-        );
-    }
-    #[test]
-    fn test_fn_signature_no_params() {
-        check(
-            r#"
-fn foo<T>() -> T where T: Copy + Display {}
-fn bar() { foo(<|>); }
-"#,
-            expect![[r#"
-                fn foo() -> {unknown}
-                ()
-            "#]],
-        );
-    }
-    #[test]
-    fn test_fn_signature_for_impl() {
-        check(
-            r#"
-struct F;
-impl F { pub fn new() { } }
-fn bar() {
-    let _ : F = F::new(<|>);
-}
-"#,
-            expect![[r#"
-                fn new()
-                ()
-            "#]],
-        );
-    }
-    #[test]
-    fn test_fn_signature_for_method_self() {
-        check(
-            r#"
-struct S;
-impl S { pub fn do_it(&self) {} }
-fn bar() {
-    let s: S = S;
-    s.do_it(<|>);
-}
-"#,
-            expect![[r#"
-                fn do_it(&self)
-                ()
-            "#]],
-        );
-    }
-    #[test]
-    fn test_fn_signature_for_method_with_arg() {
-        check(
-            r#"
-struct S;
-impl S {
-    fn foo(&self, x: i32) {}
-}
-fn main() { S.foo(<|>); }
-"#,
-            expect![[r#"
-                fn foo(&self, x: i32)
-                (<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 main() { S::foo(<|>); }
-"#,
-            expect![[r#"
-                fn foo(self: &S, x: i32)
-                (<self: &S>, x: i32)
-            "#]],
-        );
-    }
-    #[test]
-    fn test_fn_signature_with_docs_simple() {
-        check(
-            r#"
-/// test
-// non-doc-comment
-fn foo(j: u32) -> u32 {
-    j
-}
-fn bar() {
-    let _ = foo(<|>);
-}
-"#,
-            expect![[r#"
-                test
-                ------
-                fn foo(j: u32) -> u32
-                (<j: u32>)
-            "#]],
-        );
-    }
-    #[test]
-    fn test_fn_signature_with_docs() {
-        check(
-            r#"
-/// Adds one to the number given.
-///
-/// # Examples
-///
-/// ```
-/// let five = 5;
-///
-/// assert_eq!(6, my_crate::add_one(5));
-/// ```
-pub fn add_one(x: i32) -> i32 {
-    x + 1
-}
-pub fn do() {
-    add_one(<|>
-}"#,
-            expect![[r##"
-                Adds one to the number given.
-                # Examples
-                ```
-                let five = 5;
-                assert_eq!(6, my_crate::add_one(5));
-                ```
-                ------
-                fn add_one(x: i32) -> i32
-                (<x: i32>)
-            "##]],
-        );
-    }
-    #[test]
-    fn test_fn_signature_with_docs_impl() {
-        check(
-            r#"
-struct addr;
-impl addr {
-    /// Adds one to the number given.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let five = 5;
-    ///
-    /// assert_eq!(6, my_crate::add_one(5));
-    /// ```
-    pub fn add_one(x: i32) -> i32 {
-        x + 1
-    }
-}
-pub fn do_it() {
-    addr {};
-    addr::add_one(<|>);
-}
-"#,
-            expect![[r##"
-                Adds one to the number given.
-                # Examples
-                ```
-                let five = 5;
-                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() {
-        check(
-            r#"
-struct WriteHandler<E>;
-impl<E> WriteHandler<E> {
-    /// Method is called when writer emits error.
-    ///
-    /// If this method returns `ErrorAction::Continue` writer processing
-    /// continues otherwise stream processing stops.
-    fn error(&mut self, err: E, ctx: &mut Self::Context) -> Running {
-        Running::Stop
-    }
-    /// Method is called when writer finishes.
-    ///
-    /// By default this method stops actor's `Context`.
-    fn finished(&mut self, ctx: &mut Self::Context) {
-        ctx.stop()
-    }
-}
-pub fn foo(mut r: WriteHandler<()>) {
-    r.finished(<|>);
-}
-"#,
-            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);
-        check(
-            r#"
-fn foo(x: u32, y: u32) -> u32 {x + y}
-fn bar() { foo <|> (3, ); }
-"#,
-            expect![[""]],
-        );
-    }
-    #[test]
-    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>)
-            "#]],
-        );
-    }
-    #[test]
-    fn works_for_tuple_structs() {
-        check(
-            r#"
-/// A cool tuple struct
-struct S(u32, i32);
-fn main() {
-    let s = S(0, <|>);
-}
-"#,
-            expect![[r#"
-                A cool tuple struct
-                ------
-                struct S(u32, i32)
-                (u32, <i32>)
-            "#]],
-        );
-    }
-    #[test]
-    fn generic_struct() {
-        check(
-            r#"
-struct S<T>(T);
-fn main() {
-    let s = S(<|>);
-}
-"#,
-            expect![[r#"
-                struct S({unknown})
-                (<{unknown}>)
-            "#]],
-        );
-    }
-    #[test]
-    fn works_for_enum_variants() {
-        check(
-            r#"
-enum E {
-    /// A Variant
-    A(i32),
-    /// Another
-    B,
-    /// And C
-    C { a: i32, b: i32 }
-}
-fn main() {
-    let a = E::A(<|>);
-}
-"#,
-            expect![[r#"
-                A Variant
-                ------
-                enum E::A(i32)
-                (<i32>)
-            "#]],
-        );
-    }
-    #[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_record() {
-        check(
-            r#"
-enum E {
-    /// A Variant
-    A(i32),
-    /// Another
-    B,
-    /// And C
-    C { a: i32, b: i32 }
-}
-fn main() {
-    let a = E::C(<|>);
-}
-"#,
-            expect![[""]],
-        );
-    }
-    #[test]
-    fn fn_signature_for_call_in_macro() {
-        check(
-            r#"
-macro_rules! id { ($($tt:tt)*) => { $($tt)* } }
-fn foo() { }
-id! {
-    fn bar() { foo(<|>); }
-}
-"#,
-            expect![[r#"
-                fn foo()
-                ()
-            "#]],
-        );
-    }
-    #[test]
-    fn call_info_for_lambdas() {
-        check(
-            r#"
-struct S;
-fn foo(s: S) -> i32 { 92 }
-fn main() {
-    (|s| foo(s))(<|>)
-}
-        "#,
-            expect![[r#"
-                (S) -> i32
-                (<S>)
-            "#]],
-        )
-    }
-    #[test]
-    fn call_info_for_fn_ptr() {
-        check(
-            r#"
-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
deleted file mode 100644
index 9c33a5a43..000000000
--- a/crates/ra_ide/src/completion.rs
+++ /dev/null
@@ -1,211 +0,0 @@
-mod completion_config;
-mod completion_item;
-mod completion_context;
-mod presentation;
-mod patterns;
-#[cfg(test)]
-mod test_utils;
-mod complete_attribute;
-mod complete_dot;
-mod complete_record;
-mod complete_pattern;
-mod complete_fn_param;
-mod complete_keyword;
-mod complete_snippet;
-mod complete_qualified_path;
-mod complete_unqualified_path;
-mod complete_postfix;
-mod complete_macro_in_item_position;
-mod complete_trait_impl;
-mod unstable_feature_descriptor;
-use ra_ide_db::RootDatabase;
-use crate::{
-    completion::{
-        completion_context::CompletionContext,
-        completion_item::{CompletionKind, Completions},
-    },
-    FilePosition,
-};
-//FIXME: cyclic imports caused by xtask generation, this should be better
-use crate::completion::{
-    complete_attribute::LintCompletion, unstable_feature_descriptor::UNSTABLE_FEATURE_DESCRIPTOR,
-};
-pub use crate::completion::{
-    completion_config::CompletionConfig,
-    completion_item::{CompletionItem, CompletionItemKind, CompletionScore, InsertTextFormat},
-};
-//FIXME: split the following feature into fine-grained features.
-// Feature: Magic Completions
-//
-// In addition to usual reference completion, rust-analyzer provides some ✨magic✨
-// completions as well:
-//
-// Keywords like `if`, `else` `while`, `loop` are completed with braces, and cursor
-// is placed at the appropriate position. Even though `if` is easy to type, you
-// still want to complete it, to get ` { }` for free! `return` is inserted with a
-// space or `;` depending on the return type of the function.
-//
-// When completing a function call, `()` are automatically inserted. If a function
-// takes arguments, the cursor is positioned inside the parenthesis.
-//
-// There are postfix completions, which can be triggered by typing something like
-// `foo().if`. The word after `.` determines postfix completion. Possible variants are:
-//
-// - `expr.if` -> `if expr {}` or `if let ... {}` for `Option` or `Result`
-// - `expr.match` -> `match expr {}`
-// - `expr.while` -> `while expr {}` or `while let ... {}` for `Option` or `Result`
-// - `expr.ref` -> `&expr`
-// - `expr.refm` -> `&mut expr`
-// - `expr.not` -> `!expr`
-// - `expr.dbg` -> `dbg!(expr)`
-//
-// There also snippet completions:
-//
-// .Expressions
-// - `pd` -> `eprintln!(" = {:?}", );`
-// - `ppd` -> `eprintln!(" = {:#?}", );`
-//
-// .Items
-// - `tfn` -> `#[test] fn feature(){}`
-// - `tmod` ->
-// ```rust
-// #[cfg(test)]
-// mod tests {
-//     use super::*;
-//
-//     #[test]
-//     fn test_name() {}
-// }
-// ```
-/// Main entry point for completion. We run completion as a two-phase process.
-///
-/// First, we look at the position and collect a so-called `CompletionContext.
-/// This is a somewhat messy process, because, during completion, syntax tree is
-/// incomplete and can look really weird.
-///
-/// Once the context is collected, we run a series of completion routines which
-/// look at the context and produce completion items. One subtlety about this
-/// phase is that completion engine should not filter by the substring which is
-/// already present, it should give all possible variants for the identifier at
-/// the caret. In other words, for
-///
-/// ```no-run
-/// fn f() {
-///     let foo = 92;
-///     let _ = bar<|>
-/// }
-/// ```
-///
-/// `foo` *should* be present among the completion variants. Filtering by
-/// identifier prefix/fuzzy match should be done higher in the stack, together
-/// with ordering of completions (currently this is done by the client).
-pub(crate) fn completions(
-    db: &RootDatabase,
-    config: &CompletionConfig,
-    position: FilePosition,
-) -> Option<Completions> {
-    let ctx = CompletionContext::new(db, position, config)?;
-    let mut acc = Completions::default();
-    complete_attribute::complete_attribute(&mut acc, &ctx);
-    complete_fn_param::complete_fn_param(&mut acc, &ctx);
-    complete_keyword::complete_expr_keyword(&mut acc, &ctx);
-    complete_keyword::complete_use_tree_keyword(&mut acc, &ctx);
-    complete_snippet::complete_expr_snippet(&mut acc, &ctx);
-    complete_snippet::complete_item_snippet(&mut acc, &ctx);
-    complete_qualified_path::complete_qualified_path(&mut acc, &ctx);
-    complete_unqualified_path::complete_unqualified_path(&mut acc, &ctx);
-    complete_dot::complete_dot(&mut acc, &ctx);
-    complete_record::complete_record(&mut acc, &ctx);
-    complete_pattern::complete_pattern(&mut acc, &ctx);
-    complete_postfix::complete_postfix(&mut acc, &ctx);
-    complete_macro_in_item_position::complete_macro_in_item_position(&mut acc, &ctx);
-    complete_trait_impl::complete_trait_impl(&mut acc, &ctx);
-    Some(acc)
-}
-#[cfg(test)]
-mod tests {
-    use crate::completion::completion_config::CompletionConfig;
-    use crate::mock_analysis::analysis_and_position;
-    struct DetailAndDocumentation<'a> {
-        detail: &'a str,
-        documentation: &'a str,
-    }
-    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 {
-            if item.detail() == Some(expected.detail) {
-                let opt = item.documentation();
-                let doc = opt.as_ref().map(|it| it.as_str());
-                assert_eq!(doc, Some(expected.documentation));
-                return;
-            }
-        }
-        panic!("completion detail not found: {}", expected.detail)
-    }
-    #[test]
-    fn test_completion_detail_from_macro_generated_struct_fn_doc_attr() {
-        check_detail_and_documentation(
-            r#"
-            //- /lib.rs
-            macro_rules! bar {
-                () => {
-                    struct Bar;
-                    impl Bar {
-                        #[doc = "Do the foo"]
-                        fn foo(&self) {}
-                    }
-                }
-            }
-            bar!();
-            fn foo() {
-                let bar = Bar;
-                bar.fo<|>;
-            }
-            "#,
-            DetailAndDocumentation { detail: "fn foo(&self)", documentation: "Do the foo" },
-        );
-    }
-    #[test]
-    fn test_completion_detail_from_macro_generated_struct_fn_doc_comment() {
-        check_detail_and_documentation(
-            r#"
-            //- /lib.rs
-            macro_rules! bar {
-                () => {
-                    struct Bar;
-                    impl Bar {
-                        /// Do the foo
-                        fn foo(&self) {}
-                    }
-                }
-            }
-            bar!();
-            fn foo() {
-                let bar = Bar;
-                bar.fo<|>;
-            }
-            "#,
-            DetailAndDocumentation { detail: "fn foo(&self)", documentation: " Do the foo" },
-        );
-    }
-}
diff --git a/crates/ra_ide/src/completion/complete_attribute.rs b/crates/ra_ide/src/completion/complete_attribute.rs
deleted file mode 100644
index f2782d4b9..000000000
--- a/crates/ra_ide/src/completion/complete_attribute.rs
+++ /dev/null
@@ -1,654 +0,0 @@
-//! Completion for attributes
-//!
-//! This module uses a bit of static metadata to provide completions
-//! for built-in attributes.
-use ra_syntax::{ast, AstNode, SyntaxKind};
-use rustc_hash::FxHashSet;
-use crate::completion::{
-    completion_context::CompletionContext,
-    completion_item::{CompletionItem, CompletionItemKind, CompletionKind, Completions},
-};
-use crate::completion::UNSTABLE_FEATURE_DESCRIPTOR;
-pub(super) fn complete_attribute(acc: &mut Completions, ctx: &CompletionContext) -> Option<()> {
-    let attribute = ctx.attribute_under_caret.as_ref()?;
-    match (attribute.path(), attribute.token_tree()) {
-        (Some(path), Some(token_tree)) if path.to_string() == "derive" => {
-            complete_derive(acc, ctx, token_tree)
-        }
-        (Some(path), Some(token_tree)) if path.to_string() == "feature" => {
-            complete_lint(acc, ctx, token_tree, UNSTABLE_FEATURE_DESCRIPTOR);
-        }
-        (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, DEFAULT_LINT_COMPLETIONS)
-        }
-        (_, Some(_token_tree)) => {}
-        _ => complete_attribute_start(acc, ctx, attribute),
-    }
-    Some(())
-}
-fn complete_attribute_start(acc: &mut Completions, ctx: &CompletionContext, attribute: &ast::Attr) {
-    for attr_completion in ATTRIBUTES {
-        let mut item = CompletionItem::new(
-            CompletionKind::Attribute,
-            ctx.source_range(),
-            attr_completion.label,
-        )
-        .kind(CompletionItemKind::Attribute);
-        if let Some(lookup) = attr_completion.lookup {
-            item = item.lookup_by(lookup);
-        }
-        match (attr_completion.snippet, ctx.config.snippet_cap) {
-            (Some(snippet), Some(cap)) => {
-                item = item.insert_snippet(cap, snippet);
-            }
-            _ => {}
-        }
-        if attribute.kind() == ast::AttrKind::Inner || !attr_completion.prefer_inner {
-            acc.add(item);
-        }
-    }
-}
-struct AttrCompletion {
-    label: &'static str,
-    lookup: Option<&'static str>,
-    snippet: Option<&'static str>,
-    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] = &[
-    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:lint})")).prefer_inner(),
-    attr("forbid(…)", Some("forbid"), Some("forbid(${0:lint})")),
-    // FIXME: resolve through macro resolution?
-    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_comma_sep_input(derive_input) {
-        for derive_completion in DEFAULT_DERIVE_COMPLETIONS
-            .into_iter()
-            .filter(|completion| !existing_derives.contains(completion.label))
-        {
-            let mut label = derive_completion.label.to_owned();
-            for dependency in derive_completion
-                .dependencies
-                .into_iter()
-                .filter(|&&dependency| !existing_derives.contains(dependency))
-            {
-                label.push_str(", ");
-                label.push_str(dependency);
-            }
-            acc.add(
-                CompletionItem::new(CompletionKind::Attribute, ctx.source_range(), label)
-                    .kind(CompletionItemKind::Attribute),
-            );
-        }
-        for custom_derive_name in get_derive_names_in_scope(ctx).difference(&existing_derives) {
-            acc.add(
-                CompletionItem::new(
-                    CompletionKind::Attribute,
-                    ctx.source_range(),
-                    custom_derive_name,
-                )
-                .kind(CompletionItemKind::Attribute),
-            );
-        }
-    }
-}
-fn complete_lint(
-    acc: &mut Completions,
-    ctx: &CompletionContext,
-    derive_input: ast::TokenTree,
-    lints_completions: &[LintCompletion],
-) {
-    if let Ok(existing_lints) = parse_comma_sep_input(derive_input) {
-        for lint_completion in lints_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
-                && right_paren.kind() == SyntaxKind::R_PAREN =>
-        {
-            let mut input_derives = FxHashSet::default();
-            let mut current_derive = String::new();
-            for token in derive_input
-                .syntax()
-                .children_with_tokens()
-                .filter_map(|token| token.into_token())
-                .skip_while(|token| token != &left_paren)
-                .skip(1)
-                .take_while(|token| token != &right_paren)
-            {
-                if SyntaxKind::COMMA == token.kind() {
-                    if !current_derive.is_empty() {
-                        input_derives.insert(current_derive);
-                        current_derive = String::new();
-                    }
-                } else {
-                    current_derive.push_str(token.to_string().trim());
-                }
-            }
-            if !current_derive.is_empty() {
-                input_derives.insert(current_derive);
-            }
-            Ok(input_derives)
-        }
-        _ => Err(()),
-    }
-}
-fn get_derive_names_in_scope(ctx: &CompletionContext) -> FxHashSet<String> {
-    let mut result = FxHashSet::default();
-    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());
-            }
-        }
-    });
-    result
-}
-struct DeriveCompletion {
-    label: &'static str,
-    dependencies: &'static [&'static str],
-}
-/// 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"] },
-    DeriveCompletion { label: "Debug", dependencies: &[] },
-    DeriveCompletion { label: "Default", dependencies: &[] },
-    DeriveCompletion { label: "Hash", dependencies: &[] },
-    DeriveCompletion { label: "PartialEq", dependencies: &[] },
-    DeriveCompletion { label: "Eq", dependencies: &["PartialEq"] },
-    DeriveCompletion { label: "PartialOrd", dependencies: &["PartialEq"] },
-    DeriveCompletion { label: "Ord", dependencies: &["PartialOrd", "Eq", "PartialEq"] },
-];
-pub(crate) struct LintCompletion {
-    pub label: &'static str,
-    pub 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 expect::{expect, Expect};
-    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() {
-        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() {
-        check(
-            r#"
-#[derive{<|>)]
-struct Test {}
-"#,
-            expect![[r#""#]],
-        )
-    }
-    #[test]
-    fn derive_with_input_completion() {
-        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() {
-        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() {
-        check(r#"#[cfg(<|>)]"#, expect![[]])
-    }
-    #[test]
-    fn test_inner_attribute_completion() {
-        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
deleted file mode 100644
index 532665285..000000000
--- a/crates/ra_ide/src/completion/complete_dot.rs
+++ /dev/null
@@ -1,416 +0,0 @@
-//! Completes references after dot (fields and method calls).
-use hir::{HasVisibility, Type};
-use rustc_hash::FxHashSet;
-use test_utils::mark;
-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,
-        _ => return,
-    };
-    let receiver_ty = match ctx.sema.type_of_expr(&dot_receiver) {
-        Some(ty) => ty,
-        _ => return,
-    };
-    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);
-}
-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)) {
-                // Skip private field. FIXME: If the definition location of the
-                // field is editable, we should show the completion
-                continue;
-            }
-            acc.add_field(ctx, field, &ty);
-        }
-        for (i, ty) in receiver.tuple_fields(ctx.db).into_iter().enumerate() {
-            // FIXME: Handle visibility
-            acc.add_tuple_field(ctx, i, &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();
-        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))
-                && seen_methods.insert(func.name(ctx.db))
-            {
-                acc.add_function(ctx, func, None);
-            }
-            None::<()>
-        });
-    }
-}
-#[cfg(test)]
-mod tests {
-    use expect::{expect, Expect};
-    use test_utils::mark;
-    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 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() {
-        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() {
-        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() {
-        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_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,
-    }
-}
-fn foo(a: inner::A) { a.<|> }
-"#,
-            expect![[r#"
-                fd crate_field u32
-                fd pub_field   u32
-                fd super_field u32
-            "#]],
-        );
-        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_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_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() {
-        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() {
-        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() {
-        check(
-            r"
-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_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() {
-        check(
-            r#"
-fn foo() {
-   let b = (0, 3.14);
-   b.<|>
-}
-"#,
-            expect![[r#"
-                fd 0 i32
-                fd 1 f64
-            "#]],
-        )
-    }
-    #[test]
-    fn test_tuple_field_inference() {
-        check(
-            r#"
-pub struct S;
-impl S { pub fn blah(&self) {} }
-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<|>
-    }
-}
-"#,
-            expect![[r#"
-                me blah() pub fn blah(&self)
-            "#]],
-        );
-    }
-    #[test]
-    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() {
-        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
-        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() {
-        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() {
-        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_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
deleted file mode 100644
index 406334257..000000000
--- a/crates/ra_ide/src/completion/complete_fn_param.rs
+++ /dev/null
@@ -1,135 +0,0 @@
-//! See `complete_fn_param`.
-use ra_syntax::{
-    ast::{self, ModuleItemOwner},
-    match_ast, AstNode,
-};
-use rustc_hash::FxHashMap;
-use crate::completion::{CompletionContext, CompletionItem, CompletionKind, Completions};
-/// Complete repeated parameters, both name and type. For example, if all
-/// functions in a file have a `spam: &mut Spam` parameter, a completion with
-/// `spam: &mut Spam` insert text/label and `spam` lookup string will be
-/// suggested.
-pub(super) fn complete_fn_param(acc: &mut Completions, ctx: &CompletionContext) {
-    if !ctx.is_param {
-        return;
-    }
-    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() {
-        match_ast! {
-            match node {
-                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,
-            }
-        };
-    }
-    params
-        .into_iter()
-        .filter_map(|(label, param)| {
-            let lookup = param.pat()?.syntax().text().to_string();
-            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)
-        });
-}
-#[cfg(test)]
-mod tests {
-    use expect::{expect, Expect};
-    use crate::completion::{test_utils::completion_list, CompletionKind};
-    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() {
-        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() {
-        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() {
-        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
deleted file mode 100644
index b62064797..000000000
--- a/crates/ra_ide/src/completion/complete_keyword.rs
+++ /dev/null
@@ -1,536 +0,0 @@
-//! FIXME: write short doc here
-use ra_syntax::{ast, SyntaxKind};
-use test_utils::mark;
-use crate::completion::{
-    CompletionContext, CompletionItem, CompletionItemKind, CompletionKind, Completions,
-};
-pub(super) fn complete_use_tree_keyword(acc: &mut Completions, ctx: &CompletionContext) {
-    // complete keyword "crate" in use stmt
-    let source_range = ctx.source_range();
-    match (ctx.use_item_syntax.as_ref(), ctx.path_prefix.as_ref()) {
-        (Some(_), None) => {
-            CompletionItem::new(CompletionKind::Keyword, source_range, "crate::")
-                .kind(CompletionItemKind::Keyword)
-                .insert_text("crate::")
-                .add_to(acc);
-            CompletionItem::new(CompletionKind::Keyword, source_range, "self")
-                .kind(CompletionItemKind::Keyword)
-                .add_to(acc);
-            CompletionItem::new(CompletionKind::Keyword, source_range, "super::")
-                .kind(CompletionItemKind::Keyword)
-                .insert_text("super::")
-                .add_to(acc);
-        }
-        (Some(_), Some(_)) => {
-            CompletionItem::new(CompletionKind::Keyword, source_range, "self")
-                .kind(CompletionItemKind::Keyword)
-                .add_to(acc);
-            CompletionItem::new(CompletionKind::Keyword, source_range, "super::")
-                .kind(CompletionItemKind::Keyword)
-                .insert_text("super::")
-                .add_to(acc);
-        }
-        _ => {}
-    }
-    // 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 ");
-        return;
-    }
-    if ctx.unsafe_is_prev {
-        if ctx.has_item_list_or_source_file_parent || ctx.block_expr_parent {
-            add_keyword(ctx, acc, "fn", "fn $0() {}")
-        }
-        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 || 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) || 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 {
-        add_keyword(ctx, acc, "enum", "enum $0 {}");
-        add_keyword(ctx, acc, "struct", "struct $0");
-        add_keyword(ctx, acc, "union", "union $0 {}");
-    }
-    if ctx.is_expr {
-        add_keyword(ctx, acc, "match", "match $0 {}");
-        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.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) || 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 || 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) || ctx.block_expr_parent {
-        add_keyword(ctx, acc, "static", "static ");
-    };
-    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
-        || has_trait_or_impl_parent
-        || ctx.block_expr_parent
-        || ctx.is_match_arm
-    {
-        add_keyword(ctx, acc, "unsafe", "unsafe ");
-    }
-    if ctx.in_loop_body {
-        if ctx.can_be_stmt {
-            add_keyword(ctx, acc, "continue", "continue;");
-            add_keyword(ctx, acc, "break", "break;");
-        } else {
-            add_keyword(ctx, acc, "continue", "continue");
-            add_keyword(ctx, acc, "break", "break");
-        }
-    }
-    if ctx.has_item_list_or_source_file_parent || ctx.has_impl_parent {
-        add_keyword(ctx, acc, "pub", "pub ")
-    }
-    if !ctx.is_trivial_path {
-        return;
-    }
-    let fn_def = match &ctx.function_syntax {
-        Some(it) => it,
-        None => return,
-    };
-    acc.add_all(complete_return(ctx, &fn_def, ctx.can_be_stmt));
-}
-fn keyword(ctx: &CompletionContext, kw: &str, snippet: &str) -> CompletionItem {
-    let res = CompletionItem::new(CompletionKind::Keyword, ctx.source_range(), kw)
-        .kind(CompletionItemKind::Keyword);
-    match ctx.config.snippet_cap {
-        Some(cap) => res.insert_snippet(cap, snippet),
-        _ => res.insert_text(if snippet.contains('$') { kw } else { snippet }),
-    }
-    .build()
-}
-fn add_keyword(ctx: &CompletionContext, acc: &mut Completions, kw: &str, snippet: &str) {
-    acc.add(keyword(ctx, kw, snippet));
-}
-fn complete_return(
-    ctx: &CompletionContext,
-    fn_def: &ast::Fn,
-    can_be_stmt: bool,
-) -> Option<CompletionItem> {
-    let snip = match (can_be_stmt, fn_def.ret_type().is_some()) {
-        (true, true) => "return $0;",
-        (true, false) => "return;",
-        (false, true) => "return $0",
-        (false, false) => "return",
-    };
-    Some(keyword(ctx, "return", snip))
-}
-#[cfg(test)]
-mod tests {
-    use expect::{expect, Expect};
-    use crate::completion::{
-        test_utils::{check_edit, completion_list},
-        CompletionKind,
-    };
-    use test_utils::mark;
-    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() {
-        check(
-            r"use <|>",
-            expect![[r#"
-                kw crate::
-                kw self
-                kw super::
-            "#]],
-        );
-        check(
-            r"use a::<|>",
-            expect![[r#"
-                kw self
-                kw super::
-            "#]],
-        );
-        check(
-            r"use a::{b, <|>}",
-            expect![[r#"
-                kw self
-                kw super::
-            "#]],
-        );
-    }
-    #[test]
-    fn test_keywords_at_source_file_level() {
-        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() {
-        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() {
-        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() {
-        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() {
-        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() {
-        check(
-            r"trait My { <|> }",
-            expect![[r#"
-                kw const
-                kw fn
-                kw type
-                kw unsafe
-            "#]],
-        );
-    }
-    #[test]
-    fn test_keywords_in_impl_def() {
-        check(
-            r"impl My { <|> }",
-            expect![[r#"
-                kw const
-                kw fn
-                kw pub
-                kw type
-                kw unsafe
-            "#]],
-        );
-    }
-    #[test]
-    fn test_keywords_in_loop() {
-        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() {
-        check(
-            r"unsafe <|>",
-            expect![[r#"
-                kw fn
-                kw impl
-                kw trait
-            "#]],
-        );
-    }
-    #[test]
-    fn test_keywords_after_unsafe_in_block_expr() {
-        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() {
-        check(
-            r"fn my_fn(&<|>) {}",
-            expect![[r#"
-                kw mut
-            "#]],
-        );
-        check(
-            r"fn my_fn(<|>) {}",
-            expect![[r#"
-                kw mut
-            "#]],
-        );
-        check(
-            r"fn my_fn() { let &<|> }",
-            expect![[r#"
-                kw mut
-            "#]],
-        );
-    }
-    #[test]
-    fn test_where_keyword() {
-        check(
-            r"trait A <|>",
-            expect![[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
deleted file mode 100644
index 0447f0511..000000000
--- a/crates/ra_ide/src/completion/complete_macro_in_item_position.rs
+++ /dev/null
@@ -1,41 +0,0 @@
-//! FIXME: write short doc here
-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| {
-            if let hir::ScopeDef::MacroDef(mac) = res {
-                acc.add_macro(ctx, Some(name.to_string()), mac);
-            }
-        })
-    }
-}
-#[cfg(test)]
-mod tests {
-    use expect::{expect, Expect};
-    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_macros_as_item() {
-        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
deleted file mode 100644
index aceb77cb5..000000000
--- a/crates/ra_ide/src/completion/complete_pattern.rs
+++ /dev/null
@@ -1,88 +0,0 @@
-//! FIXME: write short doc here
-use crate::completion::{CompletionContext, Completions};
-/// Completes constats and paths in patterns.
-pub(super) fn complete_pattern(acc: &mut Completions, ctx: &CompletionContext) {
-    if !ctx.is_pat_binding_or_const {
-        return;
-    }
-    if ctx.record_pat_syntax.is_some() {
-        return;
-    }
-    // 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| {
-        match &res {
-            hir::ScopeDef::ModuleDef(def) => match def {
-                hir::ModuleDef::Adt(hir::Adt::Enum(..))
-                | hir::ModuleDef::Adt(hir::Adt::Struct(..))
-                | hir::ModuleDef::EnumVariant(..)
-                | hir::ModuleDef::Const(..)
-                | hir::ModuleDef::Module(..) => (),
-                _ => return,
-            },
-            hir::ScopeDef::MacroDef(_) => (),
-            _ => return,
-        };
-        acc.add_resolution(ctx, name.to_string(), &res)
-    });
-}
-#[cfg(test)]
-mod tests {
-    use expect::{expect, Expect};
-    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() {
-        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 }
-fn foo() {
-   match E::X { <|> }
-}
-"#,
-            expect![[r#"
-                st Bar
-                en E
-                ev X   ()
-                ct Z
-                md m
-            "#]],
-        );
-    }
-    #[test]
-    fn completes_in_simple_macro_call() {
-        check(
-            r#"
-macro_rules! m { ($e:expr) => { $e } }
-enum E { X }
-fn foo() {
-   m!(match E::X { <|> })
-}
-"#,
-            expect![[r#"
-                en E
-                ma m!(…) macro_rules! m
-            "#]],
-        );
-    }
-}
diff --git a/crates/ra_ide/src/completion/complete_postfix.rs b/crates/ra_ide/src/completion/complete_postfix.rs
deleted file mode 100644
index 8735b9010..000000000
--- a/crates/ra_ide/src/completion/complete_postfix.rs
+++ /dev/null
@@ -1,378 +0,0 @@
-//! FIXME: write short doc here
-use ra_assists::utils::TryEnum;
-use ra_syntax::{
-    ast::{self, AstNode},
-    TextRange, TextSize,
-};
-use ra_text_edit::TextEdit;
-use crate::{
-    completion::{
-        completion_config::SnippetCap,
-        completion_context::CompletionContext,
-        completion_item::{Builder, CompletionKind, Completions},
-    },
-    CompletionItem, CompletionItemKind,
-};
-pub(super) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
-    if !ctx.config.enable_postfix_completions {
-        return;
-    }
-    let dot_receiver = match &ctx.dot_receiver {
-        Some(it) => it,
-        None => return,
-    };
-    let receiver_text =
-        get_receiver_text(dot_receiver, ctx.dot_receiver_is_ambiguous_float_literal);
-    let receiver_ty = match ctx.sema.type_of_expr(&dot_receiver) {
-        Some(it) => it,
-        None => return,
-    };
-    let cap = match ctx.config.snippet_cap {
-        Some(it) => it,
-        None => return,
-    };
-    let try_enum = TryEnum::from_ty(&ctx.sema, &receiver_ty);
-    if let Some(try_enum) = &try_enum {
-        match try_enum {
-            TryEnum::Result => {
-                postfix_snippet(
-                    ctx,
-                    cap,
-                    &dot_receiver,
-                    "ifl",
-                    "if let Ok {}",
-                    &format!("if let Ok($1) = {} {{\n    $0\n}}", receiver_text),
-                )
-                .add_to(acc);
-                postfix_snippet(
-                    ctx,
-                    cap,
-                    &dot_receiver,
-                    "while",
-                    "while let Ok {}",
-                    &format!("while let Ok($1) = {} {{\n    $0\n}}", receiver_text),
-                )
-                .add_to(acc);
-            }
-            TryEnum::Option => {
-                postfix_snippet(
-                    ctx,
-                    cap,
-                    &dot_receiver,
-                    "ifl",
-                    "if let Some {}",
-                    &format!("if let Some($1) = {} {{\n    $0\n}}", receiver_text),
-                )
-                .add_to(acc);
-                postfix_snippet(
-                    ctx,
-                    cap,
-                    &dot_receiver,
-                    "while",
-                    "while let Some {}",
-                    &format!("while let Some($1) = {} {{\n    $0\n}}", receiver_text),
-                )
-                .add_to(acc);
-            }
-        }
-    } else if receiver_ty.is_bool() || receiver_ty.is_unknown() {
-        postfix_snippet(
-            ctx,
-            cap,
-            &dot_receiver,
-            "if",
-            "if expr {}",
-            &format!("if {} {{\n    $0\n}}", receiver_text),
-        )
-        .add_to(acc);
-        postfix_snippet(
-            ctx,
-            cap,
-            &dot_receiver,
-            "while",
-            "while expr {}",
-            &format!("while {} {{\n    $0\n}}", receiver_text),
-        )
-        .add_to(acc);
-        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);
-    postfix_snippet(
-        ctx,
-        cap,
-        &dot_receiver,
-        "refm",
-        "&mut expr",
-        &format!("&mut {}", receiver_text),
-    )
-    .add_to(acc);
-    // The rest of the postfix completions create an expression that moves an argument,
-    // so it's better to consider references now to avoid breaking the compilation
-    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(
-                    ctx,
-                    cap,
-                    &dot_receiver,
-                    "match",
-                    "match expr {}",
-                    &format!("match {} {{\n    Ok(${{1:_}}) => {{$2}},\n    Err(${{3:_}}) => {{$0}},\n}}", receiver_text),
-                )
-                .add_to(acc);
-            }
-            TryEnum::Option => {
-                postfix_snippet(
-                    ctx,
-                    cap,
-                    &dot_receiver,
-                    "match",
-                    "match expr {}",
-                    &format!(
-                        "match {} {{\n    Some(${{1:_}}) => {{$2}},\n    None => {{$0}},\n}}",
-                        receiver_text
-                    ),
-                )
-                .add_to(acc);
-            }
-        },
-        None => {
-            postfix_snippet(
-                ctx,
-                cap,
-                &dot_receiver,
-                "match",
-                "match expr {}",
-                &format!("match {} {{\n    ${{1:_}} => {{$0}},\n}}", receiver_text),
-            )
-            .add_to(acc);
-        }
-    }
-    postfix_snippet(
-        ctx,
-        cap,
-        &dot_receiver,
-        "box",
-        "Box::new(expr)",
-        &format!("Box::new({})", receiver_text),
-    )
-    .add_to(acc);
-    postfix_snippet(
-        ctx,
-        cap,
-        &dot_receiver,
-        "dbg",
-        "dbg!(expr)",
-        &format!("dbg!({})", receiver_text),
-    )
-    .add_to(acc);
-    postfix_snippet(
-        ctx,
-        cap,
-        &dot_receiver,
-        "call",
-        "function(expr)",
-        &format!("${{1}}({})", receiver_text),
-    )
-    .add_to(acc);
-}
-fn get_receiver_text(receiver: &ast::Expr, receiver_is_ambiguous_float_literal: bool) -> String {
-    if receiver_is_ambiguous_float_literal {
-        let text = receiver.syntax().text();
-        let without_dot = ..text.len() - TextSize::of('.');
-        text.slice(without_dot).to_string()
-    } else {
-        receiver.to_string()
-    }
-}
-fn include_references(initial_element: &ast::Expr) -> ast::Expr {
-    let mut resulting_element = initial_element.clone();
-    while let Some(parent_ref_element) =
-        resulting_element.syntax().parent().and_then(ast::RefExpr::cast)
-    {
-        resulting_element = ast::Expr::from(parent_ref_element);
-    }
-    resulting_element
-}
-fn postfix_snippet(
-    ctx: &CompletionContext,
-    cap: SnippetCap,
-    receiver: &ast::Expr,
-    label: &str,
-    detail: &str,
-    snippet: &str,
-) -> Builder {
-    let edit = {
-        let receiver_syntax = receiver.syntax();
-        let receiver_range = ctx.sema.original_range(receiver_syntax).range;
-        let delete_range = TextRange::new(receiver_range.start(), ctx.source_range().end());
-        TextEdit::replace(delete_range, snippet.to_string())
-    };
-    CompletionItem::new(CompletionKind::Postfix, ctx.source_range(), label)
-        .detail(detail)
-        .kind(CompletionItemKind::Snippet)
-        .snippet_edit(cap, edit)
-}
-#[cfg(test)]
-mod tests {
-    use expect::{expect, Expect};
-    use crate::completion::{
-        test_utils::{check_edit, completion_list},
-        CompletionKind,
-    };
-    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() {
-        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_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 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 = Option::Some(true);
-    if let Some($1) = bar {
-    $0
-}
-}
-"#,
-        );
-    }
-    #[test]
-    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() {
-        check_edit("refm", r#"fn main() { 42.<|> }"#, r#"fn main() { &mut 42 }"#)
-    }
-    #[test]
-    fn works_in_simple_macro() {
-        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() {
-        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
deleted file mode 100644
index b08f5b9b4..000000000
--- a/crates/ra_ide/src/completion/complete_qualified_path.rs
+++ /dev/null
@@ -1,733 +0,0 @@
-//! Completion of paths, i.e. `some::prefix::<|>`.
-use hir::{Adt, HasVisibility, PathResolution, ScopeDef};
-use ra_syntax::AstNode;
-use rustc_hash::FxHashSet;
-use test_utils::mark;
-use crate::completion::{CompletionContext, Completions};
-pub(super) fn complete_qualified_path(acc: &mut Completions, ctx: &CompletionContext) {
-    let path = match &ctx.path_prefix {
-        Some(path) => path.clone(),
-        None => return,
-    };
-    if ctx.attribute_under_caret.is_some() {
-        return;
-    }
-    let context_module = ctx.scope.module();
-    let resolution = match ctx.scope.resolve_hir_path_qualifier(&path) {
-        Some(res) => res,
-        None => return,
-    };
-    // Add associated types on type parameters and `Self`.
-    resolution.assoc_type_shorthand_candidates(ctx.db, |alias| {
-        acc.add_type_alias(ctx, alias);
-        None::<()>
-    });
-    match resolution {
-        PathResolution::Def(hir::ModuleDef::Module(module)) => {
-            let module_scope = module.scope(ctx.db, context_module);
-            for (name, def) in module_scope {
-                if ctx.use_item_syntax.is_some() {
-                    if let ScopeDef::Unknown = def {
-                        if let Some(name_ref) = ctx.name_ref_syntax.as_ref() {
-                            if name_ref.syntax().text() == name.to_string().as_str() {
-                                // for `use self::foo<|>`, don't suggest `foo` as a completion
-                                mark::hit!(dont_complete_current_use);
-                                continue;
-                            }
-                        }
-                    }
-                }
-                acc.add_resolution(ctx, name.to_string(), &def);
-            }
-        }
-        PathResolution::Def(def @ hir::ModuleDef::Adt(_))
-        | PathResolution::Def(def @ hir::ModuleDef::TypeAlias(_)) => {
-            if let hir::ModuleDef::Adt(Adt::Enum(e)) = def {
-                for variant in e.variants(ctx.db) {
-                    acc.add_enum_variant(ctx, variant, None);
-                }
-            }
-            let ty = match def {
-                hir::ModuleDef::Adt(adt) => adt.ty(ctx.db),
-                hir::ModuleDef::TypeAlias(a) => a.ty(ctx.db),
-                _ => unreachable!(),
-            };
-            // XXX: For parity with Rust bug #22519, this does not complete Ty::AssocType.
-            // (where AssocType is defined on a trait, not an inherent impl)
-            let krate = ctx.krate;
-            if let Some(krate) = krate {
-                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;
-                    }
-                    match item {
-                        hir::AssocItem::Function(func) => {
-                            acc.add_function(ctx, func, None);
-                        }
-                        hir::AssocItem::Const(ct) => acc.add_const(ctx, ct),
-                        hir::AssocItem::TypeAlias(ty) => acc.add_type_alias(ctx, ty),
-                    }
-                    None::<()>
-                });
-                // Iterate assoc types separately
-                ty.iterate_assoc_items(ctx.db, krate, |item| {
-                    if context_module.map_or(false, |m| !item.is_visible_from(ctx.db, m)) {
-                        return None;
-                    }
-                    match item {
-                        hir::AssocItem::Function(_) | hir::AssocItem::Const(_) => {}
-                        hir::AssocItem::TypeAlias(ty) => acc.add_type_alias(ctx, ty),
-                    }
-                    None::<()>
-                });
-            }
-        }
-        PathResolution::Def(hir::ModuleDef::Trait(t)) => {
-            // Handles `Trait::assoc` as well as `<Ty as Trait>::assoc`.
-            for item in t.items(ctx.db) {
-                if context_module.map_or(false, |m| !item.is_visible_from(ctx.db, m)) {
-                    continue;
-                }
-                match item {
-                    hir::AssocItem::Function(func) => {
-                        acc.add_function(ctx, func, None);
-                    }
-                    hir::AssocItem::Const(ct) => acc.add_const(ctx, ct),
-                    hir::AssocItem::TypeAlias(ty) => acc.add_type_alias(ctx, ty),
-                }
-            }
-        }
-        PathResolution::TypeParam(_) | PathResolution::SelfType(_) => {
-            if let Some(krate) = ctx.krate {
-                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 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)) {
-                        return None;
-                    }
-                    // We might iterate candidates of a trait multiple times here, so deduplicate
-                    // them.
-                    if seen.insert(item) {
-                        match item {
-                            hir::AssocItem::Function(func) => {
-                                acc.add_function(ctx, func, None);
-                            }
-                            hir::AssocItem::Const(ct) => acc.add_const(ctx, ct),
-                            hir::AssocItem::TypeAlias(ty) => acc.add_type_alias(ctx, ty),
-                        }
-                    }
-                    None::<()>
-                });
-            }
-        }
-        _ => {}
-    }
-}
-#[cfg(test)]
-mod tests {
-    use expect::{expect, Expect};
-    use test_utils::mark;
-    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 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);
-        check(r#"use self::foo<|>;"#, expect![[""]]);
-    }
-    #[test]
-    fn dont_complete_current_use_in_braces_with_glob() {
-        check(
-            r#"
-mod foo { pub struct S; }
-use self::{foo::*, bar<|>};
-"#,
-            expect![[r#"
-                st S
-                md foo
-            "#]],
-        );
-    }
-    #[test]
-    fn dont_complete_primitive_in_use() {
-        check_builtin(r#"use self::<|>;"#, expect![[""]]);
-    }
-    #[test]
-    fn dont_complete_primitive_in_module_scope() {
-        check_builtin(r#"fn foo() { self::<|> }"#, expect![[""]]);
-    }
-    #[test]
-    fn completes_primitives() {
-        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() {
-        check(
-            r#"
-use self::my::<|>;
-mod my { pub struct Bar; }
-fn my() {}
-"#,
-            expect![[r#"
-                st Bar
-            "#]],
-        );
-    }
-    #[test]
-    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() {
-        check(
-            r#"
-use self::m::<|>;
-mod m { pub struct Bar; }
-"#,
-            expect![[r#"
-                st Bar
-            "#]],
-        );
-    }
-    #[test]
-    fn completes_use_item_starting_with_crate() {
-        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() {
-        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() {
-        check(
-            r#"
-//- /lib.rs
-mod foo;
-pub mod bar {
-    pub mod baz {
-        pub struct Spam;
-    }
-}
-//- /foo.rs
-use crate::{bar::{baz::Sp<|>}};
-"#,
-            expect![[r#"
-                st Spam
-            "#]],
-        );
-    }
-    #[test]
-    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_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::<|> }
-"#,
-            expect![[r#"
-                ct C   const C: i32 = 42;
-                ta T   type T = i32;
-                fn a() fn a()
-                me b() fn b(&self)
-            "#]],
-        );
-    }
-    #[test]
-    fn associated_item_visibility() {
-        check(
-            r#"
-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::<|> }
-"#,
-            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() {
-        check(
-            r#"
-enum E {};
-impl E { fn m() { } }
-fn foo() { let _ = E::<|> }
-        "#,
-            expect![[r#"
-                fn m() fn m()
-            "#]],
-        );
-    }
-    #[test]
-    fn completes_union_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() {
-        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() {
-        check(
-            r#"
-trait Trait { fn m(); }
-fn foo() { let _ = Trait::<|> }
-"#,
-            expect![[r#"
-                fn m() fn m()
-            "#]],
-        );
-    }
-    #[test]
-    fn completes_trait_associated_method_2() {
-        check(
-            r#"
-trait Trait { fn m(); }
-struct S;
-impl Trait for S {}
-fn foo() { let _ = S::<|> }
-"#,
-            expect![[r#"
-                fn m() fn m()
-            "#]],
-        );
-    }
-    #[test]
-    fn completes_trait_associated_method_3() {
-        check(
-            r#"
-trait Trait { fn m(); }
-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() {
-        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) {}
-}
-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() {
-        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) {}
-}
-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() {
-        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() {
-        check(
-            r#"
-#[macro_export]
-macro_rules! foo { () => {} }
-fn main() { let _ = crate::<|> }
-        "#,
-            expect![[r##"
-                ma foo!(…) #[macro_export]
-                macro_rules! foo
-                fn main()  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() {
-        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 {};
-}
-"#,
-            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() {
-        check(
-            r#"
-macro_rules! m { ($e:expr) => { $e } }
-fn main() { m!(self::f<|>); }
-fn foo() {}
-"#,
-            expect![[r#"
-                fn foo()  fn foo()
-                fn main() fn main()
-            "#]],
-        );
-    }
-    #[test]
-    fn function_mod_share_name() {
-        check(
-            r#"
-fn foo() { self::m::<|> }
-mod m {
-    pub mod z {}
-    pub fn z() {}
-}
-"#,
-            expect![[r#"
-                md z
-                fn z() pub fn z()
-            "#]],
-        );
-    }
-    #[test]
-    fn completes_hashmap_new() {
-        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() {
-        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
deleted file mode 100644
index 74b94594d..000000000
--- a/crates/ra_ide/src/completion/complete_record.rs
+++ /dev/null
@@ -1,226 +0,0 @@
-//! Complete fields in record literals and patterns.
-use crate::completion::{CompletionContext, Completions};
-pub(super) fn complete_record(acc: &mut Completions, ctx: &CompletionContext) -> Option<()> {
-    let missing_fields = match (ctx.record_pat_syntax.as_ref(), ctx.record_lit_syntax.as_ref()) {
-        (None, None) => return None,
-        (Some(_), Some(_)) => unreachable!("A record cannot be both a literal and a pattern"),
-        (Some(record_pat), _) => ctx.sema.record_pattern_missing_fields(record_pat),
-        (_, Some(record_lit)) => ctx.sema.record_literal_missing_fields(record_lit),
-    };
-    for (field, ty) in missing_fields {
-        acc.add_field(ctx, field, &ty)
-    }
-    Some(())
-}
-#[cfg(test)]
-mod tests {
-    use expect::{expect, Expect};
-    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 test_record_pattern_field() {
-        check(
-            r#"
-struct S { foo: u32 }
-fn process(f: S) {
-    match f {
-        S { f<|>: 92 } => (),
-    }
-}
-"#,
-            expect![[r#"
-                fd foo u32
-            "#]],
-        );
-    }
-    #[test]
-    fn test_record_pattern_enum_variant() {
-        check(
-            r#"
-enum E { S { foo: u32, bar: () } }
-fn process(e: E) {
-    match e {
-        E::S { <|> } => (),
-    }
-}
-"#,
-            expect![[r#"
-                fd bar ()
-                fd foo u32
-            "#]],
-        );
-    }
-    #[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
-            "#]],
-        );
-    }
-    #[test]
-    fn only_missing_fields_are_completed_in_destruct_pats() {
-        check(
-            r#"
-struct S {
-    foo1: u32, foo2: u32,
-    bar: u32, baz: u32,
-}
-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() {
-        check(
-            r#"
-struct A { the_field: u32 }
-fn foo() {
-   A { the<|> }
-}
-"#,
-            expect![[r#"
-                fd the_field 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() {
-        check(
-            r#"
-struct A { a: u32 }
-struct B { b: u32 }
-fn foo() {
-   let _: A = B { <|> }
-}
-"#,
-            expect![[r#"
-                fd b u32
-            "#]],
-        );
-    }
-    #[test]
-    fn test_record_literal_generic_struct() {
-        check(
-            r#"
-struct A<T> { a: T }
-fn foo() {
-   let _: A<u32> = A { <|> }
-}
-"#,
-            expect![[r#"
-                fd a 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() {
-        check(
-            r#"
-struct S {
-    foo1: u32, foo2: u32,
-    bar: u32, baz: 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() {
-        check(
-            r#"
-struct S { foo1: u32, foo2: 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
deleted file mode 100644
index 28d8f7876..000000000
--- a/crates/ra_ide/src/completion/complete_snippet.rs
+++ /dev/null
@@ -1,116 +0,0 @@
-//! FIXME: write short doc here
-use crate::completion::{
-    completion_config::SnippetCap, completion_item::Builder, CompletionContext, CompletionItem,
-    CompletionItemKind, CompletionKind, Completions,
-};
-fn snippet(ctx: &CompletionContext, cap: SnippetCap, label: &str, snippet: &str) -> Builder {
-    CompletionItem::new(CompletionKind::Snippet, ctx.source_range(), label)
-        .insert_snippet(cap, snippet)
-        .kind(CompletionItemKind::Snippet)
-}
-pub(super) fn complete_expr_snippet(acc: &mut Completions, ctx: &CompletionContext) {
-    if !(ctx.is_trivial_path && ctx.function_syntax.is_some()) {
-        return;
-    }
-    let cap = match ctx.config.snippet_cap {
-        Some(it) => it,
-        None => return,
-    };
-    snippet(ctx, cap, "pd", "eprintln!(\"$0 = {:?}\", $0);").add_to(acc);
-    snippet(ctx, cap, "ppd", "eprintln!(\"$0 = {:#?}\", $0);").add_to(acc);
-}
-pub(super) fn complete_item_snippet(acc: &mut Completions, ctx: &CompletionContext) {
-    if !ctx.is_new_item {
-        return;
-    }
-    let cap = match ctx.config.snippet_cap {
-        Some(it) => it,
-        None => return,
-    };
-    snippet(
-        ctx,
-        cap,
-        "Test module",
-        "\
-#[cfg(test)]
-mod tests {
-    use super::*;
-    #[test]
-    fn ${1:test_name}() {
-        $0
-    }
-}",
-    )
-    .lookup_by("tmod")
-    .add_to(acc);
-    snippet(
-        ctx,
-        cap,
-        "Test function",
-        "\
-#[test]
-fn ${1:feature}() {
-    $0
-}",
-    )
-    .lookup_by("tfn")
-    .add_to(acc);
-    snippet(ctx, cap, "macro_rules", "macro_rules! $1 {\n\t($2) => {\n\t\t$0\n\t};\n}").add_to(acc);
-    snippet(ctx, cap, "pub(crate)", "pub(crate) $0").add_to(acc);
-}
-#[cfg(test)]
-mod tests {
-    use expect::{expect, Expect};
-    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() {
-        check(
-            r#"fn foo(x: i32) { <|> }"#,
-            expect![[r#"
-                sn pd
-                sn ppd
-            "#]],
-        );
-    }
-    #[test]
-    fn should_not_complete_snippets_in_path() {
-        check(r#"fn foo(x: i32) { ::foo<|> }"#, expect![[""]]);
-        check(r#"fn foo(x: i32) { ::<|> }"#, expect![[""]]);
-    }
-    #[test]
-    fn completes_snippets_in_items() {
-        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
deleted file mode 100644
index d9a0ef167..000000000
--- a/crates/ra_ide/src/completion/complete_trait_impl.rs
+++ /dev/null
@@ -1,488 +0,0 @@
-//! Completion for associated items in a trait implementation.
-//!
-//! 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`, `TYPE_ALIAS`, or `CONST` node
-//! and an direct child of an `IMPL`.
-//!
-//! # Examples
-//!
-//! Considering the following trait `impl`:
-//!
-//! ```ignore
-//! trait SomeTrait {
-//!     fn foo();
-//! }
-//!
-//! impl SomeTrait for () {
-//!     fn f<|>
-//! }
-//! ```
-//!
-//! may result in the completion of the following method:
-//!
-//! ```ignore
-//! # trait SomeTrait {
-//! #    fn foo();
-//! # }
-//!
-//! impl SomeTrait for () {
-//!     fn foo() {}<|>
-//! }
-//! ```
-use hir::{self, Docs, HasSource};
-use ra_assists::utils::get_missing_assoc_items;
-use ra_syntax::{
-    ast::{self, edit, Impl},
-    AstNode, SyntaxKind, SyntaxNode, TextRange, T,
-};
-use ra_text_edit::TextEdit;
-use crate::{
-    completion::{
-        CompletionContext, CompletionItem, CompletionItemKind, CompletionKind, Completions,
-    },
-    display::function_declaration,
-};
-pub(crate) fn complete_trait_impl(acc: &mut Completions, ctx: &CompletionContext) {
-    if let Some((trigger, impl_def)) = completion_match(ctx) {
-        match trigger.kind() {
-            SyntaxKind::NAME_REF => get_missing_assoc_items(&ctx.sema, &impl_def)
-                .into_iter()
-                .for_each(|item| match item {
-                    hir::AssocItem::Function(fn_item) => {
-                        add_function_impl(&trigger, acc, ctx, fn_item)
-                    }
-                    hir::AssocItem::TypeAlias(type_item) => {
-                        add_type_alias_impl(&trigger, acc, ctx, type_item)
-                    }
-                    hir::AssocItem::Const(const_item) => {
-                        add_const_impl(&trigger, acc, ctx, const_item)
-                    }
-                }),
-            SyntaxKind::FN => {
-                for missing_fn in get_missing_assoc_items(&ctx.sema, &impl_def)
-                    .into_iter()
-                    .filter_map(|item| match item {
-                        hir::AssocItem::Function(fn_item) => Some(fn_item),
-                        _ => None,
-                    })
-                {
-                    add_function_impl(&trigger, acc, ctx, missing_fn);
-                }
-            }
-            SyntaxKind::TYPE_ALIAS => {
-                for missing_fn in get_missing_assoc_items(&ctx.sema, &impl_def)
-                    .into_iter()
-                    .filter_map(|item| match item {
-                        hir::AssocItem::TypeAlias(type_item) => Some(type_item),
-                        _ => None,
-                    })
-                {
-                    add_type_alias_impl(&trigger, acc, ctx, missing_fn);
-                }
-            }
-            SyntaxKind::CONST => {
-                for missing_fn in get_missing_assoc_items(&ctx.sema, &impl_def)
-                    .into_iter()
-                    .filter_map(|item| match item {
-                        hir::AssocItem::Const(const_item) => Some(const_item),
-                        _ => None,
-                    })
-                {
-                    add_const_impl(&trigger, acc, ctx, missing_fn);
-                }
-            }
-            _ => {}
-        }
-    }
-}
-fn completion_match(ctx: &CompletionContext) -> Option<(SyntaxNode, Impl)> {
-    let (trigger, impl_def_offset) = ctx.token.ancestors().find_map(|p| match p.kind() {
-        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::Impl::cast)?;
-    Some((trigger, impl_def))
-}
-fn add_function_impl(
-    fn_def_node: &SyntaxNode,
-    acc: &mut Completions,
-    ctx: &CompletionContext,
-    func: hir::Function,
-) {
-    let fn_name = func.name(ctx.db).to_string();
-    let label = if !func.params(ctx.db).is_empty() {
-        format!("fn {}(..)", fn_name)
-    } else {
-        format!("fn {}()", fn_name)
-    };
-    let builder = CompletionItem::new(CompletionKind::Magic, ctx.source_range(), label)
-        .lookup_by(fn_name)
-        .set_documentation(func.docs(ctx.db));
-    let completion_kind = if func.has_self_param(ctx.db) {
-        CompletionItemKind::Method
-    } else {
-        CompletionItemKind::Function
-    };
-    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}}", function_decl);
-            builder.snippet_edit(cap, TextEdit::replace(range, snippet))
-        }
-        None => {
-            let header = format!("{} {{", function_decl);
-            builder.text_edit(TextEdit::replace(range, header))
-        }
-    }
-    .kind(completion_kind)
-    .add_to(acc);
-}
-fn add_type_alias_impl(
-    type_def_node: &SyntaxNode,
-    acc: &mut Completions,
-    ctx: &CompletionContext,
-    type_alias: hir::TypeAlias,
-) {
-    let alias_name = type_alias.name(ctx.db).to_string();
-    let snippet = format!("type {} = ", alias_name);
-    let range = TextRange::new(type_def_node.text_range().start(), ctx.source_range().end());
-    CompletionItem::new(CompletionKind::Magic, ctx.source_range(), snippet.clone())
-        .text_edit(TextEdit::replace(range, snippet))
-        .lookup_by(alias_name)
-        .kind(CompletionItemKind::TypeAlias)
-        .set_documentation(type_alias.docs(ctx.db))
-        .add_to(acc);
-}
-fn add_const_impl(
-    const_def_node: &SyntaxNode,
-    acc: &mut Completions,
-    ctx: &CompletionContext,
-    const_: hir::Const,
-) {
-    let const_name = const_.name(ctx.db).map(|n| n.to_string());
-    if let Some(const_name) = const_name {
-        let snippet = make_const_compl_syntax(&const_.source(ctx.db).value);
-        let range = TextRange::new(const_def_node.text_range().start(), ctx.source_range().end());
-        CompletionItem::new(CompletionKind::Magic, ctx.source_range(), snippet.clone())
-            .text_edit(TextEdit::replace(range, snippet))
-            .lookup_by(const_name)
-            .kind(CompletionItemKind::Const)
-            .set_documentation(const_.docs(ctx.db))
-            .add_to(acc);
-    }
-}
-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();
-    let const_end = const_.syntax().text_range().end();
-    let start =
-        const_.syntax().first_child_or_token().map_or(const_start, |f| f.text_range().start());
-    let end = const_
-        .syntax()
-        .children_with_tokens()
-        .find(|s| s.kind() == T![;] || s.kind() == T![=])
-        .map_or(const_end, |f| f.text_range().start());
-    let len = end - start;
-    let range = TextRange::new(0.into(), len);
-    let syntax = const_.syntax().text().slice(range).to_string();
-    format!("{} = ", syntax.trim_end())
-}
-#[cfg(test)]
-mod tests {
-    use expect::{expect, Expect};
-    use crate::completion::{
-        test_utils::{check_edit, completion_list},
-        CompletionKind,
-    };
-    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() {
-        check(
-            r#"
-trait Test {
-    type TestType;
-    const TEST_CONST: u16;
-    fn test();
-}
-struct T;
-impl Test for T {
-    t<|>
-}
-"#,
-            expect![["
-ct const TEST_CONST: u16 = \n\
-fn fn test()
-ta type TestType = \n\
-            "]],
-        );
-    }
-    #[test]
-    fn no_nested_fn_completions() {
-        check(
-            r"
-trait Test {
-    fn test();
-    fn test2();
-}
-struct T;
-impl Test for T {
-    fn test() {
-        t<|>
-    }
-}
-",
-            expect![[""]],
-        );
-    }
-    #[test]
-    fn name_ref_single_function() {
-        check_edit(
-            "test",
-            r#"
-trait Test {
-    fn test();
-}
-struct T;
-impl Test for T {
-    t<|>
-}
-"#,
-            r#"
-trait Test {
-    fn test();
-}
-struct T;
-impl Test for T {
-    fn test() {
-    $0
-}
-}
-"#,
-        );
-    }
-    #[test]
-    fn single_function() {
-        check_edit(
-            "test",
-            r#"
-trait Test {
-    fn test();
-}
-struct T;
-impl Test for T {
-    fn t<|>
-}
-"#,
-            r#"
-trait Test {
-    fn test();
-}
-struct T;
-impl Test for T {
-    fn test() {
-    $0
-}
-}
-"#,
-        );
-    }
-    #[test]
-    fn hide_implemented_fn() {
-        check(
-            r#"
-trait Test {
-    fn foo();
-    fn foo_bar();
-}
-struct T;
-impl Test for T {
-    fn foo() {}
-    fn f<|>
-}
-"#,
-            expect![[r#"
-                fn fn foo_bar()
-            "#]],
-        );
-    }
-    #[test]
-    fn generic_fn() {
-        check_edit(
-            "foo",
-            r#"
-trait Test {
-    fn foo<T>();
-}
-struct T;
-impl Test for T {
-    fn f<|>
-}
-"#,
-            r#"
-trait Test {
-    fn foo<T>();
-}
-struct T;
-impl Test for T {
-    fn foo<T>() {
-    $0
-}
-}
-"#,
-        );
-        check_edit(
-            "foo",
-            r#"
-trait Test {
-    fn foo<T>() where T: Into<String>;
-}
-struct T;
-impl Test for T {
-    fn f<|>
-}
-"#,
-            r#"
-trait Test {
-    fn foo<T>() where T: Into<String>;
-}
-struct T;
-impl Test for T {
-    fn foo<T>()
-where T: Into<String> {
-    $0
-}
-}
-"#,
-        );
-    }
-    #[test]
-    fn associated_type() {
-        check_edit(
-            "SomeType",
-            r#"
-trait Test {
-    type SomeType;
-}
-impl Test for () {
-    type S<|>
-}
-"#,
-            "
-trait Test {
-    type SomeType;
-}
-impl Test for () {
-    type SomeType = \n\
-}
-",
-        );
-    }
-    #[test]
-    fn associated_const() {
-        check_edit(
-            "SOME_CONST",
-            r#"
-trait Test {
-    const SOME_CONST: u16;
-}
-impl Test for () {
-    const S<|>
-}
-"#,
-            "
-trait Test {
-    const SOME_CONST: u16;
-}
-impl Test for () {
-    const SOME_CONST: u16 = \n\
-}
-",
-        );
-        check_edit(
-            "SOME_CONST",
-            r#"
-trait Test {
-    const SOME_CONST: u16 = 92;
-}
-impl Test for () {
-    const S<|>
-}
-"#,
-            "
-trait Test {
-    const SOME_CONST: u16 = 92;
-}
-impl Test for () {
-    const SOME_CONST: u16 = \n\
-}
-",
-        );
-    }
-}
diff --git a/crates/ra_ide/src/completion/complete_unqualified_path.rs b/crates/ra_ide/src/completion/complete_unqualified_path.rs
deleted file mode 100644
index bd9551f35..000000000
--- a/crates/ra_ide/src/completion/complete_unqualified_path.rs
+++ /dev/null
@@ -1,658 +0,0 @@
-//! Completion of names from the current scope, e.g. locals and imported items.
-use hir::{Adt, ModuleDef, ScopeDef, Type};
-use ra_syntax::AstNode;
-use test_utils::mark;
-use crate::completion::{CompletionContext, Completions};
-pub(super) fn complete_unqualified_path(acc: &mut Completions, ctx: &CompletionContext) {
-    if !(ctx.is_trivial_path || ctx.is_pat_binding_or_const) {
-        return;
-    }
-    if ctx.record_lit_syntax.is_some()
-        || ctx.record_pat_syntax.is_some()
-        || ctx.attribute_under_caret.is_some()
-    {
-        return;
-    }
-    if let Some(ty) = &ctx.expected_type {
-        complete_enum_variants(acc, ctx, ty);
-    }
-    if ctx.is_pat_binding_or_const {
-        return;
-    }
-    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() {
-                    mark::hit!(self_fulfilling_completion);
-                    return;
-                }
-            }
-        }
-        acc.add_resolution(ctx, name.to_string(), &res)
-    });
-}
-fn complete_enum_variants(acc: &mut Completions, ctx: &CompletionContext, ty: &Type) {
-    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() {
-            // Compute path from the completion site if available.
-            module
-        } else {
-            // Otherwise fall back to the enum's definition site.
-            enum_data.module(ctx.db)
-        };
-        for variant in variants {
-            if let Some(path) = module.find_use_path(ctx.db, ModuleDef::from(variant)) {
-                // Variants with trivial paths are already added by the existing completion logic,
-                // so we should avoid adding these twice
-                if path.segments.len() > 1 {
-                    acc.add_qualified_enum_variant(ctx, variant, path);
-                }
-            }
-        }
-    }
-}
-#[cfg(test)]
-mod tests {
-    use expect::{expect, Expect};
-    use test_utils::mark;
-    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)
-    }
-    #[test]
-    fn self_fulfilling_completion() {
-        mark::check!(self_fulfilling_completion);
-        check(
-            r#"
-use foo<|>
-use std::collections;
-"#,
-            expect![[r#"
-                ?? collections
-            "#]],
-        );
-    }
-    #[test]
-    fn bind_pat_and_path_ignore_at() {
-        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() {
-        check(
-            r#"
-enum Enum { A, B }
-fn quux(x: Option<Enum>) {
-    match x {
-        None => (),
-        Some(ref en<|>) => (),
-    }
-}
-"#,
-            expect![[""]],
-        );
-    }
-    #[test]
-    fn bind_pat_and_path() {
-        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() {
-        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() {
-        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() {
-        check(
-            r#"
-fn quux() {
-    for x in &[1, 2, 3] { <|> }
-}
-"#,
-            expect![[r#"
-                fn quux() fn quux()
-                bn x
-            "#]],
-        );
-    }
-    #[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() {
-        check(
-            r#"fn quux<T>() { <|> }"#,
-            expect![[r#"
-                tp T
-                fn quux() fn quux<T>()
-            "#]],
-        );
-    }
-    #[test]
-    fn completes_generic_params_in_struct() {
-        check(
-            r#"struct S<T> { x: <|>}"#,
-            expect![[r#"
-                st S<…>
-                tp Self
-                tp T
-            "#]],
-        );
-    }
-    #[test]
-    fn completes_self_in_enum() {
-        check(
-            r#"enum X { Y(<|>) }"#,
-            expect![[r#"
-                tp Self
-                en X
-            "#]],
-        );
-    }
-    #[test]
-    fn completes_module_items() {
-        check(
-            r#"
-struct S;
-enum E {}
-fn quux() { <|> }
-"#,
-            expect![[r#"
-                en E
-                st S
-                fn quux() fn quux()
-            "#]],
-        );
-    }
-    #[test]
-    fn completes_extern_prelude() {
-        check(
-            r#"
-//- /lib.rs
-use <|>;
-//- /other_crate/lib.rs
-// nothing here
-"#,
-            expect![[r#"
-                md other_crate
-            "#]],
-        );
-    }
-    #[test]
-    fn completes_module_items_in_nested_modules() {
-        check(
-            r#"
-struct Foo;
-mod m {
-    struct Bar;
-    fn quux() { <|> }
-}
-"#,
-            expect![[r#"
-                st Bar
-                fn quux() fn quux()
-            "#]],
-        );
-    }
-    #[test]
-    fn completes_return_type() {
-        check(
-            r#"
-struct Foo;
-fn x() -> <|>
-"#,
-            expect![[r#"
-                st Foo
-                fn x() fn x()
-            "#]],
-        );
-    }
-    #[test]
-    fn dont_show_both_completions_for_shadowing() {
-        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() {
-        check(
-            r#"impl S { fn foo(&self) { <|> } }"#,
-            expect![[r#"
-                tp Self
-                bn self &{unknown}
-            "#]],
-        );
-    }
-    #[test]
-    fn completes_prelude() {
-        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() {
-        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() {
-        check(
-            r#"
-macro_rules! foo { () => {} }
-#[macro_use]
-mod m1 {
-    macro_rules! bar { () => {} }
-}
-mod m2 {
-    macro_rules! nope { () => {} }
-    #[macro_export]
-    macro_rules! baz { () => {} }
-}
-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() {
-        check(
-            r#"
-macro_rules! foo { () => {} }
-fn foo() { <|> }
-"#,
-            expect![[r#"
-                ma foo!(…) macro_rules! foo
-                fn foo()   fn foo()
-            "#]],
-        );
-    }
-    #[test]
-    fn completes_macros_as_type() {
-        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() {
-        check(
-            r#"
-macro_rules! foo { () => {} }
-fn main() { <|> }
-"#,
-            expect![[r#"
-                ma foo!(…) macro_rules! foo
-                fn main()  fn main()
-            "#]],
-        );
-    }
-    #[test]
-    fn completes_local_item() {
-        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() {
-        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() {
-        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
-            "#]],
-        );
-    }
-    #[test]
-    fn completes_in_simple_macro_without_closing_parens() {
-        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
-            "#]],
-        );
-    }
-    #[test]
-    fn completes_unresolved_uses() {
-        check(
-            r#"
-use spam::Quux;
-fn main() { <|> }
-"#,
-            expect![[r#"
-                ?? Quux
-                fn main() fn main()
-            "#]],
-        );
-    }
-    #[test]
-    fn completes_enum_variant_matcharm() {
-        check(
-            r#"
-enum Foo { Bar, Baz, Quux }
-fn main() {
-    let foo = Foo::Quux;
-    match foo { Qu<|> }
-}
-"#,
-            expect![[r#"
-                en Foo
-                ev Foo::Bar  ()
-                ev Foo::Baz  ()
-                ev Foo::Quux ()
-            "#]],
-        )
-    }
-    #[test]
-    fn completes_enum_variant_iflet() {
-        check(
-            r#"
-enum Foo { Bar, Baz, Quux }
-fn main() {
-    let foo = Foo::Quux;
-    if let Qu<|> = foo { }
-}
-"#,
-            expect![[r#"
-                en Foo
-                ev Foo::Bar  ()
-                ev Foo::Baz  ()
-                ev Foo::Quux ()
-            "#]],
-        )
-    }
-    #[test]
-    fn completes_enum_variant_basic_expr() {
-        check(
-            r#"
-enum Foo { Bar, Baz, Quux }
-fn main() { let foo: Foo = Q<|> }
-"#,
-            expect![[r#"
-                en Foo
-                ev Foo::Bar  ()
-                ev Foo::Baz  ()
-                ev Foo::Quux ()
-                fn main()    fn main()
-            "#]],
-        )
-    }
-    #[test]
-    fn completes_enum_variant_from_module() {
-        check(
-            r#"
-mod m { pub enum E { V } }
-fn f() -> m::E { V<|> }
-"#,
-            expect![[r#"
-                fn f()     fn f() -> m::E
-                md m
-                ev m::E::V ()
-            "#]],
-        )
-    }
-    #[test]
-    fn dont_complete_attr() {
-        check(
-            r#"
-struct Foo;
-#[<|>]
-fn f() {}
-"#,
-            expect![[""]],
-        )
-    }
-    #[test]
-    fn completes_type_or_trait_in_impl_block() {
-        check(
-            r#"
-trait MyTrait {}
-struct MyStruct {}
-impl My<|>
-"#,
-            expect![[r#"
-                st MyStruct
-                tt MyTrait
-                tp Self
-            "#]],
-        )
-    }
-}
diff --git a/crates/ra_ide/src/completion/completion_config.rs b/crates/ra_ide/src/completion/completion_config.rs
deleted file mode 100644
index 71b49ace8..000000000
--- a/crates/ra_ide/src/completion/completion_config.rs
+++ /dev/null
@@ -1,35 +0,0 @@
-//! Settings for tweaking completion.
-//!
-//! The fun thing here is `SnippetCap` -- this type can only be created in this
-//! module, and we use to statically check that we only produce snippet
-//! completions if we are allowed to.
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct CompletionConfig {
-    pub enable_postfix_completions: bool,
-    pub add_call_parenthesis: bool,
-    pub add_call_argument_snippets: bool,
-    pub snippet_cap: Option<SnippetCap>,
-}
-impl CompletionConfig {
-    pub fn allow_snippets(&mut self, yes: bool) {
-        self.snippet_cap = if yes { Some(SnippetCap { _private: () }) } else { None }
-    }
-}
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct SnippetCap {
-    _private: (),
-}
-impl Default for CompletionConfig {
-    fn default() -> Self {
-        CompletionConfig {
-            enable_postfix_completions: true,
-            add_call_parenthesis: true,
-            add_call_argument_snippets: true,
-            snippet_cap: Some(SnippetCap { _private: () }),
-        }
-    }
-}
diff --git a/crates/ra_ide/src/completion/completion_context.rs b/crates/ra_ide/src/completion/completion_context.rs
deleted file mode 100644
index 6b03b30bb..000000000
--- a/crates/ra_ide/src/completion/completion_context.rs
+++ /dev/null
@@ -1,465 +0,0 @@
-//! FIXME: write short doc here
-use hir::{Semantics, SemanticsScope, Type};
-use ra_db::SourceDatabase;
-use ra_ide_db::RootDatabase;
-use ra_syntax::{
-    algo::{find_covering_element, find_node_at_offset},
-    ast, match_ast, AstNode, NodeOrToken,
-    SyntaxKind::*,
-    SyntaxNode, SyntaxToken, TextRange, TextSize,
-};
-use ra_text_edit::Indel;
-use super::patterns::{
-    has_bind_pat_parent, has_block_expr_parent, has_impl_as_prev_sibling, has_impl_