99 files changed, 3128 insertions, 1048 deletions
diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index 633015956..ee74d7486 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -13,7 +13,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
    - name: Checkout repository
-      uses: actions/checkout@v1
+      uses: actions/checkout@v2
    - run: cargo install cargo-audit
    - run: cargo audit
@@ -37,7 +37,7 @@ jobs:
    steps:
    - name: Checkout repository
-      uses: actions/checkout@v1
+      uses: actions/checkout@v2
    # We need to disable the existing toolchain to avoid updating rust-docs
    # which takes a long time. The fastest way to do this is to rename the
@@ -94,7 +94,7 @@ jobs:
      CC: gcc-4.9
    steps:
    - name: Checkout repository
-      uses: actions/checkout@v1
+      uses: actions/checkout@v2
    - name: Install Nodejs
      uses: actions/setup-node@v1
diff --git a/.github/workflows/release.yaml b/.github/workflows/release.yaml
index d58be0fd7..0434b6128 100644
--- a/.github/workflows/release.yaml
+++ b/.github/workflows/release.yaml
@@ -23,7 +23,7 @@ jobs:
    steps:
    - name: Checkout repository
-      uses: actions/checkout@v1
+      uses: actions/checkout@v2
    # We need to disable the existing toolchain to avoid updating rust-docs
    # which takes a long time. The fastest way to do this is to rename the
@@ -42,6 +42,7 @@ jobs:
        override: true
    - name: Install Nodejs
+      if: matrix.os == 'ubuntu-latest'
      uses: actions/setup-node@v1
      with:
        node-version: 12.x
@@ -70,14 +71,14 @@ jobs:
      with:
        node-version: 12.x
-    - run: echo "::set-env name=TAG::$(date --iso)"
+    - run: echo "::set-env name=TAG::$(date --iso --utc)"
      if: github.event_name == 'push'
    - run: echo "::set-env name=TAG::nightly"
      if: github.event_name == 'schedule'
    - run: 'echo "TAG: $TAG"'
    - name: Checkout repository
-      uses: actions/checkout@v1
+      uses: actions/checkout@v2
    - uses: actions/download-artifact@v1
      with:
@@ -107,4 +108,4 @@ jobs:
      if: github.event_name == 'push'
      working-directory: ./editors/code
      # token from https://dev.azure.com/rust-analyzer/
-      run: npx vsce publish 0.1.$(date +%Y%m%d) --pat ${{ secrets.MARKETPLACE_TOKEN }} --packagePath ../../dist/rust-analyzer.vsix
+      run: npx vsce publish --pat ${{ secrets.MARKETPLACE_TOKEN }} --packagePath ../../dist/rust-analyzer.vsix
diff --git a/.github/workflows/rustdoc.yaml b/.github/workflows/rustdoc.yaml
index e75e92695..c84ce5d48 100644
--- a/.github/workflows/rustdoc.yaml
+++ b/.github/workflows/rustdoc.yaml
@@ -13,7 +13,7 @@ jobs:
    steps:
    - name: Checkout repository
-      uses: actions/checkout@v1
+      uses: actions/checkout@v2
    - name: Install Rust toolchain
      uses: actions-rs/toolchain@v1
diff --git a/Cargo.lock b/Cargo.lock
index 80e778bcf..330bdd1cb 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2,9 +2,9 @@
 # It is not intended for manual editing.
 [[package]]
 name = "aho-corasick"
-version = "0.7.9"
+version = "0.7.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d5e63fd144e18ba274ae7095c0197a870a7b9468abc801dd62f190d80817d2ec"
+checksum = "8716408b8bc624ed7f65d223ddb9ac2d044c0547b6fa4b0d554f3a9540496ada"
 dependencies = [
 "memchr",
 ]
@@ -88,21 +88,6 @@ dependencies = [
 ]
 [[package]]
