62 files changed, 2422 insertions, 1093 deletions

diff --git a/Cargo.lock b/Cargo.lock
index 308e36836..f6d5b900f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -10,6 +10,12 @@ dependencies = [
 ]
 
 [[package]]
+name = "adler32"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "567b077b825e468cc974f0020d4082ee6e03132512f207ef1a02fd5d00d1f32d"
+
+[[package]]
 name = "aho-corasick"
 version = "0.7.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -55,22 +61,23 @@ checksum = "f8aac770f1885fd7e387acedd76065302551364496e46b3dd00860b2f8359b9d"
 
 [[package]]
 name = "backtrace"
-version = "0.3.48"
+version = "0.3.49"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0df2f85c8a2abbe3b7d7e748052fdd9b76a0458fdeb16ad4223f5eca78c7c130"
+checksum = "05100821de9e028f12ae3d189176b41ee198341eb8f369956407fea2f5cc666c"
 dependencies = [
  "addr2line",
  "cfg-if",
  "libc",
+ "miniz_oxide",
  "object",
  "rustc-demangle",
 ]
 
 [[package]]
 name = "base64"
-version = "0.12.1"
+version = "0.12.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "53d1ccbaf7d9ec9537465a97bf19edc1a4e158ecb49fc16178202238c569cc42"
+checksum = "e223af0dc48c96d4f8342ec01a4974f139df863896b316681efd36742f22cc67"
 
 [[package]]
 name = "bitflags"
