rename ra_ide_api -> ra_ide

60 files changed, 17199 insertions, 0 deletions

diff --git a/crates/ra_ide/Cargo.toml b/crates/ra_ide/Cargo.toml
new file mode 100644
index 000000000..e6383dd35
--- /dev/null
+++ b/crates/ra_ide/Cargo.toml
@@ -0,0 +1,46 @@
+[package]
+edition = "2018"
+name = "ra_ide"
+version = "0.1.0"
+authors = ["rust-analyzer developers"]
+
+[lib]
+doctest = false
+
+[features]
+wasm = []
+
+[dependencies]
+format-buf = "1.0.0"
+itertools = "0.8.0"
+join_to_string = "0.1.3"
+log = "0.4.5"
+rayon = "1.0.2"
+fst = { version = "0.3.1", default-features = false }
+rustc-hash = "1.0"
+unicase = "2.2.0"
+superslice = "1.0.0"
+rand = { version = "0.7.0", features = ["small_rng"] }
+once_cell = "1.2.0"
+
+ra_syntax = { path = "../ra_syntax" }
+ra_text_edit = { path = "../ra_text_edit" }
+ra_db = { path = "../ra_db" }
+ra_cfg = { path = "../ra_cfg" }
+ra_fmt = { path = "../ra_fmt" }
+ra_prof = { path = "../ra_prof" }
+test_utils = { path = "../test_utils" }
+ra_assists = { path = "../ra_assists" }
+
+# ra_ide should depend only on the top-level `hir` package. if you need
+# something from some `hir_xxx` subpackage, reexport the API via `hir`.
+hir = { path = "../ra_hir", package = "ra_hir" }
+
+[dev-dependencies]
+insta = "0.12.0"
+
+[dev-dependencies.proptest]
+version = "0.9.0"
+# Disable `fork` feature to allow compiling on webassembly
+default-features = false
+features = ["std", "bit-set", "break-dead-code"]
diff --git a/crates/ra_ide/src/assists.rs b/crates/ra_ide/src/assists.rs
new file mode 100644
index 000000000..e00589733
--- /dev/null
+++ b/crates/ra_ide/src/assists.rs
@@ -0,0 +1,28 @@
+//! FIXME: write short doc here
+
+use ra_db::{FilePosition, FileRange};
+
+use crate::{db::RootDatabase, SourceChange, SourceFileEdit};
+
+pub use ra_assists::AssistId;
+
+#[derive(Debug)]
+pub struct Assist {
+    pub id: AssistId,
+    pub change: SourceChange,
+}
+
+pub(crate) fn assists(db: &RootDatabase, frange: FileRange) -> Vec<Assist> {
+    ra_assists::assists(db, frange)
+        .into_iter()
+        .map(|(label, action)| {
+            let file_id = frange.file_id;
+            let file_edit = SourceFileEdit { file_id, edit: action.edit };
+            let id = label.id;
+            let change = SourceChange::source_file_edit(label.label, file_edit).with_cursor_opt(
+                action.cursor_position.map(|offset| FilePosition { offset, file_id }),
+            );
+            Assist { id, change }
+        })
+        .collect()
+}
diff --git a/crates/ra_ide/src/call_info.rs b/crates/ra_ide/src/call_info.rs
new file mode 100644
index 000000000..d559dc4d0
--- /dev/null
+++ b/crates/ra_ide/src/call_info.rs
@@ -0,0 +1,592 @@
+//! FIXME: write short doc here
+
+use ra_db::SourceDatabase;
+use ra_syntax::{
+    algo::ancestors_at_offset,
+    ast::{self, ArgListOwner},
+    match_ast, AstNode, SyntaxNode, TextUnit,
+};
+use test_utils::tested_by;
+
+use crate::{db::RootDatabase, CallInfo, FilePosition, FunctionSignature};
+
+/// Computes parameter information for the given call expression.
+pub(crate) fn call_info(db: &RootDatabase, position: FilePosition) -> Option<CallInfo> {
+    let parse = db.parse(position.file_id);
+    let syntax = parse.tree().syntax().clone();
+
+    // Find the calling expression and it's NameRef
+    let calling_node = FnCallNode::with_node(&syntax, position.offset)?;
+    let name_ref = calling_node.name_ref()?;
+    let name_ref = hir::Source::new(position.file_id.into(), name_ref.syntax());
+
+    let analyzer = hir::SourceAnalyzer::new(db, name_ref, None);
+    let (mut call_info, has_self) = match &calling_node {
+        FnCallNode::CallExpr(expr) => {
+            //FIXME: Type::as_callable is broken
+            let callable_def = analyzer.type_of(db, &expr.expr()?)?.as_callable()?;
+            match callable_def {
+                hir::CallableDef::FunctionId(it) => {
+                    let fn_def = it.into();
+                    (CallInfo::with_fn(db, fn_def), fn_def.has_self_param(db))
+                }
+                hir::CallableDef::StructId(it) => (CallInfo::with_struct(db, it.into())?, false),
+                hir::CallableDef::EnumVariantId(it) => {
+                    (CallInfo::with_enum_variant(db, it.into())?, false)
+                }
+            }
+        }
+        FnCallNode::MethodCallExpr(expr) => {
+            let function = analyzer.resolve_method_call(&expr)?;
+            (CallInfo::with_fn(db, function), function.has_self_param(db))
+        }
+        FnCallNode::MacroCallExpr(expr) => {
+            let macro_def = analyzer.resolve_macro_call(db, name_ref.with_value(&expr))?;
+            (CallInfo::with_macro(db, macro_def)?, false)
+        }
+    };
+
+    // If we have a calling expression let's find which argument we are on
+    let num_params = call_info.parameters().len();
+
+    if num_params == 1 {
+        if !has_self {
+            call_info.active_parameter = Some(0);
+        }
+    } else if num_params > 1 {
+        // Count how many parameters into the call we are.
+        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(position.offset) {
+                tested_by!(call_info_bad_offset);
+                return None;
+            }
+
+            let mut param = std::cmp::min(
+                num_args_at_callsite,
+                arg_list
+                    .args()
+                    .take_while(|arg| arg.syntax().text_range().end() < position.offset)
+                    .count(),
+            );
+
+            // If we are in a method account for `self`
+            if has_self {
+                param += 1;
+            }
+
+            call_info.active_parameter = Some(param);
+        }
+    }
+
+    Some(call_info)
+}
+
+#[derive(Debug)]
+enum FnCallNode {
+    CallExpr(ast::CallExpr),
+    MethodCallExpr(ast::MethodCallExpr),
+    MacroCallExpr(ast::MacroCall),
+}
+
+impl FnCallNode {
+    fn with_node(syntax: &SyntaxNode, offset: TextUnit) -> Option<FnCallNode> {
+        ancestors_at_offset(syntax, offset).find_map(|node| {
+            match_ast! {
+                match node {
+                    ast::CallExpr(it) => { Some(FnCallNode::CallExpr(it)) },
+                    ast::MethodCallExpr(it) => { Some(FnCallNode::MethodCallExpr(it)) },
+                    ast::MacroCall(it) => { Some(FnCallNode::MacroCallExpr(it)) },
+                    _ => { None },
+                }
+            }
+        })
+    }
+
+    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).nth(0)
+            }
+
+            FnCallNode::MacroCallExpr(call_expr) => call_expr.path()?.segment()?.name_ref(),
+        }
+    }
+
+    fn arg_list(&self) -> Option<ast::ArgList> {
+        match self {
+            FnCallNode::CallExpr(expr) => expr.arg_list(),
+            FnCallNode::MethodCallExpr(expr) => expr.arg_list(),
+            FnCallNode::MacroCallExpr(_) => None,
+        }
+    }
+}
+
+impl CallInfo {
+    fn with_fn(db: &RootDatabase, function: hir::Function) -> Self {
+        let signature = FunctionSignature::from_hir(db, function);
+
+        CallInfo { signature, active_parameter: None }
+    }
+
+    fn with_struct(db: &RootDatabase, st: hir::Struct) -> Option<Self> {
+        let signature = FunctionSignature::from_struct(db, st)?;
+
+        Some(CallInfo { signature, active_parameter: None })
+    }
+
+    fn with_enum_variant(db: &RootDatabase, variant: hir::EnumVariant) -> Option<Self> {
+        let signature = FunctionSignature::from_enum_variant(db, variant)?;
+
+        Some(CallInfo { signature, active_parameter: None })
+    }
+
+    fn with_macro(db: &RootDatabase, macro_def: hir::MacroDef) -> Option<Self> {
+        let signature = FunctionSignature::from_macro(db, macro_def)?;
+
+        Some(CallInfo { signature, active_parameter: None })
+    }
+
+    fn parameters(&self) -> &[String] {
+        &self.signature.parameters
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use test_utils::covers;
+
+    use crate::mock_analysis::single_file_with_position;
+
+    use super::*;
+
+    // These are only used when testing
+    impl CallInfo {
+        fn doc(&self) -> Option<hir::Documentation> {
+            self.signature.doc.clone()
+        }
+
+        fn label(&self) -> String {
+            self.signature.to_string()
+        }
+    }
+
+    fn call_info(text: &str) -> CallInfo {
+        let (analysis, position) = single_file_with_position(text);
+        analysis.call_info(position).unwrap().unwrap()
+    }
+
+    #[test]
+    fn test_fn_signature_two_args_firstx() {
+        let info = call_info(
+            r#"fn foo(x: u32, y: u32) -> u32 {x + y}
+fn bar() { foo(<|>3, ); }"#,
+        );
+
+        assert_eq!(info.parameters(), ["x: u32", "y: u32"]);
+        assert_eq!(info.active_parameter, Some(0));
+    }
+
+    #[test]
+    fn test_fn_signature_two_args_second() {
+        let info = call_info(
+            r#"fn foo(x: u32, y: u32) -> u32 {x + y}
+fn bar() { foo(3, <|>); }"#,
+        );
+
+        assert_eq!(info.parameters(), ["x: u32", "y: u32"]);
+        assert_eq!(info.active_parameter, Some(1));
+    }
+
+    #[test]
+    fn test_fn_signature_two_args_empty() {
+        let info = call_info(
+            r#"fn foo(x: u32, y: u32) -> u32 {x + y}
+fn bar() { foo(<|>); }"#,
+        );
+
+        assert_eq!(info.parameters(), ["x: u32", "y: u32"]);
+        assert_eq!(info.active_parameter, Some(0));
+    }
+
+    #[test]
+    fn test_fn_signature_two_args_first_generics() {
+        let info = call_info(
+            r#"fn foo<T, U: Copy + Display>(x: T, y: U) -> u32 where T: Copy + Display, U: Debug {x + y}
+fn bar() { foo(<|>3, ); }"#,
+        );
+
+        assert_eq!(info.parameters(), ["x: T", "y: U"]);
+        assert_eq!(
+            info.label(),
+            r#"
+fn foo<T, U: Copy + Display>(x: T, y: U) -> u32
+where T: Copy + Display,
+      U: Debug
+    "#
+            .trim()
+        );
+        assert_eq!(info.active_parameter, Some(0));
+    }
+
+    #[test]
+    fn test_fn_signature_no_params() {
+        let info = call_info(
+            r#"fn foo<T>() -> T where T: Copy + Display {}
+fn bar() { foo(<|>); }"#,
+        );
+
+        assert!(info.parameters().is_empty());
+        assert_eq!(
+            info.label(),
+            r#"
+fn foo<T>() -> T
+where T: Copy + Display
+    "#
+            .trim()
+        );
+        assert!(info.active_parameter.is_none());
+    }
+
+    #[test]
+    fn test_fn_signature_for_impl() {
+        let info = call_info(
+            r#"struct F; impl F { pub fn new() { F{}} }
+fn bar() {let _ : F = F::new(<|>);}"#,
+        );
+
+        assert!(info.parameters().is_empty());
+        assert_eq!(info.active_parameter, None);
+    }
+
+    #[test]
+    fn test_fn_signature_for_method_self() {
+        let info = call_info(
+            r#"struct F;
+impl F {
+    pub fn new() -> F{
+        F{}
+    }
+
+    pub fn do_it(&self) {}
+}
+
+fn bar() {
+    let f : F = F::new();
+    f.do_it(<|>);
+}"#,
+        );
+
+        assert_eq!(info.parameters(), ["&self"]);
+        assert_eq!(info.active_parameter, None);
+    }
+
+    #[test]
+    fn test_fn_signature_for_method_with_arg() {
+        let info = call_info(
+            r#"struct F;
+impl F {
+    pub fn new() -> F{
+        F{}
+    }
+
+    pub fn do_it(&self, x: i32) {}
+}
+
+fn bar() {
+    let f : F = F::new();
+    f.do_it(<|>);
+}"#,
+        );
+
+        assert_eq!(info.parameters(), ["&self", "x: i32"]);
+        assert_eq!(info.active_parameter, Some(1));
+    }
+
+    #[test]
+    fn test_fn_signature_with_docs_simple() {
+        let info = call_info(
+            r#"
+/// test
+// non-doc-comment
+fn foo(j: u32) -> u32 {
+    j
+}
+
+fn bar() {
+    let _ = foo(<|>);
+}
+"#,
+        );
+
+        assert_eq!(info.parameters(), ["j: u32"]);
+        assert_eq!(info.active_parameter, Some(0));
+        assert_eq!(info.label(), "fn foo(j: u32) -> u32");
+        assert_eq!(info.doc().map(|it| it.into()), Some("test".to_string()));
+    }
+
+    #[test]
+    fn test_fn_signature_with_docs() {
+        let info = call_info(
+            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(<|>
+}"#,
+        );
+
+        assert_eq!(info.parameters(), ["x: i32"]);
+        assert_eq!(info.active_parameter, Some(0));
+        assert_eq!(info.label(), "pub fn add_one(x: i32) -> i32");
+        assert_eq!(
+            info.doc().map(|it| it.into()),
+            Some(
+                r#"Adds one to the number given.
+
+# Examples
+
+```
+let five = 5;
+
+assert_eq!(6, my_crate::add_one(5));
+```"#
+                    .to_string()
+            )
+        );
+    }
+
+    #[test]
+    fn test_fn_signature_with_docs_impl() {
+        let info = call_info(
+            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(<|>);
+}"#,
+        );
+
+        assert_eq!(info.parameters(), ["x: i32"]);
+        assert_eq!(info.active_parameter, Some(0));
+        assert_eq!(info.label(), "pub fn add_one(x: i32) -> i32");
+        assert_eq!(
+            info.doc().map(|it| it.into()),
+            Some(
+                r#"Adds one to the number given.
+
+# Examples
+
+```
+let five = 5;
+
+assert_eq!(6, my_crate::add_one(5));
+```"#
+                    .to_string()
+            )
+        );
+    }
+
+    #[test]
+    fn test_fn_signature_with_docs_from_actix() {
+        let info = call_info(
+            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(<|>);
+}
+
+"#,
+        );
+
+        assert_eq!(info.label(), "fn finished(&mut self, ctx: &mut Self::Context)".to_string());
+        assert_eq!(info.parameters(), ["&mut self", "ctx: &mut Self::Context"]);
+        assert_eq!(info.active_parameter, Some(1));
+        assert_eq!(
+            info.doc().map(|it| it.into()),
+            Some(
+                r#"Method is called when writer finishes.
+
+By default this method stops actor's `Context`."#
+                    .to_string()
+            )
+        );
+    }
+
+    #[test]
+    fn call_info_bad_offset() {
+        covers!(call_info_bad_offset);
+        let (analysis, position) = single_file_with_position(
+            r#"fn foo(x: u32, y: u32) -> u32 {x + y}
+               fn bar() { foo <|> (3, ); }"#,
+        );
+        let call_info = analysis.call_info(position).unwrap();
+        assert!(call_info.is_none());
+    }
+
+    #[test]
+    fn test_nested_method_in_lamba() {
+        let info = call_info(
+            r#"struct Foo;
+
+impl Foo {
+    fn bar(&self, _: u32) { }
+}
+
+fn bar(_: u32) { }
+
+fn main() {
+    let foo = Foo;
+    std::thread::spawn(move || foo.bar(<|>));
+}"#,
+        );
+
+        assert_eq!(info.parameters(), ["&self", "_: u32"]);
+        assert_eq!(info.active_parameter, Some(1));
+        assert_eq!(info.label(), "fn bar(&self, _: u32)");
+    }
+
+    #[test]
+    fn works_for_tuple_structs() {
+        let info = call_info(
+            r#"
+/// A cool tuple struct
+struct TS(u32, i32);
+fn main() {
+    let s = TS(0, <|>);
+}"#,
+        );
+
+        assert_eq!(info.label(), "struct TS(u32, i32) -> TS");
+        assert_eq!(info.doc().map(|it| it.into()), Some("A cool tuple struct".to_string()));
+        assert_eq!(info.active_parameter, Some(1));
+    }
+
+    #[test]
+    #[should_panic]
+    fn cant_call_named_structs() {
+        let _ = call_info(
+            r#"
+struct TS { x: u32, y: i32 }
+fn main() {
+    let s = TS(<|>);
+}"#,
+        );
+    }
+
+    #[test]
+    fn works_for_enum_variants() {
+        let info = call_info(
+            r#"
+enum E {
+    /// A Variant
+    A(i32),
+    /// Another
+    B,
+    /// And C
+    C { a: i32, b: i32 }
+}
+
+fn main() {
+    let a = E::A(<|>);
+}
+            "#,
+        );
+
+        assert_eq!(info.label(), "E::A(0: i32)");
+        assert_eq!(info.doc().map(|it| it.into()), Some("A Variant".to_string()));
+        assert_eq!(info.active_parameter, Some(0));
+    }
+
+    #[test]
+    #[should_panic]
+    fn cant_call_enum_records() {
+        let _ = call_info(
+            r#"
+enum E {
+    /// A Variant
+    A(i32),
+    /// Another
+    B,
+    /// And C
+    C { a: i32, b: i32 }
+}
+
+fn main() {
+    let a = E::C(<|>);
+}
+            "#,
+        );
+    }
+
+    #[test]
+    fn fn_signature_for_macro() {
+        let info = call_info(
+            r#"
+/// empty macro
+macro_rules! foo {
+    () => {}
+}
+
+fn f() {
+    foo!(<|>);
+}
+        "#,
+        );
+
+        assert_eq!(info.label(), "foo!()");
+        assert_eq!(info.doc().map(|it| it.into()), Some("empty macro".to_string()));
+    }
+}
diff --git a/crates/ra_ide/src/change.rs b/crates/ra_ide/src/change.rs
new file mode 100644
index 000000000..4a76d1dd8
--- /dev/null
+++ b/crates/ra_ide/src/change.rs
@@ -0,0 +1,354 @@
+//! FIXME: write short doc here
+
+use std::{fmt, sync::Arc, time};
+
+use ra_db::{
+    salsa::{Database, Durability, SweepStrategy},
+    CrateGraph, CrateId, FileId, RelativePathBuf, SourceDatabase, SourceDatabaseExt, SourceRoot,
+    SourceRootId,
+};
+use ra_prof::{memory_usage, profile, Bytes};
+use ra_syntax::SourceFile;
+#[cfg(not(feature = "wasm"))]
+use rayon::prelude::*;
+use rustc_hash::FxHashMap;
+
+use crate::{
+    db::{DebugData, RootDatabase},
+    symbol_index::{SymbolIndex, SymbolsDatabase},
+};
+
+#[derive(Default)]
+pub struct AnalysisChange {
+    new_roots: Vec<(SourceRootId, bool)>,
+    roots_changed: FxHashMap<SourceRootId, RootChange>,
+    files_changed: Vec<(FileId, Arc<String>)>,
+    libraries_added: Vec<LibraryData>,
+    crate_graph: Option<CrateGraph>,
+    debug_data: DebugData,
+}
+
+impl fmt::Debug for AnalysisChange {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        let mut d = fmt.debug_struct("AnalysisChange");
+        if !self.new_roots.is_empty() {
+            d.field("new_roots", &self.new_roots);
+        }
+        if !self.roots_changed.is_empty() {
+            d.field("roots_changed", &self.roots_changed);
+        }
+        if !self.files_changed.is_empty() {
+            d.field("files_changed", &self.files_changed.len());
+        }
+        if !self.libraries_added.is_empty() {
+            d.field("libraries_added", &self.libraries_added.len());
+        }
+        if !self.crate_graph.is_none() {
+            d.field("crate_graph", &self.crate_graph);
+        }
+        d.finish()
+    }
+}
+
+impl AnalysisChange {
+    pub fn new() -> AnalysisChange {
+        AnalysisChange::default()
+    }
+
+    pub fn add_root(&mut self, root_id: SourceRootId, is_local: bool) {
+        self.new_roots.push((root_id, is_local));
+    }
+
+    pub fn add_file(
+        &mut self,
+        root_id: SourceRootId,
+        file_id: FileId,
+        path: RelativePathBuf,
+        text: Arc<String>,
+    ) {
+        let file = AddFile { file_id, path, text };
+        self.roots_changed.entry(root_id).or_default().added.push(file);
+    }
+
+    pub fn change_file(&mut self, file_id: FileId, new_text: Arc<String>) {
+        self.files_changed.push((file_id, new_text))
+    }
+
+    pub fn remove_file(&mut self, root_id: SourceRootId, file_id: FileId, path: RelativePathBuf) {
+        let file = RemoveFile { file_id, path };
+        self.roots_changed.entry(root_id).or_default().removed.push(file);
+    }
+
+    pub fn add_library(&mut self, data: LibraryData) {
+        self.libraries_added.push(data)
+    }
+
+    pub fn set_crate_graph(&mut self, graph: CrateGraph) {
+        self.crate_graph = Some(graph);
+    }
+
+    pub fn set_debug_crate_name(&mut self, crate_id: CrateId, name: String) {
+        self.debug_data.crate_names.insert(crate_id, name);
+    }
+
+    pub fn set_debug_root_path(&mut self, source_root_id: SourceRootId, path: String) {
+        self.debug_data.root_paths.insert(source_root_id, path);
+    }
+}
+
+#[derive(Debug)]
+struct AddFile {
+    file_id: FileId,
+    path: RelativePathBuf,
+    text: Arc<String>,
+}
+
+#[derive(Debug)]
+struct RemoveFile {
+    file_id: FileId,
+    path: RelativePathBuf,
+}
+
+#[derive(Default)]
+struct RootChange {
+    added: Vec<AddFile>,
+    removed: Vec<RemoveFile>,
+}
+
+impl fmt::Debug for RootChange {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        fmt.debug_struct("AnalysisChange")
+            .field("added", &self.added.len())
+            .field("removed", &self.removed.len())
+            .finish()
+    }
+}
+
+pub struct LibraryData {
+    root_id: SourceRootId,
+    root_change: RootChange,
+    symbol_index: SymbolIndex,
+}
+
+impl fmt::Debug for LibraryData {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.debug_struct("LibraryData")
+            .field("root_id", &self.root_id)
+            .field("root_change", &self.root_change)
+            .field("n_symbols", &self.symbol_index.len())
+            .finish()
+    }
+}
+
+impl LibraryData {
+    pub fn prepare(
+        root_id: SourceRootId,
+        files: Vec<(FileId, RelativePathBuf, Arc<String>)>,
+    ) -> LibraryData {
+        #[cfg(not(feature = "wasm"))]
+        let iter = files.par_iter();
+        #[cfg(feature = "wasm")]
+        let iter = files.iter();
+
+        let symbol_index = SymbolIndex::for_files(iter.map(|(file_id, _, text)| {
+            let parse = SourceFile::parse(text);
+            (*file_id, parse)
+        }));
+        let mut root_change = RootChange::default();
+        root_change.added = files
+            .into_iter()
+            .map(|(file_id, path, text)| AddFile { file_id, path, text })
+            .collect();
+        LibraryData { root_id, root_change, symbol_index }
+    }
+}
+
+const GC_COOLDOWN: time::Duration = time::Duration::from_millis(100);
+
+impl RootDatabase {
+    pub(crate) fn apply_change(&mut self, change: AnalysisChange) {
+        let _p = profile("RootDatabase::apply_change");
+        log::info!("apply_change {:?}", change);
+        {
+            let _p = profile("RootDatabase::apply_change/cancellation");
+            self.salsa_runtime_mut().synthetic_write(Durability::LOW);
+        }
+        if !change.new_roots.is_empty() {
+            let mut local_roots = Vec::clone(&self.local_roots());
+            for (root_id, is_local) in change.new_roots {
+                let root = if is_local { SourceRoot::new() } else { SourceRoot::new_library() };
+                let durability = durability(&root);
+                self.set_source_root_with_durability(root_id, Arc::new(root), durability);
+                if is_local {
+                    local_roots.push(root_id);
+                }
+            }
+            self.set_local_roots_with_durability(Arc::new(local_roots), Durability::HIGH);
+        }
+
+        for (root_id, root_change) in change.roots_changed {
+            self.apply_root_change(root_id, root_change);
+        }
+        for (file_id, text) in change.files_changed {
+            let source_root_id = self.file_source_root(file_id);
+            let source_root = self.source_root(source_root_id);
+            let durability = durability(&source_root);
+            self.set_file_text_with_durability(file_id, text, durability)
+        }
+        if !change.libraries_added.is_empty() {
+            let mut libraries = Vec::clone(&self.library_roots());
+            for library in change.libraries_added {
+                libraries.push(library.root_id);
+                self.set_source_root_with_durability(
+                    library.root_id,
+                    Default::default(),
+                    Durability::HIGH,
+                );
+                self.set_library_symbols_with_durability(
+                    library.root_id,
+                    Arc::new(library.symbol_index),
+                    Durability::HIGH,
+                );
+                self.apply_root_change(library.root_id, library.root_change);
+            }
+            self.set_library_roots_with_durability(Arc::new(libraries), Durability::HIGH);
+        }
+        if let Some(crate_graph) = change.crate_graph {
+            self.set_crate_graph_with_durability(Arc::new(crate_graph), Durability::HIGH)
+        }
+
+        Arc::make_mut(&mut self.debug_data).merge(change.debug_data)
+    }
+
+    fn apply_root_change(&mut self, root_id: SourceRootId, root_change: RootChange) {
+        let mut source_root = SourceRoot::clone(&self.source_root(root_id));
+        let durability = durability(&source_root);
+        for add_file in root_change.added {
+            self.set_file_text_with_durability(add_file.file_id, add_file.text, durability);
+            self.set_file_relative_path_with_durability(
+                add_file.file_id,
+                add_file.path.clone(),
+                durability,
+            );
+            self.set_file_source_root_with_durability(add_file.file_id, root_id, durability);
+            source_root.insert_file(add_file.path, add_file.file_id);
+        }
+        for remove_file in root_change.removed {
+            self.set_file_text_with_durability(remove_file.file_id, Default::default(), durability);
+            source_root.remove_file(&remove_file.path);
+        }
+        self.set_source_root_with_durability(root_id, Arc::new(source_root), durability);
+    }
+
+    pub(crate) fn maybe_collect_garbage(&mut self) {
+        if cfg!(feature = "wasm") {
+            return;
+        }
+
+        if self.last_gc_check.elapsed() > GC_COOLDOWN {
+            self.last_gc_check = crate::wasm_shims::Instant::now();
+        }
+    }
+
+    pub(crate) fn collect_garbage(&mut self) {
+        if cfg!(feature = "wasm") {
+            return;
+        }
+
+        let _p = profile("RootDatabase::collect_garbage");
+        self.last_gc = crate::wasm_shims::Instant::now();
+
+        let sweep = SweepStrategy::default().discard_values().sweep_all_revisions();
+
+        self.query(ra_db::ParseQuery).sweep(sweep);
+        self.query(hir::db::ParseMacroQuery).sweep(sweep);
+
+        // Macros do take significant space, but less then the syntax trees
+        // self.query(hir::db::MacroDefQuery).sweep(sweep);
+        // self.query(hir::db::MacroArgQuery).sweep(sweep);
+        // self.query(hir::db::MacroExpandQuery).sweep(sweep);
+
+        self.query(hir::db::AstIdMapQuery).sweep(sweep);
+
+        self.query(hir::db::RawItemsWithSourceMapQuery).sweep(sweep);
+        self.query(hir::db::BodyWithSourceMapQuery).sweep(sweep);
+
+        self.query(hir::db::ExprScopesQuery).sweep(sweep);
+        self.query(hir::db::InferQuery).sweep(sweep);
+        self.query(hir::db::BodyQuery).sweep(sweep);
+    }
+
+    pub(crate) fn per_query_memory_usage(&mut self) -> Vec<(String, Bytes)> {
+        let mut acc: Vec<(String, Bytes)> = vec![];
+        let sweep = SweepStrategy::default().discard_values().sweep_all_revisions();
+        macro_rules! sweep_each_query {
+            ($($q:path)*) => {$(
+                let before = memory_usage().allocated;
+                self.query($q).sweep(sweep);
+                let after = memory_usage().allocated;
+                let q: $q = Default::default();
+                let name = format!("{:?}", q);
+                acc.push((name, before - after));
+
+                let before = memory_usage().allocated;
+                self.query($q).sweep(sweep.discard_everything());
+                let after = memory_usage().allocated;
+                let q: $q = Default::default();
+                let name = format!("{:?} (deps)", q);
+                acc.push((name, before - after));
+            )*}
+        }
+        sweep_each_query![
+            ra_db::ParseQuery
+            ra_db::SourceRootCratesQuery
+            hir::db::AstIdMapQuery
+            hir::db::ParseMacroQuery
+            hir::db::MacroDefQuery
+            hir::db::MacroArgQuery
+            hir::db::MacroExpandQuery
+            hir::db::StructDataQuery
+            hir::db::EnumDataQuery
+            hir::db::TraitDataQuery
+            hir::db::RawItemsWithSourceMapQuery
+            hir::db::RawItemsQuery
+            hir::db::CrateDefMapQuery
+            hir::db::GenericParamsQuery
+            hir::db::FunctionDataQuery
+            hir::db::TypeAliasDataQuery
+            hir::db::ConstDataQuery
+            hir::db::StaticDataQuery
+            hir::db::ModuleLangItemsQuery
+            hir::db::CrateLangItemsQuery
+            hir::db::LangItemQuery
+            hir::db::DocumentationQuery
+            hir::db::ExprScopesQuery
+            hir::db::InferQuery
+            hir::db::TyQuery
+            hir::db::ValueTyQuery
+            hir::db::FieldTypesQuery
+            hir::db::CallableItemSignatureQuery
+            hir::db::GenericPredicatesQuery
+            hir::db::GenericDefaultsQuery
+            hir::db::BodyWithSourceMapQuery
+            hir::db::BodyQuery
+            hir::db::ImplsInCrateQuery
+            hir::db::ImplsForTraitQuery
+            hir::db::AssociatedTyDataQuery
+            hir::db::TraitDatumQuery
+            hir::db::StructDatumQuery
+            hir::db::ImplDatumQuery
+            hir::db::ImplDataQuery
+            hir::db::TraitSolveQuery
+        ];
+        acc.sort_by_key(|it| std::cmp::Reverse(it.1));
+        acc
+    }
+}
+
+fn durability(source_root: &SourceRoot) -> Durability {
+    if source_root.is_library {
+        Durability::HIGH
+    } else {
+        Durability::LOW
+    }
+}
diff --git a/crates/ra_ide/src/completion.rs b/crates/ra_ide/src/completion.rs
new file mode 100644
index 000000000..abe1f36ce
--- /dev/null
+++ b/crates/ra_ide/src/completion.rs
@@ -0,0 +1,77 @@
+//! FIXME: write short doc here
+
+mod completion_item;
+mod completion_context;
+mod presentation;
+
+mod complete_dot;
+mod complete_record_literal;
+mod complete_record_pattern;
+mod complete_pattern;
+mod complete_fn_param;
+mod complete_keyword;
+mod complete_snippet;
+mod complete_path;
+mod complete_scope;
+mod complete_postfix;
+mod complete_macro_in_item_position;
+
+use ra_db::SourceDatabase;
+
+#[cfg(test)]
+use crate::completion::completion_item::do_completion;
+use crate::{
+    completion::{
+        completion_context::CompletionContext,
+        completion_item::{CompletionKind, Completions},
+    },
+    db, FilePosition,
+};
+
+pub use crate::completion::completion_item::{
+    CompletionItem, CompletionItemKind, InsertTextFormat,
+};
+
+/// 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: &db::RootDatabase, position: FilePosition) -> Option<Completions> {
+    let original_parse = db.parse(position.file_id);
+    let ctx = CompletionContext::new(db, &original_parse, position)?;
+
+    let mut acc = Completions::default();
+
+    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_path::complete_path(&mut acc, &ctx);
+    complete_scope::complete_scope(&mut acc, &ctx);
+    complete_dot::complete_dot(&mut acc, &ctx);
+    complete_record_literal::complete_record_literal(&mut acc, &ctx);
+    complete_record_pattern::complete_record_pattern(&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);
+    Some(acc)
+}
diff --git a/crates/ra_ide/src/completion/complete_dot.rs b/crates/ra_ide/src/completion/complete_dot.rs
new file mode 100644
index 000000000..b6fe48627
--- /dev/null
+++ b/crates/ra_ide/src/completion/complete_dot.rs
@@ -0,0 +1,456 @@
+//! FIXME: write short doc here
+
+use hir::Type;
+
+use crate::completion::completion_item::CompletionKind;
+use crate::{
+    completion::{completion_context::CompletionContext, completion_item::Completions},
+    CompletionItem,
+};
+use rustc_hash::FxHashSet;
+
+/// Complete dot accesses, i.e. fields or methods (and .await syntax).
+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.analyzer.type_of(ctx.db, &dot_receiver) {
+        Some(ty) => ty,
+        _ => return,
+    };
+
+    if !ctx.is_call {
+        complete_fields(acc, ctx, &receiver_ty);
+    }
+    complete_methods(acc, ctx, &receiver_ty);
+
+    // Suggest .await syntax for types that implement Future trait
+    if ctx.analyzer.impls_future(ctx.db, receiver_ty.into_ty()) {
+        CompletionItem::new(CompletionKind::Keyword, ctx.source_range(), "await")
+            .detail("expr.await")
+            .insert_text("await")
+            .add_to(acc);
+    }
+}
+
+fn complete_fields(acc: &mut Completions, ctx: &CompletionContext, receiver: &Type) {
+    for receiver in receiver.autoderef(ctx.db) {
+        for (field, ty) in receiver.fields(ctx.db) {
+            acc.add_field(ctx, field, &ty);
+        }
+        for (i, ty) in receiver.tuple_fields(ctx.db).into_iter().enumerate() {
+            acc.add_tuple_field(ctx, i, &ty);
+        }
+    }
+}
+
+fn complete_methods(acc: &mut Completions, ctx: &CompletionContext, receiver: &Type) {
+    let mut seen_methods = FxHashSet::default();
+    ctx.analyzer.iterate_method_candidates(ctx.db, receiver, None, |_ty, func| {
+        if func.has_self_param(ctx.db) && seen_methods.insert(func.name(ctx.db)) {
+            acc.add_function(ctx, func);
+        }
+        None::<()>
+    });
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::completion::{do_completion, CompletionItem, CompletionKind};
+    use insta::assert_debug_snapshot;
+
+    fn do_ref_completion(code: &str) -> Vec<CompletionItem> {
+        do_completion(code, CompletionKind::Reference)
+    }
+
+    #[test]
+    fn test_struct_field_completion() {
+        assert_debug_snapshot!(
+        do_ref_completion(
+                r"
+                struct A { the_field: u32 }
+                fn foo(a: A) {
+                a.<|>
+                }
+                ",
+        ),
+            @r###"
+        [
+            CompletionItem {
+                label: "the_field",
+                source_range: [94; 94),
+                delete: [94; 94),
+                insert: "the_field",
+                kind: Field,
+                detail: "u32",
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
+    fn test_struct_field_completion_self() {
+        assert_debug_snapshot!(
+        do_ref_completion(
+            r"
+            struct A {
+                /// This is the_field
+                the_field: (u32,)
+            }
+            impl A {
+                fn foo(self) {
+                    self.<|>
+                }
+            }
+            ",
+        ),
+        @r###"
+        [
+            CompletionItem {
+                label: "foo()",
+                source_range: [187; 187),
+                delete: [187; 187),
+                insert: "foo()$0",
+                kind: Method,
+                lookup: "foo",
+                detail: "fn foo(self)",
+            },
+            CompletionItem {
+                label: "the_field",
+                source_range: [187; 187),
+                delete: [187; 187),
+                insert: "the_field",
+                kind: Field,
+                detail: "(u32,)",
+                documentation: Documentation(
+                    "This is the_field",
+                ),
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
+    fn test_struct_field_completion_autoderef() {
+        assert_debug_snapshot!(
+        do_ref_completion(
+            r"
+            struct A { the_field: (u32, i32) }
+            impl A {
+                fn foo(&self) {
+                    self.<|>
+                }
+            }
+            ",
+        ),
+        @r###"
+        [
+            CompletionItem {
+                label: "foo()",
+                source_range: [126; 126),
+                delete: [126; 126),
+                insert: "foo()$0",
+                kind: Method,
+                lookup: "foo",
+                detail: "fn foo(&self)",
+            },
+            CompletionItem {
+                label: "the_field",
+                source_range: [126; 126),
+                delete: [126; 126),
+                insert: "the_field",
+                kind: Field,
+                detail: "(u32, i32)",
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
+    fn test_no_struct_field_completion_for_method_call() {
+        assert_debug_snapshot!(
+        do_ref_completion(
+            r"
+            struct A { the_field: u32 }
+            fn foo(a: A) {
+               a.<|>()
+            }
+            ",
+        ),
+        @"[]"
+        );
+    }
+
+    #[test]
+    fn test_method_completion() {
+        assert_debug_snapshot!(
+        do_ref_completion(
+            r"
+            struct A {}
+            impl A {
+                fn the_method(&self) {}
+            }
+            fn foo(a: A) {
+               a.<|>
+            }
+            ",
+        ),
+        @r###"
+        [
+            CompletionItem {
+                label: "the_method()",
+                source_range: [144; 144),
+                delete: [144; 144),
+                insert: "the_method()$0",
+                kind: Method,
+                lookup: "the_method",
+                detail: "fn the_method(&self)",
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
+    fn test_trait_method_completion() {
+        assert_debug_snapshot!(
+            do_ref_completion(
+                r"
+            struct A {}
+            trait Trait { fn the_method(&self); }
+            impl Trait for A {}
+            fn foo(a: A) {
+               a.<|>
+            }
+            ",
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "the_method()",
+                source_range: [151; 151),
+                delete: [151; 151),
+                insert: "the_method()$0",
+                kind: Method,
+                lookup: "the_method",
+                detail: "fn the_method(&self)",
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
+    fn test_trait_method_completion_deduplicated() {
+        assert_debug_snapshot!(
+            do_ref_completion(
+                r"
+            struct A {}
+            trait Trait { fn the_method(&self); }
+            impl<T> Trait for T {}
+            fn foo(a: &A) {
+               a.<|>
+            }
+            ",
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "the_method()",
+                source_range: [155; 155),
+                delete: [155; 155),
+                insert: "the_method()$0",
+                kind: Method,
+                lookup: "the_method",
+                detail: "fn the_method(&self)",
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
+    fn test_no_non_self_method() {
+        assert_debug_snapshot!(
+        do_ref_completion(
+            r"
+            struct A {}
+            impl A {
+                fn the_method() {}
+            }
+            fn foo(a: A) {
+               a.<|>
+            }
+            ",
+        ),
+        @"[]"
+        );
+    }
+
+    #[test]
+    fn test_method_attr_filtering() {
+        assert_debug_snapshot!(
+        do_ref_completion(
+            r"
+            struct A {}
+            impl A {
+                #[inline]
+                fn the_method(&self) {
+                    let x = 1;
+                    let y = 2;
+                }
+            }
+            fn foo(a: A) {
+               a.<|>
+            }
+            ",
+        ),
+        @r###"
+        [
+            CompletionItem {
+                label: "the_method()",
+                source_range: [249; 249),
+                delete: [249; 249),
+                insert: "the_method()$0",
+                kind: Method,
+                lookup: "the_method",
+                detail: "fn the_method(&self)",
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
+    fn test_tuple_field_completion() {
+        assert_debug_snapshot!(
+        do_ref_completion(
+            r"
+            fn foo() {
+               let b = (0, 3.14);
+               b.<|>
+            }
+            ",
+        ),
+        @r###"
+        [
+            CompletionItem {
+                label: "0",
+                source_range: [75; 75),
+                delete: [75; 75),
+                insert: "0",
+                kind: Field,
+                detail: "i32",
+            },
+            CompletionItem {
+                label: "1",
+                source_range: [75; 75),
+                delete: [75; 75),
+                insert: "1",
+                kind: Field,
+                detail: "f64",
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
+    fn test_tuple_field_inference() {
+        assert_debug_snapshot!(
+        do_ref_completion(
+            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<|>
+                }
+            }
+            ",
+        ),
+        @r###"
+        [
+            CompletionItem {
+                label: "blah()",
+                source_range: [299; 300),
+                delete: [299; 300),
+                insert: "blah()$0",
+                kind: Method,
+                lookup: "blah",
+                detail: "pub fn blah(&self)",
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
+    fn test_completion_works_in_consts() {
+        assert_debug_snapshot!(
+        do_ref_completion(
+            r"
+            struct A { the_field: u32 }
+            const X: u32 = {
+                A { the_field: 92 }.<|>
+            };
+            ",
+        ),
+        @r###"
+        [
+            CompletionItem {
+                label: "the_field",
+                source_range: [106; 106),
+                delete: [106; 106),
+                insert: "the_field",
+                kind: Field,
+                detail: "u32",
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
+    fn test_completion_await_impls_future() {
+        assert_debug_snapshot!(
+        do_completion(
+            r###"
+            //- /main.rs
+            use std::future::*;
+            struct A {}
+            impl Future for A {}
+            fn foo(a: A) {
+                a.<|>
+            }
+
+            //- /std/lib.rs
+            pub mod future {
+                pub trait Future {}
+            }
+            "###, CompletionKind::Keyword),
+        @r###"
+        [
+            CompletionItem {
+                label: "await",
+                source_range: [74; 74),
+                delete: [74; 74),
+                insert: "await",
+                detail: "expr.await",
+            },
+        ]
+        "###
+        )
+    }
+}
diff --git a/crates/ra_ide/src/completion/complete_fn_param.rs b/crates/ra_ide/src/completion/complete_fn_param.rs
new file mode 100644
index 000000000..502458706
--- /dev/null
+++ b/crates/ra_ide/src/completion/complete_fn_param.rs
@@ -0,0 +1,136 @@
+//! FIXME: write short doc here
+
+use ra_syntax::{ast, match_ast, AstNode};
+use rustc_hash::FxHashMap;
+
+use crate::completion::{CompletionContext, CompletionItem, CompletionKind, Completions};
+
+/// Complete repeated parameters, both name and type. For example, if all
+/// functions in a file have a `spam: &mut Spam` parameter, a completion with
+/// `spam: &mut Spam` insert text/label and `spam` lookup string will be
+/// suggested.
+pub(super) fn complete_fn_param(acc: &mut Completions, ctx: &CompletionContext) {
+    if !ctx.is_param {
+        return;
+    }
+
+    let mut params = FxHashMap::default();
+    for node in ctx.token.parent().ancestors() {
+        match_ast! {
+            match node {
+                ast::SourceFile(it) => { process(it, &mut params) },
+                ast::ItemList(it) => { process(it, &mut params) },
+                _ => (),
+            }
+        }
+    }
+    params
+        .into_iter()
+        .filter_map(|(label, (count, param))| {
+            let lookup = param.pat()?.syntax().text().to_string();
+            if count < 2 {
+                None
+            } else {
+                Some((label, lookup))
+            }
+        })
+        .for_each(|(label, lookup)| {
+            CompletionItem::new(CompletionKind::Magic, ctx.source_range(), label)
+                .lookup_by(lookup)
+                .add_to(acc)
+        });
+
+    fn process<N: ast::FnDefOwner>(node: N, params: &mut FxHashMap<String, (u32, ast::Param)>) {
+        node.functions().filter_map(|it| it.param_list()).flat_map(|it| it.params()).for_each(
+            |param| {
+                let text = param.syntax().text().to_string();
+                params.entry(text).or_insert((0, param)).0 += 1;
+            },
+        )
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::completion::{do_completion, CompletionItem, CompletionKind};
+    use insta::assert_debug_snapshot;
+
+    fn do_magic_completion(code: &str) -> Vec<CompletionItem> {
+        do_completion(code, CompletionKind::Magic)
+    }
+
+    #[test]
+    fn test_param_completion_last_param() {
+        assert_debug_snapshot!(
+        do_magic_completion(
+                r"
+                fn foo(file_id: FileId) {}
+                fn bar(file_id: FileId) {}
+                fn baz(file<|>) {}
+                ",
+        ),
+            @r###"
+        [
+            CompletionItem {
+                label: "file_id: FileId",
+                source_range: [110; 114),
+                delete: [110; 114),
+                insert: "file_id: FileId",
+                lookup: "file_id",
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
+    fn test_param_completion_nth_param() {
+        assert_debug_snapshot!(
+        do_magic_completion(
+                r"
+                fn foo(file_id: FileId) {}
+                fn bar(file_id: FileId) {}
+                fn baz(file<|>, x: i32) {}
+                ",
+        ),
+            @r###"
+        [
+            CompletionItem {
+                label: "file_id: FileId",
+                source_range: [110; 114),
+                delete: [110; 114),
+                insert: "file_id: FileId",
+                lookup: "file_id",
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
+    fn test_param_completion_trait_param() {
+        assert_debug_snapshot!(
+        do_magic_completion(
+                r"
+                pub(crate) trait SourceRoot {
+                    pub fn contains(&self, file_id: FileId) -> bool;
+                    pub fn module_map(&self) -> &ModuleMap;
+                    pub fn lines(&self, file_id: FileId) -> &LineIndex;
+                    pub fn syntax(&self, file<|>)
+                }
+                ",
+        ),
+            @r###"
+        [
+            CompletionItem {
+                label: "file_id: FileId",
+                source_range: [289; 293),
+                delete: [289; 293),
+                insert: "file_id: FileId",
+                lookup: "file_id",
+            },
+        ]
+        "###
+        );
+    }
+}
diff --git a/crates/ra_ide/src/completion/complete_keyword.rs b/crates/ra_ide/src/completion/complete_keyword.rs
new file mode 100644
index 000000000..eb7cd9ac2
--- /dev/null
+++ b/crates/ra_ide/src/completion/complete_keyword.rs
@@ -0,0 +1,781 @@
+//! FIXME: write short doc here
+
+use ra_syntax::{
+    ast::{self, LoopBodyOwner},
+    match_ast, AstNode,
+    SyntaxKind::*,
+    SyntaxToken,
+};
+
+use crate::completion::{
+    CompletionContext, CompletionItem, CompletionItemKind, CompletionKind, Completions,
+};
+
+pub(super) fn complete_use_tree_keyword(acc: &mut Completions, ctx: &CompletionContext) {
+    // complete keyword "crate" in use stmt
+    let source_range = ctx.source_range();
+    match (ctx.use_item_syntax.as_ref(), ctx.path_prefix.as_ref()) {
+        (Some(_), None) => {
+            CompletionItem::new(CompletionKind::Keyword, source_range, "crate")
+                .kind(CompletionItemKind::Keyword)
+                .insert_text("crate::")
+                .add_to(acc);
+            CompletionItem::new(CompletionKind::Keyword, source_range, "self")
+                .kind(CompletionItemKind::Keyword)
+                .add_to(acc);
+            CompletionItem::new(CompletionKind::Keyword, source_range, "super")
+                .kind(CompletionItemKind::Keyword)
+                .insert_text("super::")
+                .add_to(acc);
+        }
+        (Some(_), Some(_)) => {
+            CompletionItem::new(CompletionKind::Keyword, source_range, "self")
+                .kind(CompletionItemKind::Keyword)
+                .add_to(acc);
+            CompletionItem::new(CompletionKind::Keyword, source_range, "super")
+                .kind(CompletionItemKind::Keyword)
+                .insert_text("super::")
+                .add_to(acc);
+        }
+        _ => {}
+    }
+}
+
+fn keyword(ctx: &CompletionContext, kw: &str, snippet: &str) -> CompletionItem {
+    CompletionItem::new(CompletionKind::Keyword, ctx.source_range(), kw)
+        .kind(CompletionItemKind::Keyword)
+        .insert_snippet(snippet)
+        .build()
+}
+
+pub(super) fn complete_expr_keyword(acc: &mut Completions, ctx: &CompletionContext) {
+    if !ctx.is_trivial_path {
+        return;
+    }
+
+    let fn_def = match &ctx.function_syntax {
+        Some(it) => it,
+        None => return,
+    };
+    acc.add(keyword(ctx, "if", "if $0 {}"));
+    acc.add(keyword(ctx, "match", "match $0 {}"));
+    acc.add(keyword(ctx, "while", "while $0 {}"));
+    acc.add(keyword(ctx, "loop", "loop {$0}"));
+
+    if ctx.after_if {
+        acc.add(keyword(ctx, "else", "else {$0}"));
+        acc.add(keyword(ctx, "else if", "else if $0 {}"));
+    }
+    if is_in_loop_body(&ctx.token) {
+        if ctx.can_be_stmt {
+            acc.add(keyword(ctx, "continue", "continue;"));
+            acc.add(keyword(ctx, "break", "break;"));
+        } else {
+            acc.add(keyword(ctx, "continue", "continue"));
+            acc.add(keyword(ctx, "break", "break"));
+        }
+    }
+    acc.add_all(complete_return(ctx, &fn_def, ctx.can_be_stmt));
+}
+
+fn is_in_loop_body(leaf: &SyntaxToken) -> bool {
+    for node in leaf.parent().ancestors() {
+        if node.kind() == FN_DEF || node.kind() == LAMBDA_EXPR {
+            break;
+        }
+        let loop_body = match_ast! {
+            match node {
+                ast::ForExpr(it) => { it.loop_body() },
+                ast::WhileExpr(it) => { it.loop_body() },
+                ast::LoopExpr(it) => { it.loop_body() },
+                _ => None,
+            }
+        };
+        if let Some(body) = loop_body {
+            if leaf.text_range().is_subrange(&body.syntax().text_range()) {
+                return true;
+            }
+        }
+    }
+    false
+}
+
+fn complete_return(
+    ctx: &CompletionContext,
+    fn_def: &ast::FnDef,
+    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 crate::completion::{do_completion, CompletionItem, CompletionKind};
+    use insta::assert_debug_snapshot;
+
+    fn do_keyword_completion(code: &str) -> Vec<CompletionItem> {
+        do_completion(code, CompletionKind::Keyword)
+    }
+
+    #[test]
+    fn completes_keywords_in_use_stmt() {
+        assert_debug_snapshot!(
+            do_keyword_completion(
+                r"
+                use <|>
+                ",
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "crate",
+                source_range: [21; 21),
+                delete: [21; 21),
+                insert: "crate::",
+                kind: Keyword,
+            },
+            CompletionItem {
+                label: "self",
+                source_range: [21; 21),
+                delete: [21; 21),
+                insert: "self",
+                kind: Keyword,
+            },
+            CompletionItem {
+                label: "super",
+                source_range: [21; 21),
+                delete: [21; 21),
+                insert: "super::",
+                kind: Keyword,
+            },
+        ]
+        "###
+        );
+
+        assert_debug_snapshot!(
+            do_keyword_completion(
+                r"
+                use a::<|>
+                ",
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "self",
+                source_range: [24; 24),
+                delete: [24; 24),
+                insert: "self",
+                kind: Keyword,
+            },
+            CompletionItem {
+                label: "super",
+                source_range: [24; 24),
+                delete: [24; 24),
+                insert: "super::",
+                kind: Keyword,
+            },
+        ]
+        "###
+        );
+
+        assert_debug_snapshot!(
+            do_keyword_completion(
+                r"
+                use a::{b, <|>}
+                ",
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "self",
+                source_range: [28; 28),
+                delete: [28; 28),
+                insert: "self",
+                kind: Keyword,
+            },
+            CompletionItem {
+                label: "super",
+                source_range: [28; 28),
+                delete: [28; 28),
+                insert: "super::",
+                kind: Keyword,
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
+    fn completes_various_keywords_in_function() {
+        assert_debug_snapshot!(
+            do_keyword_completion(
+                r"
+                fn quux() {
+                    <|>
+                }
+                ",
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "if",
+                source_range: [49; 49),
+                delete: [49; 49),
+                insert: "if $0 {}",
+                kind: Keyword,
+            },
+            CompletionItem {
+                label: "loop",
+                source_range: [49; 49),
+                delete: [49; 49),
+                insert: "loop {$0}",
+                kind: Keyword,
+            },
+            CompletionItem {
+                label: "match",
+                source_range: [49; 49),
+                delete: [49; 49),
+                insert: "match $0 {}",
+                kind: Keyword,
+            },
+            CompletionItem {
+                label: "return",
+                source_range: [49; 49),
+                delete: [49; 49),
+                insert: "return;",
+                kind: Keyword,
+            },
+            CompletionItem {
+                label: "while",
+                source_range: [49; 49),
+                delete: [49; 49),
+                insert: "while $0 {}",
+                kind: Keyword,
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
+    fn completes_else_after_if() {
+        assert_debug_snapshot!(
+            do_keyword_completion(
+                r"
+                fn quux() {
+                    if true {
+                        ()
+                    } <|>
+                }
+                ",
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "else",
+                source_range: [108; 108),
+                delete: [108; 108),
+                insert: "else {$0}",
+                kind: Keyword,
+            },
+            CompletionItem {
+                label: "else if",
+                source_range: [108; 108),
+                delete: [108; 108),
+                insert: "else if $0 {}",
+                kind: Keyword,
+            },
+            CompletionItem {
+                label: "if",
+                source_range: [108; 108),
+                delete: [108; 108),
+                insert: "if $0 {}",
+                kind: Keyword,
+            },
+            CompletionItem {
+                label: "loop",
+                source_range: [108; 108),
+                delete: [108; 108),
+                insert: "loop {$0}",
+                kind: Keyword,
+            },
+            CompletionItem {
+                label: "match",
+                source_range: [108; 108),
+                delete: [108; 108),
+                insert: "match $0 {}",
+                kind: Keyword,
+            },
+            CompletionItem {
+                label: "return",
+                source_range: [108; 108),
+                delete: [108; 108),
+                insert: "return;",
+                kind: Keyword,
+            },
+            CompletionItem {
+                label: "while",
+                source_range: [108; 108),
+                delete: [108; 108),
+                insert: "while $0 {}",
+                kind: Keyword,
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
+    fn test_completion_return_value() {
+        assert_debug_snapshot!(
+            do_keyword_completion(
+                r"
+                fn quux() -> i32 {
+                    <|>
+                    92
+                }
+                ",
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "if",
+                source_range: [56; 56),
+                delete: [56; 56),
+                insert: "if $0 {}",
+                kind: Keyword,
+            },
+            CompletionItem {
+                label: "loop",
+                source_range: [56; 56),
+                delete: [56; 56),
+                insert: "loop {$0}",
+                kind: Keyword,
+            },
+            CompletionItem {
+                label: "match",
+                source_range: [56; 56),
+                delete: [56; 56),
+                insert: "match $0 {}",
+                kind: Keyword,
+            },
+            CompletionItem {
+                label: "return",
+                source_range: [56; 56),
+                delete: [56; 56),
+                insert: "return $0;",
+                kind: Keyword,
+            },
+            CompletionItem {
+                label: "while",
+                source_range: [56; 56),
+                delete: [56; 56),
+                insert: "while $0 {}",
+                kind: Keyword,
+            },
+        ]
+        "###
+        );
+        assert_debug_snapshot!(
+            do_keyword_completion(
+                r"
+                fn quux() {
+                    <|>
+                    92
+                }
+                ",
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "if",
+                source_range: [49; 49),
+                delete: [49; 49),
+                insert: "if $0 {}",
+                kind: Keyword,
+            },
+            CompletionItem {
+                label: "loop",
+                source_range: [49; 49),
+                delete: [49; 49),
+                insert: "loop {$0}",
+                kind: Keyword,
+            },
+            CompletionItem {
+                label: "match",
+                source_range: [49; 49),
+                delete: [49; 49),
+                insert: "match $0 {}",
+                kind: Keyword,
+            },
+            CompletionItem {
+                label: "return",
+                source_range: [49; 49),
+                delete: [49; 49),
+                insert: "return;",
+                kind: Keyword,
+            },
+            CompletionItem {
+                label: "while",
+                source_range: [49; 49),
+                delete: [49; 49),
+                insert: "while $0 {}",
+                kind: Keyword,
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
+    fn dont_add_semi_after_return_if_not_a_statement() {
+        assert_debug_snapshot!(
+            do_keyword_completion(
+                r"
+                fn quux() -> i32 {
+                    match () {
+                        () => <|>
+                    }
+                }
+                ",
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "if",
+                source_range: [97; 97),
+                delete: [97; 97),
+                insert: "if $0 {}",
+                kind: Keyword,
+            },
+            CompletionItem {
+                label: "loop",
+                source_range: [97; 97),
+                delete: [97; 97),
+                insert: "loop {$0}",
+                kind: Keyword,
+            },
+            CompletionItem {
+                label: "match",
+                source_range: [97; 97),
+                delete: [97; 97),
+                insert: "match $0 {}",
+                kind: Keyword,
+            },
+            CompletionItem {
+                label: "return",
+                source_range: [97; 97),
+                delete: [97; 97),
+                insert: "return $0",
+                kind: Keyword,
+            },
+            CompletionItem {
+                label: "while",
+                source_range: [97; 97),
+                delete: [97; 97),
+                insert: "while $0 {}",
+                kind: Keyword,
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
+    fn last_return_in_block_has_semi() {
+        assert_debug_snapshot!(
+            do_keyword_completion(
+                r"
+                fn quux() -> i32 {
+                    if condition {
+                        <|>
+                    }
+                }
+                ",
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "if",
+                source_range: [95; 95),
+                delete: [95; 95),
+                insert: "if $0 {}",
+                kind: Keyword,
+            },
+            CompletionItem {
+                label: "loop",
+                source_range: [95; 95),
+                delete: [95; 95),
+                insert: "loop {$0}",
+                kind: Keyword,
+            },
+            CompletionItem {
+                label: "match",
+                source_range: [95; 95),
+                delete: [95; 95),
+                insert: "match $0 {}",
+                kind: Keyword,
+            },
+            CompletionItem {
+                label: "return",
+                source_range: [95; 95),
+                delete: [95; 95),
+                insert: "return $0;",
+                kind: Keyword,
+            },
+            CompletionItem {
+                label: "while",
+                source_range: [95; 95),
+                delete: [95; 95),
+                insert: "while $0 {}",
+                kind: Keyword,
+            },
+        ]
+        "###
+        );
+        assert_debug_snapshot!(
+            do_keyword_completion(
+                r"
+                fn quux() -> i32 {
+                    if condition {
+                        <|>
+                    }
+                    let x = 92;
+                    x
+                }
+                ",
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "if",
+                source_range: [95; 95),
+                delete: [95; 95),
+                insert: "if $0 {}",
+                kind: Keyword,
+            },
+            CompletionItem {
+                label: "loop",
+                source_range: [95; 95),
+                delete: [95; 95),
+                insert: "loop {$0}",
+                kind: Keyword,
+            },
+            CompletionItem {
+                label: "match",
+                source_range: [95; 95),
+                delete: [95; 95),
+                insert: "match $0 {}",
+                kind: Keyword,
+            },
+            CompletionItem {
+                label: "return",
+                source_range: [95; 95),
+                delete: [95; 95),
+                insert: "return $0;",
+                kind: Keyword,
+            },
+            CompletionItem {
+                label: "while",
+                source_range: [95; 95),
+                delete: [95; 95),
+                insert: "while $0 {}",
+                kind: Keyword,
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
+    fn completes_break_and_continue_in_loops() {
+        assert_debug_snapshot!(
+            do_keyword_completion(
+                r"
+                fn quux() -> i32 {
+                    loop { <|> }
+                }
+                ",
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "break",
+                source_range: [63; 63),
+                delete: [63; 63),
+                insert: "break;",
+                kind: Keyword,
+            },
+            CompletionItem {
+                label: "continue",
+                source_range: [63; 63),
+                delete: [63; 63),
+                insert: "continue;",
+                kind: Keyword,
+            },
+            CompletionItem {
+                label: "if",
+                source_range: [63; 63),
+                delete: [63; 63),
+                insert: "if $0 {}",
+                kind: Keyword,
+            },
+            CompletionItem {
+                label: "loop",
+                source_range: [63; 63),
+                delete: [63; 63),
+                insert: "loop {$0}",
+                kind: Keyword,
+            },
+            CompletionItem {
+                label: "match",
+                source_range: [63; 63),
+                delete: [63; 63),
+                insert: "match $0 {}",
+                kind: Keyword,
+            },
+            CompletionItem {
+                label: "return",
+                source_range: [63; 63),
+                delete: [63; 63),
+                insert: "return $0;",
+                kind: Keyword,
+            },
+            CompletionItem {
+                label: "while",
+                source_range: [63; 63),
+                delete: [63; 63),
+                insert: "while $0 {}",
+                kind: Keyword,
+            },
+        ]
+        "###
+        );
+
+        // No completion: lambda isolates control flow
+        assert_debug_snapshot!(
+            do_keyword_completion(
+                r"
+                fn quux() -> i32 {
+                    loop { || { <|> } }
+                }
+                ",
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "if",
+                source_range: [68; 68),
+                delete: [68; 68),
+                insert: "if $0 {}",
+                kind: Keyword,
+            },
+            CompletionItem {
+                label: "loop",
+                source_range: [68; 68),
+                delete: [68; 68),
+                insert: "loop {$0}",
+                kind: Keyword,
+            },
+            CompletionItem {
+                label: "match",
+                source_range: [68; 68),
+                delete: [68; 68),
+                insert: "match $0 {}",
+                kind: Keyword,
+            },
+            CompletionItem {
+                label: "return",
+                source_range: [68; 68),
+                delete: [68; 68),
+                insert: "return $0;",
+                kind: Keyword,
+            },
+            CompletionItem {
+                label: "while",
+                source_range: [68; 68),
+                delete: [68; 68),
+                insert: "while $0 {}",
+                kind: Keyword,
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
+    fn no_semi_after_break_continue_in_expr() {
+        assert_debug_snapshot!(
+            do_keyword_completion(
+                r"
+                fn f() {
+                    loop {
+                        match () {
+                            () => br<|>
+                        }
+                    }
+                }
+                ",
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "break",
+                source_range: [122; 124),
+                delete: [122; 124),
+                insert: "break",
+                kind: Keyword,
+            },
+            CompletionItem {
+                label: "continue",
+                source_range: [122; 124),
+                delete: [122; 124),
+                insert: "continue",
+                kind: Keyword,
+            },
+            CompletionItem {
+                label: "if",
+                source_range: [122; 124),
+                delete: [122; 124),
+                insert: "if $0 {}",
+                kind: Keyword,
+            },
+            CompletionItem {
+                label: "loop",
+                source_range: [122; 124),
+                delete: [122; 124),
+                insert: "loop {$0}",
+                kind: Keyword,
+            },
+            CompletionItem {
+                label: "match",
+                source_range: [122; 124),
+                delete: [122; 124),
+                insert: "match $0 {}",
+                kind: Keyword,
+            },
+            CompletionItem {
+                label: "return",
+                source_range: [122; 124),
+                delete: [122; 124),
+                insert: "return",
+                kind: Keyword,
+            },
+            CompletionItem {
+                label: "while",
+                source_range: [122; 124),
+                delete: [122; 124),
+                insert: "while $0 {}",
+                kind: Keyword,
+            },
+        ]
+        "###
+        )
+    }
+}
diff --git a/crates/ra_ide/src/completion/complete_macro_in_item_position.rs b/crates/ra_ide/src/completion/complete_macro_in_item_position.rs
new file mode 100644
index 000000000..faadd1e3f
--- /dev/null
+++ b/crates/ra_ide/src/completion/complete_macro_in_item_position.rs
@@ -0,0 +1,143 @@
+//! 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.analyzer.process_all_names(ctx.db, &mut |name, res| {
+            if let hir::ScopeDef::MacroDef(mac) = res {
+                acc.add_macro(ctx, Some(name.to_string()), mac);
+            }
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::completion::{do_completion, CompletionItem, CompletionKind};
+    use insta::assert_debug_snapshot;
+
+    fn do_reference_completion(code: &str) -> Vec<CompletionItem> {
+        do_completion(code, CompletionKind::Reference)
+    }
+
+    #[test]
+    fn completes_macros_as_item() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                "
+                //- /main.rs
+                macro_rules! foo {
+                    () => {}
+                }
+
+                fn foo() {}
+
+                <|>
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "foo!",
+                source_range: [46; 46),
+                delete: [46; 46),
+                insert: "foo!($0)",
+                kind: Macro,
+                detail: "macro_rules! foo",
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
+    fn completes_vec_macros_with_square_brackets() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                "
+                //- /main.rs
+                /// Creates a [`Vec`] containing the arguments.
+                ///
+                /// - Create a [`Vec`] containing a given list of elements:
+                ///
+                /// ```
+                /// let v = vec![1, 2, 3];
+                /// assert_eq!(v[0], 1);
+                /// assert_eq!(v[1], 2);
+                /// assert_eq!(v[2], 3);
+                /// ```
+                macro_rules! vec {
+                    () => {}
+                }
+
+                fn foo() {}
+
+                <|>
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "vec!",
+                source_range: [280; 280),
+                delete: [280; 280),
+                insert: "vec![$0]",
+                kind: Macro,
+                detail: "macro_rules! vec",
+                documentation: Documentation(
+                    "Creates a [`Vec`] containing the arguments.\n\n- Create a [`Vec`] containing a given list of elements:\n\n```\nlet v = vec![1, 2, 3];\nassert_eq!(v[0], 1);\nassert_eq!(v[1], 2);\nassert_eq!(v[2], 3);\n```",
+                ),
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
+    fn completes_macros_braces_guessing() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                "
+                //- /main.rs
+                /// Foo
+                ///
+                /// Not call `fooo!()` `fooo!()`, or `_foo![]` `_foo![]`.
+                /// Call as `let _=foo!  { hello world };`
+                macro_rules! foo {
+                    () => {}
+                }
+
+                fn main() {
+                    <|>
+                }
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "foo!",
+                source_range: [163; 163),
+                delete: [163; 163),
+                insert: "foo! {$0}",
+                kind: Macro,
+                detail: "macro_rules! foo",
+                documentation: Documentation(
+                    "Foo\n\nNot call `fooo!()` `fooo!()`, or `_foo![]` `_foo![]`.\nCall as `let _=foo!  { hello world };`",
+                ),
+            },
+            CompletionItem {
+                label: "main()",
+                source_range: [163; 163),
+                delete: [163; 163),
+                insert: "main()$0",
+                kind: Function,
+                lookup: "main",
+                detail: "fn main()",
+            },
+        ]
+        "###
+        );
+    }
+}
diff --git a/crates/ra_ide/src/completion/complete_path.rs b/crates/ra_ide/src/completion/complete_path.rs
new file mode 100644
index 000000000..89e0009a1
--- /dev/null
+++ b/crates/ra_ide/src/completion/complete_path.rs
@@ -0,0 +1,785 @@
+//! FIXME: write short doc here
+
+use hir::{Adt, Either, HasSource, PathResolution};
+use ra_syntax::AstNode;
+use test_utils::tested_by;
+
+use crate::completion::{CompletionContext, Completions};
+
+pub(super) fn complete_path(acc: &mut Completions, ctx: &CompletionContext) {
+    let path = match &ctx.path_prefix {
+        Some(path) => path.clone(),
+        _ => return,
+    };
+    let def = match ctx.analyzer.resolve_hir_path(ctx.db, &path) {
+        Some(PathResolution::Def(def)) => def,
+        _ => return,
+    };
+    match def {
+        hir::ModuleDef::Module(module) => {
+            let module_scope = module.scope(ctx.db);
+            for (name, def, import) in module_scope {
+                if let hir::ScopeDef::ModuleDef(hir::ModuleDef::BuiltinType(..)) = def {
+                    if ctx.use_item_syntax.is_some() {
+                        tested_by!(dont_complete_primitive_in_use);
+                        continue;
+                    }
+                }
+                if Some(module) == ctx.module {
+                    if let Some(import) = import {
+                        if let Either::A(use_tree) = import.source(ctx.db).value {
+                            if use_tree.syntax().text_range().contains_inclusive(ctx.offset) {
+                                // for `use self::foo<|>`, don't suggest `foo` as a completion
+                                tested_by!(dont_complete_current_use);
+                                continue;
+                            }
+                        }
+                    }
+                }
+                acc.add_resolution(ctx, name.to_string(), &def);
+            }
+        }
+        hir::ModuleDef::Adt(_) | hir::ModuleDef::TypeAlias(_) => {
+            if let hir::ModuleDef::Adt(Adt::Enum(e)) = def {
+                for variant in e.variants(ctx.db) {
+                    acc.add_enum_variant(ctx, variant);
+                }
+            }
+            let ty = match def {
+                hir::ModuleDef::Adt(adt) => adt.ty(ctx.db),
+                hir::ModuleDef::TypeAlias(a) => a.ty(ctx.db),
+                _ => unreachable!(),
+            };
+            ctx.analyzer.iterate_path_candidates(ctx.db, &ty, None, |_ty, item| {
+                match item {
+                    hir::AssocItem::Function(func) => {
+                        if !func.has_self_param(ctx.db) {
+                            acc.add_function(ctx, func);
+                        }
+                    }
+                    hir::AssocItem::Const(ct) => acc.add_const(ctx, ct),
+                    hir::AssocItem::TypeAlias(ty) => acc.add_type_alias(ctx, ty),
+                }
+                None::<()>
+            });
+            // Iterate assoc types separately
+            // FIXME: complete T::AssocType
+            let krate = ctx.module.map(|m| m.krate());
+            if let Some(krate) = krate {
+                ty.iterate_impl_items(ctx.db, krate, |item| {
+                    match item {
+                        hir::AssocItem::Function(_) | hir::AssocItem::Const(_) => {}
+                        hir::AssocItem::TypeAlias(ty) => acc.add_type_alias(ctx, ty),
+                    }
+                    None::<()>
+                });
+            }
+        }
+        hir::ModuleDef::Trait(t) => {
+            for item in t.items(ctx.db) {
+                match item {
+                    hir::AssocItem::Function(func) => {
+                        if !func.has_self_param(ctx.db) {
+                            acc.add_function(ctx, func);
+                        }
+                    }
+                    hir::AssocItem::Const(ct) => acc.add_const(ctx, ct),
+                    hir::AssocItem::TypeAlias(ty) => acc.add_type_alias(ctx, ty),
+                }
+            }
+        }
+        _ => {}
+    };
+}
+
+#[cfg(test)]
+mod tests {
+    use test_utils::covers;
+
+    use crate::completion::{do_completion, CompletionItem, CompletionKind};
+    use insta::assert_debug_snapshot;
+
+    fn do_reference_completion(code: &str) -> Vec<CompletionItem> {
+        do_completion(code, CompletionKind::Reference)
+    }
+
+    #[test]
+    fn dont_complete_current_use() {
+        covers!(dont_complete_current_use);
+        let completions = do_completion(r"use self::foo<|>;", CompletionKind::Reference);
+        assert!(completions.is_empty());
+    }
+
+    #[test]
+    fn dont_complete_current_use_in_braces_with_glob() {
+        let completions = do_completion(
+            r"
+            mod foo { pub struct S; }
+            use self::{foo::*, bar<|>};
+            ",
+            CompletionKind::Reference,
+        );
+        assert_eq!(completions.len(), 2);
+    }
+
+    #[test]
+    fn dont_complete_primitive_in_use() {
+        covers!(dont_complete_primitive_in_use);
+        let completions = do_completion(r"use self::<|>;", CompletionKind::BuiltinType);
+        assert!(completions.is_empty());
+    }
+
+    #[test]
+    fn completes_primitives() {
+        let completions =
+            do_completion(r"fn main() { let _: <|> = 92; }", CompletionKind::BuiltinType);
+        assert_eq!(completions.len(), 17);
+    }
+
+    #[test]
+    fn completes_mod_with_docs() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                r"
+                use self::my<|>;
+
+                /// Some simple
+                /// docs describing `mod my`.
+                mod my {
+                    struct Bar;
+                }
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "my",
+                source_range: [27; 29),
+                delete: [27; 29),
+                insert: "my",
+                kind: Module,
+                documentation: Documentation(
+                    "Some simple\ndocs describing `mod my`.",
+                ),
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
+    fn completes_use_item_starting_with_self() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                r"
+                use self::m::<|>;
+
+                mod m {
+                    struct Bar;
+                }
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "Bar",
+                source_range: [30; 30),
+                delete: [30; 30),
+                insert: "Bar",
+                kind: Struct,
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
+    fn completes_use_item_starting_with_crate() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                "
+                //- /lib.rs
+                mod foo;
+                struct Spam;
+                //- /foo.rs
+                use crate::Sp<|>
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "Spam",
+                source_range: [11; 13),
+                delete: [11; 13),
+                insert: "Spam",
+                kind: Struct,
+            },
+            CompletionItem {
+                label: "foo",
+                source_range: [11; 13),
+                delete: [11; 13),
+                insert: "foo",
+                kind: Module,
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
+    fn completes_nested_use_tree() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                "
+                //- /lib.rs
+                mod foo;
+                struct Spam;
+                //- /foo.rs
+                use crate::{Sp<|>};
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "Spam",
+                source_range: [12; 14),
+                delete: [12; 14),
+                insert: "Spam",
+                kind: Struct,
+            },
+            CompletionItem {
+                label: "foo",
+                source_range: [12; 14),
+                delete: [12; 14),
+                insert: "foo",
+                kind: Module,
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
+    fn completes_deeply_nested_use_tree() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                "
+                //- /lib.rs
+                mod foo;
+                pub mod bar {
+                    pub mod baz {
+                        pub struct Spam;
+                    }
+                }
+                //- /foo.rs
+                use crate::{bar::{baz::Sp<|>}};
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "Spam",
+                source_range: [23; 25),
+                delete: [23; 25),
+                insert: "Spam",
+                kind: Struct,
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
+    fn completes_enum_variant() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                "
+                //- /lib.rs
+                /// An enum
+                enum E {
+                    /// Foo Variant
+                    Foo,
+                    /// Bar Variant with i32
+                    Bar(i32)
+                }
+                fn foo() { let _ = E::<|> }
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "Bar",
+                source_range: [116; 116),
+                delete: [116; 116),
+                insert: "Bar",
+                kind: EnumVariant,
+                detail: "(i32)",
+                documentation: Documentation(
+                    "Bar Variant with i32",
+                ),
+            },
+            CompletionItem {
+                label: "Foo",
+                source_range: [116; 116),
+                delete: [116; 116),
+                insert: "Foo",
+                kind: EnumVariant,
+                detail: "()",
+                documentation: Documentation(
+                    "Foo Variant",
+                ),
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
+    fn completes_enum_variant_with_details() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                "
+                //- /lib.rs
+                struct S { field: u32 }
+                /// An enum
+                enum E {
+                    /// Foo Variant (empty)
+                    Foo,
+                    /// Bar Variant with i32 and u32
+                    Bar(i32, u32),
+                    ///
+                    S(S),
+                }
+                fn foo() { let _ = E::<|> }
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "Bar",
+                source_range: [180; 180),
+                delete: [180; 180),
+                insert: "Bar",
+                kind: EnumVariant,
+                detail: "(i32, u32)",
+                documentation: Documentation(
+                    "Bar Variant with i32 and u32",
+                ),
+            },
+            CompletionItem {
+                label: "Foo",
+                source_range: [180; 180),
+                delete: [180; 180),
+                insert: "Foo",
+                kind: EnumVariant,
+                detail: "()",
+                documentation: Documentation(
+                    "Foo Variant (empty)",
+                ),
+            },
+            CompletionItem {
+                label: "S",
+                source_range: [180; 180),
+                delete: [180; 180),
+                insert: "S",
+                kind: EnumVariant,
+                detail: "(S)",
+                documentation: Documentation(
+                    "",
+                ),
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
+    fn completes_struct_associated_method() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                "
+                //- /lib.rs
+                /// A Struct
+                struct S;
+
+                impl S {
+                    /// An associated method
+                    fn m() { }
+                }
+
+                fn foo() { let _ = S::<|> }
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "m()",
+                source_range: [100; 100),
+                delete: [100; 100),
+                insert: "m()$0",
+                kind: Function,
+                lookup: "m",
+                detail: "fn m()",
+                documentation: Documentation(
+                    "An associated method",
+                ),
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
+    fn completes_struct_associated_const() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                "
+                //- /lib.rs
+                /// A Struct
+                struct S;
+
+                impl S {
+                    /// An associated const
+                    const C: i32 = 42;
+                }
+
+                fn foo() { let _ = S::<|> }
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "C",
+                source_range: [107; 107),
+                delete: [107; 107),
+                insert: "C",
+                kind: Const,
+                detail: "const C: i32 = 42;",
+                documentation: Documentation(
+                    "An associated const",
+                ),
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
+    fn completes_struct_associated_type() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                "
+                //- /lib.rs
+                /// A Struct
+                struct S;
+
+                impl S {
+                    /// An associated type
+                    type T = i32;
+                }
+
+                fn foo() { let _ = S::<|> }
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "T",
+                source_range: [101; 101),
+                delete: [101; 101),
+                insert: "T",
+                kind: TypeAlias,
+                detail: "type T = i32;",
+                documentation: Documentation(
+                    "An associated type",
+                ),
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
+    fn completes_enum_associated_method() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                "
+                //- /lib.rs
+                /// An enum
+                enum S {};
+
+                impl S {
+                    /// An associated method
+                    fn m() { }
+                }
+
+                fn foo() { let _ = S::<|> }
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "m()",
+                source_range: [100; 100),
+                delete: [100; 100),
+                insert: "m()$0",
+                kind: Function,
+                lookup: "m",
+                detail: "fn m()",
+                documentation: Documentation(
+                    "An associated method",
+                ),
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
+    fn completes_union_associated_method() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                "
+                //- /lib.rs
+                /// A union
+                union U {};
+
+                impl U {
+                    /// An associated method
+                    fn m() { }
+                }
+
+                fn foo() { let _ = U::<|> }
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "m()",
+                source_range: [101; 101),
+                delete: [101; 101),
+                insert: "m()$0",
+                kind: Function,
+                lookup: "m",
+                detail: "fn m()",
+                documentation: Documentation(
+                    "An associated method",
+                ),
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
+    fn completes_use_paths_across_crates() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                "
+                //- /main.rs
+                use foo::<|>;
+
+                //- /foo/lib.rs
+                pub mod bar {
+                    pub struct S;
+                }
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "bar",
+                source_range: [9; 9),
+                delete: [9; 9),
+                insert: "bar",
+                kind: Module,
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
+    fn completes_trait_associated_method_1() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                "
+                //- /lib.rs
+                trait Trait {
+                  /// A trait method
+                  fn m();
+                }
+
+                fn foo() { let _ = Trait::<|> }
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "m()",
+                source_range: [73; 73),
+                delete: [73; 73),
+                insert: "m()$0",
+                kind: Function,
+                lookup: "m",
+                detail: "fn m()",
+                documentation: Documentation(
+                    "A trait method",
+                ),
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
+    fn completes_trait_associated_method_2() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                "
+                //- /lib.rs
+                trait Trait {
+                  /// A trait method
+                  fn m();
+                }
+
+                struct S;
+                impl Trait for S {}
+
+                fn foo() { let _ = S::<|> }
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "m()",
+                source_range: [99; 99),
+                delete: [99; 99),
+                insert: "m()$0",
+                kind: Function,
+                lookup: "m",
+                detail: "fn m()",
+                documentation: Documentation(
+                    "A trait method",
+                ),
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
+    fn completes_trait_associated_method_3() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                "
+                //- /lib.rs
+                trait Trait {
+                  /// A trait method
+                  fn m();
+                }
+
+                struct S;
+                impl Trait for S {}
+
+                fn foo() { let _ = <S as Trait>::<|> }
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "m()",
+                source_range: [110; 110),
+                delete: [110; 110),
+                insert: "m()$0",
+                kind: Function,
+                lookup: "m",
+                detail: "fn m()",
+                documentation: Documentation(
+                    "A trait method",
+                ),
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
+    fn completes_type_alias() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                "
+                struct S;
+                impl S { fn foo() {} }
+                type T = S;
+                impl T { fn bar() {} }
+
+                fn main() {
+                    T::<|>;
+                }
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "bar()",
+                source_range: [185; 185),
+                delete: [185; 185),
+                insert: "bar()$0",
+                kind: Function,
+                lookup: "bar",
+                detail: "fn bar()",
+            },
+            CompletionItem {
+                label: "foo()",
+                source_range: [185; 185),
+                delete: [185; 185),
+                insert: "foo()$0",
+                kind: Function,
+                lookup: "foo",
+                detail: "fn foo()",
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
+    fn completes_qualified_macros() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                "
+                #[macro_export]
+                macro_rules! foo {
+                    () => {}
+                }
+
+                fn main() {
+                    let _ = crate::<|>
+                }
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "foo!",
+                source_range: [179; 179),
+                delete: [179; 179),
+                insert: "foo!($0)",
+                kind: Macro,
+                detail: "#[macro_export]\nmacro_rules! foo",
+            },
+            CompletionItem {
+                label: "main()",
+                source_range: [179; 179),
+                delete: [179; 179),
+                insert: "main()$0",
+                kind: Function,
+                lookup: "main",
+                detail: "fn main()",
+            },
+        ]
+        "###
+        );
+    }
+}
diff --git a/crates/ra_ide/src/completion/complete_pattern.rs b/crates/ra_ide/src/completion/complete_pattern.rs
new file mode 100644
index 000000000..fd03b1c40
--- /dev/null
+++ b/crates/ra_ide/src/completion/complete_pattern.rs
@@ -0,0 +1,89 @@
+//! 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 {
+        return;
+    }
+    // FIXME: ideally, we should look at the type we are matching against and
+    // suggest variants + auto-imports
+    ctx.analyzer.process_all_names(ctx.db, &mut |name, res| {
+        let def = match &res {
+            hir::ScopeDef::ModuleDef(def) => def,
+            _ => return,
+        };
+        match def {
+            hir::ModuleDef::Adt(hir::Adt::Enum(..))
+            | hir::ModuleDef::EnumVariant(..)
+            | hir::ModuleDef::Const(..)
+            | hir::ModuleDef::Module(..) => (),
+            _ => return,
+        }
+        acc.add_resolution(ctx, name.to_string(), &res)
+    });
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::completion::{do_completion, CompletionItem, CompletionKind};
+    use insta::assert_debug_snapshot;
+
+    fn complete(code: &str) -> Vec<CompletionItem> {
+        do_completion(code, CompletionKind::Reference)
+    }
+
+    #[test]
+    fn completes_enum_variants_and_modules() {
+        let completions = complete(
+            r"
+            enum E { X }
+            use self::E::X;
+            const Z: E = E::X;
+            mod m {}
+
+            static FOO: E = E::X;
+            struct Bar { f: u32 }
+
+            fn foo() {
+               match E::X {
+                   <|>
+               }
+            }
+            ",
+        );
+        assert_debug_snapshot!(completions, @r###"
+        [
+            CompletionItem {
+                label: "E",
+                source_range: [246; 246),
+                delete: [246; 246),
+                insert: "E",
+                kind: Enum,
+            },
+            CompletionItem {
+                label: "X",
+                source_range: [246; 246),
+                delete: [246; 246),
+                insert: "X",
+                kind: EnumVariant,
+            },
+            CompletionItem {
+                label: "Z",
+                source_range: [246; 246),
+                delete: [246; 246),
+                insert: "Z",
+                kind: Const,
+            },
+            CompletionItem {
+                label: "m",
+                source_range: [246; 246),
+                delete: [246; 246),
+                insert: "m",
+                kind: Module,
+            },
+        ]
+        "###);
+    }
+}
diff --git a/crates/ra_ide/src/completion/complete_postfix.rs b/crates/ra_ide/src/completion/complete_postfix.rs
new file mode 100644
index 000000000..646a30c76
--- /dev/null
+++ b/crates/ra_ide/src/completion/complete_postfix.rs
@@ -0,0 +1,282 @@
+//! FIXME: write short doc here
+
+use ra_syntax::{ast::AstNode, TextRange, TextUnit};
+use ra_text_edit::TextEdit;
+
+use crate::{
+    completion::{
+        completion_context::CompletionContext,
+        completion_item::{Builder, CompletionKind, Completions},
+    },
+    CompletionItem,
+};
+
+pub(super) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
+    if ctx.db.feature_flags.get("completion.enable-postfix") == false {
+        return;
+    }
+
+    let dot_receiver = match &ctx.dot_receiver {
+        Some(it) => it,
+        None => return,
+    };
+
+    let receiver_text = if ctx.dot_receiver_is_ambiguous_float_literal {
+        let text = dot_receiver.syntax().text();
+        let without_dot = ..text.len() - TextUnit::of_char('.');
+        text.slice(without_dot).to_string()
+    } else {
+        dot_receiver.syntax().text().to_string()
+    };
+
+    let receiver_ty = match ctx.analyzer.type_of(ctx.db, &dot_receiver) {
+        Some(it) => it,
+        None => return,
+    };
+
+    if receiver_ty.is_bool() || receiver_ty.is_unknown() {
+        postfix_snippet(ctx, "if", "if expr {}", &format!("if {} {{$0}}", receiver_text))
+            .add_to(acc);
+        postfix_snippet(
+            ctx,
+            "while",
+            "while expr {}",
+            &format!("while {} {{\n$0\n}}", receiver_text),
+        )
+        .add_to(acc);
+    }
+
+    postfix_snippet(ctx, "not", "!expr", &format!("!{}", receiver_text)).add_to(acc);
+
+    postfix_snippet(ctx, "ref", "&expr", &format!("&{}", receiver_text)).add_to(acc);
+    postfix_snippet(ctx, "refm", "&mut expr", &format!("&mut {}", receiver_text)).add_to(acc);
+
+    postfix_snippet(
+        ctx,
+        "match",
+        "match expr {}",
+        &format!("match {} {{\n    ${{1:_}} => {{$0\\}},\n}}", receiver_text),
+    )
+    .add_to(acc);
+
+    postfix_snippet(ctx, "dbg", "dbg!(expr)", &format!("dbg!({})", receiver_text)).add_to(acc);
+
+    postfix_snippet(ctx, "box", "Box::new(expr)", &format!("Box::new({})", receiver_text))
+        .add_to(acc);
+}
+
+fn postfix_snippet(ctx: &CompletionContext, label: &str, detail: &str, snippet: &str) -> Builder {
+    let edit = {
+        let receiver_range =
+            ctx.dot_receiver.as_ref().expect("no receiver available").syntax().text_range();
+        let delete_range = TextRange::from_to(receiver_range.start(), ctx.source_range().end());
+        TextEdit::replace(delete_range, snippet.to_string())
+    };
+    CompletionItem::new(CompletionKind::Postfix, ctx.source_range(), label)
+        .detail(detail)
+        .snippet_edit(edit)
+}
+
+#[cfg(test)]
+mod tests {
+    use insta::assert_debug_snapshot;
+
+    use crate::completion::{do_completion, CompletionItem, CompletionKind};
+
+    fn do_postfix_completion(code: &str) -> Vec<CompletionItem> {
+        do_completion(code, CompletionKind::Postfix)
+    }
+
+    #[test]
+    fn postfix_completion_works_for_trivial_path_expression() {
+        assert_debug_snapshot!(
+            do_postfix_completion(
+                r#"
+                fn main() {
+                    let bar = true;
+                    bar.<|>
+                }
+                "#,
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "box",
+                source_range: [89; 89),
+                delete: [85; 89),
+                insert: "Box::new(bar)",
+                detail: "Box::new(expr)",
+            },
+            CompletionItem {
+                label: "dbg",
+                source_range: [89; 89),
+                delete: [85; 89),
+                insert: "dbg!(bar)",
+                detail: "dbg!(expr)",
+            },
+            CompletionItem {
+                label: "if",
+                source_range: [89; 89),
+                delete: [85; 89),
+                insert: "if bar {$0}",
+                detail: "if expr {}",
+            },
+            CompletionItem {
+                label: "match",
+                source_range: [89; 89),
+                delete: [85; 89),
+                insert: "match bar {\n    ${1:_} => {$0\\},\n}",
+                detail: "match expr {}",
+            },
+            CompletionItem {
+                label: "not",
+                source_range: [89; 89),
+                delete: [85; 89),
+                insert: "!bar",
+                detail: "!expr",
+            },
+            CompletionItem {
+                label: "ref",
+                source_range: [89; 89),
+                delete: [85; 89),
+                insert: "&bar",
+                detail: "&expr",
+            },
+            CompletionItem {
+                label: "refm",
+                source_range: [89; 89),
+                delete: [85; 89),
+                insert: "&mut bar",
+                detail: "&mut expr",
+            },
+            CompletionItem {
+                label: "while",
+                source_range: [89; 89),
+                delete: [85; 89),
+                insert: "while bar {\n$0\n}",
+                detail: "while expr {}",
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
+    fn some_postfix_completions_ignored() {
+        assert_debug_snapshot!(
+            do_postfix_completion(
+                r#"
+                fn main() {
+                    let bar: u8 = 12;
+                    bar.<|>
+                }
+                "#,
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "box",
+                source_range: [91; 91),
+                delete: [87; 91),
+                insert: "Box::new(bar)",
+                detail: "Box::new(expr)",
+            },
+            CompletionItem {
+                label: "dbg",
+                source_range: [91; 91),
+                delete: [87; 91),
+                insert: "dbg!(bar)",
+                detail: "dbg!(expr)",
+            },
+            CompletionItem {
+                label: "match",
+                source_range: [91; 91),
+                delete: [87; 91),
+                insert: "match bar {\n    ${1:_} => {$0\\},\n}",
+                detail: "match expr {}",
+            },
+            CompletionItem {
+                label: "not",
+                source_range: [91; 91),
+                delete: [87; 91),
+                insert: "!bar",
+                detail: "!expr",
+            },
+            CompletionItem {
+                label: "ref",
+                source_range: [91; 91),
+                delete: [87; 91),
+                insert: "&bar",
+                detail: "&expr",
+            },
+            CompletionItem {
+                label: "refm",
+                source_range: [91; 91),
+                delete: [87; 91),
+                insert: "&mut bar",
+                detail: "&mut expr",
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
+    fn postfix_completion_works_for_ambiguous_float_literal() {
+        assert_debug_snapshot!(
+            do_postfix_completion(
+                r#"
+                fn main() {
+                    42.<|>
+                }
+                "#,
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "box",
+                source_range: [52; 52),
+                delete: [49; 52),
+                insert: "Box::new(42)",
+                detail: "Box::new(expr)",
+            },
+            CompletionItem {
+                label: "dbg",
+                source_range: [52; 52),
+                delete: [49; 52),
+                insert: "dbg!(42)",
+                detail: "dbg!(expr)",
+            },
+            CompletionItem {
+                label: "match",
+                source_range: [52; 52),
+                delete: [49; 52),
+                insert: "match 42 {\n    ${1:_} => {$0\\},\n}",
+                detail: "match expr {}",
+            },
+            CompletionItem {
+                label: "not",
+                source_range: [52; 52),
+                delete: [49; 52),
+                insert: "!42",
+                detail: "!expr",
+            },
+            CompletionItem {
+                label: "ref",
+                source_range: [52; 52),
+                delete: [49; 52),
+                insert: "&42",
+                detail: "&expr",
+            },
+            CompletionItem {
+                label: "refm",
+                source_range: [52; 52),
+                delete: [49; 52),
+                insert: "&mut 42",
+                detail: "&mut expr",
+            },
+        ]
+        "###
+        );
+    }
+}
diff --git a/crates/ra_ide/src/completion/complete_record_literal.rs b/crates/ra_ide/src/completion/complete_record_literal.rs
new file mode 100644
index 000000000..577c394d2
--- /dev/null
+++ b/crates/ra_ide/src/completion/complete_record_literal.rs
@@ -0,0 +1,159 @@
+//! FIXME: write short doc here
+
+use crate::completion::{CompletionContext, Completions};
+
+/// Complete fields in fields literals.
+pub(super) fn complete_record_literal(acc: &mut Completions, ctx: &CompletionContext) {
+    let (ty, variant) = match ctx.record_lit_syntax.as_ref().and_then(|it| {
+        Some((
+            ctx.analyzer.type_of(ctx.db, &it.clone().into())?,
+            ctx.analyzer.resolve_record_literal(it)?,
+        ))
+    }) {
+        Some(it) => it,
+        _ => return,
+    };
+
+    for (field, field_ty) in ty.variant_fields(ctx.db, variant) {
+        acc.add_field(ctx, field, &field_ty);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::completion::{do_completion, CompletionItem, CompletionKind};
+    use insta::assert_debug_snapshot;
+
+    fn complete(code: &str) -> Vec<CompletionItem> {
+        do_completion(code, CompletionKind::Reference)
+    }
+
+    #[test]
+    fn test_record_literal_deprecated_field() {
+        let completions = complete(
+            r"
+            struct A {
+                #[deprecated]
+                the_field: u32,
+            }
+            fn foo() {
+               A { the<|> }
+            }
+            ",
+        );
+        assert_debug_snapshot!(completions, @r###"
+        [
+            CompletionItem {
+                label: "the_field",
+                source_range: [142; 145),
+                delete: [142; 145),
+                insert: "the_field",
+                kind: Field,
+                detail: "u32",
+                deprecated: true,
+            },
+        ]
+        "###);
+    }
+
+    #[test]
+    fn test_record_literal_field() {
+        let completions = complete(
+            r"
+            struct A { the_field: u32 }
+            fn foo() {
+               A { the<|> }
+            }
+            ",
+        );
+        assert_debug_snapshot!(completions, @r###"
+        [
+            CompletionItem {
+                label: "the_field",
+                source_range: [83; 86),
+                delete: [83; 86),
+                insert: "the_field",
+                kind: Field,
+                detail: "u32",
+            },
+        ]
+        "###);
+    }
+
+    #[test]
+    fn test_record_literal_enum_variant() {
+        let completions = complete(
+            r"
+            enum E {
+                A { a: u32 }
+            }
+            fn foo() {
+                let _ = E::A { <|> }
+            }
+            ",
+        );
+        assert_debug_snapshot!(completions, @r###"
+        [
+            CompletionItem {
+                label: "a",
+                source_range: [119; 119),
+                delete: [119; 119),
+                insert: "a",
+                kind: Field,
+                detail: "u32",
+            },
+        ]
+        "###);
+    }
+
+    #[test]
+    fn test_record_literal_two_structs() {
+        let completions = complete(
+            r"
+            struct A { a: u32 }
+            struct B { b: u32 }
+
+            fn foo() {
+               let _: A = B { <|> }
+            }
+            ",
+        );
+        assert_debug_snapshot!(completions, @r###"
+        [
+            CompletionItem {
+                label: "b",
+                source_range: [119; 119),
+                delete: [119; 119),
+                insert: "b",
+                kind: Field,
+                detail: "u32",
+            },
+        ]
+        "###);
+    }
+
+    #[test]
+    fn test_record_literal_generic_struct() {
+        let completions = complete(
+            r"
+            struct A<T> { a: T }
+
+            fn foo() {
+               let _: A<u32> = A { <|> }
+            }
+            ",
+        );
+        assert_debug_snapshot!(completions, @r###"
+        [
+            CompletionItem {
+                label: "a",
+                source_range: [93; 93),
+                delete: [93; 93),
+                insert: "a",
+                kind: Field,
+                detail: "u32",
+            },
+        ]
+        "###);
+    }
+}
diff --git a/crates/ra_ide/src/completion/complete_record_pattern.rs b/crates/ra_ide/src/completion/complete_record_pattern.rs
new file mode 100644
index 000000000..a56c7e3a1
--- /dev/null
+++ b/crates/ra_ide/src/completion/complete_record_pattern.rs
@@ -0,0 +1,93 @@
+//! FIXME: write short doc here
+
+use crate::completion::{CompletionContext, Completions};
+
+pub(super) fn complete_record_pattern(acc: &mut Completions, ctx: &CompletionContext) {
+    let (ty, variant) = match ctx.record_lit_pat.as_ref().and_then(|it| {
+        Some((
+            ctx.analyzer.type_of_pat(ctx.db, &it.clone().into())?,
+            ctx.analyzer.resolve_record_pattern(it)?,
+        ))
+    }) {
+        Some(it) => it,
+        _ => return,
+    };
+
+    for (field, field_ty) in ty.variant_fields(ctx.db, variant) {
+        acc.add_field(ctx, field, &field_ty);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::completion::{do_completion, CompletionItem, CompletionKind};
+    use insta::assert_debug_snapshot;
+
+    fn complete(code: &str) -> Vec<CompletionItem> {
+        do_completion(code, CompletionKind::Reference)
+    }
+
+    #[test]
+    fn test_record_pattern_field() {
+        let completions = complete(
+            r"
+            struct S { foo: u32 }
+
+            fn process(f: S) {
+                match f {
+                    S { f<|>: 92 } => (),
+                }
+            }
+            ",
+        );
+        assert_debug_snapshot!(completions, @r###"
+        [
+            CompletionItem {
+                label: "foo",
+                source_range: [117; 118),
+                delete: [117; 118),
+                insert: "foo",
+                kind: Field,
+                detail: "u32",
+            },
+        ]
+        "###);
+    }
+
+    #[test]
+    fn test_record_pattern_enum_variant() {
+        let completions = complete(
+            r"
+            enum E {
+                S { foo: u32, bar: () }
+            }
+
+            fn process(e: E) {
+                match e {
+                    E::S { <|> } => (),
+                }
+            }
+            ",
+        );
+        assert_debug_snapshot!(completions, @r###"
+        [
+            CompletionItem {
+                label: "bar",
+                source_range: [161; 161),
+                delete: [161; 161),
+                insert: "bar",
+                kind: Field,
+                detail: "()",
+            },
+            CompletionItem {
+                label: "foo",
+                source_range: [161; 161),
+                delete: [161; 161),
+                insert: "foo",
+                kind: Field,
+                detail: "u32",
+            },
+        ]
+        "###);
+    }
+}
diff --git a/crates/ra_ide/src/completion/complete_scope.rs b/crates/ra_ide/src/completion/complete_scope.rs
new file mode 100644
index 000000000..d5739b58a
--- /dev/null
+++ b/crates/ra_ide/src/completion/complete_scope.rs
@@ -0,0 +1,876 @@
+//! FIXME: write short doc here
+
+use ra_assists::auto_import_text_edit;
+use ra_syntax::{ast, AstNode, SmolStr};
+use ra_text_edit::TextEditBuilder;
+use rustc_hash::FxHashMap;
+
+use crate::completion::{CompletionContext, CompletionItem, CompletionKind, Completions};
+
+pub(super) fn complete_scope(acc: &mut Completions, ctx: &CompletionContext) {
+    if !ctx.is_trivial_path {
+        return;
+    }
+
+    ctx.analyzer.process_all_names(ctx.db, &mut |name, res| {
+        acc.add_resolution(ctx, name.to_string(), &res)
+    });
+
+    // auto-import
+    // We fetch ident from the original file, because we need to pre-filter auto-imports
+    if ast::NameRef::cast(ctx.token.parent()).is_some() {
+        let import_resolver = ImportResolver::new();
+        let import_names = import_resolver.all_names(ctx.token.text());
+        import_names.into_iter().for_each(|(name, path)| {
+            let edit = {
+                let mut builder = TextEditBuilder::default();
+                builder.replace(ctx.source_range(), name.to_string());
+                auto_import_text_edit(
+                    &ctx.token.parent(),
+                    &ctx.token.parent(),
+                    &path,
+                    &mut builder,
+                );
+                builder.finish()
+            };
+
+            // Hack: copied this check form conv.rs beacause auto import can produce edits
+            // that invalidate assert in conv_with.
+            if edit
+                .as_atoms()
+                .iter()
+                .filter(|atom| !ctx.source_range().is_subrange(&atom.delete))
+                .all(|atom| ctx.source_range().intersection(&atom.delete).is_none())
+            {
+                CompletionItem::new(
+                    CompletionKind::Reference,
+                    ctx.source_range(),
+                    build_import_label(&name, &path),
+                )
+                .text_edit(edit)
+                .add_to(acc);
+            }
+        });
+    }
+}
+
+fn build_import_label(name: &str, path: &[SmolStr]) -> String {
+    let mut buf = String::with_capacity(64);
+    buf.push_str(name);
+    buf.push_str(" (");
+    fmt_import_path(path, &mut buf);
+    buf.push_str(")");
+    buf
+}
+
+fn fmt_import_path(path: &[SmolStr], buf: &mut String) {
+    let mut segments = path.iter();
+    if let Some(s) = segments.next() {
+        buf.push_str(&s);
+    }
+    for s in segments {
+        buf.push_str("::");
+        buf.push_str(&s);
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub(crate) struct ImportResolver {
+    // todo: use fst crate or something like that
+    dummy_names: Vec<(SmolStr, Vec<SmolStr>)>,
+}
+
+impl ImportResolver {
+    pub(crate) fn new() -> Self {
+        let dummy_names = vec![
+            (SmolStr::new("fmt"), vec![SmolStr::new("std"), SmolStr::new("fmt")]),
+            (SmolStr::new("io"), vec![SmolStr::new("std"), SmolStr::new("io")]),
+            (SmolStr::new("iter"), vec![SmolStr::new("std"), SmolStr::new("iter")]),
+            (SmolStr::new("hash"), vec![SmolStr::new("std"), SmolStr::new("hash")]),
+            (
+                SmolStr::new("Debug"),
+                vec![SmolStr::new("std"), SmolStr::new("fmt"), SmolStr::new("Debug")],
+            ),
+            (
+                SmolStr::new("Display"),
+                vec![SmolStr::new("std"), SmolStr::new("fmt"), SmolStr::new("Display")],
+            ),
+            (
+                SmolStr::new("Hash"),
+                vec![SmolStr::new("std"), SmolStr::new("hash"), SmolStr::new("Hash")],
+            ),
+            (
+                SmolStr::new("Hasher"),
+                vec![SmolStr::new("std"), SmolStr::new("hash"), SmolStr::new("Hasher")],
+            ),
+            (
+                SmolStr::new("Iterator"),
+                vec![SmolStr::new("std"), SmolStr::new("iter"), SmolStr::new("Iterator")],
+            ),
+        ];
+
+        ImportResolver { dummy_names }
+    }
+
+    // Returns a map of importable items filtered by name.
+    // The map associates item name with its full path.
+    // todo: should return Resolutions
+    pub(crate) fn all_names(&self, name: &str) -> FxHashMap<SmolStr, Vec<SmolStr>> {
+        if name.len() > 1 {
+            self.dummy_names.iter().filter(|(n, _)| n.contains(name)).cloned().collect()
+        } else {
+            FxHashMap::default()
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::completion::{do_completion, CompletionItem, CompletionKind};
+    use insta::assert_debug_snapshot;
+
+    fn do_reference_completion(code: &str) -> Vec<CompletionItem> {
+        do_completion(code, CompletionKind::Reference)
+    }
+
+    #[test]
+    fn completes_bindings_from_let() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                r"
+                fn quux(x: i32) {
+                    let y = 92;
+                    1 + <|>;
+                    let z = ();
+                }
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "quux(…)",
+                source_range: [91; 91),
+                delete: [91; 91),
+                insert: "quux($0)",
+                kind: Function,
+                lookup: "quux",
+                detail: "fn quux(x: i32)",
+            },
+            CompletionItem {
+                label: "x",
+                source_range: [91; 91),
+                delete: [91; 91),
+                insert: "x",
+                kind: Binding,
+                detail: "i32",
+            },
+            CompletionItem {
+                label: "y",
+                source_range: [91; 91),
+                delete: [91; 91),
+                insert: "y",
+                kind: Binding,
+                detail: "i32",
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
+    fn completes_bindings_from_if_let() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                r"
+                fn quux() {
+                    if let Some(x) = foo() {
+                        let y = 92;
+                    };
+                    if let Some(a) = bar() {
+                        let b = 62;
+                        1 + <|>
+                    }
+                }
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "a",
+                source_range: [242; 242),
+                delete: [242; 242),
+                insert: "a",
+                kind: Binding,
+            },
+            CompletionItem {
+                label: "b",
+                source_range: [242; 242),
+                delete: [242; 242),
+                insert: "b",
+                kind: Binding,
+                detail: "i32",
+            },
+            CompletionItem {
+                label: "quux()",
+                source_range: [242; 242),
+                delete: [242; 242),
+                insert: "quux()$0",
+                kind: Function,
+                lookup: "quux",
+                detail: "fn quux()",
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
+    fn completes_bindings_from_for() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                r"
+                fn quux() {
+                    for x in &[1, 2, 3] {
+                        <|>
+                    }
+                }
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "quux()",
+                source_range: [95; 95),
+                delete: [95; 95),
+                insert: "quux()$0",
+                kind: Function,
+                lookup: "quux",
+                detail: "fn quux()",
+            },
+            CompletionItem {
+                label: "x",
+                source_range: [95; 95),
+                delete: [95; 95),
+                insert: "x",
+                kind: Binding,
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
+    fn completes_generic_params() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                r"
+                fn quux<T>() {
+                    <|>
+                }
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "T",
+                source_range: [52; 52),
+                delete: [52; 52),
+                insert: "T",
+                kind: TypeParam,
+            },
+            CompletionItem {
+                label: "quux()",
+                source_range: [52; 52),
+                delete: [52; 52),
+                insert: "quux()$0",
+                kind: Function,
+                lookup: "quux",
+                detail: "fn quux<T>()",
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
+    fn completes_generic_params_in_struct() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                r"
+                struct X<T> {
+                    x: <|>
+                }
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "Self",
+                source_range: [54; 54),
+                delete: [54; 54),
+                insert: "Self",
+                kind: TypeParam,
+            },
+            CompletionItem {
+                label: "T",
+                source_range: [54; 54),
+                delete: [54; 54),
+                insert: "T",
+                kind: TypeParam,
+            },
+            CompletionItem {
+                label: "X<…>",
+                source_range: [54; 54),
+                delete: [54; 54),
+                insert: "X<$0>",
+                kind: Struct,
+                lookup: "X",
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
+    fn completes_self_in_enum() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                r"
+                enum X {
+                    Y(<|>)
+                }
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "Self",
+                source_range: [48; 48),
+                delete: [48; 48),
+                insert: "Self",
+                kind: TypeParam,
+            },
+            CompletionItem {
+                label: "X",
+                source_range: [48; 48),
+                delete: [48; 48),
+                insert: "X",
+                kind: Enum,
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
+    fn completes_module_items() {
+        assert_debug_snapshot!(
+        do_reference_completion(
+            r"
+                struct Foo;
+                enum Baz {}
+                fn quux() {
+                    <|>
+                }
+                "
+        ),
+        @r###"
+        [
+            CompletionItem {
+                label: "Baz",
+                source_range: [105; 105),
+                delete: [105; 105),
+                insert: "Baz",
+                kind: Enum,
+            },
+            CompletionItem {
+                label: "Foo",
+                source_range: [105; 105),
+                delete: [105; 105),
+                insert: "Foo",
+                kind: Struct,
+            },
+            CompletionItem {
+                label: "quux()",
+                source_range: [105; 105),
+                delete: [105; 105),
+                insert: "quux()$0",
+                kind: Function,
+                lookup: "quux",
+                detail: "fn quux()",
+            },
+        ]
+        "###
+            );
+    }
+
+    #[test]
+    fn completes_extern_prelude() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                r"
+                //- /lib.rs
+                use <|>;
+
+                //- /other_crate/lib.rs
+                // nothing here
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "other_crate",
+                source_range: [4; 4),
+                delete: [4; 4),
+                insert: "other_crate",
+                kind: Module,
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
+    fn completes_module_items_in_nested_modules() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                r"
+                struct Foo;
+                mod m {
+                    struct Bar;
+                    fn quux() { <|> }
+                }
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "Bar",
+                source_range: [117; 117),
+                delete: [117; 117),
+                insert: "Bar",
+                kind: Struct,
+            },
+            CompletionItem {
+                label: "quux()",
+                source_range: [117; 117),
+                delete: [117; 117),
+                insert: "quux()$0",
+                kind: Function,
+                lookup: "quux",
+                detail: "fn quux()",
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
+    fn completes_return_type() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                r"
+                struct Foo;
+                fn x() -> <|>
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "Foo",
+                source_range: [55; 55),
+                delete: [55; 55),
+                insert: "Foo",
+                kind: Struct,
+            },
+            CompletionItem {
+                label: "x()",
+                source_range: [55; 55),
+                delete: [55; 55),
+                insert: "x()$0",
+                kind: Function,
+                lookup: "x",
+                detail: "fn x()",
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
+    fn dont_show_both_completions_for_shadowing() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                r"
+                fn foo() {
+                    let bar = 92;
+                    {
+                        let bar = 62;
+                        <|>
+                    }
+                }
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "bar",
+                source_range: [146; 146),
+                delete: [146; 146),
+                insert: "bar",
+                kind: Binding,
+                detail: "i32",
+            },
+            CompletionItem {
+                label: "foo()",
+                source_range: [146; 146),
+                delete: [146; 146),
+                insert: "foo()$0",
+                kind: Function,
+                lookup: "foo",
+                detail: "fn foo()",
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
+    fn completes_self_in_methods() {
+        assert_debug_snapshot!(
+            do_reference_completion(r"impl S { fn foo(&self) { <|> } }"),
+            @r###"
+        [
+            CompletionItem {
+                label: "Self",
+                source_range: [25; 25),
+                delete: [25; 25),
+                insert: "Self",
+                kind: TypeParam,
+            },
+            CompletionItem {
+                label: "self",
+                source_range: [25; 25),
+                delete: [25; 25),
+                insert: "self",
+                kind: Binding,
+                detail: "&{unknown}",
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
+    fn completes_prelude() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                "
+                //- /main.rs
+                fn foo() { let x: <|> }
+
+                //- /std/lib.rs
+                #[prelude_import]
+                use prelude::*;
+
+                mod prelude {
+                    struct Option;
+                }
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "Option",
+                source_range: [18; 18),
+                delete: [18; 18),
+                insert: "Option",
+                kind: Struct,
+            },
+            CompletionItem {
+                label: "foo()",
+                source_range: [18; 18),
+                delete: [18; 18),
+                insert: "foo()$0",
+                kind: Function,
+                lookup: "foo",
+                detail: "fn foo()",
+            },
+            CompletionItem {
+                label: "std",
+                source_range: [18; 18),
+                delete: [18; 18),
+                insert: "std",
+                kind: Module,
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
+    fn completes_std_prelude_if_core_is_defined() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                "
+                //- /main.rs
+                fn foo() { let x: <|> }
+
+                //- /core/lib.rs
+                #[prelude_import]
+                use prelude::*;
+
+                mod prelude {
+                    struct Option;
+                }
+
+                //- /std/lib.rs
+                #[prelude_import]
+                use prelude::*;
+
+                mod prelude {
+                    struct String;
+                }
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "String",
+                source_range: [18; 18),
+                delete: [18; 18),
+                insert: "String",
+                kind: Struct,
+            },
+            CompletionItem {
+                label: "core",
+                source_range: [18; 18),
+                delete: [18; 18),
+                insert: "core",
+                kind: Module,
+            },
+            CompletionItem {
+                label: "foo()",
+                source_range: [18; 18),
+                delete: [18; 18),
+                insert: "foo()$0",
+                kind: Function,
+                lookup: "foo",
+                detail: "fn foo()",
+            },
+            CompletionItem {
+                label: "std",
+                source_range: [18; 18),
+                delete: [18; 18),
+                insert: "std",
+                kind: Module,
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
+    fn completes_macros_as_value() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                "
+                //- /main.rs
+                macro_rules! foo {
+                    () => {}
+                }
+
+                #[macro_use]
+                mod m1 {
+                    macro_rules! bar {
+                        () => {}
+                    }
+                }
+
+                mod m2 {
+                    macro_rules! nope {
+                        () => {}
+                    }
+
+                    #[macro_export]
+                    macro_rules! baz {
+                        () => {}
+                    }
+                }
+
+                fn main() {
+                    let v = <|>
+                }
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "bar!",
+                source_range: [252; 252),
+                delete: [252; 252),
+                insert: "bar!($0)",
+                kind: Macro,
+                detail: "macro_rules! bar",
+            },
+            CompletionItem {
+                label: "baz!",
+                source_range: [252; 252),
+                delete: [252; 252),
+                insert: "baz!($0)",
+                kind: Macro,
+                detail: "#[macro_export]\nmacro_rules! baz",
+            },
+            CompletionItem {
+                label: "foo!",
+                source_range: [252; 252),
+                delete: [252; 252),
+                insert: "foo!($0)",
+                kind: Macro,
+                detail: "macro_rules! foo",
+            },
+            CompletionItem {
+                label: "m1",
+                source_range: [252; 252),
+                delete: [252; 252),
+                insert: "m1",
+                kind: Module,
+            },
+            CompletionItem {
+                label: "m2",
+                source_range: [252; 252),
+                delete: [252; 252),
+                insert: "m2",
+                kind: Module,
+            },
+            CompletionItem {
+                label: "main()",
+                source_range: [252; 252),
+                delete: [252; 252),
+                insert: "main()$0",
+                kind: Function,
+                lookup: "main",
+                detail: "fn main()",
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
+    fn completes_both_macro_and_value() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                "
+                //- /main.rs
+                macro_rules! foo {
+                    () => {}
+                }
+
+                fn foo() {
+                    <|>
+                }
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "foo!",
+                source_range: [49; 49),
+                delete: [49; 49),
+                insert: "foo!($0)",
+                kind: Macro,
+                detail: "macro_rules! foo",
+            },
+            CompletionItem {
+                label: "foo()",
+                source_range: [49; 49),
+                delete: [49; 49),
+                insert: "foo()$0",
+                kind: Function,
+                lookup: "foo",
+                detail: "fn foo()",
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
+    fn completes_macros_as_type() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                "
+                //- /main.rs
+                macro_rules! foo {
+                    () => {}
+                }
+
+                fn main() {
+                    let x: <|>
+                }
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "foo!",
+                source_range: [57; 57),
+                delete: [57; 57),
+                insert: "foo!($0)",
+                kind: Macro,
+                detail: "macro_rules! foo",
+            },
+            CompletionItem {
+                label: "main()",
+                source_range: [57; 57),
+                delete: [57; 57),
+                insert: "main()$0",
+                kind: Function,
+                lookup: "main",
+                detail: "fn main()",
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
+    fn completes_macros_as_stmt() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                "
+                //- /main.rs
+                macro_rules! foo {
+                    () => {}
+                }
+
+                fn main() {
+                    <|>
+                }
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "foo!",
+                source_range: [50; 50),
+                delete: [50; 50),
+                insert: "foo!($0)",
+                kind: Macro,
+                detail: "macro_rules! foo",
+            },
+            CompletionItem {
+                label: "main()",
+                source_range: [50; 50),
+                delete: [50; 50),
+                insert: "main()$0",
+                kind: Function,
+                lookup: "main",