69 files changed, 3240 insertions, 1806 deletions
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 first_node_text = |pat: &Pat| pat.syntax().first_child().map(|node| node.text());
-    let var_head = var.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() {
+            // Now that we've brought the name into scope, re-qualify all paths that could be
-                // Here we are assuming the assist will provide a correct use statement
+            // affected (that is, all paths inside the node we added the `use` to).
-                // so we can delete the path qualifier
+            let mut rewriter = SyntaxRewriter::default();
-                builder.delete(TextRange::new(
+            let syntax = container.either(|l| l.syntax().clone(), |r| r.syntax().clone());
-                    path.syntax().text_range().start(),
+            shorten_paths(&mut rewriter, syntax, path);
-                    last.syntax().text_range().start(),
+            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| {
+    let container = find_insert_use_container(position, ctx);
-        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())
-    });
    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/find_path.rs b/crates/ra_hir_def/src/find_path.rs
index a7f59e028..06701a830 100644
--- a/crates/ra_hir_def/src/find_path.rs
+++ b/crates/ra_hir_def/src/find_path.rs
@@ -159,10 +159,16 @@ fn find_path_inner(
        let crate_graph = db.crate_graph();
        let extern_paths = crate_graph[from.krate].dependencies.iter().filter_map(|dep| {
            let import_map = db.import_map(dep.crate_id);
-            import_map.path_of(item).map(|modpath| {
+            import_map.import_info_for(item).and_then(|info| {
-                let mut modpath = modpath.clone();
+                // Determine best path for containing module and append last segment from `info`.
-                modpath.segments.insert(0, dep.as_name());
+                let mut path = find_path_inner(
-                modpath
+                    db,
+                    ItemInNs::Types(ModuleDefId::ModuleId(info.container)),
+                    from,
+                    best_path_len - 1,
+                )?;
+                path.segments.push(info.path.segments.last().unwrap().clone());
+                Some(path)
            })
        });
@@ -299,8 +305,8 @@ mod tests {
    /// `code` needs to contain a cursor marker; checks that `find_path` for the
    /// item the `path` refers to returns that same path when called from the
    /// module the cursor is in.
-    fn check_found_path(code: &str, path: &str) {
+    fn check_found_path(ra_fixture: &str, path: &str) {
-        let (db, pos) = TestDB::with_position(code);
+        let (db, pos) = TestDB::with_position(ra_fixture);
        let module = db.module_for_file(pos.file_id);
        let parsed_path_file = ra_syntax::SourceFile::parse(&format!("use {};", path));
        let ast_path = parsed_path_file
@@ -420,7 +426,6 @@ mod tests {
    #[test]
    fn different_crate_renamed() {
-        // Even if a local path exists, if the item is defined externally, prefer an external path.
        let code = r#"
            //- /main.rs crate:main deps:std
            extern crate std as std_renamed;
@@ -428,7 +433,45 @@ mod tests {
            //- /std.rs crate:std
            pub struct S;
        "#;
-        check_found_path(code, "std::S");
+        check_found_path(code, "std_renamed::S");
+    }
+    #[test]
+    fn partially_imported() {
+        // Tests that short paths are used even for external items, when parts of the path are
+        // already in scope.
+        check_found_path(
+            r#"
+            //- /main.rs crate:main deps:ra_syntax
+            use ra_syntax::ast;
+            <|>
+            //- /lib.rs crate:ra_syntax
+            pub mod ast {
+                pub enum ModuleItem {
+                    A, B, C,
+                }
+            }
+        "#,
+            "ast::ModuleItem",
+        );
+        check_found_path(
+            r#"
+            //- /main.rs crate:main deps:ra_syntax
+            <|>
+            //- /lib.rs crate:ra_syntax
+            pub mod ast {
+                pub enum ModuleItem {
+                    A, B, C,
+                }
+            }
+        "#,
+            "ra_syntax::ast::ModuleItem",
+        );
    }
    #[test]
diff --git a/crates/ra_hir_def/src/import_map.rs b/crates/ra_hir_def/src/import_map.rs
index 36b4fdd81..68e20d06b 100644
--- a/crates/ra_hir_def/src/import_map.rs
+++ b/crates/ra_hir_def/src/import_map.rs
@@ -17,6 +17,15 @@ use crate::{
 type FxIndexMap<K, V> = IndexMap<K, V, BuildHasherDefault<FxHasher>>;
+/// Item import details stored in the `ImportMap`.
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct ImportInfo {
+    /// A path that can be used to import the item, relative to the crate's root.
+    pub path: ModPath,
+    /// The module containing this item.
+    pub container: ModuleId,
+}
 /// A map from publicly exported items to the path needed to import/name them from a downstream
 /// crate.
 ///
@@ -26,7 +35,7 @@ type FxIndexMap<K, V> = IndexMap<K, V, BuildHasherDefault<FxHasher>>;
 /// Note that all paths are relative to the containing crate's root, so the crate name still needs
 /// to be prepended to the `ModPath` before the path is valid.
 pub struct ImportMap {
-    map: FxIndexMap<ItemInNs, ModPath>,
+    map: FxIndexMap<ItemInNs, ImportInfo>,
    /// List of keys stored in `map`, sorted lexicographically by their `ModPath`. Indexed by the
    /// values returned by running `fst`.
@@ -78,12 +87,12 @@ impl ImportMap {
                    let path = mk_path();
                    match import_map.entry(item) {
                        Entry::Vacant(entry) => {
-                            entry.insert(path);
+                            entry.insert(ImportInfo { path, container: module });
                        }
                        Entry::Occupied(mut entry) => {
                            // If the new path is shorter, prefer that one.
-                            if path.len() < entry.get().len() {
+                            if path.len() < entry.get().path.len() {
-                                *entry.get_mut() = path;
+                                *entry.get_mut() = ImportInfo { path, container: module };
                            } else {
                                continue;
                            }
@@ -119,7 +128,7 @@ impl ImportMap {
            let start = last_batch_start;
            last_batch_start = idx + 1;
-            let key = fst_path(&importables[start].1);
+            let key = fst_path(&importables[start].1.path);
            builder.insert(key, start as u64).unwrap();
        }
@@ -132,6 +141,10 @@ impl ImportMap {
    /// Returns the `ModPath` needed to import/mention `item`, relative to this crate's root.
    pub fn path_of(&self, item: ItemInNs) -> Option<&ModPath> {
+        Some(&self.map.get(&item)?.path)
+    }
+    pub fn import_info_for(&self, item: ItemInNs) -> Option<&ImportInfo> {
        self.map.get(&item)
    }
 }
@@ -150,13 +163,13 @@ impl fmt::Debug for ImportMap {
        let mut importable_paths: Vec<_> = self
            .map
            .iter()
-            .map(|(item, modpath)| {
+            .map(|(item, info)| {
                let ns = match item {
                    ItemInNs::Types(_) => "t",
                    ItemInNs::Values(_) => "v",
                    ItemInNs::Macros(_) => "m",
                };
-                format!("- {} ({})", modpath, ns)
+                format!("- {} ({})", info.path, ns)
            })
            .collect();
@@ -171,9 +184,9 @@ fn fst_path(path: &ModPath) -> String {
    s
 }
-fn cmp((_, lhs): &(&ItemInNs, &ModPath), (_, rhs): &(&ItemInNs, &ModPath)) -> Ordering {
+fn cmp((_, lhs): &(&ItemInNs, &ImportInfo), (_, rhs): &(&ItemInNs, &ImportInfo)) -> Ordering {
-    let lhs_str = fst_path(lhs);
+    let lhs_str = fst_path(&lhs.path);
-    let rhs_str = fst_path(rhs);
+    let rhs_str = fst_path(&rhs.path);
    lhs_str.cmp(&rhs_str)
 }
@@ -243,7 +256,7 @@ pub fn search_dependencies<'a>(
            let importables = &import_map.importables[indexed_value.value as usize..];
            // Path shared by the importable items in this group.
-            let path = &import_map.map[&importables[0]];
+            let path = &import_map.map[&importables[0]].path;
            if query.anchor_end {
                // Last segment must match query.
@@ -256,14 +269,14 @@ pub fn search_dependencies<'a>(
            // Add the items from this `ModPath` group. Those are all subsequent items in
            // `importables` whose paths match `path`.
            let iter = importables.iter().copied().take_while(|item| {
-                let item_path = &import_map.map[item];
+                let item_path = &import_map.map[item].path;
                fst_path(item_path) == fst_path(path)
            });
            if query.case_sensitive {
                // FIXME: This does not do a subsequence match.
                res.extend(iter.filter(|item| {
-                    let item_path = &import_map.map[item];
+                    let item_path = &import_map.map[item].path;
                    item_path.to_string().contains(&query.query)
                }));
            } else {
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!("{}.rs", name)).to_string());
-                candidate_files.push(self.path.join(&format!("{}/mod.rs", name)));
+                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]
+//! - (a) the patterns cover every possible constructor for the type (exhaustiveness).
-//! (b) each pattern is necessary [usefulness]
+//! - (b) each pattern is necessary (usefulness).
 //!
-//! The algorithm implemented here is a modified version of the one described in:
+//! The algorithm implemented here is a modified version of the one described in
-//! http://moscova.inria.fr/~maranget/papers/warn/index.html
+//! <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
+//! 1. We can pop a given constructor off the top of a stack. This operation is called
-//!        pop the tuple constructor, we are left with `[Some(true), _]`, and if we then pop the
+//!    `specialize`, and is denoted `S(c, p)` where `c` is a constructor (like `Some` or
-//!        `Some` constructor we get `[true, _]`. If we had popped `None` instead, we would get
+//!    `None`) and `p` a pattern-stack.
-//!        nothing back.
+//!    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`
+//!          r_1, .., r_a, p_2, .., p_n
-//!        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))
 //!
-//!     2. We can pop a wildcard off the top of the stack. This is called `D(p)`, where `p` is
+//!    * 1.2. `p_1 = c'(r_1, .., r_a')` where `c ≠ c'`. We discard the current stack and return
-//!        a pattern-stack.
+//!           nothing.
-//!        This is used when we know there are missing constructor cases, but there might be
+//!    * 1.3. `p_1 = _`. We push onto the stack as many wildcards as the constructor `c` has
-//!        existing wildcard patterns, so to check the usefulness of the matrix, we have to check
+//!           arguments (its arity), and return the resulting stack:
-//!        all its *other* components.
 //!
-//!        It is computed as follows. We look at the pattern `p_1` on top of the stack,
+//!          _, .., _, p_2, .., p_n
-//!        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
+//!    * 1.4. `p_1 = r_1 | r_2`. We expand the OR-pattern and then recurse on each resulting stack:
-//!     exhaustive integer matching rules, so they're written here for posterity.
+//!
+//!          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)
+//! 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`),
+//! - If `P` already contains an empty pattern (i.e., if the number of patterns `m > 0`), then
-//!       then `U(P, p)` is false.
+//!   `U(P, p)` is false.
-//!     - Otherwise, `P` must be empty, so `U(P, p)` is true.
+//! - 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
+//!   ```text
-//!                  [which may then be expanded into further columns later])
+//!   U(P, p) := U(S(c, P), S(c, p))
-//!     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`.
 //!
-//!           For example, if `P` is:
+//!   This special case is handled in `is_useful_specialized`.
-//!           [
-//!               [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])`.
 //!
-//!         - If `p_1 == _`, then we look at the list of constructors that appear in the first
+//!   For example, if `P` is:
-//!               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:
+//!   ```text
-//!               [
+//!   [
-//!                   [_, true, _],
+//!       [Some(true), _],
-//!                   [None, false, 1],
+//!       [None, 0],
-//!               ]
+//!   ]
-//!               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
+//!   and `p` is `[Some(false), 0]`, then we don't care about row 2 since we know `p` only
-//!               case we must check whether the wildcard pattern covers any unmatched value. For
+//!   matches values that row 2 doesn't. For row 1 however, we need to dig into the
-//!               that, we can think of the `_` pattern as a big OR-pattern that covers all
+//!   arguments of `Some` to know whether some new value is covered. So we compute
-//!               possible constructors. For `Option`, that would mean `_ = None | Some(_)` for
+//!   `U([[true, _]], [false, 0])`.
-//!               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:
+//! - If `p_1 == _`, then we look at the list of constructors that appear in the first component of
-//!               [
+//!   the rows of `P`:
-//!                   [Some(true), _],
+//!     - If there are some constructors that aren't present, then we might think that the
-//!                   [None, false],
+//!       wildcard `_` is useful, since it covers those constructors that weren't covered
-//!               ]
+//!       before.
-//!               and `p` is [_, false], both `None` and `Some` constructors appear in the first
+//!       That's almost correct, but only works if there were no wildcards in those first
-//!               components of `P`. We will therefore try popping both constructors in turn: we
+//!       components. So we need to check that `p` is useful with respect to the rows that
-//!               compute U([[true, _]], [_, false]) for the `Some` constructor, and U([[false]],
+//!       start with a wildcard, if there are any. This is where `D` comes in:
-//!               [false]) for the `None` constructor. The first case returns true, so we know that
+//!       `U(P, p) := U(D(P), D(p))`
-//!               `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:
+//!       For example, if `P` is:
-//!           `U(P, p) := U(P, (r_1, p_2, .., p_n))
+//!       ```text
-//!                    || U(P, (r_2, p_2, .., p_n))`
+//!       [
+//!           [_, 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 {
+    pub(super) fn check_diagnostic_message(ra_fixture: &str) -> String {
-        TestDB::with_single_file(content).0.diagnostic::<MissingMatchArms>().0
+        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"
+        check_diagnostic(
-             enum Either {
+            r"
-                 A { foo: bool, bar: bool },
+            enum Either {
-                 B,
+                A { foo: bool, bar: bool },
-             }
+                B,
-             fn test_fn() {
+            }
-                 match Either::B {
+            fn test_fn() {
-                     Either::A { foo: true, .. } => (),
+                match Either::B {
-                     Either::B => (),
+                    Either::A { foo: true, .. } => (),
-                 }
+                    Either::B => (),
-             }
+                }
-         ";
+            }
+        ",
-        check_diagnostic(content);
+        );
    }
    #[test]
    fn enum_record_ellipsis_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
-             enum Either {
+            r"
-                 A { foo: bool, bar: bool },
+            enum Either {
-                 B,
+                A { foo: bool, bar: bool },
-             }
+                B,
-             fn test_fn() {
+            }
-                 let a = Either::A { foo: true };
+            fn test_fn() {
-                 match a {
+                let a = Either::A { foo: true };
-                     Either::A { foo: true, .. } => (),
+                match a {
-                     Either::A { foo: false, .. } => (),
+                    Either::A { foo: true, .. } => (),
-                     Either::B => (),
+                    Either::A { foo: false, .. } => (),
-                 }
+                    Either::B => (),
-             }
+                }
-         ";
+            }
+        ",
-        check_no_diagnostic(content);
+        );
    }
    #[test]
    fn enum_record_ellipsis_all_fields_missing_arm() {
-        let content = r"
+        check_diagnostic(
-             enum Either {
+            r"
-                 A { foo: bool, bar: bool },
+            enum Either {
-                 B,
+                A { foo: bool, bar: bool },
-             }
+                B,
-             fn test_fn() {
+            }
-                 let a = Either::B;
+            fn test_fn() {
-                 match a {
+                let a = Either::B;
-                     Either::A { .. } => (),
+                match a {
-                 }
+                    Either::A { .. } => (),
-             }
+                }
-         ";
+            }
+        ",
-        check_diagnostic(content);
+        );
    }
    #[test]
    fn enum_record_ellipsis_all_fields_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
-             enum Either {
+            r"
-                 A { foo: bool, bar: bool },
+            enum Either {
-                 B,
+                A { foo: bool, bar: bool },
-             }
+                B,
-             fn test_fn() {
+            }
-                 let a = Either::B;
+            fn test_fn() {
-                 match a {
+                let a = Either::B;
-                     Either::A { .. } => (),
+                match a {
-                     Either::B => (),
+                    Either::A { .. } => (),
-                 }
+                    Either::B => (),
-             }
+                }
-         ";
+            }
+        ",
-        check_no_diagnostic(content);
+        );
    }
    #[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.rs b/crates/ra_ide/src/completion.rs
index a721e23c6..e1fcf379d 100644
--- a/crates/ra_ide/src/completion.rs
+++ b/crates/ra_ide/src/completion.rs
@@ -15,6 +15,7 @@ mod complete_unqualified_path;
 mod complete_postfix;
 mod complete_macro_in_item_position;
 mod complete_trait_impl;
+mod patterns;
 #[cfg(test)]
 mod test_utils;
diff --git a/crates/ra_ide/src/completion/complete_keyword.rs b/crates/ra_ide/src/completion/complete_keyword.rs
index fd95bc410..b2f621a11 100644
--- a/crates/ra_ide/src/completion/complete_keyword.rs
+++ b/crates/ra_ide/src/completion/complete_keyword.rs
@@ -1,11 +1,6 @@
 //! FIXME: write short doc here
-use ra_syntax::{
+use ra_syntax::ast;
-    ast::{self, LoopBodyOwner},
-    match_ast, AstNode,
-    SyntaxKind::*,
-    SyntaxToken,
-};
 use crate::completion::{
    CompletionContext, CompletionItem, CompletionItemKind, CompletionKind, Completions,
@@ -41,68 +36,122 @@ pub(super) fn complete_use_tree_keyword(acc: &mut Completions, ctx: &CompletionC
    }
 }
-fn keyword(ctx: &CompletionContext, kw: &str, snippet: &str) -> CompletionItem {
+pub(super) fn complete_expr_keyword(acc: &mut Completions, ctx: &CompletionContext) {
-    let res = CompletionItem::new(CompletionKind::Keyword, ctx.source_range(), kw)
+    let has_trait_or_impl_parent = ctx.has_impl_parent || ctx.has_trait_parent;
-        .kind(CompletionItemKind::Keyword);
+    if ctx.trait_as_prev_sibling || ctx.impl_as_prev_sibling {
+        add_keyword(ctx, acc, "where", "where ");
-    match ctx.config.snippet_cap {
+        return;
-        Some(cap) => res.insert_snippet(cap, snippet),
-        _ => res.insert_text(if snippet.contains('$') { kw } else { snippet }),
    }
-    .build()
+    if ctx.unsafe_is_prev {
-}
+        if ctx.has_item_list_or_source_file_parent || ctx.block_expr_parent {
+            add_keyword(ctx, acc, "fn", "fn $0() {}")
+        }
+        if (ctx.has_item_list_or_source_file_parent && !has_trait_or_impl_parent)
+            || ctx.block_expr_parent
+        {
+            add_keyword(ctx, acc, "trait", "trait $0 {}");
+            add_keyword(ctx, acc, "impl", "impl $0 {}");
+        }
-pub(super) fn complete_expr_keyword(acc: &mut Completions, ctx: &CompletionContext) {
-    if !ctx.is_trivial_path {
        return;
    }
+    if ctx.has_item_list_or_source_file_parent || ctx.block_expr_parent {
+        add_keyword(ctx, acc, "fn", "fn $0() {}");
+    }
+    if (ctx.has_item_list_or_source_file_parent && !has_trait_or_impl_parent)
+        || ctx.block_expr_parent
+    {
+        add_keyword(ctx, acc, "use", "use ");
+        add_keyword(ctx, acc, "impl", "impl $0 {}");
+        add_keyword(ctx, acc, "trait", "trait $0 {}");
+    }
-    let fn_def = match &ctx.function_syntax {
+    if ctx.has_item_list_or_source_file_parent && !has_trait_or_impl_parent {
-        Some(it) => it,
+        add_keyword(ctx, acc, "enum", "enum $0 {}");
-        None => return,
+        add_keyword(ctx, acc, "struct", "struct $0 {}");
-    };
+        add_keyword(ctx, acc, "union", "union $0 {}");
-    acc.add(keyword(ctx, "if", "if $0 {}"));
+    }
-    acc.add(keyword(ctx, "match", "match $0 {}"));
-    acc.add(keyword(ctx, "while", "while $0 {}"));
-    acc.add(keyword(ctx, "loop", "loop {$0}"));
+    if ctx.block_expr_parent || ctx.is_match_arm {
+        add_keyword(ctx, acc, "match", "match $0 {}");
+        add_keyword(ctx, acc, "loop", "loop {$0}");
+    }
+    if ctx.block_expr_parent {
+        add_keyword(ctx, acc, "while", "while $0 {}");
+    }
+    if ctx.if_is_prev || ctx.block_expr_parent {
+        add_keyword(ctx, acc, "let", "let ");
+    }
+    if ctx.if_is_prev || ctx.block_expr_parent || ctx.is_match_arm {
+        add_keyword(ctx, acc, "if", "if ");
+        add_keyword(ctx, acc, "if let", "if let ");
+    }
    if ctx.after_if {
-        acc.add(keyword(ctx, "else", "else {$0}"));
+        add_keyword(ctx, acc, "else", "else {$0}");
-        acc.add(keyword(ctx, "else if", "else if $0 {}"));
+        add_keyword(ctx, acc, "else if", "else if $0 {}");
+    }
+    if (ctx.has_item_list_or_source_file_parent && !has_trait_or_impl_parent)
+        || ctx.block_expr_parent
+    {
+        add_keyword(ctx, acc, "mod", "mod $0 {}");
+    }
+    if ctx.bind_pat_parent || ctx.ref_pat_parent {
+        add_keyword(ctx, acc, "mut", "mut ");
    }
-    if is_in_loop_body(&ctx.token) {
+    if ctx.has_item_list_or_source_file_parent || ctx.block_expr_parent {
+        add_keyword(ctx, acc, "const", "const ");
+        add_keyword(ctx, acc, "type", "type ");
+    }
+    if (ctx.has_item_list_or_source_file_parent && !has_trait_or_impl_parent)
+        || ctx.block_expr_parent
+    {
+        add_keyword(ctx, acc, "static", "static ");
+    };
+    if (ctx.has_item_list_or_source_file_parent && !has_trait_or_impl_parent)
+        || ctx.block_expr_parent
+    {
+        add_keyword(ctx, acc, "extern", "extern ");
+    }
+    if ctx.has_item_list_or_source_file_parent || ctx.block_expr_parent || ctx.is_match_arm {
+        add_keyword(ctx, acc, "unsafe", "unsafe ");
+    }
+    if ctx.in_loop_body {
        if ctx.can_be_stmt {
-            acc.add(keyword(ctx, "continue", "continue;"));
+            add_keyword(ctx, acc, "continue", "continue;");
-            acc.add(keyword(ctx, "break", "break;"));
+            add_keyword(ctx, acc, "break", "break;");
        } else {
-            acc.add(keyword(ctx, "continue", "continue"));
+            add_keyword(ctx, acc, "continue", "continue");
-            acc.add(keyword(ctx, "break", "break"));
+            add_keyword(ctx, acc, "break", "break");
        }
    }
+    if ctx.has_item_list_or_source_file_parent && !ctx.has_trait_parent {
+        add_keyword(ctx, acc, "pub", "pub ")
+    }
+    if !ctx.is_trivial_path {
+        return;
+    }
+    let fn_def = match &ctx.function_syntax {
+        Some(it) => it,
+        None => return,
+    };
    acc.add_all(complete_return(ctx, &fn_def, ctx.can_be_stmt));
 }
-fn is_in_loop_body(leaf: &SyntaxToken) -> bool {
+fn keyword(ctx: &CompletionContext, kw: &str, snippet: &str) -> CompletionItem {
-    // FIXME move this to CompletionContext and make it handle macros
+    let res = CompletionItem::new(CompletionKind::Keyword, ctx.source_range(), kw)
-    for node in leaf.parent().ancestors() {
+        .kind(CompletionItemKind::Keyword);
-        if node.kind() == FN_DEF || node.kind() == LAMBDA_EXPR {
-            break;
+    match ctx.config.snippet_cap {
-        }
+        Some(cap) => res.insert_snippet(cap, snippet),
-        let loop_body = match_ast! {
+        _ => res.insert_text(if snippet.contains('$') { kw } else { snippet }),
-            match node {
-                ast::ForExpr(it) => it.loop_body(),
-                ast::WhileExpr(it) => it.loop_body(),
-                ast::LoopExpr(it) => it.loop_body(),
-                _ => None,
-            }
-        };
-        if let Some(body) = loop_body {
-            if body.syntax().text_range().contains_range(leaf.text_range()) {
-                return true;
-            }
-        }
    }
-    false
+    .build()
+}
+fn add_keyword(ctx: &CompletionContext, acc: &mut Completions, kw: &str, snippet: &str) {
+    acc.add(keyword(ctx, kw, snippet));
 }
 fn complete_return(
@@ -121,327 +170,156 @@ fn complete_return(
 #[cfg(test)]
 mod tests {
-    use crate::completion::{test_utils::do_completion, CompletionItem, CompletionKind};
+    use crate::completion::{test_utils::completion_list, CompletionKind};
-    use insta::assert_debug_snapshot;
+    use insta::assert_snapshot;
-    fn do_keyword_completion(code: &str) -> Vec<CompletionItem> {
+    fn get_keyword_completions(code: &str) -> String {
-        do_completion(code, CompletionKind::Keyword)
+        completion_list(code, CompletionKind::Keyword)
    }
    #[test]
-    fn completes_keywords_in_use_stmt() {
+    fn test_keywords_in_use_stmt() {
-        assert_debug_snapshot!(
+        assert_snapshot!(
-            do_keyword_completion(
+            get_keyword_completions(r"use <|>"),
-                r"
-                use <|>
-                ",
-            ),
            @r###"
-        [
+            kw crate
-            CompletionItem {
+            kw self
-                label: "crate",
+            kw super
-                source_range: 21..21,
-                delete: 21..21,
-                insert: "crate::",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "self",
-                source_range: 21..21,
-                delete: 21..21,
-                insert: "self",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "super",
-                source_range: 21..21,
-                delete: 21..21,
-                insert: "super::",
-                kind: Keyword,
-            },
-        ]
        "###
        );
-        assert_debug_snapshot!(
+        assert_snapshot!(
-            do_keyword_completion(
+            get_keyword_completions(r"use a::<|>"),
-                r"
-                use a::<|>
-                ",
-            ),
            @r###"
-        [
+            kw self
-            CompletionItem {
+            kw super
-                label: "self",
-                source_range: 24..24,
-                delete: 24..24,
-                insert: "self",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "super",
-                source_range: 24..24,
-                delete: 24..24,
-                insert: "super::",
-                kind: Keyword,
-            },
-        ]
        "###
        );
-        assert_debug_snapshot!(
+        assert_snapshot!(
-            do_keyword_completion(
+            get_keyword_completions(r"use a::{b, <|>}"),
-                r"
-                use a::{b, <|>}
-                ",
-            ),
            @r###"
-        [
+            kw self
-            CompletionItem {
+            kw super
-                label: "self",
-                source_range: 28..28,
-                delete: 28..28,
-                insert: "self",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "super",
-                source_range: 28..28,
-                delete: 28..28,
-                insert: "super::",
-                kind: Keyword,
-            },
-        ]
        "###
        );
    }
    #[test]
-    fn completes_various_keywords_in_function() {
+    fn test_keywords_at_source_file_level() {
-        assert_debug_snapshot!(
+        assert_snapshot!(
-            do_keyword_completion(
+            get_keyword_completions(r"m<|>"),
-                r"
-                fn quux() {
-                    <|>
-                }
-                ",
-            ),
            @r###"
-        [
+            kw const
-            CompletionItem {
+            kw enum
-                label: "if",
+            kw extern
-                source_range: 49..49,
+            kw fn
-                delete: 49..49,
+            kw impl
-                insert: "if $0 {}",
+            kw mod
-                kind: Keyword,
+            kw pub
-            },
+            kw static
-            CompletionItem {
+            kw struct
-                label: "loop",
+            kw trait
-                source_range: 49..49,
+            kw type
-                delete: 49..49,
+            kw union
-                insert: "loop {$0}",
+            kw unsafe
-                kind: Keyword,
+            kw use
-            },
-            CompletionItem {
-                label: "match",
-                source_range: 49..49,
-                delete: 49..49,
-                insert: "match $0 {}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "return",
-                source_range: 49..49,
-                delete: 49..49,
-                insert: "return;",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "while",
-                source_range: 49..49,
-                delete: 49..49,
-                insert: "while $0 {}",
-                kind: Keyword,
-            },
-        ]
        "###
        );
    }
    #[test]
-    fn completes_else_after_if() {
+    fn test_keywords_in_function() {
-        assert_debug_snapshot!(
+        assert_snapshot!(
-            do_keyword_completion(
+            get_keyword_completions(r"fn quux() { <|> }"),
-                r"
-                fn quux() {
-                    if true {
-                        ()
-                    } <|>
-                }
-                ",
-            ),
            @r###"
-        [
+            kw const
-            CompletionItem {
+            kw extern
-                label: "else",
+            kw fn
-                source_range: 108..108,
+            kw if
-                delete: 108..108,
+            kw if let
-                insert: "else {$0}",
+            kw impl
-                kind: Keyword,
+            kw let
-            },
+            kw loop
-            CompletionItem {
+            kw match
-                label: "else if",
+            kw mod
-                source_range: 108..108,
+            kw return
-                delete: 108..108,
+            kw static
-                insert: "else if $0 {}",
+            kw trait
-                kind: Keyword,
+            kw type
-            },
+            kw unsafe
-            CompletionItem {
+            kw use
-                label: "if",
+            kw while
-                source_range: 108..108,
-                delete: 108..108,
-                insert: "if $0 {}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "loop",
-                source_range: 108..108,
-                delete: 108..108,
-                insert: "loop {$0}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "match",
-                source_range: 108..108,
-                delete: 108..108,
-                insert: "match $0 {}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "return",
-                source_range: 108..108,
-                delete: 108..108,
-                insert: "return;",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "while",
-                source_range: 108..108,
-                delete: 108..108,
-                insert: "while $0 {}",
-                kind: Keyword,
-            },
-        ]
        "###
        );
    }
    #[test]
-    fn test_completion_return_value() {
+    fn test_keywords_inside_block() {
-        assert_debug_snapshot!(
+        assert_snapshot!(
-            do_keyword_completion(
+            get_keyword_completions(r"fn quux() { if true { <|> } }"),
-                r"
-                fn quux() -> i32 {
-                    <|>
-                    92
-                }
-                ",
-            ),
            @r###"
-        [
+            kw const
-            CompletionItem {
+            kw extern
-                label: "if",
+            kw fn
-                source_range: 56..56,
+            kw if
-                delete: 56..56,
+            kw if let
-                insert: "if $0 {}",
+            kw impl
-                kind: Keyword,
+            kw let
-            },
+            kw loop
-            CompletionItem {
+            kw match
-                label: "loop",
+            kw mod
-                source_range: 56..56,
+            kw return
-                delete: 56..56,
+            kw static
-                insert: "loop {$0}",
+            kw trait
-                kind: Keyword,
+            kw type
-            },
+            kw unsafe
-            CompletionItem {
+            kw use
-                label: "match",
+            kw while
-                source_range: 56..56,
-                delete: 56..56,
-                insert: "match $0 {}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "return",
-                source_range: 56..56,
-                delete: 56..56,
-                insert: "return $0;",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "while",
-                source_range: 56..56,
-                delete: 56..56,
-                insert: "while $0 {}",
-                kind: Keyword,
-            },
-        ]
        "###
        );
-        assert_debug_snapshot!(
+    }
-            do_keyword_completion(
+    #[test]
+    fn test_keywords_after_if() {
+        assert_snapshot!(
+            get_keyword_completions(
                r"
                fn quux() {
-                    <|>
+                    if true {
-                    92
+                        ()
+                    } <|>
                }
                ",
            ),
            @r###"
-        [
+            kw const
-            CompletionItem {
+            kw else
-                label: "if",
+            kw else if
-                source_range: 49..49,
+            kw extern
-                delete: 49..49,
+            kw fn
-                insert: "if $0 {}",
+            kw if
-                kind: Keyword,
+            kw if let
-            },
+            kw impl
-            CompletionItem {
+            kw let
-                label: "loop",
+            kw loop
-                source_range: 49..49,
+            kw match
-                delete: 49..49,
+            kw mod
-                insert: "loop {$0}",
+            kw return
-                kind: Keyword,
+            kw static
-            },
+            kw trait
-            CompletionItem {
+            kw type
-                label: "match",
+            kw unsafe
-                source_range: 49..49,
+            kw use
-                delete: 49..49,
+            kw while
-                insert: "match $0 {}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "return",
-                source_range: 49..49,
-                delete: 49..49,
-                insert: "return;",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "while",
-                source_range: 49..49,
-                delete: 49..49,
-                insert: "while $0 {}",
-                kind: Keyword,
-            },
-        ]
        "###
        );
    }
    #[test]
-    fn dont_add_semi_after_return_if_not_a_statement() {
+    fn test_keywords_in_match_arm() {
-        assert_debug_snapshot!(
+        assert_snapshot!(
-            do_keyword_completion(
+            get_keyword_completions(
                r"
                fn quux() -> i32 {
                    match () {
@@ -451,336 +329,130 @@ mod tests {
                ",
            ),
            @r###"
-        [
+            kw if
-            CompletionItem {
+            kw if let
-                label: "if",
+            kw loop
-                source_range: 97..97,
+            kw match
-                delete: 97..97,
+            kw return
-                insert: "if $0 {}",
+            kw unsafe
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "loop",
-                source_range: 97..97,
-                delete: 97..97,
-                insert: "loop {$0}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "match",
-                source_range: 97..97,
-                delete: 97..97,
-                insert: "match $0 {}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "return",
-                source_range: 97..97,
-                delete: 97..97,
-                insert: "return $0",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "while",
-                source_range: 97..97,
-                delete: 97..97,
-                insert: "while $0 {}",
-                kind: Keyword,
-            },
-        ]
        "###
        );
    }
    #[test]
-    fn last_return_in_block_has_semi() {
+    fn test_keywords_in_trait_def() {
-        assert_debug_snapshot!(
+        assert_snapshot!(
-            do_keyword_completion(
+            get_keyword_completions(r"trait My { <|> }"),
-                r"
-                fn quux() -> i32 {
-                    if condition {
-                        <|>
-                    }
-                }
-                ",
-            ),
            @r###"
-        [
+            kw const
-            CompletionItem {
+            kw fn
-                label: "if",
+            kw type
-                source_range: 95..95,
+            kw unsafe
-                delete: 95..95,
-                insert: "if $0 {}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "loop",
-                source_range: 95..95,
-                delete: 95..95,
-                insert: "loop {$0}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "match",
-                source_range: 95..95,
-                delete: 95..95,
-                insert: "match $0 {}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "return",
-                source_range: 95..95,
-                delete: 95..95,
-                insert: "return $0;",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "while",
-                source_range: 95..95,
-                delete: 95..95,
-                insert: "while $0 {}",
-                kind: Keyword,
-            },
-        ]
        "###
        );
-        assert_debug_snapshot!(
+    }
-            do_keyword_completion(
-                r"
+    #[test]
-                fn quux() -> i32 {
+    fn test_keywords_in_impl_def() {
-                    if condition {
+        assert_snapshot!(
-                        <|>
+            get_keyword_completions(r"impl My { <|> }"),
-                    }
-                    let x = 92;
-                    x
-                }
-                ",
-            ),
            @r###"
-        [
+            kw const
-            CompletionItem {
+            kw fn
-                label: "if",
+            kw pub
-                source_range: 95..95,
+            kw type
-                delete: 95..95,
+            kw unsafe
-                insert: "if $0 {}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "loop",
-                source_range: 95..95,
-                delete: 95..95,
-                insert: "loop {$0}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "match",
-                source_range: 95..95,
-                delete: 95..95,
-                insert: "match $0 {}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "return",
-                source_range: 95..95,
-                delete: 95..95,
-                insert: "return $0;",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "while",
-                source_range: 95..95,
-                delete: 95..95,
-                insert: "while $0 {}",
-                kind: Keyword,
-            },
-        ]
        "###
        );
    }
    #[test]
-    fn completes_break_and_continue_in_loops() {
+    fn test_keywords_in_loop() {
-        assert_debug_snapshot!(
+        assert_snapshot!(
-            do_keyword_completion(
+            get_keyword_completions(r"fn my() { loop { <|> } }"),
-                r"
-                fn quux() -> i32 {
-                    loop { <|> }
-                }
-                ",
-            ),
            @r###"
-        [
+            kw break
-            CompletionItem {
+            kw const
-                label: "break",
+            kw continue
-                source_range: 63..63,
+            kw extern
-                delete: 63..63,
+            kw fn
-                insert: "break;",
+            kw if
-                kind: Keyword,
+            kw if let
-            },
+            kw impl
-            CompletionItem {
+            kw let
-                label: "continue",
+            kw loop
-                source_range: 63..63,
+            kw match
-                delete: 63..63,
+            kw mod
-                insert: "continue;",
+            kw return
-                kind: Keyword,
+            kw static
-            },
+            kw trait
-            CompletionItem {
+            kw type
-                label: "if",
+            kw unsafe
-                source_range: 63..63,
+            kw use
-                delete: 63..63,
+            kw while
-                insert: "if $0 {}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "loop",
-                source_range: 63..63,
-                delete: 63..63,
-                insert: "loop {$0}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "match",
-                source_range: 63..63,
-                delete: 63..63,
-                insert: "match $0 {}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "return",
-                source_range: 63..63,
-                delete: 63..63,
-                insert: "return $0;",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "while",
-                source_range: 63..63,
-                delete: 63..63,
-                insert: "while $0 {}",
-                kind: Keyword,
-            },
-        ]
        "###
        );
+    }
-        // No completion: lambda isolates control flow
+    #[test]
-        assert_debug_snapshot!(
+    fn test_keywords_after_unsafe_in_item_list() {
-            do_keyword_completion(
+        assert_snapshot!(
-                r"
+            get_keyword_completions(r"unsafe <|>"),
-                fn quux() -> i32 {
-                    loop { || { <|> } }
-                }
-                ",
-            ),
            @r###"
-        [
+            kw fn
-            CompletionItem {
+            kw impl
-                label: "if",
+            kw trait
-                source_range: 68..68,
-                delete: 68..68,
-                insert: "if $0 {}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "loop",
-                source_range: 68..68,
-                delete: 68..68,
-                insert: "loop {$0}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "match",
-                source_range: 68..68,
-                delete: 68..68,
-                insert: "match $0 {}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "return",
-                source_range: 68..68,
-                delete: 68..68,
-                insert: "return $0;",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "while",
-                source_range: 68..68,
-                delete: 68..68,
-                insert: "while $0 {}",
-                kind: Keyword,
-            },
-        ]
        "###
        );
    }
    #[test]
-    fn no_semi_after_break_continue_in_expr() {
+    fn test_keywords_after_unsafe_in_block_expr() {
-        assert_debug_snapshot!(
+        assert_snapshot!(
-            do_keyword_completion(
+            get_keyword_completions(r"fn my_fn() { unsafe <|> }"),
-                r"
-                fn f() {
-                    loop {
-                        match () {
-                            () => br<|>
-                        }
-                    }
-                }
-                ",
-            ),
            @r###"
-        [
+            kw fn
-            CompletionItem {
+            kw impl
-                label: "break",
+            kw trait
-                source_range: 122..124,
-                delete: 122..124,
-                insert: "break",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "continue",
-                source_range: 122..124,
-                delete: 122..124,
-                insert: "continue",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "if",
-                source_range: 122..124,
-                delete: 122..124,
-                insert: "if $0 {}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "loop",
-                source_range: 122..124,
-                delete: 122..124,
-                insert: "loop {$0}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "match",
-                source_range: 122..124,
-                delete: 122..124,
-                insert: "match $0 {}",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "return",
-                source_range: 122..124,
-                delete: 122..124,
-                insert: "return",
-                kind: Keyword,
-            },
-            CompletionItem {
-                label: "while",
-                source_range: 122..124,
-                delete: 122..124,
-                insert: "while $0 {}",
-                kind: Keyword,
-            },
-        ]
        "###
-        )
+        );
+    }
+    #[test]
+    fn test_mut_in_ref_and_in_fn_parameters_list() {
+        assert_snapshot!(
+            get_keyword_completions(r"fn my_fn(&<|>) {}"),
+            @r###"
+            kw mut
+        "###
+        );
+        assert_snapshot!(
+            get_keyword_completions(r"fn my_fn(<|>) {}"),
+            @r###"
+            kw mut
+        "###
+        );
+        assert_snapshot!(
+            get_keyword_completions(r"fn my_fn() { let &<|> }"),
+            @r###"
+            kw mut
+        "###
+        );
+    }
+    #[test]
+    fn test_where_keyword() {
+        assert_snapshot!(
+            get_keyword_completions(r"trait A <|>"),
+            @r###"
+            kw where
+        "###
+        );
+        assert_snapshot!(
+            get_keyword_completions(r"impl A <|>"),
+            @r###"
+            kw where
+        "###
+        );
    }
 }
diff --git a/crates/ra_ide/src/completion/complete_postfix.rs b/crates/ra_ide/src/completion/complete_postfix.rs
index 59b58bf98..b878aeb0a 100644
--- a/crates/ra_ide/src/completion/complete_postfix.rs
+++ b/crates/ra_ide/src/completion/complete_postfix.rs
@@ -91,7 +91,7 @@ pub(super) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
            &dot_receiver,
            "if",
            "if expr {}",
-            &format!("if {} {{$0}}", receiver_text),
+            &format!("if {} {{\n    $0\n}}", receiver_text),
        )
        .add_to(acc);
        postfix_snippet(
@@ -100,7 +100,7 @@ pub(super) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
            &dot_receiver,
            "while",
            "while expr {}",
-            &format!("while {} {{\n$0\n}}", receiver_text),
+            &format!("while {} {{\n    $0\n}}", receiver_text),
        )
        .add_to(acc);
    }
@@ -283,7 +283,7 @@ mod tests {
                label: "if",
                source_range: 89..89,
                delete: 85..89,
-                insert: "if bar {$0}",
+                insert: "if bar {\n    $0\n}",
                detail: "if expr {}",
            },
            CompletionItem {
@@ -318,7 +318,7 @@ mod tests {
                label: "while",
                source_range: 89..89,
                delete: 85..89,
-                insert: "while bar {\n$0\n}",
+                insert: "while bar {\n    $0\n}",
                detail: "while expr {}",
            },
        ]
diff --git a/crates/ra_ide/src/completion/completion_context.rs b/crates/ra_ide/src/completion/completion_context.rs
index c4646b727..560fb19e6 100644
--- a/crates/ra_ide/src/completion/completion_context.rs
+++ b/crates/ra_ide/src/completion/completion_context.rs
@@ -5,12 +5,17 @@ use ra_db::SourceDatabase;
 use ra_ide_db::RootDatabase;
 use ra_syntax::{
    algo::{find_covering_element, find_node_at_offset},
-    ast, match_ast, AstNode,
+    ast, match_ast, AstNode, NodeOrToken,
    SyntaxKind::*,
    SyntaxNode, SyntaxToken, TextRange, TextSize,
 };
 use ra_text_edit::Indel;
+use super::patterns::{
+    has_bind_pat_parent, has_block_expr_parent, has_impl_as_prev_sibling, has_impl_parent,
+    has_item_list_or_source_file_parent, has_ref_parent, has_trait_as_prev_sibling,
+    has_trait_parent, if_is_prev, is_in_loop_body, is_match_arm, unsafe_is_prev,
+};
 use crate::{call_info::ActiveParameter, completion::CompletionConfig, FilePosition};
 use test_utils::mark;
@@ -60,6 +65,18 @@ pub(crate) struct CompletionContext<'a> {
    pub(super) is_path_type: bool,
    pub(super) has_type_args: bool,
    pub(super) attribute_under_caret: Option<ast::Attr>,
+    pub(super) unsafe_is_prev: bool,
+    pub(super) if_is_prev: bool,
+    pub(super) block_expr_parent: bool,
+    pub(super) bind_pat_parent: bool,
+    pub(super) ref_pat_parent: bool,
+    pub(super) in_loop_body: bool,
+    pub(super) has_trait_parent: bool,
+    pub(super) has_impl_parent: bool,
+    pub(super) trait_as_prev_sibling: bool,
+    pub(super) impl_as_prev_sibling: bool,
+    pub(super) is_match_arm: bool,
+    pub(super) has_item_list_or_source_file_parent: bool,
 }
 impl<'a> CompletionContext<'a> {
@@ -118,6 +135,18 @@ impl<'a> CompletionContext<'a> {
            has_type_args: false,
            dot_receiver_is_ambiguous_float_literal: false,
            attribute_under_caret: None,
+            unsafe_is_prev: false,
+            in_loop_body: false,
+            ref_pat_parent: false,
+            bind_pat_parent: false,
+            block_expr_parent: false,
+            has_trait_parent: false,
+            has_impl_parent: false,
+            trait_as_prev_sibling: false,
+            impl_as_prev_sibling: false,
+            if_is_prev: false,
+            is_match_arm: false,
+            has_item_list_or_source_file_parent: false,
        };
        let mut original_file = original_file.syntax().clone();
@@ -159,7 +188,7 @@ impl<'a> CompletionContext<'a> {
                break;
            }
        }
+        ctx.fill_keyword_patterns(&hypothetical_file, offset);
        ctx.fill(&original_file, hypothetical_file, offset);
        Some(ctx)
    }
@@ -188,6 +217,24 @@ impl<'a> CompletionContext<'a> {
        self.sema.scope_at_offset(&self.token.parent(), self.offset)
    }
+    fn fill_keyword_patterns(&mut self, file_with_fake_ident: &SyntaxNode, offset: TextSize) {
+        let fake_ident_token = file_with_fake_ident.token_at_offset(offset).right_biased().unwrap();
+        let syntax_element = NodeOrToken::Token(fake_ident_token.clone());
+        self.block_expr_parent = has_block_expr_parent(syntax_element.clone());
+        self.unsafe_is_prev = unsafe_is_prev(syntax_element.clone());
+        self.if_is_prev = if_is_prev(syntax_element.clone());
+        self.bind_pat_parent = has_bind_pat_parent(syntax_element.clone());
+        self.ref_pat_parent = has_ref_parent(syntax_element.clone());
+        self.in_loop_body = is_in_loop_body(syntax_element.clone());
+        self.has_trait_parent = has_trait_parent(syntax_element.clone());
+        self.has_impl_parent = has_impl_parent(syntax_element.clone());
+        self.impl_as_prev_sibling = has_impl_as_prev_sibling(syntax_element.clone());
+        self.trait_as_prev_sibling = has_trait_as_prev_sibling(syntax_element.clone());
+        self.is_match_arm = is_match_arm(syntax_element.clone());
+        self.has_item_list_or_source_file_parent =
+            has_item_list_or_source_file_parent(syntax_element.clone());
+    }
    fn fill(
        &mut self,
        original_file: &SyntaxNode,
@@ -334,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/completion/completion_item.rs b/crates/ra_ide/src/completion/completion_item.rs
index cfb7c1e38..98348b349 100644
--- a/crates/ra_ide/src/completion/completion_item.rs
+++ b/crates/ra_ide/src/completion/completion_item.rs
@@ -125,6 +125,32 @@ pub enum CompletionItemKind {
    Attribute,
 }
+impl CompletionItemKind {
+    #[cfg(test)]
+    pub(crate) fn tag(&self) -> &'static str {
+        match self {
+            CompletionItemKind::Snippet => "sn",
+            CompletionItemKind::Keyword => "kw",
+            CompletionItemKind::Module => "md",
+            CompletionItemKind::Function => "fn",
+            CompletionItemKind::BuiltinType => "bt",
+            CompletionItemKind::Struct => "st",
+            CompletionItemKind::Enum => "en",
+            CompletionItemKind::EnumVariant => "ev",
+            CompletionItemKind::Binding => "bn",
+            CompletionItemKind::Field => "fd",
+            CompletionItemKind::Static => "sc",
+            CompletionItemKind::Const => "ct",
+            CompletionItemKind::Trait => "tt",
+            CompletionItemKind::TypeAlias => "ta",
+            CompletionItemKind::Method => "me",
+            CompletionItemKind::TypeParam => "tp",
+            CompletionItemKind::Macro => "ma",
+            CompletionItemKind::Attribute => "at",
+        }
+    }
+}
 #[derive(Debug, PartialEq, Eq, Copy, Clone)]
 pub(crate) enum CompletionKind {
    /// Parser-based keyword completion.
diff --git a/crates/ra_ide/src/completion/patterns.rs b/crates/ra_ide/src/completion/patterns.rs
new file mode 100644
index 000000000..b2fe13280
--- /dev/null
+++ b/crates/ra_ide/src/completion/patterns.rs
@@ -0,0 +1,194 @@
+//! Patterns telling us certain facts about current syntax element, they are used in completion context
+use ra_syntax::{
+    algo::non_trivia_sibling,
+    ast::{self, LoopBodyOwner},
+    match_ast, AstNode, Direction, NodeOrToken, SyntaxElement,
+    SyntaxKind::*,
+    SyntaxNode, SyntaxToken,
+};
+#[cfg(test)]
+use crate::completion::test_utils::check_pattern_is_applicable;
+pub(crate) fn has_trait_parent(element: SyntaxElement) -> bool {
+    not_same_range_ancestor(element)
+        .filter(|it| it.kind() == ITEM_LIST)
+        .and_then(|it| it.parent())
+        .filter(|it| it.kind() == TRAIT_DEF)
+        .is_some()
+}
+#[test]
+fn test_has_trait_parent() {
+    check_pattern_is_applicable(r"trait A { f<|> }", has_trait_parent);
+}
+pub(crate) fn has_impl_parent(element: SyntaxElement) -> bool {
+    not_same_range_ancestor(element)
+        .filter(|it| it.kind() == ITEM_LIST)
+        .and_then(|it| it.parent())
+        .filter(|it| it.kind() == IMPL_DEF)
+        .is_some()
+}
+#[test]
+fn test_has_impl_parent() {
+    check_pattern_is_applicable(r"impl A { f<|> }", has_impl_parent);
+}
+pub(crate) fn has_block_expr_parent(element: SyntaxElement) -> bool {
+    not_same_range_ancestor(element).filter(|it| it.kind() == BLOCK_EXPR).is_some()
+}
+#[test]
+fn test_has_block_expr_parent() {
+    check_pattern_is_applicable(r"fn my_fn() { let a = 2; f<|> }", has_block_expr_parent);
+}
+pub(crate) fn has_bind_pat_parent(element: SyntaxElement) -> bool {
+    element.ancestors().find(|it| it.kind() == BIND_PAT).is_some()
+}
+#[test]
+fn test_has_bind_pat_parent() {
+    check_pattern_is_applicable(r"fn my_fn(m<|>) {}", has_bind_pat_parent);
+    check_pattern_is_applicable(r"fn my_fn() { let m<|> }", has_bind_pat_parent);
+}
+pub(crate) fn has_ref_parent(element: SyntaxElement) -> bool {
+    not_same_range_ancestor(element)
+        .filter(|it| it.kind() == REF_PAT || it.kind() == REF_EXPR)
+        .is_some()
+}
+#[test]
+fn test_has_ref_parent() {
+    check_pattern_is_applicable(r"fn my_fn(&m<|>) {}", has_ref_parent);
+    check_pattern_is_applicable(r"fn my() { let &m<|> }", has_ref_parent);
+}
+pub(crate) fn has_item_list_or_source_file_parent(element: SyntaxElement) -> bool {
+    let ancestor = not_same_range_ancestor(element);
+    if !ancestor.is_some() {
+        return true;
+    }
+    ancestor.filter(|it| it.kind() == SOURCE_FILE || it.kind() == ITEM_LIST).is_some()
+}
+#[test]
+fn test_has_item_list_or_source_file_parent() {
+    check_pattern_is_applicable(r"i<|>", has_item_list_or_source_file_parent);
+    check_pattern_is_applicable(r"impl { f<|> }", has_item_list_or_source_file_parent);
+}
+pub(crate) fn is_match_arm(element: SyntaxElement) -> bool {
+    not_same_range_ancestor(element.clone()).filter(|it| it.kind() == MATCH_ARM).is_some()
+        && previous_sibling_or_ancestor_sibling(element)
+            .and_then(|it| it.into_token())
+            .filter(|it| it.kind() == FAT_ARROW)
+            .is_some()
+}
+#[test]
+fn test_is_match_arm() {
+    check_pattern_is_applicable(r"fn my_fn() { match () { () => m<|> } }", is_match_arm);
+}
+pub(crate) fn unsafe_is_prev(element: SyntaxElement) -> bool {
+    element
+        .into_token()
+        .and_then(|it| previous_non_trivia_token(it))
+        .filter(|it| it.kind() == UNSAFE_KW)
+        .is_some()
+}
+#[test]
+fn test_unsafe_is_prev() {
+    check_pattern_is_applicable(r"unsafe i<|>", unsafe_is_prev);
+}
+pub(crate) fn if_is_prev(element: SyntaxElement) -> bool {
+    element
+        .into_token()
+        .and_then(|it| previous_non_trivia_token(it))
+        .filter(|it| it.kind() == IF_KW)
+        .is_some()
+}
+#[test]
+fn test_if_is_prev() {
+    check_pattern_is_applicable(r"if l<|>", if_is_prev);
+}
+pub(crate) fn has_trait_as_prev_sibling(element: SyntaxElement) -> bool {
+    previous_sibling_or_ancestor_sibling(element).filter(|it| it.kind() == TRAIT_DEF).is_some()
+}
+#[test]
+fn test_has_trait_as_prev_sibling() {
+    check_pattern_is_applicable(r"trait A w<|> {}", has_trait_as_prev_sibling);
+}
+pub(crate) fn has_impl_as_prev_sibling(element: SyntaxElement) -> bool {
+    previous_sibling_or_ancestor_sibling(element).filter(|it| it.kind() == IMPL_DEF).is_some()
+}
+#[test]
+fn test_has_impl_as_prev_sibling() {
+    check_pattern_is_applicable(r"impl A w<|> {}", has_impl_as_prev_sibling);
+}
+pub(crate) fn is_in_loop_body(element: SyntaxElement) -> bool {
+    let leaf = match element {
+        NodeOrToken::Node(node) => node,
+        NodeOrToken::Token(token) => token.parent(),
+    };
+    for node in leaf.ancestors() {
+        if node.kind() == FN_DEF || node.kind() == LAMBDA_EXPR {
+            break;
+        }
+        let loop_body = match_ast! {
+            match node {
+                ast::ForExpr(it) => it.loop_body(),
+                ast::WhileExpr(it) => it.loop_body(),
+                ast::LoopExpr(it) => it.loop_body(),
+                _ => None,
+            }
+        };
+        if let Some(body) = loop_body {
+            if body.syntax().text_range().contains_range(leaf.text_range()) {
+                return true;
+            }
+        }
+    }
+    false
+}
+fn not_same_range_ancestor(element: SyntaxElement) -> Option<SyntaxNode> {
+    element
+        .ancestors()
+        .take_while(|it| it.text_range() == element.text_range())
+        .last()
+        .and_then(|it| it.parent())
+}
+fn previous_non_trivia_token(token: SyntaxToken) -> Option<SyntaxToken> {
+    let mut token = token.prev_token();
+    while let Some(inner) = token.clone() {
+        if !inner.kind().is_trivia() {
+            return Some(inner);
+        } else {
+            token = inner.prev_token();
+        }
+    }
+    None
+}
+fn previous_sibling_or_ancestor_sibling(element: SyntaxElement) -> Option<SyntaxElement> {
+    let token_sibling = non_trivia_sibling(element.clone(), Direction::Prev);
+    if let Some(sibling) = token_sibling {
+        Some(sibling)
+    } else {
+        // if not trying to find first ancestor which has such a sibling
+        let node = match element {
+            NodeOrToken::Node(node) => node,
+            NodeOrToken::Token(token) => token.parent(),
+        };
+        let range = node.text_range();
+        let top_node = node.ancestors().take_while(|it| it.text_range() == range).last()?;
+        let prev_sibling_node = top_node.ancestors().find(|it| {
+            non_trivia_sibling(NodeOrToken::Node(it.to_owned()), Direction::Prev).is_some()
+        })?;
+        non_trivia_sibling(NodeOrToken::Node(prev_sibling_node), Direction::Prev)
+    }
+}
diff --git a/crates/ra_ide/src/completion/test_utils.rs b/crates/ra_ide/src/completion/test_utils.rs
index bf22452a2..1e16a43ca 100644
--- a/crates/ra_ide/src/completion/test_utils.rs
+++ b/crates/ra_ide/src/completion/test_utils.rs
@@ -5,25 +5,63 @@ use crate::{
    mock_analysis::{analysis_and_position, single_file_with_position},
    CompletionItem,
 };
+use hir::Semantics;
+use ra_syntax::{AstNode, NodeOrToken, SyntaxElement};
 pub(crate) fn do_completion(code: &str, kind: CompletionKind) -> Vec<CompletionItem> {
    do_completion_with_options(code, kind, &CompletionConfig::default())
 }
+pub(crate) fn completion_list(code: &str, kind: CompletionKind) -> String {
+    completion_list_with_options(code, kind, &CompletionConfig::default())
+}
 pub(crate) fn do_completion_with_options(
    code: &str,
    kind: CompletionKind,
    options: &CompletionConfig,
 ) -> Vec<CompletionItem> {
+    let mut kind_completions: Vec<CompletionItem> = get_all_completion_items(code, options)
+        .into_iter()
+        .filter(|c| c.completion_kind == kind)
+        .collect();
+    kind_completions.sort_by(|l, r| l.label().cmp(r.label()));
+    kind_completions
+}
+fn get_all_completion_items(code: &str, options: &CompletionConfig) -> Vec<CompletionItem> {
    let (analysis, position) = if code.contains("//-") {
        analysis_and_position(code)
    } else {
        single_file_with_position(code)
    };
-    let completions = analysis.completions(options, position).unwrap().unwrap();
+    analysis.completions(options, position).unwrap().unwrap().into()
-    let completion_items: Vec<CompletionItem> = completions.into();
+}
-    let mut kind_completions: Vec<CompletionItem> =
-        completion_items.into_iter().filter(|c| c.completion_kind == kind).collect();
+pub(crate) fn completion_list_with_options(
+    code: &str,
+    kind: CompletionKind,
+    options: &CompletionConfig,
+) -> String {
+    let mut kind_completions: Vec<CompletionItem> = get_all_completion_items(code, options)
+        .into_iter()
+        .filter(|c| c.completion_kind == kind)
+        .collect();
    kind_completions.sort_by_key(|c| c.label().to_owned());
    kind_completions
+        .into_iter()
+        .map(|it| format!("{} {}\n", it.kind().unwrap().tag(), it.label()))
+        .collect()
+}
+pub(crate) fn check_pattern_is_applicable(code: &str, check: fn(SyntaxElement) -> bool) {
+    let (analysis, pos) = single_file_with_position(code);
+    analysis
+        .with_db(|db| {
+            let sema = Semantics::new(db);
+            let original_file = sema.parse(pos.file_id);
+            let token = original_file.syntax().token_at_offset(pos.offset).left_biased().unwrap();
+            assert!(check(NodeOrToken::Token(token)));
+        })
+        .unwrap();
 }
diff --git a/crates/ra_ide/src/diagnostics.rs b/crates/ra_ide/src/diagnostics.rs
index f44feaf69..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 fix = Fix::new(
-        let path = db
+            "Create module",
-            .file_relative_path(original_file)
+            FileSystemEdit::CreateFile { anchor: original_file, dst: d.candidate.clone() }.into(),
-            .parent()
+        );
-            .unwrap_or_else(|| RelativePath::new(""))
-            .join(&d.candidate);
-        let fix =
-            Fix::new("Create module", FileSystemEdit::CreateFile { source_root, path }.into());
        res.borrow_mut().push(Diagnostic {
            range: sema.diagnostics_range(d).range,
            message: d.message(),
@@ -187,7 +183,8 @@ fn check_struct_shorthand_initialization(
        if let (Some(name_ref), Some(expr)) = (record_field.name_ref(), record_field.expr()) {
            let field_name = name_ref.syntax().text().to_string();
            let field_expr = expr.syntax().text().to_string();
-            if field_name == field_expr {
+            let field_name_is_tup_index = name_ref.as_tuple_field().is_some();
+            if field_name == field_expr && !field_name_is_tup_index {
                let mut edit_builder = TextEditBuilder::default();
                edit_builder.delete(record_field.syntax().text_range());
                edit_builder.insert(record_field.syntax().text_range().start(), field_name);
@@ -611,10 +608,10 @@ mod tests {
                            source_file_edits: [],
                            file_system_edits: [
                                CreateFile {
-                                    source_root: SourceRootId(
+                                    anchor: FileId(
-                                        0,
+                                        1,
                                    ),
-                                    path: "foo.rs",
+                                    dst: "foo.rs",
                                },
                            ],
                            is_snippet: false,
@@ -719,6 +716,18 @@ mod tests {
        "#,
            check_struct_shorthand_initialization,
        );
+        check_not_applicable(
+            r#"
+            struct A(usize);
+            fn main() {
+                A {
+                    0: 0
+                }
+            }
+        "#,
+            check_struct_shorthand_initialization,
+        );
        check_apply(
            r#"
diff --git a/crates/ra_ide/src/lib.rs b/crates/ra_ide/src/lib.rs
index 28f686767..375da1f45 100644
--- a/crates/ra_ide/src/lib.rs
+++ b/crates/ra_ide/src/lib.rs
@@ -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 546224b50..99c2581b7 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::{Module, ModuleDef, ModuleSource, Semantics};
-use ra_db::{RelativePath, RelativePathBuf, SourceDatabaseExt};
+use ra_db::{RelativePathBuf, SourceDatabaseExt};
 use ra_ide_db::{
    defs::{classify_name, classify_name_ref, Definition, NameClass, NameRefClass},
    RootDatabase,
@@ -111,23 +111,14 @@ fn rename_mod(
        ModuleSource::SourceFile(..) => {
            let mod_path: RelativePathBuf = 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") {
+            let dst = if mod_path.file_stem() == Some("mod") {
-                mod_path
+                format!("../{}/mod.rs", new_name)
-                    .parent()
-                    .and_then(|p| p.parent())
-                    .or_else(|| Some(RelativePath::new("")))
-                    .map(|p| p.join(new_name).join("mod.rs"))
            } 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 =
-                let move_file = FileSystemEdit::MoveFile {
+                FileSystemEdit::MoveFile { src: file_id, anchor: position.file_id, dst };
-                    src: file_id,
+            file_system_edits.push(move_file);
-                    dst_source_root: db.file_source_root(position.file_id),
-                    dst_path: path,
-                };
-                file_system_edits.push(move_file);
-            }
        }
        ModuleSource::Module(..) => {}
    }
@@ -644,16 +635,16 @@ mod tests {
    #[test]
    fn test_rename_mod() {
        let (analysis, position) = analysis_and_position(
-            "
+            r#"
-            //- /lib.rs
+//- /lib.rs
-            mod bar;
+mod bar;
-            //- /bar.rs
+//- /bar.rs
-            mod foo<|>;
+mod foo<|>;
-            //- /bar/foo.rs
+//- /bar/foo.rs
-            // emtpy
+// emtpy
-            ",
+            "#,
        );
        let new_name = "foo2";
        let source_change = analysis.rename(position, new_name).unwrap();
@@ -683,10 +674,10 @@ mod tests {
                            src: FileId(
                                3,
                            ),
-                            dst_source_root: SourceRootId(
+                            anchor: FileId(
-                                0,
+                                2,
                            ),
-                            dst_path: "bar/foo2.rs",
+                            dst: "foo2.rs",
                        },
                    ],
                    is_snippet: false,
@@ -699,18 +690,18 @@ mod tests {
    #[test]
    fn test_rename_mod_in_use_tree() {
        let (analysis, position) = analysis_and_position(
-            "
+            r#"
-            //- /main.rs
+//- /main.rs
-            pub mod foo;
+pub mod foo;
-            pub mod bar;
+pub mod bar;
-            fn main() {}
+fn main() {}
-            //- /foo.rs
+//- /foo.rs
-            pub struct FooContent;
+pub struct FooContent;
-            //- /bar.rs
+//- /bar.rs
-            use crate::foo<|>::FooContent;
+use crate::foo<|>::FooContent;
-            ",
+            "#,
        );
        let new_name = "qux";
        let source_change = analysis.rename(position, new_name).unwrap();
@@ -753,10 +744,10 @@ mod tests {
                            src: FileId(
                                2,
                            ),
-                            dst_source_root: SourceRootId(
+                            anchor: FileId(
-                                0,
+                                3,
                            ),
-                            dst_path: "qux.rs",
+                            dst: "qux.rs",
                        },
                    ],
                    is_snippet: false,
@@ -769,12 +760,12 @@ mod tests {
    #[test]
    fn test_rename_mod_in_dir() {
        let (analysis, position) = analysis_and_position(
-            "
+            r#"
-            //- /lib.rs
+//- /lib.rs
-            mod fo<|>o;
+mod fo<|>o;
-            //- /foo/mod.rs
+//- /foo/mod.rs
-            // emtpy
+// emtpy
-            ",
+            "#,
        );
        let new_name = "foo2";
        let source_change = analysis.rename(position, new_name).unwrap();
@@ -804,10 +795,10 @@ mod tests {
                            src: FileId(
                                2,
                            ),
-                            dst_source_root: SourceRootId(
+                            anchor: FileId(
-                                0,
+                                1,
                            ),
-                            dst_path: "foo2/mod.rs",
+                            dst: "../foo2/mod.rs",
                        },
                    ],
                    is_snippet: false,
@@ -844,19 +835,19 @@ mod tests {
    #[test]
    fn test_rename_mod_filename_and_path() {
        let (analysis, position) = analysis_and_position(
-            "
+            r#"
-            //- /lib.rs
+//- /lib.rs
-            mod bar;
+mod bar;
-            fn f() {
+fn f() {
-                bar::foo::fun()
+    bar::foo::fun()
-            }
+}
-            //- /bar.rs
+//- /bar.rs
-            pub mod foo<|>;
+pub mod foo<|>;
-            //- /bar/foo.rs
+//- /bar/foo.rs
-            // pub fn fun() {}
+// pub fn fun() {}
-            ",
+            "#,
        );
        let new_name = "foo2";
        let source_change = analysis.rename(position, new_name).unwrap();
@@ -899,10 +890,10 @@ mod tests {
                            src: FileId(
                                3,
                            ),
-                            dst_source_root: SourceRootId(
+                            anchor: FileId(
-                                0,
+                                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="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="unresolved_reference">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?;
+            let (var, remainder) = part?;
-            is_expr(var_type)?;
            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> {
+fn split_by_var(s: &str) -> Result<(&str, &str), SsrError> {
-    let end_of_name = s.find(':').ok_or_else(|| SsrError("Use $<name>:expr".into()))?;
+    let end_of_name = s.find(|c| !char::is_ascii_alphanumeric(&c)).unwrap_or_else(|| s.len());
-    let name = &s[0..end_of_name];
+    let name = &s[..end_of_name];
    is_name(name)?;
-    let type_begin = end_of_name + 1;
+    Ok((name, &s[end_of_name..]))
-    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..]))
 }
 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/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) = parent
-                if let Some(name) =
+                .parent()
-                    fmt_macro_call.path().and_then(|p| p.segment()).and_then(|s| s.name_ref())
+                .and_then(ast::MacroCall::cast)
-                {
+                .and_then(|mc| mc.path())
-                    match name.text().as_str() {
+                .and_then(|p| p.segment())
-                        "format_args" | "format_args_nl" => {
+                .and_then(|s| s.name_ref())
-                            format_string = parent
+            {
-                                .children_with_tokens()
+                match name.text().as_str() {
-                                .filter(|t| t.kind() != WHITESPACE)
+                    "format_args" | "format_args_nl" => {
-                                .nth(1)
+                        format_string = parent
-                                .filter(|e| {
+                            .children_with_tokens()
-                                    ast::String::can_cast(e.kind())
+                            .filter(|t| t.kind() != WHITESPACE)
-                                        || ast::RawString::can_cast(e.kind())
+                            .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)) =
+        if let Some((highlight, binding_hash)) = highlight_element(
-            highlight_element(&sema, &mut bindings_shadow_count, element_to_highlight.clone())
+            &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("```") {
+            if let Some(idx) = comment.text().find(RUSTDOC_FENCE) {
-                is_doctest = !is_doctest;
+                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/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 },
+    CreateFile { anchor: FileId, dst: String },
-    MoveFile { src: FileId, dst_source_root: SourceRootId, dst_path: RelativePathBuf },
+    MoveFile { src: FileId, anchor: FileId, dst: String },
 }
 impl From<FileSystemEdit> for SourceChange {
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 {
+    let forbid = matches!(kind, BIN_EXPR | RANGE_EXPR);
-        BIN_EXPR | RANGE_EXPR | IF_EXPR => false,
+    !forbid
-        _ => true,
-    }
 }
 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 },
+    Json { project: JsonProject, project_location: PathBuf },
-}
-impl From<JsonProject> for ProjectWorkspace {
-    fn from(project: JsonProject) -> ProjectWorkspace {
-        ProjectWorkspace::Json { project }
-    }
 }
 /// `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 } => {
+            ProjectWorkspace::Json { project, project_location } => project
-                project.roots.iter().map(|r| PackageRoot::new_member(r.path.clone())).collect()
+                .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/ast/generated/nodes.rs b/crates/ra_syntax/src/ast/generated/nodes.rs
index 40081ebb1..58141da11 100644
--- a/crates/ra_syntax/src/ast/generated/nodes.rs
+++ b/crates/ra_syntax/src/ast/generated/nodes.rs
@@ -4851,687 +4851,687 @@ impl AstNode for FieldDefList {
    }
 }
 impl std::fmt::Display for NominalDef {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for GenericParam {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for GenericArg {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for TypeRef {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for ModuleItem {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for AssocItem {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for ExternItem {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for Expr {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for Pat {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for RecordInnerPat {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for AttrInput {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for Stmt {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for FieldDefList {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for SourceFile {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for FnDef {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for RetType {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for StructDef {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for UnionDef {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for RecordFieldDefList {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for RecordFieldDef {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for TupleFieldDefList {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for TupleFieldDef {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for EnumDef {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for EnumVariantList {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for EnumVariant {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for TraitDef {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for Module {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for ItemList {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for ConstDef {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for StaticDef {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for TypeAliasDef {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for ImplDef {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for ParenType {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for TupleType {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for NeverType {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for PathType {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for PointerType {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for ArrayType {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for SliceType {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for ReferenceType {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for PlaceholderType {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for FnPointerType {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for ForType {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for ImplTraitType {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for DynTraitType {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for TupleExpr {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for ArrayExpr {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for ParenExpr {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for PathExpr {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for LambdaExpr {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for IfExpr {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for LoopExpr {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for EffectExpr {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for ForExpr {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for WhileExpr {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for ContinueExpr {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for BreakExpr {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for Label {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for BlockExpr {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for ReturnExpr {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for CallExpr {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for MethodCallExpr {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for IndexExpr {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for FieldExpr {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for AwaitExpr {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for TryExpr {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for CastExpr {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for RefExpr {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for PrefixExpr {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for BoxExpr {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for RangeExpr {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for BinExpr {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for Literal {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for MatchExpr {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for MatchArmList {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for MatchArm {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for MatchGuard {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for RecordLit {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for RecordFieldList {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for RecordField {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for OrPat {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for ParenPat {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for RefPat {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for BoxPat {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for BindPat {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for PlaceholderPat {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for DotDotPat {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for PathPat {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for SlicePat {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for RangePat {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for LiteralPat {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for MacroPat {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for RecordPat {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for RecordFieldPatList {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for RecordFieldPat {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for TupleStructPat {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for TuplePat {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for Visibility {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for Name {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for NameRef {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for MacroCall {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for Attr {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for TokenTree {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for TypeParamList {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for TypeParam {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for ConstParam {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for LifetimeParam {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for TypeBound {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for TypeBoundList {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for WherePred {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for WhereClause {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for Abi {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for ExprStmt {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for LetStmt {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for Condition {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for ParamList {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for SelfParam {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for Param {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for UseItem {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for UseTree {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for Alias {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for UseTreeList {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for ExternCrateItem {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for ArgList {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for Path {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for PathSegment {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for TypeArgList {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for TypeArg {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for AssocTypeArg {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for LifetimeArg {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for ConstArg {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for MacroItems {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for MacroStmts {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for ExternItemList {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for ExternBlock {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for MetaItem {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
 impl std::fmt::Display for MacroDef {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(self.syntax(), f)
    }
 }
diff --git a/crates/ra_syntax/src/ast/generated/tokens.rs b/crates/ra_syntax/src/ast/generated/tokens.rs
index f91befaac..abadd0b61 100644
--- a/crates/ra_syntax/src/ast/generated/tokens.rs
+++ b/crates/ra_syntax/src/ast/generated/tokens.rs
@@ -11,7 +11,7 @@ pub struct Whitespace {
    pub(crate) syntax: SyntaxToken,
 }
 impl std::fmt::Display for Whitespace {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(&self.syntax, f)
    }
 }
@@ -32,7 +32,7 @@ pub struct Comment {
    pub(crate) syntax: SyntaxToken,
 }
 impl std::fmt::Display for Comment {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(&self.syntax, f)
    }
 }
@@ -53,7 +53,7 @@ pub struct String {
    pub(crate) syntax: SyntaxToken,
 }
 impl std::fmt::Display for String {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(&self.syntax, f)
    }
 }
@@ -74,7 +74,7 @@ pub struct RawString {
    pub(crate) syntax: SyntaxToken,
 }
 impl std::fmt::Display for RawString {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(&self.syntax, f)
    }
 }
diff --git a/crates/ra_syntax/src/ast/tokens.rs b/crates/ra_syntax/src/ast/tokens.rs
index 56378385a..2e72d4927 100644
--- a/crates/ra_syntax/src/ast/tokens.rs
+++ b/crates/ra_syntax/src/ast/tokens.rs
@@ -84,7 +84,7 @@ impl Whitespace {
 }
 pub struct QuoteOffsets {
-    pub quotes: [TextRange; 2],
+    pub quotes: (TextRange, TextRange),
    pub contents: TextRange,
 }
@@ -103,7 +103,7 @@ impl QuoteOffsets {
        let end = TextSize::of(literal);
        let res = QuoteOffsets {
-            quotes: [TextRange::new(start, left_quote), TextRange::new(right_quote, end)],
+            quotes: (TextRange::new(start, left_quote), TextRange::new(right_quote, end)),
            contents: TextRange::new(left_quote, right_quote),
        };
        Some(res)
@@ -116,17 +116,17 @@ pub trait HasQuotes: AstToken {
        let offsets = QuoteOffsets::new(text)?;
        let o = self.syntax().text_range().start();
        let offsets = QuoteOffsets {
-            quotes: [offsets.quotes[0] + o, offsets.quotes[1] + o],
+            quotes: (offsets.quotes.0 + o, offsets.quotes.1 + o),
            contents: offsets.contents + o,
        };
        Some(offsets)
    }
    fn open_quote_text_range(&self) -> Option<TextRange> {
-        self.quote_offsets().map(|it| it.quotes[0])
+        self.quote_offsets().map(|it| it.quotes.0)
    }
    fn close_quote_text_range(&self) -> Option<TextRange> {
-        self.quote_offsets().map(|it| it.quotes[1])
+        self.quote_offsets().map(|it| it.quotes.1)
    }
    fn text_range_between_quotes(&self) -> Option<TextRange> {
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() {
+        let crate_id = match global_state_snapshot.analysis().crate_for(file_id)?.first() {
-            Some(crate_id) => crate_id,
+            Some(crate_id) => *crate_id,
            None => return Ok(None),
        };
-        let file_id = world.analysis().crate_root(crate_id)?;
+        let (cargo_ws, target) = match global_state_snapshot.cargo_target_for_crate_root(crate_id) {
-        let path = world.file_id_to_path(file_id);
+            Some(it) => it,
-        let res = world.workspaces.iter().find_map(|ws| match ws {
+            None => return Ok(None),
-            ProjectWorkspace::Cargo { cargo, .. } => {
+        };
-                let tgt = cargo.target_by_root(&path)?;
+        let res = CargoTargetSpec {
-                Some(CargoTargetSpec {
+            package: cargo_ws.package_flag(&cargo_ws[cargo_ws[target].package]),
-                    package: cargo.package_flag(&cargo[cargo[tgt].package]),
+            target: cargo_ws[target].name.clone(),
-                    target: cargo[tgt].name.clone(),
+            target_kind: cargo_ws[target].kind,
-                    target_kind: cargo[tgt].kind,
+        };
-                })
+        Ok(Some(res))
-            }
-            ProjectWorkspace::Json { .. } => None,
-        });
-        Ok(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.snap b/crates/rust-analyzer/src/diagnostics/snapshots/rust_analyzer__diagnostics__to_proto__tests__snap_rustc_unused_variable.snap
index f0273315e..9a7972ff5 100644
--- a/crates/rust-analyzer/src/diagnostics/snapshots/rust_analyzer__diagnostics__to_proto__tests__snap_rustc_unused_variable.snap
+++ b/crates/rust-analyzer/src/diagnostics/snapshots/rust_analyzer__diagnostics__to_proto__tests__snap_rustc_unused_variable.snap
@@ -29,7 +29,7 @@ expression: diag
                },
            },
            severity: Some(
-                Hint,
+                Warning,
            ),
            code: Some(
                String(
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 04e286780..ba74f15f3 100644
--- a/crates/rust-analyzer/src/diagnostics/to_proto.rs
+++ b/crates/rust-analyzer/src/diagnostics/to_proto.rs
@@ -1,10 +1,6 @@
 //! This module provides the functionality needed to convert diagnostics from
 //! `cargo check` json format to the LSP diagnostic format.
-use std::{
+use std::{collections::HashMap, path::Path};
-    collections::HashMap,
-    path::{Component, Path, Prefix},
-    str::FromStr,
-};
 use lsp_types::{
    Diagnostic, DiagnosticRelatedInformation, DiagnosticSeverity, DiagnosticTag, Location,
@@ -13,14 +9,24 @@ use lsp_types::{
 use ra_flycheck::{Applicability, DiagnosticLevel, DiagnosticSpan, DiagnosticSpanMacroExpansion};
 use stdx::format_to;
-use crate::{lsp_ext, Result};
+use super::DiagnosticsConfig;
+use crate::{lsp_ext, to_proto::url_from_abs_path};
-/// Converts a Rust level string to a LSP severity
+/// Determines the LSP severity from a diagnostic
-fn map_level_to_severity(val: DiagnosticLevel) -> Option<DiagnosticSeverity> {
+fn map_diagnostic_to_severity(
-    let res = match val {
+    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,
@@ -65,7 +71,7 @@ fn map_span_to_location(span: &DiagnosticSpan, workspace_root: &Path) -> Locatio
 fn map_span_to_location_naive(span: &DiagnosticSpan, workspace_root: &Path) -> Location {
    let mut file_name = workspace_root.to_path_buf();
    file_name.push(&span.file_name);
-    let uri = url_from_path_with_drive_lowercasing(file_name).unwrap();
+    let uri = url_from_abs_path(&file_name);
    // FIXME: this doesn't handle UTF16 offsets correctly
    let range = Range::new(
@@ -176,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> {
@@ -184,7 +191,7 @@ pub(crate) fn map_rust_diagnostic_to_lsp(
        return Vec::new();
    }
-    let mut 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());
@@ -226,7 +233,6 @@ pub(crate) fn map_rust_diagnostic_to_lsp(
    }
    if is_unused_or_unnecessary(rd) {
-        severity = Some(DiagnosticSeverity::Hint);
        tags.push(DiagnosticTag::Unnecessary);
    }
@@ -275,70 +281,16 @@ pub(crate) fn map_rust_diagnostic_to_lsp(
        .collect()
 }
-/// Returns a `Url` object from a given path, will lowercase drive letters if present.
-/// This will only happen when processing windows paths.
-///
-/// When processing non-windows path, this is essentially the same as `Url::from_file_path`.
-pub fn url_from_path_with_drive_lowercasing(path: impl AsRef<Path>) -> Result<Url> {
-    let component_has_windows_drive = path.as_ref().components().any(|comp| {
-        if let Component::Prefix(c) = comp {
-            return matches!(c.kind(), Prefix::Disk(_) | Prefix::VerbatimDisk(_));
-        }
-        false
-    });
-    // VSCode expects drive letters to be lowercased, where rust will uppercase the drive letters.
-    let res = if component_has_windows_drive {
-        let url_original = Url::from_file_path(&path)
-            .map_err(|_| format!("can't convert path to url: {}", path.as_ref().display()))?;
-        let drive_partition: Vec<&str> = url_original.as_str().rsplitn(2, ':').collect();
-        // There is a drive partition, but we never found a colon.
-        // This should not happen, but in this case we just pass it through.
-        if drive_partition.len() == 1 {
-            return Ok(url_original);
-        }
-        let joined = drive_partition[1].to_ascii_lowercase() + ":" + drive_partition[0];
-        let url = Url::from_str(&joined).expect("This came from a valid `Url`");
-        url
-    } else {
-        Url::from_file_path(&path)
-            .map_err(|_| format!("can't convert path to url: {}", path.as_ref().display()))?
-    };
-    Ok(res)
-}
 #[cfg(test)]
+#[cfg(not(windows))]
 mod tests {
    use super::*;
-    // `Url` is not able to parse windows paths on unix machines.
-    #[test]
-    #[cfg(target_os = "windows")]
-    fn test_lowercase_drive_letter_with_drive() {
-        let url = url_from_path_with_drive_lowercasing("C:\\Test").unwrap();
-        assert_eq!(url.to_string(), "file:///c:/Test");
-    }
-    #[test]
-    #[cfg(target_os = "windows")]
-    fn test_drive_without_colon_passthrough() {
-        let url = url_from_path_with_drive_lowercasing(r#"\\localhost\C$\my_dir"#).unwrap();
-        assert_eq!(url.to_string(), "file://localhost/C$/my_dir");
-    }
-    #[cfg(not(windows))]
    fn parse_diagnostic(val: &str) -> ra_flycheck::Diagnostic {
        serde_json::from_str::<ra_flycheck::Diagnostic>(val).unwrap()
    }
    #[test]
-    #[cfg(not(windows))]
    fn snap_rustc_incompatible_type_for_trait() {
        let diag = parse_diagnostic(
            r##"{
@@ -387,12 +339,11 @@ 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() {
        let diag = parse_diagnostic(
            r##"{
@@ -470,12 +421,187 @@ 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);
+    }
+    #[test]
    fn snap_rustc_wrong_number_of_parameters() {
        let diag = parse_diagnostic(
            r##"{
@@ -595,12 +721,11 @@ 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_clippy_pass_by_ref() {
        let diag = parse_diagnostic(
            r##"{
@@ -716,12 +841,11 @@ 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_mismatched_type() {
        let diag = parse_diagnostic(
            r##"{
@@ -760,12 +884,11 @@ 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_handles_macro_location() {
        let diag = parse_diagnostic(
            r##"{
@@ -1032,12 +1155,11 @@ 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_macro_compiler_error() {
        let diag = parse_diagnostic(
            r##"{
@@ -1262,12 +1384,11 @@ 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_multi_line_fix() {
        let diag = parse_diagnostic(
            r##"{
@@ -1396,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/from_proto.rs b/crates/rust-analyzer/src/from_proto.rs
index 206673829..40f856e6e 100644
--- a/crates/rust-analyzer/src/from_proto.rs
+++ b/crates/rust-analyzer/src/from_proto.rs
@@ -17,7 +17,7 @@ pub(crate) fn text_range(line_index: &LineIndex, range: lsp_types::Range) -> Tex
 }
 pub(crate) fn file_id(world: &GlobalStateSnapshot, url: &lsp_types::Url) -> Result<FileId> {
-    world.uri_to_file_id(url)
+    world.url_to_file_id(url)
 }
 pub(crate) fn file_position(
diff --git a/crates/rust-analyzer/src/global_state.rs b/crates/rust-analyzer/src/global_state.rs
index 21116e165..ef6c7d44d 100644
--- a/crates/rust-analyzer/src/global_state.rs
+++ b/crates/rust-analyzer/src/global_state.rs
@@ -15,21 +15,20 @@ use ra_flycheck::{Flycheck, FlycheckConfig};
 use ra_ide::{
    Analysis, AnalysisChange, AnalysisHost, CrateGraph, FileId, LibraryData, SourceRootId,
 };
-use ra_project_model::{ProcMacroClient, ProjectWorkspace};
+use ra_project_model::{CargoWorkspace, ProcMacroClient, ProjectWorkspace, Target};
-use ra_vfs::{LineEndings, RootEntry, Vfs, VfsChange, VfsFile, VfsRoot, VfsTask, Watch};
+use ra_vfs::{LineEndings, RootEntry, Vfs, VfsChange, VfsFile, VfsTask, Watch};
 use relative_path::RelativePathBuf;
 use stdx::format_to;
 use crate::{
    config::Config,
-    diagnostics::{
+    diagnostics::{CheckFixes, DiagnosticCollection},
-        to_proto::url_from_path_with_drive_lowercasing, CheckFixes, DiagnosticCollection,
-    },
    main_loop::pending_requests::{CompletedRequest, LatestRequests},
+    to_proto::url_from_abs_path,
    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> {
@@ -274,8 +273,8 @@ impl GlobalStateSnapshot {
        &self.analysis
    }
-    pub fn uri_to_file_id(&self, uri: &Url) -> Result<FileId> {
+    pub fn url_to_file_id(&self, url: &Url) -> Result<FileId> {
-        let path = uri.to_file_path().map_err(|()| format!("invalid uri: {}", uri))?;
+        let path = url.to_file_path().map_err(|()| format!("invalid uri: {}", url))?;
        let file = self.vfs.read().path2file(&path).ok_or_else(|| {
            // Show warning as this file is outside current workspace
            // FIXME: just handle such files, and remove `LspError::UNKNOWN_FILE`.
@@ -287,27 +286,33 @@ impl GlobalStateSnapshot {
        Ok(FileId(file.0))
    }
-    pub fn file_id_to_uri(&self, id: FileId) -> Result<Url> {
+    pub fn file_id_to_url(&self, id: FileId) -> Url {
-        let path = self.vfs.read().file2path(VfsFile(id.0));
+        file_id_to_url(&self.vfs.read(), id)
-        let url = url_from_path_with_drive_lowercasing(path)?;
-        Ok(url)
-    }
-    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_uri(&self, root: SourceRootId, path: &RelativePathBuf) -> Result<Url> {
+    pub fn anchored_path(&self, file_id: FileId, path: &str) -> Url {
-        let base = self.vfs.read().root2path(VfsRoot(root.0));
+        let mut base = self.vfs.read().file2path(VfsFile(file_id.0));
-        let path = path.to_path(base);
+        base.pop();
-        let url = Url::from_file_path(&path)
+        let path = base.join(path);
-            .map_err(|_| format!("can't convert path to url: {}", path.display()))?;
+        url_from_abs_path(&path)
-        Ok(url)
+    }
+    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 {
@@ -335,3 +340,8 @@ impl GlobalStateSnapshot {
        self.workspaces.iter().find_map(|ws| ws.workspace_root_for(&path))
    }
 }
+pub(crate) fn file_id_to_url(vfs: &Vfs, id: FileId) -> Url {
+    let path = vfs.file2path(VfsFile(id.0));
+    url_from_abs_path(&path)
+}
diff --git a/crates/rust-analyzer/src/main_loop.rs b/crates/rust-analyzer/src/main_loop.rs
index 752dbf145..80cfd3c28 100644
--- a/crates/rust-analyzer/src/main_loop.rs
+++ b/crates/rust-analyzer/src/main_loop.rs
@@ -27,7 +27,7 @@ use ra_flycheck::{CheckTask, Status};
 use ra_ide::{Canceled, FileId, LibraryData, LineIndex, SourceRootId};
 use ra_prof::profile;
 use ra_project_model::{PackageRoot, ProjectWorkspace};
-use ra_vfs::{VfsFile, VfsTask, Watch};
+use ra_vfs::{VfsTask, Watch};
 use relative_path::RelativePathBuf;
 use rustc_hash::FxHashSet;
 use serde::{de::DeserializeOwned, Serialize};
@@ -35,9 +35,9 @@ use threadpool::ThreadPool;
 use crate::{
    config::{Config, FilesWatcher, LinkedProject},
-    diagnostics::{to_proto::url_from_path_with_drive_lowercasing, DiagnosticTask},
+    diagnostics::DiagnosticTask,
    from_proto,
-    global_state::{GlobalState, GlobalStateSnapshot},
+    global_state::{file_id_to_url, GlobalState, GlobalStateSnapshot},
    lsp_ext,
    main_loop::{
        pending_requests::{PendingRequest, PendingRequests},
@@ -121,7 +121,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<_>>()
        };
@@ -664,14 +669,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 +697,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();
+                old_text.replace_range(Range::<usize>::from(range), &change.text);
-                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);
-                    }
-                }
            }
            None => {
                *old_text = change.text;
@@ -729,6 +719,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,
            );
@@ -801,17 +792,9 @@ fn on_diagnostic_task(task: DiagnosticTask, msg_sender: &Sender<Message>, state:
    let subscriptions = state.diagnostics.handle_task(task);
    for file_id in subscriptions {
-        let path = state.vfs.read().file2path(VfsFile(file_id.0));
+        let url = file_id_to_url(&state.vfs.read(), file_id);
-        let uri = match url_from_path_with_drive_lowercasing(&path) {
-            Ok(uri) => uri,
-            Err(err) => {
-                log::error!("Couldn't convert path to url ({}): {}", err, path.display());
-                continue;
-            }
-        };
        let diagnostics = state.diagnostics.diagnostics_for(file_id).cloned().collect();
-        let params = lsp_types::PublishDiagnosticsParams { uri, diagnostics, version: None };
+        let params = lsp_types::PublishDiagnosticsParams { uri: url, diagnostics, version: None };
        let not = notification_new::<lsp_types::notification::PublishDiagnostics>(params);
        msg_sender.send(not.into()).unwrap();
    }
diff --git a/crates/rust-analyzer/src/main_loop/handlers.rs b/crates/rust-analyzer/src/main_loop/handlers.rs
index a41adf8b0..b34b529b5 100644
--- a/crates/rust-analyzer/src/main_loop/handlers.rs
+++ b/crates/rust-analyzer/src/main_loop/handlers.rs
@@ -258,7 +258,7 @@ pub fn handle_document_symbol(
    let res = if snap.config.client_caps.hierarchical_symbols {
        document_symbols.into()
    } else {
-        let url = to_proto::url(&snap, file_id)?;
+        let url = to_proto::url(&snap, file_id);
        let mut symbol_information = Vec::<SymbolInformation>::new();
        for symbol in document_symbols {
            flatten_document_symbol(&symbol, None, &url, &mut symbol_information);
@@ -1160,7 +1160,7 @@ fn show_impl_command_link(
 ) -> Option<lsp_ext::CommandLinkGroup> {
    if snap.config.hover.implementations {
        if let Some(nav_data) = snap.analysis().goto_implementation(*position).unwrap_or(None) {
-            let uri = to_proto::url(snap, position.file_id).ok()?;
+            let uri = to_proto::url(snap, position.file_id);
            let line_index = snap.analysis().file_line_index(position.file_id).ok()?;
            let position = to_proto::position(&line_index, position.offset);
            let locations: Vec<_> = nav_data
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 710df1fbd..055c97455 100644
--- a/crates/rust-analyzer/src/to_proto.rs
+++ b/crates/rust-analyzer/src/to_proto.rs
@@ -1,4 +1,7 @@
 //! Conversion of rust-analyzer specific types to lsp_types equivalents.
+use std::path::{self, Path};
+use itertools::Itertools;
 use ra_db::{FileId, FileRange};
 use ra_ide::{
    Assist, CompletionItem, CompletionItemKind, Documentation, FileSystemEdit, Fold, FoldKind,
@@ -321,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() {
@@ -385,24 +389,55 @@ pub(crate) fn folding_range(
    }
 }
-pub(crate) fn url(snap: &GlobalStateSnapshot, file_id: FileId) -> Result<lsp_types::Url> {
+pub(crate) fn url(snap: &GlobalStateSnapshot, file_id: FileId) -> lsp_types::Url {
-    snap.file_id_to_uri(file_id)
+    snap.file_id_to_url(file_id)
+}
+/// Returns a `Url` object from a given path, will lowercase drive letters if present.
+/// This will only happen when processing windows paths.
+///
+/// When processing non-windows path, this is essentially the same as `Url::from_file_path`.
+pub(crate) fn url_from_abs_path(path: &Path) -> lsp_types::Url {
+    assert!(path.is_absolute());
+    let url = lsp_types::Url::from_file_path(path).unwrap();
+    match path.components().next() {
+        Some(path::Component::Prefix(prefix)) if matches!(prefix.kind(), path::Prefix::Disk(_) | path::Prefix::VerbatimDisk(_)) =>
+        {
+            // Need to lowercase driver letter
+        }
+        _ => return url,
+    }
+    let driver_letter_range = {
+        let (scheme, drive_letter, _rest) = match url.as_str().splitn(3, ':').collect_tuple() {
+            Some(it) => it,
+            None => return url,
+        };
+        let start = scheme.len() + ':'.len_utf8();
+        start..(start + drive_letter.len())
+    };
+    // Note: lowercasing the `path` itself doesn't help, the `Url::parse`
+    // machinery *also* canonicalizes the drive letter. So, just massage the
+    // string in place.
+    let mut url = url.into_string();
+    url[driver_letter_range].make_ascii_lowercase();
+    lsp_types::Url::parse(&url).unwrap()
 }
 pub(crate) fn versioned_text_document_identifier(
    snap: &GlobalStateSnapshot,
    file_id: FileId,
    version: Option<i64>,
-) -> Result<lsp_types::VersionedTextDocumentIdentifier> {
+) -> lsp_types::VersionedTextDocumentIdentifier {
-    let res = lsp_types::VersionedTextDocumentIdentifier { uri: url(snap, file_id)?, version };
+    lsp_types::VersionedTextDocumentIdentifier { uri: url(snap, file_id), version }
-    Ok(res)
 }
 pub(crate) fn location(
    snap: &GlobalStateSnapshot,
    frange: FileRange,
 ) -> Result<lsp_types::Location> {
-    let url = url(snap, frange.file_id)?;
+    let url = url(snap, frange.file_id);
    let line_index = snap.analysis().file_line_index(frange.file_id)?;
    let range = range(&line_index, frange.range);
    let loc = lsp_types::Location::new(url, range);
@@ -438,7 +473,7 @@ fn location_info(
 ) -> Result<(lsp_types::Url, lsp_types::Range, lsp_types::Range)> {
    let line_index = snap.analysis().file_line_index(target.file_id())?;
-    let target_uri = url(snap, target.file_id())?;
+    let target_uri = url(snap, target.file_id());
    let target_range = range(&line_index, target.full_range());
    let target_selection_range =
        target.focus_range().map(|it| range(&line_index, it)).unwrap_or(target_range);
@@ -478,7 +513,7 @@ pub(crate) fn snippet_text_document_edit(
    is_snippet: bool,
    source_file_edit: SourceFileEdit,
 ) -> Result<lsp_ext::SnippetTextDocumentEdit> {
-    let text_document = versioned_text_document_identifier(snap, source_file_edit.file_id, None)?;
+    let text_document = versioned_text_document_identifier(snap, source_file_edit.file_id, None);
    let line_index = snap.analysis().file_line_index(source_file_edit.file_id)?;
    let line_endings = snap.file_line_endings(source_file_edit.file_id);
    let edits = source_file_edit
@@ -492,19 +527,18 @@ pub(crate) fn snippet_text_document_edit(
 pub(crate) fn resource_op(
    snap: &GlobalStateSnapshot,
    file_system_edit: FileSystemEdit,
-) -> Result<lsp_types::ResourceOp> {
+) -> lsp_types::ResourceOp {
-    let res = match file_system_edit {
+    match file_system_edit {
-        FileSystemEdit::CreateFile { source_root, path } => {
+        FileSystemEdit::CreateFile { anchor, dst } => {
-            let uri = snap.path_to_uri(source_root, &path)?;
+            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_uri(src)?;
+            let old_uri = snap.file_id_to_url(src);
-            let new_uri = snap.path_to_uri(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 })
        }
-    };
+    }
-    Ok(res)
 }
 pub(crate) fn snippet_workspace_edit(
@@ -513,7 +547,7 @@ pub(crate) fn snippet_workspace_edit(
 ) -> Result<lsp_ext::SnippetWorkspaceEdit> {
    let mut document_changes: Vec<lsp_ext::SnippetDocumentChangeOperation> = Vec::new();
    for op in source_change.file_system_edits {
-        let op = resource_op(&snap, op)?;
+        let op = resource_op(&snap, op);
        document_changes.push(lsp_ext::SnippetDocumentChangeOperation::Op(op));
    }
    for edit in source_change.source_file_edits {
@@ -568,7 +602,7 @@ impl From<lsp_ext::SnippetWorkspaceEdit> for lsp_types::WorkspaceEdit {
    }
 }
-pub fn call_hierarchy_item(
+pub(crate) fn call_hierarchy_item(
    snap: &GlobalStateSnapshot,
    target: NavigationTarget,
 ) -> Result<lsp_types::CallHierarchyItem> {
@@ -579,50 +613,6 @@ pub fn call_hierarchy_item(
    Ok(lsp_types::CallHierarchyItem { name, kind, tags: None, detail, uri, range, selection_range })
 }
-#[cfg(test)]
-mod tests {
-    use test_utils::extract_ranges;
-    use super::*;
-    #[test]
-    fn conv_fold_line_folding_only_fixup() {
-        let text = r#"<fold>mod a;
-mod b;
-mod c;</fold>
-fn main() <fold>{
-    if cond <fold>{
-        a::do_a();
-    }</fold> else <fold>{
-        b::do_b();
-    }</fold>
-}</fold>"#;
-        let (ranges, text) = extract_ranges(text, "fold");
-        assert_eq!(ranges.len(), 4);
-        let folds = vec![
-            Fold { range: ranges[0], kind: FoldKind::Mods },
-            Fold { range: ranges[1], kind: FoldKind::Block },
-            Fold { range: ranges[2], kind: FoldKind::Block },
-            Fold { range: ranges[3], kind: FoldKind::Block },
-        ];
-        let line_index = LineIndex::new(&text);
-        let converted: Vec<lsp_types::FoldingRange> =
-            folds.into_iter().map(|it| folding_range(&text, &line_index, true, it)).collect();
-        let expected_lines = [(0, 2), (4, 10), (5, 6), (7, 9)];
-        assert_eq!(converted.len(), expected_lines.len());
-        for (folding_range, (start_line, end_line)) in converted.iter().zip(expected_lines.iter()) {
-            assert_eq!(folding_range.start_line, *start_line);
-            assert_eq!(folding_range.start_character, None);
-            assert_eq!(folding_range.end_line, *end_line);
-            assert_eq!(folding_range.end_character, None);
-        }
-    }
-}
 pub(crate) fn unresolved_code_action(
    snap: &GlobalStateSnapshot,
    assist: Assist,
@@ -676,3 +666,62 @@ pub(crate) fn runnable(
        },
    })
 }
+#[cfg(test)]
+mod tests {
+    use test_utils::extract_ranges;
+    use super::*;
+    #[test]
+    fn conv_fold_line_folding_only_fixup() {
+        let text = r#"<fold>mod a;
+mod b;
+mod c;</fold>
+fn main() <fold>{
+    if cond <fold>{
+        a::do_a();
+    }</fold> else <fold>{
+        b::do_b();
+    }</fold>
+}</fold>"#;
+        let (ranges, text) = extract_ranges(text, "fold");
+        assert_eq!(ranges.len(), 4);
+        let folds = vec![
+            Fold { range: ranges[0], kind: FoldKind::Mods },
+            Fold { range: ranges[1], kind: FoldKind::Block },
+            Fold { range: ranges[2], kind: FoldKind::Block },
+            Fold { range: ranges[3], kind: FoldKind::Block },
+        ];
+        let line_index = LineIndex::new(&text);
+        let converted: Vec<lsp_types::FoldingRange> =
+            folds.into_iter().map(|it| folding_range(&text, &line_index, true, it)).collect();
+        let expected_lines = [(0, 2), (4, 10), (5, 6), (7, 9)];
+        assert_eq!(converted.len(), expected_lines.len());
+        for (folding_range, (start_line, end_line)) in converted.iter().zip(expected_lines.iter()) {
+            assert_eq!(folding_range.start_line, *start_line);
+            assert_eq!(folding_range.start_character, None);
+            assert_eq!(folding_range.end_line, *end_line);
+            assert_eq!(folding_range.end_character, None);
+        }
+    }
+    // `Url` is not able to parse windows paths on unix machines.
+    #[test]
+    #[cfg(target_os = "windows")]
+    fn test_lowercase_drive_letter_with_drive() {
+        let url = url_from_abs_path(Path::new("C:\\Test"));
+        assert_eq!(url.to_string(), "file:///c:/Test");
+    }
+    #[test]
+    #[cfg(target_os = "windows")]
+    fn test_drive_without_colon_passthrough() {
+        let url = url_from_abs_path(Path::new(r#"\\localhost\C$\my_dir"#));
+        assert_eq!(url.to_string(), "file://localhost/C$/my_dir");
+    }
+}
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()
+}