-name = "byteorder"
-version = "1.3.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08c48aae112d48ed9f069b33538ea9e3e90aa263cfa3d1c24309612b1f7472de"
-[[package]]
-name = "c2-chacha"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "214238caa1bf3a496ec3392968969cab8549f96ff30652c9e56885329315f6bb"
-dependencies = [
- "ppv-lite86",
-]
-[[package]]
 name = "cargo_metadata"
 version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -213,15 +198,14 @@ dependencies = [
 [[package]]
 name = "console"
-version = "0.9.2"
+version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "45e0f3986890b3acbc782009e2629dfe2baa430ac091519ce3be26164a2ae6c0"
+checksum = "6728a28023f207181b193262711102bfbaf47cc9d13bc71d0736607ef8efe88c"
 dependencies = [
 "clicolors-control",
 "encode_unicode",
 "lazy_static",
 "libc",
- "regex",
 "termios",
 "winapi 0.3.8",
 ]
@@ -402,12 +386,9 @@ dependencies = [
 [[package]]
 name = "fst"
-version = "0.3.5"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "927fb434ff9f0115b215dc0efd2e4fbdd7448522a92a1aa37c77d6a2f8f1ebd6"
+checksum = "3f7c13470d799474d44e2b9c6a0925807def7af4d120cd4de761433be76f7579"
-dependencies = [
- "byteorder",
-]
 [[package]]
 name = "fuchsia-zircon"
@@ -509,9 +490,9 @@ dependencies = [
 [[package]]
 name = "insta"
-version = "0.13.1"
+version = "0.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8df742abee84dbf27d20869c9adf77b0d8f7ea3eead13c2c9e3998d136a97058"
+checksum = "8de3f029212a3fe78a6090f1f2b993877ca245a9ded863f3fcbd6eae084fc1ed"
 dependencies = [
 "console",
 "difference",
@@ -655,9 +636,9 @@ dependencies = [
 [[package]]
 name = "lsp-types"
-version = "0.72.0"
+version = "0.73.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "face91691e558746745dc9dc6c67a4e2a24e044926e274d8378e6f19659329f0"
+checksum = "93d0cf64ea141b43d9e055f6b9df13f0bce32b103d84237509ce0a571ab9b159"
 dependencies = [
 "base64",
 "bitflags",
@@ -960,6 +941,7 @@ name = "ra_hir"
 version = "0.1.0"
 dependencies = [
 "either",
+ "itertools",
 "log",
 "ra_db",
 "ra_hir_def",
@@ -1180,11 +1162,11 @@ dependencies = [
 [[package]]
 name = "rand_chacha"
-version = "0.2.1"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "03a2a90da8c7523f554344f921aa97283eadf6ac484a6d2a7d0212fa7f8d6853"
+checksum = "f4c8ed856279c9737206bf725bf36935d8666ead7aa69b52be55af369d193402"
 dependencies = [
- "c2-chacha",
+ "ppv-lite86",
 "rand_core",
 ]
diff --git a/crates/ra_cargo_watch/Cargo.toml b/crates/ra_cargo_watch/Cargo.toml
index 731d50371..741345a21 100644
--- a/crates/ra_cargo_watch/Cargo.toml
+++ b/crates/ra_cargo_watch/Cargo.toml
@@ -6,10 +6,10 @@ authors = ["rust-analyzer developers"]
 [dependencies]
 crossbeam-channel = "0.4.0"
-lsp-types = { version = "0.72.0", features = ["proposed"] }
+lsp-types = { version = "0.73.0", features = ["proposed"] }
 log = "0.4.8"
 cargo_metadata = "0.9.1"
 serde_json = "1.0.48"
 [dev-dependencies]
-insta = "0.13.1"
+insta = "0.15.0"
diff --git a/crates/ra_db/src/fixture.rs b/crates/ra_db/src/fixture.rs
index da7af110c..3dc86ca2d 100644
--- a/crates/ra_db/src/fixture.rs
+++ b/crates/ra_db/src/fixture.rs
@@ -5,7 +5,7 @@ use std::sync::Arc;
 use ra_cfg::CfgOptions;
 use rustc_hash::FxHashMap;
-use test_utils::{extract_offset, parse_fixture, CURSOR_MARKER};
+use test_utils::{extract_offset, parse_fixture, parse_single_fixture, CURSOR_MARKER};
 use crate::{
    input::CrateName, CrateGraph, CrateId, Edition, Env, FileId, FilePosition, RelativePathBuf,
@@ -45,22 +45,45 @@ pub trait WithFixture: Default + SourceDatabaseExt + 'static {
 impl<DB: SourceDatabaseExt + Default + 'static> WithFixture for DB {}
-fn with_single_file(db: &mut dyn SourceDatabaseExt, text: &str) -> FileId {
+fn with_single_file(db: &mut dyn SourceDatabaseExt, ra_fixture: &str) -> FileId {
    let file_id = FileId(0);
    let rel_path: RelativePathBuf = "/main.rs".into();
    let mut source_root = SourceRoot::new_local();
    source_root.insert_file(rel_path.clone(), file_id);
-    let mut crate_graph = CrateGraph::default();
+    let fixture = parse_single_fixture(ra_fixture);
-    crate_graph.add_crate_root(
-        file_id,
+    let crate_graph = if let Some(entry) = fixture {
-        Edition::Edition2018,
+        let meta = match parse_meta(&entry.meta) {
-        CfgOptions::default(),
+            ParsedMeta::File(it) => it,
-        Env::default(),
+            _ => panic!("with_single_file only support file meta"),
-    );
+        };
-    db.set_file_text(file_id, Arc::new(text.to_string()));
+        let mut crate_graph = CrateGraph::default();
+        crate_graph.add_crate_root(
+            file_id,
+            meta.edition,
+            meta.krate,
+            meta.cfg,
+            meta.env,
+            Default::default(),
+        );
+        crate_graph
+    } else {
+        let mut crate_graph = CrateGraph::default();
+        crate_graph.add_crate_root(
+            file_id,
+            Edition::Edition2018,
+            None,
+            CfgOptions::default(),
+            Env::default(),
+            Default::default(),
+        );
+        crate_graph
+    };
+    db.set_file_text(file_id, Arc::new(ra_fixture.to_string()));
    db.set_file_relative_path(file_id, rel_path);
    db.set_file_source_root(file_id, WORKSPACE);
    db.set_source_root(WORKSPACE, Arc::new(source_root));
@@ -98,8 +121,14 @@ fn with_files(db: &mut dyn SourceDatabaseExt, fixture: &str) -> Option<FilePosit
        assert!(meta.path.starts_with(&source_root_prefix));
        if let Some(krate) = meta.krate {
-            let crate_id =
+            let crate_id = crate_graph.add_crate_root(
-                crate_graph.add_crate_root(file_id, meta.edition, meta.cfg, Env::default());
+                file_id,
+                meta.edition,
+                Some(krate.clone()),
+                meta.cfg,
+                meta.env,
+                Default::default(),
+            );
            let prev = crates.insert(krate.clone(), crate_id);
            assert!(prev.is_none());
            for dep in meta.deps {
@@ -132,8 +161,10 @@ fn with_files(db: &mut dyn SourceDatabaseExt, fixture: &str) -> Option<FilePosit
        crate_graph.add_crate_root(
            crate_root,
            Edition::Edition2018,
+            None,
            CfgOptions::default(),
            Env::default(),
+            Default::default(),
        );
    } else {
        for (from, to) in crate_deps {
@@ -160,9 +191,10 @@ struct FileMeta {
    deps: Vec<String>,
    cfg: CfgOptions,
    edition: Edition,
+    env: Env,
 }
-//- /lib.rs crate:foo deps:bar,baz
+//- /lib.rs crate:foo deps:bar,baz cfg:foo=a,bar=b env:OUTDIR=path/to,OTHER=foo)
 fn parse_meta(meta: &str) -> ParsedMeta {
    let components = meta.split_ascii_whitespace().collect::<Vec<_>>();
@@ -179,6 +211,7 @@ fn parse_meta(meta: &str) -> ParsedMeta {
    let mut deps = Vec::new();
    let mut edition = Edition::Edition2018;
    let mut cfg = CfgOptions::default();
+    let mut env = Env::default();
    for component in components[1..].iter() {
        let (key, value) = split1(component, ':').unwrap();
        match key {
@@ -193,11 +226,18 @@ fn parse_meta(meta: &str) -> ParsedMeta {
                    }
                }
            }
+            "env" => {
+                for key in value.split(',') {
+                    if let Some((k, v)) = split1(key, '=') {
+                        env.set(k.into(), v.into());
+                    }
+                }
+            }
            _ => panic!("bad component: {:?}", component),
        }
    }
-    ParsedMeta::File(FileMeta { path, krate, deps, edition, cfg })
+    ParsedMeta::File(FileMeta { path, krate, deps, edition, cfg, env })
 }
 fn split1(haystack: &str, delim: char) -> Option<(&str, &str)> {
diff --git a/crates/ra_db/src/input.rs b/crates/ra_db/src/input.rs
index eaff99fd3..06d40db96 100644
--- a/crates/ra_db/src/input.rs
+++ b/crates/ra_db/src/input.rs
@@ -6,7 +6,7 @@
 //! actual IO. See `vfs` and `project_model` in the `rust-analyzer` crate for how
 //! actual IO is done and lowered to input.
-use std::{fmt, str::FromStr};
+use std::{fmt, ops, str::FromStr};
 use ra_cfg::CfgOptions;
 use ra_syntax::SmolStr;
@@ -86,7 +86,7 @@ pub struct CrateId(pub u32);
 pub struct CrateName(SmolStr);
 impl CrateName {
-    /// Crates a crate name, checking for dashes in the string provided.
+    /// Creates a crate name, checking for dashes in the string provided.
    /// Dashes are not allowed in the crate names,
    /// hence the input string is returned as `Err` for those cases.
    pub fn new(name: &str) -> Result<CrateName, &str> {
@@ -97,19 +97,24 @@ impl CrateName {
        }
    }
-    /// Crates a crate name, unconditionally replacing the dashes with underscores.
+    /// Creates a crate name, unconditionally replacing the dashes with underscores.
    pub fn normalize_dashes(name: &str) -> CrateName {
        Self(SmolStr::new(name.replace('-', "_")))
    }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
-struct CrateData {
+pub struct CrateData {
-    file_id: FileId,
+    pub root_file_id: FileId,
-    edition: Edition,
+    pub edition: Edition,
-    cfg_options: CfgOptions,
+    /// The name to display to the end user.
-    env: Env,
+    /// This actual crate name can be different in a particular dependent crate
-    dependencies: Vec<Dependency>,
+    /// or may even be missing for some cases, such as a dummy crate for the code snippet.
+    pub display_name: Option<String>,
+    pub cfg_options: CfgOptions,
+    pub env: Env,
+    pub extern_source: ExternSource,
+    pub dependencies: Vec<Dependency>,
 }
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -118,11 +123,22 @@ pub enum Edition {
    Edition2015,
 }
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct ExternSourceId(pub u32);
 #[derive(Default, Debug, Clone, PartialEq, Eq)]
 pub struct Env {
    entries: FxHashMap<String, String>,
 }
+// FIXME: Redesign vfs for solve the following limitation ?
+// Note: Some env variables (e.g. OUT_DIR) are located outside of the
+// crate. We store a map to allow remap it to ExternSourceId
+#[derive(Default, Debug, Clone, PartialEq, Eq)]
+pub struct ExternSource {
+    extern_paths: FxHashMap<String, ExternSourceId>,
+}
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Dependency {
    pub crate_id: CrateId,
@@ -134,20 +150,26 @@ impl CrateGraph {
        &mut self,
        file_id: FileId,
        edition: Edition,
+        display_name: Option<String>,
        cfg_options: CfgOptions,
        env: Env,
+        extern_source: ExternSource,
    ) -> CrateId {
-        let data = CrateData::new(file_id, edition, cfg_options, env);
+        let data = CrateData {
+            root_file_id: file_id,
+            edition,
+            display_name,
+            cfg_options,
+            env,
+            extern_source,
+            dependencies: Vec::new(),
+        };
        let crate_id = CrateId(self.arena.len() as u32);
        let prev = self.arena.insert(crate_id, data);
        assert!(prev.is_none());
        crate_id
    }
-    pub fn cfg_options(&self, crate_id: CrateId) -> &CfgOptions {
-        &self.arena[&crate_id].cfg_options
-    }
    pub fn add_dep(
        &mut self,
        from: CrateId,
@@ -169,24 +191,13 @@ impl CrateGraph {
        self.arena.keys().copied()
    }
-    pub fn crate_root(&self, crate_id: CrateId) -> FileId {
-        self.arena[&crate_id].file_id
-    }
-    pub fn edition(&self, crate_id: CrateId) -> Edition {
-        self.arena[&crate_id].edition
-    }
    // FIXME: this only finds one crate with the given root; we could have multiple
    pub fn crate_id_for_crate_root(&self, file_id: FileId) -> Option<CrateId> {
-        let (&crate_id, _) = self.arena.iter().find(|(_crate_id, data)| data.file_id == file_id)?;
+        let (&crate_id, _) =
+            self.arena.iter().find(|(_crate_id, data)| data.root_file_id == file_id)?;
        Some(crate_id)
    }
-    pub fn dependencies(&self, crate_id: CrateId) -> impl Iterator<Item = &Dependency> {
-        self.arena[&crate_id].dependencies.iter()
-    }
    /// Extends this crate graph by adding a complete disjoint second crate
    /// graph.
    ///
@@ -209,8 +220,8 @@ impl CrateGraph {
            return false;
        }
-        for dep in self.dependencies(from) {
+        for dep in &self[from].dependencies {
-            let crate_id = dep.crate_id();
+            let crate_id = dep.crate_id;
            if crate_id == target {
                return true;
            }
@@ -223,6 +234,13 @@ impl CrateGraph {
    }
 }
+impl ops::Index<CrateId> for CrateGraph {
+    type Output = CrateData;
+    fn index(&self, crate_id: CrateId) -> &CrateData {
+        &self.arena[&crate_id]
+    }
+}
 impl CrateId {
    pub fn shift(self, amount: u32) -> CrateId {
        CrateId(self.0 + amount)
@@ -230,10 +248,6 @@ impl CrateId {
 }
 impl CrateData {
-    fn new(file_id: FileId, edition: Edition, cfg_options: CfgOptions, env: Env) -> CrateData {
-        CrateData { file_id, edition, dependencies: Vec::new(), cfg_options, env }
-    }
    fn add_dep(&mut self, name: SmolStr, crate_id: CrateId) {
        self.dependencies.push(Dependency { name, crate_id })
    }
@@ -261,9 +275,34 @@ impl fmt::Display for Edition {
    }
 }
-impl Dependency {
+impl Env {
-    pub fn crate_id(&self) -> CrateId {
+    pub fn set(&mut self, env: &str, value: String) {
-        self.crate_id
+        self.entries.insert(env.to_owned(), value);
+    }
+    pub fn get(&self, env: &str) -> Option<String> {
+        self.entries.get(env).cloned()
+    }
+}
+impl ExternSource {
+    pub fn extern_path(&self, path: &str) -> Option<(ExternSourceId, RelativePathBuf)> {
+        self.extern_paths.iter().find_map(|(root_path, id)| {
+            if path.starts_with(root_path) {
+                let mut rel_path = &path[root_path.len()..];
+                if rel_path.starts_with("/") {
+                    rel_path = &rel_path[1..];
+                }
+                let rel_path = RelativePathBuf::from_path(rel_path).ok()?;
+                Some((id.clone(), rel_path))
+            } else {
+                None
+            }
+        })
+    }
+    pub fn set_extern_path(&mut self, root_path: &str, root: ExternSourceId) {
+        self.extern_paths.insert(root_path.to_owned(), root);
    }
 }
@@ -290,12 +329,30 @@ mod tests {
    #[test]
    fn it_should_panic_because_of_cycle_dependencies() {
        let mut graph = CrateGraph::default();
-        let crate1 =
+        let crate1 = graph.add_crate_root(
-            graph.add_crate_root(FileId(1u32), Edition2018, CfgOptions::default(), Env::default());
+            FileId(1u32),
-        let crate2 =
+            Edition2018,
-            graph.add_crate_root(FileId(2u32), Edition2018, CfgOptions::default(), Env::default());
+            None,
-        let crate3 =
+            CfgOptions::default(),
-            graph.add_crate_root(FileId(3u32), Edition2018, CfgOptions::default(), Env::default());
+            Env::default(),
+            Default::default(),
+        );
+        let crate2 = graph.add_crate_root(
+            FileId(2u32),
+            Edition2018,
+            None,
+            CfgOptions::default(),
+            Env::default(),
+            Default::default(),
+        );
+        let crate3 = graph.add_crate_root(
+            FileId(3u32),
+            Edition2018,
+            None,
+            CfgOptions::default(),
+            Env::default(),
+            Default::default(),
+        );
        assert!(graph.add_dep(crate1, CrateName::new("crate2").unwrap(), crate2).is_ok());
        assert!(graph.add_dep(crate2, CrateName::new("crate3").unwrap(), crate3).is_ok());
        assert!(graph.add_dep(crate3, CrateName::new("crate1").unwrap(), crate1).is_err());
@@ -304,12 +361,30 @@ mod tests {
    #[test]
    fn it_works() {
        let mut graph = CrateGraph::default();
-        let crate1 =
+        let crate1 = graph.add_crate_root(
-            graph.add_crate_root(FileId(1u32), Edition2018, CfgOptions::default(), Env::default());
+            FileId(1u32),
-        let crate2 =
+            Edition2018,
-            graph.add_crate_root(FileId(2u32), Edition2018, CfgOptions::default(), Env::default());
+            None,
-        let crate3 =
+            CfgOptions::default(),
-            graph.add_crate_root(FileId(3u32), Edition2018, CfgOptions::default(), Env::default());
+            Env::default(),
+            Default::default(),
+        );
+        let crate2 = graph.add_crate_root(
+            FileId(2u32),
+            Edition2018,
+            None,
+            CfgOptions::default(),
+            Env::default(),
+            Default::default(),
+        );
+        let crate3 = graph.add_crate_root(
+            FileId(3u32),
+            Edition2018,
+            None,
+            CfgOptions::default(),
+            Env::default(),
+            Default::default(),
+        );
        assert!(graph.add_dep(crate1, CrateName::new("crate2").unwrap(), crate2).is_ok());
        assert!(graph.add_dep(crate2, CrateName::new("crate3").unwrap(), crate3).is_ok());
    }
@@ -317,16 +392,28 @@ mod tests {
    #[test]
    fn dashes_are_normalized() {
        let mut graph = CrateGraph::default();
-        let crate1 =
+        let crate1 = graph.add_crate_root(
-            graph.add_crate_root(FileId(1u32), Edition2018, CfgOptions::default(), Env::default());
+            FileId(1u32),
-        let crate2 =
+            Edition2018,
-            graph.add_crate_root(FileId(2u32), Edition2018, CfgOptions::default(), Env::default());
+            None,
+            CfgOptions::default(),
+            Env::default(),
+            Default::default(),
+        );
+        let crate2 = graph.add_crate_root(
+            FileId(2u32),
+            Edition2018,
+            None,
+            CfgOptions::default(),
+            Env::default(),
+            Default::default(),
+        );
        assert!(graph
            .add_dep(crate1, CrateName::normalize_dashes("crate-name-with-dashes"), crate2)
            .is_ok());
        assert_eq!(
-            graph.dependencies(crate1).collect::<Vec<_>>(),
+            graph[crate1].dependencies,
-            vec![&Dependency { crate_id: crate2, name: "crate_name_with_dashes".into() }]
+            vec![Dependency { crate_id: crate2, name: "crate_name_with_dashes".into() }]
        );
    }
 }
diff --git a/crates/ra_db/src/lib.rs b/crates/ra_db/src/lib.rs
index fb002d717..d500d5e85 100644
--- a/crates/ra_db/src/lib.rs
+++ b/crates/ra_db/src/lib.rs
@@ -11,7 +11,8 @@ use ra_syntax::{ast, Parse, SourceFile, TextRange, TextUnit};
 pub use crate::{
    cancellation::Canceled,
    input::{
-        CrateGraph, CrateId, CrateName, Dependency, Edition, Env, FileId, SourceRoot, SourceRootId,
+        CrateGraph, CrateId, CrateName, Dependency, Edition, Env, ExternSource, ExternSourceId,
+        FileId, SourceRoot, SourceRootId,
    },
 };
 pub use relative_path::{RelativePath, RelativePathBuf};
@@ -87,6 +88,12 @@ pub trait FileLoader {
    fn resolve_relative_path(&self, anchor: FileId, relative_path: &RelativePath)
        -> Option<FileId>;
    fn relevant_crates(&self, file_id: FileId) -> Arc<Vec<CrateId>>;
+    fn resolve_extern_path(
+        &self,
+        extern_id: ExternSourceId,
+        relative_path: &RelativePath,
+    ) -> Option<FileId>;
 }
 /// Database which stores all significant input facts: source code and project
@@ -164,4 +171,13 @@ impl<T: SourceDatabaseExt> FileLoader for FileLoaderDelegate<&'_ T> {
        let source_root = self.0.file_source_root(file_id);
        self.0.source_root_crates(source_root)
    }
+    fn resolve_extern_path(
+        &self,
+        extern_id: ExternSourceId,
+        relative_path: &RelativePath,
+    ) -> Option<FileId> {
+        let source_root = self.0.source_root(SourceRootId(extern_id.0));
+        source_root.file_by_relative_path(&relative_path)
+    }
 }
diff --git a/crates/ra_hir/Cargo.toml b/crates/ra_hir/Cargo.toml
index 0555a0de7..266c4cff3 100644
--- a/crates/ra_hir/Cargo.toml
+++ b/crates/ra_hir/Cargo.toml
@@ -12,6 +12,8 @@ log = "0.4.8"
 rustc-hash = "1.1.0"
 either = "1.5.3"
+itertools = "0.8.2"
 ra_syntax = { path = "../ra_syntax" }
 ra_db = { path = "../ra_db" }
 ra_prof = { path = "../ra_prof" }
diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs
index 2944926e6..41d4e2ed3 100644
--- a/crates/ra_hir/src/code_model.rs
+++ b/crates/ra_hir/src/code_model.rs
@@ -54,10 +54,11 @@ pub struct CrateDependency {
 impl Crate {
    pub fn dependencies(self, db: &impl DefDatabase) -> Vec<CrateDependency> {
-        db.crate_graph()
+        db.crate_graph()[self.id]
-            .dependencies(self.id)
+            .dependencies
+            .iter()
            .map(|dep| {
-                let krate = Crate { id: dep.crate_id() };
+                let krate = Crate { id: dep.crate_id };
                let name = dep.as_name();
                CrateDependency { krate, name }
            })
@@ -69,7 +70,9 @@ impl Crate {
        let crate_graph = db.crate_graph();
        crate_graph
            .iter()
-            .filter(|&krate| crate_graph.dependencies(krate).any(|it| it.crate_id == self.id))
+            .filter(|&krate| {
+                crate_graph[krate].dependencies.iter().any(|it| it.crate_id == self.id)
+            })
            .map(|id| Crate { id })
            .collect()
    }
@@ -80,12 +83,11 @@ impl Crate {
    }
    pub fn root_file(self, db: &impl DefDatabase) -> FileId {
-        db.crate_graph().crate_root(self.id)
+        db.crate_graph()[self.id].root_file_id
    }
    pub fn edition(self, db: &impl DefDatabase) -> Edition {
-        let crate_graph = db.crate_graph();
+        db.crate_graph()[self.id].edition
-        crate_graph.edition(self.id)
    }
    pub fn all(db: &impl DefDatabase) -> Vec<Crate> {
@@ -204,10 +206,26 @@ impl Module {
    }
    /// Returns a `ModuleScope`: a set of items, visible in this module.
-    pub fn scope(self, db: &impl HirDatabase) -> Vec<(Name, ScopeDef)> {
+    pub fn scope(
+        self,
+        db: &impl HirDatabase,
+        visible_from: Option<Module>,
+    ) -> Vec<(Name, ScopeDef)> {
        db.crate_def_map(self.id.krate)[self.id.local_id]
            .scope
            .entries()
+            .filter_map(|(name, def)| {
+                if let Some(m) = visible_from {
+                    let filtered = def.filter_visibility(|vis| vis.is_visible_from(db, m.id));
+                    if filtered.is_none() && !def.is_none() {
+                        None
+                    } else {
+                        Some((name, filtered))
+                    }
+                } else {
+                    Some((name, def))
+                }
+            })
            .map(|(name, def)| (name.clone(), def.into()))
            .collect()
    }
@@ -480,6 +498,14 @@ impl Adt {
    pub fn krate(self, db: &impl HirDatabase) -> Option<Crate> {
        Some(self.module(db).krate())
    }
+    pub fn name(&self, db: &impl HirDatabase) -> Name {
+        match self {
+            Adt::Struct(s) => s.name(db),
+            Adt::Union(u) => u.name(db),
+            Adt::Enum(e) => e.name(db),
+        }
+    }
 }
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
@@ -507,6 +533,14 @@ impl VariantDef {
        }
    }
+    pub fn name(&self, db: &impl HirDatabase) -> Name {
+        match self {
+            VariantDef::Struct(s) => s.name(db),
+            VariantDef::Union(u) => u.name(db),
+            VariantDef::EnumVariant(e) => e.name(db),
+        }
+    }
    pub(crate) fn variant_data(self, db: &impl DefDatabase) -> Arc<VariantData> {
        match self {
            VariantDef::Struct(it) => it.variant_data(db),
@@ -534,6 +568,14 @@ impl DefWithBody {
            DefWithBody::Static(s) => s.module(db),
        }
    }
+    pub fn name(self, db: &impl HirDatabase) -> Option<Name> {
+        match self {
+            DefWithBody::Function(f) => Some(f.name(db)),
+            DefWithBody::Static(s) => s.name(db),
+            DefWithBody::Const(c) => c.name(db),
+        }
+    }
 }
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -571,6 +613,14 @@ impl Function {
    }
 }
+impl HasVisibility for Function {
+    fn visibility(&self, db: &impl HirDatabase) -> Visibility {
+        let function_data = db.function_data(self.id);
+        let visibility = &function_data.visibility;
+        visibility.resolve(db, &self.id.resolver(db))
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct Const {
    pub(crate) id: ConstId,
@@ -590,6 +640,14 @@ impl Const {
    }
 }
+impl HasVisibility for Const {
+    fn visibility(&self, db: &impl HirDatabase) -> Visibility {
+        let function_data = db.const_data(self.id);
+        let visibility = &function_data.visibility;
+        visibility.resolve(db, &self.id.resolver(db))
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct Static {
    pub(crate) id: StaticId,
@@ -664,6 +722,14 @@ impl TypeAlias {
    }
 }
+impl HasVisibility for TypeAlias {
+    fn visibility(&self, db: &impl HirDatabase) -> Visibility {
+        let function_data = db.type_alias_data(self.id);
+        let visibility = &function_data.visibility;
+        visibility.resolve(db, &self.id.resolver(db))
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct MacroDef {
    pub(crate) id: MacroDefId,
@@ -751,6 +817,16 @@ impl AssocItem {
    }
 }
+impl HasVisibility for AssocItem {
+    fn visibility(&self, db: &impl HirDatabase) -> Visibility {
+        match self {
+            AssocItem::Function(f) => f.visibility(db),
+            AssocItem::Const(c) => c.visibility(db),
+            AssocItem::TypeAlias(t) => t.visibility(db),
+        }
+    }
+}
 #[derive(Clone, Copy, PartialEq, Eq, Debug, Hash)]
 pub enum GenericDef {
    Function(Function),
diff --git a/crates/ra_hir/src/db.rs b/crates/ra_hir/src/db.rs
index a77bf6de6..fcba95091 100644
--- a/crates/ra_hir/src/db.rs
+++ b/crates/ra_hir/src/db.rs
@@ -1,7 +1,7 @@
 //! FIXME: write short doc here
 pub use hir_def::db::{
-    AttrsQuery, BodyQuery, BodyWithSourceMapQuery, ComputeCrateDefMapQuery, ConstDataQuery,
+    AttrsQuery, BodyQuery, BodyWithSourceMapQuery, ConstDataQuery, CrateDefMapQueryQuery,
    CrateLangItemsQuery, DefDatabase, DefDatabaseStorage, DocumentationQuery, EnumDataQuery,
    ExprScopesQuery, FunctionDataQuery, GenericParamsQuery, ImplDataQuery, InternConstQuery,
    InternDatabase, InternDatabaseStorage, InternEnumQuery, InternFunctionQuery, InternImplQuery,
@@ -14,12 +14,11 @@ pub use hir_expand::db::{
    MacroExpandQuery, ParseMacroQuery,
 };
 pub use hir_ty::db::{
-    AssociatedTyDataQuery, AssociatedTyValueQuery, CallableItemSignatureQuery, DoInferQuery,
+    AssociatedTyDataQuery, AssociatedTyValueQuery, CallableItemSignatureQuery, FieldTypesQuery,
-    FieldTypesQuery, GenericDefaultsQuery, GenericPredicatesForParamQuery, GenericPredicatesQuery,
+    GenericDefaultsQuery, GenericPredicatesForParamQuery, GenericPredicatesQuery, HirDatabase,
-    HirDatabase, HirDatabaseStorage, ImplDatumQuery, ImplSelfTyQuery, ImplTraitQuery,
+    HirDatabaseStorage, ImplDatumQuery, ImplSelfTyQuery, ImplTraitQuery, ImplsForTraitQuery,
-    ImplsForTraitQuery, ImplsInCrateQuery, InternAssocTyValueQuery, InternChalkImplQuery,
+    ImplsInCrateQuery, InferQueryQuery, InternAssocTyValueQuery, InternChalkImplQuery,
-    InternTypeCtorQuery, StructDatumQuery, TraitDatumQuery, TraitSolveQuery, TraitSolverQuery,
+    InternTypeCtorQuery, StructDatumQuery, TraitDatumQuery, TraitSolveQuery, TyQuery, ValueTyQuery,
-    TyQuery, ValueTyQuery,
 };
 #[test]
diff --git a/crates/ra_hir/src/semantics.rs b/crates/ra_hir/src/semantics.rs
index 965d185a4..3782a9984 100644
--- a/crates/ra_hir/src/semantics.rs
+++ b/crates/ra_hir/src/semantics.rs
@@ -6,7 +6,7 @@ use std::{cell::RefCell, fmt, iter::successors};
 use hir_def::{
    resolver::{self, HasResolver, Resolver},
-    TraitId,
+    AsMacroCall, TraitId,
 };
 use hir_expand::ExpansionInfo;
 use ra_db::{FileId, FileRange};
@@ -70,6 +70,20 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {
        Some(node)
    }
+    pub fn expand_hypothetical(
+        &self,
+        actual_macro_call: &ast::MacroCall,
+        hypothetical_args: &ast::TokenTree,
+        token_to_map: SyntaxToken,
+    ) -> Option<(SyntaxNode, SyntaxToken)> {
+        let macro_call =
+            self.find_file(actual_macro_call.syntax().clone()).with_value(actual_macro_call);
+        let sa = self.analyze2(macro_call.map(|it| it.syntax()), None);
+        let macro_call_id = macro_call
+            .as_call_id(self.db, |path| sa.resolver.resolve_path_as_macro(self.db, &path))?;
+        hir_expand::db::expand_hypothetical(self.db, macro_call_id, hypothetical_args, token_to_map)
+    }
    pub fn descend_into_macros(&self, token: SyntaxToken) -> SyntaxToken {
        let parent = token.parent();
        let parent = self.find_file(parent);
@@ -104,6 +118,25 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {
        node.ancestors_with_macros(self.db).map(|it| it.value)
    }
+    pub fn ancestors_at_offset_with_macros(
+        &self,
+        node: &SyntaxNode,
+        offset: TextUnit,
+    ) -> impl Iterator<Item = SyntaxNode> + '_ {
+        use itertools::Itertools;
+        node.token_at_offset(offset)
+            .map(|token| self.ancestors_with_macros(token.parent()))
+            .kmerge_by(|node1, node2| node1.text_range().len() < node2.text_range().len())
+    }
+    pub fn find_node_at_offset_with_macros<N: AstNode>(
+        &self,
+        node: &SyntaxNode,
+        offset: TextUnit,
+    ) -> Option<N> {
+        self.ancestors_at_offset_with_macros(node, offset).find_map(N::cast)
+    }
    pub fn type_of_expr(&self, expr: &ast::Expr) -> Option<Type> {
        self.analyze(expr.syntax()).type_of(self.db, &expr)
    }
diff --git a/crates/ra_hir_def/Cargo.toml b/crates/ra_hir_def/Cargo.toml
index fa25cc4fb..30a12337e 100644
--- a/crates/ra_hir_def/Cargo.toml
+++ b/crates/ra_hir_def/Cargo.toml
@@ -26,4 +26,4 @@ ra_cfg = { path = "../ra_cfg" }
 tt = { path = "../ra_tt", package = "ra_tt" }
 [dev-dependencies]
-insta = "0.13.1"
+insta = "0.15.0"
diff --git a/crates/ra_hir_def/src/data.rs b/crates/ra_hir_def/src/data.rs
index 9fc43f3fb..a72eb5369 100644
--- a/crates/ra_hir_def/src/data.rs
+++ b/crates/ra_hir_def/src/data.rs
@@ -7,13 +7,16 @@ use hir_expand::{
    AstId, InFile,
 };
 use ra_prof::profile;
-use ra_syntax::ast::{self, AstNode, ImplItem, ModuleItemOwner, NameOwner, TypeAscriptionOwner};
+use ra_syntax::ast::{
+    self, AstNode, ImplItem, ModuleItemOwner, NameOwner, TypeAscriptionOwner, VisibilityOwner,
+};
 use crate::{
    db::DefDatabase,
    path::{path, GenericArgs, Path},
    src::HasSource,
    type_ref::{Mutability, TypeBound, TypeRef},
+    visibility::RawVisibility,
    AssocContainerId, AssocItemId, ConstId, ConstLoc, Expander, FunctionId, FunctionLoc, HasModule,
    ImplId, Intern, Lookup, ModuleId, StaticId, TraitId, TypeAliasId, TypeAliasLoc,
 };
@@ -26,6 +29,7 @@ pub struct FunctionData {
    /// True if the first param is `self`. This is relevant to decide whether this
    /// can be called as a method.
    pub has_self_param: bool,
+    pub visibility: RawVisibility,
 }
 impl FunctionData {
@@ -72,7 +76,9 @@ impl FunctionData {
            ret_type
        };
-        let sig = FunctionData { name, params, ret_type, has_self_param };
+        let visibility = RawVisibility::from_ast(db, src.map(|s| s.visibility()));
+        let sig = FunctionData { name, params, ret_type, has_self_param, visibility };
        Arc::new(sig)
    }
 }
@@ -91,6 +97,7 @@ fn desugar_future_path(orig: TypeRef) -> Path {
 pub struct TypeAliasData {
    pub name: Name,
    pub type_ref: Option<TypeRef>,
+    pub visibility: RawVisibility,
 }
 impl TypeAliasData {
@@ -98,10 +105,11 @@ impl TypeAliasData {
        db: &impl DefDatabase,
        typ: TypeAliasId,
    ) -> Arc<TypeAliasData> {
-        let node = typ.lookup(db).source(db).value;
+        let node = typ.lookup(db).source(db);
-        let name = node.name().map_or_else(Name::missing, |n| n.as_name());
+        let name = node.value.name().map_or_else(Name::missing, |n| n.as_name());
-        let type_ref = node.type_ref().map(TypeRef::from_ast);
+        let type_ref = node.value.type_ref().map(TypeRef::from_ast);
-        Arc::new(TypeAliasData { name, type_ref })
+        let visibility = RawVisibility::from_ast(db, node.map(|n| n.visibility()));
+        Arc::new(TypeAliasData { name, type_ref, visibility })
    }
 }
@@ -217,23 +225,28 @@ pub struct ConstData {
    /// const _: () = ();
    pub name: Option<Name>,
    pub type_ref: TypeRef,
+    pub visibility: RawVisibility,
 }
 impl ConstData {
    pub(crate) fn const_data_query(db: &impl DefDatabase, konst: ConstId) -> Arc<ConstData> {
-        let node = konst.lookup(db).source(db).value;
+        let node = konst.lookup(db).source(db);
-        Arc::new(ConstData::new(&node))
+        Arc::new(ConstData::new(db, node))
    }
    pub(crate) fn static_data_query(db: &impl DefDatabase, konst: StaticId) -> Arc<ConstData> {
-        let node = konst.lookup(db).source(db).value;
+        let node = konst.lookup(db).source(db);
-        Arc::new(ConstData::new(&node))
+        Arc::new(ConstData::new(db, node))
    }
-    fn new<N: NameOwner + TypeAscriptionOwner>(node: &N) -> ConstData {
+    fn new<N: NameOwner + TypeAscriptionOwner + VisibilityOwner>(
-        let name = node.name().map(|n| n.as_name());
+        db: &impl DefDatabase,
-        let type_ref = TypeRef::from_ast_opt(node.ascribed_type());
+        node: InFile<N>,
-        ConstData { name, type_ref }
+    ) -> ConstData {
+        let name = node.value.name().map(|n| n.as_name());
+        let type_ref = TypeRef::from_ast_opt(node.value.ascribed_type());
+        let visibility = RawVisibility::from_ast(db, node.map(|n| n.visibility()));
+        ConstData { name, type_ref, visibility }
    }
 }
diff --git a/crates/ra_hir_def/src/db.rs b/crates/ra_hir_def/src/db.rs
index 2338b2cbe..dcd377aae 100644
--- a/crates/ra_hir_def/src/db.rs
+++ b/crates/ra_hir_def/src/db.rs
@@ -47,11 +47,11 @@ pub trait DefDatabase: InternDatabase + AstDatabase {
    #[salsa::invoke(RawItems::raw_items_query)]
    fn raw_items(&self, file_id: HirFileId) -> Arc<RawItems>;
-    #[salsa::transparent]
+    #[salsa::invoke(crate_def_map_wait)]
    fn crate_def_map(&self, krate: CrateId) -> Arc<CrateDefMap>;
-    #[salsa::invoke(CrateDefMap::compute_crate_def_map_query)]
+    #[salsa::invoke(CrateDefMap::crate_def_map_query)]
-    fn compute_crate_def_map(&self, krate: CrateId) -> Arc<CrateDefMap>;
+    fn crate_def_map_query(&self, krate: CrateId) -> Arc<CrateDefMap>;
    #[salsa::invoke(StructData::struct_data_query)]
    fn struct_data(&self, id: StructId) -> Arc<StructData>;
@@ -109,7 +109,7 @@ pub trait DefDatabase: InternDatabase + AstDatabase {
    fn documentation(&self, def: AttrDefId) -> Option<Documentation>;
 }
-fn crate_def_map(db: &impl DefDatabase, krate: CrateId) -> Arc<CrateDefMap> {
+fn crate_def_map_wait(db: &impl DefDatabase, krate: CrateId) -> Arc<CrateDefMap> {
-    let _p = profile("wait_crate_def_map");
+    let _p = profile("crate_def_map:wait");
-    db.compute_crate_def_map(krate)
+    db.crate_def_map_query(krate)
 }
diff --git a/crates/ra_hir_def/src/find_path.rs b/crates/ra_hir_def/src/find_path.rs
index 43b9b124a..07ca74ec3 100644
--- a/crates/ra_hir_def/src/find_path.rs
+++ b/crates/ra_hir_def/src/find_path.rs
@@ -176,7 +176,7 @@ fn find_importable_locations(
    // directly (only through reexports in direct dependencies).
    for krate in Some(from.krate)
        .into_iter()
-        .chain(crate_graph.dependencies(from.krate).map(|dep| dep.crate_id))
+        .chain(crate_graph[from.krate].dependencies.iter().map(|dep| dep.crate_id))
    {
        result.extend(
            importable_locations_in_crate(db, item, krate)
diff --git a/crates/ra_hir_def/src/lang_item.rs b/crates/ra_hir_def/src/lang_item.rs
index 5a336ea1f..6de49730e 100644
--- a/crates/ra_hir_def/src/lang_item.rs
+++ b/crates/ra_hir_def/src/lang_item.rs
@@ -116,8 +116,9 @@ impl LangItems {
        if let Some(target) = start_crate_target {
            return Some(*target);
        }
-        db.crate_graph()
+        db.crate_graph()[start_crate]
-            .dependencies(start_crate)
+            .dependencies
+            .iter()
            .find_map(|dep| db.lang_item(dep.crate_id, item.clone()))
    }
diff --git a/crates/ra_hir_def/src/nameres.rs b/crates/ra_hir_def/src/nameres.rs
index 166d1c421..81eac52ad 100644
--- a/crates/ra_hir_def/src/nameres.rs
+++ b/crates/ra_hir_def/src/nameres.rs
@@ -176,16 +176,11 @@ pub struct ModuleData {
 }
 impl CrateDefMap {
-    pub(crate) fn compute_crate_def_map_query(
+    pub(crate) fn crate_def_map_query(db: &impl DefDatabase, krate: CrateId) -> Arc<CrateDefMap> {
-        // Note that this doesn't have `+ AstDatabase`!
+        let _p = profile("crate_def_map_query")
-        // This gurantess that `CrateDefMap` is stable across reparses.
+            .detail(|| db.crate_graph()[krate].display_name.clone().unwrap_or_default());
-        db: &impl DefDatabase,
-        krate: CrateId,
-    ) -> Arc<CrateDefMap> {
-        let _p = profile("crate_def_map");
        let def_map = {
-            let crate_graph = db.crate_graph();
+            let edition = db.crate_graph()[krate].edition;
-            let edition = crate_graph.edition(krate);
            let mut modules: Arena<LocalModuleId, ModuleData> = Arena::default();
            let root = modules.alloc(ModuleData::default());
            CrateDefMap {
diff --git a/crates/ra_hir_def/src/nameres/collector.rs b/crates/ra_hir_def/src/nameres/collector.rs
index 51c65a5d7..d0459d9b0 100644
--- a/crates/ra_hir_def/src/nameres/collector.rs
+++ b/crates/ra_hir_def/src/nameres/collector.rs
@@ -34,7 +34,7 @@ pub(super) fn collect_defs(db: &impl DefDatabase, mut def_map: CrateDefMap) -> C
    let crate_graph = db.crate_graph();
    // populate external prelude
-    for dep in crate_graph.dependencies(def_map.krate) {
+    for dep in &crate_graph[def_map.krate].dependencies {
        let dep_def_map = db.crate_def_map(dep.crate_id);
        log::debug!("crate dep {:?} -> {:?}", dep.name, dep.crate_id);
        def_map.extern_prelude.insert(
@@ -51,7 +51,7 @@ pub(super) fn collect_defs(db: &impl DefDatabase, mut def_map: CrateDefMap) -> C
        }
    }
-    let cfg_options = crate_graph.cfg_options(def_map.krate);
+    let cfg_options = &crate_graph[def_map.krate].cfg_options;
    let mut collector = DefCollector {
        db,
@@ -128,8 +128,7 @@ where
    DB: DefDatabase,
 {
    fn collect(&mut self) {
-        let crate_graph = self.db.crate_graph();
+        let file_id = self.db.crate_graph()[self.def_map.krate].root_file_id;
-        let file_id = crate_graph.crate_root(self.def_map.krate);
        let raw_items = self.db.raw_items(file_id.into());
        let module_id = self.def_map.root;
        self.def_map.modules[module_id].origin = ModuleOrigin::CrateRoot { definition: file_id };
@@ -955,7 +954,7 @@ mod tests {
        let krate = db.test_crate();
        let def_map = {
-            let edition = db.crate_graph().edition(krate);
+            let edition = db.crate_graph()[krate].edition;
            let mut modules: Arena<LocalModuleId, ModuleData> = Arena::default();
            let root = modules.alloc(ModuleData::default());
            CrateDefMap {
diff --git a/crates/ra_hir_def/src/test_db.rs b/crates/ra_hir_def/src/test_db.rs
index 1568820e9..0756916a8 100644
--- a/crates/ra_hir_def/src/test_db.rs
+++ b/crates/ra_hir_def/src/test_db.rs
@@ -6,7 +6,7 @@ use std::{
 };
 use crate::db::DefDatabase;
-use ra_db::{salsa, CrateId, FileId, FileLoader, FileLoaderDelegate, RelativePath};
+use ra_db::{salsa, CrateId, ExternSourceId, FileId, FileLoader, FileLoaderDelegate, RelativePath};
 #[salsa::database(
    ra_db::SourceDatabaseExtStorage,
@@ -52,6 +52,14 @@ impl FileLoader for TestDB {
    fn relevant_crates(&self, file_id: FileId) -> Arc<Vec<CrateId>> {
        FileLoaderDelegate(self).relevant_crates(file_id)
    }
+    fn resolve_extern_path(
+        &self,
+        extern_id: ExternSourceId,
+        relative_path: &RelativePath,
+    ) -> Option<FileId> {
+        FileLoaderDelegate(self).resolve_extern_path(extern_id, relative_path)
+    }
 }
 impl TestDB {
diff --git a/crates/ra_hir_expand/src/builtin_macro.rs b/crates/ra_hir_expand/src/builtin_macro.rs
index 9fc33e4b1..a90007f26 100644
--- a/crates/ra_hir_expand/src/builtin_macro.rs
+++ b/crates/ra_hir_expand/src/builtin_macro.rs
@@ -7,6 +7,7 @@ use crate::{
 use crate::{quote, EagerMacroId, LazyMacroId, MacroCallId};
 use either::Either;
+use mbe::parse_to_token_tree;
 use ra_db::{FileId, RelativePath};
 use ra_parser::FragmentKind;
@@ -89,15 +90,15 @@ register_builtin! {
    (line, Line) => line_expand,
    (stringify, Stringify) => stringify_expand,
    (format_args, FormatArgs) => format_args_expand,
-    (env, Env) => env_expand,
-    (option_env, OptionEnv) => option_env_expand,
    // format_args_nl only differs in that it adds a newline in the end,
    // so we use the same stub expansion for now
    (format_args_nl, FormatArgsNl) => format_args_expand,
    EAGER:
    (concat, Concat) => concat_expand,
-    (include, Include) => include_expand
+    (include, Include) => include_expand,
+    (env, Env) => env_expand,
+    (option_env, OptionEnv) => option_env_expand
 }
 fn line_expand(
@@ -136,28 +137,6 @@ fn stringify_expand(
    Ok(expanded)
 }
-fn env_expand(
-    _db: &dyn AstDatabase,
-    _id: LazyMacroId,
-    _tt: &tt::Subtree,
-) -> Result<tt::Subtree, mbe::ExpandError> {
-    // dummy implementation for type-checking purposes
-    let expanded = quote! { "" };
-    Ok(expanded)
-}
-fn option_env_expand(
-    _db: &dyn AstDatabase,
-    _id: LazyMacroId,
-    _tt: &tt::Subtree,
-) -> Result<tt::Subtree, mbe::ExpandError> {
-    // dummy implementation for type-checking purposes
-    let expanded = quote! { std::option::Option::None::<&str> };
-    Ok(expanded)
-}
 fn column_expand(
    _db: &dyn AstDatabase,
    _id: LazyMacroId,
@@ -274,44 +253,101 @@ fn concat_expand(
 fn relative_file(db: &dyn AstDatabase, call_id: MacroCallId, path: &str) -> Option<FileId> {
    let call_site = call_id.as_file().original_file(db);
-    let path = RelativePath::new(&path);
-    db.resolve_relative_path(call_site, &path)
+    // Handle trivial case
+    if let Some(res) = db.resolve_relative_path(call_site, &RelativePath::new(&path)) {
+        // Prevent include itself
+        return if res == call_site { None } else { Some(res) };
+    }
+    // Extern paths ?
+    let krate = db.relevant_crates(call_site).get(0)?.clone();
+    let (extern_source_id, relative_file) =
+        db.crate_graph()[krate].extern_source.extern_path(path)?;
+    db.resolve_extern_path(extern_source_id, &relative_file)
 }
-fn include_expand(
+fn parse_string(tt: &tt::Subtree) -> Result<String, mbe::ExpandError> {
-    db: &dyn AstDatabase,
+    tt.token_trees
-    arg_id: EagerMacroId,
-    tt: &tt::Subtree,
-) -> Result<(tt::Subtree, FragmentKind), mbe::ExpandError> {
-    let path = tt
-        .token_trees
        .get(0)
        .and_then(|tt| match tt {
            tt::TokenTree::Leaf(tt::Leaf::Literal(it)) => unquote_str(&it),
            _ => None,
        })
-        .ok_or_else(|| mbe::ExpandError::ConversionError)?;
+        .ok_or_else(|| mbe::ExpandError::ConversionError)
+}
+fn include_expand(
+    db: &dyn AstDatabase,
+    arg_id: EagerMacroId,
+    tt: &tt::Subtree,
+) -> Result<(tt::Subtree, FragmentKind), mbe::ExpandError> {
+    let path = parse_string(tt)?;
    let file_id =
        relative_file(db, arg_id.into(), &path).ok_or_else(|| mbe::ExpandError::ConversionError)?;
    // FIXME:
    // Handle include as expression
-    let node =
+    let res = parse_to_token_tree(&db.file_text(file_id.into()))
-        db.parse_or_expand(file_id.into()).ok_or_else(|| mbe::ExpandError::ConversionError)?;
+        .ok_or_else(|| mbe::ExpandError::ConversionError)?
-    let res =
+        .0;
-        mbe::syntax_node_to_token_tree(&node).ok_or_else(|| mbe::ExpandError::ConversionError)?.0;
    Ok((res, FragmentKind::Items))
 }
+fn get_env_inner(db: &dyn AstDatabase, arg_id: EagerMacroId, key: &str) -> Option<String> {
+    let call_id: MacroCallId = arg_id.into();
+    let original_file = call_id.as_file().original_file(db);
+    let krate = db.relevant_crates(original_file).get(0)?.clone();
+    db.crate_graph()[krate].env.get(key)
+}
+fn env_expand(
+    db: &dyn AstDatabase,
+    arg_id: EagerMacroId,
+    tt: &tt::Subtree,
+) -> Result<(tt::Subtree, FragmentKind), mbe::ExpandError> {
+    let key = parse_string(tt)?;
+    // FIXME:
+    // If the environment variable is not defined int rustc, then a compilation error will be emitted.
+    // We might do the same if we fully support all other stuffs.
+    // But for now on, we should return some dummy string for better type infer purpose.
+    // However, we cannot use an empty string here, because for
+    // `include!(concat!(env!("OUT_DIR"), "/foo.rs"))` will become
+    // `include!("foo.rs"), which might go to infinite loop
+    let s = get_env_inner(db, arg_id, &key).unwrap_or("__RA_UNIMPLEMENTATED__".to_string());
+    let expanded = quote! { #s };
+    Ok((expanded, FragmentKind::Expr))
+}
+fn option_env_expand(
+    db: &dyn AstDatabase,
+    arg_id: EagerMacroId,
+    tt: &tt::Subtree,
+) -> Result<(tt::Subtree, FragmentKind), mbe::ExpandError> {
+    let key = parse_string(tt)?;
+    let expanded = match get_env_inner(db, arg_id, &key) {
+        None => quote! { std::option::Option::None::<&str> },
+        Some(s) => quote! { std::option::Some(#s) },
+    };
+    Ok((expanded, FragmentKind::Expr))
+}
 #[cfg(test)]
 mod tests {
    use super::*;
-    use crate::{name::AsName, test_db::TestDB, AstNode, MacroCallId, MacroCallKind, MacroCallLoc};
+    use crate::{
+        name::AsName, test_db::TestDB, AstNode, EagerCallLoc, MacroCallId, MacroCallKind,
+        MacroCallLoc,
+    };
    use ra_db::{fixture::WithFixture, SourceDatabase};
    use ra_syntax::ast::NameOwner;
+    use std::sync::Arc;
    fn expand_builtin_macro(ra_fixture: &str) -> String {
        let (db, file_id) = TestDB::with_single_file(&ra_fixture);
@@ -322,27 +358,61 @@ mod tests {
        let ast_id_map = db.ast_id_map(file_id.into());
        let expander = find_by_name(&macro_calls[0].name().unwrap().as_name()).unwrap();
-        let expander = expander.left().unwrap();
-        // the first one should be a macro_rules
+        let file_id = match expander {
-        let def = MacroDefId {
+            Either::Left(expander) => {
-            krate: Some(CrateId(0)),
+                // the first one should be a macro_rules
-            ast_id: Some(AstId::new(file_id.into(), ast_id_map.ast_id(&macro_calls[0]))),
+                let def = MacroDefId {
-            kind: MacroDefKind::BuiltIn(expander),
+                    krate: Some(CrateId(0)),
-        };
+                    ast_id: Some(AstId::new(file_id.into(), ast_id_map.ast_id(&macro_calls[0]))),
+                    kind: MacroDefKind::BuiltIn(expander),
+                };
-        let loc = MacroCallLoc {
+                let loc = MacroCallLoc {
-            def,
+                    def,
-            kind: MacroCallKind::FnLike(AstId::new(
+                    kind: MacroCallKind::FnLike(AstId::new(
-                file_id.into(),
+                        file_id.into(),
-                ast_id_map.ast_id(&macro_calls[1]),
+                        ast_id_map.ast_id(&macro_calls[1]),
-            )),
+                    )),
-        };
+                };
-        let id: MacroCallId = db.intern_macro(loc).into();
+                let id: MacroCallId = db.intern_macro(loc).into();
-        let parsed = db.parse_or_expand(id.as_file()).unwrap();
+                id.as_file()
+            }
+            Either::Right(expander) => {
+                // the first one should be a macro_rules
+                let def = MacroDefId {
+                    krate: Some(CrateId(0)),
+                    ast_id: Some(AstId::new(file_id.into(), ast_id_map.ast_id(&macro_calls[0]))),
+                    kind: MacroDefKind::BuiltInEager(expander),
+                };
+                let args = macro_calls[1].token_tree().unwrap();
+                let parsed_args = mbe::ast_to_token_tree(&args).unwrap().0;
+                let arg_id = db.intern_eager_expansion({
+                    EagerCallLoc {
+                        def,
+                        fragment: FragmentKind::Expr,
+                        subtree: Arc::new(parsed_args.clone()),
+                        file_id: file_id.into(),
+                    }
+                });
+                let (subtree, fragment) = expander.expand(&db, arg_id, &parsed_args).unwrap();
+                let eager = EagerCallLoc {
+                    def,
+                    fragment,
+                    subtree: Arc::new(subtree),
+                    file_id: file_id.into(),
+                };
-        parsed.text().to_string()
+                let id: MacroCallId = db.intern_eager_expansion(eager.into()).into();
+                id.as_file()
+            }
+        };
+        db.parse_or_expand(file_id).unwrap().to_string()
    }
    #[test]
@@ -394,7 +464,7 @@ mod tests {
            "#,
        );
-        assert_eq!(expanded, "\"\"");
+        assert_eq!(expanded, "\"__RA_UNIMPLEMENTATED__\"");
    }
    #[test]
diff --git a/crates/ra_hir_expand/src/db.rs b/crates/ra_hir_expand/src/db.rs
index f3a84cacc..29dde3d80 100644
--- a/crates/ra_hir_expand/src/db.rs
+++ b/crates/ra_hir_expand/src/db.rs
@@ -72,6 +72,30 @@ pub trait AstDatabase: SourceDatabase {
    fn intern_eager_expansion(&self, eager: EagerCallLoc) -> EagerMacroId;
 }
+/// This expands the given macro call, but with different arguments. This is
+/// used for completion, where we want to see what 'would happen' if we insert a
+/// token. The `token_to_map` mapped down into the expansion, with the mapped
+/// token returned.
+pub fn expand_hypothetical(
+    db: &impl AstDatabase,
+    actual_macro_call: MacroCallId,
+    hypothetical_args: &ra_syntax::ast::TokenTree,
+    token_to_map: ra_syntax::SyntaxToken,
+) -> Option<(SyntaxNode, ra_syntax::SyntaxToken)> {
+    let macro_file = MacroFile { macro_call_id: actual_macro_call };
+    let (tt, tmap_1) = mbe::syntax_node_to_token_tree(hypothetical_args.syntax()).unwrap();
+    let range =
+        token_to_map.text_range().checked_sub(hypothetical_args.syntax().text_range().start())?;
+    let token_id = tmap_1.token_by_range(range)?;
+    let macro_def = expander(db, actual_macro_call)?;
+    let (node, tmap_2) =
+        parse_macro_with_arg(db, macro_file, Some(std::sync::Arc::new((tt, tmap_1))))?;
+    let token_id = macro_def.0.map_id_down(token_id);
+    let range = tmap_2.range_by_token(token_id)?.by_kind(token_to_map.kind())?;
+    let token = ra_syntax::algo::find_covering_element(&node.syntax_node(), range).into_token()?;
+    Some((node.syntax_node(), token))
+}
 pub(crate) fn ast_id_map(db: &dyn AstDatabase, file_id: HirFileId) -> Arc<AstIdMap> {
    let map =
        db.parse_or_expand(file_id).map_or_else(AstIdMap::default, |it| AstIdMap::from_source(&it));
@@ -130,15 +154,42 @@ pub(crate) fn macro_expand(
    db: &dyn AstDatabase,
    id: MacroCallId,
 ) -> Result<Arc<tt::Subtree>, String> {
+    macro_expand_with_arg(db, id, None)
+}
+fn expander(db: &dyn AstDatabase, id: MacroCallId) -> Option<Arc<(TokenExpander, mbe::TokenMap)>> {
+    let lazy_id = match id {
+        MacroCallId::LazyMacro(id) => id,
+        MacroCallId::EagerMacro(_id) => {
+            return None;
+        }
+    };
+    let loc = db.lookup_intern_macro(lazy_id);
+    let macro_rules = db.macro_def(loc.def)?;
+    Some(macro_rules)
+}
+fn macro_expand_with_arg(
+    db: &dyn AstDatabase,
+    id: MacroCallId,
+    arg: Option<Arc<(tt::Subtree, mbe::TokenMap)>>,
+) -> Result<Arc<tt::Subtree>, String> {
    let lazy_id = match id {
        MacroCallId::LazyMacro(id) => id,
        MacroCallId::EagerMacro(id) => {
-            return Ok(db.lookup_intern_eager_expansion(id).subtree);
+            if arg.is_some() {
+                return Err(
+                    "hypothetical macro expansion not implemented for eager macro".to_owned()
+                );
+            } else {
+                return Ok(db.lookup_intern_eager_expansion(id).subtree);
+            }
        }
    };
    let loc = db.lookup_intern_macro(lazy_id);
-    let macro_arg = db.macro_arg(id).ok_or("Fail to args in to tt::TokenTree")?;
+    let macro_arg = arg.or_else(|| db.macro_arg(id)).ok_or("Fail to args in to tt::TokenTree")?;
    let macro_rules = db.macro_def(loc.def).ok_or("Fail to find macro definition")?;
    let tt = macro_rules.0.expand(db, lazy_id, &macro_arg.0).map_err(|err| format!("{:?}", err))?;
@@ -163,11 +214,23 @@ pub(crate) fn parse_macro(
    db: &dyn AstDatabase,
    macro_file: MacroFile,
 ) -> Option<(Parse<SyntaxNode>, Arc<mbe::TokenMap>)> {
+    parse_macro_with_arg(db, macro_file, None)
+}
+pub fn parse_macro_with_arg(
+    db: &dyn AstDatabase,
+    macro_file: MacroFile,
+    arg: Option<Arc<(tt::Subtree, mbe::TokenMap)>>,
+) -> Option<(Parse<SyntaxNode>, Arc<mbe::TokenMap>)> {
    let _p = profile("parse_macro_query");
    let macro_call_id = macro_file.macro_call_id;
-    let tt = db
+    let expansion = if let Some(arg) = arg {
-        .macro_expand(macro_call_id)
+        macro_expand_with_arg(db, macro_call_id, Some(arg))
+    } else {
+        db.macro_expand(macro_call_id)
+    };
+    let tt = expansion
        .map_err(|err| {
            // Note:
            // The final goal we would like to make all parse_macro success,
diff --git a/crates/ra_hir_expand/src/test_db.rs b/crates/ra_hir_expand/src/test_db.rs
index 918736e2a..c1fb762de 100644
--- a/crates/ra_hir_expand/src/test_db.rs
+++ b/crates/ra_hir_expand/src/test_db.rs
@@ -5,7 +5,7 @@ use std::{
    sync::{Arc, Mutex},
 };
-use ra_db::{salsa, CrateId, FileId, FileLoader, FileLoaderDelegate, RelativePath};
+use ra_db::{salsa, CrateId, ExternSourceId, FileId, FileLoader, FileLoaderDelegate, RelativePath};
 #[salsa::database(
    ra_db::SourceDatabaseExtStorage,
@@ -51,4 +51,11 @@ impl FileLoader for TestDB {
    fn relevant_crates(&self, file_id: FileId) -> Arc<Vec<CrateId>> {
        FileLoaderDelegate(self).relevant_crates(file_id)
    }
+    fn resolve_extern_path(
+        &self,
+        anchor: ExternSourceId,
+        relative_path: &RelativePath,
+    ) -> Option<FileId> {
+        FileLoaderDelegate(self).resolve_extern_path(anchor, relative_path)
+    }
 }
diff --git a/crates/ra_hir_ty/Cargo.toml b/crates/ra_hir_ty/Cargo.toml
index f2558b579..9962112db 100644
--- a/crates/ra_hir_ty/Cargo.toml
+++ b/crates/ra_hir_ty/Cargo.toml
@@ -26,4 +26,4 @@ chalk-rust-ir = { git = "https://github.com/rust-lang/chalk.git", rev = "177d713
 chalk-ir =      { git = "https://github.com/rust-lang/chalk.git", rev = "177d71340acc7a7204a33115fc63075d86452179" }
 [dev-dependencies]
-insta = "0.13.1"
+insta = "0.15.0"
diff --git a/crates/ra_hir_ty/src/db.rs b/crates/ra_hir_ty/src/db.rs
index c43619d1c..74b309005 100644
--- a/crates/ra_hir_ty/src/db.rs
+++ b/crates/ra_hir_ty/src/db.rs
@@ -16,15 +16,16 @@ use crate::{
    Binders, CallableDef, GenericPredicate, InferenceResult, PolyFnSig, Substs, TraitRef, Ty,
    TyDefId, TypeCtor, ValueTyDefId,
 };
+use hir_expand::name::Name;
 #[salsa::query_group(HirDatabaseStorage)]
 #[salsa::requires(salsa::Database)]
 pub trait HirDatabase: DefDatabase {
-    #[salsa::transparent]
+    #[salsa::invoke(infer_wait)]
    fn infer(&self, def: DefWithBodyId) -> Arc<InferenceResult>;
-    #[salsa::invoke(crate::do_infer_query)]
+    #[salsa::invoke(crate::infer::infer_query)]
-    fn do_infer(&self, def: DefWithBodyId) -> Arc<InferenceResult>;
+    fn infer_query(&self, def: DefWithBodyId) -> Arc<InferenceResult>;
    #[salsa::invoke(crate::lower::ty_query)]
    #[salsa::cycle(crate::lower::ty_recover)]
@@ -65,14 +66,6 @@ pub trait HirDatabase: DefDatabase {
    #[salsa::invoke(crate::traits::impls_for_trait_query)]
    fn impls_for_trait(&self, krate: CrateId, trait_: TraitId) -> Arc<[ImplId]>;
-    /// This provides the Chalk trait solver instance. Because Chalk always
-    /// works from a specific crate, this query is keyed on the crate; and
-    /// because Chalk does its own internal caching, the solver is wrapped in a
-    /// Mutex and the query does an untracked read internally, to make sure the
-    /// cached state is thrown away when input facts change.
-    #[salsa::invoke(crate::traits::trait_solver_query)]
-    fn trait_solver(&self, krate: CrateId) -> crate::traits::TraitSolver;
    // Interned IDs for Chalk integration
    #[salsa::interned]
    fn intern_type_ctor(&self, type_ctor: TypeCtor) -> crate::TypeCtorId;
@@ -110,9 +103,17 @@ pub trait HirDatabase: DefDatabase {
    ) -> Option<crate::traits::Solution>;
 }
-fn infer(db: &impl HirDatabase, def: DefWithBodyId) -> Arc<InferenceResult> {
+fn infer_wait(db: &impl HirDatabase, def: DefWithBodyId) -> Arc<InferenceResult> {
-    let _p = profile("wait_infer");
+    let _p = profile("infer:wait").detail(|| match def {
-    db.do_infer(def)
+        DefWithBodyId::FunctionId(it) => db.function_data(it).name.to_string(),
+        DefWithBodyId::StaticId(it) => {
+            db.static_data(it).name.clone().unwrap_or_else(Name::missing).to_string()
+        }
+        DefWithBodyId::ConstId(it) => {
+            db.const_data(it).name.clone().unwrap_or_else(Name::missing).to_string()
+        }
+    });
+    db.infer_query(def)
 }
 #[test]
diff --git a/crates/ra_hir_ty/src/infer.rs b/crates/ra_hir_ty/src/infer.rs
index 437086ff6..947833412 100644
--- a/crates/ra_hir_ty/src/infer.rs
+++ b/crates/ra_hir_ty/src/infer.rs
@@ -63,8 +63,8 @@ mod pat;
 mod coerce;
 /// The entry point of type inference.
-pub fn do_infer_query(db: &impl HirDatabase, def: DefWithBodyId) -> Arc<InferenceResult> {
+pub(crate) fn infer_query(db: &impl HirDatabase, def: DefWithBodyId) -> Arc<InferenceResult> {
-    let _p = profile("infer");
+    let _p = profile("infer_query");
    let resolver = def.resolver(db);
    let mut ctx = InferenceContext::new(db, def, resolver);
diff --git a/crates/ra_hir_ty/src/infer/path.rs b/crates/ra_hir_ty/src/infer/path.rs
index 471d60342..c733b9e1d 100644
--- a/crates/ra_hir_ty/src/infer/path.rs
+++ b/crates/ra_hir_ty/src/infer/path.rs
@@ -40,7 +40,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
            let ty = self.make_ty(type_ref);
            let remaining_segments_for_ty = path.segments().take(path.segments().len() - 1);
            let ctx = crate::lower::TyLoweringContext::new(self.db, &resolver);
-            let ty = Ty::from_type_relative_path(&ctx, ty, remaining_segments_for_ty);
+            let (ty, _) = Ty::from_type_relative_path(&ctx, ty, None, remaining_segments_for_ty);
            self.resolve_ty_assoc_item(
                ty,
                &path.segments().last().expect("path had at least one segment").name,
@@ -115,7 +115,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                let remaining_segments_for_ty =
                    remaining_segments.take(remaining_segments.len() - 1);
                let ctx = crate::lower::TyLoweringContext::new(self.db, &self.resolver);
-                let ty = Ty::from_partly_resolved_hir_path(
+                let (ty, _) = Ty::from_partly_resolved_hir_path(
                    &ctx,
                    def,
                    resolved_segment,
diff --git a/crates/ra_hir_ty/src/lib.rs b/crates/ra_hir_ty/src/lib.rs
index ca194f806..4127f1a8d 100644
--- a/crates/ra_hir_ty/src/lib.rs
+++ b/crates/ra_hir_ty/src/lib.rs
@@ -26,7 +26,7 @@ pub mod traits;
 pub mod method_resolution;
 mod op;
 mod lower;
-mod infer;
+pub(crate) mod infer;
 pub mod display;
 pub(crate) mod utils;
 pub mod db;
@@ -57,7 +57,7 @@ use crate::{
 use display::HirDisplay;
 pub use autoderef::autoderef;
-pub use infer::{do_infer_query, InferTy, InferenceResult};
+pub use infer::{InferTy, InferenceResult};
 pub use lower::CallableDef;
 pub use lower::{
    callable_item_sig, ImplTraitLoweringMode, TyDefId, TyLoweringContext, ValueTyDefId,
diff --git a/crates/ra_hir_ty/src/lower.rs b/crates/ra_hir_ty/src/lower.rs
index 092977e93..b96dc126c 100644
--- a/crates/ra_hir_ty/src/lower.rs
+++ b/crates/ra_hir_ty/src/lower.rs
@@ -91,7 +91,14 @@ pub enum TypeParamLoweringMode {
 impl Ty {
    pub fn from_hir(ctx: &TyLoweringContext<'_, impl HirDatabase>, type_ref: &TypeRef) -> Self {
-        match type_ref {
+        Ty::from_hir_ext(ctx, type_ref).0
+    }
+    pub fn from_hir_ext(
+        ctx: &TyLoweringContext<'_, impl HirDatabase>,
+        type_ref: &TypeRef,
+    ) -> (Self, Option<TypeNs>) {
+        let mut res = None;
+        let ty = match type_ref {
            TypeRef::Never => Ty::simple(TypeCtor::Never),
            TypeRef::Tuple(inner) => {
                let inner_tys: Arc<[Ty]> = inner.iter().map(|tr| Ty::from_hir(ctx, tr)).collect();
@@ -100,7 +107,11 @@ impl Ty {
                    Substs(inner_tys),
                )
            }
-            TypeRef::Path(path) => Ty::from_hir_path(ctx, path),
+            TypeRef::Path(path) => {
+                let (ty, res_) = Ty::from_hir_path(ctx, path);
+                res = res_;
+                ty
+            }
            TypeRef::RawPtr(inner, mutability) => {
                let inner_ty = Ty::from_hir(ctx, inner);
                Ty::apply_one(TypeCtor::RawPtr(*mutability), inner_ty)
@@ -183,7 +194,8 @@ impl Ty {
                }
            }
            TypeRef::Error => Ty::Unknown,
-        }
+        };
+        (ty, res)
    }
    /// This is only for `generic_predicates_for_param`, where we can't just
@@ -217,17 +229,19 @@ impl Ty {
    pub(crate) fn from_type_relative_path(
        ctx: &TyLoweringContext<'_, impl HirDatabase>,
        ty: Ty,
+        // We need the original resolution to lower `Self::AssocTy` correctly
+        res: Option<TypeNs>,
        remaining_segments: PathSegments<'_>,
-    ) -> Ty {
+    ) -> (Ty, Option<TypeNs>) {
        if remaining_segments.len() == 1 {
            // resolve unselected assoc types
            let segment = remaining_segments.first().unwrap();
-            Ty::select_associated_type(ctx, ty, segment)
+            (Ty::select_associated_type(ctx, ty, res, segment), None)
        } else if remaining_segments.len() > 1 {
            // FIXME report error (ambiguous associated type)
-            Ty::Unknown
+            (Ty::Unknown, None)
        } else {
-            ty
+            (ty, res)
        }
    }
@@ -236,14 +250,14 @@ impl Ty {
        resolution: TypeNs,
        resolved_segment: PathSegment<'_>,
        remaining_segments: PathSegments<'_>,
-    ) -> Ty {
+    ) -> (Ty, Option<TypeNs>) {
        let ty = match resolution {
            TypeNs::TraitId(trait_) => {
                // if this is a bare dyn Trait, we'll directly put the required ^0 for the self type in there
                let self_ty = if remaining_segments.len() == 0 { Some(Ty::Bound(0)) } else { None };
                let trait_ref =
                    TraitRef::from_resolved_path(ctx, trait_, resolved_segment, self_ty);
-                return if remaining_segments.len() == 1 {
+                let ty = if remaining_segments.len() == 1 {
                    let segment = remaining_segments.first().unwrap();
                    let associated_ty = associated_type_by_name_including_super_traits(
                        ctx.db,
@@ -269,6 +283,7 @@ impl Ty {
                } else {
                    Ty::Dyn(Arc::new([GenericPredicate::Implemented(trait_ref)]))
                };
+                return (ty, None);
            }
            TypeNs::GenericParam(param_id) => {
                let generics =
@@ -306,22 +321,25 @@ impl Ty {
            TypeNs::BuiltinType(it) => Ty::from_hir_path_inner(ctx, resolved_segment, it.into()),
            TypeNs::TypeAliasId(it) => Ty::from_hir_path_inner(ctx, resolved_segment, it.into()),
            // FIXME: report error
-            TypeNs::EnumVariantId(_) => return Ty::Unknown,
+            TypeNs::EnumVariantId(_) => return (Ty::Unknown, None),
        };
-        Ty::from_type_relative_path(ctx, ty, remaining_segments)
+        Ty::from_type_relative_path(ctx, ty, Some(resolution), remaining_segments)
    }
-    pub(crate) fn from_hir_path(ctx: &TyLoweringContext<'_, impl HirDatabase>, path: &Path) -> Ty {
+    pub(crate) fn from_hir_path(
+        ctx: &TyLoweringContext<'_, impl HirDatabase>,
+        path: &Path,
+    ) -> (Ty, Option<TypeNs>) {
        // Resolve the path (in type namespace)
        if let Some(type_ref) = path.type_anchor() {
-            let ty = Ty::from_hir(ctx, &type_ref);
+            let (ty, res) = Ty::from_hir_ext(ctx, &type_ref);
-            return Ty::from_type_relative_path(ctx, ty, path.segments());
+            return Ty::from_type_relative_path(ctx, ty, res, path.segments());
        }
        let (resolution, remaining_index) =
            match ctx.resolver.resolve_path_in_type_ns(ctx.db, path.mod_path()) {
                Some(it) => it,
-                None => return Ty::Unknown,
+                None => return (Ty::Unknown, None),
            };
        let (resolved_segment, remaining_segments) = match remaining_index {
            None => (
@@ -336,31 +354,27 @@ impl Ty {
    fn select_associated_type(
        ctx: &TyLoweringContext<'_, impl HirDatabase>,
        self_ty: Ty,
+        res: Option<TypeNs>,
        segment: PathSegment<'_>,
    ) -> Ty {
-        let def = match ctx.resolver.generic_def() {
+        let traits_from_env: Vec<_> = match res {
-            Some(def) => def,
+            Some(TypeNs::SelfType(impl_id)) => match ctx.db.impl_trait(impl_id) {
-            None => return Ty::Unknown, // this can't actually happen
+                None => return Ty::Unknown,
-        };
+                Some(trait_ref) => vec![trait_ref.value.trait_],
-        let param_id = match self_ty {
+            },
-            Ty::Placeholder(id) if ctx.type_param_mode == TypeParamLoweringMode::Placeholder => id,
+            Some(TypeNs::GenericParam(param_id)) => {
-            Ty::Bound(idx) if ctx.type_param_mode == TypeParamLoweringMode::Variable => {
+                let predicates = ctx.db.generic_predicates_for_param(param_id);
-                let generics = generics(ctx.db, def);
+                predicates
-                let param_id = if let Some((id, _)) = generics.iter().nth(idx as usize) {
+                    .iter()
-                    id
+                    .filter_map(|pred| match &pred.value {
-                } else {
+                        GenericPredicate::Implemented(tr) => Some(tr.trait_),
-                    return Ty::Unknown;
+                        _ => None,
-                };
+                    })
-                param_id
+                    .collect()
            }
-            _ => return Ty::Unknown, // Error: Ambiguous associated type
+            _ => return Ty::Unknown,
        };
-        let predicates = ctx.db.generic_predicates_for_param(param_id);
+        let traits = traits_from_env.into_iter().flat_map(|t| all_super_traits(ctx.db, t));
-        let traits_from_env = predicates.iter().filter_map(|pred| match &pred.value {
-            GenericPredicate::Implemented(tr) => Some(tr.trait_),
-            _ => None,
-        });
-        let traits = traits_from_env.flat_map(|t| all_super_traits(ctx.db, t));
        for t in traits {
            if let Some(associated_ty) = ctx.db.trait_data(t).associated_type_by_name(&segment.name)
            {
diff --git a/crates/ra_hir_ty/src/method_resolution.rs b/crates/ra_hir_ty/src/method_resolution.rs
index b7e8855fb..7f5e1469e 100644
--- a/crates/ra_hir_ty/src/method_resolution.rs
+++ b/crates/ra_hir_ty/src/method_resolution.rs
@@ -516,9 +516,31 @@ pub(crate) fn inherent_impl_substs(
    let self_ty_with_vars =
        Canonical { num_vars: vars.len() + self_ty.num_vars, value: self_ty_with_vars };
    let substs = super::infer::unify(&self_ty_with_vars, self_ty);
-    // we only want the substs for the vars we added, not the ones from self_ty
+    // We only want the substs for the vars we added, not the ones from self_ty.
-    let result = substs.map(|s| s.suffix(vars.len()));
+    // Also, if any of the vars we added are still in there, we replace them by
-    result
+    // Unknown. I think this can only really happen if self_ty contained
+    // Unknown, and in that case we want the result to contain Unknown in those
+    // places again.
+    substs.map(|s| fallback_bound_vars(s.suffix(vars.len()), self_ty.num_vars))
+}
+/// This replaces any 'free' Bound vars in `s` (i.e. those with indices past
+/// num_vars_to_keep) by `Ty::Unknown`.
+fn fallback_bound_vars(s: Substs, num_vars_to_keep: usize) -> Substs {
+    s.fold_binders(
+        &mut |ty, binders| {
+            if let Ty::Bound(idx) = &ty {
+                if *idx >= binders as u32 {
+                    Ty::Unknown
+                } else {
+                    ty
+                }
+            } else {
+                ty
+            }
+        },
+        num_vars_to_keep,
+    )
 }
 fn transform_receiver_ty(
diff --git a/crates/ra_hir_ty/src/test_db.rs b/crates/ra_hir_ty/src/test_db.rs
index c794f7b84..0be2fea4b 100644
--- a/crates/ra_hir_ty/src/test_db.rs
+++ b/crates/ra_hir_ty/src/test_db.rs
@@ -67,6 +67,13 @@ impl FileLoader for TestDB {
    fn relevant_crates(&self, file_id: FileId) -> Arc<Vec<CrateId>> {
        FileLoaderDelegate(self).relevant_crates(file_id)
    }
+    fn resolve_extern_path(
+        &self,
+        extern_id: ra_db::ExternSourceId,
+        relative_path: &RelativePath,
+    ) -> Option<FileId> {
+        FileLoaderDelegate(self).resolve_extern_path(extern_id, relative_path)
+    }
 }
 impl TestDB {
diff --git a/crates/ra_hir_ty/src/tests/macros.rs b/crates/ra_hir_ty/src/tests/macros.rs
index 42814941f..32457bbf7 100644
--- a/crates/ra_hir_ty/src/tests/macros.rs
+++ b/crates/ra_hir_ty/src/tests/macros.rs
@@ -484,6 +484,51 @@ fn bar() -> u32 {0}
 }
 #[test]
+fn infer_builtin_macros_include_concat_with_bad_env_should_failed() {
+    let (db, pos) = TestDB::with_position(
+        r#"
+//- /main.rs 
+#[rustc_builtin_macro]
+macro_rules! include {() => {}}
+#[rustc_builtin_macro]
+macro_rules! concat {() => {}}
+#[rustc_builtin_macro]
+macro_rules! env {() => {}}
+include!(concat!(env!("OUT_DIR"), "/foo.rs"));
+fn main() {
+    bar()<|>;
+}
+//- /foo.rs
+fn bar() -> u32 {0}
+"#,
+    );
+    assert_eq!("{unknown}", type_at_pos(&db, pos));
+}
+#[test]
+fn infer_builtin_macros_include_itself_should_failed() {
+    let (db, pos) = TestDB::with_position(
+        r#"
+//- /main.rs 
+#[rustc_builtin_macro]
+macro_rules! include {() => {}}
+include!("main.rs");
+fn main() {
+    0<|>
+}
+"#,
+    );
+    assert_eq!("i32", type_at_pos(&db, pos));
+}
+#[test]
 fn infer_builtin_macros_concat_with_lazy() {
    assert_snapshot!(
        infer(r#"
@@ -505,6 +550,26 @@ fn main() {
 }
 #[test]
+fn infer_builtin_macros_env() {
+    assert_snapshot!(
+        infer(r#"
+//- /main.rs env:foo=bar
+#[rustc_builtin_macro]
+macro_rules! env {() => {}}
+fn main() {
+    let x = env!("foo");
+}
+"#),
+        @r###"
+    ![0; 5) '"bar"': &str
+    [88; 116) '{     ...o"); }': ()
+    [98; 99) 'x': &str
+    "###
+    );
+}
+#[test]
 fn infer_derive_clone_simple() {
    let (db, pos) = TestDB::with_position(
        r#"
diff --git a/crates/ra_hir_ty/src/tests/traits.rs b/crates/ra_hir_ty/src/tests/traits.rs
index 547010b35..f009a708c 100644
--- a/crates/ra_hir_ty/src/tests/traits.rs
+++ b/crates/ra_hir_ty/src/tests/traits.rs
@@ -1803,6 +1803,47 @@ fn test<T, U>() where T::Item: Trait2, T: Trait<U::Item>, U: Trait<()> {
 }
 #[test]
+fn unselected_projection_on_trait_self() {
+    assert_snapshot!(infer(
+        r#"
+//- /main.rs
+trait Trait {
+    type Item;
+    fn f(&self, x: Self::Item);
+}
+struct S;
+impl Trait for S {
+    type Item = u32;
+    fn f(&self, x: Self::Item) { let y = x; }
+}
+struct S2;
+impl Trait for S2 {
+    type Item = i32;
+    fn f(&self, x: <Self>::Item) { let y = x; }
+}
+"#,
+    ), @r###"
+    [54; 58) 'self': &Self
+    [60; 61) 'x': {unknown}
+    [140; 144) 'self': &S
+    [146; 147) 'x': u32
+    [161; 175) '{ let y = x; }': ()
+    [167; 168) 'y': u32
+    [171; 172) 'x': u32
+    [242; 246) 'self': &S2
+    [248; 249) 'x': i32
+    [265; 279) '{ let y = x; }': ()
+    [271; 272) 'y': i32
+    [275; 276) 'x': i32
+    "###);
+}
+#[test]
 fn trait_impl_self_ty() {
    let t = type_at(
        r#"
diff --git a/crates/ra_hir_ty/src/traits.rs b/crates/ra_hir_ty/src/traits.rs
index bc6ee2600..6e1c8e42a 100644
--- a/crates/ra_hir_ty/src/traits.rs
+++ b/crates/ra_hir_ty/src/traits.rs
@@ -1,12 +1,9 @@
 //! Trait solving using Chalk.
-use std::{
+use std::{panic, sync::Arc};
-    panic,
-    sync::{Arc, Mutex},
-};
 use chalk_ir::cast::Cast;
 use hir_def::{expr::ExprId, DefWithBodyId, ImplId, TraitId, TypeAliasId};
-use ra_db::{impl_intern_key, salsa, Canceled, CrateId};
+use ra_db::{impl_intern_key, salsa, CrateId};
 use ra_prof::profile;
 use rustc_hash::FxHashSet;
@@ -19,74 +16,6 @@ use self::chalk::{from_chalk, Interner, ToChalk};
 pub(crate) mod chalk;
 mod builtin;
-#[derive(Debug, Clone)]
-pub struct TraitSolver {
-    krate: CrateId,
-    inner: Arc<Mutex<chalk_solve::Solver<Interner>>>,
-}
-/// We need eq for salsa
-impl PartialEq for TraitSolver {
-    fn eq(&self, other: &TraitSolver) -> bool {
-        Arc::ptr_eq(&self.inner, &other.inner)
-    }
-}
-impl Eq for TraitSolver {}
-impl TraitSolver {
-    fn solve(
-        &self,
-        db: &impl HirDatabase,
-        goal: &chalk_ir::UCanonical<chalk_ir::InEnvironment<chalk_ir::Goal<Interner>>>,
-    ) -> Option<chalk_solve::Solution<Interner>> {
-        let context = ChalkContext { db, krate: self.krate };
-        log::debug!("solve goal: {:?}", goal);
-        let mut solver = match self.inner.lock() {
-            Ok(it) => it,
-            // Our cancellation works via unwinding, but, as chalk is not
-            // panic-safe, we need to make sure to propagate the cancellation.
-            // Ideally, we should also make chalk panic-safe.
-            Err(_) => ra_db::Canceled::throw(),
-        };
-        let fuel = std::cell::Cell::new(CHALK_SOLVER_FUEL);
-        let solution = panic::catch_unwind({
-            let solver = panic::AssertUnwindSafe(&mut solver);
-            let context = panic::AssertUnwindSafe(&context);
-            move || {
-                solver.0.solve_limited(context.0, goal, || {
-                    context.0.db.check_canceled();
-                    let remaining = fuel.get();
-                    fuel.set(remaining - 1);
-                    if remaining == 0 {
-                        log::debug!("fuel exhausted");
-                    }
-                    remaining > 0
-                })
-            }
-        });
-        let solution = match solution {
-            Ok(it) => it,
-            Err(err) => {
-                if err.downcast_ref::<Canceled>().is_some() {
-                    panic::resume_unwind(err)
-                } else {
-                    log::error!("chalk panicked :-(");
-                    // Reset the solver, as it is not panic-safe.
-                    *solver = create_chalk_solver();
-                    None
-                }
-            }
-        };
-        log::debug!("solve({:?}) => {:?}", goal, solution);
-        solution
-    }
-}
 /// This controls the maximum size of types Chalk considers. If we set this too
 /// high, we can run into slow edge cases; if we set it too low, Chalk won't
 /// find some solutions.
@@ -100,16 +29,6 @@ struct ChalkContext<'a, DB> {
    krate: CrateId,
 }
-pub(crate) fn trait_solver_query(
-    db: &(impl HirDatabase + salsa::Database),
-    krate: CrateId,
-) -> TraitSolver {
-    db.salsa_runtime().report_untracked_read();
-    // krate parameter is just so we cache a unique solver per crate
-    log::debug!("Creating new solver for crate {:?}", krate);
-    TraitSolver { krate, inner: Arc::new(Mutex::new(create_chalk_solver())) }
-}
 fn create_chalk_solver() -> chalk_solve::Solver<Interner> {
    let solver_choice =
        chalk_solve::SolverChoice::SLG { max_size: CHALK_SOLVER_MAX_SIZE, expected_answers: None };
@@ -128,7 +47,7 @@ pub(crate) fn impls_for_trait_query(
    // will only ever get called for a few crates near the root of the tree (the
    // ones the user is editing), so this may actually be a waste of memory. I'm
    // doing it like this mainly for simplicity for now.
-    for dep in db.crate_graph().dependencies(krate) {
+    for dep in &db.crate_graph()[krate].dependencies {
        impls.extend(db.impls_for_trait(dep.crate_id, trait_).iter());
    }
    let crate_impl_defs = db.impls_in_crate(krate);
@@ -221,7 +140,10 @@ pub(crate) fn trait_solve_query(
    krate: CrateId,
    goal: Canonical<InEnvironment<Obligation>>,
 ) -> Option<Solution> {
-    let _p = profile("trait_solve_query");
+    let _p = profile("trait_solve_query").detail(|| match &goal.value.value {
+        Obligation::Trait(it) => db.trait_data(it.trait_).name.to_string(),
+        Obligation::Projection(_) => "projection".to_string(),
+    });
    log::debug!("trait_solve_query({})", goal.value.value.display(db));
    if let Obligation::Projection(pred) = &goal.value.value {
@@ -236,10 +158,35 @@ pub(crate) fn trait_solve_query(
    // We currently don't deal with universes (I think / hope they're not yet
    // relevant for our use cases?)
    let u_canonical = chalk_ir::UCanonical { canonical, universes: 1 };
-    let solution = db.trait_solver(krate).solve(db, &u_canonical);
+    let solution = solve(db, krate, &u_canonical);
    solution.map(|solution| solution_from_chalk(db, solution))
 }
+fn solve(
+    db: &impl HirDatabase,
+    krate: CrateId,
+    goal: &chalk_ir::UCanonical<chalk_ir::InEnvironment<chalk_ir::Goal<Interner>>>,
+) -> Option<chalk_solve::Solution<Interner>> {
+    let context = ChalkContext { db, krate };
+    log::debug!("solve goal: {:?}", goal);
+    let mut solver = create_chalk_solver();
+    let fuel = std::cell::Cell::new(CHALK_SOLVER_FUEL);
+    let solution = solver.solve_limited(&context, goal, || {
+        context.db.check_canceled();
+        let remaining = fuel.get();
+        fuel.set(remaining - 1);
+        if remaining == 0 {
+            log::debug!("fuel exhausted");
+        }
+        remaining > 0
+    });
+    log::debug!("solve({:?}) => {:?}", goal, solution);
+    solution
+}
 fn solution_from_chalk(
    db: &impl HirDatabase,
    solution: chalk_solve::Solution<Interner>,
diff --git a/crates/ra_ide/Cargo.toml b/crates/ra_ide/Cargo.toml
index 410d8de62..7235c944c 100644
--- a/crates/ra_ide/Cargo.toml
+++ b/crates/ra_ide/Cargo.toml
@@ -35,4 +35,4 @@ ra_assists = { path = "../ra_assists" }
 hir = { path = "../ra_hir", package = "ra_hir" }
 [dev-dependencies]
-insta = "0.13.1"
+insta = "0.15.0"
diff --git a/crates/ra_ide/src/completion.rs b/crates/ra_ide/src/completion.rs
index c378c2c62..93e53c921 100644
--- a/crates/ra_ide/src/completion.rs
+++ b/crates/ra_ide/src/completion.rs
@@ -16,11 +16,11 @@ mod complete_scope;
 mod complete_postfix;
 mod complete_macro_in_item_position;
 mod complete_trait_impl;
+#[cfg(test)]
+mod test_utils;
 use ra_ide_db::RootDatabase;
-#[cfg(test)]
-use crate::completion::completion_item::do_completion;
 use crate::{
    completion::{
        completion_context::CompletionContext,
@@ -33,6 +33,23 @@ pub use crate::completion::completion_item::{
    CompletionItem, CompletionItemKind, InsertTextFormat,
 };
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct CompletionOptions {
+    pub enable_postfix_completions: bool,
+    pub add_call_parenthesis: bool,
+    pub add_call_argument_snippets: bool,
+}
+impl Default for CompletionOptions {
+    fn default() -> Self {
+        CompletionOptions {
+            enable_postfix_completions: true,
+            add_call_parenthesis: true,
+            add_call_argument_snippets: true,
+        }
+    }
+}
 /// Main entry point for completion. We run completion as a two-phase process.
 ///
 /// First, we look at the position and collect a so-called `CompletionContext.
@@ -55,8 +72,12 @@ pub use crate::completion::completion_item::{
 /// `foo` *should* be present among the completion variants. Filtering by
 /// identifier prefix/fuzzy match should be done higher in the stack, together
 /// with ordering of completions (currently this is done by the client).
-pub(crate) fn completions(db: &RootDatabase, position: FilePosition) -> Option<Completions> {
+pub(crate) fn completions(
-    let ctx = CompletionContext::new(db, position)?;
+    db: &RootDatabase,
+    position: FilePosition,
+    opts: &CompletionOptions,
+) -> Option<Completions> {
+    let ctx = CompletionContext::new(db, position, opts)?;
    let mut acc = Completions::default();
diff --git a/crates/ra_ide/src/completion/complete_dot.rs b/crates/ra_ide/src/completion/complete_dot.rs
index 9145aa183..81e5037aa 100644
--- a/crates/ra_ide/src/completion/complete_dot.rs
+++ b/crates/ra_ide/src/completion/complete_dot.rs
@@ -38,7 +38,7 @@ pub(super) fn complete_dot(acc: &mut Completions, ctx: &CompletionContext) {
 fn complete_fields(acc: &mut Completions, ctx: &CompletionContext, receiver: &Type) {
    for receiver in receiver.autoderef(ctx.db) {
        for (field, ty) in receiver.fields(ctx.db) {
-            if ctx.module.map_or(false, |m| !field.is_visible_from(ctx.db, m)) {
+            if ctx.scope().module().map_or(false, |m| !field.is_visible_from(ctx.db, m)) {
                // Skip private field. FIXME: If the definition location of the
                // field is editable, we should show the completion
                continue;
@@ -53,11 +53,14 @@ fn complete_fields(acc: &mut Completions, ctx: &CompletionContext, receiver: &Ty
 }
 fn complete_methods(acc: &mut Completions, ctx: &CompletionContext, receiver: &Type) {
-    if let Some(krate) = ctx.module.map(|it| it.krate()) {
+    if let Some(krate) = ctx.krate {
        let mut seen_methods = FxHashSet::default();
        let traits_in_scope = ctx.scope().traits_in_scope();
        receiver.iterate_method_candidates(ctx.db, krate, &traits_in_scope, None, |_ty, func| {
-            if func.has_self_param(ctx.db) && seen_methods.insert(func.name(ctx.db)) {
+            if func.has_self_param(ctx.db)
+                && ctx.scope().module().map_or(true, |m| func.is_visible_from(ctx.db, m))
+                && seen_methods.insert(func.name(ctx.db))
+            {
                acc.add_function(ctx, func);
            }
            None::<()>
@@ -67,7 +70,7 @@ fn complete_methods(acc: &mut Completions, ctx: &CompletionContext, receiver: &T
 #[cfg(test)]
 mod tests {
-    use crate::completion::{do_completion, CompletionItem, CompletionKind};
+    use crate::completion::{test_utils::do_completion, CompletionItem, CompletionKind};
    use insta::assert_debug_snapshot;
    fn do_ref_completion(code: &str) -> Vec<CompletionItem> {
@@ -308,6 +311,39 @@ mod tests {
    }
    #[test]
+    fn test_method_completion_private() {
+        assert_debug_snapshot!(
+            do_ref_completion(
+                r"
+            struct A {}
+            mod m {
+                impl super::A {
+                    fn private_method(&self) {}
+                    pub(super) fn the_method(&self) {}
+                }
+            }
+            fn foo(a: A) {
+               a.<|>
+            }
+            ",
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "the_method()",
+                source_range: [256; 256),
+                delete: [256; 256),
+                insert: "the_method()$0",
+                kind: Method,
+                lookup: "the_method",
+                detail: "pub(super) fn the_method(&self)",
+            },
+        ]
+        "###
+        );
+    }
+    #[test]
    fn test_trait_method_completion() {
        assert_debug_snapshot!(
            do_ref_completion(
@@ -584,4 +620,133 @@ mod tests {
        "###
        );
    }
+    #[test]
+    fn works_in_simple_macro_1() {
+        assert_debug_snapshot!(
+            do_ref_completion(
+                r"
+                macro_rules! m { ($e:expr) => { $e } }
+                struct A { the_field: u32 }
+                fn foo(a: A) {
+                    m!(a.x<|>)
+                }
+                ",
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "the_field",
+                source_range: [156; 157),
+                delete: [156; 157),
+                insert: "the_field",
+                kind: Field,
+                detail: "u32",
+            },
+        ]
+        "###
+        );
+    }
+    #[test]
+    fn works_in_simple_macro_recursive() {
+        assert_debug_snapshot!(
+            do_ref_completion(
+                r"
+                macro_rules! m { ($e:expr) => { $e } }
+                struct A { the_field: u32 }
+                fn foo(a: A) {
+                    m!(a.x<|>)
+                }
+                ",
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "the_field",
+                source_range: [156; 157),
+                delete: [156; 157),
+                insert: "the_field",
+                kind: Field,
+                detail: "u32",
+            },
+        ]
+        "###
+        );
+    }
+    #[test]
+    fn works_in_simple_macro_2() {
+        // this doesn't work yet because the macro doesn't expand without the token -- maybe it can be fixed with better recovery
+        assert_debug_snapshot!(
+            do_ref_completion(
+                r"
+                macro_rules! m { ($e:expr) => { $e } }
+                struct A { the_field: u32 }
+                fn foo(a: A) {
+                    m!(a.<|>)
+                }
+                ",
+            ),
+            @r###"[]"###
+        );
+    }
+    #[test]
+    fn works_in_simple_macro_recursive_1() {
+        assert_debug_snapshot!(
+            do_ref_completion(
+                r"
+                macro_rules! m { ($e:expr) => { $e } }
+                struct A { the_field: u32 }
+                fn foo(a: A) {
+                    m!(m!(m!(a.x<|>)))
+                }
+                ",
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "the_field",
+                source_range: [162; 163),
+                delete: [162; 163),
+                insert: "the_field",
+                kind: Field,
+                detail: "u32",
+            },
+        ]
+        "###
+        );
+    }
+    #[test]
+    fn test_method_completion_3547() {
+        assert_debug_snapshot!(
+            do_ref_completion(
+                r"
+            struct HashSet<T> {}
+            impl<T> HashSet<T> {
+                pub fn the_method(&self) {}
+            }
+            fn foo() {
+                let s: HashSet<_>;
+                s.<|>
+            }
+            ",
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "the_method()",
+                source_range: [201; 201),
+                delete: [201; 201),
+                insert: "the_method()$0",
+                kind: Method,
+                lookup: "the_method",
+                detail: "pub fn the_method(&self)",
+            },
+        ]
+        "###
+        );
+    }
 }
diff --git a/crates/ra_ide/src/completion/complete_fn_param.rs b/crates/ra_ide/src/completion/complete_fn_param.rs
index 502458706..9226ac055 100644
--- a/crates/ra_ide/src/completion/complete_fn_param.rs
+++ b/crates/ra_ide/src/completion/complete_fn_param.rs
@@ -52,7 +52,7 @@ pub(super) fn complete_fn_param(acc: &mut Completions, ctx: &CompletionContext)
 #[cfg(test)]
 mod tests {
-    use crate::completion::{do_completion, CompletionItem, CompletionKind};
+    use crate::completion::{test_utils::do_completion, CompletionItem, CompletionKind};
    use insta::assert_debug_snapshot;
    fn do_magic_completion(code: &str) -> Vec<CompletionItem> {
diff --git a/crates/ra_ide/src/completion/complete_keyword.rs b/crates/ra_ide/src/completion/complete_keyword.rs
index eb7cd9ac2..1e053ea4a 100644
--- a/crates/ra_ide/src/completion/complete_keyword.rs
+++ b/crates/ra_ide/src/completion/complete_keyword.rs
@@ -79,6 +79,7 @@ pub(super) fn complete_expr_keyword(acc: &mut Completions, ctx: &CompletionConte
 }
 fn is_in_loop_body(leaf: &SyntaxToken) -> bool {
+    // FIXME move this to CompletionContext and make it handle macros
    for node in leaf.parent().ancestors() {
        if node.kind() == FN_DEF || node.kind() == LAMBDA_EXPR {
            break;
@@ -116,7 +117,7 @@ fn complete_return(
 #[cfg(test)]
 mod tests {
-    use crate::completion::{do_completion, CompletionItem, CompletionKind};
+    use crate::completion::{test_utils::do_completion, CompletionItem, CompletionKind};
    use insta::assert_debug_snapshot;
    fn do_keyword_completion(code: &str) -> Vec<CompletionItem> {
diff --git a/crates/ra_ide/src/completion/complete_macro_in_item_position.rs b/crates/ra_ide/src/completion/complete_macro_in_item_position.rs
index 1866d9e6c..270e96df0 100644
--- a/crates/ra_ide/src/completion/complete_macro_in_item_position.rs
+++ b/crates/ra_ide/src/completion/complete_macro_in_item_position.rs
@@ -15,9 +15,10 @@ pub(super) fn complete_macro_in_item_position(acc: &mut Completions, ctx: &Compl
 #[cfg(test)]
 mod tests {
-    use crate::completion::{do_completion, CompletionItem, CompletionKind};
    use insta::assert_debug_snapshot;
+    use crate::completion::{test_utils::do_completion, CompletionItem, CompletionKind};
    fn do_reference_completion(code: &str) -> Vec<CompletionItem> {
        do_completion(code, CompletionKind::Reference)
    }
diff --git a/crates/ra_ide/src/completion/complete_path.rs b/crates/ra_ide/src/completion/complete_path.rs
index 1a9699466..d588ee364 100644
--- a/crates/ra_ide/src/completion/complete_path.rs
+++ b/crates/ra_ide/src/completion/complete_path.rs
@@ -1,6 +1,6 @@
-//! Completion of paths, including when writing a single name.
+//! Completion of paths, i.e. `some::prefix::<|>`.
-use hir::{Adt, PathResolution, ScopeDef};
+use hir::{Adt, HasVisibility, PathResolution, ScopeDef};
 use ra_syntax::AstNode;
 use test_utils::tested_by;
@@ -15,9 +15,10 @@ pub(super) fn complete_path(acc: &mut Completions, ctx: &CompletionContext) {
        Some(PathResolution::Def(def)) => def,
        _ => return,
    };
+    let context_module = ctx.scope().module();
    match def {
        hir::ModuleDef::Module(module) => {
-            let module_scope = module.scope(ctx.db);
+            let module_scope = module.scope(ctx.db, context_module);
            for (name, def) in module_scope {
                if ctx.use_item_syntax.is_some() {
                    if let ScopeDef::Unknown = def {
@@ -47,10 +48,13 @@ pub(super) fn complete_path(acc: &mut Completions, ctx: &CompletionContext) {
            };
            // Iterate assoc types separately
            // FIXME: complete T::AssocType
-            let krate = ctx.module.map(|m| m.krate());
+            let krate = ctx.krate;
            if let Some(krate) = krate {
                let traits_in_scope = ctx.scope().traits_in_scope();
                ty.iterate_path_candidates(ctx.db, krate, &traits_in_scope, None, |_ty, item| {
+                    if context_module.map_or(false, |m| !item.is_visible_from(ctx.db, m)) {
+                        return None;
+                    }
                    match item {
                        hir::AssocItem::Function(func) => {
                            if !func.has_self_param(ctx.db) {
@@ -64,6 +68,9 @@ pub(super) fn complete_path(acc: &mut Completions, ctx: &CompletionContext) {
                });
                ty.iterate_impl_items(ctx.db, krate, |item| {
+                    if context_module.map_or(false, |m| !item.is_visible_from(ctx.db, m)) {
+                        return None;
+                    }
                    match item {
                        hir::AssocItem::Function(_) | hir::AssocItem::Const(_) => {}
                        hir::AssocItem::TypeAlias(ty) => acc.add_type_alias(ctx, ty),
@@ -74,6 +81,9 @@ pub(super) fn complete_path(acc: &mut Completions, ctx: &CompletionContext) {
        }
        hir::ModuleDef::Trait(t) => {
            for item in t.items(ctx.db) {
+                if context_module.map_or(false, |m| !item.is_visible_from(ctx.db, m)) {
+                    continue;
+                }
                match item {
                    hir::AssocItem::Function(func) => {
                        if !func.has_self_param(ctx.db) {
@@ -93,7 +103,7 @@ pub(super) fn complete_path(acc: &mut Completions, ctx: &CompletionContext) {
 mod tests {
    use test_utils::covers;
-    use crate::completion::{do_completion, CompletionItem, CompletionKind};
+    use crate::completion::{test_utils::do_completion, CompletionItem, CompletionKind};
    use insta::assert_debug_snapshot;
    fn do_reference_completion(code: &str) -> Vec<CompletionItem> {
@@ -170,6 +180,41 @@ mod tests {
    }
    #[test]
+    fn path_visibility() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                r"
+                use self::my::<|>;
+                mod my {
+                    struct Bar;
+                    pub struct Foo;
+                    pub use Bar as PublicBar;
+                }
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "Foo",
+                source_range: [31; 31),
+                delete: [31; 31),
+                insert: "Foo",
+                kind: Struct,
+            },
+            CompletionItem {
+                label: "PublicBar",
+                source_range: [31; 31),
+                delete: [31; 31),
+                insert: "PublicBar",
+                kind: Struct,
+            },
+        ]
+        "###
+        );
+    }
+    #[test]
    fn completes_use_item_starting_with_self() {
        assert_debug_snapshot!(
            do_reference_completion(
@@ -177,7 +222,7 @@ mod tests {
                use self::m::<|>;
                mod m {
-                    struct Bar;
+                    pub struct Bar;
                }
                "
            ),
@@ -502,6 +547,60 @@ mod tests {
    }
    #[test]
+    fn associated_item_visibility() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                "
+                //- /lib.rs
+                struct S;
+                mod m {
+                    impl super::S {
+                        pub(super) fn public_method() { }
+                        fn private_method() { }
+                        pub(super) type PublicType = u32;
+                        type PrivateType = u32;
+                        pub(super) const PUBLIC_CONST: u32 = 1;
+                        const PRIVATE_CONST: u32 = 1;
+                    }
+                }
+                fn foo() { let _ = S::<|> }
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "PUBLIC_CONST",
+                source_range: [302; 302),
+                delete: [302; 302),
+                insert: "PUBLIC_CONST",
+                kind: Const,
+                detail: "pub(super) const PUBLIC_CONST: u32 = 1;",
+            },
+            CompletionItem {
+                label: "PublicType",
+                source_range: [302; 302),
+                delete: [302; 302),
+                insert: "PublicType",
+                kind: TypeAlias,
+                detail: "pub(super) type PublicType = u32;",
+            },
+            CompletionItem {
+                label: "public_method()",
+                source_range: [302; 302),
+                delete: [302; 302),
+                insert: "public_method()$0",
+                kind: Function,
+                lookup: "public_method",
+                detail: "pub(super) fn public_method()",
+            },
+        ]
+        "###
+        );
+    }
+    #[test]
    fn completes_enum_associated_method() {
        assert_debug_snapshot!(
            do_reference_completion(
@@ -835,4 +934,37 @@ mod tests {
        "###
        );
    }
+    #[test]
+    fn completes_in_simple_macro_call() {
+        let completions = do_reference_completion(
+            r#"
+                macro_rules! m { ($e:expr) => { $e } }
+                fn main() { m!(self::f<|>); }
+                fn foo() {}
+            "#,
+        );
+        assert_debug_snapshot!(completions, @r###"
+        [
+            CompletionItem {
+                label: "foo()",
+                source_range: [93; 94),
+                delete: [93; 94),
+                insert: "foo()$0",
+                kind: Function,
+                lookup: "foo",
+                detail: "fn foo()",
+            },
+            CompletionItem {
+                label: "main()",
+                source_range: [93; 94),
+                delete: [93; 94),
+                insert: "main()$0",
+                kind: Function,
+                lookup: "main",
+                detail: "fn main()",
+            },
+        ]
+        "###);
+    }
 }
diff --git a/crates/ra_ide/src/completion/complete_pattern.rs b/crates/ra_ide/src/completion/complete_pattern.rs
index c2c6ca002..6a1a66ef1 100644
--- a/crates/ra_ide/src/completion/complete_pattern.rs
+++ b/crates/ra_ide/src/completion/complete_pattern.rs
@@ -27,7 +27,7 @@ pub(super) fn complete_pattern(acc: &mut Completions, ctx: &CompletionContext) {
 #[cfg(test)]
 mod tests {
-    use crate::completion::{do_completion, CompletionItem, CompletionKind};
+    use crate::completion::{test_utils::do_completion, CompletionItem, CompletionKind};
    use insta::assert_debug_snapshot;
    fn complete(code: &str) -> Vec<CompletionItem> {
@@ -86,4 +86,22 @@ mod tests {
        ]
        "###);
    }
+    #[test]
+    fn completes_in_simple_macro_call() {
+        // FIXME: doesn't work yet because of missing error recovery in macro expansion
+        let completions = complete(
+            r"
+            macro_rules! m { ($e:expr) => { $e } }
+            enum E { X }
+            fn foo() {
+               m!(match E::X {
+                   <|>
+               })
+            }
+            ",
+        );
+        assert_debug_snapshot!(completions, @r###"[]"###);
+    }
 }
diff --git a/crates/ra_ide/src/completion/complete_postfix.rs b/crates/ra_ide/src/completion/complete_postfix.rs
index 8a74f993a..0ba382165 100644
--- a/crates/ra_ide/src/completion/complete_postfix.rs
+++ b/crates/ra_ide/src/completion/complete_postfix.rs
@@ -12,7 +12,7 @@ use crate::{
 };
 pub(super) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
-    if !ctx.db.feature_flags.get("completion.enable-postfix") {
+    if !ctx.options.enable_postfix_completions {
        return;
    }
@@ -67,8 +67,8 @@ pub(super) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
 fn postfix_snippet(ctx: &CompletionContext, label: &str, detail: &str, snippet: &str) -> Builder {
    let edit = {
-        let receiver_range =
+        let receiver_syntax = ctx.dot_receiver.as_ref().expect("no receiver available").syntax();
-            ctx.dot_receiver.as_ref().expect("no receiver available").syntax().text_range();
+        let receiver_range = ctx.sema.original_range(receiver_syntax).range;
        let delete_range = TextRange::from_to(receiver_range.start(), ctx.source_range().end());
        TextEdit::replace(delete_range, snippet.to_string())
    };
@@ -81,7 +81,7 @@ fn postfix_snippet(ctx: &CompletionContext, label: &str, detail: &str, snippet:
 mod tests {
    use insta::assert_debug_snapshot;
-    use crate::completion::{do_completion, CompletionItem, CompletionKind};
+    use crate::completion::{test_utils::do_completion, CompletionItem, CompletionKind};
    fn do_postfix_completion(code: &str) -> Vec<CompletionItem> {
        do_completion(code, CompletionKind::Postfix)
@@ -279,4 +279,65 @@ mod tests {
        "###
        );
    }
+    #[test]
+    fn works_in_simple_macro() {
+        assert_debug_snapshot!(
+            do_postfix_completion(
+                r#"
+                macro_rules! m { ($e:expr) => { $e } }
+                fn main() {
+                    let bar: u8 = 12;
+                    m!(bar.b<|>)
+                }
+                "#,
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "box",
+                source_range: [149; 150),
+                delete: [145; 150),
+                insert: "Box::new(bar)",
+                detail: "Box::new(expr)",
+            },
+            CompletionItem {
+                label: "dbg",
+                source_range: [149; 150),
+                delete: [145; 150),
+                insert: "dbg!(bar)",
+                detail: "dbg!(expr)",
+            },
+            CompletionItem {
+                label: "match",
+                source_range: [149; 150),
+                delete: [145; 150),
+                insert: "match bar {\n    ${1:_} => {$0\\},\n}",
+                detail: "match expr {}",
+            },
+            CompletionItem {
+                label: "not",
+                source_range: [149; 150),
+                delete: [145; 150),
+                insert: "!bar",
+                detail: "!expr",
+            },
+            CompletionItem {
+                label: "ref",
+                source_range: [149; 150),
+                delete: [145; 150),
+                insert: "&bar",
+                detail: "&expr",
+            },
+            CompletionItem {
+                label: "refm",
+                source_range: [149; 150),
+                delete: [145; 150),
+                insert: "&mut bar",
+                detail: "&mut expr",
+            },
+        ]
+        "###
+        );
+    }
 }
diff --git a/crates/ra_ide/src/completion/complete_record_literal.rs b/crates/ra_ide/src/completion/complete_record_literal.rs
index f98353d76..83ed1d52c 100644
--- a/crates/ra_ide/src/completion/complete_record_literal.rs
+++ b/crates/ra_ide/src/completion/complete_record_literal.rs
@@ -18,7 +18,7 @@ pub(super) fn complete_record_literal(acc: &mut Completions, ctx: &CompletionCon
 #[cfg(test)]
 mod tests {
-    use crate::completion::{do_completion, CompletionItem, CompletionKind};
+    use crate::completion::{test_utils::do_completion, CompletionItem, CompletionKind};
    use insta::assert_debug_snapshot;
    fn complete(code: &str) -> Vec<CompletionItem> {
@@ -153,4 +153,29 @@ mod tests {
        ]
        "###);
    }
+    #[test]
+    fn test_record_literal_field_in_simple_macro() {
+        let completions = complete(
+            r"
+            macro_rules! m { ($e:expr) => { $e } }
+            struct A { the_field: u32 }
+            fn foo() {
+               m!(A { the<|> })
+            }
+            ",
+        );
+        assert_debug_snapshot!(completions, @r###"
+        [
+            CompletionItem {
+                label: "the_field",
+                source_range: [137; 140),
+                delete: [137; 140),
+                insert: "the_field",
+                kind: Field,
+                detail: "u32",
+            },
+        ]
+        "###);
+    }
 }
diff --git a/crates/ra_ide/src/completion/complete_record_pattern.rs b/crates/ra_ide/src/completion/complete_record_pattern.rs
index 9bdeae49f..962376428 100644
--- a/crates/ra_ide/src/completion/complete_record_pattern.rs
+++ b/crates/ra_ide/src/completion/complete_record_pattern.rs
@@ -17,7 +17,7 @@ pub(super) fn complete_record_pattern(acc: &mut Completions, ctx: &CompletionCon
 #[cfg(test)]
 mod tests {
-    use crate::completion::{do_completion, CompletionItem, CompletionKind};
+    use crate::completion::{test_utils::do_completion, CompletionItem, CompletionKind};
    use insta::assert_debug_snapshot;
    fn complete(code: &str) -> Vec<CompletionItem> {
@@ -87,4 +87,32 @@ mod tests {
        ]
        "###);
    }
+    #[test]
+    fn test_record_pattern_field_in_simple_macro() {
+        let completions = complete(
+            r"
+            macro_rules! m { ($e:expr) => { $e } }
+            struct S { foo: u32 }
+            fn process(f: S) {
+                m!(match f {
+                    S { f<|>: 92 } => (),
+                })
+            }
+            ",
+        );
+        assert_debug_snapshot!(completions, @r###"
+        [
+            CompletionItem {
+                label: "foo",
+                source_range: [171; 172),
+                delete: [171; 172),
+                insert: "foo",
+                kind: Field,
+                detail: "u32",
+            },
+        ]
+        "###);
+    }
 }
diff --git a/crates/ra_ide/src/completion/complete_scope.rs b/crates/ra_ide/src/completion/complete_scope.rs
index 2b9a0e556..bd4adf23a 100644
--- a/crates/ra_ide/src/completion/complete_scope.rs
+++ b/crates/ra_ide/src/completion/complete_scope.rs
@@ -1,4 +1,4 @@
-//! FIXME: write short doc here
+//! Completion of names from the current scope, e.g. locals and imported items.
 use crate::completion::{CompletionContext, Completions};
@@ -14,10 +14,10 @@ pub(super) fn complete_scope(acc: &mut Completions, ctx: &CompletionContext) {
 mod tests {
    use insta::assert_debug_snapshot;
-    use crate::completion::{do_completion, CompletionItem, CompletionKind};
+    use crate::completion::{test_utils::do_completion, CompletionItem, CompletionKind};
-    fn do_reference_completion(code: &str) -> Vec<CompletionItem> {
+    fn do_reference_completion(ra_fixture: &str) -> Vec<CompletionItem> {
-        do_completion(code, CompletionKind::Reference)
+        do_completion(ra_fixture, CompletionKind::Reference)
    }
    #[test]
@@ -797,4 +797,72 @@ mod tests {
        "###
        )
    }
+    #[test]
+    fn completes_in_simple_macro_1() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                r"
+                macro_rules! m { ($e:expr) => { $e } }
+                fn quux(x: i32) {
+                    let y = 92;
+                    m!(<|>);
+                }
+                "
+            ),
+            @"[]"
+        );
+    }
+    #[test]
+    fn completes_in_simple_macro_2() {
+        assert_debug_snapshot!(
+            do_reference_completion(
+                r"
+                macro_rules! m { ($e:expr) => { $e } }
+                fn quux(x: i32) {
+                    let y = 92;
+                    m!(x<|>);
+                }
+                "
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "m!",
+                source_range: [145; 146),
+                delete: [145; 146),
+                insert: "m!($0)",
+                kind: Macro,
+                detail: "macro_rules! m",
+            },
+            CompletionItem {
+                label: "quux(…)",
+                source_range: [145; 146),
+                delete: [145; 146),
+                insert: "quux(${1:x})$0",
+                kind: Function,
+                lookup: "quux",
+                detail: "fn quux(x: i32)",
+            },
+            CompletionItem {
+                label: "x",
+                source_range: [145; 146),
+                delete: [145; 146),
+                insert: "x",
+                kind: Binding,
+                detail: "i32",
+            },
+            CompletionItem {
+                label: "y",
+                source_range: [145; 146),
+                delete: [145; 146),
+                insert: "y",
+                kind: Binding,
+                detail: "i32",
+            },
+        ]
+        "###
+        );
+    }
 }
diff --git a/crates/ra_ide/src/completion/complete_snippet.rs b/crates/ra_ide/src/completion/complete_snippet.rs
index 731b4fd82..f731e9b9a 100644
--- a/crates/ra_ide/src/completion/complete_snippet.rs
+++ b/crates/ra_ide/src/completion/complete_snippet.rs
@@ -42,7 +42,7 @@ fn ${1:feature}() {
 #[cfg(test)]
 mod tests {
-    use crate::completion::{do_completion, CompletionItem, CompletionKind};
+    use crate::completion::{test_utils::do_completion, CompletionItem, CompletionKind};
    use insta::assert_debug_snapshot;
    fn do_snippet_completion(code: &str) -> Vec<CompletionItem> {
diff --git a/crates/ra_ide/src/completion/complete_trait_impl.rs b/crates/ra_ide/src/completion/complete_trait_impl.rs
index 18a1d2995..7fefa2c7a 100644
--- a/crates/ra_ide/src/completion/complete_trait_impl.rs
+++ b/crates/ra_ide/src/completion/complete_trait_impl.rs
@@ -34,7 +34,7 @@
 use hir::{self, Docs, HasSource};
 use ra_assists::utils::get_missing_impl_items;
 use ra_syntax::{
-    ast::{self, edit},
+    ast::{self, edit, ImplDef},
    AstNode, SyntaxKind, SyntaxNode, TextRange,
 };
 use ra_text_edit::TextEdit;
@@ -47,22 +47,22 @@ use crate::{
 };
 pub(crate) fn complete_trait_impl(acc: &mut Completions, ctx: &CompletionContext) {
-    let trigger = ctx.token.ancestors().find(|p| match p.kind() {
+    if let Some((trigger, impl_def)) = completion_match(ctx) {
-        SyntaxKind::FN_DEF
-        | SyntaxKind::TYPE_ALIAS_DEF
-        | SyntaxKind::CONST_DEF
-        | SyntaxKind::BLOCK_EXPR => true,
-        _ => false,
-    });
-    let impl_def = trigger
-        .as_ref()
-        .and_then(|node| node.parent())
-        .and_then(|node| node.parent())
-        .and_then(ast::ImplDef::cast);
-    if let (Some(trigger), Some(impl_def)) = (trigger, impl_def) {
        match trigger.kind() {
+            SyntaxKind::NAME_REF => {
+                get_missing_impl_items(&ctx.sema, &impl_def).iter().for_each(|item| match item {
+                    hir::AssocItem::Function(fn_item) => {
+                        add_function_impl(&trigger, acc, ctx, &fn_item)
+                    }
+                    hir::AssocItem::TypeAlias(type_item) => {
+                        add_type_alias_impl(&trigger, acc, ctx, &type_item)
+                    }
+                    hir::AssocItem::Const(const_item) => {
+                        add_const_impl(&trigger, acc, ctx, &const_item)
+                    }
+                })
+            }
            SyntaxKind::FN_DEF => {
                for missing_fn in get_missing_impl_items(&ctx.sema, &impl_def).iter().filter_map(
                    |item| match item {
@@ -101,6 +101,21 @@ pub(crate) fn complete_trait_impl(acc: &mut Completions, ctx: &CompletionContext
    }
 }
+fn completion_match(ctx: &CompletionContext) -> Option<(SyntaxNode, ImplDef)> {
+    let (trigger, impl_def_offset) = ctx.token.ancestors().find_map(|p| match p.kind() {
+        SyntaxKind::FN_DEF
+        | SyntaxKind::TYPE_ALIAS_DEF
+        | SyntaxKind::CONST_DEF
+        | SyntaxKind::BLOCK_EXPR => Some((p, 2)),
+        SyntaxKind::NAME_REF => Some((p, 5)),
+        _ => None,
+    })?;
+    let impl_def = (0..impl_def_offset - 1)
+        .try_fold(trigger.parent()?, |t, _| t.parent())
+        .and_then(ast::ImplDef::cast)?;
+    Some((trigger, impl_def))
+}
 fn add_function_impl(
    fn_def_node: &SyntaxNode,
    acc: &mut Completions,
@@ -202,7 +217,7 @@ fn make_const_compl_syntax(const_: &ast::ConstDef) -> String {
 #[cfg(test)]
 mod tests {
-    use crate::completion::{do_completion, CompletionItem, CompletionKind};
+    use crate::completion::{test_utils::do_completion, CompletionItem, CompletionKind};
    use insta::assert_debug_snapshot;
    fn complete(code: &str) -> Vec<CompletionItem> {
@@ -210,6 +225,103 @@ mod tests {
    }
    #[test]
+    fn name_ref_function_type_const() {
+        let completions = complete(
+            r"
+            trait Test {
+                type TestType;
+                const TEST_CONST: u16;
+                fn test();
+            }
+            struct T1;
+            impl Test for T1 {
+                t<|>
+            }
+            ",
+        );
+        assert_debug_snapshot!(completions, @r###"
+        [
+            CompletionItem {
+                label: "const TEST_CONST: u16 = ",
+                source_range: [209; 210),
+                delete: [209; 210),
+                insert: "const TEST_CONST: u16 = ",
+                kind: Const,
+                lookup: "TEST_CONST",
+            },
+            CompletionItem {
+                label: "fn test()",
+                source_range: [209; 210),
+                delete: [209; 210),
+                insert: "fn test() {}",
+                kind: Function,
+                lookup: "test",
+            },
+            CompletionItem {
+                label: "type TestType = ",
+                source_range: [209; 210),
+                delete: [209; 210),
+                insert: "type TestType = ",
+                kind: TypeAlias,
+                lookup: "TestType",
+            },
+        ]
+        "###);
+    }
+    #[test]
+    fn no_nested_fn_completions() {
+        let completions = complete(
+            r"
+            trait Test {
+                fn test();
+                fn test2();
+            }
+            struct T1;
+            impl Test for T1 {
+                fn test() {
+                    t<|>
+                }
+            }
+            ",
+        );
+        assert_debug_snapshot!(completions, @r###"[]"###);
+    }
+    #[test]
+    fn name_ref_single_function() {
+        let completions = complete(
+            r"
+            trait Test {
+                fn test();
+            }
+            struct T1;
+            impl Test for T1 {
+                t<|>
+            }
+            ",
+        );
+        assert_debug_snapshot!(completions, @r###"
+        [
+            CompletionItem {
+                label: "fn test()",
+                source_range: [139; 140),
+                delete: [139; 140),
+                insert: "fn test() {}",
+                kind: Function,
+                lookup: "test",
+            },
+        ]
+        "###);
+    }
+    #[test]
    fn single_function() {
        let completions = complete(
            r"
diff --git a/crates/ra_ide/src/completion/completion_context.rs b/crates/ra_ide/src/completion/completion_context.rs
index 9aa5a705d..3646fb8dc 100644
--- a/crates/ra_ide/src/completion/completion_context.rs
+++ b/crates/ra_ide/src/completion/completion_context.rs
@@ -5,13 +5,13 @@ use ra_db::SourceDatabase;
 use ra_ide_db::RootDatabase;
 use ra_syntax::{
    algo::{find_covering_element, find_node_at_offset},
-    ast, AstNode, SourceFile,
+    ast, AstNode,
    SyntaxKind::*,
    SyntaxNode, SyntaxToken, TextRange, TextUnit,
 };
 use ra_text_edit::AtomTextEdit;
-use crate::FilePosition;
+use crate::{completion::CompletionOptions, FilePosition};
 /// `CompletionContext` is created early during completion to figure out, where
 /// exactly is the cursor, syntax-wise.
@@ -19,9 +19,13 @@ use crate::FilePosition;
 pub(crate) struct CompletionContext<'a> {
    pub(super) sema: Semantics<'a, RootDatabase>,
    pub(super) db: &'a RootDatabase,
+    pub(super) options: &'a CompletionOptions,
    pub(super) offset: TextUnit,
+    /// The token before the cursor, in the original file.
+    pub(super) original_token: SyntaxToken,
+    /// The token before the cursor, in the macro-expanded file.
    pub(super) token: SyntaxToken,
-    pub(super) module: Option<hir::Module>,
+    pub(super) krate: Option<hir::Crate>,
    pub(super) name_ref_syntax: Option<ast::NameRef>,
    pub(super) function_syntax: Option<ast::FnDef>,
    pub(super) use_item_syntax: Option<ast::UseItem>,
@@ -54,6 +58,7 @@ impl<'a> CompletionContext<'a> {
    pub(super) fn new(
        db: &'a RootDatabase,
        position: FilePosition,
+        options: &'a CompletionOptions,
    ) -> Option<CompletionContext<'a>> {
        let sema = Semantics::new(db);
@@ -67,15 +72,21 @@ impl<'a> CompletionContext<'a> {
            let edit = AtomTextEdit::insert(position.offset, "intellijRulezz".to_string());
            parse.reparse(&edit).tree()
        };
+        let fake_ident_token =
+            file_with_fake_ident.syntax().token_at_offset(position.offset).right_biased().unwrap();
-        let module = sema.to_module_def(position.file_id);
+        let krate = sema.to_module_def(position.file_id).map(|m| m.krate());
-        let token = original_file.syntax().token_at_offset(position.offset).left_biased()?;
+        let original_token =
+            original_file.syntax().token_at_offset(position.offset).left_biased()?;
+        let token = sema.descend_into_macros(original_token.clone());
        let mut ctx = CompletionContext {
            sema,
            db,
+            options,
+            original_token,
            token,
            offset: position.offset,
-            module,
+            krate,
            name_ref_syntax: None,
            function_syntax: None,
            use_item_syntax: None,
@@ -95,15 +106,57 @@ impl<'a> CompletionContext<'a> {
            has_type_args: false,
            dot_receiver_is_ambiguous_float_literal: false,
        };
-        ctx.fill(&original_file, file_with_fake_ident, position.offset);
+        let mut original_file = original_file.syntax().clone();
+        let mut hypothetical_file = file_with_fake_ident.syntax().clone();
+        let mut offset = position.offset;
+        let mut fake_ident_token = fake_ident_token;
+        // Are we inside a macro call?
+        while let (Some(actual_macro_call), Some(macro_call_with_fake_ident)) = (
+            find_node_at_offset::<ast::MacroCall>(&original_file, offset),
+            find_node_at_offset::<ast::MacroCall>(&hypothetical_file, offset),
+        ) {
+            if actual_macro_call.path().as_ref().map(|s| s.syntax().text())
+                != macro_call_with_fake_ident.path().as_ref().map(|s| s.syntax().text())
+            {
+                break;
+            }
+            let hypothetical_args = match macro_call_with_fake_ident.token_tree() {
+                Some(tt) => tt,
+                None => break,
+            };
+            if let (Some(actual_expansion), Some(hypothetical_expansion)) = (
+                ctx.sema.expand(&actual_macro_call),
+                ctx.sema.expand_hypothetical(
+                    &actual_macro_call,
+                    &hypothetical_args,
+                    fake_ident_token,
+                ),
+            ) {
+                let new_offset = hypothetical_expansion.1.text_range().start();
+                if new_offset >= actual_expansion.text_range().end() {
+                    break;
+                }
+                original_file = actual_expansion;
+                hypothetical_file = hypothetical_expansion.0;
+                fake_ident_token = hypothetical_expansion.1;
+                offset = new_offset;
+            } else {
+                break;
+            }
+        }
+        ctx.fill(&original_file, hypothetical_file, offset);
        Some(ctx)
    }
    // The range of the identifier that is being completed.
    pub(crate) fn source_range(&self) -> TextRange {
+        // check kind of macro-expanded token, but use range of original token
        match self.token.kind() {
            // workaroud when completion is triggered by trigger characters.
-            IDENT => self.token.text_range(),
+            IDENT => self.original_token.text_range(),
            _ => TextRange::offset_len(self.offset, 0.into()),
        }
    }
@@ -114,27 +167,24 @@ impl<'a> CompletionContext<'a> {
    fn fill(
        &mut self,
-        original_file: &ast::SourceFile,
+        original_file: &SyntaxNode,
-        file_with_fake_ident: ast::SourceFile,
+        file_with_fake_ident: SyntaxNode,
        offset: TextUnit,
    ) {
        // First, let's try to complete a reference to some declaration.
-        if let Some(name_ref) =
+        if let Some(name_ref) = find_node_at_offset::<ast::NameRef>(&file_with_fake_ident, offset) {
-            find_node_at_offset::<ast::NameRef>(file_with_fake_ident.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(original_file, name_ref);
+            self.classify_name_ref(original_file, name_ref, offset);
        }
        // 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_with_fake_ident.syntax(), offset)
+        if let Some(name) = find_node_at_offset::<ast::Name>(&file_with_fake_ident, offset) {
-        {
            if let Some(bind_pat) = name.syntax().ancestors().find_map(ast::BindPat::cast) {
                let parent = bind_pat.syntax().parent();
                if parent.clone().and_then(ast::MatchArm::cast).is_some()
@@ -148,23 +198,29 @@ impl<'a> CompletionContext<'a> {
                return;
            }
            if name.syntax().ancestors().find_map(ast::RecordFieldPatList::cast).is_some() {
-                self.record_lit_pat = find_node_at_offset(original_file.syntax(), self.offset);
+                self.record_lit_pat =
+                    self.sema.find_node_at_offset_with_macros(&original_file, offset);
            }
        }
    }
-    fn classify_name_ref(&mut self, original_file: &SourceFile, name_ref: ast::NameRef) {
+    fn classify_name_ref(
+        &mut self,
+        original_file: &SyntaxNode,
+        name_ref: ast::NameRef,
+        offset: TextUnit,
+    ) {
        self.name_ref_syntax =
-            find_node_at_offset(original_file.syntax(), name_ref.syntax().text_range().start());
+            find_node_at_offset(&original_file, name_ref.syntax().text_range().start());
        let name_range = name_ref.syntax().text_range();
        if name_ref.syntax().parent().and_then(ast::RecordField::cast).is_some() {
-            self.record_lit_syntax = find_node_at_offset(original_file.syntax(), self.offset);
+            self.record_lit_syntax =
+                self.sema.find_node_at_offset_with_macros(&original_file, offset);
        }
        self.impl_def = self
-            .token
+            .sema
-            .parent()
+            .ancestors_with_macros(self.token.parent())
-            .ancestors()
            .take_while(|it| it.kind() != SOURCE_FILE && it.kind() != MODULE)
            .find_map(ast::ImplDef::cast);
@@ -183,12 +239,12 @@ impl<'a> CompletionContext<'a> {
            _ => (),
        }
-        self.use_item_syntax = self.token.parent().ancestors().find_map(ast::UseItem::cast);
+        self.use_item_syntax =
+            self.sema.ancestors_with_macros(self.token.parent()).find_map(ast::UseItem::cast);
        self.function_syntax = self
-            .token
+            .sema
-            .parent()
+            .ancestors_with_macros(self.token.parent())
-            .ancestors()
            .take_while(|it| it.kind() != SOURCE_FILE && it.kind() != MODULE)
            .find_map(ast::FnDef::cast);
@@ -242,7 +298,7 @@ impl<'a> CompletionContext<'a> {
                if let Some(off) = name_ref.syntax().text_range().start().checked_sub(2.into()) {
                    if let Some(if_expr) =
-                        find_node_at_offset::<ast::IfExpr>(original_file.syntax(), off)
+                        self.sema.find_node_at_offset_with_macros::<ast::IfExpr>(original_file, off)
                    {
                        if if_expr.syntax().text_range().end()
                            < name_ref.syntax().text_range().start()
@@ -259,7 +315,7 @@ impl<'a> CompletionContext<'a> {
            self.dot_receiver = field_expr
                .expr()
                .map(|e| e.syntax().text_range())
-                .and_then(|r| find_node_with_range(original_file.syntax(), r));
+                .and_then(|r| find_node_with_range(original_file, r));
            self.dot_receiver_is_ambiguous_float_literal =
                if let Some(ast::Expr::Literal(l)) = &self.dot_receiver {
                    match l.kind() {
@@ -275,7 +331,7 @@ impl<'a> CompletionContext<'a> {
            self.dot_receiver = method_call_expr
                .expr()
                .map(|e| e.syntax().text_range())
-                .and_then(|r| find_node_with_range(original_file.syntax(), r));
+                .and_then(|r| find_node_with_range(original_file, r));
            self.is_call = true;
        }
    }
diff --git a/crates/ra_ide/src/completion/completion_item.rs b/crates/ra_ide/src/completion/completion_item.rs
index 61867c0ff..ef0eb43b2 100644
--- a/crates/ra_ide/src/completion/completion_item.rs
+++ b/crates/ra_ide/src/completion/completion_item.rs
@@ -13,7 +13,7 @@ pub struct CompletionItem {
    /// Used only internally in tests, to check only specific kind of
    /// completion (postfix, keyword, reference, etc).
    #[allow(unused)]
-    completion_kind: CompletionKind,
+    pub(crate) completion_kind: CompletionKind,
    /// Label in the completion pop up which identifies completion.
    label: String,
    /// Range of identifier that is being completed.
@@ -47,6 +47,10 @@ pub struct CompletionItem {
    /// Whether this item is marked as deprecated
    deprecated: bool,
+    /// If completing a function call, ask the editor to show parameter popup
+    /// after completion.
+    trigger_call_info: bool,
 }
 // We use custom debug for CompletionItem to make `insta`'s diffs more readable.
@@ -139,6 +143,7 @@ impl CompletionItem {
            kind: None,
            text_edit: None,
            deprecated: None,
+            trigger_call_info: None,
        }
    }
    /// What user sees in pop-up in the UI.
@@ -177,6 +182,10 @@ impl CompletionItem {
    pub fn deprecated(&self) -> bool {
        self.deprecated
    }
+    pub fn trigger_call_info(&self) -> bool {
+        self.trigger_call_info
+    }
 }
 /// A helper to make `CompletionItem`s.
@@ -193,6 +202,7 @@ pub(crate) struct Builder {
    kind: Option<CompletionItemKind>,
    text_edit: Option<TextEdit>,
    deprecated: Option<bool>,
+    trigger_call_info: Option<bool>,
 }
 impl Builder {
@@ -221,6 +231,7 @@ impl Builder {
            kind: self.kind,
            completion_kind: self.completion_kind,
            deprecated: self.deprecated.unwrap_or(false),
+            trigger_call_info: self.trigger_call_info.unwrap_or(false),
        }
    }
    pub(crate) fn lookup_by(mut self, lookup: impl Into<String>) -> Builder {
@@ -271,6 +282,10 @@ impl Builder {
        self.deprecated = Some(deprecated);
        self
    }
+    pub(crate) fn trigger_call_info(mut self) -> Builder {
+        self.trigger_call_info = Some(true);
+        self
+    }
 }
 impl<'a> Into<CompletionItem> for Builder {
@@ -303,20 +318,3 @@ impl Into<Vec<CompletionItem>> for Completions {
        self.buf
    }
 }
-#[cfg(test)]
-pub(crate) fn do_completion(code: &str, kind: CompletionKind) -> Vec<CompletionItem> {
-    use crate::completion::completions;
-    use crate::mock_analysis::{analysis_and_position, single_file_with_position};
-    let (analysis, position) = if code.contains("//-") {
-        analysis_and_position(code)
-    } else {
-        single_file_with_position(code)
-    };
-    let completions = completions(&analysis.db, position).unwrap();
-    let completion_items: Vec<CompletionItem> = completions.into();
-    let mut kind_completions: Vec<CompletionItem> =
-        completion_items.into_iter().filter(|c| c.completion_kind == kind).collect();
-    kind_completions.sort_by_key(|c| c.label.clone());
-    kind_completions
-}
diff --git a/crates/ra_ide/src/completion/presentation.rs b/crates/ra_ide/src/completion/presentation.rs
index dac232a85..5213def20 100644
--- a/crates/ra_ide/src/completion/presentation.rs
+++ b/crates/ra_ide/src/completion/presentation.rs
@@ -103,11 +103,8 @@ impl Completions {
            }
        };
-        // If not an import, add parenthesis automatically.
+        // Add `<>` for generic types
-        if ctx.is_path_type
+        if ctx.is_path_type && !ctx.has_type_args && ctx.options.add_call_parenthesis {
-            && !ctx.has_type_args
-            && ctx.db.feature_flags.get("completion.insertion.add-call-parenthesis")
-        {
            let has_non_default_type_params = match resolution {
                ScopeDef::ModuleDef(Adt(it)) => it.has_non_default_type_params(ctx.db),
                ScopeDef::ModuleDef(TypeAlias(it)) => it.has_non_default_type_params(ctx.db),
@@ -211,26 +208,29 @@ impl Completions {
                .set_deprecated(is_deprecated(func, ctx.db))
                .detail(function_signature.to_string());
-        // Add `<>` for generic types
+        // If not an import, add parenthesis automatically.
-        if ctx.use_item_syntax.is_none()
+        if ctx.use_item_syntax.is_none() && !ctx.is_call && ctx.options.add_call_parenthesis {
-            && !ctx.is_call
-            && ctx.db.feature_flags.get("completion.insertion.add-call-parenthesis")
-        {
            tested_by!(inserts_parens_for_function_calls);
            let (snippet, label) = if params.is_empty() || has_self_param && params.len() == 1 {
                (format!("{}()$0", name), format!("{}()", name))
            } else {
-                let to_skip = if has_self_param { 1 } else { 0 };
+                builder = builder.trigger_call_info();
-                let function_params_snippet =
+                let snippet = if ctx.options.add_call_argument_snippets {
-                    join(
+                    let to_skip = if has_self_param { 1 } else { 0 };
+                    let function_params_snippet = join(
                        function_signature.parameter_names.iter().skip(to_skip).enumerate().map(
                            |(index, param_name)| format!("${{{}:{}}}", index + 1, param_name),
                        ),
                    )
                    .separator(", ")
                    .to_string();
-                (format!("{}({})$0", name, function_params_snippet), format!("{}(…)", name))
+                    format!("{}({})$0", name, function_params_snippet)
+                } else {
+                    format!("{}($0)", name)
+                };
+                (snippet, format!("{}(…)", name))
            };
            builder = builder.lookup_by(name).label(label).insert_snippet(snippet);
        }
@@ -307,12 +307,22 @@ mod tests {
    use insta::assert_debug_snapshot;
    use test_utils::covers;
-    use crate::completion::{do_completion, CompletionItem, CompletionKind};
+    use crate::completion::{
+        test_utils::{do_completion, do_completion_with_options},
+        CompletionItem, CompletionKind, CompletionOptions,
+    };
    fn do_reference_completion(ra_fixture: &str) -> Vec<CompletionItem> {
        do_completion(ra_fixture, CompletionKind::Reference)
    }
+    fn do_reference_completion_with_options(
+        ra_fixture: &str,
+        options: CompletionOptions,
+    ) -> Vec<CompletionItem> {
+        do_completion_with_options(ra_fixture, CompletionKind::Reference, &options)
+    }
    #[test]
    fn enum_detail_includes_names_for_record() {
        assert_debug_snapshot!(
@@ -533,7 +543,7 @@ mod tests {
    }
    #[test]
-    fn parens_for_method_call() {
+    fn arg_snippets_for_method_call() {
        assert_debug_snapshot!(
            do_reference_completion(
                r"
@@ -563,6 +573,40 @@ mod tests {
    }
    #[test]
+    fn no_arg_snippets_for_method_call() {
+        assert_debug_snapshot!(
+            do_reference_completion_with_options(
+                r"
+                struct S {}
+                impl S {
+                    fn foo(&self, x: i32) {}
+                }
+                fn bar(s: &S) {
+                    s.f<|>
+                }
+                ",
+                CompletionOptions {
+                    add_call_argument_snippets: false,
+                    .. Default::default()
+                }
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "foo(…)",
+                source_range: [171; 172),
+                delete: [171; 172),
+                insert: "foo($0)",
+                kind: Method,
+                lookup: "foo",
+                detail: "fn foo(&self, x: i32)",
+            },
+        ]
+        "###
+        )
+    }
+    #[test]
    fn dont_render_function_parens_in_use_item() {
        assert_debug_snapshot!(
            do_reference_completion(
diff --git a/crates/ra_ide/src/completion/test_utils.rs b/crates/ra_ide/src/completion/test_utils.rs
new file mode 100644
index 000000000..136857315
--- /dev/null
+++ b/crates/ra_ide/src/completion/test_utils.rs
@@ -0,0 +1,29 @@
+//! Runs completion for testing purposes.
+use crate::{
+    completion::{completion_item::CompletionKind, CompletionOptions},
+    mock_analysis::{analysis_and_position, single_file_with_position},
+    CompletionItem,
+};
+pub(crate) fn do_completion(code: &str, kind: CompletionKind) -> Vec<CompletionItem> {
+    do_completion_with_options(code, kind, &CompletionOptions::default())
+}
+pub(crate) fn do_completion_with_options(
+    code: &str,
+    kind: CompletionKind,
+    options: &CompletionOptions,
+) -> Vec<CompletionItem> {
+    let (analysis, position) = if code.contains("//-") {
+        analysis_and_position(code)
+    } else {
+        single_file_with_position(code)
+    };
+    let completions = analysis.completions(position, options).unwrap().unwrap();
+    let completion_items: Vec<CompletionItem> = completions.into();
+    let mut kind_completions: Vec<CompletionItem> =
+        completion_items.into_iter().filter(|c| c.completion_kind == kind).collect();
+    kind_completions.sort_by_key(|c| c.label().to_owned());
+    kind_completions
+}
diff --git a/crates/ra_ide/src/display.rs b/crates/ra_ide/src/display.rs
index 1c26a8697..eaeaaa2b4 100644
--- a/crates/ra_ide/src/display.rs
+++ b/crates/ra_ide/src/display.rs
@@ -68,17 +68,23 @@ pub(crate) fn macro_label(node: &ast::MacroCall) -> String {
 }
 pub(crate) fn rust_code_markup<CODE: AsRef<str>>(val: CODE) -> String {
-    rust_code_markup_with_doc::<_, &str>(val, None)
+    rust_code_markup_with_doc::<_, &str>(val, None, None)
 }
-pub(crate) fn rust_code_markup_with_doc<CODE, DOC>(val: CODE, doc: Option<DOC>) -> String
+pub(crate) fn rust_code_markup_with_doc<CODE, DOC>(
+    val: CODE,
+    doc: Option<DOC>,
+    mod_path: Option<String>,
+) -> String
 where
    CODE: AsRef<str>,
    DOC: AsRef<str>,
 {
+    let mod_path =
+        mod_path.filter(|path| !path.is_empty()).map(|path| path + "\n").unwrap_or_default();
    if let Some(doc) = doc {
-        format!("```rust\n{}\n```\n\n{}", val.as_ref(), doc.as_ref())
+        format!("```rust\n{}{}\n```\n\n{}", mod_path, val.as_ref(), doc.as_ref())
    } else {
-        format!("```rust\n{}\n```", val.as_ref())
+        format!("```rust\n{}{}\n```", mod_path, val.as_ref())
    }
 }
diff --git a/crates/ra_ide/src/hover.rs b/crates/ra_ide/src/hover.rs
index e9c682557..25e038a55 100644
--- a/crates/ra_ide/src/hover.rs
+++ b/crates/ra_ide/src/hover.rs
@@ -1,6 +1,10 @@
 //! FIXME: write short doc here
-use hir::{Adt, HasSource, HirDisplay, Semantics};
+use hir::{
+    Adt, AsAssocItem, AssocItemContainer, FieldSource, HasSource, HirDisplay, ModuleDef,
+    ModuleSource, Semantics,
+};
+use ra_db::SourceDatabase;
 use ra_ide_db::{
    defs::{classify_name, classify_name_ref, Definition},
    RootDatabase,
@@ -16,6 +20,8 @@ use crate::{
    display::{macro_label, rust_code_markup, rust_code_markup_with_doc, ShortLabel},
    FilePosition, RangeInfo,
 };
+use itertools::Itertools;
+use std::iter::once;
 /// Contains the results when hovering over an item
 #[derive(Debug, Clone)]
@@ -83,44 +89,86 @@ impl HoverResult {
    }
 }
-fn hover_text(docs: Option<String>, desc: Option<String>) -> Option<String> {
+fn hover_text(
-    match (desc, docs) {
+    docs: Option<String>,
-        (Some(desc), docs) => Some(rust_code_markup_with_doc(desc, docs)),
+    desc: Option<String>,
-        (None, Some(docs)) => Some(docs),
+    mod_path: Option<String>,
+) -> Option<String> {
+    match (desc, docs, mod_path) {
+        (Some(desc), docs, mod_path) => Some(rust_code_markup_with_doc(desc, docs, mod_path)),
+        (None, Some(docs), _) => Some(docs),
+        _ => None,
+    }
+}
+fn definition_owner_name(db: &RootDatabase, def: &Definition) -> Option<String> {
+    match def {
+        Definition::StructField(f) => Some(f.parent_def(db).name(db)),
+        Definition::Local(l) => l.parent(db).name(db),
+        Definition::ModuleDef(md) => match md {
+            ModuleDef::Function(f) => match f.as_assoc_item(db)?.container(db) {
+                AssocItemContainer::Trait(t) => Some(t.name(db)),
+                AssocItemContainer::ImplDef(i) => i.target_ty(db).as_adt().map(|adt| adt.name(db)),
+            },
+            ModuleDef::EnumVariant(e) => Some(e.parent_enum(db).name(db)),
+            _ => None,
+        },
+        Definition::SelfType(i) => i.target_ty(db).as_adt().map(|adt| adt.name(db)),
        _ => None,
    }
+    .map(|name| name.to_string())
+}
+fn determine_mod_path(db: &RootDatabase, def: &Definition) -> Option<String> {
+    let mod_path = def.module(db).map(|module| {
+        once(db.crate_graph()[module.krate().into()].display_name.clone())
+            .chain(
+                module
+                    .path_to_root(db)
+                    .into_iter()
+                    .rev()
+                    .map(|it| it.name(db).map(|name| name.to_string())),
+            )
+            .chain(once(definition_owner_name(db, def)))
+            .flatten()
+            .join("::")
+    });
+    mod_path
 }
 fn hover_text_from_name_kind(db: &RootDatabase, def: Definition) -> Option<String> {
+    let mod_path = determine_mod_path(db, &def);
    return match def {
        Definition::Macro(it) => {
            let src = it.source(db);
-            hover_text(src.value.doc_comment_text(), Some(macro_label(&src.value)))
+            hover_text(src.value.doc_comment_text(), Some(macro_label(&src.value)), mod_path)
        }
        Definition::StructField(it) => {
            let src = it.source(db);
            match src.value {
-                hir::FieldSource::Named(it) => hover_text(it.doc_comment_text(), it.short_label()),
+                FieldSource::Named(it) => {
+                    hover_text(it.doc_comment_text(), it.short_label(), mod_path)
+                }
                _ => None,
            }
        }
        Definition::ModuleDef(it) => match it {
-            hir::ModuleDef::Module(it) => match it.definition_source(db).value {
+            ModuleDef::Module(it) => match it.definition_source(db).value {
-                hir::ModuleSource::Module(it) => {
+                ModuleSource::Module(it) => {
-                    hover_text(it.doc_comment_text(), it.short_label())
+                    hover_text(it.doc_comment_text(), it.short_label(), mod_path)
                }
                _ => None,
            },
-            hir::ModuleDef::Function(it) => from_def_source(db, it),
+            ModuleDef::Function(it) => from_def_source(db, it, mod_path),
-            hir::ModuleDef::Adt(Adt::Struct(it)) => from_def_source(db, it),
+            ModuleDef::Adt(Adt::Struct(it)) => from_def_source(db, it, mod_path),
-            hir::ModuleDef::Adt(Adt::Union(it)) => from_def_source(db, it),
+            ModuleDef::Adt(Adt::Union(it)) => from_def_source(db, it, mod_path),
-            hir::ModuleDef::Adt(Adt::Enum(it)) => from_def_source(db, it),
+            ModuleDef::Adt(Adt::Enum(it)) => from_def_source(db, it, mod_path),
-            hir::ModuleDef::EnumVariant(it) => from_def_source(db, it),
+            ModuleDef::EnumVariant(it) => from_def_source(db, it, mod_path),
-            hir::ModuleDef::Const(it) => from_def_source(db, it),
+            ModuleDef::Const(it) => from_def_source(db, it, mod_path),
-            hir::ModuleDef::Static(it) => from_def_source(db, it),
+            ModuleDef::Static(it) => from_def_source(db, it, mod_path),
-            hir::ModuleDef::Trait(it) => from_def_source(db, it),
+            ModuleDef::Trait(it) => from_def_source(db, it, mod_path),
-            hir::ModuleDef::TypeAlias(it) => from_def_source(db, it),
+            ModuleDef::TypeAlias(it) => from_def_source(db, it, mod_path),
-            hir::ModuleDef::BuiltinType(it) => Some(it.to_string()),
+            ModuleDef::BuiltinType(it) => Some(it.to_string()),
        },
        Definition::Local(it) => {
            Some(rust_code_markup(it.ty(db).display_truncated(db, None).to_string()))
@@ -131,13 +179,13 @@ fn hover_text_from_name_kind(db: &RootDatabase, def: Definition) -> Option<Strin
        }
    };
-    fn from_def_source<A, D>(db: &RootDatabase, def: D) -> Option<String>
+    fn from_def_source<A, D>(db: &RootDatabase, def: D, mod_path: Option<String>) -> Option<String>
    where
        D: HasSource<Ast = A>,
        A: ast::DocCommentsOwner + ast::NameOwner + ShortLabel,
    {
        let src = def.source(db);
-        hover_text(src.value.doc_comment_text(), src.value.short_label())
+        hover_text(src.value.doc_comment_text(), src.value.short_label(), mod_path)
    }
 }
@@ -345,7 +393,7 @@ mod tests {
                };
            }
        "#,
-            &["field_a: u32"],
+            &["Foo\nfield_a: u32"],
        );
        // Hovering over the field in the definition
@@ -362,7 +410,7 @@ mod tests {
                };
            }
        "#,
-            &["field_a: u32"],
+            &["Foo\nfield_a: u32"],
        );
    }
@@ -415,7 +463,7 @@ fn main() {
            ",
        );
        let hover = analysis.hover(position).unwrap().unwrap();
-        assert_eq!(trim_markup_opt(hover.info.first()), Some("Some"));
+        assert_eq!(trim_markup_opt(hover.info.first()), Some("Option\nSome"));
        let (analysis, position) = single_file_with_position(
            "
@@ -442,6 +490,7 @@ fn main() {
            }
        "#,
            &["
+Option
 None
 ```
@@ -462,6 +511,7 @@ The None variant
            }
        "#,
            &["
+Option
 Some
 ```
@@ -528,21 +578,23 @@ fn func(foo: i32) { if true { <|>foo; }; }
    fn test_hover_infer_associated_method_exact() {
        let (analysis, position) = single_file_with_position(
            "
-            struct Thing { x: u32 }
+            mod wrapper {
+                struct Thing { x: u32 }
-            impl Thing {
+                impl Thing {
-                fn new() -> Thing {
+                    fn new() -> Thing {
-                    Thing { x: 0 }
+                        Thing { x: 0 }
+                    }
                }
            }
            fn main() {
-                let foo_test = Thing::new<|>();
+                let foo_test = wrapper::Thing::new<|>();
            }
            ",
        );
        let hover = analysis.hover(position).unwrap().unwrap();
-        assert_eq!(trim_markup_opt(hover.info.first()), Some("fn new() -> Thing"));
+        assert_eq!(trim_markup_opt(hover.info.first()), Some("wrapper::Thing\nfn new() -> Thing"));
        assert_eq!(hover.info.is_exact(), true);
    }
diff --git a/crates/ra_ide/src/inlay_hints.rs b/crates/ra_ide/src/inlay_hints.rs
index 69098a630..cf0cbdbd0 100644
--- a/crates/ra_ide/src/inlay_hints.rs
+++ b/crates/ra_ide/src/inlay_hints.rs
@@ -119,6 +119,12 @@ fn should_not_display_type_hint(db: &RootDatabase, bind_pat: &ast::BindPat, pat_
        return true;
    }
+    if let Some(Adt::Struct(s)) = pat_ty.as_adt() {
+        if s.fields(db).is_empty() && s.name(db).to_string() == bind_pat.syntax().to_string() {
+            return true;
+        }
+    }
    for node in bind_pat.syntax().ancestors() {
        match_ast! {
            match node {
@@ -943,4 +949,30 @@ fn main() {
        "###
        );
    }
+    #[test]
+    fn unit_structs_have_no_type_hints() {
+        let (analysis, file_id) = single_file(
+            r#"
+enum CustomResult<T, E> {
+    Ok(T),
+    Err(E),
+}
+use CustomResult::*;
+struct SyntheticSyntax;
+fn main() {
+    match Ok(()) {
+        Ok(_) => (),
+        Err(SyntheticSyntax) => (),
+    }
+}"#,
+        );
+        assert_debug_snapshot!(analysis.inlay_hints(file_id, Some(8)).unwrap(), @r###"
+        []
+        "###
+        );
+    }
 }
diff --git a/crates/ra_ide/src/lib.rs b/crates/ra_ide/src/lib.rs
index 4dfe0553e..015fae195 100644
--- a/crates/ra_ide/src/lib.rs
+++ b/crates/ra_ide/src/lib.rs
@@ -62,7 +62,7 @@ use crate::display::ToNav;
 pub use crate::{
    assists::{Assist, AssistId},
    call_hierarchy::CallItem,
-    completion::{CompletionItem, CompletionItemKind, InsertTextFormat},
+    completion::{CompletionItem, CompletionItemKind, CompletionOptions, InsertTextFormat},
    diagnostics::Severity,
    display::{file_structure, FunctionSignature, NavigationTarget, StructureNode},
    expand_macro::ExpandedMacro,
@@ -84,7 +84,6 @@ pub use ra_db::{
 };
 pub use ra_ide_db::{
    change::{AnalysisChange, LibraryData},
-    feature_flags::FeatureFlags,
    line_index::{LineCol, LineIndex},
    line_index_utils::translate_offset_with_edit,
    search::SearchScope,
@@ -131,13 +130,13 @@ pub struct AnalysisHost {
 impl Default for AnalysisHost {
    fn default() -> AnalysisHost {
-        AnalysisHost::new(None, FeatureFlags::default())
+        AnalysisHost::new(None)
    }
 }
 impl AnalysisHost {
-    pub fn new(lru_capcity: Option<usize>, feature_flags: FeatureFlags) -> AnalysisHost {
+    pub fn new(lru_capacity: Option<usize>) -> AnalysisHost {
-        AnalysisHost { db: RootDatabase::new(lru_capcity, feature_flags) }
+        AnalysisHost { db: RootDatabase::new(lru_capacity) }
    }
    /// Returns a snapshot of the current state, which you can query for
    /// semantic information.
@@ -145,10 +144,6 @@ impl AnalysisHost {
        Analysis { db: self.db.snapshot() }
    }
-    pub fn feature_flags(&self) -> &FeatureFlags {
-        &self.db.feature_flags
-    }
    /// Applies changes to the current state of the world. If there are
    /// outstanding snapshots, they will be canceled.
    pub fn apply_change(&mut self, change: AnalysisChange) {
@@ -211,18 +206,20 @@ impl Analysis {
        // Default to enable test for single file.
        let mut cfg_options = CfgOptions::default();
        cfg_options.insert_atom("test".into());
-        crate_graph.add_crate_root(file_id, Edition::Edition2018, cfg_options, Env::default());
+        crate_graph.add_crate_root(
+            file_id,
+            Edition::Edition2018,
+            None,
+            cfg_options,
+            Env::default(),
+            Default::default(),
+        );
        change.add_file(source_root, file_id, "main.rs".into(), Arc::new(text));
        change.set_crate_graph(crate_graph);
        host.apply_change(change);
        (host.analysis(), file_id)
    }
-    /// Features for Analysis.
-    pub fn feature_flags(&self) -> &FeatureFlags {
-        &self.db.feature_flags
-    }
    /// Debug info about the current state of the analysis.
    pub fn status(&self) -> Cancelable<String> {
        self.with_db(|db| status::status(&*db))
@@ -415,12 +412,12 @@ impl Analysis {
    /// Returns the edition of the given crate.
    pub fn crate_edition(&self, crate_id: CrateId) -> Cancelable<Edition> {
-        self.with_db(|db| db.crate_graph().edition(crate_id))
+        self.with_db(|db| db.crate_graph()[crate_id].edition)
    }
    /// Returns the root file of the given crate.
    pub fn crate_root(&self, crate_id: CrateId) -> Cancelable<FileId> {
-        self.with_db(|db| db.crate_graph().crate_root(crate_id))
+        self.with_db(|db| db.crate_graph()[crate_id].root_file_id)
    }
    /// Returns the set of possible targets to run for the current file.
@@ -444,8 +441,12 @@ impl Analysis {
    }
    /// Computes completions at the given position.
-    pub fn completions(&self, position: FilePosition) -> Cancelable<Option<Vec<CompletionItem>>> {
+    pub fn completions(
-        self.with_db(|db| completion::completions(db, position).map(Into::into))
+        &self,
+        position: FilePosition,
+        options: &CompletionOptions,
+    ) -> Cancelable<Option<Vec<CompletionItem>>> {
+        self.with_db(|db| completion::completions(db, position, options).map(Into::into))
    }
    /// Computes assists (aka code actions aka intentions) for the given
diff --git a/crates/ra_ide/src/mock_analysis.rs b/crates/ra_ide/src/mock_analysis.rs
index f4cd6deb7..25816cf6f 100644
--- a/crates/ra_ide/src/mock_analysis.rs
+++ b/crates/ra_ide/src/mock_analysis.rs
@@ -99,13 +99,21 @@ impl MockAnalysis {
                root_crate = Some(crate_graph.add_crate_root(
                    file_id,
                    Edition2018,
+                    None,
                    cfg_options,
                    Env::default(),
+                    Default::default(),
                ));
            } else if path.ends_with("/lib.rs") {
-                let other_crate =
-                    crate_graph.add_crate_root(file_id, Edition2018, cfg_options, Env::default());
                let crate_name = path.parent().unwrap().file_name().unwrap();
+                let other_crate = crate_graph.add_crate_root(
+                    file_id,
+                    Edition2018,
+                    Some(crate_name.to_owned()),
+                    cfg_options,
+                    Env::default(),
+                    Default::default(),
+                );
                if let Some(root_crate) = root_crate {
                    crate_graph
                        .add_dep(root_crate, CrateName::new(crate_name).unwrap(), other_crate)
diff --git a/crates/ra_ide/src/parent_module.rs b/crates/ra_ide/src/parent_module.rs
index 2c4bdb039..76d130b9b 100644
--- a/crates/ra_ide/src/parent_module.rs
+++ b/crates/ra_ide/src/parent_module.rs
@@ -133,8 +133,10 @@ mod tests {
        let crate_id = crate_graph.add_crate_root(
            root_file,
            Edition2018,
+            None,
            CfgOptions::default(),
            Env::default(),
+            Default::default(),
        );
        let mut change = AnalysisChange::new();
        change.set_crate_graph(crate_graph);
diff --git a/crates/ra_ide/src/references/rename.rs b/crates/ra_ide/src/references/rename.rs
index 5b4bcf434..7d1190af9 100644
--- a/crates/ra_ide/src/references/rename.rs
+++ b/crates/ra_ide/src/references/rename.rs
@@ -9,7 +9,8 @@ use ra_syntax::{
 use ra_text_edit::TextEdit;
 use crate::{
-    FileId, FilePosition, FileSystemEdit, RangeInfo, SourceChange, SourceFileEdit, TextRange,
+    FilePosition, FileSystemEdit, RangeInfo, Reference, ReferenceKind, SourceChange,
+    SourceFileEdit, TextRange,
 };
 use super::find_all_refs;
@@ -46,12 +47,29 @@ fn find_name_and_module_at_offset(
    Some((ast_name, ast_module))
 }
-fn source_edit_from_file_id_range(
+fn source_edit_from_reference(reference: Reference, new_name: &str) -> SourceFileEdit {
-    file_id: FileId,
+    let mut replacement_text = String::new();
-    range: TextRange,
+    let file_id = reference.file_range.file_id;
-    new_name: &str,
+    let range = match reference.kind {
-) -> SourceFileEdit {
+        ReferenceKind::StructFieldShorthandForField => {
-    SourceFileEdit { file_id, edit: TextEdit::replace(range, new_name.into()) }
+            replacement_text.push_str(new_name);
+            replacement_text.push_str(": ");
+            TextRange::from_to(
+                reference.file_range.range.start(),
+                reference.file_range.range.start(),
+            )
+        }
+        ReferenceKind::StructFieldShorthandForLocal => {
+            replacement_text.push_str(": ");
+            replacement_text.push_str(new_name);
+            TextRange::from_to(reference.file_range.range.end(), reference.file_range.range.end())
+        }
+        _ => {
+            replacement_text.push_str(new_name);
+            reference.file_range.range
+        }
+    };
+    SourceFileEdit { file_id, edit: TextEdit::replace(range, replacement_text) }
 }
 fn rename_mod(
@@ -99,13 +117,10 @@ fn rename_mod(
    source_file_edits.push(edit);
    if let Some(RangeInfo { range: _, info: refs }) = find_all_refs(sema.db, position, None) {
-        let ref_edits = refs.references.into_iter().map(|reference| {
+        let ref_edits = refs
-            source_edit_from_file_id_range(
+            .references
-                reference.file_range.file_id,
+            .into_iter()
-                reference.file_range.range,
+            .map(|reference| source_edit_from_reference(reference, new_name));
-                new_name,
-            )
-        });
        source_file_edits.extend(ref_edits);
    }
@@ -121,13 +136,7 @@ fn rename_reference(
    let edit = refs
        .into_iter()
-        .map(|reference| {
+        .map(|reference| source_edit_from_reference(reference, new_name))
-            source_edit_from_file_id_range(
-                reference.file_range.file_id,
-                reference.file_range.range,
-                new_name,
-            )
-        })
        .collect::<Vec<_>>();
    if edit.is_empty() {
@@ -286,6 +295,163 @@ mod tests {
    }
    #[test]
+    fn test_rename_struct_field() {
+        test_rename(
+            r#"
+    struct Foo {
+        i<|>: i32,
+    }
+    impl Foo {
+        fn new(i: i32) -> Self {
+            Self { i: i }
+        }
+    }
+    "#,
+            "j",
+            r#"
+    struct Foo {
+        j: i32,
+    }
+    impl Foo {
+        fn new(i: i32) -> Self {
+            Self { j: i }
+        }
+    }
+    "#,
+        );
+    }
+    #[test]
+    fn test_rename_struct_field_for_shorthand() {
+        test_rename(
+            r#"
+    struct Foo {
+        i<|>: i32,
+    }
+    impl Foo {
+        fn new(i: i32) -> Self {
+            Self { i }
+        }
+    }
+    "#,
+            "j",
+            r#"
+    struct Foo {
+        j: i32,
+    }
+    impl Foo {
+        fn new(i: i32) -> Self {
+            Self { j: i }
+        }
+    }
+    "#,
+        );
+    }
+    #[test]
+    fn test_rename_local_for_field_shorthand() {
+        test_rename(
+            r#"
+    struct Foo {
+        i: i32,
+    }
+    impl Foo {
+        fn new(i<|>: i32) -> Self {
+            Self { i }
+        }
+    }
+    "#,
+            "j",
+            r#"
+    struct Foo {
+        i: i32,
+    }
+    impl Foo {
+        fn new(j: i32) -> Self {
+            Self { i: j }
+        }
+    }
+    "#,
+        );
+    }
+    #[test]
+    fn test_field_shorthand_correct_struct() {
+        test_rename(
+            r#"
+    struct Foo {
+        i<|>: i32,
+    }
+    struct Bar {
+        i: i32,
+    }
+    impl Bar {
+        fn new(i: i32) -> Self {
+            Self { i }
+        }
+    }
+    "#,
+            "j",
+            r#"
+    struct Foo {
+        j: i32,
+    }
+    struct Bar {
+        i: i32,
+    }
+    impl Bar {
+        fn new(i: i32) -> Self {
+            Self { i }
+        }
+    }
+    "#,
+        );
+    }
+    #[test]
+    fn test_shadow_local_for_struct_shorthand() {
+        test_rename(
+            r#"
+    struct Foo {
+        i: i32,
+    }
+    fn baz(i<|>: i32) -> Self {
+         let x = Foo { i };
+         {
+             let i = 0;
+             Foo { i }
+         }
+     }
+    "#,
+            "j",
+            r#"
+    struct Foo {
+        i: i32,
+    }
+    fn baz(j: i32) -> Self {
+         let x = Foo { i: j };
+         {
+             let i = 0;
+             Foo { i }
+         }
+     }
+    "#,
+        );
+    }
+    #[test]
    fn test_rename_mod() {
        let (analysis, position) = analysis_and_position(
            "
diff --git a/crates/ra_ide/src/typing.rs b/crates/ra_ide/src/typing.rs
index 7f1b9150f..53c65f8bc 100644
--- a/crates/ra_ide/src/typing.rs
+++ b/crates/ra_ide/src/typing.rs
@@ -13,77 +13,21 @@
 //! Language server executes such typing assists synchronously. That is, they
 //! block user's typing and should be pretty fast for this reason!
+mod on_enter;
 use ra_db::{FilePosition, SourceDatabase};
 use ra_fmt::leading_indent;
 use ra_ide_db::RootDatabase;
 use ra_syntax::{
    algo::find_node_at_offset,
    ast::{self, AstToken},
-    AstNode, SmolStr, SourceFile,
+    AstNode, SourceFile, TextRange, TextUnit,
-    SyntaxKind::*,
-    SyntaxToken, TextRange, TextUnit, TokenAtOffset,
 };
 use ra_text_edit::TextEdit;
-use crate::{source_change::SingleFileChange, SourceChange, SourceFileEdit};
+use crate::{source_change::SingleFileChange, SourceChange};
-pub(crate) fn on_enter(db: &RootDatabase, position: FilePosition) -> Option<SourceChange> {
-    let parse = db.parse(position.file_id);
-    let file = parse.tree();
-    let comment = file
-        .syntax()
-        .token_at_offset(position.offset)
-        .left_biased()
-        .and_then(ast::Comment::cast)?;
-    if comment.kind().shape.is_block() {
-        return None;
-    }
-    let prefix = comment.prefix();
-    let comment_range = comment.syntax().text_range();
-    if position.offset < comment_range.start() + TextUnit::of_str(prefix) {
-        return None;
-    }
-    // Continuing non-doc line comments (like this one :) ) is annoying
-    if prefix == "//" && comment_range.end() == position.offset {
-        return None;
-    }
-    let indent = node_indent(&file, comment.syntax())?;
-    let inserted = format!("\n{}{} ", indent, prefix);
-    let cursor_position = position.offset + TextUnit::of_str(&inserted);
-    let edit = TextEdit::insert(position.offset, inserted);
-    Some(
+pub(crate) use on_enter::on_enter;
-        SourceChange::source_file_edit(
-            "on enter",
-            SourceFileEdit { edit, file_id: position.file_id },
-        )
-        .with_cursor(FilePosition { offset: cursor_position, file_id: position.file_id }),
-    )
-}
-fn node_indent(file: &SourceFile, token: &SyntaxToken) -> Option<SmolStr> {
-    let ws = match file.syntax().token_at_offset(token.text_range().start()) {
-        TokenAtOffset::Between(l, r) => {
-            assert!(r == *token);
-            l
-        }
-        TokenAtOffset::Single(n) => {
-            assert!(n == *token);
-            return Some("".into());
-        }
-        TokenAtOffset::None => unreachable!(),
-    };
-    if ws.kind() != WHITESPACE {
-        return None;
-    }
-    let text = ws.text();
-    let pos = text.rfind('\n').map(|it| it + 1).unwrap_or(0);
-    Some(text[pos..].into())
-}
 pub(crate) const TRIGGER_CHARS: &str = ".=>";
@@ -196,102 +140,10 @@ fn on_arrow_typed(file: &SourceFile, offset: TextUnit) -> Option<SingleFileChang
 #[cfg(test)]
 mod tests {
-    use test_utils::{add_cursor, assert_eq_text, extract_offset};
+    use test_utils::{assert_eq_text, extract_offset};
-    use crate::mock_analysis::single_file;
    use super::*;
-    #[test]
-    fn test_on_enter() {
-        fn apply_on_enter(before: &str) -> Option<String> {
-            let (offset, before) = extract_offset(before);
-            let (analysis, file_id) = single_file(&before);
-            let result = analysis.on_enter(FilePosition { offset, file_id }).unwrap()?;
-            assert_eq!(result.source_file_edits.len(), 1);
-            let actual = result.source_file_edits[0].edit.apply(&before);
-            let actual = add_cursor(&actual, result.cursor_position.unwrap().offset);
-            Some(actual)
-        }
-        fn do_check(before: &str, after: &str) {
-            let actual = apply_on_enter(before).unwrap();
-            assert_eq_text!(after, &actual);
-        }
-        fn do_check_noop(text: &str) {
-            assert!(apply_on_enter(text).is_none())
-        }
-        do_check(
-            r"
-/// Some docs<|>
-fn foo() {
-}
-",
-            r"
-/// Some docs
-/// <|>
-fn foo() {
-}
-",
-        );
-        do_check(
-            r"
-impl S {
-    /// Some<|> docs.
-    fn foo() {}
-}
-",
-            r"
-impl S {
-    /// Some
-    /// <|> docs.
-    fn foo() {}
-}
-",
-        );
-        do_check(
-            r"
-fn main() {
-    // Fix<|> me
-    let x = 1 + 1;
-}
-",
-            r"
-fn main() {
-    // Fix
-    // <|> me
-    let x = 1 + 1;
-}
-",
-        );
-        do_check(
-            r"
-///<|> Some docs
-fn foo() {
-}
-",
-            r"
-///
-/// <|> Some docs
-fn foo() {
-}
-",
-        );
-        do_check_noop(
-            r"
-fn main() {
-    // Fix me<|>
-    let x = 1 + 1;
-}
-",
-        );
-        do_check_noop(r"<|>//! docz");
-    }
    fn do_type_char(char_typed: char, before: &str) -> Option<(String, SingleFileChange)> {
        let (offset, before) = extract_offset(before);
        let edit = TextEdit::insert(offset, char_typed.to_string());
diff --git a/crates/ra_ide/src/typing/on_enter.rs b/crates/ra_ide/src/typing/on_enter.rs
new file mode 100644
index 000000000..6bcf2d72b
--- /dev/null
+++ b/crates/ra_ide/src/typing/on_enter.rs
@@ -0,0 +1,216 @@
+//! Handles the `Enter` key press. At the momently, this only continues
+//! comments, but should handle indent some time in the future as well.
+use ra_db::{FilePosition, SourceDatabase};
+use ra_ide_db::RootDatabase;
+use ra_syntax::{
+    ast::{self, AstToken},
+    AstNode, SmolStr, SourceFile,
+    SyntaxKind::*,
+    SyntaxToken, TextUnit, TokenAtOffset,
+};
+use ra_text_edit::TextEdit;
+use crate::{SourceChange, SourceFileEdit};
+pub(crate) fn on_enter(db: &RootDatabase, position: FilePosition) -> Option<SourceChange> {
+    let parse = db.parse(position.file_id);
+    let file = parse.tree();
+    let comment = file
+        .syntax()
+        .token_at_offset(position.offset)
+        .left_biased()
+        .and_then(ast::Comment::cast)?;
+    if comment.kind().shape.is_block() {
+        return None;
+    }
+    let prefix = comment.prefix();
+    let comment_range = comment.syntax().text_range();
+    if position.offset < comment_range.start() + TextUnit::of_str(prefix) {
+        return None;
+    }
+    // Continuing single-line non-doc comments (like this one :) ) is annoying
+    if prefix == "//" && comment_range.end() == position.offset && !followed_by_comment(&comment) {
+        return None;
+    }
+    let indent = node_indent(&file, comment.syntax())?;
+    let inserted = format!("\n{}{} ", indent, prefix);
+    let cursor_position = position.offset + TextUnit::of_str(&inserted);
+    let edit = TextEdit::insert(position.offset, inserted);
+    Some(
+        SourceChange::source_file_edit(
+            "on enter",
+            SourceFileEdit { edit, file_id: position.file_id },
+        )
+        .with_cursor(FilePosition { offset: cursor_position, file_id: position.file_id }),
+    )
+}
+fn followed_by_comment(comment: &ast::Comment) -> bool {
+    let ws = match comment.syntax().next_token().and_then(ast::Whitespace::cast) {
+        Some(it) => it,
+        None => return false,
+    };
+    if ws.spans_multiple_lines() {
+        return false;
+    }
+    ws.syntax().next_token().and_then(ast::Comment::cast).is_some()
+}
+fn node_indent(file: &SourceFile, token: &SyntaxToken) -> Option<SmolStr> {
+    let ws = match file.syntax().token_at_offset(token.text_range().start()) {
+        TokenAtOffset::Between(l, r) => {
+            assert!(r == *token);
+            l
+        }
+        TokenAtOffset::Single(n) => {
+            assert!(n == *token);
+            return Some("".into());
+        }
+        TokenAtOffset::None => unreachable!(),
+    };
+    if ws.kind() != WHITESPACE {
+        return None;
+    }
+    let text = ws.text();
+    let pos = text.rfind('\n').map(|it| it + 1).unwrap_or(0);
+    Some(text[pos..].into())
+}
+#[cfg(test)]
+mod tests {
+    use test_utils::{add_cursor, assert_eq_text, extract_offset};
+    use crate::mock_analysis::single_file;
+    use super::*;
+    fn apply_on_enter(before: &str) -> Option<String> {
+        let (offset, before) = extract_offset(before);
+        let (analysis, file_id) = single_file(&before);
+        let result = analysis.on_enter(FilePosition { offset, file_id }).unwrap()?;
+        assert_eq!(result.source_file_edits.len(), 1);
+        let actual = result.source_file_edits[0].edit.apply(&before);
+        let actual = add_cursor(&actual, result.cursor_position.unwrap().offset);
+        Some(actual)
+    }
+    fn do_check(ra_fixture_before: &str, ra_fixture_after: &str) {
+        let actual = apply_on_enter(ra_fixture_before).unwrap();
+        assert_eq_text!(ra_fixture_after, &actual);
+    }
+    fn do_check_noop(ra_fixture_text: &str) {
+        assert!(apply_on_enter(ra_fixture_text).is_none())
+    }
+    #[test]
+    fn continues_doc_comment() {
+        do_check(
+            r"
+/// Some docs<|>
+fn foo() {
+}
+",
+            r"
+/// Some docs
+/// <|>
+fn foo() {
+}
+",
+        );
+        do_check(
+            r"
+impl S {
+    /// Some<|> docs.
+    fn foo() {}
+}
+",
+            r"
+impl S {
+    /// Some
+    /// <|> docs.
+    fn foo() {}
+}
+",
+        );
+        do_check(
+            r"
+///<|> Some docs
+fn foo() {
+}
+",
+            r"
+///
+/// <|> Some docs
+fn foo() {
+}
+",
+        );
+    }
+    #[test]
+    fn does_not_continue_before_doc_comment() {
+        do_check_noop(r"<|>//! docz");
+    }
+    #[test]
+    fn continues_code_comment_in_the_middle_of_line() {
+        do_check(
+            r"
+fn main() {
+    // Fix<|> me
+    let x = 1 + 1;
+}
+",
+            r"
+fn main() {
+    // Fix
+    // <|> me
+    let x = 1 + 1;
+}
+",
+        );
+    }
+    #[test]
+    fn continues_code_comment_in_the_middle_several_lines() {
+        do_check(
+            r"
+fn main() {
+    // Fix<|>
+    // me
+    let x = 1 + 1;
+}
+",
+            r"
+fn main() {
+    // Fix
+    // <|>
+    // me
+    let x = 1 + 1;
+}
+",
+        );
+    }
+    #[test]
+    fn does_not_continue_end_of_code_comment() {
+        do_check_noop(
+            r"
+fn main() {
+    // Fix me<|>
+    let x = 1 + 1;
+}
+",
+        );
+    }
+}
diff --git a/crates/ra_ide_db/Cargo.toml b/crates/ra_ide_db/Cargo.toml
index 52f0f23df..de4f5bce0 100644
--- a/crates/ra_ide_db/Cargo.toml
+++ b/crates/ra_ide_db/Cargo.toml
@@ -13,7 +13,7 @@ wasm = []
 [dependencies]
 log = "0.4.8"
 rayon = "1.3.0"
-fst = { version = "0.3.5", default-features = false }
+fst = { version = "0.4", default-features = false }
 rustc-hash = "1.1.0"
 superslice = "1.0.0"
 once_cell = "1.3.1"
diff --git a/crates/ra_ide_db/src/change.rs b/crates/ra_ide_db/src/change.rs
index 7e9310005..628cf6416 100644
--- a/crates/ra_ide_db/src/change.rs
+++ b/crates/ra_ide_db/src/change.rs
@@ -5,7 +5,7 @@ use std::{fmt, sync::Arc, time};
 use ra_db::{
    salsa::{Database, Durability, SweepStrategy},
-    CrateGraph, CrateId, FileId, RelativePathBuf, SourceDatabase, SourceDatabaseExt, SourceRoot,
+    CrateGraph, FileId, RelativePathBuf, SourceDatabase, SourceDatabaseExt, SourceRoot,
    SourceRootId,
 };
 use ra_prof::{memory_usage, profile, Bytes};
@@ -88,10 +88,6 @@ impl AnalysisChange {
        self.crate_graph = Some(graph);
    }
-    pub fn set_debug_crate_name(&mut self, crate_id: CrateId, name: String) {
-        self.debug_data.crate_names.insert(crate_id, name);
-    }
    pub fn set_debug_root_path(&mut self, source_root_id: SourceRootId, path: String) {
        self.debug_data.root_paths.insert(source_root_id, path);
    }
@@ -279,7 +275,7 @@ impl RootDatabase {
        self.query(hir::db::BodyWithSourceMapQuery).sweep(sweep);
        self.query(hir::db::ExprScopesQuery).sweep(sweep);
-        self.query(hir::db::DoInferQuery).sweep(sweep);
+        self.query(hir::db::InferQueryQuery).sweep(sweep);
        self.query(hir::db::BodyQuery).sweep(sweep);
    }
@@ -318,7 +314,7 @@ impl RootDatabase {
            // DefDatabase
            hir::db::RawItemsQuery
-            hir::db::ComputeCrateDefMapQuery
+            hir::db::CrateDefMapQueryQuery
            hir::db::StructDataQuery
            hir::db::UnionDataQuery
            hir::db::EnumDataQuery
@@ -350,7 +346,7 @@ impl RootDatabase {
            hir::db::InternImplQuery
            // HirDatabase
-            hir::db::DoInferQuery
+            hir::db::InferQueryQuery
            hir::db::TyQuery
            hir::db::ValueTyQuery
            hir::db::ImplSelfTyQuery
@@ -362,7 +358,6 @@ impl RootDatabase {
            hir::db::GenericDefaultsQuery
            hir::db::ImplsInCrateQuery
            hir::db::ImplsForTraitQuery
-            hir::db::TraitSolverQuery
            hir::db::InternTypeCtorQuery
            hir::db::InternChalkImplQuery
            hir::db::InternAssocTyValueQuery
diff --git a/crates/ra_ide_db/src/lib.rs b/crates/ra_ide_db/src/lib.rs
index 79f48c9e3..fc1b19def 100644
--- a/crates/ra_ide_db/src/lib.rs
+++ b/crates/ra_ide_db/src/lib.rs
@@ -5,7 +5,6 @@
 pub mod marks;
 pub mod line_index;
 pub mod line_index_utils;
-pub mod feature_flags;
 pub mod symbol_index;
 pub mod change;
 pub mod defs;
@@ -22,7 +21,7 @@ use ra_db::{
 };
 use rustc_hash::FxHashMap;
-use crate::{feature_flags::FeatureFlags, line_index::LineIndex, symbol_index::SymbolsDatabase};
+use crate::{line_index::LineIndex, symbol_index::SymbolsDatabase};
 #[salsa::database(
    ra_db::SourceDatabaseStorage,
@@ -37,7 +36,6 @@ use crate::{feature_flags::FeatureFlags, line_index::LineIndex, symbol_index::Sy
 #[derive(Debug)]
 pub struct RootDatabase {
    runtime: salsa::Runtime<RootDatabase>,
-    pub feature_flags: Arc<FeatureFlags>,
    pub(crate) debug_data: Arc<DebugData>,
    pub last_gc: crate::wasm_shims::Instant,
    pub last_gc_check: crate::wasm_shims::Instant,
@@ -57,6 +55,13 @@ impl FileLoader for RootDatabase {
    fn relevant_crates(&self, file_id: FileId) -> Arc<Vec<CrateId>> {
        FileLoaderDelegate(self).relevant_crates(file_id)
    }
+    fn resolve_extern_path(
+        &self,
+        extern_id: ra_db::ExternSourceId,
+        relative_path: &RelativePath,
+    ) -> Option<FileId> {
+        FileLoaderDelegate(self).resolve_extern_path(extern_id, relative_path)
+    }
 }
 impl salsa::Database for RootDatabase {
@@ -82,17 +87,16 @@ impl salsa::Database for RootDatabase {
 impl Default for RootDatabase {
    fn default() -> RootDatabase {
-        RootDatabase::new(None, FeatureFlags::default())
+        RootDatabase::new(None)
    }
 }
 impl RootDatabase {
-    pub fn new(lru_capacity: Option<usize>, feature_flags: FeatureFlags) -> RootDatabase {
+    pub fn new(lru_capacity: Option<usize>) -> RootDatabase {
        let mut db = RootDatabase {
            runtime: salsa::Runtime::default(),
            last_gc: crate::wasm_shims::Instant::now(),
            last_gc_check: crate::wasm_shims::Instant::now(),
-            feature_flags: Arc::new(feature_flags),
            debug_data: Default::default(),
        };
        db.set_crate_graph_with_durability(Default::default(), Durability::HIGH);
@@ -112,7 +116,6 @@ impl salsa::ParallelDatabase for RootDatabase {
            runtime: self.runtime.snapshot(self),
            last_gc: self.last_gc,
            last_gc_check: self.last_gc_check,
-            feature_flags: Arc::clone(&self.feature_flags),
            debug_data: Arc::clone(&self.debug_data),
        })
    }
@@ -131,12 +134,10 @@ fn line_index(db: &impl LineIndexDatabase, file_id: FileId) -> Arc<LineIndex> {
 #[derive(Debug, Default, Clone)]
 pub(crate) struct DebugData {
    pub(crate) root_paths: FxHashMap<SourceRootId, String>,
-    pub(crate) crate_names: FxHashMap<CrateId, String>,
 }
 impl DebugData {
    pub(crate) fn merge(&mut self, other: DebugData) {
        self.root_paths.extend(other.root_paths.into_iter());
-        self.crate_names.extend(other.crate_names.into_iter());
    }
 }
diff --git a/crates/ra_ide_db/src/search.rs b/crates/ra_ide_db/src/search.rs
index 6f198df04..cf78d3e41 100644
--- a/crates/ra_ide_db/src/search.rs
+++ b/crates/ra_ide_db/src/search.rs
@@ -17,7 +17,7 @@ use rustc_hash::FxHashMap;
 use test_utils::tested_by;
 use crate::{
-    defs::{classify_name_ref, Definition},
+    defs::{classify_name_ref, Definition, NameRefClass},
    RootDatabase,
 };
@@ -30,6 +30,8 @@ pub struct Reference {
 #[derive(Debug, Clone, PartialEq)]
 pub enum ReferenceKind {
+    StructFieldShorthandForField,
+    StructFieldShorthandForLocal,
    StructLiteral,
    Other,
 }
@@ -237,9 +239,8 @@ impl Definition {
                // FIXME: reuse sb
                // See https://github.com/rust-lang/rust/pull/68198#issuecomment-574269098
-                if let Some(d) = classify_name_ref(&sema, &name_ref) {
+                match classify_name_ref(&sema, &name_ref) {
-                    let d = d.definition();
+                    Some(NameRefClass::Definition(def)) if &def == self => {
-                    if &d == self {
                        let kind = if is_record_lit_name_ref(&name_ref)
                            || is_call_expr_name_ref(&name_ref)
                        {
@@ -252,9 +253,26 @@ impl Definition {
                        refs.push(Reference {
                            file_range,
                            kind,
-                            access: reference_access(&d, &name_ref),
+                            access: reference_access(&def, &name_ref),
                        });
                    }
+                    Some(NameRefClass::FieldShorthand { local, field }) => {
+                        match self {
+                            Definition::StructField(_) if &field == self => refs.push(Reference {
+                                file_range: sema.original_range(name_ref.syntax()),
+                                kind: ReferenceKind::StructFieldShorthandForField,
+                                access: reference_access(&field, &name_ref),
+                            }),
+                            Definition::Local(l) if &local == l => refs.push(Reference {
+                                file_range: sema.original_range(name_ref.syntax()),
+                                kind: ReferenceKind::StructFieldShorthandForLocal,
+                                access: reference_access(&Definition::Local(local), &name_ref),
+                            }),
+                            _ => {} // not a usage
+                        };
+                    }
+                    _ => {} // not a usage
                }
            }
        }
diff --git a/crates/ra_ide_db/src/symbol_index.rs b/crates/ra_ide_db/src/symbol_index.rs
index e6b3126b6..884359ee3 100644
--- a/crates/ra_ide_db/src/symbol_index.rs
+++ b/crates/ra_ide_db/src/symbol_index.rs
@@ -163,7 +163,7 @@ pub fn index_resolve(db: &RootDatabase, name_ref: &ast::NameRef) -> Vec<FileSymb
 #[derive(Default)]
 pub struct SymbolIndex {
    symbols: Vec<FileSymbol>,
-    map: fst::Map,
+    map: fst::Map<Vec<u8>>,
 }
 impl fmt::Debug for SymbolIndex {
@@ -221,7 +221,7 @@ impl SymbolIndex {
            builder.insert(key, value).unwrap();
        }
-        let map = fst::Map::from_bytes(builder.into_inner().unwrap()).unwrap();
+        let map = fst::Map::new(builder.into_inner().unwrap()).unwrap();
        SymbolIndex { symbols, map }
    }
diff --git a/crates/ra_mbe/src/lib.rs b/crates/ra_mbe/src/lib.rs
index 2c6ae5658..43afe24cc 100644
--- a/crates/ra_mbe/src/lib.rs
+++ b/crates/ra_mbe/src/lib.rs
@@ -31,7 +31,8 @@ pub enum ExpandError {
 }
 pub use crate::syntax_bridge::{
-    ast_to_token_tree, syntax_node_to_token_tree, token_tree_to_syntax_node, TokenMap,
+    ast_to_token_tree, parse_to_token_tree, syntax_node_to_token_tree, token_tree_to_syntax_node,
+    TokenMap,
 };
 /// This struct contains AST for a single `macro_rules` definition. What might
diff --git a/crates/ra_mbe/src/mbe_expander/matcher.rs b/crates/ra_mbe/src/mbe_expander/matcher.rs
index ffba03898..49c53183a 100644
--- a/crates/ra_mbe/src/mbe_expander/matcher.rs
+++ b/crates/ra_mbe/src/mbe_expander/matcher.rs
@@ -247,6 +247,7 @@ impl<'a> TtIter<'a> {
        ra_parser::parse_fragment(&mut src, &mut sink, fragment_kind);
        if !sink.cursor.is_root() || sink.error {
+            // FIXME better recovery in this case would help completion inside macros immensely
            return Err(());
        }
@@ -375,7 +376,8 @@ fn match_meta_var(kind: &str, input: &mut TtIter) -> Result<Option<Fragment>, Ex
            return Ok(Some(Fragment::Tokens(tt)));
        }
    };
-    let tt = input.expect_fragment(fragment).map_err(|()| err!())?;
+    let tt =
+        input.expect_fragment(fragment).map_err(|()| err!("fragment did not parse as {}", kind))?;
    let fragment = if kind == "expr" { Fragment::Ast(tt) } else { Fragment::Tokens(tt) };
    Ok(Some(fragment))
 }
diff --git a/crates/ra_mbe/src/syntax_bridge.rs b/crates/ra_mbe/src/syntax_bridge.rs
index fb9fa5314..fcb73fbc7 100644
--- a/crates/ra_mbe/src/syntax_bridge.rs
+++ b/crates/ra_mbe/src/syntax_bridge.rs
@@ -2,8 +2,10 @@
 use ra_parser::{FragmentKind, ParseError, TreeSink};
 use ra_syntax::{
-    ast, AstToken, NodeOrToken, Parse, SmolStr, SyntaxKind, SyntaxKind::*, SyntaxNode,
+    ast::{self, make::tokens::doc_comment},
-    SyntaxTreeBuilder, TextRange, TextUnit, T,
+    tokenize, AstToken, NodeOrToken, Parse, SmolStr, SyntaxKind,
+    SyntaxKind::*,
+    SyntaxNode, SyntaxTreeBuilder, TextRange, TextUnit, Token, T,
 };
 use rustc_hash::FxHashMap;
 use std::iter::successors;
@@ -48,9 +50,11 @@ pub fn ast_to_token_tree(ast: &impl ast::AstNode) -> Option<(tt::Subtree, TokenM
 /// will consume).
 pub fn syntax_node_to_token_tree(node: &SyntaxNode) -> Option<(tt::Subtree, TokenMap)> {
    let global_offset = node.text_range().start();
-    let mut c = Convertor { map: TokenMap::default(), global_offset, next_id: 0 };
+    let mut c = Convertor {
+        id_alloc: { TokenIdAlloc { map: TokenMap::default(), global_offset, next_id: 0 } },
+    };
    let subtree = c.go(node)?;
-    Some((subtree, c.map))
+    Some((subtree, c.id_alloc.map))
 }
 // The following items are what `rustc` macro can be parsed into :
@@ -89,6 +93,28 @@ pub fn token_tree_to_syntax_node(
    Ok((parse, range_map))
 }
+/// Convert a string to a `TokenTree`
+pub fn parse_to_token_tree(text: &str) -> Option<(tt::Subtree, TokenMap)> {
+    let (tokens, errors) = tokenize(text);
+    if !errors.is_empty() {
+        return None;
+    }
+    let mut conv = RawConvertor {
+        text,
+        offset: TextUnit::default(),
+        inner: tokens.iter(),
+        id_alloc: TokenIdAlloc {
+            map: Default::default(),
+            global_offset: TextUnit::default(),
+            next_id: 0,
+        },
+    };
+    let subtree = conv.go()?;
+    Some((subtree, conv.id_alloc.map))
+}
 impl TokenMap {
    pub fn token_by_range(&self, relative_range: TextRange) -> Option<tt::TokenId> {
        let &(token_id, _) = self.entries.iter().find(|(_, range)| match range {
@@ -118,6 +144,14 @@ impl TokenMap {
        self.entries
            .push((token_id, TokenTextRange::Delimiter(open_relative_range, close_relative_range)));
    }
+    fn update_close_delim(&mut self, token_id: tt::TokenId, close_relative_range: TextRange) {
+        if let Some(entry) = self.entries.iter_mut().find(|(tid, _)| *tid == token_id) {
+            if let TokenTextRange::Delimiter(dim, _) = entry.1 {
+                entry.1 = TokenTextRange::Delimiter(dim, close_relative_range);
+            }
+        }
+    }
 }
 /// Returns the textual content of a doc comment block as a quoted string
@@ -188,12 +222,161 @@ fn convert_doc_comment(token: &ra_syntax::SyntaxToken) -> Option<Vec<tt::TokenTr
    }
 }
-struct Convertor {
+struct TokenIdAlloc {
    map: TokenMap,
    global_offset: TextUnit,
    next_id: u32,
 }
+impl TokenIdAlloc {
+    fn alloc(&mut self, absolute_range: TextRange) -> tt::TokenId {
+        let relative_range = absolute_range - self.global_offset;
+        let token_id = tt::TokenId(self.next_id);
+        self.next_id += 1;
+        self.map.insert(token_id, relative_range);
+        token_id
+    }
+    fn delim(&mut self, open_abs_range: TextRange, close_abs_range: TextRange) -> tt::TokenId {
+        let open_relative_range = open_abs_range - self.global_offset;
+        let close_relative_range = close_abs_range - self.global_offset;
+        let token_id = tt::TokenId(self.next_id);
+        self.next_id += 1;
+        self.map.insert_delim(token_id, open_relative_range, close_relative_range);
+        token_id
+    }
+    fn open_delim(&mut self, open_abs_range: TextRange) -> tt::TokenId {
+        let token_id = tt::TokenId(self.next_id);
+        self.next_id += 1;
+        self.map.insert_delim(token_id, open_abs_range, open_abs_range);
+        token_id
+    }
+    fn close_delim(&mut self, id: tt::TokenId, close_abs_range: TextRange) {
+        self.map.update_close_delim(id, close_abs_range);
+    }
+}
+/// A Raw Token (straightly from lexer) convertor
+struct RawConvertor<'a> {
+    text: &'a str,
+    offset: TextUnit,
+    id_alloc: TokenIdAlloc,
+    inner: std::slice::Iter<'a, Token>,
+}
+impl RawConvertor<'_> {
+    fn go(&mut self) -> Option<tt::Subtree> {
+        let mut subtree = tt::Subtree::default();
+        subtree.delimiter = None;
+        while self.peek().is_some() {
+            self.collect_leaf(&mut subtree.token_trees);
+        }
+        if subtree.token_trees.is_empty() {
+            return None;
+        }
+        if subtree.token_trees.len() == 1 {
+            if let tt::TokenTree::Subtree(first) = &subtree.token_trees[0] {
+                return Some(first.clone());
+            }
+        }
+        Some(subtree)
+    }
+    fn bump(&mut self) -> Option<(Token, TextRange)> {
+        let token = self.inner.next()?;
+        let range = TextRange::offset_len(self.offset, token.len);
+        self.offset += token.len;
+        Some((*token, range))
+    }
+    fn peek(&self) -> Option<Token> {
+        self.inner.as_slice().get(0).cloned()
+    }
+    fn collect_leaf(&mut self, result: &mut Vec<tt::TokenTree>) {
+        let (token, range) = match self.bump() {
+            None => return,
+            Some(it) => it,
+        };
+        let k: SyntaxKind = token.kind;
+        if k == COMMENT {
+            let node = doc_comment(&self.text[range]);
+            if let Some(tokens) = convert_doc_comment(&node) {
+                result.extend(tokens);
+            }
+            return;
+        }
+        result.push(if k.is_punct() {
+            let delim = match k {
+                T!['('] => Some((tt::DelimiterKind::Parenthesis, T![')'])),
+                T!['{'] => Some((tt::DelimiterKind::Brace, T!['}'])),
+                T!['['] => Some((tt::DelimiterKind::Bracket, T![']'])),
+                _ => None,
+            };
+            if let Some((kind, closed)) = delim {
+                let mut subtree = tt::Subtree::default();
+                let id = self.id_alloc.open_delim(range);
+                subtree.delimiter = Some(tt::Delimiter { kind, id });
+                while self.peek().map(|it| it.kind != closed).unwrap_or(false) {
+                    self.collect_leaf(&mut subtree.token_trees);
+                }
+                let last_range = match self.bump() {
+                    None => return,
+                    Some(it) => it.1,
+                };
+                self.id_alloc.close_delim(id, last_range);
+                subtree.into()
+            } else {
+                let spacing = match self.peek() {
+                    Some(next)
+                        if next.kind.is_trivia()
+                            || next.kind == T!['[']
+                            || next.kind == T!['{']
+                            || next.kind == T!['('] =>
+                    {
+                        tt::Spacing::Alone
+                    }
+                    Some(next) if next.kind.is_punct() => tt::Spacing::Joint,
+                    _ => tt::Spacing::Alone,
+                };
+                let char =
+                    self.text[range].chars().next().expect("Token from lexer must be single char");
+                tt::Leaf::from(tt::Punct { char, spacing, id: self.id_alloc.alloc(range) }).into()
+            }
+        } else {
+            macro_rules! make_leaf {
+                ($i:ident) => {
+                    tt::$i { id: self.id_alloc.alloc(range), text: self.text[range].into() }.into()
+                };
+            }
+            let leaf: tt::Leaf = match k {
+                T![true] | T![false] => make_leaf!(Literal),
+                IDENT | LIFETIME => make_leaf!(Ident),
+                k if k.is_keyword() => make_leaf!(Ident),
+                k if k.is_literal() => make_leaf!(Literal),
+                _ => return,
+            };
+            leaf.into()
+        });
+    }
+}
+// FIXME: There are some duplicate logic between RawConvertor and Convertor
+// It would be nice to refactor to converting SyntaxNode to ra_parser::Token and thus
+// use RawConvertor directly. But performance-wise it may not be a good idea ?
+struct Convertor {
+    id_alloc: TokenIdAlloc,
+}
 impl Convertor {
    fn go(&mut self, tt: &SyntaxNode) -> Option<tt::Subtree> {
        // This tree is empty
@@ -236,7 +419,7 @@ impl Convertor {
        };
        let delimiter = delimiter_kind.map(|kind| tt::Delimiter {
            kind,
-            id: self.alloc_delim(first_child.text_range(), last_child.text_range()),
+            id: self.id_alloc.delim(first_child.text_range(), last_child.text_range()),
        });
        let mut token_trees = Vec::new();
@@ -273,7 +456,7 @@ impl Convertor {
                                tt::Leaf::from(tt::Punct {
                                    char,
                                    spacing,
-                                    id: self.alloc(token.text_range()),
+                                    id: self.id_alloc.alloc(token.text_range()),
                                })
                                .into(),
                            );
@@ -282,7 +465,7 @@ impl Convertor {
                        macro_rules! make_leaf {
                            ($i:ident) => {
                                tt::$i {
-                                    id: self.alloc(token.text_range()),
+                                    id: self.id_alloc.alloc(token.text_range()),
                                    text: token.text().clone(),
                                }
                                .into()
@@ -313,28 +496,6 @@ impl Convertor {
        let res = tt::Subtree { delimiter, token_trees };
        Some(res)
    }
-    fn alloc(&mut self, absolute_range: TextRange) -> tt::TokenId {
-        let relative_range = absolute_range - self.global_offset;
-        let token_id = tt::TokenId(self.next_id);
-        self.next_id += 1;
-        self.map.insert(token_id, relative_range);
-        token_id
-    }
-    fn alloc_delim(
-        &mut self,
-        open_abs_range: TextRange,
-        close_abs_range: TextRange,
-    ) -> tt::TokenId {
-        let open_relative_range = open_abs_range - self.global_offset;
-        let close_relative_range = close_abs_range - self.global_offset;
-        let token_id = tt::TokenId(self.next_id);
-        self.next_id += 1;
-        self.map.insert_delim(token_id, open_relative_range, close_relative_range);
-        token_id
-    }
 }
 struct TtTreeSink<'a> {
diff --git a/crates/ra_mbe/src/tests.rs b/crates/ra_mbe/src/tests.rs
index 066ce150b..6d5d1e9e6 100644
--- a/crates/ra_mbe/src/tests.rs
+++ b/crates/ra_mbe/src/tests.rs
@@ -1499,12 +1499,20 @@ impl MacroFixture {
    }
 }
-pub(crate) fn parse_macro(macro_definition: &str) -> MacroFixture {
+pub(crate) fn parse_macro(ra_fixture: &str) -> MacroFixture {
-    let source_file = ast::SourceFile::parse(macro_definition).ok().unwrap();
+    let source_file = ast::SourceFile::parse(ra_fixture).ok().unwrap();
    let macro_definition =
        source_file.syntax().descendants().find_map(ast::MacroCall::cast).unwrap();
    let (definition_tt, _) = ast_to_token_tree(&macro_definition.token_tree().unwrap()).unwrap();
+    let parsed = parse_to_token_tree(
+        &ra_fixture[macro_definition.token_tree().unwrap().syntax().text_range()],
+    )
+    .unwrap()
+    .0;
+    assert_eq!(definition_tt, parsed);
    let rules = MacroRules::parse(&definition_tt).unwrap();
    MacroFixture { rules }
 }
diff --git a/crates/ra_parser/src/grammar/expressions.rs b/crates/ra_parser/src/grammar/expressions.rs
index 4163a2cf5..0c170ac5e 100644
--- a/crates/ra_parser/src/grammar/expressions.rs
+++ b/crates/ra_parser/src/grammar/expressions.rs
@@ -278,7 +278,7 @@ fn current_op(p: &Parser) -> (u8, SyntaxKind) {
 }
 // Parses expression with binding power of at least bp.
-fn expr_bp(p: &mut Parser, r: Restrictions, bp: u8) -> (Option<CompletedMarker>, BlockLike) {
+fn expr_bp(p: &mut Parser, mut r: Restrictions, bp: u8) -> (Option<CompletedMarker>, BlockLike) {
    let mut lhs = match lhs(p, r) {
        Some((lhs, blocklike)) => {
            // test stmt_bin_expr_ambiguity
@@ -311,6 +311,12 @@ fn expr_bp(p: &mut Parser, r: Restrictions, bp: u8) -> (Option<CompletedMarker>,
        let m = lhs.precede(p);
        p.bump(op);
+        // test binop_resets_statementness
+        // fn foo() {
+        //     v = {1}&2;
+        // }
+        r = Restrictions { prefer_stmt: false, ..r };
        if is_range {
            // test postfix_range
            // fn foo() {
@@ -327,7 +333,7 @@ fn expr_bp(p: &mut Parser, r: Restrictions, bp: u8) -> (Option<CompletedMarker>,
            }
        }
-        expr_bp(p, r, op_bp + 1);
+        expr_bp(p, Restrictions { prefer_stmt: false, ..r }, op_bp + 1);
        lhs = m.complete(p, if is_range { RANGE_EXPR } else { BIN_EXPR });
    }
    (Some(lhs), BlockLike::NotBlock)
diff --git a/crates/ra_prof/src/lib.rs b/crates/ra_prof/src/lib.rs
index 6853a4794..9e167db96 100644
--- a/crates/ra_prof/src/lib.rs
+++ b/crates/ra_prof/src/lib.rs
@@ -88,7 +88,7 @@ pub type Label = &'static str;
 pub fn profile(label: Label) -> Profiler {
    assert!(!label.is_empty());
    if !PROFILING_ENABLED.load(Ordering::Relaxed) {
-        return Profiler { label: None };
+        return Profiler { label: None, detail: None };
    }
    PROFILE_STACK.with(|stack| {
@@ -101,15 +101,15 @@ pub fn profile(label: Label) -> Profiler {
            };
        }
        if stack.starts.len() > stack.filter_data.depth {
-            return Profiler { label: None };
+            return Profiler { label: None, detail: None };
        }
        let allowed = &stack.filter_data.allowed;
        if stack.starts.is_empty() && !allowed.is_empty() && !allowed.contains(label) {
-            return Profiler { label: None };
+            return Profiler { label: None, detail: None };
        }
        stack.starts.push(Instant::now());
-        Profiler { label: Some(label) }
+        Profiler { label: Some(label), detail: None }
    })
 }
@@ -130,6 +130,16 @@ pub fn print_time(label: Label) -> impl Drop {
 pub struct Profiler {
    label: Option<Label>,
+    detail: Option<String>,
+}
+impl Profiler {
+    pub fn detail(mut self, detail: impl FnOnce() -> String) -> Profiler {
+        if self.label.is_some() {
+            self.detail = Some(detail())
+        }
+        self
+    }
 }
 pub struct Filter {
@@ -183,6 +193,7 @@ struct Message {
    level: usize,
    duration: Duration,
    label: Label,
+    detail: Option<String>,
 }
 impl ProfileStack {
@@ -208,13 +219,13 @@ thread_local!(static PROFILE_STACK: RefCell<ProfileStack> = RefCell::new(Profile
 impl Drop for Profiler {
    fn drop(&mut self) {
        match self {
-            Profiler { label: Some(label) } => {
+            Profiler { label: Some(label), detail } => {
                PROFILE_STACK.with(|stack| {
                    let mut stack = stack.borrow_mut();
                    let start = stack.starts.pop().unwrap();
                    let duration = start.elapsed();
                    let level = stack.starts.len();
-                    stack.messages.push(Message { level, duration, label });
+                    stack.messages.push(Message { level, duration, label, detail: detail.take() });
                    if level == 0 {
                        let stdout = stderr();
                        let longer_than = stack.filter_data.longer_than;
@@ -228,7 +239,7 @@ impl Drop for Profiler {
                    }
                });
            }
-            Profiler { label: None } => (),
+            Profiler { label: None, .. } => (),
        }
    }
 }
@@ -251,8 +262,16 @@ fn print_for_idx(
 ) {
    let current = &msgs[current_idx];
    let current_indent = "    ".repeat(current.level);
-    writeln!(out, "{}{:5}ms - {}", current_indent, current.duration.as_millis(), current.label)
+    let detail = current.detail.as_ref().map(|it| format!(" @ {}", it)).unwrap_or_default();
-        .expect("printing profiling info");
+    writeln!(
+        out,
+        "{}{:5}ms - {}{}",
+        current_indent,
+        current.duration.as_millis(),
+        current.label,
+        detail,
+    )
+    .expect("printing profiling info");
    let longer_than_millis = longer_than.as_millis();
    let children_indices = &children_map[current_idx];
@@ -417,9 +436,9 @@ mod tests {
    fn test_longer_than() {
        let mut result = vec![];
        let msgs = vec![
-            Message { level: 1, duration: Duration::from_nanos(3), label: "bar" },
+            Message { level: 1, duration: Duration::from_nanos(3), label: "bar", detail: None },
-            Message { level: 1, duration: Duration::from_nanos(2), label: "bar" },
+            Message { level: 1, duration: Duration::from_nanos(2), label: "bar", detail: None },
-            Message { level: 0, duration: Duration::from_millis(1), label: "foo" },
+            Message { level: 0, duration: Duration::from_millis(1), label: "foo", detail: None },
        ];
        print(&msgs, Duration::from_millis(0), &mut result);
        // The calls to `bar` are so short that they'll be rounded to 0ms and should get collapsed
@@ -434,8 +453,8 @@ mod tests {
    fn test_unaccounted_for_topmost() {
        let mut result = vec![];
        let msgs = vec![
-            Message { level: 1, duration: Duration::from_millis(2), label: "bar" },
+            Message { level: 1, duration: Duration::from_millis(2), label: "bar", detail: None },
-            Message { level: 0, duration: Duration::from_millis(5), label: "foo" },
+            Message { level: 0, duration: Duration::from_millis(5), label: "foo", detail: None },
        ];
        print(&msgs, Duration::from_millis(0), &mut result);
        assert_eq!(
@@ -453,11 +472,11 @@ mod tests {
    fn test_unaccounted_for_multiple_levels() {
        let mut result = vec![];
        let msgs = vec![
-            Message { level: 2, duration: Duration::from_millis(3), label: "baz" },
+            Message { level: 2, duration: Duration::from_millis(3), label: "baz", detail: None },
-            Message { level: 1, duration: Duration::from_millis(5), label: "bar" },
+            Message { level: 1, duration: Duration::from_millis(5), label: "bar", detail: None },
-            Message { level: 2, duration: Duration::from_millis(2), label: "baz" },
+            Message { level: 2, duration: Duration::from_millis(2), label: "baz", detail: None },
-            Message { level: 1, duration: Duration::from_millis(4), label: "bar" },
+            Message { level: 1, duration: Duration::from_millis(4), label: "bar", detail: None },
-            Message { level: 0, duration: Duration::from_millis(9), label: "foo" },
+            Message { level: 0, duration: Duration::from_millis(9), label: "foo", detail: None },
        ];
        print(&msgs, Duration::from_millis(0), &mut result);
        assert_eq!(
diff --git a/crates/ra_project_model/src/lib.rs b/crates/ra_project_model/src/lib.rs
index bcf12460d..a6274709d 100644
--- a/crates/ra_project_model/src/lib.rs
+++ b/crates/ra_project_model/src/lib.rs
@@ -14,7 +14,7 @@ use std::{
 use anyhow::{bail, Context, Result};
 use ra_cfg::CfgOptions;
-use ra_db::{CrateGraph, CrateId, CrateName, Edition, Env, FileId};
+use ra_db::{CrateGraph, CrateName, Edition, Env, ExternSource, ExternSourceId, FileId};
 use rustc_hash::FxHashMap;
 use serde_json::from_reader;
@@ -162,10 +162,10 @@ impl ProjectWorkspace {
    pub fn to_crate_graph(
        &self,
        default_cfg_options: &CfgOptions,
+        outdirs: &FxHashMap<String, (ExternSourceId, String)>,
        load: &mut dyn FnMut(&Path) -> Option<FileId>,
-    ) -> (CrateGraph, FxHashMap<CrateId, String>) {
+    ) -> CrateGraph {
        let mut crate_graph = CrateGraph::default();
-        let mut names = FxHashMap::default();
        match self {
            ProjectWorkspace::Json { project } => {
                let mut crates = FxHashMap::default();
@@ -186,13 +186,18 @@ impl ProjectWorkspace {
                            }
                            opts
                        };
+                        // FIXME: No crate name in json definition such that we cannot add OUT_DIR to env
                        crates.insert(
                            crate_id,
                            crate_graph.add_crate_root(
                                file_id,
                                edition,
+                                // FIXME json definitions can store the crate name
+                                None,
                                cfg_options,
                                Env::default(),
+                                Default::default(),
                            ),
                        );
                    }
@@ -230,14 +235,22 @@ impl ProjectWorkspace {
                            opts
                        };
+                        let mut env = Env::default();
+                        let mut extern_source = ExternSource::default();
+                        if let Some((id, path)) = outdirs.get(krate.name(&sysroot)) {
+                            env.set("OUT_DIR", path.clone());
+                            extern_source.set_extern_path(&path, *id);
+                        }
                        let crate_id = crate_graph.add_crate_root(
                            file_id,
                            Edition::Edition2018,
+                            Some(krate.name(&sysroot).to_string()),
                            cfg_options,
-                            Env::default(),
+                            env,
+                            extern_source,
                        );
                        sysroot_crates.insert(krate, crate_id);
-                        names.insert(crate_id, krate.name(&sysroot).to_string());
                    }
                }
                for from in sysroot.crates() {
@@ -274,13 +287,20 @@ impl ProjectWorkspace {
                                opts.insert_features(pkg.features(&cargo).iter().map(Into::into));
                                opts
                            };
+                            let mut env = Env::default();
+                            let mut extern_source = ExternSource::default();
+                            if let Some((id, path)) = outdirs.get(pkg.name(&cargo)) {
+                                env.set("OUT_DIR", path.clone());
+                                extern_source.set_extern_path(&path, *id);
+                            }
                            let crate_id = crate_graph.add_crate_root(
                                file_id,
                                edition,
+                                Some(pkg.name(&cargo).to_string()),
                                cfg_options,
-                                Env::default(),
+                                env,
+                                extern_source,
                            );
-                            names.insert(crate_id, pkg.name(&cargo).to_string());
                            if tgt.kind(&cargo) == TargetKind::Lib {
                                lib_tgt = Some(crate_id);
                                pkg_to_lib_crate.insert(pkg, crate_id);
@@ -381,7 +401,7 @@ impl ProjectWorkspace {
                }
            }
        }
-        (crate_graph, names)
+        crate_graph
    }
    pub fn workspace_root_for(&self, path: &Path) -> Option<&Path> {
diff --git a/crates/ra_syntax/src/ast/make.rs b/crates/ra_syntax/src/ast/make.rs
index 53d6fa562..ae8829807 100644
--- a/crates/ra_syntax/src/ast/make.rs
+++ b/crates/ra_syntax/src/ast/make.rs
@@ -267,6 +267,12 @@ pub mod tokens {
        sf.syntax().first_child_or_token().unwrap().into_token().unwrap()
    }
+    pub fn doc_comment(text: &str) -> SyntaxToken {
+        assert!(!text.trim().is_empty());
+        let sf = SourceFile::parse(text).ok().unwrap();
+        sf.syntax().first_child_or_token().unwrap().into_token().unwrap()
+    }
    pub fn literal(text: &str) -> SyntaxToken {
        assert_eq!(text.trim(), text);
        let lit: ast::Literal = super::ast_from_text(&format!("fn f() {{ let _ = {}; }}", text));
diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0158_binop_resets_statementness.rs b/crates/ra_syntax/test_data/parser/inline/ok/0158_binop_resets_statementness.rs
new file mode 100644
index 000000000..05acc30f1
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/inline/ok/0158_binop_resets_statementness.rs
@@ -0,0 +1,3 @@
+fn foo() {
+    v = {1}&2;
+}
diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0158_binop_resets_statementness.txt b/crates/ra_syntax/test_data/parser/inline/ok/0158_binop_resets_statementness.txt
new file mode 100644
index 000000000..d568a1d45
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/inline/ok/0158_binop_resets_statementness.txt
@@ -0,0 +1,38 @@
+SOURCE_FILE@[0; 28)
+  FN_DEF@[0; 27)
+    FN_KW@[0; 2) "fn"
+    WHITESPACE@[2; 3) " "
+    NAME@[3; 6)
+      IDENT@[3; 6) "foo"
+    PARAM_LIST@[6; 8)
+      L_PAREN@[6; 7) "("
+      R_PAREN@[7; 8) ")"
+    WHITESPACE@[8; 9) " "
+    BLOCK_EXPR@[9; 27)
+      BLOCK@[9; 27)
+        L_CURLY@[9; 10) "{"
+        WHITESPACE@[10; 15) "\n    "
+        EXPR_STMT@[15; 25)
+          BIN_EXPR@[15; 24)
+            PATH_EXPR@[15; 16)
+              PATH@[15; 16)
+                PATH_SEGMENT@[15; 16)
+                  NAME_REF@[15; 16)
+                    IDENT@[15; 16) "v"
+            WHITESPACE@[16; 17) " "
+            EQ@[17; 18) "="
+            WHITESPACE@[18; 19) " "
+            BIN_EXPR@[19; 24)
+              BLOCK_EXPR@[19; 22)
+                BLOCK@[19; 22)
+                  L_CURLY@[19; 20) "{"
+                  LITERAL@[20; 21)
+                    INT_NUMBER@[20; 21) "1"
+                  R_CURLY@[21; 22) "}"
+              AMP@[22; 23) "&"
+              LITERAL@[23; 24)
+                INT_NUMBER@[23; 24) "2"
+          SEMI@[24; 25) ";"
+        WHITESPACE@[25; 26) "\n"
+        R_CURLY@[26; 27) "}"
+  WHITESPACE@[27; 28) "\n"
diff --git a/crates/rust-analyzer/Cargo.toml b/crates/rust-analyzer/Cargo.toml
index b14ebb268..d44f0ef1d 100644
--- a/crates/rust-analyzer/Cargo.toml
+++ b/crates/rust-analyzer/Cargo.toml
@@ -20,7 +20,7 @@ globset = "0.4.4"
 itertools = "0.8.2"
 jod-thread = "0.1.0"
 log = "0.4.8"
-lsp-types = { version = "0.72.0", features = ["proposed"] }
+lsp-types = { version = "0.73.0", features = ["proposed"] }
 parking_lot = "0.10.0"
 pico-args = "0.3.1"
 rand = { version = "0.7.3", features = ["small_rng"] }
diff --git a/crates/rust-analyzer/src/cli/analysis_bench.rs b/crates/rust-analyzer/src/cli/analysis_bench.rs
index 91855e592..28a23934f 100644
--- a/crates/rust-analyzer/src/cli/analysis_bench.rs
+++ b/crates/rust-analyzer/src/cli/analysis_bench.rs
@@ -12,7 +12,7 @@ use ra_db::{
    salsa::{Database, Durability},
    FileId, SourceDatabaseExt,
 };
-use ra_ide::{Analysis, AnalysisChange, AnalysisHost, FilePosition, LineCol};
+use ra_ide::{Analysis, AnalysisChange, AnalysisHost, CompletionOptions, FilePosition, LineCol};
 use crate::cli::{load_cargo::load_cargo, Verbosity};
@@ -94,17 +94,19 @@ pub fn analysis_bench(verbosity: Verbosity, path: &Path, what: BenchWhat) -> Res
                .analysis()
                .file_line_index(file_id)?
                .offset(LineCol { line: pos.line - 1, col_utf16: pos.column });
-            let file_postion = FilePosition { file_id, offset };
+            let file_position = FilePosition { file_id, offset };
            if is_completion {
-                let res =
+                let options = CompletionOptions::default();
-                    do_work(&mut host, file_id, |analysis| analysis.completions(file_postion));
+                let res = do_work(&mut host, file_id, |analysis| {
+                    analysis.completions(file_position, &options)
+                });
                if verbosity.is_verbose() {
                    println!("\n{:#?}", res);
                }
            } else {
                let res =
-                    do_work(&mut host, file_id, |analysis| analysis.goto_definition(file_postion));
+                    do_work(&mut host, file_id, |analysis| analysis.goto_definition(file_position));
                if verbosity.is_verbose() {
                    println!("\n{:#?}", res);
                }
diff --git a/crates/rust-analyzer/src/cli/load_cargo.rs b/crates/rust-analyzer/src/cli/load_cargo.rs
index 8cd08ecb6..2ce69c9b3 100644
--- a/crates/rust-analyzer/src/cli/load_cargo.rs
+++ b/crates/rust-analyzer/src/cli/load_cargo.rs
@@ -6,7 +6,7 @@ use std::path::Path;
 use anyhow::Result;
 use crossbeam_channel::{unbounded, Receiver};
 use ra_db::{CrateGraph, FileId, SourceRootId};
-use ra_ide::{AnalysisChange, AnalysisHost, FeatureFlags};
+use ra_ide::{AnalysisChange, AnalysisHost};
 use ra_project_model::{get_rustc_cfg_options, PackageRoot, ProjectWorkspace};
 use ra_vfs::{RootEntry, Vfs, VfsChange, VfsTask, Watch};
 use rustc_hash::{FxHashMap, FxHashSet};
@@ -52,12 +52,14 @@ pub(crate) fn load_cargo(
        opts
    };
-    let (crate_graph, _crate_names) =
+    // FIXME: outdirs?
-        ws.to_crate_graph(&default_cfg_options, &mut |path: &Path| {
+    let outdirs = FxHashMap::default();
-            let vfs_file = vfs.load(path);
-            log::debug!("vfs file {:?} -> {:?}", path, vfs_file);
+    let crate_graph = ws.to_crate_graph(&default_cfg_options, &outdirs, &mut |path: &Path| {
-            vfs_file.map(vfs_file_to_id)
+        let vfs_file = vfs.load(path);
-        });
+        log::debug!("vfs file {:?} -> {:?}", path, vfs_file);
+        vfs_file.map(vfs_file_to_id)
+    });
    log::debug!("crate graph: {:?}", crate_graph);
    let source_roots = roots
@@ -83,7 +85,7 @@ pub(crate) fn load(
    receiver: Receiver<VfsTask>,
 ) -> AnalysisHost {
    let lru_cap = std::env::var("RA_LRU_CAP").ok().and_then(|it| it.parse::<usize>().ok());
-    let mut host = AnalysisHost::new(lru_cap, FeatureFlags::default());
+    let mut host = AnalysisHost::new(lru_cap);
    let mut analysis_change = AnalysisChange::new();
    analysis_change.set_crate_graph(crate_graph);
diff --git a/crates/rust-analyzer/src/config.rs b/crates/rust-analyzer/src/config.rs
index 3314269ec..a8bf29ddf 100644
--- a/crates/rust-analyzer/src/config.rs
+++ b/crates/rust-analyzer/src/config.rs
@@ -44,6 +44,9 @@ pub struct ServerConfig {
    /// Fine grained feature flags to disable specific features.
    pub feature_flags: FxHashMap<String, bool>,
+    /// Fine grained controls for additional `OUT_DIR` env variables
+    pub additional_out_dirs: FxHashMap<String, String>,
    pub rustfmt_args: Vec<String>,
    /// Cargo feature configurations.
@@ -64,6 +67,7 @@ impl Default for ServerConfig {
            cargo_watch_all_targets: true,
            with_sysroot: true,
            feature_flags: FxHashMap::default(),
+            additional_out_dirs: FxHashMap::default(),
            cargo_features: Default::default(),
            rustfmt_args: Vec::new(),
        }
diff --git a/crates/rust-analyzer/src/conv.rs b/crates/rust-analyzer/src/conv.rs
index eeeb33e8f..a2d68c344 100644
--- a/crates/rust-analyzer/src/conv.rs
+++ b/crates/rust-analyzer/src/conv.rs
@@ -3,10 +3,10 @@
 use lsp_types::{
    self, CreateFile, DiagnosticSeverity, DocumentChangeOperation, DocumentChanges, Documentation,
-    Location, LocationLink, MarkupContent, MarkupKind, Position, Range, RenameFile, ResourceOp,
+    Location, LocationLink, MarkupContent, MarkupKind, ParameterInformation, ParameterLabel,
-    SemanticTokenModifier, SemanticTokenType, SymbolKind, TextDocumentEdit, TextDocumentIdentifier,
+    Position, Range, RenameFile, ResourceOp, SemanticTokenModifier, SemanticTokenType,
-    TextDocumentItem, TextDocumentPositionParams, Url, VersionedTextDocumentIdentifier,
+    SignatureInformation, SymbolKind, TextDocumentEdit, TextDocumentIdentifier, TextDocumentItem,
-    WorkspaceEdit,
+    TextDocumentPositionParams, Url, VersionedTextDocumentIdentifier, WorkspaceEdit,
 };
 use ra_ide::{
    translate_offset_with_edit, CompletionItem, CompletionItemKind, FileId, FilePosition,
@@ -150,6 +150,16 @@ impl ConvWith<(&LineIndex, LineEndings)> for CompletionItem {
            additional_text_edits: Some(additional_text_edits),
            documentation: self.documentation().map(|it| it.conv()),
            deprecated: Some(self.deprecated()),
+            command: if self.trigger_call_info() {
+                let cmd = lsp_types::Command {
+                    title: "triggerParameterHints".into(),
+                    command: "editor.action.triggerParameterHints".into(),
+                    arguments: None,
+                };
+                Some(cmd)
+            } else {
+                None
+            },
            ..Default::default()
        };
@@ -210,17 +220,20 @@ impl Conv for ra_ide::Documentation {
    }
 }
-impl Conv for ra_ide::FunctionSignature {
+impl ConvWith<bool> for ra_ide::FunctionSignature {
    type Output = lsp_types::SignatureInformation;
-    fn conv(self) -> Self::Output {
+    fn conv_with(self, concise: bool) -> Self::Output {
-        use lsp_types::{ParameterInformation, ParameterLabel, SignatureInformation};
+        let (label, documentation, params) = if concise {
+            let mut params = self.parameters;
-        let label = self.to_string();
+            if self.has_self_param {
+                params.remove(0);
-        let documentation = self.doc.map(|it| it.conv());
+            }
+            (params.join(", "), None, params)
+        } else {
+            (self.to_string(), self.doc.map(|it| it.conv()), self.parameters)
+        };
-        let parameters: Vec<ParameterInformation> = self
+        let parameters: Vec<ParameterInformation> = params
-            .parameters
            .into_iter()
            .map(|param| ParameterInformation {
                label: ParameterLabel::Simple(param),
diff --git a/crates/ra_ide_db/src/feature_flags.rs b/crates/rust-analyzer/src/feature_flags.rs
index 76655f572..dbb3f50a0 100644
--- a/crates/ra_ide_db/src/feature_flags.rs
+++ b/crates/rust-analyzer/src/feature_flags.rs
@@ -2,6 +2,10 @@
 use rustc_hash::FxHashMap;
+// FIXME: looks like a much better design is to pass options to each call,
+// rather than to have a global ambient feature flags -- that way, the clients
+// can issue two successive calls with different options.
 /// Feature flags hold fine-grained toggles for all *user-visible* features of
 /// rust-analyzer.
 ///
@@ -54,7 +58,9 @@ impl Default for FeatureFlags {
        FeatureFlags::new(&[
            ("lsp.diagnostics", true),
            ("completion.insertion.add-call-parenthesis", true),
+            ("completion.insertion.add-argument-snippets", true),
            ("completion.enable-postfix", true),
+            ("call-info.full", true),
            ("notifications.workspace-loaded", true),
            ("notifications.cargo-toml-not-found", true),
        ])
diff --git a/crates/rust-analyzer/src/lib.rs b/crates/rust-analyzer/src/lib.rs
index a0f968823..e50e47b19 100644
--- a/crates/rust-analyzer/src/lib.rs
+++ b/crates/rust-analyzer/src/lib.rs
@@ -37,6 +37,7 @@ mod config;
 mod world;
 mod diagnostics;
 mod semantic_tokens;
+mod feature_flags;
 use serde::de::DeserializeOwned;
diff --git a/crates/rust-analyzer/src/main_loop.rs b/crates/rust-analyzer/src/main_loop.rs
index 580ad1f2c..4f7aac754 100644
--- a/crates/rust-analyzer/src/main_loop.rs
+++ b/crates/rust-analyzer/src/main_loop.rs
@@ -18,7 +18,7 @@ use crossbeam_channel::{select, unbounded, RecvError, Sender};
 use lsp_server::{Connection, ErrorCode, Message, Notification, Request, RequestId, Response};
 use lsp_types::{ClientCapabilities, NumberOrString};
 use ra_cargo_watch::{url_from_path_with_drive_lowercasing, CheckOptions, CheckTask};
-use ra_ide::{Canceled, FeatureFlags, FileId, LibraryData, SourceRootId};
+use ra_ide::{Canceled, FileId, LibraryData, SourceRootId};
 use ra_prof::profile;
 use ra_vfs::{VfsFile, VfsTask, Watch};
 use relative_path::RelativePathBuf;
@@ -28,6 +28,7 @@ use threadpool::ThreadPool;
 use crate::{
    diagnostics::DiagnosticTask,
+    feature_flags::FeatureFlags,
    main_loop::{
        pending_requests::{PendingRequest, PendingRequests},
        subscriptions::Subscriptions,
@@ -44,6 +45,8 @@ pub struct LspError {
 }
 impl LspError {
+    pub const UNKNOWN_FILE: i32 = -32900;
    pub fn new(code: i32, message: String) -> LspError {
        LspError { code, message }
    }
@@ -193,6 +196,7 @@ pub fn main_loop(
            Watch(!config.use_client_watching),
            options,
            feature_flags,
+            config.additional_out_dirs,
        )
    };
@@ -421,7 +425,7 @@ fn loop_turn(
    {
        loop_state.workspace_loaded = true;
        let n_packages: usize = world_state.workspaces.iter().map(|it| it.n_packages()).sum();
-        if world_state.feature_flags().get("notifications.workspace-loaded") {
+        if world_state.feature_flags.get("notifications.workspace-loaded") {
            let msg = format!("workspace loaded, {} rust packages", n_packages);
            show_message(req::MessageType::Info, msg, &connection.sender);
        }
@@ -631,6 +635,9 @@ fn on_notification(
        }
        Err(not) => not,
    };
+    if not.method.starts_with("$/") {
+        return Ok(());
+    }
    log::error!("unhandled notification: {:?}", not);
    Ok(())
 }
@@ -802,7 +809,14 @@ where
    let response = match result {
        Ok(resp) => Response::new_ok(id, &resp),
        Err(e) => match e.downcast::<LspError>() {
-            Ok(lsp_error) => Response::new_err(id, lsp_error.code, lsp_error.message),
+            Ok(lsp_error) => {
+                if lsp_error.code == LspError::UNKNOWN_FILE {
+                    // Work-around for https://github.com/rust-analyzer/rust-analyzer/issues/1521
+                    Response::new_ok(id, ())
+                } else {
+                    Response::new_err(id, lsp_error.code, lsp_error.message)
+                }
+            }
            Err(e) => {
                if is_canceled(&e) {
                    Response::new_err(
@@ -827,7 +841,7 @@ fn update_file_notifications_on_threadpool(
    subscriptions: Vec<FileId>,
 ) {
    log::trace!("updating notifications for {:?}", subscriptions);
-    let publish_diagnostics = world.feature_flags().get("lsp.diagnostics");
+    let publish_diagnostics = world.feature_flags.get("lsp.diagnostics");
    pool.execute(move || {
        for file_id in subscriptions {
            if publish_diagnostics {
diff --git a/crates/rust-analyzer/src/main_loop/handlers.rs b/crates/rust-analyzer/src/main_loop/handlers.rs
index b5db1fd38..fcb40432d 100644
--- a/crates/rust-analyzer/src/main_loop/handlers.rs
+++ b/crates/rust-analyzer/src/main_loop/handlers.rs
@@ -20,8 +20,8 @@ use lsp_types::{
    TextEdit, WorkspaceEdit,
 };
 use ra_ide::{
-    Assist, AssistId, FileId, FilePosition, FileRange, Query, RangeInfo, Runnable, RunnableKind,
+    Assist, AssistId, CompletionOptions, FileId, FilePosition, FileRange, Query, RangeInfo,
-    SearchScope,
+    Runnable, RunnableKind, SearchScope,
 };
 use ra_prof::profile;
 use ra_syntax::{AstNode, SyntaxKind, TextRange, TextUnit};
@@ -85,11 +85,11 @@ pub fn handle_expand_macro(
 pub fn handle_selection_range(
    world: WorldSnapshot,
    params: req::SelectionRangeParams,
-) -> Result<Vec<req::SelectionRange>> {
+) -> Result<Option<Vec<req::SelectionRange>>> {
    let _p = profile("handle_selection_range");
    let file_id = params.text_document.try_conv_with(&world)?;
    let line_index = world.analysis().file_line_index(file_id)?;
-    params
+    let res: Result<Vec<req::SelectionRange>> = params
        .positions
        .into_iter()
        .map_conv_with(&line_index)
@@ -120,7 +120,9 @@ pub fn handle_selection_range(
            }
            Ok(range)
        })
-        .collect()
+        .collect();
+    Ok(Some(res?))
 }
 pub fn handle_find_matching_brace(
@@ -422,7 +424,15 @@ pub fn handle_completion(
        return Ok(None);
    }
-    let items = match world.analysis().completions(position)? {
+    let options = CompletionOptions {
+        enable_postfix_completions: world.feature_flags.get("completion.enable-postfix"),
+        add_call_parenthesis: world.feature_flags.get("completion.insertion.add-call-parenthesis"),
+        add_call_argument_snippets: world
+            .feature_flags
+            .get("completion.insertion.add-argument-snippets"),
+    };
+    let items = match world.analysis().completions(position, &options)? {
        None => return Ok(None),
        Some(items) => items,
    };
@@ -459,8 +469,12 @@ pub fn handle_signature_help(
    let _p = profile("handle_signature_help");
    let position = params.try_conv_with(&world)?;
    if let Some(call_info) = world.analysis().call_info(position)? {
-        let active_parameter = call_info.active_parameter.map(|it| it as i64);
+        let concise = !world.feature_flags.get("call-info.full");
-        let sig_info = call_info.signature.conv();
+        let mut active_parameter = call_info.active_parameter.map(|it| it as i64);
+        if concise && call_info.signature.has_self_param {
+            active_parameter = active_parameter.map(|it| it.saturating_sub(1));
+        }
+        let sig_info = call_info.signature.conv_with(concise);
        Ok(Some(req::SignatureHelp {
            signatures: vec![sig_info],
diff --git a/crates/rust-analyzer/src/world.rs b/crates/rust-analyzer/src/world.rs
index 96efab844..9ef368529 100644
--- a/crates/rust-analyzer/src/world.rs
+++ b/crates/rust-analyzer/src/world.rs
@@ -9,13 +9,11 @@ use std::{
 };
 use crossbeam_channel::{unbounded, Receiver};
-use lsp_server::ErrorCode;
 use lsp_types::Url;
 use parking_lot::RwLock;
 use ra_cargo_watch::{url_from_path_with_drive_lowercasing, CheckOptions, CheckWatcher};
 use ra_ide::{
-    Analysis, AnalysisChange, AnalysisHost, CrateGraph, FeatureFlags, FileId, LibraryData,
+    Analysis, AnalysisChange, AnalysisHost, CrateGraph, FileId, LibraryData, SourceRootId,
-    SourceRootId,
 };
 use ra_project_model::{get_rustc_cfg_options, ProjectWorkspace};
 use ra_vfs::{LineEndings, RootEntry, Vfs, VfsChange, VfsFile, VfsRoot, VfsTask, Watch};
@@ -23,10 +21,13 @@ use relative_path::RelativePathBuf;
 use crate::{
    diagnostics::{CheckFixes, DiagnosticCollection},
+    feature_flags::FeatureFlags,
    main_loop::pending_requests::{CompletedRequest, LatestRequests},
    vfs_glob::{Glob, RustPackageFilterBuilder},
    LspError, Result,
 };
+use ra_db::ExternSourceId;
+use rustc_hash::{FxHashMap, FxHashSet};
 #[derive(Debug, Clone)]
 pub struct Options {
@@ -46,6 +47,7 @@ pub struct Options {
 #[derive(Debug)]
 pub struct WorldState {
    pub options: Options,
+    pub feature_flags: Arc<FeatureFlags>,
    //FIXME: this belongs to `LoopState` rather than to `WorldState`
    pub roots_to_scan: usize,
    pub roots: Vec<PathBuf>,
@@ -61,6 +63,7 @@ pub struct WorldState {
 /// An immutable snapshot of the world's state at a point in time.
 pub struct WorldSnapshot {
    pub options: Options,
+    pub feature_flags: Arc<FeatureFlags>,
    pub workspaces: Arc<Vec<ProjectWorkspace>>,
    pub analysis: Analysis,
    pub latest_requests: Arc<RwLock<LatestRequests>>,
@@ -77,6 +80,7 @@ impl WorldState {
        watch: Watch,
        options: Options,
        feature_flags: FeatureFlags,
+        additional_out_dirs: FxHashMap<String, String>,
    ) -> WorldState {
        let mut change = AnalysisChange::new();
@@ -98,6 +102,19 @@ impl WorldState {
                RootEntry::new(pkg_root.path().clone(), filter.into_vfs_filter())
            }));
        }
+        let extern_dirs: FxHashSet<_> =
+            additional_out_dirs.iter().map(|(_, path)| (PathBuf::from(path))).collect();
+        let mut extern_source_roots = FxHashMap::default();
+        roots.extend(additional_out_dirs.iter().map(|(_, path)| {
+            let mut filter = RustPackageFilterBuilder::default().set_member(false);
+            for glob in exclude_globs.iter() {
+                filter = filter.exclude(glob.clone());
+            }
+            RootEntry::new(PathBuf::from(&path), filter.into_vfs_filter())
+        }));
        let (task_sender, task_receiver) = unbounded();
        let task_sender = Box::new(move |t| task_sender.send(t).unwrap());
        let (mut vfs, vfs_roots) = Vfs::new(roots, task_sender, watch);
@@ -107,6 +124,11 @@ impl WorldState {
            let is_local = folder_roots.iter().any(|it| vfs_root_path.starts_with(it));
            change.add_root(SourceRootId(r.0), is_local);
            change.set_debug_root_path(SourceRootId(r.0), vfs_root_path.display().to_string());
+            // FIXME: add path2root in vfs to simpily this logic
+            if extern_dirs.contains(&vfs_root_path) {
+                extern_source_roots.insert(vfs_root_path, ExternSourceId(r.0));
+            }
        }
        // FIXME: Read default cfgs from config
@@ -123,13 +145,21 @@ impl WorldState {
            let vfs_file = vfs.load(path);
            vfs_file.map(|f| FileId(f.0))
        };
-        for ws in workspaces.iter() {
-            let (graph, crate_names) = ws.to_crate_graph(&default_cfg_options, &mut load);
+        let mut outdirs = FxHashMap::default();
-            let shift = crate_graph.extend(graph);
+        for (name, path) in additional_out_dirs {
-            for (crate_id, name) in crate_names {
+            let path = PathBuf::from(&path);
-                change.set_debug_crate_name(crate_id.shift(shift), name)
+            if let Some(id) = extern_source_roots.get(&path) {
+                outdirs.insert(name, (id.clone(), path.to_string_lossy().replace("\\", "/")));
            }
        }
+        workspaces
+            .iter()
+            .map(|ws| ws.to_crate_graph(&default_cfg_options, &outdirs, &mut load))
+            .for_each(|graph| {
+                crate_graph.extend(graph);
+            });
        change.set_crate_graph(crate_graph);
        // FIXME: Figure out the multi-workspace situation
@@ -148,10 +178,11 @@ impl WorldState {
                CheckWatcher::dummy()
            });
-        let mut analysis_host = AnalysisHost::new(lru_capacity, feature_flags);
+        let mut analysis_host = AnalysisHost::new(lru_capacity);
        analysis_host.apply_change(change);
        WorldState {
            options,
+            feature_flags: Arc::new(feature_flags),
            roots_to_scan,
            roots: folder_roots,
            workspaces: Arc::new(workspaces),
@@ -218,6 +249,7 @@ impl WorldState {
    pub fn snapshot(&self) -> WorldSnapshot {
        WorldSnapshot {
            options: self.options.clone(),
+            feature_flags: Arc::clone(&self.feature_flags),
            workspaces: Arc::clone(&self.workspaces),
            analysis: self.analysis_host.analysis(),
            vfs: Arc::clone(&self.vfs),
@@ -237,10 +269,6 @@ impl WorldState {
    pub fn complete_request(&mut self, request: CompletedRequest) {
        self.latest_requests.write().record(request)
    }
-    pub fn feature_flags(&self) -> &FeatureFlags {
-        self.analysis_host.feature_flags()
-    }
 }
 impl WorldSnapshot {
@@ -252,8 +280,9 @@ impl WorldSnapshot {
        let path = uri.to_file_path().map_err(|()| format!("invalid uri: {}", uri))?;
        let file = self.vfs.read().path2file(&path).ok_or_else(|| {
            // Show warning as this file is outside current workspace
+            // FIXME: just handle such files, and remove `LspError::UNKNOWN_FILE`.
            LspError {
-                code: ErrorCode::InvalidRequest as i32,
+                code: LspError::UNKNOWN_FILE,
                message: "Rust file outside current workspace is not supported yet.".to_string(),
            }
        })?;
@@ -307,8 +336,4 @@ impl WorldSnapshot {
        let path = self.vfs.read().file2path(VfsFile(file_id.0));
        self.workspaces.iter().find_map(|ws| ws.workspace_root_for(&path))
    }
-    pub fn feature_flags(&self) -> &FeatureFlags {
-        self.analysis.feature_flags()
-    }
 }
diff --git a/crates/test_utils/src/lib.rs b/crates/test_utils/src/lib.rs
index 69deddcb5..a0d8f4d37 100644
--- a/crates/test_utils/src/lib.rs
+++ b/crates/test_utils/src/lib.rs
@@ -202,6 +202,19 @@ pub fn parse_fixture(fixture: &str) -> Vec<FixtureEntry> {
    res
 }
+/// Same as `parse_fixture`, except it allow empty fixture
+pub fn parse_single_fixture(fixture: &str) -> Option<FixtureEntry> {
+    if !fixture.lines().any(|it| it.trim_start().starts_with("//-")) {
+        return None;
+    }
+    let fixtures = parse_fixture(fixture);
+    if fixtures.len() > 1 {
+        panic!("too many fixtures");
+    }
+    fixtures.into_iter().nth(0)
+}
 // Comparison functionality borrowed from cargo:
 /// Compare a line with an expected pattern.
diff --git a/docs/user/readme.adoc b/docs/user/readme.adoc
index f1386a8f9..4e99dd0a6 100644
--- a/docs/user/readme.adoc
+++ b/docs/user/readme.adoc
@@ -2,6 +2,13 @@
 :toc: preamble
 :sectanchors:
 :page-layout: post
+// https://gist.github.com/dcode/0cfbf2699a1fe9b46ff04c41721dda74#admonitions
+:tip-caption: :bulb:
+:note-caption: :information_source:
+:important-caption: :heavy_exclamation_mark:
+:caution-caption: :fire:
+:warning-caption: :warning:
 // Master copy of this document lives in the https://github.com/rust-analyzer/rust-analyzer repository
@@ -30,7 +37,7 @@ $ rustup component add rust-src
 === VS Code
-This the best supported editor at the moment.
+This is the best supported editor at the moment.
 rust-analyzer plugin for VS Code is maintained
 https://github.com/rust-analyzer/rust-analyzer/tree/master/editors/code[in tree].
@@ -40,6 +47,16 @@ By default, the plugin will prompt you to download the matching version of the s
 image::https://user-images.githubusercontent.com/9021944/75067008-17502500-54ba-11ea-835a-f92aac50e866.png[]
+[NOTE]
+====
+To disable this notification put the following to `settings.json`
+[source,json]
+----
+{ "rust-analyzer.updates.askBeforeDownload": false }
+----
+====
 The server binary is stored in `~/.config/Code/User/globalStorage/matklad.rust-analyzer`.
 Note that we only support the latest version of VS Code.
@@ -124,7 +141,7 @@ let g:LanguageClient_serverCommands = {
 NeoVim 0.5 (not yet released) has built-in language server support.
 For a quick start configuration of rust-analyzer, use https://github.com/neovim/nvim-lsp#rust_analyzer[neovim/nvim-lsp].
-Once `neovim/nvim-lsp` is installed, use `lua require'nvim_lsp'.rust_analyzer.setup({})` in your `init.vim`.
+Once `neovim/nvim-lsp` is installed, use `+lua require'nvim_lsp'.rust_analyzer.setup({})+` in your `init.vim`.
 === Sublime Text 3
diff --git a/editors/code/package-lock.json b/editors/code/package-lock.json
index b07caf034..b07964546 100644
--- a/editors/code/package-lock.json
+++ b/editors/code/package-lock.json
@@ -114,9 +114,9 @@
            }
        },
        "@types/vscode": {
-            "version": "1.42.0",
+            "version": "1.43.0",
-            "resolved": "https://registry.npmjs.org/@types/vscode/-/vscode-1.42.0.tgz",
+            "resolved": "https://registry.npmjs.org/@types/vscode/-/vscode-1.43.0.tgz",
-            "integrity": "sha512-ds6TceMsh77Fs0Mq0Vap6Y72JbGWB8Bay4DrnJlf5d9ui2RSe1wis13oQm+XhguOeH1HUfLGzaDAoupTUtgabw==",
+            "integrity": "sha512-kIaR9qzd80rJOxePKpCB/mdy00mz8Apt2QA5Y6rdrKFn13QNFNeP3Hzmsf37Bwh/3cS7QjtAeGSK7wSqAU0sYQ==",
            "dev": true
        },
        "@typescript-eslint/eslint-plugin": {
@@ -171,9 +171,9 @@
            }
        },
        "acorn": {
-            "version": "7.1.0",
+            "version": "7.1.1",
-            "resolved": "https://registry.npmjs.org/acorn/-/acorn-7.1.0.tgz",
+            "resolved": "https://registry.npmjs.org/acorn/-/acorn-7.1.1.tgz",
-            "integrity": "sha512-kL5CuoXA/dgxlBbVrflsflzQ3PAas7RYZB52NOm/6839iVYJgKMJ3cQJD+t2i5+qFa8h3MDpEOJiS64E8JLnSQ==",
+            "integrity": "sha512-add7dgA5ppRPxCFJoAGfMDi7PIBXq1RtGo7BhbLaxwrXPOmw8gq48Y9ozT01hUKy9byMjlR20EJhu5zlkErEkg==",
            "dev": true
        },
        "acorn-jsx": {
@@ -1328,9 +1328,9 @@
            }
        },
        "rollup": {
-            "version": "1.32.0",
+            "version": "1.32.1",
-            "resolved": "https://registry.npmjs.org/rollup/-/rollup-1.32.0.tgz",
+            "resolved": "https://registry.npmjs.org/rollup/-/rollup-1.32.1.tgz",
-            "integrity": "sha512-ab2tF5pdDqm2zuI8j02ceyrJSScl9V2C24FgWQ1v1kTFTu1UrG5H0hpP++mDZlEFyZX4k0chtGEHU2i+pAzBgA==",
+            "integrity": "sha512-/2HA0Ec70TvQnXdzynFffkjA6XN+1e2pEv/uKS5Ulca40g2L7KuOE3riasHoNVHOsFD5KKZgDsMk1CP3Tw9s+A==",
            "dev": true,
            "requires": {
                "@types/estree": "*",
diff --git a/editors/code/package.json b/editors/code/package.json
index 830358605..1fe8e9f8a 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -21,7 +21,7 @@
        "Programming Languages"
    ],
    "engines": {
-        "vscode": "^1.42.0"
+        "vscode": "^1.43.0"
    },
    "enableProposedApi": true,
    "scripts": {
@@ -41,11 +41,11 @@
        "@rollup/plugin-node-resolve": "^7.1.1",
        "@types/node": "^12.12.29",
        "@types/node-fetch": "^2.5.5",
-        "@types/vscode": "^1.42.0",
+        "@types/vscode": "^1.43.0",
        "@typescript-eslint/eslint-plugin": "^2.22.0",
        "@typescript-eslint/parser": "^2.22.0",
        "eslint": "^6.8.0",
-        "rollup": "^1.32.0",
+        "rollup": "^1.32.1",
        "tslib": "^1.11.1",
        "typescript": "^3.8.3",
        "typescript-formatter": "^7.2.2",
@@ -191,26 +191,44 @@
                    "properties": {
                        "lsp.diagnostics": {
                            "type": "boolean",
-                            "description": "Whether to show diagnostics from `cargo check`"
+                            "markdownDescription": "Whether to show diagnostics from `cargo check`"
                        },
                        "completion.insertion.add-call-parenthesis": {
                            "type": "boolean",
                            "description": "Whether to add parenthesis when completing functions"
                        },
+                        "completion.insertion.add-argument-snippets": {
+                            "type": "boolean",
+                            "description": "Whether to add argument snippets when completing functions"
+                        },
                        "completion.enable-postfix": {
                            "type": "boolean",
-                            "description": "Whether to show postfix snippets like `dbg`, `if`, `not`, etc."
+                            "markdownDescription": "Whether to show postfix snippets like `dbg`, `if`, `not`, etc."
+                        },
+                        "call-info.full": {
+                            "type": "boolean",
+                            "description": "Show function name and docs in parameter hints"
                        },
                        "notifications.workspace-loaded": {
                            "type": "boolean",
-                            "description": "Whether to show `workspace loaded` message"
+                            "markdownDescription": "Whether to show `workspace loaded` message"
                        },
                        "notifications.cargo-toml-not-found": {
                            "type": "boolean",
-                            "description": "Whether to show `can't find Cargo.toml` error message"
+                            "markdownDescription": "Whether to show `can't find Cargo.toml` error message"
                        }
                    }
                },
+                "rust-analyzer.updates.askBeforeDownload": {
+                    "type": "boolean",
+                    "default": true,
+                    "description": "Whether to ask for permission before downloading any files from the Internet"
+                },
+                "rust-analyzer.additionalOutDirs": {
+                    "type": "object",
+                    "default": {},
+                    "markdownDescription": "Fine grained controls for OUT_DIR `env!(\"OUT_DIR\")` variable. e.g. `{\"foo\":\"/path/to/foo\"}`, "
+                },
                "rust-analyzer.serverPath": {
                    "type": [
                        "null",
@@ -243,24 +261,24 @@
                "rust-analyzer.cargo-watch.enable": {
                    "type": "boolean",
                    "default": true,
-                    "description": "Run `cargo check` for diagnostics on save"
+                    "markdownDescription": "Run `cargo check` for diagnostics on save"
                },
                "rust-analyzer.cargo-watch.arguments": {
                    "type": "array",
                    "items": {
                        "type": "string"
                    },
-                    "description": "`cargo-watch` arguments. (e.g: `--features=\"shumway,pdf\"` will run as `cargo watch -x \"check --features=\"shumway,pdf\"\"` )",
+                    "markdownDescription": "`cargo-watch` arguments. (e.g: `--features=\"shumway,pdf\"` will run as `cargo watch -x \"check --features=\"shumway,pdf\"\"` )",
                    "default": []
                },
                "rust-analyzer.cargo-watch.command": {
                    "type": "string",
-                    "description": "`cargo-watch` command. (e.g: `clippy` will run as `cargo watch -x clippy` )",
+                    "markdownDescription": "`cargo-watch` command. (e.g: `clippy` will run as `cargo watch -x clippy` )",
                    "default": "check"
                },
                "rust-analyzer.cargo-watch.allTargets": {
                    "type": "boolean",
-                    "description": "Check all targets and tests (will be passed as `--all-targets`)",
+                    "markdownDescription": "Check all targets and tests (will be passed as `--all-targets`)",
                    "default": true
                },
                "rust-analyzer.trace.server": {
@@ -312,7 +330,7 @@
                "rust-analyzer.cargoFeatures.noDefaultFeatures": {
                    "type": "boolean",
                    "default": false,
-                    "description": "Do not activate the `default` feature"
+                    "markdownDescription": "Do not activate the `default` feature"
                },
                "rust-analyzer.cargoFeatures.allFeatures": {
                    "type": "boolean",
diff --git a/editors/code/src/client.ts b/editors/code/src/client.ts
index 540f7c9ea..6ce3b9235 100644
--- a/editors/code/src/client.ts
+++ b/editors/code/src/client.ts
@@ -37,6 +37,7 @@ export async function createClient(config: Config, serverPath: string): Promise<
            excludeGlobs: config.excludeGlobs,
            useClientWatching: config.useClientWatching,
            featureFlags: config.featureFlags,
+            additionalOutDirs: config.additionalOutDirs,
            withSysroot: config.withSysroot,
            cargoFeatures: config.cargoFeatures,
            rustfmtArgs: config.rustfmtArgs,
diff --git a/editors/code/src/config.ts b/editors/code/src/config.ts
index bf915102c..3ade7e900 100644
--- a/editors/code/src/config.ts
+++ b/editors/code/src/config.ts
@@ -1,6 +1,6 @@
 import * as os from "os";
 import * as vscode from 'vscode';
-import { BinarySource } from "./installation/interfaces";
+import { ArtifactSource } from "./installation/interfaces";
 import { log } from "./util";
 const RA_LSP_DEBUG = process.env.__RA_LSP_SERVER_DEBUG;
@@ -114,12 +114,12 @@ export class Config {
        }
    }
-    get serverSource(): null | BinarySource {
+    get serverSource(): null | ArtifactSource {
        const serverPath = RA_LSP_DEBUG ?? this.cfg.get<null | string>("serverPath");
        if (serverPath) {
            return {
-                type: BinarySource.Type.ExplicitPath,
+                type: ArtifactSource.Type.ExplicitPath,
                path: Config.replaceTildeWithHomeDir(serverPath)
            };
        }
@@ -129,11 +129,12 @@ export class Config {
        if (!prebuiltBinaryName) return null;
        return {
-            type: BinarySource.Type.GithubRelease,
+            type: ArtifactSource.Type.GithubRelease,
            dir: this.ctx.globalStoragePath,
            file: prebuiltBinaryName,
            storage: this.ctx.globalState,
-            version: Config.extensionVersion,
+            tag: Config.extensionVersion,
+            askBeforeDownload: this.cfg.get("updates.askBeforeDownload") as boolean,
            repo: {
                name: "rust-analyzer",
                owner: "rust-analyzer",
@@ -153,6 +154,7 @@ export class Config {
    get excludeGlobs() { return this.cfg.get("excludeGlobs") as string[]; }
    get useClientWatching() { return this.cfg.get("useClientWatching") as boolean; }
    get featureFlags() { return this.cfg.get("featureFlags") as Record<string, boolean>; }
+    get additionalOutDirs() { return this.cfg.get("additionalOutDirs") as Record<string, string>; }
    get rustfmtArgs() { return this.cfg.get("rustfmtArgs") as string[]; }
    get cargoWatchOptions(): CargoWatchOptions {
diff --git a/editors/code/src/ctx.ts b/editors/code/src/ctx.ts
index b4e983a0c..25ef38aed 100644
--- a/editors/code/src/ctx.ts
+++ b/editors/code/src/ctx.ts
@@ -3,7 +3,7 @@ import * as lc from 'vscode-languageclient';
 import { Config } from './config';
 import { createClient } from './client';
-import { isRustDocument } from './util';
+import { isRustEditor, RustEditor } from './util';
 export class Ctx {
    private constructor(
@@ -22,17 +22,15 @@ export class Ctx {
        return res;
    }
-    get activeRustEditor(): vscode.TextEditor | undefined {
+    get activeRustEditor(): RustEditor | undefined {
        const editor = vscode.window.activeTextEditor;
-        return editor && isRustDocument(editor.document)
+        return editor && isRustEditor(editor)
            ? editor
            : undefined;
    }
-    get visibleRustEditors(): vscode.TextEditor[] {
+    get visibleRustEditors(): RustEditor[] {
-        return vscode.window.visibleTextEditors.filter(
+        return vscode.window.visibleTextEditors.filter(isRustEditor);
-            editor => isRustDocument(editor.document),
-        );
    }
    registerCommand(name: string, factory: (ctx: Ctx) => Cmd) {
diff --git a/editors/code/src/inlay_hints.ts b/editors/code/src/inlay_hints.ts
index 08d3a64a7..e1a82e03e 100644
--- a/editors/code/src/inlay_hints.ts
+++ b/editors/code/src/inlay_hints.ts
@@ -1,156 +1,214 @@
+import * as lc from "vscode-languageclient";
 import * as vscode from 'vscode';
 import * as ra from './rust-analyzer-api';
-import { Ctx } from './ctx';
+import { Ctx, Disposable } from './ctx';
-import { log, sendRequestWithRetry, isRustDocument } from './util';
+import { sendRequestWithRetry, isRustDocument, RustDocument, RustEditor } from './util';
-export function activateInlayHints(ctx: Ctx) {
-    const hintsUpdater = new HintsUpdater(ctx);
-    vscode.window.onDidChangeVisibleTextEditors(
-        async _ => hintsUpdater.refresh(),
-        null,
-        ctx.subscriptions
-    );
-    vscode.workspace.onDidChangeTextDocument(
+export function activateInlayHints(ctx: Ctx) {
-        async event => {
+    const maybeUpdater = {
-            if (event.contentChanges.length === 0) return;
+        updater: null as null | HintsUpdater,
-            if (!isRustDocument(event.document)) return;
+        onConfigChange() {
-            await hintsUpdater.refresh();
+            if (!ctx.config.displayInlayHints) {
+                return this.dispose();
+            }
+            if (!this.updater) this.updater = new HintsUpdater(ctx);
        },
-        null,
+        dispose() {
-        ctx.subscriptions
+            this.updater?.dispose();
-    );
+            this.updater = null;
+        }
+    };
+    ctx.pushCleanup(maybeUpdater);
    vscode.workspace.onDidChangeConfiguration(
-        async _ => hintsUpdater.setEnabled(ctx.config.displayInlayHints),
+        maybeUpdater.onConfigChange, maybeUpdater, ctx.subscriptions
-        null,
-        ctx.subscriptions
    );
-    ctx.pushCleanup({
+    maybeUpdater.onConfigChange();
-        dispose() {
+}
-            hintsUpdater.clear();
+const typeHints = {
+    decorationType: vscode.window.createTextEditorDecorationType({
+        after: {
+            color: new vscode.ThemeColor('rust_analyzer.inlayHint'),
+            fontStyle: "normal",
        }
-    });
+    }),
-    // XXX: we don't await this, thus Promise rejections won't be handled, but
+    toDecoration(hint: ra.InlayHint.TypeHint, conv: lc.Protocol2CodeConverter): vscode.DecorationOptions {
-    // this should never throw in fact...
+        return {
-    void hintsUpdater.setEnabled(ctx.config.displayInlayHints);
+            range: conv.asRange(hint.range),
-}
+            renderOptions: { after: { contentText: `: ${hint.label}` } }
+        };
+    }
+};
+const paramHints = {
+    decorationType: vscode.window.createTextEditorDecorationType({
+        before: {
+            color: new vscode.ThemeColor('rust_analyzer.inlayHint'),
+            fontStyle: "normal",
+        }
+    }),
-const typeHintDecorationType = vscode.window.createTextEditorDecorationType({
+    toDecoration(hint: ra.InlayHint.ParamHint, conv: lc.Protocol2CodeConverter): vscode.DecorationOptions {
-    after: {
+        return {
-        color: new vscode.ThemeColor('rust_analyzer.inlayHint'),
+            range: conv.asRange(hint.range),
-        fontStyle: "normal",
+            renderOptions: { before: { contentText: `${hint.label}: ` } }
-    },
+        };
-});
-const parameterHintDecorationType = vscode.window.createTextEditorDecorationType({
-    before: {
-        color: new vscode.ThemeColor('rust_analyzer.inlayHint'),
-        fontStyle: "normal",
-    },
-});
-class HintsUpdater {
-    private pending = new Map<string, vscode.CancellationTokenSource>();
-    private ctx: Ctx;
-    private enabled: boolean;
-    constructor(ctx: Ctx) {
-        this.ctx = ctx;
-        this.enabled = false;
    }
+};
-    async setEnabled(enabled: boolean): Promise<void> {
+class HintsUpdater implements Disposable {
-        log.debug({ enabled, prev: this.enabled });
+    private sourceFiles = new Map<string, RustSourceFile>(); // map Uri -> RustSourceFile
+    private readonly disposables: Disposable[] = [];
-        if (this.enabled === enabled) return;
+    constructor(private readonly ctx: Ctx) {
-        this.enabled = enabled;
+        vscode.window.onDidChangeVisibleTextEditors(
+            this.onDidChangeVisibleTextEditors,
+            this,
+            this.disposables
+        );
-        if (this.enabled) {
+        vscode.workspace.onDidChangeTextDocument(
-            return await this.refresh();
+            this.onDidChangeTextDocument,
-        } else {
+            this,
-            return this.clear();
+            this.disposables
-        }
+        );
+        // Set up initial cache shape
+        ctx.visibleRustEditors.forEach(editor => this.sourceFiles.set(
+            editor.document.uri.toString(),
+            {
+                document: editor.document,
+                inlaysRequest: null,
+                cachedDecorations: null
+            }
+        ));
+        this.syncCacheAndRenderHints();
    }
-    clear() {
+    dispose() {
-        this.ctx.visibleRustEditors.forEach(it => {
+        this.sourceFiles.forEach(file => file.inlaysRequest?.cancel());
-            this.setTypeDecorations(it, []);
+        this.ctx.visibleRustEditors.forEach(editor => this.renderDecorations(editor, { param: [], type: [] }));
-            this.setParameterDecorations(it, []);
+        this.disposables.forEach(d => d.dispose());
-        });
+    }
+    onDidChangeTextDocument({ contentChanges, document }: vscode.TextDocumentChangeEvent) {
+        if (contentChanges.length === 0 || !isRustDocument(document)) return;
+        this.syncCacheAndRenderHints();
    }
-    async refresh() {
+    private syncCacheAndRenderHints() {
-        if (!this.enabled) return;
+        // FIXME: make inlayHints request pass an array of files?
-        await Promise.all(this.ctx.visibleRustEditors.map(it => this.refreshEditor(it)));
+        this.sourceFiles.forEach((file, uri) => this.fetchHints(file).then(hints => {
+            if (!hints) return;
+            file.cachedDecorations = this.hintsToDecorations(hints);
+            for (const editor of this.ctx.visibleRustEditors) {
+                if (editor.document.uri.toString() === uri) {
+                    this.renderDecorations(editor, file.cachedDecorations);
+                }
+            }
+        }));
    }
-    private async refreshEditor(editor: vscode.TextEditor): Promise<void> {
+    onDidChangeVisibleTextEditors() {
-        const newHints = await this.queryHints(editor.document.uri.toString());
+        const newSourceFiles = new Map<string, RustSourceFile>();
-        if (newHints == null) return;
+        // Rerendering all, even up-to-date editors for simplicity
-        const newTypeDecorations = newHints
+        this.ctx.visibleRustEditors.forEach(async editor => {
-            .filter(hint => hint.kind === ra.InlayKind.TypeHint)
+            const uri = editor.document.uri.toString();
-            .map(hint => ({
+            const file = this.sourceFiles.get(uri) ?? {
-                range: this.ctx.client.protocol2CodeConverter.asRange(hint.range),
+                document: editor.document,
-                renderOptions: {
+                inlaysRequest: null,
-                    after: {
+                cachedDecorations: null
-                        contentText: `: ${hint.label}`,
+            };
-                    },
+            newSourceFiles.set(uri, file);
-                },
-            }));
+            // No text documents changed, so we may try to use the cache
-        this.setTypeDecorations(editor, newTypeDecorations);
+            if (!file.cachedDecorations) {
+                file.inlaysRequest?.cancel();
-        const newParameterDecorations = newHints
-            .filter(hint => hint.kind === ra.InlayKind.ParameterHint)
+                const hints = await this.fetchHints(file);
-            .map(hint => ({
+                if (!hints) return;
-                range: this.ctx.client.protocol2CodeConverter.asRange(hint.range),
-                renderOptions: {
+                file.cachedDecorations = this.hintsToDecorations(hints);
-                    before: {
+            }
-                        contentText: `${hint.label}: `,
-                    },
+            this.renderDecorations(editor, file.cachedDecorations);
-                },
+        });
-            }));
-        this.setParameterDecorations(editor, newParameterDecorations);
+        // Cancel requests for no longer visible (disposed) source files
+        this.sourceFiles.forEach((file, uri) => {
+            if (!newSourceFiles.has(uri)) file.inlaysRequest?.cancel();
+        });
+        this.sourceFiles = newSourceFiles;
    }
-    private setTypeDecorations(
+    private renderDecorations(editor: RustEditor, decorations: InlaysDecorations) {
-        editor: vscode.TextEditor,
+        editor.setDecorations(typeHints.decorationType, decorations.type);
-        decorations: vscode.DecorationOptions[],
+        editor.setDecorations(paramHints.decorationType, decorations.param);
-    ) {
-        editor.setDecorations(
-            typeHintDecorationType,
-            this.enabled ? decorations : [],
-        );
    }
-    private setParameterDecorations(
+    private hintsToDecorations(hints: ra.InlayHint[]): InlaysDecorations {
-        editor: vscode.TextEditor,
+        const decorations: InlaysDecorations = { type: [], param: [] };
-        decorations: vscode.DecorationOptions[],
+        const conv = this.ctx.client.protocol2CodeConverter;
-    ) {
-        editor.setDecorations(
+        for (const hint of hints) {
-            parameterHintDecorationType,
+            switch (hint.kind) {
-            this.enabled ? decorations : [],
+                case ra.InlayHint.Kind.TypeHint: {
-        );
+                    decorations.type.push(typeHints.toDecoration(hint, conv));
+                    continue;
+                }
+                case ra.InlayHint.Kind.ParamHint: {
+                    decorations.param.push(paramHints.toDecoration(hint, conv));
+                    continue;
+                }
+            }
+        }
+        return decorations;
    }
-    private async queryHints(documentUri: string): Promise<ra.InlayHint[] | null> {
+    private async fetchHints(file: RustSourceFile): Promise<null | ra.InlayHint[]> {
-        this.pending.get(documentUri)?.cancel();
+        file.inlaysRequest?.cancel();
        const tokenSource = new vscode.CancellationTokenSource();
-        this.pending.set(documentUri, tokenSource);
+        file.inlaysRequest = tokenSource;
-        const request = { textDocument: { uri: documentUri } };
+        const request = { textDocument: { uri: file.document.uri.toString() } };
        return sendRequestWithRetry(this.ctx.client, ra.inlayHints, request, tokenSource.token)
            .catch(_ => null)
            .finally(() => {
-                if (!tokenSource.token.isCancellationRequested) {
+                if (file.inlaysRequest === tokenSource) {
-                    this.pending.delete(documentUri);
+                    file.inlaysRequest = null;
                }
            });
    }
 }
+interface InlaysDecorations {
+    type: vscode.DecorationOptions[];
+    param: vscode.DecorationOptions[];
+}
+interface RustSourceFile {
+    /*
+    * Source of the token to cancel in-flight inlay hints request if any.
+    */
+    inlaysRequest: null | vscode.CancellationTokenSource;
+    /**
+    * Last applied decorations.
+    */
+    cachedDecorations: null | InlaysDecorations;
+    document: RustDocument;
+}
diff --git a/editors/code/src/installation/interfaces.ts b/editors/code/src/installation/interfaces.ts
index e40839e4b..50b635921 100644
--- a/editors/code/src/installation/interfaces.ts
+++ b/editors/code/src/installation/interfaces.ts
@@ -14,14 +14,14 @@ export interface ArtifactReleaseInfo {
 }
 /**
- * Represents the source of a binary artifact which is either specified by the user
+ * Represents the source of a an artifact which is either specified by the user
 * explicitly, or bundled by this extension from GitHub releases.
 */
-export type BinarySource = BinarySource.ExplicitPath | BinarySource.GithubRelease;
+export type ArtifactSource = ArtifactSource.ExplicitPath | ArtifactSource.GithubRelease;
-export namespace BinarySource {
+export namespace ArtifactSource {
    /**
-     * Type tag for `BinarySource` discriminated union.
+     * Type tag for `ArtifactSource` discriminated union.
     */
    export const enum Type { ExplicitPath, GithubRelease }
@@ -56,13 +56,18 @@ export namespace BinarySource {
        /**
         * Tag of github release that denotes a version required by this extension.
         */
-        version: string;
+        tag: string;
        /**
         * Object that provides `get()/update()` operations to store metadata
         * about the actual binary, e.g. its actual version.
         */
        storage: vscode.Memento;
+        /**
+         * Ask for the user permission before downloading the artifact.
+         */
+        askBeforeDownload: boolean;
    }
 }
diff --git a/editors/code/src/installation/server.ts b/editors/code/src/installation/server.ts
index 6a6cf4f8c..ef1c45ff6 100644
--- a/editors/code/src/installation/server.ts
+++ b/editors/code/src/installation/server.ts
@@ -3,12 +3,12 @@ import * as path from "path";
 import { promises as dns } from "dns";
 import { spawnSync } from "child_process";
-import { BinarySource } from "./interfaces";
+import { ArtifactSource } from "./interfaces";
 import { fetchArtifactReleaseInfo } from "./fetch_artifact_release_info";
 import { downloadArtifact } from "./download_artifact";
 import { log, assert } from "../util";
-export async function ensureServerBinary(source: null | BinarySource): Promise<null | string> {
+export async function ensureServerBinary(source: null | ArtifactSource): Promise<null | string> {
    if (!source) {
        vscode.window.showErrorMessage(
            "Unfortunately we don't ship binaries for your platform yet. " +
@@ -22,7 +22,7 @@ export async function ensureServerBinary(source: null | BinarySource): Promise<n
    }
    switch (source.type) {
-        case BinarySource.Type.ExplicitPath: {
+        case ArtifactSource.Type.ExplicitPath: {
            if (isBinaryAvailable(source.path)) {
                return source.path;
            }
@@ -34,11 +34,11 @@ export async function ensureServerBinary(source: null | BinarySource): Promise<n
            );
            return null;
        }
-        case BinarySource.Type.GithubRelease: {
+        case ArtifactSource.Type.GithubRelease: {
            const prebuiltBinaryPath = path.join(source.dir, source.file);
            const installedVersion: null | string = getServerVersion(source.storage);
-            const requiredVersion: string = source.version;
+            const requiredVersion: string = source.tag;
            log.debug("Installed version:", installedVersion, "required:", requiredVersion);
@@ -46,12 +46,14 @@ export async function ensureServerBinary(source: null | BinarySource): Promise<n
                return prebuiltBinaryPath;
            }
-            const userResponse = await vscode.window.showInformationMessage(
+            if (source.askBeforeDownload) {
-                `Language server version ${source.version} for rust-analyzer is not installed. ` +
+                const userResponse = await vscode.window.showInformationMessage(
-                "Do you want to download it now?",
+                    `Language server version ${source.tag} for rust-analyzer is not installed. ` +
-                "Download now", "Cancel"
+                    "Do you want to download it now?",
-            );
+                    "Download now", "Cancel"
-            if (userResponse !== "Download now") return null;
+                );
+                if (userResponse !== "Download now") return null;
+            }
            if (!await downloadServer(source)) return null;
@@ -60,9 +62,9 @@ export async function ensureServerBinary(source: null | BinarySource): Promise<n
    }
 }
-async function downloadServer(source: BinarySource.GithubRelease): Promise<boolean> {
+async function downloadServer(source: ArtifactSource.GithubRelease): Promise<boolean> {
    try {
-        const releaseInfo = await fetchArtifactReleaseInfo(source.repo, source.file, source.version);
+        const releaseInfo = await fetchArtifactReleaseInfo(source.repo, source.file, source.tag);
        await downloadArtifact(releaseInfo, source.file, source.dir, "language server");
        await setServerVersion(source.storage, releaseInfo.releaseName);
diff --git a/editors/code/src/rust-analyzer-api.ts b/editors/code/src/rust-analyzer-api.ts
index c5a010e94..bd6e3ada0 100644
--- a/editors/code/src/rust-analyzer-api.ts
+++ b/editors/code/src/rust-analyzer-api.ts
@@ -86,14 +86,20 @@ export interface Runnable {
 export const runnables = request<RunnablesParams, Vec<Runnable>>("runnables");
-export const enum InlayKind {
-    TypeHint = "TypeHint",
+export type InlayHint = InlayHint.TypeHint | InlayHint.ParamHint;
-    ParameterHint = "ParameterHint",
-}
+export namespace InlayHint {
-export interface InlayHint {
+    export const enum Kind {
-    range: lc.Range;
+        TypeHint = "TypeHint",
-    kind: InlayKind;
+        ParamHint = "ParameterHint",
-    label: string;
+    }
+    interface Common {
+        range: lc.Range;
+        label: string;
+    }
+    export type TypeHint = Common & { kind: Kind.TypeHint };
+    export type ParamHint = Common & { kind: Kind.ParamHint };
 }
 export interface InlayHintsParams {
    textDocument: lc.TextDocumentIdentifier;
diff --git a/editors/code/src/util.ts b/editors/code/src/util.ts
index 7c95769bb..95a5f1227 100644
--- a/editors/code/src/util.ts
+++ b/editors/code/src/util.ts
@@ -1,7 +1,6 @@
 import * as lc from "vscode-languageclient";
 import * as vscode from "vscode";
 import { strict as nativeAssert } from "assert";
-import { TextDocument } from "vscode";
 export function assert(condition: boolean, explanation: string): asserts condition {
    try {
@@ -67,9 +66,16 @@ function sleep(ms: number) {
    return new Promise(resolve => setTimeout(resolve, ms));
 }
-export function isRustDocument(document: TextDocument) {
+export type RustDocument = vscode.TextDocument & { languageId: "rust" };
+export type RustEditor = vscode.TextEditor & { document: RustDocument; id: string };
+export function isRustDocument(document: vscode.TextDocument): document is RustDocument {
    return document.languageId === 'rust'
        // SCM diff views have the same URI as the on-disk document but not the same content
        && document.uri.scheme !== 'git'
        && document.uri.scheme !== 'svn';
-}
-\ No newline at end of file
+}
+export function isRustEditor(editor: vscode.TextEditor): editor is RustEditor {
+    return isRustDocument(editor.document);
+}
diff --git a/xtask/src/dist.rs b/xtask/src/dist.rs
index 12bad820f..bb3593b11 100644
--- a/xtask/src/dist.rs
+++ b/xtask/src/dist.rs
@@ -27,7 +27,13 @@ fn dist_client(nightly: bool) -> Result<()> {
    let _restore =
        Restore { path: package_json_path.clone(), contents: original_package_json.clone() };
-    let mut package_json = original_package_json.replace(r#""enableProposedApi": true,"#, r#""#);
+    let date = run!("date --utc +%Y%m%d")?;
+    let version_suffix = if nightly { "-nightly" } else { "" };
+    let mut package_json = original_package_json.replace(
+        r#""version": "0.2.20200211-dev""#,
+        &format!(r#""version": "0.1.{}{}""#, date, version_suffix),
+    );
    if nightly {
        package_json = package_json.replace(
@@ -35,7 +41,7 @@ fn dist_client(nightly: bool) -> Result<()> {
            r#""displayName": "rust-analyzer nightly""#,
        );
    } else {
-        package_json = original_package_json.replace(r#""enableProposedApi": true,"#, r#""#);
+        package_json = package_json.replace(r#""enableProposedApi": true,"#, r#""#);
    }
    fs2::write(package_json_path, package_json)?;
@@ -47,10 +53,16 @@ fn dist_client(nightly: bool) -> Result<()> {
 fn dist_server() -> Result<()> {
    if cfg!(target_os = "linux") {
        std::env::set_var("CC", "clang");
-        run!("cargo build --package rust-analyzer --bin rust-analyzer --release --target x86_64-unknown-linux-musl")?;
+        run!(
+            "cargo build --manifest-path ./crates/rust-analyzer/Cargo.toml --bin rust-analyzer --release
+             --target x86_64-unknown-linux-musl
+            "
+            // We'd want to add, but that requires setting the right linker somehow
+            // --features=jemalloc
+        )?;
        run!("strip ./target/x86_64-unknown-linux-musl/release/rust-analyzer")?;
    } else {
-        run!("cargo build --package rust-analyzer --bin rust-analyzer --release")?;
+        run!("cargo build --manifest-path ./crates/rust-analyzer/Cargo.toml --bin rust-analyzer --release")?;
    }
    let (src, dst) = if cfg!(target_os = "linux") {