Extract call_info and completion into separate crates

28 files changed, 11 insertions, 9244 deletions

diff --git a/crates/ide/Cargo.toml b/crates/ide/Cargo.toml
index 29dc9a6a8..63299dc31 100644
--- a/crates/ide/Cargo.toml
+++ b/crates/ide/Cargo.toml
@@ -30,6 +30,8 @@ profile = { path = "../profile", version = "0.0.0" }
 test_utils = { path = "../test_utils", version = "0.0.0" }
 assists = { path = "../assists", version = "0.0.0" }
 ssr = { path = "../ssr", version = "0.0.0" }
+call_info = { path = "../call_info", version = "0.0.0" }
+completion = { path = "../completion", version = "0.0.0" }
 
 # ide should depend only on the top-level `hir` package. if you need
 # something from some `hir_xxx` subpackage, reexport the API via `hir`.
diff --git a/crates/ide/src/call_hierarchy.rs b/crates/ide/src/call_hierarchy.rs
index d2cf2cc7d..9d6433fe0 100644
--- a/crates/ide/src/call_hierarchy.rs
+++ b/crates/ide/src/call_hierarchy.rs
@@ -2,13 +2,13 @@
 
 use indexmap::IndexMap;
 
+use call_info::FnCallNode;
 use hir::Semantics;
 use ide_db::RootDatabase;
 use syntax::{ast, match_ast, AstNode, TextRange};
 
 use crate::{
-    call_info::FnCallNode, display::ToNav, goto_definition, references, FilePosition,
-    NavigationTarget, RangeInfo,
+    display::ToNav, goto_definition, references, FilePosition, NavigationTarget, RangeInfo,
 };
 
 #[derive(Debug, Clone)]