@@ -438,9 +445,9 @@ dependencies = [
 
 [[package]]
 name = "hermit-abi"
-version = "0.1.13"
+version = "0.1.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "91780f809e750b0a89f5544be56617ff6b1227ee485bcb06ebe10cdf89bd3b71"
+checksum = "b9586eedd4ce6b3c498bc3b4dd92fc9f11166aa908a914071953768066c67909"
 dependencies = [
  "libc",
 ]
@@ -695,6 +702,15 @@ dependencies = [
 ]
 
 [[package]]
+name = "miniz_oxide"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "791daaae1ed6889560f8c4359194f56648355540573244a5448a83ba1ecc7435"
+dependencies = [
+ "adler32",
+]
+
+[[package]]
 name = "mio"
 version = "0.6.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -778,9 +794,9 @@ dependencies = [
 
 [[package]]
 name = "object"
-version = "0.19.0"
+version = "0.20.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9cbca9424c482ee628fa549d9c812e2cd22f1180b9222c9200fdfa6eb31aecb2"
+checksum = "1ab52be62400ca80aa00285d25253d7f7c437b7375c4de678f5405d3afe82ca5"
 
 [[package]]
 name = "once_cell"
@@ -814,9 +830,9 @@ dependencies = [
 
 [[package]]
 name = "paste"
-version = "0.1.16"
+version = "0.1.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d508492eeb1e5c38ee696371bf7b9fc33c83d46a7d451606b96458fbbbdc2dec"
+checksum = "026c63fe245362be0322bfec5a9656d458d13f9cfb1785d1b38458b9968e8080"
 dependencies = [
  "paste-impl",
  "proc-macro-hack",
@@ -824,17 +840,18 @@ dependencies = [
 
 [[package]]
 name = "paste-impl"
-version = "0.1.16"
+version = "0.1.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "84f328a6a63192b333fce5fbb4be79db6758a4d518dfac6d54412f1492f72d32"
+checksum = "7b9281a268ec213237dcd2aa3c3d0f46681b04ced37c1616fd36567a9e6954b0"
 dependencies = [
  "proc-macro-hack",
- "proc-macro2",
- "quote",
- "syn",
 ]
 
 [[package]]
+name = "paths"
+version = "0.1.0"
+
+[[package]]
 name = "percent-encoding"
 version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -852,9 +869,9 @@ dependencies = [
 
 [[package]]
 name = "pico-args"
-version = "0.3.1"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3ad1f1b834a05d42dae330066e9699a173b28185b3bdc3dbf14ca239585de8cc"
+checksum = "6a71836ceac43f0349e3bd964f5bb902f7b003916f32a4ad00354dafc447fa8f"
 
 [[package]]
 name = "plain"
@@ -1271,10 +1288,11 @@ dependencies = [
 
 [[package]]
 name = "rayon"
-version = "1.3.0"
+version = "1.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "db6ce3297f9c85e16621bb8cca38a06779ffc31bb8184e1be4bed2be4678a098"
+checksum = "62f02856753d04e03e26929f820d0a0a337ebe71f849801eea335d464b349080"
 dependencies = [
+ "autocfg",
  "crossbeam-deque",
  "either",
  "rayon-core",
@@ -1282,9 +1300,9 @@ dependencies = [
 
 [[package]]
 name = "rayon-core"
-version = "1.7.0"
+version = "1.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08a89b46efaf957e52b18062fb2f4660f8b8a4dde1807ca002690868ef2c85a9"
+checksum = "e92e15d89083484e11353891f1af602cc661426deb9564c298b270c726973280"
 dependencies = [
  "crossbeam-deque",
  "crossbeam-queue",
@@ -1319,15 +1337,15 @@ checksum = "26412eb97c6b088a6997e05f69403a802a92d520de2f8e63c2b65f9e0f47c4e8"
 
 [[package]]
 name = "relative-path"
-version = "1.0.0"
+version = "1.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bedde000f40f2921ce439ea165c9c53fd629bfa115140c72e22aceacb4a21954"
+checksum = "c602122c47b382cd045b10866a084b184035d45d8c2609cdd3762852ddfae2a1"
 
 [[package]]
 name = "remove_dir_all"
-version = "0.5.2"
+version = "0.5.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4a83fa3702a688b9359eccba92d153ac33fd2e8462f9e0e3fdf155239ea7792e"
+checksum = "3acd125665422973a33ac9d3dd2df85edad0f4ae9b00dafb1a05e43a9f5ef8e7"
 dependencies = [
  "winapi 0.3.8",
 ]
@@ -1501,18 +1519,18 @@ checksum = "388a1df253eca08550bef6c72392cfe7c30914bf41df5269b68cbd6ff8f570a3"
 
 [[package]]
 name = "serde"
-version = "1.0.111"
+version = "1.0.112"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c9124df5b40cbd380080b2cc6ab894c040a3070d995f5c9dc77e18c34a8ae37d"
+checksum = "736aac72d1eafe8e5962d1d1c3d99b0df526015ba40915cb3c49d042e92ec243"
 dependencies = [
  "serde_derive",
 ]
 
 [[package]]
 name = "serde_derive"
-version = "1.0.111"
+version = "1.0.112"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3f2c3ac8e6ca1e9c80b8be1023940162bf81ae3cffbb1809474152f2ce1eb250"
+checksum = "bf0343ce212ac0d3d6afd9391ac8e9c9efe06b533c8d33f660f6390cc4093f57"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1726,6 +1744,18 @@ dependencies = [
 ]
 
 [[package]]
+name = "vfs"
+version = "0.1.0"
+dependencies = [
+ "crossbeam-channel",
+ "globset",
+ "jod-thread",
+ "paths",
+ "rustc-hash",
+ "walkdir",
+]
+
+[[package]]
 name = "walkdir"
 version = "2.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
diff --git a/README.md b/README.md
index 1e7c3e9b4..7ba705e73 100644
--- a/README.md
+++ b/README.md
@@ -12,6 +12,7 @@ Work on rust-analyzer is sponsored by
 
 [<img src="https://user-images.githubusercontent.com/1711539/58105231-cf306900-7bee-11e9-83d8-9f1102e59d29.png" alt="Ferrous Systems" width="300">](https://ferrous-systems.com/)
 - [Mozilla](https://www.mozilla.org/en-US/)
+- [Embark Studios](https://embark-studios.com/)
 - [freiheit.com](https://www.freiheit.com)
 
 ## Quick Start
diff --git a/crates/paths/Cargo.toml b/crates/paths/Cargo.toml
new file mode 100644
index 000000000..646ee7fd5
--- /dev/null
+++ b/crates/paths/Cargo.toml
@@ -0,0 +1,8 @@
+[package]
+name = "paths"
+version = "0.1.0"
+authors = ["rust-analyzer developers"]
+edition = "2018"
+
+[lib]
+doctest = false
diff --git a/crates/paths/src/lib.rs b/crates/paths/src/lib.rs
new file mode 100644
index 000000000..c7ce0c42f
--- /dev/null
+++ b/crates/paths/src/lib.rs
@@ -0,0 +1,123 @@
+//! Thin wrappers around `std::path`, distinguishing between absolute and
+//! relative paths.
+use std::{
+    convert::{TryFrom, TryInto},
+    ops,
+    path::{Component, Path, PathBuf},
+};
+
+#[derive(Debug, Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
+pub struct AbsPathBuf(PathBuf);
+
+impl From<AbsPathBuf> for PathBuf {
+    fn from(AbsPathBuf(path_buf): AbsPathBuf) -> PathBuf {
+        path_buf
+    }
+}
+
+impl ops::Deref for AbsPathBuf {
+    type Target = AbsPath;
+    fn deref(&self) -> &AbsPath {
+        self.as_path()
+    }
+}
+
+impl AsRef<Path> for AbsPathBuf {
+    fn as_ref(&self) -> &Path {
+        self.0.as_path()
+    }
+}
+
+impl TryFrom<PathBuf> for AbsPathBuf {
+    type Error = PathBuf;
+    fn try_from(path_buf: PathBuf) -> Result<AbsPathBuf, PathBuf> {
+        if !path_buf.is_absolute() {
+            return Err(path_buf);
+        }
+        Ok(AbsPathBuf(path_buf))
+    }
+}
+
+impl TryFrom<&str> for AbsPathBuf {
+    type Error = PathBuf;
+    fn try_from(path: &str) -> Result<AbsPathBuf, PathBuf> {
+        AbsPathBuf::try_from(PathBuf::from(path))
+    }
+}
+
+impl AbsPathBuf {
+    pub fn as_path(&self) -> &AbsPath {
+        AbsPath::new_unchecked(self.0.as_path())
+    }
+    pub fn pop(&mut self) -> bool {
+        self.0.pop()
+    }
+}
+
+#[derive(Debug, Ord, PartialOrd, Eq, PartialEq, Hash)]
+#[repr(transparent)]
+pub struct AbsPath(Path);
+
+impl ops::Deref for AbsPath {
+    type Target = Path;
+    fn deref(&self) -> &Path {
+        &self.0
+    }
+}
+
+impl AsRef<Path> for AbsPath {
+    fn as_ref(&self) -> &Path {
+        &self.0
+    }
+}
+
+impl<'a> TryFrom<&'a Path> for &'a AbsPath {
+    type Error = &'a Path;
+    fn try_from(path: &'a Path) -> Result<&'a AbsPath, &'a Path> {
+        if !path.is_absolute() {
+            return Err(path);
+        }
+        Ok(AbsPath::new_unchecked(path))
+    }
+}
+
+impl AbsPath {
+    fn new_unchecked(path: &Path) -> &AbsPath {
+        unsafe { &*(path as *const Path as *const AbsPath) }
+    }
+
+    pub fn join(&self, path: impl AsRef<Path>) -> AbsPathBuf {
+        self.as_ref().join(path).try_into().unwrap()
+    }
+    pub fn normalize(&self) -> AbsPathBuf {
+        AbsPathBuf(normalize_path(&self.0))
+    }
+}
+
+// https://github.com/rust-lang/cargo/blob/79c769c3d7b4c2cf6a93781575b7f592ef974255/src/cargo/util/paths.rs#L60-L85
+fn normalize_path(path: &Path) -> PathBuf {
+    let mut components = path.components().peekable();
+    let mut ret = if let Some(c @ Component::Prefix(..)) = components.peek().cloned() {
+        components.next();
+        PathBuf::from(c.as_os_str())
+    } else {
+        PathBuf::new()
+    };
+
+    for component in components {
+        match component {
+            Component::Prefix(..) => unreachable!(),
+            Component::RootDir => {
+                ret.push(component.as_os_str());
+            }
+            Component::CurDir => {}
+            Component::ParentDir => {
+                ret.pop();
+            }
+            Component::Normal(c) => {
+                ret.push(c);
+            }
+        }
+    }
+    ret
+}
diff --git a/crates/ra_assists/src/assist_context.rs b/crates/ra_assists/src/assist_context.rs
index edd8255f4..ee614de72 100644
--- a/crates/ra_assists/src/assist_context.rs
+++ b/crates/ra_assists/src/assist_context.rs
@@ -252,7 +252,7 @@ impl AssistBuilder {
     pub(crate) fn rewrite(&mut self, rewriter: SyntaxRewriter) {
         let node = rewriter.rewrite_root().unwrap();
         let new = rewriter.rewrite(&node);
-        algo::diff(&node, &new).into_text_edit(&mut self.edit)
+        algo::diff(&node, &new).into_text_edit(&mut self.edit);
     }
 
     // FIXME: kill this API
diff --git a/crates/ra_assists/src/ast_transform.rs b/crates/ra_assists/src/ast_transform.rs
index 3079a02a2..00fa95b6c 100644
--- a/crates/ra_assists/src/ast_transform.rs
+++ b/crates/ra_assists/src/ast_transform.rs
@@ -106,6 +106,7 @@ impl<'a> SubstituteTypeParams<'a> {
             _ => return None,
         };
         // FIXME: use `hir::Path::from_src` instead.
+        #[allow(deprecated)]
         let path = hir::Path::from_ast(path)?;
         let resolution = self.source_scope.resolve_hir_path(&path)?;
         match resolution {
@@ -150,6 +151,7 @@ impl<'a> QualifyPaths<'a> {
             return None;
         }
         // FIXME: use `hir::Path::from_src` instead.
+        #[allow(deprecated)]
         let hir_path = hir::Path::from_ast(p.clone());
         let resolution = self.source_scope.resolve_hir_path(&hir_path?)?;
         match resolution {
diff --git a/crates/ra_assists/src/handlers/fill_match_arms.rs b/crates/ra_assists/src/handlers/fill_match_arms.rs
index cc303285b..569efb768 100644
--- a/crates/ra_assists/src/handlers/fill_match_arms.rs
+++ b/crates/ra_assists/src/handlers/fill_match_arms.rs
@@ -136,8 +136,20 @@ fn is_variant_missing(existing_arms: &mut Vec<MatchArm>, var: &Pat) -> bool {
 }
 
 fn does_pat_match_variant(pat: &Pat, var: &Pat) -> bool {
-    let pat_head = pat.syntax().first_child().map(|node| node.text());
-    let var_head = var.syntax().first_child().map(|node| node.text());
+    let first_node_text = |pat: &Pat| pat.syntax().first_child().map(|node| node.text());
+
+    let pat_head = match pat {
+        Pat::BindPat(bind_pat) => {
+            if let Some(p) = bind_pat.pat() {
+                first_node_text(&p)
+            } else {
+                return false;
+            }
+        }
+        pat => first_node_text(pat),
+    };
+
+    let var_head = first_node_text(var);
 
     pat_head == var_head
 }
@@ -351,6 +363,40 @@ mod tests {
     }
 
     #[test]
+    fn partial_fill_bind_pat() {
+        check_assist(
+            fill_match_arms,
+            r#"
+            enum A {
+                As,
+                Bs,
+                Cs(Option<i32>),
+            }
+            fn main() {
+                match A::As<|> {
+                    A::As(_) => {}
+                    a @ A::Bs(_) => {}
+                }
+            }
+            "#,
+            r#"
+            enum A {
+                As,
+                Bs,
+                Cs(Option<i32>),
+            }
+            fn main() {
+                match A::As {
+                    A::As(_) => {}
+                    a @ A::Bs(_) => {}
+                    $0A::Cs(_) => {}
+                }
+            }
+            "#,
+        );
+    }
+
+    #[test]
     fn fill_match_arms_empty_body() {
         check_assist(
             fill_match_arms,
diff --git a/crates/ra_assists/src/handlers/replace_qualified_name_with_use.rs b/crates/ra_assists/src/handlers/replace_qualified_name_with_use.rs
index 0197a8cf0..b4784c333 100644
--- a/crates/ra_assists/src/handlers/replace_qualified_name_with_use.rs
+++ b/crates/ra_assists/src/handlers/replace_qualified_name_with_use.rs
@@ -1,7 +1,10 @@
 use hir;
-use ra_syntax::{ast, AstNode, SmolStr, TextRange};
+use ra_syntax::{algo::SyntaxRewriter, ast, match_ast, AstNode, SmolStr, SyntaxNode};
 
-use crate::{utils::insert_use_statement, AssistContext, AssistId, Assists};
+use crate::{
+    utils::{find_insert_use_container, insert_use_statement},
+    AssistContext, AssistId, Assists,
+};
 
 // Assist: replace_qualified_name_with_use
 //
@@ -39,16 +42,18 @@ pub(crate) fn replace_qualified_name_with_use(
         target,
         |builder| {
             let path_to_import = hir_path.mod_path().clone();
+            let container = match find_insert_use_container(path.syntax(), ctx) {
+                Some(c) => c,
+                None => return,
+            };
             insert_use_statement(path.syntax(), &path_to_import, ctx, builder.text_edit_builder());
 
-            if let Some(last) = path.segment() {
-                // Here we are assuming the assist will provide a correct use statement
-                // so we can delete the path qualifier
-                builder.delete(TextRange::new(
-                    path.syntax().text_range().start(),
-                    last.syntax().text_range().start(),
-                ));
-            }
+            // Now that we've brought the name into scope, re-qualify all paths that could be
+            // affected (that is, all paths inside the node we added the `use` to).
+            let mut rewriter = SyntaxRewriter::default();
+            let syntax = container.either(|l| l.syntax().clone(), |r| r.syntax().clone());
+            shorten_paths(&mut rewriter, syntax, path);
+            builder.rewrite(rewriter);
         },
     )
 }
@@ -73,6 +78,69 @@ fn collect_hir_path_segments(path: &hir::Path) -> Option<Vec<SmolStr>> {
     Some(ps)
 }
 
+/// Adds replacements to `re` that shorten `path` in all descendants of `node`.
+fn shorten_paths(rewriter: &mut SyntaxRewriter<'static>, node: SyntaxNode, path: ast::Path) {
+    for child in node.children() {
+        match_ast! {
+            match child {
+                // Don't modify `use` items, as this can break the `use` item when injecting a new
+                // import into the use tree.
+                ast::UseItem(_it) => continue,
+                // Don't descend into submodules, they don't have the same `use` items in scope.
+                ast::Module(_it) => continue,
+
+                ast::Path(p) => {
+                    match maybe_replace_path(rewriter, p.clone(), path.clone()) {
+                        Some(()) => {},
+                        None => shorten_paths(rewriter, p.syntax().clone(), path.clone()),
+                    }
+                },
+                _ => shorten_paths(rewriter, child, path.clone()),
+            }
+        }
+    }
+}
+
+fn maybe_replace_path(
+    rewriter: &mut SyntaxRewriter<'static>,
+    path: ast::Path,
+    target: ast::Path,
+) -> Option<()> {
+    if !path_eq(path.clone(), target.clone()) {
+        return None;
+    }
+
+    // Shorten `path`, leaving only its last segment.
+    if let Some(parent) = path.qualifier() {
+        rewriter.delete(parent.syntax());
+    }
+    if let Some(double_colon) = path.coloncolon_token() {
+        rewriter.delete(&double_colon);
+    }
+
+    Some(())
+}
+
+fn path_eq(lhs: ast::Path, rhs: ast::Path) -> bool {
+    let mut lhs_curr = lhs;
+    let mut rhs_curr = rhs;
+    loop {
+        match (lhs_curr.segment(), rhs_curr.segment()) {
+            (Some(lhs), Some(rhs)) if lhs.syntax().text() == rhs.syntax().text() => (),
+            _ => return false,
+        }
+
+        match (lhs_curr.qualifier(), rhs_curr.qualifier()) {
+            (Some(lhs), Some(rhs)) => {
+                lhs_curr = lhs;
+                rhs_curr = rhs;
+            }
+            (None, None) => return true,
+            _ => return false,
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use crate::tests::{check_assist, check_assist_not_applicable};
@@ -83,10 +151,10 @@ mod tests {
     fn test_replace_add_use_no_anchor() {
         check_assist(
             replace_qualified_name_with_use,
-            "
+            r"
 std::fmt::Debug<|>
     ",
-            "
+            r"
 use std::fmt::Debug;
 
 Debug
@@ -97,13 +165,13 @@ Debug
     fn test_replace_add_use_no_anchor_with_item_below() {
         check_assist(
             replace_qualified_name_with_use,
-            "
+            r"
 std::fmt::Debug<|>
 
 fn main() {
 }
     ",
-            "
+            r"
 use std::fmt::Debug;
 
 Debug
@@ -118,13 +186,13 @@ fn main() {
     fn test_replace_add_use_no_anchor_with_item_above() {
         check_assist(
             replace_qualified_name_with_use,
-            "
+            r"
 fn main() {
 }
 
 std::fmt::Debug<|>
     ",
-            "
+            r"
 use std::fmt::Debug;
 
 fn main() {
@@ -139,10 +207,10 @@ Debug
     fn test_replace_add_use_no_anchor_2seg() {
         check_assist(
             replace_qualified_name_with_use,
-            "
+            r"
 std::fmt<|>::Debug
     ",
-            "
+            r"
 use std::fmt;
 
 fmt::Debug
@@ -154,13 +222,13 @@ fmt::Debug
     fn test_replace_add_use() {
         check_assist(
             replace_qualified_name_with_use,
-            "
+            r"
 use stdx;
 
 impl std::fmt::Debug<|> for Foo {
 }
     ",
-            "
+            r"
 use stdx;
 use std::fmt::Debug;
 
@@ -174,11 +242,11 @@ impl Debug for Foo {
     fn test_replace_file_use_other_anchor() {
         check_assist(
             replace_qualified_name_with_use,
-            "
+            r"
 impl std::fmt::Debug<|> for Foo {
 }
     ",
-            "
+            r"
 use std::fmt::Debug;
 
 impl Debug for Foo {
@@ -191,11 +259,11 @@ impl Debug for Foo {
     fn test_replace_add_use_other_anchor_indent() {
         check_assist(
             replace_qualified_name_with_use,
-            "
+            r"
     impl std::fmt::Debug<|> for Foo {
     }
     ",
-            "
+            r"
     use std::fmt::Debug;
 
     impl Debug for Foo {
@@ -208,13 +276,13 @@ impl Debug for Foo {
     fn test_replace_split_different() {
         check_assist(
             replace_qualified_name_with_use,
-            "
+            r"
 use std::fmt;
 
 impl std::io<|> for Foo {
 }
     ",
-            "
+            r"
 use std::{io, fmt};
 
 impl io for Foo {
@@ -227,13 +295,13 @@ impl io for Foo {
     fn test_replace_split_self_for_use() {
         check_assist(
             replace_qualified_name_with_use,
-            "
+            r"
 use std::fmt;
 
 impl std::fmt::Debug<|> for Foo {
 }
     ",
-            "
+            r"
 use std::fmt::{self, Debug, };
 
 impl Debug for Foo {
@@ -246,13 +314,13 @@ impl Debug for Foo {
     fn test_replace_split_self_for_target() {
         check_assist(
             replace_qualified_name_with_use,
-            "
+            r"
 use std::fmt::Debug;
 
 impl std::fmt<|> for Foo {
 }
     ",
-            "
+            r"
 use std::fmt::{self, Debug};
 
 impl fmt for Foo {
@@ -265,13 +333,13 @@ impl fmt for Foo {
     fn test_replace_add_to_nested_self_nested() {
         check_assist(
             replace_qualified_name_with_use,
-            "
+            r"
 use std::fmt::{Debug, nested::{Display}};
 
 impl std::fmt::nested<|> for Foo {
 }
 ",
-            "
+            r"
 use std::fmt::{Debug, nested::{Display, self}};
 
 impl nested for Foo {
@@ -284,13 +352,13 @@ impl nested for Foo {
     fn test_replace_add_to_nested_self_already_included() {
         check_assist(
             replace_qualified_name_with_use,
-            "
+            r"
 use std::fmt::{Debug, nested::{self, Display}};
 
 impl std::fmt::nested<|> for Foo {
 }
 ",
-            "
+            r"
 use std::fmt::{Debug, nested::{self, Display}};
 
 impl nested for Foo {
@@ -303,13 +371,13 @@ impl nested for Foo {
     fn test_replace_add_to_nested_nested() {
         check_assist(
             replace_qualified_name_with_use,
-            "
+            r"
 use std::fmt::{Debug, nested::{Display}};
 
 impl std::fmt::nested::Debug<|> for Foo {
 }
 ",
-            "
+            r"
 use std::fmt::{Debug, nested::{Display, Debug}};
 
 impl Debug for Foo {
@@ -322,13 +390,13 @@ impl Debug for Foo {
     fn test_replace_split_common_target_longer() {
         check_assist(
             replace_qualified_name_with_use,
-            "
+            r"
 use std::fmt::Debug;
 
 impl std::fmt::nested::Display<|> for Foo {
 }
 ",
-            "
+            r"
 use std::fmt::{nested::Display, Debug};
 
 impl Display for Foo {
@@ -341,13 +409,13 @@ impl Display for Foo {
     fn test_replace_split_common_use_longer() {
         check_assist(
             replace_qualified_name_with_use,
-            "
+            r"
 use std::fmt::nested::Debug;
 
 impl std::fmt::Display<|> for Foo {
 }
 ",
-            "
+            r"
 use std::fmt::{Display, nested::Debug};
 
 impl Display for Foo {
@@ -360,7 +428,7 @@ impl Display for Foo {
     fn test_replace_use_nested_import() {
         check_assist(
             replace_qualified_name_with_use,
-            "
+            r"
 use crate::{
     ty::{Substs, Ty},
     AssocItem,
@@ -368,7 +436,7 @@ use crate::{
 
 fn foo() { crate::ty::lower<|>::trait_env() }
 ",
-            "
+            r"
 use crate::{
     ty::{Substs, Ty, lower},
     AssocItem,
@@ -383,13 +451,13 @@ fn foo() { lower::trait_env() }
     fn test_replace_alias() {
         check_assist(
             replace_qualified_name_with_use,
-            "
+            r"
 use std::fmt as foo;
 
 impl foo::Debug<|> for Foo {
 }
 ",
-            "
+            r"
 use std::fmt as foo;
 
 impl Debug for Foo {
@@ -402,7 +470,7 @@ impl Debug for Foo {
     fn test_replace_not_applicable_one_segment() {
         check_assist_not_applicable(
             replace_qualified_name_with_use,
-            "
+            r"
 impl foo<|> for Foo {
 }
 ",
@@ -413,7 +481,7 @@ impl foo<|> for Foo {
     fn test_replace_not_applicable_in_use() {
         check_assist_not_applicable(
             replace_qualified_name_with_use,
-            "
+            r"
 use std::fmt<|>;
 ",
         );
@@ -423,14 +491,14 @@ use std::fmt<|>;
     fn test_replace_add_use_no_anchor_in_mod_mod() {
         check_assist(
             replace_qualified_name_with_use,
-            "
+            r"
 mod foo {
     mod bar {
         std::fmt::Debug<|>
     }
 }
     ",
-            "
+            r"
 mod foo {
     mod bar {
         use std::fmt::Debug;
@@ -446,14 +514,14 @@ mod foo {
     fn inserts_imports_after_inner_attributes() {
         check_assist(
             replace_qualified_name_with_use,
-            "
+            r"
 #![allow(dead_code)]
 
 fn main() {
     std::fmt::Debug<|>
 }
     ",
-            "
+            r"
 #![allow(dead_code)]
 use std::fmt::Debug;
 
@@ -463,4 +531,116 @@ fn main() {
     ",
         );
     }
+
+    #[test]
+    fn replaces_all_affected_paths() {
+        check_assist(
+            replace_qualified_name_with_use,
+            r"
+fn main() {
+    std::fmt::Debug<|>;
+    let x: std::fmt::Debug = std::fmt::Debug;
+}
+    ",
+            r"
+use std::fmt::Debug;
+
+fn main() {
+    Debug;
+    let x: Debug = Debug;
+}
+    ",
+        );
+    }
+
+    #[test]
+    fn replaces_all_affected_paths_mod() {
+        check_assist(
+            replace_qualified_name_with_use,
+            r"
+mod m {
+    fn f() {
+        std::fmt::Debug<|>;
+        let x: std::fmt::Debug = std::fmt::Debug;
+    }
+    fn g() {
+        std::fmt::Debug;
+    }
+}
+
+fn f() {
+    std::fmt::Debug;
+}
+    ",
+            r"
+mod m {
+    use std::fmt::Debug;
+
+    fn f() {
+        Debug;
+        let x: Debug = Debug;
+    }
+    fn g() {
+        Debug;
+    }
+}
+
+fn f() {
+    std::fmt::Debug;
+}
+    ",
+        );
+    }
+
+    #[test]
+    fn does_not_replace_in_submodules() {
+        check_assist(
+            replace_qualified_name_with_use,
+            r"
+fn main() {
+    std::fmt::Debug<|>;
+}
+
+mod sub {
+    fn f() {
+        std::fmt::Debug;
+    }
+}
+    ",
+            r"
+use std::fmt::Debug;
+
+fn main() {
+    Debug;
+}
+
+mod sub {
+    fn f() {
+        std::fmt::Debug;
+    }
+}
+    ",
+        );
+    }
+
+    #[test]
+    fn does_not_replace_in_use() {
+        check_assist(
+            replace_qualified_name_with_use,
+            r"
+use std::fmt::Display;
+
+fn main() {
+    std::fmt<|>;
+}
+    ",
+            r"
+use std::fmt::{self, Display};
+
+fn main() {
+    fmt;
+}
+    ",
+        );
+    }
 }
diff --git a/crates/ra_assists/src/utils.rs b/crates/ra_assists/src/utils.rs
index 0038a9764..c1ff0de7b 100644
--- a/crates/ra_assists/src/utils.rs
+++ b/crates/ra_assists/src/utils.rs
@@ -13,7 +13,7 @@ use rustc_hash::FxHashSet;
 
 use crate::assist_config::SnippetCap;
 
-pub(crate) use insert_use::insert_use_statement;
+pub(crate) use insert_use::{find_insert_use_container, insert_use_statement};
 
 #[derive(Clone, Copy, Debug)]
 pub(crate) enum Cursor<'a> {
diff --git a/crates/ra_assists/src/utils/insert_use.rs b/crates/ra_assists/src/utils/insert_use.rs
index 0ee43482f..8c4f33e59 100644
--- a/crates/ra_assists/src/utils/insert_use.rs
+++ b/crates/ra_assists/src/utils/insert_use.rs
@@ -12,6 +12,20 @@ use ra_syntax::{
 use ra_text_edit::TextEditBuilder;
 
 use crate::assist_context::AssistContext;
+use either::Either;
+
+/// Determines the containing syntax node in which to insert a `use` statement affecting `position`.
+pub(crate) fn find_insert_use_container(
+    position: &SyntaxNode,
+    ctx: &AssistContext,
+) -> Option<Either<ast::ItemList, ast::SourceFile>> {
+    ctx.sema.ancestors_with_macros(position.clone()).find_map(|n| {
+        if let Some(module) = ast::Module::cast(n.clone()) {
+            return module.item_list().map(|it| Either::Left(it));
+        }
+        Some(Either::Right(ast::SourceFile::cast(n)?))
+    })
+}
 
 /// Creates and inserts a use statement for the given path to import.
 /// The use statement is inserted in the scope most appropriate to the
@@ -24,15 +38,11 @@ pub(crate) fn insert_use_statement(
     builder: &mut TextEditBuilder,
 ) {
     let target = path_to_import.to_string().split("::").map(SmolStr::new).collect::<Vec<_>>();
-    let container = ctx.sema.ancestors_with_macros(position.clone()).find_map(|n| {
-        if let Some(module) = ast::Module::cast(n.clone()) {
-            return module.item_list().map(|it| it.syntax().clone());
-        }
-        ast::SourceFile::cast(n).map(|it| it.syntax().clone())
-    });
+    let container = find_insert_use_container(position, ctx);
 
     if let Some(container) = container {
-        let action = best_action_for_target(container, position.clone(), &target);
+        let syntax = container.either(|l| l.syntax().clone(), |r| r.syntax().clone());
+        let action = best_action_for_target(syntax, position.clone(), &target);
         make_assist(&action, &target, builder);
     }
 }
diff --git a/crates/ra_hir_def/src/diagnostics.rs b/crates/ra_hir_def/src/diagnostics.rs
index 510c5e064..30db48f86 100644
--- a/crates/ra_hir_def/src/diagnostics.rs
+++ b/crates/ra_hir_def/src/diagnostics.rs
@@ -3,7 +3,6 @@
 use std::any::Any;
 
 use hir_expand::diagnostics::Diagnostic;
-use ra_db::RelativePathBuf;
 use ra_syntax::{ast, AstPtr, SyntaxNodePtr};
 
 use hir_expand::{HirFileId, InFile};
@@ -12,7 +11,7 @@ use hir_expand::{HirFileId, InFile};
 pub struct UnresolvedModule {
     pub file: HirFileId,
     pub decl: AstPtr<ast::Module>,
-    pub candidate: RelativePathBuf,
+    pub candidate: String,
 }
 
 impl Diagnostic for UnresolvedModule {
diff --git a/crates/ra_hir_def/src/nameres.rs b/crates/ra_hir_def/src/nameres.rs
index f279c2ad4..b3e5f491a 100644
--- a/crates/ra_hir_def/src/nameres.rs
+++ b/crates/ra_hir_def/src/nameres.rs
@@ -296,7 +296,6 @@ pub enum ModuleSource {
 
 mod diagnostics {
     use hir_expand::diagnostics::DiagnosticSink;
-    use ra_db::RelativePathBuf;
     use ra_syntax::{ast, AstPtr};
 
     use crate::{db::DefDatabase, diagnostics::UnresolvedModule, nameres::LocalModuleId, AstId};
@@ -306,7 +305,7 @@ mod diagnostics {
         UnresolvedModule {
             module: LocalModuleId,
             declaration: AstId<ast::Module>,
-            candidate: RelativePathBuf,
+            candidate: String,
         },
     }
 
diff --git a/crates/ra_hir_def/src/nameres/mod_resolution.rs b/crates/ra_hir_def/src/nameres/mod_resolution.rs
index cede4a6fc..19fe0615a 100644
--- a/crates/ra_hir_def/src/nameres/mod_resolution.rs
+++ b/crates/ra_hir_def/src/nameres/mod_resolution.rs
@@ -44,7 +44,7 @@ impl ModDir {
         file_id: HirFileId,
         name: &Name,
         attr_path: Option<&SmolStr>,
-    ) -> Result<(FileId, ModDir), RelativePathBuf> {
+    ) -> Result<(FileId, ModDir), String> {
         let file_id = file_id.original_file(db.upcast());
 
         let mut candidate_files = Vec::new();
@@ -52,11 +52,11 @@ impl ModDir {
             Some(attr_path) => {
                 let base =
                     if self.root_non_dir_owner { self.path.parent().unwrap() } else { &self.path };
-                candidate_files.push(base.join(attr_path))
+                candidate_files.push(base.join(attr_path).to_string())
             }
             None => {
-                candidate_files.push(self.path.join(&format!("{}.rs", name)));
-                candidate_files.push(self.path.join(&format!("{}/mod.rs", name)));
+                candidate_files.push(self.path.join(&format!("{}.rs", name)).to_string());
+                candidate_files.push(self.path.join(&format!("{}/mod.rs", name)).to_string());
             }
         };
 
diff --git a/crates/ra_hir_def/src/path.rs b/crates/ra_hir_def/src/path.rs
index ba16442bd..190d6d98d 100644
--- a/crates/ra_hir_def/src/path.rs
+++ b/crates/ra_hir_def/src/path.rs
@@ -154,7 +154,7 @@ pub enum GenericArg {
 
 impl Path {
     /// Converts an `ast::Path` to `Path`. Works with use trees.
-    /// DEPRECATED: It does not handle `$crate` from macro call.
+    #[deprecated = "Doesn't handle hygiene, don't add new calls, remove old ones"]
     pub fn from_ast(path: ast::Path) -> Option<Path> {
         lower::lower_path(path, &Hygiene::new_unhygienic())
     }
diff --git a/crates/ra_hir_ty/src/_match.rs b/crates/ra_hir_ty/src/_match.rs
index 3e6e1e333..02a7a61f1 100644
--- a/crates/ra_hir_ty/src/_match.rs
+++ b/crates/ra_hir_ty/src/_match.rs
@@ -8,11 +8,11 @@
 //! This file includes the logic for exhaustiveness and usefulness checking for
 //! pattern-matching. Specifically, given a list of patterns for a type, we can
 //! tell whether:
-//! (a) the patterns cover every possible constructor for the type [exhaustiveness]
-//! (b) each pattern is necessary [usefulness]
+//! - (a) the patterns cover every possible constructor for the type (exhaustiveness).
+//! - (b) each pattern is necessary (usefulness).
 //!
-//! The algorithm implemented here is a modified version of the one described in:
-//! http://moscova.inria.fr/~maranget/papers/warn/index.html
+//! The algorithm implemented here is a modified version of the one described in
+//! <http://moscova.inria.fr/~maranget/papers/warn/index.html>.
 //! However, to save future implementors from reading the original paper, we
 //! summarise the algorithm here to hopefully save time and be a little clearer
 //! (without being so rigorous).
@@ -37,20 +37,26 @@
 //! new pattern `p`.
 //!
 //! For example, say we have the following:
+//!
+//! ```ignore
+//! // x: (Option<bool>, Result<()>)
+//! match x {
+//!     (Some(true), _) => {}
+//!     (None, Err(())) => {}
+//!     (None, Err(_)) => {}
+//! }
 //! ```
-//!     // x: (Option<bool>, Result<()>)
-//!     match x {
-//!         (Some(true), _) => {}
-//!         (None, Err(())) => {}
-//!         (None, Err(_)) => {}
-//!     }
-//! ```
+//!
 //! Here, the matrix `P` starts as:
+//!
+//! ```text
 //! [
 //!     [(Some(true), _)],
 //!     [(None, Err(()))],
 //!     [(None, Err(_))],
 //! ]
+//! ```
+//!
 //! We can tell it's not exhaustive, because `U(P, _)` is true (we're not covering
 //! `[(Some(false), _)]`, for instance). In addition, row 3 is not useful, because
 //! all the values it covers are already covered by row 2.
@@ -60,53 +66,61 @@
 //! To match the paper, the top of the stack is at the beginning / on the left.
 //!
 //! There are two important operations on pattern-stacks necessary to understand the algorithm:
-//!     1. We can pop a given constructor off the top of a stack. This operation is called
-//!        `specialize`, and is denoted `S(c, p)` where `c` is a constructor (like `Some` or
-//!        `None`) and `p` a pattern-stack.
-//!        If the pattern on top of the stack can cover `c`, this removes the constructor and
-//!        pushes its arguments onto the stack. It also expands OR-patterns into distinct patterns.
-//!        Otherwise the pattern-stack is discarded.
-//!        This essentially filters those pattern-stacks whose top covers the constructor `c` and
-//!        discards the others.
 //!
-//!        For example, the first pattern above initially gives a stack `[(Some(true), _)]`. If we
-//!        pop the tuple constructor, we are left with `[Some(true), _]`, and if we then pop the
-//!        `Some` constructor we get `[true, _]`. If we had popped `None` instead, we would get
-//!        nothing back.
+//! 1. We can pop a given constructor off the top of a stack. This operation is called
+//!    `specialize`, and is denoted `S(c, p)` where `c` is a constructor (like `Some` or
+//!    `None`) and `p` a pattern-stack.
+//!    If the pattern on top of the stack can cover `c`, this removes the constructor and
+//!    pushes its arguments onto the stack. It also expands OR-patterns into distinct patterns.
+//!    Otherwise the pattern-stack is discarded.
+//!    This essentially filters those pattern-stacks whose top covers the constructor `c` and
+//!    discards the others.
+//!
+//!    For example, the first pattern above initially gives a stack `[(Some(true), _)]`. If we
+//!    pop the tuple constructor, we are left with `[Some(true), _]`, and if we then pop the
+//!    `Some` constructor we get `[true, _]`. If we had popped `None` instead, we would get
+//!    nothing back.
+//!
+//!    This returns zero or more new pattern-stacks, as follows. We look at the pattern `p_1`
+//!    on top of the stack, and we have four cases:
+//!
+//!    * 1.1. `p_1 = c(r_1, .., r_a)`, i.e. the top of the stack has constructor `c`. We push onto
+//!           the stack the arguments of this constructor, and return the result:
 //!
-//!        This returns zero or more new pattern-stacks, as follows. We look at the pattern `p_1`
-//!        on top of the stack, and we have four cases:
-//!             1.1. `p_1 = c(r_1, .., r_a)`, i.e. the top of the stack has constructor `c`. We
-//!                  push onto the stack the arguments of this constructor, and return the result:
-//!                     r_1, .., r_a, p_2, .., p_n
-//!             1.2. `p_1 = c'(r_1, .., r_a')` where `c ≠ c'`. We discard the current stack and
-//!                  return nothing.
-//!             1.3. `p_1 = _`. We push onto the stack as many wildcards as the constructor `c` has
-//!                  arguments (its arity), and return the resulting stack:
-//!                     _, .., _, p_2, .., p_n
-//!             1.4. `p_1 = r_1 | r_2`. We expand the OR-pattern and then recurse on each resulting
-//!                  stack:
-//!                     S(c, (r_1, p_2, .., p_n))
-//!                     S(c, (r_2, p_2, .., p_n))
+//!          r_1, .., r_a, p_2, .., p_n
 //!
-//!     2. We can pop a wildcard off the top of the stack. This is called `D(p)`, where `p` is
-//!        a pattern-stack.
-//!        This is used when we know there are missing constructor cases, but there might be
-//!        existing wildcard patterns, so to check the usefulness of the matrix, we have to check
-//!        all its *other* components.
+//!    * 1.2. `p_1 = c'(r_1, .., r_a')` where `c ≠ c'`. We discard the current stack and return
+//!           nothing.
+//!    * 1.3. `p_1 = _`. We push onto the stack as many wildcards as the constructor `c` has
+//!           arguments (its arity), and return the resulting stack:
 //!
-//!        It is computed as follows. We look at the pattern `p_1` on top of the stack,
-//!        and we have three cases:
-//!             1.1. `p_1 = c(r_1, .., r_a)`. We discard the current stack and return nothing.
-//!             1.2. `p_1 = _`. We return the rest of the stack:
-//!                     p_2, .., p_n
-//!             1.3. `p_1 = r_1 | r_2`. We expand the OR-pattern and then recurse on each resulting
-//!               stack.
-//!                     D((r_1, p_2, .., p_n))
-//!                     D((r_2, p_2, .., p_n))
+//!          _, .., _, p_2, .., p_n
 //!
-//!     Note that the OR-patterns are not always used directly in Rust, but are used to derive the
-//!     exhaustive integer matching rules, so they're written here for posterity.
+//!    * 1.4. `p_1 = r_1 | r_2`. We expand the OR-pattern and then recurse on each resulting stack:
+//!
+//!          S(c, (r_1, p_2, .., p_n))
+//!          S(c, (r_2, p_2, .., p_n))
+//!
+//! 2. We can pop a wildcard off the top of the stack. This is called `D(p)`, where `p` is
+//!    a pattern-stack.
+//!    This is used when we know there are missing constructor cases, but there might be
+//!    existing wildcard patterns, so to check the usefulness of the matrix, we have to check
+//!    all its *other* components.
+//!
+//!    It is computed as follows. We look at the pattern `p_1` on top of the stack,
+//!    and we have three cases:
+//!    * 1.1. `p_1 = c(r_1, .., r_a)`. We discard the current stack and return nothing.
+//!    * 1.2. `p_1 = _`. We return the rest of the stack:
+//!
+//!          p_2, .., p_n
+//!
+//!    * 1.3. `p_1 = r_1 | r_2`. We expand the OR-pattern and then recurse on each resulting stack:
+//!
+//!          D((r_1, p_2, .., p_n))
+//!          D((r_2, p_2, .., p_n))
+//!
+//!    Note that the OR-patterns are not always used directly in Rust, but are used to derive the
+//!    exhaustive integer matching rules, so they're written here for posterity.
 //!
 //! Both those operations extend straightforwardly to a list or pattern-stacks, i.e. a matrix, by
 //! working row-by-row. Popping a constructor ends up keeping only the matrix rows that start with
@@ -120,73 +134,88 @@
 //! operates principally on the first component of the matrix and new pattern-stack `p`.
 //! This algorithm is realised in the `is_useful` function.
 //!
-//! Base case. (`n = 0`, i.e., an empty tuple pattern)
-//!     - If `P` already contains an empty pattern (i.e., if the number of patterns `m > 0`),
-//!       then `U(P, p)` is false.
-//!     - Otherwise, `P` must be empty, so `U(P, p)` is true.
+//! Base case (`n = 0`, i.e., an empty tuple pattern):
+//! - If `P` already contains an empty pattern (i.e., if the number of patterns `m > 0`), then
+//!   `U(P, p)` is false.
+//! - Otherwise, `P` must be empty, so `U(P, p)` is true.
+//!
+//! Inductive step (`n > 0`, i.e., whether there's at least one column [which may then be expanded
+//! into further columns later]). We're going to match on the top of the new pattern-stack, `p_1`:
+//!
+//! - If `p_1 == c(r_1, .., r_a)`, i.e. we have a constructor pattern.
+//!   Then, the usefulness of `p_1` can be reduced to whether it is useful when
+//!   we ignore all the patterns in the first column of `P` that involve other constructors.
+//!   This is where `S(c, P)` comes in:
 //!
-//! Inductive step. (`n > 0`, i.e., whether there's at least one column
-//!                  [which may then be expanded into further columns later])
-//!     We're going to match on the top of the new pattern-stack, `p_1`.
-//!         - If `p_1 == c(r_1, .., r_a)`, i.e. we have a constructor pattern.
-//!           Then, the usefulness of `p_1` can be reduced to whether it is useful when
-//!           we ignore all the patterns in the first column of `P` that involve other constructors.
-//!           This is where `S(c, P)` comes in:
-//!           `U(P, p) := U(S(c, P), S(c, p))`
-//!           This special case is handled in `is_useful_specialized`.
+//!   ```text
+//!   U(P, p) := U(S(c, P), S(c, p))
+//!   ```
 //!
-//!           For example, if `P` is:
-//!           [
-//!               [Some(true), _],
-//!               [None, 0],
-//!           ]
-//!           and `p` is [Some(false), 0], then we don't care about row 2 since we know `p` only
-//!           matches values that row 2 doesn't. For row 1 however, we need to dig into the
-//!           arguments of `Some` to know whether some new value is covered. So we compute
-//!           `U([[true, _]], [false, 0])`.
+//!   This special case is handled in `is_useful_specialized`.
 //!
-//!         - If `p_1 == _`, then we look at the list of constructors that appear in the first
-//!               component of the rows of `P`:
-//!             + If there are some constructors that aren't present, then we might think that the
-//!               wildcard `_` is useful, since it covers those constructors that weren't covered
-//!               before.
-//!               That's almost correct, but only works if there were no wildcards in those first
-//!               components. So we need to check that `p` is useful with respect to the rows that
-//!               start with a wildcard, if there are any. This is where `D` comes in:
-//!               `U(P, p) := U(D(P), D(p))`
+//!   For example, if `P` is:
 //!
-//!               For example, if `P` is:
-//!               [
-//!                   [_, true, _],
-//!                   [None, false, 1],
-//!               ]
-//!               and `p` is [_, false, _], the `Some` constructor doesn't appear in `P`. So if we
-//!               only had row 2, we'd know that `p` is useful. However row 1 starts with a
-//!               wildcard, so we need to check whether `U([[true, _]], [false, 1])`.
+//!   ```text
+//!   [
+//!       [Some(true), _],
+//!       [None, 0],
+//!   ]
+//!   ```
 //!
-//!             + Otherwise, all possible constructors (for the relevant type) are present. In this
-//!               case we must check whether the wildcard pattern covers any unmatched value. For
-//!               that, we can think of the `_` pattern as a big OR-pattern that covers all
-//!               possible constructors. For `Option`, that would mean `_ = None | Some(_)` for
-//!               example. The wildcard pattern is useful in this case if it is useful when
-//!               specialized to one of the possible constructors. So we compute:
-//!               `U(P, p) := ∃(k ϵ constructors) U(S(k, P), S(k, p))`
+//!   and `p` is `[Some(false), 0]`, then we don't care about row 2 since we know `p` only
+//!   matches values that row 2 doesn't. For row 1 however, we need to dig into the
+//!   arguments of `Some` to know whether some new value is covered. So we compute
+//!   `U([[true, _]], [false, 0])`.
 //!
-//!               For example, if `P` is:
-//!               [
-//!                   [Some(true), _],
-//!                   [None, false],
-//!               ]
-//!               and `p` is [_, false], both `None` and `Some` constructors appear in the first
-//!               components of `P`. We will therefore try popping both constructors in turn: we
-//!               compute U([[true, _]], [_, false]) for the `Some` constructor, and U([[false]],
-//!               [false]) for the `None` constructor. The first case returns true, so we know that
-//!               `p` is useful for `P`. Indeed, it matches `[Some(false), _]` that wasn't matched
-//!               before.
+//! - If `p_1 == _`, then we look at the list of constructors that appear in the first component of
+//!   the rows of `P`:
+//!     - If there are some constructors that aren't present, then we might think that the
+//!       wildcard `_` is useful, since it covers those constructors that weren't covered
+//!       before.
+//!       That's almost correct, but only works if there were no wildcards in those first
+//!       components. So we need to check that `p` is useful with respect to the rows that
+//!       start with a wildcard, if there are any. This is where `D` comes in:
+//!       `U(P, p) := U(D(P), D(p))`
 //!
-//!         - If `p_1 == r_1 | r_2`, then the usefulness depends on each `r_i` separately:
-//!           `U(P, p) := U(P, (r_1, p_2, .., p_n))
-//!                    || U(P, (r_2, p_2, .., p_n))`
+//!       For example, if `P` is:
+//!       ```text
+//!       [
+//!           [_, true, _],
+//!           [None, false, 1],
+//!       ]
+//!       ```
+//!       and `p` is `[_, false, _]`, the `Some` constructor doesn't appear in `P`. So if we
+//!       only had row 2, we'd know that `p` is useful. However row 1 starts with a
+//!       wildcard, so we need to check whether `U([[true, _]], [false, 1])`.
+//!
+//!     - Otherwise, all possible constructors (for the relevant type) are present. In this
+//!       case we must check whether the wildcard pattern covers any unmatched value. For
+//!       that, we can think of the `_` pattern as a big OR-pattern that covers all
+//!       possible constructors. For `Option`, that would mean `_ = None | Some(_)` for
+//!       example. The wildcard pattern is useful in this case if it is useful when
+//!       specialized to one of the possible constructors. So we compute:
+//!       `U(P, p) := ∃(k ϵ constructors) U(S(k, P), S(k, p))`
+//!
+//!       For example, if `P` is:
+//!       ```text
+//!       [
+//!           [Some(true), _],
+//!           [None, false],
+//!       ]
+//!       ```
+//!       and `p` is `[_, false]`, both `None` and `Some` constructors appear in the first
+//!       components of `P`. We will therefore try popping both constructors in turn: we
+//!       compute `U([[true, _]], [_, false])` for the `Some` constructor, and `U([[false]],
+//!       [false])` for the `None` constructor. The first case returns true, so we know that
+//!       `p` is useful for `P`. Indeed, it matches `[Some(false), _]` that wasn't matched
+//!       before.
+//!
+//! - If `p_1 == r_1 | r_2`, then the usefulness depends on each `r_i` separately:
+//!
+//!   ```text
+//!   U(P, p) := U(P, (r_1, p_2, .., p_n))
+//!            || U(P, (r_2, p_2, .., p_n))
+//!   ```
 use std::sync::Arc;
 
 use smallvec::{smallvec, SmallVec};
@@ -333,7 +362,12 @@ impl PatStack {
         cx: &MatchCheckCtx,
         constructor: &Constructor,
     ) -> MatchCheckResult<Option<PatStack>> {
-        let result = match (self.head().as_pat(cx), constructor) {
+        if self.is_empty() {
+            return Ok(None);
+        }
+
+        let head_pat = self.head().as_pat(cx);
+        let result = match (head_pat, constructor) {
             (Pat::Tuple { args: ref pat_ids, ellipsis }, Constructor::Tuple { arity: _ }) => {
                 if ellipsis.is_some() {
                     // If there are ellipsis here, we should add the correct number of
@@ -502,7 +536,7 @@ impl Matrix {
     }
 
     fn heads(&self) -> Vec<PatIdOrWild> {
-        self.0.iter().map(|p| p.head()).collect()
+        self.0.iter().flat_map(|p| p.get_head()).collect()
     }
 
     /// Computes `D(self)` for each contained PatStack.
@@ -808,194 +842,193 @@ mod tests {
 
     pub(super) use crate::{diagnostics::MissingMatchArms, test_db::TestDB};
 
-    pub(super) fn check_diagnostic_message(content: &str) -> String {
-        TestDB::with_single_file(content).0.diagnostic::<MissingMatchArms>().0
+    pub(super) fn check_diagnostic_message(ra_fixture: &str) -> String {
+        TestDB::with_single_file(ra_fixture).0.diagnostic::<MissingMatchArms>().0
     }
 
-    pub(super) fn check_diagnostic(content: &str) {
+    pub(super) fn check_diagnostic(ra_fixture: &str) {
         let diagnostic_count =
-            TestDB::with_single_file(content).0.diagnostic::<MissingMatchArms>().1;
+            TestDB::with_single_file(ra_fixture).0.diagnostic::<MissingMatchArms>().1;
 
         assert_eq!(1, diagnostic_count, "no diagnostic reported");
     }
 
-    pub(super) fn check_no_diagnostic(content: &str) {
+    pub(super) fn check_no_diagnostic(ra_fixture: &str) {
         let diagnostic_count =
-            TestDB::with_single_file(content).0.diagnostic::<MissingMatchArms>().1;
+            TestDB::with_single_file(ra_fixture).0.diagnostic::<MissingMatchArms>().1;
 
         assert_eq!(0, diagnostic_count, "expected no diagnostic, found one");
     }
 
     #[test]
     fn empty_tuple_no_arms_diagnostic_message() {
-        let content = r"
-            fn test_fn() {
-                match () {
-                }
-            }
-        ";
-
         assert_snapshot!(
-            check_diagnostic_message(content),
+            check_diagnostic_message(r"
+                fn test_fn() {
+                    match () {
+                    }
+                }
+            "),
             @"\"()\": Missing match arm\n"
         );
     }
 
     #[test]
     fn empty_tuple_no_arms() {
-        let content = r"
+        check_diagnostic(
+            r"
             fn test_fn() {
                 match () {
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn empty_tuple_wild() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             fn test_fn() {
                 match () {
                     _ => {}
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn empty_tuple_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             fn test_fn() {
                 match () {
                     () => {}
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn tuple_of_empty_tuple_no_arms() {
-        let content = r"
+        check_diagnostic(
+            r"
             fn test_fn() {
                 match (()) {
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn tuple_of_empty_tuple_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             fn test_fn() {
                 match (()) {
                     (()) => {}
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn tuple_of_two_empty_tuple_no_arms() {
-        let content = r"
+        check_diagnostic(
+            r"
             fn test_fn() {
                 match ((), ()) {
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn tuple_of_two_empty_tuple_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             fn test_fn() {
                 match ((), ()) {
                     ((), ()) => {}
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn bool_no_arms() {
-        let content = r"
+        check_diagnostic(
+            r"
             fn test_fn() {
                 match false {
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn bool_missing_arm() {
-        let content = r"
+        check_diagnostic(
+            r"
             fn test_fn() {
                 match false {
                     true => {}
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn bool_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             fn test_fn() {
                 match false {
                     true => {}
                     false => {}
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn tuple_of_bools_no_arms() {
-        let content = r"
+        check_diagnostic(
+            r"
             fn test_fn() {
                 match (false, true) {
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn tuple_of_bools_missing_arms() {
-        let content = r"
+        check_diagnostic(
+            r"
             fn test_fn() {
                 match (false, true) {
                     (true, true) => {},
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn tuple_of_bools_missing_arm() {
-        let content = r"
+        check_diagnostic(
+            r"
             fn test_fn() {
                 match (false, true) {
                     (false, true) => {},
@@ -1003,14 +1036,14 @@ mod tests {
                     (true, false) => {},
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn tuple_of_bools_with_wilds() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             fn test_fn() {
                 match (false, true) {
                     (false, _) => {},
@@ -1018,14 +1051,14 @@ mod tests {
                     (_, true) => {},
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn tuple_of_bools_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             fn test_fn() {
                 match (false, true) {
                     (true, true) => {},
@@ -1034,27 +1067,27 @@ mod tests {
                     (false, false) => {},
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn tuple_of_bools_binding_missing_arms() {
-        let content = r"
+        check_diagnostic(
+            r"
             fn test_fn() {
                 match (false, true) {
                     (true, _x) => {},
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn tuple_of_bools_binding_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             fn test_fn() {
                 match (false, true) {
                     (true, _x) => {},
@@ -1062,80 +1095,80 @@ mod tests {
                     (false, false) => {},
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn tuple_of_bools_with_ellipsis_at_end_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             fn test_fn() {
                 match (false, true, false) {
                     (false, ..) => {},
                     (true, ..) => {},
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn tuple_of_bools_with_ellipsis_at_beginning_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             fn test_fn() {
                 match (false, true, false) {
                     (.., false) => {},
                     (.., true) => {},
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn tuple_of_bools_with_ellipsis_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             fn test_fn() {
                 match (false, true, false) {
                     (..) => {},
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn tuple_of_tuple_and_bools_no_arms() {
-        let content = r"
+        check_diagnostic(
+            r"
             fn test_fn() {
                 match (false, ((), false)) {
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn tuple_of_tuple_and_bools_missing_arms() {
-        let content = r"
+        check_diagnostic(
+            r"
             fn test_fn() {
                 match (false, ((), false)) {
                     (true, ((), true)) => {},
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn tuple_of_tuple_and_bools_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             fn test_fn() {
                 match (false, ((), false)) {
                     (true, ((), true)) => {},
@@ -1144,27 +1177,27 @@ mod tests {
                     (false, ((), false)) => {},
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn tuple_of_tuple_and_bools_wildcard_missing_arms() {
-        let content = r"
+        check_diagnostic(
+            r"
             fn test_fn() {
                 match (false, ((), false)) {
                     (true, _) => {},
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn tuple_of_tuple_and_bools_wildcard_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             fn test_fn() {
                 match (false, ((), false)) {
                     (true, ((), true)) => {},
@@ -1172,14 +1205,14 @@ mod tests {
                     (false, _) => {},
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_no_arms() {
-        let content = r"
+        check_diagnostic(
+            r"
             enum Either {
                 A,
                 B,
@@ -1188,14 +1221,14 @@ mod tests {
                 match Either::A {
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_missing_arms() {
-        let content = r"
+        check_diagnostic(
+            r"
             enum Either {
                 A,
                 B,
@@ -1205,14 +1238,14 @@ mod tests {
                     Either::A => {},
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             enum Either {
                 A,
                 B,
@@ -1223,14 +1256,14 @@ mod tests {
                     Either::B => {},
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_ref_missing_arms() {
-        let content = r"
+        check_diagnostic(
+            r"
             enum Either {
                 A,
                 B,
@@ -1240,14 +1273,14 @@ mod tests {
                     Either::A => {},
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_ref_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             enum Either {
                 A,
                 B,
@@ -1258,14 +1291,14 @@ mod tests {
                     Either::B => {},
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_containing_bool_no_arms() {
-        let content = r"
+        check_diagnostic(
+            r"
             enum Either {
                 A(bool),
                 B,
@@ -1274,14 +1307,14 @@ mod tests {
                 match Either::B {
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_containing_bool_missing_arms() {
-        let content = r"
+        check_diagnostic(
+            r"
             enum Either {
                 A(bool),
                 B,
@@ -1292,14 +1325,14 @@ mod tests {
                     Either::B => (),
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_containing_bool_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             enum Either {
                 A(bool),
                 B,
@@ -1311,14 +1344,14 @@ mod tests {
                     Either::B => (),
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_containing_bool_with_wild_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             enum Either {
                 A(bool),
                 B,
@@ -1329,14 +1362,14 @@ mod tests {
                     _ => (),
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_containing_bool_with_wild_2_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             enum Either {
                 A(bool),
                 B,
@@ -1347,14 +1380,14 @@ mod tests {
                     Either::B => (),
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_different_sizes_missing_arms() {
-        let content = r"
+        check_diagnostic(
+            r"
             enum Either {
                 A(bool),
                 B(bool, bool),
@@ -1365,14 +1398,14 @@ mod tests {
                     Either::B(false, _) => (),
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_different_sizes_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             enum Either {
                 A(bool),
                 B(bool, bool),
@@ -1384,14 +1417,14 @@ mod tests {
                     Either::B(false, _) => (),
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn or_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             enum Either {
                 A(bool),
                 B(bool, bool),
@@ -1403,14 +1436,14 @@ mod tests {
                     Either::B(false, _) => (),
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn tuple_of_enum_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             enum Either {
                 A(bool),
                 B(bool, bool),
@@ -1427,14 +1460,16 @@ mod tests {
                     (Either::B(_, _), Either2::D) => (),
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn mismatched_types() {
-        let content = r"
+        // Match statements with arms that don't match the
+        // expression pattern do not fire this diagnostic.
+        check_no_diagnostic(
+            r"
             enum Either {
                 A,
                 B,
@@ -1449,47 +1484,47 @@ mod tests {
                     Either2::D => (),
                 }
             }
-        ";
-
-        // Match statements with arms that don't match the
-        // expression pattern do not fire this diagnostic.
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn mismatched_types_with_different_arity() {
-        let content = r"
+        // Match statements with arms that don't match the
+        // expression pattern do not fire this diagnostic.
+        check_no_diagnostic(
+            r"
             fn test_fn() {
                 match (true, false) {
                     (true, false, true) => (),
                     (true) => (),
                 }
             }
-        ";
-
-        // Match statements with arms that don't match the
-        // expression pattern do not fire this diagnostic.
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn malformed_match_arm_tuple_missing_pattern() {
-        let content = r"
+        // Match statements with arms that don't match the
+        // expression pattern do not fire this diagnostic.
+        check_no_diagnostic(
+            r"
             fn test_fn() {
                 match (0) {
                     () => (),
                 }
             }
-        ";
-
-        // Match statements with arms that don't match the
-        // expression pattern do not fire this diagnostic.
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn malformed_match_arm_tuple_enum_missing_pattern() {
-        let content = r"
+        // We are testing to be sure we don't panic here when the match
+        // arm `Either::B` is missing its pattern.
+        check_no_diagnostic(
+            r"
             enum Either {
                 A,
                 B(u32),
@@ -1500,32 +1535,30 @@ mod tests {
                     Either::B() => (),
                 }
             }
-        ";
-
-        // We are testing to be sure we don't panic here when the match
-        // arm `Either::B` is missing its pattern.
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_not_in_scope() {
-        let content = r"
+        // The enum is not in scope so we don't perform exhaustiveness
+        // checking, but we want to be sure we don't panic here (and
+        // we don't create a diagnostic).
+        check_no_diagnostic(
+            r"
             fn test_fn() {
                 match Foo::Bar {
                     Foo::Baz => (),
                 }
             }
-        ";
-
-        // The enum is not in scope so we don't perform exhaustiveness
-        // checking, but we want to be sure we don't panic here (and
-        // we don't create a diagnostic).
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn expr_diverges() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             enum Either {
                 A,
                 B,
@@ -1536,14 +1569,14 @@ mod tests {
                     Either::B => (),
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn expr_loop_with_break() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             enum Either {
                 A,
                 B,
@@ -1554,14 +1587,14 @@ mod tests {
                     Either::B => (),
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn expr_partially_diverges() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             enum Either<T> {
                 A(T),
                 B,
@@ -1575,14 +1608,14 @@ mod tests {
                     Either::B => 0,
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_record_no_arms() {
-        let content = r"
+        check_diagnostic(
+            r"
             enum Either {
                 A { foo: bool },
                 B,
@@ -1592,14 +1625,14 @@ mod tests {
                 match a {
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_record_missing_arms() {
-        let content = r"
+        check_diagnostic(
+            r"
             enum Either {
                 A { foo: bool },
                 B,
@@ -1610,14 +1643,14 @@ mod tests {
                     Either::A { foo: true } => (),
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_record_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             enum Either {
                 A { foo: bool },
                 B,
@@ -1630,14 +1663,17 @@ mod tests {
                     Either::B => (),
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_record_missing_field_no_diagnostic() {
-        let content = r"
+        // When `Either::A` is missing a struct member, we don't want
+        // to fire the missing match arm diagnostic. This should fire
+        // some other diagnostic.
+        check_no_diagnostic(
+            r"
             enum Either {
                 A { foo: bool },
                 B,
@@ -1649,17 +1685,16 @@ mod tests {
                     Either::B => (),
                 }
             }
-        ";
-
-        // When `Either::A` is missing a struct member, we don't want
-        // to fire the missing match arm diagnostic. This should fire
-        // some other diagnostic.
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_record_missing_field_missing_match_arm() {
-        let content = r"
+        // Even though `Either::A` is missing fields, we still want to fire
+        // the missing arm diagnostic here, since we know `Either::B` is missing.
+        check_diagnostic(
+            r"
             enum Either {
                 A { foo: bool },
                 B,
@@ -1670,16 +1705,14 @@ mod tests {
                     Either::A { } => (),
                 }
             }
-        ";
-
-        // Even though `Either::A` is missing fields, we still want to fire
-        // the missing arm diagnostic here, since we know `Either::B` is missing.
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_record_no_diagnostic_wild() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             enum Either {
                 A { foo: bool },
                 B,
@@ -1691,14 +1724,14 @@ mod tests {
                     Either::B => (),
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_record_fields_out_of_order_missing_arm() {
-        let content = r"
+        check_diagnostic(
+            r"
             enum Either {
                 A { foo: bool, bar: () },
                 B,
@@ -1710,14 +1743,14 @@ mod tests {
                     Either::A { foo: true, bar: () } => (),
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_record_fields_out_of_order_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             enum Either {
                 A { foo: bool, bar: () },
                 B,
@@ -1730,89 +1763,89 @@ mod tests {
                     Either::B => (),
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_record_ellipsis_missing_arm() {
-        let content = r"
-             enum Either {
-                 A { foo: bool, bar: bool },
-                 B,
-             }
-             fn test_fn() {
-                 match Either::B {
-                     Either::A { foo: true, .. } => (),
-                     Either::B => (),
-                 }
-             }
-         ";
-
-        check_diagnostic(content);
+        check_diagnostic(
+            r"
+            enum Either {
+                A { foo: bool, bar: bool },
+                B,
+            }
+            fn test_fn() {
+                match Either::B {
+                    Either::A { foo: true, .. } => (),
+                    Either::B => (),
+                }
+            }
+        ",
+        );
     }
 
     #[test]
     fn enum_record_ellipsis_no_diagnostic() {
-        let content = r"
-             enum Either {
-                 A { foo: bool, bar: bool },
-                 B,
-             }
-             fn test_fn() {
-                 let a = Either::A { foo: true };
-                 match a {
-                     Either::A { foo: true, .. } => (),
-                     Either::A { foo: false, .. } => (),
-                     Either::B => (),
-                 }
-             }
-         ";
-
-        check_no_diagnostic(content);
+        check_no_diagnostic(
+            r"
+            enum Either {
+                A { foo: bool, bar: bool },
+                B,
+            }
+            fn test_fn() {
+                let a = Either::A { foo: true };
+                match a {
+                    Either::A { foo: true, .. } => (),
+                    Either::A { foo: false, .. } => (),
+                    Either::B => (),
+                }
+            }
+        ",
+        );
     }
 
     #[test]
     fn enum_record_ellipsis_all_fields_missing_arm() {
-        let content = r"
-             enum Either {
-                 A { foo: bool, bar: bool },
-                 B,
-             }
-             fn test_fn() {
-                 let a = Either::B;
-                 match a {
-                     Either::A { .. } => (),
-                 }
-             }
-         ";
-
-        check_diagnostic(content);
+        check_diagnostic(
+            r"
+            enum Either {
+                A { foo: bool, bar: bool },
+                B,
+            }
+            fn test_fn() {
+                let a = Either::B;
+                match a {
+                    Either::A { .. } => (),
+                }
+            }
+        ",
+        );
     }
 
     #[test]
     fn enum_record_ellipsis_all_fields_no_diagnostic() {
-        let content = r"
-             enum Either {
-                 A { foo: bool, bar: bool },
-                 B,
-             }
-             fn test_fn() {
-                 let a = Either::B;
-                 match a {
-                     Either::A { .. } => (),
-                     Either::B => (),
-                 }
-             }
-         ";
-
-        check_no_diagnostic(content);
+        check_no_diagnostic(
+            r"
+            enum Either {
+                A { foo: bool, bar: bool },
+                B,
+            }
+            fn test_fn() {
+                let a = Either::B;
+                match a {
+                    Either::A { .. } => (),
+                    Either::B => (),
+                }
+            }
+        ",
+        );
     }
 
     #[test]
     fn enum_tuple_partial_ellipsis_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             enum Either {
                 A(bool, bool, bool, bool),
                 B,
@@ -1826,14 +1859,14 @@ mod tests {
                     Either::B => {},
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_tuple_partial_ellipsis_2_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             enum Either {
                 A(bool, bool, bool, bool),
                 B,
@@ -1847,14 +1880,14 @@ mod tests {
                     Either::B => {},
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_tuple_partial_ellipsis_missing_arm() {
-        let content = r"
+        check_diagnostic(
+            r"
             enum Either {
                 A(bool, bool, bool, bool),
                 B,
@@ -1867,14 +1900,14 @@ mod tests {
                     Either::B => {},
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_tuple_partial_ellipsis_2_missing_arm() {
-        let content = r"
+        check_diagnostic(
+            r"
             enum Either {
                 A(bool, bool, bool, bool),
                 B,
@@ -1887,14 +1920,14 @@ mod tests {
                     Either::B => {},
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_tuple_ellipsis_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             enum Either {
                 A(bool, bool, bool, bool),
                 B,
@@ -1905,51 +1938,51 @@ mod tests {
                     Either::B => {},
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_never() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             enum Never {}
 
             fn test_fn(never: Never) {
                 match never {}
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn type_never() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             fn test_fn(never: !) {
                 match never {}
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_never_ref() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             enum Never {}
 
             fn test_fn(never: &Never) {
                 match never {}
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn expr_diverges_missing_arm() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             enum Either {
                 A,
                 B,
@@ -1959,9 +1992,27 @@ mod tests {
                     Either::A => (),
                 }
             }
-        ";
+        ",
+        );
+    }
 
-        check_no_diagnostic(content);
+    #[test]
+    fn or_pattern_panic() {
+        check_no_diagnostic(
+            r"
+            pub enum Category {
+                Infinity,
+                Zero,
+            }
+
+            fn panic(a: Category, b: Category) {
+                match (a, b) {
+                    (Category::Zero | Category::Infinity, _) => {}
+                    (_, Category::Zero | Category::Infinity) => {}
+                }
+            }
+        ",
+        );
     }
 }
 
@@ -1981,23 +2032,26 @@ mod false_negatives {
 
     #[test]
     fn integers() {
-        let content = r"
+        // This is a false negative.
+        // We don't currently check integer exhaustiveness.
+        check_no_diagnostic(
+            r"
             fn test_fn() {
                 match 5 {
                     10 => (),
                     11..20 => (),
                 }
             }
-        ";
-
-        // This is a false negative.
-        // We don't currently check integer exhaustiveness.
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn internal_or() {
-        let content = r"
+        // This is a false negative.
+        // We do not currently handle patterns with internal `or`s.
+        check_no_diagnostic(
+            r"
             fn test_fn() {
                 enum Either {
                     A(bool),
@@ -2007,16 +2061,18 @@ mod false_negatives {
                     Either::A(true | false) => (),
                 }
             }
-        ";
-
-        // This is a false negative.
-        // We do not currently handle patterns with internal `or`s.
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn expr_loop_missing_arm() {
-        let content = r"
+        // This is a false negative.
+        // We currently infer the type of `loop { break Foo::A }` to `!`, which
+        // causes us to skip the diagnostic since `Either::A` doesn't type check
+        // with `!`.
+        check_diagnostic(
+            r"
             enum Either {
                 A,
                 B,
@@ -2026,48 +2082,46 @@ mod false_negatives {
                     Either::A => (),
                 }
             }
-        ";
-
-        // This is a false negative.
-        // We currently infer the type of `loop { break Foo::A }` to `!`, which
-        // causes us to skip the diagnostic since `Either::A` doesn't type check
-        // with `!`.
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn tuple_of_bools_with_ellipsis_at_end_missing_arm() {
-        let content = r"
+        // This is a false negative.
+        // We don't currently handle tuple patterns with ellipsis.
+        check_no_diagnostic(
+            r"
             fn test_fn() {
                 match (false, true, false) {
                     (false, ..) => {},
                 }
             }
-        ";
-
-        // This is a false negative.
-        // We don't currently handle tuple patterns with ellipsis.
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn tuple_of_bools_with_ellipsis_at_beginning_missing_arm() {
-        let content = r"
+        // This is a false negative.
+        // We don't currently handle tuple patterns with ellipsis.
+        check_no_diagnostic(
+            r"
             fn test_fn() {
                 match (false, true, false) {
                     (.., false) => {},
                 }
             }
-        ";
-
-        // This is a false negative.
-        // We don't currently handle tuple patterns with ellipsis.
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn struct_missing_arm() {
-        let content = r"
+        // This is a false negative.
+        // We don't currently handle structs.
+        check_no_diagnostic(
+            r"
             struct Foo {
                 a: bool,
             }
@@ -2076,10 +2130,7 @@ mod false_negatives {
                     Foo { a: true } => {},
                 }
             }
-        ";
-
-        // This is a false negative.
-        // We don't currently handle structs.
-        check_no_diagnostic(content);
+        ",
+        );
     }
 }
diff --git a/crates/ra_ide/src/completion/completion_context.rs b/crates/ra_ide/src/completion/completion_context.rs
index 9f4c582d0..560fb19e6 100644
--- a/crates/ra_ide/src/completion/completion_context.rs
+++ b/crates/ra_ide/src/completion/completion_context.rs
@@ -381,6 +381,7 @@ impl<'a> CompletionContext<'a> {
             self.is_path_type = path.syntax().parent().and_then(ast::PathType::cast).is_some();
             self.has_type_args = segment.type_arg_list().is_some();
 
+            #[allow(deprecated)]
             if let Some(path) = hir::Path::from_ast(path.clone()) {
                 if let Some(path_prefix) = path.qualifier() {
                     self.path_prefix = Some(path_prefix);
diff --git a/crates/ra_ide/src/diagnostics.rs b/crates/ra_ide/src/diagnostics.rs
index e1bfd72f9..fd9abb55b 100644
--- a/crates/ra_ide/src/diagnostics.rs
+++ b/crates/ra_ide/src/diagnostics.rs
@@ -11,7 +11,7 @@ use hir::{
     Semantics,
 };
 use itertools::Itertools;
-use ra_db::{RelativePath, SourceDatabase, SourceDatabaseExt};
+use ra_db::SourceDatabase;
 use ra_ide_db::RootDatabase;
 use ra_prof::profile;
 use ra_syntax::{
@@ -57,14 +57,10 @@ pub(crate) fn diagnostics(db: &RootDatabase, file_id: FileId) -> Vec<Diagnostic>
     })
     .on::<hir::diagnostics::UnresolvedModule, _>(|d| {
         let original_file = d.source().file_id.original_file(db);
-        let source_root = db.file_source_root(original_file);
-        let path = db
-            .file_relative_path(original_file)
-            .parent()
-            .unwrap_or_else(|| RelativePath::new(""))
-            .join(&d.candidate);
-        let fix =
-            Fix::new("Create module", FileSystemEdit::CreateFile { source_root, path }.into());
+        let fix = Fix::new(
+            "Create module",
+            FileSystemEdit::CreateFile { anchor: original_file, dst: d.candidate.clone() }.into(),
+        );
         res.borrow_mut().push(Diagnostic {
             range: sema.diagnostics_range(d).range,
             message: d.message(),
@@ -612,10 +608,10 @@ mod tests {
                             source_file_edits: [],
                             file_system_edits: [
                                 CreateFile {
-                                    source_root: SourceRootId(
-                                        0,
+                                    anchor: FileId(
+                                        1,
                                     ),
-                                    path: "foo.rs",
+                                    dst: "foo.rs",
                                 },
                             ],
                             is_snippet: false,
diff --git a/crates/ra_ide/src/lib.rs b/crates/ra_ide/src/lib.rs
index 28f686767..51dc1f041 100644
--- a/crates/ra_ide/src/lib.rs
+++ b/crates/ra_ide/src/lib.rs
@@ -82,7 +82,7 @@ pub use ra_db::{
     Canceled, CrateGraph, CrateId, Edition, FileId, FilePosition, FileRange, SourceRootId,
 };
 pub use ra_ide_db::{
-    change::{AnalysisChange, LibraryData},
+    change::AnalysisChange,
     line_index::{LineCol, LineIndex},
     search::SearchScope,
     source_change::{FileSystemEdit, SourceChange, SourceFileEdit},
@@ -440,12 +440,14 @@ impl Analysis {
 
     /// Computes syntax highlighting for the given file
     pub fn highlight(&self, file_id: FileId) -> Cancelable<Vec<HighlightedRange>> {
-        self.with_db(|db| syntax_highlighting::highlight(db, file_id, None))
+        self.with_db(|db| syntax_highlighting::highlight(db, file_id, None, false))
     }
 
     /// Computes syntax highlighting for the given file range.
     pub fn highlight_range(&self, frange: FileRange) -> Cancelable<Vec<HighlightedRange>> {
-        self.with_db(|db| syntax_highlighting::highlight(db, frange.file_id, Some(frange.range)))
+        self.with_db(|db| {
+            syntax_highlighting::highlight(db, frange.file_id, Some(frange.range), false)
+        })
     }
 
     /// Computes syntax highlighting for the given file.
diff --git a/crates/ra_ide/src/prime_caches.rs b/crates/ra_ide/src/prime_caches.rs
index 90bf7d25f..c5ab5a1d8 100644
--- a/crates/ra_ide/src/prime_caches.rs
+++ b/crates/ra_ide/src/prime_caches.rs
@@ -7,6 +7,6 @@ use crate::{FileId, RootDatabase};
 
 pub(crate) fn prime_caches(db: &RootDatabase, files: Vec<FileId>) {
     for file in files {
-        let _ = crate::syntax_highlighting::highlight(db, file, None);
+        let _ = crate::syntax_highlighting::highlight(db, file, None, false);
     }
 }
diff --git a/crates/ra_ide/src/references/rename.rs b/crates/ra_ide/src/references/rename.rs
index 915d4f4d3..c4f07f905 100644
--- a/crates/ra_ide/src/references/rename.rs
+++ b/crates/ra_ide/src/references/rename.rs
@@ -1,7 +1,7 @@
 //! FIXME: write short doc here
 
 use hir::{ModuleSource, Semantics};
-use ra_db::{RelativePath, RelativePathBuf, SourceDatabaseExt};
+use ra_db::{RelativePathBuf, SourceDatabaseExt};
 use ra_ide_db::RootDatabase;
 use ra_syntax::{
     algo::find_node_at_offset, ast, ast::TypeAscriptionOwner, lex_single_valid_syntax_kind,
@@ -92,23 +92,14 @@ fn rename_mod(
             ModuleSource::SourceFile(..) => {
                 let mod_path: RelativePathBuf = sema.db.file_relative_path(file_id);
                 // mod is defined in path/to/dir/mod.rs
-                let dst_path = if mod_path.file_stem() == Some("mod") {
-                    mod_path
-                        .parent()
-                        .and_then(|p| p.parent())
-                        .or_else(|| Some(RelativePath::new("")))
-                        .map(|p| p.join(new_name).join("mod.rs"))
+                let dst = if mod_path.file_stem() == Some("mod") {
+                    format!("../{}/mod.rs", new_name)
                 } else {
-                    Some(mod_path.with_file_name(new_name).with_extension("rs"))
+                    format!("{}.rs", new_name)
                 };
-                if let Some(path) = dst_path {
-                    let move_file = FileSystemEdit::MoveFile {
-                        src: file_id,
-                        dst_source_root: sema.db.file_source_root(position.file_id),
-                        dst_path: path,
-                    };
-                    file_system_edits.push(move_file);
-                }
+                let move_file =
+                    FileSystemEdit::MoveFile { src: file_id, anchor: position.file_id, dst };
+                file_system_edits.push(move_file);
             }
             ModuleSource::Module(..) => {}
         }
@@ -623,16 +614,16 @@ mod tests {
     #[test]
     fn test_rename_mod() {
         let (analysis, position) = analysis_and_position(
-            "
-            //- /lib.rs
-            mod bar;
+            r#"
+//- /lib.rs
+mod bar;
 
-            //- /bar.rs
-            mod foo<|>;
+//- /bar.rs
+mod foo<|>;
 
-            //- /bar/foo.rs
-            // emtpy
-            ",
+//- /bar/foo.rs
+// emtpy
+            "#,
         );
         let new_name = "foo2";
         let source_change = analysis.rename(position, new_name).unwrap();
@@ -662,10 +653,10 @@ mod tests {
                             src: FileId(
                                 3,
                             ),
-                            dst_source_root: SourceRootId(
-                                0,
+                            anchor: FileId(
+                                2,
                             ),
-                            dst_path: "bar/foo2.rs",
+                            dst: "foo2.rs",
                         },
                     ],
                     is_snippet: false,
@@ -678,12 +669,12 @@ mod tests {
     #[test]
     fn test_rename_mod_in_dir() {
         let (analysis, position) = analysis_and_position(
-            "
-            //- /lib.rs
-            mod fo<|>o;
-            //- /foo/mod.rs
-            // emtpy
-            ",
+            r#"
+//- /lib.rs
+mod fo<|>o;
+//- /foo/mod.rs
+// emtpy
+            "#,
         );
         let new_name = "foo2";
         let source_change = analysis.rename(position, new_name).unwrap();
@@ -713,10 +704,10 @@ mod tests {
                             src: FileId(
                                 2,
                             ),
-                            dst_source_root: SourceRootId(
-                                0,
+                            anchor: FileId(
+                                1,
                             ),
-                            dst_path: "foo2/mod.rs",
+                            dst: "../foo2/mod.rs",
                         },
                     ],
                     is_snippet: false,
@@ -753,19 +744,19 @@ mod tests {
     #[test]
     fn test_rename_mod_filename_and_path() {
         let (analysis, position) = analysis_and_position(
-            "
-            //- /lib.rs
-            mod bar;
-            fn f() {
-                bar::foo::fun()
-            }
+            r#"
+//- /lib.rs
+mod bar;
+fn f() {
+    bar::foo::fun()
+}
 
-            //- /bar.rs
-            pub mod foo<|>;
+//- /bar.rs
+pub mod foo<|>;
 
-            //- /bar/foo.rs
-            // pub fn fun() {}
-            ",
+//- /bar/foo.rs
+// pub fn fun() {}
+            "#,
         );
         let new_name = "foo2";
         let source_change = analysis.rename(position, new_name).unwrap();
@@ -808,10 +799,10 @@ mod tests {
                             src: FileId(
                                 3,
                             ),
-                            dst_source_root: SourceRootId(
-                                0,
+                            anchor: FileId(
+                                2,
                             ),
-                            dst_path: "bar/foo2.rs",
+                            dst: "foo2.rs",
                         },
                     ],
                     is_snippet: false,
diff --git a/crates/ra_ide/src/snapshots/highlight_doctest.html b/crates/ra_ide/src/snapshots/highlight_doctest.html
index 0ae8c7efc..f92a0aba5 100644
--- a/crates/ra_ide/src/snapshots/highlight_doctest.html
+++ b/crates/ra_ide/src/snapshots/highlight_doctest.html
@@ -25,22 +25,30 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .variable           { color: #DCDCCC; }
 .format_specifier   { color: #CC696B; }
 .mutable            { text-decoration: underline; }
+.unresolved_reference { color: #FC5555; }
+.escape_sequence    { color: #94BFF3; }
 
 .keyword            { color: #F0DFAF; font-weight: bold; }
 .keyword.unsafe     { color: #BC8383; font-weight: bold; }
 .control            { font-style: italic; }
 </style>
-<pre><code><span class="keyword">impl</span> <span class="unresolved_reference">Foo</span> {
+<pre><code><span class="keyword">struct</span> <span class="struct declaration">Foo</span> {
+    <span class="field declaration">bar</span>: <span class="builtin_type">bool</span>,
+}
+
+<span class="keyword">impl</span> <span class="struct">Foo</span> {
+    <span class="keyword">pub</span> <span class="keyword">const</span> <span class="constant declaration">bar</span>: <span class="builtin_type">bool</span> = <span class="bool_literal">true</span>;
+
     <span class="comment">/// Constructs a new `Foo`.</span>
     <span class="comment">///</span>
     <span class="comment">/// # Examples</span>
     <span class="comment">///</span>
     <span class="comment">/// ```</span>
     <span class="comment">/// #</span> <span class="attribute">#![</span><span class="function attribute">allow</span><span class="attribute">(unused_mut)]</span>
-    <span class="comment">/// </span><span class="keyword">let</span> <span class="keyword">mut</span> <span class="variable declaration mutable">foo</span>: <span class="unresolved_reference">Foo</span> = <span class="unresolved_reference">Foo</span>::<span class="unresolved_reference">new</span>();
+    <span class="comment">/// </span><span class="keyword">let</span> <span class="keyword">mut</span> <span class="variable declaration mutable">foo</span>: <span class="struct">Foo</span> = <span class="struct">Foo</span>::<span class="function">new</span>();
     <span class="comment">/// ```</span>
-    <span class="keyword">pub</span> <span class="keyword">const</span> <span class="keyword">fn</span> <span class="function declaration">new</span>() -&gt; <span class="unresolved_reference">Foo</span> {
-        <span class="unresolved_reference">Foo</span> { }
+    <span class="keyword">pub</span> <span class="keyword">const</span> <span class="keyword">fn</span> <span class="function declaration">new</span>() -&gt; <span class="struct">Foo</span> {
+        <span class="struct">Foo</span> { <span class="field">bar</span>: <span class="bool_literal">true</span> }
     }
 
     <span class="comment">/// `bar` method on `Foo`.</span>
@@ -48,11 +56,15 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
     <span class="comment">/// # Examples</span>
     <span class="comment">///</span>
     <span class="comment">/// ```</span>
-    <span class="comment">/// </span><span class="keyword">let</span> <span class="variable declaration">foo</span> = <span class="unresolved_reference">Foo</span>::<span class="unresolved_reference">new</span>();
+    <span class="comment">/// </span><span class="keyword">use</span> <span class="module">x</span>::<span class="module">y</span>;
+    <span class="comment">///</span>
+    <span class="comment">/// </span><span class="keyword">let</span> <span class="variable declaration">foo</span> = <span class="struct">Foo</span>::<span class="function">new</span>();
     <span class="comment">///</span>
     <span class="comment">/// </span><span class="comment">// calls bar on foo</span>
     <span class="comment">/// </span><span class="macro">assert!</span>(foo.bar());
     <span class="comment">///</span>
+    <span class="comment">/// </span><span class="keyword">let</span> <span class="variable declaration">bar</span> = <span class="variable">foo</span>.<span class="field">bar</span> || <span class="struct">Foo</span>::<span class="constant">bar</span>;
+    <span class="comment">///</span>
     <span class="comment">/// </span><span class="comment">/* multi-line
     </span><span class="comment">/// </span><span class="comment">       comment */</span>
     <span class="comment">///</span>
@@ -62,8 +74,12 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
     <span class="comment">///</span>
     <span class="comment">/// ```</span>
     <span class="comment">///</span>
+    <span class="comment">/// ```rust,no_run</span>
+    <span class="comment">/// </span><span class="keyword">let</span> <span class="variable declaration">foobar</span> = <span class="struct">Foo</span>::<span class="function">new</span>().<span class="function">bar</span>();
     <span class="comment">/// ```</span>
-    <span class="comment">/// </span><span class="keyword">let</span> <span class="variable declaration">foobar</span> = <span class="unresolved_reference">Foo</span>::<span class="unresolved_reference">new</span>().<span class="unresolved_reference">bar</span>();
+    <span class="comment">///</span>
+    <span class="comment">/// ```sh</span>
+    <span class="comment">/// echo 1</span>
     <span class="comment">/// ```</span>
     <span class="keyword">pub</span> <span class="keyword">fn</span> <span class="function declaration">foo</span>(&<span class="self_keyword">self</span>) -&gt; <span class="builtin_type">bool</span> {
         <span class="bool_literal">true</span>
diff --git a/crates/ra_ide/src/snapshots/highlight_injection.html b/crates/ra_ide/src/snapshots/highlight_injection.html
index dec06eb51..47dbd7bc8 100644
--- a/crates/ra_ide/src/snapshots/highlight_injection.html
+++ b/crates/ra_ide/src/snapshots/highlight_injection.html
@@ -25,6 +25,8 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .variable           { color: #DCDCCC; }
 .format_specifier   { color: #CC696B; }
 .mutable            { text-decoration: underline; }
+.unresolved_reference { color: #FC5555; }
+.escape_sequence    { color: #94BFF3; }
 
 .keyword            { color: #F0DFAF; font-weight: bold; }
 .keyword.unsafe     { color: #BC8383; font-weight: bold; }
diff --git a/crates/ra_ide/src/snapshots/highlight_strings.html b/crates/ra_ide/src/snapshots/highlight_strings.html
index 849eb3b73..b46fa44c6 100644
--- a/crates/ra_ide/src/snapshots/highlight_strings.html
+++ b/crates/ra_ide/src/snapshots/highlight_strings.html
@@ -25,6 +25,8 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .variable           { color: #DCDCCC; }
 .format_specifier   { color: #CC696B; }
 .mutable            { text-decoration: underline; }
+.unresolved_reference { color: #FC5555; }
+.escape_sequence    { color: #94BFF3; }
 
 .keyword            { color: #F0DFAF; font-weight: bold; }
 .keyword.unsafe     { color: #BC8383; font-weight: bold; }
@@ -82,6 +84,10 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 
     <span class="macro">println!</span>(<span class="string_literal">r"Hello, </span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal">!"</span>, <span class="string_literal">"world"</span>);
 
-    <span class="macro">println!</span>(<span class="string_literal">"</span><span class="format_specifier">{</span><span class="variable">\x41</span><span class="format_specifier">}</span><span class="string_literal">"</span>, A = <span class="numeric_literal">92</span>);
+    <span class="comment">// escape sequences</span>
+    <span class="macro">println!</span>(<span class="string_literal">"Hello</span><span class="escape_sequence">\n</span><span class="string_literal">World"</span>);
+    <span class="macro">println!</span>(<span class="string_literal">"</span><span class="escape_sequence">\u{48}</span><span class="escape_sequence">\x65</span><span class="escape_sequence">\x6C</span><span class="escape_sequence">\x6C</span><span class="escape_sequence">\x6F</span><span class="string_literal"> World"</span>);
+
+    <span class="macro">println!</span>(<span class="string_literal">"</span><span class="format_specifier">{</span><span class="escape_sequence">\x41</span><span class="format_specifier">}</span><span class="string_literal">"</span>, A = <span class="numeric_literal">92</span>);
     <span class="macro">println!</span>(<span class="string_literal">"</span><span class="format_specifier">{</span><span class="variable">ничоси</span><span class="format_specifier">}</span><span class="string_literal">"</span>, ничоси = <span class="numeric_literal">92</span>);
 }</code></pre>
\ No newline at end of file
diff --git a/crates/ra_ide/src/snapshots/highlight_unsafe.html b/crates/ra_ide/src/snapshots/highlight_unsafe.html
index bd24e6e38..73438fbb4 100644
--- a/crates/ra_ide/src/snapshots/highlight_unsafe.html
+++ b/crates/ra_ide/src/snapshots/highlight_unsafe.html
@@ -25,6 +25,8 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .variable           { color: #DCDCCC; }
 .format_specifier   { color: #CC696B; }
 .mutable            { text-decoration: underline; }
+.unresolved_reference { color: #FC5555; }
+.escape_sequence    { color: #94BFF3; }
 
 .keyword            { color: #F0DFAF; font-weight: bold; }
 .keyword.unsafe     { color: #BC8383; font-weight: bold; }
diff --git a/crates/ra_ide/src/snapshots/highlighting.html b/crates/ra_ide/src/snapshots/highlighting.html
index 33548d43c..0c4f0a018 100644
--- a/crates/ra_ide/src/snapshots/highlighting.html
+++ b/crates/ra_ide/src/snapshots/highlighting.html
@@ -25,6 +25,8 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .variable           { color: #DCDCCC; }
 .format_specifier   { color: #CC696B; }
 .mutable            { text-decoration: underline; }
+.unresolved_reference { color: #FC5555; }
+.escape_sequence    { color: #94BFF3; }
 
 .keyword            { color: #F0DFAF; font-weight: bold; }
 .keyword.unsafe     { color: #BC8383; font-weight: bold; }
@@ -62,6 +64,12 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
     }
 }
 
+<span class="macro">macro_rules!</span> <span class="macro declaration">noop</span> {
+    ($expr:expr) =&gt; {
+        $expr
+    }
+}
+
 <span class="comment">// comment</span>
 <span class="keyword">fn</span> <span class="function declaration">main</span>() {
     <span class="macro">println!</span>(<span class="string_literal">"Hello, {}!"</span>, <span class="numeric_literal">92</span>);
@@ -80,6 +88,8 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
         <span class="comment">// Do nothing</span>
     }
 
+    <span class="macro">noop!</span>(<span class="macro">noop</span><span class="macro">!</span>(<span class="numeric_literal">1</span>));
+
     <span class="keyword">let</span> <span class="keyword">mut</span> <span class="variable declaration mutable">x</span> = <span class="numeric_literal">42</span>;
     <span class="keyword">let</span> <span class="variable declaration mutable">y</span> = &<span class="keyword">mut</span> <span class="variable mutable">x</span>;
     <span class="keyword">let</span> <span class="variable declaration">z</span> = &<span class="variable mutable">y</span>;
diff --git a/crates/ra_ide/src/snapshots/rainbow_highlighting.html b/crates/ra_ide/src/snapshots/rainbow_highlighting.html
index 1ab06182c..a74a70069 100644
--- a/crates/ra_ide/src/snapshots/rainbow_highlighting.html
+++ b/crates/ra_ide/src/snapshots/rainbow_highlighting.html
@@ -25,6 +25,8 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .variable           { color: #DCDCCC; }
 .format_specifier   { color: #CC696B; }
 .mutable            { text-decoration: underline; }
+.unresolved_reference { color: #FC5555; }
+.escape_sequence    { color: #94BFF3; }
 
 .keyword            { color: #F0DFAF; font-weight: bold; }
 .keyword.unsafe     { color: #BC8383; font-weight: bold; }
diff --git a/crates/ra_ide/src/ssr.rs b/crates/ra_ide/src/ssr.rs
index 93e9aee1d..762aab962 100644
--- a/crates/ra_ide/src/ssr.rs
+++ b/crates/ra_ide/src/ssr.rs
@@ -27,11 +27,11 @@ impl std::error::Error for SsrError {}
 //
 // Search and replace with named wildcards that will match any expression.
 // The syntax for a structural search replace command is `<search_pattern> ==>> <replace_pattern>`.
-// A `$<name>:expr` placeholder in the search pattern will match any expression and `$<name>` will reference it in the replacement.
+// A `$<name>` placeholder in the search pattern will match any AST node and `$<name>` will reference it in the replacement.
 // Available via the command `rust-analyzer.ssr`.
 //
 // ```rust
-// // Using structural search replace command [foo($a:expr, $b:expr) ==>> ($a).foo($b)]
+// // Using structural search replace command [foo($a, $b) ==>> ($a).foo($b)]
 //
 // // BEFORE
 // String::from(foo(y + 5, z))
@@ -79,7 +79,7 @@ struct SsrPattern {
     vars: Vec<Var>,
 }
 
-/// represents an `$var` in an SSR query
+/// Represents a `$var` in an SSR query.
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 struct Var(String);
 
@@ -122,8 +122,7 @@ impl FromStr for SsrQuery {
         let mut pattern = it.next().expect("something").to_string();
 
         for part in it.map(split_by_var) {
-            let (var, var_type, remainder) = part?;
-            is_expr(var_type)?;
+            let (var, remainder) = part?;
             let new_var = create_name(var, &mut vars)?;
             pattern.push_str(new_var);
             pattern.push_str(remainder);
@@ -166,15 +165,11 @@ fn traverse(node: &SyntaxNode, go: &mut impl FnMut(&SyntaxNode) -> bool) {
     }
 }
 
-fn split_by_var(s: &str) -> Result<(&str, &str, &str), SsrError> {
-    let end_of_name = s.find(':').ok_or_else(|| SsrError("Use $<name>:expr".into()))?;
-    let name = &s[0..end_of_name];
+fn split_by_var(s: &str) -> Result<(&str, &str), SsrError> {
+    let end_of_name = s.find(|c| !char::is_ascii_alphanumeric(&c)).unwrap_or_else(|| s.len());
+    let name = &s[..end_of_name];
     is_name(name)?;
-    let type_begin = end_of_name + 1;
-    let type_length =
-        s[type_begin..].find(|c| !char::is_ascii_alphanumeric(&c)).unwrap_or_else(|| s.len());
-    let type_name = &s[type_begin..type_begin + type_length];
-    Ok((name, type_name, &s[type_begin + type_length..]))
+    Ok((name, &s[end_of_name..]))
 }
 
 fn is_name(s: &str) -> Result<(), SsrError> {
@@ -185,14 +180,6 @@ fn is_name(s: &str) -> Result<(), SsrError> {
     }
 }
 
-fn is_expr(s: &str) -> Result<(), SsrError> {
-    if s == "expr" {
-        Ok(())
-    } else {
-        Err(SsrError("Only $<name>:expr is supported".into()))
-    }
-}
-
 fn replace_in_template(template: String, var: &str, new_var: &str) -> String {
     let name = format!("${}", var);
     template.replace(&name, new_var)
@@ -450,7 +437,7 @@ mod tests {
 
     #[test]
     fn parser_happy_case() {
-        let result: SsrQuery = "foo($a:expr, $b:expr) ==>> bar($b, $a)".parse().unwrap();
+        let result: SsrQuery = "foo($a, $b) ==>> bar($b, $a)".parse().unwrap();
         assert_eq!(&result.pattern.pattern.text(), "foo(__search_pattern_a, __search_pattern_b)");
         assert_eq!(result.pattern.vars.len(), 2);
         assert_eq!(result.pattern.vars[0].0, "__search_pattern_a");
@@ -477,30 +464,9 @@ mod tests {
     }
 
     #[test]
-    fn parser_no_pattern_type() {
-        assert_eq!(parse_error_text("foo($a) ==>>"), "Parse error: Use $<name>:expr");
-    }
-
-    #[test]
-    fn parser_invalid_name() {
-        assert_eq!(
-            parse_error_text("foo($a+:expr) ==>>"),
-            "Parse error: Name can contain only alphanumerics and _"
-        );
-    }
-
-    #[test]
-    fn parser_invalid_type() {
-        assert_eq!(
-            parse_error_text("foo($a:ident) ==>>"),
-            "Parse error: Only $<name>:expr is supported"
-        );
-    }
-
-    #[test]
     fn parser_repeated_name() {
         assert_eq!(
-            parse_error_text("foo($a:expr, $a:expr) ==>>"),
+            parse_error_text("foo($a, $a) ==>>"),
             "Parse error: Name `a` repeats more than once"
         );
     }
@@ -517,7 +483,7 @@ mod tests {
 
     #[test]
     fn parse_match_replace() {
-        let query: SsrQuery = "foo($x:expr) ==>> bar($x)".parse().unwrap();
+        let query: SsrQuery = "foo($x) ==>> bar($x)".parse().unwrap();
         let input = "fn main() { foo(1+2); }";
 
         let code = SourceFile::parse(input).tree();
@@ -549,7 +515,7 @@ mod tests {
     #[test]
     fn ssr_function_to_method() {
         assert_ssr_transform(
-            "my_function($a:expr, $b:expr) ==>> ($a).my_method($b)",
+            "my_function($a, $b) ==>> ($a).my_method($b)",
             "loop { my_function( other_func(x, y), z + w) }",
             "loop { (other_func(x, y)).my_method(z + w) }",
         )
@@ -558,7 +524,7 @@ mod tests {
     #[test]
     fn ssr_nested_function() {
         assert_ssr_transform(
-            "foo($a:expr, $b:expr, $c:expr) ==>> bar($c, baz($a, $b))",
+            "foo($a, $b, $c) ==>> bar($c, baz($a, $b))",
             "fn main { foo  (x + value.method(b), x+y-z, true && false) }",
             "fn main { bar(true && false, baz(x + value.method(b), x+y-z)) }",
         )
@@ -567,7 +533,7 @@ mod tests {
     #[test]
     fn ssr_expected_spacing() {
         assert_ssr_transform(
-            "foo($x:expr) + bar() ==>> bar($x)",
+            "foo($x) + bar() ==>> bar($x)",
             "fn main() { foo(5) + bar() }",
             "fn main() { bar(5) }",
         );
@@ -576,7 +542,7 @@ mod tests {
     #[test]
     fn ssr_with_extra_space() {
         assert_ssr_transform(
-            "foo($x:expr  ) +    bar() ==>> bar($x)",
+            "foo($x  ) +    bar() ==>> bar($x)",
             "fn main() { foo(  5 )  +bar(   ) }",
             "fn main() { bar(5) }",
         );
@@ -585,7 +551,7 @@ mod tests {
     #[test]
     fn ssr_keeps_nested_comment() {
         assert_ssr_transform(
-            "foo($x:expr) ==>> bar($x)",
+            "foo($x) ==>> bar($x)",
             "fn main() { foo(other(5 /* using 5 */)) }",
             "fn main() { bar(other(5 /* using 5 */)) }",
         )
@@ -594,7 +560,7 @@ mod tests {
     #[test]
     fn ssr_keeps_comment() {
         assert_ssr_transform(
-            "foo($x:expr) ==>> bar($x)",
+            "foo($x) ==>> bar($x)",
             "fn main() { foo(5 /* using 5 */) }",
             "fn main() { bar(5)/* using 5 */ }",
         )
@@ -603,7 +569,7 @@ mod tests {
     #[test]
     fn ssr_struct_lit() {
         assert_ssr_transform(
-            "foo{a: $a:expr, b: $b:expr} ==>> foo::new($a, $b)",
+            "foo{a: $a, b: $b} ==>> foo::new($a, $b)",
             "fn main() { foo{b:2, a:1} }",
             "fn main() { foo::new(1, 2) }",
         )
@@ -612,7 +578,7 @@ mod tests {
     #[test]
     fn ssr_call_and_method_call() {
         assert_ssr_transform(
-            "foo::<'a>($a:expr, $b:expr)) ==>> foo2($a, $b)",
+            "foo::<'a>($a, $b)) ==>> foo2($a, $b)",
             "fn main() { get().bar.foo::<'a>(1); }",
             "fn main() { foo2(get().bar, 1); }",
         )
@@ -621,7 +587,7 @@ mod tests {
     #[test]
     fn ssr_method_call_and_call() {
         assert_ssr_transform(
-            "$o:expr.foo::<i32>($a:expr)) ==>> $o.foo2($a)",
+            "$o.foo::<i32>($a)) ==>> $o.foo2($a)",
             "fn main() { X::foo::<i32>(x, 1); }",
             "fn main() { x.foo2(1); }",
         )
diff --git a/crates/ra_ide/src/status.rs b/crates/ra_ide/src/status.rs
index 5b7992920..45411b357 100644
--- a/crates/ra_ide/src/status.rs
+++ b/crates/ra_ide/src/status.rs
@@ -16,6 +16,7 @@ use ra_prof::{memory_usage, Bytes};
 use ra_syntax::{ast, Parse, SyntaxNode};
 
 use crate::FileId;
+use rustc_hash::FxHashMap;
 
 fn syntax_tree_stats(db: &RootDatabase) -> SyntaxTreeStats {
     db.query(ra_db::ParseQuery).entries::<SyntaxTreeStats>()
@@ -123,20 +124,24 @@ struct LibrarySymbolsStats {
 
 impl fmt::Display for LibrarySymbolsStats {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        write!(fmt, "{} ({}) symbols", self.total, self.size,)
+        write!(fmt, "{} ({}) symbols", self.total, self.size)
     }
 }
 
-impl FromIterator<TableEntry<SourceRootId, Arc<SymbolIndex>>> for LibrarySymbolsStats {
+impl FromIterator<TableEntry<(), Arc<FxHashMap<SourceRootId, SymbolIndex>>>>
+    for LibrarySymbolsStats
+{
     fn from_iter<T>(iter: T) -> LibrarySymbolsStats
     where
-        T: IntoIterator<Item = TableEntry<SourceRootId, Arc<SymbolIndex>>>,
+        T: IntoIterator<Item = TableEntry<(), Arc<FxHashMap<SourceRootId, SymbolIndex>>>>,
     {
         let mut res = LibrarySymbolsStats::default();
         for entry in iter {
             let value = entry.value.unwrap();
-            res.total += value.len();
-            res.size += value.memory_size();
+            for symbols in value.values() {
+                res.total += symbols.len();
+                res.size += symbols.memory_size();
+            }
         }
         res
     }
diff --git a/crates/ra_ide/src/syntax_highlighting.rs b/crates/ra_ide/src/syntax_highlighting.rs
index ab45c364a..854b6cc6d 100644
--- a/crates/ra_ide/src/syntax_highlighting.rs
+++ b/crates/ra_ide/src/syntax_highlighting.rs
@@ -44,6 +44,7 @@ pub(crate) fn highlight(
     db: &RootDatabase,
     file_id: FileId,
     range_to_highlight: Option<TextRange>,
+    syntactic_name_ref_highlighting: bool,
 ) -> Vec<HighlightedRange> {
     let _p = profile("highlight");
     let sema = Semantics::new(db);
@@ -104,6 +105,7 @@ pub(crate) fn highlight(
                     if let Some((highlight, binding_hash)) = highlight_element(
                         &sema,
                         &mut bindings_shadow_count,
+                        syntactic_name_ref_highlighting,
                         name.syntax().clone().into(),
                     ) {
                         stack.add(HighlightedRange {
@@ -160,23 +162,25 @@ pub(crate) fn highlight(
             // Check if macro takes a format string and remember it for highlighting later.
             // The macros that accept a format string expand to a compiler builtin macros
             // `format_args` and `format_args_nl`.
-            if let Some(fmt_macro_call) = parent.parent().and_then(ast::MacroCall::cast) {
-                if let Some(name) =
-                    fmt_macro_call.path().and_then(|p| p.segment()).and_then(|s| s.name_ref())
-                {
-                    match name.text().as_str() {
-                        "format_args" | "format_args_nl" => {
-                            format_string = parent
-                                .children_with_tokens()
-                                .filter(|t| t.kind() != WHITESPACE)
-                                .nth(1)
-                                .filter(|e| {
-                                    ast::String::can_cast(e.kind())
-                                        || ast::RawString::can_cast(e.kind())
-                                })
-                        }
-                        _ => {}
+            if let Some(name) = parent
+                .parent()
+                .and_then(ast::MacroCall::cast)
+                .and_then(|mc| mc.path())
+                .and_then(|p| p.segment())
+                .and_then(|s| s.name_ref())
+            {
+                match name.text().as_str() {
+                    "format_args" | "format_args_nl" => {
+                        format_string = parent
+                            .children_with_tokens()
+                            .filter(|t| t.kind() != WHITESPACE)
+                            .nth(1)
+                            .filter(|e| {
+                                ast::String::can_cast(e.kind())
+                                    || ast::RawString::can_cast(e.kind())
+                            })
                     }
+                    _ => {}
                 }
             }
 
@@ -198,15 +202,18 @@ pub(crate) fn highlight(
 
         let is_format_string = format_string.as_ref() == Some(&element_to_highlight);
 
-        if let Some((highlight, binding_hash)) =
-            highlight_element(&sema, &mut bindings_shadow_count, element_to_highlight.clone())
-        {
+        if let Some((highlight, binding_hash)) = highlight_element(
+            &sema,
+            &mut bindings_shadow_count,
+            syntactic_name_ref_highlighting,
+            element_to_highlight.clone(),
+        ) {
             stack.add(HighlightedRange { range, highlight, binding_hash });
             if let Some(string) =
                 element_to_highlight.as_token().cloned().and_then(ast::String::cast)
             {
-                stack.push();
                 if is_format_string {
+                    stack.push();
                     string.lex_format_specifier(|piece_range, kind| {
                         if let Some(highlight) = highlight_format_specifier(kind) {
                             stack.add(HighlightedRange {
@@ -216,13 +223,27 @@ pub(crate) fn highlight(
                             });
                         }
                     });
+                    stack.pop();
+                }
+                // Highlight escape sequences
+                if let Some(char_ranges) = string.char_ranges() {
+                    stack.push();
+                    for (piece_range, _) in char_ranges.iter().filter(|(_, char)| char.is_ok()) {
+                        if string.text()[piece_range.start().into()..].starts_with('\\') {
+                            stack.add(HighlightedRange {
+                                range: piece_range + range.start(),
+                                highlight: HighlightTag::EscapeSequence.into(),
+                                binding_hash: None,
+                            });
+                        }
+                    }
+                    stack.pop_and_inject(false);
                 }
-                stack.pop();
             } else if let Some(string) =
                 element_to_highlight.as_token().cloned().and_then(ast::RawString::cast)
             {
-                stack.push();
                 if is_format_string {
+                    stack.push();
                     string.lex_format_specifier(|piece_range, kind| {
                         if let Some(highlight) = highlight_format_specifier(kind) {
                             stack.add(HighlightedRange {
@@ -232,8 +253,8 @@ pub(crate) fn highlight(
                             });
                         }
                     });
+                    stack.pop();
                 }
-                stack.pop();
             }
         }
     }
@@ -408,6 +429,7 @@ fn macro_call_range(macro_call: &ast::MacroCall) -> Option<TextRange> {
 fn highlight_element(
     sema: &Semantics<RootDatabase>,
     bindings_shadow_count: &mut FxHashMap<Name, u32>,
+    syntactic_name_ref_highlighting: bool,
     element: SyntaxElement,
 ) -> Option<(Highlight, Option<u64>)> {
     let db = sema.db;
@@ -461,6 +483,7 @@ fn highlight_element(
                     }
                     NameRefClass::FieldShorthand { .. } => HighlightTag::Field.into(),
                 },
+                None if syntactic_name_ref_highlighting => highlight_name_ref_by_syntax(name_ref),
                 None => HighlightTag::UnresolvedReference.into(),
             }
         }
@@ -493,6 +516,9 @@ fn highlight_element(
             h |= HighlightModifier::Unsafe;
             h
         }
+        T![!] if element.parent().and_then(ast::MacroCall::cast).is_some() => {
+            Highlight::new(HighlightTag::Macro)
+        }
 
         k if k.is_keyword() => {
             let h = Highlight::new(HighlightTag::Keyword);
@@ -609,3 +635,53 @@ fn highlight_name_by_syntax(name: ast::Name) -> Highlight {
 
     tag.into()
 }
+
+fn highlight_name_ref_by_syntax(name: ast::NameRef) -> Highlight {
+    let default = HighlightTag::UnresolvedReference;
+
+    let parent = match name.syntax().parent() {
+        Some(it) => it,
+        _ => return default.into(),
+    };
+
+    let tag = match parent.kind() {
+        METHOD_CALL_EXPR => HighlightTag::Function,
+        FIELD_EXPR => HighlightTag::Field,
+        PATH_SEGMENT => {
+            let path = match parent.parent().and_then(ast::Path::cast) {
+                Some(it) => it,
+                _ => return default.into(),
+            };
+            let expr = match path.syntax().parent().and_then(ast::PathExpr::cast) {
+                Some(it) => it,
+                _ => {
+                    // within path, decide whether it is module or adt by checking for uppercase name
+                    return if name.text().chars().next().unwrap_or_default().is_uppercase() {
+                        HighlightTag::Struct
+                    } else {
+                        HighlightTag::Module
+                    }
+                    .into();
+                }
+            };
+            let parent = match expr.syntax().parent() {
+                Some(it) => it,
+                None => return default.into(),
+            };
+
+            match parent.kind() {
+                CALL_EXPR => HighlightTag::Function,
+                _ => {
+                    if name.text().chars().next().unwrap_or_default().is_uppercase() {
+                        HighlightTag::Struct
+                    } else {
+                        HighlightTag::Constant
+                    }
+                }
+            }
+        }
+        _ => default,
+    };
+
+    tag.into()
+}
diff --git a/crates/ra_ide/src/syntax_highlighting/html.rs b/crates/ra_ide/src/syntax_highlighting/html.rs
index 5bada6252..99b6b25ab 100644
--- a/crates/ra_ide/src/syntax_highlighting/html.rs
+++ b/crates/ra_ide/src/syntax_highlighting/html.rs
@@ -19,7 +19,7 @@ pub(crate) fn highlight_as_html(db: &RootDatabase, file_id: FileId, rainbow: boo
         )
     }
 
-    let ranges = highlight(db, file_id, None);
+    let ranges = highlight(db, file_id, None, false);
     let text = parse.tree().syntax().to_string();
     let mut prev_pos = TextSize::from(0);
     let mut buf = String::new();
@@ -84,6 +84,8 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .variable           { color: #DCDCCC; }
 .format_specifier   { color: #CC696B; }
 .mutable            { text-decoration: underline; }
+.unresolved_reference { color: #FC5555; }
+.escape_sequence    { color: #94BFF3; }
 
 .keyword            { color: #F0DFAF; font-weight: bold; }
 .keyword.unsafe     { color: #BC8383; font-weight: bold; }
diff --git a/crates/ra_ide/src/syntax_highlighting/injection.rs b/crates/ra_ide/src/syntax_highlighting/injection.rs
index 3575a0fc6..929a5cc5c 100644
--- a/crates/ra_ide/src/syntax_highlighting/injection.rs
+++ b/crates/ra_ide/src/syntax_highlighting/injection.rs
@@ -53,6 +53,10 @@ pub(super) fn highlight_injection(
 /// Mapping from extracted documentation code to original code
 type RangesMap = BTreeMap<TextSize, TextSize>;
 
+const RUSTDOC_FENCE: &'static str = "```";
+const RUSTDOC_FENCE_TOKENS: &[&'static str] =
+    &["", "rust", "should_panic", "ignore", "no_run", "compile_fail", "edition2015", "edition2018"];
+
 /// Extracts Rust code from documentation comments as well as a mapping from
 /// the extracted source code back to the original source ranges.
 /// Lastly, a vector of new comment highlight ranges (spanning only the
@@ -67,6 +71,7 @@ pub(super) fn extract_doc_comments(
     // Mapping from extracted documentation code to original code
     let mut range_mapping: RangesMap = BTreeMap::new();
     let mut line_start = TextSize::try_from(prefix.len()).unwrap();
+    let mut is_codeblock = false;
     let mut is_doctest = false;
     // Replace the original, line-spanning comment ranges by new, only comment-prefix
     // spanning comment ranges.
@@ -76,8 +81,13 @@ pub(super) fn extract_doc_comments(
         .filter_map(|el| el.into_token().and_then(ast::Comment::cast))
         .filter(|comment| comment.kind().doc.is_some())
         .filter(|comment| {
-            if comment.text().contains("```") {
-                is_doctest = !is_doctest;
+            if let Some(idx) = comment.text().find(RUSTDOC_FENCE) {
+                is_codeblock = !is_codeblock;
+                // Check whether code is rust by inspecting fence guards
+                let guards = &comment.text()[idx + RUSTDOC_FENCE.len()..];
+                let is_rust =
+                    guards.split(',').all(|sub| RUSTDOC_FENCE_TOKENS.contains(&sub.trim()));
+                is_doctest = is_codeblock && is_rust;
                 false
             } else {
                 is_doctest
@@ -137,7 +147,7 @@ pub(super) fn highlight_doc_comment(
     let (analysis, tmp_file_id) = Analysis::from_single_file(text);
 
     stack.push();
-    for mut h in analysis.highlight(tmp_file_id).unwrap() {
+    for mut h in analysis.with_db(|db| super::highlight(db, tmp_file_id, None, true)).unwrap() {
         // Determine start offset and end offset in case of multi-line ranges
         let mut start_offset = None;
         let mut end_offset = None;
diff --git a/crates/ra_ide/src/syntax_highlighting/tags.rs b/crates/ra_ide/src/syntax_highlighting/tags.rs
index 94f466966..400d22fb6 100644
--- a/crates/ra_ide/src/syntax_highlighting/tags.rs
+++ b/crates/ra_ide/src/syntax_highlighting/tags.rs
@@ -23,6 +23,7 @@ pub enum HighlightTag {
     Constant,
     Enum,
     EnumVariant,
+    EscapeSequence,
     Field,
     FormatSpecifier,
     Function,
@@ -71,6 +72,7 @@ impl HighlightTag {
             HighlightTag::Constant => "constant",
             HighlightTag::Enum => "enum",
             HighlightTag::EnumVariant => "enum_variant",
+            HighlightTag::EscapeSequence => "escape_sequence",
             HighlightTag::Field => "field",
             HighlightTag::FormatSpecifier => "format_specifier",
             HighlightTag::Function => "function",
diff --git a/crates/ra_ide/src/syntax_highlighting/tests.rs b/crates/ra_ide/src/syntax_highlighting/tests.rs
index 949bf59a0..b4d56a7a0 100644
--- a/crates/ra_ide/src/syntax_highlighting/tests.rs
+++ b/crates/ra_ide/src/syntax_highlighting/tests.rs
@@ -43,6 +43,12 @@ def_fn! {
     }
 }
 
+macro_rules! noop {
+    ($expr:expr) => {
+        $expr
+    }
+}
+
 // comment
 fn main() {
     println!("Hello, {}!", 92);
@@ -61,6 +67,8 @@ fn main() {
         // Do nothing
     }
 
+    noop!(noop!(1));
+
     let mut x = 42;
     let y = &mut x;
     let z = &y;
@@ -238,6 +246,10 @@ fn main() {
 
     println!(r"Hello, {}!", "world");
 
+    // escape sequences
+    println!("Hello\nWorld");
+    println!("\u{48}\x65\x6C\x6C\x6F World");
+
     println!("{\x41}", A = 92);
     println!("{ничоси}", ничоси = 92);
 }"#
@@ -279,7 +291,13 @@ fn main() {
 fn test_highlight_doctest() {
     check_highlighting(
         r#"
+struct Foo {
+    bar: bool,
+}
+
 impl Foo {
+    pub const bar: bool = true;
+
     /// Constructs a new `Foo`.
     ///
     /// # Examples
@@ -289,7 +307,7 @@ impl Foo {
     /// let mut foo: Foo = Foo::new();
     /// ```
     pub const fn new() -> Foo {
-        Foo { }
+        Foo { bar: true }
     }
 
     /// `bar` method on `Foo`.
@@ -297,11 +315,15 @@ impl Foo {
     /// # Examples
     ///
     /// ```
+    /// use x::y;
+    ///
     /// let foo = Foo::new();
     ///
     /// // calls bar on foo
     /// assert!(foo.bar());
     ///
+    /// let bar = foo.bar || Foo::bar;
+    ///
     /// /* multi-line
     ///        comment */
     ///
@@ -311,9 +333,13 @@ impl Foo {
     ///
     /// ```
     ///
-    /// ```
+    /// ```rust,no_run
     /// let foobar = Foo::new().bar();
     /// ```
+    ///
+    /// ```sh
+    /// echo 1
+    /// ```
     pub fn foo(&self) -> bool {
         true
     }
@@ -322,7 +348,7 @@ impl Foo {
         .trim(),
         "crates/ra_ide/src/snapshots/highlight_doctest.html",
         false,
-    )
+    );
 }
 
 /// Highlights the code given by the `ra_fixture` argument, renders the
diff --git a/crates/ra_ide_db/src/change.rs b/crates/ra_ide_db/src/change.rs
index 2fc796a85..78ee6a515 100644
--- a/crates/ra_ide_db/src/change.rs
+++ b/crates/ra_ide_db/src/change.rs
@@ -9,22 +9,15 @@ use ra_db::{
     SourceRootId,
 };
 use ra_prof::{memory_usage, profile, Bytes};
-use ra_syntax::SourceFile;
-#[cfg(not(feature = "wasm"))]
-use rayon::prelude::*;
 use rustc_hash::FxHashMap;
 
-use crate::{
-    symbol_index::{SymbolIndex, SymbolsDatabase},
-    RootDatabase,
-};
+use crate::{symbol_index::SymbolsDatabase, RootDatabase};
 
 #[derive(Default)]
 pub struct AnalysisChange {
     new_roots: Vec<(SourceRootId, bool)>,
     roots_changed: FxHashMap<SourceRootId, RootChange>,
     files_changed: Vec<(FileId, Arc<String>)>,
-    libraries_added: Vec<LibraryData>,
     crate_graph: Option<CrateGraph>,
 }
 
@@ -40,9 +33,6 @@ impl fmt::Debug for AnalysisChange {
         if !self.files_changed.is_empty() {
             d.field("files_changed", &self.files_changed.len());
         }
-        if !self.libraries_added.is_empty() {
-            d.field("libraries_added", &self.libraries_added.len());
-        }
         if self.crate_graph.is_some() {
             d.field("crate_graph", &self.crate_graph);
         }
@@ -79,10 +69,6 @@ impl AnalysisChange {
         self.roots_changed.entry(root_id).or_default().removed.push(file);
     }
 
-    pub fn add_library(&mut self, data: LibraryData) {
-        self.libraries_added.push(data)
-    }
-
     pub fn set_crate_graph(&mut self, graph: CrateGraph) {
         self.crate_graph = Some(graph);
     }
@@ -116,47 +102,6 @@ impl fmt::Debug for RootChange {
     }
 }
 
-pub struct LibraryData {
-    root_id: SourceRootId,
-    root_change: RootChange,
-    symbol_index: SymbolIndex,
-}
-
-impl fmt::Debug for LibraryData {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_struct("LibraryData")
-            .field("root_id", &self.root_id)
-            .field("root_change", &self.root_change)
-            .field("n_symbols", &self.symbol_index.len())
-            .finish()
-    }
-}
-
-impl LibraryData {
-    pub fn prepare(
-        root_id: SourceRootId,
-        files: Vec<(FileId, RelativePathBuf, Arc<String>)>,
-    ) -> LibraryData {
-        let _p = profile("LibraryData::prepare");
-
-        #[cfg(not(feature = "wasm"))]
-        let iter = files.par_iter();
-        #[cfg(feature = "wasm")]
-        let iter = files.iter();
-
-        let symbol_index = SymbolIndex::for_files(iter.map(|(file_id, _, text)| {
-            let parse = SourceFile::parse(text);
-            (*file_id, parse)
-        }));
-        let mut root_change = RootChange::default();
-        root_change.added = files
-            .into_iter()
-            .map(|(file_id, path, text)| AddFile { file_id, path, text })
-            .collect();
-        LibraryData { root_id, root_change, symbol_index }
-    }
-}
-
 const GC_COOLDOWN: time::Duration = time::Duration::from_millis(100);
 
 impl RootDatabase {
@@ -171,6 +116,7 @@ impl RootDatabase {
         log::info!("apply_change {:?}", change);
         if !change.new_roots.is_empty() {
             let mut local_roots = Vec::clone(&self.local_roots());
+            let mut libraries = Vec::clone(&self.library_roots());
             for (root_id, is_local) in change.new_roots {
                 let root =
                     if is_local { SourceRoot::new_local() } else { SourceRoot::new_library() };
@@ -178,9 +124,12 @@ impl RootDatabase {
                 self.set_source_root_with_durability(root_id, Arc::new(root), durability);
                 if is_local {
                     local_roots.push(root_id);
+                } else {
+                    libraries.push(root_id)
                 }
             }
             self.set_local_roots_with_durability(Arc::new(local_roots), Durability::HIGH);
+            self.set_library_roots_with_durability(Arc::new(libraries), Durability::HIGH);
         }
 
         for (root_id, root_change) in change.roots_changed {
@@ -192,24 +141,6 @@ impl RootDatabase {
             let durability = durability(&source_root);
             self.set_file_text_with_durability(file_id, text, durability)
         }
-        if !change.libraries_added.is_empty() {
-            let mut libraries = Vec::clone(&self.library_roots());
-            for library in change.libraries_added {
-                libraries.push(library.root_id);
-                self.set_source_root_with_durability(
-                    library.root_id,
-                    Arc::new(SourceRoot::new_library()),
-                    Durability::HIGH,
-                );
-                self.set_library_symbols_with_durability(
-                    library.root_id,
-                    Arc::new(library.symbol_index),
-                    Durability::HIGH,
-                );
-                self.apply_root_change(library.root_id, library.root_change);
-            }
-            self.set_library_roots_with_durability(Arc::new(libraries), Durability::HIGH);
-        }
         if let Some(crate_graph) = change.crate_graph {
             self.set_crate_graph_with_durability(Arc::new(crate_graph), Durability::HIGH)
         }
diff --git a/crates/ra_ide_db/src/source_change.rs b/crates/ra_ide_db/src/source_change.rs
index f40ae8304..0bbd3c3e5 100644
--- a/crates/ra_ide_db/src/source_change.rs
+++ b/crates/ra_ide_db/src/source_change.rs
@@ -3,7 +3,7 @@
 //!
 //! It can be viewed as a dual for `AnalysisChange`.
 
-use ra_db::{FileId, RelativePathBuf, SourceRootId};
+use ra_db::FileId;
 use ra_text_edit::TextEdit;
 
 #[derive(Debug, Clone)]
@@ -44,8 +44,8 @@ impl From<Vec<SourceFileEdit>> for SourceChange {
 
 #[derive(Debug, Clone)]
 pub enum FileSystemEdit {
-    CreateFile { source_root: SourceRootId, path: RelativePathBuf },
-    MoveFile { src: FileId, dst_source_root: SourceRootId, dst_path: RelativePathBuf },
+    CreateFile { anchor: FileId, dst: String },
+    MoveFile { src: FileId, anchor: FileId, dst: String },
 }
 
 impl From<FileSystemEdit> for SourceChange {
diff --git a/crates/ra_ide_db/src/symbol_index.rs b/crates/ra_ide_db/src/symbol_index.rs
index aab918973..25c99813f 100644
--- a/crates/ra_ide_db/src/symbol_index.rs
+++ b/crates/ra_ide_db/src/symbol_index.rs
@@ -34,14 +34,15 @@ use ra_db::{
     salsa::{self, ParallelDatabase},
     CrateId, FileId, SourceDatabaseExt, SourceRootId,
 };
+use ra_prof::profile;
 use ra_syntax::{
     ast::{self, NameOwner},
     match_ast, AstNode, Parse, SmolStr, SourceFile,
     SyntaxKind::{self, *},
     SyntaxNode, SyntaxNodePtr, TextRange, WalkEvent,
 };
-#[cfg(not(feature = "wasm"))]
 use rayon::prelude::*;
+use rustc_hash::FxHashMap;
 
 use crate::RootDatabase;
 
@@ -86,10 +87,9 @@ impl Query {
 }
 
 #[salsa::query_group(SymbolsDatabaseStorage)]
-pub trait SymbolsDatabase: hir::db::HirDatabase {
+pub trait SymbolsDatabase: hir::db::HirDatabase + SourceDatabaseExt + ParallelDatabase {
     fn file_symbols(&self, file_id: FileId) -> Arc<SymbolIndex>;
-    #[salsa::input]
-    fn library_symbols(&self, id: SourceRootId) -> Arc<SymbolIndex>;
+    fn library_symbols(&self) -> Arc<FxHashMap<SourceRootId, SymbolIndex>>;
     /// The set of "local" (that is, from the current workspace) roots.
     /// Files in local roots are assumed to change frequently.
     #[salsa::input]
@@ -100,6 +100,29 @@ pub trait SymbolsDatabase: hir::db::HirDatabase {
     fn library_roots(&self) -> Arc<Vec<SourceRootId>>;
 }
 
+fn library_symbols(
+    db: &(impl SymbolsDatabase + ParallelDatabase),
+) -> Arc<FxHashMap<SourceRootId, SymbolIndex>> {
+    let _p = profile("library_symbols");
+
+    let roots = db.library_roots();
+    let res = roots
+        .iter()
+        .map(|&root_id| {
+            let root = db.source_root(root_id);
+            let files = root
+                .walk()
+                .map(|it| (it, SourceDatabaseExt::file_text(db, it)))
+                .collect::<Vec<_>>();
+            let symbol_index = SymbolIndex::for_files(
+                files.into_par_iter().map(|(file, text)| (file, SourceFile::parse(&text))),
+            );
+            (root_id, symbol_index)
+        })
+        .collect();
+    Arc::new(res)
+}
+
 fn file_symbols(db: &impl SymbolsDatabase, file_id: FileId) -> Arc<SymbolIndex> {
     db.check_canceled();
     let parse = db.parse(file_id);
@@ -112,9 +135,9 @@ fn file_symbols(db: &impl SymbolsDatabase, file_id: FileId) -> Arc<SymbolIndex>
 }
 
 /// Need to wrap Snapshot to provide `Clone` impl for `map_with`
-struct Snap(salsa::Snapshot<RootDatabase>);
-impl Clone for Snap {
-    fn clone(&self) -> Snap {
+struct Snap<DB>(DB);
+impl<DB: ParallelDatabase> Clone for Snap<salsa::Snapshot<DB>> {
+    fn clone(&self) -> Snap<salsa::Snapshot<DB>> {
         Snap(self.0.snapshot())
     }
 }
@@ -143,19 +166,11 @@ impl Clone for Snap {
 pub fn world_symbols(db: &RootDatabase, query: Query) -> Vec<FileSymbol> {
     let _p = ra_prof::profile("world_symbols").detail(|| query.query.clone());
 
-    let buf: Vec<Arc<SymbolIndex>> = if query.libs {
-        let snap = Snap(db.snapshot());
-        #[cfg(not(feature = "wasm"))]
-        let buf = db
-            .library_roots()
-            .par_iter()
-            .map_with(snap, |db, &lib_id| db.0.library_symbols(lib_id))
-            .collect();
-
-        #[cfg(feature = "wasm")]
-        let buf = db.library_roots().iter().map(|&lib_id| snap.0.library_symbols(lib_id)).collect();
-
-        buf
+    let tmp1;
+    let tmp2;
+    let buf: Vec<&SymbolIndex> = if query.libs {
+        tmp1 = db.library_symbols();
+        tmp1.values().collect()
     } else {
         let mut files = Vec::new();
         for &root in db.local_roots().iter() {
@@ -164,14 +179,11 @@ pub fn world_symbols(db: &RootDatabase, query: Query) -> Vec<FileSymbol> {
         }
 
         let snap = Snap(db.snapshot());
-        #[cfg(not(feature = "wasm"))]
-        let buf =
-            files.par_iter().map_with(snap, |db, &file_id| db.0.file_symbols(file_id)).collect();
-
-        #[cfg(feature = "wasm")]
-        let buf = files.iter().map(|&file_id| snap.0.file_symbols(file_id)).collect();
-
-        buf
+        tmp2 = files
+            .par_iter()
+            .map_with(snap, |db, &file_id| db.0.file_symbols(file_id))
+            .collect::<Vec<_>>();
+        tmp2.iter().map(|it| &**it).collect()
     };
     query.search(&buf)
 }
@@ -191,14 +203,11 @@ pub fn crate_symbols(db: &RootDatabase, krate: CrateId, query: Query) -> Vec<Fil
 
     let snap = Snap(db.snapshot());
 
-    #[cfg(not(feature = "wasm"))]
     let buf = files
         .par_iter()
         .map_with(snap, |db, &file_id| db.0.file_symbols(file_id))
         .collect::<Vec<_>>();
-
-    #[cfg(feature = "wasm")]
-    let buf = files.iter().map(|&file_id| snap.0.file_symbols(file_id)).collect::<Vec<_>>();
+    let buf = buf.iter().map(|it| &**it).collect::<Vec<_>>();
 
     query.search(&buf)
 }
@@ -245,12 +254,8 @@ impl SymbolIndex {
             lhs_chars.cmp(rhs_chars)
         }
 
-        #[cfg(not(feature = "wasm"))]
         symbols.par_sort_by(cmp);
 
-        #[cfg(feature = "wasm")]
-        symbols.sort_by(cmp);
-
         let mut builder = fst::MapBuilder::memory();
 
         let mut last_batch_start = 0;
@@ -284,7 +289,6 @@ impl SymbolIndex {
         self.map.as_fst().size() + self.symbols.len() * mem::size_of::<FileSymbol>()
     }
 
-    #[cfg(not(feature = "wasm"))]
     pub(crate) fn for_files(
         files: impl ParallelIterator<Item = (FileId, Parse<ast::SourceFile>)>,
     ) -> SymbolIndex {
@@ -294,16 +298,6 @@ impl SymbolIndex {
         SymbolIndex::new(symbols)
     }
 
-    #[cfg(feature = "wasm")]
-    pub(crate) fn for_files(
-        files: impl Iterator<Item = (FileId, Parse<ast::SourceFile>)>,
-    ) -> SymbolIndex {
-        let symbols = files
-            .flat_map(|(file_id, file)| source_file_to_file_symbols(&file.tree(), file_id))
-            .collect::<Vec<_>>();
-        SymbolIndex::new(symbols)
-    }
-
     fn range_to_map_value(start: usize, end: usize) -> u64 {
         debug_assert![start <= (std::u32::MAX as usize)];
         debug_assert![end <= (std::u32::MAX as usize)];
@@ -319,7 +313,7 @@ impl SymbolIndex {
 }
 
 impl Query {
-    pub(crate) fn search(self, indices: &[Arc<SymbolIndex>]) -> Vec<FileSymbol> {
+    pub(crate) fn search(self, indices: &[&SymbolIndex]) -> Vec<FileSymbol> {
         let mut op = fst::map::OpBuilder::new();
         for file_symbols in indices.iter() {
             let automaton = fst::automaton::Subsequence::new(&self.lowercased);
diff --git a/crates/ra_parser/src/grammar/expressions.rs b/crates/ra_parser/src/grammar/expressions.rs
index d6e8df32a..6e72eea66 100644
--- a/crates/ra_parser/src/grammar/expressions.rs
+++ b/crates/ra_parser/src/grammar/expressions.rs
@@ -50,10 +50,8 @@ fn expr_no_struct(p: &mut Parser) {
 }
 
 fn is_expr_stmt_attr_allowed(kind: SyntaxKind) -> bool {
-    match kind {
-        BIN_EXPR | RANGE_EXPR | IF_EXPR => false,
-        _ => true,
-    }
+    let forbid = matches!(kind, BIN_EXPR | RANGE_EXPR);
+    !forbid
 }
 
 pub(super) fn stmt(p: &mut Parser, with_semi: StmtWithSemi) {
diff --git a/crates/ra_project_model/src/lib.rs b/crates/ra_project_model/src/lib.rs
index cb0e27dce..9541362f5 100644
--- a/crates/ra_project_model/src/lib.rs
+++ b/crates/ra_project_model/src/lib.rs
@@ -29,13 +29,7 @@ pub enum ProjectWorkspace {
     /// Project workspace was discovered by running `cargo metadata` and `rustc --print sysroot`.
     Cargo { cargo: CargoWorkspace, sysroot: Sysroot },
     /// Project workspace was manually specified using a `rust-project.json` file.
-    Json { project: JsonProject },
-}
-
-impl From<JsonProject> for ProjectWorkspace {
-    fn from(project: JsonProject) -> ProjectWorkspace {
-        ProjectWorkspace::Json { project }
-    }
+    Json { project: JsonProject, project_location: PathBuf },
 }
 
 /// `PackageRoot` describes a package root folder.
@@ -164,10 +158,15 @@ impl ProjectWorkspace {
                     format!("Failed to open json file {}", project_json.display())
                 })?;
                 let reader = BufReader::new(file);
+                let project_location = match project_json.parent() {
+                    Some(parent) => PathBuf::from(parent),
+                    None => PathBuf::new(),
+                };
                 ProjectWorkspace::Json {
                     project: from_reader(reader).with_context(|| {
                         format!("Failed to deserialize json file {}", project_json.display())
                     })?,
+                    project_location: project_location,
                 }
             }
             ProjectManifest::CargoToml(cargo_toml) => {
@@ -200,9 +199,11 @@ impl ProjectWorkspace {
     /// the root is a member of the current workspace
     pub fn to_roots(&self) -> Vec<PackageRoot> {
         match self {
-            ProjectWorkspace::Json { project } => {
-                project.roots.iter().map(|r| PackageRoot::new_member(r.path.clone())).collect()
-            }
+            ProjectWorkspace::Json { project, project_location } => project
+                .roots
+                .iter()
+                .map(|r| PackageRoot::new_member(project_location.join(&r.path)))
+                .collect(),
             ProjectWorkspace::Cargo { cargo, sysroot } => cargo
                 .packages()
                 .map(|pkg| PackageRoot {
@@ -219,7 +220,7 @@ impl ProjectWorkspace {
 
     pub fn proc_macro_dylib_paths(&self) -> Vec<PathBuf> {
         match self {
-            ProjectWorkspace::Json { project } => project
+            ProjectWorkspace::Json { project, .. } => project
                 .crates
                 .iter()
                 .filter_map(|krate| krate.proc_macro_dylib_path.as_ref())
@@ -235,7 +236,7 @@ impl ProjectWorkspace {
 
     pub fn n_packages(&self) -> usize {
         match self {
-            ProjectWorkspace::Json { project } => project.crates.len(),
+            ProjectWorkspace::Json { project, .. } => project.crates.len(),
             ProjectWorkspace::Cargo { cargo, sysroot } => {
                 cargo.packages().len() + sysroot.crates().len()
             }
@@ -251,13 +252,14 @@ impl ProjectWorkspace {
     ) -> CrateGraph {
         let mut crate_graph = CrateGraph::default();
         match self {
-            ProjectWorkspace::Json { project } => {
+            ProjectWorkspace::Json { project, project_location } => {
                 let crates: FxHashMap<_, _> = project
                     .crates
                     .iter()
                     .enumerate()
                     .filter_map(|(seq_index, krate)| {
-                        let file_id = load(&krate.root_module)?;
+                        let file_path = project_location.join(&krate.root_module);
+                        let file_id = load(&file_path)?;
                         let edition = match krate.edition {
                             json_project::Edition::Edition2015 => Edition::Edition2015,
                             json_project::Edition::Edition2018 => Edition::Edition2018,
@@ -540,7 +542,7 @@ impl ProjectWorkspace {
             ProjectWorkspace::Cargo { cargo, .. } => {
                 Some(cargo.workspace_root()).filter(|root| path.starts_with(root))
             }
-            ProjectWorkspace::Json { project: JsonProject { roots, .. } } => roots
+            ProjectWorkspace::Json { project: JsonProject { roots, .. }, .. } => roots
                 .iter()
                 .find(|root| path.starts_with(&root.path))
                 .map(|root| root.path.as_ref()),
diff --git a/crates/ra_syntax/src/algo.rs b/crates/ra_syntax/src/algo.rs
index 664894d1f..f7a885eb3 100644
--- a/crates/ra_syntax/src/algo.rs
+++ b/crates/ra_syntax/src/algo.rs
@@ -290,6 +290,11 @@ impl<'a> SyntaxRewriter<'a> {
         N::cast(self.rewrite(node.syntax())).unwrap()
     }
 
+    /// Returns a node that encompasses all replacements to be done by this rewriter.
+    ///
+    /// Passing the returned node to `rewrite` will apply all replacements queued up in `self`.
+    ///
+    /// Returns `None` when there are no replacements.
     pub fn rewrite_root(&self) -> Option<SyntaxNode> {
         assert!(self.f.is_none());
         self.replacements
@@ -298,6 +303,9 @@ impl<'a> SyntaxRewriter<'a> {
                 SyntaxElement::Node(it) => it.clone(),
                 SyntaxElement::Token(it) => it.parent(),
             })
+            // If we only have one replacement, we must return its parent node, since `rewrite` does
+            // not replace the node passed to it.
+            .map(|it| it.parent().unwrap_or(it))
             .fold1(|a, b| least_common_ancestor(&a, &b).unwrap())
     }
 
diff --git a/crates/ra_syntax/src/lib.rs b/crates/ra_syntax/src/lib.rs
index 61e686da5..a33a35cc1 100644
--- a/crates/ra_syntax/src/lib.rs
+++ b/crates/ra_syntax/src/lib.rs
@@ -51,7 +51,8 @@ pub use crate::{
     ptr::{AstPtr, SyntaxNodePtr},
     syntax_error::SyntaxError,
     syntax_node::{
-        Direction, NodeOrToken, SyntaxElement, SyntaxNode, SyntaxToken, SyntaxTreeBuilder,
+        Direction, NodeOrToken, SyntaxElement, SyntaxElementChildren, SyntaxNode,
+        SyntaxNodeChildren, SyntaxToken, SyntaxTreeBuilder,
     },
 };
 pub use ra_parser::{SyntaxKind, T};
diff --git a/crates/ra_syntax/test_data/parser/inline/err/0009_attr_on_expr_not_allowed.rast b/crates/ra_syntax/test_data/parser/inline/err/0009_attr_on_expr_not_allowed.rast
index 0656fdf73..4e3fa704e 100644
--- a/crates/ra_syntax/test_data/parser/inline/err/0009_attr_on_expr_not_allowed.rast
+++ b/crates/ra_syntax/test_data/parser/inline/err/0009_attr_on_expr_not_allowed.rast
@@ -56,4 +56,3 @@ [email protected]
       [email protected] "}"
   [email protected] "\n"
 error 24..24: attributes are not allowed on BIN_EXPR
-error 44..44: attributes are not allowed on IF_EXPR
diff --git a/crates/rust-analyzer/src/bin/main.rs b/crates/rust-analyzer/src/bin/main.rs
index 8d071ab1c..99e3f7173 100644
--- a/crates/rust-analyzer/src/bin/main.rs
+++ b/crates/rust-analyzer/src/bin/main.rs
@@ -108,11 +108,11 @@ fn run_server() -> Result<()> {
             config.update(value);
         }
         config.update_caps(&initialize_params.capabilities);
+        let cwd = std::env::current_dir()?;
+        config.root_path =
+            initialize_params.root_uri.and_then(|it| it.to_file_path().ok()).unwrap_or(cwd);
 
         if config.linked_projects.is_empty() {
-            let cwd = std::env::current_dir()?;
-            let root =
-                initialize_params.root_uri.and_then(|it| it.to_file_path().ok()).unwrap_or(cwd);
             let workspace_roots = initialize_params
                 .workspace_folders
                 .map(|workspaces| {
@@ -122,7 +122,7 @@ fn run_server() -> Result<()> {
                         .collect::<Vec<_>>()
                 })
                 .filter(|workspaces| !workspaces.is_empty())
-                .unwrap_or_else(|| vec![root]);
+                .unwrap_or_else(|| vec![config.root_path.clone()]);
 
             config.linked_projects = ProjectManifest::discover_all(&workspace_roots)
                 .into_iter()
diff --git a/crates/rust-analyzer/src/cargo_target_spec.rs b/crates/rust-analyzer/src/cargo_target_spec.rs
index 44f856f6b..5c22dce0d 100644
--- a/crates/rust-analyzer/src/cargo_target_spec.rs
+++ b/crates/rust-analyzer/src/cargo_target_spec.rs
@@ -2,7 +2,7 @@
 
 use ra_cfg::CfgExpr;
 use ra_ide::{FileId, RunnableKind, TestId};
-use ra_project_model::{self, ProjectWorkspace, TargetKind};
+use ra_project_model::{self, TargetKind};
 
 use crate::{global_state::GlobalStateSnapshot, Result};
 
@@ -89,27 +89,23 @@ impl CargoTargetSpec {
     }
 
     pub(crate) fn for_file(
-        world: &GlobalStateSnapshot,
+        global_state_snapshot: &GlobalStateSnapshot,
         file_id: FileId,
     ) -> Result<Option<CargoTargetSpec>> {
-        let &crate_id = match world.analysis().crate_for(file_id)?.first() {
-            Some(crate_id) => crate_id,
+        let crate_id = match global_state_snapshot.analysis().crate_for(file_id)?.first() {
+            Some(crate_id) => *crate_id,
             None => return Ok(None),
         };
-        let file_id = world.analysis().crate_root(crate_id)?;
-        let path = world.file_id_to_path(file_id);
-        let res = world.workspaces.iter().find_map(|ws| match ws {
-            ProjectWorkspace::Cargo { cargo, .. } => {
-                let tgt = cargo.target_by_root(&path)?;
-                Some(CargoTargetSpec {
-                    package: cargo.package_flag(&cargo[cargo[tgt].package]),
-                    target: cargo[tgt].name.clone(),
-                    target_kind: cargo[tgt].kind,
-                })
-            }
-            ProjectWorkspace::Json { .. } => None,
-        });
-        Ok(res)
+        let (cargo_ws, target) = match global_state_snapshot.cargo_target_for_crate_root(crate_id) {
+            Some(it) => it,
+            None => return Ok(None),
+        };
+        let res = CargoTargetSpec {
+            package: cargo_ws.package_flag(&cargo_ws[cargo_ws[target].package]),
+            target: cargo_ws[target].name.clone(),
+            target_kind: cargo_ws[target].kind,
+        };
+        Ok(Some(res))
     }
 
     pub(crate) fn push_to(self, buf: &mut Vec<String>, kind: &RunnableKind) {
diff --git a/crates/rust-analyzer/src/config.rs b/crates/rust-analyzer/src/config.rs
index 1253db836..0df7427cb 100644
--- a/crates/rust-analyzer/src/config.rs
+++ b/crates/rust-analyzer/src/config.rs
@@ -9,6 +9,7 @@
 
 use std::{ffi::OsString, path::PathBuf};
 
+use crate::diagnostics::DiagnosticsConfig;
 use lsp_types::ClientCapabilities;
 use ra_flycheck::FlycheckConfig;
 use ra_ide::{AssistConfig, CompletionConfig, HoverConfig, InlayHintsConfig};
@@ -20,6 +21,7 @@ pub struct Config {
     pub client_caps: ClientCapsConfig,
 
     pub publish_diagnostics: bool,
+    pub diagnostics: DiagnosticsConfig,
     pub lru_capacity: Option<usize>,
     pub proc_macro_srv: Option<(PathBuf, Vec<OsString>)>,
     pub files: FilesConfig,
@@ -38,12 +40,13 @@ pub struct Config {
 
     pub with_sysroot: bool,
     pub linked_projects: Vec<LinkedProject>,
+    pub root_path: PathBuf,
 }
 
 #[derive(Debug, Clone)]
 pub enum LinkedProject {
     ProjectManifest(ProjectManifest),
-    JsonProject(JsonProject),
+    InlineJsonProject(JsonProject),
 }
 
 impl From<ProjectManifest> for LinkedProject {
@@ -54,7 +57,7 @@ impl From<ProjectManifest> for LinkedProject {
 
 impl From<JsonProject> for LinkedProject {
     fn from(v: JsonProject) -> Self {
-        LinkedProject::JsonProject(v)
+        LinkedProject::InlineJsonProject(v)
     }
 }
 
@@ -135,6 +138,7 @@ impl Default for Config {
 
             with_sysroot: true,
             publish_diagnostics: true,
+            diagnostics: DiagnosticsConfig::default(),
             lru_capacity: None,
             proc_macro_srv: None,
             files: FilesConfig { watcher: FilesWatcher::Notify, exclude: Vec::new() },
@@ -167,6 +171,7 @@ impl Default for Config {
             lens: LensConfig::default(),
             hover: HoverConfig::default(),
             linked_projects: Vec::new(),
+            root_path: PathBuf::new(),
         }
     }
 }
@@ -182,6 +187,8 @@ impl Config {
 
         set(value, "/withSysroot", &mut self.with_sysroot);
         set(value, "/diagnostics/enable", &mut self.publish_diagnostics);
+        set(value, "/diagnostics/warningsAsInfo", &mut self.diagnostics.warnings_as_info);
+        set(value, "/diagnostics/warningsAsHint", &mut self.diagnostics.warnings_as_hint);
         set(value, "/lruCapacity", &mut self.lru_capacity);
         self.files.watcher = match get(value, "/files/watcher") {
             Some("client") => FilesWatcher::Client,
diff --git a/crates/rust-analyzer/src/diagnostics.rs b/crates/rust-analyzer/src/diagnostics.rs
index 25856c543..290609e7f 100644
--- a/crates/rust-analyzer/src/diagnostics.rs
+++ b/crates/rust-analyzer/src/diagnostics.rs
@@ -11,6 +11,12 @@ use crate::lsp_ext;
 pub type CheckFixes = Arc<HashMap<FileId, Vec<Fix>>>;
 
 #[derive(Debug, Default, Clone)]
+pub struct DiagnosticsConfig {
+    pub warnings_as_info: Vec<String>,
+    pub warnings_as_hint: Vec<String>,
+}
+
+#[derive(Debug, Default, Clone)]
 pub struct DiagnosticCollection {
     pub native: HashMap<FileId, Vec<Diagnostic>>,
     pub check: HashMap<FileId, Vec<Diagnostic>>,
diff --git a/crates/rust-analyzer/src/diagnostics/snapshots/rust_analyzer__diagnostics__to_proto__tests__snap_rustc_unused_variable_as_hint.snap b/crates/rust-analyzer/src/diagnostics/snapshots/rust_analyzer__diagnostics__to_proto__tests__snap_rustc_unused_variable_as_hint.snap
new file mode 100644
index 000000000..f0273315e
--- /dev/null
+++ b/crates/rust-analyzer/src/diagnostics/snapshots/rust_analyzer__diagnostics__to_proto__tests__snap_rustc_unused_variable_as_hint.snap
@@ -0,0 +1,86 @@
+---
+source: crates/rust-analyzer/src/diagnostics/to_proto.rs
+expression: diag
+---
+[
+    MappedRustDiagnostic {
+        location: Location {
+            uri: "file:///test/driver/subcommand/repl.rs",
+            range: Range {
+                start: Position {
+                    line: 290,
+                    character: 8,
+                },
+                end: Position {
+                    line: 290,
+                    character: 11,
+                },
+            },
+        },
+        diagnostic: Diagnostic {
+            range: Range {
+                start: Position {
+                    line: 290,
+                    character: 8,
+                },
+                end: Position {
+                    line: 290,
+                    character: 11,
+                },
+            },
+            severity: Some(
+                Hint,
+            ),
+            code: Some(
+                String(
+                    "unused_variables",
+                ),
+            ),
+            source: Some(
+                "rustc",
+            ),
+            message: "unused variable: `foo`\n#[warn(unused_variables)] on by default",
+            related_information: None,
+            tags: Some(
+                [
+                    Unnecessary,
+                ],
+            ),
+        },
+        fixes: [
+            CodeAction {
+                title: "consider prefixing with an underscore",
+                id: None,
+                group: None,
+                kind: Some(
+                    "quickfix",
+                ),
+                command: None,
+                edit: Some(
+                    SnippetWorkspaceEdit {
+                        changes: Some(
+                            {
+                                "file:///test/driver/subcommand/repl.rs": [
+                                    TextEdit {
+                                        range: Range {
+                                            start: Position {
+                                                line: 290,
+                                                character: 8,
+                                            },
+                                            end: Position {
+                                                line: 290,
+                                                character: 11,
+                                            },
+                                        },
+                                        new_text: "_foo",
+                                    },
+                                ],
+                            },
+                        ),
+                        document_changes: None,
+                    },
+                ),
+            },
+        ],
+    },
+]
diff --git a/crates/rust-analyzer/src/diagnostics/snapshots/rust_analyzer__diagnostics__to_proto__tests__snap_rustc_unused_variable_as_info.snap b/crates/rust-analyzer/src/diagnostics/snapshots/rust_analyzer__diagnostics__to_proto__tests__snap_rustc_unused_variable_as_info.snap
new file mode 100644
index 000000000..85fd050fd
--- /dev/null
+++ b/crates/rust-analyzer/src/diagnostics/snapshots/rust_analyzer__diagnostics__to_proto__tests__snap_rustc_unused_variable_as_info.snap
@@ -0,0 +1,86 @@
+---
+source: crates/rust-analyzer/src/diagnostics/to_proto.rs
+expression: diag
+---
+[
+    MappedRustDiagnostic {
+        location: Location {
+            uri: "file:///test/driver/subcommand/repl.rs",
+            range: Range {
+                start: Position {
+                    line: 290,
+                    character: 8,
+                },
+                end: Position {
+                    line: 290,
+                    character: 11,
+                },
+            },
+        },
+        diagnostic: Diagnostic {
+            range: Range {
+                start: Position {
+                    line: 290,
+                    character: 8,
+                },
+                end: Position {
+                    line: 290,
+                    character: 11,
+                },
+            },
+            severity: Some(
+                Information,
+            ),
+            code: Some(
+                String(
+                    "unused_variables",
+                ),
+            ),
+            source: Some(
+                "rustc",
+            ),
+            message: "unused variable: `foo`\n#[warn(unused_variables)] on by default",
+            related_information: None,
+            tags: Some(
+                [
+                    Unnecessary,
+                ],
+            ),
+        },
+        fixes: [
+            CodeAction {
+                title: "consider prefixing with an underscore",
+                id: None,
+                group: None,
+                kind: Some(
+                    "quickfix",
+                ),
+                command: None,
+                edit: Some(
+                    SnippetWorkspaceEdit {
+                        changes: Some(
+                            {
+                                "file:///test/driver/subcommand/repl.rs": [
+                                    TextEdit {
+                                        range: Range {
+                                            start: Position {
+                                                line: 290,
+                                                character: 8,
+                                            },
+                                            end: Position {
+                                                line: 290,
+                                                character: 11,
+                                            },
+                                        },
+                                        new_text: "_foo",
+                                    },
+                                ],
+                            },
+                        ),
+                        document_changes: None,
+                    },
+                ),
+            },
+        ],
+    },
+]
diff --git a/crates/rust-analyzer/src/diagnostics/to_proto.rs b/crates/rust-analyzer/src/diagnostics/to_proto.rs
index 24ff9b280..ba74f15f3 100644
--- a/crates/rust-analyzer/src/diagnostics/to_proto.rs
+++ b/crates/rust-analyzer/src/diagnostics/to_proto.rs
@@ -9,14 +9,24 @@ use lsp_types::{
 use ra_flycheck::{Applicability, DiagnosticLevel, DiagnosticSpan, DiagnosticSpanMacroExpansion};
 use stdx::format_to;
 
+use super::DiagnosticsConfig;
 use crate::{lsp_ext, to_proto::url_from_abs_path};
 
-/// Converts a Rust level string to a LSP severity
-fn map_level_to_severity(val: DiagnosticLevel) -> Option<DiagnosticSeverity> {
-    let res = match val {
+/// Determines the LSP severity from a diagnostic
+fn map_diagnostic_to_severity(
+    config: &DiagnosticsConfig,
+    val: &ra_flycheck::Diagnostic,
+) -> Option<DiagnosticSeverity> {
+    let res = match val.level {
         DiagnosticLevel::Ice => DiagnosticSeverity::Error,
         DiagnosticLevel::Error => DiagnosticSeverity::Error,
-        DiagnosticLevel::Warning => DiagnosticSeverity::Warning,
+        DiagnosticLevel::Warning => match &val.code {
+            Some(code) if config.warnings_as_hint.contains(&code.code) => DiagnosticSeverity::Hint,
+            Some(code) if config.warnings_as_info.contains(&code.code) => {
+                DiagnosticSeverity::Information
+            }
+            _ => DiagnosticSeverity::Warning,
+        },
         DiagnosticLevel::Note => DiagnosticSeverity::Information,
         DiagnosticLevel::Help => DiagnosticSeverity::Hint,
         DiagnosticLevel::Unknown => return None,
@@ -172,6 +182,7 @@ pub(crate) struct MappedRustDiagnostic {
 ///
 /// If the diagnostic has no primary span this will return `None`
 pub(crate) fn map_rust_diagnostic_to_lsp(
+    config: &DiagnosticsConfig,
     rd: &ra_flycheck::Diagnostic,
     workspace_root: &Path,
 ) -> Vec<MappedRustDiagnostic> {
@@ -180,7 +191,7 @@ pub(crate) fn map_rust_diagnostic_to_lsp(
         return Vec::new();
     }
 
-    let severity = map_level_to_severity(rd.level);
+    let severity = map_diagnostic_to_severity(config, rd);
 
     let mut source = String::from("rustc");
     let mut code = rd.code.as_ref().map(|c| c.code.clone());
@@ -328,7 +339,7 @@ mod tests {
         );
 
         let workspace_root = Path::new("/test/");
-        let diag = map_rust_diagnostic_to_lsp(&diag, workspace_root);
+        let diag = map_rust_diagnostic_to_lsp(&DiagnosticsConfig::default(), &diag, workspace_root);
         insta::assert_debug_snapshot!(diag);
     }
 
@@ -410,7 +421,183 @@ mod tests {
         );
 
         let workspace_root = Path::new("/test/");
-        let diag = map_rust_diagnostic_to_lsp(&diag, workspace_root);
+        let diag = map_rust_diagnostic_to_lsp(&DiagnosticsConfig::default(), &diag, workspace_root);
+        insta::assert_debug_snapshot!(diag);
+    }
+
+    #[test]
+    #[cfg(not(windows))]
+    fn snap_rustc_unused_variable_as_info() {
+        let diag = parse_diagnostic(
+            r##"{
+    "message": "unused variable: `foo`",
+    "code": {
+        "code": "unused_variables",
+        "explanation": null
+    },
+    "level": "warning",
+    "spans": [
+        {
+            "file_name": "driver/subcommand/repl.rs",
+            "byte_start": 9228,
+            "byte_end": 9231,
+            "line_start": 291,
+            "line_end": 291,
+            "column_start": 9,
+            "column_end": 12,
+            "is_primary": true,
+            "text": [
+                {
+                    "text": "    let foo = 42;",
+                    "highlight_start": 9,
+                    "highlight_end": 12
+                }
+            ],
+            "label": null,
+            "suggested_replacement": null,
+            "suggestion_applicability": null,
+            "expansion": null
+        }
+    ],
+    "children": [
+        {
+            "message": "#[warn(unused_variables)] on by default",
+            "code": null,
+            "level": "note",
+            "spans": [],
+            "children": [],
+            "rendered": null
+        },
+        {
+            "message": "consider prefixing with an underscore",
+            "code": null,
+            "level": "help",
+            "spans": [
+                {
+                    "file_name": "driver/subcommand/repl.rs",
+                    "byte_start": 9228,
+                    "byte_end": 9231,
+                    "line_start": 291,
+                    "line_end": 291,
+                    "column_start": 9,
+                    "column_end": 12,
+                    "is_primary": true,
+                    "text": [
+                        {
+                            "text": "    let foo = 42;",
+                            "highlight_start": 9,
+                            "highlight_end": 12
+                        }
+                    ],
+                    "label": null,
+                    "suggested_replacement": "_foo",
+                    "suggestion_applicability": "MachineApplicable",
+                    "expansion": null
+                }
+            ],
+            "children": [],
+            "rendered": null
+        }
+    ],
+    "rendered": "warning: unused variable: `foo`\n   --> driver/subcommand/repl.rs:291:9\n    |\n291 |     let foo = 42;\n    |         ^^^ help: consider prefixing with an underscore: `_foo`\n    |\n    = note: #[warn(unused_variables)] on by default\n\n"
+    }"##,
+        );
+
+        let config = DiagnosticsConfig {
+            warnings_as_info: vec!["unused_variables".to_string()],
+            ..DiagnosticsConfig::default()
+        };
+
+        let workspace_root = Path::new("/test/");
+        let diag = map_rust_diagnostic_to_lsp(&config, &diag, workspace_root);
+        insta::assert_debug_snapshot!(diag);
+    }
+
+    #[test]
+    #[cfg(not(windows))]
+    fn snap_rustc_unused_variable_as_hint() {
+        let diag = parse_diagnostic(
+            r##"{
+    "message": "unused variable: `foo`",
+    "code": {
+        "code": "unused_variables",
+        "explanation": null
+    },
+    "level": "warning",
+    "spans": [
+        {
+            "file_name": "driver/subcommand/repl.rs",
+            "byte_start": 9228,
+            "byte_end": 9231,
+            "line_start": 291,
+            "line_end": 291,
+            "column_start": 9,
+            "column_end": 12,
+            "is_primary": true,
+            "text": [
+                {
+                    "text": "    let foo = 42;",
+                    "highlight_start": 9,
+                    "highlight_end": 12
+                }
+            ],
+            "label": null,
+            "suggested_replacement": null,
+            "suggestion_applicability": null,
+            "expansion": null
+        }
+    ],
+    "children": [
+        {
+            "message": "#[warn(unused_variables)] on by default",
+            "code": null,
+            "level": "note",
+            "spans": [],
+            "children": [],
+            "rendered": null
+        },
+        {
+            "message": "consider prefixing with an underscore",
+            "code": null,
+            "level": "help",
+            "spans": [
+                {
+                    "file_name": "driver/subcommand/repl.rs",
+                    "byte_start": 9228,
+                    "byte_end": 9231,
+                    "line_start": 291,
+                    "line_end": 291,
+                    "column_start": 9,
+                    "column_end": 12,
+                    "is_primary": true,
+                    "text": [
+                        {
+                            "text": "    let foo = 42;",
+                            "highlight_start": 9,
+                            "highlight_end": 12
+                        }
+                    ],
+                    "label": null,
+                    "suggested_replacement": "_foo",
+                    "suggestion_applicability": "MachineApplicable",
+                    "expansion": null
+                }
+            ],
+            "children": [],
+            "rendered": null
+        }
+    ],
+    "rendered": "warning: unused variable: `foo`\n   --> driver/subcommand/repl.rs:291:9\n    |\n291 |     let foo = 42;\n    |         ^^^ help: consider prefixing with an underscore: `_foo`\n    |\n    = note: #[warn(unused_variables)] on by default\n\n"
+    }"##,
+        );
+
+        let config = DiagnosticsConfig {
+            warnings_as_hint: vec!["unused_variables".to_string()],
+            ..DiagnosticsConfig::default()
+        };
+
+        let workspace_root = Path::new("/test/");
+        let diag = map_rust_diagnostic_to_lsp(&config, &diag, workspace_root);
         insta::assert_debug_snapshot!(diag);
     }
 
@@ -534,7 +721,7 @@ mod tests {
         );
 
         let workspace_root = Path::new("/test/");
-        let diag = map_rust_diagnostic_to_lsp(&diag, workspace_root);
+        let diag = map_rust_diagnostic_to_lsp(&DiagnosticsConfig::default(), &diag, workspace_root);
         insta::assert_debug_snapshot!(diag);
     }
 
@@ -654,7 +841,7 @@ mod tests {
         );
 
         let workspace_root = Path::new("/test/");
-        let diag = map_rust_diagnostic_to_lsp(&diag, workspace_root);
+        let diag = map_rust_diagnostic_to_lsp(&DiagnosticsConfig::default(), &diag, workspace_root);
         insta::assert_debug_snapshot!(diag);
     }
 
@@ -697,7 +884,7 @@ mod tests {
         );
 
         let workspace_root = Path::new("/test/");
-        let diag = map_rust_diagnostic_to_lsp(&diag, workspace_root);
+        let diag = map_rust_diagnostic_to_lsp(&DiagnosticsConfig::default(), &diag, workspace_root);
         insta::assert_debug_snapshot!(diag);
     }
 
@@ -968,7 +1155,7 @@ mod tests {
         );
 
         let workspace_root = Path::new("/test/");
-        let diag = map_rust_diagnostic_to_lsp(&diag, workspace_root);
+        let diag = map_rust_diagnostic_to_lsp(&DiagnosticsConfig::default(), &diag, workspace_root);
         insta::assert_debug_snapshot!(diag);
     }
 
@@ -1197,7 +1384,7 @@ mod tests {
         );
 
         let workspace_root = Path::new("/test/");
-        let diag = map_rust_diagnostic_to_lsp(&diag, workspace_root);
+        let diag = map_rust_diagnostic_to_lsp(&DiagnosticsConfig::default(), &diag, workspace_root);
         insta::assert_debug_snapshot!(diag);
     }
 
@@ -1330,7 +1517,7 @@ mod tests {
         );
 
         let workspace_root = Path::new("/test/");
-        let diag = map_rust_diagnostic_to_lsp(&diag, workspace_root);
+        let diag = map_rust_diagnostic_to_lsp(&DiagnosticsConfig::default(), &diag, workspace_root);
         insta::assert_debug_snapshot!(diag);
     }
 }
diff --git a/crates/rust-analyzer/src/global_state.rs b/crates/rust-analyzer/src/global_state.rs
index 9d5685d88..ca95d776a 100644
--- a/crates/rust-analyzer/src/global_state.rs
+++ b/crates/rust-analyzer/src/global_state.rs
@@ -12,12 +12,9 @@ use crossbeam_channel::{unbounded, Receiver};
 use lsp_types::Url;
 use parking_lot::RwLock;
 use ra_flycheck::{Flycheck, FlycheckConfig};
-use ra_ide::{
-    Analysis, AnalysisChange, AnalysisHost, CrateGraph, FileId, LibraryData, SourceRootId,
-};
-use ra_project_model::{ProcMacroClient, ProjectWorkspace};
-use ra_vfs::{LineEndings, RootEntry, Vfs, VfsChange, VfsFile, VfsRoot, VfsTask, Watch};
-use relative_path::RelativePathBuf;
+use ra_ide::{Analysis, AnalysisChange, AnalysisHost, CrateGraph, FileId, SourceRootId};
+use ra_project_model::{CargoWorkspace, ProcMacroClient, ProjectWorkspace, Target};
+use ra_vfs::{LineEndings, RootEntry, Vfs, VfsChange, VfsFile, VfsTask, Watch};
 use stdx::format_to;
 
 use crate::{
@@ -28,25 +25,21 @@ use crate::{
     vfs_glob::{Glob, RustPackageFilterBuilder},
     LspError, Result,
 };
-use ra_db::ExternSourceId;
+use ra_db::{CrateId, ExternSourceId};
 use rustc_hash::{FxHashMap, FxHashSet};
 
 fn create_flycheck(workspaces: &[ProjectWorkspace], config: &FlycheckConfig) -> Option<Flycheck> {
     // FIXME: Figure out the multi-workspace situation
-    workspaces
-        .iter()
-        .find_map(|w| match w {
-            ProjectWorkspace::Cargo { cargo, .. } => Some(cargo),
-            ProjectWorkspace::Json { .. } => None,
-        })
-        .map(|cargo| {
+    workspaces.iter().find_map(|w| match w {
+        ProjectWorkspace::Cargo { cargo, .. } => {
             let cargo_project_root = cargo.workspace_root().to_path_buf();
             Some(Flycheck::new(config.clone(), cargo_project_root))
-        })
-        .unwrap_or_else(|| {
+        }
+        ProjectWorkspace::Json { .. } => {
             log::warn!("Cargo check watching only supported for cargo workspaces, disabling");
             None
-        })
+        }
+    })
 }
 
 /// `GlobalState` is the primary mutable state of the language server
@@ -195,32 +188,18 @@ impl GlobalState {
 
     /// Returns a vec of libraries
     /// FIXME: better API here
-    pub fn process_changes(
-        &mut self,
-        roots_scanned: &mut usize,
-    ) -> Option<Vec<(SourceRootId, Vec<(FileId, RelativePathBuf, Arc<String>)>)>> {
+    pub fn process_changes(&mut self, roots_scanned: &mut usize) -> bool {
         let changes = self.vfs.write().commit_changes();
         if changes.is_empty() {
-            return None;
+            return false;
         }
-        let mut libs = Vec::new();
         let mut change = AnalysisChange::new();
         for c in changes {
             match c {
                 VfsChange::AddRoot { root, files } => {
-                    let root_path = self.vfs.read().root2path(root);
-                    let is_local = self.local_roots.iter().any(|r| root_path.starts_with(r));
-                    if is_local {
-                        *roots_scanned += 1;
-                        for (file, path, text) in files {
-                            change.add_file(SourceRootId(root.0), FileId(file.0), path, text);
-                        }
-                    } else {
-                        let files = files
-                            .into_iter()
-                            .map(|(vfsfile, path, text)| (FileId(vfsfile.0), path, text))
-                            .collect();
-                        libs.push((SourceRootId(root.0), files));
+                    *roots_scanned += 1;
+                    for (file, path, text) in files {
+                        change.add_file(SourceRootId(root.0), FileId(file.0), path, text);
                     }
                 }
                 VfsChange::AddFile { root, file, path, text } => {
@@ -235,13 +214,7 @@ impl GlobalState {
             }
         }
         self.analysis_host.apply_change(change);
-        Some(libs)
-    }
-
-    pub fn add_lib(&mut self, data: LibraryData) {
-        let mut change = AnalysisChange::new();
-        change.add_library(data);
-        self.analysis_host.apply_change(change);
+        true
     }
 
     pub fn snapshot(&self) -> GlobalStateSnapshot {
@@ -290,20 +263,31 @@ impl GlobalStateSnapshot {
         file_id_to_url(&self.vfs.read(), id)
     }
 
-    pub fn file_id_to_path(&self, id: FileId) -> PathBuf {
-        self.vfs.read().file2path(VfsFile(id.0))
-    }
-
     pub fn file_line_endings(&self, id: FileId) -> LineEndings {
         self.vfs.read().file_line_endings(VfsFile(id.0))
     }
 
-    pub fn path_to_url(&self, root: SourceRootId, path: &RelativePathBuf) -> Url {
-        let base = self.vfs.read().root2path(VfsRoot(root.0));
-        let path = path.to_path(base);
+    pub fn anchored_path(&self, file_id: FileId, path: &str) -> Url {
+        let mut base = self.vfs.read().file2path(VfsFile(file_id.0));
+        base.pop();
+        let path = base.join(path);
         url_from_abs_path(&path)
     }
 
+    pub(crate) fn cargo_target_for_crate_root(
+        &self,
+        crate_id: CrateId,
+    ) -> Option<(&CargoWorkspace, Target)> {
+        let file_id = self.analysis().crate_root(crate_id).ok()?;
+        let path = self.vfs.read().file2path(VfsFile(file_id.0));
+        self.workspaces.iter().find_map(|ws| match ws {
+            ProjectWorkspace::Cargo { cargo, .. } => {
+                cargo.target_by_root(&path).map(|it| (cargo, it))
+            }
+            ProjectWorkspace::Json { .. } => None,
+        })
+    }
+
     pub fn status(&self) -> String {
         let mut buf = String::new();
         if self.workspaces.is_empty() {
diff --git a/crates/rust-analyzer/src/main_loop.rs b/crates/rust-analyzer/src/main_loop.rs
index 8ec571b70..08b0a5a16 100644
--- a/crates/rust-analyzer/src/main_loop.rs
+++ b/crates/rust-analyzer/src/main_loop.rs
@@ -24,11 +24,10 @@ use lsp_types::{
     WorkDoneProgressReport,
 };
 use ra_flycheck::{CheckTask, Status};
-use ra_ide::{Canceled, FileId, LibraryData, LineIndex, SourceRootId};
+use ra_ide::{Canceled, FileId, LineIndex};
 use ra_prof::profile;
 use ra_project_model::{PackageRoot, ProjectWorkspace};
 use ra_vfs::{VfsTask, Watch};
-use relative_path::RelativePathBuf;
 use rustc_hash::FxHashSet;
 use serde::{de::DeserializeOwned, Serialize};
 use threadpool::ThreadPool;
@@ -121,7 +120,12 @@ pub fn main_loop(config: Config, connection: Connection) -> Result<()> {
                         })
                         .ok()
                     }
-                    LinkedProject::JsonProject(it) => Some(it.clone().into()),
+                    LinkedProject::InlineJsonProject(it) => {
+                        Some(ra_project_model::ProjectWorkspace::Json {
+                            project: it.clone(),
+                            project_location: config.root_path.clone(),
+                        })
+                    }
                 })
                 .collect::<Vec<_>>()
         };
@@ -169,12 +173,10 @@ pub fn main_loop(config: Config, connection: Connection) -> Result<()> {
 
     let pool = ThreadPool::default();
     let (task_sender, task_receiver) = unbounded::<Task>();
-    let (libdata_sender, libdata_receiver) = unbounded::<LibraryData>();
 
     log::info!("server initialized, serving requests");
     {
         let task_sender = task_sender;
-        let libdata_sender = libdata_sender;
         loop {
             log::trace!("selecting");
             let event = select! {
@@ -187,7 +189,6 @@ pub fn main_loop(config: Config, connection: Connection) -> Result<()> {
                     Ok(task) => Event::Vfs(task),
                     Err(RecvError) => return Err("vfs died".into()),
                 },
-                recv(libdata_receiver) -> data => Event::Lib(data.unwrap()),
                 recv(global_state.flycheck.as_ref().map_or(&never(), |it| &it.task_recv)) -> task => match task {
                     Ok(task) => Event::CheckWatcher(task),
                     Err(RecvError) => return Err("check watcher died".into()),
@@ -198,15 +199,7 @@ pub fn main_loop(config: Config, connection: Connection) -> Result<()> {
                     break;
                 };
             }
-            loop_turn(
-                &pool,
-                &task_sender,
-                &libdata_sender,
-                &connection,
-                &mut global_state,
-                &mut loop_state,
-                event,
-            )?;
+            loop_turn(&pool, &task_sender, &connection, &mut global_state, &mut loop_state, event)?;
         }
     }
     global_state.analysis_host.request_cancellation();
@@ -214,7 +207,6 @@ pub fn main_loop(config: Config, connection: Connection) -> Result<()> {
     task_receiver.into_iter().for_each(|task| {
         on_task(task, &connection.sender, &mut loop_state.pending_requests, &mut global_state)
     });
-    libdata_receiver.into_iter().for_each(drop);
     log::info!("...tasks have finished");
     log::info!("joining threadpool...");
     pool.join();
@@ -238,7 +230,6 @@ enum Event {
     Msg(Message),
     Task(Task),
     Vfs(VfsTask),
-    Lib(LibraryData),
     CheckWatcher(CheckTask),
 }
 
@@ -274,7 +265,6 @@ impl fmt::Debug for Event {
             Event::Msg(it) => fmt::Debug::fmt(it, f),
             Event::Task(it) => fmt::Debug::fmt(it, f),
             Event::Vfs(it) => fmt::Debug::fmt(it, f),
-            Event::Lib(it) => fmt::Debug::fmt(it, f),
             Event::CheckWatcher(it) => fmt::Debug::fmt(it, f),
         }
     }
@@ -286,10 +276,6 @@ struct LoopState {
     pending_responses: FxHashSet<RequestId>,
     pending_requests: PendingRequests,
     subscriptions: Subscriptions,
-    // We try not to index more than MAX_IN_FLIGHT_LIBS libraries at the same
-    // time to always have a thread ready to react to input.
-    in_flight_libraries: usize,
-    pending_libraries: Vec<(SourceRootId, Vec<(FileId, RelativePathBuf, Arc<String>)>)>,
     workspace_loaded: bool,
     roots_progress_reported: Option<usize>,
     roots_scanned: usize,
@@ -310,7 +296,6 @@ impl LoopState {
 fn loop_turn(
     pool: &ThreadPool,
     task_sender: &Sender<Task>,
-    libdata_sender: &Sender<LibraryData>,
     connection: &Connection,
     global_state: &mut GlobalState,
     loop_state: &mut LoopState,
@@ -334,12 +319,6 @@ fn loop_turn(
         Event::Vfs(task) => {
             global_state.vfs.write().handle_task(task);
         }
-        Event::Lib(lib) => {
-            global_state.add_lib(lib);
-            global_state.maybe_collect_garbage();
-            loop_state.in_flight_libraries -= 1;
-            loop_state.roots_scanned += 1;
-        }
         Event::CheckWatcher(task) => on_check_task(task, global_state, task_sender)?,
         Event::Msg(msg) => match msg {
             Message::Request(req) => on_request(
@@ -385,36 +364,12 @@ fn loop_turn(
         },
     };
 
-    let mut state_changed = false;
-    if let Some(changes) = global_state.process_changes(&mut loop_state.roots_scanned) {
-        state_changed = true;
-        loop_state.pending_libraries.extend(changes);
-    }
-
-    let max_in_flight_libs = pool.max_count().saturating_sub(2).max(1);
-    while loop_state.in_flight_libraries < max_in_flight_libs {
-        let (root, files) = match loop_state.pending_libraries.pop() {
-            Some(it) => it,
-            None => break,
-        };
-
-        loop_state.in_flight_libraries += 1;
-        let sender = libdata_sender.clone();
-        pool.execute(move || {
-            log::info!("indexing {:?} ... ", root);
-            let data = LibraryData::prepare(root, files);
-            sender.send(data).unwrap();
-        });
-    }
+    let mut state_changed = global_state.process_changes(&mut loop_state.roots_scanned);
 
     let show_progress =
         !loop_state.workspace_loaded && global_state.config.client_caps.work_done_progress;
 
-    if !loop_state.workspace_loaded
-        && loop_state.roots_scanned == loop_state.roots_total
-        && loop_state.pending_libraries.is_empty()
-        && loop_state.in_flight_libraries == 0
-    {
+    if !loop_state.workspace_loaded && loop_state.roots_scanned == loop_state.roots_total {
         state_changed = true;
         loop_state.workspace_loaded = true;
         if let Some(flycheck) = &global_state.flycheck {
@@ -664,14 +619,11 @@ fn apply_document_changes(
     mut line_index: Cow<'_, LineIndex>,
     content_changes: Vec<TextDocumentContentChangeEvent>,
 ) {
-    // Remove when https://github.com/rust-analyzer/rust-analyzer/issues/4263 is fixed.
-    let backup_text = old_text.clone();
-    let backup_changes = content_changes.clone();
-
     // The changes we got must be applied sequentially, but can cross lines so we
     // have to keep our line index updated.
     // Some clients (e.g. Code) sort the ranges in reverse. As an optimization, we
     // remember the last valid line in the index and only rebuild it if needed.
+    // The VFS will normalize the end of lines to `\n`.
     enum IndexValid {
         All,
         UpToLineExclusive(u64),
@@ -695,19 +647,7 @@ fn apply_document_changes(
                 }
                 index_valid = IndexValid::UpToLineExclusive(range.start.line);
                 let range = from_proto::text_range(&line_index, range);
-                let mut text = old_text.to_owned();
-                match std::panic::catch_unwind(move || {
-                    text.replace_range(Range::<usize>::from(range), &change.text);
-                    text
-                }) {
-                    Ok(t) => *old_text = t,
-                    Err(e) => {
-                        eprintln!("Bug in incremental text synchronization. Please report the following output on https://github.com/rust-analyzer/rust-analyzer/issues/4263");
-                        dbg!(&backup_text);
-                        dbg!(&backup_changes);
-                        std::panic::resume_unwind(e);
-                    }
-                }
+                old_text.replace_range(Range::<usize>::from(range), &change.text);
             }
             None => {
                 *old_text = change.text;
@@ -729,6 +669,7 @@ fn on_check_task(
 
         CheckTask::AddDiagnostic { workspace_root, diagnostic } => {
             let diagnostics = crate::diagnostics::to_proto::map_rust_diagnostic_to_lsp(
+                &global_state.config.diagnostics,
                 &diagnostic,
                 &workspace_root,
             );
diff --git a/crates/rust-analyzer/src/semantic_tokens.rs b/crates/rust-analyzer/src/semantic_tokens.rs
index 6f125c37c..2ea63d33b 100644
--- a/crates/rust-analyzer/src/semantic_tokens.rs
+++ b/crates/rust-analyzer/src/semantic_tokens.rs
@@ -45,6 +45,7 @@ define_semantic_token_types![
     (UNION, "union"),
     (UNRESOLVED_REFERENCE, "unresolvedReference"),
     (FORMAT_SPECIFIER, "formatSpecifier"),
+    (ESCAPE_SEQUENCE, "escapeSequence"),
 ];
 
 macro_rules! define_semantic_token_modifiers {
diff --git a/crates/rust-analyzer/src/to_proto.rs b/crates/rust-analyzer/src/to_proto.rs
index 881aa1c55..055c97455 100644
--- a/crates/rust-analyzer/src/to_proto.rs
+++ b/crates/rust-analyzer/src/to_proto.rs
@@ -324,6 +324,7 @@ fn semantic_token_type_and_modifiers(
         HighlightTag::UnresolvedReference => semantic_tokens::UNRESOLVED_REFERENCE,
         HighlightTag::FormatSpecifier => semantic_tokens::FORMAT_SPECIFIER,
         HighlightTag::Operator => lsp_types::SemanticTokenType::OPERATOR,
+        HighlightTag::EscapeSequence => semantic_tokens::ESCAPE_SEQUENCE,
     };
 
     for modifier in highlight.modifiers.iter() {
@@ -528,13 +529,13 @@ pub(crate) fn resource_op(
     file_system_edit: FileSystemEdit,
 ) -> lsp_types::ResourceOp {
     match file_system_edit {
-        FileSystemEdit::CreateFile { source_root, path } => {
-            let uri = snap.path_to_url(source_root, &path);
+        FileSystemEdit::CreateFile { anchor, dst } => {
+            let uri = snap.anchored_path(anchor, &dst);
             lsp_types::ResourceOp::Create(lsp_types::CreateFile { uri, options: None })
         }
-        FileSystemEdit::MoveFile { src, dst_source_root, dst_path } => {
+        FileSystemEdit::MoveFile { src, anchor, dst } => {
             let old_uri = snap.file_id_to_url(src);
-            let new_uri = snap.path_to_url(dst_source_root, &dst_path);
+            let new_uri = snap.anchored_path(anchor, &dst);
             lsp_types::ResourceOp::Rename(lsp_types::RenameFile { old_uri, new_uri, options: None })
         }
     }
diff --git a/crates/test_utils/src/lib.rs b/crates/test_utils/src/lib.rs
index 2141bfc20..981565cd7 100644
--- a/crates/test_utils/src/lib.rs
+++ b/crates/test_utils/src/lib.rs
@@ -10,17 +10,17 @@
 pub mod mark;
 
 use std::{
-    fs,
+    env, fs,
     path::{Path, PathBuf},
 };
 
-pub use ra_cfg::CfgOptions;
+use serde_json::Value;
 use stdx::split1;
+use text_size::{TextRange, TextSize};
 
+pub use ra_cfg::CfgOptions;
 pub use relative_path::{RelativePath, RelativePathBuf};
 pub use rustc_hash::FxHashMap;
-use serde_json::Value;
-use text_size::{TextRange, TextSize};
 
 pub use difference::Changeset as __Changeset;
 
@@ -625,8 +625,6 @@ pub fn skip_slow_tests() -> bool {
     should_skip
 }
 
-const REWRITE: bool = false;
-
 /// 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`.
@@ -642,7 +640,7 @@ fn assert_equal_text(expected: &str, actual: &str, path: &Path) {
         fs::write(path, actual).unwrap();
         return;
     }
-    if REWRITE {
+    if env::var("UPDATE_EXPECTATIONS").is_ok() {
         println!("rewriting {}", pretty_path.display());
         fs::write(path, actual).unwrap();
         return;
diff --git a/crates/vfs/Cargo.toml b/crates/vfs/Cargo.toml
new file mode 100644
index 000000000..c03e6363b
--- /dev/null
+++ b/crates/vfs/Cargo.toml
@@ -0,0 +1,14 @@
+[package]
+name = "vfs"
+version = "0.1.0"
+authors = ["rust-analyzer developers"]
+edition = "2018"
+
+[dependencies]
+rustc-hash = "1.0"
+jod-thread = "0.1.0"
+walkdir = "2.3.1"
+globset = "0.4.5"
+crossbeam-channel = "0.4.0"
+
+paths = { path = "../paths" }
diff --git a/crates/vfs/src/file_set.rs b/crates/vfs/src/file_set.rs
new file mode 100644
index 000000000..7dc721f7e
--- /dev/null
+++ b/crates/vfs/src/file_set.rs
@@ -0,0 +1,99 @@
+//! Partitions a list of files into disjoint subsets.
+//!
+//! Files which do not belong to any explicitly configured `FileSet` belong to
+//! the default `FileSet`.
+use std::{cmp, fmt, iter};
+
+use paths::AbsPathBuf;
+use rustc_hash::FxHashMap;
+
+use crate::{FileId, Vfs, VfsPath};
+
+#[derive(Default, Clone, Eq, PartialEq)]
+pub struct FileSet {
+    files: FxHashMap<VfsPath, FileId>,
+    paths: FxHashMap<FileId, VfsPath>,
+}
+
+impl FileSet {
+    pub fn resolve_path(&self, anchor: FileId, path: &str) -> Option<FileId> {
+        let mut base = self.paths[&anchor].clone();
+        base.pop();
+        let path = base.join(path);
+        let res = self.files.get(&path).copied();
+        res
+    }
+    pub fn insert(&mut self, file_id: FileId, path: VfsPath) {
+        self.files.insert(path.clone(), file_id);
+        self.paths.insert(file_id, path);
+    }
+    pub fn iter(&self) -> impl Iterator<Item = FileId> + '_ {
+        self.paths.keys().copied()
+    }
+}
+
+impl fmt::Debug for FileSet {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("FileSet").field("n_files", &self.files.len()).finish()
+    }
+}
+
+#[derive(Debug)]
+pub struct FileSetConfig {
+    n_file_sets: usize,
+    roots: Vec<(AbsPathBuf, usize)>,
+}
+
+impl FileSetConfig {
+    pub fn builder() -> FileSetConfigBuilder {
+        FileSetConfigBuilder::default()
+    }
+    pub fn partition(&self, vfs: &Vfs) -> Vec<FileSet> {
+        let mut res = vec![FileSet::default(); self.len()];
+        for (file_id, path) in vfs.iter() {
+            let root = self.classify(&path);
+            res[root].insert(file_id, path)
+        }
+        res
+    }
+    fn len(&self) -> usize {
+        self.n_file_sets
+    }
+    fn classify(&self, path: &VfsPath) -> usize {
+        for (root, idx) in self.roots.iter() {
+            if let Some(path) = path.as_path() {
+                if path.starts_with(root) {
+                    return *idx;
+                }
+            }
+        }
+        self.len() - 1
+    }
+}
+
+pub struct FileSetConfigBuilder {
+    roots: Vec<Vec<AbsPathBuf>>,
+}
+
+impl Default for FileSetConfigBuilder {
+    fn default() -> Self {
+        FileSetConfigBuilder { roots: Vec::new() }
+    }
+}
+
+impl FileSetConfigBuilder {
+    pub fn add_file_set(&mut self, roots: Vec<AbsPathBuf>) {
+        self.roots.push(roots)
+    }
+    pub fn build(self) -> FileSetConfig {
+        let n_file_sets = self.roots.len() + 1;
+        let mut roots: Vec<(AbsPathBuf, usize)> = self
+            .roots
+            .into_iter()
+            .enumerate()
+            .flat_map(|(i, paths)| paths.into_iter().zip(iter::repeat(i)))
+            .collect();
+        roots.sort_by_key(|(path, _)| cmp::Reverse(path.to_string_lossy().len()));
+        FileSetConfig { n_file_sets, roots }
+    }
+}
diff --git a/crates/vfs/src/lib.rs b/crates/vfs/src/lib.rs
new file mode 100644
index 000000000..75ce61cf9
--- /dev/null
+++ b/crates/vfs/src/lib.rs
@@ -0,0 +1,138 @@
+//! # Virtual File System
+//!
+//! VFS stores all files read by rust-analyzer. Reading file contents from VFS
+//! always returns the same contents, unless VFS was explicitly modified with
+//! `set_file_contents`. All changes to VFS are logged, and can be retrieved via
+//! `take_changes` method. The pack of changes is then pushed to `salsa` and
+//! triggers incremental recomputation.
+//!
+//! Files in VFS are identified with `FileId`s -- interned paths. The notion of
+//! the path, `VfsPath` is somewhat abstract: at the moment, it is represented
+//! as an `std::path::PathBuf` internally, but this is an implementation detail.
+//!
+//! VFS doesn't do IO or file watching itself. For that, see the `loader`
+//! module. `loader::Handle` is an object-safe trait which abstracts both file
+//! loading and file watching. `Handle` is dynamically configured with a set of
+//! directory entries which should be scanned and watched. `Handle` then
+//! asynchronously pushes file changes. Directory entries are configured in
+//! free-form via list of globs, it's up to the `Handle` to interpret the globs
+//! in any specific way.
+//!
+//! A simple `WalkdirLoaderHandle` is provided, which doesn't implement watching
+//! and just scans the directory using walkdir.
+//!
+//! VFS stores a flat list of files. `FileSet` can partition this list of files
+//! into disjoint sets of files. Traversal-like operations (including getting
+//! the neighbor file by the relative path) are handled by the `FileSet`.
+//! `FileSet`s are also pushed to salsa and cause it to re-check `mod foo;`
+//! declarations when files are created or deleted.
+//!
+//! `file_set::FileSet` and `loader::Entry` play similar, but different roles.
+//! Both specify the "set of paths/files", one is geared towards file watching,
+//! the other towards salsa changes. In particular, single `file_set::FileSet`
+//! may correspond to several `loader::Entry`. For example, a crate from
+//! crates.io which uses code generation would have two `Entries` -- for sources
+//! in `~/.cargo`, and for generated code in `./target/debug/build`. It will
+//! have a single `FileSet` which unions the two sources.
+mod vfs_path;
+mod path_interner;
+pub mod file_set;
+pub mod loader;
+pub mod walkdir_loader;
+
+use std::{fmt, mem};
+
+use crate::path_interner::PathInterner;
+
+pub use crate::vfs_path::VfsPath;
+pub use paths::{AbsPath, AbsPathBuf};
+
+#[derive(Copy, Clone, Debug, Ord, PartialOrd, Eq, PartialEq, Hash)]
+pub struct FileId(pub u32);
+
+#[derive(Default)]
+pub struct Vfs {
+    interner: PathInterner,
+    data: Vec<Option<Vec<u8>>>,
+    changes: Vec<ChangedFile>,
+}
+
+pub struct ChangedFile {
+    pub file_id: FileId,
+    pub change_kind: ChangeKind,
+}
+
+impl ChangedFile {
+    pub fn exists(&self) -> bool {
+        self.change_kind != ChangeKind::Delete
+    }
+    pub fn is_created_or_deleted(&self) -> bool {
+        matches!(self.change_kind, ChangeKind::Create | ChangeKind::Delete)
+    }
+}
+
+#[derive(Eq, PartialEq)]
+pub enum ChangeKind {
+    Create,
+    Modify,
+    Delete,
+}
+
+impl Vfs {
+    pub fn file_id(&self, path: &VfsPath) -> Option<FileId> {
+        self.interner.get(path).filter(|&it| self.get(it).is_some())
+    }
+    pub fn file_path(&self, file_id: FileId) -> VfsPath {
+        self.interner.lookup(file_id).clone()
+    }
+    pub fn file_contents(&self, file_id: FileId) -> &[u8] {
+        self.get(file_id).as_deref().unwrap()
+    }
+    pub fn iter(&self) -> impl Iterator<Item = (FileId, VfsPath)> + '_ {
+        (0..self.data.len())
+            .map(|it| FileId(it as u32))
+            .filter(move |&file_id| self.get(file_id).is_some())
+            .map(move |file_id| {
+                let path = self.interner.lookup(file_id).clone();
+                (file_id, path)
+            })
+    }
+    pub fn set_file_contents(&mut self, path: VfsPath, contents: Option<Vec<u8>>) {
+        let file_id = self.alloc_file_id(path);
+        let change_kind = match (&self.get(file_id), &contents) {
+            (None, None) => return,
+            (None, Some(_)) => ChangeKind::Create,
+            (Some(_), None) => ChangeKind::Delete,
+            (Some(old), Some(new)) if old == new => return,
+            (Some(_), Some(_)) => ChangeKind::Modify,
+        };
+
+        *self.get_mut(file_id) = contents;
+        self.changes.push(ChangedFile { file_id, change_kind })
+    }
+    pub fn has_changes(&self) -> bool {
+        !self.changes.is_empty()
+    }
+    pub fn take_changes(&mut self) -> Vec<ChangedFile> {
+        mem::take(&mut self.changes)
+    }
+    fn alloc_file_id(&mut self, path: VfsPath) -> FileId {
+        let file_id = self.interner.intern(path);
+        let idx = file_id.0 as usize;
+        let len = self.data.len().max(idx + 1);
+        self.data.resize_with(len, || None);
+        file_id
+    }
+    fn get(&self, file_id: FileId) -> &Option<Vec<u8>> {
+        &self.data[file_id.0 as usize]
+    }
+    fn get_mut(&mut self, file_id: FileId) -> &mut Option<Vec<u8>> {
+        &mut self.data[file_id.0 as usize]
+    }
+}
+
+impl fmt::Debug for Vfs {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Vfs").field("n_files", &self.data.len()).finish()
+    }
+}
diff --git a/crates/vfs/src/loader.rs b/crates/vfs/src/loader.rs
new file mode 100644
index 000000000..5a0ca68f3
--- /dev/null
+++ b/crates/vfs/src/loader.rs
@@ -0,0 +1,69 @@
+//! Object safe interface for file watching and reading.
+use std::fmt;
+
+use paths::AbsPathBuf;
+
+pub enum Entry {
+    Files(Vec<AbsPathBuf>),
+    Directory { path: AbsPathBuf, globs: Vec<String> },
+}
+
+pub struct Config {
+    pub load: Vec<Entry>,
+    pub watch: Vec<usize>,
+}
+
+pub enum Message {
+    DidSwitchConfig { n_entries: usize },
+    DidLoadAllEntries,
+    Loaded { files: Vec<(AbsPathBuf, Option<Vec<u8>>)> },
+}
+
+pub type Sender = Box<dyn Fn(Message) + Send>;
+
+pub trait Handle: fmt::Debug {
+    fn spawn(sender: Sender) -> Self
+    where
+        Self: Sized;
+    fn set_config(&mut self, config: Config);
+    fn invalidate(&mut self, path: AbsPathBuf);
+    fn load_sync(&mut self, path: &AbsPathBuf) -> Option<Vec<u8>>;
+}
+
+impl Entry {
+    pub fn rs_files_recursively(base: AbsPathBuf) -> Entry {
+        Entry::Directory { path: base, globs: globs(&["*.rs"]) }
+    }
+    pub fn local_cargo_package(base: AbsPathBuf) -> Entry {
+        Entry::Directory { path: base, globs: globs(&["*.rs", "!/target/"]) }
+    }
+    pub fn cargo_package_dependency(base: AbsPathBuf) -> Entry {
+        Entry::Directory {
+            path: base,
+            globs: globs(&["*.rs", "!/tests/", "!/examples/", "!/benches/"]),
+        }
+    }
+}
+
+fn globs(globs: &[&str]) -> Vec<String> {
+    globs.iter().map(|it| it.to_string()).collect()
+}
+
+impl fmt::Debug for Message {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Message::Loaded { files } => {
+                f.debug_struct("Loaded").field("n_files", &files.len()).finish()
+            }
+            Message::DidSwitchConfig { n_entries } => {
+                f.debug_struct("DidSwitchConfig").field("n_entries", n_entries).finish()
+            }
+            Message::DidLoadAllEntries => f.debug_struct("DidLoadAllEntries").finish(),
+        }
+    }
+}
+
+#[test]
+fn handle_is_object_safe() {
+    fn _assert(_: &dyn Handle) {}
+}
diff --git a/crates/vfs/src/path_interner.rs b/crates/vfs/src/path_interner.rs
new file mode 100644
index 000000000..4f70d61e8
--- /dev/null
+++ b/crates/vfs/src/path_interner.rs
@@ -0,0 +1,31 @@
+//! Maps paths to compact integer ids. We don't care about clearings paths which
+//! no longer exist -- the assumption is total size of paths we ever look at is
+//! not too big.
+use rustc_hash::FxHashMap;
+
+use crate::{FileId, VfsPath};
+
+#[derive(Default)]
+pub(crate) struct PathInterner {
+    map: FxHashMap<VfsPath, FileId>,
+    vec: Vec<VfsPath>,
+}
+
+impl PathInterner {
+    pub(crate) fn get(&self, path: &VfsPath) -> Option<FileId> {
+        self.map.get(path).copied()
+    }
+    pub(crate) fn intern(&mut self, path: VfsPath) -> FileId {
+        if let Some(id) = self.get(&path) {
+            return id;
+        }
+        let id = FileId(self.vec.len() as u32);
+        self.map.insert(path.clone(), id);
+        self.vec.push(path);
+        id
+    }
+
+    pub(crate) fn lookup(&self, id: FileId) -> &VfsPath {
+        &self.vec[id.0 as usize]
+    }
+}
diff --git a/crates/vfs/src/vfs_path.rs b/crates/vfs/src/vfs_path.rs
new file mode 100644
index 000000000..de5dc0bf3
--- /dev/null
+++ b/crates/vfs/src/vfs_path.rs
@@ -0,0 +1,49 @@
+//! Abstract-ish representation of paths for VFS.
+use std::fmt;
+
+use paths::{AbsPath, AbsPathBuf};
+
+/// Long-term, we want to support files which do not reside in the file-system,
+/// so we treat VfsPaths as opaque identifiers.
+#[derive(Debug, Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
+pub struct VfsPath(VfsPathRepr);
+
+impl VfsPath {
+    pub fn as_path(&self) -> Option<&AbsPath> {
+        match &self.0 {
+            VfsPathRepr::PathBuf(it) => Some(it.as_path()),
+        }
+    }
+    pub fn join(&self, path: &str) -> VfsPath {
+        match &self.0 {
+            VfsPathRepr::PathBuf(it) => {
+                let res = it.join(path).normalize();
+                VfsPath(VfsPathRepr::PathBuf(res))
+            }
+        }
+    }
+    pub fn pop(&mut self) -> bool {
+        match &mut self.0 {
+            VfsPathRepr::PathBuf(it) => it.pop(),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
+enum VfsPathRepr {
+    PathBuf(AbsPathBuf),
+}
+
+impl From<AbsPathBuf> for VfsPath {
+    fn from(v: AbsPathBuf) -> Self {
+        VfsPath(VfsPathRepr::PathBuf(v))
+    }
+}
+
+impl fmt::Display for VfsPath {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match &self.0 {
+            VfsPathRepr::PathBuf(it) => fmt::Display::fmt(&it.display(), f),
+        }
+    }
+}
diff --git a/crates/vfs/src/walkdir_loader.rs b/crates/vfs/src/walkdir_loader.rs
new file mode 100644
index 000000000..13e59e3f3
--- /dev/null
+++ b/crates/vfs/src/walkdir_loader.rs
@@ -0,0 +1,108 @@
+//! A walkdir-based implementation of `loader::Handle`, which doesn't try to
+//! watch files.
+use std::convert::TryFrom;
+
+use globset::{Glob, GlobSetBuilder};
+use paths::{AbsPath, AbsPathBuf};
+use walkdir::WalkDir;
+
+use crate::loader;
+
+#[derive(Debug)]
+pub struct WalkdirLoaderHandle {
+    // Relative order of fields below is significant.
+    sender: crossbeam_channel::Sender<Message>,
+    _thread: jod_thread::JoinHandle,
+}
+
+enum Message {
+    Config(loader::Config),
+    Invalidate(AbsPathBuf),
+}
+
+impl loader::Handle for WalkdirLoaderHandle {
+    fn spawn(sender: loader::Sender) -> WalkdirLoaderHandle {
+        let actor = WalkdirLoaderActor { sender };
+        let (sender, receiver) = crossbeam_channel::unbounded::<Message>();
+        let thread = jod_thread::spawn(move || actor.run(receiver));
+        WalkdirLoaderHandle { sender, _thread: thread }
+    }
+    fn set_config(&mut self, config: loader::Config) {
+        self.sender.send(Message::Config(config)).unwrap()
+    }
+    fn invalidate(&mut self, path: AbsPathBuf) {
+        self.sender.send(Message::Invalidate(path)).unwrap();
+    }
+    fn load_sync(&mut self, path: &AbsPathBuf) -> Option<Vec<u8>> {
+        read(path)
+    }
+}
+
+struct WalkdirLoaderActor {
+    sender: loader::Sender,
+}
+
+impl WalkdirLoaderActor {
+    fn run(mut self, receiver: crossbeam_channel::Receiver<Message>) {
+        for msg in receiver {
+            match msg {
+                Message::Config(config) => {
+                    self.send(loader::Message::DidSwitchConfig { n_entries: config.load.len() });
+                    for entry in config.load.into_iter() {
+                        let files = self.load_entry(entry);
+                        self.send(loader::Message::Loaded { files });
+                    }
+                    drop(config.watch);
+                    self.send(loader::Message::DidLoadAllEntries);
+                }
+                Message::Invalidate(path) => {
+                    let contents = read(path.as_path());
+                    let files = vec![(path, contents)];
+                    self.send(loader::Message::Loaded { files });
+                }
+            }
+        }
+    }
+    fn load_entry(&mut self, entry: loader::Entry) -> Vec<(AbsPathBuf, Option<Vec<u8>>)> {
+        match entry {
+            loader::Entry::Files(files) => files
+                .into_iter()
+                .map(|file| {
+                    let contents = read(file.as_path());
+                    (file, contents)
+                })
+                .collect::<Vec<_>>(),
+            loader::Entry::Directory { path, globs } => {
+                let globset = {
+                    let mut builder = GlobSetBuilder::new();
+                    for glob in &globs {
+                        builder.add(Glob::new(glob).unwrap());
+                    }
+                    builder.build().unwrap()
+                };
+
+                let files = WalkDir::new(path)
+                    .into_iter()
+                    .filter_map(|it| it.ok())
+                    .filter(|it| it.file_type().is_file())
+                    .map(|it| it.into_path())
+                    .map(|it| AbsPathBuf::try_from(it).unwrap())
+                    .filter(|it| globset.is_match(&it));
+
+                files
+                    .map(|file| {
+                        let contents = read(file.as_path());
+                        (file, contents)
+                    })
+                    .collect()
+            }
+        }
+    }
+    fn send(&mut self, msg: loader::Message) {
+        (self.sender)(msg)
+    }
+}
+
+fn read(path: &AbsPath) -> Option<Vec<u8>> {
+    std::fs::read(path).ok()
+}
diff --git a/docs/dev/README.md b/docs/dev/README.md
index 1ce8666e3..1b63d8223 100644
--- a/docs/dev/README.md
+++ b/docs/dev/README.md
@@ -1,6 +1,6 @@
 # Contributing Quick Start
 
-Rust Analyzer is just a usual rust project, which is organized as a Cargo
+Rust Analyzer is an ordinary Rust project, which is organized as a Cargo
 workspace, builds on stable and doesn't depend on C libraries. So, just
 
 ```
@@ -65,7 +65,7 @@ directory).
 
 # Launching rust-analyzer
 
-Debugging language server can be tricky: LSP is rather chatty, so driving it
+Debugging the language server can be tricky: LSP is rather chatty, so driving it
 from the command line is not really feasible, driving it via VS Code requires
 interacting with two processes.
 
@@ -73,14 +73,14 @@ For this reason, the best way to see how rust-analyzer works is to find a
 relevant test and execute it (VS Code includes an action for running a single
 test).
 
-However, launching a VS Code instance with locally build language server is
+However, launching a VS Code instance with a locally built language server is
 possible. There's **"Run Extension (Debug Build)"** launch configuration for this.
 
 In general, I use one of the following workflows for fixing bugs and
 implementing features.
 
 If the problem concerns only internal parts of rust-analyzer (i.e. I don't need
-to touch `rust-analyzer` crate or TypeScript code), there is a unit-test for it.
+to touch the `rust-analyzer` crate or TypeScript code), there is a unit-test for it.
 So, I use **Rust Analyzer: Run** action in VS Code to run this single test, and
 then just do printf-driven development/debugging. As a sanity check after I'm
 done, I use `cargo xtask install --server` and **Reload Window** action in VS
@@ -88,8 +88,8 @@ Code to sanity check that the thing works as I expect.
 
 If the problem concerns only the VS Code extension, I use **Run Installed Extension**
 launch configuration from `launch.json`. Notably, this uses the usual
-`rust-analyzer` binary from `PATH`. For this it is important to have the following
-in `setting.json` file:
+`rust-analyzer` binary from `PATH`. For this, it is important to have the following
+in your `settings.json` file:
 ```json
 {
     "rust-analyzer.serverPath": "rust-analyzer"
@@ -107,7 +107,7 @@ things up, sometimes I open a temporary hello-world project which has
 `"rust-analyzer.withSysroot": false` in `.code/settings.json`. This flag causes
 rust-analyzer to skip loading the sysroot, which greatly reduces the amount of
 things rust-analyzer needs to do, and makes printf's more useful. Note that you
-should only use `eprint!` family of macros for debugging: stdout is used for LSP
+should only use the `eprint!` family of macros for debugging: stdout is used for LSP
 communication, and `print!` would break it.
 
 If I need to fix something simultaneously in the server and in the client, I
@@ -119,20 +119,20 @@ performance optimizations, or for bug minimization.
 
 # Code Style & Review Process
 
-Our approach to "clean code" is two fold:
+Our approach to "clean code" is two-fold:
 
 * We generally don't block PRs on style changes.
 * At the same time, all code in rust-analyzer is constantly refactored.
 
-It is explicitly OK for reviewer to flag only some nits in the PR, and than send a follow up cleanup PR for things which are easier to explain by example, cc-ing the original author.
-Sending small cleanup PRs (like rename a single local variable) is encouraged.
+It is explicitly OK for a reviewer to flag only some nits in the PR, and then send a follow-up cleanup PR for things which are easier to explain by example, cc-ing the original author.
+Sending small cleanup PRs (like renaming a single local variable) is encouraged.
 
 ## Scale of Changes
 
 Everyone knows that it's better to send small & focused pull requests.
 The problem is, sometimes you *have* to, eg, rewrite the whole compiler, and that just doesn't fit into a set of isolated PRs.
 
-The main thing too keep an eye on is the boundaries between various components.
+The main things to keep an eye on are the boundaries between various components.
 There are three kinds of changes:
 
 1. Internals of a single component are changed.
@@ -144,20 +144,20 @@ There are three kinds of changes:
    A good example here would be expansion of assist API, for example, to implement lazy assists or assists groups.
 
 3. A new dependency between components is introduced.
-   Specifically, you add a `pub use` reexport from another crate or you add a new line to `[dependencies]` section of `Cargo.toml`.
+   Specifically, you add a `pub use` reexport from another crate or you add a new line to the `[dependencies]` section of `Cargo.toml`.
    A good example here would be adding reference search capability to the assists crates.
 
 For the first group, the change is generally merged as long as:
 
 * it works for the happy case,
 * it has tests,
-* it doesn't panic for unhappy case.
+* it doesn't panic for the unhappy case.
 
 For the second group, the change would be subjected to quite a bit of scrutiny and iteration.
 The new API needs to be right (or at least easy to change later).
 The actual implementation doesn't matter that much.
 It's very important to minimize the amount of changed lines of code for changes of the second kind.
-Often, you start doing change of the first kind, only to realise that you need to elevate to a change of the second kind.
+Often, you start doing a change of the first kind, only to realise that you need to elevate to a change of the second kind.
 In this case, we'll probably ask you to split API changes into a separate PR.
 
 Changes of the third group should be pretty rare, so we don't specify any specific process for them.
@@ -236,6 +236,13 @@ struct Foo {
 }
 ```
 
+## Variable Naming
+
+We generally use boring and long names for local variables ([yay code completion](https://github.com/rust-analyzer/rust-analyzer/pull/4162#discussion_r417130973)).
+The default name is a lowercased name of the type: `global_state: GlobalState`.
+Avoid ad-hoc acronyms and contractions, but use the ones that exist consistently (`db`, `ctx`, `acc`).
+The default name for "result of the function" local variable is `res`.
+
 ## Preconditions
 
 Function preconditions should generally be expressed in types and provided by the caller (rather than checked by callee):
@@ -258,8 +265,8 @@ fn frobnicate(walrus: Option<Walrus>) {
 
 ## Premature Pessimization
 
-While we don't specifically optimize code yet, avoid writing the code which is slower than it needs to be.
-Don't allocate a `Vec` were an iterator would do, don't allocate strings needlessly.
+While we don't specifically optimize code yet, avoid writing code which is slower than it needs to be.
+Don't allocate a `Vec` where an iterator would do, don't allocate strings needlessly.
 
 ```rust
 // Good
@@ -298,7 +305,7 @@ always obvious from the low-level code.
 ## Incomplete syntax trees
 
 Syntax trees are by design incomplete and do not enforce well-formedness.
-If ast method returns an `Option`, it *can* be `None` at runtime, even if this is forbidden by the grammar.
+If an AST method returns an `Option`, it *can* be `None` at runtime, even if this is forbidden by the grammar.
 
 ## LSP independence
 
@@ -326,7 +333,7 @@ The results are 100% Rust specific though.
 
 ## Parser Tests
 
-Test for parser (`ra_parser`) live in `ra_syntax` crate (see `test_data` direcotory).
+Tests for the parser (`ra_parser`) live in the `ra_syntax` crate (see `test_data` directory).
 There are two kinds of tests:
 
 * Manually written test cases in `parser/ok` and `parser/err`
@@ -335,6 +342,12 @@ 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:
+
+```bash
+env UPDATE_EXPECTATIONS=1 cargo qt
+```
+
 # Logging
 
 Logging is done by both rust-analyzer and VS Code, so it might be tricky to
@@ -361,7 +374,7 @@ To log all communication between the server and the client, there are two choice
   [@DJMcNab](https://github.com/DJMcNab) for setting this awesome infra up!
 
 
-There's also two VS Code commands which might be of interest:
+There are also two VS Code commands which might be of interest:
 
 * `Rust Analyzer: Status` shows some memory-usage statistics. To take full
   advantage of it, you need to compile rust-analyzer with jemalloc support:
diff --git a/editors/code/package.json b/editors/code/package.json
index e2027970d..3acc375f6 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -525,6 +525,24 @@
                     "markdownDescription": "Internal config for debugging, disables loading of sysroot crates",
                     "type": "boolean",
                     "default": true
+                },
+                "rust-analyzer.diagnostics.warningsAsInfo": {
+                    "type": "array",
+                    "uniqueItems": true,
+                    "items": {
+                        "type": "string"
+                    },
+                    "description": "List of warnings that should be displayed with info severity.\nThe warnings will be indicated by a blue squiggly underline in code and a blue icon in the problems panel.",
+                    "default": []
+                },
+                "rust-analyzer.diagnostics.warningsAsHint": {
+                    "type": "array",
+                    "uniqueItems": true,
+                    "items": {
+                        "type": "string"
+                    },
+                    "description": "List of warnings warnings that should be displayed with hint severity.\nThe warnings will be indicated by faded text or three dots in code and will not show up in te problems panel.",
+                    "default": []
                 }
             }
         },