313 files changed, 4614 insertions, 1607 deletions
diff --git a/.travis.yml b/.travis.yml
index ece7425fe..5e11cbd2f 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,7 +1,7 @@
 cache: cargo
 before_cache:
  - find ./target/debug -type f -maxdepth 1 -delete
-  - rm -fr ./target/debug/{deps,.fingerprint}/{*ra_*,*test*,*tools*,*gen_lsp*}
+  - rm -fr ./target/debug/{deps,.fingerprint}/{*ra_*,*test*,*tools*,*gen_lsp*,*thread_worker*}
  - rm -f  ./target/.rustc_info.json
 env:
@@ -9,7 +9,7 @@ env:
 build: &rust_build
  language: rust
-  rust: 1.31.0
+  rust: 1.31.1
  script:
    - cargo gen-tests --verify
    - cargo gen-syntax --verify
diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md
index 823db0034..b326f9c71 100644
--- a/ARCHITECTURE.md
+++ b/ARCHITECTURE.md
@@ -20,7 +20,7 @@ memory and never does any IO. Because the input data is source code, which
 typically measures in tens of megabytes at most, keeping all input data in
 memory is OK.
-A "structured semantic model" is basically an object-oriented representations of
+A "structured semantic model" is basically an object-oriented representation of
 modules, functions and types which appear in the source code. This representation
 is fully "resolved": all expressions have types, all references are bound to
 declarations, etc.
@@ -90,29 +90,29 @@ fixes a bug in the grammar.
 We use [salsa][https://github.com/salsa-rs/salsa] crate for incremental and
 on-demand computation. Roughly, you can think of salsa as a key-value store, but
 it also can compute derived values using specified functions. The `ra_db` crate
-provides a basic infrastructure for interracting with salsa. Crucially, it
+provides a basic infrastructure for interacting with salsa. Crucially, it
 defines most of the "input" queries: facts supplied by the client of the
 analyzer. Reading the docs of the `ra_db::input` module should be useful:
-everithing else is strictly derived from thouse inputs.
+everything else is strictly derived from those inputs.
 ### `crates/ra_hir`
-HIR provides a high-level "object oriented" acess to Rust code.
+HIR provides high-level "object oriented" access to Rust code.
 The principal difference between HIR and syntax trees is that HIR is bound to a
 particular crate instance. That is, it has cfg flags and features applied (in
-theory, in practice this is to be implemented). So, there relation between
+theory, in practice this is to be implemented). So, the relation between
 syntax and HIR is many-to-one. The `source_binder` modules is responsible for
-guessing a hir for a particular source position.
+guessing a HIR for a particular source position.
-Underneath, hir works on top of salsa, using a `HirDatabase` trait.
+Underneath, HIR works on top of salsa, using a `HirDatabase` trait.
 ### `crates/ra_analysis`
 A stateful library for analyzing many Rust files as they change.
