58 files changed, 2312 insertions, 1045 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 var_head = var.syntax().first_child().map(|node| node.text());
+    let first_node_text = |pat: &Pat| pat.syntax().first_child().map(|node| node.text());
+
+    let pat_head = match pat {
+        Pat::BindPat(bind_pat) => {
+            if let Some(p) = bind_pat.pat() {
+                first_node_text(&p)
+            } else {
+                return false;
+            }
+        }
+        pat => first_node_text(pat),
+    };
+
+    let var_head = first_node_text(var);
 
     pat_head == var_head
 }
@@ -351,6 +363,40 @@ mod tests {
     }
 
     #[test]
+    fn partial_fill_bind_pat() {
+        check_assist(
+            fill_match_arms,
+            r#"
+            enum A {
+                As,
+                Bs,
+                Cs(Option<i32>),
+            }
+            fn main() {
+                match A::As<|> {
+                    A::As(_) => {}
+                    a @ A::Bs(_) => {}
+                }
+            }
+            "#,
+            r#"
+            enum A {
+                As,
+                Bs,
+                Cs(Option<i32>),
+            }
+            fn main() {
+                match A::As {
+                    A::As(_) => {}
+                    a @ A::Bs(_) => {}
+                    $0A::Cs(_) => {}
+                }
+            }
+            "#,
+        );
+    }
+
+    #[test]
     fn fill_match_arms_empty_body() {
         check_assist(
             fill_match_arms,
diff --git a/crates/ra_assists/src/handlers/replace_qualified_name_with_use.rs b/crates/ra_assists/src/handlers/replace_qualified_name_with_use.rs
index 0197a8cf0..b4784c333 100644
--- a/crates/ra_assists/src/handlers/replace_qualified_name_with_use.rs
+++ b/crates/ra_assists/src/handlers/replace_qualified_name_with_use.rs
@@ -1,7 +1,10 @@
 use hir;
-use ra_syntax::{ast, AstNode, SmolStr, TextRange};
+use ra_syntax::{algo::SyntaxRewriter, ast, match_ast, AstNode, SmolStr, SyntaxNode};
 
-use crate::{utils::insert_use_statement, AssistContext, AssistId, Assists};
+use crate::{
+    utils::{find_insert_use_container, insert_use_statement},
+    AssistContext, AssistId, Assists,
+};
 
 // Assist: replace_qualified_name_with_use
 //
@@ -39,16 +42,18 @@ pub(crate) fn replace_qualified_name_with_use(
         target,
         |builder| {
             let path_to_import = hir_path.mod_path().clone();
+            let container = match find_insert_use_container(path.syntax(), ctx) {
+                Some(c) => c,
+                None => return,
+            };
             insert_use_statement(path.syntax(), &path_to_import, ctx, builder.text_edit_builder());
 
-            if let Some(last) = path.segment() {
-                // Here we are assuming the assist will provide a correct use statement
-                // so we can delete the path qualifier
-                builder.delete(TextRange::new(
-                    path.syntax().text_range().start(),
-                    last.syntax().text_range().start(),
-                ));
-            }
+            // Now that we've brought the name into scope, re-qualify all paths that could be
+            // affected (that is, all paths inside the node we added the `use` to).
+            let mut rewriter = SyntaxRewriter::default();
+            let syntax = container.either(|l| l.syntax().clone(), |r| r.syntax().clone());
+            shorten_paths(&mut rewriter, syntax, path);
+            builder.rewrite(rewriter);
         },
     )
 }
@@ -73,6 +78,69 @@ fn collect_hir_path_segments(path: &hir::Path) -> Option<Vec<SmolStr>> {
     Some(ps)
 }
 
+/// Adds replacements to `re` that shorten `path` in all descendants of `node`.
+fn shorten_paths(rewriter: &mut SyntaxRewriter<'static>, node: SyntaxNode, path: ast::Path) {
+    for child in node.children() {
+        match_ast! {
+            match child {
+                // Don't modify `use` items, as this can break the `use` item when injecting a new
+                // import into the use tree.
+                ast::UseItem(_it) => continue,
+                // Don't descend into submodules, they don't have the same `use` items in scope.
+                ast::Module(_it) => continue,
+
+                ast::Path(p) => {
+                    match maybe_replace_path(rewriter, p.clone(), path.clone()) {
+                        Some(()) => {},
+                        None => shorten_paths(rewriter, p.syntax().clone(), path.clone()),
+                    }
+                },
+                _ => shorten_paths(rewriter, child, path.clone()),
+            }
+        }
+    }
+}
+
+fn maybe_replace_path(
+    rewriter: &mut SyntaxRewriter<'static>,
+    path: ast::Path,
+    target: ast::Path,
+) -> Option<()> {
+    if !path_eq(path.clone(), target.clone()) {
+        return None;
+    }
+
+    // Shorten `path`, leaving only its last segment.
+    if let Some(parent) = path.qualifier() {
+        rewriter.delete(parent.syntax());
+    }
+    if let Some(double_colon) = path.coloncolon_token() {
+        rewriter.delete(&double_colon);
+    }
+
+    Some(())
+}
+
+fn path_eq(lhs: ast::Path, rhs: ast::Path) -> bool {
+    let mut lhs_curr = lhs;
+    let mut rhs_curr = rhs;
+    loop {
+        match (lhs_curr.segment(), rhs_curr.segment()) {
+            (Some(lhs), Some(rhs)) if lhs.syntax().text() == rhs.syntax().text() => (),
+            _ => return false,
+        }
+
+        match (lhs_curr.qualifier(), rhs_curr.qualifier()) {
+            (Some(lhs), Some(rhs)) => {
+                lhs_curr = lhs;
+                rhs_curr = rhs;
+            }
+            (None, None) => return true,
+            _ => return false,
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use crate::tests::{check_assist, check_assist_not_applicable};
@@ -83,10 +151,10 @@ mod tests {
     fn test_replace_add_use_no_anchor() {
         check_assist(
             replace_qualified_name_with_use,
-            "
+            r"
 std::fmt::Debug<|>
     ",
-            "
+            r"
 use std::fmt::Debug;
 
 Debug
@@ -97,13 +165,13 @@ Debug
     fn test_replace_add_use_no_anchor_with_item_below() {
         check_assist(
             replace_qualified_name_with_use,
-            "
+            r"
 std::fmt::Debug<|>
 
 fn main() {
 }
     ",
-            "
+            r"
 use std::fmt::Debug;
 
 Debug
@@ -118,13 +186,13 @@ fn main() {
     fn test_replace_add_use_no_anchor_with_item_above() {
         check_assist(
             replace_qualified_name_with_use,
-            "
+            r"
 fn main() {
 }
 
 std::fmt::Debug<|>
     ",
-            "
+            r"
 use std::fmt::Debug;
 
 fn main() {
@@ -139,10 +207,10 @@ Debug
     fn test_replace_add_use_no_anchor_2seg() {
         check_assist(
             replace_qualified_name_with_use,
-            "
+            r"
 std::fmt<|>::Debug
     ",
-            "
+            r"
 use std::fmt;
 
 fmt::Debug
@@ -154,13 +222,13 @@ fmt::Debug
     fn test_replace_add_use() {
         check_assist(
             replace_qualified_name_with_use,
-            "
+            r"
 use stdx;
 
 impl std::fmt::Debug<|> for Foo {
 }
     ",
-            "
+            r"
 use stdx;
 use std::fmt::Debug;
 
@@ -174,11 +242,11 @@ impl Debug for Foo {
     fn test_replace_file_use_other_anchor() {
         check_assist(
             replace_qualified_name_with_use,
-            "
+            r"
 impl std::fmt::Debug<|> for Foo {
 }
     ",
-            "
+            r"
 use std::fmt::Debug;
 
 impl Debug for Foo {
@@ -191,11 +259,11 @@ impl Debug for Foo {
     fn test_replace_add_use_other_anchor_indent() {
         check_assist(
             replace_qualified_name_with_use,
-            "
+            r"
     impl std::fmt::Debug<|> for Foo {
     }
     ",
-            "
+            r"
     use std::fmt::Debug;
 
     impl Debug for Foo {
@@ -208,13 +276,13 @@ impl Debug for Foo {
     fn test_replace_split_different() {
         check_assist(
             replace_qualified_name_with_use,
-            "
+            r"
 use std::fmt;
 
 impl std::io<|> for Foo {
 }
     ",
-            "
+            r"
 use std::{io, fmt};
 
 impl io for Foo {
@@ -227,13 +295,13 @@ impl io for Foo {
     fn test_replace_split_self_for_use() {
         check_assist(
             replace_qualified_name_with_use,
-            "
+            r"
 use std::fmt;
 
 impl std::fmt::Debug<|> for Foo {
 }
     ",
-            "
+            r"
 use std::fmt::{self, Debug, };
 
 impl Debug for Foo {
@@ -246,13 +314,13 @@ impl Debug for Foo {
     fn test_replace_split_self_for_target() {
         check_assist(
             replace_qualified_name_with_use,
-            "
+            r"
 use std::fmt::Debug;
 
 impl std::fmt<|> for Foo {
 }
     ",
-            "
+            r"
 use std::fmt::{self, Debug};
 
 impl fmt for Foo {
@@ -265,13 +333,13 @@ impl fmt for Foo {
     fn test_replace_add_to_nested_self_nested() {
         check_assist(
             replace_qualified_name_with_use,
-            "
+            r"
 use std::fmt::{Debug, nested::{Display}};
 
 impl std::fmt::nested<|> for Foo {
 }
 ",
-            "
+            r"
 use std::fmt::{Debug, nested::{Display, self}};
 
 impl nested for Foo {
@@ -284,13 +352,13 @@ impl nested for Foo {
     fn test_replace_add_to_nested_self_already_included() {
         check_assist(
             replace_qualified_name_with_use,
-            "
+            r"
 use std::fmt::{Debug, nested::{self, Display}};
 
 impl std::fmt::nested<|> for Foo {
 }
 ",
-            "
+            r"
 use std::fmt::{Debug, nested::{self, Display}};
 
 impl nested for Foo {
@@ -303,13 +371,13 @@ impl nested for Foo {
     fn test_replace_add_to_nested_nested() {
         check_assist(
             replace_qualified_name_with_use,
-            "
+            r"
 use std::fmt::{Debug, nested::{Display}};
 
 impl std::fmt::nested::Debug<|> for Foo {
 }
 ",
-            "
+            r"
 use std::fmt::{Debug, nested::{Display, Debug}};
 
 impl Debug for Foo {
@@ -322,13 +390,13 @@ impl Debug for Foo {
     fn test_replace_split_common_target_longer() {
         check_assist(
             replace_qualified_name_with_use,
-            "
+            r"
 use std::fmt::Debug;
 
 impl std::fmt::nested::Display<|> for Foo {
 }
 ",
-            "
+            r"
 use std::fmt::{nested::Display, Debug};
 
 impl Display for Foo {
@@ -341,13 +409,13 @@ impl Display for Foo {
     fn test_replace_split_common_use_longer() {
         check_assist(
             replace_qualified_name_with_use,
-            "
+            r"
 use std::fmt::nested::Debug;
 
 impl std::fmt::Display<|> for Foo {
 }
 ",
-            "
+            r"
 use std::fmt::{Display, nested::Debug};
 
 impl Display for Foo {
@@ -360,7 +428,7 @@ impl Display for Foo {
     fn test_replace_use_nested_import() {
         check_assist(
             replace_qualified_name_with_use,
-            "
+            r"
 use crate::{
     ty::{Substs, Ty},
     AssocItem,
@@ -368,7 +436,7 @@ use crate::{
 
 fn foo() { crate::ty::lower<|>::trait_env() }
 ",
-            "
+            r"
 use crate::{
     ty::{Substs, Ty, lower},
     AssocItem,
@@ -383,13 +451,13 @@ fn foo() { lower::trait_env() }
     fn test_replace_alias() {
         check_assist(
             replace_qualified_name_with_use,
-            "
+            r"
 use std::fmt as foo;
 
 impl foo::Debug<|> for Foo {
 }
 ",
-            "
+            r"
 use std::fmt as foo;
 
 impl Debug for Foo {
@@ -402,7 +470,7 @@ impl Debug for Foo {
     fn test_replace_not_applicable_one_segment() {
         check_assist_not_applicable(
             replace_qualified_name_with_use,
-            "
+            r"
 impl foo<|> for Foo {
 }
 ",
@@ -413,7 +481,7 @@ impl foo<|> for Foo {
     fn test_replace_not_applicable_in_use() {
         check_assist_not_applicable(
             replace_qualified_name_with_use,
-            "
+            r"
 use std::fmt<|>;
 ",
         );
@@ -423,14 +491,14 @@ use std::fmt<|>;
     fn test_replace_add_use_no_anchor_in_mod_mod() {
         check_assist(
             replace_qualified_name_with_use,
-            "
+            r"
 mod foo {
     mod bar {
         std::fmt::Debug<|>
     }
 }
     ",
-            "
+            r"
 mod foo {
     mod bar {
         use std::fmt::Debug;
@@ -446,14 +514,14 @@ mod foo {
     fn inserts_imports_after_inner_attributes() {
         check_assist(
             replace_qualified_name_with_use,
-            "
+            r"
 #![allow(dead_code)]
 
 fn main() {
     std::fmt::Debug<|>
 }
     ",
-            "
+            r"
 #![allow(dead_code)]
 use std::fmt::Debug;
 
@@ -463,4 +531,116 @@ fn main() {
     ",
         );
     }
+
+    #[test]
+    fn replaces_all_affected_paths() {
+        check_assist(
+            replace_qualified_name_with_use,
+            r"
+fn main() {
+    std::fmt::Debug<|>;
+    let x: std::fmt::Debug = std::fmt::Debug;
+}
+    ",
+            r"
+use std::fmt::Debug;
+
+fn main() {
+    Debug;
+    let x: Debug = Debug;
+}
+    ",
+        );
+    }
+
+    #[test]
+    fn replaces_all_affected_paths_mod() {
+        check_assist(
+            replace_qualified_name_with_use,
+            r"
+mod m {
+    fn f() {
+        std::fmt::Debug<|>;
+        let x: std::fmt::Debug = std::fmt::Debug;
+    }
+    fn g() {
+        std::fmt::Debug;
+    }
+}
+
+fn f() {
+    std::fmt::Debug;
+}
+    ",
+            r"
+mod m {
+    use std::fmt::Debug;
+
+    fn f() {
+        Debug;
+        let x: Debug = Debug;
+    }
+    fn g() {
+        Debug;
+    }
+}
+
+fn f() {
+    std::fmt::Debug;
+}
+    ",
+        );
+    }
+
+    #[test]
+    fn does_not_replace_in_submodules() {
+        check_assist(
+            replace_qualified_name_with_use,
+            r"
+fn main() {
+    std::fmt::Debug<|>;
+}
+
+mod sub {
+    fn f() {
+        std::fmt::Debug;
+    }
+}
+    ",
+            r"
+use std::fmt::Debug;
+
+fn main() {
+    Debug;
+}
+
+mod sub {
+    fn f() {
+        std::fmt::Debug;
+    }
+}
+    ",
+        );
+    }
+
+    #[test]
+    fn does_not_replace_in_use() {
+        check_assist(
+            replace_qualified_name_with_use,
+            r"
+use std::fmt::Display;
+
+fn main() {
+    std::fmt<|>;
+}
+    ",
+            r"
+use std::fmt::{self, Display};
+
+fn main() {
+    fmt;
+}
+    ",
+        );
+    }
 }
diff --git a/crates/ra_assists/src/utils.rs b/crates/ra_assists/src/utils.rs
index 0038a9764..c1ff0de7b 100644
--- a/crates/ra_assists/src/utils.rs
+++ b/crates/ra_assists/src/utils.rs
@@ -13,7 +13,7 @@ use rustc_hash::FxHashSet;
 
 use crate::assist_config::SnippetCap;
 
-pub(crate) use insert_use::insert_use_statement;
+pub(crate) use insert_use::{find_insert_use_container, insert_use_statement};
 
 #[derive(Clone, Copy, Debug)]
 pub(crate) enum Cursor<'a> {
diff --git a/crates/ra_assists/src/utils/insert_use.rs b/crates/ra_assists/src/utils/insert_use.rs
index 0ee43482f..8c4f33e59 100644
--- a/crates/ra_assists/src/utils/insert_use.rs
+++ b/crates/ra_assists/src/utils/insert_use.rs
@@ -12,6 +12,20 @@ use ra_syntax::{
 use ra_text_edit::TextEditBuilder;
 
 use crate::assist_context::AssistContext;
+use either::Either;
+
+/// Determines the containing syntax node in which to insert a `use` statement affecting `position`.
+pub(crate) fn find_insert_use_container(
+    position: &SyntaxNode,
+    ctx: &AssistContext,
+) -> Option<Either<ast::ItemList, ast::SourceFile>> {
+    ctx.sema.ancestors_with_macros(position.clone()).find_map(|n| {
+        if let Some(module) = ast::Module::cast(n.clone()) {
+            return module.item_list().map(|it| Either::Left(it));
+        }
+        Some(Either::Right(ast::SourceFile::cast(n)?))
+    })
+}
 
 /// Creates and inserts a use statement for the given path to import.
 /// The use statement is inserted in the scope most appropriate to the
@@ -24,15 +38,11 @@ pub(crate) fn insert_use_statement(
     builder: &mut TextEditBuilder,
 ) {
     let target = path_to_import.to_string().split("::").map(SmolStr::new).collect::<Vec<_>>();
-    let container = ctx.sema.ancestors_with_macros(position.clone()).find_map(|n| {
-        if let Some(module) = ast::Module::cast(n.clone()) {
-            return module.item_list().map(|it| it.syntax().clone());
-        }
-        ast::SourceFile::cast(n).map(|it| it.syntax().clone())
-    });
+    let container = find_insert_use_container(position, ctx);
 
     if let Some(container) = container {
-        let action = best_action_for_target(container, position.clone(), &target);
+        let syntax = container.either(|l| l.syntax().clone(), |r| r.syntax().clone());
+        let action = best_action_for_target(syntax, position.clone(), &target);
         make_assist(&action, &target, builder);
     }
 }
diff --git a/crates/ra_hir_def/src/diagnostics.rs b/crates/ra_hir_def/src/diagnostics.rs
index 510c5e064..30db48f86 100644
--- a/crates/ra_hir_def/src/diagnostics.rs
+++ b/crates/ra_hir_def/src/diagnostics.rs
@@ -3,7 +3,6 @@
 use std::any::Any;
 
 use hir_expand::diagnostics::Diagnostic;
-use ra_db::RelativePathBuf;
 use ra_syntax::{ast, AstPtr, SyntaxNodePtr};
 
 use hir_expand::{HirFileId, InFile};
@@ -12,7 +11,7 @@ use hir_expand::{HirFileId, InFile};
 pub struct UnresolvedModule {
     pub file: HirFileId,
     pub decl: AstPtr<ast::Module>,
-    pub candidate: RelativePathBuf,
+    pub candidate: String,
 }
 
 impl Diagnostic for UnresolvedModule {
diff --git a/crates/ra_hir_def/src/nameres.rs b/crates/ra_hir_def/src/nameres.rs
index f279c2ad4..b3e5f491a 100644
--- a/crates/ra_hir_def/src/nameres.rs
+++ b/crates/ra_hir_def/src/nameres.rs
@@ -296,7 +296,6 @@ pub enum ModuleSource {
 
 mod diagnostics {
     use hir_expand::diagnostics::DiagnosticSink;
-    use ra_db::RelativePathBuf;
     use ra_syntax::{ast, AstPtr};
 
     use crate::{db::DefDatabase, diagnostics::UnresolvedModule, nameres::LocalModuleId, AstId};
@@ -306,7 +305,7 @@ mod diagnostics {
         UnresolvedModule {
             module: LocalModuleId,
             declaration: AstId<ast::Module>,
-            candidate: RelativePathBuf,
+            candidate: String,
         },
     }
 
diff --git a/crates/ra_hir_def/src/nameres/mod_resolution.rs b/crates/ra_hir_def/src/nameres/mod_resolution.rs
index cede4a6fc..19fe0615a 100644
--- a/crates/ra_hir_def/src/nameres/mod_resolution.rs
+++ b/crates/ra_hir_def/src/nameres/mod_resolution.rs
@@ -44,7 +44,7 @@ impl ModDir {
         file_id: HirFileId,
         name: &Name,
         attr_path: Option<&SmolStr>,
-    ) -> Result<(FileId, ModDir), RelativePathBuf> {
+    ) -> Result<(FileId, ModDir), String> {
         let file_id = file_id.original_file(db.upcast());
 
         let mut candidate_files = Vec::new();
@@ -52,11 +52,11 @@ impl ModDir {
             Some(attr_path) => {
                 let base =
                     if self.root_non_dir_owner { self.path.parent().unwrap() } else { &self.path };
-                candidate_files.push(base.join(attr_path))
+                candidate_files.push(base.join(attr_path).to_string())
             }
             None => {
-                candidate_files.push(self.path.join(&format!("{}.rs", name)));
-                candidate_files.push(self.path.join(&format!("{}/mod.rs", name)));
+                candidate_files.push(self.path.join(&format!("{}.rs", name)).to_string());
+                candidate_files.push(self.path.join(&format!("{}/mod.rs", name)).to_string());
             }
         };
 
diff --git a/crates/ra_hir_def/src/path.rs b/crates/ra_hir_def/src/path.rs
index ba16442bd..190d6d98d 100644
--- a/crates/ra_hir_def/src/path.rs
+++ b/crates/ra_hir_def/src/path.rs
@@ -154,7 +154,7 @@ pub enum GenericArg {
 
 impl Path {
     /// Converts an `ast::Path` to `Path`. Works with use trees.
-    /// DEPRECATED: It does not handle `$crate` from macro call.
+    #[deprecated = "Doesn't handle hygiene, don't add new calls, remove old ones"]
     pub fn from_ast(path: ast::Path) -> Option<Path> {
         lower::lower_path(path, &Hygiene::new_unhygienic())
     }
diff --git a/crates/ra_hir_ty/src/_match.rs b/crates/ra_hir_ty/src/_match.rs
index 3e6e1e333..02a7a61f1 100644
--- a/crates/ra_hir_ty/src/_match.rs
+++ b/crates/ra_hir_ty/src/_match.rs
@@ -8,11 +8,11 @@
 //! This file includes the logic for exhaustiveness and usefulness checking for
 //! pattern-matching. Specifically, given a list of patterns for a type, we can
 //! tell whether:
-//! (a) the patterns cover every possible constructor for the type [exhaustiveness]
-//! (b) each pattern is necessary [usefulness]
+//! - (a) the patterns cover every possible constructor for the type (exhaustiveness).
+//! - (b) each pattern is necessary (usefulness).
 //!
-//! The algorithm implemented here is a modified version of the one described in:
-//! http://moscova.inria.fr/~maranget/papers/warn/index.html
+//! The algorithm implemented here is a modified version of the one described in
+//! <http://moscova.inria.fr/~maranget/papers/warn/index.html>.
 //! However, to save future implementors from reading the original paper, we
 //! summarise the algorithm here to hopefully save time and be a little clearer
 //! (without being so rigorous).
@@ -37,20 +37,26 @@
 //! new pattern `p`.
 //!
 //! For example, say we have the following:
+//!
+//! ```ignore
+//! // x: (Option<bool>, Result<()>)
+//! match x {
+//!     (Some(true), _) => {}
+//!     (None, Err(())) => {}
+//!     (None, Err(_)) => {}
+//! }
 //! ```
-//!     // x: (Option<bool>, Result<()>)
-//!     match x {
-//!         (Some(true), _) => {}
-//!         (None, Err(())) => {}
-//!         (None, Err(_)) => {}
-//!     }
-//! ```
+//!
 //! Here, the matrix `P` starts as:
+//!
+//! ```text
 //! [
 //!     [(Some(true), _)],
 //!     [(None, Err(()))],
 //!     [(None, Err(_))],
 //! ]
+//! ```
+//!
 //! We can tell it's not exhaustive, because `U(P, _)` is true (we're not covering
 //! `[(Some(false), _)]`, for instance). In addition, row 3 is not useful, because
 //! all the values it covers are already covered by row 2.
@@ -60,53 +66,61 @@
 //! To match the paper, the top of the stack is at the beginning / on the left.
 //!
 //! There are two important operations on pattern-stacks necessary to understand the algorithm:
-//!     1. We can pop a given constructor off the top of a stack. This operation is called
-//!        `specialize`, and is denoted `S(c, p)` where `c` is a constructor (like `Some` or
-//!        `None`) and `p` a pattern-stack.
-//!        If the pattern on top of the stack can cover `c`, this removes the constructor and
-//!        pushes its arguments onto the stack. It also expands OR-patterns into distinct patterns.
-//!        Otherwise the pattern-stack is discarded.
-//!        This essentially filters those pattern-stacks whose top covers the constructor `c` and
-//!        discards the others.
 //!
-//!        For example, the first pattern above initially gives a stack `[(Some(true), _)]`. If we
-//!        pop the tuple constructor, we are left with `[Some(true), _]`, and if we then pop the
-//!        `Some` constructor we get `[true, _]`. If we had popped `None` instead, we would get
-//!        nothing back.
+//! 1. We can pop a given constructor off the top of a stack. This operation is called
+//!    `specialize`, and is denoted `S(c, p)` where `c` is a constructor (like `Some` or
+//!    `None`) and `p` a pattern-stack.
+//!    If the pattern on top of the stack can cover `c`, this removes the constructor and
+//!    pushes its arguments onto the stack. It also expands OR-patterns into distinct patterns.
+//!    Otherwise the pattern-stack is discarded.
+//!    This essentially filters those pattern-stacks whose top covers the constructor `c` and
+//!    discards the others.
+//!
+//!    For example, the first pattern above initially gives a stack `[(Some(true), _)]`. If we
+//!    pop the tuple constructor, we are left with `[Some(true), _]`, and if we then pop the
+//!    `Some` constructor we get `[true, _]`. If we had popped `None` instead, we would get
+//!    nothing back.
+//!
+//!    This returns zero or more new pattern-stacks, as follows. We look at the pattern `p_1`
+//!    on top of the stack, and we have four cases:
+//!
+//!    * 1.1. `p_1 = c(r_1, .., r_a)`, i.e. the top of the stack has constructor `c`. We push onto
+//!           the stack the arguments of this constructor, and return the result:
 //!
-//!        This returns zero or more new pattern-stacks, as follows. We look at the pattern `p_1`
-//!        on top of the stack, and we have four cases:
-//!             1.1. `p_1 = c(r_1, .., r_a)`, i.e. the top of the stack has constructor `c`. We
-//!                  push onto the stack the arguments of this constructor, and return the result:
-//!                     r_1, .., r_a, p_2, .., p_n
-//!             1.2. `p_1 = c'(r_1, .., r_a')` where `c ≠ c'`. We discard the current stack and
-//!                  return nothing.
-//!             1.3. `p_1 = _`. We push onto the stack as many wildcards as the constructor `c` has
-//!                  arguments (its arity), and return the resulting stack:
-//!                     _, .., _, p_2, .., p_n
-//!             1.4. `p_1 = r_1 | r_2`. We expand the OR-pattern and then recurse on each resulting
-//!                  stack:
-//!                     S(c, (r_1, p_2, .., p_n))
-//!                     S(c, (r_2, p_2, .., p_n))
+//!          r_1, .., r_a, p_2, .., p_n
 //!
-//!     2. We can pop a wildcard off the top of the stack. This is called `D(p)`, where `p` is
-//!        a pattern-stack.
-//!        This is used when we know there are missing constructor cases, but there might be
-//!        existing wildcard patterns, so to check the usefulness of the matrix, we have to check
-//!        all its *other* components.
+//!    * 1.2. `p_1 = c'(r_1, .., r_a')` where `c ≠ c'`. We discard the current stack and return
+//!           nothing.
+//!    * 1.3. `p_1 = _`. We push onto the stack as many wildcards as the constructor `c` has
+//!           arguments (its arity), and return the resulting stack:
 //!
-//!        It is computed as follows. We look at the pattern `p_1` on top of the stack,
-//!        and we have three cases:
-//!             1.1. `p_1 = c(r_1, .., r_a)`. We discard the current stack and return nothing.
-//!             1.2. `p_1 = _`. We return the rest of the stack:
-//!                     p_2, .., p_n
-//!             1.3. `p_1 = r_1 | r_2`. We expand the OR-pattern and then recurse on each resulting
-//!               stack.
-//!                     D((r_1, p_2, .., p_n))
-//!                     D((r_2, p_2, .., p_n))
+//!          _, .., _, p_2, .., p_n
 //!
-//!     Note that the OR-patterns are not always used directly in Rust, but are used to derive the
-//!     exhaustive integer matching rules, so they're written here for posterity.
+//!    * 1.4. `p_1 = r_1 | r_2`. We expand the OR-pattern and then recurse on each resulting stack:
+//!
+//!          S(c, (r_1, p_2, .., p_n))
+//!          S(c, (r_2, p_2, .., p_n))
+//!
+//! 2. We can pop a wildcard off the top of the stack. This is called `D(p)`, where `p` is
+//!    a pattern-stack.
+//!    This is used when we know there are missing constructor cases, but there might be
+//!    existing wildcard patterns, so to check the usefulness of the matrix, we have to check
+//!    all its *other* components.
+//!
+//!    It is computed as follows. We look at the pattern `p_1` on top of the stack,
+//!    and we have three cases:
+//!    * 1.1. `p_1 = c(r_1, .., r_a)`. We discard the current stack and return nothing.
+//!    * 1.2. `p_1 = _`. We return the rest of the stack:
+//!
+//!          p_2, .., p_n
+//!
+//!    * 1.3. `p_1 = r_1 | r_2`. We expand the OR-pattern and then recurse on each resulting stack:
+//!
+//!          D((r_1, p_2, .., p_n))
+//!          D((r_2, p_2, .., p_n))
+//!
+//!    Note that the OR-patterns are not always used directly in Rust, but are used to derive the
+//!    exhaustive integer matching rules, so they're written here for posterity.
 //!
 //! Both those operations extend straightforwardly to a list or pattern-stacks, i.e. a matrix, by
 //! working row-by-row. Popping a constructor ends up keeping only the matrix rows that start with
@@ -120,73 +134,88 @@
 //! operates principally on the first component of the matrix and new pattern-stack `p`.
 //! This algorithm is realised in the `is_useful` function.
 //!
-//! Base case. (`n = 0`, i.e., an empty tuple pattern)
-//!     - If `P` already contains an empty pattern (i.e., if the number of patterns `m > 0`),
-//!       then `U(P, p)` is false.
-//!     - Otherwise, `P` must be empty, so `U(P, p)` is true.
+//! Base case (`n = 0`, i.e., an empty tuple pattern):
+//! - If `P` already contains an empty pattern (i.e., if the number of patterns `m > 0`), then
+//!   `U(P, p)` is false.
+//! - Otherwise, `P` must be empty, so `U(P, p)` is true.
+//!
+//! Inductive step (`n > 0`, i.e., whether there's at least one column [which may then be expanded
+//! into further columns later]). We're going to match on the top of the new pattern-stack, `p_1`:
+//!
+//! - If `p_1 == c(r_1, .., r_a)`, i.e. we have a constructor pattern.
+//!   Then, the usefulness of `p_1` can be reduced to whether it is useful when
+//!   we ignore all the patterns in the first column of `P` that involve other constructors.
+//!   This is where `S(c, P)` comes in:
 //!
-//! Inductive step. (`n > 0`, i.e., whether there's at least one column
-//!                  [which may then be expanded into further columns later])
-//!     We're going to match on the top of the new pattern-stack, `p_1`.
-//!         - If `p_1 == c(r_1, .., r_a)`, i.e. we have a constructor pattern.
-//!           Then, the usefulness of `p_1` can be reduced to whether it is useful when
-//!           we ignore all the patterns in the first column of `P` that involve other constructors.
-//!           This is where `S(c, P)` comes in:
-//!           `U(P, p) := U(S(c, P), S(c, p))`
-//!           This special case is handled in `is_useful_specialized`.
+//!   ```text
+//!   U(P, p) := U(S(c, P), S(c, p))
+//!   ```
 //!
-//!           For example, if `P` is:
-//!           [
-//!               [Some(true), _],
-//!               [None, 0],
-//!           ]
-//!           and `p` is [Some(false), 0], then we don't care about row 2 since we know `p` only
-//!           matches values that row 2 doesn't. For row 1 however, we need to dig into the
-//!           arguments of `Some` to know whether some new value is covered. So we compute
-//!           `U([[true, _]], [false, 0])`.
+//!   This special case is handled in `is_useful_specialized`.
 //!
-//!         - If `p_1 == _`, then we look at the list of constructors that appear in the first
-//!               component of the rows of `P`:
-//!             + If there are some constructors that aren't present, then we might think that the
-//!               wildcard `_` is useful, since it covers those constructors that weren't covered
-//!               before.
-//!               That's almost correct, but only works if there were no wildcards in those first
-//!               components. So we need to check that `p` is useful with respect to the rows that
-//!               start with a wildcard, if there are any. This is where `D` comes in:
-//!               `U(P, p) := U(D(P), D(p))`
+//!   For example, if `P` is:
 //!
-//!               For example, if `P` is:
-//!               [
-//!                   [_, true, _],
-//!                   [None, false, 1],
-//!               ]
-//!               and `p` is [_, false, _], the `Some` constructor doesn't appear in `P`. So if we
-//!               only had row 2, we'd know that `p` is useful. However row 1 starts with a
-//!               wildcard, so we need to check whether `U([[true, _]], [false, 1])`.
+//!   ```text
+//!   [
+//!       [Some(true), _],
+//!       [None, 0],
+//!   ]
+//!   ```
 //!
-//!             + Otherwise, all possible constructors (for the relevant type) are present. In this
-//!               case we must check whether the wildcard pattern covers any unmatched value. For
-//!               that, we can think of the `_` pattern as a big OR-pattern that covers all
-//!               possible constructors. For `Option`, that would mean `_ = None | Some(_)` for
-//!               example. The wildcard pattern is useful in this case if it is useful when
-//!               specialized to one of the possible constructors. So we compute:
-//!               `U(P, p) := ∃(k ϵ constructors) U(S(k, P), S(k, p))`
+//!   and `p` is `[Some(false), 0]`, then we don't care about row 2 since we know `p` only
+//!   matches values that row 2 doesn't. For row 1 however, we need to dig into the
+//!   arguments of `Some` to know whether some new value is covered. So we compute
+//!   `U([[true, _]], [false, 0])`.
 //!
-//!               For example, if `P` is:
-//!               [
-//!                   [Some(true), _],
-//!                   [None, false],
-//!               ]
-//!               and `p` is [_, false], both `None` and `Some` constructors appear in the first
-//!               components of `P`. We will therefore try popping both constructors in turn: we
-//!               compute U([[true, _]], [_, false]) for the `Some` constructor, and U([[false]],
-//!               [false]) for the `None` constructor. The first case returns true, so we know that
-//!               `p` is useful for `P`. Indeed, it matches `[Some(false), _]` that wasn't matched
-//!               before.
+//! - If `p_1 == _`, then we look at the list of constructors that appear in the first component of
+//!   the rows of `P`:
+//!     - If there are some constructors that aren't present, then we might think that the
+//!       wildcard `_` is useful, since it covers those constructors that weren't covered
+//!       before.
+//!       That's almost correct, but only works if there were no wildcards in those first
+//!       components. So we need to check that `p` is useful with respect to the rows that
+//!       start with a wildcard, if there are any. This is where `D` comes in:
+//!       `U(P, p) := U(D(P), D(p))`
 //!
-//!         - If `p_1 == r_1 | r_2`, then the usefulness depends on each `r_i` separately:
-//!           `U(P, p) := U(P, (r_1, p_2, .., p_n))
-//!                    || U(P, (r_2, p_2, .., p_n))`
+//!       For example, if `P` is:
+//!       ```text
+//!       [
+//!           [_, true, _],
+//!           [None, false, 1],
+//!       ]
+//!       ```
+//!       and `p` is `[_, false, _]`, the `Some` constructor doesn't appear in `P`. So if we
+//!       only had row 2, we'd know that `p` is useful. However row 1 starts with a
+//!       wildcard, so we need to check whether `U([[true, _]], [false, 1])`.
+//!
+//!     - Otherwise, all possible constructors (for the relevant type) are present. In this
+//!       case we must check whether the wildcard pattern covers any unmatched value. For
+//!       that, we can think of the `_` pattern as a big OR-pattern that covers all
+//!       possible constructors. For `Option`, that would mean `_ = None | Some(_)` for
+//!       example. The wildcard pattern is useful in this case if it is useful when
+//!       specialized to one of the possible constructors. So we compute:
+//!       `U(P, p) := ∃(k ϵ constructors) U(S(k, P), S(k, p))`
+//!
+//!       For example, if `P` is:
+//!       ```text
+//!       [
+//!           [Some(true), _],
+//!           [None, false],
+//!       ]
+//!       ```
+//!       and `p` is `[_, false]`, both `None` and `Some` constructors appear in the first
+//!       components of `P`. We will therefore try popping both constructors in turn: we
+//!       compute `U([[true, _]], [_, false])` for the `Some` constructor, and `U([[false]],
+//!       [false])` for the `None` constructor. The first case returns true, so we know that
+//!       `p` is useful for `P`. Indeed, it matches `[Some(false), _]` that wasn't matched
+//!       before.
+//!
+//! - If `p_1 == r_1 | r_2`, then the usefulness depends on each `r_i` separately:
+//!
+//!   ```text
+//!   U(P, p) := U(P, (r_1, p_2, .., p_n))
+//!            || U(P, (r_2, p_2, .., p_n))
+//!   ```
 use std::sync::Arc;
 
 use smallvec::{smallvec, SmallVec};
@@ -333,7 +362,12 @@ impl PatStack {
         cx: &MatchCheckCtx,
         constructor: &Constructor,
     ) -> MatchCheckResult<Option<PatStack>> {
-        let result = match (self.head().as_pat(cx), constructor) {
+        if self.is_empty() {
+            return Ok(None);
+        }
+
+        let head_pat = self.head().as_pat(cx);
+        let result = match (head_pat, constructor) {
             (Pat::Tuple { args: ref pat_ids, ellipsis }, Constructor::Tuple { arity: _ }) => {
                 if ellipsis.is_some() {
                     // If there are ellipsis here, we should add the correct number of
@@ -502,7 +536,7 @@ impl Matrix {
     }
 
     fn heads(&self) -> Vec<PatIdOrWild> {
-        self.0.iter().map(|p| p.head()).collect()
+        self.0.iter().flat_map(|p| p.get_head()).collect()
     }
 
     /// Computes `D(self)` for each contained PatStack.
@@ -808,194 +842,193 @@ mod tests {
 
     pub(super) use crate::{diagnostics::MissingMatchArms, test_db::TestDB};
 
-    pub(super) fn check_diagnostic_message(content: &str) -> String {
-        TestDB::with_single_file(content).0.diagnostic::<MissingMatchArms>().0
+    pub(super) fn check_diagnostic_message(ra_fixture: &str) -> String {
+        TestDB::with_single_file(ra_fixture).0.diagnostic::<MissingMatchArms>().0
     }
 
-    pub(super) fn check_diagnostic(content: &str) {
+    pub(super) fn check_diagnostic(ra_fixture: &str) {
         let diagnostic_count =
-            TestDB::with_single_file(content).0.diagnostic::<MissingMatchArms>().1;
+            TestDB::with_single_file(ra_fixture).0.diagnostic::<MissingMatchArms>().1;
 
         assert_eq!(1, diagnostic_count, "no diagnostic reported");
     }
 
-    pub(super) fn check_no_diagnostic(content: &str) {
+    pub(super) fn check_no_diagnostic(ra_fixture: &str) {
         let diagnostic_count =
-            TestDB::with_single_file(content).0.diagnostic::<MissingMatchArms>().1;
+            TestDB::with_single_file(ra_fixture).0.diagnostic::<MissingMatchArms>().1;
 
         assert_eq!(0, diagnostic_count, "expected no diagnostic, found one");
     }
 
     #[test]
     fn empty_tuple_no_arms_diagnostic_message() {
-        let content = r"
-            fn test_fn() {
-                match () {
-                }
-            }
-        ";
-
         assert_snapshot!(
-            check_diagnostic_message(content),
+            check_diagnostic_message(r"
+                fn test_fn() {
+                    match () {
+                    }
+                }
+            "),
             @"\"()\": Missing match arm\n"
         );
     }
 
     #[test]
     fn empty_tuple_no_arms() {
-        let content = r"
+        check_diagnostic(
+            r"
             fn test_fn() {
                 match () {
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn empty_tuple_wild() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             fn test_fn() {
                 match () {
                     _ => {}
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn empty_tuple_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             fn test_fn() {
                 match () {
                     () => {}
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn tuple_of_empty_tuple_no_arms() {
-        let content = r"
+        check_diagnostic(
+            r"
             fn test_fn() {
                 match (()) {
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn tuple_of_empty_tuple_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             fn test_fn() {
                 match (()) {
                     (()) => {}
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn tuple_of_two_empty_tuple_no_arms() {
-        let content = r"
+        check_diagnostic(
+            r"
             fn test_fn() {
                 match ((), ()) {
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn tuple_of_two_empty_tuple_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             fn test_fn() {
                 match ((), ()) {
                     ((), ()) => {}
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn bool_no_arms() {
-        let content = r"
+        check_diagnostic(
+            r"
             fn test_fn() {
                 match false {
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn bool_missing_arm() {
-        let content = r"
+        check_diagnostic(
+            r"
             fn test_fn() {
                 match false {
                     true => {}
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn bool_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             fn test_fn() {
                 match false {
                     true => {}
                     false => {}
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn tuple_of_bools_no_arms() {
-        let content = r"
+        check_diagnostic(
+            r"
             fn test_fn() {
                 match (false, true) {
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn tuple_of_bools_missing_arms() {
-        let content = r"
+        check_diagnostic(
+            r"
             fn test_fn() {
                 match (false, true) {
                     (true, true) => {},
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn tuple_of_bools_missing_arm() {
-        let content = r"
+        check_diagnostic(
+            r"
             fn test_fn() {
                 match (false, true) {
                     (false, true) => {},
@@ -1003,14 +1036,14 @@ mod tests {
                     (true, false) => {},
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn tuple_of_bools_with_wilds() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             fn test_fn() {
                 match (false, true) {
                     (false, _) => {},
@@ -1018,14 +1051,14 @@ mod tests {
                     (_, true) => {},
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn tuple_of_bools_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             fn test_fn() {
                 match (false, true) {
                     (true, true) => {},
@@ -1034,27 +1067,27 @@ mod tests {
                     (false, false) => {},
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn tuple_of_bools_binding_missing_arms() {
-        let content = r"
+        check_diagnostic(
+            r"
             fn test_fn() {
                 match (false, true) {
                     (true, _x) => {},
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn tuple_of_bools_binding_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             fn test_fn() {
                 match (false, true) {
                     (true, _x) => {},
@@ -1062,80 +1095,80 @@ mod tests {
                     (false, false) => {},
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn tuple_of_bools_with_ellipsis_at_end_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             fn test_fn() {
                 match (false, true, false) {
                     (false, ..) => {},
                     (true, ..) => {},
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn tuple_of_bools_with_ellipsis_at_beginning_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             fn test_fn() {
                 match (false, true, false) {
                     (.., false) => {},
                     (.., true) => {},
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn tuple_of_bools_with_ellipsis_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             fn test_fn() {
                 match (false, true, false) {
                     (..) => {},
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn tuple_of_tuple_and_bools_no_arms() {
-        let content = r"
+        check_diagnostic(
+            r"
             fn test_fn() {
                 match (false, ((), false)) {
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn tuple_of_tuple_and_bools_missing_arms() {
-        let content = r"
+        check_diagnostic(
+            r"
             fn test_fn() {
                 match (false, ((), false)) {
                     (true, ((), true)) => {},
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn tuple_of_tuple_and_bools_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             fn test_fn() {
                 match (false, ((), false)) {
                     (true, ((), true)) => {},
@@ -1144,27 +1177,27 @@ mod tests {
                     (false, ((), false)) => {},
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn tuple_of_tuple_and_bools_wildcard_missing_arms() {
-        let content = r"
+        check_diagnostic(
+            r"
             fn test_fn() {
                 match (false, ((), false)) {
                     (true, _) => {},
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn tuple_of_tuple_and_bools_wildcard_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             fn test_fn() {
                 match (false, ((), false)) {
                     (true, ((), true)) => {},
@@ -1172,14 +1205,14 @@ mod tests {
                     (false, _) => {},
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_no_arms() {
-        let content = r"
+        check_diagnostic(
+            r"
             enum Either {
                 A,
                 B,
@@ -1188,14 +1221,14 @@ mod tests {
                 match Either::A {
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_missing_arms() {
-        let content = r"
+        check_diagnostic(
+            r"
             enum Either {
                 A,
                 B,
@@ -1205,14 +1238,14 @@ mod tests {
                     Either::A => {},
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             enum Either {
                 A,
                 B,
@@ -1223,14 +1256,14 @@ mod tests {
                     Either::B => {},
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_ref_missing_arms() {
-        let content = r"
+        check_diagnostic(
+            r"
             enum Either {
                 A,
                 B,
@@ -1240,14 +1273,14 @@ mod tests {
                     Either::A => {},
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_ref_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             enum Either {
                 A,
                 B,
@@ -1258,14 +1291,14 @@ mod tests {
                     Either::B => {},
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_containing_bool_no_arms() {
-        let content = r"
+        check_diagnostic(
+            r"
             enum Either {
                 A(bool),
                 B,
@@ -1274,14 +1307,14 @@ mod tests {
                 match Either::B {
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_containing_bool_missing_arms() {
-        let content = r"
+        check_diagnostic(
+            r"
             enum Either {
                 A(bool),
                 B,
@@ -1292,14 +1325,14 @@ mod tests {
                     Either::B => (),
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_containing_bool_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             enum Either {
                 A(bool),
                 B,
@@ -1311,14 +1344,14 @@ mod tests {
                     Either::B => (),
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_containing_bool_with_wild_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             enum Either {
                 A(bool),
                 B,
@@ -1329,14 +1362,14 @@ mod tests {
                     _ => (),
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_containing_bool_with_wild_2_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             enum Either {
                 A(bool),
                 B,
@@ -1347,14 +1380,14 @@ mod tests {
                     Either::B => (),
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_different_sizes_missing_arms() {
-        let content = r"
+        check_diagnostic(
+            r"
             enum Either {
                 A(bool),
                 B(bool, bool),
@@ -1365,14 +1398,14 @@ mod tests {
                     Either::B(false, _) => (),
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_different_sizes_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             enum Either {
                 A(bool),
                 B(bool, bool),
@@ -1384,14 +1417,14 @@ mod tests {
                     Either::B(false, _) => (),
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn or_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             enum Either {
                 A(bool),
                 B(bool, bool),
@@ -1403,14 +1436,14 @@ mod tests {
                     Either::B(false, _) => (),
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn tuple_of_enum_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             enum Either {
                 A(bool),
                 B(bool, bool),
@@ -1427,14 +1460,16 @@ mod tests {
                     (Either::B(_, _), Either2::D) => (),
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn mismatched_types() {
-        let content = r"
+        // Match statements with arms that don't match the
+        // expression pattern do not fire this diagnostic.
+        check_no_diagnostic(
+            r"
             enum Either {
                 A,
                 B,
@@ -1449,47 +1484,47 @@ mod tests {
                     Either2::D => (),
                 }
             }
-        ";
-
-        // Match statements with arms that don't match the
-        // expression pattern do not fire this diagnostic.
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn mismatched_types_with_different_arity() {
-        let content = r"
+        // Match statements with arms that don't match the
+        // expression pattern do not fire this diagnostic.
+        check_no_diagnostic(
+            r"
             fn test_fn() {
                 match (true, false) {
                     (true, false, true) => (),
                     (true) => (),
                 }
             }
-        ";
-
-        // Match statements with arms that don't match the
-        // expression pattern do not fire this diagnostic.
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn malformed_match_arm_tuple_missing_pattern() {
-        let content = r"
+        // Match statements with arms that don't match the
+        // expression pattern do not fire this diagnostic.
+        check_no_diagnostic(
+            r"
             fn test_fn() {
                 match (0) {
                     () => (),
                 }
             }
-        ";
-
-        // Match statements with arms that don't match the
-        // expression pattern do not fire this diagnostic.
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn malformed_match_arm_tuple_enum_missing_pattern() {
-        let content = r"
+        // We are testing to be sure we don't panic here when the match
+        // arm `Either::B` is missing its pattern.
+        check_no_diagnostic(
+            r"
             enum Either {
                 A,
                 B(u32),
@@ -1500,32 +1535,30 @@ mod tests {
                     Either::B() => (),
                 }
             }
-        ";
-
-        // We are testing to be sure we don't panic here when the match
-        // arm `Either::B` is missing its pattern.
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_not_in_scope() {
-        let content = r"
+        // The enum is not in scope so we don't perform exhaustiveness
+        // checking, but we want to be sure we don't panic here (and
+        // we don't create a diagnostic).
+        check_no_diagnostic(
+            r"
             fn test_fn() {
                 match Foo::Bar {
                     Foo::Baz => (),
                 }
             }
-        ";
-
-        // The enum is not in scope so we don't perform exhaustiveness
-        // checking, but we want to be sure we don't panic here (and
-        // we don't create a diagnostic).
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn expr_diverges() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             enum Either {
                 A,
                 B,
@@ -1536,14 +1569,14 @@ mod tests {
                     Either::B => (),
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn expr_loop_with_break() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             enum Either {
                 A,
                 B,
@@ -1554,14 +1587,14 @@ mod tests {
                     Either::B => (),
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn expr_partially_diverges() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             enum Either<T> {
                 A(T),
                 B,
@@ -1575,14 +1608,14 @@ mod tests {
                     Either::B => 0,
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_record_no_arms() {
-        let content = r"
+        check_diagnostic(
+            r"
             enum Either {
                 A { foo: bool },
                 B,
@@ -1592,14 +1625,14 @@ mod tests {
                 match a {
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_record_missing_arms() {
-        let content = r"
+        check_diagnostic(
+            r"
             enum Either {
                 A { foo: bool },
                 B,
@@ -1610,14 +1643,14 @@ mod tests {
                     Either::A { foo: true } => (),
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_record_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             enum Either {
                 A { foo: bool },
                 B,
@@ -1630,14 +1663,17 @@ mod tests {
                     Either::B => (),
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_record_missing_field_no_diagnostic() {
-        let content = r"
+        // When `Either::A` is missing a struct member, we don't want
+        // to fire the missing match arm diagnostic. This should fire
+        // some other diagnostic.
+        check_no_diagnostic(
+            r"
             enum Either {
                 A { foo: bool },
                 B,
@@ -1649,17 +1685,16 @@ mod tests {
                     Either::B => (),
                 }
             }
-        ";
-
-        // When `Either::A` is missing a struct member, we don't want
-        // to fire the missing match arm diagnostic. This should fire
-        // some other diagnostic.
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_record_missing_field_missing_match_arm() {
-        let content = r"
+        // Even though `Either::A` is missing fields, we still want to fire
+        // the missing arm diagnostic here, since we know `Either::B` is missing.
+        check_diagnostic(
+            r"
             enum Either {
                 A { foo: bool },
                 B,
@@ -1670,16 +1705,14 @@ mod tests {
                     Either::A { } => (),
                 }
             }
-        ";
-
-        // Even though `Either::A` is missing fields, we still want to fire
-        // the missing arm diagnostic here, since we know `Either::B` is missing.
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_record_no_diagnostic_wild() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             enum Either {
                 A { foo: bool },
                 B,
@@ -1691,14 +1724,14 @@ mod tests {
                     Either::B => (),
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_record_fields_out_of_order_missing_arm() {
-        let content = r"
+        check_diagnostic(
+            r"
             enum Either {
                 A { foo: bool, bar: () },
                 B,
@@ -1710,14 +1743,14 @@ mod tests {
                     Either::A { foo: true, bar: () } => (),
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_record_fields_out_of_order_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             enum Either {
                 A { foo: bool, bar: () },
                 B,
@@ -1730,89 +1763,89 @@ mod tests {
                     Either::B => (),
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_record_ellipsis_missing_arm() {
-        let content = r"
-             enum Either {
-                 A { foo: bool, bar: bool },
-                 B,
-             }
-             fn test_fn() {
-                 match Either::B {
-                     Either::A { foo: true, .. } => (),
-                     Either::B => (),
-                 }
-             }
-         ";
-
-        check_diagnostic(content);
+        check_diagnostic(
+            r"
+            enum Either {
+                A { foo: bool, bar: bool },
+                B,
+            }
+            fn test_fn() {
+                match Either::B {
+                    Either::A { foo: true, .. } => (),
+                    Either::B => (),
+                }
+            }
+        ",
+        );
     }
 
     #[test]
     fn enum_record_ellipsis_no_diagnostic() {
-        let content = r"
-             enum Either {
-                 A { foo: bool, bar: bool },
-                 B,
-             }
-             fn test_fn() {
-                 let a = Either::A { foo: true };
-                 match a {
-                     Either::A { foo: true, .. } => (),
-                     Either::A { foo: false, .. } => (),
-                     Either::B => (),
-                 }
-             }
-         ";
-
-        check_no_diagnostic(content);
+        check_no_diagnostic(
+            r"
+            enum Either {
+                A { foo: bool, bar: bool },
+                B,
+            }
+            fn test_fn() {
+                let a = Either::A { foo: true };
+                match a {
+                    Either::A { foo: true, .. } => (),
+                    Either::A { foo: false, .. } => (),
+                    Either::B => (),
+                }
+            }
+        ",
+        );
     }
 
     #[test]
     fn enum_record_ellipsis_all_fields_missing_arm() {
-        let content = r"
-             enum Either {
-                 A { foo: bool, bar: bool },
-                 B,
-             }
-             fn test_fn() {
-                 let a = Either::B;
-                 match a {
-                     Either::A { .. } => (),
-                 }
-             }
-         ";
-
-        check_diagnostic(content);
+        check_diagnostic(
+            r"
+            enum Either {
+                A { foo: bool, bar: bool },
+                B,
+            }
+            fn test_fn() {
+                let a = Either::B;
+                match a {
+                    Either::A { .. } => (),
+                }
+            }
+        ",
+        );
     }
 
     #[test]
     fn enum_record_ellipsis_all_fields_no_diagnostic() {
-        let content = r"
-             enum Either {
-                 A { foo: bool, bar: bool },
-                 B,
-             }
-             fn test_fn() {
-                 let a = Either::B;
-                 match a {
-                     Either::A { .. } => (),
-                     Either::B => (),
-                 }
-             }
-         ";
-
-        check_no_diagnostic(content);
+        check_no_diagnostic(
+            r"
+            enum Either {
+                A { foo: bool, bar: bool },
+                B,
+            }
+            fn test_fn() {
+                let a = Either::B;
+                match a {
+                    Either::A { .. } => (),
+                    Either::B => (),
+                }
+            }
+        ",
+        );
     }
 
     #[test]
     fn enum_tuple_partial_ellipsis_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             enum Either {
                 A(bool, bool, bool, bool),
                 B,
@@ -1826,14 +1859,14 @@ mod tests {
                     Either::B => {},
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_tuple_partial_ellipsis_2_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             enum Either {
                 A(bool, bool, bool, bool),
                 B,
@@ -1847,14 +1880,14 @@ mod tests {
                     Either::B => {},
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_tuple_partial_ellipsis_missing_arm() {
-        let content = r"
+        check_diagnostic(
+            r"
             enum Either {
                 A(bool, bool, bool, bool),
                 B,
@@ -1867,14 +1900,14 @@ mod tests {
                     Either::B => {},
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_tuple_partial_ellipsis_2_missing_arm() {
-        let content = r"
+        check_diagnostic(
+            r"
             enum Either {
                 A(bool, bool, bool, bool),
                 B,
@@ -1887,14 +1920,14 @@ mod tests {
                     Either::B => {},
                 }
             }
-        ";
-
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_tuple_ellipsis_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             enum Either {
                 A(bool, bool, bool, bool),
                 B,
@@ -1905,51 +1938,51 @@ mod tests {
                     Either::B => {},
                 }
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_never() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             enum Never {}
 
             fn test_fn(never: Never) {
                 match never {}
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn type_never() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             fn test_fn(never: !) {
                 match never {}
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn enum_never_ref() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             enum Never {}
 
             fn test_fn(never: &Never) {
                 match never {}
             }
-        ";
-
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn expr_diverges_missing_arm() {
-        let content = r"
+        check_no_diagnostic(
+            r"
             enum Either {
                 A,
                 B,
@@ -1959,9 +1992,27 @@ mod tests {
                     Either::A => (),
                 }
             }
-        ";
+        ",
+        );
+    }
 
-        check_no_diagnostic(content);
+    #[test]
+    fn or_pattern_panic() {
+        check_no_diagnostic(
+            r"
+            pub enum Category {
+                Infinity,
+                Zero,
+            }
+
+            fn panic(a: Category, b: Category) {
+                match (a, b) {
+                    (Category::Zero | Category::Infinity, _) => {}
+                    (_, Category::Zero | Category::Infinity) => {}
+                }
+            }
+        ",
+        );
     }
 }
 
@@ -1981,23 +2032,26 @@ mod false_negatives {
 
     #[test]
     fn integers() {
-        let content = r"
+        // This is a false negative.
+        // We don't currently check integer exhaustiveness.
+        check_no_diagnostic(
+            r"
             fn test_fn() {
                 match 5 {
                     10 => (),
                     11..20 => (),
                 }
             }
-        ";
-
-        // This is a false negative.
-        // We don't currently check integer exhaustiveness.
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn internal_or() {
-        let content = r"
+        // This is a false negative.
+        // We do not currently handle patterns with internal `or`s.
+        check_no_diagnostic(
+            r"
             fn test_fn() {
                 enum Either {
                     A(bool),
@@ -2007,16 +2061,18 @@ mod false_negatives {
                     Either::A(true | false) => (),
                 }
             }
-        ";
-
-        // This is a false negative.
-        // We do not currently handle patterns with internal `or`s.
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn expr_loop_missing_arm() {
-        let content = r"
+        // This is a false negative.
+        // We currently infer the type of `loop { break Foo::A }` to `!`, which
+        // causes us to skip the diagnostic since `Either::A` doesn't type check
+        // with `!`.
+        check_diagnostic(
+            r"
             enum Either {
                 A,
                 B,
@@ -2026,48 +2082,46 @@ mod false_negatives {
                     Either::A => (),
                 }
             }
-        ";
-
-        // This is a false negative.
-        // We currently infer the type of `loop { break Foo::A }` to `!`, which
-        // causes us to skip the diagnostic since `Either::A` doesn't type check
-        // with `!`.
-        check_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn tuple_of_bools_with_ellipsis_at_end_missing_arm() {
-        let content = r"
+        // This is a false negative.
+        // We don't currently handle tuple patterns with ellipsis.
+        check_no_diagnostic(
+            r"
             fn test_fn() {
                 match (false, true, false) {
                     (false, ..) => {},
                 }
             }
-        ";
-
-        // This is a false negative.
-        // We don't currently handle tuple patterns with ellipsis.
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn tuple_of_bools_with_ellipsis_at_beginning_missing_arm() {
-        let content = r"
+        // This is a false negative.
+        // We don't currently handle tuple patterns with ellipsis.
+        check_no_diagnostic(
+            r"
             fn test_fn() {
                 match (false, true, false) {
                     (.., false) => {},
                 }
             }
-        ";
-
-        // This is a false negative.
-        // We don't currently handle tuple patterns with ellipsis.
-        check_no_diagnostic(content);
+        ",
+        );
     }
 
     #[test]
     fn struct_missing_arm() {
-        let content = r"
+        // This is a false negative.
+        // We don't currently handle structs.
+        check_no_diagnostic(
+            r"
             struct Foo {
                 a: bool,
             }
@@ -2076,10 +2130,7 @@ mod false_negatives {
                     Foo { a: true } => {},
                 }
             }
-        ";
-
-        // This is a false negative.
-        // We don't currently handle structs.
-        check_no_diagnostic(content);
+        ",
+        );
     }
 }
diff --git a/crates/ra_ide/src/completion/completion_context.rs b/crates/ra_ide/src/completion/completion_context.rs
index 9f4c582d0..560fb19e6 100644
--- a/crates/ra_ide/src/completion/completion_context.rs
+++ b/crates/ra_ide/src/completion/completion_context.rs
@@ -381,6 +381,7 @@ impl<'a> CompletionContext<'a> {
             self.is_path_type = path.syntax().parent().and_then(ast::PathType::cast).is_some();
             self.has_type_args = segment.type_arg_list().is_some();
 
+            #[allow(deprecated)]
             if let Some(path) = hir::Path::from_ast(path.clone()) {
                 if let Some(path_prefix) = path.qualifier() {
                     self.path_prefix = Some(path_prefix);
diff --git a/crates/ra_ide/src/diagnostics.rs b/crates/ra_ide/src/diagnostics.rs
index e1bfd72f9..fd9abb55b 100644
--- a/crates/ra_ide/src/diagnostics.rs
+++ b/crates/ra_ide/src/diagnostics.rs
@@ -11,7 +11,7 @@ use hir::{
     Semantics,
 };
 use itertools::Itertools;
-use ra_db::{RelativePath, SourceDatabase, SourceDatabaseExt};
+use ra_db::SourceDatabase;
 use ra_ide_db::RootDatabase;
 use ra_prof::profile;
 use ra_syntax::{
@@ -57,14 +57,10 @@ pub(crate) fn diagnostics(db: &RootDatabase, file_id: FileId) -> Vec<Diagnostic>
     })
     .on::<hir::diagnostics::UnresolvedModule, _>(|d| {
         let original_file = d.source().file_id.original_file(db);
-        let source_root = db.file_source_root(original_file);
-        let path = db
-            .file_relative_path(original_file)
-            .parent()
-            .unwrap_or_else(|| RelativePath::new(""))
-            .join(&d.candidate);
-        let fix =
-            Fix::new("Create module", FileSystemEdit::CreateFile { source_root, path }.into());
+        let fix = Fix::new(
+            "Create module",
+            FileSystemEdit::CreateFile { anchor: original_file, dst: d.candidate.clone() }.into(),
+        );
         res.borrow_mut().push(Diagnostic {
             range: sema.diagnostics_range(d).range,
             message: d.message(),
@@ -612,10 +608,10 @@ mod tests {
                             source_file_edits: [],
                             file_system_edits: [
                                 CreateFile {
-                                    source_root: SourceRootId(
-                                        0,
+                                    anchor: FileId(
+                                        1,
                                     ),
-                                    path: "foo.rs",
+                                    dst: "foo.rs",
                                 },
                             ],
                             is_snippet: false,
diff --git a/crates/ra_ide/src/lib.rs b/crates/ra_ide/src/lib.rs
index 28f686767..51dc1f041 100644
--- a/crates/ra_ide/src/lib.rs
+++ b/crates/ra_ide/src/lib.rs
@@ -82,7 +82,7 @@ pub use ra_db::{
     Canceled, CrateGraph, CrateId, Edition, FileId, FilePosition, FileRange, SourceRootId,
 };
 pub use ra_ide_db::{
-    change::{AnalysisChange, LibraryData},
+    change::AnalysisChange,
     line_index::{LineCol, LineIndex},
     search::SearchScope,
     source_change::{FileSystemEdit, SourceChange, SourceFileEdit},
@@ -440,12 +440,14 @@ impl Analysis {
 
     /// Computes syntax highlighting for the given file
     pub fn highlight(&self, file_id: FileId) -> Cancelable<Vec<HighlightedRange>> {
-        self.with_db(|db| syntax_highlighting::highlight(db, file_id, None))
+        self.with_db(|db| syntax_highlighting::highlight(db, file_id, None, false))
     }
 
     /// Computes syntax highlighting for the given file range.
     pub fn highlight_range(&self, frange: FileRange) -> Cancelable<Vec<HighlightedRange>> {
-        self.with_db(|db| syntax_highlighting::highlight(db, frange.file_id, Some(frange.range)))
+        self.with_db(|db| {
+            syntax_highlighting::highlight(db, frange.file_id, Some(frange.range), false)
+        })
     }
 
     /// Computes syntax highlighting for the given file.
diff --git a/crates/ra_ide/src/prime_caches.rs b/crates/ra_ide/src/prime_caches.rs
index 90bf7d25f..c5ab5a1d8 100644
--- a/crates/ra_ide/src/prime_caches.rs
+++ b/crates/ra_ide/src/prime_caches.rs
@@ -7,6 +7,6 @@ use crate::{FileId, RootDatabase};
 
 pub(crate) fn prime_caches(db: &RootDatabase, files: Vec<FileId>) {
     for file in files {
-        let _ = crate::syntax_highlighting::highlight(db, file, None);
+        let _ = crate::syntax_highlighting::highlight(db, file, None, false);
     }
 }
diff --git a/crates/ra_ide/src/references/rename.rs b/crates/ra_ide/src/references/rename.rs
index 915d4f4d3..c4f07f905 100644
--- a/crates/ra_ide/src/references/rename.rs
+++ b/crates/ra_ide/src/references/rename.rs
@@ -1,7 +1,7 @@
 //! FIXME: write short doc here
 
 use hir::{ModuleSource, Semantics};
-use ra_db::{RelativePath, RelativePathBuf, SourceDatabaseExt};
+use ra_db::{RelativePathBuf, SourceDatabaseExt};
 use ra_ide_db::RootDatabase;
 use ra_syntax::{
     algo::find_node_at_offset, ast, ast::TypeAscriptionOwner, lex_single_valid_syntax_kind,
@@ -92,23 +92,14 @@ fn rename_mod(
             ModuleSource::SourceFile(..) => {
                 let mod_path: RelativePathBuf = sema.db.file_relative_path(file_id);
                 // mod is defined in path/to/dir/mod.rs
-                let dst_path = if mod_path.file_stem() == Some("mod") {
-                    mod_path
-                        .parent()
-                        .and_then(|p| p.parent())
-                        .or_else(|| Some(RelativePath::new("")))
-                        .map(|p| p.join(new_name).join("mod.rs"))
+                let dst = if mod_path.file_stem() == Some("mod") {
+                    format!("../{}/mod.rs", new_name)
                 } else {
-                    Some(mod_path.with_file_name(new_name).with_extension("rs"))
+                    format!("{}.rs", new_name)
                 };
-                if let Some(path) = dst_path {
-                    let move_file = FileSystemEdit::MoveFile {
-                        src: file_id,
-                        dst_source_root: sema.db.file_source_root(position.file_id),
-                        dst_path: path,
-                    };
-                    file_system_edits.push(move_file);
-                }
+                let move_file =
+                    FileSystemEdit::MoveFile { src: file_id, anchor: position.file_id, dst };
+                file_system_edits.push(move_file);
             }
             ModuleSource::Module(..) => {}
         }
@@ -623,16 +614,16 @@ mod tests {
     #[test]
     fn test_rename_mod() {
         let (analysis, position) = analysis_and_position(
-            "
-            //- /lib.rs
-            mod bar;
+            r#"
+//- /lib.rs
+mod bar;
 
-            //- /bar.rs
-            mod foo<|>;
+//- /bar.rs
+mod foo<|>;
 
-            //- /bar/foo.rs
-            // emtpy
-            ",
+//- /bar/foo.rs
+// emtpy
+            "#,
         );
         let new_name = "foo2";
         let source_change = analysis.rename(position, new_name).unwrap();
@@ -662,10 +653,10 @@ mod tests {
                             src: FileId(
                                 3,
                             ),
-                            dst_source_root: SourceRootId(
-                                0,
+                            anchor: FileId(
+                                2,
                             ),
-                            dst_path: "bar/foo2.rs",
+                            dst: "foo2.rs",
                         },
                     ],
                     is_snippet: false,
@@ -678,12 +669,12 @@ mod tests {
     #[test]
     fn test_rename_mod_in_dir() {
         let (analysis, position) = analysis_and_position(
-            "
-            //- /lib.rs
-            mod fo<|>o;
-            //- /foo/mod.rs
-            // emtpy
-            ",
+            r#"
+//- /lib.rs
+mod fo<|>o;
+//- /foo/mod.rs
+// emtpy
+            "#,
         );
         let new_name = "foo2";
         let source_change = analysis.rename(position, new_name).unwrap();
@@ -713,10 +704,10 @@ mod tests {
                             src: FileId(
                                 2,
                             ),
-                            dst_source_root: SourceRootId(
-                                0,
+                            anchor: FileId(
+                                1,
                             ),
-                            dst_path: "foo2/mod.rs",
+                            dst: "../foo2/mod.rs",
                         },
                     ],
                     is_snippet: false,
@@ -753,19 +744,19 @@ mod tests {
     #[test]
     fn test_rename_mod_filename_and_path() {
         let (analysis, position) = analysis_and_position(
-            "
-            //- /lib.rs
-            mod bar;
-            fn f() {
-                bar::foo::fun()
-            }
+            r#"
+//- /lib.rs
+mod bar;
+fn f() {
+    bar::foo::fun()
+}
 
-            //- /bar.rs
-            pub mod foo<|>;
+//- /bar.rs
+pub mod foo<|>;
 
-            //- /bar/foo.rs
-            // pub fn fun() {}
-            ",
+//- /bar/foo.rs
+// pub fn fun() {}
+            "#,
         );
         let new_name = "foo2";
         let source_change = analysis.rename(position, new_name).unwrap();
@@ -808,10 +799,10 @@ mod tests {
                             src: FileId(
                                 3,
                             ),
-                            dst_source_root: SourceRootId(
-                                0,
+                            anchor: FileId(
+                                2,
                             ),
-                            dst_path: "bar/foo2.rs",
+                            dst: "foo2.rs",
                         },
                     ],
                     is_snippet: false,
diff --git a/crates/ra_ide/src/snapshots/highlight_doctest.html b/crates/ra_ide/src/snapshots/highlight_doctest.html
index 0ae8c7efc..f92a0aba5 100644
--- a/crates/ra_ide/src/snapshots/highlight_doctest.html
+++ b/crates/ra_ide/src/snapshots/highlight_doctest.html
@@ -25,22 +25,30 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .variable           { color: #DCDCCC; }
 .format_specifier   { color: #CC696B; }
 .mutable            { text-decoration: underline; }
+.unresolved_reference { color: #FC5555; }
+.escape_sequence    { color: #94BFF3; }
 
 .keyword            { color: #F0DFAF; font-weight: bold; }
 .keyword.unsafe     { color: #BC8383; font-weight: bold; }
 .control            { font-style: italic; }
 </style>
-<pre><code><span class="keyword">impl</span> <span class="unresolved_reference">Foo</span> {
+<pre><code><span class="keyword">struct</span> <span class="struct declaration">Foo</span> {
+    <span class="field declaration">bar</span>: <span class="builtin_type">bool</span>,
+}
+
+<span class="keyword">impl</span> <span class="struct">Foo</span> {
+    <span class="keyword">pub</span> <span class="keyword">const</span> <span class="constant declaration">bar</span>: <span class="builtin_type">bool</span> = <span class="bool_literal">true</span>;
+
     <span class="comment">/// Constructs a new `Foo`.</span>
     <span class="comment">///</span>
     <span class="comment">/// # Examples</span>
     <span class="comment">///</span>
     <span class="comment">/// ```</span>
     <span class="comment">/// #</span> <span class="attribute">#![</span><span class="function attribute">allow</span><span class="attribute">(unused_mut)]</span>
-    <span class="comment">/// </span><span class="keyword">let</span> <span class="keyword">mut</span> <span class="variable declaration mutable">foo</span>: <span class="unresolved_reference">Foo</span> = <span class="unresolved_reference">Foo</span>::<span class="unresolved_reference">new</span>();
+    <span class="comment">/// </span><span class="keyword">let</span> <span class="keyword">mut</span> <span class="variable declaration mutable">foo</span>: <span class="struct">Foo</span> = <span class="struct">Foo</span>::<span class="function">new</span>();
     <span class="comment">/// ```</span>
-    <span class="keyword">pub</span> <span class="keyword">const</span> <span class="keyword">fn</span> <span class="function declaration">new</span>() -&gt; <span class="unresolved_reference">Foo</span> {
-        <span class="unresolved_reference">Foo</span> { }
+    <span class="keyword">pub</span> <span class="keyword">const</span> <span class="keyword">fn</span> <span class="function declaration">new</span>() -&gt; <span class="struct">Foo</span> {
+        <span class="struct">Foo</span> { <span class="field">bar</span>: <span class="bool_literal">true</span> }
     }
 
     <span class="comment">/// `bar` method on `Foo`.</span>
@@ -48,11 +56,15 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
     <span class="comment">/// # Examples</span>
     <span class="comment">///</span>
     <span class="comment">/// ```</span>
-    <span class="comment">/// </span><span class="keyword">let</span> <span class="variable declaration">foo</span> = <span class="unresolved_reference">Foo</span>::<span class="unresolved_reference">new</span>();
+    <span class="comment">/// </span><span class="keyword">use</span> <span class="module">x</span>::<span class="module">y</span>;
+    <span class="comment">///</span>
+    <span class="comment">/// </span><span class="keyword">let</span> <span class="variable declaration">foo</span> = <span class="struct">Foo</span>::<span class="function">new</span>();
     <span class="comment">///</span>
     <span class="comment">/// </span><span class="comment">// calls bar on foo</span>
     <span class="comment">/// </span><span class="macro">assert!</span>(foo.bar());
     <span class="comment">///</span>
+    <span class="comment">/// </span><span class="keyword">let</span> <span class="variable declaration">bar</span> = <span class="variable">foo</span>.<span class="field">bar</span> || <span class="struct">Foo</span>::<span class="constant">bar</span>;
+    <span class="comment">///</span>
     <span class="comment">/// </span><span class="comment">/* multi-line
     </span><span class="comment">/// </span><span class="comment">       comment */</span>
     <span class="comment">///</span>
@@ -62,8 +74,12 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
     <span class="comment">///</span>
     <span class="comment">/// ```</span>
     <span class="comment">///</span>
+    <span class="comment">/// ```rust,no_run</span>
+    <span class="comment">/// </span><span class="keyword">let</span> <span class="variable declaration">foobar</span> = <span class="struct">Foo</span>::<span class="function">new</span>().<span class="function">bar</span>();
     <span class="comment">/// ```</span>
-    <span class="comment">/// </span><span class="keyword">let</span> <span class="variable declaration">foobar</span> = <span class="unresolved_reference">Foo</span>::<span class="unresolved_reference">new</span>().<span class="unresolved_reference">bar</span>();
+    <span class="comment">///</span>
+    <span class="comment">/// ```sh</span>
+    <span class="comment">/// echo 1</span>
     <span class="comment">/// ```</span>
     <span class="keyword">pub</span> <span class="keyword">fn</span> <span class="function declaration">foo</span>(&<span class="self_keyword">self</span>) -&gt; <span class="builtin_type">bool</span> {
         <span class="bool_literal">true</span>
diff --git a/crates/ra_ide/src/snapshots/highlight_injection.html b/crates/ra_ide/src/snapshots/highlight_injection.html
index dec06eb51..47dbd7bc8 100644
--- a/crates/ra_ide/src/snapshots/highlight_injection.html
+++ b/crates/ra_ide/src/snapshots/highlight_injection.html
@@ -25,6 +25,8 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .variable           { color: #DCDCCC; }
 .format_specifier   { color: #CC696B; }
 .mutable            { text-decoration: underline; }
+.unresolved_reference { color: #FC5555; }
+.escape_sequence    { color: #94BFF3; }
 
 .keyword            { color: #F0DFAF; font-weight: bold; }
 .keyword.unsafe     { color: #BC8383; font-weight: bold; }
diff --git a/crates/ra_ide/src/snapshots/highlight_strings.html b/crates/ra_ide/src/snapshots/highlight_strings.html
index 849eb3b73..b46fa44c6 100644
--- a/crates/ra_ide/src/snapshots/highlight_strings.html
+++ b/crates/ra_ide/src/snapshots/highlight_strings.html
@@ -25,6 +25,8 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .variable           { color: #DCDCCC; }
 .format_specifier   { color: #CC696B; }
 .mutable            { text-decoration: underline; }
+.unresolved_reference { color: #FC5555; }
+.escape_sequence    { color: #94BFF3; }
 
 .keyword            { color: #F0DFAF; font-weight: bold; }
 .keyword.unsafe     { color: #BC8383; font-weight: bold; }
@@ -82,6 +84,10 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 
     <span class="macro">println!</span>(<span class="string_literal">r"Hello, </span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal">!"</span>, <span class="string_literal">"world"</span>);
 
-    <span class="macro">println!</span>(<span class="string_literal">"</span><span class="format_specifier">{</span><span class="variable">\x41</span><span class="format_specifier">}</span><span class="string_literal">"</span>, A = <span class="numeric_literal">92</span>);
+    <span class="comment">// escape sequences</span>
+    <span class="macro">println!</span>(<span class="string_literal">"Hello</span><span class="escape_sequence">\n</span><span class="string_literal">World"</span>);
+    <span class="macro">println!</span>(<span class="string_literal">"</span><span class="escape_sequence">\u{48}</span><span class="escape_sequence">\x65</span><span class="escape_sequence">\x6C</span><span class="escape_sequence">\x6C</span><span class="escape_sequence">\x6F</span><span class="string_literal"> World"</span>);
+
+    <span class="macro">println!</span>(<span class="string_literal">"</span><span class="format_specifier">{</span><span class="escape_sequence">\x41</span><span class="format_specifier">}</span><span class="string_literal">"</span>, A = <span class="numeric_literal">92</span>);
     <span class="macro">println!</span>(<span class="string_literal">"</span><span class="format_specifier">{</span><span class="variable">ничоси</span><span class="format_specifier">}</span><span class="string_literal">"</span>, ничоси = <span class="numeric_literal">92</span>);
 }</code></pre>
\ No newline at end of file
diff --git a/crates/ra_ide/src/snapshots/highlight_unsafe.html b/crates/ra_ide/src/snapshots/highlight_unsafe.html
index bd24e6e38..73438fbb4 100644
--- a/crates/ra_ide/src/snapshots/highlight_unsafe.html
+++ b/crates/ra_ide/src/snapshots/highlight_unsafe.html
@@ -25,6 +25,8 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .variable           { color: #DCDCCC; }
 .format_specifier   { color: #CC696B; }
 .mutable            { text-decoration: underline; }
+.unresolved_reference { color: #FC5555; }
+.escape_sequence    { color: #94BFF3; }
 
 .keyword            { color: #F0DFAF; font-weight: bold; }
 .keyword.unsafe     { color: #BC8383; font-weight: bold; }
diff --git a/crates/ra_ide/src/snapshots/highlighting.html b/crates/ra_ide/src/snapshots/highlighting.html
index 33548d43c..0c4f0a018 100644
--- a/crates/ra_ide/src/snapshots/highlighting.html
+++ b/crates/ra_ide/src/snapshots/highlighting.html
@@ -25,6 +25,8 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .variable           { color: #DCDCCC; }
 .format_specifier   { color: #CC696B; }
 .mutable            { text-decoration: underline; }
+.unresolved_reference { color: #FC5555; }
+.escape_sequence    { color: #94BFF3; }
 
 .keyword            { color: #F0DFAF; font-weight: bold; }
 .keyword.unsafe     { color: #BC8383; font-weight: bold; }
@@ -62,6 +64,12 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
     }
 }
 
+<span class="macro">macro_rules!</span> <span class="macro declaration">noop</span> {
+    ($expr:expr) =&gt; {
+        $expr
+    }
+}
+
 <span class="comment">// comment</span>
 <span class="keyword">fn</span> <span class="function declaration">main</span>() {
     <span class="macro">println!</span>(<span class="string_literal">"Hello, {}!"</span>, <span class="numeric_literal">92</span>);
@@ -80,6 +88,8 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
         <span class="comment">// Do nothing</span>
     }
 
+    <span class="macro">noop!</span>(<span class="macro">noop</span><span class="macro">!</span>(<span class="numeric_literal">1</span>));
+
     <span class="keyword">let</span> <span class="keyword">mut</span> <span class="variable declaration mutable">x</span> = <span class="numeric_literal">42</span>;
     <span class="keyword">let</span> <span class="variable declaration mutable">y</span> = &<span class="keyword">mut</span> <span class="variable mutable">x</span>;
     <span class="keyword">let</span> <span class="variable declaration">z</span> = &<span class="variable mutable">y</span>;
diff --git a/crates/ra_ide/src/snapshots/rainbow_highlighting.html b/crates/ra_ide/src/snapshots/rainbow_highlighting.html
index 1ab06182c..a74a70069 100644
--- a/crates/ra_ide/src/snapshots/rainbow_highlighting.html
+++ b/crates/ra_ide/src/snapshots/rainbow_highlighting.html
@@ -25,6 +25,8 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .variable           { color: #DCDCCC; }
 .format_specifier   { color: #CC696B; }
 .mutable            { text-decoration: underline; }
+.unresolved_reference { color: #FC5555; }
+.escape_sequence    { color: #94BFF3; }
 
 .keyword            { color: #F0DFAF; font-weight: bold; }
 .keyword.unsafe     { color: #BC8383; font-weight: bold; }
diff --git a/crates/ra_ide/src/ssr.rs b/crates/ra_ide/src/ssr.rs
index 93e9aee1d..762aab962 100644
--- a/crates/ra_ide/src/ssr.rs
+++ b/crates/ra_ide/src/ssr.rs
@@ -27,11 +27,11 @@ impl std::error::Error for SsrError {}
 //
 // Search and replace with named wildcards that will match any expression.
 // The syntax for a structural search replace command is `<search_pattern> ==>> <replace_pattern>`.
-// A `$<name>:expr` placeholder in the search pattern will match any expression and `$<name>` will reference it in the replacement.
+// A `$<name>` placeholder in the search pattern will match any AST node and `$<name>` will reference it in the replacement.
 // Available via the command `rust-analyzer.ssr`.
 //
 // ```rust
-// // Using structural search replace command [foo($a:expr, $b:expr) ==>> ($a).foo($b)]
+// // Using structural search replace command [foo($a, $b) ==>> ($a).foo($b)]
 //
 // // BEFORE
 // String::from(foo(y + 5, z))
@@ -79,7 +79,7 @@ struct SsrPattern {
     vars: Vec<Var>,
 }
 
-/// represents an `$var` in an SSR query
+/// Represents a `$var` in an SSR query.
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 struct Var(String);
 
@@ -122,8 +122,7 @@ impl FromStr for SsrQuery {
         let mut pattern = it.next().expect("something").to_string();
 
         for part in it.map(split_by_var) {
-            let (var, var_type, remainder) = part?;
-            is_expr(var_type)?;
+            let (var, remainder) = part?;
             let new_var = create_name(var, &mut vars)?;
             pattern.push_str(new_var);
             pattern.push_str(remainder);
@@ -166,15 +165,11 @@ fn traverse(node: &SyntaxNode, go: &mut impl FnMut(&SyntaxNode) -> bool) {
     }
 }
 
-fn split_by_var(s: &str) -> Result<(&str, &str, &str), SsrError> {
-    let end_of_name = s.find(':').ok_or_else(|| SsrError("Use $<name>:expr".into()))?;
-    let name = &s[0..end_of_name];
+fn split_by_var(s: &str) -> Result<(&str, &str), SsrError> {
+    let end_of_name = s.find(|c| !char::is_ascii_alphanumeric(&c)).unwrap_or_else(|| s.len());
+    let name = &s[..end_of_name];
     is_name(name)?;
-    let type_begin = end_of_name + 1;
-    let type_length =
-        s[type_begin..].find(|c| !char::is_ascii_alphanumeric(&c)).unwrap_or_else(|| s.len());
-    let type_name = &s[type_begin..type_begin + type_length];
-    Ok((name, type_name, &s[type_begin + type_length..]))
+    Ok((name, &s[end_of_name..]))
 }
 
 fn is_name(s: &str) -> Result<(), SsrError> {
@@ -185,14 +180,6 @@ fn is_name(s: &str) -> Result<(), SsrError> {
     }
 }
 
-fn is_expr(s: &str) -> Result<(), SsrError> {
-    if s == "expr" {
-        Ok(())
-    } else {
-        Err(SsrError("Only $<name>:expr is supported".into()))
-    }
-}
-
 fn replace_in_template(template: String, var: &str, new_var: &str) -> String {
     let name = format!("${}", var);
     template.replace(&name, new_var)
@@ -450,7 +437,7 @@ mod tests {
 
     #[test]
     fn parser_happy_case() {
-        let result: SsrQuery = "foo($a:expr, $b:expr) ==>> bar($b, $a)".parse().unwrap();
+        let result: SsrQuery = "foo($a, $b) ==>> bar($b, $a)".parse().unwrap();
         assert_eq!(&result.pattern.pattern.text(), "foo(__search_pattern_a, __search_pattern_b)");
         assert_eq!(result.pattern.vars.len(), 2);
         assert_eq!(result.pattern.vars[0].0, "__search_pattern_a");
@@ -477,30 +464,9 @@ mod tests {
     }
 
     #[test]
-    fn parser_no_pattern_type() {
-        assert_eq!(parse_error_text("foo($a) ==>>"), "Parse error: Use $<name>:expr");
-    }
-
-    #[test]
-    fn parser_invalid_name() {
-        assert_eq!(
-            parse_error_text("foo($a+:expr) ==>>"),
-            "Parse error: Name can contain only alphanumerics and _"
-        );
-    }
-
-    #[test]
-    fn parser_invalid_type() {
-        assert_eq!(
-            parse_error_text("foo($a:ident) ==>>"),
-            "Parse error: Only $<name>:expr is supported"
-        );
-    }
-
-    #[test]
     fn parser_repeated_name() {
         assert_eq!(
-            parse_error_text("foo($a:expr, $a:expr) ==>>"),
+            parse_error_text("foo($a, $a) ==>>"),
             "Parse error: Name `a` repeats more than once"
         );
     }
@@ -517,7 +483,7 @@ mod tests {
 
     #[test]
     fn parse_match_replace() {
-        let query: SsrQuery = "foo($x:expr) ==>> bar($x)".parse().unwrap();
+        let query: SsrQuery = "foo($x) ==>> bar($x)".parse().unwrap();
         let input = "fn main() { foo(1+2); }";
 
         let code = SourceFile::parse(input).tree();
@@ -549,7 +515,7 @@ mod tests {
     #[test]
     fn ssr_function_to_method() {
         assert_ssr_transform(
-            "my_function($a:expr, $b:expr) ==>> ($a).my_method($b)",
+            "my_function($a, $b) ==>> ($a).my_method($b)",
             "loop { my_function( other_func(x, y), z + w) }",
             "loop { (other_func(x, y)).my_method(z + w) }",
         )
@@ -558,7 +524,7 @@ mod tests {
     #[test]
     fn ssr_nested_function() {
         assert_ssr_transform(
-            "foo($a:expr, $b:expr, $c:expr) ==>> bar($c, baz($a, $b))",
+            "foo($a, $b, $c) ==>> bar($c, baz($a, $b))",