112 files changed, 4407 insertions, 3938 deletions
diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index ed9191c49..7f4e75341 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -116,9 +116,9 @@ jobs:
    - run: npm ci
      working-directory: ./editors/code
-    - run: npm audit || { sleep 10 && npm audit; } || { sleep 30 && npm audit; }
+#    - run: npm audit || { sleep 10 && npm audit; } || { sleep 30 && npm audit; }
-      if: runner.os == 'Linux'
+#      if: runner.os == 'Linux'
-      working-directory: ./editors/code
+#      working-directory: ./editors/code
    - run: npm run lint
      working-directory: ./editors/code
diff --git a/Cargo.lock b/Cargo.lock
index 9e0d0714a..61ae8157a 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -52,17 +52,6 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cff77d8686867eceff3105329d4698d96c2391c176d5d03adc90c7389162b5b8"
 [[package]]
-name = "atty"
-version = "0.2.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
-dependencies = [
- "hermit-abi",
- "libc",
- "winapi 0.3.9",
-]
-[[package]]
 name = "autocfg"
 version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -196,18 +185,6 @@ dependencies = [
 ]
 [[package]]
-name = "clicolors-control"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90082ee5dcdd64dc4e9e0d37fbf3ee325419e39c0092191e0393df65518f741e"
-dependencies = [
- "atty",
- "lazy_static",
- "libc",
- "winapi 0.3.9",
-]
-[[package]]
 name = "cloudabi"
 version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -218,11 +195,10 @@ dependencies = [
 [[package]]
 name = "console"
-version = "0.10.3"
+version = "0.11.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2586208b33573b7f76ccfbe5adb076394c88deaf81b84d7213969805b0a952a7"
+checksum = "8c0994e656bba7b922d8dd1245db90672ffb701e684e45be58f20719d69abc5a"
 dependencies = [
- "clicolors-control",
 "encode_unicode",
 "lazy_static",
 "libc",
@@ -352,6 +328,15 @@ dependencies = [
 ]
 [[package]]
+name = "expect"
+version = "0.1.0"
+dependencies = [
+ "difference",
+ "once_cell",
+ "stdx",
+]
+[[package]]
 name = "filetime"
 version = "0.2.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -544,9 +529,9 @@ dependencies = [
 [[package]]
 name = "insta"
-version = "0.16.0"
+version = "0.16.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8386e795fb3927131ea4cede203c529a333652eb6dc4ff29616b832b27e9b096"
+checksum = "617e921abc813f96a3b00958c079e7bf1e2db998f8a04f1546dd967373a418ee"
 dependencies = [
 "console",
 "difference",
@@ -1134,6 +1119,7 @@ name = "ra_ide"
 version = "0.1.0"
 dependencies = [
 "either",
+ "expect",
 "indexmap",
 "insta",
 "itertools",
@@ -1262,6 +1248,7 @@ dependencies = [
 "ra_syntax",
 "ra_text_edit",
 "rustc-hash",
+ "test_utils",
 ]
 [[package]]
@@ -1464,15 +1451,18 @@ dependencies = [
 "ra_hir_def",
 "ra_hir_ty",
 "ra_ide",
+ "ra_ide_db",
 "ra_mbe",
 "ra_proc_macro_srv",
 "ra_prof",
 "ra_project_model",
+ "ra_ssr",
 "ra_syntax",
 "ra_text_edit",
 "ra_toolchain",
 "ra_tt",
 "rand",
+ "rayon",
 "rustc-hash",
 "serde",
 "serde_json",
diff --git a/Cargo.toml b/Cargo.toml
index 5278b5a16..189f4ea2b 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -24,6 +24,8 @@ opt-level = 0
 opt-level = 0
 [profile.release.package.salsa-macros]
 opt-level = 0
+[profile.release.package.tracing-attributes]
+opt-level = 0
 [profile.release.package.xtask]
 opt-level = 0
diff --git a/crates/expect/Cargo.toml b/crates/expect/Cargo.toml
new file mode 100644
index 000000000..caee43106
--- /dev/null
+++ b/crates/expect/Cargo.toml
@@ -0,0 +1,10 @@
+[package]
+name = "expect"
+version = "0.1.0"
+authors = ["rust-analyzer developers"]
+edition = "2018"
+[dependencies]
+once_cell = "1"
+difference = "2"
+stdx = { path = "../stdx" }
diff --git a/crates/expect/src/lib.rs b/crates/expect/src/lib.rs
new file mode 100644
index 000000000..a5e26fade
--- /dev/null
+++ b/crates/expect/src/lib.rs
@@ -0,0 +1,348 @@
+//! Snapshot testing library, see
+//! https://github.com/rust-analyzer/rust-analyzer/pull/5101
+use std::{
+    collections::HashMap,
+    env, fmt, fs, mem,
+    ops::Range,
+    panic,
+    path::{Path, PathBuf},
+    sync::Mutex,
+};
+use difference::Changeset;
+use once_cell::sync::Lazy;
+use stdx::{lines_with_ends, trim_indent};
+const HELP: &str = "
+You can update all `expect![[]]` tests by running:
+    env UPDATE_EXPECT=1 cargo test
+To update a single test, place the cursor on `expect` token and use `run` feature of rust-analyzer.
+";
+fn update_expect() -> bool {
+    env::var("UPDATE_EXPECT").is_ok()
+}
+/// expect![[r#"inline snapshot"#]]
+#[macro_export]
+macro_rules! expect {
+    [[$data:literal]] => {$crate::Expect {
+        position: $crate::Position {
+            file: file!(),
+            line: line!(),
+            column: column!(),
+        },
+        data: $data,
+    }};
+    [[]] => { $crate::expect![[""]] };
+}
+/// expect_file!["/crates/foo/test_data/bar.html"]
+#[macro_export]
+macro_rules! expect_file {
+    [$path:literal] => {$crate::ExpectFile { path: $path }};
+}
+#[derive(Debug)]
+pub struct Expect {
+    pub position: Position,
+    pub data: &'static str,
+}
+#[derive(Debug)]
+pub struct ExpectFile {
+    pub path: &'static str,
+}
+#[derive(Debug)]
+pub struct Position {
+    pub file: &'static str,
+    pub line: u32,
+    pub column: u32,
+}
+impl fmt::Display for Position {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}:{}:{}", self.file, self.line, self.column)
+    }
+}
+impl Expect {
+    pub fn assert_eq(&self, actual: &str) {
+        let trimmed = self.trimmed();
+        if &trimmed == actual {
+            return;
+        }
+        Runtime::fail_expect(self, &trimmed, actual);
+    }
+    pub fn assert_debug_eq(&self, actual: &impl fmt::Debug) {
+        let actual = format!("{:#?}\n", actual);
+        self.assert_eq(&actual)
+    }
+    fn trimmed(&self) -> String {
+        if !self.data.contains('\n') {
+            return self.data.to_string();
+        }
+        trim_indent(self.data)
+    }
+    fn locate(&self, file: &str) -> Location {
+        let mut target_line = None;
+        let mut line_start = 0;
+        for (i, line) in lines_with_ends(file).enumerate() {
+            if i == self.position.line as usize - 1 {
+                let pat = "expect![[";
+                let offset = line.find(pat).unwrap();
+                let literal_start = line_start + offset + pat.len();
+                let indent = line.chars().take_while(|&it| it == ' ').count();
+                target_line = Some((literal_start, indent));
+                break;
+            }
+            line_start += line.len();
+        }
+        let (literal_start, line_indent) = target_line.unwrap();
+        let literal_length =
+            file[literal_start..].find("]]").expect("Couldn't find matching `]]` for `expect![[`.");
+        let literal_range = literal_start..literal_start + literal_length;
+        Location { line_indent, literal_range }
+    }
+}
+impl ExpectFile {
+    pub fn assert_eq(&self, actual: &str) {
+        let expected = self.read();
+        if actual == expected {
+            return;
+        }
+        Runtime::fail_file(self, &expected, actual);
+    }
+    fn read(&self) -> String {
+        fs::read_to_string(self.abs_path()).unwrap_or_default().replace("\r\n", "\n")
+    }
+    fn write(&self, contents: &str) {
+        fs::write(self.abs_path(), contents).unwrap()
+    }
+    fn abs_path(&self) -> PathBuf {
+        workspace_root().join(self.path)
+    }
+}
+#[derive(Default)]
+struct Runtime {
+    help_printed: bool,
+    per_file: HashMap<&'static str, FileRuntime>,
+}
+static RT: Lazy<Mutex<Runtime>> = Lazy::new(Default::default);
+impl Runtime {
+    fn fail_expect(expect: &Expect, expected: &str, actual: &str) {
+        let mut rt = RT.lock().unwrap_or_else(|poisoned| poisoned.into_inner());
+        if update_expect() {
+            println!("\x1b[1m\x1b[92mupdating\x1b[0m: {}", expect.position);
+            rt.per_file
+                .entry(expect.position.file)
+                .or_insert_with(|| FileRuntime::new(expect))
+                .update(expect, actual);
+            return;
+        }
+        rt.panic(expect.position.to_string(), expected, actual);
+    }
+    fn fail_file(expect: &ExpectFile, expected: &str, actual: &str) {
+        let mut rt = RT.lock().unwrap_or_else(|poisoned| poisoned.into_inner());
+        if update_expect() {
+            println!("\x1b[1m\x1b[92mupdating\x1b[0m: {}", expect.path);
+            expect.write(actual);
+            return;
+        }
+        rt.panic(expect.path.to_string(), expected, actual);
+    }
+    fn panic(&mut self, position: String, expected: &str, actual: &str) {
+        let print_help = !mem::replace(&mut self.help_printed, true);
+        let help = if print_help { HELP } else { "" };
+        let diff = Changeset::new(actual, expected, "\n");
+        println!(
+            "\n
+\x1b[1m\x1b[91merror\x1b[97m: expect test failed\x1b[0m
+   \x1b[1m\x1b[34m-->\x1b[0m {}
+{}
+\x1b[1mExpect\x1b[0m:
+----
+{}
+----
+\x1b[1mActual\x1b[0m:
+----
+{}
+----
+\x1b[1mDiff\x1b[0m:
+----
+{}
+----
+",
+            position, help, expected, actual, diff
+        );
+        // Use resume_unwind instead of panic!() to prevent a backtrace, which is unnecessary noise.
+        panic::resume_unwind(Box::new(()));
+    }
+}
+struct FileRuntime {
+    path: PathBuf,
+    original_text: String,
+    patchwork: Patchwork,
+}
+impl FileRuntime {
+    fn new(expect: &Expect) -> FileRuntime {
+        let path = workspace_root().join(expect.position.file);
+        let original_text = fs::read_to_string(&path).unwrap();
+        let patchwork = Patchwork::new(original_text.clone());
+        FileRuntime { path, original_text, patchwork }
+    }
+    fn update(&mut self, expect: &Expect, actual: &str) {
+        let loc = expect.locate(&self.original_text);
+        let patch = format_patch(loc.line_indent.clone(), actual);
+        self.patchwork.patch(loc.literal_range, &patch);
+        fs::write(&self.path, &self.patchwork.text).unwrap()
+    }
+}
+#[derive(Debug)]
+struct Location {
+    line_indent: usize,
+    literal_range: Range<usize>,
+}
+#[derive(Debug)]
+struct Patchwork {
+    text: String,
+    indels: Vec<(Range<usize>, usize)>,
+}
+impl Patchwork {
+    fn new(text: String) -> Patchwork {
+        Patchwork { text, indels: Vec::new() }
+    }
+    fn patch(&mut self, mut range: Range<usize>, patch: &str) {
+        self.indels.push((range.clone(), patch.len()));
+        self.indels.sort_by_key(|(delete, _insert)| delete.start);
+        let (delete, insert) = self
+            .indels
+            .iter()
+            .take_while(|(delete, _)| delete.start < range.start)
+            .map(|(delete, insert)| (delete.end - delete.start, insert))
+            .fold((0usize, 0usize), |(x1, y1), (x2, y2)| (x1 + x2, y1 + y2));
+        for pos in &mut [&mut range.start, &mut range.end] {
+            **pos -= delete;
+            **pos += insert;
+        }
+        self.text.replace_range(range, &patch);
+    }
+}
+fn format_patch(line_indent: usize, patch: &str) -> String {
+    let mut max_hashes = 0;
+    let mut cur_hashes = 0;
+    for byte in patch.bytes() {
+        if byte != b'#' {
+            cur_hashes = 0;
+            continue;
+        }
+        cur_hashes += 1;
+        max_hashes = max_hashes.max(cur_hashes);
+    }
+    let hashes = &"#".repeat(max_hashes + 1);
+    let indent = &" ".repeat(line_indent);
+    let is_multiline = patch.contains('\n');
+    let mut buf = String::new();
+    buf.push('r');
+    buf.push_str(hashes);
+    buf.push('"');
+    if is_multiline {
+        buf.push('\n');
+    }
+    let mut final_newline = false;
+    for line in lines_with_ends(patch) {
+        if is_multiline {
+            buf.push_str(indent);
+            buf.push_str("    ");
+        }
+        buf.push_str(line);
+        final_newline = line.ends_with('\n');
+    }
+    if final_newline {
+        buf.push_str(indent);
+    }
+    buf.push('"');
+    buf.push_str(hashes);
+    buf
+}
+fn workspace_root() -> PathBuf {
+    Path::new(
+        &env::var("CARGO_MANIFEST_DIR").unwrap_or_else(|_| env!("CARGO_MANIFEST_DIR").to_owned()),
+    )
+    .ancestors()
+    .nth(2)
+    .unwrap()
+    .to_path_buf()
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn test_format_patch() {
+        let patch = format_patch(0, "hello\nworld\n");
+        expect![[r##"
+            r#"
+                hello
+                world
+            "#"##]]
+        .assert_eq(&patch);
+        let patch = format_patch(4, "single line");
+        expect![[r##"r#"single line"#"##]].assert_eq(&patch);
+    }
+    #[test]
+    fn test_patchwork() {
+        let mut patchwork = Patchwork::new("one two three".to_string());
+        patchwork.patch(4..7, "zwei");
+        patchwork.patch(0..3, "один");
+        patchwork.patch(8..13, "3");
+        expect![[r#"
+            Patchwork {
+                text: "один zwei 3",
+                indels: [
+                    (
+                        0..3,
+                        8,
+                    ),
+                    (
+                        4..7,
+                        4,
+                    ),
+                    (
+                        8..13,
+                        1,
+                    ),
+                ],
+            }
+        "#]]
+        .assert_debug_eq(&patchwork);
+    }
+}
diff --git a/crates/flycheck/src/lib.rs b/crates/flycheck/src/lib.rs
index 1023d3040..844b093d4 100644
--- a/crates/flycheck/src/lib.rs
+++ b/crates/flycheck/src/lib.rs
@@ -132,6 +132,7 @@ impl FlycheckActor {
                    self.cancel_check_process();
                    let mut command = self.check_command();
+                    log::info!("restart flycheck {:?}", command);
                    command.stdout(Stdio::piped()).stderr(Stdio::null()).stdin(Stdio::null());
                    if let Ok(child) = command.spawn().map(JodChild) {
                        self.cargo_handle = Some(CargoHandle::spawn(child));
diff --git a/crates/ra_assists/src/assist_context.rs b/crates/ra_assists/src/assist_context.rs
index ee614de72..3640bb4d2 100644
--- a/crates/ra_assists/src/assist_context.rs
+++ b/crates/ra_assists/src/assist_context.rs
@@ -55,7 +55,6 @@ use crate::{
 pub(crate) struct AssistContext<'a> {
    pub(crate) config: &'a AssistConfig,
    pub(crate) sema: Semantics<'a, RootDatabase>,
-    pub(crate) db: &'a RootDatabase,
    pub(crate) frange: FileRange,
    source_file: SourceFile,
 }
@@ -67,8 +66,11 @@ impl<'a> AssistContext<'a> {
        frange: FileRange,
    ) -> AssistContext<'a> {
        let source_file = sema.parse(frange.file_id);
-        let db = sema.db;
+        AssistContext { config, sema, frange, source_file }
-        AssistContext { config, sema, db, frange, source_file }
+    }
+    pub(crate) fn db(&self) -> &RootDatabase {
+        self.sema.db
    }
    // NB, this ignores active selection.
diff --git a/crates/ra_assists/src/ast_transform.rs b/crates/ra_assists/src/ast_transform.rs
index 00fa95b6c..01adb834c 100644
--- a/crates/ra_assists/src/ast_transform.rs
+++ b/crates/ra_assists/src/ast_transform.rs
@@ -2,7 +2,6 @@
 use rustc_hash::FxHashMap;
 use hir::{HirDisplay, PathResolution, SemanticsScope};
-use ra_ide_db::RootDatabase;
 use ra_syntax::{
    algo::SyntaxRewriter,
    ast::{self, AstNode},
@@ -32,14 +31,14 @@ impl<'a> AstTransform<'a> for NullTransformer {
 }
 pub struct SubstituteTypeParams<'a> {
-    source_scope: &'a SemanticsScope<'a, RootDatabase>,
+    source_scope: &'a SemanticsScope<'a>,
    substs: FxHashMap<hir::TypeParam, ast::TypeRef>,
    previous: Box<dyn AstTransform<'a> + 'a>,
 }
 impl<'a> SubstituteTypeParams<'a> {
    pub fn for_trait_impl(
-        source_scope: &'a SemanticsScope<'a, RootDatabase>,
+        source_scope: &'a SemanticsScope<'a>,
        // FIXME: there's implicit invariant that `trait_` and  `source_scope` match...
        trait_: hir::Trait,
        impl_def: ast::ImplDef,
@@ -126,16 +125,13 @@ impl<'a> AstTransform<'a> for SubstituteTypeParams<'a> {
 }
 pub struct QualifyPaths<'a> {
-    target_scope: &'a SemanticsScope<'a, RootDatabase>,
+    target_scope: &'a SemanticsScope<'a>,
-    source_scope: &'a SemanticsScope<'a, RootDatabase>,
+    source_scope: &'a SemanticsScope<'a>,
    previous: Box<dyn AstTransform<'a> + 'a>,
 }
 impl<'a> QualifyPaths<'a> {
-    pub fn new(
+    pub fn new(target_scope: &'a SemanticsScope<'a>, source_scope: &'a SemanticsScope<'a>) -> Self {
-        target_scope: &'a SemanticsScope<'a, RootDatabase>,
-        source_scope: &'a SemanticsScope<'a, RootDatabase>,
-    ) -> Self {
        Self { target_scope, source_scope, previous: Box::new(NullTransformer) }
    }
@@ -156,7 +152,7 @@ impl<'a> QualifyPaths<'a> {
        let resolution = self.source_scope.resolve_hir_path(&hir_path?)?;
        match resolution {
            PathResolution::Def(def) => {
-                let found_path = from.find_use_path(self.source_scope.db, def)?;
+                let found_path = from.find_use_path(self.source_scope.db.upcast(), def)?;
                let mut path = path_to_ast(found_path);
                let type_args = p
diff --git a/crates/ra_assists/src/handlers/add_explicit_type.rs b/crates/ra_assists/src/handlers/add_explicit_type.rs
index 90b06a625..11df922a2 100644
--- a/crates/ra_assists/src/handlers/add_explicit_type.rs
+++ b/crates/ra_assists/src/handlers/add_explicit_type.rs
@@ -57,7 +57,7 @@ pub(crate) fn add_explicit_type(acc: &mut Assists, ctx: &AssistContext) -> Optio
        return None;
    }
-    let inferred_type = ty.display_source_code(ctx.db, module.into()).ok()?;
+    let inferred_type = ty.display_source_code(ctx.db(), module.into()).ok()?;
    acc.add(
        AssistId("add_explicit_type"),
        format!("Insert explicit type `{}`", inferred_type),
diff --git a/crates/ra_assists/src/handlers/add_function.rs b/crates/ra_assists/src/handlers/add_function.rs
index 1cfbd75aa..fc4e82309 100644
--- a/crates/ra_assists/src/handlers/add_function.rs
+++ b/crates/ra_assists/src/handlers/add_function.rs
@@ -117,7 +117,7 @@ impl FunctionBuilder {
        let mut file = ctx.frange.file_id;
        let target = match &target_module {
            Some(target_module) => {
-                let module_source = target_module.definition_source(ctx.db);
+                let module_source = target_module.definition_source(ctx.db());
                let (in_file, target) = next_space_for_fn_in_module(ctx.sema.db, &module_source)?;
                file = in_file;
                target
@@ -269,7 +269,7 @@ fn fn_arg_type(
        return None;
    }
-    if let Ok(rendered) = ty.display_source_code(ctx.db, target_module.into()) {
+    if let Ok(rendered) = ty.display_source_code(ctx.db(), target_module.into()) {
        Some(rendered)
    } else {
        None
diff --git a/crates/ra_assists/src/handlers/add_missing_impl_members.rs b/crates/ra_assists/src/handlers/add_missing_impl_members.rs
index abacd4065..77e092f62 100644
--- a/crates/ra_assists/src/handlers/add_missing_impl_members.rs
+++ b/crates/ra_assists/src/handlers/add_missing_impl_members.rs
@@ -128,9 +128,9 @@ fn add_missing_impl_members_inner(
    let missing_items = get_missing_assoc_items(&ctx.sema, &impl_def)
        .iter()
        .map(|i| match i {
-            hir::AssocItem::Function(i) => ast::AssocItem::FnDef(i.source(ctx.db).value),
+            hir::AssocItem::Function(i) => ast::AssocItem::FnDef(i.source(ctx.db()).value),
-            hir::AssocItem::TypeAlias(i) => ast::AssocItem::TypeAliasDef(i.source(ctx.db).value),
+            hir::AssocItem::TypeAlias(i) => ast::AssocItem::TypeAliasDef(i.source(ctx.db()).value),
-            hir::AssocItem::Const(i) => ast::AssocItem::ConstDef(i.source(ctx.db).value),
+            hir::AssocItem::Const(i) => ast::AssocItem::ConstDef(i.source(ctx.db()).value),
        })
        .filter(|t| def_name(&t).is_some())
        .filter(|t| match t {
diff --git a/crates/ra_assists/src/handlers/add_new.rs b/crates/ra_assists/src/handlers/add_new.rs
index 837aa8377..e41b2aa06 100644
--- a/crates/ra_assists/src/handlers/add_new.rs
+++ b/crates/ra_assists/src/handlers/add_new.rs
@@ -122,7 +122,7 @@ fn generate_impl_text(strukt: &ast::StructDef, code: &str) -> String {
 // FIXME: change the new fn checking to a more semantic approach when that's more
 // viable (e.g. we process proc macros, etc)
 fn find_struct_impl(ctx: &AssistContext, strukt: &ast::StructDef) -> Option<Option<ast::ImplDef>> {
-    let db = ctx.db;
+    let db = ctx.db();
    let module = strukt.syntax().ancestors().find(|node| {
        ast::Module::can_cast(node.kind()) || ast::SourceFile::can_cast(node.kind())
    })?;
diff --git a/crates/ra_assists/src/handlers/auto_import.rs b/crates/ra_assists/src/handlers/auto_import.rs
index d1cafa7d9..7b6499a08 100644
--- a/crates/ra_assists/src/handlers/auto_import.rs
+++ b/crates/ra_assists/src/handlers/auto_import.rs
@@ -5,7 +5,7 @@ use hir::{
    AsAssocItem, AssocItemContainer, ModPath, Module, ModuleDef, PathResolution, Semantics, Trait,
    Type,
 };
-use ra_ide_db::{imports_locator::ImportsLocator, RootDatabase};
+use ra_ide_db::{imports_locator, RootDatabase};
 use ra_prof::profile;
 use ra_syntax::{
    ast::{self, AstNode},
@@ -35,8 +35,8 @@ use crate::{utils::insert_use_statement, AssistContext, AssistId, Assists, Group
 // # pub mod std { pub mod collections { pub struct HashMap { } } }
 // ```
 pub(crate) fn auto_import(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
-    let auto_import_assets = AutoImportAssets::new(&ctx)?;
+    let auto_import_assets = AutoImportAssets::new(ctx)?;
-    let proposed_imports = auto_import_assets.search_for_imports(ctx.db);
+    let proposed_imports = auto_import_assets.search_for_imports(ctx);
    if proposed_imports.is_empty() {
        return None;
    }
@@ -127,11 +127,11 @@ impl AutoImportAssets {
        GroupLabel(name)
    }
-    fn search_for_imports(&self, db: &RootDatabase) -> BTreeSet<ModPath> {
+    fn search_for_imports(&self, ctx: &AssistContext) -> BTreeSet<ModPath> {
        let _p = profile("auto_import::search_for_imports");
+        let db = ctx.db();
        let current_crate = self.module_with_name_to_import.krate();
-        ImportsLocator::new(db, current_crate)
+        imports_locator::find_imports(&ctx.sema, current_crate, &self.get_search_query())
-            .find_imports(&self.get_search_query())
            .into_iter()
            .filter_map(|candidate| match &self.import_candidate {
                ImportCandidate::TraitAssocItem(assoc_item_type, _) => {
diff --git a/crates/ra_assists/src/handlers/extract_struct_from_enum_variant.rs b/crates/ra_assists/src/handlers/extract_struct_from_enum_variant.rs
index 43b4584b4..ca19cf198 100644
--- a/crates/ra_assists/src/handlers/extract_struct_from_enum_variant.rs
+++ b/crates/ra_assists/src/handlers/extract_struct_from_enum_variant.rs
@@ -37,15 +37,15 @@ pub(crate) fn extract_struct_from_enum_variant(
    };
    let variant_name = variant.name()?.to_string();
    let variant_hir = ctx.sema.to_def(&variant)?;
-    if existing_struct_def(ctx.db, &variant_name, &variant_hir) {
+    if existing_struct_def(ctx.db(), &variant_name, &variant_hir) {
        return None;
    }
    let enum_ast = variant.parent_enum();
    let visibility = enum_ast.visibility();
    let enum_hir = ctx.sema.to_def(&enum_ast)?;
-    let variant_hir_name = variant_hir.name(ctx.db);
+    let variant_hir_name = variant_hir.name(ctx.db());
    let enum_module_def = ModuleDef::from(enum_hir);
-    let current_module = enum_hir.module(ctx.db);
+    let current_module = enum_hir.module(ctx.db());
    let target = variant.syntax().text_range();
    acc.add(
        AssistId("extract_struct_from_enum_variant"),
@@ -53,7 +53,7 @@ pub(crate) fn extract_struct_from_enum_variant(
        target,
        |builder| {
            let definition = Definition::ModuleDef(ModuleDef::EnumVariant(variant_hir));
-            let res = definition.find_usages(&ctx.db, None);
+            let res = definition.find_usages(&ctx.sema, None);
            let start_offset = variant.parent_enum().syntax().text_range().start();
            let mut visited_modules_set = FxHashSet::default();
            visited_modules_set.insert(current_module);
@@ -101,7 +101,7 @@ fn insert_import(
    enum_module_def: &ModuleDef,
    variant_hir_name: &Name,
 ) -> Option<()> {
-    let db = ctx.db;
+    let db = ctx.db();
    let mod_path = module.find_use_path(db, enum_module_def.clone());
    if let Some(mut mod_path) = mod_path {
        mod_path.segments.pop();
diff --git a/crates/ra_assists/src/handlers/fill_match_arms.rs b/crates/ra_assists/src/handlers/fill_match_arms.rs
index 64270c86f..5b1235682 100644
--- a/crates/ra_assists/src/handlers/fill_match_arms.rs
+++ b/crates/ra_assists/src/handlers/fill_match_arms.rs
@@ -51,11 +51,11 @@ pub(crate) fn fill_match_arms(acc: &mut Assists, ctx: &AssistContext) -> Option<
    let module = ctx.sema.scope(expr.syntax()).module()?;
    let missing_arms: Vec<MatchArm> = if let Some(enum_def) = resolve_enum_def(&ctx.sema, &expr) {
-        let variants = enum_def.variants(ctx.db);
+        let variants = enum_def.variants(ctx.db());
        let mut variants = variants
            .into_iter()
-            .filter_map(|variant| build_pat(ctx.db, module, variant))
+            .filter_map(|variant| build_pat(ctx.db(), module, variant))
            .filter(|variant_pat| is_variant_missing(&mut arms, variant_pat))
            .map(|pat| make::match_arm(iter::once(pat), make::expr_empty_block()))
            .collect::<Vec<_>>();
@@ -84,11 +84,11 @@ pub(crate) fn fill_match_arms(acc: &mut Assists, ctx: &AssistContext) -> Option<
        // where each tuple represents a proposed match arm.
        enum_defs
            .into_iter()
-            .map(|enum_def| enum_def.variants(ctx.db))
+            .map(|enum_def| enum_def.variants(ctx.db()))
            .multi_cartesian_product()
            .map(|variants| {
                let patterns =
-                    variants.into_iter().filter_map(|variant| build_pat(ctx.db, module, variant));
+                    variants.into_iter().filter_map(|variant| build_pat(ctx.db(), module, variant));
                ast::Pat::from(make::tuple_pat(patterns))
            })
            .filter(|variant_pat| is_variant_missing(&mut arms, variant_pat))
diff --git a/crates/ra_assists/src/handlers/fix_visibility.rs b/crates/ra_assists/src/handlers/fix_visibility.rs
index 19d4dac5e..c0f57c329 100644
--- a/crates/ra_assists/src/handlers/fix_visibility.rs
+++ b/crates/ra_assists/src/handlers/fix_visibility.rs
@@ -41,14 +41,14 @@ fn add_vis_to_referenced_module_def(acc: &mut Assists, ctx: &AssistContext) -> O
    };
    let current_module = ctx.sema.scope(&path.syntax()).module()?;
-    let target_module = def.module(ctx.db)?;
+    let target_module = def.module(ctx.db())?;
-    let vis = target_module.visibility_of(ctx.db, &def)?;
+    let vis = target_module.visibility_of(ctx.db(), &def)?;
-    if vis.is_visible_from(ctx.db, current_module.into()) {
+    if vis.is_visible_from(ctx.db(), current_module.into()) {
        return None;
    };
-    let (offset, target, target_file, target_name) = target_data_for_def(ctx.db, def)?;
+    let (offset, target, target_file, target_name) = target_data_for_def(ctx.db(), def)?;
    let missing_visibility =
        if current_module.krate() == target_module.krate() { "pub(crate)" } else { "pub" };
@@ -72,16 +72,16 @@ fn add_vis_to_referenced_record_field(acc: &mut Assists, ctx: &AssistContext) ->
    let (record_field_def, _) = ctx.sema.resolve_record_field(&record_field)?;
    let current_module = ctx.sema.scope(record_field.syntax()).module()?;
-    let visibility = record_field_def.visibility(ctx.db);
+    let visibility = record_field_def.visibility(ctx.db());
-    if visibility.is_visible_from(ctx.db, current_module.into()) {
+    if visibility.is_visible_from(ctx.db(), current_module.into()) {
        return None;
    }
-    let parent = record_field_def.parent_def(ctx.db);
+    let parent = record_field_def.parent_def(ctx.db());
-    let parent_name = parent.name(ctx.db);
+    let parent_name = parent.name(ctx.db());
-    let target_module = parent.module(ctx.db);
+    let target_module = parent.module(ctx.db());
-    let in_file_source = record_field_def.source(ctx.db);
+    let in_file_source = record_field_def.source(ctx.db());
    let (offset, target) = match in_file_source.value {
        hir::FieldSource::Named(it) => {
            let s = it.syntax();
@@ -95,9 +95,9 @@ fn add_vis_to_referenced_record_field(acc: &mut Assists, ctx: &AssistContext) ->
    let missing_visibility =
        if current_module.krate() == target_module.krate() { "pub(crate)" } else { "pub" };
-    let target_file = in_file_source.file_id.original_file(ctx.db);
+    let target_file = in_file_source.file_id.original_file(ctx.db());
-    let target_name = record_field_def.name(ctx.db);
+    let target_name = record_field_def.name(ctx.db());
    let assist_label =
        format!("Change visibility of {}.{} to {}", parent_name, target_name, missing_visibility);
diff --git a/crates/ra_assists/src/handlers/inline_local_variable.rs b/crates/ra_assists/src/handlers/inline_local_variable.rs
index d26e68847..259839535 100644
--- a/crates/ra_assists/src/handlers/inline_local_variable.rs
+++ b/crates/ra_assists/src/handlers/inline_local_variable.rs
@@ -44,7 +44,7 @@ pub(crate) fn inline_local_variable(acc: &mut Assists, ctx: &AssistContext) -> O
    let def = ctx.sema.to_def(&bind_pat)?;
    let def = Definition::Local(def);
-    let refs = def.find_usages(ctx.db, None);
+    let refs = def.find_usages(&ctx.sema, None);
    if refs.is_empty() {
        mark::hit!(test_not_applicable_if_variable_unused);
        return None;
diff --git a/crates/ra_assists/src/handlers/reorder_fields.rs b/crates/ra_assists/src/handlers/reorder_fields.rs
index bc58ce5fe..b8cf30e7f 100644
--- a/crates/ra_assists/src/handlers/reorder_fields.rs
+++ b/crates/ra_assists/src/handlers/reorder_fields.rs
@@ -90,10 +90,10 @@ fn struct_definition(path: &ast::Path, sema: &Semantics<RootDatabase>) -> Option
 fn compute_fields_ranks(path: &ast::Path, ctx: &AssistContext) -> Option<FxHashMap<String, usize>> {
    Some(
        struct_definition(path, &ctx.sema)?
-            .fields(ctx.db)
+            .fields(ctx.db())
            .iter()
            .enumerate()
-            .map(|(idx, field)| (field.name(ctx.db).to_string(), idx))
+            .map(|(idx, field)| (field.name(ctx.db()).to_string(), idx))
            .collect(),
    )
 }
diff --git a/crates/ra_db/src/fixture.rs b/crates/ra_db/src/fixture.rs
index 4f4fb4494..209713987 100644
--- a/crates/ra_db/src/fixture.rs
+++ b/crates/ra_db/src/fixture.rs
@@ -149,15 +149,17 @@ fn with_files(
            let crate_id = crate_graph.add_crate_root(
                file_id,
                meta.edition,
-                Some(CrateName::new(&krate).unwrap()),
+                Some(krate.clone()),
                meta.cfg,
                meta.env,
                Default::default(),
            );
-            let prev = crates.insert(krate.clone(), crate_id);
+            let crate_name = CrateName::new(&krate).unwrap();
+            let prev = crates.insert(crate_name.clone(), crate_id);
            assert!(prev.is_none());
            for dep in meta.deps {
-                crate_deps.push((krate.clone(), dep))
+                let dep = CrateName::new(&dep).unwrap();
+                crate_deps.push((crate_name.clone(), dep))
            }
        } else if meta.path == "/main.rs" || meta.path == "/lib.rs" {
            assert!(default_crate_root.is_none());
diff --git a/crates/ra_db/src/input.rs b/crates/ra_db/src/input.rs
index 7f3660118..aaa492759 100644
--- a/crates/ra_db/src/input.rs
+++ b/crates/ra_db/src/input.rs
@@ -67,7 +67,7 @@ pub struct CrateGraph {
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct CrateId(pub u32);
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct CrateName(SmolStr);
 impl CrateName {
@@ -94,6 +94,13 @@ impl fmt::Display for CrateName {
    }
 }
+impl ops::Deref for CrateName {
+    type Target = str;
+    fn deref(&self) -> &Self::Target {
+        &*self.0
+    }
+}
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub struct ProcMacroId(pub u32);
@@ -117,7 +124,7 @@ pub struct CrateData {
    /// The name to display to the end user.
    /// This actual crate name can be different in a particular dependent crate
    /// or may even be missing for some cases, such as a dummy crate for the code snippet.
-    pub display_name: Option<CrateName>,
+    pub display_name: Option<String>,
    pub cfg_options: CfgOptions,
    pub env: Env,
    pub dependencies: Vec<Dependency>,
@@ -138,7 +145,7 @@ pub struct Env {
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Dependency {
    pub crate_id: CrateId,
-    pub name: SmolStr,
+    pub name: CrateName,
 }
 impl CrateGraph {
@@ -146,7 +153,7 @@ impl CrateGraph {
        &mut self,
        file_id: FileId,
        edition: Edition,
-        display_name: Option<CrateName>,
+        display_name: Option<String>,
        cfg_options: CfgOptions,
        env: Env,
        proc_macro: Vec<(SmolStr, Arc<dyn ra_tt::TokenExpander>)>,
@@ -178,7 +185,7 @@ impl CrateGraph {
        if self.dfs_find(from, to, &mut FxHashSet::default()) {
            return Err(CyclicDependenciesError);
        }
-        self.arena.get_mut(&from).unwrap().add_dep(name.0, to);
+        self.arena.get_mut(&from).unwrap().add_dep(name, to);
        Ok(())
    }
@@ -190,6 +197,23 @@ impl CrateGraph {
        self.arena.keys().copied()
    }
+    /// Returns an iterator over all transitive dependencies of the given crate.
+    pub fn transitive_deps(&self, of: CrateId) -> impl Iterator<Item = CrateId> + '_ {
+        let mut worklist = vec![of];
+        let mut deps = FxHashSet::default();
+        while let Some(krate) = worklist.pop() {
+            if !deps.insert(krate) {
+                continue;
+            }
+            worklist.extend(self[krate].dependencies.iter().map(|dep| dep.crate_id));
+        }
+        deps.remove(&of);
+        deps.into_iter()
+    }
    // 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, _) =
@@ -247,7 +271,7 @@ impl CrateId {
 }
 impl CrateData {
-    fn add_dep(&mut self, name: SmolStr, crate_id: CrateId) {
+    fn add_dep(&mut self, name: CrateName, crate_id: CrateId) {
        self.dependencies.push(Dependency { name, crate_id })
    }
 }
@@ -429,7 +453,10 @@ mod tests {
            .is_ok());
        assert_eq!(
            graph[crate1].dependencies,
-            vec![Dependency { crate_id: crate2, name: "crate_name_with_dashes".into() }]
+            vec![Dependency {
+                crate_id: crate2,
+                name: CrateName::new("crate_name_with_dashes").unwrap()
+            }]
        );
    }
 }
diff --git a/crates/ra_db/src/lib.rs b/crates/ra_db/src/lib.rs
index 4a3ba57da..1ddacc1f6 100644
--- a/crates/ra_db/src/lib.rs
+++ b/crates/ra_db/src/lib.rs
@@ -80,7 +80,7 @@ pub struct FilePosition {
    pub offset: TextSize,
 }
-#[derive(Clone, Copy, Debug)]
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub struct FileRange {
    pub file_id: FileId,
    pub range: TextRange,
diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs
index e86077dd6..1b3525011 100644
--- a/crates/ra_hir/src/code_model.rs
+++ b/crates/ra_hir/src/code_model.rs
@@ -31,7 +31,7 @@ use hir_ty::{
    ApplicationTy, Canonical, GenericPredicate, InEnvironment, Substs, TraitEnvironment, Ty,
    TyDefId, TypeCtor,
 };
-use ra_db::{CrateId, CrateName, Edition, FileId};
+use ra_db::{CrateId, Edition, FileId};
 use ra_prof::profile;
 use ra_syntax::ast::{self, AttrsOwner, NameOwner};
 use rustc_hash::FxHashSet;
@@ -94,8 +94,8 @@ impl Crate {
        db.crate_graph()[self.id].edition
    }
-    pub fn display_name(self, db: &dyn HirDatabase) -> Option<CrateName> {
+    pub fn display_name(self, db: &dyn HirDatabase) -> Option<String> {
-        db.crate_graph()[self.id].display_name.as_ref().cloned()
+        db.crate_graph()[self.id].display_name.clone()
    }
    pub fn query_external_importables(
@@ -1053,12 +1053,14 @@ pub struct ImplDef {
 impl ImplDef {
    pub fn all_in_crate(db: &dyn HirDatabase, krate: Crate) -> Vec<ImplDef> {
-        let impls = db.impls_in_crate(krate.id);
+        let inherent = db.inherent_impls_in_crate(krate.id);
-        impls.all_impls().map(Self::from).collect()
+        let trait_ = db.trait_impls_in_crate(krate.id);
+        inherent.all_impls().chain(trait_.all_impls()).map(Self::from).collect()
    }
    pub fn for_trait(db: &dyn HirDatabase, krate: Crate, trait_: Trait) -> Vec<ImplDef> {
-        let impls = db.impls_in_crate(krate.id);
+        let impls = db.trait_impls_in_crate(krate.id);
-        impls.lookup_impl_defs_for_trait(trait_.id).map(Self::from).collect()
+        impls.for_trait(trait_.id).map(Self::from).collect()
    }
    pub fn target_trait(self, db: &dyn HirDatabase) -> Option<TypeRef> {
@@ -1187,7 +1189,7 @@ impl Type {
            None => return false,
        };
-        let canonical_ty = Canonical { value: self.ty.value.clone(), num_vars: 0 };
+        let canonical_ty = Canonical { value: self.ty.value.clone(), kinds: Arc::new([]) };
        method_resolution::implements_trait(
            &canonical_ty,
            db,
@@ -1211,7 +1213,7 @@ impl Type {
                self.ty.environment.clone(),
                hir_ty::Obligation::Trait(trait_ref),
            ),
-            num_vars: 0,
+            kinds: Arc::new([]),
        };
        db.trait_solve(self.krate, goal).is_some()
@@ -1286,7 +1288,7 @@ impl Type {
    pub fn autoderef<'a>(&'a self, db: &'a dyn HirDatabase) -> impl Iterator<Item = Type> + 'a {
        // There should be no inference vars in types passed here
        // FIXME check that?
-        let canonical = Canonical { value: self.ty.value.clone(), num_vars: 0 };
+        let canonical = Canonical { value: self.ty.value.clone(), kinds: Arc::new([]) };
        let environment = self.ty.environment.clone();
        let ty = InEnvironment { value: canonical, environment };
        autoderef(db, Some(self.krate), ty)
@@ -1303,10 +1305,10 @@ impl Type {
        mut callback: impl FnMut(AssocItem) -> Option<T>,
    ) -> Option<T> {
        for krate in self.ty.value.def_crates(db, krate.id)? {
-            let impls = db.impls_in_crate(krate);
+            let impls = db.inherent_impls_in_crate(krate);
-            for impl_def in impls.lookup_impl_defs(&self.ty.value) {
+            for impl_def in impls.for_self_ty(&self.ty.value) {
-                for &item in db.impl_data(impl_def).items.iter() {
+                for &item in db.impl_data(*impl_def).items.iter() {
                    if let Some(result) = callback(item.into()) {
                        return Some(result);
                    }
@@ -1327,7 +1329,7 @@ impl Type {
        // There should be no inference vars in types passed here
        // FIXME check that?
        // FIXME replace Unknown by bound vars here
-        let canonical = Canonical { value: self.ty.value.clone(), num_vars: 0 };
+        let canonical = Canonical { value: self.ty.value.clone(), kinds: Arc::new([]) };
        let env = self.ty.environment.clone();
        let krate = krate.id;
@@ -1358,7 +1360,7 @@ impl Type {
        // There should be no inference vars in types passed here
        // FIXME check that?
        // FIXME replace Unknown by bound vars here
-        let canonical = Canonical { value: self.ty.value.clone(), num_vars: 0 };
+        let canonical = Canonical { value: self.ty.value.clone(), kinds: Arc::new([]) };
        let env = self.ty.environment.clone();
        let krate = krate.id;
diff --git a/crates/ra_hir/src/db.rs b/crates/ra_hir/src/db.rs
index bb67952de..cb48ca065 100644
--- a/crates/ra_hir/src/db.rs
+++ b/crates/ra_hir/src/db.rs
@@ -16,10 +16,10 @@ pub use hir_expand::db::{
 pub use hir_ty::db::{
    AssociatedTyDataQuery, AssociatedTyValueQuery, CallableItemSignatureQuery, FieldTypesQuery,
    GenericDefaultsQuery, GenericPredicatesForParamQuery, GenericPredicatesQuery, HirDatabase,
-    HirDatabaseStorage, ImplDatumQuery, ImplSelfTyQuery, ImplTraitQuery, ImplsFromDepsQuery,
+    HirDatabaseStorage, ImplDatumQuery, ImplSelfTyQuery, ImplTraitQuery, InferQueryQuery,
-    ImplsInCrateQuery, InferQueryQuery, InternAssocTyValueQuery, InternChalkImplQuery,
+    InherentImplsInCrateQuery, InternAssocTyValueQuery, InternChalkImplQuery, InternTypeCtorQuery,
-    InternTypeCtorQuery, InternTypeParamIdQuery, ReturnTypeImplTraitsQuery, StructDatumQuery,
+    InternTypeParamIdQuery, ReturnTypeImplTraitsQuery, StructDatumQuery, TraitDatumQuery,
-    TraitDatumQuery, TraitSolveQuery, TyQuery, ValueTyQuery,
+    TraitImplsInCrateQuery, TraitImplsInDepsQuery, TraitSolveQuery, TyQuery, ValueTyQuery,
 };
 #[test]
diff --git a/crates/ra_hir/src/semantics.rs b/crates/ra_hir/src/semantics.rs
index 6a49c424a..3d78f71c1 100644
--- a/crates/ra_hir/src/semantics.rs
+++ b/crates/ra_hir/src/semantics.rs
@@ -83,6 +83,11 @@ impl PathResolution {
 /// Primary API to get semantic information, like types, from syntax trees.
 pub struct Semantics<'db, DB> {
    pub db: &'db DB,
+    imp: SemanticsImpl<'db>,
+}
+pub struct SemanticsImpl<'db> {
+    pub db: &'db dyn HirDatabase,
    s2d_cache: RefCell<SourceToDefCache>,
    cache: RefCell<FxHashMap<SyntaxNode, HirFileId>>,
 }
@@ -95,20 +100,180 @@ impl<DB> fmt::Debug for Semantics<'_, DB> {
 impl<'db, DB: HirDatabase> Semantics<'db, DB> {
    pub fn new(db: &DB) -> Semantics<DB> {
-        Semantics { db, s2d_cache: Default::default(), cache: Default::default() }
+        let impl_ = SemanticsImpl::new(db);
+        Semantics { db, imp: impl_ }
    }
    pub fn parse(&self, file_id: FileId) -> ast::SourceFile {
-        let tree = self.db.parse(file_id).tree();
+        self.imp.parse(file_id)
-        self.cache(tree.syntax().clone(), file_id.into());
-        tree
    }
    pub fn ast<T: AstDiagnostic + Diagnostic>(&self, d: &T) -> <T as AstDiagnostic>::AST {
        let file_id = d.source().file_id;
        let root = self.db.parse_or_expand(file_id).unwrap();
-        self.cache(root, file_id);
+        self.imp.cache(root, file_id);
-        d.ast(self.db)
+        d.ast(self.db.upcast())
+    }
+    pub fn expand(&self, macro_call: &ast::MacroCall) -> Option<SyntaxNode> {
+        self.imp.expand(macro_call)
+    }
+    pub fn expand_hypothetical(
+        &self,
+        actual_macro_call: &ast::MacroCall,
+        hypothetical_args: &ast::TokenTree,
+        token_to_map: SyntaxToken,
+    ) -> Option<(SyntaxNode, SyntaxToken)> {
+        self.imp.expand_hypothetical(actual_macro_call, hypothetical_args, token_to_map)
+    }
+    pub fn descend_into_macros(&self, token: SyntaxToken) -> SyntaxToken {
+        self.imp.descend_into_macros(token)
+    }
+    pub fn descend_node_at_offset<N: ast::AstNode>(
+        &self,
+        node: &SyntaxNode,
+        offset: TextSize,
+    ) -> Option<N> {
+        self.imp.descend_node_at_offset(node, offset).find_map(N::cast)
+    }
+    pub fn original_range(&self, node: &SyntaxNode) -> FileRange {
+        self.imp.original_range(node)
+    }
+    pub fn diagnostics_range(&self, diagnostics: &dyn Diagnostic) -> FileRange {
+        self.imp.diagnostics_range(diagnostics)
+    }
+    pub fn ancestors_with_macros(&self, node: SyntaxNode) -> impl Iterator<Item = SyntaxNode> + '_ {
+        self.imp.ancestors_with_macros(node)
+    }
+    pub fn ancestors_at_offset_with_macros(
+        &self,
+        node: &SyntaxNode,
+        offset: TextSize,
+    ) -> impl Iterator<Item = SyntaxNode> + '_ {
+        self.imp.ancestors_at_offset_with_macros(node, offset)
+    }
+    /// Find a AstNode by offset inside SyntaxNode, if it is inside *Macrofile*,
+    /// search up until it is of the target AstNode type
+    pub fn find_node_at_offset_with_macros<N: AstNode>(
+        &self,
+        node: &SyntaxNode,
+        offset: TextSize,
+    ) -> Option<N> {
+        self.imp.ancestors_at_offset_with_macros(node, offset).find_map(N::cast)
+    }
+    /// Find a AstNode by offset inside SyntaxNode, if it is inside *MacroCall*,
+    /// descend it and find again
+    pub fn find_node_at_offset_with_descend<N: AstNode>(
+        &self,
+        node: &SyntaxNode,
+        offset: TextSize,
+    ) -> Option<N> {
+        if let Some(it) = find_node_at_offset(&node, offset) {
+            return Some(it);
+        }
+        self.imp.descend_node_at_offset(node, offset).find_map(N::cast)
+    }
+    pub fn type_of_expr(&self, expr: &ast::Expr) -> Option<Type> {
+        self.imp.type_of_expr(expr)
+    }
+    pub fn type_of_pat(&self, pat: &ast::Pat) -> Option<Type> {
+        self.imp.type_of_pat(pat)
+    }
+    pub fn resolve_method_call(&self, call: &ast::MethodCallExpr) -> Option<Function> {
+        self.imp.resolve_method_call(call)
+    }
+    pub fn resolve_field(&self, field: &ast::FieldExpr) -> Option<Field> {
+        self.imp.resolve_field(field)
+    }
+    pub fn resolve_record_field(&self, field: &ast::RecordField) -> Option<(Field, Option<Local>)> {
+        self.imp.resolve_record_field(field)
+    }
+    pub fn resolve_record_field_pat(&self, field: &ast::RecordFieldPat) -> Option<Field> {
+        self.imp.resolve_record_field_pat(field)
+    }
+    pub fn resolve_macro_call(&self, macro_call: &ast::MacroCall) -> Option<MacroDef> {
+        self.imp.resolve_macro_call(macro_call)
+    }
+    pub fn resolve_path(&self, path: &ast::Path) -> Option<PathResolution> {
+        self.imp.resolve_path(path)
+    }
+    pub fn resolve_variant(&self, record_lit: ast::RecordLit) -> Option<VariantId> {
+        self.imp.resolve_variant(record_lit)
+    }
+    pub fn lower_path(&self, path: &ast::Path) -> Option<Path> {
+        self.imp.lower_path(path)
+    }
+    pub fn resolve_bind_pat_to_const(&self, pat: &ast::BindPat) -> Option<ModuleDef> {
+        self.imp.resolve_bind_pat_to_const(pat)
+    }
+    // FIXME: use this instead?
+    // pub fn resolve_name_ref(&self, name_ref: &ast::NameRef) -> Option<???>;
+    pub fn record_literal_missing_fields(&self, literal: &ast::RecordLit) -> Vec<(Field, Type)> {
+        self.imp.record_literal_missing_fields(literal)
+    }
+    pub fn record_pattern_missing_fields(&self, pattern: &ast::RecordPat) -> Vec<(Field, Type)> {
+        self.imp.record_pattern_missing_fields(pattern)
+    }
+    pub fn to_def<T: ToDef>(&self, src: &T) -> Option<T::Def> {
+        let src = self.imp.find_file(src.syntax().clone()).with_value(src).cloned();
+        T::to_def(&self.imp, src)
+    }
+    pub fn to_module_def(&self, file: FileId) -> Option<Module> {
+        self.imp.to_module_def(file)
+    }
+    pub fn scope(&self, node: &SyntaxNode) -> SemanticsScope<'db> {
+        self.imp.scope(node)
+    }
+    pub fn scope_at_offset(&self, node: &SyntaxNode, offset: TextSize) -> SemanticsScope<'db> {
+        self.imp.scope_at_offset(node, offset)
+    }
+    pub fn scope_for_def(&self, def: Trait) -> SemanticsScope<'db> {
+        self.imp.scope_for_def(def)
+    }
+    pub fn assert_contains_node(&self, node: &SyntaxNode) {
+        self.imp.assert_contains_node(node)
+    }
+}
+impl<'db> SemanticsImpl<'db> {
+    pub fn new(db: &'db dyn HirDatabase) -> Self {
+        Self { db, s2d_cache: Default::default(), cache: Default::default() }
+    }
+    pub fn parse(&self, file_id: FileId) -> ast::SourceFile {
+        let tree = self.db.parse(file_id).tree();
+        self.cache(tree.syntax().clone(), file_id.into());
+        tree
    }
    pub fn expand(&self, macro_call: &ast::MacroCall) -> Option<SyntaxNode> {
@@ -130,9 +295,15 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {
            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 krate = sa.resolver.krate()?;
-        let macro_call_id = macro_call
+        let macro_call_id = macro_call.as_call_id(self.db.upcast(), krate, |path| {
-            .as_call_id(self.db, krate, |path| sa.resolver.resolve_path_as_macro(self.db, &path))?;
+            sa.resolver.resolve_path_as_macro(self.db.upcast(), &path)
-        hir_expand::db::expand_hypothetical(self.db, macro_call_id, hypothetical_args, token_to_map)
+        })?;
+        hir_expand::db::expand_hypothetical(
+            self.db.upcast(),
+            macro_call_id,
+            hypothetical_args,
+            token_to_map,
+        )
    }
    pub fn descend_into_macros(&self, token: SyntaxToken) -> SyntaxToken {
@@ -147,7 +318,7 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {
                return None;
            }
            let file_id = sa.expand(self.db, token.with_value(&macro_call))?;
-            let token = file_id.expansion_info(self.db)?.map_token_down(token.as_ref())?;
+            let token = file_id.expansion_info(self.db.upcast())?.map_token_down(token.as_ref())?;
            self.cache(find_root(&token.value.parent()), token.file_id);
@@ -159,15 +330,16 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {
        token.value
    }
-    pub fn descend_node_at_offset<N: ast::AstNode>(
+    pub fn descend_node_at_offset(
        &self,
        node: &SyntaxNode,
        offset: TextSize,
-    ) -> Option<N> {
+    ) -> impl Iterator<Item = SyntaxNode> + '_ {
        // Handle macro token cases
        node.token_at_offset(offset)
            .map(|token| self.descend_into_macros(token))
-            .find_map(|it| self.ancestors_with_macros(it.parent()).find_map(N::cast))
+            .map(|it| self.ancestors_with_macros(it.parent()))
+            .flatten()
    }
    pub fn original_range(&self, node: &SyntaxNode) -> FileRange {
@@ -184,7 +356,7 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {
    pub fn ancestors_with_macros(&self, node: SyntaxNode) -> impl Iterator<Item = SyntaxNode> + '_ {
        let node = self.find_file(node);
-        node.ancestors_with_macros(self.db).map(|it| it.value)
+        node.ancestors_with_macros(self.db.upcast()).map(|it| it.value)
    }
    pub fn ancestors_at_offset_with_macros(
@@ -197,29 +369,6 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {
            .kmerge_by(|node1, node2| node1.text_range().len() < node2.text_range().len())
    }
-    /// Find a AstNode by offset inside SyntaxNode, if it is inside *Macrofile*,
-    /// search up until it is of the target AstNode type
-    pub fn find_node_at_offset_with_macros<N: AstNode>(
-        &self,
-        node: &SyntaxNode,
-        offset: TextSize,
-    ) -> Option<N> {
-        self.ancestors_at_offset_with_macros(node, offset).find_map(N::cast)
-    }
-    /// Find a AstNode by offset inside SyntaxNode, if it is inside *MacroCall*,
-    /// descend it and find again
-    pub fn find_node_at_offset_with_descend<N: AstNode>(
-        &self,
-        node: &SyntaxNode,
-        offset: TextSize,
-    ) -> Option<N> {
-        if let Some(it) = find_node_at_offset(&node, offset) {
-            return Some(it);
-        }
-        self.descend_node_at_offset(&node, offset)
-    }
    pub fn type_of_expr(&self, expr: &ast::Expr) -> Option<Type> {
        self.analyze(expr.syntax()).type_of(self.db, &expr)
    }
@@ -267,9 +416,6 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {
        self.analyze(pat.syntax()).resolve_bind_pat_to_const(self.db, pat)
    }
-    // FIXME: use this instead?
-    // pub fn resolve_name_ref(&self, name_ref: &ast::NameRef) -> Option<???>;
    pub fn record_literal_missing_fields(&self, literal: &ast::RecordLit) -> Vec<(Field, Type)> {
        self.analyze(literal.syntax())
            .record_literal_missing_fields(self.db, literal)
@@ -282,11 +428,6 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {
            .unwrap_or_default()
    }
-    pub fn to_def<T: ToDef>(&self, src: &T) -> Option<T::Def> {
-        let src = self.find_file(src.syntax().clone()).with_value(src).cloned();
-        T::to_def(self, src)
-    }
    fn with_ctx<F: FnOnce(&mut SourceToDefCtx) -> T, T>(&self, f: F) -> T {
        let mut cache = self.s2d_cache.borrow_mut();
        let mut ctx = SourceToDefCtx { db: self.db, cache: &mut *cache };
@@ -297,20 +438,20 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {
        self.with_ctx(|ctx| ctx.file_to_def(file)).map(Module::from)
    }
-    pub fn scope(&self, node: &SyntaxNode) -> SemanticsScope<'db, DB> {
+    pub fn scope(&self, node: &SyntaxNode) -> SemanticsScope<'db> {
        let node = self.find_file(node.clone());
        let resolver = self.analyze2(node.as_ref(), None).resolver;
        SemanticsScope { db: self.db, resolver }
    }
-    pub fn scope_at_offset(&self, node: &SyntaxNode, offset: TextSize) -> SemanticsScope<'db, DB> {
+    pub fn scope_at_offset(&self, node: &SyntaxNode, offset: TextSize) -> SemanticsScope<'db> {
        let node = self.find_file(node.clone());
        let resolver = self.analyze2(node.as_ref(), Some(offset)).resolver;
        SemanticsScope { db: self.db, resolver }
    }
-    pub fn scope_for_def(&self, def: Trait) -> SemanticsScope<'db, DB> {
+    pub fn scope_for_def(&self, def: Trait) -> SemanticsScope<'db> {
-        let resolver = def.id.resolver(self.db);
+        let resolver = def.id.resolver(self.db.upcast());
        SemanticsScope { db: self.db, resolver }
    }
@@ -331,17 +472,17 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {
            ChildContainer::DefWithBodyId(def) => {
                return SourceAnalyzer::new_for_body(self.db, def, src, offset)
            }
-            ChildContainer::TraitId(it) => it.resolver(self.db),
+            ChildContainer::TraitId(it) => it.resolver(self.db.upcast()),
-            ChildContainer::ImplId(it) => it.resolver(self.db),
+            ChildContainer::ImplId(it) => it.resolver(self.db.upcast()),
-            ChildContainer::ModuleId(it) => it.resolver(self.db),
+            ChildContainer::ModuleId(it) => it.resolver(self.db.upcast()),
-            ChildContainer::EnumId(it) => it.resolver(self.db),
+            ChildContainer::EnumId(it) => it.resolver(self.db.upcast()),
-            ChildContainer::VariantId(it) => it.resolver(self.db),
+            ChildContainer::VariantId(it) => it.resolver(self.db.upcast()),
-            ChildContainer::GenericDefId(it) => it.resolver(self.db),
+            ChildContainer::GenericDefId(it) => it.resolver(self.db.upcast()),
        };
        SourceAnalyzer::new_for_resolver(resolver, src)
    }
-    fn cache(&self, root_node: SyntaxNode, file_id: HirFileId) {
+    pub fn cache(&self, root_node: SyntaxNode, file_id: HirFileId) {
        assert!(root_node.parent().is_none());
        let mut cache = self.cache.borrow_mut();
        let prev = cache.insert(root_node, file_id);
@@ -357,7 +498,7 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {
        cache.get(root_node).copied()
    }
-    fn find_file(&self, node: SyntaxNode) -> InFile<SyntaxNode> {
+    pub fn find_file(&self, node: SyntaxNode) -> InFile<SyntaxNode> {
        let root_node = find_root(&node);
        let file_id = self.lookup(&root_node).unwrap_or_else(|| {
            panic!(
@@ -382,14 +523,14 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {
 pub trait ToDef: AstNode + Clone {
    type Def;
-    fn to_def<DB: HirDatabase>(sema: &Semantics<DB>, src: InFile<Self>) -> Option<Self::Def>;
+    fn to_def(sema: &SemanticsImpl, src: InFile<Self>) -> Option<Self::Def>;
 }
 macro_rules! to_def_impls {
    ($(($def:path, $ast:path, $meth:ident)),* ,) => {$(
        impl ToDef for $ast {
            type Def = $def;
-            fn to_def<DB: HirDatabase>(sema: &Semantics<DB>, src: InFile<Self>) -> Option<Self::Def> {
+            fn to_def(sema: &SemanticsImpl, src: InFile<Self>) -> Option<Self::Def> {
                sema.with_ctx(|ctx| ctx.$meth(src)).map(<$def>::from)
            }
        }
@@ -419,12 +560,12 @@ fn find_root(node: &SyntaxNode) -> SyntaxNode {
    node.ancestors().last().unwrap()
 }
-pub struct SemanticsScope<'a, DB> {
+pub struct SemanticsScope<'a> {
-    pub db: &'a DB,
+    pub db: &'a dyn HirDatabase,
    resolver: Resolver,
 }
-impl<'a, DB: HirDatabase> SemanticsScope<'a, DB> {
+impl<'a> SemanticsScope<'a> {
    pub fn module(&self) -> Option<Module> {
        Some(Module { id: self.resolver.module()? })
    }
@@ -433,13 +574,13 @@ impl<'a, DB: HirDatabase> SemanticsScope<'a, DB> {
    // FIXME: rename to visible_traits to not repeat scope?
    pub fn traits_in_scope(&self) -> FxHashSet<TraitId> {
        let resolver = &self.resolver;
-        resolver.traits_in_scope(self.db)
+        resolver.traits_in_scope(self.db.upcast())
    }
    pub fn process_all_names(&self, f: &mut dyn FnMut(Name, ScopeDef)) {
        let resolver = &self.resolver;
-        resolver.process_all_names(self.db, &mut |name, def| {
+        resolver.process_all_names(self.db.upcast(), &mut |name, def| {
            let def = match def {
                resolver::ScopeDef::PerNs(it) => {
                    let items = ScopeDef::all_items(it);
diff --git a/crates/ra_hir_def/src/item_scope.rs b/crates/ra_hir_def/src/item_scope.rs
index 4d446c707..beeb98559 100644
--- a/crates/ra_hir_def/src/item_scope.rs
+++ b/crates/ra_hir_def/src/item_scope.rs
@@ -1,6 +1,8 @@
 //! Describes items defined or visible (ie, imported) in a certain scope.
 //! This is shared between modules and blocks.
+use std::collections::hash_map::Entry;
 use hir_expand::name::Name;
 use once_cell::sync::Lazy;
 use ra_db::CrateId;
@@ -27,7 +29,11 @@ pub struct PerNsGlobImports {
 #[derive(Debug, Default, PartialEq, Eq)]
 pub struct ItemScope {
-    visible: FxHashMap<Name, PerNs>,
+    types: FxHashMap<Name, (ModuleDefId, Visibility)>,
+    values: FxHashMap<Name, (ModuleDefId, Visibility)>,
+    macros: FxHashMap<Name, (MacroDefId, Visibility)>,
+    unresolved: FxHashSet<Name>,
    defs: Vec<ModuleDefId>,
    impls: Vec<ImplId>,
    /// Macros visible in current module in legacy textual scope
@@ -65,14 +71,16 @@ pub(crate) enum BuiltinShadowMode {
 /// Other methods will only resolve values, types and module scoped macros only.
 impl ItemScope {
    pub fn entries<'a>(&'a self) -> impl Iterator<Item = (&'a Name, PerNs)> + 'a {
-        //FIXME: shadowing
+        // FIXME: shadowing
-        self.visible.iter().map(|(n, def)| (n, *def))
+        let keys: FxHashSet<_> = self
-    }
+            .types
+            .keys()
-    pub fn entries_without_primitives<'a>(
+            .chain(self.values.keys())
-        &'a self,
+            .chain(self.macros.keys())
-    ) -> impl Iterator<Item = (&'a Name, PerNs)> + 'a {
+            .chain(self.unresolved.iter())
-        self.visible.iter().map(|(n, def)| (n, *def))
+            .collect();
+        keys.into_iter().map(move |name| (name, self.get(name)))
    }
    pub fn declarations(&self) -> impl Iterator<Item = ModuleDefId> + '_ {
@@ -91,7 +99,7 @@ impl ItemScope {
    /// Iterate over all module scoped macros
    pub(crate) fn macros<'a>(&'a self) -> impl Iterator<Item = (&'a Name, MacroDefId)> + 'a {
-        self.visible.iter().filter_map(|(name, def)| def.take_macros().map(|macro_| (name, macro_)))
+        self.entries().filter_map(|(name, def)| def.take_macros().map(|macro_| (name, macro_)))
    }
    /// Iterate over all legacy textual scoped macros visible at the end of the module
@@ -101,12 +109,16 @@ impl ItemScope {
    /// Get a name from current module scope, legacy macros are not included
    pub(crate) fn get(&self, name: &Name) -> PerNs {
-        self.visible.get(name).copied().unwrap_or_else(PerNs::none)
+        PerNs {
+            types: self.types.get(name).copied(),
+            values: self.values.get(name).copied(),
+            macros: self.macros.get(name).copied(),
+        }
    }
    pub(crate) fn name_of(&self, item: ItemInNs) -> Option<(&Name, Visibility)> {
-        for (name, per_ns) in &self.visible {
+        for (name, per_ns) in self.entries() {
-            if let Some(vis) = item.match_with(*per_ns) {
+            if let Some(vis) = item.match_with(per_ns) {
                return Some((name, vis));
            }
        }
@@ -114,8 +126,8 @@ impl ItemScope {
    }
    pub(crate) fn traits<'a>(&'a self) -> impl Iterator<Item = TraitId> + 'a {
-        self.visible.values().filter_map(|def| match def.take_types() {
+        self.types.values().filter_map(|(def, _)| match def {
-            Some(ModuleDefId::TraitId(t)) => Some(t),
+            ModuleDefId::TraitId(t) => Some(*t),
            _ => None,
        })
    }
@@ -138,21 +150,30 @@ impl ItemScope {
    pub(crate) fn push_res(&mut self, name: Name, def: PerNs) -> bool {
        let mut changed = false;
-        let existing = self.visible.entry(name).or_default();
-        if existing.types.is_none() && def.types.is_some() {
+        if let Some(types) = def.types {
-            existing.types = def.types;
+            self.types.entry(name.clone()).or_insert_with(|| {
-            changed = true;
+                changed = true;
+                types
+            });
        }
+        if let Some(values) = def.values {
-        if existing.values.is_none() && def.values.is_some() {
+            self.values.entry(name.clone()).or_insert_with(|| {
-            existing.values = def.values;
+                changed = true;
-            changed = true;
+                values
+            });
+        }
+        if let Some(macros) = def.macros {
+            self.macros.entry(name.clone()).or_insert_with(|| {
+                changed = true;
+                macros
+            });
        }
-        if existing.macros.is_none() && def.macros.is_some() {
+        if def.is_none() {
-            existing.macros = def.macros;
+            if self.unresolved.insert(name) {
-            changed = true;
+                changed = true;
+            }
        }
        changed
@@ -166,17 +187,17 @@ impl ItemScope {
        def_import_type: ImportType,
    ) -> bool {
        let mut changed = false;
-        let existing = self.visible.entry(lookup.1.clone()).or_default();
        macro_rules! check_changed {
            (
                $changed:ident,
-                ( $existing:ident / $def:ident ) . $field:ident,
+                ( $this:ident / $def:ident ) . $field:ident,
                $glob_imports:ident [ $lookup:ident ],
                $def_import_type:ident
-            ) => {
+            ) => {{
-                match ($existing.$field, $def.$field) {
+                let existing = $this.$field.entry($lookup.1.clone());
-                    (None, Some(_)) => {
+                match (existing, $def.$field) {
+                    (Entry::Vacant(entry), Some(_)) => {
                        match $def_import_type {
                            ImportType::Glob => {
                                $glob_imports.$field.insert($lookup.clone());
@@ -186,32 +207,42 @@ impl ItemScope {
                            }
                        }
-                        $existing.$field = $def.$field;
+                        if let Some(fld) = $def.$field {
+                            entry.insert(fld);
+                        }
                        $changed = true;
                    }
-                    (Some(_), Some(_))
+                    (Entry::Occupied(mut entry), Some(_))
                        if $glob_imports.$field.contains(&$lookup)
                            && matches!($def_import_type, ImportType::Named) =>
                    {
                        mark::hit!(import_shadowed);
                        $glob_imports.$field.remove(&$lookup);
-                        $existing.$field = $def.$field;
+                        if let Some(fld) = $def.$field {
+                            entry.insert(fld);
+                        }
                        $changed = true;
                    }
                    _ => {}
                }
-            };
+            }};
        }
-        check_changed!(changed, (existing / def).types, glob_imports[lookup], def_import_type);
+        check_changed!(changed, (self / def).types, glob_imports[lookup], def_import_type);
-        check_changed!(changed, (existing / def).values, glob_imports[lookup], def_import_type);
+        check_changed!(changed, (self / def).values, glob_imports[lookup], def_import_type);
-        check_changed!(changed, (existing / def).macros, glob_imports[lookup], def_import_type);
+        check_changed!(changed, (self / def).macros, glob_imports[lookup], def_import_type);
+        if def.is_none() {
+            if self.unresolved.insert(lookup.1) {
+                changed = true;
+            }
+        }
        changed
    }
    pub(crate) fn resolutions<'a>(&'a self) -> impl Iterator<Item = (Name, PerNs)> + 'a {
-        self.visible.iter().map(|(name, res)| (name.clone(), *res))
+        self.entries().map(|(name, res)| (name.clone(), res))
    }
    pub(crate) fn collect_legacy_macros(&self) -> FxHashMap<Name, MacroDefId> {
diff --git a/crates/ra_hir_def/src/item_tree/lower.rs b/crates/ra_hir_def/src/item_tree/lower.rs
index 5149dd141..06743d7fc 100644
--- a/crates/ra_hir_def/src/item_tree/lower.rs
+++ b/crates/ra_hir_def/src/item_tree/lower.rs
@@ -211,7 +211,7 @@ impl Ctx {
    fn lower_record_field(&mut self, field: &ast::RecordFieldDef) -> Option<Field> {
        let name = field.name()?.as_name();
        let visibility = self.lower_visibility(field);
-        let type_ref = self.lower_type_ref(&field.ascribed_type()?);
+        let type_ref = self.lower_type_ref_opt(field.ascribed_type());
        let res = Field { name, type_ref, visibility };
        Some(res)
    }
diff --git a/crates/ra_hir_def/src/resolver.rs b/crates/ra_hir_def/src/resolver.rs
index 15fdd9019..0bf51eb7b 100644
--- a/crates/ra_hir_def/src/resolver.rs
+++ b/crates/ra_hir_def/src/resolver.rs
@@ -511,11 +511,9 @@ impl Scope {
                    });
                }
            }
-            Scope::LocalItemsScope(body) => {
+            Scope::LocalItemsScope(body) => body.item_scope.entries().for_each(|(name, def)| {
-                body.item_scope.entries_without_primitives().for_each(|(name, def)| {
+                f(name.clone(), ScopeDef::PerNs(def));
-                    f(name.clone(), ScopeDef::PerNs(def));
+            }),
-                })
-            }
            Scope::GenericParams { params, def } => {
                for (local_id, param) in params.types.iter() {
                    if let Some(name) = &param.name {
diff --git a/crates/ra_hir_expand/src/builtin_derive.rs b/crates/ra_hir_expand/src/builtin_derive.rs
index 26b667b55..f2d664863 100644
--- a/crates/ra_hir_expand/src/builtin_derive.rs
+++ b/crates/ra_hir_expand/src/builtin_derive.rs
@@ -161,7 +161,7 @@ fn find_builtin_crate(db: &dyn AstDatabase, id: LazyMacroId) -> tt::TokenTree {
    // XXX
    //  All crates except core itself should have a dependency on core,
    //  We detect `core` by seeing whether it doesn't have such a dependency.
-    let tt = if cg[krate].dependencies.iter().any(|dep| dep.name == "core") {
+    let tt = if cg[krate].dependencies.iter().any(|dep| &*dep.name == "core") {
        quote! { core }
    } else {
        quote! { crate }
diff --git a/crates/ra_hir_expand/src/diagnostics.rs b/crates/ra_hir_expand/src/diagnostics.rs
index 99209c6e8..545cff9bd 100644
--- a/crates/ra_hir_expand/src/diagnostics.rs
+++ b/crates/ra_hir_expand/src/diagnostics.rs
@@ -28,7 +28,7 @@ pub trait Diagnostic: Any + Send + Sync + fmt::Debug + 'static {
 pub trait AstDiagnostic {
    type AST;
-    fn ast(&self, db: &impl AstDatabase) -> Self::AST;
+    fn ast(&self, db: &dyn AstDatabase) -> Self::AST;
 }
 impl dyn Diagnostic {
diff --git a/crates/ra_hir_expand/src/name.rs b/crates/ra_hir_expand/src/name.rs
index 1b0303685..969a2e5b8 100644
--- a/crates/ra_hir_expand/src/name.rs
+++ b/crates/ra_hir_expand/src/name.rs
@@ -117,7 +117,7 @@ impl AsName for ast::FieldKind {
 impl AsName for ra_db::Dependency {
    fn as_name(&self) -> Name {
-        Name::new_text(self.name.clone())
+        Name::new_text(SmolStr::new(&*self.name))
    }
 }
diff --git a/crates/ra_hir_ty/src/autoderef.rs b/crates/ra_hir_ty/src/autoderef.rs
index 1b0f84c5c..c727012c6 100644
--- a/crates/ra_hir_ty/src/autoderef.rs
+++ b/crates/ra_hir_ty/src/autoderef.rs
@@ -37,7 +37,7 @@ pub(crate) fn deref(
    ty: InEnvironment<&Canonical<Ty>>,
 ) -> Option<Canonical<Ty>> {
    if let Some(derefed) = ty.value.value.builtin_deref() {
-        Some(Canonical { value: derefed, num_vars: ty.value.num_vars })
+        Some(Canonical { value: derefed, kinds: ty.value.kinds.clone() })
    } else {
        deref_by_trait(db, krate, ty)
    }
@@ -68,8 +68,8 @@ fn deref_by_trait(
    // Check that the type implements Deref at all
    let trait_ref = TraitRef { trait_: deref_trait, substs: parameters.clone() };
-    let implements_goal = super::Canonical {
+    let implements_goal = Canonical {
-        num_vars: ty.value.num_vars,
+        kinds: ty.value.kinds.clone(),
        value: InEnvironment {
            value: Obligation::Trait(trait_ref),
            environment: ty.environment.clone(),
@@ -81,7 +81,7 @@ fn deref_by_trait(
    // Now do the assoc type projection
    let projection = super::traits::ProjectionPredicate {
-        ty: Ty::Bound(BoundVar::new(DebruijnIndex::INNERMOST, ty.value.num_vars)),
+        ty: Ty::Bound(BoundVar::new(DebruijnIndex::INNERMOST, ty.value.kinds.len())),
        projection_ty: super::ProjectionTy { associated_ty: target, parameters },
    };
@@ -89,7 +89,8 @@ fn deref_by_trait(
    let in_env = InEnvironment { value: obligation, environment: ty.environment };
-    let canonical = super::Canonical { num_vars: 1 + ty.value.num_vars, value: in_env };
+    let canonical =
+        Canonical::new(in_env, ty.value.kinds.iter().copied().chain(Some(super::TyKind::General)));
    let solution = db.trait_solve(krate, canonical)?;
@@ -110,7 +111,7 @@ fn deref_by_trait(
            // assumptions will be broken. We would need to properly introduce
            // new variables in that case
-            for i in 1..vars.0.num_vars {
+            for i in 1..vars.0.kinds.len() {
                if vars.0.value[i - 1] != Ty::Bound(BoundVar::new(DebruijnIndex::INNERMOST, i - 1))
                {
                    warn!("complex solution for derefing {:?}: {:?}, ignoring", ty.value, solution);
@@ -119,7 +120,7 @@ fn deref_by_trait(
            }
            Some(Canonical {
                value: vars.0.value[vars.0.value.len() - 1].clone(),
-                num_vars: vars.0.num_vars,
+                kinds: vars.0.kinds.clone(),
            })
        }
        Solution::Ambig(_) => {
diff --git a/crates/ra_hir_ty/src/db.rs b/crates/ra_hir_ty/src/db.rs
index cad553273..dc06c0ee7 100644
--- a/crates/ra_hir_ty/src/db.rs
+++ b/crates/ra_hir_ty/src/db.rs
@@ -11,7 +11,7 @@ use ra_db::{impl_intern_key, salsa, CrateId, Upcast};
 use ra_prof::profile;
 use crate::{
-    method_resolution::CrateImplDefs,
+    method_resolution::{InherentImpls, TraitImpls},
    traits::{chalk, AssocTyValue, Impl},
    Binders, CallableDef, GenericPredicate, InferenceResult, OpaqueTyId, PolyFnSig,
    ReturnTypeImplTraits, TraitRef, Ty, TyDefId, TypeCtor, ValueTyDefId,
@@ -67,11 +67,14 @@ pub trait HirDatabase: DefDatabase + Upcast<dyn DefDatabase> {
    #[salsa::invoke(crate::lower::generic_defaults_query)]
    fn generic_defaults(&self, def: GenericDefId) -> Arc<[Binders<Ty>]>;
-    #[salsa::invoke(crate::method_resolution::CrateImplDefs::impls_in_crate_query)]
+    #[salsa::invoke(InherentImpls::inherent_impls_in_crate_query)]
-    fn impls_in_crate(&self, krate: CrateId) -> Arc<CrateImplDefs>;
+    fn inherent_impls_in_crate(&self, krate: CrateId) -> Arc<InherentImpls>;
-    #[salsa::invoke(crate::method_resolution::CrateImplDefs::impls_from_deps_query)]
+    #[salsa::invoke(TraitImpls::trait_impls_in_crate_query)]
-    fn impls_from_deps(&self, krate: CrateId) -> Arc<CrateImplDefs>;
+    fn trait_impls_in_crate(&self, krate: CrateId) -> Arc<TraitImpls>;
+    #[salsa::invoke(TraitImpls::trait_impls_in_deps_query)]
+    fn trait_impls_in_deps(&self, krate: CrateId) -> Arc<TraitImpls>;
    // Interned IDs for Chalk integration
    #[salsa::interned]
diff --git a/crates/ra_hir_ty/src/diagnostics.rs b/crates/ra_hir_ty/src/diagnostics.rs
index a59efb347..0289911de 100644
--- a/crates/ra_hir_ty/src/diagnostics.rs
+++ b/crates/ra_hir_ty/src/diagnostics.rs
@@ -32,7 +32,7 @@ impl Diagnostic for NoSuchField {
 impl AstDiagnostic for NoSuchField {
    type AST = ast::RecordField;
-    fn ast(&self, db: &impl AstDatabase) -> Self::AST {
+    fn ast(&self, db: &dyn AstDatabase) -> Self::AST {
        let root = db.parse_or_expand(self.source().file_id).unwrap();
        let node = self.source().value.to_node(&root);
        ast::RecordField::cast(node).unwrap()
@@ -65,7 +65,7 @@ impl Diagnostic for MissingFields {
 impl AstDiagnostic for MissingFields {
    type AST = ast::RecordFieldList;
-    fn ast(&self, db: &impl AstDatabase) -> Self::AST {
+    fn ast(&self, db: &dyn AstDatabase) -> Self::AST {
        let root = db.parse_or_expand(self.source().file_id).unwrap();
        let node = self.source().value.to_node(&root);
        ast::RecordFieldList::cast(node).unwrap()
@@ -135,7 +135,7 @@ impl Diagnostic for MissingOkInTailExpr {
 impl AstDiagnostic for MissingOkInTailExpr {
    type AST = ast::Expr;
-    fn ast(&self, db: &impl AstDatabase) -> Self::AST {
+    fn ast(&self, db: &dyn AstDatabase) -> Self::AST {
        let root = db.parse_or_expand(self.file).unwrap();
        let node = self.source().value.to_node(&root);
        ast::Expr::cast(node).unwrap()
@@ -163,7 +163,7 @@ impl Diagnostic for BreakOutsideOfLoop {
 impl AstDiagnostic for BreakOutsideOfLoop {
    type AST = ast::Expr;
-    fn ast(&self, db: &impl AstDatabase) -> Self::AST {
+    fn ast(&self, db: &dyn AstDatabase) -> Self::AST {
        let root = db.parse_or_expand(self.file).unwrap();
        let node = self.source().value.to_node(&root);
        ast::Expr::cast(node).unwrap()
@@ -191,7 +191,7 @@ impl Diagnostic for MissingUnsafe {
 impl AstDiagnostic for MissingUnsafe {
    type AST = ast::Expr;
-    fn ast(&self, db: &impl AstDatabase) -> Self::AST {
+    fn ast(&self, db: &dyn AstDatabase) -> Self::AST {
        let root = db.parse_or_expand(self.source().file_id).unwrap();
        let node = self.source().value.to_node(&root);
        ast::Expr::cast(node).unwrap()
diff --git a/crates/ra_hir_ty/src/infer/unify.rs b/crates/ra_hir_ty/src/infer/unify.rs
index 269495ca0..2e895d911 100644
--- a/crates/ra_hir_ty/src/infer/unify.rs
+++ b/crates/ra_hir_ty/src/infer/unify.rs
@@ -9,7 +9,7 @@ use test_utils::mark;
 use super::{InferenceContext, Obligation};
 use crate::{
    BoundVar, Canonical, DebruijnIndex, GenericPredicate, InEnvironment, InferTy, Substs, Ty,
-    TypeCtor, TypeWalk,
+    TyKind, TypeCtor, TypeWalk,
 };
 impl<'a> InferenceContext<'a> {
@@ -86,10 +86,20 @@ where
    }
    fn into_canonicalized<T>(self, result: T) -> Canonicalized<T> {
-        Canonicalized {
+        let kinds = self
-            value: Canonical { value: result, num_vars: self.free_vars.len() },
+            .free_vars
-            free_vars: self.free_vars,
+            .iter()
-        }
+            .map(|v| match v {
+                // mapping MaybeNeverTypeVar to the same kind as general ones
+                // should be fine, because as opposed to int or float type vars,
+                // they don't restrict what kind of type can go into them, they
+                // just affect fallback.
+                InferTy::TypeVar(_) | InferTy::MaybeNeverTypeVar(_) => TyKind::General,
+                InferTy::IntVar(_) => TyKind::Integer,
+                InferTy::FloatVar(_) => TyKind::Float,
+            })
+            .collect();
+        Canonicalized { value: Canonical { value: result, kinds }, free_vars: self.free_vars }
    }
    pub(crate) fn canonicalize_ty(mut self, ty: Ty) -> Canonicalized<Ty> {
@@ -131,26 +141,41 @@ impl<T> Canonicalized<T> {
        ty
    }
-    pub fn apply_solution(&self, ctx: &mut InferenceContext<'_>, solution: Canonical<Vec<Ty>>) {
+    pub fn apply_solution(&self, ctx: &mut InferenceContext<'_>, solution: Canonical<Substs>) {
        // the solution may contain new variables, which we need to convert to new inference vars
-        let new_vars = Substs((0..solution.num_vars).map(|_| ctx.table.new_type_var()).collect());
+        let new_vars = Substs(
+            solution
+                .kinds
+                .iter()
+                .map(|k| match k {
+                    TyKind::General => ctx.table.new_type_var(),
+                    TyKind::Integer => ctx.table.new_integer_var(),
+                    TyKind::Float => ctx.table.new_float_var(),
+                })
+                .collect(),
+        );
        for (i, ty) in solution.value.into_iter().enumerate() {
            let var = self.free_vars[i];
            // eagerly replace projections in the type; we may be getting types
            // e.g. from where clauses where this hasn't happened yet
-            let ty = ctx.normalize_associated_types_in(ty.subst_bound_vars(&new_vars));
+            let ty = ctx.normalize_associated_types_in(ty.clone().subst_bound_vars(&new_vars));
            ctx.table.unify(&Ty::Infer(var), &ty);
        }
    }
 }
-pub fn unify(ty1: &Canonical<Ty>, ty2: &Canonical<Ty>) -> Option<Substs> {
+pub fn unify(tys: &Canonical<(Ty, Ty)>) -> Option<Substs> {
    let mut table = InferenceTable::new();
-    let num_vars = ty1.num_vars.max(ty2.num_vars);
+    let vars = Substs(
-    let vars =
+        tys.kinds
-        Substs::builder(num_vars).fill(std::iter::repeat_with(|| table.new_type_var())).build();
+            .iter()
-    let ty1_with_vars = ty1.value.clone().subst_bound_vars(&vars);
+            // we always use type vars here because we want everything to
-    let ty2_with_vars = ty2.value.clone().subst_bound_vars(&vars);
+            // fallback to Unknown in the end (kind of hacky, as below)
+            .map(|_| table.new_type_var())
+            .collect(),
+    );
+    let ty1_with_vars = tys.value.0.clone().subst_bound_vars(&vars);
+    let ty2_with_vars = tys.value.1.clone().subst_bound_vars(&vars);
    if !table.unify(&ty1_with_vars, &ty2_with_vars) {
        return None;
    }
@@ -162,7 +187,7 @@ pub fn unify(ty1: &Canonical<Ty>, ty2: &Canonical<Ty>) -> Option<Substs> {
        }
    }
    Some(
-        Substs::builder(ty1.num_vars)
+        Substs::builder(tys.kinds.len())
            .fill(vars.iter().map(|v| table.resolve_ty_completely(v.clone())))
            .build(),
    )
diff --git a/crates/ra_hir_ty/src/lib.rs b/crates/ra_hir_ty/src/lib.rs
index c9513b752..7f3f5e771 100644
--- a/crates/ra_hir_ty/src/lib.rs
+++ b/crates/ra_hir_ty/src/lib.rs
@@ -662,13 +662,27 @@ impl TypeWalk for GenericPredicate {
 /// Basically a claim (currently not validated / checked) that the contained
 /// type / trait ref contains no inference variables; any inference variables it
-/// contained have been replaced by bound variables, and `num_vars` tells us how
+/// contained have been replaced by bound variables, and `kinds` tells us how
-/// many there are. This is used to erase irrelevant differences between types
+/// many there are and whether they were normal or float/int variables. This is
-/// before using them in queries.
+/// used to erase irrelevant differences between types before using them in
+/// queries.
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Canonical<T> {
    pub value: T,
-    pub num_vars: usize,
+    pub kinds: Arc<[TyKind]>,
+}
+impl<T> Canonical<T> {
+    pub fn new(value: T, kinds: impl IntoIterator<Item = TyKind>) -> Self {
+        Self { value, kinds: kinds.into_iter().collect() }
+    }
+}
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+pub enum TyKind {
+    General,
+    Integer,
+    Float,
 }
 /// A function signature as seen by type inference: Several parameter types and
diff --git a/crates/ra_hir_ty/src/method_resolution.rs b/crates/ra_hir_ty/src/method_resolution.rs
index c19519cf1..a45febbf7 100644
--- a/crates/ra_hir_ty/src/method_resolution.rs
+++ b/crates/ra_hir_ty/src/method_resolution.rs
@@ -2,7 +2,7 @@
 //! For details about how this works in rustc, see the method lookup page in the
 //! [rustc guide](https://rust-lang.github.io/rustc-guide/method-lookup.html)
 //! and the corresponding code mostly in librustc_typeck/check/method/probe.rs.
-use std::sync::Arc;
+use std::{iter, sync::Arc};
 use arrayvec::ArrayVec;
 use hir_def::{
@@ -17,7 +17,8 @@ use rustc_hash::{FxHashMap, FxHashSet};
 use super::Substs;
 use crate::{
    autoderef, db::HirDatabase, primitive::FloatBitness, utils::all_super_traits, ApplicationTy,
-    Canonical, DebruijnIndex, InEnvironment, TraitEnvironment, TraitRef, Ty, TypeCtor, TypeWalk,
+    Canonical, DebruijnIndex, InEnvironment, TraitEnvironment, TraitRef, Ty, TyKind, TypeCtor,
+    TypeWalk,
 };
 /// This is used as a key for indexing impls.
@@ -38,136 +39,131 @@ impl TyFingerprint {
    }
 }
-/// A queryable and mergeable collection of impls.
+/// Trait impls defined or available in some crate.
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Debug, Eq, PartialEq)]
-pub struct CrateImplDefs {
+pub struct TraitImpls {
-    inherent_impls: FxHashMap<TyFingerprint, Vec<ImplId>>,
+    // If the `Option<TyFingerprint>` is `None`, the impl may apply to any self type.
-    impls_by_trait: FxHashMap<TraitId, FxHashMap<Option<TyFingerprint>, Vec<ImplId>>>,
+    map: FxHashMap<TraitId, FxHashMap<Option<TyFingerprint>, Vec<ImplId>>>,
 }
-impl CrateImplDefs {
+impl TraitImpls {
-    pub(crate) fn impls_in_crate_query(db: &dyn HirDatabase, krate: CrateId) -> Arc<CrateImplDefs> {
+    pub(crate) fn trait_impls_in_crate_query(db: &dyn HirDatabase, krate: CrateId) -> Arc<Self> {
-        let _p = profile("impls_in_crate_query");
+        let _p = profile("trait_impls_in_crate_query");
-        let mut res = CrateImplDefs {
+        let mut impls = Self { map: FxHashMap::default() };
-            inherent_impls: FxHashMap::default(),
-            impls_by_trait: FxHashMap::default(),
-        };
-        res.fill(db, krate);
-        Arc::new(res)
+        let crate_def_map = db.crate_def_map(krate);
+        for (_module_id, module_data) in crate_def_map.modules.iter() {
+            for impl_id in module_data.scope.impls() {
+                let target_trait = match db.impl_trait(impl_id) {
+                    Some(tr) => tr.value.trait_,
+                    None => continue,
+                };
+                let self_ty = db.impl_self_ty(impl_id);
+                let self_ty_fp = TyFingerprint::for_impl(&self_ty.value);
+                impls
+                    .map
+                    .entry(target_trait)
+                    .or_default()
+                    .entry(self_ty_fp)
+                    .or_default()
+                    .push(impl_id);
+            }
+        }
+        Arc::new(impls)
    }
-    /// Collects all impls from transitive dependencies of `krate` that may be used by `krate`.
+    pub(crate) fn trait_impls_in_deps_query(db: &dyn HirDatabase, krate: CrateId) -> Arc<Self> {
-    ///
+        let _p = profile("trait_impls_in_deps_query");
-    /// The full set of impls that can be used by `krate` is the returned map plus all the impls
-    /// from `krate` itself.
-    pub(crate) fn impls_from_deps_query(
-        db: &dyn HirDatabase,
-        krate: CrateId,
-    ) -> Arc<CrateImplDefs> {
-        let _p = profile("impls_from_deps_query");
        let crate_graph = db.crate_graph();
-        let mut res = CrateImplDefs {
+        let mut res = Self { map: FxHashMap::default() };
-            inherent_impls: FxHashMap::default(),
-            impls_by_trait: FxHashMap::default(),
-        };
-        // For each dependency, calculate `impls_from_deps` recursively, then add its own
+        for krate in crate_graph.transitive_deps(krate) {
-        // `impls_in_crate`.
+            res.merge(&db.trait_impls_in_crate(krate));
-        // As we might visit crates multiple times, `merge` has to deduplicate impls to avoid
-        // wasting memory.
-        for dep in &crate_graph[krate].dependencies {
-            res.merge(&db.impls_from_deps(dep.crate_id));
-            res.merge(&db.impls_in_crate(dep.crate_id));
        }
        Arc::new(res)
    }
-    fn fill(&mut self, db: &dyn HirDatabase, krate: CrateId) {
-        let crate_def_map = db.crate_def_map(krate);
-        for (_module_id, module_data) in crate_def_map.modules.iter() {
-            for impl_id in module_data.scope.impls() {
-                match db.impl_trait(impl_id) {
-                    Some(tr) => {
-                        let self_ty = db.impl_self_ty(impl_id);
-                        let self_ty_fp = TyFingerprint::for_impl(&self_ty.value);
-                        self.impls_by_trait
-                            .entry(tr.value.trait_)
-                            .or_default()
-                            .entry(self_ty_fp)
-                            .or_default()
-                            .push(impl_id);
-                    }
-                    None => {
-                        let self_ty = db.impl_self_ty(impl_id);
-                        if let Some(self_ty_fp) = TyFingerprint::for_impl(&self_ty.value) {
-                            self.inherent_impls.entry(self_ty_fp).or_default().push(impl_id);
-                        }
-                    }
-                }
-            }
-        }
-    }
    fn merge(&mut self, other: &Self) {
-        for (fp, impls) in &other.inherent_impls {
+        for (trait_, other_map) in &other.map {
-            let vec = self.inherent_impls.entry(*fp).or_default();
+            let map = self.map.entry(*trait_).or_default();
-            vec.extend(impls);
-            vec.sort();
-            vec.dedup();
-        }
-        for (trait_, other_map) in &other.impls_by_trait {
-            let map = self.impls_by_trait.entry(*trait_).or_default();
            for (fp, impls) in other_map {
                let vec = map.entry(*fp).or_default();
                vec.extend(impls);
-                vec.sort();
-                vec.dedup();
            }
        }
    }
-    pub fn lookup_impl_defs(&self, ty: &Ty) -> impl Iterator<Item = ImplId> + '_ {
+    /// Queries all impls of the given trait.
-        let fingerprint = TyFingerprint::for_impl(ty);
+    pub fn for_trait(&self, trait_: TraitId) -> impl Iterator<Item = ImplId> + '_ {
-        fingerprint.and_then(|f| self.inherent_impls.get(&f)).into_iter().flatten().copied()
+        self.map
-    }
+            .get(&trait_)
-    pub fn lookup_impl_defs_for_trait(&self, tr: TraitId) -> impl Iterator<Item = ImplId> + '_ {
-        self.impls_by_trait
-            .get(&tr)
            .into_iter()
-            .flat_map(|m| m.values().flat_map(|v| v.iter().copied()))
+            .flat_map(|map| map.values().flat_map(|v| v.iter().copied()))
    }
-    pub fn lookup_impl_defs_for_trait_and_ty(
+    /// Queries all impls of `trait_` that may apply to `self_ty`.
+    pub fn for_trait_and_self_ty(
        &self,
-        tr: TraitId,
+        trait_: TraitId,
-        fp: TyFingerprint,
+        self_ty: TyFingerprint,
    ) -> impl Iterator<Item = ImplId> + '_ {
-        self.impls_by_trait
+        self.map
-            .get(&tr)
+            .get(&trait_)
-            .and_then(|m| m.get(&Some(fp)))
            .into_iter()
-            .flatten()
+            .flat_map(move |map| map.get(&None).into_iter().chain(map.get(&Some(self_ty))))
-            .copied()
+            .flat_map(|v| v.iter().copied())
-            .chain(
+    }
-                self.impls_by_trait
-                    .get(&tr)
+    pub fn all_impls(&self) -> impl Iterator<Item = ImplId> + '_ {
-                    .and_then(|m| m.get(&None))
+        self.map.values().flat_map(|map| map.values().flat_map(|v| v.iter().copied()))
-                    .into_iter()
+    }
-                    .flatten()
+}
-                    .copied(),
-            )
+/// Inherent impls defined in some crate.
+///
+/// Inherent impls can only be defined in the crate that also defines the self type of the impl
+/// (note that some primitives are considered to be defined by both libcore and liballoc).
+///
+/// This makes inherent impl lookup easier than trait impl lookup since we only have to consider a
+/// single crate.
+#[derive(Debug, Eq, PartialEq)]
+pub struct InherentImpls {
+    map: FxHashMap<TyFingerprint, Vec<ImplId>>,
+}
+impl InherentImpls {
+    pub(crate) fn inherent_impls_in_crate_query(db: &dyn HirDatabase, krate: CrateId) -> Arc<Self> {
+        let mut map: FxHashMap<_, Vec<_>> = FxHashMap::default();
+        let crate_def_map = db.crate_def_map(krate);
+        for (_module_id, module_data) in crate_def_map.modules.iter() {
+            for impl_id in module_data.scope.impls() {
+                let data = db.impl_data(impl_id);
+                if data.target_trait.is_some() {
+                    continue;
+                }
+                let self_ty = db.impl_self_ty(impl_id);
+                if let Some(fp) = TyFingerprint::for_impl(&self_ty.value) {
+                    map.entry(fp).or_default().push(impl_id);
+                }
+            }
+        }
+        Arc::new(Self { map })
+    }
+    pub fn for_self_ty(&self, self_ty: &Ty) -> &[ImplId] {
+        match TyFingerprint::for_impl(self_ty) {
+            Some(fp) => self.map.get(&fp).map(|vec| vec.as_ref()).unwrap_or(&[]),
+            None => &[],
+        }
    }
-    pub fn all_impls<'a>(&'a self) -> impl Iterator<Item = ImplId> + 'a {
+    pub fn all_impls(&self) -> impl Iterator<Item = ImplId> + '_ {
-        self.inherent_impls
+        self.map.values().flat_map(|v| v.iter().copied())
-            .values()
-            .chain(self.impls_by_trait.values().flat_map(|m| m.values()))
-            .flatten()
-            .copied()
    }
 }
@@ -377,7 +373,7 @@ fn iterate_method_candidates_with_autoref(
        return true;
    }
    let refed = Canonical {
-        num_vars: deref_chain[0].num_vars,
+        kinds: deref_chain[0].kinds.clone(),
        value: Ty::apply_one(TypeCtor::Ref(Mutability::Shared), deref_chain[0].value.clone()),
    };
    if iterate_method_candidates_by_receiver(
@@ -393,7 +389,7 @@ fn iterate_method_candidates_with_autoref(
        return true;
    }
    let ref_muted = Canonical {
-        num_vars: deref_chain[0].num_vars,
+        kinds: deref_chain[0].kinds.clone(),
        value: Ty::apply_one(TypeCtor::Ref(Mutability::Mut), deref_chain[0].value.clone()),
    };
    if iterate_method_candidates_by_receiver(
@@ -524,9 +520,9 @@ fn iterate_inherent_methods(
        None => return false,
    };
    for krate in def_crates {
-        let impls = db.impls_in_crate(krate);
+        let impls = db.inherent_impls_in_crate(krate);
-        for impl_def in impls.lookup_impl_defs(&self_ty.value) {
+        for &impl_def in impls.for_self_ty(&self_ty.value) {
            for &item in db.impl_data(impl_def).items.iter() {
                if !is_valid_candidate(db, name, receiver_ty, item, self_ty) {
                    continue;
@@ -612,18 +608,19 @@ pub(crate) fn inherent_impl_substs(
    // we create a var for each type parameter of the impl; we need to keep in
    // mind here that `self_ty` might have vars of its own
    let vars = Substs::build_for_def(db, impl_id)
-        .fill_with_bound_vars(DebruijnIndex::INNERMOST, self_ty.num_vars)
+        .fill_with_bound_vars(DebruijnIndex::INNERMOST, self_ty.kinds.len())
        .build();
    let self_ty_with_vars = db.impl_self_ty(impl_id).subst(&vars);
-    let self_ty_with_vars =
+    let mut kinds = self_ty.kinds.to_vec();
-        Canonical { num_vars: vars.len() + self_ty.num_vars, value: self_ty_with_vars };
+    kinds.extend(iter::repeat(TyKind::General).take(vars.len()));
-    let substs = super::infer::unify(&self_ty_with_vars, self_ty);
+    let tys = Canonical { kinds: kinds.into(), value: (self_ty_with_vars, self_ty.value.clone()) };
+    let substs = super::infer::unify(&tys);
    // We only want the substs for the vars we added, not the ones from self_ty.
    // Also, if any of the vars we added are still in there, we replace them by
    // 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))
+    substs.map(|s| fallback_bound_vars(s.suffix(vars.len()), self_ty.kinds.len()))
 }
 /// This replaces any 'free' Bound vars in `s` (i.e. those with indices past
@@ -683,15 +680,15 @@ fn generic_implements_goal(
    trait_: TraitId,
    self_ty: Canonical<Ty>,
 ) -> Canonical<InEnvironment<super::Obligation>> {
-    let num_vars = self_ty.num_vars;
+    let mut kinds = self_ty.kinds.to_vec();
    let substs = super::Substs::build_for_def(db, trait_)
        .push(self_ty.value)
-        .fill_with_bound_vars(DebruijnIndex::INNERMOST, num_vars)
+        .fill_with_bound_vars(DebruijnIndex::INNERMOST, kinds.len())
        .build();
-    let num_vars = substs.len() - 1 + self_ty.num_vars;
+    kinds.extend(iter::repeat(TyKind::General).take(substs.len() - 1));
    let trait_ref = TraitRef { trait_, substs };
    let obligation = super::Obligation::Trait(trait_ref);
-    Canonical { num_vars, value: InEnvironment::new(env, obligation) }
+    Canonical { kinds: kinds.into(), value: InEnvironment::new(env, obligation) }
 }
 fn autoderef_method_receiver(
@@ -704,9 +701,9 @@ fn autoderef_method_receiver(
    if let Some(Ty::Apply(ApplicationTy { ctor: TypeCtor::Array, parameters })) =
        deref_chain.last().map(|ty| &ty.value)
    {
-        let num_vars = deref_chain.last().unwrap().num_vars;
+        let kinds = deref_chain.last().unwrap().kinds.clone();
        let unsized_ty = Ty::apply(TypeCtor::Slice, parameters.clone());
-        deref_chain.push(Canonical { value: unsized_ty, num_vars })
+        deref_chain.push(Canonical { value: unsized_ty, kinds })
    }
    deref_chain
 }
diff --git a/crates/ra_hir_ty/src/test_db.rs b/crates/ra_hir_ty/src/test_db.rs
index 0481a7b12..fddf0604d 100644
--- a/crates/ra_hir_ty/src/test_db.rs
+++ b/crates/ra_hir_ty/src/test_db.rs
@@ -8,8 +8,10 @@ use std::{
 use hir_def::{db::DefDatabase, AssocItemId, ModuleDefId, ModuleId};
 use hir_expand::{db::AstDatabase, diagnostics::DiagnosticSink};
 use ra_db::{salsa, CrateId, FileId, FileLoader, FileLoaderDelegate, SourceDatabase, Upcast};
-use rustc_hash::FxHashSet;
+use ra_syntax::TextRange;
+use rustc_hash::{FxHashMap, FxHashSet};
 use stdx::format_to;
+use test_utils::extract_annotations;
 use crate::{
    db::HirDatabase, diagnostics::Diagnostic, expr::ExprValidator,
@@ -155,17 +157,27 @@ impl TestDB {
        (buf, count)
    }
-    pub fn all_files(&self) -> Vec<FileId> {
+    pub fn extract_annotations(&self) -> FxHashMap<FileId, Vec<(TextRange, String)>> {
-        let mut res = Vec::new();
+        let mut files = Vec::new();
        let crate_graph = self.crate_graph();
        for krate in crate_graph.iter() {
            let crate_def_map = self.crate_def_map(krate);
            for (module_id, _) in crate_def_map.modules.iter() {
                let file_id = crate_def_map[module_id].origin.file_id();
-                res.extend(file_id)
+                files.extend(file_id)
            }
        }
-        res
+        files
+            .into_iter()
+            .filter_map(|file_id| {
+                let text = self.file_text(file_id);
+                let annotations = extract_annotations(&text);
+                if annotations.is_empty() {
+                    return None;
+                }
+                Some((file_id, annotations))
+            })
+            .collect()
    }
 }
diff --git a/crates/ra_hir_ty/src/tests.rs b/crates/ra_hir_ty/src/tests.rs
index 5424e6bb1..eeac34d14 100644
--- a/crates/ra_hir_ty/src/tests.rs
+++ b/crates/ra_hir_ty/src/tests.rs
@@ -28,7 +28,6 @@ use ra_syntax::{
    SyntaxNode,
 };
 use stdx::format_to;
-use test_utils::extract_annotations;
 use crate::{
    db::HirDatabase, display::HirDisplay, infer::TypeMismatch, test_db::TestDB, InferenceResult, Ty,
@@ -49,9 +48,7 @@ fn check_types_source_code(ra_fixture: &str) {
 fn check_types_impl(ra_fixture: &str, display_source: bool) {
    let db = TestDB::with_files(ra_fixture);
    let mut checked_one = false;
-    for file_id in db.all_files() {
+    for (file_id, annotations) in db.extract_annotations() {
-        let text = db.parse(file_id).syntax_node().to_string();
-        let annotations = extract_annotations(&text);
        for (range, expected) in annotations {
            let ty = type_at_range(&db, FileRange { file_id, range });
            let actual = if display_source {
@@ -511,6 +508,30 @@ fn no_such_field_with_feature_flag_diagnostics_on_struct_fields() {
 }
 #[test]
+fn no_such_field_with_type_macro() {
+    let diagnostics = TestDB::with_files(
+        r"
+        macro_rules! Type {
+            () => { u32 };
+        }
+        struct Foo {
+            bar: Type![],
+        }
+        impl Foo {
+            fn new() -> Self {
+                Foo { bar: 0 }
+            }
+        }
+        ",
+    )
+    .diagnostics()
+    .0;
+    assert_snapshot!(diagnostics, @r###""###);
+}
+#[test]
 fn missing_record_pat_field_diagnostic() {
    let diagnostics = TestDB::with_files(
        r"
diff --git a/crates/ra_hir_ty/src/tests/traits.rs b/crates/ra_hir_ty/src/tests/traits.rs
index 01c919a7e..766790576 100644
--- a/crates/ra_hir_ty/src/tests/traits.rs
+++ b/crates/ra_hir_ty/src/tests/traits.rs
@@ -3029,3 +3029,21 @@ fn infer_dyn_fn_output() {
    "###
    );
 }
+#[test]
+fn variable_kinds() {
+    check_types(
+        r#"
+trait Trait<T> { fn get(self, t: T) -> T; }
+struct S;
+impl Trait<u128> for S {}
+impl Trait<f32> for S {}
+fn test() {
+    S.get(1);
+  //^^^^^^^^ u128
+    S.get(1.);
+  //^^^^^^^^ f32
+}
+        "#,
+    );
+}
diff --git a/crates/ra_hir_ty/src/traits.rs b/crates/ra_hir_ty/src/traits.rs
index 6f43c3a22..2a6d7faef 100644
--- a/crates/ra_hir_ty/src/traits.rs
+++ b/crates/ra_hir_ty/src/traits.rs
@@ -1,5 +1,5 @@
 //! Trait solving using Chalk.
-use std::{panic, sync::Arc};
+use std::sync::Arc;
 use chalk_ir::cast::Cast;
 use hir_def::{
@@ -8,7 +8,7 @@ use hir_def::{
 use ra_db::{impl_intern_key, salsa, CrateId};
 use ra_prof::profile;
-use crate::{db::HirDatabase, DebruijnIndex};
+use crate::{db::HirDatabase, DebruijnIndex, Substs};
 use super::{Canonical, GenericPredicate, HirDisplay, ProjectionTy, TraitRef, Ty, TypeWalk};
@@ -190,15 +190,7 @@ fn solution_from_chalk(
    solution: chalk_solve::Solution<Interner>,
 ) -> Solution {
    let convert_subst = |subst: chalk_ir::Canonical<chalk_ir::Substitution<Interner>>| {
-        let value = subst
+        let result = from_chalk(db, subst);
-            .value
-            .iter(&Interner)
-            .map(|p| match p.ty(&Interner) {
-                Some(ty) => from_chalk(db, ty.clone()),
-                None => unimplemented!(),
-            })
-            .collect();
-        let result = Canonical { value, num_vars: subst.binders.len(&Interner) };
        SolutionVariables(result)
    };
    match solution {
@@ -222,7 +214,7 @@ fn solution_from_chalk(
 }
 #[derive(Clone, Debug, PartialEq, Eq)]
-pub struct SolutionVariables(pub Canonical<Vec<Ty>>);
+pub struct SolutionVariables(pub Canonical<Substs>);
 #[derive(Clone, Debug, PartialEq, Eq)]
 /// A (possible) solution for a proposed goal.
diff --git a/crates/ra_hir_ty/src/traits/chalk.rs b/crates/ra_hir_ty/src/traits/chalk.rs
index 8ef4941c0..c97b81d57 100644
--- a/crates/ra_hir_ty/src/traits/chalk.rs
+++ b/crates/ra_hir_ty/src/traits/chalk.rs
@@ -77,8 +77,8 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
        // Note: Since we're using impls_for_trait, only impls where the trait
        // can be resolved should ever reach Chalk. `impl_datum` relies on that
        // and will panic if the trait can't be resolved.
-        let in_deps = self.db.impls_from_deps(self.krate);
+        let in_deps = self.db.trait_impls_in_deps(self.krate);
-        let in_self = self.db.impls_in_crate(self.krate);
+        let in_self = self.db.trait_impls_in_crate(self.krate);
        let impl_maps = [in_deps, in_self];
        let id_to_chalk = |id: hir_def::ImplId| Impl::ImplDef(id).to_chalk(self.db);
@@ -87,14 +87,12 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
            Some(fp) => impl_maps
                .iter()
                .flat_map(|crate_impl_defs| {
-                    crate_impl_defs.lookup_impl_defs_for_trait_and_ty(trait_, fp).map(id_to_chalk)
+                    crate_impl_defs.for_trait_and_self_ty(trait_, fp).map(id_to_chalk)
                })
                .collect(),
            None => impl_maps
                .iter()
-                .flat_map(|crate_impl_defs| {
+                .flat_map(|crate_impl_defs| crate_impl_defs.for_trait(trait_).map(id_to_chalk))
-                    crate_impl_defs.lookup_impl_defs_for_trait(trait_).map(id_to_chalk)
-                })
                .collect(),
        };
diff --git a/crates/ra_hir_ty/src/traits/chalk/mapping.rs b/crates/ra_hir_ty/src/traits/chalk/mapping.rs
index ac82ea831..433d6aa03 100644
--- a/crates/ra_hir_ty/src/traits/chalk/mapping.rs
+++ b/crates/ra_hir_ty/src/traits/chalk/mapping.rs
@@ -17,7 +17,7 @@ use crate::{
    primitive::{FloatBitness, FloatTy, IntBitness, IntTy, Signedness},
    traits::{builtin, AssocTyValue, Canonical, Impl, Obligation},
    ApplicationTy, CallableDef, GenericPredicate, InEnvironment, OpaqueTy, OpaqueTyId,
-    ProjectionPredicate, ProjectionTy, Substs, TraitEnvironment, TraitRef, Ty, TypeCtor,
+    ProjectionPredicate, ProjectionTy, Substs, TraitEnvironment, TraitRef, Ty, TyKind, TypeCtor,
 };
 use super::interner::*;
@@ -555,22 +555,39 @@ where
    type Chalk = chalk_ir::Canonical<T::Chalk>;
    fn to_chalk(self, db: &dyn HirDatabase) -> chalk_ir::Canonical<T::Chalk> {
-        let parameter = chalk_ir::CanonicalVarKind::new(
+        let kinds = self
-            chalk_ir::VariableKind::Ty(chalk_ir::TyKind::General),
+            .kinds
-            chalk_ir::UniverseIndex::ROOT,
+            .iter()
-        );
+            .map(|k| match k {
+                TyKind::General => chalk_ir::TyKind::General,
+                TyKind::Integer => chalk_ir::TyKind::Integer,
+                TyKind::Float => chalk_ir::TyKind::Float,
+            })
+            .map(|tk| {
+                chalk_ir::CanonicalVarKind::new(
+                    chalk_ir::VariableKind::Ty(tk),
+                    chalk_ir::UniverseIndex::ROOT,
+                )
+            });
        let value = self.value.to_chalk(db);
-        chalk_ir::Canonical {
+        chalk_ir::Canonical { value, binders: chalk_ir::CanonicalVarKinds::from(&Interner, kinds) }
-            value,
-            binders: chalk_ir::CanonicalVarKinds::from(&Interner, vec![parameter; self.num_vars]),
-        }
    }
    fn from_chalk(db: &dyn HirDatabase, canonical: chalk_ir::Canonical<T::Chalk>) -> Canonical<T> {
-        Canonical {
+        let kinds = canonical
-            num_vars: canonical.binders.len(&Interner),
+            .binders
-            value: from_chalk(db, canonical.value),
+            .iter(&Interner)
-        }
+            .map(|k| match k.kind {
+                chalk_ir::VariableKind::Ty(tk) => match tk {
+                    chalk_ir::TyKind::General => TyKind::General,
+                    chalk_ir::TyKind::Integer => TyKind::Integer,
+                    chalk_ir::TyKind::Float => TyKind::Float,
+                },
+                chalk_ir::VariableKind::Lifetime => panic!("unexpected lifetime from Chalk"),
+                chalk_ir::VariableKind::Const(_) => panic!("unexpected const from Chalk"),
+            })
+            .collect();
+        Canonical { kinds, value: from_chalk(db, canonical.value) }
    }
 }
diff --git a/crates/ra_ide/Cargo.toml b/crates/ra_ide/Cargo.toml
index bbc6a5c9b..8e8892309 100644
--- a/crates/ra_ide/Cargo.toml
+++ b/crates/ra_ide/Cargo.toml
@@ -28,6 +28,7 @@ ra_cfg = { path = "../ra_cfg" }
 ra_fmt = { path = "../ra_fmt" }
 ra_prof = { path = "../ra_prof" }
 test_utils = { path = "../test_utils" }
+expect = { path = "../expect" }
 ra_assists = { path = "../ra_assists" }
 ra_ssr = { path = "../ra_ssr" }
diff --git a/crates/ra_ide/src/call_hierarchy.rs b/crates/ra_ide/src/call_hierarchy.rs
index 1e3a31602..884353808 100644
--- a/crates/ra_ide/src/call_hierarchy.rs
+++ b/crates/ra_ide/src/call_hierarchy.rs
@@ -39,10 +39,11 @@ pub(crate) fn call_hierarchy(
 pub(crate) fn incoming_calls(db: &RootDatabase, position: FilePosition) -> Option<Vec<CallItem>> {
    let sema = Semantics::new(db);
    // 1. Find all refs
    // 2. Loop through refs and determine unique fndef. This will become our `from: CallHierarchyItem,` in the reply.
    // 3. Add ranges relative to the start of the fndef.
-    let refs = references::find_all_refs(db, position, None)?;
+    let refs = references::find_all_refs(&sema, position, None)?;
    let mut calls = CallLocations::default();
@@ -355,4 +356,41 @@ fn caller3() {
            &["caller3 FN_DEF FileId(1) 66..83 69..76 : [52..59]"],
        );
    }
+    #[test]
+    fn test_call_hierarchy_issue_5103() {
+        check_hierarchy(
+            r#"
+fn a() {
+    b()
+}
+fn b() {}
+fn main() {
+    a<|>()
+}
+"#,
+            "a FN_DEF FileId(1) 0..18 3..4",
+            &["main FN_DEF FileId(1) 31..52 34..38 : [47..48]"],
+            &["b FN_DEF FileId(1) 20..29 23..24 : [13..14]"],
+        );
+        check_hierarchy(
+            r#"
+fn a() {
+    b<|>()
+}
+fn b() {}
+fn main() {
+    a()
+}
+"#,
+            "b FN_DEF FileId(1) 20..29 23..24",
+            &["a FN_DEF FileId(1) 0..18 3..4 : [13..14]"],
+            &[],
+        );
+    }
 }
diff --git a/crates/ra_ide/src/completion.rs b/crates/ra_ide/src/completion.rs
index e1fcf379d..9ebb8ebb7 100644
--- a/crates/ra_ide/src/completion.rs
+++ b/crates/ra_ide/src/completion.rs
@@ -63,11 +63,11 @@ pub use crate::completion::{
 // There also snippet completions:
 //
 // .Expressions
-// - `pd` -> `println!("{:?}")`
+// - `pd` -> `eprintln!(" = {:?}", );")`
-// - `ppd` -> `println!("{:#?}")`
+// - `ppd` -> `eprintln!(" = {:#?}", );`
 //
 // .Items
-// - `tfn` -> `#[test] fn f(){}`
+// - `tfn` -> `#[test] fn feature(){}`
 // - `tmod` ->
 // ```rust
 // #[cfg(test)]
@@ -75,7 +75,7 @@ pub use crate::completion::{
 //     use super::*;
 //
 //     #[test]
-//     fn test_fn() {}
+//     fn test_name() {}
 // }
 // ```
@@ -137,8 +137,8 @@ mod tests {
        documentation: &'a str,
    }
-    fn check_detail_and_documentation(fixture: &str, expected: DetailAndDocumentation) {
+    fn check_detail_and_documentation(ra_fixture: &str, expected: DetailAndDocumentation) {
-        let (analysis, position) = analysis_and_position(fixture);
+        let (analysis, position) = analysis_and_position(ra_fixture);
        let config = CompletionConfig::default();
        let completions = analysis.completions(&config, position).unwrap().unwrap();
        for item in completions {
diff --git a/crates/ra_ide/src/completion/complete_keyword.rs b/crates/ra_ide/src/completion/complete_keyword.rs
index 3b174f916..e599cc3d1 100644
--- a/crates/ra_ide/src/completion/complete_keyword.rs
+++ b/crates/ra_ide/src/completion/complete_keyword.rs
@@ -1,6 +1,6 @@
 //! FIXME: write short doc here
-use ra_syntax::ast;
+use ra_syntax::{ast, SyntaxKind};
 use crate::completion::{
    CompletionContext, CompletionItem, CompletionItemKind, CompletionKind, Completions,
@@ -37,6 +37,10 @@ pub(super) fn complete_use_tree_keyword(acc: &mut Completions, ctx: &CompletionC
 }
 pub(super) fn complete_expr_keyword(acc: &mut Completions, ctx: &CompletionContext) {
+    if ctx.token.kind() == SyntaxKind::COMMENT {
+        return;
+    }
    let has_trait_or_impl_parent = ctx.has_impl_parent || ctx.has_trait_parent;
    if ctx.trait_as_prev_sibling || ctx.impl_as_prev_sibling {
        add_keyword(ctx, acc, "where", "where ");
diff --git a/crates/ra_ide/src/completion/completion_context.rs b/crates/ra_ide/src/completion/completion_context.rs
index 560fb19e6..ef22ea54d 100644
--- a/crates/ra_ide/src/completion/completion_context.rs
+++ b/crates/ra_ide/src/completion/completion_context.rs
@@ -213,7 +213,7 @@ impl<'a> CompletionContext<'a> {
        }
    }
-    pub(crate) fn scope(&self) -> SemanticsScope<'_, RootDatabase> {
+    pub(crate) fn scope(&self) -> SemanticsScope<'_> {
        self.sema.scope_at_offset(&self.token.parent(), self.offset)
    }
diff --git a/crates/ra_ide/src/completion/presentation.rs b/crates/ra_ide/src/completion/presentation.rs
index 4fdc2f0bb..b18279746 100644
--- a/crates/ra_ide/src/completion/presentation.rs
+++ b/crates/ra_ide/src/completion/presentation.rs
@@ -1516,4 +1516,54 @@ mod tests {
        "###
        );
    }
+    #[test]
+    fn no_keyword_autocompletion_on_line_comments() {
+        assert_debug_snapshot!(
+        do_completion(
+                r"
+                    fn test() {
+                        let x = 2; // A comment<|>
+                    }
+                    ",
+                CompletionKind::Keyword
+        ),
+            @r###"
+            []
+            "###
+        );
+    }
+    #[test]
+    fn no_keyword_autocompletion_on_multi_line_comments() {
+        assert_debug_snapshot!(
+        do_completion(
+                r"
+                    /*
+                    Some multi-line comment<|>
+                    */
+                    ",
+                CompletionKind::Keyword
+        ),
+            @r###"
+            []
+            "###
+        );
+    }
+    #[test]
+    fn no_keyword_autocompletion_on_doc_comments() {
+        assert_debug_snapshot!(
+        do_completion(
+                r"
+                    /// Some doc comment
+                    /// let test<|> = 1
+                    ",
+                CompletionKind::Keyword
+        ),
+            @r###"
+            []
+            "###
+        );
+    }
 }
diff --git a/crates/ra_ide/src/diagnostics.rs b/crates/ra_ide/src/diagnostics.rs
index 05fb799d6..46f8c31c7 100644
--- a/crates/ra_ide/src/diagnostics.rs
+++ b/crates/ra_ide/src/diagnostics.rs
@@ -324,10 +324,10 @@ mod tests {
    ///  * a diagnostic is produced
    ///  * this diagnostic touches the input cursor position
    ///  * that the contents of the file containing the cursor match `after` after the diagnostic fix is applied
-    fn check_apply_diagnostic_fix_from_position(fixture: &str, after: &str) {
+    fn check_apply_diagnostic_fix_from_position(ra_fixture: &str, after: &str) {
        let after = trim_indent(after);
-        let (analysis, file_position) = analysis_and_position(fixture);
+        let (analysis, file_position) = analysis_and_position(ra_fixture);
        let diagnostic = analysis.diagnostics(file_position.file_id).unwrap().pop().unwrap();
        let mut fix = diagnostic.fix.unwrap();
        let edit = fix.source_change.source_file_edits.pop().unwrap().edit;
@@ -365,14 +365,14 @@ mod tests {
    /// Takes a multi-file input fixture with annotated cursor position and checks that no diagnostics
    /// apply to the file containing the cursor.
-    fn check_no_diagnostic_for_target_file(fixture: &str) {
+    fn check_no_diagnostic_for_target_file(ra_fixture: &str) {
-        let (analysis, file_position) = analysis_and_position(fixture);
+        let (analysis, file_position) = analysis_and_position(ra_fixture);
        let diagnostics = analysis.diagnostics(file_position.file_id).unwrap();
        assert_eq!(diagnostics.len(), 0);
    }
-    fn check_no_diagnostic(content: &str) {
+    fn check_no_diagnostic(ra_fixture: &str) {
-        let (analysis, file_id) = single_file(content);
+        let (analysis, file_id) = single_file(ra_fixture);
        let diagnostics = analysis.diagnostics(file_id).unwrap();
        assert_eq!(diagnostics.len(), 0, "expected no diagnostic, found one");
    }
@@ -473,7 +473,8 @@ mod tests {
    #[test]
    fn test_wrap_return_type_not_applicable_when_expr_type_does_not_match_ok_type() {
-        let content = r#"
+        check_no_diagnostic_for_target_file(
+            r"
            //- /main.rs
            use core::result::Result::{self, Ok, Err};
@@ -485,13 +486,14 @@ mod tests {
            pub mod result {
                pub enum Result<T, E> { Ok(T), Err(E) }
            }
-        "#;
+        ",
-        check_no_diagnostic_for_target_file(content);
+        );
    }
    #[test]
    fn test_wrap_return_type_not_applicable_when_return_type_is_not_result() {
-        let content = r#"
+        check_no_diagnostic_for_target_file(
+            r"
            //- /main.rs
            use core::result::Result::{self, Ok, Err};
@@ -508,8 +510,8 @@ mod tests {
            pub mod result {
                pub enum Result<T, E> { Ok(T), Err(E) }
            }
-        "#;
+        ",
-        check_no_diagnostic_for_target_file(content);
+        );
    }
    #[test]
@@ -618,7 +620,8 @@ mod tests {
    #[test]
    fn test_fill_struct_fields_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
            struct TestStruct {
                one: i32,
                two: i64,
@@ -628,14 +631,14 @@ mod tests {
                let one = 1;
                let s = TestStruct{ one, two: 2 };
            }
-        ";
+        ",
+        );
-        check_no_diagnostic(content);
    }
    #[test]
    fn test_fill_struct_fields_no_diagnostic_on_spread() {
-        let content = r"
+        check_no_diagnostic(
+            r"
            struct TestStruct {
                one: i32,
                two: i64,
@@ -645,9 +648,8 @@ mod tests {
                let one = 1;
                let s = TestStruct{ ..a };
            }
-        ";
+        ",
+        );
-        check_no_diagnostic(content);
    }
    #[test]
diff --git a/crates/ra_ide/src/display/navigation_target.rs b/crates/ra_ide/src/display/navigation_target.rs
index 0b52b01ab..8bf2428ed 100644
--- a/crates/ra_ide/src/display/navigation_target.rs
+++ b/crates/ra_ide/src/display/navigation_target.rs
@@ -11,7 +11,7 @@ use ra_syntax::{
    TextRange,
 };
-use crate::{FileRange, FileSymbol};
+use crate::FileSymbol;
 use super::short_label::ShortLabel;
@@ -47,6 +47,19 @@ impl NavigationTarget {
    pub fn range(&self) -> TextRange {
        self.focus_range.unwrap_or(self.full_range)
    }
+    /// A "most interesting" range withing the `full_range`.
+    ///
+    /// Typically, `full_range` is the whole syntax node,
+    /// including doc comments, and `focus_range` is the range of the identifier.
+    pub fn focus_range(&self) -> Option<TextRange> {
+        self.focus_range
+    }
+    pub fn full_range(&self) -> TextRange {
+        self.full_range
+    }
+    pub fn file_id(&self) -> FileId {
+        self.file_id
+    }
    pub fn name(&self) -> &SmolStr {
        &self.name
@@ -60,18 +73,6 @@ impl NavigationTarget {
        self.kind
    }
-    pub fn file_id(&self) -> FileId {
-        self.file_id
-    }
-    pub fn file_range(&self) -> FileRange {
-        FileRange { file_id: self.file_id, range: self.full_range }
-    }
-    pub fn full_range(&self) -> TextRange {
-        self.full_range
-    }
    pub fn docs(&self) -> Option<&str> {
        self.docs.as_deref()
    }
@@ -80,14 +81,6 @@ impl NavigationTarget {
        self.description.as_deref()
    }
-    /// A "most interesting" range withing the `full_range`.
-    ///
-    /// Typically, `full_range` is the whole syntax node,
-    /// including doc comments, and `focus_range` is the range of the identifier.
-    pub fn focus_range(&self) -> Option<TextRange> {
-        self.focus_range
-    }
    pub(crate) fn from_module_to_decl(db: &RootDatabase, module: hir::Module) -> NavigationTarget {
        let name = module.name(db).map(|it| it.to_string().into()).unwrap_or_default();
        if let Some(src) = module.declaration_source(db) {
@@ -278,16 +271,22 @@ impl ToNav for hir::Module {
 impl ToNav for hir::ImplDef {
    fn to_nav(&self, db: &RootDatabase) -> NavigationTarget {
        let src = self.source(db);
-        let frange = if let Some(item) = self.is_builtin_derive(db) {
+        let derive_attr = self.is_builtin_derive(db);
+        let frange = if let Some(item) = &derive_attr {
            original_range(db, item.syntax())
        } else {
            original_range(db, src.as_ref().map(|it| it.syntax()))
        };
+        let focus_range = if derive_attr.is_some() {
+            None
+        } else {
+            src.value.target_type().map(|ty| original_range(db, src.with_value(ty.syntax())).range)
+        };
        NavigationTarget::from_syntax(
            frange.file_id,
            "impl".into(),
-            None,
+            focus_range,
            frange.range,
            src.value.syntax().kind(),
        )
diff --git a/crates/ra_ide/src/display/structure.rs b/crates/ra_ide/src/display/structure.rs
index aad5a8e4d..c22a5d17b 100644
--- a/crates/ra_ide/src/display/structure.rs
+++ b/crates/ra_ide/src/display/structure.rs
@@ -173,12 +173,19 @@ fn structure_node(node: &SyntaxNode) -> Option<StructureNode> {
 #[cfg(test)]
 mod tests {
+    use expect::{expect, Expect};
    use super::*;
-    use insta::assert_debug_snapshot;
+    fn check(ra_fixture: &str, expect: Expect) {
+        let file = SourceFile::parse(ra_fixture).ok().unwrap();
+        let structure = file_structure(&file);
+        expect.assert_debug_eq(&structure)
+    }
    #[test]
    fn test_file_structure() {
-        let file = SourceFile::parse(
+        check(
            r#"
 struct Foo {
    x: i32
@@ -223,216 +230,211 @@ fn obsolete() {}
 #[deprecated(note = "for awhile")]
 fn very_obsolete() {}
 "#,
-        )
+            expect![[r#"
-        .ok()
+                [
-        .unwrap();
+                    StructureNode {
-        let structure = file_structure(&file);
+                        parent: None,
-        assert_debug_snapshot!(structure,
+                        label: "Foo",
-        @r###"
+                        navigation_range: 8..11,
-        [
+                        node_range: 1..26,
-            StructureNode {
+                        kind: STRUCT_DEF,
-                parent: None,
+                        detail: None,
-                label: "Foo",
+                        deprecated: false,
-                navigation_range: 8..11,
+                    },
-                node_range: 1..26,
+                    StructureNode {
-                kind: STRUCT_DEF,
+                        parent: Some(
-                detail: None,
+                            0,
-                deprecated: false,
+                        ),
-            },
+                        label: "x",
-            StructureNode {
+                        navigation_range: 18..19,
-                parent: Some(
+                        node_range: 18..24,
-                    0,
+                        kind: RECORD_FIELD_DEF,
-                ),
+                        detail: Some(
-                label: "x",
+                            "i32",
-                navigation_range: 18..19,
+                        ),
-                node_range: 18..24,
+                        deprecated: false,
-                kind: RECORD_FIELD_DEF,
+                    },
-                detail: Some(
+                    StructureNode {
-                    "i32",
+                        parent: None,
-                ),
+                        label: "m",
-                deprecated: false,
+                        navigation_range: 32..33,
-            },
+                        node_range: 28..158,
-            StructureNode {
+                        kind: MODULE,
-                parent: None,
+                        detail: None,
-                label: "m",
+                        deprecated: false,
-                navigation_range: 32..33,
+                    },
-                node_range: 28..158,
+                    StructureNode {
-                kind: MODULE,
+                        parent: Some(
-                detail: None,
+                            2,
-                deprecated: false,
+                        ),
-            },
+                        label: "bar1",
-            StructureNode {
+                        navigation_range: 43..47,
-                parent: Some(
+                        node_range: 40..52,
-                    2,
+                        kind: FN_DEF,
-                ),
+                        detail: Some(
-                label: "bar1",
+                            "fn()",
-                navigation_range: 43..47,
+                        ),
-                node_range: 40..52,
+                        deprecated: false,
-                kind: FN_DEF,
+                    },
-                detail: Some(
+                    StructureNode {
-                    "fn()",
+                        parent: Some(
-                ),
+                            2,
-                deprecated: false,
+                        ),
-            },
+                        label: "bar2",
-            StructureNode {
+                        navigation_range: 60..64,
-                parent: Some(
+                        node_range: 57..81,
-                    2,
+                        kind: FN_DEF,
-                ),
+                        detail: Some(
-                label: "bar2",
+                            "fn<T>(t: T) -> T",
-                navigation_range: 60..64,
+                        ),
-                node_range: 57..81,
+                        deprecated: false,
-                kind: FN_DEF,
+                    },
-                detail: Some(
+                    StructureNode {
-                    "fn<T>(t: T) -> T",
+                        parent: Some(
-                ),
+                            2,
-                deprecated: false,
+                        ),
-            },
+                        label: "bar3",
-            StructureNode {
+                        navigation_range: 89..93,
-                parent: Some(
+                        node_range: 86..156,
-                    2,
+                        kind: FN_DEF,
-                ),
+                        detail: Some(
-                label: "bar3",
+                            "fn<A, B>(a: A, b: B) -> Vec< u32 >",
-                navigation_range: 89..93,
+                        ),
-                node_range: 86..156,
+                        deprecated: false,
-                kind: FN_DEF,
+                    },
-                detail: Some(
+                    StructureNode {
-                    "fn<A, B>(a: A, b: B) -> Vec< u32 >",
+                        parent: None,
-                ),
+                        label: "E",
-                deprecated: false,
+                        navigation_range: 165..166,
-            },
+                        node_range: 160..180,
-            StructureNode {
+                        kind: ENUM_DEF,
-                parent: None,
+                        detail: None,
-                label: "E",
+                        deprecated: false,
-                navigation_range: 165..166,
+                    },
-                node_range: 160..180,
+                    StructureNode {
-                kind: ENUM_DEF,
+                        parent: Some(
-                detail: None,
+                            6,
-                deprecated: false,
+                        ),
-            },
+                        label: "X",
-            StructureNode {
+                        navigation_range: 169..170,
-                parent: Some(
+                        node_range: 169..170,
-                    6,
+                        kind: ENUM_VARIANT,
-                ),
+                        detail: None,
-                label: "X",
+                        deprecated: false,
-                navigation_range: 169..170,
+                    },
-                node_range: 169..170,
+                    StructureNode {
-                kind: ENUM_VARIANT,
+                        parent: Some(
-                detail: None,
+                            6,
-                deprecated: false,
+                        ),
-            },
+                        label: "Y",
-            StructureNode {
+                        navigation_range: 172..173,
-                parent: Some(
+                        node_range: 172..178,
-                    6,
+                        kind: ENUM_VARIANT,
-                ),
+                        detail: None,
-                label: "Y",
+                        deprecated: false,
-                navigation_range: 172..173,
+                    },
-                node_range: 172..178,
+                    StructureNode {
-                kind: ENUM_VARIANT,
+                        parent: None,
-                detail: None,
+                        label: "T",
-                deprecated: false,
+                        navigation_range: 186..187,
-            },
+                        node_range: 181..193,
-            StructureNode {
+                        kind: TYPE_ALIAS_DEF,
-                parent: None,
+                        detail: Some(
-                label: "T",
+                            "()",
-                navigation_range: 186..187,
+                        ),
-                node_range: 181..193,
+                        deprecated: false,
-                kind: TYPE_ALIAS_DEF,
+                    },
-                detail: Some(
+                    StructureNode {
-                    "()",
+                        parent: None,
-                ),
+                        label: "S",
-                deprecated: false,
+                        navigation_range: 201..202,
-            },
+                        node_range: 194..213,
-            StructureNode {
+                        kind: STATIC_DEF,
-                parent: None,
+                        detail: Some(
-                label: "S",
+                            "i32",
-                navigation_range: 201..202,
+                        ),
-                node_range: 194..213,
+                        deprecated: false,
-                kind: STATIC_DEF,
+                    },
-                detail: Some(
+                    StructureNode {
-                    "i32",
+                        parent: None,
-                ),
+                        label: "C",
-                deprecated: false,
+                        navigation_range: 220..221,
-            },
+                        node_range: 214..232,
-            StructureNode {
+                        kind: CONST_DEF,
-                parent: None,
+                        detail: Some(
-                label: "C",
+                            "i32",
-                navigation_range: 220..221,
+                        ),
-                node_range: 214..232,
+                        deprecated: false,
-                kind: CONST_DEF,
+                    },
-                detail: Some(
+                    StructureNode {
-                    "i32",
+                        parent: None,
-                ),
+                        label: "impl E",
-                deprecated: false,
+                        navigation_range: 239..240,
-            },
+                        node_range: 234..243,
-            StructureNode {
+                        kind: IMPL_DEF,
-                parent: None,
+                        detail: None,
-                label: "impl E",
+                        deprecated: false,
-                navigation_range: 239..240,
+                    },
-                node_range: 234..243,
+                    StructureNode {
-                kind: IMPL_DEF,
+                        parent: None,
-                detail: None,
+                        label: "impl fmt::Debug for E",
-                deprecated: false,
+                        navigation_range: 265..266,
-            },
+                        node_range: 245..269,
-            StructureNode {
+                        kind: IMPL_DEF,
-                parent: None,
+                        detail: None,
-                label: "impl fmt::Debug for E",
+                        deprecated: false,
-                navigation_range: 265..266,
+                    },
-                node_range: 245..269,
+                    StructureNode {
-                kind: IMPL_DEF,
+                        parent: None,
-                detail: None,
+                        label: "mc",
-                deprecated: false,
+                        navigation_range: 284..286,
-            },
+                        node_range: 271..303,
-            StructureNode {
+                        kind: MACRO_CALL,
-                parent: None,
+                        detail: None,
-                label: "mc",
+                        deprecated: false,
-                navigation_range: 284..286,
+                    },
-                node_range: 271..303,
+                    StructureNode {
-                kind: MACRO_CALL,
+                        parent: None,
-                detail: None,
+                        label: "mcexp",
-                deprecated: false,
+                        navigation_range: 334..339,
-            },
+                        node_range: 305..356,
-            StructureNode {
+                        kind: MACRO_CALL,
-                parent: None,
+                        detail: None,
-                label: "mcexp",
+                        deprecated: false,
-                navigation_range: 334..339,
+                    },
-                node_range: 305..356,
+                    StructureNode {
-                kind: MACRO_CALL,
+                        parent: None,
-                detail: None,
+                        label: "mcexp",
-                deprecated: false,
+                        navigation_range: 387..392,
-            },
+                        node_range: 358..409,
-            StructureNode {
+                        kind: MACRO_CALL,
-                parent: None,
+                        detail: None,
-                label: "mcexp",
+                        deprecated: false,
-                navigation_range: 387..392,
+                    },
-                node_range: 358..409,
+                    StructureNode {
-                kind: MACRO_CALL,
+                        parent: None,
-                detail: None,
+                        label: "obsolete",
-                deprecated: false,
+                        navigation_range: 428..436,
-            },
+                        node_range: 411..441,
-            StructureNode {
+                        kind: FN_DEF,
-                parent: None,
+                        detail: Some(
-                label: "obsolete",
+                            "fn()",
-                navigation_range: 428..436,
+                        ),
-                node_range: 411..441,
+                        deprecated: true,
-                kind: FN_DEF,
+                    },
-                detail: Some(
+                    StructureNode {
-                    "fn()",
+                        parent: None,
-                ),
+                        label: "very_obsolete",
-                deprecated: true,
+                        navigation_range: 481..494,
-            },
+                        node_range: 443..499,
-            StructureNode {
+                        kind: FN_DEF,
-                parent: None,
+                        detail: Some(
-                label: "very_obsolete",
+                            "fn()",
-                navigation_range: 481..494,
+                        ),
-                node_range: 443..499,
+                        deprecated: true,
-                kind: FN_DEF,
+                    },
-                detail: Some(
+                ]
-                    "fn()",
+            "#]],
-                ),
+        );
-                deprecated: true,
-            },
-        ]
-        "###
-                );
    }
 }
diff --git a/crates/ra_ide/src/expand_macro.rs b/crates/ra_ide/src/expand_macro.rs
index 54a47aac0..043515f54 100644
--- a/crates/ra_ide/src/expand_macro.rs
+++ b/crates/ra_ide/src/expand_macro.rs
@@ -2,7 +2,9 @@ use hir::Semantics;
 use ra_ide_db::RootDatabase;
 use ra_syntax::{
    algo::{find_node_at_offset, SyntaxRewriter},
-    ast, AstNode, NodeOrToken, SyntaxKind, SyntaxNode, WalkEvent, T,
+    ast, AstNode, NodeOrToken, SyntaxKind,
+    SyntaxKind::*,
+    SyntaxNode, WalkEvent, T,
 };
 use crate::FilePosition;
@@ -65,8 +67,6 @@ fn expand_macro_recur(
 // FIXME: It would also be cool to share logic here and in the mbe tests,
 // which are pretty unreadable at the moment.
 fn insert_whitespaces(syn: SyntaxNode) -> String {
-    use SyntaxKind::*;
    let mut res = String::new();
    let mut token_iter = syn
        .preorder_with_tokens()
@@ -120,175 +120,164 @@ fn insert_whitespaces(syn: SyntaxNode) -> String {
 #[cfg(test)]
 mod tests {
-    use insta::assert_snapshot;
+    use expect::{expect, Expect};
    use crate::mock_analysis::analysis_and_position;
-    use super::*;
+    fn check(ra_fixture: &str, expect: Expect) {
+        let (analysis, pos) = analysis_and_position(ra_fixture);
-    fn check_expand_macro(fixture: &str) -> ExpandedMacro {
+        let expansion = analysis.expand_macro(pos).unwrap().unwrap();
-        let (analysis, pos) = analysis_and_position(fixture);
+        let actual = format!("{}\n{}", expansion.name, expansion.expansion);
-        analysis.expand_macro(pos).unwrap().unwrap()
+        expect.assert_eq(&actual);
    }
    #[test]
    fn macro_expand_recursive_expansion() {
-        let res = check_expand_macro(
+        check(
            r#"
-        //- /lib.rs
+macro_rules! bar {
-        macro_rules! bar {
+    () => { fn  b() {} }
-            () => { fn  b() {} }
+}
-        }
+macro_rules! foo {
-        macro_rules! foo {
+    () => { bar!(); }
-            () => { bar!(); }
+}
-        }
+macro_rules! baz {
-        macro_rules! baz {
+    () => { foo!(); }
-            () => { foo!(); }
+}
-        }
+f<|>oo!();
-        f<|>oo!();
+"#,
-        "#,
+            expect![[r#"
+                foo
+                fn b(){}
+            "#]],
        );
-        assert_eq!(res.name, "foo");
-        assert_snapshot!(res.expansion, @r###"
-fn b(){}
-"###);
    }
    #[test]
    fn macro_expand_multiple_lines() {
-        let res = check_expand_macro(
+        check(
            r#"
-        //- /lib.rs
+macro_rules! foo {
-        macro_rules! foo {
+    () => {
-            () => {
+        fn some_thing() -> u32 {
-                fn some_thing() -> u32 {
+            let a = 0;
-                    let a = 0;
+            a + 10
-                    a + 10
-                }
-            }
        }
-        f<|>oo!();
+    }
+}
+f<|>oo!();
        "#,
+            expect![[r#"
+            foo
+            fn some_thing() -> u32 {
+              let a = 0;
+              a+10
+            }"#]],
        );
-        assert_eq!(res.name, "foo");
-        assert_snapshot!(res.expansion, @r###"
-fn some_thing() -> u32 {
-  let a = 0;
-  a+10
-}
-"###);
    }
    #[test]
    fn macro_expand_match_ast() {
-        let res = check_expand_macro(
+        check(
            r#"
-        //- /lib.rs
+macro_rules! match_ast {
-        macro_rules! match_ast {
+    (match $node:ident { $($tt:tt)* }) => { match_ast!(match ($node) { $($tt)* }) };
-            (match $node:ident { $($tt:tt)* }) => { match_ast!(match ($node) { $($tt)* }) };
+    (match ($node:expr) {
+        $( ast::$ast:ident($it:ident) => $res:block, )*
+        _ => $catch_all:expr $(,)?
+    }) => {{
+        $( if let Some($it) = ast::$ast::cast($node.clone()) $res else )*
+        { $catch_all }
+    }};
+}
-            (match ($node:expr) {
+fn main() {
-                $( ast::$ast:ident($it:ident) => $res:block, )*
+    mat<|>ch_ast! {
-                _ => $catch_all:expr $(,)?
+        match container {
-            }) => {{
+            ast::TraitDef(it) => {},
-                $( if let Some($it) = ast::$ast::cast($node.clone()) $res else )*
+            ast::ImplDef(it) => {},
-                { $catch_all }
+            _ => { continue },
-            }};
        }
-        fn main() {
-            mat<|>ch_ast! {
-                match container {
-                    ast::TraitDef(it) => {},
-                    ast::ImplDef(it) => {},
-                    _ => { continue },
-                }
-            }
-        }
-        "#,
-        );
-        assert_eq!(res.name, "match_ast");
-        assert_snapshot!(res.expansion, @r###"
-{
-  if let Some(it) = ast::TraitDef::cast(container.clone()){}
-  else if let Some(it) = ast::ImplDef::cast(container.clone()){}
-  else {
-    {
-      continue
    }
-  }
 }
-"###);
+"#,
+            expect![[r#"
+       match_ast
+       {
+         if let Some(it) = ast::TraitDef::cast(container.clone()){}
+         else if let Some(it) = ast::ImplDef::cast(container.clone()){}
+         else {
+           {
+             continue
+           }
+         }
+       }"#]],
+        );
    }
    #[test]
    fn macro_expand_match_ast_inside_let_statement() {
-        let res = check_expand_macro(
+        check(
            r#"
-        //- /lib.rs
+macro_rules! match_ast {
-        macro_rules! match_ast {
+    (match $node:ident { $($tt:tt)* }) => { match_ast!(match ($node) { $($tt)* }) };
-            (match $node:ident { $($tt:tt)* }) => { match_ast!(match ($node) { $($tt)* }) };
+    (match ($node:expr) {}) => {{}};
-            (match ($node:expr) {}) => {{}};
+}
-        }
-        fn main() {
+fn main() {
-            let p = f(|it| {
+    let p = f(|it| {
-                let res = mat<|>ch_ast! { match c {}};
+        let res = mat<|>ch_ast! { match c {}};
-                Some(res)
+        Some(res)
-            })?;
+    })?;
-        }
+}
-        "#,
+"#,
+            expect![[r#"
+                match_ast
+                {}
+            "#]],
        );
-        assert_eq!(res.name, "match_ast");
-        assert_snapshot!(res.expansion, @r###"{}"###);
    }
    #[test]
    fn macro_expand_inner_macro_fail_to_expand() {
-        let res = check_expand_macro(
+        check(
            r#"
-        //- /lib.rs
+macro_rules! bar {
-        macro_rules! bar {
+    (BAD) => {};
-            (BAD) => {};
+}
-        }
+macro_rules! foo {
-        macro_rules! foo {
+    () => {bar!()};
-            () => {bar!()};
+}
-        }
-        fn main() {
+fn main() {
-            let res = fo<|>o!();
+    let res = fo<|>o!();
-        }
+}
-        "#,
+"#,
+            expect![[r#"
+                foo
+            "#]],
        );
-        assert_eq!(res.name, "foo");
-        assert_snapshot!(res.expansion, @r###""###);
    }
    #[test]
    fn macro_expand_with_dollar_crate() {
-        let res = check_expand_macro(
+        check(
            r#"
-        //- /lib.rs
+#[macro_export]
-        #[macro_export]
+macro_rules! bar {
-        macro_rules! bar {
+    () => {0};
-            () => {0};
+}
-        }
+macro_rules! foo {
-        macro_rules! foo {
+    () => {$crate::bar!()};
-            () => {$crate::bar!()};
+}
-        }
-        fn main() {
+fn main() {
-            let res = fo<|>o!();
+    let res = fo<|>o!();
-        }
+}
-        "#,
+"#,
+            expect![[r#"
+                foo
+                0 "#]],
        );
-        assert_eq!(res.name, "foo");
-        assert_snapshot!(res.expansion, @r###"0"###);
    }
 }
diff --git a/crates/ra_ide/src/folding_ranges.rs b/crates/ra_ide/src/folding_ranges.rs
index 8657377de..5cec689f8 100644
--- a/crates/ra_ide/src/folding_ranges.rs
+++ b/crates/ra_ide/src/folding_ranges.rs
@@ -15,6 +15,7 @@ pub enum FoldKind {
    Imports,
    Mods,
    Block,
+    ArgList,
 }
 #[derive(Debug)]
@@ -83,6 +84,7 @@ fn fold_kind(kind: SyntaxKind) -> Option<FoldKind> {
    match kind {
        COMMENT => Some(FoldKind::Comment),
        USE_ITEM => Some(FoldKind::Imports),
+        ARG_LIST => Some(FoldKind::ArgList),
        RECORD_FIELD_DEF_LIST
        | RECORD_FIELD_PAT_LIST
        | ITEM_LIST
@@ -196,89 +198,85 @@ fn contiguous_range_for_comment(
 #[cfg(test)]
 mod tests {
+    use test_utils::extract_tags;
    use super::*;
-    use test_utils::extract_ranges;
-    fn do_check(text: &str, fold_kinds: &[FoldKind]) {
+    fn check(ra_fixture: &str) {
-        let (ranges, text) = extract_ranges(text, "fold");
+        let (ranges, text) = extract_tags(ra_fixture, "fold");
        let parse = SourceFile::parse(&text);
        let folds = folding_ranges(&parse.tree());
        assert_eq!(
            folds.len(),
            ranges.len(),
            "The amount of folds is different than the expected amount"
        );
-        assert_eq!(
-            folds.len(),
+        for (fold, (range, attr)) in folds.iter().zip(ranges.into_iter()) {
-            fold_kinds.len(),
-            "The amount of fold kinds is different than the expected amount"
-        );
-        for ((fold, range), fold_kind) in
-            folds.iter().zip(ranges.into_iter()).zip(fold_kinds.iter())
-        {
            assert_eq!(fold.range.start(), range.start());
            assert_eq!(fold.range.end(), range.end());
-            assert_eq!(&fold.kind, fold_kind);
+            let kind = match fold.kind {
+                FoldKind::Comment => "comment",
+                FoldKind::Imports => "imports",
+                FoldKind::Mods => "mods",
+                FoldKind::Block => "block",
+                FoldKind::ArgList => "arglist",
+            };
+            assert_eq!(kind, &attr.unwrap());
        }
    }
    #[test]
    fn test_fold_comments() {
-        let text = r#"
+        check(
-<fold>// Hello
+            r#"
+<fold comment>// Hello
 // this is a multiline
 // comment
 //</fold>
 // But this is not
-fn main() <fold>{
+fn main() <fold block>{
-    <fold>// We should
+    <fold comment>// We should
    // also
    // fold
    // this one.</fold>
-    <fold>//! But this one is different
+    <fold comment>//! But this one is different
    //! because it has another flavor</fold>
-    <fold>/* As does this
+    <fold comment>/* As does this
    multiline comment */</fold>
-}</fold>"#;
+}</fold>"#,
+        );
-        let fold_kinds = &[
-            FoldKind::Comment,
-            FoldKind::Block,
-            FoldKind::Comment,
-            FoldKind::Comment,
-            FoldKind::Comment,
-        ];
-        do_check(text, fold_kinds);
    }
    #[test]
    fn test_fold_imports() {
-        let text = r#"
+        check(
-<fold>use std::<fold>{
+            r#"
+<fold imports>use std::<fold block>{
    str,
    vec,
    io as iop
 }</fold>;</fold>
-fn main() <fold>{
+fn main() <fold block>{
-}</fold>"#;
+}</fold>"#,
+        );
-        let folds = &[FoldKind::Imports, FoldKind::Block, FoldKind::Block];
-        do_check(text, folds);
    }
    #[test]
    fn test_fold_mods() {
-        let text = r#"
+        check(
+            r#"
 pub mod foo;
-<fold>mod after_pub;
+<fold mods>mod after_pub;
 mod after_pub_next;</fold>
-<fold>mod before_pub;
+<fold mods>mod before_pub;
 mod before_pub_next;</fold>
 pub mod bar;
@@ -286,90 +284,93 @@ mod not_folding_single;
 pub mod foobar;
 pub not_folding_single_next;
-<fold>#[cfg(test)]
+<fold mods>#[cfg(test)]
 mod with_attribute;
 mod with_attribute_next;</fold>
-fn main() <fold>{
+fn main() <fold block>{
-}</fold>"#;
+}</fold>"#,
+        );
-        let folds = &[FoldKind::Mods, FoldKind::Mods, FoldKind::Mods, FoldKind::Block];
-        do_check(text, folds);
    }
    #[test]
    fn test_fold_import_groups() {
-        let text = r#"
+        check(
-<fold>use std::str;
+            r#"
+<fold imports>use std::str;
 use std::vec;
 use std::io as iop;</fold>
-<fold>use std::mem;
+<fold imports>use std::mem;
 use std::f64;</fold>
 use std::collections::HashMap;
 // Some random comment
 use std::collections::VecDeque;
-fn main() <fold>{
+fn main() <fold block>{
-}</fold>"#;
+}</fold>"#,
+        );
-        let folds = &[FoldKind::Imports, FoldKind::Imports, FoldKind::Block];
-        do_check(text, folds);
    }
    #[test]
    fn test_fold_import_and_groups() {
-        let text = r#"
+        check(
-<fold>use std::str;
+            r#"
+<fold imports>use std::str;
 use std::vec;
 use std::io as iop;</fold>
-<fold>use std::mem;
+<fold imports>use std::mem;
 use std::f64;</fold>
-<fold>use std::collections::<fold>{
+<fold imports>use std::collections::<fold block>{
    HashMap,
    VecDeque,
 }</fold>;</fold>
 // Some random comment
-fn main() <fold>{
+fn main() <fold block>{
-}</fold>"#;
+}</fold>"#,
+        );
-        let folds = &[
-            FoldKind::Imports,
-            FoldKind::Imports,
-            FoldKind::Imports,
-            FoldKind::Block,
-            FoldKind::Block,
-        ];
-        do_check(text, folds);
    }
    #[test]
    fn test_folds_macros() {
-        let text = r#"
+        check(
-macro_rules! foo <fold>{
+            r#"
+macro_rules! foo <fold block>{
    ($($tt:tt)*) => { $($tt)* }
 }</fold>
-"#;
+"#,
+        );
-        let folds = &[FoldKind::Block];
-        do_check(text, folds);
    }
    #[test]
    fn test_fold_match_arms() {
-        let text = r#"
+        check(
-fn main() <fold>{
+            r#"
-    match 0 <fold>{
+fn main() <fold block>{
+    match 0 <fold block>{
        0 => 0,
        _ => 1,
    }</fold>
-}</fold>"#;
+}</fold>"#,
+        );
+    }
-        let folds = &[FoldKind::Block, FoldKind::Block];
+    #[test]
-        do_check(text, folds);
+    fn fold_big_calls() {
+        check(
+            r#"
+fn main() <fold block>{
+    frobnicate<fold arglist>(
+        1,
+        2,
+        3,
+    )</fold>
+}</fold>
+        "#,
+        )
    }
 }
diff --git a/crates/ra_ide/src/goto_definition.rs b/crates/ra_ide/src/goto_definition.rs
index bea7fbfa7..4c78fa214 100644
--- a/crates/ra_ide/src/goto_definition.rs
+++ b/crates/ra_ide/src/goto_definition.rs
@@ -103,205 +103,149 @@ pub(crate) fn reference_definition(
 #[cfg(test)]
 mod tests {
-    use test_utils::assert_eq_text;
+    use ra_db::FileRange;
+    use ra_syntax::{TextRange, TextSize};
-    use crate::mock_analysis::analysis_and_position;
+    use crate::mock_analysis::MockAnalysis;
-    fn check_goto(ra_fixture: &str, expected: &str, expected_range: &str) {
-        let (analysis, pos) = analysis_and_position(ra_fixture);
+    fn check(ra_fixture: &str) {
+        let (mock, position) = MockAnalysis::with_files_and_position(ra_fixture);
+        let (mut expected, data) = mock.annotation();
+        let analysis = mock.analysis();
+        match data.as_str() {
+            "" => (),
+            "file" => {
+                expected.range =
+                    TextRange::up_to(TextSize::of(&*analysis.file_text(expected.file_id).unwrap()))
+            }
+            data => panic!("bad data: {}", data),
+        }
-        let mut navs = analysis.goto_definition(pos).unwrap().unwrap().info;
+        let mut navs = analysis.goto_definition(position).unwrap().unwrap().info;
        if navs.len() == 0 {
            panic!("unresolved reference")
        }
        assert_eq!(navs.len(), 1);
        let nav = navs.pop().unwrap();
-        let file_text = analysis.file_text(nav.file_id()).unwrap();
+        assert_eq!(expected, FileRange { file_id: nav.file_id(), range: nav.range() });
-        let mut actual = file_text[nav.full_range()].to_string();
-        if let Some(focus) = nav.focus_range() {
-            actual += "|";
-            actual += &file_text[focus];
-        }
-        if !expected_range.contains("...") {
-            test_utils::assert_eq_text!(&actual, expected_range);
-        } else {
-            let mut parts = expected_range.split("...");
-            let prefix = parts.next().unwrap();
-            let suffix = parts.next().unwrap();
-            assert!(
-                actual.starts_with(prefix) && actual.ends_with(suffix),
-                "\nExpected: {}\n Actual: {}\n",
-                expected_range,
-                actual
-            );
-        }
-        nav.assert_match(expected);
    }
    #[test]
    fn goto_def_in_items() {
-        check_goto(
+        check(
-            "
+            r#"
-            //- /lib.rs
+struct Foo;
-            struct Foo;
+     //^^^
-            enum E { X(Foo<|>) }
+enum E { X(Foo<|>) }
-            ",
+"#,
-            "Foo STRUCT_DEF FileId(1) 0..11 7..10",
-            "struct Foo;|Foo",
        );
    }
    #[test]
    fn goto_def_at_start_of_item() {
-        check_goto(
+        check(
-            "
+            r#"
-            //- /lib.rs
+struct Foo;
-            struct Foo;
+     //^^^
-            enum E { X(<|>Foo) }
+enum E { X(<|>Foo) }
-            ",
+"#,
-            "Foo STRUCT_DEF FileId(1) 0..11 7..10",
-            "struct Foo;|Foo",
        );
    }
    #[test]
    fn goto_definition_resolves_correct_name() {
-        check_goto(
+        check(
-            "
+            r#"
-            //- /lib.rs
+//- /lib.rs
-            use a::Foo;
+use a::Foo;
-            mod a;
+mod a;
-            mod b;
+mod b;
-            enum E { X(Foo<|>) }
+enum E { X(Foo<|>) }
-            //- /a.rs
+//- /a.rs
-            struct Foo;
+struct Foo;
+     //^^^
-            //- /b.rs
+//- /b.rs
-            struct Foo;
+struct Foo;
-            ",
+"#,
-            "Foo STRUCT_DEF FileId(2) 0..11 7..10",
-            "struct Foo;|Foo",
        );
    }
    #[test]
    fn goto_def_for_module_declaration() {
-        check_goto(
+        check(
            r#"
 //- /lib.rs
 mod <|>foo;
 //- /foo.rs
 // empty
+//^ file
 "#,
-            "foo SOURCE_FILE FileId(2) 0..9",
-            "// empty\n",
        );
-        check_goto(
+        check(
            r#"
 //- /lib.rs
 mod <|>foo;
 //- /foo/mod.rs
 // empty
+//^ file
 "#,
-            "foo SOURCE_FILE FileId(2) 0..9",
-            "// empty\n",
        );
    }
    #[test]
    fn goto_def_for_macros() {
-        check_goto(
+        check(
-            "
+            r#"
-            //- /lib.rs
+macro_rules! foo { () => { () } }
-            macro_rules! foo { () => { () } }
+           //^^^
+fn bar() {
-            fn bar() {
+    <|>foo!();
-                <|>foo!();
+}
-            }
+"#,
-            ",
-            "foo MACRO_CALL FileId(1) 0..33 13..16",
-            "macro_rules! foo { () => { () } }|foo",
        );
    }
    #[test]
    fn goto_def_for_macros_from_other_crates() {
-        check_goto(
+        check(
-            "
-            //- /lib.rs
-            use foo::foo;
-            fn bar() {
-                <|>foo!();
-            }
-            //- /foo/lib.rs
-            #[macro_export]
-            macro_rules! foo { () => { () } }
-            ",
-            "foo MACRO_CALL FileId(2) 0..49 29..32",
-            "#[macro_export]\nmacro_rules! foo { () => { () } }|foo",
-        );
-    }
-    #[test]
-    fn goto_def_for_use_alias() {
-        check_goto(
            r#"
 //- /lib.rs
-use foo as bar<|>;
+use foo::foo;
+fn bar() {
+    <|>foo!();
+}
 //- /foo/lib.rs
 #[macro_export]
 macro_rules! foo { () => { () } }
+           //^^^
 "#,
-            "SOURCE_FILE FileId(2) 0..50",
-            "#[macro_export]\nmacro_rules! foo { () => { () } }\n",
-        );
-    }
-    #[test]
-    fn goto_def_for_use_alias_foo_macro() {
-        check_goto(
-            "
-            //- /lib.rs
-            use foo::foo as bar<|>;
-            //- /foo/lib.rs
-            #[macro_export]
-            macro_rules! foo { () => { () } }
-            ",
-            "foo MACRO_CALL FileId(2) 0..49 29..32",
-            "#[macro_export]\nmacro_rules! foo { () => { () } }|foo",
        );
    }
    #[test]
    fn goto_def_for_macros_in_use_tree() {
-        check_goto(
+        check(
-            "
+            r#"
-            //- /lib.rs
+//- /lib.rs
-            use foo::foo<|>;
+use foo::foo<|>;
-            //- /foo/lib.rs
+//- /foo/lib.rs
-            #[macro_export]
+#[macro_export]
-            macro_rules! foo { () => { () } }
+macro_rules! foo { () => { () } }
-            ",
+           //^^^
-            "foo MACRO_CALL FileId(2) 0..49 29..32",
+"#,
-            "#[macro_export]\nmacro_rules! foo { () => { () } }|foo",
        );
    }
    #[test]
    fn goto_def_for_macro_defined_fn_with_arg() {
-        check_goto(
+        check(
            r#"
 //- /lib.rs
 macro_rules! define_fn {
@@ -309,522 +253,478 @@ macro_rules! define_fn {
 }
 define_fn!(foo);
+         //^^^
 fn bar() {
   <|>foo();
 }
 "#,
-            "foo FN_DEF FileId(1) 65..81 76..79",
-            "define_fn!(foo);|foo",
        );
    }
    #[test]
    fn goto_def_for_macro_defined_fn_no_arg() {
-        check_goto(
+        check(
            r#"
 //- /lib.rs
 macro_rules! define_fn {
    () => (fn foo() {})
 }
-define_fn!();
+  define_fn!();
+//^^^^^^^^^^^^^
 fn bar() {
   <|>foo();
 }
 "#,
-            "foo FN_DEF FileId(1) 52..65 52..65",
-            "define_fn!();|define_fn!();",
        );
    }
    #[test]
    fn goto_definition_works_for_macro_inside_pattern() {
-        check_goto(
+        check(
-            "
+            r#"
-            //- /lib.rs
+//- /lib.rs
-            macro_rules! foo {() => {0}}
+macro_rules! foo {() => {0}}
+           //^^^
-            fn bar() {
-                match (0,1) {
+fn bar() {
-                    (<|>foo!(), _) => {}
+    match (0,1) {
-                }
+        (<|>foo!(), _) => {}
-            }
+    }
-            ",
+}
-            "foo MACRO_CALL FileId(1) 0..28 13..16",
+"#,
-            "macro_rules! foo {() => {0}}|foo",
        );
    }
    #[test]
    fn goto_definition_works_for_macro_inside_match_arm_lhs() {
-        check_goto(
+        check(
-            "
+            r#"
-            //- /lib.rs
+//- /lib.rs
-            macro_rules! foo {() => {0}}
+macro_rules! foo {() => {0}}
+           //^^^
-            fn bar() {
+fn bar() {
-                match 0 {
+    match 0 {
-                    <|>foo!() => {}
+        <|>foo!() => {}
-                }
+    }
-            }
+}
-            ",
+"#,
-            "foo MACRO_CALL FileId(1) 0..28 13..16",
+        );
-            "macro_rules! foo {() => {0}}|foo",
+    }
+    #[test]
+    fn goto_def_for_use_alias() {
+        check(
+            r#"
+//- /lib.rs
+use foo as bar<|>;
+//- /foo/lib.rs
+// empty
+//^ file
+"#,
+        );
+    }
+    #[test]
+    fn goto_def_for_use_alias_foo_macro() {
+        check(
+            r#"
+//- /lib.rs
+use foo::foo as bar<|>;
+//- /foo/lib.rs
+#[macro_export]
+macro_rules! foo { () => { () } }
+           //^^^
+"#,
        );
    }
    #[test]
    fn goto_def_for_methods() {
-        check_goto(
+        check(
-            "
+            r#"
-            //- /lib.rs
+//- /lib.rs
-            struct Foo;
+struct Foo;
-            impl Foo {
+impl Foo {
-                fn frobnicate(&self) { }
+    fn frobnicate(&self) { }
-            }
+     //^^^^^^^^^^
+}
-            fn bar(foo: &Foo) {
+fn bar(foo: &Foo) {
-                foo.frobnicate<|>();
+    foo.frobnicate<|>();
-            }
+}
-            ",
+"#,
-            "frobnicate FN_DEF FileId(1) 27..51 30..40",
-            "fn frobnicate(&self) { }|frobnicate",
        );
    }
    #[test]
    fn goto_def_for_fields() {
-        check_goto(
+        check(
-            r"
+            r#"
-            //- /lib.rs
+struct Foo {
-            struct Foo {
+    spam: u32,
-                spam: u32,
+} //^^^^
-            }
-            fn bar(foo: &Foo) {
+fn bar(foo: &Foo) {
-                foo.spam<|>;
+    foo.spam<|>;
-            }
+}
-            ",
+"#,
-            "spam RECORD_FIELD_DEF FileId(1) 17..26 17..21",
-            "spam: u32|spam",
        );
    }
    #[test]
    fn goto_def_for_record_fields() {
-        check_goto(
+        check(
-            r"
+            r#"
-            //- /lib.rs
+//- /lib.rs
-            struct Foo {
+struct Foo {
-                spam: u32,
+    spam: u32,
-            }
+} //^^^^
-            fn bar() -> Foo {
+fn bar() -> Foo {
-                Foo {
+    Foo {
-                    spam<|>: 0,
+        spam<|>: 0,
-                }
+    }
-            }
+}
-            ",
+"#,
-            "spam RECORD_FIELD_DEF FileId(1) 17..26 17..21",
-            "spam: u32|spam",
        );
    }
    #[test]
    fn goto_def_for_record_pat_fields() {
-        check_goto(
+        check(
-            r"
+            r#"
-            //- /lib.rs
+//- /lib.rs
-            struct Foo {
+struct Foo {
-                spam: u32,
+    spam: u32,
-            }
+} //^^^^
-            fn bar(foo: Foo) -> Foo {
+fn bar(foo: Foo) -> Foo {
-                let Foo { spam<|>: _, } = foo
+    let Foo { spam<|>: _, } = foo
-            }
+}
-            ",
+"#,
-            "spam RECORD_FIELD_DEF FileId(1) 17..26 17..21",
-            "spam: u32|spam",
        );
    }
    #[test]
    fn goto_def_for_record_fields_macros() {
-        check_goto(
+        check(
            r"
-            //- /lib.rs
+macro_rules! m { () => { 92 };}
-            macro_rules! m { () => { 92 };}
+struct Foo { spam: u32 }
-            struct Foo { spam: u32 }
+           //^^^^
-            fn bar() -> Foo {
+fn bar() -> Foo {
-                Foo { spam<|>: m!() }
+    Foo { spam<|>: m!() }
-            }
+}
-            ",
+",
-            "spam RECORD_FIELD_DEF FileId(1) 45..54 45..49",
-            "spam: u32|spam",
        );
    }
    #[test]
    fn goto_for_tuple_fields() {
-        check_goto(
+        check(
-            "
+            r#"
-            //- /lib.rs
+struct Foo(u32);
-            struct Foo(u32);
+         //^^^
-            fn bar() {
+fn bar() {
-                let foo = Foo(0);
+    let foo = Foo(0);
-                foo.<|>0;
+    foo.<|>0;
-            }
+}
-            ",
+"#,
-            "TUPLE_FIELD_DEF FileId(1) 11..14",
-            "u32",
        );
    }
    #[test]
    fn goto_def_for_ufcs_inherent_methods() {
-        check_goto(
+        check(
-            "
+            r#"
-            //- /lib.rs
+struct Foo;
-            struct Foo;
+impl Foo {
-            impl Foo {
+    fn frobnicate() { }
-                fn frobnicate() { }
+}    //^^^^^^^^^^
-            }
-            fn bar(foo: &Foo) {
+fn bar(foo: &Foo) {
-                Foo::frobnicate<|>();
+    Foo::frobnicate<|>();
-            }
+}
-            ",
+"#,
-            "frobnicate FN_DEF FileId(1) 27..46 30..40",
-            "fn frobnicate() { }|frobnicate",
        );
    }
    #[test]
    fn goto_def_for_ufcs_trait_methods_through_traits() {
-        check_goto(
+        check(
-            "
+            r#"
-            //- /lib.rs
+trait Foo {
-            trait Foo {
+    fn frobnicate();
-                fn frobnicate();
+}    //^^^^^^^^^^
-            }
-            fn bar() {
+fn bar() {
-                Foo::frobnicate<|>();
+    Foo::frobnicate<|>();
-            }
+}
-            ",
+"#,
-            "frobnicate FN_DEF FileId(1) 16..32 19..29",
-            "fn frobnicate();|frobnicate",
        );
    }
    #[test]
    fn goto_def_for_ufcs_trait_methods_through_self() {
-        check_goto(
+        check(
-            "
+            r#"
-            //- /lib.rs
+struct Foo;
-            struct Foo;
+trait Trait {
-            trait Trait {
+    fn frobnicate();
-                fn frobnicate();
+}    //^^^^^^^^^^
-            }
+impl Trait for Foo {}
-            impl Trait for Foo {}
-            fn bar() {
+fn bar() {
-                Foo::frobnicate<|>();
+    Foo::frobnicate<|>();
-            }
+}
-            ",
+"#,
-            "frobnicate FN_DEF FileId(1) 30..46 33..43",
-            "fn frobnicate();|frobnicate",
        );
    }
    #[test]
    fn goto_definition_on_self() {
-        check_goto(
+        check(
-            "
+            r#"
-            //- /lib.rs
+struct Foo;
-            struct Foo;
+impl Foo {
-            impl Foo {
+   //^^^
-                pub fn new() -> Self {
+    pub fn new() -> Self {
-                    Self<|> {}
+        Self<|> {}
-                }
+    }
-            }
+}
-            ",
+"#,
-            "impl IMPL_DEF FileId(1) 12..73",
+        );
-            "impl Foo {...}",
+        check(
-        );
+            r#"
+struct Foo;
-        check_goto(
+impl Foo {
-            "
+   //^^^
-            //- /lib.rs
+    pub fn new() -> Self<|> {
-            struct Foo;
+        Self {}
-            impl Foo {
+    }
-                pub fn new() -> Self<|> {
+}
-                    Self {}
+"#,
-                }
+        );
-            }
-            ",
+        check(
-            "impl IMPL_DEF FileId(1) 12..73",
+            r#"
-            "impl Foo {...}",
+enum Foo { A }
-        );
+impl Foo {
+   //^^^
-        check_goto(
+    pub fn new() -> Self<|> {
-            "
+        Foo::A
-            //- /lib.rs
+    }
-            enum Foo { A }
+}
-            impl Foo {
+"#,
-                pub fn new() -> Self<|> {
+        );
-                    Foo::A
-                }
+        check(
-            }
+            r#"
-            ",
+enum Foo { A }
-            "impl IMPL_DEF FileId(1) 15..75",
+impl Foo {
-            "impl Foo {...}",
+   //^^^
-        );
+    pub fn thing(a: &Self<|>) {
+    }
-        check_goto(
+}
-            "
+"#,
-            //- /lib.rs
-            enum Foo { A }
-            impl Foo {
-                pub fn thing(a: &Self<|>) {
-                }
-            }
-            ",
-            "impl IMPL_DEF FileId(1) 15..62",
-            "impl Foo {...}",
        );
    }
    #[test]
    fn goto_definition_on_self_in_trait_impl() {
-        check_goto(
+        check(
-            "
+            r#"
-            //- /lib.rs
+struct Foo;
-            struct Foo;
+trait Make {
-            trait Make {
+    fn new() -> Self;
-                fn new() -> Self;
+}
-            }
+impl Make for Foo {
-            impl Make for Foo {
+            //^^^
-                fn new() -> Self {
+    fn new() -> Self {
-                    Self<|> {}
+        Self<|> {}
-                }
+    }
-            }
+}
-            ",
+"#,
-            "impl IMPL_DEF FileId(1) 49..115",
-            "impl Make for Foo {...}",
        );
-        check_goto(
+        check(
-            "
+            r#"
-            //- /lib.rs
+struct Foo;
-            struct Foo;
+trait Make {
-            trait Make {
+    fn new() -> Self;
-                fn new() -> Self;
+}
-            }
+impl Make for Foo {
-            impl Make for Foo {
+            //^^^
-                fn new() -> Self<|> {
+    fn new() -> Self<|> {
-                    Self {}
+        Self {}
-                }
+    }
-            }
+}
-            ",
+"#,
-            "impl IMPL_DEF FileId(1) 49..115",
-            "impl Make for Foo {...}",
        );
    }
    #[test]
    fn goto_def_when_used_on_definition_name_itself() {
-        check_goto(
+        check(
-            "
+            r#"
-            //- /lib.rs
+struct Foo<|> { value: u32 }
-            struct Foo<|> { value: u32 }
+     //^^^
-            ",
+            "#,
-            "Foo STRUCT_DEF FileId(1) 0..25 7..10",
-            "struct Foo { value: u32 }|Foo",
        );
-        check_goto(
+        check(
            r#"
-            //- /lib.rs
+struct Foo {
-            struct Foo {
+    field<|>: string,
-                field<|>: string,
+} //^^^^^
-            }
+"#,
-            "#,
-            "field RECORD_FIELD_DEF FileId(1) 17..30 17..22",
-            "field: string|field",
        );
-        check_goto(
+        check(
-            "
+            r#"
-            //- /lib.rs
+fn foo_test<|>() { }
-            fn foo_test<|>() { }
+ //^^^^^^^^
-            ",
+"#,
-            "foo_test FN_DEF FileId(1) 0..17 3..11",
-            "fn foo_test() { }|foo_test",
        );
-        check_goto(
+        check(
-            "
+            r#"
-            //- /lib.rs
+enum Foo<|> { Variant }
-            enum Foo<|> {
+   //^^^
-                Variant,
+"#,
-            }
-            ",
-            "Foo ENUM_DEF FileId(1) 0..25 5..8",
-            "enum Foo {...}|Foo",
-        );
-        check_goto(
-            "
-            //- /lib.rs
-            enum Foo {
-                Variant1,
-                Variant2<|>,
-                Variant3,
-            }
-            ",
-            "Variant2 ENUM_VARIANT FileId(1) 29..37 29..37",
-            "Variant2|Variant2",
        );
-        check_goto(
+        check(
            r#"
-            //- /lib.rs
+enum Foo {
-            static INNER<|>: &str = "";
+    Variant1,
-            "#,
+    Variant2<|>,
-            "INNER STATIC_DEF FileId(1) 0..24 7..12",
+  //^^^^^^^^
-            "static INNER: &str = \"\";|INNER",
+    Variant3,
+}
+"#,
        );
-        check_goto(
+        check(
            r#"
-            //- /lib.rs
+static INNER<|>: &str = "";
-            const INNER<|>: &str = "";
+     //^^^^^
-            "#,
+"#,
-            "INNER CONST_DEF FileId(1) 0..23 6..11",
-            "const INNER: &str = \"\";|INNER",
        );
-        check_goto(
+        check(
            r#"
-            //- /lib.rs
+const INNER<|>: &str = "";
-            type Thing<|> = Option<()>;
+    //^^^^^
-            "#,
+"#,
-            "Thing TYPE_ALIAS_DEF FileId(1) 0..24 5..10",
-            "type Thing = Option<()>;|Thing",
        );
-        check_goto(
+        check(
            r#"
-            //- /lib.rs
+type Thing<|> = Option<()>;
-            trait Foo<|> { }
+   //^^^^^
-            "#,
+"#,
-            "Foo TRAIT_DEF FileId(1) 0..13 6..9",
-            "trait Foo { }|Foo",
        );
-        check_goto(
+        check(
            r#"
-            //- /lib.rs
+trait Foo<|> { }
-            mod bar<|> { }
+    //^^^
-            "#,
+"#,
-            "bar MODULE FileId(1) 0..11 4..7",
+        );
-            "mod bar { }|bar",
+        check(
+            r#"
+mod bar<|> { }
+  //^^^
+"#,
        );
    }
    #[test]
    fn goto_from_macro() {
-        check_goto(
+        check(
-            "
+            r#"
-            //- /lib.rs
+macro_rules! id {
-            macro_rules! id {
+    ($($tt:tt)*) => { $($tt)* }
-                ($($tt:tt)*) => { $($tt)* }
+}
-            }
+fn foo() {}
-            fn foo() {}
+ //^^^
-            id! {
+id! {
-                fn bar() {
+    fn bar() {
-                    fo<|>o();
+        fo<|>o();
-                }
+    }
-            }
+}
-            mod confuse_index { fn foo(); }
+mod confuse_index { fn foo(); }
-            ",
+"#,
-            "foo FN_DEF FileId(1) 52..63 55..58",
-            "fn foo() {}|foo",
        );
    }
    #[test]
    fn goto_through_format() {
-        check_goto(
+        check(
-            "
+            r#"
-            //- /lib.rs
+#[macro_export]
-            #[macro_export]
+macro_rules! format {
-            macro_rules! format {
+    ($($arg:tt)*) => ($crate::fmt::format($crate::__export::format_args!($($arg)*)))
-                ($($arg:tt)*) => ($crate::fmt::format($crate::__export::format_args!($($arg)*)))
+}
-            }
+#[rustc_builtin_macro]
-            #[rustc_builtin_macro]
+#[macro_export]
-            #[macro_export]
+macro_rules! format_args {
-            macro_rules! format_args {
+    ($fmt:expr) => ({ /* compiler built-in */ });
-                ($fmt:expr) => ({ /* compiler built-in */ });
+    ($fmt:expr, $($args:tt)*) => ({ /* compiler built-in */ })
-                ($fmt:expr, $($args:tt)*) => ({ /* compiler built-in */ })
+}
-            }
+pub mod __export {
-            pub mod __export {
+    pub use crate::format_args;
-                pub use crate::format_args;
+    fn foo() {} // for index confusion
-                fn foo() {} // for index confusion
+}
-            }
+fn foo() -> i8 {}
-            fn foo() -> i8 {}
+ //^^^
-            fn test() {
+fn test() {
-                format!(\"{}\", fo<|>o())
+    format!("{}", fo<|>o())
-            }
+}
-            ",
+"#,
-            "foo FN_DEF FileId(1) 398..415 401..404",
-            "fn foo() -> i8 {}|foo",
        );
    }
    #[test]
    fn goto_for_type_param() {
-        check_goto(
+        check(
            r#"
-            //- /lib.rs
+struct Foo<T: Clone> { t: <|>T }
-            struct Foo<T: Clone> {
+         //^
-                t: <|>T,
+"#,
-            }
-            "#,
-            "T TYPE_PARAM FileId(1) 11..19 11..12",
-            "T: Clone|T",
        );
    }
    #[test]
    fn goto_within_macro() {
-        check_goto(
+        check(
            r#"
-//- /lib.rs
 macro_rules! id {
    ($($tt:tt)*) => ($($tt)*)
 }
 fn foo() {
    let x = 1;
+      //^
    id!({
        let y = <|>x;
        let z = y;
    });
 }
 "#,
-            "x BIND_PAT FileId(1) 70..71",
-            "x",
        );
-        check_goto(
+        check(
            r#"
-//- /lib.rs
 macro_rules! id {
    ($($tt:tt)*) => ($($tt)*)
 }
@@ -833,159 +733,125 @@ fn foo() {
    let x = 1;
    id!({
        let y = x;
+          //^
        let z = <|>y;
    });
 }
 "#,
-            "y BIND_PAT FileId(1) 99..100",
-            "y",
        );
    }
    #[test]
    fn goto_def_in_local_fn() {
-        check_goto(
+        check(
-            "
+            r#"
-            //- /lib.rs
+fn main() {
-            fn main() {
+    fn foo() {
-                fn foo() {
+        let x = 92;
-                    let x = 92;
+          //^
-                    <|>x;
+        <|>x;
-                }
+    }
-            }
+}
-            ",
+"#,
-            "x BIND_PAT FileId(1) 39..40",
-            "x",
        );
    }
    #[test]
    fn goto_def_in_local_macro() {
-        check_goto(
+        check(
-            r"
+            r#"
-            //- /lib.rs
+fn bar() {
-            fn bar() {
+    macro_rules! foo { () => { () } }
-                macro_rules! foo { () => { () } }
+               //^^^
-                <|>foo!();
+    <|>foo!();
-            }
+}
-            ",
+"#,
-            "foo MACRO_CALL FileId(1) 15..48 28..31",
-            "macro_rules! foo { () => { () } }|foo",
        );
    }
    #[test]
    fn goto_def_for_field_init_shorthand() {
-        check_goto(
+        check(
-            "
+            r#"
-            //- /lib.rs
+struct Foo { x: i32 }
-            struct Foo { x: i32 }
+fn main() {
-            fn main() {
+    let x = 92;
-                let x = 92;
+      //^
-                Foo { x<|> };
+    Foo { x<|> };
-            }
+}
-            ",
+"#,
-            "x BIND_PAT FileId(1) 42..43",
-            "x",
        )
    }
    #[test]
    fn goto_def_for_enum_variant_field() {
-        check_goto(
+        check(
-            "
+            r#"
-            //- /lib.rs
+enum Foo {
-            enum Foo {
+    Bar { x: i32 }
-                Bar { x: i32 }
+}       //^
-            }
+fn baz(foo: Foo) {
-            fn baz(foo: Foo) {
+    match foo {
-                match foo {
+        Foo::Bar { x<|> } => x
-                    Foo::Bar { x<|> } => x
+    };
-                };
+}
-            }
+"#,
-            ",
-            "x RECORD_FIELD_DEF FileId(1) 21..27 21..22",
-            "x: i32|x",
        );
    }
    #[test]
    fn goto_def_for_enum_variant_self_pattern_const() {
-        check_goto(
+        check(
-            "
+            r#"
-            //- /lib.rs
+enum Foo { Bar }
-            enum Foo {
+         //^^^
-                Bar,
+impl Foo {
-            }
+    fn baz(self) {
-            impl Foo {
+        match self { Self::Bar<|> => {} }
-                fn baz(self) {
+    }
-                    match self {
+}
-                        Self::Bar<|> => {}
+"#,
-                    }
-                }
-            }
-            ",
-            "Bar ENUM_VARIANT FileId(1) 15..18 15..18",
-            "Bar|Bar",
        );
    }
    #[test]
    fn goto_def_for_enum_variant_self_pattern_record() {
-        check_goto(
+        check(
-            "
+            r#"
-            //- /lib.rs
+enum Foo { Bar { val: i32 } }
-            enum Foo {
+         //^^^
-                Bar { val: i32 },
+impl Foo {
-            }
+    fn baz(self) -> i32 {
-            impl Foo {
+        match self { Self::Bar<|> { val } => {} }
-                fn baz(self) -> i32 {
+    }
-                    match self {
+}
-                        Self::Bar<|> { val } => {}
+"#,
-                    }
-                }
-            }
-            ",
-            "Bar ENUM_VARIANT FileId(1) 15..31 15..18",
-            "Bar { val: i32 }|Bar",
        );
    }
    #[test]
    fn goto_def_for_enum_variant_self_expr_const() {
-        check_goto(
+        check(
-            "
+            r#"
-            //- /lib.rs
+enum Foo { Bar }
-            enum Foo {
+         //^^^
-                Bar,
+impl Foo {
-            }
+    fn baz(self) { Self::Bar<|>; }
-            impl Foo {
+}
-                fn baz(self) {
+"#,
-                    Self::Bar<|>;
-                }
-            }
-            ",
-            "Bar ENUM_VARIANT FileId(1) 15..18 15..18",
-            "Bar|Bar",
        );
    }
    #[test]
    fn goto_def_for_enum_variant_self_expr_record() {
-        check_goto(
+        check(
-            "
+            r#"
-            //- /lib.rs
+enum Foo { Bar { val: i32 } }
-            enum Foo {
+         //^^^
-                Bar { val: i32 },
+impl Foo {
-            }
+    fn baz(self) { Self::Bar<|> {val: 4}; }
-            impl Foo {
+}
-                fn baz(self) {
+"#,
-                    Self::Bar<|> {val: 4};
-                }
-            }
-            ",
-            "Bar ENUM_VARIANT FileId(1) 15..31 15..18",
-            "Bar { val: i32 }|Bar",
        );
    }
 }
diff --git a/crates/ra_ide/src/goto_implementation.rs b/crates/ra_ide/src/goto_implementation.rs
index 0cec0657e..9acc960fc 100644
--- a/crates/ra_ide/src/goto_implementation.rs
+++ b/crates/ra_ide/src/goto_implementation.rs
@@ -74,135 +74,156 @@ fn impls_for_trait(
 #[cfg(test)]
 mod tests {
-    use crate::mock_analysis::analysis_and_position;
+    use ra_db::FileRange;
-    fn check_goto(fixture: &str, expected: &[&str]) {
+    use crate::mock_analysis::MockAnalysis;
-        let (analysis, pos) = analysis_and_position(fixture);
-        let mut navs = analysis.goto_implementation(pos).unwrap().unwrap().info;
+    fn check(ra_fixture: &str) {
-        assert_eq!(navs.len(), expected.len());
+        let (mock, position) = MockAnalysis::with_files_and_position(ra_fixture);
-        navs.sort_by_key(|nav| (nav.file_id(), nav.full_range().start()));
+        let annotations = mock.annotations();
-        navs.into_iter().enumerate().for_each(|(i, nav)| nav.assert_match(expected[i]));
+        let analysis = mock.analysis();
+        let navs = analysis.goto_implementation(position).unwrap().unwrap().info;
+        let key = |frange: &FileRange| (frange.file_id, frange.range.start());
+        let mut expected = annotations
+            .into_iter()
+            .map(|(range, data)| {
+                assert!(data.is_empty());
+                range
+            })
+            .collect::<Vec<_>>();
+        expected.sort_by_key(key);
+        let mut actual = navs
+            .into_iter()
+            .map(|nav| FileRange { file_id: nav.file_id(), range: nav.range() })
+            .collect::<Vec<_>>();
+        actual.sort_by_key(key);
+        assert_eq!(expected, actual);
    }
    #[test]
    fn goto_implementation_works() {
-        check_goto(
+        check(
-            "
+            r#"
-            //- /lib.rs
+struct Foo<|>;
-            struct Foo<|>;
+impl Foo {}
-            impl Foo {}
+   //^^^
-            ",
+"#,
-            &["impl IMPL_DEF FileId(1) 12..23"],
        );
    }
    #[test]
    fn goto_implementation_works_multiple_blocks() {
-        check_goto(
+        check(
-            "
+            r#"
-            //- /lib.rs
+struct Foo<|>;
-            struct Foo<|>;
+impl Foo {}
-            impl Foo {}
+   //^^^
-            impl Foo {}
+impl Foo {}
-            ",
+   //^^^
-            &["impl IMPL_DEF FileId(1) 12..23", "impl IMPL_DEF FileId(1) 24..35"],
+"#,
        );
    }
    #[test]
    fn goto_implementation_works_multiple_mods() {
-        check_goto(
+        check(
-            "
+            r#"
-            //- /lib.rs
+struct Foo<|>;
-            struct Foo<|>;
+mod a {
-            mod a {
+    impl super::Foo {}
-                impl super::Foo {}
+       //^^^^^^^^^^
-            }
+}
-            mod b {
+mod b {
-                impl super::Foo {}
+    impl super::Foo {}
-            }
+       //^^^^^^^^^^
-            ",
+}
-            &["impl IMPL_DEF FileId(1) 24..42", "impl IMPL_DEF FileId(1) 57..75"],
+"#,
        );
    }
    #[test]
    fn goto_implementation_works_multiple_files() {
-        check_goto(
+        check(
-            "
+            r#"
-            //- /lib.rs
+//- /lib.rs
-            struct Foo<|>;
+struct Foo<|>;
-            mod a;
+mod a;
-            mod b;
+mod b;
-            //- /a.rs
+//- /a.rs
-            impl crate::Foo {}
+impl crate::Foo {}
-            //- /b.rs
+   //^^^^^^^^^^
-            impl crate::Foo {}
+//- /b.rs
-            ",
+impl crate::Foo {}
-            &["impl IMPL_DEF FileId(2) 0..18", "impl IMPL_DEF FileId(3) 0..18"],
+   //^^^^^^^^^^
+"#,
        );
    }
    #[test]
    fn goto_implementation_for_trait() {
-        check_goto(
+        check(
-            "
+            r#"
-            //- /lib.rs
+trait T<|> {}
-            trait T<|> {}
+struct Foo;
-            struct Foo;
+impl T for Foo {}
-            impl T for Foo {}
+         //^^^
-            ",
+"#,
-            &["impl IMPL_DEF FileId(1) 23..40"],
        );
    }
    #[test]
    fn goto_implementation_for_trait_multiple_files() {
-        check_goto(
+        check(
-            "
+            r#"
-            //- /lib.rs
+//- /lib.rs
-            trait T<|> {};
+trait T<|> {};
-            struct Foo;
+struct Foo;
-            mod a;
+mod a;
-            mod b;
+mod b;
-            //- /a.rs
+//- /a.rs
-            impl crate::T for crate::Foo {}
+impl crate::T for crate::Foo {}
-            //- /b.rs
+                //^^^^^^^^^^
-            impl crate::T for crate::Foo {}
+//- /b.rs
-            ",
+impl crate::T for crate::Foo {}
-            &["impl IMPL_DEF FileId(2) 0..31", "impl IMPL_DEF FileId(3) 0..31"],
+                //^^^^^^^^^^
+            "#,
        );
    }
    #[test]
    fn goto_implementation_all_impls() {
-        check_goto(
+        check(
-            "
+            r#"
-            //- /lib.rs
+//- /lib.rs
-            trait T {}
+trait T {}
-            struct Foo<|>;
+struct Foo<|>;
-            impl Foo {}
+impl Foo {}
-            impl T for Foo {}
+   //^^^
-            impl T for &Foo {}
+impl T for Foo {}
-            ",
+         //^^^
-            &[
+impl T for &Foo {}
-                "impl IMPL_DEF FileId(1) 23..34",
+         //^^^^
-                "impl IMPL_DEF FileId(1) 35..52",
+"#,
-                "impl IMPL_DEF FileId(1) 53..71",
-            ],
        );
    }
    #[test]
    fn goto_implementation_to_builtin_derive() {
-        check_goto(
+        check(
-            "
+            r#"
-            //- /lib.rs
+  #[derive(Copy)]
-            #[derive(Copy)]
+//^^^^^^^^^^^^^^^
-            struct Foo<|>;
+struct Foo<|>;
-            ",
-            &["impl IMPL_DEF FileId(1) 0..15"],
+mod marker {
+    trait Copy {}
+}
+"#,
        );
    }
 }
diff --git a/crates/ra_ide/src/goto_type_definition.rs b/crates/ra_ide/src/goto_type_definition.rs
index 91a3097fb..7eb40d637 100644
--- a/crates/ra_ide/src/goto_type_definition.rs
+++ b/crates/ra_ide/src/goto_type_definition.rs
@@ -55,8 +55,8 @@ fn pick_best(tokens: TokenAtOffset<SyntaxToken>) -> Option<SyntaxToken> {
 mod tests {
    use crate::mock_analysis::analysis_and_position;
-    fn check_goto(fixture: &str, expected: &str) {
+    fn check_goto(ra_fixture: &str, expected: &str) {
-        let (analysis, pos) = analysis_and_position(fixture);
+        let (analysis, pos) = analysis_and_position(ra_fixture);
        let mut navs = analysis.goto_type_definition(pos).unwrap().unwrap().info;
        assert_eq!(navs.len(), 1);
@@ -67,7 +67,7 @@ mod tests {
    #[test]
    fn goto_type_definition_works_simple() {
        check_goto(
-            "
+            r"
            //- /lib.rs
            struct Foo;
            fn foo() {
@@ -82,7 +82,7 @@ mod tests {
    #[test]
    fn goto_type_definition_works_simple_ref() {
        check_goto(
-            "
+            r"
            //- /lib.rs
            struct Foo;
            fn foo() {
@@ -97,7 +97,7 @@ mod tests {
    #[test]
    fn goto_type_definition_works_through_macro() {
        check_goto(
-            "
+            r"
            //- /lib.rs
            macro_rules! id {
                ($($tt:tt)*) => { $($tt)* }
@@ -116,7 +116,7 @@ mod tests {
    #[test]
    fn goto_type_definition_for_param() {
        check_goto(
-            "
+            r"
            //- /lib.rs
            struct Foo;
            fn foo(<|>f: Foo) {}
@@ -128,7 +128,7 @@ mod tests {
    #[test]
    fn goto_type_definition_for_tuple_field() {
        check_goto(
-            "
+            r"
            //- /lib.rs
            struct Foo;
            struct Bar(Foo);
diff --git a/crates/ra_ide/src/hover.rs b/crates/ra_ide/src/hover.rs
index c3e36a387..eaba2b61e 100644
--- a/crates/ra_ide/src/hover.rs
+++ b/crates/ra_ide/src/hover.rs
@@ -417,8 +417,8 @@ mod tests {
        assert_eq!(offset, position.into());
    }
-    fn check_hover_result(fixture: &str, expected: &[&str]) -> (String, Vec<HoverAction>) {
+    fn check_hover_result(ra_fixture: &str, expected: &[&str]) -> (String, Vec<HoverAction>) {
-        let (analysis, position) = analysis_and_position(fixture);
+        let (analysis, position) = analysis_and_position(ra_fixture);
        let hover = analysis.hover(position).unwrap().unwrap();
        let mut results = Vec::from(hover.info.results());
        results.sort();
@@ -435,8 +435,8 @@ mod tests {
        (content[hover.range].to_string(), hover.info.actions().to_vec())
    }
-    fn check_hover_no_result(fixture: &str) {
+    fn check_hover_no_result(ra_fixture: &str) {
-        let (analysis, position) = analysis_and_position(fixture);
+        let (analysis, position) = analysis_and_position(ra_fixture);
        assert!(analysis.hover(position).unwrap().is_none());
    }
@@ -923,7 +923,7 @@ fn func(foo: i32) { if true { <|>foo; }; }
    #[test]
    fn test_hover_through_macro() {
        let (hover_on, _) = check_hover_result(
-            "
+            r"
            //- /lib.rs
            macro_rules! id {
                ($($tt:tt)*) => { $($tt)* }
@@ -944,7 +944,7 @@ fn func(foo: i32) { if true { <|>foo; }; }
    #[test]
    fn test_hover_through_expr_in_macro() {
        let (hover_on, _) = check_hover_result(
-            "
+            r"
            //- /lib.rs
            macro_rules! id {
                ($($tt:tt)*) => { $($tt)* }
@@ -962,7 +962,7 @@ fn func(foo: i32) { if true { <|>foo; }; }
    #[test]
    fn test_hover_through_expr_in_macro_recursive() {
        let (hover_on, _) = check_hover_result(
-            "
+            r"
            //- /lib.rs
            macro_rules! id_deep {
                ($($tt:tt)*) => { $($tt)* }
@@ -983,7 +983,7 @@ fn func(foo: i32) { if true { <|>foo; }; }
    #[test]
    fn test_hover_through_func_in_macro_recursive() {
        let (hover_on, _) = check_hover_result(
-            "
+            r"
            //- /lib.rs
            macro_rules! id_deep {
                ($($tt:tt)*) => { $($tt)* }
@@ -1026,7 +1026,7 @@ fn func(foo: i32) { if true { <|>foo; }; }
    #[test]
    fn test_hover_through_assert_macro() {
        let (hover_on, _) = check_hover_result(
-            r#"
+            r"
            //- /lib.rs
            #[rustc_builtin_macro]
            macro_rules! assert {}
@@ -1035,7 +1035,7 @@ fn func(foo: i32) { if true { <|>foo; }; }
            fn foo() {
                assert!(ba<|>r());
            }
-            "#,
+            ",
            &["fn bar() -> bool"],
        );
@@ -1077,14 +1077,14 @@ fn func(foo: i32) { if true { <|>foo; }; }
    #[test]
    fn test_hover_function_show_qualifiers() {
        check_hover_result(
-            "
+            r"
            //- /lib.rs
            async fn foo<|>() {}
            ",
            &["async fn foo()"],
        );
        check_hover_result(
-            "
+            r"
            //- /lib.rs
            pub const unsafe fn foo<|>() {}
            ",
@@ -1102,7 +1102,7 @@ fn func(foo: i32) { if true { <|>foo; }; }
    #[test]
    fn test_hover_trait_show_qualifiers() {
        let (_, actions) = check_hover_result(
-            "
+            r"
            //- /lib.rs
            unsafe trait foo<|>() {}
            ",
@@ -1114,7 +1114,7 @@ fn func(foo: i32) { if true { <|>foo; }; }
    #[test]
    fn test_hover_mod_with_same_name_as_function() {
        check_hover_result(
-            "
+            r"
            //- /lib.rs
            use self::m<|>y::Bar;
@@ -1237,7 +1237,7 @@ fn func(foo: i32) { if true { <|>foo; }; }
    #[test]
    fn test_hover_trait_has_impl_action() {
        let (_, actions) = check_hover_result(
-            "
+            r"
            //- /lib.rs
            trait foo<|>() {}
            ",
@@ -1249,7 +1249,7 @@ fn func(foo: i32) { if true { <|>foo; }; }
    #[test]
    fn test_hover_struct_has_impl_action() {
        let (_, actions) = check_hover_result(
-            "
+            r"
            //- /lib.rs
            struct foo<|>() {}
            ",
@@ -1261,7 +1261,7 @@ fn func(foo: i32) { if true { <|>foo; }; }
    #[test]
    fn test_hover_union_has_impl_action() {
        let (_, actions) = check_hover_result(
-            "
+            r"
            //- /lib.rs
            union foo<|>() {}
            ",
@@ -1273,7 +1273,7 @@ fn func(foo: i32) { if true { <|>foo; }; }
    #[test]
    fn test_hover_enum_has_impl_action() {
        let (_, actions) = check_hover_result(
-            "
+            r"
            //- /lib.rs
            enum foo<|>() {
                A,
@@ -1288,7 +1288,7 @@ fn func(foo: i32) { if true { <|>foo; }; }
    #[test]
    fn test_hover_test_has_action() {
        let (_, actions) = check_hover_result(
-            "
+            r"
            //- /lib.rs
            #[test]
            fn foo_<|>test() {}
@@ -1332,7 +1332,7 @@ fn func(foo: i32) { if true { <|>foo; }; }
    #[test]
    fn test_hover_test_mod_has_action() {
        let (_, actions) = check_hover_result(
-            "
+            r"
            //- /lib.rs
            mod tests<|> {
                #[test]
@@ -1373,7 +1373,7 @@ fn func(foo: i32) { if true { <|>foo; }; }
    #[test]
    fn test_hover_struct_has_goto_type_action() {
        let (_, actions) = check_hover_result(
-            "
+            r"
            //- /main.rs
            struct S{ f1: u32 }
@@ -1416,7 +1416,7 @@ fn func(foo: i32) { if true { <|>foo; }; }
    #[test]
    fn test_hover_generic_struct_has_goto_type_actions() {
        let (_, actions) = check_hover_result(
-            "
+            r"
            //- /main.rs
            struct Arg(u32);
            struct S<T>{ f1: T }
@@ -1479,7 +1479,7 @@ fn func(foo: i32) { if true { <|>foo; }; }
    #[test]
    fn test_hover_generic_struct_has_flattened_goto_type_actions() {
        let (_, actions) = check_hover_result(
-            "
+            r"
            //- /main.rs
            struct Arg(u32);
            struct S<T>{ f1: T }
@@ -1542,7 +1542,7 @@ fn func(foo: i32) { if true { <|>foo; }; }
    #[test]
    fn test_hover_tuple_has_goto_type_actions() {
        let (_, actions) = check_hover_result(
-            "
+            r"
            //- /main.rs
            struct A(u32);
            struct B(u32);
@@ -1627,7 +1627,7 @@ fn func(foo: i32) { if true { <|>foo; }; }
    #[test]
    fn test_hover_return_impl_trait_has_goto_type_action() {
        let (_, actions) = check_hover_result(
-            "
+            r"
            //- /main.rs
            trait Foo {}
@@ -1672,7 +1672,7 @@ fn func(foo: i32) { if true { <|>foo; }; }
    #[test]
    fn test_hover_generic_return_impl_trait_has_goto_type_action() {
        let (_, actions) = check_hover_result(
-            "
+            r"
            //- /main.rs
            trait Foo<T> {}
            struct S;
@@ -1737,7 +1737,7 @@ fn func(foo: i32) { if true { <|>foo; }; }
    #[test]
    fn test_hover_return_impl_traits_has_goto_type_action() {
        let (_, actions) = check_hover_result(
-            "
+            r"
            //- /main.rs
            trait Foo {}
            trait Bar {}
@@ -1802,7 +1802,7 @@ fn func(foo: i32) { if true { <|>foo; }; }
    #[test]
    fn test_hover_generic_return_impl_traits_has_goto_type_action() {
        let (_, actions) = check_hover_result(
-            "
+            r"
            //- /main.rs
            trait Foo<T> {}
            trait Bar<T> {}
@@ -1907,7 +1907,7 @@ fn func(foo: i32) { if true { <|>foo; }; }
    #[test]
    fn test_hover_arg_impl_trait_has_goto_type_action() {
        let (_, actions) = check_hover_result(
-            "
+            r"
            //- /lib.rs
            trait Foo {}
            fn foo(ar<|>g: &impl Foo) {}
@@ -1947,7 +1947,7 @@ fn func(foo: i32) { if true { <|>foo; }; }
    #[test]
    fn test_hover_arg_impl_traits_has_goto_type_action() {
        let (_, actions) = check_hover_result(
-            "
+            r"
            //- /lib.rs
            trait Foo {}
            trait Bar<T> {}
@@ -2028,7 +2028,7 @@ fn func(foo: i32) { if true { <|>foo; }; }
    #[test]
    fn test_hover_arg_generic_impl_trait_has_goto_type_action() {
        let (_, actions) = check_hover_result(
-            "
+            r"
            //- /lib.rs
            trait Foo<T> {}
            struct S {}
@@ -2088,7 +2088,7 @@ fn func(foo: i32) { if true { <|>foo; }; }
    #[test]
    fn test_hover_dyn_return_has_goto_type_action() {
        let (_, actions) = check_hover_result(
-            "
+            r"
            //- /main.rs
            trait Foo {}
            struct S;
@@ -2156,7 +2156,7 @@ fn func(foo: i32) { if true { <|>foo; }; }
    #[test]
    fn test_hover_dyn_arg_has_goto_type_action() {
        let (_, actions) = check_hover_result(
-            "
+            r"
            //- /lib.rs
            trait Foo {}
            fn foo(ar<|>g: &dyn Foo) {}
@@ -2196,7 +2196,7 @@ fn func(foo: i32) { if true { <|>foo; }; }
    #[test]
    fn test_hover_generic_dyn_arg_has_goto_type_action() {
        let (_, actions) = check_hover_result(
-            "
+            r"
            //- /lib.rs
            trait Foo<T> {}
            struct S {}
@@ -2256,7 +2256,7 @@ fn func(foo: i32) { if true { <|>foo; }; }
    #[test]
    fn test_hover_goto_type_action_links_order() {
        let (_, actions) = check_hover_result(
-            "
+            r"
            //- /lib.rs
            trait ImplTrait<T> {}
            trait DynTrait<T> {}
@@ -2357,7 +2357,7 @@ fn func(foo: i32) { if true { <|>foo; }; }
    #[test]
    fn test_hover_associated_type_has_goto_type_action() {
        let (_, actions) = check_hover_result(
-            "
+            r"
            //- /main.rs
            trait Foo {
                type Item;
diff --git a/crates/ra_ide/src/inlay_hints.rs b/crates/ra_ide/src/inlay_hints.rs
index c87652555..62d364bfa 100644
--- a/crates/ra_ide/src/inlay_hints.rs
+++ b/crates/ra_ide/src/inlay_hints.rs
@@ -3,7 +3,7 @@ use ra_ide_db::RootDatabase;
 use ra_prof::profile;
 use ra_syntax::{
    ast::{self, ArgListOwner, AstNode, TypeAscriptionOwner},
-    match_ast, Direction, NodeOrToken, SmolStr, SyntaxKind, TextRange,
+    match_ast, Direction, NodeOrToken, SmolStr, SyntaxKind, TextRange, T,
 };
 use crate::{FileId, FunctionSignature};
@@ -112,7 +112,7 @@ fn get_chaining_hints(
    // Ignoring extra whitespace and comments
    let next = tokens.next()?.kind();
    let next_next = tokens.next()?.kind();
-    if next == SyntaxKind::WHITESPACE && next_next == SyntaxKind::DOT {
+    if next == SyntaxKind::WHITESPACE && next_next == T![.] {
        let ty = sema.type_of_expr(&expr)?;
        if ty.is_unknown() {
            return None;
@@ -345,583 +345,251 @@ fn get_fn_signature(sema: &Semantics<RootDatabase>, expr: &ast::Expr) -> Option<
 #[cfg(test)]
 mod tests {
-    use crate::inlay_hints::InlayHintsConfig;
+    use expect::{expect, Expect};
-    use insta::assert_debug_snapshot;
+    use test_utils::extract_annotations;
-    use crate::mock_analysis::single_file;
+    use crate::{inlay_hints::InlayHintsConfig, mock_analysis::single_file};
+    fn check(ra_fixture: &str) {
+        check_with_config(ra_fixture, InlayHintsConfig::default());
+    }
+    fn check_with_config(ra_fixture: &str, config: InlayHintsConfig) {
+        let (analysis, file_id) = single_file(ra_fixture);
+        let expected = extract_annotations(&*analysis.file_text(file_id).unwrap());
+        let inlay_hints = analysis.inlay_hints(file_id, &config).unwrap();
+        let actual =
+            inlay_hints.into_iter().map(|it| (it.range, it.label.to_string())).collect::<Vec<_>>();
+        assert_eq!(expected, actual);
+    }
+    fn check_expect(ra_fixture: &str, config: InlayHintsConfig, expect: Expect) {
+        let (analysis, file_id) = single_file(ra_fixture);
+        let inlay_hints = analysis.inlay_hints(file_id, &config).unwrap();
+        expect.assert_debug_eq(&inlay_hints)
+    }
    #[test]
    fn param_hints_only() {
-        let (analysis, file_id) = single_file(
+        check_with_config(
            r#"
-            fn foo(a: i32, b: i32) -> i32 { a + b }
+fn foo(a: i32, b: i32) -> i32 { a + b }
-            fn main() {
+fn main() {
-                let _x = foo(4, 4);
+    let _x = foo(
-            }"#,
+        4,
-        );
+      //^ a
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig{ parameter_hints: true, type_hints: false, chaining_hints: false, max_length: None}).unwrap(), @r###"
+        4,
-        [
+      //^ b
-            InlayHint {
+    );
-                range: 69..70,
+}"#,
-                kind: ParameterHint,
+            InlayHintsConfig {
-                label: "a",
+                parameter_hints: true,
-            },
+                type_hints: false,
-            InlayHint {
+                chaining_hints: false,
-                range: 72..73,
+                max_length: None,
-                kind: ParameterHint,
-                label: "b",
            },
-        ]
+        );
-        "###);
    }
    #[test]
    fn hints_disabled() {
-        let (analysis, file_id) = single_file(
+        check_with_config(
            r#"
-            fn foo(a: i32, b: i32) -> i32 { a + b }
+fn foo(a: i32, b: i32) -> i32 { a + b }
-            fn main() {
+fn main() {
-                let _x = foo(4, 4);
+    let _x = foo(4, 4);
-            }"#,
+}"#,
+            InlayHintsConfig {
+                type_hints: false,
+                parameter_hints: false,
+                chaining_hints: false,
+                max_length: None,
+            },
        );
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig{ type_hints: false, parameter_hints: false, chaining_hints: false, max_length: None}).unwrap(), @r###"[]"###);
    }
    #[test]
    fn type_hints_only() {
-        let (analysis, file_id) = single_file(
+        check_with_config(
            r#"
-            fn foo(a: i32, b: i32) -> i32 { a + b }
+fn foo(a: i32, b: i32) -> i32 { a + b }
-            fn main() {
+fn main() {
-                let _x = foo(4, 4);
+    let _x = foo(4, 4);
-            }"#,
+      //^^ i32
-        );
+}"#,
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig{ type_hints: true, parameter_hints: false, chaining_hints: false, max_length: None}).unwrap(), @r###"
+            InlayHintsConfig {
-        [
+                type_hints: true,
-            InlayHint {
+                parameter_hints: false,
-                range: 60..62,
+                chaining_hints: false,
-                kind: TypeHint,
+                max_length: None,
-                label: "i32",
            },
-        ]
+        );
-        "###);
    }
    #[test]
    fn default_generic_types_should_not_be_displayed() {
-        let (analysis, file_id) = single_file(
+        check(
            r#"
-struct Test<K, T = u8> {
+struct Test<K, T = u8> { k: K, t: T }
-    k: K,
-    t: T,
-}
 fn main() {
    let zz = Test { t: 23u8, k: 33 };
+      //^^ Test<i32>
    let zz_ref = &zz;
+      //^^^^^^ &Test<i32>
 }"#,
        );
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig::default()).unwrap(), @r###"
-        [
-            InlayHint {
-                range: 68..70,
-                kind: TypeHint,
-                label: "Test<i32>",
-            },
-            InlayHint {
-                range: 106..112,
-                kind: TypeHint,
-                label: "&Test<i32>",
-            },
-        ]
-        "###
-        );
    }
    #[test]
    fn let_statement() {
-        let (analysis, file_id) = single_file(
+        check(
            r#"
 #[derive(PartialEq)]
-enum CustomOption<T> {
+enum Option<T> { None, Some(T) }
-    None,
-    Some(T),
-}
 #[derive(PartialEq)]
-struct Test {
+struct Test { a: Option<u32>, b: u8 }
-    a: CustomOption<u32>,
-    b: u8,
-}
 fn main() {
    struct InnerStruct {}
    let test = 54;
+      //^^^^ i32
    let test: i32 = 33;
    let mut test = 33;
+      //^^^^^^^^ i32
    let _ = 22;
    let test = "test";
+      //^^^^ &str
    let test = InnerStruct {};
-    let test = vec![222];
+    let test = unresolved();
-    let test: Vec<_> = (0..3).collect();
-    let test = (0..3).collect::<Vec<i128>>();
-    let test = (0..3).collect::<Vec<_>>();
-    let mut test = Vec::new();
-    test.push(333);
    let test = (42, 'a');
-    let (a, (b, c, (d, e), f)) = (2, (3, 4, (6.6, 7.7), 5));
+      //^^^^ (i32, char)
+    let (a,    (b,     (c,)) = (2, (3, (9.2,));
+       //^ i32  ^ i32   ^ f64
    let &x = &92;
+       //^ i32
 }"#,
        );
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig::default()).unwrap(), @r###"
-        [
-            InlayHint {
-                range: 192..196,
-                kind: TypeHint,
-                label: "i32",
-            },
-            InlayHint {
-                range: 235..243,
-                kind: TypeHint,
-                label: "i32",
-            },
-            InlayHint {
-                range: 274..278,
-                kind: TypeHint,
-                label: "&str",
-            },
-            InlayHint {
-                range: 538..542,
-                kind: TypeHint,
-                label: "(i32, char)",
-            },
-            InlayHint {
-                range: 565..566,
-                kind: TypeHint,
-                label: "i32",
-            },
-            InlayHint {
-                range: 569..570,
-                kind: TypeHint,
-                label: "i32",
-            },
-            InlayHint {
-                range: 572..573,
-                kind: TypeHint,
-                label: "i32",
-            },
-            InlayHint {
-                range: 576..577,
-                kind: TypeHint,
-                label: "f64",
-            },
-            InlayHint {
-                range: 579..580,
-                kind: TypeHint,
-                label: "f64",
-            },
-            InlayHint {
-                range: 583..584,
-                kind: TypeHint,
-                label: "i32",
-            },
-            InlayHint {
-                range: 626..627,
-                kind: TypeHint,
-                label: "i32",
-            },
-        ]
-        "###
-        );
    }
    #[test]
    fn closure_parameters() {
-        let (analysis, file_id) = single_file(
+        check(
            r#"
 fn main() {
    let mut start = 0;
-    (0..2).for_each(|increment| {
+      //^^^^^^^^^ i32
-        start += increment;
+    (0..2).for_each(|increment| { start += increment; });
-    });
+                   //^^^^^^^^^ i32
+    let multiply =
+      //^^^^^^^^ |…| -> i32
+      | a,     b| a * b
+      //^ i32  ^ i32
+    ;
-    let multiply = |a, b, c, d| a * b * c * d;
+    let _: i32 = multiply(1, 2);
-    let _: i32 = multiply(1, 2, 3, 4);
    let multiply_ref = &multiply;
+      //^^^^^^^^^^^^ &|…| -> i32
    let return_42 = || 42;
+      //^^^^^^^^^ || -> i32
 }"#,
        );
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig::default()).unwrap(), @r###"
-        [
-            InlayHint {
-                range: 20..29,
-                kind: TypeHint,
-                label: "i32",
-            },
-            InlayHint {
-                range: 56..65,
-                kind: TypeHint,
-                label: "i32",
-            },
-            InlayHint {
-                range: 114..122,
-                kind: TypeHint,
-                label: "|…| -> i32",
-            },
-            InlayHint {
-                range: 126..127,
-                kind: TypeHint,
-                label: "i32",
-            },
-            InlayHint {
-                range: 129..130,
-                kind: TypeHint,
-                label: "i32",
-            },
-            InlayHint {
-                range: 132..133,
-                kind: TypeHint,
-                label: "i32",
-            },
-            InlayHint {
-                range: 135..136,
-                kind: TypeHint,
-                label: "i32",
-            },
-            InlayHint {
-                range: 200..212,
-                kind: TypeHint,
-                label: "&|…| -> i32",
-            },
-            InlayHint {
-                range: 235..244,
-                kind: TypeHint,
-                label: "|| -> i32",
-            },
-        ]
-        "###
-        );
    }
    #[test]
    fn for_expression() {
-        let (analysis, file_id) = single_file(
+        check(
            r#"
 fn main() {
    let mut start = 0;
-    for increment in 0..2 {
+      //^^^^^^^^^ i32
-        start += increment;
+    for increment in 0..2 { start += increment; }
-    }
+      //^^^^^^^^^ i32
 }"#,
        );
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig::default()).unwrap(), @r###"
-        [
-            InlayHint {
-                range: 20..29,
-                kind: TypeHint,
-                label: "i32",
-            },
-            InlayHint {
-                range: 43..52,
-                kind: TypeHint,
-                label: "i32",
-            },
-        ]
-        "###
-        );
    }
    #[test]
    fn if_expr() {
-        let (analysis, file_id) = single_file(
+        check(
            r#"
-#[derive(PartialEq)]
+enum Option<T> { None, Some(T) }
-enum CustomOption<T> {
+use Option::*;
-    None,
-    Some(T),
-}
-#[derive(PartialEq)]
-struct Test {
-    a: CustomOption<u32>,
-    b: u8,
-}
-use CustomOption::*;
+struct Test { a: Option<u32>, b: u8 }
 fn main() {
    let test = Some(Test { a: Some(3), b: 1 });
+      //^^^^ Option<Test>
    if let None = &test {};
    if let test = &test {};
+         //^^^^ &Option<Test>
    if let Some(test) = &test {};
-    if let Some(Test { a, b }) = &test {};
+              //^^^^ &Test
-    if let Some(Test { a: x, b: y }) = &test {};
+    if let Some(Test { a,             b }) = &test {};
-    if let Some(Test { a: Some(x), b: y }) = &test {};
+                     //^ &Option<u32> ^ &u8
-    if let Some(Test { a: None, b: y }) = &test {};
+    if let Some(Test { a: x,             b: y }) = &test {};
+                        //^ &Option<u32>    ^ &u8
+    if let Some(Test { a: Some(x),  b: y }) = &test {};
+                             //^ &u32  ^ &u8
+    if let Some(Test { a: None,  b: y }) = &test {};
+                                  //^ &u8
    if let Some(Test { b: y, .. }) = &test {};
+                        //^ &u8
    if test == None {}
 }"#,
        );
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig::default()).unwrap(), @r###"
-        [
-            InlayHint {
-                range: 187..191,
-                kind: TypeHint,
-                label: "CustomOption<Test>",
-            },
-            InlayHint {
-                range: 266..270,
-                kind: TypeHint,
-                label: "&CustomOption<Test>",
-            },
-            InlayHint {
-                range: 299..303,
-                kind: TypeHint,
-                label: "&Test",
-            },
-            InlayHint {
-                range: 340..341,
-                kind: TypeHint,
-                label: "&CustomOption<u32>",
-            },
-            InlayHint {
-                range: 343..344,
-                kind: TypeHint,
-                label: "&u8",
-            },
-            InlayHint {
-                range: 386..387,
-                kind: TypeHint,
-                label: "&CustomOption<u32>",
-            },
-            InlayHint {
-                range: 392..393,
-                kind: TypeHint,
-                label: "&u8",
-            },
-            InlayHint {
-                range: 440..441,
-                kind: TypeHint,
-                label: "&u32",
-            },
-            InlayHint {
-                range: 447..448,
-                kind: TypeHint,
-                label: "&u8",
-            },
-            InlayHint {
-                range: 499..500,
-                kind: TypeHint,
-                label: "&u8",
-            },
-            InlayHint {
-                range: 542..543,
-                kind: TypeHint,
-                label: "&u8",
-            },
-        ]
-        "###
-        );
    }
    #[test]
    fn while_expr() {
-        let (analysis, file_id) = single_file(
+        check(
            r#"
-#[derive(PartialEq)]
+enum Option<T> { None, Some(T) }
-enum CustomOption<T> {
+use Option::*;
-    None,
-    Some(T),
-}
-#[derive(PartialEq)]
+struct Test { a: Option<u32>, b: u8 }
-struct Test {
-    a: CustomOption<u32>,
-    b: u8,
-}
-use CustomOption::*;
 fn main() {
    let test = Some(Test { a: Some(3), b: 1 });
-    while let None = &test {};
+      //^^^^ Option<Test>
-    while let test = &test {};
+    while let Some(Test { a: Some(x),  b: y }) = &test {};
-    while let Some(test) = &test {};
+                                //^ &u32  ^ &u8
-    while let Some(Test { a, b }) = &test {};
-    while let Some(Test { a: x, b: y }) = &test {};
-    while let Some(Test { a: Some(x), b: y }) = &test {};
-    while let Some(Test { a: None, b: y }) = &test {};
-    while let Some(Test { b: y, .. }) = &test {};
-    while test == None {}
 }"#,
        );
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig::default()).unwrap(), @r###"
-        [
-            InlayHint {
-                range: 187..191,
-                kind: TypeHint,
-                label: "CustomOption<Test>",
-            },
-            InlayHint {
-                range: 272..276,
-                kind: TypeHint,
-                label: "&CustomOption<Test>",
-            },
-            InlayHint {
-                range: 308..312,
-                kind: TypeHint,
-                label: "&Test",
-            },
-            InlayHint {
-                range: 352..353,
-                kind: TypeHint,
-                label: "&CustomOption<u32>",
-            },
-            InlayHint {
-                range: 355..356,
-                kind: TypeHint,
-                label: "&u8",
-            },
-            InlayHint {
-                range: 401..402,
-                kind: TypeHint,
-                label: "&CustomOption<u32>",
-            },
-            InlayHint {
-                range: 407..408,
-                kind: TypeHint,
-                label: "&u8",
-            },
-            InlayHint {
-                range: 458..459,
-                kind: TypeHint,
-                label: "&u32",
-            },
-            InlayHint {
-                range: 465..466,
-                kind: TypeHint,
-                label: "&u8",
-            },
-            InlayHint {
-                range: 520..521,
-                kind: TypeHint,
-                label: "&u8",
-            },
-            InlayHint {
-                range: 566..567,
-                kind: TypeHint,
-                label: "&u8",
-            },
-        ]
-        "###
-        );
    }
    #[test]
    fn match_arm_list() {
-        let (analysis, file_id) = single_file(
+        check(
            r#"
-#[derive(PartialEq)]
+enum Option<T> { None, Some(T) }
-enum CustomOption<T> {
+use Option::*;
-    None,
-    Some(T),
-}
-#[derive(PartialEq)]
-struct Test {
-    a: CustomOption<u32>,
-    b: u8,
-}
-use CustomOption::*;
+struct Test { a: Option<u32>, b: u8 }
 fn main() {
    match Some(Test { a: Some(3), b: 1 }) {
        None => (),
        test => (),
-        Some(test) => (),
+      //^^^^ Option<Test>
-        Some(Test { a, b }) => (),
-        Some(Test { a: x, b: y }) => (),
        Some(Test { a: Some(x), b: y }) => (),
-        Some(Test { a: None, b: y }) => (),
+                          //^ u32  ^ u8
-        Some(Test { b: y, .. }) => (),
        _ => {}
    }
 }"#,
        );
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig::default()).unwrap(), @r###"
-        [
-            InlayHint {
-                range: 251..255,
-                kind: TypeHint,
-                label: "CustomOption<Test>",
-            },
-            InlayHint {
-                range: 276..280,
-                kind: TypeHint,
-                label: "Test",
-            },
-            InlayHint {
-                range: 309..310,
-                kind: TypeHint,
-                label: "CustomOption<u32>",
-            },
-            InlayHint {
-                range: 312..313,
-                kind: TypeHint,
-                label: "u8",
-            },
-            InlayHint {
-                range: 347..348,
-                kind: TypeHint,
-                label: "CustomOption<u32>",
-            },
-            InlayHint {
-                range: 353..354,
-                kind: TypeHint,
-                label: "u8",
-            },
-            InlayHint {
-                range: 393..394,
-                kind: TypeHint,
-                label: "u32",
-            },
-            InlayHint {
-                range: 400..401,
-                kind: TypeHint,
-                label: "u8",
-            },
-            InlayHint {
-                range: 444..445,
-                kind: TypeHint,
-                label: "u8",
-            },
-            InlayHint {
-                range: 479..480,
-                kind: TypeHint,
-                label: "u8",
-            },
-        ]
-        "###
-        );
    }
    #[test]
    fn hint_truncation() {
-        let (analysis, file_id) = single_file(
+        check_with_config(
            r#"
 struct Smol<T>(T);
@@ -929,52 +597,26 @@ struct VeryLongOuterName<T>(T);
 fn main() {
    let a = Smol(0u32);
+      //^ Smol<u32>
    let b = VeryLongOuterName(0usize);
+      //^ VeryLongOuterName<…>
    let c = Smol(Smol(0u32))
+      //^ Smol<Smol<…>>
 }"#,
-        );
+            InlayHintsConfig { max_length: Some(8), ..Default::default() },
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig { max_length: Some(8), ..Default::default() }).unwrap(), @r###"
-        [
-            InlayHint {
-                range: 73..74,
-                kind: TypeHint,
-                label: "Smol<u32>",
-            },
-            InlayHint {
-                range: 97..98,
-                kind: TypeHint,
-                label: "VeryLongOuterName<…>",
-            },
-            InlayHint {
-                range: 136..137,
-                kind: TypeHint,
-                label: "Smol<Smol<…>>",
-            },
-        ]
-        "###
        );
    }
    #[test]
    fn function_call_parameter_hint() {
-        let (analysis, file_id) = single_file(
+        check(
            r#"
-enum CustomOption<T> {
+enum Option<T> { None, Some(T) }
-    None,
+use Option::*;
-    Some(T),
-}
-use CustomOption::*;
 struct FileId {}
 struct SmolStr {}
-impl From<&str> for SmolStr {
-    fn from(_: &str) -> Self {
-        unimplemented!()
-    }
-}
 struct TextRange {}
 struct SyntaxKind {}
 struct NavigationTarget {}
@@ -982,18 +624,15 @@ struct NavigationTarget {}
 struct Test {}
 impl Test {
-    fn method(&self, mut param: i32) -> i32 {
+    fn method(&self, mut param: i32) -> i32 { param * 2 }
-        param * 2
-    }
    fn from_syntax(
        file_id: FileId,
        name: SmolStr,
-        focus_range: CustomOption<TextRange>,
+        focus_range: Option<TextRange>,
        full_range: TextRange,
        kind: SyntaxKind,
-        docs: CustomOption<String>,
+        docs: Option<String>,
-        description: CustomOption<String>,
    ) -> NavigationTarget {
        NavigationTarget {}
    }
@@ -1005,108 +644,35 @@ fn test_func(mut foo: i32, bar: i32, msg: &str, _: i32, last: i32) -> i32 {
 fn main() {
    let not_literal = 1;
-    let _: i32 = test_func(1, 2, "hello", 3, not_literal);
+      //^^^^^^^^^^^ i32
+    let _: i32 = test_func(1,    2,      "hello", 3,  not_literal);
+                         //^ foo ^ bar   ^^^^^^^ msg  ^^^^^^^^^^^ last
    let t: Test = Test {};
    t.method(123);
-    Test::method(&t, 3456);
+           //^^^ param
+    Test::method(&t,      3456);
+               //^^ &self ^^^^ param
    Test::from_syntax(
        FileId {},
+      //^^^^^^^^^ file_id
        "impl".into(),
+      //^^^^^^^^^^^^^ name
        None,
+      //^^^^ focus_range
        TextRange {},
+      //^^^^^^^^^^^^ full_range
        SyntaxKind {},
+      //^^^^^^^^^^^^^ kind
        None,
-        None,
+      //^^^^ docs
    );
 }"#,
        );
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig::default()).unwrap(), @r###"
-        [
-            InlayHint {
-                range: 797..808,
-                kind: TypeHint,
-                label: "i32",
-            },
-            InlayHint {
-                range: 841..842,
-                kind: ParameterHint,
-                label: "foo",
-            },
-            InlayHint {
-                range: 844..845,
-                kind: ParameterHint,
-                label: "bar",
-            },
-            InlayHint {
-                range: 847..854,
-                kind: ParameterHint,
-                label: "msg",
-            },
-            InlayHint {
-                range: 859..870,
-                kind: ParameterHint,
-                label: "last",
-            },
-            InlayHint {
-                range: 913..916,
-                kind: ParameterHint,
-                label: "param",
-            },
-            InlayHint {
-                range: 936..938,
-                kind: ParameterHint,
-                label: "&self",
-            },
-            InlayHint {
-                range: 940..944,
-                kind: ParameterHint,
-                label: "param",
-            },
-            InlayHint {
-                range: 979..988,
-                kind: ParameterHint,
-                label: "file_id",
-            },
-            InlayHint {
-                range: 998..1011,
-                kind: ParameterHint,
-                label: "name",
-            },
-            InlayHint {
-                range: 1021..1025,
-                kind: ParameterHint,
-                label: "focus_range",
-            },
-            InlayHint {
-                range: 1035..1047,
-                kind: ParameterHint,
-                label: "full_range",
-            },
-            InlayHint {
-                range: 1057..1070,
-                kind: ParameterHint,
-                label: "kind",
-            },
-            InlayHint {
-                range: 1080..1084,
-                kind: ParameterHint,
-                label: "docs",
-            },
-            InlayHint {
-                range: 1094..1098,
-                kind: ParameterHint,
-                label: "description",
-            },
-        ]
-        "###
-        );
    }
    #[test]
    fn omitted_parameters_hints_heuristics() {
-        let (analysis, file_id) = single_file(
+        check_with_config(
            r#"
 fn map(f: i32) {}
 fn filter(predicate: i32) {}
@@ -1187,23 +753,16 @@ fn main() {
    let _: f64 = a.div_euclid(b);
    let _: f64 = a.abs_sub(b);
 }"#,
-        );
+            InlayHintsConfig { max_length: Some(8), ..Default::default() },
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig { max_length: Some(8), ..Default::default() }).unwrap(), @r###"
-        []
-        "###
        );
    }
    #[test]
    fn unit_structs_have_no_type_hints() {
-        let (analysis, file_id) = single_file(
+        check_with_config(
            r#"
-enum CustomResult<T, E> {
+enum Result<T, E> { Ok(T), Err(E) }
-    Ok(T),
+use Result::*;
-    Err(E),
-}
-use CustomResult::*;
 struct SyntheticSyntax;
@@ -1213,136 +772,157 @@ fn main() {
        Err(SyntheticSyntax) => (),
    }
 }"#,
-        );
+            InlayHintsConfig { max_length: Some(8), ..Default::default() },
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig { max_length: Some(8), ..Default::default() }).unwrap(), @r###"
-        []
-        "###
        );
    }
    #[test]
    fn chaining_hints_ignore_comments() {
-        let (analysis, file_id) = single_file(
+        check_expect(
            r#"
-            struct A(B);
+struct A(B);
-            impl A { fn into_b(self) -> B { self.0 } }
+impl A { fn into_b(self) -> B { self.0 } }
-            struct B(C);
+struct B(C);
-            impl B { fn into_c(self) -> C { self.0 } }
+impl B { fn into_c(self) -> C { self.0 } }
-            struct C;
+struct C;
-            fn main() {
+fn main() {
-                let c = A(B(C))
+    let c = A(B(C))
-                    .into_b() // This is a comment
+        .into_b() // This is a comment
-                    .into_c();
+        .into_c();
-            }"#,
+}
+"#,
+            InlayHintsConfig {
+                parameter_hints: false,
+                type_hints: false,
+                chaining_hints: true,
+                max_length: None,
+            },
+            expect![[r#"
+                [
+                    InlayHint {
+                        range: 147..172,
+                        kind: ChainingHint,
+                        label: "B",
+                    },
+                    InlayHint {
+                        range: 147..154,
+                        kind: ChainingHint,
+                        label: "A",
+                    },
+                ]
+            "#]],
        );
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig{ parameter_hints: false, type_hints: false, chaining_hints: true, max_length: None}).unwrap(), @r###"
-        [
-            InlayHint {
-                range: 147..172,
-                kind: ChainingHint,
-                label: "B",
-            },
-            InlayHint {
-                range: 147..154,
-                kind: ChainingHint,
-                label: "A",
-            },
-        ]
-        "###);
    }
    #[test]
    fn chaining_hints_without_newlines() {
-        let (analysis, file_id) = single_file(
+        check_with_config(
            r#"
-            struct A(B);
+struct A(B);
-            impl A { fn into_b(self) -> B { self.0 } }
+impl A { fn into_b(self) -> B { self.0 } }
-            struct B(C);
+struct B(C);
-            impl B { fn into_c(self) -> C { self.0 } }
+impl B { fn into_c(self) -> C { self.0 } }
-            struct C;
+struct C;
-            fn main() {
+fn main() {
-                let c = A(B(C)).into_b().into_c();
+    let c = A(B(C)).into_b().into_c();
-            }"#,
+}"#,
+            InlayHintsConfig {
+                parameter_hints: false,
+                type_hints: false,
+                chaining_hints: true,
+                max_length: None,
+            },
        );
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig{ parameter_hints: false, type_hints: false, chaining_hints: true, max_length: None}).unwrap(), @r###"[]"###);
    }
    #[test]
    fn struct_access_chaining_hints() {
-        let (analysis, file_id) = single_file(
+        check_expect(
            r#"
-            struct A { pub b: B }
+struct A { pub b: B }
-            struct B { pub c: C }
+struct B { pub c: C }
-            struct C(pub bool);
+struct C(pub bool);
-            struct D;
+struct D;
-            impl D {
+impl D {
-                fn foo(&self) -> i32 { 42 }
+    fn foo(&self) -> i32 { 42 }
-            }
+}
-            fn main() {
+fn main() {
-                let x = A { b: B { c: C(true) } }
+    let x = A { b: B { c: C(true) } }
-                    .b
+        .b
-                    .c
+        .c
-                    .0;
+        .0;
-                let x = D
+    let x = D
-                    .foo();
+        .foo();
-            }"#,
+}"#,
+            InlayHintsConfig {
+                parameter_hints: false,
+                type_hints: false,
+                chaining_hints: true,
+                max_length: None,
+            },
+            expect![[r#"
+                [
+                    InlayHint {
+                        range: 143..190,
+                        kind: ChainingHint,
+                        label: "C",
+                    },
+                    InlayHint {
+                        range: 143..179,
+                        kind: ChainingHint,
+                        label: "B",
+                    },
+                ]
+            "#]],
        );
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig{ parameter_hints: false, type_hints: false, chaining_hints: true, max_length: None}).unwrap(), @r###"
-        [
-            InlayHint {
-                range: 143..190,
-                kind: ChainingHint,
-                label: "C",
-            },
-            InlayHint {
-                range: 143..179,
-                kind: ChainingHint,
-                label: "B",
-            },
-        ]
-        "###);
    }
    #[test]
    fn generic_chaining_hints() {
-        let (analysis, file_id) = single_file(
+        check_expect(
            r#"
-            struct A<T>(T);
+struct A<T>(T);
-            struct B<T>(T);
+struct B<T>(T);
-            struct C<T>(T);
+struct C<T>(T);
-            struct X<T,R>(T, R);
+struct X<T,R>(T, R);
-            impl<T> A<T> {
+impl<T> A<T> {
-                fn new(t: T) -> Self { A(t) }
+    fn new(t: T) -> Self { A(t) }
-                fn into_b(self) -> B<T> { B(self.0) }
+    fn into_b(self) -> B<T> { B(self.0) }
-            }
+}
-            impl<T> B<T> {
+impl<T> B<T> {
-                fn into_c(self) -> C<T> { C(self.0) }
+    fn into_c(self) -> C<T> { C(self.0) }
-            }
+}
-            fn main() {
+fn main() {
-                let c = A::new(X(42, true))
+    let c = A::new(X(42, true))
-                    .into_b()
+        .into_b()
-                    .into_c();
+        .into_c();
-            }"#,
+}
+"#,
+            InlayHintsConfig {
+                parameter_hints: false,
+                type_hints: false,
+                chaining_hints: true,
+                max_length: None,
+            },
+            expect![[r#"
+                [
+                    InlayHint {
+                        range: 246..283,
+                        kind: ChainingHint,
+                        label: "B<X<i32, bool>>",
+                    },
+                    InlayHint {
+                        range: 246..265,
+                        kind: ChainingHint,
+                        label: "A<X<i32, bool>>",
+                    },
+                ]
+            "#]],
        );
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig{ parameter_hints: false, type_hints: false, chaining_hints: true, max_length: None}).unwrap(), @r###"
-        [
-            InlayHint {
-                range: 246..283,
-                kind: ChainingHint,
-                label: "B<X<i32, bool>>",
-            },
-            InlayHint {
-                range: 246..265,
-                kind: ChainingHint,
-                label: "A<X<i32, bool>>",
-            },
-        ]
-        "###);
    }
 }
diff --git a/crates/ra_ide/src/lib.rs b/crates/ra_ide/src/lib.rs
index ecac5134e..8660278f1 100644
--- a/crates/ra_ide/src/lib.rs
+++ b/crates/ra_ide/src/lib.rs
@@ -75,7 +75,7 @@ pub use crate::{
    },
 };
-pub use hir::Documentation;
+pub use hir::{Documentation, Semantics};
 pub use ra_assists::{Assist, AssistConfig, AssistId, ResolvedAssist};
 pub use ra_db::{
    Canceled, CrateGraph, CrateId, Edition, FileId, FilePosition, FileRange, SourceRoot,
@@ -385,7 +385,9 @@ impl Analysis {
        position: FilePosition,
        search_scope: Option<SearchScope>,
    ) -> Cancelable<Option<ReferenceSearchResult>> {
-        self.with_db(|db| references::find_all_refs(db, position, search_scope).map(|it| it.info))
+        self.with_db(|db| {
+            references::find_all_refs(&Semantics::new(db), position, search_scope).map(|it| it.info)
+        })
    }
    /// Returns a short text describing element at position.
diff --git a/crates/ra_ide/src/mock_analysis.rs b/crates/ra_ide/src/mock_analysis.rs
index 889b84c59..a393d3dba 100644
--- a/crates/ra_ide/src/mock_analysis.rs
+++ b/crates/ra_ide/src/mock_analysis.rs
@@ -3,7 +3,9 @@ use std::sync::Arc;
 use ra_cfg::CfgOptions;
 use ra_db::{CrateName, Env, FileSet, SourceRoot, VfsPath};
-use test_utils::{extract_range_or_offset, Fixture, RangeOrOffset, CURSOR_MARKER};
+use test_utils::{
+    extract_annotations, extract_range_or_offset, Fixture, RangeOrOffset, CURSOR_MARKER,
+};
 use crate::{
    Analysis, AnalysisChange, AnalysisHost, CrateGraph, Edition, FileId, FilePosition, FileRange,
@@ -77,6 +79,24 @@ impl MockAnalysis {
            .expect("no file in this mock");
        FileId(idx as u32 + 1)
    }
+    pub fn annotations(&self) -> Vec<(FileRange, String)> {
+        self.files
+            .iter()
+            .enumerate()
+            .flat_map(|(idx, fixture)| {
+                let file_id = FileId(idx as u32 + 1);
+                let annotations = extract_annotations(&fixture.text);
+                annotations
+                    .into_iter()
+                    .map(move |(range, data)| (FileRange { file_id, range }, data))
+            })
+            .collect()
+    }
+    pub fn annotation(&self) -> (FileRange, String) {
+        let mut all = self.annotations();
+        assert_eq!(all.len(), 1);
+        all.pop().unwrap()
+    }
    pub fn analysis_host(self) -> AnalysisHost {
        let mut host = AnalysisHost::default();
        let mut change = AnalysisChange::new();
@@ -110,7 +130,7 @@ impl MockAnalysis {
                let other_crate = crate_graph.add_crate_root(
                    file_id,
                    edition,
-                    Some(CrateName::new(crate_name).unwrap()),
+                    Some(crate_name.to_string()),
                    cfg,
                    env,
                    Default::default(),
diff --git a/crates/ra_ide/src/references.rs b/crates/ra_ide/src/references.rs
index 3433fdae3..c2b0d5efe 100644
--- a/crates/ra_ide/src/references.rs
+++ b/crates/ra_ide/src/references.rs
@@ -86,12 +86,11 @@ impl IntoIterator for ReferenceSearchResult {
 }
 pub(crate) fn find_all_refs(
-    db: &RootDatabase,
+    sema: &Semantics<RootDatabase>,
    position: FilePosition,
    search_scope: Option<SearchScope>,
 ) -> Option<RangeInfo<ReferenceSearchResult>> {
    let _p = profile("find_all_refs");
-    let sema = Semantics::new(db);
    let syntax = sema.parse(position.file_id).syntax().clone();
    let (opt_name, search_kind) = if let Some(name) =
@@ -108,15 +107,15 @@ pub(crate) fn find_all_refs(
    let RangeInfo { range, info: def } = find_name(&sema, &syntax, position, opt_name)?;
    let references = def
-        .find_usages(db, search_scope)
+        .find_usages(sema, search_scope)
        .into_iter()
        .filter(|r| search_kind == ReferenceKind::Other || search_kind == r.kind)
        .collect();
-    let decl_range = def.try_to_nav(db)?.range();
+    let decl_range = def.try_to_nav(sema.db)?.range();
    let declaration = Declaration {
-        nav: def.try_to_nav(db)?,
+        nav: def.try_to_nav(sema.db)?,
        kind: ReferenceKind::Other,
        access: decl_access(&def, &syntax, decl_range),
    };
diff --git a/crates/ra_ide/src/references/rename.rs b/crates/ra_ide/src/references/rename.rs
index 7ebc0adcf..b6a2266b4 100644
--- a/crates/ra_ide/src/references/rename.rs
+++ b/crates/ra_ide/src/references/rename.rs
@@ -24,23 +24,24 @@ pub(crate) fn rename(
    position: FilePosition,
    new_name: &str,
 ) -> Option<RangeInfo<SourceChange>> {
+    let sema = Semantics::new(db);
    match lex_single_valid_syntax_kind(new_name)? {
        SyntaxKind::IDENT | SyntaxKind::UNDERSCORE => (),
-        SyntaxKind::SELF_KW => return rename_to_self(db, position),
+        SyntaxKind::SELF_KW => return rename_to_self(&sema, position),
        _ => return None,
    }
-    let sema = Semantics::new(db);
    let source_file = sema.parse(position.file_id);
    let syntax = source_file.syntax();
    if let Some(module) = find_module_at_offset(&sema, position, syntax) {
-        rename_mod(db, position, module, new_name)
+        rename_mod(&sema, position, module, new_name)
    } else if let Some(self_token) =
        syntax.token_at_offset(position.offset).find(|t| t.kind() == SyntaxKind::SELF_KW)
    {
-        rename_self_to_param(db, position, self_token, new_name)
+        rename_self_to_param(&sema, position, self_token, new_name)
    } else {
-        rename_reference(sema.db, position, new_name)
+        rename_reference(&sema, position, new_name)
    }
 }
@@ -97,7 +98,7 @@ fn source_edit_from_reference(reference: Reference, new_name: &str) -> SourceFil
 }
 fn rename_mod(
-    db: &RootDatabase,
+    sema: &Semantics<RootDatabase>,
    position: FilePosition,
    module: Module,
    new_name: &str,
@@ -105,12 +106,12 @@ fn rename_mod(
    let mut source_file_edits = Vec::new();
    let mut file_system_edits = Vec::new();
-    let src = module.definition_source(db);
+    let src = module.definition_source(sema.db);
-    let file_id = src.file_id.original_file(db);
+    let file_id = src.file_id.original_file(sema.db);
    match src.value {
        ModuleSource::SourceFile(..) => {
            // mod is defined in path/to/dir/mod.rs
-            let dst = if module.is_mod_rs(db) {
+            let dst = if module.is_mod_rs(sema.db) {
                format!("../{}/mod.rs", new_name)
            } else {
                format!("{}.rs", new_name)
@@ -122,17 +123,17 @@ fn rename_mod(
        ModuleSource::Module(..) => {}
    }
-    if let Some(src) = module.declaration_source(db) {
+    if let Some(src) = module.declaration_source(sema.db) {
-        let file_id = src.file_id.original_file(db);
+        let file_id = src.file_id.original_file(sema.db);
        let name = src.value.name()?;
        let edit = SourceFileEdit {
-            file_id: file_id,
+            file_id,
            edit: TextEdit::replace(name.syntax().text_range(), new_name.into()),
        };
        source_file_edits.push(edit);
    }
-    let RangeInfo { range, info: refs } = find_all_refs(db, position, None)?;
+    let RangeInfo { range, info: refs } = find_all_refs(sema, position, None)?;
    let ref_edits = refs
        .references
        .into_iter()
@@ -142,8 +143,10 @@ fn rename_mod(
    Some(RangeInfo::new(range, SourceChange::from_edits(source_file_edits, file_system_edits)))
 }
-fn rename_to_self(db: &RootDatabase, position: FilePosition) -> Option<RangeInfo<SourceChange>> {
+fn rename_to_self(
-    let sema = Semantics::new(db);
+    sema: &Semantics<RootDatabase>,
+    position: FilePosition,
+) -> Option<RangeInfo<SourceChange>> {
    let source_file = sema.parse(position.file_id);
    let syn = source_file.syntax();
@@ -158,7 +161,7 @@ fn rename_to_self(db: &RootDatabase, position: FilePosition) -> Option<RangeInfo
        _ => return None, // not renaming other types
    };
-    let RangeInfo { range, info: refs } = find_all_refs(db, position, None)?;
+    let RangeInfo { range, info: refs } = find_all_refs(sema, position, None)?;
    let param_range = first_param.syntax().text_range();
    let (param_ref, usages): (Vec<Reference>, Vec<Reference>) = refs
@@ -210,16 +213,15 @@ fn text_edit_from_self_param(
 }
 fn rename_self_to_param(
-    db: &RootDatabase,
+    sema: &Semantics<RootDatabase>,
    position: FilePosition,
    self_token: SyntaxToken,
    new_name: &str,
 ) -> Option<RangeInfo<SourceChange>> {
-    let sema = Semantics::new(db);
    let source_file = sema.parse(position.file_id);
    let syn = source_file.syntax();
-    let text = db.file_text(position.file_id);
+    let text = sema.db.file_text(position.file_id);
    let fn_def = find_node_at_offset::<ast::FnDef>(syn, position.offset)?;
    let search_range = fn_def.syntax().text_range();
@@ -249,11 +251,11 @@ fn rename_self_to_param(
 }
 fn rename_reference(
-    db: &RootDatabase,
+    sema: &Semantics<RootDatabase>,
    position: FilePosition,
    new_name: &str,
 ) -> Option<RangeInfo<SourceChange>> {
-    let RangeInfo { range, info: refs } = find_all_refs(db, position, None)?;
+    let RangeInfo { range, info: refs } = find_all_refs(sema, position, None)?;
    let edit = refs
        .into_iter()
diff --git a/crates/ra_ide/src/runnables.rs b/crates/ra_ide/src/runnables.rs
index f569a3f17..ed15d6494 100644
--- a/crates/ra_ide/src/runnables.rs
+++ b/crates/ra_ide/src/runnables.rs
@@ -251,13 +251,21 @@ fn runnable_mod(
 #[cfg(test)]
 mod tests {
-    use insta::assert_debug_snapshot;
+    use expect::{expect, Expect};
    use crate::mock_analysis::analysis_and_position;
-    use super::{Runnable, RunnableAction, BENCH, BIN, DOCTEST, TEST};
+    use super::{RunnableAction, BENCH, BIN, DOCTEST, TEST};
-    fn assert_actions(runnables: &[Runnable], actions: &[&RunnableAction]) {
+    fn check(
+        ra_fixture: &str,
+        // FIXME: fold this into `expect` as well
+        actions: &[&RunnableAction],
+        expect: Expect,
+    ) {
+        let (analysis, position) = analysis_and_position(ra_fixture);
+        let runnables = analysis.runnables(position.file_id).unwrap();
+        expect.assert_debug_eq(&runnables);
        assert_eq!(
            actions,
            runnables.into_iter().map(|it| it.action()).collect::<Vec<_>>().as_slice()
@@ -266,579 +274,557 @@ mod tests {
    #[test]
    fn test_runnables() {
-        let (analysis, pos) = analysis_and_position(
+        check(
            r#"
-        //- /lib.rs
+//- /lib.rs
-        <|> //empty
+<|>
-        fn main() {}
+fn main() {}
-        #[test]
+#[test]
-        fn test_foo() {}
+fn test_foo() {}
-        #[test]
+#[test]
-        #[ignore]
+#[ignore]
-        fn test_foo() {}
+fn test_foo() {}
-        #[bench]
+#[bench]
-        fn bench() {}
+fn bench() {}
-        "#,
+"#,
-        );
+            &[&BIN, &TEST, &TEST, &BENCH],
-        let runnables = analysis.runnables(pos.file_id).unwrap();
+            expect![[r#"
-        assert_debug_snapshot!(&runnables,
+                [
-        @r###"
+                    Runnable {
-        [
+                        nav: NavigationTarget {
-            Runnable {
+                            file_id: FileId(
-                nav: NavigationTarget {
+                                1,
-                    file_id: FileId(
+                            ),
-                        1,
+                            full_range: 1..13,
-                    ),
+                            name: "main",
-                    full_range: 1..21,
+                            kind: FN_DEF,
-                    name: "main",
+                            focus_range: Some(
-                    kind: FN_DEF,
+                                4..8,
-                    focus_range: Some(
+                            ),
-                        12..16,
+                            container_name: None,
-                    ),
+                            description: None,
-                    container_name: None,
+                            docs: None,
-                    description: None,
+                        },
-                    docs: None,
+                        kind: Bin,
-                },
+                        cfg_exprs: [],
-                kind: Bin,
-                cfg_exprs: [],
-            },
-            Runnable {
-                nav: NavigationTarget {
-                    file_id: FileId(
-                        1,
-                    ),
-                    full_range: 23..47,
-                    name: "test_foo",
-                    kind: FN_DEF,
-                    focus_range: Some(
-                        34..42,
-                    ),
-                    container_name: None,
-                    description: None,
-                    docs: None,
-                },
-                kind: Test {
-                    test_id: Path(
-                        "test_foo",
-                    ),
-                    attr: TestAttr {
-                        ignore: false,
                    },
-                },
+                    Runnable {
-                cfg_exprs: [],
+                        nav: NavigationTarget {
-            },
+                            file_id: FileId(
-            Runnable {
+                                1,
-                nav: NavigationTarget {
+                            ),
-                    file_id: FileId(
+                            full_range: 15..39,
-                        1,
+                            name: "test_foo",
-                    ),
+                            kind: FN_DEF,
-                    full_range: 49..83,
+                            focus_range: Some(
-                    name: "test_foo",
+                                26..34,
-                    kind: FN_DEF,
+                            ),
-                    focus_range: Some(
+                            container_name: None,
-                        70..78,
+                            description: None,
-                    ),
+                            docs: None,
-                    container_name: None,
+                        },
-                    description: None,
+                        kind: Test {
-                    docs: None,
+                            test_id: Path(
-                },
+                                "test_foo",
-                kind: Test {
+                            ),
-                    test_id: Path(
+                            attr: TestAttr {
-                        "test_foo",
+                                ignore: false,
-                    ),
+                            },
-                    attr: TestAttr {
+                        },
-                        ignore: true,
+                        cfg_exprs: [],
+                    },
+                    Runnable {
+                        nav: NavigationTarget {
+                            file_id: FileId(
+                                1,
+                            ),
+                            full_range: 41..75,
+                            name: "test_foo",
+                            kind: FN_DEF,
+                            focus_range: Some(
+                                62..70,
+                            ),
+                            container_name: None,
+                            description: None,
+                            docs: None,
+                        },
+                        kind: Test {
+                            test_id: Path(
+                                "test_foo",
+                            ),
+                            attr: TestAttr {
+                                ignore: true,
+                            },
+                        },
+                        cfg_exprs: [],
                    },
-                },
+                    Runnable {
-                cfg_exprs: [],
+                        nav: NavigationTarget {
-            },
+                            file_id: FileId(
-            Runnable {
+                                1,
-                nav: NavigationTarget {
+                            ),
-                    file_id: FileId(
+                            full_range: 77..99,
-                        1,
+                            name: "bench",
-                    ),
+                            kind: FN_DEF,
-                    full_range: 85..107,
+                            focus_range: Some(
-                    name: "bench",
+                                89..94,
-                    kind: FN_DEF,
+                            ),
-                    focus_range: Some(
+                            container_name: None,
-                        97..102,
+                            description: None,
-                    ),
+                            docs: None,
-                    container_name: None,
+                        },
-                    description: None,
+                        kind: Bench {
-                    docs: None,
+                            test_id: Path(
-                },
+                                "bench",
-                kind: Bench {
+                            ),
-                    test_id: Path(
+                        },
-                        "bench",
+                        cfg_exprs: [],
-                    ),
+                    },
-                },
+                ]
-                cfg_exprs: [],
+            "#]],
-            },
+        );
-        ]
-        "###
-                );
-        assert_actions(&runnables, &[&BIN, &TEST, &TEST, &BENCH]);
    }
    #[test]
    fn test_runnables_doc_test() {
-        let (analysis, pos) = analysis_and_position(
+        check(
            r#"
-        //- /lib.rs
+//- /lib.rs
-        <|> //empty
+<|>
-        fn main() {}
+fn main() {}
-        /// ```
+/// ```
-        /// let x = 5;
+/// let x = 5;
-        /// ```
+/// ```
-        fn foo() {}
+fn foo() {}
-        "#,
+"#,
+            &[&BIN, &DOCTEST],
+            expect![[r#"
+                [
+                    Runnable {
+                        nav: NavigationTarget {
+                            file_id: FileId(
+                                1,
+                            ),
+                            full_range: 1..13,
+                            name: "main",
+                            kind: FN_DEF,
+                            focus_range: Some(
+                                4..8,
+                            ),
+                            container_name: None,
+                            description: None,
+                            docs: None,
+                        },
+                        kind: Bin,
+                        cfg_exprs: [],
+                    },
+                    Runnable {
+                        nav: NavigationTarget {
+                            file_id: FileId(
+                                1,
+                            ),
+                            full_range: 15..57,
+                            name: "foo",
+                            kind: FN_DEF,
+                            focus_range: None,
+                            container_name: None,
+                            description: None,
+                            docs: None,
+                        },
+                        kind: DocTest {
+                            test_id: Path(
+                                "foo",
+                            ),
+                        },
+                        cfg_exprs: [],
+                    },
+                ]
+            "#]],
        );
-        let runnables = analysis.runnables(pos.file_id).unwrap();
-        assert_debug_snapshot!(&runnables,
-        @r###"
-        [
-            Runnable {
-                nav: NavigationTarget {
-                    file_id: FileId(
-                        1,
-                    ),
-                    full_range: 1..21,
-                    name: "main",
-                    kind: FN_DEF,
-                    focus_range: Some(
-                        12..16,
-                    ),
-                    container_name: None,
-                    description: None,
-                    docs: None,
-                },
-                kind: Bin,
-                cfg_exprs: [],
-            },
-            Runnable {
-                nav: NavigationTarget {
-                    file_id: FileId(
-                        1,
-                    ),
-                    full_range: 23..65,
-                    name: "foo",
-                    kind: FN_DEF,
-                    focus_range: None,
-                    container_name: None,
-                    description: None,
-                    docs: None,
-                },
-                kind: DocTest {
-                    test_id: Path(
-                        "foo",
-                    ),
-                },
-                cfg_exprs: [],
-            },
-        ]
-        "###
-                );
-        assert_actions(&runnables, &[&BIN, &DOCTEST]);
    }
    #[test]
    fn test_runnables_doc_test_in_impl() {
-        let (analysis, pos) = analysis_and_position(
+        check(
            r#"
-        //- /lib.rs
+//- /lib.rs
-        <|> //empty
+<|>
-        fn main() {}
+fn main() {}
-        struct Data;
+struct Data;
-        impl Data {
+impl Data {
-            /// ```
+    /// ```
-            /// let x = 5;
+    /// let x = 5;
-            /// ```
+    /// ```
-            fn foo() {}
+    fn foo() {}
-        }
+}
-        "#,
+"#,
+            &[&BIN, &DOCTEST],
+            expect![[r#"
+                [
+                    Runnable {
+                        nav: NavigationTarget {
+                            file_id: FileId(
+                                1,
+                            ),
+                            full_range: 1..13,
+                            name: "main",
+                            kind: FN_DEF,
+                            focus_range: Some(
+                                4..8,
+                            ),
+                            container_name: None,
+                            description: None,
+                            docs: None,
+                        },
+                        kind: Bin,
+                        cfg_exprs: [],
+                    },
+                    Runnable {
+                        nav: NavigationTarget {
+                            file_id: FileId(
+                                1,
+                            ),
+                            full_range: 44..98,
+                            name: "foo",
+                            kind: FN_DEF,
+                            focus_range: None,
+                            container_name: None,
+                            description: None,
+                            docs: None,
+                        },
+                        kind: DocTest {
+                            test_id: Path(
+                                "Data::foo",
+                            ),
+                        },
+                        cfg_exprs: [],
+                    },
+                ]
+            "#]],
        );
-        let runnables = analysis.runnables(pos.file_id).unwrap();
-        assert_debug_snapshot!(&runnables,
-        @r###"
-        [
-            Runnable {
-                nav: NavigationTarget {
-                    file_id: FileId(
-                        1,
-                    ),
-                    full_range: 1..21,
-                    name: "main",
-                    kind: FN_DEF,
-                    focus_range: Some(
-                        12..16,
-                    ),
-                    container_name: None,
-                    description: None,
-                    docs: None,
-                },
-                kind: Bin,
-                cfg_exprs: [],
-            },
-            Runnable {
-                nav: NavigationTarget {
-                    file_id: FileId(
-                        1,
-                    ),
-                    full_range: 52..106,
-                    name: "foo",
-                    kind: FN_DEF,
-                    focus_range: None,
-                    container_name: None,
-                    description: None,
-                    docs: None,
-                },
-                kind: DocTest {
-                    test_id: Path(
-                        "Data::foo",
-                    ),
-                },
-                cfg_exprs: [],
-            },
-        ]
-        "###
-                );
-        assert_actions(&runnables, &[&BIN, &DOCTEST]);
    }
    #[test]
    fn test_runnables_module() {
-        let (analysis, pos) = analysis_and_position(
+        check(
            r#"
-        //- /lib.rs
+//- /lib.rs
-        <|> //empty
+<|>
-        mod test_mod {
+mod test_mod {
-            #[test]
+    #[test]
-            fn test_foo1() {}
+    fn test_foo1() {}
-        }
+}
-        "#,
+"#,
-        );
+            &[&TEST, &TEST],
-        let runnables = analysis.runnables(pos.file_id).unwrap();
+            expect![[r#"
-        assert_debug_snapshot!(&runnables,
+                [
-        @r###"
+                    Runnable {
-        [
+                        nav: NavigationTarget {
-            Runnable {
+                            file_id: FileId(
-                nav: NavigationTarget {
+                                1,
-                    file_id: FileId(
+                            ),
-                        1,
+                            full_range: 1..51,
-                    ),
+                            name: "test_mod",
-                    full_range: 1..59,
+                            kind: MODULE,
-                    name: "test_mod",
+                            focus_range: Some(
-                    kind: MODULE,
+                                5..13,
-                    focus_range: Some(
+                            ),
-                        13..21,
+                            container_name: None,
-                    ),
+                            description: None,
-                    container_name: None,
+                            docs: None,
-                    description: None,
+                        },
-                    docs: None,
+                        kind: TestMod {
-                },
+                            path: "test_mod",
-                kind: TestMod {
+                        },
-                    path: "test_mod",
+                        cfg_exprs: [],
-                },
+                    },
-                cfg_exprs: [],
+                    Runnable {
-            },
+                        nav: NavigationTarget {
-            Runnable {
+                            file_id: FileId(
-                nav: NavigationTarget {
+                                1,
-                    file_id: FileId(
+                            ),
-                        1,
+                            full_range: 20..49,
-                    ),
+                            name: "test_foo1",
-                    full_range: 28..57,
+                            kind: FN_DEF,
-                    name: "test_foo1",
+                            focus_range: Some(
-                    kind: FN_DEF,
+                                35..44,
-                    focus_range: Some(
+                            ),
-                        43..52,
+                            container_name: None,
-                    ),
+                            description: None,
-                    container_name: None,
+                            docs: None,
-                    description: None,
+                        },
-                    docs: None,
+                        kind: Test {
-                },
+                            test_id: Path(
-                kind: Test {
+                                "test_mod::test_foo1",
-                    test_id: Path(
+                            ),
-                        "test_mod::test_foo1",
+                            attr: TestAttr {
-                    ),
+                                ignore: false,
-                    attr: TestAttr {
+                            },
-                        ignore: false,
+                        },
+                        cfg_exprs: [],
                    },
-                },
+                ]
-                cfg_exprs: [],
+            "#]],
-            },
+        );
-        ]
-        "###
-                );
-        assert_actions(&runnables, &[&TEST, &TEST]);
    }
    #[test]
    fn test_runnables_one_depth_layer_module() {
-        let (analysis, pos) = analysis_and_position(
+        check(
            r#"
-        //- /lib.rs
+//- /lib.rs
-        <|> //empty
+<|>
-        mod foo {
+mod foo {
-            mod test_mod {
+    mod test_mod {
-                #[test]
+        #[test]
-                fn test_foo1() {}
+        fn test_foo1() {}
-            }
+    }
-        }
+}
-        "#,
+"#,
-        );
+            &[&TEST, &TEST],
-        let runnables = analysis.runnables(pos.file_id).unwrap();
+            expect![[r#"
-        assert_debug_snapshot!(&runnables,
+                [
-        @r###"
+                    Runnable {
-        [
+                        nav: NavigationTarget {
-            Runnable {
+                            file_id: FileId(
-                nav: NavigationTarget {
+                                1,
-                    file_id: FileId(
+                            ),
-                        1,
+                            full_range: 15..77,
-                    ),
+                            name: "test_mod",
-                    full_range: 23..85,
+                            kind: MODULE,
-                    name: "test_mod",
+                            focus_range: Some(
-                    kind: MODULE,
+                                19..27,
-                    focus_range: Some(
+                            ),
-                        27..35,
+                            container_name: None,
-                    ),
+                            description: None,
-                    container_name: None,
+                            docs: None,
-                    description: None,
+                        },
-                    docs: None,
+                        kind: TestMod {
-                },
+                            path: "foo::test_mod",
-                kind: TestMod {
+                        },
-                    path: "foo::test_mod",
+                        cfg_exprs: [],
-                },
+                    },
-                cfg_exprs: [],
+                    Runnable {
-            },
+                        nav: NavigationTarget {
-            Runnable {
+                            file_id: FileId(
-                nav: NavigationTarget {
+                                1,
-                    file_id: FileId(
+                            ),
-                        1,
+                            full_range: 38..71,
-                    ),
+                            name: "test_foo1",
-                    full_range: 46..79,
+                            kind: FN_DEF,
-                    name: "test_foo1",
+                            focus_range: Some(
-                    kind: FN_DEF,
+                                57..66,
-                    focus_range: Some(
+                            ),
-                        65..74,
+                            container_name: None,
-                    ),
+                            description: None,
-                    container_name: None,
+                            docs: None,
-                    description: None,
+                        },
-                    docs: None,
+                        kind: Test {
-                },
+                            test_id: Path(
-                kind: Test {
+                                "foo::test_mod::test_foo1",
-                    test_id: Path(
+                            ),
-                        "foo::test_mod::test_foo1",
+                            attr: TestAttr {
-                    ),
+                                ignore: false,
-                    attr: TestAttr {
+                            },
-                        ignore: false,
+                        },
+                        cfg_exprs: [],
                    },
-                },
+                ]
-                cfg_exprs: [],
+            "#]],
-            },
+        );
-        ]
-        "###
-                );
-        assert_actions(&runnables, &[&TEST, &TEST]);
    }
    #[test]
    fn test_runnables_multiple_depth_module() {
-        let (analysis, pos) = analysis_and_position(
+        check(
            r#"
-        //- /lib.rs
+//- /lib.rs
-        <|> //empty
+<|>
-        mod foo {
+mod foo {
-            mod bar {
+    mod bar {
-                mod test_mod {
+        mod test_mod {
-                    #[test]
+            #[test]
-                    fn test_foo1() {}
+            fn test_foo1() {}
-                }
-            }
        }
-        "#,
+    }
-        );
+}
-        let runnables = analysis.runnables(pos.file_id).unwrap();
+"#,
-        assert_debug_snapshot!(&runnables,
+            &[&TEST, &TEST],
-        @r###"
+            expect![[r#"
-        [
+                [
-            Runnable {
+                    Runnable {
-                nav: NavigationTarget {
+                        nav: NavigationTarget {
-                    file_id: FileId(
+                            file_id: FileId(
-                        1,
+                                1,
-                    ),
+                            ),
-                    full_range: 41..115,
+                            full_range: 33..107,
-                    name: "test_mod",
+                            name: "test_mod",
-                    kind: MODULE,
+                            kind: MODULE,
-                    focus_range: Some(
+                            focus_range: Some(
-                        45..53,
+                                37..45,
-                    ),
+                            ),
-                    container_name: None,
+                            container_name: None,
-                    description: None,
+                            description: None,
-                    docs: None,
+                            docs: None,
-                },
+                        },
-                kind: TestMod {
+                        kind: TestMod {
-                    path: "foo::bar::test_mod",
+                            path: "foo::bar::test_mod",
-                },
+                        },
-                cfg_exprs: [],
+                        cfg_exprs: [],
-            },
+                    },
-            Runnable {
+                    Runnable {
-                nav: NavigationTarget {
+                        nav: NavigationTarget {
-                    file_id: FileId(
+                            file_id: FileId(
-                        1,
+                                1,
-                    ),
+                            ),
-                    full_range: 68..105,
+                            full_range: 60..97,
-                    name: "test_foo1",
+                            name: "test_foo1",
-                    kind: FN_DEF,
+                            kind: FN_DEF,
-                    focus_range: Some(
+                            focus_range: Some(
-                        91..100,
+                                83..92,
-                    ),
+                            ),
-                    container_name: None,
+                            container_name: None,
-                    description: None,
+                            description: None,
-                    docs: None,
+                            docs: None,
-                },
+                        },
-                kind: Test {
+                        kind: Test {
-                    test_id: Path(
+                            test_id: Path(
-                        "foo::bar::test_mod::test_foo1",
+                                "foo::bar::test_mod::test_foo1",
-                    ),
+                            ),
-                    attr: TestAttr {
+                            attr: TestAttr {
-                        ignore: false,
+                                ignore: false,
+                            },
+                        },
+                        cfg_exprs: [],
                    },
-                },
+                ]
-                cfg_exprs: [],
+            "#]],
-            },
+        );
-        ]
-        "###
-                );
-        assert_actions(&runnables, &[&TEST, &TEST]);
    }
    #[test]
    fn test_runnables_with_feature() {
-        let (analysis, pos) = analysis_and_position(
+        check(
            r#"
-        //- /lib.rs crate:foo cfg:feature=foo
+//- /lib.rs crate:foo cfg:feature=foo
-        <|> //empty
+<|>
-        #[test]
+#[test]
-        #[cfg(feature = "foo")]
+#[cfg(feature = "foo")]
-        fn test_foo1() {}
+fn test_foo1() {}
-        "#,
+"#,
-        );
+            &[&TEST],
-        let runnables = analysis.runnables(pos.file_id).unwrap();
+            expect![[r#"
-        assert_debug_snapshot!(&runnables,
+                [
-        @r###"
+                    Runnable {
-        [
+                        nav: NavigationTarget {
-            Runnable {
+                            file_id: FileId(
-                nav: NavigationTarget {
+                                1,
-                    file_id: FileId(
+                            ),
-                        1,
+                            full_range: 1..50,
-                    ),
+                            name: "test_foo1",
-                    full_range: 1..58,
+                            kind: FN_DEF,
-                    name: "test_foo1",
+                            focus_range: Some(
-                    kind: FN_DEF,
+                                36..45,
-                    focus_range: Some(
+                            ),
-                        44..53,
+                            container_name: None,
-                    ),
+                            description: None,
-                    container_name: None,
+                            docs: None,
-                    description: None,
+                        },
-                    docs: None,
+                        kind: Test {
-                },
+                            test_id: Path(
-                kind: Test {
+                                "test_foo1",
-                    test_id: Path(
+                            ),
-                        "test_foo1",
+                            attr: TestAttr {
-                    ),
+                                ignore: false,
-                    attr: TestAttr {
+                            },
-                        ignore: false,
+                        },
-                    },
+                        cfg_exprs: [
-                },
+                            KeyValue {
-                cfg_exprs: [
+                                key: "feature",
-                    KeyValue {
+                                value: "foo",
-                        key: "feature",
+                            },
-                        value: "foo",
+                        ],
                    },
-                ],
+                ]
-            },
+            "#]],
-        ]
+        );
-        "###
-                );
-        assert_actions(&runnables, &[&TEST]);
    }
    #[test]
    fn test_runnables_with_features() {
-        let (analysis, pos) = analysis_and_position(
+        check(
            r#"
-        //- /lib.rs crate:foo cfg:feature=foo,feature=bar
+//- /lib.rs crate:foo cfg:feature=foo,feature=bar
-        <|> //empty
+<|>
-        #[test]
+#[test]
-        #[cfg(all(feature = "foo", feature = "bar"))]
+#[cfg(all(feature = "foo", feature = "bar"))]
-        fn test_foo1() {}
+fn test_foo1() {}
-        "#,
+"#,
-        );
+            &[&TEST],
-        let runnables = analysis.runnables(pos.file_id).unwrap();
+            expect![[r#"
-        assert_debug_snapshot!(&runnables,
+                [
-        @r###"
+                    Runnable {
-        [
+                        nav: NavigationTarget {
-            Runnable {
+                            file_id: FileId(
-                nav: NavigationTarget {
+                                1,
-                    file_id: FileId(
+                            ),
-                        1,
+                            full_range: 1..72,
-                    ),
+                            name: "test_foo1",
-                    full_range: 1..80,
+                            kind: FN_DEF,
-                    name: "test_foo1",
+                            focus_range: Some(
-                    kind: FN_DEF,
+                                58..67,
-                    focus_range: Some(
+                            ),
-                        66..75,
+                            container_name: None,
-                    ),
+                            description: None,
-                    container_name: None,
+                            docs: None,
-                    description: None,
+                        },
-                    docs: None,
+                        kind: Test {
-                },
+                            test_id: Path(
-                kind: Test {
+                                "test_foo1",
-                    test_id: Path(
+                            ),
-                        "test_foo1",
+                            attr: TestAttr {
-                    ),
+                                ignore: false,
-                    attr: TestAttr {
-                        ignore: false,
-                    },
-                },
-                cfg_exprs: [
-                    All(
-                        [
-                            KeyValue {
-                                key: "feature",
-                                value: "foo",
-                            },
-                            KeyValue {
-                                key: "feature",
-                                value: "bar",
                            },
+                        },
+                        cfg_exprs: [
+                            All(
+                                [
+                                    KeyValue {
+                                        key: "feature",
+                                        value: "foo",
+                                    },
+                                    KeyValue {
+                                        key: "feature",
+                                        value: "bar",
+                                    },
+                                ],
+                            ),
                        ],
-                    ),
+                    },
-                ],
+                ]
-            },
+            "#]],
-        ]
+        );
-        "###
-                );
-        assert_actions(&runnables, &[&TEST]);
    }
    #[test]
    fn test_runnables_no_test_function_in_module() {
-        let (analysis, pos) = analysis_and_position(
+        check(
            r#"
-        //- /lib.rs
+//- /lib.rs
-        <|> //empty
+<|>
-        mod test_mod {
+mod test_mod {
-            fn foo1() {}
+    fn foo1() {}
-        }
+}
-        "#,
+"#,
+            &[],
+            expect![[r#"
+                []
+            "#]],
        );
-        let runnables = analysis.runnables(pos.file_id).unwrap();
-        assert!(runnables.is_empty())
    }
 }
diff --git a/crates/ra_ide/src/ssr.rs b/crates/ra_ide/src/ssr.rs
index 6cb96608b..b3e9e5dfe 100644
--- a/crates/ra_ide/src/ssr.rs
+++ b/crates/ra_ide/src/ssr.rs
@@ -4,12 +4,24 @@ use ra_ide_db::{symbol_index::SymbolsDatabase, RootDatabase};
 use crate::SourceFileEdit;
 use ra_ssr::{MatchFinder, SsrError, SsrRule};
-// Feature: Structural Seach and Replace
+// Feature: Structural Search and Replace
 //
 // Search and replace with named wildcards that will match any expression, type, path, pattern or item.
 // The syntax for a structural search replace command is `<search_pattern> ==>> <replace_pattern>`.
 // A `$<name>` placeholder in the search pattern will match any AST node and `$<name>` will reference it in the replacement.
 // Within a macro call, a placeholder will match up until whatever token follows the placeholder.
+//
+// Placeholders may be given constraints by writing them as `${<name>:<constraint1>:<constraint2>...}`.
+//
+// Supported constraints:
+//
+// |===
+// | Constraint    | Restricts placeholder
+//
+// | kind(literal) | Is a literal (e.g. `42` or `"forty two"`)
+// | not(a)        | Negates the constraint `a`
+// |===
+//
 // Available via the command `rust-analyzer.ssr`.
 //
 // ```rust
diff --git a/crates/ra_ide/src/syntax_highlighting/tests.rs b/crates/ra_ide/src/syntax_highlighting/tests.rs
index b7fad9719..aa7c887d6 100644
--- a/crates/ra_ide/src/syntax_highlighting/tests.rs
+++ b/crates/ra_ide/src/syntax_highlighting/tests.rs
@@ -1,6 +1,7 @@
 use std::fs;
-use test_utils::{assert_eq_text, project_dir, read_text};
+use expect::{expect_file, ExpectFile};
+use test_utils::project_dir;
 use crate::{mock_analysis::single_file, FileRange, TextRange};
@@ -91,7 +92,7 @@ impl<T> Option<T> {
 }
 "#
        .trim(),
-        "crates/ra_ide/src/snapshots/highlighting.html",
+        expect_file!["crates/ra_ide/test_data/highlighting.html"],
        false,
    );
 }
@@ -114,7 +115,7 @@ fn bar() {
 }
 "#
        .trim(),
-        "crates/ra_ide/src/snapshots/rainbow_highlighting.html",
+        expect_file!["crates/ra_ide/test_data/rainbow_highlighting.html"],
        true,
    );
 }
@@ -167,7 +168,7 @@ fn main() {
    );
 }"##
        .trim(),
-        "crates/ra_ide/src/snapshots/highlight_injection.html",
+        expect_file!["crates/ra_ide/test_data/highlight_injection.html"],
        false,
    );
 }
@@ -250,7 +251,7 @@ fn main() {
    println!("{ничоси}", ничоси = 92);
 }"#
        .trim(),
-        "crates/ra_ide/src/snapshots/highlight_strings.html",
+        expect_file!["crates/ra_ide/test_data/highlight_strings.html"],
        false,
    );
 }
@@ -278,7 +279,7 @@ fn main() {
 }
 "#
        .trim(),
-        "crates/ra_ide/src/snapshots/highlight_unsafe.html",
+        expect_file!["crates/ra_ide/test_data/highlight_unsafe.html"],
        false,
    );
 }
@@ -354,7 +355,7 @@ macro_rules! noop {
 }
 "#
        .trim(),
-        "crates/ra_ide/src/snapshots/highlight_doctest.html",
+        expect_file!["crates/ra_ide/test_data/highlight_doctest.html"],
        false,
    );
 }
@@ -362,11 +363,8 @@ macro_rules! noop {
 /// Highlights the code given by the `ra_fixture` argument, renders the
 /// result as HTML, and compares it with the HTML file given as `snapshot`.
 /// Note that the `snapshot` file is overwritten by the rendered HTML.
-fn check_highlighting(ra_fixture: &str, snapshot: &str, rainbow: bool) {
+fn check_highlighting(ra_fixture: &str, expect: ExpectFile, rainbow: bool) {
    let (analysis, file_id) = single_file(ra_fixture);
-    let dst_file = project_dir().join(snapshot);
    let actual_html = &analysis.highlight_as_html(file_id, rainbow).unwrap();
-    let expected_html = &read_text(&dst_file);
+    expect.assert_eq(actual_html)
-    fs::write(dst_file, &actual_html).unwrap();
-    assert_eq_text!(expected_html, actual_html);
 }
diff --git a/crates/ra_ide/src/snapshots/highlight_doctest.html b/crates/ra_ide/test_data/highlight_doctest.html
index e8155def7..e8155def7 100644
--- a/crates/ra_ide/src/snapshots/highlight_doctest.html
+++ b/crates/ra_ide/test_data/highlight_doctest.html
diff --git a/crates/ra_ide/src/snapshots/highlight_injection.html b/crates/ra_ide/test_data/highlight_injection.html
index 1b0349bae..1b0349bae 100644
--- a/crates/ra_ide/src/snapshots/highlight_injection.html
+++ b/crates/ra_ide/test_data/highlight_injection.html
diff --git a/crates/ra_ide/src/snapshots/highlight_strings.html b/crates/ra_ide/test_data/highlight_strings.html
index d184b5691..d184b5691 100644
--- a/crates/ra_ide/src/snapshots/highlight_strings.html
+++ b/crates/ra_ide/test_data/highlight_strings.html
diff --git a/crates/ra_ide/src/snapshots/highlight_unsafe.html b/crates/ra_ide/test_data/highlight_unsafe.html
index 6936e949f..6936e949f 100644
--- a/crates/ra_ide/src/snapshots/highlight_unsafe.html
+++ b/crates/ra_ide/test_data/highlight_unsafe.html
diff --git a/crates/ra_ide/src/snapshots/highlighting.html b/crates/ra_ide/test_data/highlighting.html
index 8d0b38f95..8d0b38f95 100644
--- a/crates/ra_ide/src/snapshots/highlighting.html
+++ b/crates/ra_ide/test_data/highlighting.html
diff --git a/crates/ra_ide/src/snapshots/rainbow_highlighting.html b/crates/ra_ide/test_data/rainbow_highlighting.html
index 9516c7441..9516c7441 100644
--- a/crates/ra_ide/src/snapshots/rainbow_highlighting.html
+++ b/crates/ra_ide/test_data/rainbow_highlighting.html
diff --git a/crates/ra_ide_db/src/change.rs b/crates/ra_ide_db/src/change.rs
index b507000f2..dbe6eacc5 100644
--- a/crates/ra_ide_db/src/change.rs
+++ b/crates/ra_ide_db/src/change.rs
@@ -243,8 +243,9 @@ impl RootDatabase {
            hir::db::GenericPredicatesForParamQuery
            hir::db::GenericPredicatesQuery
            hir::db::GenericDefaultsQuery
-            hir::db::ImplsInCrateQuery
+            hir::db::InherentImplsInCrateQuery
-            hir::db::ImplsFromDepsQuery
+            hir::db::TraitImplsInCrateQuery
+            hir::db::TraitImplsInDepsQuery
            hir::db::InternTypeCtorQuery
            hir::db::InternTypeParamIdQuery
            hir::db::InternChalkImplQuery
diff --git a/crates/ra_ide_db/src/imports_locator.rs b/crates/ra_ide_db/src/imports_locator.rs
index fff112e66..1fba71ff8 100644
--- a/crates/ra_ide_db/src/imports_locator.rs
+++ b/crates/ra_ide_db/src/imports_locator.rs
@@ -13,57 +13,53 @@ use crate::{
 use either::Either;
 use rustc_hash::FxHashSet;
-pub struct ImportsLocator<'a> {
+pub fn find_imports<'a>(
-    sema: Semantics<'a, RootDatabase>,
+    sema: &Semantics<'a, RootDatabase>,
    krate: Crate,
-}
+    name_to_import: &str,
+) -> Vec<Either<ModuleDef, MacroDef>> {
-impl<'a> ImportsLocator<'a> {
+    let _p = profile("search_for_imports");
-    pub fn new(db: &'a RootDatabase, krate: Crate) -> Self {
+    let db = sema.db;
-        Self { sema: Semantics::new(db), krate }
-    }
-    pub fn find_imports(&mut self, name_to_import: &str) -> Vec<Either<ModuleDef, MacroDef>> {
+    // Query dependencies first.
-        let _p = profile("search_for_imports");
+    let mut candidates: FxHashSet<_> =
-        let db = self.sema.db;
+        krate.query_external_importables(db, name_to_import).collect();
-        // Query dependencies first.
+    // Query the local crate using the symbol index.
-        let mut candidates: FxHashSet<_> =
+    let local_results = {
-            self.krate.query_external_importables(db, name_to_import).collect();
+        let mut query = Query::new(name_to_import.to_string());
+        query.exact();
+        query.limit(40);
+        symbol_index::crate_symbols(db, krate.into(), query)
+    };
-        // Query the local crate using the symbol index.
+    candidates.extend(
-        let local_results = {
+        local_results
-            let mut query = Query::new(name_to_import.to_string());
+            .into_iter()
-            query.exact();
+            .filter_map(|import_candidate| get_name_definition(sema, &import_candidate))
-            query.limit(40);
+            .filter_map(|name_definition_to_import| match name_definition_to_import {
-            symbol_index::crate_symbols(db, self.krate.into(), query)
+                Definition::ModuleDef(module_def) => Some(Either::Left(module_def)),
-        };
+                Definition::Macro(macro_def) => Some(Either::Right(macro_def)),
+                _ => None,
+            }),
+    );
-        candidates.extend(
+    candidates.into_iter().collect()
-            local_results
+}
-                .into_iter()
-                .filter_map(|import_candidate| self.get_name_definition(&import_candidate))
-                .filter_map(|name_definition_to_import| match name_definition_to_import {
-                    Definition::ModuleDef(module_def) => Some(Either::Left(module_def)),
-                    Definition::Macro(macro_def) => Some(Either::Right(macro_def)),
-                    _ => None,
-                }),
-        );
-        candidates.into_iter().collect()
-    }
-    fn get_name_definition(&mut self, import_candidate: &FileSymbol) -> Option<Definition> {
+fn get_name_definition<'a>(
-        let _p = profile("get_name_definition");
+    sema: &Semantics<'a, RootDatabase>,
-        let file_id = import_candidate.file_id;
+    import_candidate: &FileSymbol,
+) -> Option<Definition> {
+    let _p = profile("get_name_definition");
+    let file_id = import_candidate.file_id;
-        let candidate_node = import_candidate.ptr.to_node(self.sema.parse(file_id).syntax());
+    let candidate_node = import_candidate.ptr.to_node(sema.parse(file_id).syntax());
-        let candidate_name_node = if candidate_node.kind() != NAME {
+    let candidate_name_node = if candidate_node.kind() != NAME {
-            candidate_node.children().find(|it| it.kind() == NAME)?
+        candidate_node.children().find(|it| it.kind() == NAME)?
-        } else {
+    } else {
-            candidate_node
+        candidate_node
-        };
+    };
-        let name = ast::Name::cast(candidate_name_node)?;
+    let name = ast::Name::cast(candidate_name_node)?;
-        classify_name(&self.sema, &name)?.into_definition()
+    classify_name(sema, &name)?.into_definition()
-    }
 }
diff --git a/crates/ra_ide_db/src/lib.rs b/crates/ra_ide_db/src/lib.rs
index a808de4f1..c78071ad6 100644
--- a/crates/ra_ide_db/src/lib.rs
+++ b/crates/ra_ide_db/src/lib.rs
@@ -13,7 +13,7 @@ mod wasm_shims;
 use std::sync::Arc;
-use hir::db::{AstDatabase, DefDatabase};
+use hir::db::{AstDatabase, DefDatabase, HirDatabase};
 use ra_db::{
    salsa::{self, Database, Durability},
    Canceled, CheckCanceled, CrateId, FileId, FileLoader, FileLoaderDelegate, SourceDatabase,
@@ -52,6 +52,12 @@ impl Upcast<dyn DefDatabase> for RootDatabase {
    }
 }
+impl Upcast<dyn HirDatabase> for RootDatabase {
+    fn upcast(&self) -> &(dyn HirDatabase + 'static) {
+        &*self
+    }
+}
 impl FileLoader for RootDatabase {
    fn file_text(&self, file_id: FileId) -> Arc<String> {
        FileLoaderDelegate(self).file_text(file_id)
diff --git a/crates/ra_ide_db/src/search.rs b/crates/ra_ide_db/src/search.rs
index 44d5c35e6..81553150b 100644
--- a/crates/ra_ide_db/src/search.rs
+++ b/crates/ra_ide_db/src/search.rs
@@ -180,20 +180,20 @@ impl Definition {
    pub fn find_usages(
        &self,
-        db: &RootDatabase,
+        sema: &Semantics<RootDatabase>,
        search_scope: Option<SearchScope>,
    ) -> Vec<Reference> {
        let _p = profile("Definition::find_usages");
        let search_scope = {
-            let base = self.search_scope(db);
+            let base = self.search_scope(sema.db);
            match search_scope {
                None => base,
                Some(scope) => base.intersection(&scope),
            }
        };
-        let name = match self.name(db) {
+        let name = match self.name(sema.db) {
            None => return Vec::new(),
            Some(it) => it.to_string(),
        };
@@ -202,11 +202,10 @@ impl Definition {
        let mut refs = vec![];
        for (file_id, search_range) in search_scope {
-            let text = db.file_text(file_id);
+            let text = sema.db.file_text(file_id);
            let search_range =
                search_range.unwrap_or(TextRange::up_to(TextSize::of(text.as_str())));
-            let sema = Semantics::new(db);
            let tree = Lazy::new(|| sema.parse(file_id).syntax().clone());
            for (idx, _) in text.match_indices(pat) {
@@ -222,9 +221,6 @@ impl Definition {
                        continue;
                    };
-                // FIXME: reuse sb
-                // See https://github.com/rust-lang/rust/pull/68198#issuecomment-574269098
                match classify_name_ref(&sema, &name_ref) {
                    Some(NameRefClass::Definition(def)) if &def == self => {
                        let kind = if is_record_lit_name_ref(&name_ref)
diff --git a/crates/ra_proc_macro_srv/src/tests/mod.rs b/crates/ra_proc_macro_srv/src/tests/mod.rs
index 82cefbb29..8e6f28abd 100644
--- a/crates/ra_proc_macro_srv/src/tests/mod.rs
+++ b/crates/ra_proc_macro_srv/src/tests/mod.rs
@@ -11,7 +11,7 @@ fn test_derive_serialize_proc_macro() {
        "serde_derive",
        "Serialize",
        "1.0",
-        r##"struct Foo {}"##,
+        r"struct Foo {}",
        include_str!("fixtures/test_serialize_proc_macro.txt"),
    );
 }
@@ -22,9 +22,7 @@ fn test_derive_serialize_proc_macro_failed() {
        "serde_derive",
        "Serialize",
        "1.0",
-        r##"
+        r"struct {}",
-    struct {}
-"##,
        r##"
 SUBTREE $
  IDENT   compile_error 4294967295
diff --git a/crates/ra_proc_macro_srv/src/tests/utils.rs b/crates/ra_proc_macro_srv/src/tests/utils.rs
index 8d85f2d8a..dcb00671f 100644
--- a/crates/ra_proc_macro_srv/src/tests/utils.rs
+++ b/crates/ra_proc_macro_srv/src/tests/utils.rs
@@ -44,12 +44,12 @@ pub fn assert_expand(
    crate_name: &str,
    macro_name: &str,
    version: &str,
-    fixture: &str,
+    ra_fixture: &str,
    expect: &str,
 ) {
    let path = fixtures::dylib_path(crate_name, version);
    let expander = dylib::Expander::new(&path).unwrap();
-    let fixture = parse_string(fixture).unwrap();
+    let fixture = parse_string(ra_fixture).unwrap();
    let res = expander.expand(macro_name, &fixture.subtree, None).unwrap();
    assert_eq_text!(&format!("{:?}", res), &expect.trim());
diff --git a/crates/ra_project_model/src/cargo_workspace.rs b/crates/ra_project_model/src/cargo_workspace.rs
index 3b124020d..47a1d393d 100644
--- a/crates/ra_project_model/src/cargo_workspace.rs
+++ b/crates/ra_project_model/src/cargo_workspace.rs
@@ -1,6 +1,11 @@
 //! FIXME: write short doc here
-use std::{ffi::OsStr, ops, path::Path, process::Command};
+use std::{
+    ffi::OsStr,
+    ops,
+    path::{Path, PathBuf},
+    process::Command,
+};
 use anyhow::{Context, Result};
 use cargo_metadata::{BuildScript, CargoOpt, Message, MetadataCommand, PackageId};
@@ -308,9 +313,13 @@ pub fn load_extern_resources(
        if let Ok(message) = message {
            match message {
                Message::BuildScriptExecuted(BuildScript { package_id, out_dir, cfgs, .. }) => {
-                    let out_dir = AbsPathBuf::assert(out_dir);
+                    // cargo_metadata crate returns default (empty) path for
-                    res.out_dirs.insert(package_id.clone(), out_dir);
+                    // older cargos, which is not absolute, so work around that.
-                    res.cfgs.insert(package_id, cfgs);
+                    if out_dir != PathBuf::default() {
+                        let out_dir = AbsPathBuf::assert(out_dir);
+                        res.out_dirs.insert(package_id.clone(), out_dir);
+                        res.cfgs.insert(package_id, cfgs);
+                    }
                }
                Message::CompilerArtifact(message) => {
                    if message.target.kind.contains(&"proc-macro".to_string()) {
diff --git a/crates/ra_project_model/src/lib.rs b/crates/ra_project_model/src/lib.rs
index 8b85b4831..8dbf4e6ea 100644
--- a/crates/ra_project_model/src/lib.rs
+++ b/crates/ra_project_model/src/lib.rs
@@ -288,10 +288,7 @@ impl ProjectWorkspace {
                        if let (Some(&from), Some(&to)) =
                            (crates.get(&from_crate_id), crates.get(&to_crate_id))
                        {
-                            if crate_graph
+                            if crate_graph.add_dep(from, dep.name.clone(), to).is_err() {
-                                .add_dep(from, CrateName::new(&dep.name).unwrap(), to)
-                                .is_err()
-                            {
                                log::error!(
                                    "cyclic dependency {:?} -> {:?}",
                                    from_crate_id,
@@ -312,13 +309,11 @@ impl ProjectWorkspace {
                        let env = Env::default();
                        let proc_macro = vec![];
-                        let crate_name = CrateName::new(&sysroot[krate].name)
+                        let name = sysroot[krate].name.clone();
-                            .expect("Sysroot crate names should not contain dashes");
                        let crate_id = crate_graph.add_crate_root(
                            file_id,
                            Edition::Edition2018,
-                            Some(crate_name),
+                            Some(name),
                            cfg_options.clone(),
                            env,
                            proc_macro,
@@ -392,7 +387,7 @@ impl ProjectWorkspace {
                            let crate_id = crate_graph.add_crate_root(
                                file_id,
                                edition,
-                                Some(CrateName::normalize_dashes(&cargo[pkg].name)),
+                                Some(cargo[pkg].name.clone()),
                                cfg_options,
                                env,
                                proc_macro.clone(),
diff --git a/crates/ra_project_model/src/project_json.rs b/crates/ra_project_model/src/project_json.rs
index 4b5dcd634..b0fe09333 100644
--- a/crates/ra_project_model/src/project_json.rs
+++ b/crates/ra_project_model/src/project_json.rs
@@ -4,13 +4,13 @@ use std::path::PathBuf;
 use paths::{AbsPath, AbsPathBuf};
 use ra_cfg::CfgOptions;
-use ra_db::{CrateId, Dependency, Edition};
+use ra_db::{CrateId, CrateName, Dependency, Edition};
 use rustc_hash::FxHashSet;
-use serde::Deserialize;
+use serde::{de, Deserialize};
 use stdx::split_delim;
 /// Roots and crates that compose this Rust project.
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub struct ProjectJson {
    pub(crate) roots: Vec<Root>,
    pub(crate) crates: Vec<Crate>,
@@ -18,14 +18,14 @@ pub struct ProjectJson {
 /// A root points to the directory which contains Rust crates. rust-analyzer watches all files in
 /// all roots. Roots might be nested.
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub struct Root {
    pub(crate) path: AbsPathBuf,
 }
 /// A crate points to the root module of a crate and lists the dependencies of the crate. This is
 /// useful in creating the crate graph.
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub struct Crate {
    pub(crate) root_module: AbsPathBuf,
    pub(crate) edition: Edition,
@@ -50,7 +50,7 @@ impl ProjectJson {
                        .into_iter()
                        .map(|dep_data| Dependency {
                            crate_id: CrateId(dep_data.krate as u32),
-                            name: dep_data.name.into(),
+                            name: dep_data.name,
                        })
                        .collect::<Vec<_>>(),
                    cfg: {
@@ -113,5 +113,14 @@ struct DepData {
    /// Identifies a crate by position in the crates array.
    #[serde(rename = "crate")]
    krate: usize,
-    name: String,
+    #[serde(deserialize_with = "deserialize_crate_name")]
+    name: CrateName,
+}
+fn deserialize_crate_name<'de, D>(de: D) -> Result<CrateName, D::Error>
+where
+    D: de::Deserializer<'de>,
+{
+    let name = String::deserialize(de)?;
+    CrateName::new(&name).map_err(|err| de::Error::custom(format!("invalid crate name: {:?}", err)))
 }
diff --git a/crates/ra_ssr/Cargo.toml b/crates/ra_ssr/Cargo.toml
index 3c2f15a83..fe098aaee 100644
--- a/crates/ra_ssr/Cargo.toml
+++ b/crates/ra_ssr/Cargo.toml
@@ -17,3 +17,4 @@ ra_db = { path = "../ra_db" }
 ra_ide_db = { path = "../ra_ide_db" }
 hir = { path = "../ra_hir", package = "ra_hir" }
 rustc-hash = "1.1.0"
+test_utils = { path = "../test_utils" }
diff --git a/crates/ra_ssr/src/lib.rs b/crates/ra_ssr/src/lib.rs
index e148f4564..422e15ee6 100644
--- a/crates/ra_ssr/src/lib.rs
+++ b/crates/ra_ssr/src/lib.rs
@@ -9,10 +9,11 @@ mod replacing;
 #[cfg(test)]
 mod tests;
-use crate::matching::Match;
+pub use crate::matching::Match;
+use crate::matching::{record_match_fails_reasons_scope, MatchFailureReason};
 use hir::Semantics;
 use ra_db::{FileId, FileRange};
-use ra_syntax::{ast, AstNode, SmolStr, SyntaxNode};
+use ra_syntax::{ast, AstNode, SmolStr, SyntaxKind, SyntaxNode, TextRange};
 use ra_text_edit::TextEdit;
 use rustc_hash::FxHashMap;
@@ -26,7 +27,7 @@ pub struct SsrRule {
 }
 #[derive(Debug)]
-struct SsrPattern {
+pub struct SsrPattern {
    raw: parsing::RawSearchPattern,
    /// Placeholders keyed by the stand-in ident that we use in Rust source code.
    placeholders_by_stand_in: FxHashMap<SmolStr, parsing::Placeholder>,
@@ -45,7 +46,7 @@ pub struct SsrError(String);
 #[derive(Debug, Default)]
 pub struct SsrMatches {
-    matches: Vec<Match>,
+    pub matches: Vec<Match>,
 }
 /// Searches a crate for pattern matches and possibly replaces them with something else.
@@ -64,6 +65,12 @@ impl<'db> MatchFinder<'db> {
        self.rules.push(rule);
    }
+    /// Adds a search pattern. For use if you intend to only call `find_matches_in_file`. If you
+    /// intend to do replacement, use `add_rule` instead.
+    pub fn add_search_pattern(&mut self, pattern: SsrPattern) {
+        self.add_rule(SsrRule { pattern, template: "()".parse().unwrap() })
+    }
    pub fn edits_for_file(&self, file_id: FileId) -> Option<TextEdit> {
        let matches = self.find_matches_in_file(file_id);
        if matches.matches.is_empty() {
@@ -74,7 +81,7 @@ impl<'db> MatchFinder<'db> {
        }
    }
-    fn find_matches_in_file(&self, file_id: FileId) -> SsrMatches {
+    pub fn find_matches_in_file(&self, file_id: FileId) -> SsrMatches {
        let file = self.sema.parse(file_id);
        let code = file.syntax();
        let mut matches = SsrMatches::default();
@@ -82,6 +89,32 @@ impl<'db> MatchFinder<'db> {
        matches
    }
+    /// Finds all nodes in `file_id` whose text is exactly equal to `snippet` and attempts to match
+    /// them, while recording reasons why they don't match. This API is useful for command
+    /// line-based debugging where providing a range is difficult.
+    pub fn debug_where_text_equal(&self, file_id: FileId, snippet: &str) -> Vec<MatchDebugInfo> {
+        use ra_db::SourceDatabaseExt;
+        let file = self.sema.parse(file_id);
+        let mut res = Vec::new();
+        let file_text = self.sema.db.file_text(file_id);
+        let mut remaining_text = file_text.as_str();
+        let mut base = 0;
+        let len = snippet.len() as u32;
+        while let Some(offset) = remaining_text.find(snippet) {
+            let start = base + offset as u32;
+            let end = start + len;
+            self.output_debug_for_nodes_at_range(
+                file.syntax(),
+                FileRange { file_id, range: TextRange::new(start.into(), end.into()) },
+                &None,
+                &mut res,
+            );
+            remaining_text = &remaining_text[offset + snippet.len()..];
+            base = end;
+        }
+        res
+    }
    fn find_matches(
        &self,
        code: &SyntaxNode,
@@ -128,6 +161,59 @@ impl<'db> MatchFinder<'db> {
            self.find_matches(&child, restrict_range, matches_out);
        }
    }
+    fn output_debug_for_nodes_at_range(
+        &self,
+        node: &SyntaxNode,
+        range: FileRange,
+        restrict_range: &Option<FileRange>,
+        out: &mut Vec<MatchDebugInfo>,
+    ) {
+        for node in node.children() {
+            let node_range = self.sema.original_range(&node);
+            if node_range.file_id != range.file_id || !node_range.range.contains_range(range.range)
+            {
+                continue;
+            }
+            if node_range.range == range.range {
+                for rule in &self.rules {
+                    let pattern =
+                        rule.pattern.tree_for_kind_with_reason(node.kind()).map(|p| p.clone());
+                    out.push(MatchDebugInfo {
+                        matched: matching::get_match(true, rule, &node, restrict_range, &self.sema)
+                            .map_err(|e| MatchFailureReason {
+                                reason: e.reason.unwrap_or_else(|| {
+                                    "Match failed, but no reason was given".to_owned()
+                                }),
+                            }),
+                        pattern,
+                        node: node.clone(),
+                    });
+                }
+            } else if let Some(macro_call) = ast::MacroCall::cast(node.clone()) {
+                if let Some(expanded) = self.sema.expand(&macro_call) {
+                    if let Some(tt) = macro_call.token_tree() {
+                        self.output_debug_for_nodes_at_range(
+                            &expanded,
+                            range,
+                            &Some(self.sema.original_range(tt.syntax())),
+                            out,
+                        );
+                    }
+                }
+            } else {
+                self.output_debug_for_nodes_at_range(&node, range, restrict_range, out);
+            }
+        }
+    }
+}
+pub struct MatchDebugInfo {
+    node: SyntaxNode,
+    /// Our search pattern parsed as the same kind of syntax node as `node`. e.g. expression, item,
+    /// etc. Will be absent if the pattern can't be parsed as that kind.
+    pattern: Result<SyntaxNode, MatchFailureReason>,
+    matched: Result<Match, MatchFailureReason>,
 }
 impl std::fmt::Display for SsrError {
@@ -136,4 +222,70 @@ impl std::fmt::Display for SsrError {
    }
 }
+impl std::fmt::Debug for MatchDebugInfo {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "========= PATTERN ==========\n")?;
+        match &self.pattern {
+            Ok(pattern) => {
+                write!(f, "{:#?}", pattern)?;
+            }
+            Err(err) => {
+                write!(f, "{}", err.reason)?;
+            }
+        }
+        write!(
+            f,
+            "\n============ AST ===========\n\
+            {:#?}\n============================\n",
+            self.node
+        )?;
+        match &self.matched {
+            Ok(_) => write!(f, "Node matched")?,
+            Err(reason) => write!(f, "Node failed to match because: {}", reason.reason)?,
+        }
+        Ok(())
+    }
+}
+impl SsrPattern {
+    fn tree_for_kind_with_reason(
+        &self,
+        kind: SyntaxKind,
+    ) -> Result<&SyntaxNode, MatchFailureReason> {
+        record_match_fails_reasons_scope(true, || self.tree_for_kind(kind))
+            .map_err(|e| MatchFailureReason { reason: e.reason.unwrap() })
+    }
+}
+impl SsrMatches {
+    /// Returns `self` with any nested matches removed and made into top-level matches.
+    pub fn flattened(self) -> SsrMatches {
+        let mut out = SsrMatches::default();
+        self.flatten_into(&mut out);
+        out
+    }
+    fn flatten_into(self, out: &mut SsrMatches) {
+        for mut m in self.matches {
+            for p in m.placeholder_values.values_mut() {
+                std::mem::replace(&mut p.inner_matches, SsrMatches::default()).flatten_into(out);
+            }
+            out.matches.push(m);
+        }
+    }
+}
+impl Match {
+    pub fn matched_text(&self) -> String {
+        self.matched_node.text().to_string()
+    }
+}
 impl std::error::Error for SsrError {}
+#[cfg(test)]
+impl MatchDebugInfo {
+    pub(crate) fn match_failure_reason(&self) -> Option<&str> {
+        self.matched.as_ref().err().map(|r| r.reason.as_str())
+    }
+}
diff --git a/crates/ra_ssr/src/matching.rs b/crates/ra_ssr/src/matching.rs
index bb87bda43..ce53d46d2 100644
--- a/crates/ra_ssr/src/matching.rs
+++ b/crates/ra_ssr/src/matching.rs
@@ -2,17 +2,16 @@
 //! process of matching, placeholder values are recorded.
 use crate::{
-    parsing::{Placeholder, SsrTemplate},
+    parsing::{Constraint, NodeKind, Placeholder, SsrTemplate},
    SsrMatches, SsrPattern, SsrRule,
 };
 use hir::Semantics;
 use ra_db::FileRange;
 use ra_syntax::ast::{AstNode, AstToken};
-use ra_syntax::{
+use ra_syntax::{ast, SyntaxElement, SyntaxElementChildren, SyntaxKind, SyntaxNode, SyntaxToken};
-    ast, SyntaxElement, SyntaxElementChildren, SyntaxKind, SyntaxNode, SyntaxToken, TextRange,
-};
 use rustc_hash::FxHashMap;
 use std::{cell::Cell, iter::Peekable};
+use test_utils::mark;
 // Creates a match error. If we're currently attempting to match some code that we thought we were
 // going to match, as indicated by the --debug-snippet flag, then populate the reason field.
@@ -44,8 +43,8 @@ macro_rules! fail_match {
 /// Information about a match that was found.
 #[derive(Debug)]
-pub(crate) struct Match {
+pub struct Match {
-    pub(crate) range: TextRange,
+    pub(crate) range: FileRange,
    pub(crate) matched_node: SyntaxNode,
    pub(crate) placeholder_values: FxHashMap<Var, PlaceholderMatch>,
    pub(crate) ignored_comments: Vec<ast::Comment>,
@@ -135,7 +134,7 @@ impl<'db, 'sema> MatchState<'db, 'sema> {
        match_state.attempt_match_node(&match_inputs, &pattern_tree, code)?;
        match_state.validate_range(&sema.original_range(code))?;
        match_state.match_out = Some(Match {
-            range: sema.original_range(code).range,
+            range: sema.original_range(code),
            matched_node: code.clone(),
            placeholder_values: FxHashMap::default(),
            ignored_comments: Vec::new(),
@@ -171,6 +170,9 @@ impl<'db, 'sema> MatchState<'db, 'sema> {
        if let Some(placeholder) =
            match_inputs.get_placeholder(&SyntaxElement::Node(pattern.clone()))
        {
+            for constraint in &placeholder.constraints {
+                self.check_constraint(constraint, code)?;
+            }
            if self.match_out.is_none() {
                return Ok(());
            }
@@ -225,7 +227,7 @@ impl<'db, 'sema> MatchState<'db, 'sema> {
            match self.next_non_trivial(&mut code_it) {
                None => {
                    if let Some(p) = pattern_it.next() {
-                        fail_match!("Part of the pattern was unmached: {:?}", p);
+                        fail_match!("Part of the pattern was unmatched: {:?}", p);
                    }
                    return Ok(());
                }
@@ -294,6 +296,24 @@ impl<'db, 'sema> MatchState<'db, 'sema> {
        Ok(())
    }
+    fn check_constraint(
+        &self,
+        constraint: &Constraint,
+        code: &SyntaxNode,
+    ) -> Result<(), MatchFailed> {
+        match constraint {
+            Constraint::Kind(kind) => {
+                kind.matches(code)?;
+            }
+            Constraint::Not(sub) => {
+                if self.check_constraint(&*sub, code).is_ok() {
+                    fail_match!("Constraint {:?} failed for '{}'", constraint, code.text());
+                }
+            }
+        }
+        Ok(())
+    }
    /// We want to allow the records to match in any order, so we have special matching logic for
    /// them.
    fn attempt_match_record_field_list(
@@ -517,6 +537,21 @@ impl SsrPattern {
    }
 }
+impl NodeKind {
+    fn matches(&self, node: &SyntaxNode) -> Result<(), MatchFailed> {
+        let ok = match self {
+            Self::Literal => {
+                mark::hit!(literal_constraint);
+                ast::Literal::can_cast(node.kind())
+            }
+        };
+        if !ok {
+            fail_match!("Code '{}' isn't of kind {:?}", node.text(), self);
+        }
+        Ok(())
+    }
+}
 // If `node` contains nothing but an ident then return it, otherwise return None.
 fn only_ident(element: SyntaxElement) -> Option<SyntaxToken> {
    match element {
diff --git a/crates/ra_ssr/src/parsing.rs b/crates/ra_ssr/src/parsing.rs
index 1ae166d19..5ea125616 100644
--- a/crates/ra_ssr/src/parsing.rs
+++ b/crates/ra_ssr/src/parsing.rs
@@ -6,7 +6,7 @@
 //! e.g. expressions, type references etc.
 use crate::{SsrError, SsrPattern, SsrRule};
-use ra_syntax::{ast, AstNode, SmolStr, SyntaxKind};
+use ra_syntax::{ast, AstNode, SmolStr, SyntaxKind, T};
 use rustc_hash::{FxHashMap, FxHashSet};
 use std::str::FromStr;
@@ -39,6 +39,18 @@ pub(crate) struct Placeholder {
    pub(crate) ident: SmolStr,
    /// A unique name used in place of this placeholder when we parse the pattern as Rust code.
    stand_in_name: String,
+    pub(crate) constraints: Vec<Constraint>,
+}
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) enum Constraint {
+    Kind(NodeKind),
+    Not(Box<Constraint>),
+}
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) enum NodeKind {
+    Literal,
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -55,7 +67,7 @@ impl FromStr for SsrRule {
        let pattern = it.next().expect("at least empty string").trim();
        let template = it
            .next()
-            .ok_or_else(|| SsrError("Cannot find delemiter `==>>`".into()))?
+            .ok_or_else(|| SsrError("Cannot find delimiter `==>>`".into()))?
            .trim()
            .to_string();
        if it.next().is_some() {
@@ -149,7 +161,7 @@ fn parse_pattern(pattern_str: &str) -> Result<Vec<PatternElement>, SsrError> {
    let mut placeholder_names = FxHashSet::default();
    let mut tokens = tokenize(pattern_str)?.into_iter();
    while let Some(token) = tokens.next() {
-        if token.kind == SyntaxKind::DOLLAR {
+        if token.kind == T![$] {
            let placeholder = parse_placeholder(&mut tokens)?;
            if !placeholder_names.insert(placeholder.ident.clone()) {
                bail!("Name `{}` repeats more than once", placeholder.ident);
@@ -177,6 +189,9 @@ fn validate_rule(rule: &SsrRule) -> Result<(), SsrError> {
            if !defined_placeholders.contains(&placeholder.ident) {
                undefined.push(format!("${}", placeholder.ident));
            }
+            if !placeholder.constraints.is_empty() {
+                bail!("Replacement placeholders cannot have constraints");
+            }
        }
    }
    if !undefined.is_empty() {
@@ -205,23 +220,90 @@ fn tokenize(source: &str) -> Result<Vec<Token>, SsrError> {
 fn parse_placeholder(tokens: &mut std::vec::IntoIter<Token>) -> Result<Placeholder, SsrError> {
    let mut name = None;
+    let mut constraints = Vec::new();
    if let Some(token) = tokens.next() {
        match token.kind {
            SyntaxKind::IDENT => {
                name = Some(token.text);
            }
+            T!['{'] => {
+                let token =
+                    tokens.next().ok_or_else(|| SsrError::new("Unexpected end of placeholder"))?;
+                if token.kind == SyntaxKind::IDENT {
+                    name = Some(token.text);
+                }
+                loop {
+                    let token = tokens
+                        .next()
+                        .ok_or_else(|| SsrError::new("Placeholder is missing closing brace '}'"))?;
+                    match token.kind {
+                        T![:] => {
+                            constraints.push(parse_constraint(tokens)?);
+                        }
+                        T!['}'] => break,
+                        _ => bail!("Unexpected token while parsing placeholder: '{}'", token.text),
+                    }
+                }
+            }
            _ => {
-                bail!("Placeholders should be $name");
+                bail!("Placeholders should either be $name or ${name:constraints}");
            }
        }
    }
    let name = name.ok_or_else(|| SsrError::new("Placeholder ($) with no name"))?;
-    Ok(Placeholder::new(name))
+    Ok(Placeholder::new(name, constraints))
+}
+fn parse_constraint(tokens: &mut std::vec::IntoIter<Token>) -> Result<Constraint, SsrError> {
+    let constraint_type = tokens
+        .next()
+        .ok_or_else(|| SsrError::new("Found end of placeholder while looking for a constraint"))?
+        .text
+        .to_string();
+    match constraint_type.as_str() {
+        "kind" => {
+            expect_token(tokens, "(")?;
+            let t = tokens.next().ok_or_else(|| {
+                SsrError::new("Unexpected end of constraint while looking for kind")
+            })?;
+            if t.kind != SyntaxKind::IDENT {
+                bail!("Expected ident, found {:?} while parsing kind constraint", t.kind);
+            }
+            expect_token(tokens, ")")?;
+            Ok(Constraint::Kind(NodeKind::from(&t.text)?))
+        }
+        "not" => {
+            expect_token(tokens, "(")?;
+            let sub = parse_constraint(tokens)?;
+            expect_token(tokens, ")")?;
+            Ok(Constraint::Not(Box::new(sub)))
+        }
+        x => bail!("Unsupported constraint type '{}'", x),
+    }
+}
+fn expect_token(tokens: &mut std::vec::IntoIter<Token>, expected: &str) -> Result<(), SsrError> {
+    if let Some(t) = tokens.next() {
+        if t.text == expected {
+            return Ok(());
+        }
+        bail!("Expected {} found {}", expected, t.text);
+    }
+    bail!("Expected {} found end of stream");
+}
+impl NodeKind {
+    fn from(name: &SmolStr) -> Result<NodeKind, SsrError> {
+        Ok(match name.as_str() {
+            "literal" => NodeKind::Literal,
+            _ => bail!("Unknown node kind '{}'", name),
+        })
+    }
 }
 impl Placeholder {
-    fn new(name: SmolStr) -> Self {
+    fn new(name: SmolStr, constraints: Vec<Constraint>) -> Self {
-        Self { stand_in_name: format!("__placeholder_{}", name), ident: name }
+        Self { stand_in_name: format!("__placeholder_{}", name), constraints, ident: name }
    }
 }
@@ -241,31 +323,31 @@ mod tests {
            PatternElement::Token(Token { kind, text: SmolStr::new(text) })
        }
        fn placeholder(name: &str) -> PatternElement {
-            PatternElement::Placeholder(Placeholder::new(SmolStr::new(name)))
+            PatternElement::Placeholder(Placeholder::new(SmolStr::new(name), Vec::new()))
        }
        let result: SsrRule = "foo($a, $b) ==>> bar($b, $a)".parse().unwrap();
        assert_eq!(
            result.pattern.raw.tokens,
            vec![
                token(SyntaxKind::IDENT, "foo"),
-                token(SyntaxKind::L_PAREN, "("),
+                token(T!['('], "("),
                placeholder("a"),
-                token(SyntaxKind::COMMA, ","),
+                token(T![,], ","),
                token(SyntaxKind::WHITESPACE, " "),
                placeholder("b"),
-                token(SyntaxKind::R_PAREN, ")"),
+                token(T![')'], ")"),
            ]
        );
        assert_eq!(
            result.template.tokens,
            vec![
                token(SyntaxKind::IDENT, "bar"),
-                token(SyntaxKind::L_PAREN, "("),
+                token(T!['('], "("),
                placeholder("b"),
-                token(SyntaxKind::COMMA, ","),
+                token(T![,], ","),
                token(SyntaxKind::WHITESPACE, " "),
                placeholder("a"),
-                token(SyntaxKind::R_PAREN, ")"),
+                token(T![')'], ")"),
            ]
        );
    }
diff --git a/crates/ra_ssr/src/replacing.rs b/crates/ra_ssr/src/replacing.rs
index 70ce1c185..e43cc5167 100644
--- a/crates/ra_ssr/src/replacing.rs
+++ b/crates/ra_ssr/src/replacing.rs
@@ -21,8 +21,10 @@ fn matches_to_edit_at_offset(
 ) -> TextEdit {
    let mut edit_builder = ra_text_edit::TextEditBuilder::default();
    for m in &matches.matches {
-        edit_builder
+        edit_builder.replace(
-            .replace(m.range.checked_sub(relative_start).unwrap(), render_replace(m, file_src));
+            m.range.range.checked_sub(relative_start).unwrap(),
+            render_replace(m, file_src),
+        );
    }
    edit_builder.finish()
 }
diff --git a/crates/ra_ssr/src/tests.rs b/crates/ra_ssr/src/tests.rs
index 8be60c293..9568d4432 100644
--- a/crates/ra_ssr/src/tests.rs
+++ b/crates/ra_ssr/src/tests.rs
@@ -1,150 +1,6 @@
-use crate::matching::MatchFailureReason;
+use crate::{MatchFinder, SsrRule};
-use crate::{matching, Match, MatchFinder, SsrMatches, SsrPattern, SsrRule};
+use ra_db::{FileId, SourceDatabaseExt};
-use matching::record_match_fails_reasons_scope;
+use test_utils::mark;
-use ra_db::{FileId, FileRange, SourceDatabaseExt};
-use ra_syntax::ast::AstNode;
-use ra_syntax::{ast, SyntaxKind, SyntaxNode, TextRange};
-struct MatchDebugInfo {
-    node: SyntaxNode,
-    /// Our search pattern parsed as the same kind of syntax node as `node`. e.g. expression, item,
-    /// etc. Will be absent if the pattern can't be parsed as that kind.
-    pattern: Result<SyntaxNode, MatchFailureReason>,
-    matched: Result<Match, MatchFailureReason>,
-}
-impl SsrPattern {
-    pub(crate) fn tree_for_kind_with_reason(
-        &self,
-        kind: SyntaxKind,
-    ) -> Result<&SyntaxNode, MatchFailureReason> {
-        record_match_fails_reasons_scope(true, || self.tree_for_kind(kind))
-            .map_err(|e| MatchFailureReason { reason: e.reason.unwrap() })
-    }
-}
-impl std::fmt::Debug for MatchDebugInfo {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "========= PATTERN ==========\n")?;
-        match &self.pattern {
-            Ok(pattern) => {
-                write!(f, "{:#?}", pattern)?;
-            }
-            Err(err) => {
-                write!(f, "{}", err.reason)?;
-            }
-        }
-        write!(
-            f,
-            "\n============ AST ===========\n\
-            {:#?}\n============================",
-            self.node
-        )?;
-        match &self.matched {
-            Ok(_) => write!(f, "Node matched")?,
-            Err(reason) => write!(f, "Node failed to match because: {}", reason.reason)?,
-        }
-        Ok(())
-    }
-}
-impl SsrMatches {
-    /// Returns `self` with any nested matches removed and made into top-level matches.
-    pub(crate) fn flattened(self) -> SsrMatches {
-        let mut out = SsrMatches::default();
-        self.flatten_into(&mut out);
-        out
-    }
-    fn flatten_into(self, out: &mut SsrMatches) {
-        for mut m in self.matches {
-            for p in m.placeholder_values.values_mut() {
-                std::mem::replace(&mut p.inner_matches, SsrMatches::default()).flatten_into(out);
-            }
-            out.matches.push(m);
-        }
-    }
-}
-impl Match {
-    pub(crate) fn matched_text(&self) -> String {
-        self.matched_node.text().to_string()
-    }
-}
-impl<'db> MatchFinder<'db> {
-    /// Adds a search pattern. For use if you intend to only call `find_matches_in_file`. If you
-    /// intend to do replacement, use `add_rule` instead.
-    fn add_search_pattern(&mut self, pattern: SsrPattern) {
-        self.add_rule(SsrRule { pattern, template: "()".parse().unwrap() })
-    }
-    /// Finds all nodes in `file_id` whose text is exactly equal to `snippet` and attempts to match
-    /// them, while recording reasons why they don't match. This API is useful for command
-    /// line-based debugging where providing a range is difficult.
-    fn debug_where_text_equal(&self, file_id: FileId, snippet: &str) -> Vec<MatchDebugInfo> {
-        let file = self.sema.parse(file_id);
-        let mut res = Vec::new();
-        let file_text = self.sema.db.file_text(file_id);
-        let mut remaining_text = file_text.as_str();
-        let mut base = 0;
-        let len = snippet.len() as u32;
-        while let Some(offset) = remaining_text.find(snippet) {
-            let start = base + offset as u32;
-            let end = start + len;
-            self.output_debug_for_nodes_at_range(
-                file.syntax(),
-                TextRange::new(start.into(), end.into()),
-                &None,
-                &mut res,
-            );
-            remaining_text = &remaining_text[offset + snippet.len()..];
-            base = end;
-        }
-        res
-    }
-    fn output_debug_for_nodes_at_range(
-        &self,
-        node: &SyntaxNode,
-        range: TextRange,
-        restrict_range: &Option<FileRange>,
-        out: &mut Vec<MatchDebugInfo>,
-    ) {
-        for node in node.children() {
-            if !node.text_range().contains_range(range) {
-                continue;
-            }
-            if node.text_range() == range {
-                for rule in &self.rules {
-                    let pattern =
-                        rule.pattern.tree_for_kind_with_reason(node.kind()).map(|p| p.clone());
-                    out.push(MatchDebugInfo {
-                        matched: matching::get_match(true, rule, &node, restrict_range, &self.sema)
-                            .map_err(|e| MatchFailureReason {
-                                reason: e.reason.unwrap_or_else(|| {
-                                    "Match failed, but no reason was given".to_owned()
-                                }),
-                            }),
-                        pattern,
-                        node: node.clone(),
-                    });
-                }
-            } else if let Some(macro_call) = ast::MacroCall::cast(node.clone()) {
-                if let Some(expanded) = self.sema.expand(&macro_call) {
-                    if let Some(tt) = macro_call.token_tree() {
-                        self.output_debug_for_nodes_at_range(
-                            &expanded,
-                            range,
-                            &Some(self.sema.original_range(tt.syntax())),
-                            out,
-                        );
-                    }
-                }
-            }
-        }
-    }
-}
 fn parse_error_text(query: &str) -> String {
    format!("{}", query.parse::<SsrRule>().unwrap_err())
@@ -152,12 +8,12 @@ fn parse_error_text(query: &str) -> String {
 #[test]
 fn parser_empty_query() {
-    assert_eq!(parse_error_text(""), "Parse error: Cannot find delemiter `==>>`");
+    assert_eq!(parse_error_text(""), "Parse error: Cannot find delimiter `==>>`");
 }
 #[test]
 fn parser_no_delimiter() {
-    assert_eq!(parse_error_text("foo()"), "Parse error: Cannot find delemiter `==>>`");
+    assert_eq!(parse_error_text("foo()"), "Parse error: Cannot find delimiter `==>>`");
 }
 #[test]
@@ -227,7 +83,7 @@ fn assert_ssr_transforms(rules: &[&str], input: &str, result: &str) {
        let mut after = db.file_text(file_id).to_string();
        edits.apply(&mut after);
        // Likewise, we need to make sure that whatever transformations fixture parsing applies,
-        // also get appplied to our expected result.
+        // also get applied to our expected result.
        let result = normalize_code(result);
        assert_eq!(after, result);
    } else {
@@ -260,6 +116,19 @@ fn assert_no_match(pattern: &str, code: &str) {
    assert_matches(pattern, code, &[]);
 }
+fn assert_match_failure_reason(pattern: &str, code: &str, snippet: &str, expected_reason: &str) {
+    let (db, file_id) = single_file(code);
+    let mut match_finder = MatchFinder::new(&db);
+    match_finder.add_search_pattern(pattern.parse().unwrap());
+    let mut reasons = Vec::new();
+    for d in match_finder.debug_where_text_equal(file_id, snippet) {
+        if let Some(reason) = d.match_failure_reason() {
+            reasons.push(reason.to_owned());
+        }
+    }
+    assert_eq!(reasons, vec![expected_reason]);
+}
 #[test]
 fn ssr_function_to_method() {
    assert_ssr_transform(
@@ -434,6 +303,22 @@ fn match_pattern() {
 }
 #[test]
+fn literal_constraint() {
+    mark::check!(literal_constraint);
+    let code = r#"
+        fn f1() {
+            let x1 = Some(42);
+            let x2 = Some("foo");
+            let x3 = Some(x1);
+            let x4 = Some(40 + 2);
+            let x5 = Some(true);
+        }
+        "#;
+    assert_matches("Some(${a:kind(literal)})", code, &["Some(42)", "Some(\"foo\")", "Some(true)"]);
+    assert_matches("Some(${a:not(kind(literal))})", code, &["Some(x1)", "Some(40 + 2)"]);
+}
+#[test]
 fn match_reordered_struct_instantiation() {
    assert_matches(
        "Foo {aa: 1, b: 2, ccc: 3}",
@@ -623,3 +508,30 @@ fn preserves_whitespace_within_macro_expansion() {
            fn f() {macro1!(4 - 3 - 1   *   2}"#,
    )
 }
+#[test]
+fn match_failure_reasons() {
+    let code = r#"
+        macro_rules! foo {
+            ($a:expr) => {
+                1 + $a + 2
+            };
+        }
+        fn f1() {
+            bar(1, 2);
+            foo!(5 + 43.to_string() + 5);
+        }
+        "#;
+    assert_match_failure_reason(
+        "bar($a, 3)",
+        code,
+        "bar(1, 2)",
+        r#"Pattern wanted token '3' (INT_NUMBER), but code had token '2' (INT_NUMBER)"#,
+    );
+    assert_match_failure_reason(
+        "42.to_string()",
+        code,
+        "43.to_string()",
+        r#"Pattern wanted token '42' (INT_NUMBER), but code had token '43' (INT_NUMBER)"#,
+    );
+}
diff --git a/crates/ra_syntax/src/tests.rs b/crates/ra_syntax/src/tests.rs
index 959967b79..7b4232497 100644
--- a/crates/ra_syntax/src/tests.rs
+++ b/crates/ra_syntax/src/tests.rs
@@ -1,9 +1,11 @@
 use std::{
+    env,
    fmt::Write,
+    fs,
    path::{Component, Path, PathBuf},
 };
-use test_utils::{collect_rust_files, dir_tests, project_dir, read_text};
+use test_utils::{assert_eq_text, project_dir};
 use crate::{fuzz, tokenize, SourceFile, SyntaxError, TextRange, TextSize, Token};
@@ -200,3 +202,99 @@ where
        }
    });
 }
+/// Calls callback `f` with input code and file paths for each `.rs` file in `test_data_dir`
+/// subdirectories defined by `paths`.
+///
+/// If the content of the matching output file differs from the output of `f()`
+/// the test will fail.
+///
+/// If there is no matching output file it will be created and filled with the
+/// output of `f()`, but the test will fail.
+fn dir_tests<F>(test_data_dir: &Path, paths: &[&str], outfile_extension: &str, f: F)
+where
+    F: Fn(&str, &Path) -> String,
+{
+    for (path, input_code) in collect_rust_files(test_data_dir, paths) {
+        let actual = f(&input_code, &path);
+        let path = path.with_extension(outfile_extension);
+        if !path.exists() {
+            println!("\nfile: {}", path.display());
+            println!("No .txt file with expected result, creating...\n");
+            println!("{}\n{}", input_code, actual);
+            fs::write(&path, &actual).unwrap();
+            panic!("No expected result");
+        }
+        let expected = read_text(&path);
+        assert_equal_text(&expected, &actual, &path);
+    }
+}
+/// Collects all `.rs` files from `dir` subdirectories defined by `paths`.
+fn collect_rust_files(root_dir: &Path, paths: &[&str]) -> Vec<(PathBuf, String)> {
+    paths
+        .iter()
+        .flat_map(|path| {
+            let path = root_dir.to_owned().join(path);
+            rust_files_in_dir(&path).into_iter()
+        })
+        .map(|path| {
+            let text = read_text(&path);
+            (path, text)
+        })
+        .collect()
+}
+/// Collects paths to all `.rs` files from `dir` in a sorted `Vec<PathBuf>`.
+fn rust_files_in_dir(dir: &Path) -> Vec<PathBuf> {
+    let mut acc = Vec::new();
+    for file in fs::read_dir(&dir).unwrap() {
+        let file = file.unwrap();
+        let path = file.path();
+        if path.extension().unwrap_or_default() == "rs" {
+            acc.push(path);
+        }
+    }
+    acc.sort();
+    acc
+}
+/// Asserts that `expected` and `actual` strings are equal. If they differ only
+/// in trailing or leading whitespace the test won't fail and
+/// the contents of `actual` will be written to the file located at `path`.
+fn assert_equal_text(expected: &str, actual: &str, path: &Path) {
+    if expected == actual {
+        return;
+    }
+    let dir = project_dir();
+    let pretty_path = path.strip_prefix(&dir).unwrap_or_else(|_| path);
+    if expected.trim() == actual.trim() {
+        println!("whitespace difference, rewriting");
+        println!("file: {}\n", pretty_path.display());
+        fs::write(path, actual).unwrap();
+        return;
+    }
+    if env::var("UPDATE_EXPECT").is_ok() {
+        println!("rewriting {}", pretty_path.display());
+        fs::write(path, actual).unwrap();
+        return;
+    }
+    assert_eq_text!(expected, actual, "file: {}", pretty_path.display());
+}
+/// Read file and normalize newlines.
+///
+/// `rustc` seems to always normalize `\r\n` newlines to `\n`:
+///
+/// ```
+/// let s = "
+/// ";
+/// assert_eq!(s.as_bytes(), &[10]);
+/// ```
+///
+/// so this should always be correct.
+fn read_text(path: &Path) -> String {
+    fs::read_to_string(path)
+        .unwrap_or_else(|_| panic!("File at {:?} should be valid", path))
+        .replace("\r\n", "\n")
+}
diff --git a/crates/rust-analyzer/Cargo.toml b/crates/rust-analyzer/Cargo.toml
index 53621fb44..837b6714d 100644
--- a/crates/rust-analyzer/Cargo.toml
+++ b/crates/rust-analyzer/Cargo.toml
@@ -28,6 +28,7 @@ rustc-hash = "1.1.0"
 serde = { version = "1.0.106", features = ["derive"] }
 serde_json = "1.0.48"
 threadpool = "1.7.1"
+rayon = "1.3.1"
 stdx = { path = "../stdx" }
@@ -45,6 +46,8 @@ ra_toolchain = { path = "../ra_toolchain" }
 # This should only be used in CLI
 ra_db = { path = "../ra_db" }
+ra_ide_db = { path = "../ra_ide_db" }
+ra_ssr = { path = "../ra_ssr" }
 hir = { path = "../ra_hir", package = "ra_hir" }
 hir_def = { path = "../ra_hir_def", package = "ra_hir_def" }
 hir_ty = { path = "../ra_hir_ty", package = "ra_hir_ty" }
diff --git a/crates/rust-analyzer/src/bin/args.rs b/crates/rust-analyzer/src/bin/args.rs
index 8e3ca9343..8c0f4df8b 100644
--- a/crates/rust-analyzer/src/bin/args.rs
+++ b/crates/rust-analyzer/src/bin/args.rs
@@ -5,6 +5,7 @@
 use anyhow::{bail, Result};
 use pico_args::Arguments;
+use ra_ssr::{SsrPattern, SsrRule};
 use rust_analyzer::cli::{BenchWhat, Position, Verbosity};
 use std::{fmt::Write, path::PathBuf};
@@ -24,6 +25,7 @@ pub(crate) enum Command {
    },
    Stats {
        randomize: bool,
+        parallel: bool,
        memory_usage: bool,
        only: Option<String>,
        with_deps: bool,
@@ -45,6 +47,13 @@ pub(crate) enum Command {
        /// this would include the parser test files.
        all: bool,
    },
+    Ssr {
+        rules: Vec<SsrRule>,
+    },
+    StructuredSearch {
+        debug_snippet: Option<String>,
+        patterns: Vec<SsrPattern>,
+    },
    ProcMacro,
    RunServer,
    Version,
@@ -94,7 +103,7 @@ USAGE:
    rust-analyzer parse [FLAGS]
 FLAGS:
-    -h, --help       Prints help inforamtion
+    -h, --help       Prints help information
        --no-dump"
                    );
                    return Ok(Err(HelpPrinted));
@@ -153,10 +162,14 @@ USAGE:
    rust-analyzer analysis-stats [FLAGS] [OPTIONS] [PATH]
 FLAGS:
+    -o, --only              Only analyze items matching this path
    -h, --help              Prints help information
-        --memory-usage
+        --memory-usage      Collect memory usage statistics (requires `--feature jemalloc`)
+        --randomize         Randomize order in which crates, modules, and items are processed
+        --parallel          Run type inference in parallel
        --load-output-dirs  Load OUT_DIR values by running `cargo check` before analysis
-        --with-proc-macro    Use ra-proc-macro-srv for proc-macro expanding
+        --with-proc-macro   Use ra-proc-macro-srv for proc-macro expanding
+        --with-deps         Also analyze all dependencies
    -v, --verbose
    -q, --quiet
@@ -170,6 +183,7 @@ ARGS:
                }
                let randomize = matches.contains("--randomize");
+                let parallel = matches.contains("--parallel");
                let memory_usage = matches.contains("--memory-usage");
                let only: Option<String> = matches.opt_value_from_str(["-o", "--only"])?;
                let with_deps: bool = matches.contains("--with-deps");
@@ -185,6 +199,7 @@ ARGS:
                Command::Stats {
                    randomize,
+                    parallel,
                    memory_usage,
                    only,
                    with_deps,
@@ -205,7 +220,7 @@ USAGE:
 FLAGS:
    -h, --help          Prints help information
    --load-output-dirs  Load OUT_DIR values by running `cargo check` before analysis
-    --with-proc-macro    Use ra-proc-macro-srv for proc-macro expanding
+    --with-proc-macro   Use ra-proc-macro-srv for proc-macro expanding
    -v, --verbose
 OPTIONS:
@@ -270,6 +285,61 @@ ARGS:
                Command::Diagnostics { path, load_output_dirs, with_proc_macro, all }
            }
            "proc-macro" => Command::ProcMacro,
+            "ssr" => {
+                if matches.contains(["-h", "--help"]) {
+                    eprintln!(
+                        "\
+rust-analyzer ssr
+USAGE:
+    rust-analyzer ssr [FLAGS] [RULE...]
+EXAMPLE:
+    rust-analyzer ssr '$a.foo($b) ==> bar($a, $b)'
+FLAGS:
+    --debug <snippet>   Prints debug information for any nodes with source exactly equal to <snippet>
+    -h, --help          Prints help information
+ARGS:
+    <RULE>              A structured search replace rule"
+                    );
+                    return Ok(Err(HelpPrinted));
+                }
+                let mut rules = Vec::new();
+                while let Some(rule) = matches.free_from_str()? {
+                    rules.push(rule);
+                }
+                Command::Ssr { rules }
+            }
+            "search" => {
+                if matches.contains(["-h", "--help"]) {
+                    eprintln!(
+                        "\
+rust-analyzer search
+USAGE:
+    rust-analyzer search [FLAGS] [PATTERN...]
+EXAMPLE:
+    rust-analyzer search '$a.foo($b)'
+FLAGS:
+    --debug <snippet>   Prints debug information for any nodes with source exactly equal to <snippet>
+    -h, --help          Prints help information
+ARGS:
+    <PATTERN>           A structured search pattern"
+                    );
+                    return Ok(Err(HelpPrinted));
+                }
+                let debug_snippet = matches.opt_value_from_str("--debug")?;
+                let mut patterns = Vec::new();
+                while let Some(rule) = matches.free_from_str()? {
+                    patterns.push(rule);
+                }
+                Command::StructuredSearch { patterns, debug_snippet }
+            }
            _ => {
                print_subcommands();
                return Ok(Err(HelpPrinted));
@@ -297,6 +367,8 @@ SUBCOMMANDS:
    diagnostics
    proc-macro
    parse
+    search
+    ssr
    symbols"
    )
 }
diff --git a/crates/rust-analyzer/src/bin/main.rs b/crates/rust-analyzer/src/bin/main.rs
index 45204d1a3..eec76d415 100644
--- a/crates/rust-analyzer/src/bin/main.rs
+++ b/crates/rust-analyzer/src/bin/main.rs
@@ -32,6 +32,7 @@ fn main() -> Result<()> {
        args::Command::Highlight { rainbow } => cli::highlight(rainbow)?,
        args::Command::Stats {
            randomize,
+            parallel,
            memory_usage,
            only,
            with_deps,
@@ -45,6 +46,7 @@ fn main() -> Result<()> {
            only.as_ref().map(String::as_ref),
            with_deps,
            randomize,
+            parallel,
            load_output_dirs,
            with_proc_macro,
        )?,
@@ -60,6 +62,12 @@ fn main() -> Result<()> {
        args::Command::Diagnostics { path, load_output_dirs, with_proc_macro, all } => {
            cli::diagnostics(path.as_ref(), load_output_dirs, with_proc_macro, all)?
        }
+        args::Command::Ssr { rules } => {
+            cli::apply_ssr_rules(rules)?;
+        }
+        args::Command::StructuredSearch { patterns, debug_snippet } => {
+            cli::search_for_patterns(patterns, debug_snippet)?;
+        }
        args::Command::Version => println!("rust-analyzer {}", env!("REV")),
    }
    Ok(())
diff --git a/crates/rust-analyzer/src/cli.rs b/crates/rust-analyzer/src/cli.rs
index c5faec83a..6863f100b 100644
--- a/crates/rust-analyzer/src/cli.rs
+++ b/crates/rust-analyzer/src/cli.rs
@@ -5,6 +5,7 @@ mod analysis_stats;
 mod analysis_bench;
 mod diagnostics;
 mod progress_report;
+mod ssr;
 use std::io::Read;
@@ -17,6 +18,7 @@ pub use analysis_bench::{analysis_bench, BenchWhat, Position};
 pub use analysis_stats::analysis_stats;
 pub use diagnostics::diagnostics;
 pub use load_cargo::load_cargo;
+pub use ssr::{apply_ssr_rules, search_for_patterns};
 #[derive(Clone, Copy)]
 pub enum Verbosity {
diff --git a/crates/rust-analyzer/src/cli/analysis_stats.rs b/crates/rust-analyzer/src/cli/analysis_stats.rs
index 9d09501cd..14982919d 100644
--- a/crates/rust-analyzer/src/cli/analysis_stats.rs
+++ b/crates/rust-analyzer/src/cli/analysis_stats.rs
@@ -5,6 +5,7 @@ use std::{path::Path, time::Instant};
 use itertools::Itertools;
 use rand::{seq::SliceRandom, thread_rng};
+use rayon::prelude::*;
 use rustc_hash::FxHashSet;
 use hir::{
@@ -13,12 +14,23 @@ use hir::{
 };
 use hir_def::FunctionId;
 use hir_ty::{Ty, TypeWalk};
-use ra_db::SourceDatabaseExt;
+use ra_db::{
+    salsa::{self, ParallelDatabase},
+    SourceDatabaseExt,
+};
 use ra_syntax::AstNode;
 use stdx::format_to;
 use crate::cli::{load_cargo::load_cargo, progress_report::ProgressReport, Result, Verbosity};
+/// Need to wrap Snapshot to provide `Clone` impl for `map_with`
+struct Snap<DB>(DB);
+impl<DB: ParallelDatabase> Clone for Snap<salsa::Snapshot<DB>> {
+    fn clone(&self) -> Snap<salsa::Snapshot<DB>> {
+        Snap(self.0.snapshot())
+    }
+}
 pub fn analysis_stats(
    verbosity: Verbosity,
    memory_usage: bool,
@@ -26,6 +38,7 @@ pub fn analysis_stats(
    only: Option<&str>,
    with_deps: bool,
    randomize: bool,
+    parallel: bool,
    load_output_dirs: bool,
    with_proc_macro: bool,
 ) -> Result<()> {
@@ -91,12 +104,26 @@ pub fn analysis_stats(
        funcs.shuffle(&mut thread_rng());
    }
-    let inference_time = Instant::now();
    let mut bar = match verbosity {
        Verbosity::Quiet | Verbosity::Spammy => ProgressReport::hidden(),
        _ => ProgressReport::new(funcs.len() as u64),
    };
+    if parallel {
+        let inference_time = Instant::now();
+        let snap = Snap(db.snapshot());
+        funcs
+            .par_iter()
+            .map_with(snap, |snap, &f| {
+                let f_id = FunctionId::from(f);
+                snap.0.body(f_id.into());
+                snap.0.infer(f_id.into());
+            })
+            .count();
+        println!("Parallel Inference: {:?}, {}", inference_time.elapsed(), ra_prof::memory_usage());
+    }
+    let inference_time = Instant::now();
    bar.tick();
    let mut num_exprs = 0;
    let mut num_exprs_unknown = 0;
diff --git a/crates/rust-analyzer/src/cli/ssr.rs b/crates/rust-analyzer/src/cli/ssr.rs
new file mode 100644
index 000000000..4fb829ea5
--- /dev/null
+++ b/crates/rust-analyzer/src/cli/ssr.rs
@@ -0,0 +1,71 @@
+//! Applies structured search replace rules from the command line.
+use crate::cli::{load_cargo::load_cargo, Result};
+use ra_ide::SourceFileEdit;
+use ra_ssr::{MatchFinder, SsrPattern, SsrRule};
+pub fn apply_ssr_rules(rules: Vec<SsrRule>) -> Result<()> {
+    use ra_db::SourceDatabaseExt;
+    use ra_ide_db::symbol_index::SymbolsDatabase;
+    let (host, vfs) = load_cargo(&std::env::current_dir()?, true, true)?;
+    let db = host.raw_database();
+    let mut match_finder = MatchFinder::new(db);
+    for rule in rules {
+        match_finder.add_rule(rule);
+    }
+    let mut edits = Vec::new();
+    for &root in db.local_roots().iter() {
+        let sr = db.source_root(root);
+        for file_id in sr.iter() {
+            if let Some(edit) = match_finder.edits_for_file(file_id) {
+                edits.push(SourceFileEdit { file_id, edit });
+            }
+        }
+    }
+    for edit in edits {
+        if let Some(path) = vfs.file_path(edit.file_id).as_path() {
+            let mut contents = db.file_text(edit.file_id).to_string();
+            edit.edit.apply(&mut contents);
+            std::fs::write(path, contents)?;
+        }
+    }
+    Ok(())
+}
+/// Searches for `patterns`, printing debug information for any nodes whose text exactly matches
+/// `debug_snippet`. This is intended for debugging and probably isn't in it's current form useful
+/// for much else.
+pub fn search_for_patterns(patterns: Vec<SsrPattern>, debug_snippet: Option<String>) -> Result<()> {
+    use ra_db::SourceDatabaseExt;
+    use ra_ide_db::symbol_index::SymbolsDatabase;
+    let (host, vfs) = load_cargo(&std::env::current_dir()?, true, true)?;
+    let db = host.raw_database();
+    let mut match_finder = MatchFinder::new(db);
+    for pattern in patterns {
+        match_finder.add_search_pattern(pattern);
+    }
+    for &root in db.local_roots().iter() {
+        let sr = db.source_root(root);
+        for file_id in sr.iter() {
+            if let Some(debug_snippet) = &debug_snippet {
+                for debug_info in match_finder.debug_where_text_equal(file_id, debug_snippet) {
+                    println!("{:#?}", debug_info);
+                }
+            } else {
+                let matches = match_finder.find_matches_in_file(file_id);
+                if !matches.matches.is_empty() {
+                    let matches = matches.flattened().matches;
+                    if let Some(path) = vfs.file_path(file_id).as_path() {
+                        println!("{} matches in '{}'", matches.len(), path.to_string_lossy());
+                    }
+                    // We could possibly at some point do something more useful than just printing
+                    // the matched text. For now though, that's the easiest thing to do.
+                    for m in matches {
+                        println!("{}", m.matched_text());
+                    }
+                }
+            }
+        }
+    }
+    Ok(())
+}
diff --git a/crates/rust-analyzer/src/config.rs b/crates/rust-analyzer/src/config.rs
index 6b17ce18b..6c311648a 100644
--- a/crates/rust-analyzer/src/config.rs
+++ b/crates/rust-analyzer/src/config.rs
@@ -44,7 +44,7 @@ pub struct Config {
    pub root_path: AbsPathBuf,
 }
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Eq, PartialEq)]
 pub enum LinkedProject {
    ProjectManifest(ProjectManifest),
    InlineJsonProject(ProjectJson),
diff --git a/crates/rust-analyzer/src/global_state.rs b/crates/rust-analyzer/src/global_state.rs
index b8aa1e5b5..b7b4edf66 100644
--- a/crates/rust-analyzer/src/global_state.rs
+++ b/crates/rust-analyzer/src/global_state.rs
@@ -27,7 +27,7 @@ use crate::{
    Result,
 };
-#[derive(Eq, PartialEq)]
+#[derive(Eq, PartialEq, Copy, Clone)]
 pub(crate) enum Status {
    Loading,
    Ready,
diff --git a/crates/rust-analyzer/src/handlers.rs b/crates/rust-analyzer/src/handlers.rs
index e35a5e846..3cb532b62 100644
--- a/crates/rust-analyzer/src/handlers.rs
+++ b/crates/rust-analyzer/src/handlers.rs
@@ -23,7 +23,7 @@ use ra_ide::{
 };
 use ra_prof::profile;
 use ra_project_model::TargetKind;
-use ra_syntax::{AstNode, SyntaxKind, TextRange, TextSize};
+use ra_syntax::{algo, ast, AstNode, SyntaxKind, TextRange, TextSize};
 use serde::{Deserialize, Serialize};
 use serde_json::to_value;
 use stdx::{format_to, split_delim};
@@ -330,11 +330,12 @@ pub(crate) fn handle_workspace_symbol(
    fn exec_query(snap: &GlobalStateSnapshot, query: Query) -> Result<Vec<SymbolInformation>> {
        let mut res = Vec::new();
        for nav in snap.analysis.symbol_search(query)? {
+            let container_name = nav.container_name().map(|v| v.to_string());
            let info = SymbolInformation {
                name: nav.name().to_string(),
                kind: to_proto::symbol_kind(nav.kind()),
-                location: to_proto::location(snap, nav.file_range())?,
+                location: to_proto::location_from_nav(snap, nav)?,
-                container_name: nav.container_name().map(|v| v.to_string()),
+                container_name,
                deprecated: None,
            };
            res.push(info);
@@ -407,8 +408,19 @@ pub(crate) fn handle_runnables(
    let file_id = from_proto::file_id(&snap, &params.text_document.uri)?;
    let line_index = snap.analysis.file_line_index(file_id)?;
    let offset = params.position.map(|it| from_proto::offset(&line_index, it));
-    let mut res = Vec::new();
    let cargo_spec = CargoTargetSpec::for_file(&snap, file_id)?;
+    let expect_test = match offset {
+        Some(offset) => {
+            let source_file = snap.analysis.parse(file_id)?;
+            algo::find_node_at_offset::<ast::MacroCall>(source_file.syntax(), offset)
+                .and_then(|it| it.path()?.segment()?.name_ref())
+                .map_or(false, |it| it.text() == "expect" || it.text() == "expect_file")
+        }
+        None => false,
+    };
+    let mut res = Vec::new();
    for runnable in snap.analysis.runnables(file_id)? {
        if let Some(offset) = offset {
            if !runnable.nav.full_range().contains_inclusive(offset) {
@@ -418,8 +430,12 @@ pub(crate) fn handle_runnables(
        if should_skip_target(&runnable, cargo_spec.as_ref()) {
            continue;
        }
+        let mut runnable = to_proto::runnable(&snap, file_id, runnable)?;
-        res.push(to_proto::runnable(&snap, file_id, runnable)?);
+        if expect_test {
+            runnable.label = format!("{} + expect", runnable.label);
+            runnable.args.expect_test = Some(true);
+        }
+        res.push(runnable);
    }
    // Add `cargo check` and `cargo test` for the whole package
@@ -438,6 +454,7 @@ pub(crate) fn handle_runnables(
                            spec.package.clone(),
                        ],
                        executable_args: Vec::new(),
+                        expect_test: None,
                    },
                })
            }
@@ -451,6 +468,7 @@ pub(crate) fn handle_runnables(
                    workspace_root: None,
                    cargo_args: vec!["check".to_string(), "--workspace".to_string()],
                    executable_args: Vec::new(),
+                    expect_test: None,
                },
            });
        }
@@ -1027,7 +1045,7 @@ pub(crate) fn handle_call_hierarchy_incoming(
    let item = params.item;
    let doc = TextDocumentIdentifier::new(item.uri);
-    let frange = from_proto::file_range(&snap, doc, item.range)?;
+    let frange = from_proto::file_range(&snap, doc, item.selection_range)?;
    let fpos = FilePosition { file_id: frange.file_id, offset: frange.range.start() };
    let call_items = match snap.analysis.incoming_calls(fpos)? {
@@ -1062,7 +1080,7 @@ pub(crate) fn handle_call_hierarchy_outgoing(
    let item = params.item;
    let doc = TextDocumentIdentifier::new(item.uri);
-    let frange = from_proto::file_range(&snap, doc, item.range)?;
+    let frange = from_proto::file_range(&snap, doc, item.selection_range)?;
    let fpos = FilePosition { file_id: frange.file_id, offset: frange.range.start() };
    let call_items = match snap.analysis.outgoing_calls(fpos)? {
@@ -1196,8 +1214,8 @@ fn show_impl_command_link(
            let position = to_proto::position(&line_index, position.offset);
            let locations: Vec<_> = nav_data
                .info
-                .iter()
+                .into_iter()
-                .filter_map(|it| to_proto::location(snap, it.file_range()).ok())
+                .filter_map(|nav| to_proto::location_from_nav(snap, nav).ok())
                .collect();
            let title = implementation_title(locations.len());
            let command = show_references_command(title, &uri, position, locations);
diff --git a/crates/rust-analyzer/src/lsp_ext.rs b/crates/rust-analyzer/src/lsp_ext.rs
index 1371f6cb4..82207bbb8 100644
--- a/crates/rust-analyzer/src/lsp_ext.rs
+++ b/crates/rust-analyzer/src/lsp_ext.rs
@@ -14,12 +14,12 @@ impl Request for AnalyzerStatus {
    const METHOD: &'static str = "rust-analyzer/analyzerStatus";
 }
-pub enum CollectGarbage {}
+pub enum ReloadWorkspace {}
-impl Request for CollectGarbage {
+impl Request for ReloadWorkspace {
    type Params = ();
    type Result = ();
-    const METHOD: &'static str = "rust-analyzer/collectGarbage";
+    const METHOD: &'static str = "rust-analyzer/reloadWorkspace";
 }
 pub enum SyntaxTree {}
@@ -161,6 +161,8 @@ pub struct CargoRunnable {
    pub cargo_args: Vec<String>,
    // stuff after --
    pub executable_args: Vec<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub expect_test: Option<bool>,
 }
 pub enum InlayHints {}
diff --git a/crates/rust-analyzer/src/main_loop.rs b/crates/rust-analyzer/src/main_loop.rs
index 9fd16ef3b..e03038b25 100644
--- a/crates/rust-analyzer/src/main_loop.rs
+++ b/crates/rust-analyzer/src/main_loop.rs
@@ -136,7 +136,7 @@ impl GlobalState {
            log::info!("queued count = {}", queue_count);
        }
-        let mut became_ready = false;
+        let prev_status = self.status;
        match event {
            Event::Lsp(msg) => match msg {
                lsp_server::Message::Request(req) => self.on_request(loop_start, req)?,
@@ -168,22 +168,26 @@ impl GlobalState {
                    }
                }
                vfs::loader::Message::Progress { n_total, n_done } => {
-                    let state = if n_done == 0 {
+                    if n_total == 0 {
-                        Progress::Begin
-                    } else if n_done < n_total {
-                        Progress::Report
-                    } else {
-                        assert_eq!(n_done, n_total);
                        self.status = Status::Ready;
-                        became_ready = true;
+                    } else {
-                        Progress::End
+                        let state = if n_done == 0 {
-                    };
+                            self.status = Status::Loading;
-                    self.report_progress(
+                            Progress::Begin
-                        "roots scanned",
+                        } else if n_done < n_total {
-                        state,
+                            Progress::Report
-                        Some(format!("{}/{}", n_done, n_total)),
+                        } else {
-                        Some(Progress::percentage(n_done, n_total)),
+                            assert_eq!(n_done, n_total);
-                    )
+                            self.status = Status::Ready;
+                            Progress::End
+                        };
+                        self.report_progress(
+                            "roots scanned",
+                            state,
+                            Some(format!("{}/{}", n_done, n_total)),
+                            Some(Progress::percentage(n_done, n_total)),
+                        )
+                    }
                }
            },
            Event::Flycheck(task) => match task {
@@ -231,13 +235,13 @@ impl GlobalState {
        }
        let state_changed = self.process_changes();
-        if became_ready {
+        if prev_status == Status::Loading && self.status == Status::Ready {
            if let Some(flycheck) = &self.flycheck {
                flycheck.handle.update();
            }
        }
-        if self.status == Status::Ready && (state_changed || became_ready) {
+        if self.status == Status::Ready && (state_changed || prev_status == Status::Loading) {
            let subscriptions = self
                .mem_docs
                .iter()
@@ -274,7 +278,7 @@ impl GlobalState {
        self.register_request(&req, request_received);
        RequestDispatcher { req: Some(req), global_state: self }
-            .on_sync::<lsp_ext::CollectGarbage>(|s, ()| Ok(s.analysis_host.collect_garbage()))?
+            .on_sync::<lsp_ext::ReloadWorkspace>(|s, ()| Ok(s.reload()))?
            .on_sync::<lsp_ext::JoinLines>(|s, p| handlers::handle_join_lines(s.snapshot(), p))?
            .on_sync::<lsp_ext::OnEnter>(|s, p| handlers::handle_on_enter(s.snapshot(), p))?
            .on_sync::<lsp_types::request::Shutdown>(|_, ()| Ok(()))?
diff --git a/crates/rust-analyzer/src/reload.rs b/crates/rust-analyzer/src/reload.rs
index ec71f8b29..0c1fd1b8b 100644
--- a/crates/rust-analyzer/src/reload.rs
+++ b/crates/rust-analyzer/src/reload.rs
@@ -19,11 +19,14 @@ impl GlobalState {
        if self.config.lru_capacity != old_config.lru_capacity {
            self.analysis_host.update_lru_capacity(old_config.lru_capacity);
        }
-        if self.config.flycheck != old_config.flycheck {
+        if self.config.linked_projects != old_config.linked_projects {
+            self.reload()
+        } else if self.config.flycheck != old_config.flycheck {
            self.reload_flycheck();
        }
    }
    pub(crate) fn reload(&mut self) {
+        log::info!("reloading projects: {:?}", self.config.linked_projects);
        let workspaces = {
            if self.config.linked_projects.is_empty()
                && self.config.notifications.cargo_toml_not_found
diff --git a/crates/rust-analyzer/src/to_proto.rs b/crates/rust-analyzer/src/to_proto.rs
index f6cb8e4bb..95dd8e408 100644
--- a/crates/rust-analyzer/src/to_proto.rs
+++ b/crates/rust-analyzer/src/to_proto.rs
@@ -352,7 +352,7 @@ pub(crate) fn folding_range(
    let kind = match fold.kind {
        FoldKind::Comment => Some(lsp_types::FoldingRangeKind::Comment),
        FoldKind::Imports => Some(lsp_types::FoldingRangeKind::Imports),
-        FoldKind::Mods | FoldKind::Block => None,
+        FoldKind::Mods | FoldKind::Block | FoldKind::ArgList => None,
    };
    let range = range(line_index, fold.range);
@@ -446,6 +446,18 @@ pub(crate) fn location(
    Ok(loc)
 }
+/// Perefer using `location_link`, if the client has the cap.
+pub(crate) fn location_from_nav(
+    snap: &GlobalStateSnapshot,
+    nav: NavigationTarget,
+) -> Result<lsp_types::Location> {
+    let url = url(snap, nav.file_id());
+    let line_index = snap.analysis.file_line_index(nav.file_id())?;
+    let range = range(&line_index, nav.full_range());
+    let loc = lsp_types::Location::new(url, range);
+    Ok(loc)
+}
 pub(crate) fn location_link(
    snap: &GlobalStateSnapshot,
    src: Option<FileRange>,
@@ -666,38 +678,34 @@ pub(crate) fn runnable(
            workspace_root: workspace_root.map(|it| it.into()),
            cargo_args,
            executable_args,
+            expect_test: None,
        },
    })
 }
 #[cfg(test)]
 mod tests {
-    use test_utils::extract_ranges;
+    use ra_ide::Analysis;
    use super::*;
    #[test]
    fn conv_fold_line_folding_only_fixup() {
-        let text = r#"<fold>mod a;
+        let text = r#"mod a;
 mod b;
-mod c;</fold>
+mod c;
-fn main() <fold>{
+fn main() {
-    if cond <fold>{
+    if cond {
        a::do_a();
-    }</fold> else <fold>{
+    } else {
        b::do_b();
-    }</fold>
+    }
-}</fold>"#;
+}"#;
-        let (ranges, text) = extract_ranges(text, "fold");
+        let (analysis, file_id) = Analysis::from_single_file(text.to_string());
-        assert_eq!(ranges.len(), 4);
+        let folds = analysis.folding_ranges(file_id).unwrap();
-        let folds = vec![
+        assert_eq!(folds.len(), 4);
-            Fold { range: ranges[0], kind: FoldKind::Mods },
-            Fold { range: ranges[1], kind: FoldKind::Block },
-            Fold { range: ranges[2], kind: FoldKind::Block },
-            Fold { range: ranges[3], kind: FoldKind::Block },
-        ];
        let line_index = LineIndex::new(&text);
        let converted: Vec<lsp_types::FoldingRange> =
diff --git a/crates/test_utils/src/lib.rs b/crates/test_utils/src/lib.rs
index caf847273..e4aa894ac 100644
--- a/crates/test_utils/src/lib.rs
+++ b/crates/test_utils/src/lib.rs
@@ -11,8 +11,9 @@ pub mod mark;
 mod fixture;
 use std::{
+    convert::{TryFrom, TryInto},
    env, fs,
-    path::{Path, PathBuf},
+    path::PathBuf,
 };
 use serde_json::Value;
@@ -117,8 +118,8 @@ pub fn extract_range_or_offset(text: &str) -> (RangeOrOffset, String) {
 }
 /// Extracts ranges, marked with `<tag> </tag>` pairs from the `text`
-pub fn extract_ranges(mut text: &str, tag: &str) -> (Vec<TextRange>, String) {
+pub fn extract_tags(mut text: &str, tag: &str) -> (Vec<(TextRange, Option<String>)>, String) {
-    let open = format!("<{}>", tag);
+    let open = format!("<{}", tag);
    let close = format!("</{}>", tag);
    let mut ranges = Vec::new();
    let mut res = String::new();
@@ -133,22 +134,35 @@ pub fn extract_ranges(mut text: &str, tag: &str) -> (Vec<TextRange>, String) {
                res.push_str(&text[..i]);
                text = &text[i..];
                if text.starts_with(&open) {
-                    text = &text[open.len()..];
+                    let close_open = text.find('>').unwrap();
+                    let attr = text[open.len()..close_open].trim();
+                    let attr = if attr.is_empty() { None } else { Some(attr.to_string()) };
+                    text = &text[close_open + '>'.len_utf8()..];
                    let from = TextSize::of(&res);
-                    stack.push(from);
+                    stack.push((from, attr));
                } else if text.starts_with(&close) {
                    text = &text[close.len()..];
-                    let from = stack.pop().unwrap_or_else(|| panic!("unmatched </{}>", tag));
+                    let (from, attr) =
+                        stack.pop().unwrap_or_else(|| panic!("unmatched </{}>", tag));
                    let to = TextSize::of(&res);
-                    ranges.push(TextRange::new(from, to));
+                    ranges.push((TextRange::new(from, to), attr));
+                } else {
+                    res.push('<');
+                    text = &text['<'.len_utf8()..];
                }
            }
        }
    }
    assert!(stack.is_empty(), "unmatched <{}>", tag);
-    ranges.sort_by_key(|r| (r.start(), r.end()));
+    ranges.sort_by_key(|r| (r.0.start(), r.0.end()));
    (ranges, res)
 }
+#[test]
+fn test_extract_tags() {
+    let (tags, text) = extract_tags(r#"<tag fn>fn <tag>main</tag>() {}</tag>"#, "tag");
+    let actual = tags.into_iter().map(|(range, attr)| (&text[range], attr)).collect::<Vec<_>>();
+    assert_eq!(actual, vec![("fn main() {}", Some("fn".into())), ("main", None),]);
+}
 /// Inserts `<|>` marker into the `text` at `offset`.
 pub fn add_cursor(text: &str, offset: TextSize) -> String {
@@ -168,8 +182,9 @@ pub fn extract_annotations(text: &str) -> Vec<(TextRange, String)> {
    for line in lines_with_ends(text) {
        if let Some(idx) = line.find("//^") {
            let offset = prev_line_start.unwrap() + TextSize::of(&line[..idx + "//".len()]);
-            let data = line[idx + "//^".len()..].trim().to_string();
+            for (line_range, text) in extract_line_annotations(&line[idx + "//".len()..]) {
-            res.push((TextRange::at(offset, 1.into()), data))
+                res.push((line_range + offset, text))
+            }
        }
        prev_line_start = Some(line_start);
        line_start += TextSize::of(line);
@@ -177,22 +192,37 @@ pub fn extract_annotations(text: &str) -> Vec<(TextRange, String)> {
    res
 }
+fn extract_line_annotations(mut line: &str) -> Vec<(TextRange, String)> {
+    let mut res = Vec::new();
+    let mut offset: TextSize = 0.into();
+    while !line.is_empty() {
+        let len = line.chars().take_while(|&it| it == '^').count();
+        assert!(len > 0);
+        let range = TextRange::at(offset, len.try_into().unwrap());
+        let next = line[len..].find('^').map_or(line.len(), |it| it + len);
+        res.push((range, line[len..][..next - len].trim().to_string()));
+        line = &line[next..];
+        offset += TextSize::try_from(next).unwrap();
+    }
+    res
+}
 #[test]
 fn test_extract_annotations() {
    let text = stdx::trim_indent(
        r#"
 fn main() {
-    let x = 92;
+    let (x,     y) = (9, 2);
-      //^ def
+       //^ def  ^ def
-    z + 1
+    zoo + 1
-} //^ i32
+} //^^^ i32
    "#,
    );
    let res = extract_annotations(&text)
        .into_iter()
        .map(|(range, ann)| (&text[range], ann))
        .collect::<Vec<_>>();
-    assert_eq!(res, vec![("x", "def".into()), ("z", "i32".into()),]);
+    assert_eq!(res, vec![("x", "def".into()), ("y", "def".into()), ("zoo", "i32".into()),]);
 }
 // Comparison functionality borrowed from cargo:
@@ -282,85 +312,6 @@ pub fn find_mismatch<'a>(expected: &'a Value, actual: &'a Value) -> Option<(&'a
    }
 }
-/// Calls callback `f` with input code and file paths for each `.rs` file in `test_data_dir`
-/// subdirectories defined by `paths`.
-///
-/// If the content of the matching output file differs from the output of `f()`
-/// the test will fail.
-///
-/// If there is no matching output file it will be created and filled with the
-/// output of `f()`, but the test will fail.
-pub fn dir_tests<F>(test_data_dir: &Path, paths: &[&str], outfile_extension: &str, f: F)
-where
-    F: Fn(&str, &Path) -> String,
-{
-    for (path, input_code) in collect_rust_files(test_data_dir, paths) {
-        let actual = f(&input_code, &path);
-        let path = path.with_extension(outfile_extension);
-        if !path.exists() {
-            println!("\nfile: {}", path.display());
-            println!("No .txt file with expected result, creating...\n");
-            println!("{}\n{}", input_code, actual);
-            fs::write(&path, &actual).unwrap();
-            panic!("No expected result");
-        }
-        let expected = read_text(&path);
-        assert_equal_text(&expected, &actual, &path);
-    }
-}
-/// Collects all `.rs` files from `dir` subdirectories defined by `paths`.
-pub fn collect_rust_files(root_dir: &Path, paths: &[&str]) -> Vec<(PathBuf, String)> {
-    paths
-        .iter()
-        .flat_map(|path| {
-            let path = root_dir.to_owned().join(path);
-            rust_files_in_dir(&path).into_iter()
-        })
-        .map(|path| {
-            let text = read_text(&path);
-            (path, text)
-        })
-        .collect()
-}
-/// Collects paths to all `.rs` files from `dir` in a sorted `Vec<PathBuf>`.
-fn rust_files_in_dir(dir: &Path) -> Vec<PathBuf> {
-    let mut acc = Vec::new();
-    for file in fs::read_dir(&dir).unwrap() {
-        let file = file.unwrap();
-        let path = file.path();
-        if path.extension().unwrap_or_default() == "rs" {
-            acc.push(path);
-        }
-    }
-    acc.sort();
-    acc
-}
-/// Returns the path to the root directory of `rust-analyzer` project.
-pub fn project_dir() -> PathBuf {
-    let dir = env!("CARGO_MANIFEST_DIR");
-    PathBuf::from(dir).parent().unwrap().parent().unwrap().to_owned()
-}
-/// Read file and normalize newlines.
-///
-/// `rustc` seems to always normalize `\r\n` newlines to `\n`:
-///
-/// ```
-/// let s = "
-/// ";
-/// assert_eq!(s.as_bytes(), &[10]);
-/// ```
-///
-/// so this should always be correct.
-pub fn read_text(path: &Path) -> String {
-    fs::read_to_string(path)
-        .unwrap_or_else(|_| panic!("File at {:?} should be valid", path))
-        .replace("\r\n", "\n")
-}
 /// Returns `false` if slow tests should not run, otherwise returns `true` and
 /// also creates a file at `./target/.slow_tests_cookie` which serves as a flag
 /// that slow tests did run.
@@ -375,25 +326,8 @@ pub fn skip_slow_tests() -> bool {
    should_skip
 }
-/// Asserts that `expected` and `actual` strings are equal. If they differ only
+/// Returns the path to the root directory of `rust-analyzer` project.
-/// in trailing or leading whitespace the test won't fail and
+pub fn project_dir() -> PathBuf {
-/// the contents of `actual` will be written to the file located at `path`.
+    let dir = env!("CARGO_MANIFEST_DIR");
-fn assert_equal_text(expected: &str, actual: &str, path: &Path) {
+    PathBuf::from(dir).parent().unwrap().parent().unwrap().to_owned()
-    if expected == actual {
-        return;
-    }
-    let dir = project_dir();
-    let pretty_path = path.strip_prefix(&dir).unwrap_or_else(|_| path);
-    if expected.trim() == actual.trim() {
-        println!("whitespace difference, rewriting");
-        println!("file: {}\n", pretty_path.display());
-        fs::write(path, actual).unwrap();
-        return;
-    }
-    if env::var("UPDATE_EXPECTATIONS").is_ok() {
-        println!("rewriting {}", pretty_path.display());
-        fs::write(path, actual).unwrap();
-        return;
-    }
-    assert_eq_text!(expected, actual, "file: {}", pretty_path.display());
 }
diff --git a/crates/vfs/src/file_set.rs b/crates/vfs/src/file_set.rs
index d0ddeafe7..977ba3010 100644
--- a/crates/vfs/src/file_set.rs
+++ b/crates/vfs/src/file_set.rs
@@ -69,7 +69,7 @@ impl FileSetConfig {
            Ok(it) => it,
            Err(it) => it.saturating_sub(1),
        };
-        if path.starts_with(&self.roots[idx].0) {
+        if !self.roots.is_empty() && path.starts_with(&self.roots[idx].0) {
            self.roots[idx].1
        } else {
            self.len() - 1
diff --git a/docs/dev/README.md b/docs/dev/README.md
index 6b6824ded..f87462400 100644
--- a/docs/dev/README.md
+++ b/docs/dev/README.md
@@ -177,6 +177,9 @@ There are many benefits to this:
 * less stuff printed during printf-debugging
 * less time to run test
+It also makes sense to format snippets more compactly (for example, by placing enum defitions like `enum E { Foo, Bar }` on a single line),
+as long as they are still readable.
 ## Order of Imports
 We separate import groups with blank lines
@@ -358,10 +361,10 @@ There are two kinds of tests:
 The purpose of inline tests is not to achieve full coverage by test cases, but to explain to the reader of the code what each particular `if` and `match` is responsible for.
 If you are tempted to add a large inline test, it might be a good idea to leave only the simplest example in place, and move the test to a manual `parser/ok` test.
-To update test data, run with `UPDATE_EXPECTATIONS` variable:
+To update test data, run with `UPDATE_EXPECT` variable:
 ```bash
-env UPDATE_EXPECTATIONS=1 cargo qt
+env UPDATE_EXPECT=1 cargo qt
 ```
 After adding a new inline test you need to run `cargo xtest codegen` and also update the test data as described above.
diff --git a/docs/dev/lsp-extensions.md b/docs/dev/lsp-extensions.md
index a0847dad3..c0afb16d3 100644
--- a/docs/dev/lsp-extensions.md
+++ b/docs/dev/lsp-extensions.md
@@ -389,15 +389,15 @@ rust-analyzer supports only one `kind`, `"cargo"`. The `args` for `"cargo"` look
 Returns internal status message, mostly for debugging purposes.
-## Collect Garbage
+## Reload Workspace
-**Method:** `rust-analyzer/collectGarbage`
+**Method:** `rust-analyzer/reloadWorkspace`
 **Request:** `null`
 **Response:** `null`
-Frees some caches. For internal use, and is mostly broken at the moment.
+Reloads project information (that is, re-executes `cargo metadata`).
 ## Syntax Tree
@@ -504,4 +504,4 @@ Such actions on the client side are appended to a hover bottom as command links:
  | TITLE _Action1_ | _Action2_ |  <- second group
  +-----------------------------+
  ...
-```
-\ No newline at end of file
+```
diff --git a/editors/code/package-lock.json b/editors/code/package-lock.json
index 3b4a31682..4f94c2dc5 100644
--- a/editors/code/package-lock.json
+++ b/editors/code/package-lock.json
@@ -5,35 +5,35 @@
    "requires": true,
    "dependencies": {
        "@babel/code-frame": {
-            "version": "7.8.3",
+            "version": "7.10.3",
-            "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.8.3.tgz",
+            "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.10.3.tgz",
-            "integrity": "sha512-a9gxpmdXtZEInkCSHUJDLHZVBgb1QS0jhss4cPP93EW7s+uC5bikET2twEF3KV+7rDblJcmNvTR7VJejqd2C2g==",
+            "integrity": "sha512-fDx9eNW0qz0WkUeqL6tXEXzVlPh6Y5aCDEZesl0xBGA8ndRukX91Uk44ZqnkECp01NAZUdCAl+aiQNGi0k88Eg==",
            "dev": true,
            "requires": {
-                "@babel/highlight": "^7.8.3"
+                "@babel/highlight": "^7.10.3"
            }
        },
        "@babel/helper-validator-identifier": {
-            "version": "7.9.5",
+            "version": "7.10.3",
-            "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.9.5.tgz",
+            "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.10.3.tgz",
-            "integrity": "sha512-/8arLKUFq882w4tWGj9JYzRpAlZgiWUJ+dtteNTDqrRBz9Iguck9Rn3ykuBDoUwh2TO4tSAJlrxDUOXWklJe4g==",
+            "integrity": "sha512-bU8JvtlYpJSBPuj1VUmKpFGaDZuLxASky3LhaKj3bmpSTY6VWooSM8msk+Z0CZoErFye2tlABF6yDkT3FOPAXw==",
            "dev": true
        },
        "@babel/highlight": {
-            "version": "7.9.0",
+            "version": "7.10.3",
-            "resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.9.0.tgz",
+            "resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.10.3.tgz",
-            "integrity": "sha512-lJZPilxX7Op3Nv/2cvFdnlepPXDxi29wxteT57Q965oc5R9v86ztx0jfxVrTcBk8C2kcPkkDa2Z4T3ZsPPVWsQ==",
+            "integrity": "sha512-Ih9B/u7AtgEnySE2L2F0Xm0GaM729XqqLfHkalTsbjXGyqmf/6M0Cu0WpvqueUlW+xk88BHw9Nkpj49naU+vWw==",
            "dev": true,
            "requires": {
-                "@babel/helper-validator-identifier": "^7.9.0",
+                "@babel/helper-validator-identifier": "^7.10.3",
                "chalk": "^2.0.0",
                "js-tokens": "^4.0.0"
            }
        },
        "@rollup/plugin-commonjs": {
-            "version": "12.0.0",
+            "version": "13.0.0",
-            "resolved": "https://registry.npmjs.org/@rollup/plugin-commonjs/-/plugin-commonjs-12.0.0.tgz",
+            "resolved": "https://registry.npmjs.org/@rollup/plugin-commonjs/-/plugin-commonjs-13.0.0.tgz",
-            "integrity": "sha512-8+mDQt1QUmN+4Y9D3yCG8AJNewuTSLYPJVzKKUZ+lGeQrI+bV12Tc5HCyt2WdlnG6ihIL/DPbKRJlB40DX40mw==",
+            "integrity": "sha512-Anxc3qgkAi7peAyesTqGYidG5GRim9jtg8xhmykNaZkImtvjA7Wsqep08D2mYsqw1IF7rA3lYfciLgzUSgRoqw==",
            "dev": true,
            "requires": {
                "@rollup/pluginutils": "^3.0.8",
@@ -46,9 +46,9 @@
            }
        },
        "@rollup/plugin-node-resolve": {
-            "version": "8.0.0",
+            "version": "8.1.0",
-            "resolved": "https://registry.npmjs.org/@rollup/plugin-node-resolve/-/plugin-node-resolve-8.0.0.tgz",
+            "resolved": "https://registry.npmjs.org/@rollup/plugin-node-resolve/-/plugin-node-resolve-8.1.0.tgz",
-            "integrity": "sha512-5poJCChrkVggXXND/sQ7yNqwjUNT4fP31gpRWCnSNnlXuUXTCMHT33xZrTGxgjm5Rl18MHj7iEzlCT8rYWwQSA==",
+            "integrity": "sha512-ovq7ZM3JJYUUmEjjO+H8tnUdmQmdQudJB7xruX8LFZ1W2q8jXdPUS6SsIYip8ByOApu4RR7729Am9WhCeCMiHA==",
            "dev": true,
            "requires": {
                "@rollup/pluginutils": "^3.0.8",
@@ -89,19 +89,12 @@
            "integrity": "sha512-EYNwp3bU+98cpU4lAWYYL7Zz+2gryWH1qbdDTidVd6hkiR6weksdbMadyXKXNPEkQFhXM+hVO9ZygomHXp+AIw==",
            "dev": true
        },
-        "@types/events": {
-            "version": "3.0.0",
-            "resolved": "https://registry.npmjs.org/@types/events/-/events-3.0.0.tgz",
-            "integrity": "sha512-EaObqwIvayI5a8dCzhFrjKzVwKLxjoG9T6Ppd5CEo07LRKfQ8Yokw54r5+Wq7FaBQ+yXRvQAYPrHwya1/UFt9g==",
-            "dev": true
-        },
        "@types/glob": {
-            "version": "7.1.1",
+            "version": "7.1.2",
-            "resolved": "https://registry.npmjs.org/@types/glob/-/glob-7.1.1.tgz",
+            "resolved": "https://registry.npmjs.org/@types/glob/-/glob-7.1.2.tgz",
-            "integrity": "sha512-1Bh06cbWJUHMC97acuD6UMG29nMt0Aqz1vF3guLfG+kHHJhy3AyohZFFxYk2f7Q1SQIrNwvncxAE0N/9s70F2w==",
+            "integrity": "sha512-VgNIkxK+j7Nz5P7jvUZlRvhuPSmsEfS03b0alKcq5V/STUKAa3Plemsn5mrQUO7am6OErJ4rhGEGJbACclrtRA==",
            "dev": true,
            "requires": {
-                "@types/events": "*",
                "@types/minimatch": "*",
                "@types/node": "*"
            }
@@ -125,9 +118,9 @@
            "dev": true
        },
        "@types/node": {
-            "version": "14.0.5",
+            "version": "12.7.12",
-            "resolved": "https://registry.npmjs.org/@types/node/-/node-14.0.5.tgz",
+            "resolved": "https://registry.npmjs.org/@types/node/-/node-12.7.12.tgz",
-            "integrity": "sha512-90hiq6/VqtQgX8Sp0EzeIsv3r+ellbGj4URKj5j30tLlZvRUpnAe9YbYnjl3pJM93GyXU0tghHhvXHq+5rnCKA==",
+            "integrity": "sha512-KPYGmfD0/b1eXurQ59fXD1GBzhSQfz6/lKBxkaHX9dKTzjXbK68Zt7yGUxUsCS1jeTy/8aL+d9JEr+S54mpkWQ==",
            "dev": true
        },
        "@types/node-fetch": {
@@ -156,18 +149,46 @@
            "dev": true
        },
        "@typescript-eslint/eslint-plugin": {
-            "version": "3.0.0",
+            "version": "3.4.0",
-            "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-3.0.0.tgz",
+            "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-3.4.0.tgz",
-            "integrity": "sha512-lcZ0M6jD4cqGccYOERKdMtg+VWpoq3NSnWVxpc/AwAy0zhkUYVioOUZmfNqiNH8/eBNGhCn6HXd6mKIGRgNc1Q==",
+            "integrity": "sha512-wfkpiqaEVhZIuQRmudDszc01jC/YR7gMSxa6ulhggAe/Hs0KVIuo9wzvFiDbG3JD5pRFQoqnf4m7REDsUvBnMQ==",
            "dev": true,
            "requires": {
-                "@typescript-eslint/experimental-utils": "3.0.0",
+                "@typescript-eslint/experimental-utils": "3.4.0",
+                "debug": "^4.1.1",
                "functional-red-black-tree": "^1.0.1",
                "regexpp": "^3.0.0",
                "semver": "^7.3.2",
                "tsutils": "^3.17.1"
            },
            "dependencies": {
+                "@typescript-eslint/experimental-utils": {
+                    "version": "3.4.0",
+                    "resolved": "https://registry.npmjs.org/@typescript-eslint/experimental-utils/-/experimental-utils-3.4.0.tgz",
+                    "integrity": "sha512-rHPOjL43lOH1Opte4+dhC0a/+ks+8gOBwxXnyrZ/K4OTAChpSjP76fbI8Cglj7V5GouwVAGaK+xVwzqTyE/TPw==",
+                    "dev": true,
+                    "requires": {
+                        "@types/json-schema": "^7.0.3",
+                        "@typescript-eslint/typescript-estree": "3.4.0",
+                        "eslint-scope": "^5.0.0",
+                        "eslint-utils": "^2.0.0"
+                    }
+                },
+                "@typescript-eslint/typescript-estree": {
+                    "version": "3.4.0",
+                    "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-3.4.0.tgz",
+                    "integrity": "sha512-zKwLiybtt4uJb4mkG5q2t6+W7BuYx2IISiDNV+IY68VfoGwErDx/RfVI7SWL4gnZ2t1A1ytQQwZ+YOJbHHJ2rw==",
+                    "dev": true,
+                    "requires": {
+                        "debug": "^4.1.1",
+                        "eslint-visitor-keys": "^1.1.0",
+                        "glob": "^7.1.6",
+                        "is-glob": "^4.0.1",
+                        "lodash": "^4.17.15",
+                        "semver": "^7.3.2",
+                        "tsutils": "^3.17.1"
+                    }
+                },
                "semver": {
                    "version": "7.3.2",
                    "resolved": "https://registry.npmjs.org/semver/-/semver-7.3.2.tgz",
@@ -177,33 +198,33 @@
            }
        },
        "@typescript-eslint/experimental-utils": {
-            "version": "3.0.0",
+            "version": "3.4.0",
-            "resolved": "https://registry.npmjs.org/@typescript-eslint/experimental-utils/-/experimental-utils-3.0.0.tgz",
+            "resolved": "https://registry.npmjs.org/@typescript-eslint/experimental-utils/-/experimental-utils-3.4.0.tgz",
-            "integrity": "sha512-BN0vmr9N79M9s2ctITtChRuP1+Dls0x/wlg0RXW1yQ7WJKPurg6X3Xirv61J2sjPif4F8SLsFMs5Nzte0WYoTQ==",
+            "integrity": "sha512-rHPOjL43lOH1Opte4+dhC0a/+ks+8gOBwxXnyrZ/K4OTAChpSjP76fbI8Cglj7V5GouwVAGaK+xVwzqTyE/TPw==",
            "dev": true,
            "requires": {
                "@types/json-schema": "^7.0.3",
-                "@typescript-eslint/typescript-estree": "3.0.0",
+                "@typescript-eslint/typescript-estree": "3.4.0",
                "eslint-scope": "^5.0.0",
                "eslint-utils": "^2.0.0"
            }
        },
        "@typescript-eslint/parser": {
-            "version": "3.0.0",
+            "version": "3.4.0",
-            "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-3.0.0.tgz",
+            "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-3.4.0.tgz",
-            "integrity": "sha512-8RRCA9KLxoFNO0mQlrLZA0reGPd/MsobxZS/yPFj+0/XgMdS8+mO8mF3BDj2ZYQj03rkayhSJtF1HAohQ3iylw==",
+            "integrity": "sha512-ZUGI/de44L5x87uX5zM14UYcbn79HSXUR+kzcqU42gH0AgpdB/TjuJy3m4ezI7Q/jk3wTQd755mxSDLhQP79KA==",
            "dev": true,
            "requires": {
                "@types/eslint-visitor-keys": "^1.0.0",
-                "@typescript-eslint/experimental-utils": "3.0.0",
+                "@typescript-eslint/experimental-utils": "3.4.0",
-                "@typescript-eslint/typescript-estree": "3.0.0",
+                "@typescript-eslint/typescript-estree": "3.4.0",
                "eslint-visitor-keys": "^1.1.0"
            }
        },
        "@typescript-eslint/typescript-estree": {
-            "version": "3.0.0",
+            "version": "3.4.0",
-            "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-3.0.0.tgz",
+            "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-3.4.0.tgz",
-            "integrity": "sha512-nevQvHyNghsfLrrByzVIH4ZG3NROgJ8LZlfh3ddwPPH4CH7W4GAiSx5qu+xHuX5pWsq6q/eqMc1io840ZhAnUg==",
+            "integrity": "sha512-zKwLiybtt4uJb4mkG5q2t6+W7BuYx2IISiDNV+IY68VfoGwErDx/RfVI7SWL4gnZ2t1A1ytQQwZ+YOJbHHJ2rw==",
            "dev": true,
            "requires": {
                "debug": "^4.1.1",
@@ -224,9 +245,9 @@
            }
        },
        "acorn": {
-            "version": "7.2.0",
+            "version": "7.3.1",
-            "resolved": "https://registry.npmjs.org/acorn/-/acorn-7.2.0.tgz",
+            "resolved": "https://registry.npmjs.org/acorn/-/acorn-7.3.1.tgz",
-            "integrity": "sha512-apwXVmYVpQ34m/i71vrApRrRKCWQnZZF1+npOD0WV5xZFfwWOmKGQ2RWlfdy9vWITsenisM8M0Qeq8agcFHNiQ==",
+            "integrity": "sha512-tLc0wSnatxAQHVHUapaHdz72pi9KUyHjq5KyHjGg9Y8Ifdc79pTh2XvI6I1/chZbnM7QtNKzh66ooDogPZSleA==",
            "dev": true
        },
        "acorn-jsx": {
@@ -262,23 +283,6 @@
            "integrity": "sha512-LEHHyuhlPY3TmuUYMh2oz89lTShfvgbmzaBcxve9t/9Wuy7Dwf4yoAKcND7KFT1HAQfqZ12qtc+DUrBMeKF9nw==",
            "dev": true
        },
-        "ansi-escapes": {
-            "version": "4.3.1",
-            "resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-4.3.1.tgz",
-            "integrity": "sha512-JWF7ocqNrp8u9oqpgV+wH5ftbt+cfvv+PTjOvKLT3AdYly/LmORARfEVT1iyjwN+4MqE5UmVKoAdIBqeoCHgLA==",
-            "dev": true,
-            "requires": {
-                "type-fest": "^0.11.0"
-            },
-            "dependencies": {
-                "type-fest": {
-                    "version": "0.11.0",
-                    "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.11.0.tgz",
-                    "integrity": "sha512-OdjXJxnCN1AvyLSzeKIgXTXxV+99ZuXl3Hpo9XpJAv9MBcHrrJOQ5kV7ypXOuQie+AmWG25hLbiKdwYTifzcfQ==",
-                    "dev": true
-                }
-            }
-        },
        "ansi-regex": {
            "version": "5.0.0",
            "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.0.tgz",
@@ -313,6 +317,18 @@
                "sprintf-js": "~1.0.2"
            }
        },
+        "array.prototype.map": {
+            "version": "1.0.2",
+            "resolved": "https://registry.npmjs.org/array.prototype.map/-/array.prototype.map-1.0.2.tgz",
+            "integrity": "sha512-Az3OYxgsa1g7xDYp86l0nnN4bcmuEITGe1rbdEBVkrqkzMgDcbdQ2R7r41pNzti+4NMces3H8gMmuioZUilLgw==",
+            "dev": true,
+            "requires": {
+                "define-properties": "^1.1.3",
+                "es-abstract": "^1.17.0-next.1",
+                "es-array-method-boxes-properly": "^1.0.0",
+                "is-string": "^1.0.4"
+            }
+        },
        "astral-regex": {
            "version": "1.0.0",
            "resolved": "https://registry.npmjs.org/astral-regex/-/astral-regex-1.0.0.tgz",
@@ -344,9 +360,9 @@
            "dev": true
        },
        "binary-extensions": {
-            "version": "2.0.0",
+            "version": "2.1.0",
-            "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.0.0.tgz",
+            "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.1.0.tgz",
-            "integrity": "sha512-Phlt0plgpIIBOGTT/ehfFnbNlfsDEiqmzE2KRXoX1bLIlir4X/MR+zSyBEkL05ffWgnRSf/DXv+WrUAVr93/ow==",
+            "integrity": "sha512-1Yj8h9Q+QDF5FzhMs/c9+6UntbD5MkRfRwac8DoEm9ZfUBZ7tZ55YcGVAzEe4bXsdQHEk+s9S5wsOKVdZrw0tQ==",
            "dev": true
        },
        "boolbase": {
@@ -415,12 +431,6 @@
                "supports-color": "^5.3.0"
            }
        },
-        "chardet": {
-            "version": "0.7.0",
-            "resolved": "https://registry.npmjs.org/chardet/-/chardet-0.7.0.tgz",
-            "integrity": "sha512-mT8iDcrh03qDGRRmoA2hmBJnxpllMR+0/0qlzjqZES6NdiWDcZkCNAk4rPFZ9Q85r27unkiNNg8ZOiwZXBHwcA==",
-            "dev": true
-        },
        "cheerio": {
            "version": "1.0.0-rc.3",
            "resolved": "https://registry.npmjs.org/cheerio/-/cheerio-1.0.0-rc.3.tgz",
@@ -436,36 +446,21 @@
            }
        },
        "chokidar": {
-            "version": "3.3.0",
+            "version": "3.3.1",
-            "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.3.0.tgz",
+            "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.3.1.tgz",
-            "integrity": "sha512-dGmKLDdT3Gdl7fBUe8XK+gAtGmzy5Fn0XkkWQuYxGIgWVPPse2CxFA5mtrlD0TOHaHjEUqkWNyP1XdHoJES/4A==",
+            "integrity": "sha512-4QYCEWOcK3OJrxwvyyAOxFuhpvOVCYkr33LPfFNBjAD/w3sEzWsp2BUOkI4l9bHvWioAd0rc6NlHUOEaWkTeqg==",
            "dev": true,
            "requires": {
                "anymatch": "~3.1.1",
                "braces": "~3.0.2",
-                "fsevents": "~2.1.1",
+                "fsevents": "~2.1.2",
                "glob-parent": "~5.1.0",
                "is-binary-path": "~2.1.0",
                "is-glob": "~4.0.1",
                "normalize-path": "~3.0.0",
-                "readdirp": "~3.2.0"
+                "readdirp": "~3.3.0"
            }
        },
-        "cli-cursor": {
-            "version": "3.1.0",
-            "resolved": "https://registry.npmjs.org/cli-cursor/-/cli-cursor-3.1.0.tgz",
-            "integrity": "sha512-I/zHAwsKf9FqGoXM4WWRACob9+SNukZTd94DWF57E4toouRulbCxcUh6RKUEOQlYTHJnzkPMySvPNaaSLNfLZw==",
-            "dev": true,
-            "requires": {
-                "restore-cursor": "^3.1.0"
-            }
-        },
-        "cli-width": {
-            "version": "2.2.1",
-            "resolved": "https://registry.npmjs.org/cli-width/-/cli-width-2.2.1.tgz",
-            "integrity": "sha512-GRMWDxpOB6Dgk2E5Uo+3eEBvtOOlimMmpbFiKuLFnQzYDavtLFY3K5ona41jgN/WdRZtG7utuVSVTL4HbZHGkw==",
-            "dev": true
-        },
        "cliui": {
            "version": "5.0.0",
            "resolved": "https://registry.npmjs.org/cliui/-/cliui-5.0.0.tgz",
@@ -483,29 +478,6 @@
                    "integrity": "sha512-1apePfXM1UOSqw0o9IiFAovVz9M5S1Dg+4TrDwfMewQ6p/rmMueb7tWZjQ1rx4Loy1ArBggoqGpfqqdI4rondg==",
                    "dev": true
                },
-                "emoji-regex": {
-                    "version": "7.0.3",
-                    "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-7.0.3.tgz",
-                    "integrity": "sha512-CwBLREIQ7LvYFB0WyRvwhq5N5qPhc6PMjD6bYggFlI5YyDgl+0vxq5VHbMOFqLg7hfWzmu8T5Z1QofhmTIhItA==",
-                    "dev": true
-                },
-                "is-fullwidth-code-point": {
-                    "version": "2.0.0",
-                    "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz",
-                    "integrity": "sha1-o7MKXE8ZkYMWeqq5O+764937ZU8=",
-                    "dev": true
-                },
-                "string-width": {
-                    "version": "3.1.0",
-                    "resolved": "https://registry.npmjs.org/string-width/-/string-width-3.1.0.tgz",
-                    "integrity": "sha512-vafcv6KjVZKSgz06oM/H6GDBrAtz8vdhQakGjFIvNrHA6y3HCF1CInLy+QLq8dTJPQ1b+KDUqDFctkdRW44e1w==",
-                    "dev": true,
-                    "requires": {
-                        "emoji-regex": "^7.0.1",
-                        "is-fullwidth-code-point": "^2.0.0",
-                        "strip-ansi": "^5.1.0"
-                    }
-                },
                "strip-ansi": {
                    "version": "5.2.0",
                    "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-5.2.0.tgz",
@@ -566,9 +538,9 @@
            "dev": true
        },
        "cross-spawn": {
-            "version": "7.0.2",
+            "version": "7.0.3",
-            "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.2.tgz",
+            "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.3.tgz",
-            "integrity": "sha512-PD6G8QG3S4FK/XCGFbEQrDqO2AnMMsy0meR7lerlIOHAAbkuavGU/pOqprrlvfTNjvowivTeBsjebAL0NSoMxw==",
+            "integrity": "sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w==",
            "dev": true,
            "requires": {
                "path-key": "^3.1.0",
@@ -649,9 +621,9 @@
            "dev": true
        },
        "diff": {
-            "version": "3.5.0",
+            "version": "4.0.2",
-            "resolved": "https://registry.npmjs.org/diff/-/diff-3.5.0.tgz",
+            "resolved": "https://registry.npmjs.org/diff/-/diff-4.0.2.tgz",
-            "integrity": "sha512-A46qtFgd+g7pDZinpnwiRJtxbC1hpgf0uzP3iG89scHk0AUC7A1TGxf5OiiOUv/JMZR8GOt8hL900hV0bOy5xA==",
+            "integrity": "sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A==",
            "dev": true
        },
        "doctrine": {
@@ -719,11 +691,20 @@
            }
        },
        "emoji-regex": {
-            "version": "8.0.0",
+            "version": "7.0.3",
-            "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
+            "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-7.0.3.tgz",
-            "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
+            "integrity": "sha512-CwBLREIQ7LvYFB0WyRvwhq5N5qPhc6PMjD6bYggFlI5YyDgl+0vxq5VHbMOFqLg7hfWzmu8T5Z1QofhmTIhItA==",
            "dev": true
        },
+        "enquirer": {
+            "version": "2.3.5",
+            "resolved": "https://registry.npmjs.org/enquirer/-/enquirer-2.3.5.tgz",
+            "integrity": "sha512-BNT1C08P9XD0vNg3J475yIUG+mVdp9T6towYFHUv897X0KoHBjB1shyrNmhmtHWKP17iSWgo7Gqh7BBuzLZMSA==",
+            "dev": true,
+            "requires": {
+                "ansi-colors": "^3.2.1"
+            }
+        },
        "entities": {
            "version": "1.1.2",
            "resolved": "https://registry.npmjs.org/entities/-/entities-1.1.2.tgz",
@@ -731,22 +712,43 @@
            "dev": true
        },
        "es-abstract": {
-            "version": "1.17.5",
+            "version": "1.17.6",
-            "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.17.5.tgz",
+            "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.17.6.tgz",
-            "integrity": "sha512-BR9auzDbySxOcfog0tLECW8l28eRGpDpU3Dm3Hp4q/N+VtLTmyj4EUN088XZWQDW/hzj6sYRDXeOFsaAODKvpg==",
+            "integrity": "sha512-Fr89bON3WFyUi5EvAeI48QTWX0AyekGgLA8H+c+7fbfCkJwRWRMLd8CQedNEyJuoYYhmtEqY92pgte1FAhBlhw==",
            "dev": true,
            "requires": {
                "es-to-primitive": "^1.2.1",
                "function-bind": "^1.1.1",
                "has": "^1.0.3",
                "has-symbols": "^1.0.1",
-                "is-callable": "^1.1.5",
+                "is-callable": "^1.2.0",
-                "is-regex": "^1.0.5",
+                "is-regex": "^1.1.0",
                "object-inspect": "^1.7.0",
                "object-keys": "^1.1.1",
                "object.assign": "^4.1.0",
-                "string.prototype.trimleft": "^2.1.1",
+                "string.prototype.trimend": "^1.0.1",
-                "string.prototype.trimright": "^2.1.1"
+                "string.prototype.trimstart": "^1.0.1"
+            }
+        },
+        "es-array-method-boxes-properly": {
+            "version": "1.0.0",
+            "resolved": "https://registry.npmjs.org/es-array-method-boxes-properly/-/es-array-method-boxes-properly-1.0.0.tgz",
+            "integrity": "sha512-wd6JXUmyHmt8T5a2xreUwKcGPq6f1f+WwIJkijUqiGcJz1qqnZgP6XIK+QyIWU5lT7imeNxUll48bziG+TSYcA==",
+            "dev": true
+        },
+        "es-get-iterator": {
+            "version": "1.1.0",
+            "resolved": "https://registry.npmjs.org/es-get-iterator/-/es-get-iterator-1.1.0.tgz",
+            "integrity": "sha512-UfrmHuWQlNMTs35e1ypnvikg6jCz3SK8v8ImvmDsh36fCVUR1MqoFDiyn0/k52C8NqO3YsO8Oe0azeesNuqSsQ==",
+            "dev": true,
+            "requires": {
+                "es-abstract": "^1.17.4",
+                "has-symbols": "^1.0.1",
+                "is-arguments": "^1.0.4",
+                "is-map": "^2.0.1",
+                "is-set": "^2.0.1",
+                "is-string": "^1.0.5",
+                "isarray": "^2.0.5"
            }
        },
        "es-to-primitive": {
@@ -782,9 +784,9 @@
            "dev": true
        },
        "eslint": {
-            "version": "7.1.0",
+            "version": "7.3.1",
-            "resolved": "https://registry.npmjs.org/eslint/-/eslint-7.1.0.tgz",
+            "resolved": "https://registry.npmjs.org/eslint/-/eslint-7.3.1.tgz",
-            "integrity": "sha512-DfS3b8iHMK5z/YLSme8K5cge168I8j8o1uiVmFCgnnjxZQbCGyraF8bMl7Ju4yfBmCuxD7shOF7eqGkcuIHfsA==",
+            "integrity": "sha512-cQC/xj9bhWUcyi/RuMbRtC3I0eW8MH0jhRELSvpKYkWep3C6YZ2OkvcvJVUeO6gcunABmzptbXBuDoXsjHmfTA==",
            "dev": true,
            "requires": {
                "@babel/code-frame": "^7.0.0",
@@ -793,10 +795,11 @@
                "cross-spawn": "^7.0.2",
                "debug": "^4.0.1",
                "doctrine": "^3.0.0",
-                "eslint-scope": "^5.0.0",
+                "enquirer": "^2.3.5",
+                "eslint-scope": "^5.1.0",
                "eslint-utils": "^2.0.0",
-                "eslint-visitor-keys": "^1.1.0",
+                "eslint-visitor-keys": "^1.2.0",
-                "espree": "^7.0.0",
+                "espree": "^7.1.0",
                "esquery": "^1.2.0",
                "esutils": "^2.0.2",
                "file-entry-cache": "^5.0.1",
@@ -806,7 +809,6 @@
                "ignore": "^4.0.6",
                "import-fresh": "^3.0.0",
                "imurmurhash": "^0.1.4",
-                "inquirer": "^7.0.0",
                "is-glob": "^4.0.0",
                "js-yaml": "^3.13.1",
                "json-stable-stringify-without-jsonify": "^1.0.1",
@@ -836,9 +838,9 @@
                    }
                },
                "chalk": {
-                    "version": "4.0.0",
+                    "version": "4.1.0",
-                    "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.0.0.tgz",
+                    "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.0.tgz",
-                    "integrity": "sha512-N9oWFcegS0sFr9oh1oz2d7Npos6vNoWW9HvtCg5N1KRFpUhaAhvTv5Y58g880fZaEYSNm3qDz8SU1UrGvp+n7A==",
+                    "integrity": "sha512-qwx12AxXe2Q5xQ43Ac//I6v5aXTipYrSESdOgzrN+9XjgEpyjpKuvSGaN4qE93f7TQTlerQQ8S+EQ0EyDoVL1A==",
                    "dev": true,
                    "requires": {
                        "ansi-styles": "^4.1.0",
@@ -860,6 +862,22 @@
                    "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
                    "dev": true
                },
+                "eslint-scope": {
+                    "version": "5.1.0",
+                    "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-5.1.0.tgz",
+                    "integrity": "sha512-iiGRvtxWqgtx5m8EyQUJihBloE4EnYeGE/bz1wSPwJE6tZuJUtHlhqDM4Xj2ukE8Dyy1+HCZ4hE0fzIVMzb58w==",
+                    "dev": true,
+                    "requires": {
+                        "esrecurse": "^4.1.0",
+                        "estraverse": "^4.1.1"
+                    }
+                },
+                "eslint-visitor-keys": {
+                    "version": "1.3.0",
+                    "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-1.3.0.tgz",
+                    "integrity": "sha512-6J72N8UNa462wa/KFODt/PJ3IU60SDpC3QXC1Hjc1BXXpfL2C9R5+AU7jhe0F6GREqVMh4Juu+NY7xn+6dipUQ==",
+                    "dev": true
+                },
                "has-flag": {
                    "version": "4.0.0",
                    "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
@@ -909,14 +927,22 @@
            "dev": true
        },
        "espree": {
-            "version": "7.0.0",
+            "version": "7.1.0",
-            "resolved": "https://registry.npmjs.org/espree/-/espree-7.0.0.tgz",
+            "resolved": "https://registry.npmjs.org/espree/-/espree-7.1.0.tgz",
-            "integrity": "sha512-/r2XEx5Mw4pgKdyb7GNLQNsu++asx/dltf/CI8RFi9oGHxmQFgvLbc5Op4U6i8Oaj+kdslhJtVlEZeAqH5qOTw==",
+            "integrity": "sha512-dcorZSyfmm4WTuTnE5Y7MEN1DyoPYy1ZR783QW1FJoenn7RailyWFsq/UL6ZAAA7uXurN9FIpYyUs3OfiIW+Qw==",
            "dev": true,
            "requires": {
-                "acorn": "^7.1.1",
+                "acorn": "^7.2.0",
                "acorn-jsx": "^5.2.0",
-                "eslint-visitor-keys": "^1.1.0"
+                "eslint-visitor-keys": "^1.2.0"
+            },
+            "dependencies": {
+                "eslint-visitor-keys": {
+                    "version": "1.3.0",
+                    "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-1.3.0.tgz",
+                    "integrity": "sha512-6J72N8UNa462wa/KFODt/PJ3IU60SDpC3QXC1Hjc1BXXpfL2C9R5+AU7jhe0F6GREqVMh4Juu+NY7xn+6dipUQ==",
+                    "dev": true
+                }
            }
        },
        "esprima": {
@@ -969,21 +995,10 @@
            "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==",
            "dev": true
        },
-        "external-editor": {
-            "version": "3.1.0",
-            "resolved": "https://registry.npmjs.org/external-editor/-/external-editor-3.1.0.tgz",
-            "integrity": "sha512-hMQ4CX1p1izmuLYyZqLMO/qGNw10wSv9QDCPfzXfyFrOaCSSoRfqE1Kf1s5an66J5JZC62NewG+mK49jOCtQew==",
-            "dev": true,
-            "requires": {
-                "chardet": "^0.7.0",
-                "iconv-lite": "^0.4.24",
-                "tmp": "^0.0.33"
-            }
-        },
        "fast-deep-equal": {
-            "version": "3.1.1",
+            "version": "3.1.3",
-            "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.1.tgz",
+            "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
-            "integrity": "sha512-8UEa58QDLauDNfpbrX55Q9jrGHThw2ZMdOky5Gl1CDtVeJDPVrG4Jxx1N8jw2gkWaff5UUuX1KJd+9zGe2B+ZA==",
+            "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==",
            "dev": true
        },
        "fast-json-stable-stringify": {
@@ -1007,15 +1022,6 @@
                "pend": "~1.2.0"
            }
        },
-        "figures": {
-            "version": "3.2.0",
-            "resolved": "https://registry.npmjs.org/figures/-/figures-3.2.0.tgz",
-            "integrity": "sha512-yaduQFRKLXYOGgEn6AZau90j3ggSOyiqXU0F9JZfeXYhNa+Jk4X+s45A2zg5jns87GAFa34BBm2kXw4XpNcbdg==",
-            "dev": true,
-            "requires": {
-                "escape-string-regexp": "^1.0.5"
-            }
-        },
        "file-entry-cache": {
            "version": "5.0.1",
            "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-5.0.1.tgz",
@@ -1035,12 +1041,13 @@
            }
        },
        "find-up": {
-            "version": "3.0.0",
+            "version": "4.1.0",
-            "resolved": "https://registry.npmjs.org/find-up/-/find-up-3.0.0.tgz",
+            "resolved": "https://registry.npmjs.org/find-up/-/find-up-4.1.0.tgz",
-            "integrity": "sha512-1yD6RmLI1XBfxugvORwlck6f75tYL+iR0jqwsOrOxMZyGYqUuDhJ0l4AXdO1iX/FTs9cBAMEk1gWSEx1kSbylg==",
+            "integrity": "sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==",
            "dev": true,
            "requires": {
-                "locate-path": "^3.0.0"
+                "locate-path": "^5.0.0",
+                "path-exists": "^4.0.0"
            }
        },
        "flat": {
@@ -1238,15 +1245,6 @@
                }
            }
        },
-        "iconv-lite": {
-            "version": "0.4.24",
-            "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz",
-            "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==",
-            "dev": true,
-            "requires": {
-                "safer-buffer": ">= 2.1.2 < 3"
-            }
-        },
        "ignore": {
            "version": "4.0.6",
            "resolved": "https://registry.npmjs.org/ignore/-/ignore-4.0.6.tgz",
@@ -1285,78 +1283,11 @@
            "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
            "dev": true
        },
-        "inquirer": {
+        "is-arguments": {
-            "version": "7.1.0",
+            "version": "1.0.4",
-            "resolved": "https://registry.npmjs.org/inquirer/-/inquirer-7.1.0.tgz",
+            "resolved": "https://registry.npmjs.org/is-arguments/-/is-arguments-1.0.4.tgz",
-            "integrity": "sha512-5fJMWEmikSYu0nv/flMc475MhGbB7TSPd/2IpFV4I4rMklboCH2rQjYY5kKiYGHqUF9gvaambupcJFFG9dvReg==",
+            "integrity": "sha512-xPh0Rmt8NE65sNzvyUmWgI1tz3mKq74lGA0mL8LYZcoIzKOzDh6HmrYm3d18k60nHerC8A9Km8kYu87zfSFnLA==",
-            "dev": true,
+            "dev": true
-            "requires": {
-                "ansi-escapes": "^4.2.1",
-                "chalk": "^3.0.0",
-                "cli-cursor": "^3.1.0",
-                "cli-width": "^2.0.0",
-                "external-editor": "^3.0.3",
-                "figures": "^3.0.0",
-                "lodash": "^4.17.15",
-                "mute-stream": "0.0.8",
-                "run-async": "^2.4.0",
-                "rxjs": "^6.5.3",
-                "string-width": "^4.1.0",
-                "strip-ansi": "^6.0.0",
-                "through": "^2.3.6"
-            },
-            "dependencies": {
-                "ansi-styles": {
-                    "version": "4.2.1",
-                    "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.2.1.tgz",
-                    "integrity": "sha512-9VGjrMsG1vePxcSweQsN20KY/c4zN0h9fLjqAbwbPfahM3t+NL+M9HC8xeXG2I8pX5NoamTGNuomEUFI7fcUjA==",
-                    "dev": true,
-                    "requires": {
-                        "@types/color-name": "^1.1.1",
-                        "color-convert": "^2.0.1"
-                    }
-                },
-                "chalk": {
-                    "version": "3.0.0",
-                    "resolved": "https://registry.npmjs.org/chalk/-/chalk-3.0.0.tgz",
-                    "integrity": "sha512-4D3B6Wf41KOYRFdszmDqMCGq5VV/uMAB273JILmO+3jAlh8X4qDtdtgCR3fxtbLEMzSx22QdhnDcJvu2u1fVwg==",
-                    "dev": true,
-                    "requires": {
-                        "ansi-styles": "^4.1.0",
-                        "supports-color": "^7.1.0"
-                    }
-                },
-                "color-convert": {
-                    "version": "2.0.1",
-                    "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
-                    "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
-                    "dev": true,
-                    "requires": {
-                        "color-name": "~1.1.4"
-                    }
-                },
-                "color-name": {
-                    "version": "1.1.4",
-                    "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
-                    "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
-                    "dev": true
-                },
-                "has-flag": {
-                    "version": "4.0.0",
-                    "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
-                    "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
-                    "dev": true
-                },
-                "supports-color": {
-                    "version": "7.1.0",
-                    "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.1.0.tgz",
-                    "integrity": "sha512-oRSIpR8pxT1Wr2FquTNnGet79b3BWljqOuoW/h4oBhxJ/HUbX5nX6JSruTkvXDCFMwDPvsaTTbvMLKZWSy0R5g==",
-                    "dev": true,
-                    "requires": {
-                        "has-flag": "^4.0.0"
-                    }
-                }
-            }
        },
        "is-binary-path": {
            "version": "2.1.0",
@@ -1374,9 +1305,9 @@
            "dev": true
        },
        "is-callable": {
-            "version": "1.1.5",
+            "version": "1.2.0",
-            "resolved": "https://registry.npmjs.org/is-callable/-/is-callable-1.1.5.tgz",
+            "resolved": "https://registry.npmjs.org/is-callable/-/is-callable-1.2.0.tgz",
-            "integrity": "sha512-ESKv5sMCJB2jnHTWZ3O5itG+O128Hsus4K4Qh1h2/cgn2vbgnLSVqfV46AeJA9D5EeeLa9w81KUXMtn34zhX+Q==",
+            "integrity": "sha512-pyVD9AaGLxtg6srb2Ng6ynWJqkHU9bEM087AKck0w8QwDarTfNcpIYoU8x8Hv2Icm8u6kFJM18Dag8lyqGkviw==",
            "dev": true
        },
        "is-date-object": {
@@ -1392,9 +1323,9 @@
            "dev": true
        },
        "is-fullwidth-code-point": {
-            "version": "3.0.0",
+            "version": "2.0.0",
-            "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
+            "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz",
-            "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
+            "integrity": "sha1-o7MKXE8ZkYMWeqq5O+764937ZU8=",
            "dev": true
        },
        "is-glob": {
@@ -1406,6 +1337,12 @@
                "is-extglob": "^2.1.1"
            }
        },
+        "is-map": {
+            "version": "2.0.1",
+            "resolved": "https://registry.npmjs.org/is-map/-/is-map-2.0.1.tgz",
+            "integrity": "sha512-T/S49scO8plUiAOA2DBTBG3JHpn1yiw0kRp6dgiZ0v2/6twi5eiB0rHtHFH9ZIrvlWc6+4O+m4zg5+Z833aXgw==",
+            "dev": true
+        },
        "is-module": {
            "version": "1.0.0",
            "resolved": "https://registry.npmjs.org/is-module/-/is-module-1.0.0.tgz",
@@ -1419,23 +1356,35 @@
            "dev": true
        },
        "is-reference": {
-            "version": "1.1.4",
+            "version": "1.2.1",
-            "resolved": "https://registry.npmjs.org/is-reference/-/is-reference-1.1.4.tgz",
+            "resolved": "https://registry.npmjs.org/is-reference/-/is-reference-1.2.1.tgz",
-            "integrity": "sha512-uJA/CDPO3Tao3GTrxYn6AwkM4nUPJiGGYu5+cB8qbC7WGFlrKZbiRo7SFKxUAEpFUfiHofWCXBUNhvYJMh+6zw==",
+            "integrity": "sha512-U82MsXXiFIrjCK4otLT+o2NA2Cd2g5MLoOVXUZjIOhLurrRxpEXzI8O0KZHr3IjLvlAH1kTPYSuqer5T9ZVBKQ==",
            "dev": true,
            "requires": {
-                "@types/estree": "0.0.39"
+                "@types/estree": "*"
            }
        },
        "is-regex": {
-            "version": "1.0.5",
+            "version": "1.1.0",
-            "resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.0.5.tgz",
+            "resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.1.0.tgz",
-            "integrity": "sha512-vlKW17SNq44owv5AQR3Cq0bQPEb8+kF3UKZ2fiZNOWtztYE5i0CzCZxFDwO58qAOWtxdBRVO/V5Qin1wjCqFYQ==",
+            "integrity": "sha512-iI97M8KTWID2la5uYXlkbSDQIg4F6o1sYboZKKTDpnDQMLtUL86zxhgDet3Q2SriaYsyGqZ6Mn2SjbRKeLHdqw==",
            "dev": true,
            "requires": {
-                "has": "^1.0.3"
+                "has-symbols": "^1.0.1"
            }
        },
+        "is-set": {
+            "version": "2.0.1",
+            "resolved": "https://registry.npmjs.org/is-set/-/is-set-2.0.1.tgz",
+            "integrity": "sha512-eJEzOtVyenDs1TMzSQ3kU3K+E0GUS9sno+F0OBT97xsgcJsF9nXMBtkT9/kut5JEpM7oL7X/0qxR17K3mcwIAA==",
+            "dev": true
+        },
+        "is-string": {
+            "version": "1.0.5",
+            "resolved": "https://registry.npmjs.org/is-string/-/is-string-1.0.5.tgz",
+            "integrity": "sha512-buY6VNRjhQMiF1qWDouloZlQbRhDPCebwxSjxMjxgemYT46YMd2NR0/H+fBhEfWX4A/w9TBJ+ol+okqJKFE6vQ==",
+            "dev": true
+        },
        "is-symbol": {
            "version": "1.0.3",
            "resolved": "https://registry.npmjs.org/is-symbol/-/is-symbol-1.0.3.tgz",
@@ -1445,12 +1394,34 @@
                "has-symbols": "^1.0.1"
            }
        },
+        "isarray": {
+            "version": "2.0.5",
+            "resolved": "https://registry.npmjs.org/isarray/-/isarray-2.0.5.tgz",
+            "integrity": "sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw==",
+            "dev": true
+        },
        "isexe": {
            "version": "2.0.0",
            "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
            "integrity": "sha1-6PvzdNxVb/iUehDcsFctYz8s+hA=",
            "dev": true
        },
+        "iterate-iterator": {
+            "version": "1.0.1",
+            "resolved": "https://registry.npmjs.org/iterate-iterator/-/iterate-iterator-1.0.1.tgz",
+            "integrity": "sha512-3Q6tudGN05kbkDQDI4CqjaBf4qf85w6W6GnuZDtUVYwKgtC1q8yxYX7CZed7N+tLzQqS6roujWvszf13T+n9aw==",
+            "dev": true
+        },
+        "iterate-value": {
+            "version": "1.0.2",
+            "resolved": "https://registry.npmjs.org/iterate-value/-/iterate-value-1.0.2.tgz",
+            "integrity": "sha512-A6fMAio4D2ot2r/TYzr4yUWrmwNdsN5xL7+HUiyACE4DXm+q8HtPcnFTp+NnW3k4N05tZ7FVYFFb2CR13NxyHQ==",
+            "dev": true,
+            "requires": {
+                "es-get-iterator": "^1.0.2",
+                "iterate-iterator": "^1.0.1"
+            }
+        },
        "js-tokens": {
            "version": "4.0.0",
            "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
@@ -1505,13 +1476,12 @@
            }
        },
        "locate-path": {
-            "version": "3.0.0",
+            "version": "5.0.0",
-            "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-3.0.0.tgz",
+            "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-5.0.0.tgz",
-            "integrity": "sha512-7AO748wWnIhNqAuaty2ZWHkQHRSNfPVIsPIfwEOWO22AmaoVrWavlOcMR5nzTLNYvp36X220/maaRsrec1G65A==",
+            "integrity": "sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==",
            "dev": true,
            "requires": {
-                "p-locate": "^3.0.0",
+                "p-locate": "^4.1.0"
-                "path-exists": "^3.0.0"
            }
        },
        "lodash": {
@@ -1596,12 +1566,6 @@
                "mime-db": "1.44.0"
            }
        },
-        "mimic-fn": {
-            "version": "2.1.0",
-            "resolved": "https://registry.npmjs.org/mimic-fn/-/mimic-fn-2.1.0.tgz",
-            "integrity": "sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==",
-            "dev": true
-        },
        "minimatch": {
            "version": "3.0.4",
            "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.0.4.tgz",
@@ -1627,37 +1591,44 @@
            }
        },
        "mocha": {
-            "version": "7.2.0",
+            "version": "8.0.1",
-            "resolved": "https://registry.npmjs.org/mocha/-/mocha-7.2.0.tgz",
+            "resolved": "https://registry.npmjs.org/mocha/-/mocha-8.0.1.tgz",
-            "integrity": "sha512-O9CIypScywTVpNaRrCAgoUnJgozpIofjKUYmJhiCIJMiuYnLI6otcb1/kpW9/n/tJODHGZ7i8aLQoDVsMtOKQQ==",
+            "integrity": "sha512-vefaXfdYI8+Yo8nPZQQi0QO2o+5q9UIMX1jZ1XMmK3+4+CQjc7+B0hPdUeglXiTlr8IHMVRo63IhO9Mzt6fxOg==",
            "dev": true,
            "requires": {
-                "ansi-colors": "3.2.3",
+                "ansi-colors": "4.1.1",
                "browser-stdout": "1.3.1",
-                "chokidar": "3.3.0",
+                "chokidar": "3.3.1",
                "debug": "3.2.6",
-                "diff": "3.5.0",
+                "diff": "4.0.2",
                "escape-string-regexp": "1.0.5",
-                "find-up": "3.0.0",
+                "find-up": "4.1.0",
-                "glob": "7.1.3",
+                "glob": "7.1.6",
                "growl": "1.10.5",
                "he": "1.2.0",
                "js-yaml": "3.13.1",
                "log-symbols": "3.0.0",
                "minimatch": "3.0.4",
-                "mkdirp": "0.5.5",
+                "ms": "2.1.2",
-                "ms": "2.1.1",
-                "node-environment-flags": "1.0.6",
                "object.assign": "4.1.0",
-                "strip-json-comments": "2.0.1",
+                "promise.allsettled": "1.0.2",
-                "supports-color": "6.0.0",
+                "serialize-javascript": "3.0.0",
-                "which": "1.3.1",
+                "strip-json-comments": "3.0.1",
+                "supports-color": "7.1.0",
+                "which": "2.0.2",
                "wide-align": "1.1.3",
+                "workerpool": "6.0.0",
                "yargs": "13.3.2",
                "yargs-parser": "13.1.2",
                "yargs-unparser": "1.6.0"
            },
            "dependencies": {
+                "ansi-colors": {
+                    "version": "4.1.1",
+                    "resolved": "https://registry.npmjs.org/ansi-colors/-/ansi-colors-4.1.1.tgz",
+                    "integrity": "sha512-JoX0apGbHaUJBNl6yF+p6JAFYZ666/hhCGKN5t9QFjbJQKUU/g8MNbFDbvfrgKXvI1QpZplPOnwIo99lX/AAmA==",
+                    "dev": true
+                },
                "debug": {
                    "version": "3.2.6",
                    "resolved": "https://registry.npmjs.org/debug/-/debug-3.2.6.tgz",
@@ -1667,19 +1638,11 @@
                        "ms": "^2.1.1"
                    }
                },
-                "glob": {
+                "has-flag": {
-                    "version": "7.1.3",
+                    "version": "4.0.0",
-                    "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.3.tgz",
+                    "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
-                    "integrity": "sha512-vcfuiIxogLV4DlGBHIUOwI0IbrJ8HWPc4MU7HzviGeNho/UJDfi6B5p3sHeWIQ0KGIU0Jpxi5ZHxemQfLkkAwQ==",
+                    "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
-                    "dev": true,
+                    "dev": true
-                    "requires": {
-                        "fs.realpath": "^1.0.0",
-                        "inflight": "^1.0.4",
-                        "inherits": "2",
-                        "minimatch": "^3.0.4",
-                        "once": "^1.3.0",
-                        "path-is-absolute": "^1.0.0"
-                    }
                },
                "js-yaml": {
                    "version": "3.13.1",
@@ -1691,34 +1654,19 @@
                        "esprima": "^4.0.0"
                    }
                },
-                "ms": {
-                    "version": "2.1.1",
-                    "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.1.tgz",
-                    "integrity": "sha512-tgp+dl5cGk28utYktBsrFqA7HKgrhgPsg6Z/EfhWI4gl1Hwq8B/GmY/0oXZ6nF8hDVesS/FpnYaD/kOWhYQvyg==",
-                    "dev": true
-                },
                "strip-json-comments": {
-                    "version": "2.0.1",
+                    "version": "3.0.1",
-                    "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-2.0.1.tgz",
+                    "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.0.1.tgz",
-                    "integrity": "sha1-PFMZQukIwml8DsNEhYwobHygpgo=",
+                    "integrity": "sha512-VTyMAUfdm047mwKl+u79WIdrZxtFtn+nBxHeb844XBQ9uMNTuTHdx2hc5RiAJYqwTj3wc/xe5HLSdJSkJ+WfZw==",
                    "dev": true
                },
                "supports-color": {
-                    "version": "6.0.0",
+                    "version": "7.1.0",
-                    "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-6.0.0.tgz",
+                    "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.1.0.tgz",
-                    "integrity": "sha512-on9Kwidc1IUQo+bQdhi8+Tijpo0e1SS6RoGo2guUwn5vdaxw8RXOF9Vb2ws+ihWOmh4JnCJOvaziZWP1VABaLg==",
+                    "integrity": "sha512-oRSIpR8pxT1Wr2FquTNnGet79b3BWljqOuoW/h4oBhxJ/HUbX5nX6JSruTkvXDCFMwDPvsaTTbvMLKZWSy0R5g==",
-                    "dev": true,
-                    "requires": {
-                        "has-flag": "^3.0.0"
-                    }
-                },
-                "which": {
-                    "version": "1.3.1",
-                    "resolved": "https://registry.npmjs.org/which/-/which-1.3.1.tgz",
-                    "integrity": "sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ==",
                    "dev": true,
                    "requires": {
-                        "isexe": "^2.0.0"
+                        "has-flag": "^4.0.0"
                    }
                }
            }
@@ -1741,24 +1689,6 @@
            "integrity": "sha1-Sr6/7tdUHywnrPspvbvRXI1bpPc=",
            "dev": true
        },
-        "node-environment-flags": {
-            "version": "1.0.6",
-            "resolved": "https://registry.npmjs.org/node-environment-flags/-/node-environment-flags-1.0.6.tgz",
-            "integrity": "sha512-5Evy2epuL+6TM0lCQGpFIj6KwiEsGh1SrHUhTbNX+sLbBtjidPZFAnVK9y5yU1+h//RitLbRHTIMyxQPtxMdHw==",
-            "dev": true,
-            "requires": {
-                "object.getownpropertydescriptors": "^2.0.3",
-                "semver": "^5.7.0"
-            },
-            "dependencies": {
-                "semver": {
-                    "version": "5.7.1",
-                    "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.1.tgz",
-                    "integrity": "sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ==",
-                    "dev": true
-                }
-            }
-        },
        "node-fetch": {
            "version": "2.6.0",
            "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.6.0.tgz",
@@ -1780,9 +1710,9 @@
            }
        },
        "object-inspect": {
-            "version": "1.7.0",
+            "version": "1.8.0",
-            "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.7.0.tgz",
+            "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.8.0.tgz",
-            "integrity": "sha512-a7pEHdh1xKIAgTySUGgLMx/xwDZskN1Ud6egYYN3EdRW4ZMPNEDUTF+hwy2LUC+Bl+SyLXANnwz/jyh/qutKUw==",
+            "integrity": "sha512-jLdtEOB112fORuypAyl/50VRVIBIdVQOSUUGQHzJ4xBSbit81zRarz7GThkEFZy1RceYrWYcPcBFPQwHyAc1gA==",
            "dev": true
        },
        "object-keys": {
@@ -1803,16 +1733,6 @@
                "object-keys": "^1.0.11"
            }
        },
-        "object.getownpropertydescriptors": {
-            "version": "2.1.0",
-            "resolved": "https://registry.npmjs.org/object.getownpropertydescriptors/-/object.getownpropertydescriptors-2.1.0.tgz",
-            "integrity": "sha512-Z53Oah9A3TdLoblT7VKJaTDdXdT+lQO+cNpKVnya5JDe9uLvzu1YyY1yFDFrcxrlRgWrEFH0jJtD/IbuwjcEVg==",
-            "dev": true,
-            "requires": {
-                "define-properties": "^1.1.3",
-                "es-abstract": "^1.17.0-next.1"
-            }
-        },
        "once": {
            "version": "1.4.0",
            "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
@@ -1822,15 +1742,6 @@
                "wrappy": "1"
            }
        },
-        "onetime": {
-            "version": "5.1.0",
-            "resolved": "https://registry.npmjs.org/onetime/-/onetime-5.1.0.tgz",
-            "integrity": "sha512-5NcSkPHhwTVFIQN+TUqXoS5+dlElHXdpAWu9I0HP20YOtIi+aZ0Ct82jdlILDxjLEAWwvm+qj1m6aEtsDVmm6Q==",
-            "dev": true,
-            "requires": {
-                "mimic-fn": "^2.1.0"
-            }
-        },
        "optionator": {
            "version": "0.9.1",
            "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.1.tgz",
@@ -1883,12 +1794,12 @@
            }
        },
        "p-locate": {
-            "version": "3.0.0",
+            "version": "4.1.0",
-            "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-3.0.0.tgz",
+            "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-4.1.0.tgz",
-            "integrity": "sha512-x+12w/To+4GFfgJhBEpiDcLozRJGegY+Ei7/z0tSLkMmxGZNybVMSfWj9aJn8Z5Fc7dBUNJOOVgPv2H7IwulSQ==",
+            "integrity": "sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==",
            "dev": true,
            "requires": {
-                "p-limit": "^2.0.0"
+                "p-limit": "^2.2.0"
            }
        },
        "p-try": {
@@ -1933,9 +1844,9 @@
            }
        },
        "path-exists": {
-            "version": "3.0.0",
+            "version": "4.0.0",
-            "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-3.0.0.tgz",
+            "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz",
-            "integrity": "sha1-zg6+ql94yxiSXqfYENe1mwEP1RU=",
+            "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==",
            "dev": true
        },
        "path-is-absolute": {
@@ -1980,6 +1891,19 @@
            "integrity": "sha512-7PiHtLll5LdnKIMw100I+8xJXR5gW2QwWYkT6iJva0bXitZKa/XMrSbdmg3r2Xnaidz9Qumd0VPaMrZlF9V9sA==",
            "dev": true
        },
+        "promise.allsettled": {
+            "version": "1.0.2",
+            "resolved": "https://registry.npmjs.org/promise.allsettled/-/promise.allsettled-1.0.2.tgz",
+            "integrity": "sha512-UpcYW5S1RaNKT6pd+s9jp9K9rlQge1UXKskec0j6Mmuq7UJCvlS2J2/s/yuPN8ehftf9HXMxWlKiPbGGUzpoRg==",
+            "dev": true,
+            "requires": {
+                "array.prototype.map": "^1.0.1",
+                "define-properties": "^1.1.3",
+                "es-abstract": "^1.17.0-next.1",
+                "function-bind": "^1.1.1",
+                "iterate-value": "^1.0.0"
+            }
+        },
        "pseudomap": {
            "version": "1.0.2",
            "resolved": "https://registry.npmjs.org/pseudomap/-/pseudomap-1.0.2.tgz",
@@ -2013,12 +1937,12 @@
            }
        },
        "readdirp": {
-            "version": "3.2.0",
+            "version": "3.3.0",
-            "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.2.0.tgz",
+            "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.3.0.tgz",
-            "integrity": "sha512-crk4Qu3pmXwgxdSgGhgA/eXiJAPQiX4GMOZZMXnqKxHX7TaoL+3gQVo/WeuAiogr07DpnfjIMpXXa+PAIvwPGQ==",
+            "integrity": "sha512-zz0pAkSPOXXm1viEwygWIPSPkcBYjW1xU5j/JBh5t9bGCJwa6f9+BJa6VaB2g+b55yVrmXzqkyLf4xaWYM0IkQ==",
            "dev": true,
            "requires": {
-                "picomatch": "^2.0.4"
+                "picomatch": "^2.0.7"
            }
        },
        "regexpp": {
@@ -2054,16 +1978,6 @@
            "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==",
            "dev": true
        },
-        "restore-cursor": {
-            "version": "3.1.0",
-            "resolved": "https://registry.npmjs.org/restore-cursor/-/restore-cursor-3.1.0.tgz",
-            "integrity": "sha512-l+sSefzHpj5qimhFSE5a8nufZYAM3sBSVMAPtYkmC+4EH2anSGaEMXSD0izRQbu9nfyQ9y5JrVmp7E8oZrUjvA==",
-            "dev": true,
-            "requires": {
-                "onetime": "^5.1.0",
-                "signal-exit": "^3.0.2"
-            }
-        },
        "rimraf": {
            "version": "2.6.3",
            "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-2.6.3.tgz",
@@ -2074,54 +1988,31 @@
            }
        },
        "rollup": {
-            "version": "2.10.9",
+            "version": "2.18.1",
-            "resolved": "https://registry.npmjs.org/rollup/-/rollup-2.10.9.tgz",
+            "resolved": "https://registry.npmjs.org/rollup/-/rollup-2.18.1.tgz",
-            "integrity": "sha512-dY/EbjiWC17ZCUSyk14hkxATAMAShkMsD43XmZGWjLrgFj15M3Dw2kEkA9ns64BiLFm9PKN6vTQw8neHwK74eg==",
+            "integrity": "sha512-w4X77ADA+WTGlapC8Z6yggdJtODw3SBl6R2LSkA7ZW5MtdkgcB7sfaSD1UWyx8diXbMcGIb0eI9gCx/dyqOgNQ==",
            "dev": true,
            "requires": {
                "fsevents": "~2.1.2"
            }
        },
-        "run-async": {
-            "version": "2.4.1",
-            "resolved": "https://registry.npmjs.org/run-async/-/run-async-2.4.1.tgz",
-            "integrity": "sha512-tvVnVv01b8c1RrA6Ep7JkStj85Guv/YrMcwqYQnwjsAS2cTmmPGBBjAjpCW7RrSodNSoE2/qg9O4bceNvUuDgQ==",
-            "dev": true
-        },
-        "rxjs": {
-            "version": "6.5.5",
-            "resolved": "https://registry.npmjs.org/rxjs/-/rxjs-6.5.5.tgz",
-            "integrity": "sha512-WfQI+1gohdf0Dai/Bbmk5L5ItH5tYqm3ki2c5GdWhKjalzjg93N3avFjVStyZZz+A2Em+ZxKH5bNghw9UeylGQ==",
-            "dev": true,
-            "requires": {
-                "tslib": "^1.9.0"
-            },
-            "dependencies": {
-                "tslib": {
-                    "version": "1.13.0",
-                    "resolved": "https://registry.npmjs.org/tslib/-/tslib-1.13.0.tgz",
-                    "integrity": "sha512-i/6DQjL8Xf3be4K/E6Wgpekn5Qasl1usyw++dAA35Ue5orEn65VIxOA+YvNNl9HV3qv70T7CNwjODHZrLwvd1Q==",
-                    "dev": true
-                }
-            }
-        },
        "safe-buffer": {
            "version": "5.2.0",
            "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.0.tgz",
            "integrity": "sha512-fZEwUGbVl7kouZs1jCdMLdt95hdIv0ZeHg6L7qPeciMZhZ+/gdesW4wgTARkrFWEpspjEATAzUGPG8N2jJiwbg==",
            "dev": true
        },
-        "safer-buffer": {
-            "version": "2.1.2",
-            "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
-            "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==",
-            "dev": true
-        },
        "semver": {
            "version": "6.3.0",
            "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz",
            "integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw=="
        },
+        "serialize-javascript": {
+            "version": "3.0.0",
+            "resolved": "https://registry.npmjs.org/serialize-javascript/-/serialize-javascript-3.0.0.tgz",
+            "integrity": "sha512-skZcHYw2vEX4bw90nAr2iTTsz6x2SrHEnfxgKYmZlvJYBEZrvbKtobJWlQ20zczKb3bsHHXXTYt48zBA7ni9cw==",
+            "dev": true
+        },
        "set-blocking": {
            "version": "2.0.0",
            "resolved": "https://registry.npmjs.org/set-blocking/-/set-blocking-2.0.0.tgz",
@@ -2149,12 +2040,6 @@
            "integrity": "sha1-P/IfGYytIXX587eBhT/ZTQ0ZtZA=",
            "dev": true
        },
-        "signal-exit": {
-            "version": "3.0.3",
-            "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.3.tgz",
-            "integrity": "sha512-VUJ49FC8U1OxwZLxIbTTrDvLnf/6TDgxZcK8wxR8zs13xpx7xbG60ndBlhNrFi2EMuFRoeDoJO7wthSLq42EjA==",
-            "dev": true
-        },
        "slice-ansi": {
            "version": "2.1.0",
            "resolved": "https://registry.npmjs.org/slice-ansi/-/slice-ansi-2.1.0.tgz",
@@ -2164,14 +2049,6 @@
                "ansi-styles": "^3.2.0",
                "astral-regex": "^1.0.0",
                "is-fullwidth-code-point": "^2.0.0"
-            },
-            "dependencies": {
-                "is-fullwidth-code-point": {
-                    "version": "2.0.0",
-                    "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz",
-                    "integrity": "sha1-o7MKXE8ZkYMWeqq5O+764937ZU8=",
-                    "dev": true
-                }
            }
        },
        "sourcemap-codec": {
@@ -2187,14 +2064,31 @@
            "dev": true
        },
        "string-width": {
-            "version": "4.2.0",
+            "version": "3.1.0",
-            "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.0.tgz",
+            "resolved": "https://registry.npmjs.org/string-width/-/string-width-3.1.0.tgz",
-            "integrity": "sha512-zUz5JD+tgqtuDjMhwIg5uFVV3dtqZ9yQJlZVfq4I01/K5Paj5UHj7VyrQOJvzawSVlKpObApbfD0Ed6yJc+1eg==",
+            "integrity": "sha512-vafcv6KjVZKSgz06oM/H6GDBrAtz8vdhQakGjFIvNrHA6y3HCF1CInLy+QLq8dTJPQ1b+KDUqDFctkdRW44e1w==",
            "dev": true,
            "requires": {
-                "emoji-regex": "^8.0.0",
+                "emoji-regex": "^7.0.1",
-                "is-fullwidth-code-point": "^3.0.0",
+                "is-fullwidth-code-point": "^2.0.0",
-                "strip-ansi": "^6.0.0"
+                "strip-ansi": "^5.1.0"
+            },
+            "dependencies": {
+                "ansi-regex": {
+                    "version": "4.1.0",
+                    "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-4.1.0.tgz",
+                    "integrity": "sha512-1apePfXM1UOSqw0o9IiFAovVz9M5S1Dg+4TrDwfMewQ6p/rmMueb7tWZjQ1rx4Loy1ArBggoqGpfqqdI4rondg==",
+                    "dev": true
+                },
+                "strip-ansi": {
+                    "version": "5.2.0",
+                    "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-5.2.0.tgz",
+                    "integrity": "sha512-DuRs1gKbBqsMKIZlrffwlug8MHkcnpjs5VPmL1PAh+mA30U0DTotfDZ0d2UUsXpPmPmMMJ6W773MaA3J+lbiWA==",
+                    "dev": true,
+                    "requires": {
+                        "ansi-regex": "^4.1.0"
+                    }
+                }
            }
        },
        "string.prototype.trimend": {
@@ -2207,28 +2101,6 @@
                "es-abstract": "^1.17.5"
            }
        },
-        "string.prototype.trimleft": {
-            "version": "2.1.2",
-            "resolved": "https://registry.npmjs.org/string.prototype.trimleft/-/string.prototype.trimleft-2.1.2.tgz",
-            "integrity": "sha512-gCA0tza1JBvqr3bfAIFJGqfdRTyPae82+KTnm3coDXkZN9wnuW3HjGgN386D7hfv5CHQYCI022/rJPVlqXyHSw==",
-            "dev": true,
-            "requires": {
-                "define-properties": "^1.1.3",
-                "es-abstract": "^1.17.5",
-                "string.prototype.trimstart": "^1.0.0"
-            }
-        },
-        "string.prototype.trimright": {
-            "version": "2.1.2",
-            "resolved": "https://registry.npmjs.org/string.prototype.trimright/-/string.prototype.trimright-2.1.2.tgz",
-            "integrity": "sha512-ZNRQ7sY3KroTaYjRS6EbNiiHrOkjihL9aQE/8gfQ4DtAC/aEBRHFJa44OmoWxGGqXuJlfKkZW4WcXErGr+9ZFg==",
-            "dev": true,
-            "requires": {
-                "define-properties": "^1.1.3",
-                "es-abstract": "^1.17.5",
-                "string.prototype.trimend": "^1.0.0"
-            }
-        },
        "string.prototype.trimstart": {
            "version": "1.0.1",
            "resolved": "https://registry.npmjs.org/string.prototype.trimstart/-/string.prototype.trimstart-1.0.1.tgz",
@@ -2282,46 +2154,6 @@
                "lodash": "^4.17.14",
                "slice-ansi": "^2.1.0",
                "string-width": "^3.0.0"
-            },
-            "dependencies": {
-                "ansi-regex": {
-                    "version": "4.1.0",
-                    "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-4.1.0.tgz",
-                    "integrity": "sha512-1apePfXM1UOSqw0o9IiFAovVz9M5S1Dg+4TrDwfMewQ6p/rmMueb7tWZjQ1rx4Loy1ArBggoqGpfqqdI4rondg==",
-                    "dev": true
-                },
-                "emoji-regex": {
-                    "version": "7.0.3",
-                    "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-7.0.3.tgz",
-                    "integrity": "sha512-CwBLREIQ7LvYFB0WyRvwhq5N5qPhc6PMjD6bYggFlI5YyDgl+0vxq5VHbMOFqLg7hfWzmu8T5Z1QofhmTIhItA==",
-                    "dev": true
-                },
-                "is-fullwidth-code-point": {
-                    "version": "2.0.0",
-                    "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz",
-                    "integrity": "sha1-o7MKXE8ZkYMWeqq5O+764937ZU8=",
-                    "dev": true
-                },
-                "string-width": {
-                    "version": "3.1.0",
-                    "resolved": "https://registry.npmjs.org/string-width/-/string-width-3.1.0.tgz",
-                    "integrity": "sha512-vafcv6KjVZKSgz06oM/H6GDBrAtz8vdhQakGjFIvNrHA6y3HCF1CInLy+QLq8dTJPQ1b+KDUqDFctkdRW44e1w==",
-                    "dev": true,
-                    "requires": {
-                        "emoji-regex": "^7.0.1",
-                        "is-fullwidth-code-point": "^2.0.0",
-                        "strip-ansi": "^5.1.0"
-                    }
-                },
-                "strip-ansi": {
-                    "version": "5.2.0",
-                    "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-5.2.0.tgz",
-                    "integrity": "sha512-DuRs1gKbBqsMKIZlrffwlug8MHkcnpjs5VPmL1PAh+mA30U0DTotfDZ0d2UUsXpPmPmMMJ6W773MaA3J+lbiWA==",
-                    "dev": true,
-                    "requires": {
-                        "ansi-regex": "^4.1.0"
-                    }
-                }
            }
        },
        "text-table": {
@@ -2330,21 +2162,6 @@
            "integrity": "sha1-f17oI66AUgfACvLfSoTsP8+lcLQ=",
            "dev": true
        },
-        "through": {
-            "version": "2.3.8",
-            "resolved": "https://registry.npmjs.org/through/-/through-2.3.8.tgz",
-            "integrity": "sha1-DdTJ/6q8NXlgsbckEV1+Doai4fU=",
-            "dev": true
-        },
-        "tmp": {
-            "version": "0.0.33",
-            "resolved": "https://registry.npmjs.org/tmp/-/tmp-0.0.33.tgz",
-            "integrity": "sha512-jRCJlojKnZ3addtTOjdIqoRuPEKBvNXcGYqzO6zWZX8KfKEpnGY5jfggJQ3EjKuu8D4bJRr0y+cYJFmYbImXGw==",
-            "dev": true,
-            "requires": {
-                "os-tmpdir": "~1.0.2"
-            }
-        },
        "to-regex-range": {
            "version": "5.0.1",
            "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
@@ -2409,9 +2226,9 @@
            }
        },
        "typescript": {
-            "version": "3.9.3",
+            "version": "3.9.5",
-            "resolved": "https://registry.npmjs.org/typescript/-/typescript-3.9.3.tgz",
+            "resolved": "https://registry.npmjs.org/typescript/-/typescript-3.9.5.tgz",
-            "integrity": "sha512-D/wqnB2xzNFIcoBG9FG8cXRDjiqSTbG2wd8DMZeQyJlP1vfTkIxH4GKveWaEBYySKIg+USu+E+EDIR47SqnaMQ==",
+            "integrity": "sha512-hSAifV3k+i6lEoCJ2k6R2Z/rp/H3+8sdmcn5NrS3/3kE7+RyZXm9aqvxWqjEXHAd8b0pShatpcdMTvEdvAJltQ==",
            "dev": true
        },
        "typescript-formatter": {
@@ -2458,9 +2275,9 @@
            "dev": true
        },
        "v8-compile-cache": {
-            "version": "2.1.0",
+            "version": "2.1.1",
-            "resolved": "https://registry.npmjs.org/v8-compile-cache/-/v8-compile-cache-2.1.0.tgz",
+            "resolved": "https://registry.npmjs.org/v8-compile-cache/-/v8-compile-cache-2.1.1.tgz",
-            "integrity": "sha512-usZBT3PW+LOjM25wbqIlZwPeJV+3OSz3M1k1Ws8snlW39dZyYL9lOGC5FgPVHfk0jKmjiDV8Z0mIbVQPiwFs7g==",
+            "integrity": "sha512-8OQ9CL+VWyt3JStj7HX7/ciTL2V3Rl1Wf5OL+SNTm0yK1KvtReVulksyeRnCANHHuUxHlQig+JJDlUhBt1NQDQ==",
            "dev": true
        },
        "vsce": {
@@ -2537,9 +2354,9 @@
            "integrity": "sha512-tZFUSbyjUcrh+qQf13ALX4QDdOfDX0cVaBFgy7ktJ0VwS7AW/yRKgGPSxVqqP9OCMNPdqP57O5q47w2pEwfaUg=="
        },
        "vscode-test": {
-            "version": "1.3.0",
+            "version": "1.4.0",
-            "resolved": "https://registry.npmjs.org/vscode-test/-/vscode-test-1.3.0.tgz",
+            "resolved": "https://registry.npmjs.org/vscode-test/-/vscode-test-1.4.0.tgz",
-            "integrity": "sha512-LddukcBiSU2FVTDr3c1D8lwkiOvwlJdDL2hqVbn6gIz+rpTqUCkMZSKYm94Y1v0WXlHSDQBsXyY+tchWQgGVsw==",
+            "integrity": "sha512-Jt7HNGvSE0+++Tvtq5wc4hiXLIr2OjDShz/gbAfM/mahQpy4rKBnmOK33D+MR67ATWviQhl+vpmU3p/qwSH/Pg==",
            "dev": true,
            "requires": {
                "http-proxy-agent": "^2.1.0",
@@ -2577,12 +2394,6 @@
                    "integrity": "sha1-7QMXwyIGT3lGbAKWa922Bas32Zg=",
                    "dev": true
                },
-                "is-fullwidth-code-point": {
-                    "version": "2.0.0",
-                    "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz",
-                    "integrity": "sha1-o7MKXE8ZkYMWeqq5O+764937ZU8=",
-                    "dev": true
-                },
                "string-width": {
                    "version": "2.1.1",
                    "resolved": "https://registry.npmjs.org/string-width/-/string-width-2.1.1.tgz",
@@ -2610,6 +2421,12 @@
            "integrity": "sha512-Hz/mrNwitNRh/HUAtM/VT/5VH+ygD6DV7mYKZAtHOrbs8U7lvPS6xf7EJKMF0uW1KJCl0H701g3ZGus+muE5vQ==",
            "dev": true
        },
+        "workerpool": {
+            "version": "6.0.0",
+            "resolved": "https://registry.npmjs.org/workerpool/-/workerpool-6.0.0.tgz",
+            "integrity": "sha512-fU2OcNA/GVAJLLyKUoHkAgIhKb0JoCpSjLC/G2vYKxUjVmQwGbRVeoPJ1a8U4pnVofz4AQV5Y/NEw8oKqxEBtA==",
+            "dev": true
+        },
        "wrap-ansi": {
            "version": "5.1.0",
            "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-5.1.0.tgz",
@@ -2627,29 +2444,6 @@
                    "integrity": "sha512-1apePfXM1UOSqw0o9IiFAovVz9M5S1Dg+4TrDwfMewQ6p/rmMueb7tWZjQ1rx4Loy1ArBggoqGpfqqdI4rondg==",
                    "dev": true
                },
-                "emoji-regex": {
-                    "version": "7.0.3",
-                    "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-7.0.3.tgz",
-                    "integrity": "sha512-CwBLREIQ7LvYFB0WyRvwhq5N5qPhc6PMjD6bYggFlI5YyDgl+0vxq5VHbMOFqLg7hfWzmu8T5Z1QofhmTIhItA==",
-                    "dev": true
-                },
-                "is-fullwidth-code-point": {
-                    "version": "2.0.0",
-                    "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz",
-                    "integrity": "sha1-o7MKXE8ZkYMWeqq5O+764937ZU8=",
-                    "dev": true
-                },
-                "string-width": {
-                    "version": "3.1.0",
-                    "resolved": "https://registry.npmjs.org/string-width/-/string-width-3.1.0.tgz",
-                    "integrity": "sha512-vafcv6KjVZKSgz06oM/H6GDBrAtz8vdhQakGjFIvNrHA6y3HCF1CInLy+QLq8dTJPQ1b+KDUqDFctkdRW44e1w==",
-                    "dev": true,
-                    "requires": {
-                        "emoji-regex": "^7.0.1",
-                        "is-fullwidth-code-point": "^2.0.0",
-                        "strip-ansi": "^5.1.0"
-                    }
-                },
                "strip-ansi": {
                    "version": "5.2.0",
                    "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-5.2.0.tgz",
@@ -2706,43 +2500,39 @@
                "yargs-parser": "^13.1.2"
            },
            "dependencies": {
-                "ansi-regex": {
+                "find-up": {
-                    "version": "4.1.0",
+                    "version": "3.0.0",
-                    "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-4.1.0.tgz",
+                    "resolved": "https://registry.npmjs.org/find-up/-/find-up-3.0.0.tgz",
-                    "integrity": "sha512-1apePfXM1UOSqw0o9IiFAovVz9M5S1Dg+4TrDwfMewQ6p/rmMueb7tWZjQ1rx4Loy1ArBggoqGpfqqdI4rondg==",
+                    "integrity": "sha512-1yD6RmLI1XBfxugvORwlck6f75tYL+iR0jqwsOrOxMZyGYqUuDhJ0l4AXdO1iX/FTs9cBAMEk1gWSEx1kSbylg==",
-                    "dev": true
+                    "dev": true,
-                },
+                    "requires": {
-                "emoji-regex": {
+                        "locate-path": "^3.0.0"
-                    "version": "7.0.3",
+                    }
-                    "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-7.0.3.tgz",
-                    "integrity": "sha512-CwBLREIQ7LvYFB0WyRvwhq5N5qPhc6PMjD6bYggFlI5YyDgl+0vxq5VHbMOFqLg7hfWzmu8T5Z1QofhmTIhItA==",
-                    "dev": true
-                },
-                "is-fullwidth-code-point": {
-                    "version": "2.0.0",
-                    "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz",
-                    "integrity": "sha1-o7MKXE8ZkYMWeqq5O+764937ZU8=",
-                    "dev": true
                },
-                "string-width": {
+                "locate-path": {
-                    "version": "3.1.0",
+                    "version": "3.0.0",
-                    "resolved": "https://registry.npmjs.org/string-width/-/string-width-3.1.0.tgz",
+                    "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-3.0.0.tgz",
-                    "integrity": "sha512-vafcv6KjVZKSgz06oM/H6GDBrAtz8vdhQakGjFIvNrHA6y3HCF1CInLy+QLq8dTJPQ1b+KDUqDFctkdRW44e1w==",
+                    "integrity": "sha512-7AO748wWnIhNqAuaty2ZWHkQHRSNfPVIsPIfwEOWO22AmaoVrWavlOcMR5nzTLNYvp36X220/maaRsrec1G65A==",
                    "dev": true,
                    "requires": {
-                        "emoji-regex": "^7.0.1",
+                        "p-locate": "^3.0.0",
-                        "is-fullwidth-code-point": "^2.0.0",
+                        "path-exists": "^3.0.0"
-                        "strip-ansi": "^5.1.0"
                    }
                },
-                "strip-ansi": {
+                "p-locate": {
-                    "version": "5.2.0",
+                    "version": "3.0.0",
-                    "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-5.2.0.tgz",
+                    "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-3.0.0.tgz",
-                    "integrity": "sha512-DuRs1gKbBqsMKIZlrffwlug8MHkcnpjs5VPmL1PAh+mA30U0DTotfDZ0d2UUsXpPmPmMMJ6W773MaA3J+lbiWA==",
+                    "integrity": "sha512-x+12w/To+4GFfgJhBEpiDcLozRJGegY+Ei7/z0tSLkMmxGZNybVMSfWj9aJn8Z5Fc7dBUNJOOVgPv2H7IwulSQ==",
                    "dev": true,
                    "requires": {
-                        "ansi-regex": "^4.1.0"
+                        "p-limit": "^2.0.0"
                    }
+                },
+                "path-exists": {
+                    "version": "3.0.0",
+                    "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-3.0.0.tgz",
+                    "integrity": "sha1-zg6+ql94yxiSXqfYENe1mwEP1RU=",
+                    "dev": true
                }
            }
        },
diff --git a/editors/code/package.json b/editors/code/package.json
index f542a490a..af0a5c851 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -39,29 +39,29 @@
        "vscode-languageclient": "7.0.0-next.1"
    },
    "devDependencies": {
-        "@rollup/plugin-commonjs": "^12.0.0",
+        "@rollup/plugin-commonjs": "^13.0.0",
-        "@rollup/plugin-node-resolve": "^8.0.0",
+        "@rollup/plugin-node-resolve": "^8.1.0",
-        "@types/glob": "^7.1.1",
+        "@types/glob": "^7.1.2",
        "@types/mocha": "^7.0.2",
-        "@types/node": "^14.0.5",
+        "@types/node": "~12.7.0",
        "@types/node-fetch": "^2.5.7",
        "@types/vscode": "^1.44.1",
-        "@typescript-eslint/eslint-plugin": "^3.0.0",
+        "@typescript-eslint/eslint-plugin": "^3.4.0",
-        "@typescript-eslint/parser": "^3.0.0",
+        "@typescript-eslint/parser": "^3.4.0",
-        "eslint": "^7.0.0",
+        "eslint": "^7.3.1",
        "glob": "^7.1.6",
-        "mocha": "^7.1.2",
+        "mocha": "^8.0.1",
-        "rollup": "^2.10.7",
+        "rollup": "^2.18.1",
        "tslib": "^2.0.0",
-        "typescript": "^3.9.3",
+        "typescript": "^3.9.5",
        "typescript-formatter": "^7.2.2",
        "vsce": "^1.75.0",
-        "vscode-test": "^1.3.0"
+        "vscode-test": "^1.4.0"
    },
    "activationEvents": [
        "onLanguage:rust",
        "onCommand:rust-analyzer.analyzerStatus",
-        "onCommand:rust-analyzer.collectGarbage",
+        "onCommand:rust-analyzer.reloadWorkspace",
        "workspaceContains:**/Cargo.toml"
    ],
    "main": "./out/src/main",
@@ -143,8 +143,8 @@
                "category": "Rust Analyzer"
            },
            {
-                "command": "rust-analyzer.collectGarbage",
+                "command": "rust-analyzer.reloadWorkspace",
-                "title": "Run garbage collection",
+                "title": "Reload workspace",
                "category": "Rust Analyzer"
            },
            {
@@ -815,7 +815,7 @@
                    "when": "inRustProject"
                },
                {
-                    "command": "rust-analyzer.collectGarbage",
+                    "command": "rust-analyzer.reloadWorkspace",
                    "when": "inRustProject"
                },
                {
diff --git a/editors/code/rollup.config.js b/editors/code/rollup.config.js
index 4b4c47f4a..27abf75ac 100644
--- a/editors/code/rollup.config.js
+++ b/editors/code/rollup.config.js
@@ -16,7 +16,6 @@ export default {
    external: [...nodeBuiltins, 'vscode'],
    output: {
        file: './out/src/main.js',
-        format: 'cjs',
+        format: 'cjs'
-        exports: 'named'
    }
 };
diff --git a/editors/code/rust.tmGrammar.json b/editors/code/rust.tmGrammar.json
index ab87cd39f..0be2583db 100644
--- a/editors/code/rust.tmGrammar.json
+++ b/editors/code/rust.tmGrammar.json
@@ -268,7 +268,7 @@
                        "match": "\\b(log|error|warn|info|debug|trace|log_enabled)!"
                },
                {
-                        "comment": "Invokation of a macro",
+                        "comment": "Invocation of a macro",
                        "match": "\\b([a-zA-Z_][a-zA-Z0-9_]*\\!)\\s*[({\\[]",
                        "captures": {
                                "1": {
@@ -683,4 +683,4 @@
                        ]
                }
        }
-}
-\ No newline at end of file
+}
diff --git a/editors/code/src/commands.ts b/editors/code/src/commands.ts
index 0e78f5101..19a9c2a0d 100644
--- a/editors/code/src/commands.ts
+++ b/editors/code/src/commands.ts
@@ -330,8 +330,8 @@ export function expandMacro(ctx: Ctx): Cmd {
    };
 }
-export function collectGarbage(ctx: Ctx): Cmd {
+export function reloadWorkspace(ctx: Ctx): Cmd {
-    return async () => ctx.client.sendRequest(ra.collectGarbage, null);
+    return async () => ctx.client.sendRequest(ra.reloadWorkspace, null);
 }
 export function showReferences(ctx: Ctx): Cmd {
diff --git a/editors/code/src/lsp_ext.ts b/editors/code/src/lsp_ext.ts
index e16ea799c..981b6f40e 100644
--- a/editors/code/src/lsp_ext.ts
+++ b/editors/code/src/lsp_ext.ts
@@ -6,7 +6,7 @@ import * as lc from "vscode-languageclient";
 export const analyzerStatus = new lc.RequestType<null, string, void>("rust-analyzer/analyzerStatus");
-export const collectGarbage = new lc.RequestType<null, null, void>("rust-analyzer/collectGarbage");
+export const reloadWorkspace = new lc.RequestType<null, null, void>("rust-analyzer/reloadWorkspace");
 export interface SyntaxTreeParams {
    textDocument: lc.TextDocumentIdentifier;
@@ -60,6 +60,7 @@ export interface Runnable {
        workspaceRoot?: string;
        cargoArgs: string[];
        executableArgs: string[];
+        expectTest?: boolean;
    };
 }
 export const runnables = new lc.RequestType<RunnablesParams, Runnable[], void>("experimental/runnables");
diff --git a/editors/code/src/main.ts b/editors/code/src/main.ts
index 1ad75a03c..a1521a93b 100644
--- a/editors/code/src/main.ts
+++ b/editors/code/src/main.ts
@@ -19,6 +19,16 @@ let ctx: Ctx | undefined;
 const RUST_PROJECT_CONTEXT_NAME = "inRustProject";
 export async function activate(context: vscode.ExtensionContext) {
+    // For some reason vscode not always shows pop-up error notifications
+    // when an extension fails to activate, so we do it explicitly by ourselves.
+    // FIXME: remove this bit of code once vscode fixes this issue: https://github.com/microsoft/vscode/issues/101242
+    await tryActivate(context).catch(err => {
+        void vscode.window.showErrorMessage(`Cannot activate rust-analyzer: ${err.message}`);
+        throw err;
+    });
+}
+async function tryActivate(context: vscode.ExtensionContext) {
    // Register a "dumb" onEnter command for the case where server fails to
    // start.
    //
@@ -58,9 +68,7 @@ export async function activate(context: vscode.ExtensionContext) {
    const workspaceFolder = vscode.workspace.workspaceFolders?.[0];
    if (workspaceFolder === undefined) {
-        const err = "Cannot activate rust-analyzer when no folder is opened";
+        throw new Error("no folder is opened");
-        void vscode.window.showErrorMessage(err);
-        throw new Error(err);
    }
    // Note: we try to start the server before we activate type hints so that it
@@ -88,7 +96,7 @@ export async function activate(context: vscode.ExtensionContext) {
    });
    ctx.registerCommand('analyzerStatus', commands.analyzerStatus);
-    ctx.registerCommand('collectGarbage', commands.collectGarbage);
+    ctx.registerCommand('reloadWorkspace', commands.reloadWorkspace);
    ctx.registerCommand('matchingBrace', commands.matchingBrace);
    ctx.registerCommand('joinLines', commands.joinLines);
    ctx.registerCommand('parentModule', commands.parentModule);
diff --git a/editors/code/src/run.ts b/editors/code/src/run.ts
index 766b05112..e1430e31f 100644
--- a/editors/code/src/run.ts
+++ b/editors/code/src/run.ts
@@ -108,12 +108,16 @@ export async function createTask(runnable: ra.Runnable, config: Config): Promise
    if (runnable.args.executableArgs.length > 0) {
        args.push('--', ...runnable.args.executableArgs);
    }
+    const env: { [key: string]: string } = { "RUST_BACKTRACE": "short" };
+    if (runnable.args.expectTest) {
+        env["UPDATE_EXPECT"] = "1";
+    }
    const definition: tasks.CargoTaskDefinition = {
        type: tasks.TASK_TYPE,
        command: args[0], // run, test, etc...
        args: args.slice(1),
        cwd: runnable.args.workspaceRoot,
-        env: Object.assign({}, process.env as { [key: string]: string }, { "RUST_BACKTRACE": "short" }),
+        env: Object.assign({}, process.env as { [key: string]: string }, env),
    };
    const target = vscode.workspace.workspaceFolders![0]; // safe, see main activate()