-`AnalysisHost` is a mutable entity (clojure's atom) which holds
+`AnalysisHost` is a mutable entity (clojure's atom) which holds the
 current state, incorporates changes and handles out `Analysis` --- an
-immutable consistent snapshot of world state at a point in time, which
+immutable and consistent snapshot of world state at a point in time, which
 actually powers analysis.
 One interesting aspect of analysis is its support for cancellation. When a change
@@ -137,7 +137,7 @@ without the need to fiddle with build-systems, file
 synchronization and such.
 In a sense, `ra_editor` is just a bunch of pure functions which take a
-syntax tree as an input.
+syntax tree as input.
 The tests for `ra_editor` are `#[cfg(test)] mod tests` unit-tests spread
 throughout its modules.
diff --git a/Cargo.lock b/Cargo.lock
index 5e5db84c3..5bf946b34 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -334,7 +334,6 @@ dependencies = [
 "languageserver-types 0.53.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.82 (registry+https://github.com/rust-lang/crates.io-index)",
- "serde_derive 1.0.82 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_json 1.0.33 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
@@ -649,7 +648,7 @@ dependencies = [
 "rayon 1.0.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "relative-path 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-hash 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "salsa 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "salsa 0.8.0 (git+https://github.com/matklad/salsa?branch=no-upgrade)",
 "test_utils 0.1.0",
 ]
@@ -674,7 +673,7 @@ dependencies = [
 "ra_syntax 0.1.0",
 "relative-path 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-hash 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "salsa 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "salsa 0.8.0 (git+https://github.com/matklad/salsa?branch=no-upgrade)",
 "test_utils 0.1.0",
 ]
@@ -704,7 +703,7 @@ dependencies = [
 "ra_syntax 0.1.0",
 "relative-path 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-hash 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "salsa 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "salsa 0.8.0 (git+https://github.com/matklad/salsa?branch=no-upgrade)",
 "test_utils 0.1.0",
 ]
@@ -732,9 +731,8 @@ dependencies = [
 "relative-path 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "rustc-hash 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde 1.0.82 (registry+https://github.com/rust-lang/crates.io-index)",
- "serde_derive 1.0.82 (registry+https://github.com/rust-lang/crates.io-index)",
 "serde_json 1.0.33 (registry+https://github.com/rust-lang/crates.io-index)",
- "smol_str 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
+ "smol_str 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "tempdir 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
 "test_utils 0.1.0",
 "text_unit 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -959,7 +957,7 @@ version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
 "parking_lot 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)",
- "smol_str 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
+ "smol_str 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 "text_unit 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
@@ -997,7 +995,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 [[package]]
 name = "salsa"
 version = "0.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
+source = "git+https://github.com/matklad/salsa?branch=no-upgrade#1a7ae719af1601fda81186fb48bd100edd9cfb7f"
 dependencies = [
 "derive-new 0.5.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "indexmap 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -1092,7 +1090,7 @@ dependencies = [
 [[package]]
 name = "smol_str"
-version = "0.1.7"
+version = "0.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
 "serde 1.0.82 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -1554,7 +1552,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 "checksum rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "138e3e0acb6c9fb258b19b67cb8abd63c00679d2851805ea151465464fe9030a"
 "checksum ryu 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)" = "eb9e9b8cde282a9fe6a42dd4681319bfb63f121b8a8ee9439c6f4107e58a46f7"
 "checksum safemem 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "8dca453248a96cb0749e36ccdfe2b0b4e54a61bfef89fb97ec621eb8e0a93dd9"
-"checksum salsa 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "e56b13ce9b2bfaa1c89863d76880838c0734de85beeaef437fd70d4fa7e253d3"
+"checksum salsa 0.8.0 (git+https://github.com/matklad/salsa?branch=no-upgrade)" = "<none>"
 "checksum same-file 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)" = "8f20c4be53a8a1ff4c1f1b2bd14570d2f634628709752f0702ecdd2b3f9a5267"
 "checksum scopeguard 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "94258f53601af11e6a49f722422f6e3425c52b06245a5cf9bc09908b174f5e27"
 "checksum semver 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)" = "1d7eb9ef2c18661902cc47e535f9bc51b78acd254da71d375c2f6720d9a40403"
@@ -1565,7 +1563,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 "checksum sha-1 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "51b9d1f3b5de8a167ab06834a7c883bd197f2191e1dda1a22d9ccfeedbf9aded"
 "checksum slug 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "b3bc762e6a4b6c6fcaade73e77f9ebc6991b676f88bb2358bddb56560f073373"
 "checksum smallvec 0.6.7 (registry+https://github.com/rust-lang/crates.io-index)" = "b73ea3738b47563803ef814925e69be00799a8c07420be8b996f8e98fb2336db"
-"checksum smol_str 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "f3ed6f19b800d76574926e458d5f8e2dbea86c2b58c08d33a982448f09ac8d0c"
+"checksum smol_str 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)" = "486a74e9b9fc53373808f7a17e10fc728adcb1fbe272292271d8bea61175e181"
 "checksum stable_deref_trait 1.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "dba1a27d3efae4351c8051072d619e3ade2820635c3958d826bfea39d59b54c8"
 "checksum strsim 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "bb4f380125926a99e52bc279241539c018323fab05ad6368b56f93d9369ff550"
 "checksum superslice 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "b50b13d42370e0f5fc62eafdd5c2d20065eaf5458dab215ff3e20e63eea96b30"
diff --git a/Cargo.toml b/Cargo.toml
index 95830561d..cbb9a09d5 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -4,3 +4,10 @@ members = [ "crates/*" ]
 [profile.release]
 incremental = true
 debug = true
+[patch.'crates-io']
+# https://github.com/salsa-rs/salsa/pull/75
+# and
+# https://github.com/salsa-rs/salsa/issues/99
+salsa = { git = "https://github.com/matklad/salsa", branch = "no-upgrade" }
diff --git a/crates/gen_lsp_server/Cargo.toml b/crates/gen_lsp_server/Cargo.toml
index 6c91e38aa..9776a82e3 100644
--- a/crates/gen_lsp_server/Cargo.toml
+++ b/crates/gen_lsp_server/Cargo.toml
@@ -12,6 +12,5 @@ languageserver-types = "0.53.0"
 log = "0.4.3"
 failure = "0.1.2"
 serde_json = "1.0.24"
-serde = "1.0.71"
+serde = { version = "1.0.71", features = ["derive"] }
-serde_derive = "1.0.71"
 crossbeam-channel = "0.2.4"
diff --git a/crates/gen_lsp_server/src/msg.rs b/crates/gen_lsp_server/src/msg.rs
index 22d273d55..f68cbc541 100644
--- a/crates/gen_lsp_server/src/msg.rs
+++ b/crates/gen_lsp_server/src/msg.rs
@@ -1,13 +1,13 @@
 use std::io::{BufRead, Write};
 use languageserver_types::{notification::Notification, request::Request};
-use serde_derive::{Deserialize, Serialize};
+use serde::{Deserialize, Serialize};
 use serde_json::{from_str, from_value, to_string, to_value, Value};
 use failure::{bail, format_err};
 use crate::Result;
-#[derive(Debug, Serialize, Deserialize, Clone)]
+#[derive(Serialize, Deserialize, Debug, Clone)]
 #[serde(untagged)]
 pub enum RawMessage {
    Request(RawRequest),
@@ -152,12 +152,18 @@ impl RawNotification {
            params: to_value(params).unwrap(),
        }
    }
+    pub fn is<N>(&self) -> bool
+    where
+        N: Notification,
+    {
+        self.method == N::METHOD
+    }
    pub fn cast<N>(self) -> ::std::result::Result<N::Params, RawNotification>
    where
        N: Notification,
        N::Params: serde::de::DeserializeOwned,
    {
-        if self.method != N::METHOD {
+        if !self.is::<N>() {
            return Err(self);
        }
        Ok(from_value(self.params).unwrap())
diff --git a/crates/ra_analysis/src/completion.rs b/crates/ra_analysis/src/completion.rs
index f480af611..d742d6295 100644
--- a/crates/ra_analysis/src/completion.rs
+++ b/crates/ra_analysis/src/completion.rs
@@ -1,444 +1,60 @@
-mod reference_completion;
+mod completion_item;
+mod completion_context;
+mod complete_fn_param;
+mod complete_keyword;
+mod complete_snippet;
+mod complete_path;
+mod complete_scope;
-use ra_editor::find_node_at_offset;
-use ra_text_edit::AtomTextEdit;
-use ra_syntax::{
-    algo::visit::{visitor_ctx, VisitorCtx},
-    ast,
-    AstNode,
-    SyntaxNodeRef,
-};
 use ra_db::SyntaxDatabase;
-use rustc_hash::{FxHashMap};
-use hir::source_binder;
 use crate::{
    db,
-    Cancelable, FilePosition
+    Cancelable, FilePosition,
+    completion::{
+        completion_item::{Completions, CompletionKind},
+        completion_context::CompletionContext,
+    },
 };
-#[derive(Debug)]
+pub use crate::completion::completion_item::{CompletionItem, InsertText, CompletionItemKind};
-pub struct CompletionItem {
-    /// What user sees in pop-up
-    pub label: String,
-    /// What string is used for filtering, defaults to label
-    pub lookup: Option<String>,
-    /// What is inserted, defaults to label
-    pub snippet: Option<String>,
-}
+/// Main entry point for copmletion. We run comletion 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 readlly weired.
+///
+/// Once the context is collected, we run a series of completion routines whihc
+/// look at the context and produce completion items.
 pub(crate) fn completions(
    db: &db::RootDatabase,
    position: FilePosition,
-) -> Cancelable<Option<Vec<CompletionItem>>> {
+) -> Cancelable<Option<Completions>> {
    let original_file = db.source_file(position.file_id);
-    // Insert a fake ident to get a valid parse tree
+    let ctx = ctry!(CompletionContext::new(db, &original_file, position)?);
-    let file = {
-        let edit = AtomTextEdit::insert(position.offset, "intellijRulezz".to_string());
-        original_file.reparse(&edit)
-    };
-    let module = ctry!(source_binder::module_from_position(db, position)?);
-    let mut res = Vec::new();
+    let mut acc = Completions::default();
-    let mut has_completions = false;
-    // First, let's try to complete a reference to some declaration.
-    if let Some(name_ref) = find_node_at_offset::<ast::NameRef>(file.syntax(), position.offset) {
-        has_completions = true;
-        reference_completion::completions(&mut res, db, &module, &file, name_ref)?;
-        // special case, `trait T { fn foo(i_am_a_name_ref) {} }`
-        if is_node::<ast::Param>(name_ref.syntax()) {
-            param_completions(name_ref.syntax(), &mut res);
-        }
-    }
-    // Otherwise, if this is a declaration, use heuristics to suggest a name.
+    complete_fn_param::complete_fn_param(&mut acc, &ctx);
-    if let Some(name) = find_node_at_offset::<ast::Name>(file.syntax(), position.offset) {
+    complete_keyword::complete_expr_keyword(&mut acc, &ctx);
-        if is_node::<ast::Param>(name.syntax()) {
+    complete_snippet::complete_expr_snippet(&mut acc, &ctx);
-            has_completions = true;
+    complete_snippet::complete_item_snippet(&mut acc, &ctx);
-            param_completions(name.syntax(), &mut res);
+    complete_path::complete_path(&mut acc, &ctx)?;
-        }
+    complete_scope::complete_scope(&mut acc, &ctx)?;
-    }
-    let res = if has_completions { Some(res) } else { None };
-    Ok(res)
-}
-fn param_completions(ctx: SyntaxNodeRef, acc: &mut Vec<CompletionItem>) {
-    let mut params = FxHashMap::default();
-    for node in ctx.ancestors() {
-        let _ = visitor_ctx(&mut params)
-            .visit::<ast::SourceFile, _>(process)
-            .visit::<ast::ItemList, _>(process)
-            .accept(node);
-    }
-    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)| {
-            acc.push(CompletionItem {
-                label,
-                lookup: Some(lookup),
-                snippet: None,
-            })
-        });
-    fn process<'a, N: ast::FnDefOwner<'a>>(
-        node: N,
-        params: &mut FxHashMap<String, (u32, ast::Param<'a>)>,
-    ) {
-        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;
-            })
-    }
-}
-fn is_node<'a, N: AstNode<'a>>(node: SyntaxNodeRef<'a>) -> bool {
+    Ok(Some(acc))
-    match node.ancestors().filter_map(N::cast).next() {
-        None => false,
-        Some(n) => n.syntax().range() == node.range(),
-    }
 }
 #[cfg(test)]
-mod tests {
+fn check_completion(code: &str, expected_completions: &str, kind: CompletionKind) {
-    use test_utils::assert_eq_dbg;
+    use crate::mock_analysis::{single_file_with_position, analysis_and_position};
+    let (analysis, position) = if code.contains("//-") {
-    use crate::mock_analysis::single_file_with_position;
+        analysis_and_position(code)
+    } else {
-    use super::*;
+        single_file_with_position(code)
+    };
-    fn check_scope_completion(code: &str, expected_completions: &str) {
+    let completions = completions(&analysis.imp.db, position).unwrap().unwrap();
-        let (analysis, position) = single_file_with_position(code);
+    completions.assert_match(expected_completions, kind);
-        let completions = completions(&analysis.imp.db, position)
-            .unwrap()
-            .unwrap()
-            .into_iter()
-            .filter(|c| c.snippet.is_none())
-            .collect::<Vec<_>>();
-        assert_eq_dbg(expected_completions, &completions);
-    }
-    fn check_snippet_completion(code: &str, expected_completions: &str) {
-        let (analysis, position) = single_file_with_position(code);
-        let completions = completions(&analysis.imp.db, position)
-            .unwrap()
-            .unwrap()
-            .into_iter()
-            .filter(|c| c.snippet.is_some())
-            .collect::<Vec<_>>();
-        assert_eq_dbg(expected_completions, &completions);
-    }
-    #[test]
-    fn test_completion_let_scope() {
-        check_scope_completion(
-            r"
-            fn quux(x: i32) {
-                let y = 92;
-                1 + <|>;
-                let z = ();
-            }
-            ",
-            r#"[CompletionItem { label: "y", lookup: None, snippet: None },
-                   CompletionItem { label: "x", lookup: None, snippet: None },
-                   CompletionItem { label: "quux", lookup: None, snippet: None }]"#,
-        );
-    }
-    #[test]
-    fn test_completion_if_let_scope() {
-        check_scope_completion(
-            r"
-            fn quux() {
-                if let Some(x) = foo() {
-                    let y = 92;
-                };
-                if let Some(a) = bar() {
-                    let b = 62;
-                    1 + <|>
-                }
-            }
-            ",
-            r#"[CompletionItem { label: "b", lookup: None, snippet: None },
-                   CompletionItem { label: "a", lookup: None, snippet: None },
-                   CompletionItem { label: "quux", lookup: None, snippet: None }]"#,
-        );
-    }
-    #[test]
-    fn test_completion_for_scope() {
-        check_scope_completion(
-            r"
-            fn quux() {
-                for x in &[1, 2, 3] {
-                    <|>
-                }
-            }
-            ",
-            r#"[CompletionItem { label: "x", lookup: None, snippet: None },
-                   CompletionItem { label: "quux", lookup: None, snippet: None }]"#,
-        );
-    }
-    #[test]
-    fn test_completion_mod_scope() {
-        check_scope_completion(
-            r"
-            struct Foo;
-            enum Baz {}
-            fn quux() {
-                <|>
-            }
-            ",
-            r#"[CompletionItem { label: "quux", lookup: None, snippet: None },
-                CompletionItem { label: "Foo", lookup: None, snippet: None },
-                CompletionItem { label: "Baz", lookup: None, snippet: None }]"#,
-        );
-    }
-    #[test]
-    fn test_completion_mod_scope_no_self_use() {
-        check_scope_completion(
-            r"
-            use foo<|>;
-            ",
-            r#"[]"#,
-        );
-    }
-    #[test]
-    fn test_completion_self_path() {
-        check_scope_completion(
-            r"
-            use self::m::<|>;
-            mod m {
-                struct Bar;
-            }
-            ",
-            r#"[CompletionItem { label: "Bar", lookup: None, snippet: None }]"#,
-        );
-    }
-    #[test]
-    fn test_completion_mod_scope_nested() {
-        check_scope_completion(
-            r"
-            struct Foo;
-            mod m {
-                struct Bar;
-                fn quux() { <|> }
-            }
-            ",
-            r#"[CompletionItem { label: "quux", lookup: None, snippet: None },
-                CompletionItem { label: "Bar", lookup: None, snippet: None }]"#,
-        );
-    }
-    #[test]
-    fn test_complete_type() {
-        check_scope_completion(
-            r"
-            struct Foo;
-            fn x() -> <|>
-        ",
-            r#"[CompletionItem { label: "Foo", lookup: None, snippet: None },
-               CompletionItem { label: "x", lookup: None, snippet: None }]"#,
-        )
-    }
-    #[test]
-    fn test_complete_shadowing() {
-        check_scope_completion(
-            r"
-            fn foo() -> {
-                let bar = 92;
-                {
-                    let bar = 62;
-                    <|>
-                }
-            }
-        ",
-            r#"[CompletionItem { label: "bar", lookup: None, snippet: None },
-               CompletionItem { label: "foo", lookup: None, snippet: None }]"#,
-        )
-    }
-    #[test]
-    fn test_complete_self() {
-        check_scope_completion(
-            r"
-            impl S { fn foo(&self) { <|> } }
-        ",
-            r#"[CompletionItem { label: "self", lookup: None, snippet: None }]"#,
-        )
-    }
-    #[test]
-    fn test_completion_kewords() {
-        check_snippet_completion(r"
-            fn quux() {
-                <|>
-            }
-            ", r#"[CompletionItem { label: "if", lookup: None, snippet: Some("if $0 {}") },
-                   CompletionItem { label: "match", lookup: None, snippet: Some("match $0 {}") },
-                   CompletionItem { label: "while", lookup: None, snippet: Some("while $0 {}") },
-                   CompletionItem { label: "loop", lookup: None, snippet: Some("loop {$0}") },
-                   CompletionItem { label: "return", lookup: None, snippet: Some("return") },
-                   CompletionItem { label: "pd", lookup: None, snippet: Some("eprintln!(\"$0 = {:?}\", $0);") },
-                   CompletionItem { label: "ppd", lookup: None, snippet: Some("eprintln!(\"$0 = {:#?}\", $0);") }]"#);
-    }
-    #[test]
-    fn test_completion_else() {
-        check_snippet_completion(r"
-            fn quux() {
-                if true {
-                    ()
-                } <|>
-            }
-            ", r#"[CompletionItem { label: "if", lookup: None, snippet: Some("if $0 {}") },
-                   CompletionItem { label: "match", lookup: None, snippet: Some("match $0 {}") },
-                   CompletionItem { label: "while", lookup: None, snippet: Some("while $0 {}") },
-                   CompletionItem { label: "loop", lookup: None, snippet: Some("loop {$0}") },
-                   CompletionItem { label: "else", lookup: None, snippet: Some("else {$0}") },
-                   CompletionItem { label: "else if", lookup: None, snippet: Some("else if $0 {}") },
-                   CompletionItem { label: "return", lookup: None, snippet: Some("return") },
-                   CompletionItem { label: "pd", lookup: None, snippet: Some("eprintln!(\"$0 = {:?}\", $0);") },
-                   CompletionItem { label: "ppd", lookup: None, snippet: Some("eprintln!(\"$0 = {:#?}\", $0);") }]"#);
-    }
-    #[test]
-    fn test_completion_return_value() {
-        check_snippet_completion(r"
-            fn quux() -> i32 {
-                <|>
-                92
-            }
-            ", r#"[CompletionItem { label: "if", lookup: None, snippet: Some("if $0 {}") },
-                   CompletionItem { label: "match", lookup: None, snippet: Some("match $0 {}") },
-                   CompletionItem { label: "while", lookup: None, snippet: Some("while $0 {}") },
-                   CompletionItem { label: "loop", lookup: None, snippet: Some("loop {$0}") },
-                   CompletionItem { label: "return", lookup: None, snippet: Some("return $0;") },
-                   CompletionItem { label: "pd", lookup: None, snippet: Some("eprintln!(\"$0 = {:?}\", $0);") },
-                   CompletionItem { label: "ppd", lookup: None, snippet: Some("eprintln!(\"$0 = {:#?}\", $0);") }]"#);
-        check_snippet_completion(r"
-            fn quux() {
-                <|>
-                92
-            }
-            ", r#"[CompletionItem { label: "if", lookup: None, snippet: Some("if $0 {}") },
-                   CompletionItem { label: "match", lookup: None, snippet: Some("match $0 {}") },
-                   CompletionItem { label: "while", lookup: None, snippet: Some("while $0 {}") },
-                   CompletionItem { label: "loop", lookup: None, snippet: Some("loop {$0}") },
-                   CompletionItem { label: "return", lookup: None, snippet: Some("return;") },
-                   CompletionItem { label: "pd", lookup: None, snippet: Some("eprintln!(\"$0 = {:?}\", $0);") },
-                   CompletionItem { label: "ppd", lookup: None, snippet: Some("eprintln!(\"$0 = {:#?}\", $0);") }]"#);
-    }
-    #[test]
-    fn test_completion_return_no_stmt() {
-        check_snippet_completion(r"
-            fn quux() -> i32 {
-                match () {
-                    () => <|>
-                }
-            }
-            ", r#"[CompletionItem { label: "if", lookup: None, snippet: Some("if $0 {}") },
-                   CompletionItem { label: "match", lookup: None, snippet: Some("match $0 {}") },
-                   CompletionItem { label: "while", lookup: None, snippet: Some("while $0 {}") },
-                   CompletionItem { label: "loop", lookup: None, snippet: Some("loop {$0}") },
-                   CompletionItem { label: "return", lookup: None, snippet: Some("return $0") },
-                   CompletionItem { label: "pd", lookup: None, snippet: Some("eprintln!(\"$0 = {:?}\", $0);") },
-                   CompletionItem { label: "ppd", lookup: None, snippet: Some("eprintln!(\"$0 = {:#?}\", $0);") }]"#);
-    }
-    #[test]
-    fn test_continue_break_completion() {
-        check_snippet_completion(r"
-            fn quux() -> i32 {
-                loop { <|> }
-            }
-            ", r#"[CompletionItem { label: "if", lookup: None, snippet: Some("if $0 {}") },
-                   CompletionItem { label: "match", lookup: None, snippet: Some("match $0 {}") },
-                   CompletionItem { label: "while", lookup: None, snippet: Some("while $0 {}") },
-                   CompletionItem { label: "loop", lookup: None, snippet: Some("loop {$0}") },
-                   CompletionItem { label: "continue", lookup: None, snippet: Some("continue") },
-                   CompletionItem { label: "break", lookup: None, snippet: Some("break") },
-                   CompletionItem { label: "return", lookup: None, snippet: Some("return $0") },
-                   CompletionItem { label: "pd", lookup: None, snippet: Some("eprintln!(\"$0 = {:?}\", $0);") },
-                   CompletionItem { label: "ppd", lookup: None, snippet: Some("eprintln!(\"$0 = {:#?}\", $0);") }]"#);
-        check_snippet_completion(r"
-            fn quux() -> i32 {
-                loop { || { <|> } }
-            }
-            ", r#"[CompletionItem { label: "if", lookup: None, snippet: Some("if $0 {}") },
-                   CompletionItem { label: "match", lookup: None, snippet: Some("match $0 {}") },
-                   CompletionItem { label: "while", lookup: None, snippet: Some("while $0 {}") },
-                   CompletionItem { label: "loop", lookup: None, snippet: Some("loop {$0}") },
-                   CompletionItem { label: "return", lookup: None, snippet: Some("return $0") },
-                   CompletionItem { label: "pd", lookup: None, snippet: Some("eprintln!(\"$0 = {:?}\", $0);") },
-                   CompletionItem { label: "ppd", lookup: None, snippet: Some("eprintln!(\"$0 = {:#?}\", $0);") }]"#);
-    }
-    #[test]
-    fn test_param_completion_last_param() {
-        check_scope_completion(r"
-            fn foo(file_id: FileId) {}
-            fn bar(file_id: FileId) {}
-            fn baz(file<|>) {}
-        ", r#"[CompletionItem { label: "file_id: FileId", lookup: Some("file_id"), snippet: None }]"#);
-    }
-    #[test]
-    fn test_param_completion_nth_param() {
-        check_scope_completion(r"
-            fn foo(file_id: FileId) {}
-            fn bar(file_id: FileId) {}
-            fn baz(file<|>, x: i32) {}
-        ", r#"[CompletionItem { label: "file_id: FileId", lookup: Some("file_id"), snippet: None }]"#);
-    }
-    #[test]
-    fn test_param_completion_trait_param() {
-        check_scope_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: "self", lookup: None, snippet: None },
-               CompletionItem { label: "SourceRoot", lookup: None, snippet: None },
-               CompletionItem { label: "file_id: FileId", lookup: Some("file_id"), snippet: None }]"#);
-    }
-    #[test]
-    fn test_item_snippets() {
-        // check_snippet_completion(r"
-        //     <|>
-        //     ",
-        //     r##"[CompletionItem { label: "Test function", lookup: None, snippet: Some("#[test]\nfn test_${1:feature}() {\n$0\n}"##,
-        // );
-        check_snippet_completion(r"
-            #[cfg(test)]
-            mod tests {
-                <|>
-            }
-            ",
-            r##"[CompletionItem { label: "Test function", lookup: Some("tfn"), snippet: Some("#[test]\nfn ${1:feature}() {\n$0\n}") },
-                 CompletionItem { label: "pub(crate)", lookup: None, snippet: Some("pub(crate) $0") }]"##,
-        );
-    }
 }
diff --git a/crates/ra_analysis/src/completion/complete_fn_param.rs b/crates/ra_analysis/src/completion/complete_fn_param.rs
new file mode 100644
index 000000000..bb5fdfda0
--- /dev/null
+++ b/crates/ra_analysis/src/completion/complete_fn_param.rs
@@ -0,0 +1,102 @@
+use ra_syntax::{
+    algo::visit::{visitor_ctx, VisitorCtx},
+    ast,
+    AstNode,
+};
+use rustc_hash::FxHashMap;
+use crate::completion::{CompletionContext, Completions, CompletionKind, CompletionItem};
+/// Complete repeated parametes, 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.leaf.ancestors() {
+        let _ = visitor_ctx(&mut params)
+            .visit::<ast::SourceFile, _>(process)
+            .visit::<ast::ItemList, _>(process)
+            .accept(node);
+    }
+    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, label)
+                .lookup_by(lookup)
+                .add_to(acc)
+        });
+    fn process<'a, N: ast::FnDefOwner<'a>>(
+        node: N,
+        params: &mut FxHashMap<String, (u32, ast::Param<'a>)>,
+    ) {
+        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::*;
+    fn check_magic_completion(code: &str, expected_completions: &str) {
+        check_completion(code, expected_completions, CompletionKind::Magic);
+    }
+    #[test]
+    fn test_param_completion_last_param() {
+        check_magic_completion(
+            r"
+            fn foo(file_id: FileId) {}
+            fn bar(file_id: FileId) {}
+            fn baz(file<|>) {}
+            ",
+            r#"file_id "file_id: FileId""#,
+        );
+    }
+    #[test]
+    fn test_param_completion_nth_param() {
+        check_magic_completion(
+            r"
+            fn foo(file_id: FileId) {}
+            fn bar(file_id: FileId) {}
+            fn baz(file<|>, x: i32) {}
+            ",
+            r#"file_id "file_id: FileId""#,
+        );
+    }
+    #[test]
+    fn test_param_completion_trait_param() {
+        check_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#"file_id "file_id: FileId""#,
+        );
+    }
+}
diff --git a/crates/ra_analysis/src/completion/complete_keyword.rs b/crates/ra_analysis/src/completion/complete_keyword.rs
new file mode 100644
index 000000000..5427fcb11
--- /dev/null
+++ b/crates/ra_analysis/src/completion/complete_keyword.rs
@@ -0,0 +1,204 @@
+use ra_syntax::{
+    algo::visit::{visitor, Visitor},
+    AstNode,
+    ast::{self, LoopBodyOwner},
+    SyntaxKind::*, SyntaxNodeRef,
+};
+use crate::completion::{CompletionContext, CompletionItem, Completions, CompletionKind, CompletionItemKind};
+fn keyword(kw: &str, snippet: &str) -> CompletionItem {
+    CompletionItem::new(CompletionKind::Keyword, kw)
+        .kind(CompletionItemKind::Keyword)
+        .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.enclosing_fn {
+        Some(it) => it,
+        None => return,
+    };
+    acc.add(keyword("if", "if $0 {}"));
+    acc.add(keyword("match", "match $0 {}"));
+    acc.add(keyword("while", "while $0 {}"));
+    acc.add(keyword("loop", "loop {$0}"));
+    if ctx.after_if {
+        acc.add(keyword("else", "else {$0}"));
+        acc.add(keyword("else if", "else if $0 {}"));
+    }
+    if is_in_loop_body(ctx.leaf) {
+        acc.add(keyword("continue", "continue"));
+        acc.add(keyword("break", "break"));
+    }
+    acc.add_all(complete_return(fn_def, ctx.is_stmt));
+}
+fn is_in_loop_body(leaf: SyntaxNodeRef) -> bool {
+    for node in leaf.ancestors() {
+        if node.kind() == FN_DEF || node.kind() == LAMBDA_EXPR {
+            break;
+        }
+        let loop_body = visitor()
+            .visit::<ast::ForExpr, _>(LoopBodyOwner::loop_body)
+            .visit::<ast::WhileExpr, _>(LoopBodyOwner::loop_body)
+            .visit::<ast::LoopExpr, _>(LoopBodyOwner::loop_body)
+            .accept(node);
+        if let Some(Some(body)) = loop_body {
+            if leaf.range().is_subrange(&body.syntax().range()) {
+                return true;
+            }
+        }
+    }
+    false
+}
+fn complete_return(fn_def: ast::FnDef, is_stmt: bool) -> Option<CompletionItem> {
+    let snip = match (is_stmt, fn_def.ret_type().is_some()) {
+        (true, true) => "return $0;",
+        (true, false) => "return;",
+        (false, true) => "return $0",
+        (false, false) => "return",
+    };
+    Some(keyword("return", snip))
+}
+#[cfg(test)]
+mod tests {
+    use crate::completion::{CompletionKind, check_completion};
+    fn check_keyword_completion(code: &str, expected_completions: &str) {
+        check_completion(code, expected_completions, CompletionKind::Keyword);
+    }
+    #[test]
+    fn test_completion_kewords() {
+        check_keyword_completion(
+            r"
+            fn quux() {
+                <|>
+            }
+            ",
+            r#"
+            if "if $0 {}"
+            match "match $0 {}"
+            while "while $0 {}"
+            loop "loop {$0}"
+            return "return"
+            "#,
+        );
+    }
+    #[test]
+    fn test_completion_else() {
+        check_keyword_completion(
+            r"
+            fn quux() {
+                if true {
+                    ()
+                } <|>
+            }
+            ",
+            r#"
+            if "if $0 {}"
+            match "match $0 {}"
+            while "while $0 {}"
+            loop "loop {$0}"
+            else "else {$0}"
+            else if "else if $0 {}"
+            return "return"
+            "#,
+        );
+    }
+    #[test]
+    fn test_completion_return_value() {
+        check_keyword_completion(
+            r"
+            fn quux() -> i32 {
+                <|>
+                92
+            }
+            ",
+            r#"
+            if "if $0 {}"
+            match "match $0 {}"
+            while "while $0 {}"
+            loop "loop {$0}"
+            return "return $0;"
+            "#,
+        );
+        check_keyword_completion(
+            r"
+            fn quux() {
+                <|>
+                92
+            }
+            ",
+            r#"
+            if "if $0 {}"
+            match "match $0 {}"
+            while "while $0 {}"
+            loop "loop {$0}"
+            return "return;"
+            "#,
+        );
+    }
+    #[test]
+    fn test_completion_return_no_stmt() {
+        check_keyword_completion(
+            r"
+            fn quux() -> i32 {
+                match () {
+                    () => <|>
+                }
+            }
+            ",
+            r#"
+            if "if $0 {}"
+            match "match $0 {}"
+            while "while $0 {}"
+            loop "loop {$0}"
+            return "return $0"
+            "#,
+        );
+    }
+    #[test]
+    fn test_continue_break_completion() {
+        check_keyword_completion(
+            r"
+            fn quux() -> i32 {
+                loop { <|> }
+            }
+            ",
+            r#"
+            if "if $0 {}"
+            match "match $0 {}"
+            while "while $0 {}"
+            loop "loop {$0}"
+            continue "continue"
+            break "break"
+            return "return $0"
+            "#,
+        );
+        check_keyword_completion(
+            r"
+            fn quux() -> i32 {
+                loop { || { <|> } }
+            }
+            ",
+            r#"
+            if "if $0 {}"
+            match "match $0 {}"
+            while "while $0 {}"
+            loop "loop {$0}"
+            return "return $0"
+            "#,
+        );
+    }
+}
diff --git a/crates/ra_analysis/src/completion/complete_path.rs b/crates/ra_analysis/src/completion/complete_path.rs
new file mode 100644
index 000000000..ad4d68a33
--- /dev/null
+++ b/crates/ra_analysis/src/completion/complete_path.rs
@@ -0,0 +1,95 @@
+use crate::{
+    Cancelable,
+    completion::{CompletionItem, Completions, CompletionKind, CompletionContext},
+};
+pub(super) fn complete_path(acc: &mut Completions, ctx: &CompletionContext) -> Cancelable<()> {
+    let (path, module) = match (&ctx.path_prefix, &ctx.module) {
+        (Some(path), Some(module)) => (path.clone(), module),
+        _ => return Ok(()),
+    };
+    let def_id = match module.resolve_path(ctx.db, path)? {
+        Some(it) => it,
+        None => return Ok(()),
+    };
+    let target_module = match def_id.resolve(ctx.db)? {
+        hir::Def::Module(it) => it,
+        _ => return Ok(()),
+    };
+    let module_scope = target_module.scope(ctx.db)?;
+    module_scope.entries().for_each(|(name, res)| {
+        CompletionItem::new(CompletionKind::Reference, name.to_string())
+            .from_resolution(ctx.db, res)
+            .add_to(acc)
+    });
+    Ok(())
+}
+#[cfg(test)]
+mod tests {
+    use crate::completion::{CompletionKind, check_completion};
+    fn check_reference_completion(code: &str, expected_completions: &str) {
+        check_completion(code, expected_completions, CompletionKind::Reference);
+    }
+    #[test]
+    fn completes_use_item_starting_with_self() {
+        check_reference_completion(
+            r"
+            use self::m::<|>;
+            mod m {
+                struct Bar;
+            }
+            ",
+            "Bar",
+        );
+    }
+    #[test]
+    fn completes_use_item_starting_with_crate() {
+        check_reference_completion(
+            "
+            //- /lib.rs
+            mod foo;
+            struct Spam;
+            //- /foo.rs
+            use crate::Sp<|>
+            ",
+            "Spam;foo",
+        );
+    }
+    #[test]
+    fn completes_nested_use_tree() {
+        check_reference_completion(
+            "
+            //- /lib.rs
+            mod foo;
+            struct Spam;
+            //- /foo.rs
+            use crate::{Sp<|>};
+            ",
+            "Spam;foo",
+        );
+    }
+    #[test]
+    fn completes_deeply_nested_use_tree() {
+        check_reference_completion(
+            "
+            //- /lib.rs
+            mod foo;
+            pub mod bar {
+                pub mod baz {
+                    pub struct Spam;
+                }
+            }
+            //- /foo.rs
+            use crate::{bar::{baz::Sp<|>}};
+            ",
+            "Spam",
+        );
+    }
+}
diff --git a/crates/ra_analysis/src/completion/complete_scope.rs b/crates/ra_analysis/src/completion/complete_scope.rs
new file mode 100644
index 000000000..a57670e3b
--- /dev/null
+++ b/crates/ra_analysis/src/completion/complete_scope.rs
@@ -0,0 +1,173 @@
+use rustc_hash::FxHashSet;
+use ra_syntax::TextUnit;
+use crate::{
+    Cancelable,
+    completion::{CompletionItem, CompletionItemKind, Completions, CompletionKind, CompletionContext},
+};
+pub(super) fn complete_scope(acc: &mut Completions, ctx: &CompletionContext) -> Cancelable<()> {
+    if !ctx.is_trivial_path {
+        return Ok(());
+    }
+    let module = match &ctx.module {
+        Some(it) => it,
+        None => return Ok(()),
+    };
+    if let Some(fn_def) = ctx.enclosing_fn {
+        let function = hir::source_binder::function_from_module(ctx.db, module, fn_def);
+        let scopes = function.scopes(ctx.db);
+        complete_fn(acc, &scopes, ctx.offset);
+    }
+    let module_scope = module.scope(ctx.db)?;
+    module_scope
+        .entries()
+        .filter(|(_name, res)| {
+            // Don't expose this item
+            match res.import {
+                None => true,
+                Some(import) => {
+                    let range = import.range(ctx.db, module.source().file_id());
+                    !range.is_subrange(&ctx.leaf.range())
+                }
+            }
+        })
+        .for_each(|(name, res)| {
+            CompletionItem::new(CompletionKind::Reference, name.to_string())
+                .from_resolution(ctx.db, res)
+                .add_to(acc)
+        });
+    Ok(())
+}
+fn complete_fn(acc: &mut Completions, scopes: &hir::FnScopes, offset: TextUnit) {
+    let mut shadowed = FxHashSet::default();
+    scopes
+        .scope_chain_for_offset(offset)
+        .flat_map(|scope| scopes.entries(scope).iter())
+        .filter(|entry| shadowed.insert(entry.name()))
+        .for_each(|entry| {
+            CompletionItem::new(CompletionKind::Reference, entry.name().to_string())
+                .kind(CompletionItemKind::Binding)
+                .add_to(acc)
+        });
+    if scopes.self_param.is_some() {
+        CompletionItem::new(CompletionKind::Reference, "self").add_to(acc);
+    }
+}
+#[cfg(test)]
+mod tests {
+    use crate::completion::{CompletionKind, check_completion};
+    fn check_reference_completion(code: &str, expected_completions: &str) {
+        check_completion(code, expected_completions, CompletionKind::Reference);
+    }
+    #[test]
+    fn completes_bindings_from_let() {
+        check_reference_completion(
+            r"
+            fn quux(x: i32) {
+                let y = 92;
+                1 + <|>;
+                let z = ();
+            }
+            ",
+            "y;x;quux",
+        );
+    }
+    #[test]
+    fn completes_bindings_from_if_let() {
+        check_reference_completion(
+            r"
+            fn quux() {
+                if let Some(x) = foo() {
+                    let y = 92;
+                };
+                if let Some(a) = bar() {
+                    let b = 62;
+                    1 + <|>
+                }
+            }
+            ",
+            "b;a;quux",
+        );
+    }
+    #[test]
+    fn completes_bindings_from_for() {
+        check_reference_completion(
+            r"
+            fn quux() {
+                for x in &[1, 2, 3] {
+                    <|>
+                }
+            }
+            ",
+            "x;quux",
+        );
+    }
+    #[test]
+    fn completes_module_items() {
+        check_reference_completion(
+            r"
+            struct Foo;
+            enum Baz {}
+            fn quux() {
+                <|>
+            }
+            ",
+            "quux;Foo;Baz",
+        );
+    }
+    #[test]
+    fn completes_module_items_in_nested_modules() {
+        check_reference_completion(
+            r"
+            struct Foo;
+            mod m {
+                struct Bar;
+                fn quux() { <|> }
+            }
+            ",
+            "quux;Bar",
+        );
+    }
+    #[test]
+    fn completes_return_type() {
+        check_reference_completion(
+            r"
+            struct Foo;
+            fn x() -> <|>
+            ",
+            "Foo;x",
+        )
+    }
+    #[test]
+    fn dont_show_to_completions_for_shadowing() {
+        check_reference_completion(
+            r"
+            fn foo() -> {
+                let bar = 92;
+                {
+                    let bar = 62;
+                    <|>
+                }
+            }
+            ",
+            "bar;foo",
+        )
+    }
+    #[test]
+    fn completes_self_in_methods() {
+        check_reference_completion(r"impl S { fn foo(&self) { <|> } }", "self")
+    }
+}
diff --git a/crates/ra_analysis/src/completion/complete_snippet.rs b/crates/ra_analysis/src/completion/complete_snippet.rs
new file mode 100644
index 000000000..fb9da0a4f
--- /dev/null
+++ b/crates/ra_analysis/src/completion/complete_snippet.rs
@@ -0,0 +1,73 @@
+use crate::completion::{CompletionItem, Completions, CompletionKind, CompletionItemKind, CompletionContext, completion_item::Builder};
+fn snippet(label: &str, snippet: &str) -> Builder {
+    CompletionItem::new(CompletionKind::Snippet, label)
+        .snippet(snippet)
+        .kind(CompletionItemKind::Snippet)
+}
+pub(super) fn complete_expr_snippet(acc: &mut Completions, ctx: &CompletionContext) {
+    if !(ctx.is_trivial_path && ctx.enclosing_fn.is_some()) {
+        return;
+    }
+    snippet("pd", "eprintln!(\"$0 = {:?}\", $0);").add_to(acc);
+    snippet("ppd", "eprintln!(\"$0 = {:#?}\", $0);").add_to(acc);
+}
+pub(super) fn complete_item_snippet(acc: &mut Completions, ctx: &CompletionContext) {
+    if !ctx.is_new_item {
+        return;
+    }
+    snippet(
+        "Test function",
+        "\
+#[test]
+fn ${1:feature}() {
+    $0
+}",
+    )
+    .lookup_by("tfn")
+    .add_to(acc);
+    snippet("pub(crate)", "pub(crate) $0").add_to(acc);
+}
+#[cfg(test)]
+mod tests {
+    use crate::completion::{CompletionKind, check_completion};
+    fn check_snippet_completion(code: &str, expected_completions: &str) {
+        check_completion(code, expected_completions, CompletionKind::Snippet);
+    }
+    #[test]
+    fn completes_snippets_in_expressions() {
+        check_snippet_completion(
+            r"fn foo(x: i32) { <|> }",
+            r##"
+            pd "eprintln!(\"$0 = {:?}\", $0);"
+            ppd "eprintln!(\"$0 = {:#?}\", $0);"
+            "##,
+        );
+    }
+    #[test]
+    fn completes_snippets_in_items() {
+        // check_snippet_completion(r"
+        //     <|>
+        //     ",
+        //     r##"[CompletionItem { label: "Test function", lookup: None, snippet: Some("#[test]\nfn test_${1:feature}() {\n$0\n}"##,
+        // );
+        check_snippet_completion(
+            r"
+            #[cfg(test)]
+            mod tests {
+                <|>
+            }
+            ",
+            r##"
+            tfn "Test function" "#[test]\nfn ${1:feature}() {\n    $0\n}"
+            pub(crate) "pub(crate) $0"
+            "##,
+        );
+    }
+}
diff --git a/crates/ra_analysis/src/completion/completion_context.rs b/crates/ra_analysis/src/completion/completion_context.rs
new file mode 100644
index 000000000..064fbc6f7
--- /dev/null
+++ b/crates/ra_analysis/src/completion/completion_context.rs
@@ -0,0 +1,156 @@
+use ra_editor::find_node_at_offset;
+use ra_text_edit::AtomTextEdit;
+use ra_syntax::{
+    algo::find_leaf_at_offset,
+    ast,
+    AstNode,
+    SyntaxNodeRef,
+    SourceFileNode,
+    TextUnit,
+    SyntaxKind::*,
+};
+use hir::source_binder;
+use crate::{db, FilePosition, Cancelable};
+/// `CompletionContext` is created early during completion to figure out, where
+/// exactly is the cursor, syntax-wise.
+#[derive(Debug)]
+pub(super) struct CompletionContext<'a> {
+    pub(super) db: &'a db::RootDatabase,
+    pub(super) offset: TextUnit,
+    pub(super) leaf: SyntaxNodeRef<'a>,
+    pub(super) module: Option<hir::Module>,
+    pub(super) enclosing_fn: Option<ast::FnDef<'a>>,
+    pub(super) is_param: bool,
+    /// A single-indent path, like `foo`.
+    pub(super) is_trivial_path: bool,
+    /// If not a trivial, path, the prefix (qualifier).
+    pub(super) path_prefix: Option<hir::Path>,
+    pub(super) after_if: bool,
+    pub(super) is_stmt: bool,
+    /// Something is typed at the "top" level, in module or impl/trait.
+    pub(super) is_new_item: bool,
+}
+impl<'a> CompletionContext<'a> {
+    pub(super) fn new(
+        db: &'a db::RootDatabase,
+        original_file: &'a SourceFileNode,
+        position: FilePosition,
+    ) -> Cancelable<Option<CompletionContext<'a>>> {
+        let module = source_binder::module_from_position(db, position)?;
+        let leaf =
+            ctry!(find_leaf_at_offset(original_file.syntax(), position.offset).left_biased());
+        let mut ctx = CompletionContext {
+            db,
+            leaf,
+            offset: position.offset,
+            module,
+            enclosing_fn: None,
+            is_param: false,
+            is_trivial_path: false,
+            path_prefix: None,
+            after_if: false,
+            is_stmt: false,
+            is_new_item: false,
+        };
+        ctx.fill(original_file, position.offset);
+        Ok(Some(ctx))
+    }
+    fn fill(&mut self, original_file: &SourceFileNode, offset: TextUnit) {
+        // Insert a fake ident to get a valid parse tree. We will use this file
+        // to determine context, though the original_file will be used for
+        // actual completion.
+        let file = {
+            let edit = AtomTextEdit::insert(offset, "intellijRulezz".to_string());
+            original_file.reparse(&edit)
+        };
+        // First, let's try to complete a reference to some declaration.
+        if let Some(name_ref) = find_node_at_offset::<ast::NameRef>(file.syntax(), offset) {
+            // Special case, `trait T { fn foo(i_am_a_name_ref) {} }`.
+            // See RFC#1685.
+            if is_node::<ast::Param>(name_ref.syntax()) {
+                self.is_param = true;
+                return;
+            }
+            self.classify_name_ref(&file, name_ref);
+        }
+        // Otherwise, see if this is a declaration. We can use heuristics to
+        // suggest declaration names, see `CompletionKind::Magic`.
+        if let Some(name) = find_node_at_offset::<ast::Name>(file.syntax(), offset) {
+            if is_node::<ast::Param>(name.syntax()) {
+                self.is_param = true;
+                return;
+            }
+        }
+    }
+    fn classify_name_ref(&mut self, file: &SourceFileNode, name_ref: ast::NameRef) {
+        let name_range = name_ref.syntax().range();
+        let top_node = name_ref
+            .syntax()
+            .ancestors()
+            .take_while(|it| it.range() == name_range)
+            .last()
+            .unwrap();
+        match top_node.parent().map(|it| it.kind()) {
+            Some(SOURCE_FILE) | Some(ITEM_LIST) => {
+                self.is_new_item = true;
+                return;
+            }
+            _ => (),
+        }
+        let parent = match name_ref.syntax().parent() {
+            Some(it) => it,
+            None => return,
+        };
+        if let Some(segment) = ast::PathSegment::cast(parent) {
+            let path = segment.parent_path();
+            if let Some(mut path) = hir::Path::from_ast(path) {
+                if !path.is_ident() {
+                    path.segments.pop().unwrap();
+                    self.path_prefix = Some(path);
+                    return;
+                }
+            }
+            if path.qualifier().is_none() {
+                self.is_trivial_path = true;
+                self.enclosing_fn = self
+                    .leaf
+                    .ancestors()
+                    .take_while(|it| it.kind() != SOURCE_FILE && it.kind() != MODULE)
+                    .find_map(ast::FnDef::cast);
+                self.is_stmt = match name_ref
+                    .syntax()
+                    .ancestors()
+                    .filter_map(ast::ExprStmt::cast)
+                    .next()
+                {
+                    None => false,
+                    Some(expr_stmt) => expr_stmt.syntax().range() == name_ref.syntax().range(),
+                };
+                if let Some(off) = name_ref.syntax().range().start().checked_sub(2.into()) {
+                    if let Some(if_expr) = find_node_at_offset::<ast::IfExpr>(file.syntax(), off) {
+                        if if_expr.syntax().range().end() < name_ref.syntax().range().start() {
+                            self.after_if = true;
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+fn is_node<'a, N: AstNode<'a>>(node: SyntaxNodeRef<'a>) -> bool {
+    match node.ancestors().filter_map(N::cast).next() {
+        None => false,
+        Some(n) => n.syntax().range() == node.range(),
+    }
+}
diff --git a/crates/ra_analysis/src/completion/completion_item.rs b/crates/ra_analysis/src/completion/completion_item.rs
new file mode 100644
index 000000000..911f08468
--- /dev/null
+++ b/crates/ra_analysis/src/completion/completion_item.rs
@@ -0,0 +1,214 @@
+use crate::db;
+/// `CompletionItem` describes a single completion variant in the editor pop-up.
+/// It is basically a POD with various properties. To construct a
+/// `CompletionItem`, use `new` method and the `Builder` struct.
+#[derive(Debug)]
+pub struct CompletionItem {
+    /// Used only internally in tests, to check only specific kind of
+    /// completion.
+    completion_kind: CompletionKind,
+    label: String,
+    lookup: Option<String>,
+    snippet: Option<String>,
+    kind: Option<CompletionItemKind>,
+}
+pub enum InsertText {
+    PlainText { text: String },
+    Snippet { text: String },
+}
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum CompletionItemKind {
+    Snippet,
+    Keyword,
+    Module,
+    Function,
+    Binding,
+}
+#[derive(Debug, PartialEq, Eq)]
+pub(crate) enum CompletionKind {
+    /// Parser-based keyword completion.
+    Keyword,
+    /// Your usual "complete all valid identifiers".
+    Reference,
+    /// "Secret sauce" completions.
+    Magic,
+    Snippet,
+}
+impl CompletionItem {
+    pub(crate) fn new(completion_kind: CompletionKind, label: impl Into<String>) -> Builder {
+        let label = label.into();
+        Builder {
+            completion_kind,
+            label,
+            lookup: None,
+            snippet: None,
+            kind: None,
+        }
+    }
+    /// What user sees in pop-up in the UI.
+    pub fn label(&self) -> &str {
+        &self.label
+    }
+    /// What string is used for filtering.
+    pub fn lookup(&self) -> &str {
+        self.lookup
+            .as_ref()
+            .map(|it| it.as_str())
+            .unwrap_or(self.label())
+    }
+    /// What is inserted.
+    pub fn insert_text(&self) -> InsertText {
+        match &self.snippet {
+            None => InsertText::PlainText {
+                text: self.label.clone(),
+            },
+            Some(it) => InsertText::Snippet { text: it.clone() },
+        }
+    }
+    pub fn kind(&self) -> Option<CompletionItemKind> {
+        self.kind
+    }
+}
+/// A helper to make `CompletionItem`s.
+#[must_use]
+pub(crate) struct Builder {
+    completion_kind: CompletionKind,
+    label: String,
+    lookup: Option<String>,
+    snippet: Option<String>,
+    kind: Option<CompletionItemKind>,
+}
+impl Builder {
+    pub(crate) fn add_to(self, acc: &mut Completions) {
+        acc.add(self.build())
+    }
+    pub(crate) fn build(self) -> CompletionItem {
+        CompletionItem {
+            label: self.label,
+            lookup: self.lookup,
+            snippet: self.snippet,
+            kind: self.kind,
+            completion_kind: self.completion_kind,
+        }
+    }
+    pub(crate) fn lookup_by(mut self, lookup: impl Into<String>) -> Builder {
+        self.lookup = Some(lookup.into());
+        self
+    }
+    pub(crate) fn snippet(mut self, snippet: impl Into<String>) -> Builder {
+        self.snippet = Some(snippet.into());
+        self
+    }
+    pub(crate) fn kind(mut self, kind: CompletionItemKind) -> Builder {
+        self.kind = Some(kind);
+        self
+    }
+    pub(crate) fn from_resolution(
+        mut self,
+        db: &db::RootDatabase,
+        resolution: &hir::Resolution,
+    ) -> Builder {
+        if let Some(def_id) = resolution.def_id {
+            if let Ok(def) = def_id.resolve(db) {
+                let kind = match def {
+                    hir::Def::Module(..) => CompletionItemKind::Module,
+                    hir::Def::Function(..) => CompletionItemKind::Function,
+                    _ => return self,
+                };
+                self.kind = Some(kind);
+            }
+        }
+        self
+    }
+}
+impl Into<CompletionItem> for Builder {
+    fn into(self) -> CompletionItem {
+        self.build()
+    }
+}
+/// Represents an in-progress set of completions being built.
+#[derive(Debug, Default)]
+pub(crate) struct Completions {
+    buf: Vec<CompletionItem>,
+}
+impl Completions {
+    pub(crate) fn add(&mut self, item: impl Into<CompletionItem>) {
+        self.buf.push(item.into())
+    }
+    pub(crate) fn add_all<I>(&mut self, items: I)
+    where
+        I: IntoIterator,
+        I::Item: Into<CompletionItem>,
+    {
+        items.into_iter().for_each(|item| self.add(item.into()))
+    }
+    #[cfg(test)]
+    pub(crate) fn assert_match(&self, expected: &str, kind: CompletionKind) {
+        let expected = normalize(expected);
+        let actual = self.debug_render(kind);
+        test_utils::assert_eq_text!(expected.as_str(), actual.as_str(),);
+        /// Normalize the textual representation of `Completions`:
+        /// replace `;` with newlines, normalize whitespace
+        fn normalize(expected: &str) -> String {
+            use ra_syntax::{tokenize, TextUnit, TextRange, SyntaxKind::SEMI};
+            let mut res = String::new();
+            for line in expected.trim().lines() {
+                let line = line.trim();
+                let mut start_offset: TextUnit = 0.into();
+                // Yep, we use rust tokenize in completion tests :-)
+                for token in tokenize(line) {
+                    let range = TextRange::offset_len(start_offset, token.len);
+                    start_offset += token.len;
+                    if token.kind == SEMI {
+                        res.push('\n');
+                    } else {
+                        res.push_str(&line[range]);
+                    }
+                }
+                res.push('\n');
+            }
+            res
+        }
+    }
+    #[cfg(test)]
+    fn debug_render(&self, kind: CompletionKind) -> String {
+        let mut res = String::new();
+        for c in self.buf.iter() {
+            if c.completion_kind == kind {
+                if let Some(lookup) = &c.lookup {
+                    res.push_str(lookup);
+                    res.push_str(&format!(" {:?}", c.label));
+                } else {
+                    res.push_str(&c.label);
+                }
+                if let Some(snippet) = &c.snippet {
+                    res.push_str(&format!(" {:?}", snippet));
+                }
+                res.push('\n');
+            }
+        }
+        res
+    }
+}
+impl Into<Vec<CompletionItem>> for Completions {
+    fn into(self) -> Vec<CompletionItem> {
+        self.buf
+    }
+}
diff --git a/crates/ra_analysis/src/completion/reference_completion.rs b/crates/ra_analysis/src/completion/reference_completion.rs
deleted file mode 100644
index f483ed045..000000000
--- a/crates/ra_analysis/src/completion/reference_completion.rs
+++ /dev/null
@@ -1,294 +0,0 @@
-use rustc_hash::{FxHashSet};
-use ra_editor::find_node_at_offset;
-use ra_syntax::{
-    algo::visit::{visitor, Visitor},
-    SourceFileNode, AstNode,
-    ast::{self, LoopBodyOwner},
-    SyntaxKind::*,
-};
-use     hir::{
-        self,
-        FnScopes,
-        Def,
-        Path,
-};
-use crate::{
-    db::RootDatabase,
-    completion::CompletionItem,
-    Cancelable
-};
-pub(super) fn completions(
-    acc: &mut Vec<CompletionItem>,
-    db: &RootDatabase,
-    module: &hir::Module,
-    file: &SourceFileNode,
-    name_ref: ast::NameRef,
-) -> Cancelable<()> {
-    let kind = match classify_name_ref(name_ref) {
-        Some(it) => it,
-        None => return Ok(()),
-    };
-    match kind {
-        NameRefKind::LocalRef { enclosing_fn } => {
-            if let Some(fn_def) = enclosing_fn {
-                let scopes = FnScopes::new(fn_def);
-                complete_fn(name_ref, &scopes, acc);
-                complete_expr_keywords(&file, fn_def, name_ref, acc);
-                complete_expr_snippets(acc);
-            }
-            let module_scope = module.scope(db)?;
-            acc.extend(
-                module_scope
-                    .entries()
-                    .filter(|(_name, res)| {
-                        // Don't expose this item
-                        match res.import {
-                            None => true,
-                            Some(import) => {
-                                let range = import.range(db, module.source().file_id());
-                                !range.is_subrange(&name_ref.syntax().range())
-                            }
-                        }
-                    })
-                    .map(|(name, _res)| CompletionItem {
-                        label: name.to_string(),
-                        lookup: None,
-                        snippet: None,
-                    }),
-            );
-        }
-        NameRefKind::Path(path) => complete_path(acc, db, module, path)?,
-        NameRefKind::BareIdentInMod => {
-            let name_range = name_ref.syntax().range();
-            let top_node = name_ref
-                .syntax()
-                .ancestors()
-                .take_while(|it| it.range() == name_range)
-                .last()
-                .unwrap();
-            match top_node.parent().map(|it| it.kind()) {
-                Some(SOURCE_FILE) | Some(ITEM_LIST) => complete_mod_item_snippets(acc),
-                _ => (),
-            }
-        }
-    }
-    Ok(())
-}
-enum NameRefKind<'a> {
-    /// NameRef is a part of single-segment path, for example, a refernece to a
-    /// local variable.
-    LocalRef {
-        enclosing_fn: Option<ast::FnDef<'a>>,
-    },
-    /// NameRef is the last segment in some path
-    Path(Path),
-    /// NameRef is bare identifier at the module's root.
-    /// Used for keyword completion
-    BareIdentInMod,
-}
-fn classify_name_ref(name_ref: ast::NameRef) -> Option<NameRefKind> {
-    let name_range = name_ref.syntax().range();
-    let top_node = name_ref
-        .syntax()
-        .ancestors()
-        .take_while(|it| it.range() == name_range)
-        .last()
-        .unwrap();
-    match top_node.parent().map(|it| it.kind()) {
-        Some(SOURCE_FILE) | Some(ITEM_LIST) => return Some(NameRefKind::BareIdentInMod),
-        _ => (),
-    }
-    let parent = name_ref.syntax().parent()?;
-    if let Some(segment) = ast::PathSegment::cast(parent) {
-        let path = segment.parent_path();
-        if let Some(path) = Path::from_ast(path) {
-            if !path.is_ident() {
-                return Some(NameRefKind::Path(path));
-            }
-        }
-        if path.qualifier().is_none() {
-            let enclosing_fn = name_ref
-                .syntax()
-                .ancestors()
-                .take_while(|it| it.kind() != SOURCE_FILE && it.kind() != MODULE)
-                .find_map(ast::FnDef::cast);
-            return Some(NameRefKind::LocalRef { enclosing_fn });
-        }
-    }
-    None
-}
-fn complete_fn(name_ref: ast::NameRef, scopes: &FnScopes, acc: &mut Vec<CompletionItem>) {
-    let mut shadowed = FxHashSet::default();
-    acc.extend(
-        scopes
-            .scope_chain(name_ref.syntax())
-            .flat_map(|scope| scopes.entries(scope).iter())
-            .filter(|entry| shadowed.insert(entry.name()))
-            .map(|entry| CompletionItem {
-                label: entry.name().to_string(),
-                lookup: None,
-                snippet: None,
-            }),
-    );
-    if scopes.self_param.is_some() {
-        acc.push(CompletionItem {
-            label: "self".to_string(),
-            lookup: None,
-            snippet: None,
-        })
-    }
-}
-fn complete_path(
-    acc: &mut Vec<CompletionItem>,
-    db: &RootDatabase,
-    module: &hir::Module,
-    mut path: Path,
-) -> Cancelable<()> {
-    if path.segments.is_empty() {
-        return Ok(());
-    }
-    path.segments.pop();
-    let def_id = match module.resolve_path(db, path)? {
-        None => return Ok(()),
-        Some(it) => it,
-    };
-    let target_module = match def_id.resolve(db)? {
-        Def::Module(it) => it,
-        _ => return Ok(()),
-    };
-    let module_scope = target_module.scope(db)?;
-    let completions = module_scope.entries().map(|(name, _res)| CompletionItem {
-        label: name.to_string(),
-        lookup: None,
-        snippet: None,
-    });
-    acc.extend(completions);
-    Ok(())
-}
-fn complete_mod_item_snippets(acc: &mut Vec<CompletionItem>) {
-    acc.push(CompletionItem {
-        label: "Test function".to_string(),
-        lookup: Some("tfn".to_string()),
-        snippet: Some(
-            "#[test]\n\
-             fn ${1:feature}() {\n\
-             $0\n\
-             }"
-            .to_string(),
-        ),
-    });
-    acc.push(CompletionItem {
-        label: "pub(crate)".to_string(),
-        lookup: None,
-        snippet: Some("pub(crate) $0".to_string()),
-    })
-}
-fn complete_expr_keywords(
-    file: &SourceFileNode,
-    fn_def: ast::FnDef,
-    name_ref: ast::NameRef,
-    acc: &mut Vec<CompletionItem>,
-) {
-    acc.push(keyword("if", "if $0 {}"));
-    acc.push(keyword("match", "match $0 {}"));
-    acc.push(keyword("while", "while $0 {}"));
-    acc.push(keyword("loop", "loop {$0}"));
-    if let Some(off) = name_ref.syntax().range().start().checked_sub(2.into()) {
-        if let Some(if_expr) = find_node_at_offset::<ast::IfExpr>(file.syntax(), off) {
-            if if_expr.syntax().range().end() < name_ref.syntax().range().start() {
-                acc.push(keyword("else", "else {$0}"));
-                acc.push(keyword("else if", "else if $0 {}"));
-            }
-        }
-    }
-    if is_in_loop_body(name_ref) {
-        acc.push(keyword("continue", "continue"));
-        acc.push(keyword("break", "break"));
-    }
-    acc.extend(complete_return(fn_def, name_ref));
-}
-fn is_in_loop_body(name_ref: ast::NameRef) -> bool {
-    for node in name_ref.syntax().ancestors() {
-        if node.kind() == FN_DEF || node.kind() == LAMBDA_EXPR {
-            break;
-        }
-        let loop_body = visitor()
-            .visit::<ast::ForExpr, _>(LoopBodyOwner::loop_body)
-            .visit::<ast::WhileExpr, _>(LoopBodyOwner::loop_body)
-            .visit::<ast::LoopExpr, _>(LoopBodyOwner::loop_body)
-            .accept(node);
-        if let Some(Some(body)) = loop_body {
-            if name_ref
-                .syntax()
-                .range()
-                .is_subrange(&body.syntax().range())
-            {
-                return true;
-            }
-        }
-    }
-    false
-}
-fn complete_return(fn_def: ast::FnDef, name_ref: ast::NameRef) -> Option<CompletionItem> {
-    // let is_last_in_block = name_ref.syntax().ancestors().filter_map(ast::Expr::cast)
-    //     .next()
-    //     .and_then(|it| it.syntax().parent())
-    //     .and_then(ast::Block::cast)
-    //     .is_some();
-    // if is_last_in_block {
-    //     return None;
-    // }
-    let is_stmt = match name_ref
-        .syntax()
-        .ancestors()
-        .filter_map(ast::ExprStmt::cast)
-        .next()
-    {
-        None => false,
-        Some(expr_stmt) => expr_stmt.syntax().range() == name_ref.syntax().range(),
-    };
-    let snip = match (is_stmt, fn_def.ret_type().is_some()) {
-        (true, true) => "return $0;",
-        (true, false) => "return;",
-        (false, true) => "return $0",
-        (false, false) => "return",
-    };
-    Some(keyword("return", snip))
-}
-fn keyword(kw: &str, snip: &str) -> CompletionItem {
-    CompletionItem {
-        label: kw.to_string(),
-        lookup: None,
-        snippet: Some(snip.to_string()),
-    }
-}
-fn complete_expr_snippets(acc: &mut Vec<CompletionItem>) {
-    acc.push(CompletionItem {
-        label: "pd".to_string(),
-        lookup: None,
-        snippet: Some("eprintln!(\"$0 = {:?}\", $0);".to_string()),
-    });
-    acc.push(CompletionItem {
-        label: "ppd".to_string(),
-        lookup: None,
-        snippet: Some("eprintln!(\"$0 = {:#?}\", $0);".to_string()),
-    });
-}
diff --git a/crates/ra_analysis/src/db.rs b/crates/ra_analysis/src/db.rs
index 3d0f13f34..94729d296 100644
--- a/crates/ra_analysis/src/db.rs
+++ b/crates/ra_analysis/src/db.rs
@@ -1,4 +1,4 @@
-use std::sync::Arc;
+use std::{fmt, sync::Arc};
 use salsa::{self, Database};
 use ra_db::{LocationIntener, BaseDatabase};
 use hir::{self, DefId, DefLoc};
@@ -13,11 +13,19 @@ pub(crate) struct RootDatabase {
    id_maps: Arc<IdMaps>,
 }
-#[derive(Debug, Default)]
+#[derive(Default)]
 struct IdMaps {
    defs: LocationIntener<DefLoc, DefId>,
 }
+impl fmt::Debug for IdMaps {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.debug_struct("IdMaps")
+            .field("n_defs", &self.defs.len())
+            .finish()
+    }
+}
 impl salsa::Database for RootDatabase {
    fn salsa_runtime(&self) -> &salsa::Runtime<RootDatabase> {
        &self.runtime
diff --git a/crates/ra_analysis/src/imp.rs b/crates/ra_analysis/src/imp.rs
index b44d9297a..b01382808 100644
--- a/crates/ra_analysis/src/imp.rs
+++ b/crates/ra_analysis/src/imp.rs
@@ -25,7 +25,7 @@ use crate::{
    db,
    symbol_index::{SymbolIndex, SymbolsDatabase, LibrarySymbolsQuery},
    AnalysisChange, RootChange, Cancelable, CrateId, Diagnostic, FileId,
-    FileSystemEdit, FilePosition, Query, SourceChange, SourceFileNodeEdit,
+    FileSystemEdit, FilePosition, Query, SourceChange, SourceFileEdit,
    ReferenceResolution,
 };
@@ -219,7 +219,8 @@ impl AnalysisImpl {
        self.db.crate_graph().crate_root(crate_id)
    }
    pub fn completions(&self, position: FilePosition) -> Cancelable<Option<Vec<CompletionItem>>> {
-        completions(&self.db, position)
+        let completions = completions(&self.db, position)?;
+        Ok(completions.map(|it| it.into()))
    }
    pub fn approximately_resolve_symbol(
        &self,
@@ -234,7 +235,7 @@ impl AnalysisImpl {
                position.file_id,
                name_ref.syntax(),
            )? {
-                let scope = fn_descr.scope(&*self.db);
+                let scope = fn_descr.scopes(&*self.db);
                // First try to resolve the symbol locally
                if let Some(entry) = scope.resolve_local_name(name_ref) {
                    rr.add_resolution(
@@ -293,7 +294,7 @@ impl AnalysisImpl {
        let mut ret = vec![(position.file_id, binding.syntax().range())];
        ret.extend(
            descr
-                .scope(&*self.db)
+                .scopes(&*self.db)
                .find_all_refs(binding)
                .into_iter()
                .map(|ref_desc| (position.file_id, ref_desc.range)),
@@ -321,7 +322,7 @@ impl AnalysisImpl {
                position.file_id,
                name_ref.syntax(),
            )?);
-            let scope = descr.scope(db);
+            let scope = descr.scopes(db);
            let resolved = ctry!(scope.resolve_local_name(name_ref));
            let resolved = resolved.ptr().resolve(source_file);
            let binding = ctry!(find_node_at_offset::<ast::BindPat>(
@@ -368,10 +369,11 @@ impl AnalysisImpl {
            .collect::<Vec<_>>();
        if let Some(m) = source_binder::module_from_file_id(&*self.db, file_id)? {
            for (name_node, problem) in m.problems(&*self.db) {
+                let source_root = self.db.file_source_root(file_id);
                let diag = match problem {
                    Problem::UnresolvedModule { candidate } => {
                        let create_file = FileSystemEdit::CreateFile {
-                            anchor: file_id,
+                            source_root,
                            path: candidate.clone(),
                        };
                        let fix = SourceChange {
@@ -388,11 +390,12 @@ impl AnalysisImpl {
                    }
                    Problem::NotDirOwner { move_to, candidate } => {
                        let move_file = FileSystemEdit::MoveFile {
-                            file: file_id,
+                            src: file_id,
-                            path: move_to.clone(),
+                            dst_source_root: source_root,
+                            dst_path: move_to.clone(),
                        };
                        let create_file = FileSystemEdit::CreateFile {
-                            anchor: file_id,
+                            source_root,
                            path: move_to.join(candidate),
                        };
                        let fix = SourceChange {
@@ -518,9 +521,9 @@ impl AnalysisImpl {
 impl SourceChange {
    pub(crate) fn from_local_edit(file_id: FileId, label: &str, edit: LocalEdit) -> SourceChange {
-        let file_edit = SourceFileNodeEdit {
+        let file_edit = SourceFileEdit {
            file_id,
-            edits: edit.edit.into_atoms(),
+            edit: edit.edit,
        };
        SourceChange {
            label: label.to_string(),
diff --git a/crates/ra_analysis/src/lib.rs b/crates/ra_analysis/src/lib.rs
index a1d462528..85df9c089 100644
--- a/crates/ra_analysis/src/lib.rs
+++ b/crates/ra_analysis/src/lib.rs
@@ -20,7 +20,7 @@ use std::{fmt, sync::Arc};
 use rustc_hash::FxHashMap;
 use ra_syntax::{SourceFileNode, TextRange, TextUnit};
-use ra_text_edit::AtomTextEdit;
+use ra_text_edit::TextEdit;
 use rayon::prelude::*;
 use relative_path::RelativePathBuf;
@@ -30,7 +30,7 @@ use crate::{
 };
 pub use crate::{
-    completion::CompletionItem,
+    completion::{CompletionItem, CompletionItemKind, InsertText},
 };
 pub use ra_editor::{
    FileSymbol, Fold, FoldKind, HighlightedRange, LineIndex, Runnable, RunnableKind, StructureNode,
@@ -72,13 +72,23 @@ struct RemoveFile {
 impl fmt::Debug for AnalysisChange {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        fmt.debug_struct("AnalysisChange")
+        let mut d = fmt.debug_struct("AnalysisChange");
-            .field("new_roots", &self.new_roots)
+        if !self.new_roots.is_empty() {
-            .field("roots_changed", &self.roots_changed)
+            d.field("new_roots", &self.new_roots);
-            .field("files_changed", &self.files_changed.len())
+        }
-            .field("libraries_added", &self.libraries_added.len())
+        if !self.roots_changed.is_empty() {
-            .field("crate_graph", &self.crate_graph)
+            d.field("roots_changed", &self.roots_changed);
-            .finish()
+        }
+        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_some() {
+            d.field("crate_graph", &self.crate_graph);
+        }
+        d.finish()
    }
 }
@@ -159,26 +169,27 @@ impl AnalysisHost {
 #[derive(Debug)]
 pub struct SourceChange {
    pub label: String,
-    pub source_file_edits: Vec<SourceFileNodeEdit>,
+    pub source_file_edits: Vec<SourceFileEdit>,
    pub file_system_edits: Vec<FileSystemEdit>,
    pub cursor_position: Option<FilePosition>,
 }
 #[derive(Debug)]
-pub struct SourceFileNodeEdit {
+pub struct SourceFileEdit {
    pub file_id: FileId,
-    pub edits: Vec<AtomTextEdit>,
+    pub edit: TextEdit,
 }
 #[derive(Debug)]
 pub enum FileSystemEdit {
    CreateFile {
-        anchor: FileId,
+        source_root: SourceRootId,
        path: RelativePathBuf,
    },
    MoveFile {
-        file: FileId,
+        src: FileId,
-        path: RelativePathBuf,
+        dst_source_root: SourceRootId,
+        dst_path: RelativePathBuf,
    },
 }
@@ -357,13 +368,22 @@ impl Analysis {
    }
 }
-#[derive(Debug)]
 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,
diff --git a/crates/ra_analysis/src/symbol_index.rs b/crates/ra_analysis/src/symbol_index.rs
index b48a37229..e5bdf0aa1 100644
--- a/crates/ra_analysis/src/symbol_index.rs
+++ b/crates/ra_analysis/src/symbol_index.rs
@@ -56,6 +56,10 @@ impl Hash for SymbolIndex {
 }
 impl SymbolIndex {
+    pub(crate) fn len(&self) -> usize {
+        self.symbols.len()
+    }
    pub(crate) fn for_files(
        files: impl ParallelIterator<Item = (FileId, SourceFileNode)>,
    ) -> SymbolIndex {
diff --git a/crates/ra_analysis/tests/tests.rs b/crates/ra_analysis/tests/tests.rs
index 889b568b9..938ca797a 100644
--- a/crates/ra_analysis/tests/tests.rs
+++ b/crates/ra_analysis/tests/tests.rs
@@ -81,7 +81,7 @@ fn test_unresolved_module_diagnostic() {
            fix: Some(SourceChange {
                label: "create module",
                source_file_edits: [],
-                file_system_edits: [CreateFile { anchor: FileId(1), path: "../foo.rs" }],
+                file_system_edits: [CreateFile { source_root: SourceRootId(0), path: "foo.rs" }],
                cursor_position: None }) }]"#,
        &diagnostics,
    );
@@ -452,63 +452,3 @@ fn test_find_all_refs_for_fn_param() {
    let refs = get_all_refs(code);
    assert_eq!(refs.len(), 2);
 }
-#[test]
-fn test_complete_crate_path() {
-    let (analysis, position) = analysis_and_position(
-        "
-        //- /lib.rs
-        mod foo;
-        struct Spam;
-        //- /foo.rs
-        use crate::Sp<|>
-    ",
-    );
-    let completions = analysis.completions(position).unwrap().unwrap();
-    assert_eq_dbg(
-        r#"[CompletionItem { label: "Spam", lookup: None, snippet: None },
-            CompletionItem { label: "foo", lookup: None, snippet: None }]"#,
-        &completions,
-    );
-}
-#[test]
-fn test_complete_crate_path_with_braces() {
-    let (analysis, position) = analysis_and_position(
-        "
-        //- /lib.rs
-        mod foo;
-        struct Spam;
-        //- /foo.rs
-        use crate::{Sp<|>};
-    ",
-    );
-    let completions = analysis.completions(position).unwrap().unwrap();
-    assert_eq_dbg(
-        r#"[CompletionItem { label: "Spam", lookup: None, snippet: None },
-            CompletionItem { label: "foo", lookup: None, snippet: None }]"#,
-        &completions,
-    );
-}
-#[test]
-fn test_complete_crate_path_in_nested_tree() {
-    let (analysis, position) = analysis_and_position(
-        "
-        //- /lib.rs
-        mod foo;
-        pub mod bar {
-            pub mod baz {
-                pub struct Spam;
-            }
-        }
-        //- /foo.rs
-        use crate::{bar::{baz::Sp<|>}};
-    ",
-    );
-    let completions = analysis.completions(position).unwrap().unwrap();
-    assert_eq_dbg(
-        r#"[CompletionItem { label: "Spam", lookup: None, snippet: None }]"#,
-        &completions,
-    );
-}
diff --git a/crates/ra_db/src/input.rs b/crates/ra_db/src/input.rs
index f12dd9345..7c3dd9296 100644
--- a/crates/ra_db/src/input.rs
+++ b/crates/ra_db/src/input.rs
@@ -7,11 +7,13 @@
 /// actual IO is done and lowered to input.
 use std::sync::Arc;
-use rustc_hash::{FxHashMap};
 use relative_path::RelativePathBuf;
-use ra_syntax::SmolStr;
+use rustc_hash::FxHashMap;
 use salsa;
+use ra_syntax::SmolStr;
+use rustc_hash::FxHashSet;
 /// `FileId` is an integer which uniquely identifies a file. File paths are
 /// messy and system-dependent, so most of the code should work directly with
 /// `FileId`, without inspecting the path. The mapping between `FileId` and path
@@ -92,12 +94,16 @@ impl CrateGraph {
        assert!(prev.is_none());
        crate_id
    }
-    // FIXME: check that we don't have cycles here.
-    // Just a simple depth first search from `to` should work,
-    // the graph is small.
    pub fn add_dep(&mut self, from: CrateId, name: SmolStr, to: CrateId) {
+        let mut visited = FxHashSet::default();
+        if self.dfs_find(from, to, &mut visited) {
+            panic!("Cycle dependencies found.")
+        }
        self.arena.get_mut(&from).unwrap().add_dep(name, to)
    }
+    pub fn is_empty(&self) -> bool {
+        self.arena.is_empty()
+    }
    pub fn crate_root(&self, crate_id: CrateId) -> FileId {
        self.arena[&crate_id].file_id
    }
@@ -114,6 +120,52 @@ impl CrateGraph {
    ) -> impl Iterator<Item = &'a Dependency> + 'a {
        self.arena[&crate_id].dependencies.iter()
    }
+    fn dfs_find(&self, target: CrateId, from: CrateId, visited: &mut FxHashSet<CrateId>) -> bool {
+        if !visited.insert(from) {
+            return false;
+        }
+        for dep in self.dependencies(from) {
+            let crate_id = dep.crate_id();
+            if crate_id == target {
+                return true;
+            }
+            if self.dfs_find(target, crate_id, visited) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
+#[cfg(test)]
+mod tests {
+    use super::{CrateGraph, FxHashMap, FileId, SmolStr};
+    #[test]
+    #[should_panic]
+    fn it_should_painc_because_of_cycle_dependencies() {
+        let mut graph = CrateGraph::default();
+        let crate1 = graph.add_crate_root(FileId(1u32));
+        let crate2 = graph.add_crate_root(FileId(2u32));
+        let crate3 = graph.add_crate_root(FileId(3u32));
+        graph.add_dep(crate1, SmolStr::new("crate2"), crate2);
+        graph.add_dep(crate2, SmolStr::new("crate3"), crate3);
+        graph.add_dep(crate3, SmolStr::new("crate1"), crate1);
+    }
+    #[test]
+    fn it_works() {
+        let mut graph = CrateGraph {
+            arena: FxHashMap::default(),
+        };
+        let crate1 = graph.add_crate_root(FileId(1u32));
+        let crate2 = graph.add_crate_root(FileId(2u32));
+        let crate3 = graph.add_crate_root(FileId(3u32));
+        graph.add_dep(crate1, SmolStr::new("crate2"), crate2);
+        graph.add_dep(crate2, SmolStr::new("crate3"), crate3);
+    }
 }
 salsa::query_group! {
diff --git a/crates/ra_db/src/lib.rs b/crates/ra_db/src/lib.rs
index 65fa3cbfa..0aca6f343 100644
--- a/crates/ra_db/src/lib.rs
+++ b/crates/ra_db/src/lib.rs
@@ -15,7 +15,7 @@ pub type Cancelable<T> = Result<T, Canceled>;
 impl std::fmt::Display for Canceled {
    fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        fmt.write_str("Canceled")
+        fmt.write_str("canceled")
    }
 }
diff --git a/crates/ra_db/src/loc2id.rs b/crates/ra_db/src/loc2id.rs
index 69ba43d0f..2dc7930d8 100644
--- a/crates/ra_db/src/loc2id.rs
+++ b/crates/ra_db/src/loc2id.rs
@@ -42,6 +42,10 @@ where
    ID: NumericId,
    LOC: Clone + Eq + Hash,
 {
+    pub fn len(&self) -> usize {
+        self.loc2id.len()
+    }
    pub fn loc2id(&mut self, loc: &LOC) -> ID {
        match self.loc2id.get(loc) {
            Some(id) => return id.clone(),
@@ -91,6 +95,9 @@ where
    ID: NumericId,
    LOC: Clone + Eq + Hash,
 {
+    pub fn len(&self) -> usize {
+        self.map.lock().len()
+    }
    pub fn loc2id(&self, loc: &LOC) -> ID {
        self.map.lock().loc2id(loc)
    }
diff --git a/crates/ra_editor/src/folding_ranges.rs b/crates/ra_editor/src/folding_ranges.rs
index 2a8fa3cda..da542ecf0 100644
--- a/crates/ra_editor/src/folding_ranges.rs
+++ b/crates/ra_editor/src/folding_ranges.rs
@@ -10,6 +10,7 @@ use ra_syntax::{
 pub enum FoldKind {
    Comment,
    Imports,
+    Block,
 }
 #[derive(Debug)]
@@ -62,6 +63,8 @@ fn fold_kind(kind: SyntaxKind) -> Option<FoldKind> {
    match kind {
        COMMENT => Some(FoldKind::Comment),
        USE_ITEM => Some(FoldKind::Imports),
+        NAMED_FIELD_DEF_LIST | FIELD_PAT_LIST | ITEM_LIST | EXTERN_ITEM_LIST | USE_TREE_LIST
+        | BLOCK | ENUM_VARIANT_LIST => Some(FoldKind::Block),
        _ => None,
    }
 }
@@ -170,7 +173,7 @@ mod tests {
    use test_utils::extract_ranges;
    fn do_check(text: &str, fold_kinds: &[FoldKind]) {
-        let (ranges, text) = extract_ranges(text);
+        let (ranges, text) = extract_ranges(text, "fold");
        let file = SourceFileNode::parse(&text);
        let folds = folding_ranges(&file);
@@ -198,26 +201,27 @@ mod tests {
    #[test]
    fn test_fold_comments() {
        let text = r#"
-<|>// Hello
+<fold>// Hello
 // this is a multiline
 // comment
-//<|>
+//</fold>
 // But this is not
-fn main() {
+fn main() <fold>{
-    <|>// We should
+    <fold>// We should
    // also
    // fold
-    // this one.<|>
+    // this one.</fold>
-    <|>//! But this one is different
+    <fold>//! But this one is different
-    //! because it has another flavor<|>
+    //! because it has another flavor</fold>
-    <|>/* As does this
+    <fold>/* As does this
-    multiline comment */<|>
+    multiline comment */</fold>
-}"#;
+}</fold>"#;
        let fold_kinds = &[
            FoldKind::Comment,
+            FoldKind::Block,
            FoldKind::Comment,
            FoldKind::Comment,
            FoldKind::Comment,
@@ -228,60 +232,66 @@ fn main() {
    #[test]
    fn test_fold_imports() {
        let text = r#"
-<|>use std::{
+<fold>use std::<fold>{
    str,
    vec,
    io as iop
-};<|>
+}</fold>;</fold>
-fn main() {
+fn main() <fold>{
-}"#;
+}</fold>"#;
-        let folds = &[FoldKind::Imports];
+        let folds = &[FoldKind::Imports, FoldKind::Block, FoldKind::Block];
        do_check(text, folds);
    }
    #[test]
    fn test_fold_import_groups() {
        let text = r#"
-<|>use std::str;
+<fold>use std::str;
 use std::vec;
-use std::io as iop;<|>
+use std::io as iop;</fold>
-<|>use std::mem;
+<fold>use std::mem;
-use std::f64;<|>
+use std::f64;</fold>
 use std::collections::HashMap;
 // Some random comment
 use std::collections::VecDeque;
-fn main() {
+fn main() <fold>{
-}"#;
+}</fold>"#;
-        let folds = &[FoldKind::Imports, FoldKind::Imports];
+        let folds = &[FoldKind::Imports, FoldKind::Imports, FoldKind::Block];
        do_check(text, folds);
    }
    #[test]
    fn test_fold_import_and_groups() {
        let text = r#"
-<|>use std::str;
+<fold>use std::str;
 use std::vec;
-use std::io as iop;<|>
+use std::io as iop;</fold>
-<|>use std::mem;
+<fold>use std::mem;
-use std::f64;<|>
+use std::f64;</fold>
-<|>use std::collections::{
+<fold>use std::collections::<fold>{
    HashMap,
    VecDeque,
-};<|>
+}</fold>;</fold>
 // Some random comment
-fn main() {
+fn main() <fold>{
-}"#;
+}</fold>"#;
-        let folds = &[FoldKind::Imports, FoldKind::Imports, FoldKind::Imports];
+        let folds = &[
+            FoldKind::Imports,
+            FoldKind::Imports,
+            FoldKind::Imports,
+            FoldKind::Block,
+            FoldKind::Block,
+        ];
        do_check(text, folds);
    }
diff --git a/crates/ra_editor/src/typing.rs b/crates/ra_editor/src/typing.rs
index 46a6e2d62..5e412bcfa 100644
--- a/crates/ra_editor/src/typing.rs
+++ b/crates/ra_editor/src/typing.rs
@@ -164,6 +164,16 @@ fn remove_newline(
    if join_single_expr_block(edit, node).is_some() {
        return;
    }
+    // ditto for
+    //
+    // ```
+    // use foo::{<|>
+    //    bar
+    // };
+    // ```
+    if join_single_use_tree(edit, node).is_some() {
+        return;
+    }
    // The node is between two other nodes
    let prev = node.prev_sibling().unwrap();
@@ -228,6 +238,36 @@ fn single_expr(block: ast::Block) -> Option<ast::Expr> {
    res
 }
+fn join_single_use_tree(edit: &mut TextEditBuilder, node: SyntaxNodeRef) -> Option<()> {
+    let use_tree_list = ast::UseTreeList::cast(node.parent()?)?;
+    let tree = single_use_tree(use_tree_list)?;
+    edit.replace(
+        use_tree_list.syntax().range(),
+        tree.syntax().text().to_string(),
+    );
+    Some(())
+}
+fn single_use_tree(tree_list: ast::UseTreeList) -> Option<ast::UseTree> {
+    let mut res = None;
+    for child in tree_list.syntax().children() {
+        if let Some(tree) = ast::UseTree::cast(child) {
+            if tree.syntax().text().contains('\n') {
+                return None;
+            }
+            if mem::replace(&mut res, Some(tree)).is_some() {
+                return None;
+            }
+        } else {
+            match child.kind() {
+                WHITESPACE | L_CURLY | R_CURLY | COMMA => (),
+                _ => return None,
+            }
+        }
+    }
+    res
+}
 fn compute_ws(left: SyntaxNodeRef, right: SyntaxNodeRef) -> &'static str {
    match left.kind() {
        L_PAREN | L_BRACK => return "",
@@ -306,6 +346,24 @@ fn foo() {
    }
    #[test]
+    fn test_join_lines_use_tree() {
+        check_join_lines(
+            r"
+use ra_syntax::{
+    algo::<|>{
+        find_leaf_at_offset,
+    },
+    ast,
+};",
+            r"
+use ra_syntax::{
+    algo::<|>find_leaf_at_offset,
+    ast,
+};",
+        );
+    }
+    #[test]
    fn test_join_lines_normal_comments() {
        check_join_lines(
            r"
diff --git a/crates/ra_hir/src/function.rs b/crates/ra_hir/src/function.rs
index 5187dc051..2925beb16 100644
--- a/crates/ra_hir/src/function.rs
+++ b/crates/ra_hir/src/function.rs
@@ -27,7 +27,7 @@ impl Function {
        Function { fn_id }
    }
-    pub fn scope(&self, db: &impl HirDatabase) -> Arc<FnScopes> {
+    pub fn scopes(&self, db: &impl HirDatabase) -> Arc<FnScopes> {
        db.fn_scopes(self.fn_id)
    }
diff --git a/crates/ra_hir/src/function/scope.rs b/crates/ra_hir/src/function/scope.rs
index 863453291..a1a580979 100644
--- a/crates/ra_hir/src/function/scope.rs
+++ b/crates/ra_hir/src/function/scope.rs
@@ -1,7 +1,7 @@
 use rustc_hash::{FxHashMap, FxHashSet};
 use ra_syntax::{
-    AstNode, SmolStr, SyntaxNodeRef, TextRange,
+    AstNode, SmolStr, SyntaxNodeRef, TextUnit, TextRange,
    algo::generate,
    ast::{self, ArgListOwner, LoopBodyOwner, NameOwner},
 };
@@ -33,7 +33,7 @@ pub struct ScopeData {
 }
 impl FnScopes {
-    pub fn new(fn_def: ast::FnDef) -> FnScopes {
+    pub(crate) fn new(fn_def: ast::FnDef) -> FnScopes {
        let mut scopes = FnScopes {
            self_param: fn_def
                .param_list()
@@ -57,6 +57,48 @@ impl FnScopes {
            self.scopes[scope].parent
        })
    }
+    pub fn scope_chain_for_offset<'a>(
+        &'a self,
+        offset: TextUnit,
+    ) -> impl Iterator<Item = ScopeId> + 'a {
+        let scope = self
+            .scope_for
+            .iter()
+            // find containin scope
+            .min_by_key(|(ptr, _scope)| {
+                (
+                    !(ptr.range().start() <= offset && offset <= ptr.range().end()),
+                    ptr.range().len(),
+                )
+            })
+            .map(|(ptr, scope)| self.adjust(*ptr, *scope, offset));
+        generate(scope, move |&scope| self.scopes[scope].parent)
+    }
+    // XXX: during completion, cursor might be outside of any particular
+    // expression. Try to figure out the correct scope...
+    fn adjust(&self, ptr: LocalSyntaxPtr, original_scope: ScopeId, offset: TextUnit) -> ScopeId {
+        let r = ptr.range();
+        let child_scopes = self
+            .scope_for
+            .iter()
+            .map(|(ptr, scope)| (ptr.range(), scope))
+            .filter(|(range, _)| range.start() <= offset && range.is_subrange(&r) && *range != r);
+        child_scopes
+            .max_by(|(r1, _), (r2, _)| {
+                if r2.is_subrange(&r1) {
+                    std::cmp::Ordering::Greater
+                } else if r1.is_subrange(&r2) {
+                    std::cmp::Ordering::Less
+                } else {
+                    r1.start().cmp(&r2.start())
+                }
+            })
+            .map(|(_ptr, scope)| *scope)
+            .unwrap_or(original_scope)
+    }
    pub fn resolve_local_name<'a>(&'a self, name_ref: ast::NameRef) -> Option<&'a ScopeEntry> {
        let mut shadowed = FxHashSet::default();
        let ret = self
@@ -144,6 +186,8 @@ impl ScopeEntry {
 }
 fn compute_block_scopes(block: ast::Block, scopes: &mut FnScopes, mut scope: ScopeId) {
+    // A hack for completion :(
+    scopes.set_scope(block.syntax(), scope);
    for stmt in block.statements() {
        match stmt {
            ast::Stmt::LetStmt(stmt) => {
diff --git a/crates/ra_hir/src/lib.rs b/crates/ra_hir/src/lib.rs
index 5941a9ea3..f56214b47 100644
--- a/crates/ra_hir/src/lib.rs
+++ b/crates/ra_hir/src/lib.rs
@@ -39,7 +39,7 @@ use crate::{
 pub use self::{
    path::{Path, PathKind},
    krate::Crate,
-    module::{Module, ModuleId, Problem, nameres::ItemMap},
+    module::{Module, ModuleId, Problem, nameres::ItemMap, ModuleScope, Resolution},
    function::{Function, FnScopes},
 };
diff --git a/crates/ra_hir/src/module.rs b/crates/ra_hir/src/module.rs
index d5866f6ef..cd31e8cfe 100644
--- a/crates/ra_hir/src/module.rs
+++ b/crates/ra_hir/src/module.rs
@@ -16,7 +16,7 @@ use crate::{
    arena::{Arena, Id},
 };
-pub use self::nameres::ModuleScope;
+pub use self::nameres::{ModuleScope, Resolution};
 /// `Module` is API entry point to get all the information
 /// about a particular module.
diff --git a/crates/ra_hir/src/module/imp.rs b/crates/ra_hir/src/module/imp.rs
index f3a346152..748fdb64e 100644
--- a/crates/ra_hir/src/module/imp.rs
+++ b/crates/ra_hir/src/module/imp.rs
@@ -4,7 +4,7 @@ use ra_syntax::{
    ast::{self, NameOwner},
    SmolStr,
 };
-use relative_path::{RelativePathBuf, RelativePath};
+use relative_path::RelativePathBuf;
 use rustc_hash::{FxHashMap, FxHashSet};
 use arrayvec::ArrayVec;
 use ra_db::{SourceRoot, SourceRootId, Cancelable, FileId};
@@ -184,11 +184,7 @@ fn resolve_submodule(
        .collect::<Vec<_>>();
    let problem = if points_to.is_empty() {
        Some(Problem::UnresolvedModule {
-            candidate: RelativePath::new("../").join(&if is_dir_owner {
+            candidate: if is_dir_owner { file_mod } else { file_dir_mod },
-                file_mod
-            } else {
-                file_dir_mod
-            }),
        })
    } else {
        None
diff --git a/crates/ra_hir/src/module/nameres.rs b/crates/ra_hir/src/module/nameres.rs
index f44abc730..39e891cda 100644
--- a/crates/ra_hir/src/module/nameres.rs
+++ b/crates/ra_hir/src/module/nameres.rs
@@ -49,7 +49,7 @@ pub struct ModuleScope {
 }
 impl ModuleScope {
-    pub fn entries<'a>(&'a self) -> impl Iterator<Item = (&'a SmolStr, &Resolution)> + 'a {
+    pub fn entries<'a>(&'a self) -> impl Iterator<Item = (&'a SmolStr, &'a Resolution)> + 'a {
        self.items.iter()
    }
    pub fn get(&self, name: &SmolStr) -> Option<&Resolution> {
diff --git a/crates/ra_hir/src/module/nameres/tests.rs b/crates/ra_hir/src/module/nameres/tests.rs
index 9fa9146e3..3e29c3954 100644
--- a/crates/ra_hir/src/module/nameres/tests.rs
+++ b/crates/ra_hir/src/module/nameres/tests.rs
@@ -44,6 +44,25 @@ fn item_map_smoke_test() {
 }
 #[test]
+fn test_self() {
+    let (item_map, module_id) = item_map(
+        "
+            //- /lib.rs
+            mod foo;
+            use crate::foo::bar::Baz::{self};
+            <|>
+            //- /foo/mod.rs
+            pub mod bar;
+            //- /foo/bar.rs
+            pub struct Baz;
+        ",
+    );
+    let name = SmolStr::from("Baz");
+    let resolution = &item_map.per_module[&module_id].items[&name];
+    assert!(resolution.def_id.is_some());
+}
+#[test]
 fn item_map_across_crates() {
    let (mut db, sr) = MockDatabase::with_files(
        "
diff --git a/crates/ra_hir/src/path.rs b/crates/ra_hir/src/path.rs
index 4a2e427cd..e04d00900 100644
--- a/crates/ra_hir/src/path.rs
+++ b/crates/ra_hir/src/path.rs
@@ -76,17 +76,32 @@ fn expand_use_tree(
 ) {
    if let Some(use_tree_list) = tree.use_tree_list() {
        let prefix = match tree.path() {
+            // E.g. use something::{{{inner}}};
            None => prefix,
+            // E.g. `use something::{inner}` (prefix is `None`, path is `something`)
+            // or `use something::{path::{inner::{innerer}}}` (prefix is `something::path`, path is `inner`)
            Some(path) => match convert_path(prefix, path) {
                Some(it) => Some(it),
                None => return, // TODO: report errors somewhere
            },
        };
-        for tree in use_tree_list.use_trees() {
+        for child_tree in use_tree_list.use_trees() {
-            expand_use_tree(prefix.clone(), tree, cb);
+            expand_use_tree(prefix.clone(), child_tree, cb);
        }
    } else {
        if let Some(ast_path) = tree.path() {
+            // Handle self in a path.
+            // E.g. `use something::{self, <...>}`
+            if ast_path.qualifier().is_none() {
+                if let Some(segment) = ast_path.segment() {
+                    if segment.kind() == Some(ast::PathSegmentKind::SelfKw) {
+                        if let Some(prefix) = prefix {
+                            cb(prefix, Some(segment.syntax().range()));
+                            return;
+                        }
+                    }
+                }
+            }
            if let Some(path) = convert_path(prefix, ast_path) {
                let range = if tree.has_star() {
                    None
@@ -96,6 +111,8 @@ fn expand_use_tree(
                };
                cb(path, range)
            }
+            // TODO: report errors somewhere
+            // We get here if we do
        }
    }
 }
diff --git a/crates/ra_hir/src/source_binder.rs b/crates/ra_hir/src/source_binder.rs
index ce2a0f2e8..a0165aef2 100644
--- a/crates/ra_hir/src/source_binder.rs
+++ b/crates/ra_hir/src/source_binder.rs
@@ -74,6 +74,16 @@ pub fn function_from_source(
    fn_def: ast::FnDef,
 ) -> Cancelable<Option<Function>> {
    let module = ctry!(module_from_child_node(db, file_id, fn_def.syntax())?);
+    let res = function_from_module(db, &module, fn_def);
+    Ok(Some(res))
+}
+pub fn function_from_module(
+    db: &impl HirDatabase,
+    module: &Module,
+    fn_def: ast::FnDef,
+) -> Function {
+    let file_id = module.source().file_id();
    let file_items = db.file_items(file_id);
    let item_id = file_items.id_of(file_id, fn_def.syntax());
    let source_item_id = SourceItemId {
@@ -86,7 +96,7 @@ pub fn function_from_source(
        module_id: module.module_id,
        source_item_id,
    };
-    Ok(Some(Function::new(def_loc.id(db))))
+    Function::new(def_loc.id(db))
 }
 pub fn function_from_child_node(
diff --git a/crates/ra_lsp_server/Cargo.toml b/crates/ra_lsp_server/Cargo.toml
index fc10096e5..3c8c240cd 100644
--- a/crates/ra_lsp_server/Cargo.toml
+++ b/crates/ra_lsp_server/Cargo.toml
@@ -12,7 +12,6 @@ failure = "0.1.2"
 failure_derive = "0.1.2"
 serde_json = "1.0.24"
 serde = "1.0.71"
-serde_derive = "1.0.71"
 drop_bomb = "0.1.0"
 crossbeam-channel = "0.2.4"
 flexi_logger = "0.10.0"
diff --git a/crates/ra_lsp_server/src/conv.rs b/crates/ra_lsp_server/src/conv.rs
index 7467f472c..051f1f995 100644
--- a/crates/ra_lsp_server/src/conv.rs
+++ b/crates/ra_lsp_server/src/conv.rs
@@ -1,8 +1,8 @@
 use languageserver_types::{
    self, Location, Position, Range, SymbolKind, TextDocumentEdit, TextDocumentIdentifier,
-    TextDocumentItem, TextDocumentPositionParams, Url, VersionedTextDocumentIdentifier,
+    TextDocumentItem, TextDocumentPositionParams, Url, VersionedTextDocumentIdentifier, InsertTextFormat,
 };
-use ra_analysis::{FileId, FileSystemEdit, SourceChange, SourceFileNodeEdit, FilePosition};
+use ra_analysis::{FileId, FileSystemEdit, SourceChange, SourceFileEdit, FilePosition, CompletionItem, CompletionItemKind, InsertText};
 use ra_editor::{LineCol, LineIndex};
 use ra_text_edit::{AtomTextEdit, TextEdit};
 use ra_syntax::{SyntaxKind, TextRange, TextUnit};
@@ -45,6 +45,46 @@ impl Conv for SyntaxKind {
    }
 }
+impl Conv for CompletionItemKind {
+    type Output = ::languageserver_types::CompletionItemKind;
+    fn conv(self) -> <Self as Conv>::Output {
+        use ::languageserver_types::CompletionItemKind::*;
+        match self {
+            CompletionItemKind::Keyword => Keyword,
+            CompletionItemKind::Snippet => Snippet,
+            CompletionItemKind::Module => Module,
+            CompletionItemKind::Function => Function,
+            CompletionItemKind::Binding => Variable,
+        }
+    }
+}
+impl Conv for CompletionItem {
+    type Output = ::languageserver_types::CompletionItem;
+    fn conv(self) -> <Self as Conv>::Output {
+        let mut res = ::languageserver_types::CompletionItem {
+            label: self.label().to_string(),
+            filter_text: Some(self.lookup().to_string()),
+            kind: self.kind().map(|it| it.conv()),
+            ..Default::default()
+        };
+        match self.insert_text() {
+            InsertText::PlainText { text } => {
+                res.insert_text = Some(text);
+                res.insert_text_format = Some(InsertTextFormat::PlainText);
+            }
+            InsertText::Snippet { text } => {
+                res.insert_text = Some(text);
+                res.insert_text_format = Some(InsertTextFormat::Snippet);
+                res.kind = Some(languageserver_types::CompletionItemKind::Keyword);
+            }
+        }
+        res
+    }
+}
 impl ConvWith for Position {
    type Ctx = LineIndex;
    type Output = TextUnit;
@@ -97,21 +137,21 @@ impl ConvWith for TextEdit {
    type Output = Vec<languageserver_types::TextEdit>;
    fn conv_with(self, line_index: &LineIndex) -> Vec<languageserver_types::TextEdit> {
-        self.into_atoms()
+        self.as_atoms()
            .into_iter()
            .map_conv_with(line_index)
            .collect()
    }
 }
-impl ConvWith for AtomTextEdit {
+impl<'a> ConvWith for &'a AtomTextEdit {
    type Ctx = LineIndex;
    type Output = languageserver_types::TextEdit;
    fn conv_with(self, line_index: &LineIndex) -> languageserver_types::TextEdit {
        languageserver_types::TextEdit {
            range: self.delete.conv_with(line_index),
-            new_text: self.insert,
+            new_text: self.insert.clone(),
        }
    }
 }
@@ -199,7 +239,7 @@ impl TryConvWith for SourceChange {
                    .source_file_edits
                    .iter()
                    .find(|it| it.file_id == pos.file_id)
-                    .map(|it| it.edits.as_slice())