diff --git a/crates/ide/src/call_info.rs b/crates/ide/src/call_info.rs
deleted file mode 100644
index d7b2b926e..000000000
--- a/crates/ide/src/call_info.rs
+++ /dev/null
@@ -1,742 +0,0 @@
-//! FIXME: write short doc here
-use either::Either;
-use hir::{HasAttrs, HirDisplay, Semantics, Type};
-use ide_db::RootDatabase;
-use stdx::format_to;
-use syntax::{
-    ast::{self, ArgListOwner},
-    match_ast, AstNode, SyntaxNode, SyntaxToken, TextRange, TextSize,
-};
-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_test::{expect, Expect};
-    use test_utils::mark;
-
-    use crate::fixture;
-
-    fn check(ra_fixture: &str, expect: Expect) {
-        let (analysis, position) = fixture::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/ide/src/completion.rs b/crates/ide/src/completion.rs
deleted file mode 100644
index 69e875014..000000000
--- a/crates/ide/src/completion.rs
+++ /dev/null
@@ -1,260 +0,0 @@
-mod completion_config;
-mod completion_item;
-mod completion_context;
-mod presentation;
-mod patterns;
-mod generated_features;
-#[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 complete_mod;
-
-use ide_db::RootDatabase;
-
-use crate::{
-    completion::{
-        completion_context::CompletionContext,
-        completion_item::{CompletionKind, Completions},
-    },
-    FilePosition,
-};
-
-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)`
-// - `expr.dbgr` -> `dbg!(&expr)`
-// - `expr.call` -> `(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)?;
-
-    if ctx.no_completion_required() {
-        // No work required here.
-        return None;
-    }
-
-    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);
-    complete_mod::complete_mod(&mut acc, &ctx);
-
-    Some(acc)
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::completion::completion_config::CompletionConfig;
-    use crate::fixture;
-
-    struct DetailAndDocumentation<'a> {
-        detail: &'a str,
-        documentation: &'a str,
-    }
-
-    fn check_detail_and_documentation(ra_fixture: &str, expected: DetailAndDocumentation) {
-        let (analysis, position) = fixture::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)
-    }
-
-    fn check_no_completion(ra_fixture: &str) {
-        let (analysis, position) = fixture::position(ra_fixture);
-        let config = CompletionConfig::default();
-        analysis.completions(&config, position).unwrap();
-
-        let completions: Option<Vec<String>> = analysis
-            .completions(&config, position)
-            .unwrap()
-            .and_then(|completions| if completions.is_empty() { None } else { Some(completions) })
-            .map(|completions| {
-                completions.into_iter().map(|completion| format!("{:?}", completion)).collect()
-            });
-
-        // `assert_eq` instead of `assert!(completions.is_none())` to get the list of completions if test will panic.
-        assert_eq!(completions, None, "Completions were generated, but weren't expected");
-    }
-
-    #[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" },
-        );
-    }
-
-    #[test]
-    fn test_no_completions_required() {
-        // There must be no hint for 'in' keyword.
-        check_no_completion(
-            r#"
-            fn foo() {
-                for i i<|>
-            }
-            "#,
-        );
-        // After 'in' keyword hints may be spawned.
-        check_detail_and_documentation(
-            r#"
-            /// Do the foo
-            fn foo() -> &'static str { "foo" }
-
-            fn bar() {
-                for c in fo<|>
-            }
-            "#,
-            DetailAndDocumentation {
-                detail: "fn foo() -> &'static str",
-                documentation: "Do the foo",
-            },
-        );
-    }
-}
diff --git a/crates/ide/src/completion/complete_attribute.rs b/crates/ide/src/completion/complete_attribute.rs
deleted file mode 100644
index f4a9864d1..000000000
--- a/crates/ide/src/completion/complete_attribute.rs
+++ /dev/null
@@ -1,657 +0,0 @@
-//! Completion for attributes
-//!
-//! This module uses a bit of static metadata to provide completions
-//! for built-in attributes.
-
-use rustc_hash::FxHashSet;
-use syntax::{ast, AstNode, SyntaxKind};
-
-use crate::completion::{
-    completion_context::CompletionContext,
-    completion_item::{CompletionItem, CompletionItemKind, CompletionKind, Completions},
-    generated_features::FEATURES,
-};
-
-pub(super) fn complete_attribute(acc: &mut Completions, ctx: &CompletionContext) -> Option<()> {
-    if ctx.mod_declaration_under_caret.is_some() {
-        return None;
-    }
-
-    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, FEATURES)
-        }
-        (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:flag})")).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(super) struct LintCompletion {
-    pub(super) label: &'static str,
-    pub(super) 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_test::{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/ide/src/completion/complete_dot.rs b/crates/ide/src/completion/complete_dot.rs
deleted file mode 100644
index f0f9a7f1d..000000000
--- a/crates/ide/src/completion/complete_dot.rs
+++ /dev/null
@@ -1,431 +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.self_param(ctx.db).is_some()
-                && 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_test::{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)
-            "#]],
-        );
-    }
-
-    #[test]
-    fn completes_method_call_when_receiver_is_a_macro_call() {
-        check(
-            r#"
-struct S;
-impl S { fn foo(&self) {} }
-macro_rules! make_s { () => { S }; }
-fn main() { make_s!().f<|>; }
-"#,
-            expect![[r#"
-                me foo() fn foo(&self)
-            "#]],
-        )
-    }
-}
diff --git a/crates/ide/src/completion/complete_fn_param.rs b/crates/ide/src/completion/complete_fn_param.rs
deleted file mode 100644
index 9efe25461..000000000
--- a/crates/ide/src/completion/complete_fn_param.rs
+++ /dev/null
@@ -1,135 +0,0 @@
-//! See `complete_fn_param`.
-
-use rustc_hash::FxHashMap;
-use syntax::{
-    ast::{self, ModuleItemOwner},
-    match_ast, AstNode,
-};
-
-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_test::{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/ide/src/completion/complete_keyword.rs b/crates/ide/src/completion/complete_keyword.rs
deleted file mode 100644
index e59747095..000000000
--- a/crates/ide/src/completion/complete_keyword.rs
+++ /dev/null
@@ -1,568 +0,0 @@
-//! FIXME: write short doc here
-
-use 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();
-
-    if ctx.use_item_syntax.is_some() {
-        if ctx.path_qual.is_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);
-    }
-
-    // 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 | ctx.has_field_list_parent {
-        add_keyword(ctx, acc, "pub(crate)", "pub(crate) ");
-        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_test::{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 pub(crate)
-                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 pub(crate)
-                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 crate:main deps:std
-use std::future::*;
-struct A {}
-impl Future for A {}
-fn foo(a: A) { a.<|> }
-
-//- /std/lib.rs crate:std
-pub mod future {
-    #[lang = "future_trait"]
-    pub trait Future {}
-}
-"#,
-            expect![[r#"
-                kw await expr.await
-            "#]],
-        );
-
-        check(
-            r#"
-//- /main.rs crate:main deps:std
-use std::future::*;
-fn foo() {
-    let a = async {};
-    a.<|>
-}
-
-//- /std/lib.rs crate:std
-pub mod future {
-    #[lang = "future_trait"]
-    pub trait Future {
-        type Output;
-    }
-}
-"#,
-            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
-            "#]],
-        )
-    }
-
-    #[test]
-    fn before_field() {
-        check(
-            r#"
-struct Foo {
-    <|>
-    pub f: i32,
-}
-"#,
-            expect![[r#"
-                kw pub
-                kw pub(crate)
-            "#]],
-        )
-    }
-}
diff --git a/crates/ide/src/completion/complete_macro_in_item_position.rs b/crates/ide/src/completion/complete_macro_in_item_position.rs
deleted file mode 100644
index fc8625d8e..000000000
--- a/crates/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_test::{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/ide/src/completion/complete_mod.rs b/crates/ide/src/completion/complete_mod.rs
deleted file mode 100644
index c7a99bdc3..000000000
--- a/crates/ide/src/completion/complete_mod.rs
+++ /dev/null
@@ -1,324 +0,0 @@
-//! Completes mod declarations.
-
-use base_db::{SourceDatabaseExt, VfsPath};
-use hir::{Module, ModuleSource};
-use ide_db::RootDatabase;
-use rustc_hash::FxHashSet;
-
-use crate::{CompletionItem, CompletionItemKind};
-
-use super::{
-    completion_context::CompletionContext, completion_item::CompletionKind,
-    completion_item::Completions,
-};
-
-/// Complete mod declaration, i.e. `mod <|> ;`
-pub(super) fn complete_mod(acc: &mut Completions, ctx: &CompletionContext) -> Option<()> {
-    let mod_under_caret = match &ctx.mod_declaration_under_caret {
-        Some(mod_under_caret) if mod_under_caret.item_list().is_some() => return None,
-        Some(mod_under_caret) => mod_under_caret,
-        None => return None,
-    };
-
-    let _p = profile::span("completion::complete_mod");
-
-    let current_module = ctx.scope.module()?;
-
-    let module_definition_file =
-        current_module.definition_source(ctx.db).file_id.original_file(ctx.db);
-    let source_root = ctx.db.source_root(ctx.db.file_source_root(module_definition_file));
-    let directory_to_look_for_submodules = directory_to_look_for_submodules(
-        current_module,
-        ctx.db,
-        source_root.path_for_file(&module_definition_file)?,
-    )?;
-
-    let existing_mod_declarations = current_module
-        .children(ctx.db)
-        .filter_map(|module| Some(module.name(ctx.db)?.to_string()))
-        .collect::<FxHashSet<_>>();
-
-    let module_declaration_file =
-        current_module.declaration_source(ctx.db).map(|module_declaration_source_file| {
-            module_declaration_source_file.file_id.original_file(ctx.db)
-        });
-
-    source_root
-        .iter()
-        .filter(|submodule_candidate_file| submodule_candidate_file != &module_definition_file)
-        .filter(|submodule_candidate_file| {
-            Some(submodule_candidate_file) != module_declaration_file.as_ref()
-        })
-        .filter_map(|submodule_file| {
-            let submodule_path = source_root.path_for_file(&submodule_file)?;
-            let directory_with_submodule = submodule_path.parent()?;
-            match submodule_path.name_and_extension()? {
-                ("lib", Some("rs")) | ("main", Some("rs")) => None,
-                ("mod", Some("rs")) => {
-                    if directory_with_submodule.parent()? == directory_to_look_for_submodules {
-                        match directory_with_submodule.name_and_extension()? {
-                            (directory_name, None) => Some(directory_name.to_owned()),
-                            _ => None,
-                        }
-                    } else {
-                        None
-                    }
-                }
-                (file_name, Some("rs"))
-                    if directory_with_submodule == directory_to_look_for_submodules =>
-                {
-                    Some(file_name.to_owned())
-                }
-                _ => None,
-            }
-        })
-        .filter(|name| !existing_mod_declarations.contains(name))
-        .for_each(|submodule_name| {
-            let mut label = submodule_name;
-            if mod_under_caret.semicolon_token().is_none() {
-                label.push(';')
-            }
-            acc.add(
-                CompletionItem::new(CompletionKind::Magic, ctx.source_range(), &label)
-                    .kind(CompletionItemKind::Module),
-            )
-        });
-
-    Some(())
-}
-
-fn directory_to_look_for_submodules(
-    module: Module,
-    db: &RootDatabase,
-    module_file_path: &VfsPath,
-) -> Option<VfsPath> {
-    let directory_with_module_path = module_file_path.parent()?;
-    let base_directory = match module_file_path.name_and_extension()? {
-        ("mod", Some("rs")) | ("lib", Some("rs")) | ("main", Some("rs")) => {
-            Some(directory_with_module_path)
-        }
-        (regular_rust_file_name, Some("rs")) => {
-            if matches!(
-                (
-                    directory_with_module_path
-                        .parent()
-                        .as_ref()
-                        .and_then(|path| path.name_and_extension()),
-                    directory_with_module_path.name_and_extension(),
-                ),
-                (Some(("src", None)), Some(("bin", None)))
-            ) {
-                // files in /src/bin/ can import each other directly
-                Some(directory_with_module_path)
-            } else {
-                directory_with_module_path.join(regular_rust_file_name)
-            }
-        }
-        _ => None,
-    }?;
-
-    let mut resulting_path = base_directory;
-    for module in module_chain_to_containing_module_file(module, db) {
-        if let Some(name) = module.name(db) {
-            resulting_path = resulting_path.join(&name.to_string())?;
-        }
-    }
-
-    Some(resulting_path)
-}
-
-fn module_chain_to_containing_module_file(
-    current_module: Module,
-    db: &RootDatabase,
-) -> Vec<Module> {
-    let mut path = Vec::new();
-
-    let mut current_module = Some(current_module);
-    while let Some(ModuleSource::Module(_)) =
-        current_module.map(|module| module.definition_source(db).value)
-    {
-        if let Some(module) = current_module {
-            path.insert(0, module);
-            current_module = module.parent(db);
-        } else {
-            current_module = None;
-        }
-    }
-
-    path
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::completion::{test_utils::completion_list, CompletionKind};
-    use expect_test::{expect, Expect};
-
-    fn check(ra_fixture: &str, expect: Expect) {
-        let actual = completion_list(ra_fixture, CompletionKind::Magic);
-        expect.assert_eq(&actual);
-    }
-
-    #[test]
-    fn lib_module_completion() {
-        check(
-            r#"
-            //- /lib.rs
-            mod <|>
-            //- /foo.rs
-            fn foo() {}
-            //- /foo/ignored_foo.rs
-            fn ignored_foo() {}
-            //- /bar/mod.rs
-            fn bar() {}
-            //- /bar/ignored_bar.rs
-            fn ignored_bar() {}
-        "#,
-            expect![[r#"
-                md bar;
-                md foo;
-            "#]],
-        );
-    }
-
-    #[test]
-    fn no_module_completion_with_module_body() {
-        check(
-            r#"
-            //- /lib.rs
-            mod <|> {
-
-            }
-            //- /foo.rs
-            fn foo() {}
-        "#,
-            expect![[r#""#]],
-        );
-    }
-
-    #[test]
-    fn main_module_completion() {
-        check(
-            r#"
-            //- /main.rs
-            mod <|>
-            //- /foo.rs
-            fn foo() {}
-            //- /foo/ignored_foo.rs
-            fn ignored_foo() {}
-            //- /bar/mod.rs
-            fn bar() {}
-            //- /bar/ignored_bar.rs
-            fn ignored_bar() {}
-        "#,
-            expect![[r#"
-                md bar;
-                md foo;
-            "#]],
-        );
-    }
-
-    #[test]
-    fn main_test_module_completion() {
-        check(
-            r#"
-            //- /main.rs
-            mod tests {
-                mod <|>;
-            }
-            //- /tests/foo.rs
-            fn foo() {}
-        "#,
-            expect![[r#"
-                md foo
-            "#]],
-        );
-    }
-
-    #[test]
-    fn directly_nested_module_completion() {
-        check(
-            r#"
-            //- /lib.rs
-            mod foo;
-            //- /foo.rs
-            mod <|>;
-            //- /foo/bar.rs
-            fn bar() {}
-            //- /foo/bar/ignored_bar.rs
-            fn ignored_bar() {}
-            //- /foo/baz/mod.rs
-            fn baz() {}
-            //- /foo/moar/ignored_moar.rs
-            fn ignored_moar() {}
-        "#,
-            expect![[r#"
-                md bar
-                md baz
-            "#]],
-        );
-    }
-
-    #[test]
-    fn nested_in_source_module_completion() {
-        check(
-            r#"
-            //- /lib.rs
-            mod foo;
-            //- /foo.rs
-            mod bar {
-                mod <|>
-            }
-            //- /foo/bar/baz.rs
-            fn baz() {}
-        "#,
-            expect![[r#"
-                md baz;
-            "#]],
-        );
-    }
-
-    // FIXME binary modules are not supported in tests properly
-    // Binary modules are a bit special, they allow importing the modules from `/src/bin`
-    // and that's why are good to test two things:
-    // * no cycles are allowed in mod declarations
-    // * no modules from the parent directory are proposed
-    // Unfortunately, binary modules support is in cargo not rustc,
-    // hence the test does not work now
-    //
-    // #[test]
-    // fn regular_bin_module_completion() {
-    //     check(
-    //         r#"
-    //         //- /src/bin.rs
-    //         fn main() {}
-    //         //- /src/bin/foo.rs
-    //         mod <|>
-    //         //- /src/bin/bar.rs
-    //         fn bar() {}
-    //         //- /src/bin/bar/bar_ignored.rs
-    //         fn bar_ignored() {}
-    //     "#,
-    //         expect![[r#"
-    //             md bar;
-    //         "#]],foo
-    //     );
-    // }
-
-    #[test]
-    fn already_declared_bin_module_completion_omitted() {
-        check(
-            r#"
-            //- /src/bin.rs crate:main
-            fn main() {}
-            //- /src/bin/foo.rs
-            mod <|>
-            //- /src/bin/bar.rs
-            mod foo;
-            fn bar() {}
-            //- /src/bin/bar/bar_ignored.rs
-            fn bar_ignored() {}
-        "#,
-            expect![[r#""#]],
-        );
-    }
-}
diff --git a/crates/ide/src/completion/complete_pattern.rs b/crates/ide/src/completion/complete_pattern.rs
deleted file mode 100644
index 5a13574d4..000000000
--- a/crates/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_test::{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/ide/src/completion/complete_postfix.rs b/crates/ide/src/completion/complete_postfix.rs
deleted file mode 100644
index db5319618..000000000
--- a/crates/ide/src/completion/complete_postfix.rs
+++ /dev/null
@@ -1,454 +0,0 @@
-//! FIXME: write short doc here
-
-mod format_like;
-
-use assists::utils::TryEnum;
-use syntax::{
-    ast::{self, AstNode, AstToken},
-    TextRange, TextSize,
-};
-use text_edit::TextEdit;
-
-use self::format_like::add_format_like_completions;
-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, "ok", "Ok(expr)", &format!("Ok({})", 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,
-        "dbgr",
-        "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);
-
-    if let ast::Expr::Literal(literal) = dot_receiver.clone() {
-        if let Some(literal_text) = ast::String::cast(literal.token()) {
-            add_format_like_completions(acc, ctx, &dot_receiver, cap, &literal_text);
-        }
-    }
-}
-
-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_test::{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 dbgr  dbg!(&expr)
-                sn if    if expr {}
-                sn match match expr {}
-                sn not   !expr
-                sn ok    Ok(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 dbgr  dbg!(&expr)
-                sn match match expr {}
-                sn ok    Ok(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 }"#);
-    }
-
-    #[test]
-    fn postfix_completion_for_format_like_strings() {
-        check_edit(
-            "fmt",
-            r#"fn main() { "{some_var:?}".<|> }"#,
-            r#"fn main() { format!("{:?}", some_var) }"#,
-        );
-        check_edit(
-            "panic",
-            r#"fn main() { "Panic with {a}".<|> }"#,
-            r#"fn main() { panic!("Panic with {}", a) }"#,
-        );
-        check_edit(
-            "println",
-            r#"fn main() { "{ 2+2 } { SomeStruct { val: 1, other: 32 } :?}".<|> }"#,
-            r#"fn main() { println!("{} {:?}", 2+2, SomeStruct { val: 1, other: 32 }) }"#,
-        );
-        check_edit(
-            "loge",
-            r#"fn main() { "{2+2}".<|> }"#,
-            r#"fn main() { log::error!("{}", 2+2) }"#,
-        );
-        check_edit(
-            "logt",
-            r#"fn main() { "{2+2}".<|> }"#,
-            r#"fn main() { log::trace!("{}", 2+2) }"#,
-        );
-        check_edit(
-            "logd",
-            r#"fn main() { "{2+2}".<|> }"#,
-            r#"fn main() { log::debug!("{}", 2+2) }"#,
-        );
-        check_edit(
-            "logi",
-            r#"fn main() { "{2+2}".<|> }"#,
-            r#"fn main() { log::info!("{}", 2+2) }"#,
-        );
-        check_edit(
-            "logw",
-            r#"fn main() { "{2+2}".<|> }"#,
-            r#"fn main() { log::warn!("{}", 2+2) }"#,
-        );
-        check_edit(
-            "loge",
-            r#"fn main() { "{2+2}".<|> }"#,
-            r#"fn main() { log::error!("{}", 2+2) }"#,
-        );
-    }
-}
diff --git a/crates/ide/src/completion/complete_postfix/format_like.rs b/crates/ide/src/completion/complete_postfix/format_like.rs
deleted file mode 100644
index 50d1e5c81..000000000
--- a/crates/ide/src/completion/complete_postfix/format_like.rs
+++ /dev/null
@@ -1,279 +0,0 @@
-// Feature: Format String Completion.
-//
-// `"Result {result} is {2 + 2}"` is expanded to the `"Result {} is {}", result, 2 + 2`.
-//
-// The following postfix snippets are available:
-//
-// - `format` -> `format!(...)`
-// - `panic` -> `panic!(...)`
-// - `println` -> `println!(...)`
-// - `log`:
-//   + `logd` -> `log::debug!(...)`
-//   + `logt` -> `log::trace!(...)`
-//   + `logi` -> `log::info!(...)`
-//   + `logw` -> `log::warn!(...)`
-//   + `loge` -> `log::error!(...)`
-
-use crate::completion::{
-    complete_postfix::postfix_snippet, completion_config::SnippetCap,
-    completion_context::CompletionContext, completion_item::Completions,
-};
-use syntax::ast::{self, AstToken};
-
-/// Mapping ("postfix completion item" => "macro to use")
-static KINDS: &[(&str, &str)] = &[
-    ("fmt", "format!"),
-    ("panic", "panic!"),
-    ("println", "println!"),
-    ("eprintln", "eprintln!"),
-    ("logd", "log::debug!"),
-    ("logt", "log::trace!"),
-    ("logi", "log::info!"),
-    ("logw", "log::warn!"),
-    ("loge", "log::error!"),
-];
-
-pub(super) fn add_format_like_completions(
-    acc: &mut Completions,
-    ctx: &CompletionContext,
-    dot_receiver: &ast::Expr,
-    cap: SnippetCap,
-    receiver_text: &ast::String,
-) {
-    let input = match string_literal_contents(receiver_text) {
-        // It's not a string literal, do not parse input.
-        Some(input) => input,
-        None => return,
-    };
-
-    let mut parser = FormatStrParser::new(input);
-
-    if parser.parse().is_ok() {
-        for (label, macro_name) in KINDS {
-            let snippet = parser.into_suggestion(macro_name);
-
-            postfix_snippet(ctx, cap, &dot_receiver, label, macro_name, &snippet).add_to(acc);
-        }
-    }
-}
-
-/// Checks whether provided item is a string literal.
-fn string_literal_contents(item: &ast::String) -> Option<String> {
-    let item = item.text();
-    if item.len() >= 2 && item.starts_with("\"") && item.ends_with("\"") {
-        return Some(item[1..item.len() - 1].to_owned());
-    }
-
-    None
-}
-
-/// Parser for a format-like string. It is more allowing in terms of string contents,
-/// as we expect variable placeholders to be filled with expressions.
-#[derive(Debug)]
-pub struct FormatStrParser {
-    input: String,
-    output: String,
-    extracted_expressions: Vec<String>,
-    state: State,
-    parsed: bool,
-}
-
-#[derive(Debug, Clone, Copy, PartialEq)]
-enum State {
-    NotExpr,
-    MaybeExpr,
-    Expr,
-    MaybeIncorrect,
-    FormatOpts,
-}
-
-impl FormatStrParser {
-    pub fn new(input: String) -> Self {
-        Self {
-            input: input.into(),
-            output: String::new(),
-            extracted_expressions: Vec::new(),
-            state: State::NotExpr,
-            parsed: false,
-        }
-    }
-
-    pub fn parse(&mut self) -> Result<(), ()> {
-        let mut current_expr = String::new();
-
-        let mut placeholder_id = 1;
-
-        // Count of open braces inside of an expression.
-        // We assume that user knows what they're doing, thus we treat it like a correct pattern, e.g.
-        // "{MyStruct { val_a: 0, val_b: 1 }}".
-        let mut inexpr_open_count = 0;
-
-        for chr in self.input.chars() {
-            match (self.state, chr) {
-                (State::NotExpr, '{') => {
-                    self.output.push(chr);
-                    self.state = State::MaybeExpr;
-                }
-                (State::NotExpr, '}') => {
-                    self.output.push(chr);
-                    self.state = State::MaybeIncorrect;
-                }
-                (State::NotExpr, _) => {
-                    self.output.push(chr);
-                }
-                (State::MaybeIncorrect, '}') => {
-                    // It's okay, we met "}}".
-                    self.output.push(chr);
-                    self.state = State::NotExpr;
-                }
-                (State::MaybeIncorrect, _) => {
-                    // Error in the string.
-                    return Err(());
-                }
-                (State::MaybeExpr, '{') => {
-                    self.output.push(chr);
-                    self.state = State::NotExpr;
-                }
-                (State::MaybeExpr, '}') => {
-                    // This is an empty sequence '{}'. Replace it with placeholder.
-                    self.output.push(chr);
-                    self.extracted_expressions.push(format!("${}", placeholder_id));
-                    placeholder_id += 1;
-                    self.state = State::NotExpr;
-                }
-                (State::MaybeExpr, _) => {
-                    current_expr.push(chr);
-                    self.state = State::Expr;
-                }
-                (State::Expr, '}') => {
-                    if inexpr_open_count == 0 {
-                        self.output.push(chr);
-                        self.extracted_expressions.push(current_expr.trim().into());
-                        current_expr = String::new();
-                        self.state = State::NotExpr;
-                    } else {
-                        // We're closing one brace met before inside of the expression.
-                        current_expr.push(chr);
-                        inexpr_open_count -= 1;
-                    }
-                }
-                (State::Expr, ':') => {
-                    if inexpr_open_count == 0 {
-                        // We're outside of braces, thus assume that it's a specifier, like "{Some(value):?}"
-                        self.output.push(chr);
-                        self.extracted_expressions.push(current_expr.trim().into());
-                        current_expr = String::new();
-                        self.state = State::FormatOpts;
-                    } else {
-                        // We're inside of braced expression, assume that it's a struct field name/value delimeter.
-                        current_expr.push(chr);
-                    }
-                }
-                (State::Expr, '{') => {
-                    current_expr.push(chr);
-                    inexpr_open_count += 1;
-                }
-                (State::Expr, _) => {
-                    current_expr.push(chr);
-                }
-                (State::FormatOpts, '}') => {
-                    self.output.push(chr);
-                    self.state = State::NotExpr;
-                }
-                (State::FormatOpts, _) => {
-                    self.output.push(chr);
-                }
-            }
-        }
-
-        if self.state != State::NotExpr {
-            return Err(());
-        }
-
-        self.parsed = true;
-        Ok(())
-    }
-
-    pub fn into_suggestion(&self, macro_name: &str) -> String {
-        assert!(self.parsed, "Attempt to get a suggestion from not parsed expression");
-
-        let expressions_as_string = self.extracted_expressions.join(", ");
-        format!(r#"{}("{}", {})"#, macro_name, self.output, expressions_as_string)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use expect_test::{expect, Expect};
-
-    fn check(input: &str, expect: &Expect) {
-        let mut parser = FormatStrParser::new((*input).to_owned());
-        let outcome_repr = if parser.parse().is_ok() {
-            // Parsing should be OK, expected repr is "string; expr_1, expr_2".
-            if parser.extracted_expressions.is_empty() {
-                parser.output
-            } else {
-                format!("{}; {}", parser.output, parser.extracted_expressions.join(", "))
-            }
-        } else {
-            // Parsing should fail, expected repr is "-".
-            "-".to_owned()
-        };
-
-        expect.assert_eq(&outcome_repr);
-    }
-
-    #[test]
-    fn format_str_parser() {
-        let test_vector = &[
-            ("no expressions", expect![["no expressions"]]),
-            ("{expr} is {2 + 2}", expect![["{} is {}; expr, 2 + 2"]]),
-            ("{expr:?}", expect![["{:?}; expr"]]),
-            ("{malformed", expect![["-"]]),
-            ("malformed}", expect![["-"]]),
-            ("{{correct", expect![["{{correct"]]),
-            ("correct}}", expect![["correct}}"]]),
-            ("{correct}}}", expect![["{}}}; correct"]]),
-            ("{correct}}}}}", expect![["{}}}}}; correct"]]),
-            ("{incorrect}}", expect![["-"]]),
-            ("placeholders {} {}", expect![["placeholders {} {}; $1, $2"]]),
-            ("mixed {} {2 + 2} {}", expect![["mixed {} {} {}; $1, 2 + 2, $2"]]),
-            (
-                "{SomeStruct { val_a: 0, val_b: 1 }}",
-                expect![["{}; SomeStruct { val_a: 0, val_b: 1 }"]],
-            ),
-            ("{expr:?} is {2.32f64:.5}", expect![["{:?} is {:.5}; expr, 2.32f64"]]),
-            (
-                "{SomeStruct { val_a: 0, val_b: 1 }:?}",
-                expect![["{:?}; SomeStruct { val_a: 0, val_b: 1 }"]],
-            ),
-            ("{     2 + 2        }", expect![["{}; 2 + 2"]]),
-        ];
-
-        for (input, output) in test_vector {
-            check(input, output)
-        }
-    }
-
-    #[test]
-    fn test_into_suggestion() {
-        let test_vector = &[
-            ("println!", "{}", r#"println!("{}", $1)"#),
-            ("eprintln!", "{}", r#"eprintln!("{}", $1)"#),
-            (
-                "log::info!",
-                "{} {expr} {} {2 + 2}",
-                r#"log::info!("{} {} {} {}", $1, expr, $2, 2 + 2)"#,
-            ),
-            ("format!", "{expr:?}", r#"format!("{:?}", expr)"#),
-        ];
-
-        for (kind, input, output) in test_vector {
-            let mut parser = FormatStrParser::new((*input).to_owned());
-            parser.parse().expect("Parsing must succeed");
-
-            assert_eq!(&parser.into_suggestion(*kind), output);
-        }
-    }
-}
diff --git a/crates/ide/src/completion/complete_qualified_path.rs b/crates/ide/src/completion/complete_qualified_path.rs
deleted file mode 100644
index 2fafedd47..000000000
--- a/crates/ide/src/completion/complete_qualified_path.rs
+++ /dev/null
@@ -1,755 +0,0 @@
-//! Completion of paths, i.e. `some::prefix::<|>`.
-