117 files changed, 6137 insertions, 1919 deletions
diff --git a/crates/paths/src/lib.rs b/crates/paths/src/lib.rs
index c7ce0c42f..190c50913 100644
--- a/crates/paths/src/lib.rs
+++ b/crates/paths/src/lib.rs
@@ -2,7 +2,7 @@
 //! relative paths.
 use std::{
    convert::{TryFrom, TryInto},
-    ops,
+    io, ops,
    path::{Component, Path, PathBuf},
 };
@@ -46,6 +46,9 @@ impl TryFrom<&str> for AbsPathBuf {
 }
 impl AbsPathBuf {
+    pub fn canonicalized(path: &Path) -> io::Result<AbsPathBuf> {
+        path.canonicalize().map(|it| AbsPathBuf::try_from(it).unwrap())
+    }
    pub fn as_path(&self) -> &AbsPath {
        AbsPath::new_unchecked(self.0.as_path())
    }
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/handlers/replace_qualified_name_with_use.rs b/crates/ra_assists/src/handlers/replace_qualified_name_with_use.rs
index 0197a8cf0..b4784c333 100644
--- a/crates/ra_assists/src/handlers/replace_qualified_name_with_use.rs
+++ b/crates/ra_assists/src/handlers/replace_qualified_name_with_use.rs
@@ -1,7 +1,10 @@
 use hir;
-use ra_syntax::{ast, AstNode, SmolStr, TextRange};
+use ra_syntax::{algo::SyntaxRewriter, ast, match_ast, AstNode, SmolStr, SyntaxNode};
-use crate::{utils::insert_use_statement, AssistContext, AssistId, Assists};
+use crate::{
+    utils::{find_insert_use_container, insert_use_statement},
+    AssistContext, AssistId, Assists,
+};
 // Assist: replace_qualified_name_with_use
 //
@@ -39,16 +42,18 @@ pub(crate) fn replace_qualified_name_with_use(
        target,
        |builder| {
            let path_to_import = hir_path.mod_path().clone();
+            let container = match find_insert_use_container(path.syntax(), ctx) {
+                Some(c) => c,
+                None => return,
+            };
            insert_use_statement(path.syntax(), &path_to_import, ctx, builder.text_edit_builder());
-            if let Some(last) = path.segment() {
+            // Now that we've brought the name into scope, re-qualify all paths that could be
-                // Here we are assuming the assist will provide a correct use statement
+            // affected (that is, all paths inside the node we added the `use` to).
-                // so we can delete the path qualifier
+            let mut rewriter = SyntaxRewriter::default();
-                builder.delete(TextRange::new(
+            let syntax = container.either(|l| l.syntax().clone(), |r| r.syntax().clone());
-                    path.syntax().text_range().start(),
+            shorten_paths(&mut rewriter, syntax, path);
-                    last.syntax().text_range().start(),
+            builder.rewrite(rewriter);
-                ));
-            }
        },
    )
 }
@@ -73,6 +78,69 @@ fn collect_hir_path_segments(path: &hir::Path) -> Option<Vec<SmolStr>> {
    Some(ps)
 }
+/// Adds replacements to `re` that shorten `path` in all descendants of `node`.
+fn shorten_paths(rewriter: &mut SyntaxRewriter<'static>, node: SyntaxNode, path: ast::Path) {
+    for child in node.children() {
+        match_ast! {
+            match child {
+                // Don't modify `use` items, as this can break the `use` item when injecting a new
+                // import into the use tree.
+                ast::UseItem(_it) => continue,
+                // Don't descend into submodules, they don't have the same `use` items in scope.
+                ast::Module(_it) => continue,
+                ast::Path(p) => {
+                    match maybe_replace_path(rewriter, p.clone(), path.clone()) {
+                        Some(()) => {},
+                        None => shorten_paths(rewriter, p.syntax().clone(), path.clone()),
+                    }
+                },
+                _ => shorten_paths(rewriter, child, path.clone()),
+            }
+        }
+    }
+}
+fn maybe_replace_path(
+    rewriter: &mut SyntaxRewriter<'static>,
+    path: ast::Path,
+    target: ast::Path,
+) -> Option<()> {
+    if !path_eq(path.clone(), target.clone()) {
+        return None;
+    }
+    // Shorten `path`, leaving only its last segment.
+    if let Some(parent) = path.qualifier() {
+        rewriter.delete(parent.syntax());
+    }
+    if let Some(double_colon) = path.coloncolon_token() {
+        rewriter.delete(&double_colon);
+    }
+    Some(())
+}
+fn path_eq(lhs: ast::Path, rhs: ast::Path) -> bool {
+    let mut lhs_curr = lhs;
+    let mut rhs_curr = rhs;
+    loop {
+        match (lhs_curr.segment(), rhs_curr.segment()) {
+            (Some(lhs), Some(rhs)) if lhs.syntax().text() == rhs.syntax().text() => (),
+            _ => return false,
+        }
+        match (lhs_curr.qualifier(), rhs_curr.qualifier()) {
+            (Some(lhs), Some(rhs)) => {
+                lhs_curr = lhs;
+                rhs_curr = rhs;
+            }
+            (None, None) => return true,
+            _ => return false,
+        }
+    }
+}
 #[cfg(test)]
 mod tests {
    use crate::tests::{check_assist, check_assist_not_applicable};
@@ -83,10 +151,10 @@ mod tests {
    fn test_replace_add_use_no_anchor() {
        check_assist(
            replace_qualified_name_with_use,
-            "
+            r"
 std::fmt::Debug<|>
    ",
-            "
+            r"
 use std::fmt::Debug;
 Debug
@@ -97,13 +165,13 @@ Debug
    fn test_replace_add_use_no_anchor_with_item_below() {
        check_assist(
            replace_qualified_name_with_use,
-            "
+            r"
 std::fmt::Debug<|>
 fn main() {
 }
    ",
-            "
+            r"
 use std::fmt::Debug;
 Debug
@@ -118,13 +186,13 @@ fn main() {
    fn test_replace_add_use_no_anchor_with_item_above() {
        check_assist(
            replace_qualified_name_with_use,
-            "
+            r"
 fn main() {
 }
 std::fmt::Debug<|>
    ",
-            "
+            r"
 use std::fmt::Debug;
 fn main() {
@@ -139,10 +207,10 @@ Debug
    fn test_replace_add_use_no_anchor_2seg() {
        check_assist(
            replace_qualified_name_with_use,
-            "
+            r"
 std::fmt<|>::Debug
    ",
-            "
+            r"
 use std::fmt;
 fmt::Debug
@@ -154,13 +222,13 @@ fmt::Debug
    fn test_replace_add_use() {
        check_assist(
            replace_qualified_name_with_use,
-            "
+            r"
 use stdx;
 impl std::fmt::Debug<|> for Foo {
 }
    ",
-            "
+            r"
 use stdx;
 use std::fmt::Debug;
@@ -174,11 +242,11 @@ impl Debug for Foo {
    fn test_replace_file_use_other_anchor() {
        check_assist(
            replace_qualified_name_with_use,
-            "
+            r"
 impl std::fmt::Debug<|> for Foo {
 }
    ",
-            "
+            r"
 use std::fmt::Debug;
 impl Debug for Foo {
@@ -191,11 +259,11 @@ impl Debug for Foo {
    fn test_replace_add_use_other_anchor_indent() {
        check_assist(
            replace_qualified_name_with_use,
-            "
+            r"
    impl std::fmt::Debug<|> for Foo {
    }
    ",
-            "
+            r"
    use std::fmt::Debug;
    impl Debug for Foo {
@@ -208,13 +276,13 @@ impl Debug for Foo {
    fn test_replace_split_different() {
        check_assist(
            replace_qualified_name_with_use,
-            "
+            r"
 use std::fmt;
 impl std::io<|> for Foo {
 }
    ",
-            "
+            r"
 use std::{io, fmt};
 impl io for Foo {
@@ -227,13 +295,13 @@ impl io for Foo {
    fn test_replace_split_self_for_use() {
        check_assist(
            replace_qualified_name_with_use,
-            "
+            r"
 use std::fmt;
 impl std::fmt::Debug<|> for Foo {
 }
    ",
-            "
+            r"
 use std::fmt::{self, Debug, };
 impl Debug for Foo {
@@ -246,13 +314,13 @@ impl Debug for Foo {
    fn test_replace_split_self_for_target() {
        check_assist(
            replace_qualified_name_with_use,
-            "
+            r"
 use std::fmt::Debug;
 impl std::fmt<|> for Foo {
 }
    ",
-            "
+            r"
 use std::fmt::{self, Debug};
 impl fmt for Foo {
@@ -265,13 +333,13 @@ impl fmt for Foo {
    fn test_replace_add_to_nested_self_nested() {
        check_assist(
            replace_qualified_name_with_use,
-            "
+            r"
 use std::fmt::{Debug, nested::{Display}};
 impl std::fmt::nested<|> for Foo {
 }
 ",
-            "
+            r"
 use std::fmt::{Debug, nested::{Display, self}};
 impl nested for Foo {
@@ -284,13 +352,13 @@ impl nested for Foo {
    fn test_replace_add_to_nested_self_already_included() {
        check_assist(
            replace_qualified_name_with_use,
-            "
+            r"
 use std::fmt::{Debug, nested::{self, Display}};
 impl std::fmt::nested<|> for Foo {
 }
 ",
-            "
+            r"
 use std::fmt::{Debug, nested::{self, Display}};
 impl nested for Foo {
@@ -303,13 +371,13 @@ impl nested for Foo {
    fn test_replace_add_to_nested_nested() {
        check_assist(
            replace_qualified_name_with_use,
-            "
+            r"
 use std::fmt::{Debug, nested::{Display}};
 impl std::fmt::nested::Debug<|> for Foo {
 }
 ",
-            "
+            r"
 use std::fmt::{Debug, nested::{Display, Debug}};
 impl Debug for Foo {
@@ -322,13 +390,13 @@ impl Debug for Foo {
    fn test_replace_split_common_target_longer() {
        check_assist(
            replace_qualified_name_with_use,
-            "
+            r"
 use std::fmt::Debug;
 impl std::fmt::nested::Display<|> for Foo {
 }
 ",
-            "
+            r"
 use std::fmt::{nested::Display, Debug};
 impl Display for Foo {
@@ -341,13 +409,13 @@ impl Display for Foo {
    fn test_replace_split_common_use_longer() {
        check_assist(
            replace_qualified_name_with_use,
-            "
+            r"
 use std::fmt::nested::Debug;
 impl std::fmt::Display<|> for Foo {
 }
 ",
-            "
+            r"
 use std::fmt::{Display, nested::Debug};
 impl Display for Foo {
@@ -360,7 +428,7 @@ impl Display for Foo {
    fn test_replace_use_nested_import() {
        check_assist(
            replace_qualified_name_with_use,
-            "
+            r"
 use crate::{
    ty::{Substs, Ty},
    AssocItem,
@@ -368,7 +436,7 @@ use crate::{
 fn foo() { crate::ty::lower<|>::trait_env() }
 ",
-            "
+            r"
 use crate::{
    ty::{Substs, Ty, lower},
    AssocItem,
@@ -383,13 +451,13 @@ fn foo() { lower::trait_env() }
    fn test_replace_alias() {
        check_assist(
            replace_qualified_name_with_use,
-            "
+            r"
 use std::fmt as foo;
 impl foo::Debug<|> for Foo {
 }
 ",
-            "
+            r"
 use std::fmt as foo;
 impl Debug for Foo {
@@ -402,7 +470,7 @@ impl Debug for Foo {
    fn test_replace_not_applicable_one_segment() {
        check_assist_not_applicable(
            replace_qualified_name_with_use,
-            "
+            r"
 impl foo<|> for Foo {
 }
 ",
@@ -413,7 +481,7 @@ impl foo<|> for Foo {
    fn test_replace_not_applicable_in_use() {
        check_assist_not_applicable(
            replace_qualified_name_with_use,
-            "
+            r"
 use std::fmt<|>;
 ",
        );
@@ -423,14 +491,14 @@ use std::fmt<|>;
    fn test_replace_add_use_no_anchor_in_mod_mod() {
        check_assist(
            replace_qualified_name_with_use,
-            "
+            r"
 mod foo {
    mod bar {
        std::fmt::Debug<|>
    }
 }
    ",
-            "
+            r"
 mod foo {
    mod bar {
        use std::fmt::Debug;
@@ -446,14 +514,14 @@ mod foo {
    fn inserts_imports_after_inner_attributes() {
        check_assist(
            replace_qualified_name_with_use,
-            "
+            r"
 #![allow(dead_code)]
 fn main() {
    std::fmt::Debug<|>
 }
    ",
-            "
+            r"
 #![allow(dead_code)]
 use std::fmt::Debug;
@@ -463,4 +531,116 @@ fn main() {
    ",
        );
    }
+    #[test]
+    fn replaces_all_affected_paths() {
+        check_assist(
+            replace_qualified_name_with_use,
+            r"
+fn main() {
+    std::fmt::Debug<|>;
+    let x: std::fmt::Debug = std::fmt::Debug;
+}
+    ",
+            r"
+use std::fmt::Debug;
+fn main() {
+    Debug;
+    let x: Debug = Debug;
+}
+    ",
+        );
+    }
+    #[test]
+    fn replaces_all_affected_paths_mod() {
+        check_assist(
+            replace_qualified_name_with_use,
+            r"
+mod m {
+    fn f() {
+        std::fmt::Debug<|>;
+        let x: std::fmt::Debug = std::fmt::Debug;
+    }
+    fn g() {
+        std::fmt::Debug;
+    }
+}
+fn f() {
+    std::fmt::Debug;
+}
+    ",
+            r"
+mod m {
+    use std::fmt::Debug;
+    fn f() {
+        Debug;
+        let x: Debug = Debug;
+    }
+    fn g() {
+        Debug;
+    }
+}
+fn f() {
+    std::fmt::Debug;
+}
+    ",
+        );
+    }
+    #[test]
+    fn does_not_replace_in_submodules() {
+        check_assist(
+            replace_qualified_name_with_use,
+            r"
+fn main() {
+    std::fmt::Debug<|>;
+}
+mod sub {
+    fn f() {
+        std::fmt::Debug;
+    }
+}
+    ",
+            r"
+use std::fmt::Debug;
+fn main() {
+    Debug;
+}
+mod sub {
+    fn f() {
+        std::fmt::Debug;
+    }
+}
+    ",
+        );
+    }
+    #[test]
+    fn does_not_replace_in_use() {
+        check_assist(
+            replace_qualified_name_with_use,
+            r"
+use std::fmt::Display;
+fn main() {
+    std::fmt<|>;
+}
+    ",
+            r"
+use std::fmt::{self, Display};
+fn main() {
+    fmt;
+}
+    ",
+        );
+    }
 }
diff --git a/crates/ra_assists/src/utils.rs b/crates/ra_assists/src/utils.rs
index 0038a9764..c1ff0de7b 100644
--- a/crates/ra_assists/src/utils.rs
+++ b/crates/ra_assists/src/utils.rs
@@ -13,7 +13,7 @@ use rustc_hash::FxHashSet;
 use crate::assist_config::SnippetCap;
-pub(crate) use insert_use::insert_use_statement;
+pub(crate) use insert_use::{find_insert_use_container, insert_use_statement};
 #[derive(Clone, Copy, Debug)]
 pub(crate) enum Cursor<'a> {
diff --git a/crates/ra_assists/src/utils/insert_use.rs b/crates/ra_assists/src/utils/insert_use.rs
index 0ee43482f..8c4f33e59 100644
--- a/crates/ra_assists/src/utils/insert_use.rs
+++ b/crates/ra_assists/src/utils/insert_use.rs
@@ -12,6 +12,20 @@ use ra_syntax::{
 use ra_text_edit::TextEditBuilder;
 use crate::assist_context::AssistContext;
+use either::Either;
+/// Determines the containing syntax node in which to insert a `use` statement affecting `position`.
+pub(crate) fn find_insert_use_container(
+    position: &SyntaxNode,
+    ctx: &AssistContext,
+) -> Option<Either<ast::ItemList, ast::SourceFile>> {
+    ctx.sema.ancestors_with_macros(position.clone()).find_map(|n| {
+        if let Some(module) = ast::Module::cast(n.clone()) {
+            return module.item_list().map(|it| Either::Left(it));
+        }
+        Some(Either::Right(ast::SourceFile::cast(n)?))
+    })
+}
 /// Creates and inserts a use statement for the given path to import.
 /// The use statement is inserted in the scope most appropriate to the
@@ -24,15 +38,11 @@ pub(crate) fn insert_use_statement(
    builder: &mut TextEditBuilder,
 ) {
    let target = path_to_import.to_string().split("::").map(SmolStr::new).collect::<Vec<_>>();
-    let container = ctx.sema.ancestors_with_macros(position.clone()).find_map(|n| {
+    let container = find_insert_use_container(position, ctx);
-        if let Some(module) = ast::Module::cast(n.clone()) {
-            return module.item_list().map(|it| it.syntax().clone());
-        }
-        ast::SourceFile::cast(n).map(|it| it.syntax().clone())
-    });
    if let Some(container) = container {
-        let action = best_action_for_target(container, position.clone(), &target);
+        let syntax = container.either(|l| l.syntax().clone(), |r| r.syntax().clone());
+        let action = best_action_for_target(syntax, position.clone(), &target);
        make_assist(&action, &target, builder);
    }
 }
diff --git a/crates/ra_db/src/input.rs b/crates/ra_db/src/input.rs
index bf26048f2..e6af99035 100644
--- a/crates/ra_db/src/input.rs
+++ b/crates/ra_db/src/input.rs
@@ -254,12 +254,12 @@ impl CrateGraph {
            return false;
        }
+        if target == from {
+            return true;
+        }
        for dep in &self[from].dependencies {
            let crate_id = dep.crate_id;
-            if crate_id == target {
-                return true;
-            }
            if self.dfs_find(target, crate_id, visited) {
                return true;
            }
@@ -369,7 +369,7 @@ mod tests {
    use super::{CfgOptions, CrateGraph, CrateName, Dependency, Edition::Edition2018, Env, FileId};
    #[test]
-    fn it_should_panic_because_of_cycle_dependencies() {
+    fn detect_cyclic_dependency_indirect() {
        let mut graph = CrateGraph::default();
        let crate1 = graph.add_crate_root(
            FileId(1u32),
@@ -404,6 +404,31 @@ mod tests {
    }
    #[test]
+    fn detect_cyclic_dependency_direct() {
+        let mut graph = CrateGraph::default();
+        let crate1 = graph.add_crate_root(
+            FileId(1u32),
+            Edition2018,
+            None,
+            CfgOptions::default(),
+            Env::default(),
+            Default::default(),
+            Default::default(),
+        );
+        let crate2 = graph.add_crate_root(
+            FileId(2u32),
+            Edition2018,
+            None,
+            CfgOptions::default(),
+            Env::default(),
+            Default::default(),
+            Default::default(),
+        );
+        assert!(graph.add_dep(crate1, CrateName::new("crate2").unwrap(), crate2).is_ok());
+        assert!(graph.add_dep(crate2, CrateName::new("crate2").unwrap(), crate2).is_err());
+    }
+    #[test]
    fn it_works() {
        let mut graph = CrateGraph::default();
        let crate1 = graph.add_crate_root(
diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs
index 1a9f6cc76..ffd5278ec 100644
--- a/crates/ra_hir/src/code_model.rs
+++ b/crates/ra_hir/src/code_model.rs
@@ -26,8 +26,8 @@ use hir_ty::{
    autoderef,
    display::{HirDisplayError, HirFormatter},
    expr::ExprValidator,
-    method_resolution, ApplicationTy, Canonical, InEnvironment, Substs, TraitEnvironment, Ty,
+    method_resolution, ApplicationTy, Canonical, GenericPredicate, InEnvironment, Substs,
-    TyDefId, TypeCtor,
+    TraitEnvironment, Ty, TyDefId, TypeCtor,
 };
 use ra_db::{CrateId, CrateName, Edition, FileId};
 use ra_prof::profile;
@@ -186,6 +186,22 @@ impl ModuleDef {
        module.visibility_of(db, self)
    }
+    pub fn name(self, db: &dyn HirDatabase) -> Option<Name> {
+        match self {
+            ModuleDef::Adt(it) => Some(it.name(db)),
+            ModuleDef::Trait(it) => Some(it.name(db)),
+            ModuleDef::Function(it) => Some(it.name(db)),
+            ModuleDef::EnumVariant(it) => Some(it.name(db)),
+            ModuleDef::TypeAlias(it) => Some(it.name(db)),
+            ModuleDef::Module(it) => it.name(db),
+            ModuleDef::Const(it) => it.name(db),
+            ModuleDef::Static(it) => it.name(db),
+            ModuleDef::BuiltinType(it) => Some(it.as_name()),
+        }
+    }
 }
 pub use hir_def::{
@@ -1359,6 +1375,27 @@ impl Type {
        Some(adt.into())
    }
+    pub fn as_dyn_trait(&self) -> Option<Trait> {
+        self.ty.value.dyn_trait().map(Into::into)
+    }
+    pub fn as_impl_traits(&self, db: &dyn HirDatabase) -> Option<Vec<Trait>> {
+        self.ty.value.impl_trait_bounds(db).map(|it| {
+            it.into_iter()
+                .filter_map(|pred| match pred {
+                    hir_ty::GenericPredicate::Implemented(trait_ref) => {
+                        Some(Trait::from(trait_ref.trait_))
+                    }
+                    _ => None,
+                })
+                .collect()
+        })
+    }
+    pub fn as_associated_type_parent_trait(&self, db: &dyn HirDatabase) -> Option<Trait> {
+        self.ty.value.associated_type_parent_trait(db).map(Into::into)
+    }
    // FIXME: provide required accessors such that it becomes implementable from outside.
    pub fn is_equal_for_find_impls(&self, other: &Type) -> bool {
        match (&self.ty.value, &other.ty.value) {
@@ -1380,6 +1417,80 @@ impl Type {
            ty: InEnvironment { value: ty, environment: self.ty.environment.clone() },
        }
    }
+    pub fn walk(&self, db: &dyn HirDatabase, mut cb: impl FnMut(Type)) {
+        // TypeWalk::walk for a Ty at first visits parameters and only after that the Ty itself.
+        // We need a different order here.
+        fn walk_substs(
+            db: &dyn HirDatabase,
+            type_: &Type,
+            substs: &Substs,
+            cb: &mut impl FnMut(Type),
+        ) {
+            for ty in substs.iter() {
+                walk_type(db, &type_.derived(ty.clone()), cb);
+            }
+        }
+        fn walk_bounds(
+            db: &dyn HirDatabase,
+            type_: &Type,
+            bounds: &[GenericPredicate],
+            cb: &mut impl FnMut(Type),
+        ) {
+            for pred in bounds {
+                match pred {
+                    GenericPredicate::Implemented(trait_ref) => {
+                        cb(type_.clone());
+                        walk_substs(db, type_, &trait_ref.substs, cb);
+                    }
+                    _ => (),
+                }
+            }
+        }
+        fn walk_type(db: &dyn HirDatabase, type_: &Type, cb: &mut impl FnMut(Type)) {
+            let ty = type_.ty.value.strip_references();
+            match ty {
+                Ty::Apply(ApplicationTy { ctor, parameters }) => {
+                    match ctor {
+                        TypeCtor::Adt(_) => {
+                            cb(type_.derived(ty.clone()));
+                        }
+                        TypeCtor::AssociatedType(_) => {
+                            if let Some(_) = ty.associated_type_parent_trait(db) {
+                                cb(type_.derived(ty.clone()));
+                            }
+                        }
+                        _ => (),
+                    }
+                    // adt params, tuples, etc...
+                    walk_substs(db, type_, parameters, cb);
+                }
+                Ty::Opaque(opaque_ty) => {
+                    if let Some(bounds) = ty.impl_trait_bounds(db) {
+                        walk_bounds(db, &type_.derived(ty.clone()), &bounds, cb);
+                    }
+                    walk_substs(db, type_, &opaque_ty.parameters, cb);
+                }
+                Ty::Placeholder(_) => {
+                    if let Some(bounds) = ty.impl_trait_bounds(db) {
+                        walk_bounds(db, &type_.derived(ty.clone()), &bounds, cb);
+                    }
+                }
+                Ty::Dyn(bounds) => {
+                    walk_bounds(db, &type_.derived(ty.clone()), bounds.as_ref(), cb);
+                }
+                _ => (),
+            }
+        }
+        walk_type(db, self, &mut cb);
+    }
 }
 impl HirDisplay for Type {
diff --git a/crates/ra_hir/src/db.rs b/crates/ra_hir/src/db.rs
index b6b665de1..b25dac28e 100644
--- a/crates/ra_hir/src/db.rs
+++ b/crates/ra_hir/src/db.rs
@@ -16,7 +16,7 @@ pub use hir_expand::db::{
 pub use hir_ty::db::{
    AssociatedTyDataQuery, AssociatedTyValueQuery, CallableItemSignatureQuery, FieldTypesQuery,
    GenericDefaultsQuery, GenericPredicatesForParamQuery, GenericPredicatesQuery, HirDatabase,
-    HirDatabaseStorage, ImplDatumQuery, ImplSelfTyQuery, ImplTraitQuery, ImplsForTraitQuery,
+    HirDatabaseStorage, ImplDatumQuery, ImplSelfTyQuery, ImplTraitQuery, ImplsFromDepsQuery,
    ImplsInCrateQuery, InferQueryQuery, InternAssocTyValueQuery, InternChalkImplQuery,
    InternTypeCtorQuery, InternTypeParamIdQuery, ReturnTypeImplTraitsQuery, StructDatumQuery,
    TraitDatumQuery, TraitSolveQuery, TyQuery, ValueTyQuery,
diff --git a/crates/ra_hir/src/semantics.rs b/crates/ra_hir/src/semantics.rs
index a232a5856..6a49c424a 100644
--- a/crates/ra_hir/src/semantics.rs
+++ b/crates/ra_hir/src/semantics.rs
@@ -6,9 +6,9 @@ use std::{cell::RefCell, fmt, iter::successors};
 use hir_def::{
    resolver::{self, HasResolver, Resolver},
-    AsMacroCall, TraitId,
+    AsMacroCall, TraitId, VariantId,
 };
-use hir_expand::{hygiene::Hygiene, ExpansionInfo};
+use hir_expand::{diagnostics::AstDiagnostic, hygiene::Hygiene, ExpansionInfo};
 use hir_ty::associated_type_shorthand_candidates;
 use itertools::Itertools;
 use ra_db::{FileId, FileRange};
@@ -104,6 +104,13 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {
        tree
    }
+    pub fn ast<T: AstDiagnostic + Diagnostic>(&self, d: &T) -> <T as AstDiagnostic>::AST {
+        let file_id = d.source().file_id;
+        let root = self.db.parse_or_expand(file_id).unwrap();
+        self.cache(root, file_id);
+        d.ast(self.db)
+    }
    pub fn expand(&self, macro_call: &ast::MacroCall) -> Option<SyntaxNode> {
        let macro_call = self.find_file(macro_call.syntax().clone()).with_value(macro_call);
        let sa = self.analyze2(macro_call.map(|it| it.syntax()), None);
@@ -247,6 +254,10 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {
        self.analyze(path.syntax()).resolve_path(self.db, path)
    }
+    pub fn resolve_variant(&self, record_lit: ast::RecordLit) -> Option<VariantId> {
+        self.analyze(record_lit.syntax()).resolve_variant(self.db, record_lit)
+    }
    pub fn lower_path(&self, path: &ast::Path) -> Option<Path> {
        let src = self.find_file(path.syntax().clone());
        Path::from_src(path.clone(), &Hygiene::new(self.db.upcast(), src.file_id.into()))
diff --git a/crates/ra_hir/src/source_analyzer.rs b/crates/ra_hir/src/source_analyzer.rs
index 7c6bbea13..757d1e397 100644
--- a/crates/ra_hir/src/source_analyzer.rs
+++ b/crates/ra_hir/src/source_analyzer.rs
@@ -313,6 +313,16 @@ impl SourceAnalyzer {
        })?;
        Some(macro_call_id.as_file())
    }
+    pub(crate) fn resolve_variant(
+        &self,
+        db: &dyn HirDatabase,
+        record_lit: ast::RecordLit,
+    ) -> Option<VariantId> {
+        let infer = self.infer.as_ref()?;
+        let expr_id = self.expr_id(db, &record_lit.into())?;
+        infer.variant_resolution_for_expr(expr_id)
+    }
 }
 fn scope_for(
diff --git a/crates/ra_hir_def/src/body/scope.rs b/crates/ra_hir_def/src/body/scope.rs
index e48ff38f9..661f00407 100644
--- a/crates/ra_hir_def/src/body/scope.rs
+++ b/crates/ra_hir_def/src/body/scope.rs
@@ -87,15 +87,13 @@ impl ExprScopes {
    }
    fn add_bindings(&mut self, body: &Body, scope: ScopeId, pat: PatId) {
-        match &body[pat] {
+        let pattern = &body[pat];
-            Pat::Bind { name, .. } => {
+        if let Pat::Bind { name, .. } = pattern {
-                // bind can have a sub pattern, but it's actually not allowed
+            let entry = ScopeEntry { name: name.clone(), pat };
-                // to bind to things in there
+            self.scopes[scope].entries.push(entry);
-                let entry = ScopeEntry { name: name.clone(), pat };
-                self.scopes[scope].entries.push(entry)
-            }
-            p => p.walk_child_pats(|pat| self.add_bindings(body, scope, pat)),
        }
+        pattern.walk_child_pats(|pat| self.add_bindings(body, scope, pat));
    }
    fn add_params_bindings(&mut self, body: &Body, scope: ScopeId, params: &[PatId]) {
@@ -190,8 +188,8 @@ mod tests {
        }
    }
-    fn do_check(code: &str, expected: &[&str]) {
+    fn do_check(ra_fixture: &str, expected: &[&str]) {
-        let (off, code) = extract_offset(code);
+        let (off, code) = extract_offset(ra_fixture);
        let code = {
            let mut buf = String::new();
            let off: usize = off.into();
@@ -300,6 +298,22 @@ mod tests {
        );
    }
+    #[test]
+    fn test_bindings_after_at() {
+        do_check(
+            r"
+            fn foo() {
+                match Some(()) {
+                    opt @ Some(unit) => {
+                        <|>
+                    }
+                    _ => {}
+                }
+            }",
+            &["opt", "unit"],
+        );
+    }
    fn do_check_local_name(code: &str, expected_offset: u32) {
        let (off, code) = extract_offset(code);
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/lib.rs b/crates/ra_hir_def/src/lib.rs
index edc59e5a8..af2a717c9 100644
--- a/crates/ra_hir_def/src/lib.rs
+++ b/crates/ra_hir_def/src/lib.rs
@@ -159,7 +159,7 @@ pub struct TypeAliasId(salsa::InternId);
 type TypeAliasLoc = AssocItemLoc<ast::TypeAliasDef>;
 impl_intern!(TypeAliasId, TypeAliasLoc, intern_type_alias, lookup_intern_type_alias);
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Ord, PartialOrd)]
 pub struct ImplId(salsa::InternId);
 type ImplLoc = ItemLoc<ast::ImplDef>;
 impl_intern!(ImplId, ImplLoc, intern_impl, lookup_intern_impl);
diff --git a/crates/ra_hir_def/src/nameres.rs b/crates/ra_hir_def/src/nameres.rs
index f279c2ad4..b8560fdc9 100644
--- a/crates/ra_hir_def/src/nameres.rs
+++ b/crates/ra_hir_def/src/nameres.rs
@@ -119,13 +119,6 @@ impl Default for ModuleOrigin {
 }
 impl ModuleOrigin {
-    pub(crate) fn not_sure_file(file: Option<FileId>, declaration: AstId<ast::Module>) -> Self {
-        match file {
-            None => ModuleOrigin::Inline { definition: declaration },
-            Some(definition) => ModuleOrigin::File { declaration, definition },
-        }
-    }
    fn declaration(&self) -> Option<AstId<ast::Module>> {
        match self {
            ModuleOrigin::File { declaration: module, .. }
@@ -296,7 +289,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 +298,7 @@ mod diagnostics {
        UnresolvedModule {
            module: LocalModuleId,
            declaration: AstId<ast::Module>,
-            candidate: RelativePathBuf,
+            candidate: String,
        },
    }
diff --git a/crates/ra_hir_def/src/nameres/collector.rs b/crates/ra_hir_def/src/nameres/collector.rs
index 976e5e585..b8f6aac8f 100644
--- a/crates/ra_hir_def/src/nameres/collector.rs
+++ b/crates/ra_hir_def/src/nameres/collector.rs
@@ -36,8 +36,8 @@ pub(super) fn collect_defs(db: &dyn DefDatabase, mut def_map: CrateDefMap) -> Cr
    // populate external prelude
    for dep in &crate_graph[def_map.krate].dependencies {
-        let dep_def_map = db.crate_def_map(dep.crate_id);
        log::debug!("crate dep {:?} -> {:?}", dep.name, dep.crate_id);
+        let dep_def_map = db.crate_def_map(dep.crate_id);
        def_map.extern_prelude.insert(
            dep.as_name(),
            ModuleId { krate: dep.crate_id, local_id: dep_def_map.root }.into(),
@@ -825,7 +825,10 @@ impl ModCollector<'_, '_> {
        let modules = &mut self.def_collector.def_map.modules;
        let res = modules.alloc(ModuleData::default());
        modules[res].parent = Some(self.module_id);
-        modules[res].origin = ModuleOrigin::not_sure_file(definition, declaration);
+        modules[res].origin = match definition {
+            None => ModuleOrigin::Inline { definition: declaration },
+            Some(definition) => ModuleOrigin::File { declaration, definition },
+        };
        for (name, mac) in modules[self.module_id].scope.collect_legacy_macros() {
            modules[res].scope.define_legacy_macro(name, mac)
        }
diff --git a/crates/ra_hir_def/src/nameres/mod_resolution.rs b/crates/ra_hir_def/src/nameres/mod_resolution.rs
index cede4a6fc..19fe0615a 100644
--- a/crates/ra_hir_def/src/nameres/mod_resolution.rs
+++ b/crates/ra_hir_def/src/nameres/mod_resolution.rs
@@ -44,7 +44,7 @@ impl ModDir {
        file_id: HirFileId,
        name: &Name,
        attr_path: Option<&SmolStr>,
-    ) -> Result<(FileId, ModDir), RelativePathBuf> {
+    ) -> Result<(FileId, ModDir), String> {
        let file_id = file_id.original_file(db.upcast());
        let mut candidate_files = Vec::new();
@@ -52,11 +52,11 @@ impl ModDir {
            Some(attr_path) => {
                let base =
                    if self.root_non_dir_owner { self.path.parent().unwrap() } else { &self.path };
-                candidate_files.push(base.join(attr_path))
+                candidate_files.push(base.join(attr_path).to_string())
            }
            None => {
-                candidate_files.push(self.path.join(&format!("{}.rs", name)));
+                candidate_files.push(self.path.join(&format!("{}.rs", name)).to_string());
-                candidate_files.push(self.path.join(&format!("{}/mod.rs", name)));
+                candidate_files.push(self.path.join(&format!("{}/mod.rs", name)).to_string());
            }
        };
diff --git a/crates/ra_hir_ty/src/_match.rs b/crates/ra_hir_ty/src/_match.rs
index fff257193..5495ce284 100644
--- a/crates/ra_hir_ty/src/_match.rs
+++ b/crates/ra_hir_ty/src/_match.rs
@@ -312,20 +312,16 @@ impl PatStack {
        Self(v)
    }
-    fn is_empty(&self) -> bool {
-        self.0.is_empty()
-    }
-    fn head(&self) -> PatIdOrWild {
-        self.0[0]
-    }
    fn get_head(&self) -> Option<PatIdOrWild> {
        self.0.first().copied()
    }
+    fn tail(&self) -> &[PatIdOrWild] {
+        self.0.get(1..).unwrap_or(&[])
+    }
    fn to_tail(&self) -> PatStack {
-        Self::from_slice(&self.0[1..])
+        Self::from_slice(self.tail())
    }
    fn replace_head_with<I, T>(&self, pats: I) -> PatStack
@@ -347,7 +343,7 @@ impl PatStack {
    ///
    /// See the module docs and the associated documentation in rustc for details.
    fn specialize_wildcard(&self, cx: &MatchCheckCtx) -> Option<PatStack> {
-        if matches!(self.head().as_pat(cx), Pat::Wild) {
+        if matches!(self.get_head()?.as_pat(cx), Pat::Wild) {
            Some(self.to_tail())
        } else {
            None
@@ -362,7 +358,13 @@ impl PatStack {
        cx: &MatchCheckCtx,
        constructor: &Constructor,
    ) -> MatchCheckResult<Option<PatStack>> {
-        let result = match (self.head().as_pat(cx), constructor) {
+        let head = match self.get_head() {
+            Some(head) => head,
+            None => return Ok(None),
+        };
+        let head_pat = 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
@@ -389,7 +391,7 @@ impl PatStack {
            (Pat::Wild, constructor) => Some(self.expand_wildcard(cx, constructor)?),
            (Pat::Path(_), Constructor::Enum(constructor)) => {
                // unit enum variants become `Pat::Path`
-                let pat_id = self.head().as_id().expect("we know this isn't a wild");
+                let pat_id = head.as_id().expect("we know this isn't a wild");
                if !enum_variant_matches(cx, pat_id, *constructor) {
                    None
                } else {
@@ -400,7 +402,7 @@ impl PatStack {
                Pat::TupleStruct { args: ref pat_ids, ellipsis, .. },
                Constructor::Enum(enum_constructor),
            ) => {
-                let pat_id = self.head().as_id().expect("we know this isn't a wild");
+                let pat_id = head.as_id().expect("we know this isn't a wild");
                if !enum_variant_matches(cx, pat_id, *enum_constructor) {
                    None
                } else {
@@ -440,7 +442,7 @@ impl PatStack {
                }
            }
            (Pat::Record { args: ref arg_patterns, .. }, Constructor::Enum(e)) => {
-                let pat_id = self.head().as_id().expect("we know this isn't a wild");
+                let pat_id = head.as_id().expect("we know this isn't a wild");
                if !enum_variant_matches(cx, pat_id, *e) {
                    None
                } else {
@@ -486,7 +488,7 @@ impl PatStack {
    ) -> MatchCheckResult<PatStack> {
        assert_eq!(
            Pat::Wild,
-            self.head().as_pat(cx),
+            self.get_head().expect("expand_wildcard called on empty PatStack").as_pat(cx),
            "expand_wildcard must only be called on PatStack with wild at head",
        );
@@ -504,7 +506,6 @@ impl PatStack {
    }
 }
-#[derive(Debug)]
 /// A collection of PatStack.
 ///
 /// This type is modeled from the struct of the same name in `rustc`.
@@ -531,7 +532,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.
@@ -618,13 +619,16 @@ pub(crate) fn is_useful(
        _ => (),
    }
-    if v.is_empty() {
+    let head = match v.get_head() {
-        let result = if matrix.is_empty() { Usefulness::Useful } else { Usefulness::NotUseful };
+        Some(head) => head,
+        None => {
+            let result = if matrix.is_empty() { Usefulness::Useful } else { Usefulness::NotUseful };
-        return Ok(result);
+            return Ok(result);
-    }
+        }
+    };
-    if let Pat::Or(pat_ids) = v.head().as_pat(cx) {
+    if let Pat::Or(pat_ids) = head.as_pat(cx) {
        let mut found_unimplemented = false;
        let any_useful = pat_ids.iter().any(|&pat_id| {
            let v = PatStack::from_pattern(pat_id);
@@ -648,7 +652,7 @@ pub(crate) fn is_useful(
        };
    }
-    if let Some(constructor) = pat_constructor(cx, v.head())? {
+    if let Some(constructor) = pat_constructor(cx, head)? {
        let matrix = matrix.specialize_constructor(&cx, &constructor)?;
        let v = v
            .specialize_constructor(&cx, &constructor)?
@@ -837,194 +841,193 @@ mod tests {
    pub(super) use crate::{diagnostics::MissingMatchArms, test_db::TestDB};
-    pub(super) fn check_diagnostic_message(content: &str) -> String {
+    pub(super) fn check_diagnostic_message(ra_fixture: &str) -> String {
-        TestDB::with_single_file(content).0.diagnostic::<MissingMatchArms>().0
+        TestDB::with_single_file(ra_fixture).0.diagnostic::<MissingMatchArms>().0
    }
-    pub(super) fn check_diagnostic(content: &str) {
+    pub(super) fn check_diagnostic(ra_fixture: &str) {
        let diagnostic_count =
-            TestDB::with_single_file(content).0.diagnostic::<MissingMatchArms>().1;
+            TestDB::with_single_file(ra_fixture).0.diagnostic::<MissingMatchArms>().1;
        assert_eq!(1, diagnostic_count, "no diagnostic reported");
    }
-    pub(super) fn check_no_diagnostic(content: &str) {
+    pub(super) fn check_no_diagnostic(ra_fixture: &str) {
-        let diagnostic_count =
+        let (s, diagnostic_count) =
-            TestDB::with_single_file(content).0.diagnostic::<MissingMatchArms>().1;
+            TestDB::with_single_file(ra_fixture).0.diagnostic::<MissingMatchArms>();
-        assert_eq!(0, diagnostic_count, "expected no diagnostic, found one");
+        assert_eq!(0, diagnostic_count, "expected no diagnostic, found one: {}", s);
    }
    #[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) => {},
@@ -1032,14 +1035,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, _) => {},
@@ -1047,14 +1050,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) => {},
@@ -1063,27 +1066,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) => {},
@@ -1091,80 +1094,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)) => {},
@@ -1173,27 +1176,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)) => {},
@@ -1201,14 +1204,14 @@ mod tests {
                    (false, _) => {},
                }
            }
-        ";
+        ",
+        );
-        check_no_diagnostic(content);
    }
    #[test]
    fn enum_no_arms() {
-        let content = r"
+        check_diagnostic(
+            r"
            enum Either {
                A,
                B,
@@ -1217,14 +1220,14 @@ mod tests {
                match Either::A {
                }
            }
-        ";
+        ",
+        );
-        check_diagnostic(content);
    }
    #[test]
    fn enum_missing_arms() {
-        let content = r"
+        check_diagnostic(
+            r"
            enum Either {
                A,
                B,
@@ -1234,14 +1237,14 @@ mod tests {
                    Either::A => {},
                }
            }
-        ";
+        ",
+        );
-        check_diagnostic(content);
    }
    #[test]
    fn enum_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
            enum Either {
                A,
                B,
@@ -1252,14 +1255,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,
@@ -1269,14 +1272,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,
@@ -1287,14 +1290,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,
@@ -1303,14 +1306,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,
@@ -1321,14 +1324,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,
@@ -1340,14 +1343,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,
@@ -1358,14 +1361,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,
@@ -1376,14 +1379,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),
@@ -1394,14 +1397,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),
@@ -1413,14 +1416,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),
@@ -1432,14 +1435,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),
@@ -1456,14 +1459,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,
@@ -1478,47 +1483,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),
@@ -1529,32 +1534,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,
@@ -1565,14 +1568,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,
@@ -1583,14 +1586,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,
@@ -1604,14 +1607,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,
@@ -1621,14 +1624,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,
@@ -1639,14 +1642,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,
@@ -1659,14 +1662,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,
@@ -1678,17 +1684,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,
@@ -1699,16 +1704,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,
@@ -1720,14 +1723,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,
@@ -1739,14 +1742,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,
@@ -1759,89 +1762,89 @@ mod tests {
                    Either::B => (),
                }
            }
-        ";
+        ",
+        );
-        check_no_diagnostic(content);
    }
    #[test]
    fn enum_record_ellipsis_missing_arm() {
-        let content = r"
+        check_diagnostic(
-             enum Either {
+            r"
-                 A { foo: bool, bar: bool },
+            enum Either {
-                 B,
+                A { foo: bool, bar: bool },
-             }
+                B,
-             fn test_fn() {
+            }
-                 match Either::B {
+            fn test_fn() {
-                     Either::A { foo: true, .. } => (),
+                match Either::B {
-                     Either::B => (),
+                    Either::A { foo: true, .. } => (),
-                 }
+                    Either::B => (),
-             }
+                }
-         ";
+            }
+        ",
-        check_diagnostic(content);
+        );
    }
    #[test]
    fn enum_record_ellipsis_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
-             enum Either {
+            r"
-                 A { foo: bool, bar: bool },
+            enum Either {
-                 B,
+                A { foo: bool, bar: bool },
-             }
+                B,
-             fn test_fn() {
+            }
-                 let a = Either::A { foo: true };
+            fn test_fn() {
-                 match a {
+                let a = Either::A { foo: true };
-                     Either::A { foo: true, .. } => (),
+                match a {
-                     Either::A { foo: false, .. } => (),
+                    Either::A { foo: true, .. } => (),
-                     Either::B => (),
+                    Either::A { foo: false, .. } => (),
-                 }
+                    Either::B => (),
-             }
+                }
-         ";
+            }
+        ",
-        check_no_diagnostic(content);
+        );
    }
    #[test]
    fn enum_record_ellipsis_all_fields_missing_arm() {
-        let content = r"
+        check_diagnostic(
-             enum Either {
+            r"
-                 A { foo: bool, bar: bool },
+            enum Either {
-                 B,
+                A { foo: bool, bar: bool },
-             }
+                B,
-             fn test_fn() {
+            }
-                 let a = Either::B;
+            fn test_fn() {
-                 match a {
+                let a = Either::B;
-                     Either::A { .. } => (),
+                match a {
-                 }
+                    Either::A { .. } => (),
-             }
+                }
-         ";
+            }
+        ",
-        check_diagnostic(content);
+        );
    }
    #[test]
    fn enum_record_ellipsis_all_fields_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
-             enum Either {
+            r"
-                 A { foo: bool, bar: bool },
+            enum Either {
-                 B,
+                A { foo: bool, bar: bool },
-             }
+                B,
-             fn test_fn() {
+            }
-                 let a = Either::B;
+            fn test_fn() {
-                 match a {
+                let a = Either::B;
-                     Either::A { .. } => (),
+                match a {
-                     Either::B => (),
+                    Either::A { .. } => (),
-                 }
+                    Either::B => (),
-             }
+                }
-         ";
+            }
+        ",
-        check_no_diagnostic(content);
+        );
    }
    #[test]
    fn enum_tuple_partial_ellipsis_no_diagnostic() {
-        let content = r"
+        check_no_diagnostic(
+            r"
            enum Either {
                A(bool, bool, bool, bool),
                B,
@@ -1855,14 +1858,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,
@@ -1876,14 +1879,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,
@@ -1896,14 +1899,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,
@@ -1916,14 +1919,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,
@@ -1934,51 +1937,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,
@@ -1988,9 +1991,49 @@ 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) => {}
+                }
+            }
+        ",
+        );
+    }
+    #[test]
+    fn or_pattern_panic_2() {
+        // FIXME: This is a false positive, but the code used to cause a panic in the match checker,
+        // so this acts as a regression test for that.
+        check_diagnostic(
+            r"
+            pub enum Category {
+                Infinity,
+                Zero,
+            }
+            fn panic(a: Category, b: Category) {
+                match (a, b) {
+                    (Category::Infinity, Category::Infinity) | (Category::Zero, Category::Zero) => {}
+                    (Category::Infinity | Category::Zero, _) => {}
+                }
+            }
+        ",
+        );
    }
 }
@@ -2010,23 +2053,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),
@@ -2036,16 +2082,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,
@@ -2055,48 +2103,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,
            }
@@ -2105,10 +2151,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_hir_ty/src/db.rs b/crates/ra_hir_ty/src/db.rs
index bf71d38d6..7889b8d2c 100644
--- a/crates/ra_hir_ty/src/db.rs
+++ b/crates/ra_hir_ty/src/db.rs
@@ -3,15 +3,15 @@
 use std::sync::Arc;
 use hir_def::{
-    db::DefDatabase, DefWithBodyId, FunctionId, GenericDefId, ImplId, LocalFieldId, TraitId,
+    db::DefDatabase, DefWithBodyId, FunctionId, GenericDefId, ImplId, LocalFieldId, TypeParamId,
-    TypeParamId, VariantId,
+    VariantId,
 };
 use ra_arena::map::ArenaMap;
 use ra_db::{impl_intern_key, salsa, CrateId, Upcast};
 use ra_prof::profile;
 use crate::{
-    method_resolution::{CrateImplDefs, TyFingerprint},
+    method_resolution::CrateImplDefs,
    traits::{chalk, AssocTyValue, Impl},
    Binders, CallableDef, GenericPredicate, InferenceResult, OpaqueTyId, PolyFnSig,
    ReturnTypeImplTraits, Substs, TraitRef, Ty, TyDefId, TypeCtor, ValueTyDefId,
@@ -70,13 +70,8 @@ pub trait HirDatabase: DefDatabase + Upcast<dyn DefDatabase> {
    #[salsa::invoke(crate::method_resolution::CrateImplDefs::impls_in_crate_query)]
    fn impls_in_crate(&self, krate: CrateId) -> Arc<CrateImplDefs>;
-    #[salsa::invoke(crate::traits::impls_for_trait_query)]
+    #[salsa::invoke(crate::method_resolution::CrateImplDefs::impls_from_deps_query)]
-    fn impls_for_trait(
+    fn impls_from_deps(&self, krate: CrateId) -> Arc<CrateImplDefs>;
-        &self,
-        krate: CrateId,
-        trait_: TraitId,
-        self_ty_fp: Option<TyFingerprint>,
-    ) -> Arc<[ImplId]>;
    // Interned IDs for Chalk integration
    #[salsa::interned]
diff --git a/crates/ra_hir_ty/src/diagnostics.rs b/crates/ra_hir_ty/src/diagnostics.rs
index 2c7298714..ebd9cb08f 100644
--- a/crates/ra_hir_ty/src/diagnostics.rs
+++ b/crates/ra_hir_ty/src/diagnostics.rs
@@ -6,7 +6,7 @@ use hir_expand::{db::AstDatabase, name::Name, HirFileId, InFile};
 use ra_syntax::{ast, AstNode, AstPtr, SyntaxNodePtr};
 use stdx::format_to;
-pub use hir_def::{diagnostics::UnresolvedModule, expr::MatchArm};
+pub use hir_def::{diagnostics::UnresolvedModule, expr::MatchArm, path::Path};
 pub use hir_expand::diagnostics::{AstDiagnostic, Diagnostic, DiagnosticSink};
 #[derive(Debug)]
@@ -29,6 +29,16 @@ impl Diagnostic for NoSuchField {
    }
 }
+impl AstDiagnostic for NoSuchField {
+    type AST = ast::RecordField;
+    fn ast(&self, db: &impl AstDatabase) -> Self::AST {
+        let root = db.parse_or_expand(self.source().file_id).unwrap();
+        let node = self.source().value.to_node(&root);
+        ast::RecordField::cast(node).unwrap()
+    }
+}
 #[derive(Debug)]
 pub struct MissingFields {
    pub file: HirFileId,
diff --git a/crates/ra_hir_ty/src/infer/expr.rs b/crates/ra_hir_ty/src/infer/expr.rs
index 9fd310f69..a9565a58d 100644
--- a/crates/ra_hir_ty/src/infer/expr.rs
+++ b/crates/ra_hir_ty/src/infer/expr.rs
@@ -10,12 +10,12 @@ use hir_def::{
    resolver::resolver_for_expr,
    AdtId, AssocContainerId, FieldId, Lookup,
 };
-use hir_expand::name::Name;
+use hir_expand::name::{name, Name};
 use ra_syntax::ast::RangeOp;
 use crate::{
    autoderef, method_resolution, op,
-    traits::InEnvironment,
+    traits::{FnTrait, InEnvironment},
    utils::{generics, variant_data, Generics},
    ApplicationTy, Binders, CallableDef, InferTy, IntTy, Mutability, Obligation, Rawness, Substs,
    TraitRef, Ty, TypeCtor,
@@ -63,6 +63,58 @@ impl<'a> InferenceContext<'a> {
        self.resolve_ty_as_possible(ty)
    }
+    fn callable_sig_from_fn_trait(&mut self, ty: &Ty, num_args: usize) -> Option<(Vec<Ty>, Ty)> {
+        let krate = self.resolver.krate()?;
+        let fn_once_trait = FnTrait::FnOnce.get_id(self.db, krate)?;
+        let output_assoc_type =
+            self.db.trait_data(fn_once_trait).associated_type_by_name(&name![Output])?;
+        let generic_params = generics(self.db.upcast(), fn_once_trait.into());
+        if generic_params.len() != 2 {
+            return None;
+        }
+        let mut param_builder = Substs::builder(num_args);
+        let mut arg_tys = vec![];
+        for _ in 0..num_args {
+            let arg = self.table.new_type_var();
+            param_builder = param_builder.push(arg.clone());
+            arg_tys.push(arg);
+        }
+        let parameters = param_builder.build();
+        let arg_ty = Ty::Apply(ApplicationTy {
+            ctor: TypeCtor::Tuple { cardinality: num_args as u16 },
+            parameters,
+        });
+        let substs = Substs::build_for_generics(&generic_params)
+            .push(ty.clone())
+            .push(arg_ty.clone())
+            .build();
+        let trait_env = Arc::clone(&self.trait_env);
+        let implements_fn_trait =
+            Obligation::Trait(TraitRef { trait_: fn_once_trait, substs: substs.clone() });
+        let goal = self.canonicalizer().canonicalize_obligation(InEnvironment {
+            value: implements_fn_trait.clone(),
+            environment: trait_env,
+        });
+        if self.db.trait_solve(krate, goal.value).is_some() {
+            self.obligations.push(implements_fn_trait);
+            let output_proj_ty =
+                crate::ProjectionTy { associated_ty: output_assoc_type, parameters: substs };
+            let return_ty = self.normalize_projection_ty(output_proj_ty);
+            Some((arg_tys, return_ty))
+        } else {
+            None
+        }
+    }
+    pub fn callable_sig(&mut self, ty: &Ty, num_args: usize) -> Option<(Vec<Ty>, Ty)> {
+        match ty.callable_sig(self.db) {
+            Some(sig) => Some((sig.params().to_vec(), sig.ret().clone())),
+            None => self.callable_sig_from_fn_trait(ty, num_args),
+        }
+    }
    fn infer_expr_inner(&mut self, tgt_expr: ExprId, expected: &Expectation) -> Ty {
        let body = Arc::clone(&self.body); // avoid borrow checker problem
        let ty = match &body[tgt_expr] {
@@ -198,14 +250,23 @@ impl<'a> InferenceContext<'a> {
            }
            Expr::Call { callee, args } => {
                let callee_ty = self.infer_expr(*callee, &Expectation::none());
-                let (param_tys, ret_ty) = match callee_ty.callable_sig(self.db) {
+                let canonicalized = self.canonicalizer().canonicalize_ty(callee_ty.clone());
-                    Some(sig) => (sig.params().to_vec(), sig.ret().clone()),
+                let mut derefs = autoderef(
-                    None => {
+                    self.db,
-                        // Not callable
+                    self.resolver.krate(),
-                        // FIXME: report an error
+                    InEnvironment {
-                        (Vec::new(), Ty::Unknown)
+                        value: canonicalized.value.clone(),
-                    }
+                        environment: self.trait_env.clone(),
-                };
+                    },
+                );
+                let (param_tys, ret_ty): (Vec<Ty>, Ty) = derefs
+                    .find_map(|callee_deref_ty| {
+                        self.callable_sig(
+                            &canonicalized.decanonicalize_ty(callee_deref_ty.value),
+                            args.len(),
+                        )
+                    })
+                    .unwrap_or((Vec::new(), Ty::Unknown));
                self.register_obligations_for_call(&callee_ty);
                self.check_call_arguments(args, &param_tys);
                self.normalize_associated_types_in(ret_ty)
diff --git a/crates/ra_hir_ty/src/infer/path.rs b/crates/ra_hir_ty/src/infer/path.rs
index 1ad0d8397..80d7ed10e 100644
--- a/crates/ra_hir_ty/src/infer/path.rs
+++ b/crates/ra_hir_ty/src/infer/path.rs
@@ -81,7 +81,7 @@ impl<'a> InferenceContext<'a> {
                let generics = crate::utils::generics(self.db.upcast(), impl_id.into());
                let substs = Substs::type_params_for_generics(&generics);
                let ty = self.db.impl_self_ty(impl_id).subst(&substs);
-                if let Some((AdtId::StructId(struct_id), _)) = ty.as_adt() {
+                if let Some((AdtId::StructId(struct_id), substs)) = ty.as_adt() {
                    let ty = self.db.value_ty(struct_id.into()).subst(&substs);
                    return Some(ty);
                } else {
diff --git a/crates/ra_hir_ty/src/lib.rs b/crates/ra_hir_ty/src/lib.rs
index 2b9372b4b..f22232324 100644
--- a/crates/ra_hir_ty/src/lib.rs
+++ b/crates/ra_hir_ty/src/lib.rs
@@ -73,6 +73,7 @@ pub use lower::{
 pub use traits::{InEnvironment, Obligation, ProjectionPredicate, TraitEnvironment};
 pub use chalk_ir::{BoundVar, DebruijnIndex};
+use itertools::Itertools;
 /// A type constructor or type name: this might be something like the primitive
 /// type `bool`, a struct like `Vec`, or things like function pointers or
@@ -815,6 +816,11 @@ impl Ty {
        }
    }
+    /// If this is a `dyn Trait`, returns that trait.
+    pub fn dyn_trait(&self) -> Option<TraitId> {
+        self.dyn_trait_ref().map(|it| it.trait_)
+    }
    fn builtin_deref(&self) -> Option<Ty> {
        match self {
            Ty::Apply(a_ty) => match a_ty.ctor {
@@ -867,13 +873,56 @@ impl Ty {
        }
    }
-    /// If this is a `dyn Trait`, returns that trait.
+    pub fn impl_trait_bounds(&self, db: &dyn HirDatabase) -> Option<Vec<GenericPredicate>> {
-    pub fn dyn_trait(&self) -> Option<TraitId> {
        match self {
-            Ty::Dyn(predicates) => predicates.iter().find_map(|pred| match pred {
+            Ty::Opaque(opaque_ty) => {
-                GenericPredicate::Implemented(tr) => Some(tr.trait_),
+                let predicates = match opaque_ty.opaque_ty_id {
-                _ => None,
+                    OpaqueTyId::ReturnTypeImplTrait(func, idx) => {
-            }),
+                        db.return_type_impl_traits(func).map(|it| {
+                            let data = (*it)
+                                .as_ref()
+                                .map(|rpit| rpit.impl_traits[idx as usize].bounds.clone());
+                            data.clone().subst(&opaque_ty.parameters)
+                        })
+                    }
+                };
+                predicates.map(|it| it.value)
+            }
+            Ty::Placeholder(id) => {
+                let generic_params = db.generic_params(id.parent);
+                let param_data = &generic_params.types[id.local_id];
+                match param_data.provenance {
+                    hir_def::generics::TypeParamProvenance::ArgumentImplTrait => {
+                        let predicates = db
+                            .generic_predicates_for_param(*id)
+                            .into_iter()
+                            .map(|pred| pred.value.clone())
+                            .collect_vec();
+                        Some(predicates)
+                    }
+                    _ => None,
+                }
+            }
+            _ => None,
+        }
+    }
+    pub fn associated_type_parent_trait(&self, db: &dyn HirDatabase) -> Option<TraitId> {
+        match self {
+            Ty::Apply(ApplicationTy { ctor: TypeCtor::AssociatedType(type_alias_id), .. }) => {
+                match type_alias_id.lookup(db.upcast()).container {
+                    AssocContainerId::TraitId(trait_id) => Some(trait_id),
+                    _ => None,
+                }
+            }
+            Ty::Projection(projection_ty) => {
+                match projection_ty.associated_ty.lookup(db.upcast()).container {
+                    AssocContainerId::TraitId(trait_id) => Some(trait_id),
+                    _ => None,
+                }
+            }
            _ => None,
        }
    }
@@ -1057,5 +1106,5 @@ pub struct ReturnTypeImplTraits {
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
 pub(crate) struct ReturnTypeImplTrait {
-    pub(crate) bounds: Binders<Vec<GenericPredicate>>,
+    pub bounds: Binders<Vec<GenericPredicate>>,
 }
diff --git a/crates/ra_hir_ty/src/lower.rs b/crates/ra_hir_ty/src/lower.rs
index 42713928f..d5154f436 100644
--- a/crates/ra_hir_ty/src/lower.rs
+++ b/crates/ra_hir_ty/src/lower.rs
@@ -337,17 +337,17 @@ impl Ty {
                    TraitRef::from_resolved_path(ctx, trait_, resolved_segment, self_ty);
                let ty = if remaining_segments.len() == 1 {
                    let segment = remaining_segments.first().unwrap();
-                    let associated_ty = associated_type_by_name_including_super_traits(
+                    let found = associated_type_by_name_including_super_traits(
-                        ctx.db.upcast(),
+                        ctx.db,
-                        trait_ref.trait_,
+                        trait_ref.clone(),
                        &segment.name,
                    );
-                    match associated_ty {
+                    match found {
-                        Some(associated_ty) => {
+                        Some((super_trait_ref, associated_ty)) => {
                            // FIXME handle type parameters on the segment
                            Ty::Projection(ProjectionTy {
                                associated_ty,
-                                parameters: trait_ref.substs,
+                                parameters: super_trait_ref.substs,
                            })
                        }
                        None => {
@@ -467,6 +467,9 @@ impl Ty {
                            }
                            TypeParamLoweringMode::Variable => t.substs.clone(),
                        };
+                        // We need to shift in the bound vars, since
+                        // associated_type_shorthand_candidates does not do that
+                        let substs = substs.shift_bound_vars(ctx.in_binders);
                        // FIXME handle type parameters on the segment
                        return Some(Ty::Projection(ProjectionTy {
                            associated_ty,
@@ -706,17 +709,17 @@ fn assoc_type_bindings_from_type_bound<'a>(
        .flat_map(|segment| segment.args_and_bindings.into_iter())
        .flat_map(|args_and_bindings| args_and_bindings.bindings.iter())
        .flat_map(move |binding| {
-            let associated_ty = associated_type_by_name_including_super_traits(
+            let found = associated_type_by_name_including_super_traits(
-                ctx.db.upcast(),
+                ctx.db,
-                trait_ref.trait_,
+                trait_ref.clone(),
                &binding.name,
            );
-            let associated_ty = match associated_ty {
+            let (super_trait_ref, associated_ty) = match found {
                None => return SmallVec::<[GenericPredicate; 1]>::new(),
                Some(t) => t,
            };
            let projection_ty =
-                ProjectionTy { associated_ty, parameters: trait_ref.substs.clone() };
+                ProjectionTy { associated_ty, parameters: super_trait_ref.substs.clone() };
            let mut preds = SmallVec::with_capacity(
                binding.type_ref.as_ref().map_or(0, |_| 1) + binding.bounds.len(),
            );
diff --git a/crates/ra_hir_ty/src/method_resolution.rs b/crates/ra_hir_ty/src/method_resolution.rs
index e83b39456..ed638c195 100644
--- a/crates/ra_hir_ty/src/method_resolution.rs
+++ b/crates/ra_hir_ty/src/method_resolution.rs
@@ -38,18 +38,53 @@ impl TyFingerprint {
    }
 }
+/// A queryable and mergeable collection of impls.
 #[derive(Debug, PartialEq, Eq)]
 pub struct CrateImplDefs {
-    impls: FxHashMap<TyFingerprint, Vec<ImplId>>,
+    inherent_impls: FxHashMap<TyFingerprint, Vec<ImplId>>,
    impls_by_trait: FxHashMap<TraitId, FxHashMap<Option<TyFingerprint>, Vec<ImplId>>>,
 }
 impl CrateImplDefs {
    pub(crate) fn impls_in_crate_query(db: &dyn HirDatabase, krate: CrateId) -> Arc<CrateImplDefs> {
        let _p = profile("impls_in_crate_query");
-        let mut res =
+        let mut res = CrateImplDefs {
-            CrateImplDefs { impls: FxHashMap::default(), impls_by_trait: FxHashMap::default() };
+            inherent_impls: FxHashMap::default(),
+            impls_by_trait: FxHashMap::default(),
+        };
+        res.fill(db, krate);
+        Arc::new(res)
+    }
+    /// Collects all impls from transitive dependencies of `krate` that may be used by `krate`.
+    ///
+    /// The full set of impls that can be used by `krate` is the returned map plus all the impls
+    /// from `krate` itself.
+    pub(crate) fn impls_from_deps_query(
+        db: &dyn HirDatabase,
+        krate: CrateId,
+    ) -> Arc<CrateImplDefs> {
+        let _p = profile("impls_from_deps_query");
+        let crate_graph = db.crate_graph();
+        let mut res = CrateImplDefs {
+            inherent_impls: FxHashMap::default(),
+            impls_by_trait: FxHashMap::default(),
+        };
+        // For each dependency, calculate `impls_from_deps` recursively, then add its own
+        // `impls_in_crate`.
+        // As we might visit crates multiple times, `merge` has to deduplicate impls to avoid
+        // wasting memory.
+        for dep in &crate_graph[krate].dependencies {
+            res.merge(&db.impls_from_deps(dep.crate_id));
+            res.merge(&db.impls_in_crate(dep.crate_id));
+        }
+        Arc::new(res)
+    }
+    fn fill(&mut self, db: &dyn HirDatabase, krate: CrateId) {
        let crate_def_map = db.crate_def_map(krate);
        for (_module_id, module_data) in crate_def_map.modules.iter() {
            for impl_id in module_data.scope.impls() {
@@ -57,7 +92,7 @@ impl CrateImplDefs {
                    Some(tr) => {
                        let self_ty = db.impl_self_ty(impl_id);
                        let self_ty_fp = TyFingerprint::for_impl(&self_ty.value);
-                        res.impls_by_trait
+                        self.impls_by_trait
                            .entry(tr.value.trait_)
                            .or_default()
                            .entry(self_ty_fp)
@@ -67,18 +102,36 @@ impl CrateImplDefs {
                    None => {
                        let self_ty = db.impl_self_ty(impl_id);
                        if let Some(self_ty_fp) = TyFingerprint::for_impl(&self_ty.value) {
-                            res.impls.entry(self_ty_fp).or_default().push(impl_id);
+                            self.inherent_impls.entry(self_ty_fp).or_default().push(impl_id);
                        }
                    }
                }
            }
        }
+    }
-        Arc::new(res)
+    fn merge(&mut self, other: &Self) {
+        for (fp, impls) in &other.inherent_impls {
+            let vec = self.inherent_impls.entry(*fp).or_default();
+            vec.extend(impls);
+            vec.sort();
+            vec.dedup();
+        }
+        for (trait_, other_map) in &other.impls_by_trait {
+            let map = self.impls_by_trait.entry(*trait_).or_default();
+            for (fp, impls) in other_map {
+                let vec = map.entry(*fp).or_default();
+                vec.extend(impls);
+                vec.sort();
+                vec.dedup();
+            }
+        }
    }
    pub fn lookup_impl_defs(&self, ty: &Ty) -> impl Iterator<Item = ImplId> + '_ {
        let fingerprint = TyFingerprint::for_impl(ty);
-        fingerprint.and_then(|f| self.impls.get(&f)).into_iter().flatten().copied()
+        fingerprint.and_then(|f| self.inherent_impls.get(&f)).into_iter().flatten().copied()
    }
    pub fn lookup_impl_defs_for_trait(&self, tr: TraitId) -> impl Iterator<Item = ImplId> + '_ {
@@ -110,7 +163,7 @@ impl CrateImplDefs {
    }
    pub fn all_impls<'a>(&'a self) -> impl Iterator<Item = ImplId> + 'a {
-        self.impls
+        self.inherent_impls
            .values()
            .chain(self.impls_by_trait.values().flat_map(|m| m.values()))
            .flatten()
diff --git a/crates/ra_hir_ty/src/tests/regression.rs b/crates/ra_hir_ty/src/tests/regression.rs
index 1f004bd63..4da2e972b 100644
--- a/crates/ra_hir_ty/src/tests/regression.rs
+++ b/crates/ra_hir_ty/src/tests/regression.rs
@@ -633,3 +633,154 @@ where
    "###
    );
 }
+#[test]
+fn issue_4953() {
+    assert_snapshot!(
+        infer(r#"
+pub struct Foo(pub i64);
+impl Foo {
+    fn test() -> Self { Self(0i64) }
+}
+"#),
+        @r###"
+    59..73 '{ Self(0i64) }': Foo
+    61..65 'Self': Foo(i64) -> Foo
+    61..71 'Self(0i64)': Foo
+    66..70 '0i64': i64
+    "###
+    );
+    assert_snapshot!(
+        infer(r#"
+pub struct Foo<T>(pub T);
+impl Foo<i64> {
+    fn test() -> Self { Self(0i64) }
+}
+"#),
+        @r###"
+    65..79 '{ Self(0i64) }': Foo<i64>
+    67..71 'Self': Foo<i64>(i64) -> Foo<i64>
+    67..77 'Self(0i64)': Foo<i64>
+    72..76 '0i64': i64
+    "###
+    );
+}
+#[test]
+fn issue_4931() {
+    assert_snapshot!(
+        infer(r#"
+trait Div<T> {
+    type Output;
+}
+trait CheckedDiv: Div<()> {}
+trait PrimInt: CheckedDiv<Output = ()> {
+    fn pow(self);
+}
+fn check<T: PrimInt>(i: T) {
+    i.pow();
+}
+"#),
+        @r###"
+    118..122 'self': Self
+    149..150 'i': T
+    155..171 '{     ...w(); }': ()
+    161..162 'i': T
+    161..168 'i.pow()': ()
+    "###
+    );
+}
+#[test]
+fn issue_4885() {
+    assert_snapshot!(
+        infer(r#"
+#[lang = "coerce_unsized"]
+pub trait CoerceUnsized<T> {}
+trait Future {
+    type Output;
+}
+trait Foo<R> {
+    type Bar;
+}
+fn foo<R, K>(key: &K) -> impl Future<Output = K::Bar>
+where
+    K: Foo<R>,
+{
+    bar(key)
+}
+fn bar<R, K>(key: &K) -> impl Future<Output = K::Bar>
+where
+    K: Foo<R>,
+{
+}
+"#),
+        @r###"
+    137..140 'key': &K
+    199..215 '{     ...key) }': impl Future<Output = <K as Foo<R>>::Bar>
+    205..208 'bar': fn bar<R, K>(&K) -> impl Future<Output = <K as Foo<R>>::Bar>
+    205..213 'bar(key)': impl Future<Output = <K as Foo<R>>::Bar>
+    209..212 'key': &K
+    229..232 'key': &K
+    291..294 '{ }': ()
+    "###
+    );
+}
+#[test]
+fn issue_4800() {
+    assert_snapshot!(
+        infer(r#"
+trait Debug {}
+struct Foo<T>;
+type E1<T> = (T, T, T);
+type E2<T> = E1<E1<E1<(T, T, T)>>>;
+impl Debug for Foo<E2<()>> {}
+struct Request;
+pub trait Future {
+    type Output;
+}
+pub struct PeerSet<D>;
+impl<D> Service<Request> for PeerSet<D>
+where
+    D: Discover,
+    D::Key: Debug,
+{
+    type Error = ();
+    type Future = dyn Future<Output = Self::Error>;
+    fn call(&mut self) -> Self::Future {
+        loop {}
+    }
+}
+pub trait Discover {
+    type Key;
+}
+pub trait Service<Request> {
+    type Error;
+    type Future: Future<Output = Self::Error>;
+    fn call(&mut self) -> Self::Future;
+}
+"#),
+        @r###"
+    380..384 'self': &mut PeerSet<D>
+    402..425 '{     ...     }': dyn Future<Output = ()>
+    412..419 'loop {}': !
+    417..419 '{}': ()
+    576..580 'self': &mut Self
+    "###
+    );
+}
diff --git a/crates/ra_hir_ty/src/tests/traits.rs b/crates/ra_hir_ty/src/tests/traits.rs
index e81193a3c..961be4abd 100644
--- a/crates/ra_hir_ty/src/tests/traits.rs
+++ b/crates/ra_hir_ty/src/tests/traits.rs
@@ -2888,3 +2888,226 @@ impl<A: Step> iter::Iterator for ops::Range<A> {
    );
    assert_eq!(t, "i32");
 }
+#[test]
+fn infer_closure_arg() {
+    assert_snapshot!(
+        infer(
+            r#"
+            //- /lib.rs
+            enum Option<T> {
+                None,
+                Some(T)
+            }
+            fn foo() {
+                let s = Option::None;
+                let f = |x: Option<i32>| {};
+                (&f)(s)
+            }
+        "#
+        ),
+        @r###"
+    137..259 '{     ...     }': ()
+    159..160 's': Option<i32>
+    163..175 'Option::None': Option<i32>
+    197..198 'f': |Option<i32>| -> ()
+    201..220 '|x: Op...2>| {}': |Option<i32>| -> ()
+    202..203 'x': Option<i32>
+    218..220 '{}': ()
+    238..245 '(&f)(s)': ()
+    239..241 '&f': &|Option<i32>| -> ()
+    240..241 'f': |Option<i32>| -> ()
+    243..244 's': Option<i32>
+    "###
+    );
+}
+#[test]
+fn infer_fn_trait_arg() {
+    assert_snapshot!(
+        infer(
+            r#"
+            //- /lib.rs deps:std
+            #[lang = "fn_once"]
+            pub trait FnOnce<Args> {
+                type Output;
+                extern "rust-call" fn call_once(&self, args: Args) -> Self::Output;
+            }
+            #[lang = "fn"]
+            pub trait Fn<Args>:FnOnce<Args> {
+                extern "rust-call" fn call(&self, args: Args) -> Self::Output;
+            }
+            enum Option<T> {
+                None,
+                Some(T)
+            }
+            fn foo<F, T>(f: F) -> T
+            where
+                F: Fn(Option<i32>) -> T,
+            {
+                let s = None;
+                f(s)
+            }
+        "#
+        ),
+        @r###"
+    183..187 'self': &Self
+    189..193 'args': Args
+    350..354 'self': &Self
+    356..360 'args': Args
+    515..516 'f': F
+    597..663 '{     ...     }': T
+    619..620 's': Option<i32>
+    623..627 'None': Option<i32>
+    645..646 'f': F
+    645..649 'f(s)': T
+    647..648 's': Option<i32>
+    "###
+    );
+}
+#[test]
+fn infer_box_fn_arg() {
+    assert_snapshot!(
+        infer(
+            r#"
+            //- /lib.rs deps:std
+            #[lang = "fn_once"]
+            pub trait FnOnce<Args> {
+                type Output;
+                extern "rust-call" fn call_once(self, args: Args) -> Self::Output;
+            }
+            #[lang = "deref"]
+            pub trait Deref {
+                type Target: ?Sized;
+                fn deref(&self) -> &Self::Target;
+            }
+            #[lang = "owned_box"]
+            pub struct Box<T: ?Sized> {
+                inner: *mut T,
+            }
+            impl<T: ?Sized> Deref for Box<T> {
+                type Target = T;
+                fn deref(&self) -> &T {
+                    &self.inner
+                }
+            }
+            enum Option<T> {
+                None,
+                Some(T)
+            }
+            fn foo() {
+                let s = Option::None;
+                let f: Box<dyn FnOnce(&Option<i32>)> = box (|ps| {});
+                f(&s)
+            }
+        "#
+        ),
+        @r###"
+    182..186 'self': Self
+    188..192 'args': Args
+    356..360 'self': &Self
+    622..626 'self': &Box<T>
+    634..685 '{     ...     }': &T
+    656..667 '&self.inner': &*mut T
+    657..661 'self': &Box<T>
+    657..667 'self.inner': *mut T
+    812..957 '{     ...     }': FnOnce::Output<dyn FnOnce<(&Option<i32>,)>, (&Option<i32>,)>
+    834..835 's': Option<i32>
+    838..850 'Option::None': Option<i32>
+    872..873 'f': Box<dyn FnOnce<(&Option<i32>,)>>
+    907..920 'box (|ps| {})': Box<|{unknown}| -> ()>
+    912..919 '|ps| {}': |{unknown}| -> ()
+    913..915 'ps': {unknown}
+    917..919 '{}': ()
+    938..939 'f': Box<dyn FnOnce<(&Option<i32>,)>>
+    938..943 'f(&s)': FnOnce::Output<dyn FnOnce<(&Option<i32>,)>, (&Option<i32>,)>
+    940..942 '&s': &Option<i32>
+    941..942 's': Option<i32>
+    "###
+    );
+}
+#[test]
+fn infer_dyn_fn_output() {
+    assert_snapshot!(
+        infer(
+            r#"
+            //- /lib.rs deps:std
+            #[lang = "fn_once"]
+            pub trait FnOnce<Args> {
+                type Output;
+                extern "rust-call" fn call_once(self, args: Args) -> Self::Output;
+            }
+            #[lang = "fn"]
+            pub trait Fn<Args>:FnOnce<Args> {
+                extern "rust-call" fn call(&self, args: Args) -> Self::Output;
+            }
+            #[lang = "deref"]
+            pub trait Deref {
+                type Target: ?Sized;
+                fn deref(&self) -> &Self::Target;
+            }
+            #[lang = "owned_box"]
+            pub struct Box<T: ?Sized> {
+                inner: *mut T,
+            }
+            impl<T: ?Sized> Deref for Box<T> {
+                type Target = T;
+                fn deref(&self) -> &T {
+                    &self.inner
+                }
+            }
+            fn foo() {
+                let f: Box<dyn Fn() -> i32> = box(|| 5);
+                let x = f();
+            }
+        "#
+        ),
+        @r###"
+    182..186 'self': Self
+    188..192 'args': Args
+    349..353 'self': &Self
+    355..359 'args': Args
+    523..527 'self': &Self
+    789..793 'self': &Box<T>
+    801..852 '{     ...     }': &T
+    823..834 '&self.inner': &*mut T
+    824..828 'self': &Box<T>
+    824..834 'self.inner': *mut T
+    889..990 '{     ...     }': ()
+    911..912 'f': Box<dyn Fn<(), Output = i32>>
+    937..946 'box(|| 5)': Box<|| -> i32>
+    941..945 '|| 5': || -> i32
+    944..945 '5': i32
+    968..969 'x': FnOnce::Output<dyn Fn<(), Output = i32>, ()>
+    972..973 'f': Box<dyn Fn<(), Output = i32>>
+    972..975 'f()': FnOnce::Output<dyn Fn<(), Output = i32>, ()>
+    "###
+    );
+}
diff --git a/crates/ra_hir_ty/src/traits.rs b/crates/ra_hir_ty/src/traits.rs
index 6bc6d474c..6f43c3a22 100644
--- a/crates/ra_hir_ty/src/traits.rs
+++ b/crates/ra_hir_ty/src/traits.rs
@@ -2,12 +2,13 @@
 use std::{panic, sync::Arc};
 use chalk_ir::cast::Cast;
-use hir_def::{expr::ExprId, DefWithBodyId, ImplId, TraitId, TypeAliasId};
+use hir_def::{
+    expr::ExprId, lang_item::LangItemTarget, DefWithBodyId, ImplId, TraitId, TypeAliasId,
+};
 use ra_db::{impl_intern_key, salsa, CrateId};
 use ra_prof::profile;
-use rustc_hash::FxHashSet;
-use crate::{db::HirDatabase, method_resolution::TyFingerprint, DebruijnIndex};
+use crate::{db::HirDatabase, DebruijnIndex};
 use super::{Canonical, GenericPredicate, HirDisplay, ProjectionTy, TraitRef, Ty, TypeWalk};
@@ -36,34 +37,6 @@ fn create_chalk_solver() -> chalk_solve::Solver<Interner> {
    solver_choice.into_solver()
 }
-/// Collects impls for the given trait in the whole dependency tree of `krate`.
-pub(crate) fn impls_for_trait_query(
-    db: &dyn HirDatabase,
-    krate: CrateId,
-    trait_: TraitId,
-    self_ty_fp: Option<TyFingerprint>,
-) -> Arc<[ImplId]> {
-    // FIXME: We could be a lot smarter here - because of the orphan rules and
-    // the fact that the trait and the self type need to be in the dependency
-    // tree of a crate somewhere for an impl to exist, we could skip looking in
-    // a lot of crates completely
-    let mut impls = FxHashSet::default();
-    // We call the query recursively here. On the one hand, this means we can
-    // reuse results from queries for different crates; on the other hand, this
-    // will only ever get called for a few crates near the root of the tree (the
-    // ones the user is editing), so this may actually be a waste of memory. I'm
-    // doing it like this mainly for simplicity for now.
-    for dep in &db.crate_graph()[krate].dependencies {
-        impls.extend(db.impls_for_trait(dep.crate_id, trait_, self_ty_fp).iter());
-    }
-    let crate_impl_defs = db.impls_in_crate(krate);
-    match self_ty_fp {
-        Some(fp) => impls.extend(crate_impl_defs.lookup_impl_defs_for_trait_and_ty(trait_, fp)),
-        None => impls.extend(crate_impl_defs.lookup_impl_defs_for_trait(trait_)),
-    }
-    impls.into_iter().collect()
-}
 /// A set of clauses that we assume to be true. E.g. if we are inside this function:
 /// ```rust
 /// fn foo<T: Default>(t: T) {}
@@ -298,6 +271,14 @@ impl FnTrait {
            FnTrait::Fn => "fn",
        }
    }
+    pub fn get_id(&self, db: &dyn HirDatabase, krate: CrateId) -> Option<TraitId> {
+        let target = db.lang_item(krate, self.lang_item_name().into())?;
+        match target {
+            LangItemTarget::TraitId(t) => Some(t),
+            _ => None,
+        }
+    }
 }
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
diff --git a/crates/ra_hir_ty/src/traits/builtin.rs b/crates/ra_hir_ty/src/traits/builtin.rs
index 88a422d2c..6d5f2d46a 100644
--- a/crates/ra_hir_ty/src/traits/builtin.rs
+++ b/crates/ra_hir_ty/src/traits/builtin.rs
@@ -40,7 +40,7 @@ pub(super) fn get_builtin_impls(
    if let Ty::Apply(ApplicationTy { ctor: TypeCtor::Closure { def, expr }, .. }) = ty {
        for &fn_trait in [super::FnTrait::FnOnce, super::FnTrait::FnMut, super::FnTrait::Fn].iter()
        {
-            if let Some(actual_trait) = get_fn_trait(db, krate, fn_trait) {
+            if let Some(actual_trait) = fn_trait.get_id(db, krate) {
                if trait_ == actual_trait {
                    let impl_ = super::ClosureFnTraitImplData { def: *def, expr: *expr, fn_trait };
                    if check_closure_fn_trait_impl_prerequisites(db, krate, impl_) {
@@ -128,7 +128,7 @@ fn check_closure_fn_trait_impl_prerequisites(
    data: super::ClosureFnTraitImplData,
 ) -> bool {
    // the respective Fn/FnOnce/FnMut trait needs to exist
-    if get_fn_trait(db, krate, data.fn_trait).is_none() {
+    if data.fn_trait.get_id(db, krate).is_none() {
        return false;
    }
@@ -136,7 +136,7 @@ fn check_closure_fn_trait_impl_prerequisites(
    // the traits having no type params, FnOnce being a supertrait
    // the FnOnce trait needs to exist and have an assoc type named Output
-    let fn_once_trait = match get_fn_trait(db, krate, super::FnTrait::FnOnce) {
+    let fn_once_trait = match (super::FnTrait::FnOnce).get_id(db, krate) {
        Some(t) => t,
        None => return false,
    };
@@ -151,7 +151,9 @@ fn closure_fn_trait_impl_datum(
    // for some closure |X, Y| -> Z:
    // impl<T, U, V> Fn<(T, U)> for closure<fn(T, U) -> V> { Output = V }
-    let trait_ = get_fn_trait(db, krate, data.fn_trait) // get corresponding fn trait
+    let trait_ = data
+        .fn_trait
+        .get_id(db, krate) // get corresponding fn trait
        // the existence of the Fn trait has been checked before
        .expect("fn trait for closure impl missing");
@@ -211,7 +213,7 @@ fn closure_fn_trait_output_assoc_ty_value(
    let output_ty = Ty::Bound(BoundVar::new(DebruijnIndex::INNERMOST, num_args.into()));
    let fn_once_trait =
-        get_fn_trait(db, krate, super::FnTrait::FnOnce).expect("assoc ty value should not exist");
+        (super::FnTrait::FnOnce).get_id(db, krate).expect("assoc ty value should not exist");
    let output_ty_id = db
        .trait_data(fn_once_trait)
@@ -360,14 +362,6 @@ fn super_trait_object_unsize_impl_datum(
    BuiltinImplData { num_vars, trait_ref, where_clauses: Vec::new(), assoc_ty_values: Vec::new() }
 }
-fn get_fn_trait(db: &dyn HirDatabase, krate: CrateId, fn_trait: super::FnTrait) -> Option<TraitId> {
-    let target = db.lang_item(krate, fn_trait.lang_item_name().into())?;
-    match target {
-        LangItemTarget::TraitId(t) => Some(t),
-        _ => None,
-    }
-}
 fn get_unsize_trait(db: &dyn HirDatabase, krate: CrateId) -> Option<TraitId> {
    let target = db.lang_item(krate, "unsize".into())?;
    match target {
diff --git a/crates/ra_hir_ty/src/traits/chalk.rs b/crates/ra_hir_ty/src/traits/chalk.rs
index a72a82f5a..2f35d6d49 100644
--- a/crates/ra_hir_ty/src/traits/chalk.rs
+++ b/crates/ra_hir_ty/src/traits/chalk.rs
@@ -74,14 +74,26 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
        // Note: Since we're using impls_for_trait, only impls where the trait
        // can be resolved should ever reach Chalk. `impl_datum` relies on that
        // and will panic if the trait can't be resolved.
-        let mut result: Vec<_> = self
+        let in_deps = self.db.impls_from_deps(self.krate);
-            .db
+        let in_self = self.db.impls_in_crate(self.krate);
-            .impls_for_trait(self.krate, trait_, self_ty_fp)
+        let impl_maps = [in_deps, in_self];
-            .iter()
-            .copied()
+        let id_to_chalk = |id: hir_def::ImplId| Impl::ImplDef(id).to_chalk(self.db);
-            .map(Impl::ImplDef)
-            .map(|impl_| impl_.to_chalk(self.db))
+        let mut result: Vec<_> = match self_ty_fp {
-            .collect();
+            Some(fp) => impl_maps
+                .iter()
+                .flat_map(|crate_impl_defs| {
+                    crate_impl_defs.lookup_impl_defs_for_trait_and_ty(trait_, fp).map(id_to_chalk)
+                })
+                .collect(),
+            None => impl_maps
+                .iter()
+                .flat_map(|crate_impl_defs| {
+                    crate_impl_defs.lookup_impl_defs_for_trait(trait_).map(id_to_chalk)
+                })
+                .collect(),
+        };
        let arg: Option<Ty> =
            parameters.get(1).map(|p| from_chalk(self.db, p.assert_ty_ref(&Interner).clone()));
diff --git a/crates/ra_hir_ty/src/utils.rs b/crates/ra_hir_ty/src/utils.rs
index f98350bf9..c45820ff0 100644
--- a/crates/ra_hir_ty/src/utils.rs
+++ b/crates/ra_hir_ty/src/utils.rs
@@ -143,13 +143,14 @@ pub(super) fn find_super_trait_path(
 }
 pub(super) fn associated_type_by_name_including_super_traits(
-    db: &dyn DefDatabase,
+    db: &dyn HirDatabase,
-    trait_: TraitId,
+    trait_ref: TraitRef,
    name: &Name,
-) -> Option<TypeAliasId> {
+) -> Option<(TraitRef, TypeAliasId)> {
-    all_super_traits(db, trait_)
+    all_super_trait_refs(db, trait_ref).into_iter().find_map(|t| {
-        .into_iter()
+        let assoc_type = db.trait_data(t.trait_).associated_type_by_name(name)?;
-        .find_map(|t| db.trait_data(t).associated_type_by_name(name))
+        Some((t, assoc_type))
+    })
 }
 pub(super) fn variant_data(db: &dyn DefDatabase, var: VariantId) -> Arc<VariantData> {
@@ -176,6 +177,7 @@ pub(crate) fn generics(db: &dyn DefDatabase, def: GenericDefId) -> Generics {
    Generics { def, params: db.generic_params(def), parent_generics }
 }
+#[derive(Debug)]
 pub(crate) struct Generics {
    def: GenericDefId,
    pub(crate) params: Arc<GenericParams>,
diff --git a/crates/ra_ide/Cargo.toml b/crates/ra_ide/Cargo.toml
index 05c940605..bbc6a5c9b 100644
--- a/crates/ra_ide/Cargo.toml
+++ b/crates/ra_ide/Cargo.toml
@@ -29,6 +29,7 @@ ra_fmt = { path = "../ra_fmt" }
 ra_prof = { path = "../ra_prof" }
 test_utils = { path = "../test_utils" }
 ra_assists = { path = "../ra_assists" }
+ra_ssr = { path = "../ra_ssr" }
 # ra_ide should depend only on the top-level `hir` package. if you need
 # something from some `hir_xxx` subpackage, reexport the API via `hir`.
diff --git a/crates/ra_ide/src/diagnostics.rs b/crates/ra_ide/src/diagnostics.rs
index e1bfd72f9..a88a978d7 100644
--- a/crates/ra_ide/src/diagnostics.rs
+++ b/crates/ra_ide/src/diagnostics.rs
@@ -8,15 +8,15 @@ use std::cell::RefCell;
 use hir::{
    diagnostics::{AstDiagnostic, Diagnostic as _, DiagnosticSink},
-    Semantics,
+    HasSource, HirDisplay, Semantics, VariantDef,
 };
 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::{
    algo,
-    ast::{self, make, AstNode},
+    ast::{self, edit::IndentLevel, make, AstNode},
    SyntaxNode, TextRange, T,
 };
 use ra_text_edit::{TextEdit, TextEditBuilder};
@@ -57,14 +57,10 @@ pub(crate) fn diagnostics(db: &RootDatabase, file_id: FileId) -> Vec<Diagnostic>
    })
    .on::<hir::diagnostics::UnresolvedModule, _>(|d| {
        let original_file = d.source().file_id.original_file(db);
-        let source_root = db.file_source_root(original_file);
+        let fix = Fix::new(
-        let path = db
+            "Create module",
-            .file_relative_path(original_file)
+            FileSystemEdit::CreateFile { anchor: original_file, dst: d.candidate.clone() }.into(),
-            .parent()
+        );
-            .unwrap_or_else(|| RelativePath::new(""))
-            .join(&d.candidate);
-        let fix =
-            Fix::new("Create module", FileSystemEdit::CreateFile { source_root, path }.into());
        res.borrow_mut().push(Diagnostic {
            range: sema.diagnostics_range(d).range,
            message: d.message(),
@@ -123,7 +119,16 @@ pub(crate) fn diagnostics(db: &RootDatabase, file_id: FileId) -> Vec<Diagnostic>
            severity: Severity::Error,
            fix: Some(fix),
        })
+    })
+    .on::<hir::diagnostics::NoSuchField, _>(|d| {
+        res.borrow_mut().push(Diagnostic {
+            range: sema.diagnostics_range(d).range,
+            message: d.message(),
+            severity: Severity::Error,
+            fix: missing_struct_field_fix(&sema, file_id, d),
+        })
    });
    if let Some(m) = sema.to_module_def(file_id) {
        m.diagnostics(db, &mut sink);
    };
@@ -131,6 +136,68 @@ pub(crate) fn diagnostics(db: &RootDatabase, file_id: FileId) -> Vec<Diagnostic>
    res.into_inner()
 }
+fn missing_struct_field_fix(
+    sema: &Semantics<RootDatabase>,
+    file_id: FileId,
+    d: &hir::diagnostics::NoSuchField,
+) -> Option<Fix> {
+    let record_expr = sema.ast(d);
+    let record_lit = ast::RecordLit::cast(record_expr.syntax().parent()?.parent()?)?;
+    let def_id = sema.resolve_variant(record_lit)?;
+    let module;
+    let record_fields = match VariantDef::from(def_id) {
+        VariantDef::Struct(s) => {
+            module = s.module(sema.db);
+            let source = s.source(sema.db);
+            let fields = source.value.field_def_list()?;
+            record_field_def_list(fields)?
+        }
+        VariantDef::Union(u) => {
+            module = u.module(sema.db);
+            let source = u.source(sema.db);
+            source.value.record_field_def_list()?
+        }
+        VariantDef::EnumVariant(e) => {
+            module = e.module(sema.db);
+            let source = e.source(sema.db);
+            let fields = source.value.field_def_list()?;
+            record_field_def_list(fields)?
+        }
+    };
+    let new_field_type = sema.type_of_expr(&record_expr.expr()?)?;
+    let new_field = make::record_field_def(
+        record_expr.field_name()?,
+        make::type_ref(&new_field_type.display_source_code(sema.db, module.into()).ok()?),
+    );
+    let last_field = record_fields.fields().last()?;
+    let last_field_syntax = last_field.syntax();
+    let indent = IndentLevel::from_node(last_field_syntax);
+    let mut new_field = format!("\n{}{}", indent, new_field);
+    let needs_comma = !last_field_syntax.to_string().ends_with(",");
+    if needs_comma {
+        new_field = format!(",{}", new_field);
+    }
+    let source_change = SourceFileEdit {
+        file_id,
+        edit: TextEdit::insert(last_field_syntax.text_range().end(), new_field),
+    };
+    let fix = Fix::new("Create field", source_change.into());
+    return Some(fix);
+    fn record_field_def_list(field_def_list: ast::FieldDefList) -> Option<ast::RecordFieldDefList> {
+        match field_def_list {
+            ast::FieldDefList::RecordFieldDefList(it) => Some(it),
+            ast::FieldDefList::TupleFieldDefList(_) => None,
+        }
+    }
+}
 fn check_unnecessary_braces_in_use_statement(
    acc: &mut Vec<Diagnostic>,
    file_id: FileId,
@@ -612,10 +679,10 @@ mod tests {
                            source_file_edits: [],
                            file_system_edits: [
                                CreateFile {
-                                    source_root: SourceRootId(
+                                    anchor: FileId(
-                                        0,
+                                        1,
                                    ),
-                                    path: "foo.rs",
+                                    dst: "foo.rs",
                                },
                            ],
                            is_snippet: false,
@@ -795,4 +862,27 @@ fn main() {
            check_struct_shorthand_initialization,
        );
    }
+    #[test]
+    fn test_add_field_from_usage() {
+        check_apply_diagnostic_fix(
+            r"
+            fn main() {
+                Foo { bar: 3, baz: false};
+            }
+            struct Foo {
+                bar: i32
+            }
+            ",
+            r"
+            fn main() {
+                Foo { bar: 3, baz: false};
+            }
+            struct Foo {
+                bar: i32,
+                baz: bool
+            }
+            ",
+        )
+    }
 }
diff --git a/crates/ra_ide/src/display/navigation_target.rs b/crates/ra_ide/src/display/navigation_target.rs
index c7bb1e69f..0b52b01ab 100644
--- a/crates/ra_ide/src/display/navigation_target.rs
+++ b/crates/ra_ide/src/display/navigation_target.rs
@@ -135,8 +135,8 @@ impl NavigationTarget {
        db: &RootDatabase,
        node: InFile<&dyn ast::NameOwner>,
    ) -> NavigationTarget {
-        //FIXME: use `_` instead of empty string
+        let name =
-        let name = node.value.name().map(|it| it.text().clone()).unwrap_or_default();
+            node.value.name().map(|it| it.text().clone()).unwrap_or_else(|| SmolStr::new("_"));
        let focus_range =
            node.value.name().map(|it| original_range(db, node.with_value(it.syntax())).range);
        let frange = original_range(db, node.map(|it| it.syntax()));
@@ -150,6 +150,25 @@ impl NavigationTarget {
        )
    }
+    /// Allows `NavigationTarget` to be created from a `DocCommentsOwner` and a `NameOwner`
+    pub(crate) fn from_doc_commented(
+        db: &RootDatabase,
+        named: InFile<&dyn ast::NameOwner>,
+        node: InFile<&dyn ast::DocCommentsOwner>,
+    ) -> NavigationTarget {
+        let name =
+            named.value.name().map(|it| it.text().clone()).unwrap_or_else(|| SmolStr::new("_"));
+        let frange = original_range(db, node.map(|it| it.syntax()));
+        NavigationTarget::from_syntax(
+            frange.file_id,
+            name,
+            None,
+            frange.range,
+            node.value.syntax().kind(),
+        )
+    }
    fn from_syntax(
        file_id: FileId,
        name: SmolStr,
diff --git a/crates/ra_ide/src/hover.rs b/crates/ra_ide/src/hover.rs
index ad78b7671..d870e4cbc 100644
--- a/crates/ra_ide/src/hover.rs
+++ b/crates/ra_ide/src/hover.rs
@@ -2,7 +2,7 @@ use std::iter::once;
 use hir::{
    Adt, AsAssocItem, AssocItemContainer, Documentation, FieldSource, HasSource, HirDisplay,
-    ModuleDef, ModuleSource, Semantics,
+    Module, ModuleDef, ModuleSource, Semantics,
 };
 use itertools::Itertools;
 use ra_db::SourceDatabase;
@@ -13,7 +13,9 @@ use ra_ide_db::{
 use ra_syntax::{ast, match_ast, AstNode, SyntaxKind::*, SyntaxToken, TokenAtOffset};
 use crate::{
-    display::{macro_label, rust_code_markup, rust_code_markup_with_doc, ShortLabel, ToNav},
+    display::{
+        macro_label, rust_code_markup, rust_code_markup_with_doc, ShortLabel, ToNav, TryToNav,
+    },
    runnables::runnable,
    FileId, FilePosition, NavigationTarget, RangeInfo, Runnable,
 };
@@ -24,19 +26,21 @@ pub struct HoverConfig {
    pub implementations: bool,
    pub run: bool,
    pub debug: bool,
+    pub goto_type_def: bool,
 }
 impl Default for HoverConfig {
    fn default() -> Self {
-        Self { implementations: true, run: true, debug: true }
+        Self { implementations: true, run: true, debug: true, goto_type_def: true }
    }
 }
 impl HoverConfig {
-    pub const NO_ACTIONS: Self = Self { implementations: false, run: false, debug: false };
+    pub const NO_ACTIONS: Self =
+        Self { implementations: false, run: false, debug: false, goto_type_def: false };
    pub fn any(&self) -> bool {
-        self.implementations || self.runnable()
+        self.implementations || self.runnable() || self.goto_type_def
    }
    pub fn none(&self) -> bool {
@@ -52,6 +56,13 @@ impl HoverConfig {
 pub enum HoverAction {
    Runnable(Runnable),
    Implementaion(FilePosition),
+    GoToType(Vec<HoverGotoTypeData>),
+}
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct HoverGotoTypeData {
+    pub mod_path: String,
+    pub nav: NavigationTarget,
 }
 /// Contains the results when hovering over an item
@@ -138,6 +149,10 @@ pub(crate) fn hover(db: &RootDatabase, position: FilePosition) -> Option<RangeIn
                res.push_action(action);
            }
+            if let Some(action) = goto_type_action(db, name_kind) {
+                res.push_action(action);
+            }
            return Some(RangeInfo::new(range, res));
        }
    }
@@ -218,6 +233,44 @@ fn runnable_action(
    }
 }
+fn goto_type_action(db: &RootDatabase, def: Definition) -> Option<HoverAction> {
+    match def {
+        Definition::Local(it) => {
+            let mut targets: Vec<ModuleDef> = Vec::new();
+            let mut push_new_def = |item: ModuleDef| {
+                if !targets.contains(&item) {
+                    targets.push(item);
+                }
+            };
+            it.ty(db).walk(db, |t| {
+                if let Some(adt) = t.as_adt() {
+                    push_new_def(adt.into());
+                } else if let Some(trait_) = t.as_dyn_trait() {
+                    push_new_def(trait_.into());
+                } else if let Some(traits) = t.as_impl_traits(db) {
+                    traits.into_iter().for_each(|it| push_new_def(it.into()));
+                } else if let Some(trait_) = t.as_associated_type_parent_trait(db) {
+                    push_new_def(trait_.into());
+                }
+            });
+            let targets = targets
+                .into_iter()
+                .filter_map(|it| {
+                    Some(HoverGotoTypeData {
+                        mod_path: mod_path(db, &it)?,
+                        nav: it.try_to_nav(db)?,
+                    })
+                })
+                .collect();
+            Some(HoverAction::GoToType(targets))
+        }
+        _ => None,
+    }
+}
 fn hover_text(
    docs: Option<String>,
    desc: Option<String>,
@@ -248,25 +301,31 @@ fn definition_owner_name(db: &RootDatabase, def: &Definition) -> Option<String>
    .map(|name| name.to_string())
 }
-fn determine_mod_path(db: &RootDatabase, def: &Definition) -> Option<String> {
+fn determine_mod_path(db: &RootDatabase, module: Module, name: Option<String>) -> String {
-    let mod_path = def.module(db).map(|module| {
+    once(db.crate_graph()[module.krate().into()].display_name.as_ref().map(ToString::to_string))
-        once(db.crate_graph()[module.krate().into()].display_name.as_ref().map(ToString::to_string))
+        .chain(
-            .chain(
+            module
-                module
+                .path_to_root(db)
-                    .path_to_root(db)
+                .into_iter()
-                    .into_iter()
+                .rev()
-                    .rev()
+                .map(|it| it.name(db).map(|name| name.to_string())),
-                    .map(|it| it.name(db).map(|name| name.to_string())),
+        )
-            )
+        .chain(once(name))
-            .chain(once(definition_owner_name(db, def)))
+        .flatten()
-            .flatten()
+        .join("::")
-            .join("::")
+}
-    });
-    mod_path
+// returns None only for ModuleDef::BuiltinType
+fn mod_path(db: &RootDatabase, item: &ModuleDef) -> Option<String> {
+    Some(determine_mod_path(db, item.module(db)?, item.name(db).map(|name| name.to_string())))
+}
+fn definition_mod_path(db: &RootDatabase, def: &Definition) -> Option<String> {
+    def.module(db).map(|module| determine_mod_path(db, module, definition_owner_name(db, def)))
 }
 fn hover_text_from_name_kind(db: &RootDatabase, def: Definition) -> Option<String> {
-    let mod_path = determine_mod_path(db, &def);
+    let mod_path = definition_mod_path(db, &def);
    return match def {
        Definition::Macro(it) => {
            let src = it.source(db);
@@ -1310,4 +1369,1045 @@ fn func(foo: i32) { if true { <|>foo; }; }
            ]
            "###);
    }
+    #[test]
+    fn test_hover_struct_has_goto_type_action() {
+        let (_, actions) = check_hover_result(
+            "
+            //- /main.rs
+            struct S{ f1: u32 }
+            fn main() {
+                let s<|>t = S{ f1:0 };
+            }
+            ",
+            &["S"],
+        );
+        assert_debug_snapshot!(actions,
+            @r###"
+            [
+                GoToType(
+                    [
+                        HoverGotoTypeData {
+                            mod_path: "S",
+                            nav: NavigationTarget {
+                                file_id: FileId(
+                                    1,
+                                ),
+                                full_range: 0..19,
+                                name: "S",
+                                kind: STRUCT_DEF,
+                                focus_range: Some(
+                                    7..8,
+                                ),
+                                container_name: None,
+                                description: Some(
+                                    "struct S",
+                                ),
+                                docs: None,
+                            },
+                        },
+                    ],
+                ),
+            ]
+            "###);
+    }
+    #[test]
+    fn test_hover_generic_struct_has_goto_type_actions() {
+        let (_, actions) = check_hover_result(
+            "
+            //- /main.rs
+            struct Arg(u32);
+            struct S<T>{ f1: T }
+            fn main() {
+                let s<|>t = S{ f1:Arg(0) };
+            }
+            ",
+            &["S<Arg>"],
+        );
+        assert_debug_snapshot!(actions,
+            @r###"
+            [
+                GoToType(
+                    [
+                        HoverGotoTypeData {
+                            mod_path: "S",
+                            nav: NavigationTarget {
+                                file_id: FileId(
+                                    1,
+                                ),
+                                full_range: 17..37,
+                                name: "S",
+                                kind: STRUCT_DEF,
+                                focus_range: Some(
+                                    24..25,
+                                ),
+                                container_name: None,
+                                description: Some(
+                                    "struct S",
+                                ),
+                                docs: None,
+                            },
+                        },
+                        HoverGotoTypeData {
+                            mod_path: "Arg",
+                            nav: NavigationTarget {
+                                file_id: FileId(
+                                    1,
+                                ),
+                                full_range: 0..16,
+                                name: "Arg",
+                                kind: STRUCT_DEF,
+                                focus_range: Some(
+                                    7..10,
+                                ),
+                                container_name: None,
+                                description: Some(
+                                    "struct Arg",
+                                ),
+                                docs: None,
+                            },
+                        },
+                    ],
+                ),
+            ]
+            "###);
+    }
+    #[test]
+    fn test_hover_generic_struct_has_flattened_goto_type_actions() {
+        let (_, actions) = check_hover_result(
+            "
+            //- /main.rs
+            struct Arg(u32);
+            struct S<T>{ f1: T }
+            fn main() {
+                let s<|>t = S{ f1: S{ f1: Arg(0) } };
+            }
+            ",
+            &["S<S<Arg>>"],
+        );
+        assert_debug_snapshot!(actions,
+            @r###"
+            [
+                GoToType(
+                    [
+                        HoverGotoTypeData {
+                            mod_path: "S",
+                            nav: NavigationTarget {
+                                file_id: FileId(
+                                    1,
+                                ),
+                                full_range: 17..37,
+                                name: "S",
+                                kind: STRUCT_DEF,
+                                focus_range: Some(
+                                    24..25,
+                                ),
+                                container_name: None,
+                                description: Some(
+                                    "struct S",
+                                ),
+                                docs: None,
+                            },
+                        },
+                        HoverGotoTypeData {
+                            mod_path: "Arg",
+                            nav: NavigationTarget {
+                                file_id: FileId(
+                                    1,
+                                ),
+                                full_range: 0..16,
+                                name: "Arg",
+                                kind: STRUCT_DEF,
+                                focus_range: Some(
+                                    7..10,
+                                ),
+                                container_name: None,
+                                description: Some(
+                                    "struct Arg",
+                                ),
+                                docs: None,
+                            },
+                        },
+                    ],
+                ),
+            ]
+            "###);
+    }
+    #[test]
+    fn test_hover_tuple_has_goto_type_actions() {
+        let (_, actions) = check_hover_result(
+            "
+            //- /main.rs
+            struct A(u32);
+            struct B(u32);
+            mod M {
+                pub struct C(u32);
+            }
+            fn main() {
+                let s<|>t = (A(1), B(2), M::C(3) );
+            }
+            ",
+            &["(A, B, C)"],
+        );
+        assert_debug_snapshot!(actions,
+            @r###"
+            [
+                GoToType(
+                    [
+                        HoverGotoTypeData {
+                            mod_path: "A",
+                            nav: NavigationTarget {
+                                file_id: FileId(
+                                    1,
+                                ),
+                                full_range: 0..14,
+                                name: "A",
+                                kind: STRUCT_DEF,
+                                focus_range: Some(
+                                    7..8,
+                                ),
+                                container_name: None,
+                                description: Some(
+                                    "struct A",
+                                ),
+                                docs: None,
+                            },
+                        },
+                        HoverGotoTypeData {
+                            mod_path: "B",
+                            nav: NavigationTarget {
+                                file_id: FileId(
+                                    1,
+                                ),
+                                full_range: 15..29,
+                                name: "B",
+                                kind: STRUCT_DEF,
+                                focus_range: Some(
+                                    22..23,
+                                ),
+                                container_name: None,
+                                description: Some(
+                                    "struct B",
+                                ),
+                                docs: None,
+                            },
+                        },
+                        HoverGotoTypeData {
+                            mod_path: "M::C",
+                            nav: NavigationTarget {
+                                file_id: FileId(
+                                    1,
+                                ),
+                                full_range: 42..60,
+                                name: "C",
+                                kind: STRUCT_DEF,
+                                focus_range: Some(
+                                    53..54,
+                                ),
+                                container_name: None,
+                                description: Some(
+                                    "pub struct C",
+                                ),
+                                docs: None,
+                            },
+                        },
+                    ],
+                ),
+            ]
+               "###);
+    }
+    #[test]
+    fn test_hover_return_impl_trait_has_goto_type_action() {
+        let (_, actions) = check_hover_result(
+            "
+            //- /main.rs
+            trait Foo {}
+            fn foo() -> impl Foo {}
+            fn main() {
+                let s<|>t = foo();
+            }
+            ",
+            &["impl Foo"],
+        );
+        assert_debug_snapshot!(actions,
+            @r###"
+            [
+                GoToType(
+                    [
+                        HoverGotoTypeData {
+                            mod_path: "Foo",
+                            nav: NavigationTarget {
+                                file_id: FileId(
+                                    1,
+                                ),
+                                full_range: 0..12,
+                                name: "Foo",
+                                kind: TRAIT_DEF,
+                                focus_range: Some(
+                                    6..9,
+                                ),
+                                container_name: None,
+                                description: Some(
+                                    "trait Foo",
+                                ),
+                                docs: None,
+                            },
+                        },
+                    ],
+                ),
+            ]
+            "###);
+    }
+    #[test]
+    fn test_hover_generic_return_impl_trait_has_goto_type_action() {
+        let (_, actions) = check_hover_result(
+            "
+            //- /main.rs
+            trait Foo<T> {}
+            struct S;
+            fn foo() -> impl Foo<S> {}
+            fn main() {
+                let s<|>t = foo();
+            }
+            ",
+            &["impl Foo<S>"],
+        );
+        assert_debug_snapshot!(actions,
+            @r###"
+            [
+                GoToType(
+                    [
+                        HoverGotoTypeData {
+                            mod_path: "Foo",
+                            nav: NavigationTarget {
+                                file_id: FileId(
+                                    1,
+                                ),
+                                full_range: 0..15,
+                                name: "Foo",
+                                kind: TRAIT_DEF,
+                                focus_range: Some(
+                                    6..9,
+                                ),
+                                container_name: None,
+                                description: Some(
+                                    "trait Foo",
+                                ),
+                                docs: None,
+                            },
+                        },
+                        HoverGotoTypeData {
+                            mod_path: "S",
+                            nav: NavigationTarget {
+                                file_id: FileId(
+                                    1,
+                                ),
+                                full_range: 16..25,
+                                name: "S",
+                                kind: STRUCT_DEF,
+                                focus_range: Some(
+                                    23..24,
+                                ),
+                                container_name: None,
+                                description: Some(
+                                    "struct S",
+                                ),
+                                docs: None,
+                            },
+                        },
+                    ],
+                ),
+            ]
+            "###);
+    }
+    #[test]
+    fn test_hover_return_impl_traits_has_goto_type_action() {
+        let (_, actions) = check_hover_result(
+            "
+            //- /main.rs
+            trait Foo {}
+            trait Bar {}
+            fn foo() -> impl Foo + Bar {}
+            fn main() {
+                let s<|>t = foo();
+            }
+            ",
+            &["impl Foo + Bar"],
+        );
+        assert_debug_snapshot!(actions,
+            @r###"
+            [
+                GoToType(
+                    [
+                        HoverGotoTypeData {
+                            mod_path: "Foo",
+                            nav: NavigationTarget {
+                                file_id: FileId(
+                                    1,
+                                ),
+                                full_range: 0..12,
+                                name: "Foo",
+                                kind: TRAIT_DEF,
+                                focus_range: Some(
+                                    6..9,
+                                ),
+                                container_name: None,
+                                description: Some(
+                                    "trait Foo",
+                                ),
+                                docs: None,
+                            },
+                        },
+                        HoverGotoTypeData {
+                            mod_path: "Bar",
+                            nav: NavigationTarget {
+                                file_id: FileId(
+                                    1,
+                                ),
+                                full_range: 13..25,
+                                name: "Bar",
+                                kind: TRAIT_DEF,
+                                focus_range: Some(
+                                    19..22,
+                                ),
+                                container_name: None,
+                                description: Some(
+                                    "trait Bar",
+                                ),
+                                docs: None,
+                            },
+                        },
+                    ],
+                ),
+            ]
+            "###);
+    }
+    #[test]
+    fn test_hover_generic_return_impl_traits_has_goto_type_action() {
+        let (_, actions) = check_hover_result(
+            "
+            //- /main.rs
+            trait Foo<T> {}
+            trait Bar<T> {}
+            struct S1 {}
+            struct S2 {}
+            fn foo() -> impl Foo<S1> + Bar<S2> {}
+            fn main() {
+                let s<|>t = foo();
+            }
+            ",
+            &["impl Foo<S1> + Bar<S2>"],
+        );
+        assert_debug_snapshot!(actions,
+            @r###"
+            [
+                GoToType(
+                    [
+                        HoverGotoTypeData {
+                            mod_path: "Foo",
+                            nav: NavigationTarget {
+                                file_id: FileId(
+                                    1,
+                                ),
+                                full_range: 0..15,
+                                name: "Foo",
+                                kind: TRAIT_DEF,
+                                focus_range: Some(
+                                    6..9,
+                                ),
+                                container_name: None,
+                                description: Some(
+                                    "trait Foo",
+                                ),
+                                docs: None,
+                            },
+                        },
+                        HoverGotoTypeData {
+                            mod_path: "Bar",
+                            nav: NavigationTarget {
+                                file_id: FileId(
+                                    1,
+                                ),
+                                full_range: 16..31,
+                                name: "Bar",
+                                kind: TRAIT_DEF,
+                                focus_range: Some(
+                                    22..25,
+                                ),
+                                container_name: None,
+                                description: Some(
+                                    "trait Bar",
+                                ),
+                                docs: None,
+                            },
+                        },
+                        HoverGotoTypeData {
+                            mod_path: "S1",
+                            nav: NavigationTarget {
+                                file_id: FileId(
+                                    1,
+                                ),
+                                full_range: 32..44,
+                                name: "S1",
+                                kind: STRUCT_DEF,
+                                focus_range: Some(
+                                    39..41,
+                                ),
+                                container_name: None,
+                                description: Some(
+                                    "struct S1",
+                                ),
+                                docs: None,
+                            },
+                        },
+                        HoverGotoTypeData {
+                            mod_path: "S2",
+                            nav: NavigationTarget {
+                                file_id: FileId(
+                                    1,
+                                ),
+                                full_range: 45..57,
+                                name: "S2",
+                                kind: STRUCT_DEF,
+                                focus_range: Some(
+                                    52..54,
+                                ),
+                                container_name: None,
+                                description: Some(
+                                    "struct S2",
+                                ),
+                                docs: None,
+                            },
+                        },
+                    ],
+                ),
+            ]
+               "###);
+    }
+    #[test]
+    fn test_hover_arg_impl_trait_has_goto_type_action() {
+        let (_, actions) = check_hover_result(
+            "
+            //- /lib.rs
+            trait Foo {}
+            fn foo(ar<|>g: &impl Foo) {}
+            ",
+            &["&impl Foo"],
+        );
+        assert_debug_snapshot!(actions,
+            @r###"
+            [
+                GoToType(
+                    [
+                        HoverGotoTypeData {
+                            mod_path: "Foo",
+                            nav: NavigationTarget {
+                                file_id: FileId(
+                                    1,
+                                ),
+                                full_range: 0..12,
+                                name: "Foo",
+                                kind: TRAIT_DEF,
+                                focus_range: Some(
+                                    6..9,
+                                ),
+                                container_name: None,
+                                description: Some(
+                                    "trait Foo",
+                                ),
+                                docs: None,
+                            },
+                        },
+                    ],
+                ),
+            ]
+            "###);
+    }
+    #[test]
+    fn test_hover_arg_impl_traits_has_goto_type_action() {
+        let (_, actions) = check_hover_result(
+            "
+            //- /lib.rs
+            trait Foo {}
+            trait Bar<T> {}
+            struct S{}
+            fn foo(ar<|>g: &impl Foo + Bar<S>) {}
+            ",
+            &["&impl Foo + Bar<S>"],
+        );
+        assert_debug_snapshot!(actions,
+            @r###"
+            [
+                GoToType(
+                    [
+                        HoverGotoTypeData {
+                            mod_path: "Foo",
+                            nav: NavigationTarget {
+                                file_id: FileId(
+                                    1,
+                                ),
+                                full_range: 0..12,
+                                name: "Foo",
+                                kind: TRAIT_DEF,
+                                focus_range: Some(
+                                    6..9,
+                                ),
+                                container_name: None,
+                                description: Some(
+                                    "trait Foo",
+                                ),
+                                docs: None,
+                            },
+                        },
+                        HoverGotoTypeData {
+                            mod_path: "Bar",
+                            nav: NavigationTarget {
+                                file_id: FileId(
+                                    1,
+                                ),
+                                full_range: 13..28,
+                                name: "Bar",
+                                kind: TRAIT_DEF,
+                                focus_range: Some(
+                                    19..22,
+                                ),
+                                container_name: None,
+                                description: Some(
+                                    "trait Bar",
+                                ),
+                                docs: None,
+                            },
+                        },
+                        HoverGotoTypeData {
+                            mod_path: "S",
+                            nav: NavigationTarget {
+                                file_id: FileId(
+                                    1,
+                                ),
+                                full_range: 29..39,
+                                name: "S",
+                                kind: STRUCT_DEF,
+                                focus_range: Some(
+                                    36..37,
+                                ),
+                                container_name: None,
+                                description: Some(
+                                    "struct S",
+                                ),
+                                docs: None,
+                            },
+                        },
+                    ],
+                ),
+            ]
+            "###);
+    }
+    #[test]
+    fn test_hover_arg_generic_impl_trait_has_goto_type_action() {
+        let (_, actions) = check_hover_result(
+            "
+            //- /lib.rs
+            trait Foo<T> {}
+            struct S {}
+            fn foo(ar<|>g: &impl Foo<S>) {}
+            ",
+            &["&impl Foo<S>"],
+        );
+        assert_debug_snapshot!(actions,
+            @r###"
+            [
+                GoToType(
+                    [
+                        HoverGotoTypeData {
+                            mod_path: "Foo",
+                            nav: NavigationTarget {
+                                file_id: FileId(
+                                    1,
+                                ),
+                                full_range: 0..15,
+                                name: "Foo",
+                                kind: TRAIT_DEF,
+                                focus_range: Some(
+                                    6..9,
+                                ),
+                                container_name: None,
+                                description: Some(
+                                    "trait Foo",
+                                ),
+                                docs: None,
+                            },
+                        },
+                        HoverGotoTypeData {
+                            mod_path: "S",
+                            nav: NavigationTarget {
+                                file_id: FileId(
+                                    1,
+                                ),
+                                full_range: 16..27,
+                                name: "S",
+                                kind: STRUCT_DEF,
+                                focus_range: Some(
+                                    23..24,
+                                ),
+                                container_name: None,
+                                description: Some(
+                                    "struct S",
+                                ),
+                                docs: None,
+                            },
+                        },
+                    ],
+                ),
+            ]
+            "###);
+    }
+    #[test]
+    fn test_hover_dyn_return_has_goto_type_action() {
+        let (_, actions) = check_hover_result(
+            "
+            //- /main.rs
+            trait Foo {}
+            struct S;
+            impl Foo for S {}
+            struct B<T>{}
+            fn foo() -> B<dyn Foo> {}
+            fn main() {
+                let s<|>t = foo();
+            }
+            ",
+            &["B<dyn Foo>"],
+        );
+        assert_debug_snapshot!(actions,
+            @r###"
+            [
+                GoToType(
+                    [
+                        HoverGotoTypeData {
+                            mod_path: "B",
+                            nav: NavigationTarget {
+                                file_id: FileId(
+                                    1,
+                                ),
+                                full_range: 41..54,
+                                name: "B",
+                                kind: STRUCT_DEF,
+                                focus_range: Some(
+                                    48..49,
+                                ),
+                                container_name: None,
+                                description: Some(
+                                    "struct B",
+                                ),
+                                docs: None,
+                            },
+                        },
+                        HoverGotoTypeData {
+                            mod_path: "Foo",
+                            nav: NavigationTarget {
+                                file_id: FileId(
+                                    1,
+                                ),
+                                full_range: 0..12,
+                                name: "Foo",
+                                kind: TRAIT_DEF,
+                                focus_range: Some(
+                                    6..9,
+                                ),
+                                container_name: None,
+                                description: Some(
+                                    "trait Foo",
+                                ),
+                                docs: None,
+                            },
+                        },
+                    ],
+                ),
+            ]
+            "###);
+    }
+    #[test]
+    fn test_hover_dyn_arg_has_goto_type_action() {
+        let (_, actions) = check_hover_result(
+            "
+            //- /lib.rs
+            trait Foo {}
+            fn foo(ar<|>g: &dyn Foo) {}
+            ",
+            &["&dyn Foo"],
+        );
+        assert_debug_snapshot!(actions,
+            @r###"
+            [
+                GoToType(
+                    [
+                        HoverGotoTypeData {
+                            mod_path: "Foo",
+                            nav: NavigationTarget {
+                                file_id: FileId(
+                                    1,
+                                ),
+                                full_range: 0..12,
+                                name: "Foo",
+                                kind: TRAIT_DEF,
+                                focus_range: Some(
+                                    6..9,
+                                ),
+                                container_name: None,
+                                description: Some(
+                                    "trait Foo",
+                                ),
+                                docs: None,
+                            },
+                        },
+                    ],
+                ),
+            ]
+            "###);
+    }
+    #[test]
+    fn test_hover_generic_dyn_arg_has_goto_type_action() {
+        let (_, actions) = check_hover_result(
+            "
+            //- /lib.rs
+            trait Foo<T> {}
+            struct S {}
+            fn foo(ar<|>g: &dyn Foo<S>) {}
+            ",
+            &["&dyn Foo<S>"],
+        );
+        assert_debug_snapshot!(actions,
+            @r###"
+            [
+                GoToType(
+                    [
+                        HoverGotoTypeData {
+                            mod_path: "Foo",
+                            nav: NavigationTarget {
+                                file_id: FileId(
+                                    1,
+                                ),
+                                full_range: 0..15,
+                                name: "Foo",
+                                kind: TRAIT_DEF,
+                                focus_range: Some(
+                                    6..9,
+                                ),
+                                container_name: None,
+                                description: Some(
+                                    "trait Foo",
+                                ),
+                                docs: None,
+                            },
+                        },
+                        HoverGotoTypeData {
+                            mod_path: "S",
+                            nav: NavigationTarget {
+                                file_id: FileId(
+                                    1,
+                                ),
+                                full_range: 16..27,
+                                name: "S",
+                                kind: STRUCT_DEF,
+                                focus_range: Some(
+                                    23..24,
+                                ),
+                                container_name: None,
+                                description: Some(
+                                    "struct S",
+                                ),
+                                docs: None,
+                            },
+                        },
+                    ],
+                ),
+            ]
+            "###);
+    }
+    #[test]
+    fn test_hover_goto_type_action_links_order() {
+        let (_, actions) = check_hover_result(
+            "
+            //- /lib.rs
+            trait ImplTrait<T> {}
+            trait DynTrait<T> {}
+            struct B<T> {}
+            struct S {}
+            fn foo(a<|>rg: &impl ImplTrait<B<dyn DynTrait<B<S>>>>) {}
+            ",
+            &["&impl ImplTrait<B<dyn DynTrait<B<S>>>>"],
+        );
+        assert_debug_snapshot!(actions,
+            @r###"
+            [
+                GoToType(
+                    [
+                        HoverGotoTypeData {
+                            mod_path: "ImplTrait",
+                            nav: NavigationTarget {
+                                file_id: FileId(
+                                    1,
+                                ),
+                                full_range: 0..21,
+                                name: "ImplTrait",
+                                kind: TRAIT_DEF,
+                                focus_range: Some(
+                                    6..15,
+                                ),
+                                container_name: None,
+                                description: Some(
+                                    "trait ImplTrait",
+                                ),
+                                docs: None,
+                            },
+                        },
+                        HoverGotoTypeData {
+                            mod_path: "B",
+                            nav: NavigationTarget {
+                                file_id: FileId(
+                                    1,
+                                ),
+                                full_range: 43..57,
+                                name: "B",
+                                kind: STRUCT_DEF,
+                                focus_range: Some(
+                                    50..51,
+                                ),
+                                container_name: None,
+                                description: Some(
+                                    "struct B",
+                                ),
+                                docs: None,
+                            },
+                        },
+                        HoverGotoTypeData {
+                            mod_path: "DynTrait",
+                            nav: NavigationTarget {
+                                file_id: FileId(
+                                    1,
+                                ),
+                                full_range: 22..42,
+                                name: "DynTrait",
+                                kind: TRAIT_DEF,
+                                focus_range: Some(
+                                    28..36,
+                                ),
+                                container_name: None,
+                                description: Some(
+                                    "trait DynTrait",
+                                ),
+                                docs: None,
+                            },
+                        },
+                        HoverGotoTypeData {
+                            mod_path: "S",
+                            nav: NavigationTarget {
+                                file_id: FileId(
+                                    1,
+                                ),
+                                full_range: 58..69,
+                                name: "S",
+                                kind: STRUCT_DEF,
+                                focus_range: Some(
+                                    65..66,
+                                ),
+                                container_name: None,
+                                description: Some(
+                                    "struct S",
+                                ),
+                                docs: None,
+                            },
+                        },
+                    ],
+                ),
+            ]
+            "###);
+    }
+    #[test]
+    fn test_hover_associated_type_has_goto_type_action() {
+        let (_, actions) = check_hover_result(
+            "
+            //- /main.rs
+            trait Foo {
+                type Item;
+                fn get(self) -> Self::Item {}
+            }
+            struct Bar{}
+            struct S{}
+            impl Foo for S{
+                type Item = Bar;
+            }
+            fn test() -> impl Foo {
+                S{}
+            }
+            fn main() {
+                let s<|>t = test().get();
+            }
+            ",
+            &["Foo::Item<impl Foo>"],
+        );
+        assert_debug_snapshot!(actions,
+            @r###"
+            [
+                GoToType(
+                    [
+                        HoverGotoTypeData {
+                            mod_path: "Foo",
+                            nav: NavigationTarget {
+                                file_id: FileId(
+                                    1,
+                                ),
+                                full_range: 0..62,
+                                name: "Foo",
+                                kind: TRAIT_DEF,
+                                focus_range: Some(
+                                    6..9,
+                                ),
+                                container_name: None,
+                                description: Some(
+                                    "trait Foo",
+                                ),
+                                docs: None,
+                            },
+                        },
+                    ],
+                ),
+            ]
+            "###);
+    }
 }
diff --git a/crates/ra_ide/src/lib.rs b/crates/ra_ide/src/lib.rs
index 28f686767..47823718f 100644
--- a/crates/ra_ide/src/lib.rs
+++ b/crates/ra_ide/src/lib.rs
@@ -66,11 +66,10 @@ pub use crate::{
    display::{file_structure, FunctionSignature, NavigationTarget, StructureNode},
    expand_macro::ExpandedMacro,
    folding_ranges::{Fold, FoldKind},
-    hover::{HoverAction, HoverConfig, HoverResult},
+    hover::{HoverAction, HoverConfig, HoverGotoTypeData, HoverResult},
    inlay_hints::{InlayHint, InlayHintsConfig, InlayKind},
    references::{Declaration, Reference, ReferenceAccess, ReferenceKind, ReferenceSearchResult},
    runnables::{Runnable, RunnableKind, TestId},
-    ssr::SsrError,
    syntax_highlighting::{
        Highlight, HighlightModifier, HighlightModifiers, HighlightTag, HighlightedRange,
    },
@@ -82,13 +81,14 @@ 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},
    symbol_index::Query,
    RootDatabase,
 };
+pub use ra_ssr::SsrError;
 pub use ra_text_edit::{Indel, TextEdit};
 pub type Cancelable<T> = Result<T, Canceled>;
@@ -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..99c2581b7 100644
--- a/crates/ra_ide/src/references/rename.rs
+++ b/crates/ra_ide/src/references/rename.rs
@@ -1,11 +1,14 @@
 //! FIXME: write short doc here
-use hir::{ModuleSource, Semantics};
+use hir::{Module, ModuleDef, ModuleSource, Semantics};
-use ra_db::{RelativePath, RelativePathBuf, SourceDatabaseExt};
+use ra_db::{RelativePathBuf, SourceDatabaseExt};
-use ra_ide_db::RootDatabase;
+use ra_ide_db::{
+    defs::{classify_name, classify_name_ref, Definition, NameClass, NameRefClass},
+    RootDatabase,
+};
 use ra_syntax::{
-    algo::find_node_at_offset, ast, ast::TypeAscriptionOwner, lex_single_valid_syntax_kind,
+    algo::find_node_at_offset, ast, ast::NameOwner, ast::TypeAscriptionOwner,
-    AstNode, SyntaxKind, SyntaxNode, SyntaxToken,
+    lex_single_valid_syntax_kind, match_ast, AstNode, SyntaxKind, SyntaxNode, SyntaxToken,
 };
 use ra_text_edit::TextEdit;
 use std::convert::TryInto;
@@ -30,10 +33,8 @@ pub(crate) fn rename(
    let sema = Semantics::new(db);
    let source_file = sema.parse(position.file_id);
    let syntax = source_file.syntax();
-    if let Some((ast_name, ast_module)) = find_name_and_module_at_offset(syntax, position) {
+    if let Some(module) = find_module_at_offset(&sema, position, syntax) {
-        let range = ast_name.syntax().text_range();
+        rename_mod(db, position, module, new_name)
-        rename_mod(&sema, &ast_name, &ast_module, position, new_name)
-            .map(|info| RangeInfo::new(range, info))
    } else if let Some(self_token) =
        syntax.token_at_offset(position.offset).find(|t| t.kind() == SyntaxKind::SELF_KW)
    {
@@ -43,13 +44,32 @@ pub(crate) fn rename(
    }
 }
-fn find_name_and_module_at_offset(
+fn find_module_at_offset(
-    syntax: &SyntaxNode,
+    sema: &Semantics<RootDatabase>,
    position: FilePosition,
-) -> Option<(ast::Name, ast::Module)> {
+    syntax: &SyntaxNode,
-    let ast_name = find_node_at_offset::<ast::Name>(syntax, position.offset)?;
+) -> Option<Module> {
-    let ast_module = ast::Module::cast(ast_name.syntax().parent()?)?;
+    let ident = syntax.token_at_offset(position.offset).find(|t| t.kind() == SyntaxKind::IDENT)?;
-    Some((ast_name, ast_module))
+    let module = match_ast! {
+        match (ident.parent()) {
+            ast::NameRef(name_ref) => {
+                match classify_name_ref(sema, &name_ref)? {
+                    NameRefClass::Definition(Definition::ModuleDef(ModuleDef::Module(module))) => module,
+                    _ => return None,
+                }
+            },
+            ast::Name(name) => {
+                match classify_name(&sema, &name)? {
+                    NameClass::Definition(Definition::ModuleDef(ModuleDef::Module(module))) => module,
+                    _ => return None,
+                }
+            },
+            _ => return None,
+        }
+    };
+    Some(module)
 }
 fn source_edit_from_reference(reference: Reference, new_name: &str) -> SourceFileEdit {
@@ -77,58 +97,50 @@ fn source_edit_from_reference(reference: Reference, new_name: &str) -> SourceFil
 }
 fn rename_mod(
-    sema: &Semantics<RootDatabase>,
+    db: &RootDatabase,
-    ast_name: &ast::Name,
-    ast_module: &ast::Module,
    position: FilePosition,
+    module: Module,
    new_name: &str,
-) -> Option<SourceChange> {
+) -> Option<RangeInfo<SourceChange>> {
    let mut source_file_edits = Vec::new();
    let mut file_system_edits = Vec::new();
-    if let Some(module) = sema.to_def(ast_module) {
-        let src = module.definition_source(sema.db);
+    let src = module.definition_source(db);
-        let file_id = src.file_id.original_file(sema.db);
+    let file_id = src.file_id.original_file(db);
-        match src.value {
+    match src.value {
-            ModuleSource::SourceFile(..) => {
+        ModuleSource::SourceFile(..) => {
-                let mod_path: RelativePathBuf = sema.db.file_relative_path(file_id);
+            let mod_path: RelativePathBuf = db.file_relative_path(file_id);
-                // mod is defined in path/to/dir/mod.rs
+            // mod is defined in path/to/dir/mod.rs
-                let dst_path = if mod_path.file_stem() == Some("mod") {
+            let dst = if mod_path.file_stem() == Some("mod") {
-                    mod_path
+                format!("../{}/mod.rs", new_name)
-                        .parent()
+            } else {
-                        .and_then(|p| p.parent())
+                format!("{}.rs", new_name)
-                        .or_else(|| Some(RelativePath::new("")))
+            };
-                        .map(|p| p.join(new_name).join("mod.rs"))
+            let move_file =
-                } else {
+                FileSystemEdit::MoveFile { src: file_id, anchor: position.file_id, dst };
-                    Some(mod_path.with_file_name(new_name).with_extension("rs"))
+            file_system_edits.push(move_file);
-                };
-                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);
-                }
-            }
-            ModuleSource::Module(..) => {}
        }
+        ModuleSource::Module(..) => {}
    }
-    let edit = SourceFileEdit {
+    if let Some(src) = module.declaration_source(db) {
-        file_id: position.file_id,
+        let file_id = src.file_id.original_file(db);
-        edit: TextEdit::replace(ast_name.syntax().text_range(), new_name.into()),
+        let name = src.value.name()?;
-    };
+        let edit = SourceFileEdit {
-    source_file_edits.push(edit);
+            file_id: file_id,
+            edit: TextEdit::replace(name.syntax().text_range(), new_name.into()),
-    if let Some(RangeInfo { range: _, info: refs }) = find_all_refs(sema.db, position, None) {
+        };
-        let ref_edits = refs
+        source_file_edits.push(edit);
-            .references
-            .into_iter()
-            .map(|reference| source_edit_from_reference(reference, new_name));
-        source_file_edits.extend(ref_edits);
    }
-    Some(SourceChange::from_edits(source_file_edits, file_system_edits))
+    let RangeInfo { range, info: refs } = find_all_refs(db, position, None)?;
+    let ref_edits = refs
+        .references
+        .into_iter()
+        .map(|reference| source_edit_from_reference(reference, new_name));
+    source_file_edits.extend(ref_edits);
+    Some(RangeInfo::new(range, SourceChange::from_edits(source_file_edits, file_system_edits)))
 }
 fn rename_to_self(db: &RootDatabase, position: FilePosition) -> Option<RangeInfo<SourceChange>> {
@@ -623,16 +635,16 @@ mod tests {
    #[test]
    fn test_rename_mod() {
        let (analysis, position) = analysis_and_position(
-            "
+            r#"
-            //- /lib.rs
+//- /lib.rs
-            mod bar;
+mod bar;
-            //- /bar.rs
+//- /bar.rs
-            mod foo<|>;
+mod foo<|>;
-            //- /bar/foo.rs
+//- /bar/foo.rs
-            // emtpy
+// emtpy
-            ",
+            "#,
        );
        let new_name = "foo2";
        let source_change = analysis.rename(position, new_name).unwrap();
@@ -662,10 +674,80 @@ mod tests {
                            src: FileId(
                                3,
                            ),
-                            dst_source_root: SourceRootId(
+                            anchor: FileId(
-                                0,
+                                2,
                            ),
-                            dst_path: "bar/foo2.rs",
+                            dst: "foo2.rs",
+                        },
+                    ],
+                    is_snippet: false,
+                },
+            },
+        )
+        "###);
+    }
+    #[test]
+    fn test_rename_mod_in_use_tree() {
+        let (analysis, position) = analysis_and_position(
+            r#"
+//- /main.rs
+pub mod foo;
+pub mod bar;
+fn main() {}
+//- /foo.rs
+pub struct FooContent;
+//- /bar.rs
+use crate::foo<|>::FooContent;
+            "#,
+        );
+        let new_name = "qux";
+        let source_change = analysis.rename(position, new_name).unwrap();
+        assert_debug_snapshot!(&source_change,
+@r###"
+        Some(
+            RangeInfo {
+                range: 11..14,
+                info: SourceChange {
+                    source_file_edits: [
+                        SourceFileEdit {
+                            file_id: FileId(
+                                1,
+                            ),
+                            edit: TextEdit {
+                                indels: [
+                                    Indel {
+                                        insert: "qux",
+                                        delete: 8..11,
+                                    },
+                                ],
+                            },
+                        },
+                        SourceFileEdit {
+                            file_id: FileId(
+                                3,
+                            ),
+                            edit: TextEdit {
+                                indels: [
+                                    Indel {
+                                        insert: "qux",
+                                        delete: 11..14,
+                                    },
+                                ],
+                            },
+                        },
+                    ],
+                    file_system_edits: [
+                        MoveFile {
+                            src: FileId(
+                                2,
+                            ),
+                            anchor: FileId(
+                                3,
+                            ),
+                            dst: "qux.rs",
                        },
                    ],
                    is_snippet: false,
@@ -678,12 +760,12 @@ mod tests {
    #[test]
    fn test_rename_mod_in_dir() {
        let (analysis, position) = analysis_and_position(
-            "
+            r#"
-            //- /lib.rs
+//- /lib.rs
-            mod fo<|>o;
+mod fo<|>o;
-            //- /foo/mod.rs
+//- /foo/mod.rs
-            // emtpy
+// emtpy
-            ",
+            "#,
        );
        let new_name = "foo2";
        let source_change = analysis.rename(position, new_name).unwrap();
@@ -713,10 +795,10 @@ mod tests {
                            src: FileId(
                                2,
                            ),
-                            dst_source_root: SourceRootId(
+                            anchor: FileId(
-                                0,
+                                1,
                            ),
-                            dst_path: "foo2/mod.rs",
+                            dst: "../foo2/mod.rs",
                        },
                    ],
                    is_snippet: false,
@@ -753,19 +835,19 @@ mod tests {
    #[test]
    fn test_rename_mod_filename_and_path() {
        let (analysis, position) = analysis_and_position(
-            "
+            r#"
-            //- /lib.rs
+//- /lib.rs
-            mod bar;
+mod bar;
-            fn f() {
+fn f() {
-                bar::foo::fun()
+    bar::foo::fun()
-            }
+}
-            //- /bar.rs
+//- /bar.rs
-            pub mod foo<|>;
+pub mod foo<|>;
-            //- /bar/foo.rs
+//- /bar/foo.rs
-            // pub fn fun() {}
+// pub fn fun() {}
-            ",
+            "#,
        );
        let new_name = "foo2";
        let source_change = analysis.rename(position, new_name).unwrap();
@@ -808,10 +890,10 @@ mod tests {
                            src: FileId(
                                3,
                            ),
-                            dst_source_root: SourceRootId(
+                            anchor: FileId(
-                                0,
+                                2,
                            ),
-                            dst_path: "bar/foo2.rs",
+                            dst: "foo2.rs",
                        },
                    ],
                    is_snippet: false,
diff --git a/crates/ra_ide/src/runnables.rs b/crates/ra_ide/src/runnables.rs
index fc57dc33d..8105ef373 100644
--- a/crates/ra_ide/src/runnables.rs
+++ b/crates/ra_ide/src/runnables.rs
@@ -171,7 +171,15 @@ fn runnable_fn(
    let cfg_exprs =
        attrs.by_key("cfg").tt_values().map(|subtree| ra_cfg::parse_cfg(subtree)).collect();
-    let nav = NavigationTarget::from_named(sema.db, InFile::new(file_id.into(), &fn_def));
+    let nav = if let RunnableKind::DocTest { .. } = kind {
+        NavigationTarget::from_doc_commented(
+            sema.db,
+            InFile::new(file_id.into(), &fn_def),
+            InFile::new(file_id.into(), &fn_def),
+        )
+    } else {
+        NavigationTarget::from_named(sema.db, InFile::new(file_id.into(), &fn_def))
+    };
    Some(Runnable { nav, kind, cfg_exprs })
 }
@@ -419,9 +427,7 @@ mod tests {
                    full_range: 22..64,
                    name: "foo",
                    kind: FN_DEF,
-                    focus_range: Some(
+                    focus_range: None,
-                        56..59,
-                    ),
                    container_name: None,
                    description: None,
                    docs: None,
@@ -486,9 +492,7 @@ mod tests {
                    full_range: 51..105,
                    name: "foo",
                    kind: FN_DEF,
-                    focus_range: Some(
+                    focus_range: None,
-                        97..100,
-                    ),
                    container_name: None,
                    description: None,
                    docs: None,
diff --git a/crates/ra_ide/src/snapshots/highlight_doctest.html b/crates/ra_ide/src/snapshots/highlight_doctest.html
index 0ae8c7efc..63199cdbe 100644
--- a/crates/ra_ide/src/snapshots/highlight_doctest.html
+++ b/crates/ra_ide/src/snapshots/highlight_doctest.html
@@ -25,47 +25,72 @@ 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="comment">/// Constructs a new `Foo`.</span>
+    <span class="field declaration">bar</span>: <span class="builtin_type">bool</span>,
-    <span class="comment">///</span>
+}
-    <span class="comment">/// # Examples</span>
-    <span class="comment">///</span>
+<span class="keyword">impl</span> <span class="struct">Foo</span> {
-    <span class="comment">/// ```</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">/// #</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 documentation">/// Constructs a new `Foo`.</span>
-    <span class="comment">/// ```</span>
+    <span class="comment documentation">///</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="comment documentation">/// # Examples</span>
-        <span class="unresolved_reference">Foo</span> { }
+    <span class="comment documentation">///</span>
+    <span class="comment documentation">/// ```</span>
+    <span class="comment documentation">/// #</span> <span class="attribute">#![</span><span class="function attribute">allow</span><span class="attribute">(unused_mut)]</span>
+    <span class="comment documentation">/// </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 documentation">/// ```</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>
+    <span class="comment documentation">/// `bar` method on `Foo`.</span>
-    <span class="comment">///</span>
+    <span class="comment documentation">///</span>
-    <span class="comment">/// # Examples</span>
+    <span class="comment documentation">/// # Examples</span>
-    <span class="comment">///</span>
+    <span class="comment documentation">///</span>
-    <span class="comment">/// ```</span>
+    <span class="comment documentation">/// ```</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 documentation">/// </span><span class="keyword">use</span> <span class="module">x</span>::<span class="module">y</span>;
-    <span class="comment">///</span>
+    <span class="comment documentation">///</span>
-    <span class="comment">/// </span><span class="comment">// calls bar on foo</span>
+    <span class="comment documentation">/// </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="macro">assert!</span>(foo.bar());
+    <span class="comment documentation">///</span>
-    <span class="comment">///</span>
+    <span class="comment documentation">/// </span><span class="comment">// calls bar on foo</span>
-    <span class="comment">/// </span><span class="comment">/* multi-line
+    <span class="comment documentation">/// </span><span class="macro">assert!</span>(foo.bar());
-    </span><span class="comment">/// </span><span class="comment">       comment */</span>
+    <span class="comment documentation">///</span>
-    <span class="comment">///</span>
+    <span class="comment documentation">/// </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="keyword">let</span> <span class="variable declaration">multi_line_string</span> = <span class="string_literal">"Foo
+    <span class="comment documentation">///</span>
-    </span><span class="comment">/// </span><span class="string_literal">  bar
+    <span class="comment documentation">/// </span><span class="comment">/* multi-line
-    </span><span class="comment">/// </span><span class="string_literal">         "</span>;
+    </span><span class="comment documentation">/// </span><span class="comment">       comment */</span>
-    <span class="comment">///</span>
+    <span class="comment documentation">///</span>
-    <span class="comment">/// ```</span>
+    <span class="comment documentation">/// </span><span class="keyword">let</span> <span class="variable declaration">multi_line_string</span> = <span class="string_literal">"Foo
-    <span class="comment">///</span>
+    </span><span class="comment documentation">/// </span><span class="string_literal">  bar
-    <span class="comment">/// ```</span>
+    </span><span class="comment documentation">/// </span><span class="string_literal">         "</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 documentation">///</span>
-    <span class="comment">/// ```</span>
+    <span class="comment documentation">/// ```</span>
+    <span class="comment documentation">///</span>
+    <span class="comment documentation">/// ```rust,no_run</span>
+    <span class="comment documentation">/// </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 documentation">/// ```</span>
+    <span class="comment documentation">///</span>
+    <span class="comment documentation">/// ```sh</span>
+    <span class="comment documentation">/// echo 1</span>
+    <span class="comment documentation">/// ```</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>
    }
+}
+<span class="comment documentation">/// ```</span>
+<span class="comment documentation">/// </span><span class="macro">noop!</span>(<span class="numeric_literal">1</span>);
+<span class="comment documentation">/// ```</span>
+<span class="macro">macro_rules!</span> <span class="macro declaration">noop</span> {
+    ($expr:expr) =&gt; {
+        $expr
+    }
 }</code></pre>
 \ No newline at end of file
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 5c2ff6ab5..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; }
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..59c230f6c 100644
--- a/crates/ra_ide/src/ssr.rs
+++ b/crates/ra_ide/src/ssr.rs
@@ -1,37 +1,18 @@
-use std::{collections::HashMap, iter::once, str::FromStr};
+use ra_db::SourceDatabaseExt;
-use ra_db::{SourceDatabase, SourceDatabaseExt};
 use ra_ide_db::{symbol_index::SymbolsDatabase, RootDatabase};
-use ra_syntax::ast::{
-    make::try_expr_from_text, ArgList, AstToken, CallExpr, Comment, Expr, MethodCallExpr,
-    RecordField, RecordLit,
-};
-use ra_syntax::{AstNode, SyntaxElement, SyntaxKind, SyntaxNode};
-use ra_text_edit::{TextEdit, TextEditBuilder};
-use rustc_hash::FxHashMap;
 use crate::SourceFileEdit;
+use ra_ssr::{MatchFinder, SsrError, SsrRule};
-#[derive(Debug, PartialEq)]
-pub struct SsrError(String);
-impl std::fmt::Display for SsrError {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        write!(f, "Parse error: {}", self.0)
-    }
-}
-impl std::error::Error for SsrError {}
 // Feature: Structural Seach and Replace
 //
-// Search and replace with named wildcards that will match any expression.
+// Search and replace with named wildcards that will match any expression, type, path, pattern or item.
 // The syntax for a structural search replace command is `<search_pattern> ==>> <replace_pattern>`.
-// A `$<name>: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))
@@ -46,584 +27,24 @@ impl std::error::Error for SsrError {}
 // | VS Code | **Rust Analyzer: Structural Search Replace**
 // |===
 pub fn parse_search_replace(
-    query: &str,
+    rule: &str,
    parse_only: bool,
    db: &RootDatabase,
 ) -> Result<Vec<SourceFileEdit>, SsrError> {
    let mut edits = vec![];
-    let query: SsrQuery = query.parse()?;
+    let rule: SsrRule = rule.parse()?;
    if parse_only {
        return Ok(edits);
    }
+    let mut match_finder = MatchFinder::new(db);
+    match_finder.add_rule(rule);
    for &root in db.local_roots().iter() {
        let sr = db.source_root(root);
        for file_id in sr.walk() {
-            let matches = find(&query.pattern, db.parse(file_id).tree().syntax());
+            if let Some(edit) = match_finder.edits_for_file(file_id) {
-            if !matches.matches.is_empty() {
+                edits.push(SourceFileEdit { file_id, edit });
-                edits.push(SourceFileEdit { file_id, edit: replace(&matches, &query.template) });
            }
        }
    }
    Ok(edits)
 }
-#[derive(Debug)]
-struct SsrQuery {
-    pattern: SsrPattern,
-    template: SsrTemplate,
-}
-#[derive(Debug)]
-struct SsrPattern {
-    pattern: SyntaxNode,
-    vars: Vec<Var>,
-}
-/// represents an `$var` in an SSR query
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-struct Var(String);
-#[derive(Debug)]
-struct SsrTemplate {
-    template: SyntaxNode,
-    placeholders: FxHashMap<SyntaxNode, Var>,
-}
-type Binding = HashMap<Var, SyntaxNode>;
-#[derive(Debug)]
-struct Match {
-    place: SyntaxNode,
-    binding: Binding,
-    ignored_comments: Vec<Comment>,
-}
-#[derive(Debug)]
-struct SsrMatches {
-    matches: Vec<Match>,
-}
-impl FromStr for SsrQuery {
-    type Err = SsrError;
-    fn from_str(query: &str) -> Result<SsrQuery, SsrError> {
-        let mut it = query.split("==>>");
-        let pattern = it.next().expect("at least empty string").trim();
-        let mut template = it
-            .next()
-            .ok_or_else(|| SsrError("Cannot find delemiter `==>>`".into()))?
-            .trim()
-            .to_string();
-        if it.next().is_some() {
-            return Err(SsrError("More than one delimiter found".into()));
-        }
-        let mut vars = vec![];
-        let mut it = pattern.split('$');
-        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 new_var = create_name(var, &mut vars)?;
-            pattern.push_str(new_var);
-            pattern.push_str(remainder);
-            template = replace_in_template(template, var, new_var);
-        }
-        let template = try_expr_from_text(&template)
-            .ok_or(SsrError("Template is not an expression".into()))?
-            .syntax()
-            .clone();
-        let mut placeholders = FxHashMap::default();
-        traverse(&template, &mut |n| {
-            if let Some(v) = vars.iter().find(|v| v.0.as_str() == n.text()) {
-                placeholders.insert(n.clone(), v.clone());
-                false
-            } else {
-                true
-            }
-        });
-        let pattern = SsrPattern {
-            pattern: try_expr_from_text(&pattern)
-                .ok_or(SsrError("Pattern is not an expression".into()))?
-                .syntax()
-                .clone(),
-            vars,
-        };
-        let template = SsrTemplate { template, placeholders };
-        Ok(SsrQuery { pattern, template })
-    }
-}
-fn traverse(node: &SyntaxNode, go: &mut impl FnMut(&SyntaxNode) -> bool) {
-    if !go(node) {
-        return;
-    }
-    for ref child in node.children() {
-        traverse(child, go);
-    }
-}
-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];
-    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..]))
-}
-fn is_name(s: &str) -> Result<(), SsrError> {
-    if s.chars().all(|c| c.is_ascii_alphanumeric() || c == '_') {
-        Ok(())
-    } else {
-        Err(SsrError("Name can contain only alphanumerics and _".into()))
-    }
-}
-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)
-}
-fn create_name<'a>(name: &str, vars: &'a mut Vec<Var>) -> Result<&'a str, SsrError> {
-    let sanitized_name = format!("__search_pattern_{}", name);
-    if vars.iter().any(|a| a.0 == sanitized_name) {
-        return Err(SsrError(format!("Name `{}` repeats more than once", name)));
-    }
-    vars.push(Var(sanitized_name));
-    Ok(&vars.last().unwrap().0)
-}
-fn find(pattern: &SsrPattern, code: &SyntaxNode) -> SsrMatches {
-    fn check_record_lit(
-        pattern: RecordLit,
-        code: RecordLit,
-        placeholders: &[Var],
-        match_: Match,
-    ) -> Option<Match> {
-        let match_ = check_opt_nodes(pattern.path(), code.path(), placeholders, match_)?;
-        let mut pattern_fields: Vec<RecordField> =
-            pattern.record_field_list().map(|x| x.fields().collect()).unwrap_or_default();
-        let mut code_fields: Vec<RecordField> =
-            code.record_field_list().map(|x| x.fields().collect()).unwrap_or_default();
-        if pattern_fields.len() != code_fields.len() {
-            return None;
-        }
-        let by_name = |a: &RecordField, b: &RecordField| {
-            a.name_ref()
-                .map(|x| x.syntax().text().to_string())
-                .cmp(&b.name_ref().map(|x| x.syntax().text().to_string()))
-        };
-        pattern_fields.sort_by(by_name);
-        code_fields.sort_by(by_name);
-        pattern_fields.into_iter().zip(code_fields.into_iter()).fold(
-            Some(match_),
-            |accum, (a, b)| {
-                accum.and_then(|match_| check_opt_nodes(Some(a), Some(b), placeholders, match_))
-            },
-        )
-    }
-    fn check_call_and_method_call(
-        pattern: CallExpr,
-        code: MethodCallExpr,
-        placeholders: &[Var],
-        match_: Match,
-    ) -> Option<Match> {
-        let (pattern_name, pattern_type_args) = if let Some(Expr::PathExpr(path_exr)) =
-            pattern.expr()
-        {
-            let segment = path_exr.path().and_then(|p| p.segment());
-            (segment.as_ref().and_then(|s| s.name_ref()), segment.and_then(|s| s.type_arg_list()))
-        } else {
-            (None, None)
-        };
-        let match_ = check_opt_nodes(pattern_name, code.name_ref(), placeholders, match_)?;
-        let match_ =
-            check_opt_nodes(pattern_type_args, code.type_arg_list(), placeholders, match_)?;
-        let pattern_args = pattern.syntax().children().find_map(ArgList::cast)?.args();
-        let code_args = code.syntax().children().find_map(ArgList::cast)?.args();
-        let code_args = once(code.expr()?).chain(code_args);
-        check_iter(pattern_args, code_args, placeholders, match_)
-    }
-    fn check_method_call_and_call(
-        pattern: MethodCallExpr,
-        code: CallExpr,
-        placeholders: &[Var],
-        match_: Match,
-    ) -> Option<Match> {
-        let (code_name, code_type_args) = if let Some(Expr::PathExpr(path_exr)) = code.expr() {
-            let segment = path_exr.path().and_then(|p| p.segment());
-            (segment.as_ref().and_then(|s| s.name_ref()), segment.and_then(|s| s.type_arg_list()))
-        } else {
-            (None, None)
-        };
-        let match_ = check_opt_nodes(pattern.name_ref(), code_name, placeholders, match_)?;
-        let match_ =
-            check_opt_nodes(pattern.type_arg_list(), code_type_args, placeholders, match_)?;
-        let code_args = code.syntax().children().find_map(ArgList::cast)?.args();
-        let pattern_args = pattern.syntax().children().find_map(ArgList::cast)?.args();
-        let pattern_args = once(pattern.expr()?).chain(pattern_args);
-        check_iter(pattern_args, code_args, placeholders, match_)
-    }
-    fn check_opt_nodes(
-        pattern: Option<impl AstNode>,
-        code: Option<impl AstNode>,
-        placeholders: &[Var],
-        match_: Match,
-    ) -> Option<Match> {
-        match (pattern, code) {
-            (Some(pattern), Some(code)) => check(
-                &pattern.syntax().clone().into(),
-                &code.syntax().clone().into(),
-                placeholders,
-                match_,
-            ),
-            (None, None) => Some(match_),
-            _ => None,
-        }
-    }
-    fn check_iter<T, I1, I2>(
-        mut pattern: I1,
-        mut code: I2,
-        placeholders: &[Var],
-        match_: Match,
-    ) -> Option<Match>
-    where
-        T: AstNode,
-        I1: Iterator<Item = T>,
-        I2: Iterator<Item = T>,
-    {
-        pattern
-            .by_ref()
-            .zip(code.by_ref())
-            .fold(Some(match_), |accum, (a, b)| {
-                accum.and_then(|match_| {
-                    check(
-                        &a.syntax().clone().into(),
-                        &b.syntax().clone().into(),
-                        placeholders,
-                        match_,
-                    )
-                })
-            })
-            .filter(|_| pattern.next().is_none() && code.next().is_none())
-    }
-    fn check(
-        pattern: &SyntaxElement,
-        code: &SyntaxElement,
-        placeholders: &[Var],
-        mut match_: Match,
-    ) -> Option<Match> {
-        match (&pattern, &code) {
-            (SyntaxElement::Token(pattern), SyntaxElement::Token(code)) => {
-                if pattern.text() == code.text() {
-                    Some(match_)
-                } else {
-                    None
-                }
-            }
-            (SyntaxElement::Node(pattern), SyntaxElement::Node(code)) => {
-                if placeholders.iter().any(|n| n.0.as_str() == pattern.text()) {
-                    match_.binding.insert(Var(pattern.text().to_string()), code.clone());
-                    Some(match_)
-                } else {
-                    if let (Some(pattern), Some(code)) =
-                        (RecordLit::cast(pattern.clone()), RecordLit::cast(code.clone()))
-                    {
-                        check_record_lit(pattern, code, placeholders, match_)
-                    } else if let (Some(pattern), Some(code)) =
-                        (CallExpr::cast(pattern.clone()), MethodCallExpr::cast(code.clone()))
-                    {
-                        check_call_and_method_call(pattern, code, placeholders, match_)
-                    } else if let (Some(pattern), Some(code)) =
-                        (MethodCallExpr::cast(pattern.clone()), CallExpr::cast(code.clone()))
-                    {
-                        check_method_call_and_call(pattern, code, placeholders, match_)
-                    } else {
-                        let mut pattern_children = pattern
-                            .children_with_tokens()
-                            .filter(|element| !element.kind().is_trivia());
-                        let mut code_children = code
-                            .children_with_tokens()
-                            .filter(|element| !element.kind().is_trivia());
-                        let new_ignored_comments =
-                            code.children_with_tokens().filter_map(|element| {
-                                element.as_token().and_then(|token| Comment::cast(token.clone()))
-                            });
-                        match_.ignored_comments.extend(new_ignored_comments);
-                        pattern_children
-                            .by_ref()
-                            .zip(code_children.by_ref())
-                            .fold(Some(match_), |accum, (a, b)| {
-                                accum.and_then(|match_| check(&a, &b, placeholders, match_))
-                            })
-                            .filter(|_| {
-                                pattern_children.next().is_none() && code_children.next().is_none()
-                            })
-                    }
-                }
-            }
-            _ => None,
-        }
-    }
-    let kind = pattern.pattern.kind();
-    let matches = code
-        .descendants()
-        .filter(|n| {
-            n.kind() == kind
-                || (kind == SyntaxKind::CALL_EXPR && n.kind() == SyntaxKind::METHOD_CALL_EXPR)
-                || (kind == SyntaxKind::METHOD_CALL_EXPR && n.kind() == SyntaxKind::CALL_EXPR)
-        })
-        .filter_map(|code| {
-            let match_ =
-                Match { place: code.clone(), binding: HashMap::new(), ignored_comments: vec![] };
-            check(&pattern.pattern.clone().into(), &code.into(), &pattern.vars, match_)
-        })
-        .collect();
-    SsrMatches { matches }
-}
-fn replace(matches: &SsrMatches, template: &SsrTemplate) -> TextEdit {
-    let mut builder = TextEditBuilder::default();
-    for match_ in &matches.matches {
-        builder.replace(
-            match_.place.text_range(),
-            render_replace(&match_.binding, &match_.ignored_comments, template),
-        );
-    }
-    builder.finish()
-}
-fn render_replace(
-    binding: &Binding,
-    ignored_comments: &Vec<Comment>,
-    template: &SsrTemplate,
-) -> String {
-    let edit = {
-        let mut builder = TextEditBuilder::default();
-        for element in template.template.descendants() {
-            if let Some(var) = template.placeholders.get(&element) {
-                builder.replace(element.text_range(), binding[var].to_string())
-            }
-        }
-        for comment in ignored_comments {
-            builder.insert(template.template.text_range().end(), comment.syntax().to_string())
-        }
-        builder.finish()
-    };
-    let mut text = template.template.text().to_string();
-    edit.apply(&mut text);
-    text
-}
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use ra_syntax::SourceFile;
-    fn parse_error_text(query: &str) -> String {
-        format!("{}", query.parse::<SsrQuery>().unwrap_err())
-    }
-    #[test]
-    fn parser_happy_case() {
-        let result: SsrQuery = "foo($a:expr, $b:expr) ==>> 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");
-        assert_eq!(result.pattern.vars[1].0, "__search_pattern_b");
-        assert_eq!(&result.template.template.text(), "bar(__search_pattern_b, __search_pattern_a)");
-    }
-    #[test]
-    fn parser_empty_query() {
-        assert_eq!(parse_error_text(""), "Parse error: Cannot find delemiter `==>>`");
-    }
-    #[test]
-    fn parser_no_delimiter() {
-        assert_eq!(parse_error_text("foo()"), "Parse error: Cannot find delemiter `==>>`");
-    }
-    #[test]
-    fn parser_two_delimiters() {
-        assert_eq!(
-            parse_error_text("foo() ==>> a ==>> b "),
-            "Parse error: More than one delimiter found"
-        );
-    }
-    #[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: Name `a` repeats more than once"
-        );
-    }
-    #[test]
-    fn parser_invlid_pattern() {
-        assert_eq!(parse_error_text(" ==>> ()"), "Parse error: Pattern is not an expression");
-    }
-    #[test]
-    fn parser_invlid_template() {
-        assert_eq!(parse_error_text("() ==>> )"), "Parse error: Template is not an expression");
-    }
-    #[test]
-    fn parse_match_replace() {
-        let query: SsrQuery = "foo($x:expr) ==>> bar($x)".parse().unwrap();
-        let input = "fn main() { foo(1+2); }";
-        let code = SourceFile::parse(input).tree();
-        let matches = find(&query.pattern, code.syntax());
-        assert_eq!(matches.matches.len(), 1);
-        assert_eq!(matches.matches[0].place.text(), "foo(1+2)");
-        assert_eq!(matches.matches[0].binding.len(), 1);
-        assert_eq!(
-            matches.matches[0].binding[&Var("__search_pattern_x".to_string())].text(),
-            "1+2"
-        );
-        let edit = replace(&matches, &query.template);
-        let mut after = input.to_string();
-        edit.apply(&mut after);
-        assert_eq!(after, "fn main() { bar(1+2); }");
-    }
-    fn assert_ssr_transform(query: &str, input: &str, result: &str) {
-        let query: SsrQuery = query.parse().unwrap();
-        let code = SourceFile::parse(input).tree();
-        let matches = find(&query.pattern, code.syntax());
-        let edit = replace(&matches, &query.template);
-        let mut after = input.to_string();
-        edit.apply(&mut after);
-        assert_eq!(after, result);
-    }
-    #[test]
-    fn ssr_function_to_method() {
-        assert_ssr_transform(
-            "my_function($a:expr, $b:expr) ==>> ($a).my_method($b)",
-            "loop { my_function( other_func(x, y), z + w) }",
-            "loop { (other_func(x, y)).my_method(z + w) }",
-        )
-    }
-    #[test]
-    fn ssr_nested_function() {
-        assert_ssr_transform(
-            "foo($a:expr, $b:expr, $c:expr) ==>> bar($c, baz($a, $b))",
-            "fn main { foo  (x + value.method(b), x+y-z, true && false) }",
-            "fn main { bar(true && false, baz(x + value.method(b), x+y-z)) }",
-        )
-    }
-    #[test]
-    fn ssr_expected_spacing() {
-        assert_ssr_transform(
-            "foo($x:expr) + bar() ==>> bar($x)",
-            "fn main() { foo(5) + bar() }",
-            "fn main() { bar(5) }",
-        );
-    }
-    #[test]
-    fn ssr_with_extra_space() {
-        assert_ssr_transform(
-            "foo($x:expr  ) +    bar() ==>> bar($x)",
-            "fn main() { foo(  5 )  +bar(   ) }",
-            "fn main() { bar(5) }",
-        );
-    }
-    #[test]
-    fn ssr_keeps_nested_comment() {
-        assert_ssr_transform(
-            "foo($x:expr) ==>> bar($x)",
-            "fn main() { foo(other(5 /* using 5 */)) }",
-            "fn main() { bar(other(5 /* using 5 */)) }",
-        )
-    }
-    #[test]
-    fn ssr_keeps_comment() {
-        assert_ssr_transform(
-            "foo($x:expr) ==>> bar($x)",
-            "fn main() { foo(5 /* using 5 */) }",
-            "fn main() { bar(5)/* using 5 */ }",
-        )
-    }
-    #[test]
-    fn ssr_struct_lit() {
-        assert_ssr_transform(
-            "foo{a: $a:expr, b: $b:expr} ==>> foo::new($a, $b)",
-            "fn main() { foo{b:2, a:1} }",
-            "fn main() { foo::new(1, 2) }",
-        )
-    }
-    #[test]
-    fn ssr_call_and_method_call() {
-        assert_ssr_transform(
-            "foo::<'a>($a:expr, $b:expr)) ==>> foo2($a, $b)",
-            "fn main() { get().bar.foo::<'a>(1); }",
-            "fn main() { foo2(get().bar, 1); }",
-        )
-    }
-    #[test]
-    fn ssr_method_call_and_call() {
-        assert_ssr_transform(
-            "$o:expr.foo::<i32>($a:expr)) ==>> $o.foo2($a)",
-            "fn main() { X::foo::<i32>(x, 1); }",
-            "fn main() { x.foo2(1); }",
-        )
-    }
-}
diff --git a/crates/ra_ide/src/status.rs b/crates/ra_ide/src/status.rs
index 5b7992920..45411b357 100644
--- a/crates/ra_ide/src/status.rs
+++ b/crates/ra_ide/src/status.rs
@@ -16,6 +16,7 @@ use ra_prof::{memory_usage, Bytes};
 use ra_syntax::{ast, Parse, SyntaxNode};
 use crate::FileId;
+use rustc_hash::FxHashMap;
 fn syntax_tree_stats(db: &RootDatabase) -> SyntaxTreeStats {
    db.query(ra_db::ParseQuery).entries::<SyntaxTreeStats>()
@@ -123,20 +124,24 @@ struct LibrarySymbolsStats {
 impl fmt::Display for LibrarySymbolsStats {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        write!(fmt, "{} ({}) symbols", self.total, self.size,)
+        write!(fmt, "{} ({}) symbols", self.total, self.size)
    }
 }
-impl FromIterator<TableEntry<SourceRootId, Arc<SymbolIndex>>> for LibrarySymbolsStats {
+impl FromIterator<TableEntry<(), Arc<FxHashMap<SourceRootId, SymbolIndex>>>>
+    for LibrarySymbolsStats
+{
    fn from_iter<T>(iter: T) -> LibrarySymbolsStats
    where
-        T: IntoIterator<Item = TableEntry<SourceRootId, Arc<SymbolIndex>>>,
+        T: IntoIterator<Item = TableEntry<(), Arc<FxHashMap<SourceRootId, SymbolIndex>>>>,
    {
        let mut res = LibrarySymbolsStats::default();
        for entry in iter {
            let value = entry.value.unwrap();
-            res.total += value.len();
+            for symbols in value.values() {
-            res.size += value.memory_size();
+                res.total += symbols.len();
+                res.size += symbols.memory_size();
+            }
        }
        res
    }
diff --git a/crates/ra_ide/src/syntax_highlighting.rs b/crates/ra_ide/src/syntax_highlighting.rs
index bbcd52a1c..448645bdc 100644
--- a/crates/ra_ide/src/syntax_highlighting.rs
+++ b/crates/ra_ide/src/syntax_highlighting.rs
@@ -44,6 +44,7 @@ pub(crate) fn highlight(
    db: &RootDatabase,
    file_id: FileId,
    range_to_highlight: Option<TextRange>,
+    syntactic_name_ref_highlighting: bool,
 ) -> Vec<HighlightedRange> {
    let _p = profile("highlight");
    let sema = Semantics::new(db);
@@ -104,6 +105,7 @@ pub(crate) fn highlight(
                    if let Some((highlight, binding_hash)) = highlight_element(
                        &sema,
                        &mut bindings_shadow_count,
+                        syntactic_name_ref_highlighting,
                        name.syntax().clone().into(),
                    ) {
                        stack.add(HighlightedRange {
@@ -119,7 +121,6 @@ pub(crate) fn highlight(
                assert!(current_macro_call == Some(mc));
                current_macro_call = None;
                format_string = None;
-                continue;
            }
            _ => (),
        }
@@ -148,7 +149,7 @@ pub(crate) fn highlight(
        let range = element.text_range();
-        let element_to_highlight = if current_macro_call.is_some() {
+        let element_to_highlight = if current_macro_call.is_some() && element.kind() != COMMENT {
            // Inside a macro -- expand it first
            let token = match element.clone().into_token() {
                Some(it) if it.parent().kind() == TOKEN_TREE => it,
@@ -200,15 +201,18 @@ pub(crate) fn highlight(
        let is_format_string = format_string.as_ref() == Some(&element_to_highlight);
-        if let Some((highlight, binding_hash)) =
+        if let Some((highlight, binding_hash)) = highlight_element(
-            highlight_element(&sema, &mut bindings_shadow_count, element_to_highlight.clone())
+            &sema,
-        {
+            &mut bindings_shadow_count,
+            syntactic_name_ref_highlighting,
+            element_to_highlight.clone(),
+        ) {
            stack.add(HighlightedRange { range, highlight, binding_hash });
            if let Some(string) =
                element_to_highlight.as_token().cloned().and_then(ast::String::cast)
            {
-                stack.push();
                if is_format_string {
+                    stack.push();
                    string.lex_format_specifier(|piece_range, kind| {
                        if let Some(highlight) = highlight_format_specifier(kind) {
                            stack.add(HighlightedRange {
@@ -218,13 +222,27 @@ pub(crate) fn highlight(
                            });
                        }
                    });
+                    stack.pop();
+                }
+                // Highlight escape sequences
+                if let Some(char_ranges) = string.char_ranges() {
+                    stack.push();
+                    for (piece_range, _) in char_ranges.iter().filter(|(_, char)| char.is_ok()) {
+                        if string.text()[piece_range.start().into()..].starts_with('\\') {
+                            stack.add(HighlightedRange {
+                                range: piece_range + range.start(),
+                                highlight: HighlightTag::EscapeSequence.into(),
+                                binding_hash: None,
+                            });
+                        }
+                    }
+                    stack.pop_and_inject(false);
                }
-                stack.pop();
            } else if let Some(string) =
                element_to_highlight.as_token().cloned().and_then(ast::RawString::cast)
            {
-                stack.push();
                if is_format_string {
+                    stack.push();
                    string.lex_format_specifier(|piece_range, kind| {
                        if let Some(highlight) = highlight_format_specifier(kind) {
                            stack.add(HighlightedRange {
@@ -234,8 +252,8 @@ pub(crate) fn highlight(
                            });
                        }
                    });
+                    stack.pop();
                }
-                stack.pop();
            }
        }
    }
@@ -410,6 +428,7 @@ fn macro_call_range(macro_call: &ast::MacroCall) -> Option<TextRange> {
 fn highlight_element(
    sema: &Semantics<RootDatabase>,
    bindings_shadow_count: &mut FxHashMap<Name, u32>,
+    syntactic_name_ref_highlighting: bool,
    element: SyntaxElement,
 ) -> Option<(Highlight, Option<u64>)> {
    let db = sema.db;
@@ -463,12 +482,20 @@ fn highlight_element(
                    }
                    NameRefClass::FieldShorthand { .. } => HighlightTag::Field.into(),
                },
+                None if syntactic_name_ref_highlighting => highlight_name_ref_by_syntax(name_ref),
                None => HighlightTag::UnresolvedReference.into(),
            }
        }
        // Simple token-based highlighting
-        COMMENT => HighlightTag::Comment.into(),
+        COMMENT => {
+            let comment = element.into_token().and_then(ast::Comment::cast)?;
+            let h = HighlightTag::Comment;
+            match comment.kind().doc {
+                Some(_) => h | HighlightModifier::Documentation,
+                None => h.into(),
+            }
+        }
        STRING | RAW_STRING | RAW_BYTE_STRING | BYTE_STRING => HighlightTag::StringLiteral.into(),
        ATTR => HighlightTag::Attribute.into(),
        INT_NUMBER | FLOAT_NUMBER => HighlightTag::NumericLiteral.into(),
@@ -614,3 +641,53 @@ fn highlight_name_by_syntax(name: ast::Name) -> Highlight {
    tag.into()
 }
+fn highlight_name_ref_by_syntax(name: ast::NameRef) -> Highlight {
+    let default = HighlightTag::UnresolvedReference;
+    let parent = match name.syntax().parent() {
+        Some(it) => it,
+        _ => return default.into(),
+    };
+    let tag = match parent.kind() {
+        METHOD_CALL_EXPR => HighlightTag::Function,
+        FIELD_EXPR => HighlightTag::Field,
+        PATH_SEGMENT => {
+            let path = match parent.parent().and_then(ast::Path::cast) {
+                Some(it) => it,
+                _ => return default.into(),
+            };
+            let expr = match path.syntax().parent().and_then(ast::PathExpr::cast) {
+                Some(it) => it,
+                _ => {
+                    // within path, decide whether it is module or adt by checking for uppercase name
+                    return if name.text().chars().next().unwrap_or_default().is_uppercase() {
+                        HighlightTag::Struct
+                    } else {
+                        HighlightTag::Module
+                    }
+                    .into();
+                }
+            };
+            let parent = match expr.syntax().parent() {
+                Some(it) => it,
+                None => return default.into(),
+            };
+            match parent.kind() {
+                CALL_EXPR => HighlightTag::Function,
+                _ => {
+                    if name.text().chars().next().unwrap_or_default().is_uppercase() {
+                        HighlightTag::Struct
+                    } else {
+                        HighlightTag::Constant
+                    }
+                }
+            }
+        }
+        _ => default,
+    };
+    tag.into()
+}
diff --git a/crates/ra_ide/src/syntax_highlighting/html.rs b/crates/ra_ide/src/syntax_highlighting/html.rs
index 5bada6252..99b6b25ab 100644
--- a/crates/ra_ide/src/syntax_highlighting/html.rs
+++ b/crates/ra_ide/src/syntax_highlighting/html.rs
@@ -19,7 +19,7 @@ pub(crate) fn highlight_as_html(db: &RootDatabase, file_id: FileId, rainbow: boo
        )
    }
-    let ranges = highlight(db, file_id, None);
+    let ranges = highlight(db, file_id, None, false);
    let text = parse.tree().syntax().to_string();
    let mut prev_pos = TextSize::from(0);
    let mut buf = String::new();
@@ -84,6 +84,8 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .variable           { color: #DCDCCC; }
 .format_specifier   { color: #CC696B; }
 .mutable            { text-decoration: underline; }
+.unresolved_reference { color: #FC5555; }
+.escape_sequence    { color: #94BFF3; }
 .keyword            { color: #F0DFAF; font-weight: bold; }
 .keyword.unsafe     { color: #BC8383; font-weight: bold; }
diff --git a/crates/ra_ide/src/syntax_highlighting/injection.rs b/crates/ra_ide/src/syntax_highlighting/injection.rs
index 3575a0fc6..415f24a6d 100644
--- a/crates/ra_ide/src/syntax_highlighting/injection.rs
+++ b/crates/ra_ide/src/syntax_highlighting/injection.rs
@@ -7,7 +7,10 @@ use hir::Semantics;
 use ra_syntax::{ast, AstToken, SyntaxNode, SyntaxToken, TextRange, TextSize};
 use stdx::SepBy;
-use crate::{call_info::ActiveParameter, Analysis, HighlightTag, HighlightedRange, RootDatabase};
+use crate::{
+    call_info::ActiveParameter, Analysis, HighlightModifier, HighlightTag, HighlightedRange,
+    RootDatabase,
+};
 use super::HighlightedRangeStack;
@@ -53,6 +56,10 @@ pub(super) fn highlight_injection(
 /// Mapping from extracted documentation code to original code
 type RangesMap = BTreeMap<TextSize, TextSize>;
+const RUSTDOC_FENCE: &'static str = "```";
+const RUSTDOC_FENCE_TOKENS: &[&'static str] =
+    &["", "rust", "should_panic", "ignore", "no_run", "compile_fail", "edition2015", "edition2018"];
 /// Extracts Rust code from documentation comments as well as a mapping from
 /// the extracted source code back to the original source ranges.
 /// Lastly, a vector of new comment highlight ranges (spanning only the
@@ -67,6 +74,7 @@ pub(super) fn extract_doc_comments(
    // Mapping from extracted documentation code to original code
    let mut range_mapping: RangesMap = BTreeMap::new();
    let mut line_start = TextSize::try_from(prefix.len()).unwrap();
+    let mut is_codeblock = false;
    let mut is_doctest = false;
    // Replace the original, line-spanning comment ranges by new, only comment-prefix
    // spanning comment ranges.
@@ -76,8 +84,13 @@ pub(super) fn extract_doc_comments(
        .filter_map(|el| el.into_token().and_then(ast::Comment::cast))
        .filter(|comment| comment.kind().doc.is_some())
        .filter(|comment| {
-            if comment.text().contains("```") {
+            if let Some(idx) = comment.text().find(RUSTDOC_FENCE) {
-                is_doctest = !is_doctest;
+                is_codeblock = !is_codeblock;
+                // Check whether code is rust by inspecting fence guards
+                let guards = &comment.text()[idx + RUSTDOC_FENCE.len()..];
+                let is_rust =
+                    guards.split(',').all(|sub| RUSTDOC_FENCE_TOKENS.contains(&sub.trim()));
+                is_doctest = is_codeblock && is_rust;
                false
            } else {
                is_doctest
@@ -108,7 +121,7 @@ pub(super) fn extract_doc_comments(
                    range.start(),
                    range.start() + TextSize::try_from(pos).unwrap(),
                ),
-                highlight: HighlightTag::Comment.into(),
+                highlight: HighlightTag::Comment | HighlightModifier::Documentation,
                binding_hash: None,
            });
            line_start += range.len() - TextSize::try_from(pos).unwrap();
@@ -137,7 +150,7 @@ pub(super) fn highlight_doc_comment(
    let (analysis, tmp_file_id) = Analysis::from_single_file(text);
    stack.push();
-    for mut h in analysis.highlight(tmp_file_id).unwrap() {
+    for mut h in analysis.with_db(|db| super::highlight(db, tmp_file_id, None, true)).unwrap() {
        // Determine start offset and end offset in case of multi-line ranges
        let mut start_offset = None;
        let mut end_offset = None;
@@ -154,6 +167,7 @@ pub(super) fn highlight_doc_comment(
                h.range.start() + start_offset,
                h.range.end() + end_offset.unwrap_or(start_offset),
            );
            stack.add(h);
        }
    }
diff --git a/crates/ra_ide/src/syntax_highlighting/tags.rs b/crates/ra_ide/src/syntax_highlighting/tags.rs
index 94f466966..93bbb4b4d 100644
--- a/crates/ra_ide/src/syntax_highlighting/tags.rs
+++ b/crates/ra_ide/src/syntax_highlighting/tags.rs
@@ -23,6 +23,7 @@ pub enum HighlightTag {
    Constant,
    Enum,
    EnumVariant,
+    EscapeSequence,
    Field,
    FormatSpecifier,
    Function,
@@ -55,6 +56,7 @@ pub enum HighlightModifier {
    /// `foo` in `fn foo(x: i32)` is a definition, `foo` in `foo(90 + 2)` is
    /// not.
    Definition,
+    Documentation,
    Mutable,
    Unsafe,
 }
@@ -71,6 +73,7 @@ impl HighlightTag {
            HighlightTag::Constant => "constant",
            HighlightTag::Enum => "enum",
            HighlightTag::EnumVariant => "enum_variant",
+            HighlightTag::EscapeSequence => "escape_sequence",
            HighlightTag::Field => "field",
            HighlightTag::FormatSpecifier => "format_specifier",
            HighlightTag::Function => "function",
@@ -106,6 +109,7 @@ impl HighlightModifier {
        HighlightModifier::Attribute,
        HighlightModifier::ControlFlow,
        HighlightModifier::Definition,
+        HighlightModifier::Documentation,
        HighlightModifier::Mutable,
        HighlightModifier::Unsafe,
    ];
@@ -115,6 +119,7 @@ impl HighlightModifier {
            HighlightModifier::Attribute => "attribute",
            HighlightModifier::ControlFlow => "control",
            HighlightModifier::Definition => "declaration",
+            HighlightModifier::Documentation => "documentation",
            HighlightModifier::Mutable => "mutable",
            HighlightModifier::Unsafe => "unsafe",
        }
diff --git a/crates/ra_ide/src/syntax_highlighting/tests.rs b/crates/ra_ide/src/syntax_highlighting/tests.rs
index 070b24f45..93a276ffe 100644
--- a/crates/ra_ide/src/syntax_highlighting/tests.rs
+++ b/crates/ra_ide/src/syntax_highlighting/tests.rs
@@ -246,6 +246,10 @@ fn main() {
    println!(r"Hello, {}!", "world");
+    // escape sequences
+    println!("Hello\nWorld");
+    println!("\u{48}\x65\x6C\x6C\x6F World");
    println!("{\x41}", A = 92);
    println!("{ничоси}", ничоси = 92);
 }"#
@@ -287,7 +291,13 @@ fn main() {
 fn test_highlight_doctest() {
    check_highlighting(
        r#"
+struct Foo {
+    bar: bool,
+}
 impl Foo {
+    pub const bar: bool = true;
    /// Constructs a new `Foo`.
    ///
    /// # Examples
@@ -297,7 +307,7 @@ impl Foo {
    /// let mut foo: Foo = Foo::new();
    /// ```
    pub const fn new() -> Foo {
-        Foo { }
+        Foo { bar: true }
    }
    /// `bar` method on `Foo`.
@@ -305,11 +315,15 @@ impl Foo {
    /// # Examples
    ///
    /// ```
+    /// use x::y;
+    ///
    /// let foo = Foo::new();
    ///
    /// // calls bar on foo
    /// assert!(foo.bar());
    ///
+    /// let bar = foo.bar || Foo::bar;
+    ///
    /// /* multi-line
    ///        comment */
    ///
@@ -319,18 +333,31 @@ impl Foo {
    ///
    /// ```
    ///
-    /// ```
+    /// ```rust,no_run
    /// let foobar = Foo::new().bar();
    /// ```
+    ///
+    /// ```sh
+    /// echo 1
+    /// ```
    pub fn foo(&self) -> bool {
        true
    }
 }
+/// ```
+/// noop!(1);
+/// ```
+macro_rules! noop {
+    ($expr:expr) => {
+        $expr
+    }
+}
 "#
        .trim(),
        "crates/ra_ide/src/snapshots/highlight_doctest.html",
        false,
-    )
+    );
 }
 /// Highlights the code given by the `ra_fixture` argument, renders the
diff --git a/crates/ra_ide_db/src/change.rs b/crates/ra_ide_db/src/change.rs
index 2fc796a85..98993d571 100644
--- a/crates/ra_ide_db/src/change.rs
+++ b/crates/ra_ide_db/src/change.rs
@@ -9,22 +9,15 @@ use ra_db::{
    SourceRootId,
 };
 use ra_prof::{memory_usage, profile, Bytes};
-use ra_syntax::SourceFile;
-#[cfg(not(feature = "wasm"))]
-use rayon::prelude::*;
 use rustc_hash::FxHashMap;
-use crate::{
+use crate::{symbol_index::SymbolsDatabase, RootDatabase};
-    symbol_index::{SymbolIndex, SymbolsDatabase},
-    RootDatabase,
-};
 #[derive(Default)]
 pub struct AnalysisChange {
    new_roots: Vec<(SourceRootId, bool)>,
    roots_changed: FxHashMap<SourceRootId, RootChange>,
    files_changed: Vec<(FileId, Arc<String>)>,
-    libraries_added: Vec<LibraryData>,
    crate_graph: Option<CrateGraph>,
 }
@@ -40,9 +33,6 @@ impl fmt::Debug for AnalysisChange {
        if !self.files_changed.is_empty() {
            d.field("files_changed", &self.files_changed.len());
        }
-        if !self.libraries_added.is_empty() {
-            d.field("libraries_added", &self.libraries_added.len());
-        }
        if self.crate_graph.is_some() {
            d.field("crate_graph", &self.crate_graph);
        }
@@ -79,10 +69,6 @@ impl AnalysisChange {
        self.roots_changed.entry(root_id).or_default().removed.push(file);
    }
-    pub fn add_library(&mut self, data: LibraryData) {
-        self.libraries_added.push(data)
-    }
    pub fn set_crate_graph(&mut self, graph: CrateGraph) {
        self.crate_graph = Some(graph);
    }
@@ -116,47 +102,6 @@ impl fmt::Debug for RootChange {
    }
 }
-pub struct LibraryData {
-    root_id: SourceRootId,
-    root_change: RootChange,
-    symbol_index: SymbolIndex,
-}
-impl fmt::Debug for LibraryData {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_struct("LibraryData")
-            .field("root_id", &self.root_id)
-            .field("root_change", &self.root_change)
-            .field("n_symbols", &self.symbol_index.len())
-            .finish()
-    }
-}
-impl LibraryData {
-    pub fn prepare(
-        root_id: SourceRootId,
-        files: Vec<(FileId, RelativePathBuf, Arc<String>)>,
-    ) -> LibraryData {
-        let _p = profile("LibraryData::prepare");
-        #[cfg(not(feature = "wasm"))]
-        let iter = files.par_iter();
-        #[cfg(feature = "wasm")]
-        let iter = files.iter();
-        let symbol_index = SymbolIndex::for_files(iter.map(|(file_id, _, text)| {
-            let parse = SourceFile::parse(text);
-            (*file_id, parse)
-        }));
-        let mut root_change = RootChange::default();
-        root_change.added = files
-            .into_iter()
-            .map(|(file_id, path, text)| AddFile { file_id, path, text })
-            .collect();
-        LibraryData { root_id, root_change, symbol_index }
-    }
-}
 const GC_COOLDOWN: time::Duration = time::Duration::from_millis(100);
 impl RootDatabase {
@@ -171,6 +116,7 @@ impl RootDatabase {
        log::info!("apply_change {:?}", change);
        if !change.new_roots.is_empty() {
            let mut local_roots = Vec::clone(&self.local_roots());
+            let mut libraries = Vec::clone(&self.library_roots());
            for (root_id, is_local) in change.new_roots {
                let root =
                    if is_local { SourceRoot::new_local() } else { SourceRoot::new_library() };
@@ -178,9 +124,12 @@ impl RootDatabase {
                self.set_source_root_with_durability(root_id, Arc::new(root), durability);
                if is_local {
                    local_roots.push(root_id);
+                } else {
+                    libraries.push(root_id)
                }
            }
            self.set_local_roots_with_durability(Arc::new(local_roots), Durability::HIGH);
+            self.set_library_roots_with_durability(Arc::new(libraries), Durability::HIGH);
        }
        for (root_id, root_change) in change.roots_changed {
@@ -192,24 +141,6 @@ impl RootDatabase {
            let durability = durability(&source_root);
            self.set_file_text_with_durability(file_id, text, durability)
        }
-        if !change.libraries_added.is_empty() {
-            let mut libraries = Vec::clone(&self.library_roots());
-            for library in change.libraries_added {
-                libraries.push(library.root_id);
-                self.set_source_root_with_durability(
-                    library.root_id,
-                    Arc::new(SourceRoot::new_library()),
-                    Durability::HIGH,
-                );
-                self.set_library_symbols_with_durability(
-                    library.root_id,
-                    Arc::new(library.symbol_index),
-                    Durability::HIGH,
-                );
-                self.apply_root_change(library.root_id, library.root_change);
-            }
-            self.set_library_roots_with_durability(Arc::new(libraries), Durability::HIGH);
-        }
        if let Some(crate_graph) = change.crate_graph {
            self.set_crate_graph_with_durability(Arc::new(crate_graph), Durability::HIGH)
        }
@@ -352,7 +283,7 @@ impl RootDatabase {
            hir::db::GenericPredicatesQuery
            hir::db::GenericDefaultsQuery
            hir::db::ImplsInCrateQuery
-            hir::db::ImplsForTraitQuery
+            hir::db::ImplsFromDepsQuery
            hir::db::InternTypeCtorQuery
            hir::db::InternTypeParamIdQuery
            hir::db::InternChalkImplQuery
diff --git a/crates/ra_ide_db/src/source_change.rs b/crates/ra_ide_db/src/source_change.rs
index f40ae8304..0bbd3c3e5 100644
--- a/crates/ra_ide_db/src/source_change.rs
+++ b/crates/ra_ide_db/src/source_change.rs
@@ -3,7 +3,7 @@
 //!
 //! It can be viewed as a dual for `AnalysisChange`.
-use ra_db::{FileId, RelativePathBuf, SourceRootId};
+use ra_db::FileId;
 use ra_text_edit::TextEdit;
 #[derive(Debug, Clone)]
@@ -44,8 +44,8 @@ impl From<Vec<SourceFileEdit>> for SourceChange {
 #[derive(Debug, Clone)]
 pub enum FileSystemEdit {
-    CreateFile { source_root: SourceRootId, path: RelativePathBuf },
+    CreateFile { anchor: FileId, dst: String },
-    MoveFile { src: FileId, dst_source_root: SourceRootId, dst_path: RelativePathBuf },
+    MoveFile { src: FileId, anchor: FileId, dst: String },
 }
 impl From<FileSystemEdit> for SourceChange {
diff --git a/crates/ra_ide_db/src/symbol_index.rs b/crates/ra_ide_db/src/symbol_index.rs
index aab918973..25c99813f 100644
--- a/crates/ra_ide_db/src/symbol_index.rs
+++ b/crates/ra_ide_db/src/symbol_index.rs
@@ -34,14 +34,15 @@ use ra_db::{
    salsa::{self, ParallelDatabase},
    CrateId, FileId, SourceDatabaseExt, SourceRootId,
 };
+use ra_prof::profile;
 use ra_syntax::{
    ast::{self, NameOwner},
    match_ast, AstNode, Parse, SmolStr, SourceFile,
    SyntaxKind::{self, *},
    SyntaxNode, SyntaxNodePtr, TextRange, WalkEvent,
 };
-#[cfg(not(feature = "wasm"))]
 use rayon::prelude::*;
+use rustc_hash::FxHashMap;
 use crate::RootDatabase;
@@ -86,10 +87,9 @@ impl Query {
 }
 #[salsa::query_group(SymbolsDatabaseStorage)]
-pub trait SymbolsDatabase: hir::db::HirDatabase {
+pub trait SymbolsDatabase: hir::db::HirDatabase + SourceDatabaseExt + ParallelDatabase {
    fn file_symbols(&self, file_id: FileId) -> Arc<SymbolIndex>;
-    #[salsa::input]
+    fn library_symbols(&self) -> Arc<FxHashMap<SourceRootId, SymbolIndex>>;
-    fn library_symbols(&self, id: SourceRootId) -> Arc<SymbolIndex>;
    /// The set of "local" (that is, from the current workspace) roots.
    /// Files in local roots are assumed to change frequently.
    #[salsa::input]
@@ -100,6 +100,29 @@ pub trait SymbolsDatabase: hir::db::HirDatabase {
    fn library_roots(&self) -> Arc<Vec<SourceRootId>>;
 }
+fn library_symbols(
+    db: &(impl SymbolsDatabase + ParallelDatabase),
+) -> Arc<FxHashMap<SourceRootId, SymbolIndex>> {
+    let _p = profile("library_symbols");
+    let roots = db.library_roots();
+    let res = roots
+        .iter()
+        .map(|&root_id| {
+            let root = db.source_root(root_id);
+            let files = root
+                .walk()
+                .map(|it| (it, SourceDatabaseExt::file_text(db, it)))
+                .collect::<Vec<_>>();
+            let symbol_index = SymbolIndex::for_files(
+                files.into_par_iter().map(|(file, text)| (file, SourceFile::parse(&text))),
+            );
+            (root_id, symbol_index)
+        })
+        .collect();
+    Arc::new(res)
+}
 fn file_symbols(db: &impl SymbolsDatabase, file_id: FileId) -> Arc<SymbolIndex> {
    db.check_canceled();
    let parse = db.parse(file_id);
@@ -112,9 +135,9 @@ fn file_symbols(db: &impl SymbolsDatabase, file_id: FileId) -> Arc<SymbolIndex>
 }
 /// Need to wrap Snapshot to provide `Clone` impl for `map_with`
-struct Snap(salsa::Snapshot<RootDatabase>);
+struct Snap<DB>(DB);
-impl Clone for Snap {
+impl<DB: ParallelDatabase> Clone for Snap<salsa::Snapshot<DB>> {
-    fn clone(&self) -> Snap {
+    fn clone(&self) -> Snap<salsa::Snapshot<DB>> {
        Snap(self.0.snapshot())
    }
 }
@@ -143,19 +166,11 @@ impl Clone for Snap {
 pub fn world_symbols(db: &RootDatabase, query: Query) -> Vec<FileSymbol> {
    let _p = ra_prof::profile("world_symbols").detail(|| query.query.clone());
-    let buf: Vec<Arc<SymbolIndex>> = if query.libs {
+    let tmp1;
-        let snap = Snap(db.snapshot());
+    let tmp2;
-        #[cfg(not(feature = "wasm"))]
+    let buf: Vec<&SymbolIndex> = if query.libs {
-        let buf = db
+        tmp1 = db.library_symbols();
-            .library_roots()
+        tmp1.values().collect()
-            .par_iter()
-            .map_with(snap, |db, &lib_id| db.0.library_symbols(lib_id))
-            .collect();
-        #[cfg(feature = "wasm")]
-        let buf = db.library_roots().iter().map(|&lib_id| snap.0.library_symbols(lib_id)).collect();
-        buf
    } else {
        let mut files = Vec::new();
        for &root in db.local_roots().iter() {
@@ -164,14 +179,11 @@ pub fn world_symbols(db: &RootDatabase, query: Query) -> Vec<FileSymbol> {
        }
        let snap = Snap(db.snapshot());
-        #[cfg(not(feature = "wasm"))]
+        tmp2 = files
-        let buf =
+            .par_iter()
-            files.par_iter().map_with(snap, |db, &file_id| db.0.file_symbols(file_id)).collect();
+            .map_with(snap, |db, &file_id| db.0.file_symbols(file_id))
+            .collect::<Vec<_>>();
-        #[cfg(feature = "wasm")]
+        tmp2.iter().map(|it| &**it).collect()
-        let buf = files.iter().map(|&file_id| snap.0.file_symbols(file_id)).collect();
-        buf
    };
    query.search(&buf)
 }
@@ -191,14 +203,11 @@ pub fn crate_symbols(db: &RootDatabase, krate: CrateId, query: Query) -> Vec<Fil
    let snap = Snap(db.snapshot());
-    #[cfg(not(feature = "wasm"))]
    let buf = files
        .par_iter()
        .map_with(snap, |db, &file_id| db.0.file_symbols(file_id))
        .collect::<Vec<_>>();
+    let buf = buf.iter().map(|it| &**it).collect::<Vec<_>>();
-    #[cfg(feature = "wasm")]
-    let buf = files.iter().map(|&file_id| snap.0.file_symbols(file_id)).collect::<Vec<_>>();
    query.search(&buf)
 }
@@ -245,12 +254,8 @@ impl SymbolIndex {
            lhs_chars.cmp(rhs_chars)
        }
-        #[cfg(not(feature = "wasm"))]
        symbols.par_sort_by(cmp);
-        #[cfg(feature = "wasm")]
-        symbols.sort_by(cmp);
        let mut builder = fst::MapBuilder::memory();
        let mut last_batch_start = 0;
@@ -284,7 +289,6 @@ impl SymbolIndex {
        self.map.as_fst().size() + self.symbols.len() * mem::size_of::<FileSymbol>()
    }
-    #[cfg(not(feature = "wasm"))]
    pub(crate) fn for_files(
        files: impl ParallelIterator<Item = (FileId, Parse<ast::SourceFile>)>,
    ) -> SymbolIndex {
@@ -294,16 +298,6 @@ impl SymbolIndex {
        SymbolIndex::new(symbols)
    }
-    #[cfg(feature = "wasm")]
-    pub(crate) fn for_files(
-        files: impl Iterator<Item = (FileId, Parse<ast::SourceFile>)>,
-    ) -> SymbolIndex {
-        let symbols = files
-            .flat_map(|(file_id, file)| source_file_to_file_symbols(&file.tree(), file_id))
-            .collect::<Vec<_>>();
-        SymbolIndex::new(symbols)
-    }
    fn range_to_map_value(start: usize, end: usize) -> u64 {
        debug_assert![start <= (std::u32::MAX as usize)];
        debug_assert![end <= (std::u32::MAX as usize)];
@@ -319,7 +313,7 @@ impl SymbolIndex {
 }
 impl Query {
-    pub(crate) fn search(self, indices: &[Arc<SymbolIndex>]) -> Vec<FileSymbol> {
+    pub(crate) fn search(self, indices: &[&SymbolIndex]) -> Vec<FileSymbol> {
        let mut op = fst::map::OpBuilder::new();
        for file_symbols in indices.iter() {
            let automaton = fst::automaton::Subsequence::new(&self.lowercased);
diff --git a/crates/ra_proc_macro_srv/src/tests/fixtures/test_serialize_proc_macro.txt b/crates/ra_proc_macro_srv/src/tests/fixtures/test_serialize_proc_macro.txt
index bc010cfe9..e6fd21610 100644
--- a/crates/ra_proc_macro_srv/src/tests/fixtures/test_serialize_proc_macro.txt
+++ b/crates/ra_proc_macro_srv/src/tests/fixtures/test_serialize_proc_macro.txt
@@ -14,7 +14,7 @@ SUBTREE $
      PUNCH   , [alone] 4294967295
      IDENT   unused_qualifications 4294967295
  IDENT   const 4294967295
-  IDENT   _IMPL_SERIALIZE_FOR_Foo 4294967295
+  IDENT   _ 4294967295
  PUNCH   : [alone] 4294967295
  SUBTREE () 4294967295
  PUNCH   = [alone] 4294967295
diff --git a/crates/ra_ssr/Cargo.toml b/crates/ra_ssr/Cargo.toml
new file mode 100644
index 000000000..3c2f15a83
--- /dev/null
+++ b/crates/ra_ssr/Cargo.toml
@@ -0,0 +1,19 @@
+[package]
+edition = "2018"
+name = "ra_ssr"
+version = "0.1.0"
+authors = ["rust-analyzer developers"]
+license = "MIT OR Apache-2.0"
+description = "Structural search and replace of Rust code"
+repository = "https://github.com/rust-analyzer/rust-analyzer"
+[lib]
+doctest = false
+[dependencies]
+ra_text_edit = { path = "../ra_text_edit" }
+ra_syntax = { path = "../ra_syntax" }
+ra_db = { path = "../ra_db" }
+ra_ide_db = { path = "../ra_ide_db" }
+hir = { path = "../ra_hir", package = "ra_hir" }
+rustc-hash = "1.1.0"
diff --git a/crates/ra_ssr/src/lib.rs b/crates/ra_ssr/src/lib.rs
new file mode 100644
index 000000000..fc716ae82
--- /dev/null
+++ b/crates/ra_ssr/src/lib.rs
@@ -0,0 +1,120 @@
+//! Structural Search Replace
+//!
+//! Allows searching the AST for code that matches one or more patterns and then replacing that code
+//! based on a template.
+mod matching;
+mod parsing;
+mod replacing;
+#[cfg(test)]
+mod tests;
+use crate::matching::Match;
+use hir::Semantics;
+use ra_db::{FileId, FileRange};
+use ra_syntax::{AstNode, SmolStr, SyntaxNode};
+use ra_text_edit::TextEdit;
+use rustc_hash::FxHashMap;
+// A structured search replace rule. Create by calling `parse` on a str.
+#[derive(Debug)]
+pub struct SsrRule {
+    /// A structured pattern that we're searching for.
+    pattern: SsrPattern,
+    /// What we'll replace it with.
+    template: parsing::SsrTemplate,
+}
+#[derive(Debug)]
+struct SsrPattern {
+    raw: parsing::RawSearchPattern,
+    /// Placeholders keyed by the stand-in ident that we use in Rust source code.
+    placeholders_by_stand_in: FxHashMap<SmolStr, parsing::Placeholder>,
+    // We store our search pattern, parsed as each different kind of thing we can look for. As we
+    // traverse the AST, we get the appropriate one of these for the type of node we're on. For many
+    // search patterns, only some of these will be present.
+    expr: Option<SyntaxNode>,
+    type_ref: Option<SyntaxNode>,
+    item: Option<SyntaxNode>,
+    path: Option<SyntaxNode>,
+    pattern: Option<SyntaxNode>,
+}
+#[derive(Debug, PartialEq)]
+pub struct SsrError(String);
+#[derive(Debug, Default)]
+pub struct SsrMatches {
+    matches: Vec<Match>,
+}
+/// Searches a crate for pattern matches and possibly replaces them with something else.
+pub struct MatchFinder<'db> {
+    /// Our source of information about the user's code.
+    sema: Semantics<'db, ra_ide_db::RootDatabase>,
+    rules: Vec<SsrRule>,
+}
+impl<'db> MatchFinder<'db> {
+    pub fn new(db: &'db ra_ide_db::RootDatabase) -> MatchFinder<'db> {
+        MatchFinder { sema: Semantics::new(db), rules: Vec::new() }
+    }
+    pub fn add_rule(&mut self, rule: SsrRule) {
+        self.rules.push(rule);
+    }
+    pub fn edits_for_file(&self, file_id: FileId) -> Option<TextEdit> {
+        let matches = self.find_matches_in_file(file_id);
+        if matches.matches.is_empty() {
+            None
+        } else {
+            Some(replacing::matches_to_edit(&matches))
+        }
+    }
+    fn find_matches_in_file(&self, file_id: FileId) -> SsrMatches {
+        let file = self.sema.parse(file_id);
+        let code = file.syntax();
+        let mut matches = SsrMatches::default();
+        self.find_matches(code, &None, &mut matches);
+        matches
+    }
+    fn find_matches(
+        &self,
+        code: &SyntaxNode,
+        restrict_range: &Option<FileRange>,
+        matches_out: &mut SsrMatches,
+    ) {
+        for rule in &self.rules {
+            if let Ok(mut m) = matching::get_match(false, rule, &code, restrict_range, &self.sema) {
+                // Continue searching in each of our placeholders.
+                for placeholder_value in m.placeholder_values.values_mut() {
+                    // Don't search our placeholder if it's the entire matched node, otherwise we'd
+                    // find the same match over and over until we got a stack overflow.
+                    if placeholder_value.node != *code {
+                        self.find_matches(
+                            &placeholder_value.node,
+                            restrict_range,
+                            &mut placeholder_value.inner_matches,
+                        );
+                    }
+                }
+                matches_out.matches.push(m);
+                return;
+            }
+        }
+        for child in code.children() {
+            self.find_matches(&child, restrict_range, matches_out);
+        }
+    }
+}
+impl std::fmt::Display for SsrError {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        write!(f, "Parse error: {}", self.0)
+    }
+}
+impl std::error::Error for SsrError {}
diff --git a/crates/ra_ssr/src/matching.rs b/crates/ra_ssr/src/matching.rs
new file mode 100644
index 000000000..265b6d793
--- /dev/null
+++ b/crates/ra_ssr/src/matching.rs
@@ -0,0 +1,494 @@
+//! This module is responsible for matching a search pattern against a node in the AST. In the
+//! process of matching, placeholder values are recorded.
+use crate::{
+    parsing::{Placeholder, SsrTemplate},
+    SsrMatches, SsrPattern, SsrRule,
+};
+use hir::Semantics;
+use ra_db::FileRange;
+use ra_syntax::ast::{AstNode, AstToken};
+use ra_syntax::{
+    ast, SyntaxElement, SyntaxElementChildren, SyntaxKind, SyntaxNode, SyntaxToken, TextRange,
+};
+use rustc_hash::FxHashMap;
+use std::{cell::Cell, iter::Peekable};
+// Creates a match error. If we're currently attempting to match some code that we thought we were
+// going to match, as indicated by the --debug-snippet flag, then populate the reason field.
+macro_rules! match_error {
+    ($e:expr) => {{
+            MatchFailed {
+                reason: if recording_match_fail_reasons() {
+                    Some(format!("{}", $e))
+                } else {
+                    None
+                }
+            }
+    }};
+    ($fmt:expr, $($arg:tt)+) => {{
+        MatchFailed {
+            reason: if recording_match_fail_reasons() {
+                Some(format!($fmt, $($arg)+))
+            } else {
+                None
+            }
+        }
+    }};
+}
+// Fails the current match attempt, recording the supplied reason if we're recording match fail reasons.
+macro_rules! fail_match {
+    ($($args:tt)*) => {return Err(match_error!($($args)*))};
+}
+/// Information about a match that was found.
+#[derive(Debug)]
+pub(crate) struct Match {
+    pub(crate) range: TextRange,
+    pub(crate) matched_node: SyntaxNode,
+    pub(crate) placeholder_values: FxHashMap<Var, PlaceholderMatch>,
+    pub(crate) ignored_comments: Vec<ast::Comment>,
+    // A copy of the template for the rule that produced this match. We store this on the match for
+    // if/when we do replacement.
+    pub(crate) template: SsrTemplate,
+}
+/// Represents a `$var` in an SSR query.
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub(crate) struct Var(pub String);
+/// Information about a placeholder bound in a match.
+#[derive(Debug)]
+pub(crate) struct PlaceholderMatch {
+    /// The node that the placeholder matched to.
+    pub(crate) node: SyntaxNode,
+    pub(crate) range: FileRange,
+    /// More matches, found within `node`.
+    pub(crate) inner_matches: SsrMatches,
+}
+#[derive(Debug)]
+pub(crate) struct MatchFailureReason {
+    pub(crate) reason: String,
+}
+/// An "error" indicating that matching failed. Use the fail_match! macro to create and return this.
+#[derive(Clone)]
+pub(crate) struct MatchFailed {
+    /// The reason why we failed to match. Only present when debug_active true in call to
+    /// `get_match`.
+    pub(crate) reason: Option<String>,
+}
+/// Checks if `code` matches the search pattern found in `search_scope`, returning information about
+/// the match, if it does. Since we only do matching in this module and searching is done by the
+/// parent module, we don't populate nested matches.
+pub(crate) fn get_match(
+    debug_active: bool,
+    rule: &SsrRule,
+    code: &SyntaxNode,
+    restrict_range: &Option<FileRange>,
+    sema: &Semantics<ra_ide_db::RootDatabase>,
+) -> Result<Match, MatchFailed> {
+    record_match_fails_reasons_scope(debug_active, || {
+        MatchState::try_match(rule, code, restrict_range, sema)
+    })
+}
+/// Inputs to matching. This cannot be part of `MatchState`, since we mutate `MatchState` and in at
+/// least one case need to hold a borrow of a placeholder from the input pattern while calling a
+/// mutable `MatchState` method.
+struct MatchInputs<'pattern> {
+    ssr_pattern: &'pattern SsrPattern,
+}
+/// State used while attempting to match our search pattern against a particular node of the AST.
+struct MatchState<'db, 'sema> {
+    sema: &'sema Semantics<'db, ra_ide_db::RootDatabase>,
+    /// If any placeholders come from anywhere outside of this range, then the match will be
+    /// rejected.
+    restrict_range: Option<FileRange>,
+    /// The match that we're building. We do two passes for a successful match. On the first pass,
+    /// this is None so that we can avoid doing things like storing copies of what placeholders
+    /// matched to. If that pass succeeds, then we do a second pass where we collect those details.
+    /// This means that if we have a pattern like `$a.foo()` we won't do an insert into the
+    /// placeholders map for every single method call in the codebase. Instead we'll discard all the
+    /// method calls that aren't calls to `foo` on the first pass and only insert into the
+    /// placeholders map on the second pass. Likewise for ignored comments.
+    match_out: Option<Match>,
+}
+impl<'db, 'sema> MatchState<'db, 'sema> {
+    fn try_match(
+        rule: &SsrRule,
+        code: &SyntaxNode,
+        restrict_range: &Option<FileRange>,
+        sema: &'sema Semantics<'db, ra_ide_db::RootDatabase>,
+    ) -> Result<Match, MatchFailed> {
+        let mut match_state =
+            MatchState { sema, restrict_range: restrict_range.clone(), match_out: None };
+        let match_inputs = MatchInputs { ssr_pattern: &rule.pattern };
+        let pattern_tree = rule.pattern.tree_for_kind(code.kind())?;
+        // First pass at matching, where we check that node types and idents match.
+        match_state.attempt_match_node(&match_inputs, &pattern_tree, code)?;
+        match_state.validate_range(&sema.original_range(code))?;
+        match_state.match_out = Some(Match {
+            range: sema.original_range(code).range,
+            matched_node: code.clone(),
+            placeholder_values: FxHashMap::default(),
+            ignored_comments: Vec::new(),
+            template: rule.template.clone(),
+        });
+        // Second matching pass, where we record placeholder matches, ignored comments and maybe do
+        // any other more expensive checks that we didn't want to do on the first pass.
+        match_state.attempt_match_node(&match_inputs, &pattern_tree, code)?;
+        Ok(match_state.match_out.unwrap())
+    }
+    /// Checks that `range` is within the permitted range if any. This is applicable when we're
+    /// processing a macro expansion and we want to fail the match if we're working with a node that
+    /// didn't originate from the token tree of the macro call.
+    fn validate_range(&self, range: &FileRange) -> Result<(), MatchFailed> {
+        if let Some(restrict_range) = &self.restrict_range {
+            if restrict_range.file_id != range.file_id
+                || !restrict_range.range.contains_range(range.range)
+            {
+                fail_match!("Node originated from a macro");
+            }
+        }
+        Ok(())
+    }
+    fn attempt_match_node(
+        &mut self,
+        match_inputs: &MatchInputs,
+        pattern: &SyntaxNode,
+        code: &SyntaxNode,
+    ) -> Result<(), MatchFailed> {
+        // Handle placeholders.
+        if let Some(placeholder) =
+            match_inputs.get_placeholder(&SyntaxElement::Node(pattern.clone()))
+        {
+            if self.match_out.is_none() {
+                return Ok(());
+            }
+            let original_range = self.sema.original_range(code);
+            // We validated the range for the node when we started the match, so the placeholder
+            // probably can't fail range validation, but just to be safe...
+            self.validate_range(&original_range)?;
+            if let Some(match_out) = &mut self.match_out {
+                match_out.placeholder_values.insert(
+                    Var(placeholder.ident.to_string()),
+                    PlaceholderMatch::new(code, original_range),
+                );
+            }
+            return Ok(());
+        }
+        // Non-placeholders.
+        if pattern.kind() != code.kind() {
+            fail_match!("Pattern had a {:?}, code had {:?}", pattern.kind(), code.kind());
+        }
+        // Some kinds of nodes have special handling. For everything else, we fall back to default
+        // matching.
+        match code.kind() {
+            SyntaxKind::RECORD_FIELD_LIST => {
+                self.attempt_match_record_field_list(match_inputs, pattern, code)
+            }
+            _ => self.attempt_match_node_children(match_inputs, pattern, code),
+        }
+    }
+    fn attempt_match_node_children(
+        &mut self,
+        match_inputs: &MatchInputs,
+        pattern: &SyntaxNode,
+        code: &SyntaxNode,
+    ) -> Result<(), MatchFailed> {
+        self.attempt_match_sequences(
+            match_inputs,
+            PatternIterator::new(pattern),
+            code.children_with_tokens(),
+        )
+    }
+    fn attempt_match_sequences(
+        &mut self,
+        match_inputs: &MatchInputs,
+        pattern_it: PatternIterator,
+        mut code_it: SyntaxElementChildren,
+    ) -> Result<(), MatchFailed> {
+        let mut pattern_it = pattern_it.peekable();
+        loop {
+            match self.next_non_trivial(&mut code_it) {
+                None => {
+                    if let Some(p) = pattern_it.next() {
+                        fail_match!("Part of the pattern was unmached: {:?}", p);
+                    }
+                    return Ok(());
+                }
+                Some(SyntaxElement::Token(c)) => {
+                    self.attempt_match_token(&mut pattern_it, &c)?;
+                }
+                Some(SyntaxElement::Node(c)) => match pattern_it.next() {
+                    Some(SyntaxElement::Node(p)) => {
+                        self.attempt_match_node(match_inputs, &p, &c)?;
+                    }
+                    Some(p) => fail_match!("Pattern wanted '{}', code has {}", p, c.text()),
+                    None => fail_match!("Pattern reached end, code has {}", c.text()),
+                },
+            }
+        }
+    }
+    fn attempt_match_token(
+        &mut self,
+        pattern: &mut Peekable<PatternIterator>,
+        code: &ra_syntax::SyntaxToken,
+    ) -> Result<(), MatchFailed> {
+        self.record_ignored_comments(code);
+        // Ignore whitespace and comments.
+        if code.kind().is_trivia() {
+            return Ok(());
+        }
+        if let Some(SyntaxElement::Token(p)) = pattern.peek() {
+            // If the code has a comma and the pattern is about to close something, then accept the
+            // comma without advancing the pattern. i.e. ignore trailing commas.
+            if code.kind() == SyntaxKind::COMMA && is_closing_token(p.kind()) {
+                return Ok(());
+            }
+            // Conversely, if the pattern has a comma and the code doesn't, skip that part of the
+            // pattern and continue to match the code.
+            if p.kind() == SyntaxKind::COMMA && is_closing_token(code.kind()) {
+                pattern.next();
+            }
+        }
+        // Consume an element from the pattern and make sure it matches.
+        match pattern.next() {
+            Some(SyntaxElement::Token(p)) => {
+                if p.kind() != code.kind() || p.text() != code.text() {
+                    fail_match!(
+                        "Pattern wanted token '{}' ({:?}), but code had token '{}' ({:?})",
+                        p.text(),
+                        p.kind(),
+                        code.text(),
+                        code.kind()
+                    )
+                }
+            }
+            Some(SyntaxElement::Node(p)) => {
+                // Not sure if this is actually reachable.
+                fail_match!(
+                    "Pattern wanted {:?}, but code had token '{}' ({:?})",
+                    p,
+                    code.text(),
+                    code.kind()
+                );
+            }
+            None => {
+                fail_match!("Pattern exhausted, while code remains: `{}`", code.text());
+            }
+        }
+        Ok(())
+    }
+    /// We want to allow the records to match in any order, so we have special matching logic for
+    /// them.
+    fn attempt_match_record_field_list(
+        &mut self,
+        match_inputs: &MatchInputs,
+        pattern: &SyntaxNode,
+        code: &SyntaxNode,
+    ) -> Result<(), MatchFailed> {
+        // Build a map keyed by field name.
+        let mut fields_by_name = FxHashMap::default();
+        for child in code.children() {
+            if let Some(record) = ast::RecordField::cast(child.clone()) {
+                if let Some(name) = record.field_name() {
+                    fields_by_name.insert(name.text().clone(), child.clone());
+                }
+            }
+        }
+        for p in pattern.children_with_tokens() {
+            if let SyntaxElement::Node(p) = p {
+                if let Some(name_element) = p.first_child_or_token() {
+                    if match_inputs.get_placeholder(&name_element).is_some() {
+                        // If the pattern is using placeholders for field names then order
+                        // independence doesn't make sense. Fall back to regular ordered
+                        // matching.
+                        return self.attempt_match_node_children(match_inputs, pattern, code);
+                    }
+                    if let Some(ident) = only_ident(name_element) {
+                        let code_record = fields_by_name.remove(ident.text()).ok_or_else(|| {
+                            match_error!(
+                                "Placeholder has record field '{}', but code doesn't",
+                                ident
+                            )
+                        })?;
+                        self.attempt_match_node(match_inputs, &p, &code_record)?;
+                    }
+                }
+            }
+        }
+        if let Some(unmatched_fields) = fields_by_name.keys().next() {
+            fail_match!(
+                "{} field(s) of a record literal failed to match, starting with {}",
+                fields_by_name.len(),
+                unmatched_fields
+            );
+        }
+        Ok(())
+    }
+    fn next_non_trivial(&mut self, code_it: &mut SyntaxElementChildren) -> Option<SyntaxElement> {
+        loop {
+            let c = code_it.next();
+            if let Some(SyntaxElement::Token(t)) = &c {
+                self.record_ignored_comments(t);
+                if t.kind().is_trivia() {
+                    continue;
+                }
+            }
+            return c;
+        }
+    }
+    fn record_ignored_comments(&mut self, token: &SyntaxToken) {
+        if token.kind() == SyntaxKind::COMMENT {
+            if let Some(match_out) = &mut self.match_out {
+                if let Some(comment) = ast::Comment::cast(token.clone()) {
+                    match_out.ignored_comments.push(comment);
+                }
+            }
+        }
+    }
+}
+impl MatchInputs<'_> {
+    fn get_placeholder(&self, element: &SyntaxElement) -> Option<&Placeholder> {
+        only_ident(element.clone())
+            .and_then(|ident| self.ssr_pattern.placeholders_by_stand_in.get(ident.text()))
+    }
+}
+fn is_closing_token(kind: SyntaxKind) -> bool {
+    kind == SyntaxKind::R_PAREN || kind == SyntaxKind::R_CURLY || kind == SyntaxKind::R_BRACK
+}
+pub(crate) fn record_match_fails_reasons_scope<F, T>(debug_active: bool, f: F) -> T
+where
+    F: Fn() -> T,
+{
+    RECORDING_MATCH_FAIL_REASONS.with(|c| c.set(debug_active));
+    let res = f();
+    RECORDING_MATCH_FAIL_REASONS.with(|c| c.set(false));
+    res
+}
+// For performance reasons, we don't want to record the reason why every match fails, only the bit
+// of code that the user indicated they thought would match. We use a thread local to indicate when
+// we are trying to match that bit of code. This saves us having to pass a boolean into all the bits
+// of code that can make the decision to not match.
+thread_local! {
+    pub static RECORDING_MATCH_FAIL_REASONS: Cell<bool> = Cell::new(false);
+}
+fn recording_match_fail_reasons() -> bool {
+    RECORDING_MATCH_FAIL_REASONS.with(|c| c.get())
+}
+impl PlaceholderMatch {
+    fn new(node: &SyntaxNode, range: FileRange) -> Self {
+        Self { node: node.clone(), range, inner_matches: SsrMatches::default() }
+    }
+}
+impl SsrPattern {
+    pub(crate) fn tree_for_kind(&self, kind: SyntaxKind) -> Result<&SyntaxNode, MatchFailed> {
+        let (tree, kind_name) = if ast::Expr::can_cast(kind) {
+            (&self.expr, "expression")
+        } else if ast::TypeRef::can_cast(kind) {
+            (&self.type_ref, "type reference")
+        } else if ast::ModuleItem::can_cast(kind) {
+            (&self.item, "item")
+        } else if ast::Path::can_cast(kind) {
+            (&self.path, "path")
+        } else if ast::Pat::can_cast(kind) {
+            (&self.pattern, "pattern")
+        } else {
+            fail_match!("Matching nodes of kind {:?} is not supported", kind);
+        };
+        match tree {
+            Some(tree) => Ok(tree),
+            None => fail_match!("Pattern cannot be parsed as a {}", kind_name),
+        }
+    }
+}
+// If `node` contains nothing but an ident then return it, otherwise return None.
+fn only_ident(element: SyntaxElement) -> Option<SyntaxToken> {
+    match element {
+        SyntaxElement::Token(t) => {
+            if t.kind() == SyntaxKind::IDENT {
+                return Some(t);
+            }
+        }
+        SyntaxElement::Node(n) => {
+            let mut children = n.children_with_tokens();
+            if let (Some(only_child), None) = (children.next(), children.next()) {
+                return only_ident(only_child);
+            }
+        }
+    }
+    None
+}
+struct PatternIterator {
+    iter: SyntaxElementChildren,
+}
+impl Iterator for PatternIterator {
+    type Item = SyntaxElement;
+    fn next(&mut self) -> Option<SyntaxElement> {
+        while let Some(element) = self.iter.next() {
+            if !element.kind().is_trivia() {
+                return Some(element);
+            }
+        }
+        None
+    }
+}
+impl PatternIterator {
+    fn new(parent: &SyntaxNode) -> Self {
+        Self { iter: parent.children_with_tokens() }
+    }
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::MatchFinder;
+    #[test]
+    fn parse_match_replace() {
+        let rule: SsrRule = "foo($x) ==>> bar($x)".parse().unwrap();
+        let input = "fn main() { foo(1+2); }";
+        use ra_db::fixture::WithFixture;
+        let (db, file_id) = ra_ide_db::RootDatabase::with_single_file(input);
+        let mut match_finder = MatchFinder::new(&db);
+        match_finder.add_rule(rule);
+        let matches = match_finder.find_matches_in_file(file_id);
+        assert_eq!(matches.matches.len(), 1);
+        assert_eq!(matches.matches[0].matched_node.text(), "foo(1+2)");
+        assert_eq!(matches.matches[0].placeholder_values.len(), 1);
+        assert_eq!(matches.matches[0].placeholder_values[&Var("x".to_string())].node.text(), "1+2");
+        let edit = crate::replacing::matches_to_edit(&matches);
+        let mut after = input.to_string();
+        edit.apply(&mut after);
+        assert_eq!(after, "fn main() { bar(1+2); }");
+    }
+}
diff --git a/crates/ra_ssr/src/parsing.rs b/crates/ra_ssr/src/parsing.rs
new file mode 100644
index 000000000..90c13dbc2
--- /dev/null
+++ b/crates/ra_ssr/src/parsing.rs
@@ -0,0 +1,272 @@
+//! This file contains code for parsing SSR rules, which look something like `foo($a) ==>> bar($b)`.
+//! We first split everything before and after the separator `==>>`. Next, both the search pattern
+//! and the replacement template get tokenized by the Rust tokenizer. Tokens are then searched for
+//! placeholders, which start with `$`. For replacement templates, this is the final form. For
+//! search patterns, we go further and parse the pattern as each kind of thing that we can match.
+//! e.g. expressions, type references etc.
+use crate::{SsrError, SsrPattern, SsrRule};
+use ra_syntax::{ast, AstNode, SmolStr, SyntaxKind};
+use rustc_hash::{FxHashMap, FxHashSet};
+use std::str::FromStr;
+/// Returns from the current function with an error, supplied by arguments as for format!
+macro_rules! bail {
+    ($e:expr) => {return Err($crate::SsrError::new($e))};
+    ($fmt:expr, $($arg:tt)+) => {return Err($crate::SsrError::new(format!($fmt, $($arg)+)))}
+}
+#[derive(Clone, Debug)]
+pub(crate) struct SsrTemplate {
+    pub(crate) tokens: Vec<PatternElement>,
+}
+#[derive(Debug)]
+pub(crate) struct RawSearchPattern {
+    tokens: Vec<PatternElement>,
+}
+// Part of a search or replace pattern.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) enum PatternElement {
+    Token(Token),
+    Placeholder(Placeholder),
+}
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) struct Placeholder {
+    /// The name of this placeholder. e.g. for "$a", this would be "a"
+    pub(crate) ident: SmolStr,
+    /// A unique name used in place of this placeholder when we parse the pattern as Rust code.
+    stand_in_name: String,
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) struct Token {
+    kind: SyntaxKind,
+    pub(crate) text: SmolStr,
+}
+impl FromStr for SsrRule {
+    type Err = SsrError;
+    fn from_str(query: &str) -> Result<SsrRule, SsrError> {
+        let mut it = query.split("==>>");
+        let pattern = it.next().expect("at least empty string").trim();
+        let template = it
+            .next()
+            .ok_or_else(|| SsrError("Cannot find delemiter `==>>`".into()))?
+            .trim()
+            .to_string();
+        if it.next().is_some() {
+            return Err(SsrError("More than one delimiter found".into()));
+        }
+        let rule = SsrRule { pattern: pattern.parse()?, template: template.parse()? };
+        validate_rule(&rule)?;
+        Ok(rule)
+    }
+}
+impl FromStr for RawSearchPattern {
+    type Err = SsrError;
+    fn from_str(pattern_str: &str) -> Result<RawSearchPattern, SsrError> {
+        Ok(RawSearchPattern { tokens: parse_pattern(pattern_str)? })
+    }
+}
+impl RawSearchPattern {
+    /// Returns this search pattern as Rust source code that we can feed to the Rust parser.
+    fn as_rust_code(&self) -> String {
+        let mut res = String::new();
+        for t in &self.tokens {
+            res.push_str(match t {
+                PatternElement::Token(token) => token.text.as_str(),
+                PatternElement::Placeholder(placeholder) => placeholder.stand_in_name.as_str(),
+            });
+        }
+        res
+    }
+    fn placeholders_by_stand_in(&self) -> FxHashMap<SmolStr, Placeholder> {
+        let mut res = FxHashMap::default();
+        for t in &self.tokens {
+            if let PatternElement::Placeholder(placeholder) = t {
+                res.insert(SmolStr::new(placeholder.stand_in_name.clone()), placeholder.clone());
+            }
+        }
+        res
+    }
+}
+impl FromStr for SsrPattern {
+    type Err = SsrError;
+    fn from_str(pattern_str: &str) -> Result<SsrPattern, SsrError> {
+        let raw: RawSearchPattern = pattern_str.parse()?;
+        let raw_str = raw.as_rust_code();
+        let res = SsrPattern {
+            expr: ast::Expr::parse(&raw_str).ok().map(|n| n.syntax().clone()),
+            type_ref: ast::TypeRef::parse(&raw_str).ok().map(|n| n.syntax().clone()),
+            item: ast::ModuleItem::parse(&raw_str).ok().map(|n| n.syntax().clone()),
+            path: ast::Path::parse(&raw_str).ok().map(|n| n.syntax().clone()),
+            pattern: ast::Pat::parse(&raw_str).ok().map(|n| n.syntax().clone()),
+            placeholders_by_stand_in: raw.placeholders_by_stand_in(),
+            raw,
+        };
+        if res.expr.is_none()
+            && res.type_ref.is_none()
+            && res.item.is_none()
+            && res.path.is_none()
+            && res.pattern.is_none()
+        {
+            bail!("Pattern is not a valid Rust expression, type, item, path or pattern");
+        }
+        Ok(res)
+    }
+}
+impl FromStr for SsrTemplate {
+    type Err = SsrError;
+    fn from_str(pattern_str: &str) -> Result<SsrTemplate, SsrError> {
+        let tokens = parse_pattern(pattern_str)?;
+        // Validate that the template is a valid fragment of Rust code. We reuse the validation
+        // logic for search patterns since the only thing that differs is the error message.
+        if SsrPattern::from_str(pattern_str).is_err() {
+            bail!("Replacement is not a valid Rust expression, type, item, path or pattern");
+        }
+        // Our actual template needs to preserve whitespace, so we can't reuse `tokens`.
+        Ok(SsrTemplate { tokens })
+    }
+}
+/// Returns `pattern_str`, parsed as a search or replace pattern. If `remove_whitespace` is true,
+/// then any whitespace tokens will be removed, which we do for the search pattern, but not for the
+/// replace pattern.
+fn parse_pattern(pattern_str: &str) -> Result<Vec<PatternElement>, SsrError> {
+    let mut res = Vec::new();
+    let mut placeholder_names = FxHashSet::default();
+    let mut tokens = tokenize(pattern_str)?.into_iter();
+    while let Some(token) = tokens.next() {
+        if token.kind == SyntaxKind::DOLLAR {
+            let placeholder = parse_placeholder(&mut tokens)?;
+            if !placeholder_names.insert(placeholder.ident.clone()) {
+                bail!("Name `{}` repeats more than once", placeholder.ident);
+            }
+            res.push(PatternElement::Placeholder(placeholder));
+        } else {
+            res.push(PatternElement::Token(token));
+        }
+    }
+    Ok(res)
+}
+/// Checks for errors in a rule. e.g. the replace pattern referencing placeholders that the search
+/// pattern didn't define.
+fn validate_rule(rule: &SsrRule) -> Result<(), SsrError> {
+    let mut defined_placeholders = std::collections::HashSet::new();
+    for p in &rule.pattern.raw.tokens {
+        if let PatternElement::Placeholder(placeholder) = p {
+            defined_placeholders.insert(&placeholder.ident);
+        }
+    }
+    let mut undefined = Vec::new();
+    for p in &rule.template.tokens {
+        if let PatternElement::Placeholder(placeholder) = p {
+            if !defined_placeholders.contains(&placeholder.ident) {
+                undefined.push(format!("${}", placeholder.ident));
+            }
+        }
+    }
+    if !undefined.is_empty() {
+        bail!("Replacement contains undefined placeholders: {}", undefined.join(", "));
+    }
+    Ok(())
+}
+fn tokenize(source: &str) -> Result<Vec<Token>, SsrError> {
+    let mut start = 0;
+    let (raw_tokens, errors) = ra_syntax::tokenize(source);
+    if let Some(first_error) = errors.first() {
+        bail!("Failed to parse pattern: {}", first_error);
+    }
+    let mut tokens: Vec<Token> = Vec::new();
+    for raw_token in raw_tokens {
+        let token_len = usize::from(raw_token.len);
+        tokens.push(Token {
+            kind: raw_token.kind,
+            text: SmolStr::new(&source[start..start + token_len]),
+        });
+        start += token_len;
+    }
+    Ok(tokens)
+}
+fn parse_placeholder(tokens: &mut std::vec::IntoIter<Token>) -> Result<Placeholder, SsrError> {
+    let mut name = None;
+    if let Some(token) = tokens.next() {
+        match token.kind {
+            SyntaxKind::IDENT => {
+                name = Some(token.text);
+            }
+            _ => {
+                bail!("Placeholders should be $name");
+            }
+        }
+    }
+    let name = name.ok_or_else(|| SsrError::new("Placeholder ($) with no name"))?;
+    Ok(Placeholder::new(name))
+}
+impl Placeholder {
+    fn new(name: SmolStr) -> Self {
+        Self { stand_in_name: format!("__placeholder_{}", name), ident: name }
+    }
+}
+impl SsrError {
+    fn new(message: impl Into<String>) -> SsrError {
+        SsrError(message.into())
+    }
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn parser_happy_case() {
+        fn token(kind: SyntaxKind, text: &str) -> PatternElement {
+            PatternElement::Token(Token { kind, text: SmolStr::new(text) })
+        }
+        fn placeholder(name: &str) -> PatternElement {
+            PatternElement::Placeholder(Placeholder::new(SmolStr::new(name)))
+        }
+        let result: SsrRule = "foo($a, $b) ==>> bar($b, $a)".parse().unwrap();
+        assert_eq!(
+            result.pattern.raw.tokens,
+            vec![
+                token(SyntaxKind::IDENT, "foo"),
+                token(SyntaxKind::L_PAREN, "("),
+                placeholder("a"),
+                token(SyntaxKind::COMMA, ","),
+                token(SyntaxKind::WHITESPACE, " "),
+                placeholder("b"),
+                token(SyntaxKind::R_PAREN, ")"),
+            ]
+        );
+        assert_eq!(
+            result.template.tokens,
+            vec![
+                token(SyntaxKind::IDENT, "bar"),
+                token(SyntaxKind::L_PAREN, "("),
+                placeholder("b"),
+                token(SyntaxKind::COMMA, ","),
+                token(SyntaxKind::WHITESPACE, " "),
+                placeholder("a"),
+                token(SyntaxKind::R_PAREN, ")"),
+            ]
+        );
+    }
+}
diff --git a/crates/ra_ssr/src/replacing.rs b/crates/ra_ssr/src/replacing.rs
new file mode 100644
index 000000000..81a5e06a9
--- /dev/null
+++ b/crates/ra_ssr/src/replacing.rs
@@ -0,0 +1,55 @@
+//! Code for applying replacement templates for matches that have previously been found.
+use crate::matching::Var;
+use crate::parsing::PatternElement;
+use crate::{Match, SsrMatches};
+use ra_syntax::ast::AstToken;
+use ra_syntax::TextSize;
+use ra_text_edit::TextEdit;
+/// Returns a text edit that will replace each match in `matches` with its corresponding replacement
+/// template. Placeholders in the template will have been substituted with whatever they matched to
+/// in the original code.
+pub(crate) fn matches_to_edit(matches: &SsrMatches) -> TextEdit {
+    matches_to_edit_at_offset(matches, 0.into())
+}
+fn matches_to_edit_at_offset(matches: &SsrMatches, relative_start: TextSize) -> TextEdit {
+    let mut edit_builder = ra_text_edit::TextEditBuilder::default();
+    for m in &matches.matches {
+        edit_builder.replace(m.range.checked_sub(relative_start).unwrap(), render_replace(m));
+    }
+    edit_builder.finish()
+}
+fn render_replace(match_info: &Match) -> String {
+    let mut out = String::new();
+    for r in &match_info.template.tokens {
+        match r {
+            PatternElement::Token(t) => out.push_str(t.text.as_str()),
+            PatternElement::Placeholder(p) => {
+                if let Some(placeholder_value) =
+                    match_info.placeholder_values.get(&Var(p.ident.to_string()))
+                {
+                    let range = &placeholder_value.range.range;
+                    let mut matched_text = placeholder_value.node.text().to_string();
+                    let edit =
+                        matches_to_edit_at_offset(&placeholder_value.inner_matches, range.start());
+                    edit.apply(&mut matched_text);
+                    out.push_str(&matched_text);
+                } else {
+                    // We validated that all placeholder references were valid before we
+                    // started, so this shouldn't happen.
+                    panic!(
+                        "Internal error: replacement referenced unknown placeholder {}",
+                        p.ident
+                    );
+                }
+            }
+        }
+    }
+    for comment in &match_info.ignored_comments {
+        out.push_str(&comment.syntax().to_string());
+    }
+    out
+}
diff --git a/crates/ra_ssr/src/tests.rs b/crates/ra_ssr/src/tests.rs
new file mode 100644
index 000000000..4b747fe18
--- /dev/null
+++ b/crates/ra_ssr/src/tests.rs
@@ -0,0 +1,496 @@
+use crate::matching::MatchFailureReason;
+use crate::{matching, Match, MatchFinder, SsrMatches, SsrPattern, SsrRule};
+use matching::record_match_fails_reasons_scope;
+use ra_db::{FileId, FileRange, SourceDatabaseExt};
+use ra_syntax::ast::AstNode;
+use ra_syntax::{ast, SyntaxKind, SyntaxNode, TextRange};
+struct MatchDebugInfo {
+    node: SyntaxNode,
+    /// Our search pattern parsed as the same kind of syntax node as `node`. e.g. expression, item,
+    /// etc. Will be absent if the pattern can't be parsed as that kind.
+    pattern: Result<SyntaxNode, MatchFailureReason>,
+    matched: Result<Match, MatchFailureReason>,
+}
+impl SsrPattern {
+    pub(crate) fn tree_for_kind_with_reason(
+        &self,
+        kind: SyntaxKind,
+    ) -> Result<&SyntaxNode, MatchFailureReason> {
+        record_match_fails_reasons_scope(true, || self.tree_for_kind(kind))
+            .map_err(|e| MatchFailureReason { reason: e.reason.unwrap() })
+    }
+}
+impl std::fmt::Debug for MatchDebugInfo {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "========= PATTERN ==========\n")?;
+        match &self.pattern {
+            Ok(pattern) => {
+                write!(f, "{:#?}", pattern)?;
+            }
+            Err(err) => {
+                write!(f, "{}", err.reason)?;
+            }
+        }
+        write!(
+            f,
+            "\n============ AST ===========\n\
+            {:#?}\n============================",
+            self.node
+        )?;
+        match &self.matched {
+            Ok(_) => write!(f, "Node matched")?,
+            Err(reason) => write!(f, "Node failed to match because: {}", reason.reason)?,
+        }
+        Ok(())
+    }
+}
+impl SsrMatches {
+    /// Returns `self` with any nested matches removed and made into top-level matches.
+    pub(crate) fn flattened(self) -> SsrMatches {
+        let mut out = SsrMatches::default();
+        self.flatten_into(&mut out);
+        out
+    }
+    fn flatten_into(self, out: &mut SsrMatches) {
+        for mut m in self.matches {
+            for p in m.placeholder_values.values_mut() {
+                std::mem::replace(&mut p.inner_matches, SsrMatches::default()).flatten_into(out);
+            }
+            out.matches.push(m);
+        }
+    }
+}
+impl Match {
+    pub(crate) fn matched_text(&self) -> String {
+        self.matched_node.text().to_string()
+    }
+}
+impl<'db> MatchFinder<'db> {
+    /// Adds a search pattern. For use if you intend to only call `find_matches_in_file`. If you
+    /// intend to do replacement, use `add_rule` instead.
+    fn add_search_pattern(&mut self, pattern: SsrPattern) {
+        self.add_rule(SsrRule { pattern, template: "()".parse().unwrap() })
+    }
+    /// Finds all nodes in `file_id` whose text is exactly equal to `snippet` and attempts to match
+    /// them, while recording reasons why they don't match. This API is useful for command
+    /// line-based debugging where providing a range is difficult.
+    fn debug_where_text_equal(&self, file_id: FileId, snippet: &str) -> Vec<MatchDebugInfo> {
+        let file = self.sema.parse(file_id);
+        let mut res = Vec::new();
+        let file_text = self.sema.db.file_text(file_id);
+        let mut remaining_text = file_text.as_str();
+        let mut base = 0;
+        let len = snippet.len() as u32;
+        while let Some(offset) = remaining_text.find(snippet) {
+            let start = base + offset as u32;
+            let end = start + len;
+            self.output_debug_for_nodes_at_range(
+                file.syntax(),
+                TextRange::new(start.into(), end.into()),
+                &None,
+                &mut res,
+            );
+            remaining_text = &remaining_text[offset + snippet.len()..];
+            base = end;
+        }
+        res
+    }
+    fn output_debug_for_nodes_at_range(
+        &self,
+        node: &SyntaxNode,
+        range: TextRange,
+        restrict_range: &Option<FileRange>,
+        out: &mut Vec<MatchDebugInfo>,
+    ) {
+        for node in node.children() {
+            if !node.text_range().contains_range(range) {
+                continue;
+            }
+            if node.text_range() == range {
+                for rule in &self.rules {
+                    let pattern =
+                        rule.pattern.tree_for_kind_with_reason(node.kind()).map(|p| p.clone());
+                    out.push(MatchDebugInfo {
+                        matched: matching::get_match(true, rule, &node, restrict_range, &self.sema)
+                            .map_err(|e| MatchFailureReason {
+                                reason: e.reason.unwrap_or_else(|| {
+                                    "Match failed, but no reason was given".to_owned()
+                                }),
+                            }),
+                        pattern,
+                        node: node.clone(),
+                    });
+                }
+            } else if let Some(macro_call) = ast::MacroCall::cast(node.clone()) {
+                if let Some(expanded) = self.sema.expand(&macro_call) {
+                    if let Some(tt) = macro_call.token_tree() {
+                        self.output_debug_for_nodes_at_range(
+                            &expanded,
+                            range,
+                            &Some(self.sema.original_range(tt.syntax())),
+                            out,
+                        );
+                    }
+                }
+            }
+        }
+    }
+}
+fn parse_error_text(query: &str) -> String {
+    format!("{}", query.parse::<SsrRule>().unwrap_err())
+}
+#[test]
+fn parser_empty_query() {
+    assert_eq!(parse_error_text(""), "Parse error: Cannot find delemiter `==>>`");
+}
+#[test]
+fn parser_no_delimiter() {
+    assert_eq!(parse_error_text("foo()"), "Parse error: Cannot find delemiter `==>>`");
+}
+#[test]
+fn parser_two_delimiters() {
+    assert_eq!(
+        parse_error_text("foo() ==>> a ==>> b "),
+        "Parse error: More than one delimiter found"
+    );
+}
+#[test]
+fn parser_repeated_name() {
+    assert_eq!(
+        parse_error_text("foo($a, $a) ==>>"),
+        "Parse error: Name `a` repeats more than once"
+    );
+}
+#[test]
+fn parser_invalid_pattern() {
+    assert_eq!(
+        parse_error_text(" ==>> ()"),
+        "Parse error: Pattern is not a valid Rust expression, type, item, path or pattern"
+    );
+}
+#[test]
+fn parser_invalid_template() {
+    assert_eq!(
+        parse_error_text("() ==>> )"),
+        "Parse error: Replacement is not a valid Rust expression, type, item, path or pattern"
+    );
+}
+#[test]
+fn parser_undefined_placeholder_in_replacement() {
+    assert_eq!(
+        parse_error_text("42 ==>> $a"),
+        "Parse error: Replacement contains undefined placeholders: $a"
+    );
+}
+fn single_file(code: &str) -> (ra_ide_db::RootDatabase, FileId) {
+    use ra_db::fixture::WithFixture;
+    ra_ide_db::RootDatabase::with_single_file(code)
+}
+fn assert_ssr_transform(rule: &str, input: &str, result: &str) {
+    assert_ssr_transforms(&[rule], input, result);
+}
+fn assert_ssr_transforms(rules: &[&str], input: &str, result: &str) {
+    let (db, file_id) = single_file(input);
+    let mut match_finder = MatchFinder::new(&db);
+    for rule in rules {
+        let rule: SsrRule = rule.parse().unwrap();
+        match_finder.add_rule(rule);
+    }
+    if let Some(edits) = match_finder.edits_for_file(file_id) {
+        let mut after = input.to_string();
+        edits.apply(&mut after);
+        assert_eq!(after, result);
+    } else {
+        panic!("No edits were made");
+    }
+}
+fn assert_matches(pattern: &str, code: &str, expected: &[&str]) {
+    let (db, file_id) = single_file(code);
+    let mut match_finder = MatchFinder::new(&db);
+    match_finder.add_search_pattern(pattern.parse().unwrap());
+    let matched_strings: Vec<String> = match_finder
+        .find_matches_in_file(file_id)
+        .flattened()
+        .matches
+        .iter()
+        .map(|m| m.matched_text())
+        .collect();
+    if matched_strings != expected && !expected.is_empty() {
+        let debug_info = match_finder.debug_where_text_equal(file_id, &expected[0]);
+        eprintln!("Test is about to fail. Some possibly useful info: {} nodes had text exactly equal to '{}'", debug_info.len(), &expected[0]);
+        for d in debug_info {
+            eprintln!("{:#?}", d);
+        }
+    }
+    assert_eq!(matched_strings, expected);
+}
+fn assert_no_match(pattern: &str, code: &str) {
+    assert_matches(pattern, code, &[]);
+}
+#[test]
+fn ssr_function_to_method() {
+    assert_ssr_transform(
+        "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) }",
+    )
+}
+#[test]
+fn ssr_nested_function() {
+    assert_ssr_transform(
+        "foo($a, $b, $c) ==>> bar($c, baz($a, $b))",
+        "fn main { foo  (x + value.method(b), x+y-z, true && false) }",
+        "fn main { bar(true && false, baz(x + value.method(b), x+y-z)) }",
+    )
+}
+#[test]
+fn ssr_expected_spacing() {
+    assert_ssr_transform(
+        "foo($x) + bar() ==>> bar($x)",
+        "fn main() { foo(5) + bar() }",
+        "fn main() { bar(5) }",
+    );
+}
+#[test]
+fn ssr_with_extra_space() {
+    assert_ssr_transform(
+        "foo($x  ) +    bar() ==>> bar($x)",
+        "fn main() { foo(  5 )  +bar(   ) }",
+        "fn main() { bar(5) }",
+    );
+}
+#[test]
+fn ssr_keeps_nested_comment() {
+    assert_ssr_transform(
+        "foo($x) ==>> bar($x)",
+        "fn main() { foo(other(5 /* using 5 */)) }",
+        "fn main() { bar(other(5 /* using 5 */)) }",
+    )
+}
+#[test]
+fn ssr_keeps_comment() {
+    assert_ssr_transform(
+        "foo($x) ==>> bar($x)",
+        "fn main() { foo(5 /* using 5 */) }",
+        "fn main() { bar(5)/* using 5 */ }",
+    )
+}
+#[test]
+fn ssr_struct_lit() {
+    assert_ssr_transform(
+        "foo{a: $a, b: $b} ==>> foo::new($a, $b)",
+        "fn main() { foo{b:2, a:1} }",
+        "fn main() { foo::new(1, 2) }",
+    )
+}
+#[test]
+fn ignores_whitespace() {
+    assert_matches("1+2", "fn f() -> i32 {1  +  2}", &["1  +  2"]);
+    assert_matches("1 + 2", "fn f() -> i32 {1+2}", &["1+2"]);
+}
+#[test]
+fn no_match() {
+    assert_no_match("1 + 3", "fn f() -> i32 {1  +  2}");
+}
+#[test]
+fn match_fn_definition() {
+    assert_matches("fn $a($b: $t) {$c}", "fn f(a: i32) {bar()}", &["fn f(a: i32) {bar()}"]);
+}
+#[test]
+fn match_struct_definition() {
+    assert_matches(
+        "struct $n {$f: Option<String>}",
+        "struct Bar {} struct Foo {name: Option<String>}",
+        &["struct Foo {name: Option<String>}"],
+    );
+}
+#[test]
+fn match_expr() {
+    let code = "fn f() -> i32 {foo(40 + 2, 42)}";
+    assert_matches("foo($a, $b)", code, &["foo(40 + 2, 42)"]);
+    assert_no_match("foo($a, $b, $c)", code);
+    assert_no_match("foo($a)", code);
+}
+#[test]
+fn match_nested_method_calls() {
+    assert_matches(
+        "$a.z().z().z()",
+        "fn f() {h().i().j().z().z().z().d().e()}",
+        &["h().i().j().z().z().z()"],
+    );
+}
+#[test]
+fn match_complex_expr() {
+    let code = "fn f() -> i32 {foo(bar(40, 2), 42)}";
+    assert_matches("foo($a, $b)", code, &["foo(bar(40, 2), 42)"]);
+    assert_no_match("foo($a, $b, $c)", code);
+    assert_no_match("foo($a)", code);
+    assert_matches("bar($a, $b)", code, &["bar(40, 2)"]);
+}
+// Trailing commas in the code should be ignored.
+#[test]
+fn match_with_trailing_commas() {
+    // Code has comma, pattern doesn't.
+    assert_matches("foo($a, $b)", "fn f() {foo(1, 2,);}", &["foo(1, 2,)"]);
+    assert_matches("Foo{$a, $b}", "fn f() {Foo{1, 2,};}", &["Foo{1, 2,}"]);
+    // Pattern has comma, code doesn't.
+    assert_matches("foo($a, $b,)", "fn f() {foo(1, 2);}", &["foo(1, 2)"]);
+    assert_matches("Foo{$a, $b,}", "fn f() {Foo{1, 2};}", &["Foo{1, 2}"]);
+}
+#[test]
+fn match_type() {
+    assert_matches("i32", "fn f() -> i32 {1  +  2}", &["i32"]);
+    assert_matches("Option<$a>", "fn f() -> Option<i32> {42}", &["Option<i32>"]);
+    assert_no_match("Option<$a>", "fn f() -> Result<i32, ()> {42}");
+}
+#[test]
+fn match_struct_instantiation() {
+    assert_matches(
+        "Foo {bar: 1, baz: 2}",
+        "fn f() {Foo {bar: 1, baz: 2}}",
+        &["Foo {bar: 1, baz: 2}"],
+    );
+    // Now with placeholders for all parts of the struct.
+    assert_matches(
+        "Foo {$a: $b, $c: $d}",
+        "fn f() {Foo {bar: 1, baz: 2}}",
+        &["Foo {bar: 1, baz: 2}"],
+    );
+    assert_matches("Foo {}", "fn f() {Foo {}}", &["Foo {}"]);
+}
+#[test]
+fn match_path() {
+    assert_matches("foo::bar", "fn f() {foo::bar(42)}", &["foo::bar"]);
+    assert_matches("$a::bar", "fn f() {foo::bar(42)}", &["foo::bar"]);
+    assert_matches("foo::$b", "fn f() {foo::bar(42)}", &["foo::bar"]);
+}
+#[test]
+fn match_pattern() {
+    assert_matches("Some($a)", "fn f() {if let Some(x) = foo() {}}", &["Some(x)"]);
+}
+#[test]
+fn match_reordered_struct_instantiation() {
+    assert_matches(
+        "Foo {aa: 1, b: 2, ccc: 3}",
+        "fn f() {Foo {b: 2, ccc: 3, aa: 1}}",
+        &["Foo {b: 2, ccc: 3, aa: 1}"],
+    );
+    assert_no_match("Foo {a: 1}", "fn f() {Foo {b: 1}}");
+    assert_no_match("Foo {a: 1}", "fn f() {Foo {a: 2}}");
+    assert_no_match("Foo {a: 1, b: 2}", "fn f() {Foo {a: 1}}");
+    assert_no_match("Foo {a: 1, b: 2}", "fn f() {Foo {b: 2}}");
+    assert_no_match("Foo {a: 1, }", "fn f() {Foo {a: 1, b: 2}}");
+    assert_no_match("Foo {a: 1, z: 9}", "fn f() {Foo {a: 1}}");
+}
+#[test]
+fn replace_function_call() {
+    assert_ssr_transform("foo() ==>> bar()", "fn f1() {foo(); foo();}", "fn f1() {bar(); bar();}");
+}
+#[test]
+fn replace_function_call_with_placeholders() {
+    assert_ssr_transform(
+        "foo($a, $b) ==>> bar($b, $a)",
+        "fn f1() {foo(5, 42)}",
+        "fn f1() {bar(42, 5)}",
+    );
+}
+#[test]
+fn replace_nested_function_calls() {
+    assert_ssr_transform(
+        "foo($a) ==>> bar($a)",
+        "fn f1() {foo(foo(42))}",
+        "fn f1() {bar(bar(42))}",
+    );
+}
+#[test]
+fn replace_type() {
+    assert_ssr_transform(
+        "Result<(), $a> ==>> Option<$a>",
+        "fn f1() -> Result<(), Vec<Error>> {foo()}",
+        "fn f1() -> Option<Vec<Error>> {foo()}",
+    );
+}
+#[test]
+fn replace_struct_init() {
+    assert_ssr_transform(
+        "Foo {a: $a, b: $b} ==>> Foo::new($a, $b)",
+        "fn f1() {Foo{b: 1, a: 2}}",
+        "fn f1() {Foo::new(2, 1)}",
+    );
+}
+#[test]
+fn replace_binary_op() {
+    assert_ssr_transform(
+        "$a + $b ==>> $b + $a",
+        "fn f() {2 * 3 + 4 * 5}",
+        "fn f() {4 * 5 + 2 * 3}",
+    );
+    assert_ssr_transform(
+        "$a + $b ==>> $b + $a",
+        "fn f() {1 + 2 + 3 + 4}",
+        "fn f() {4 + 3 + 2 + 1}",
+    );
+}
+#[test]
+fn match_binary_op() {
+    assert_matches("$a + $b", "fn f() {1 + 2 + 3 + 4}", &["1 + 2", "1 + 2 + 3", "1 + 2 + 3 + 4"]);
+}
+#[test]
+fn multiple_rules() {
+    assert_ssr_transforms(
+        &["$a + 1 ==>> add_one($a)", "$a + $b ==>> add($a, $b)"],
+        "fn f() -> i32 {3 + 2 + 1}",
+        "fn f() -> i32 {add_one(add(3, 2))}",
+    )
+}
diff --git a/crates/ra_syntax/src/algo.rs b/crates/ra_syntax/src/algo.rs
index 664894d1f..f7a885eb3 100644
--- a/crates/ra_syntax/src/algo.rs
+++ b/crates/ra_syntax/src/algo.rs
@@ -290,6 +290,11 @@ impl<'a> SyntaxRewriter<'a> {
        N::cast(self.rewrite(node.syntax())).unwrap()
    }
+    /// Returns a node that encompasses all replacements to be done by this rewriter.
+    ///
+    /// Passing the returned node to `rewrite` will apply all replacements queued up in `self`.
+    ///
+    /// Returns `None` when there are no replacements.
    pub fn rewrite_root(&self) -> Option<SyntaxNode> {
        assert!(self.f.is_none());
        self.replacements
@@ -298,6 +303,9 @@ impl<'a> SyntaxRewriter<'a> {
                SyntaxElement::Node(it) => it.clone(),
                SyntaxElement::Token(it) => it.parent(),
            })
+            // If we only have one replacement, we must return its parent node, since `rewrite` does
+            // not replace the node passed to it.
+            .map(|it| it.parent().unwrap_or(it))
            .fold1(|a, b| least_common_ancestor(&a, &b).unwrap())
    }
diff --git a/crates/ra_syntax/src/ast/make.rs b/crates/ra_syntax/src/ast/make.rs
index da0eb0926..192c610f1 100644
--- a/crates/ra_syntax/src/ast/make.rs
+++ b/crates/ra_syntax/src/ast/make.rs
@@ -75,6 +75,10 @@ pub fn record_field(name: ast::NameRef, expr: Option<ast::Expr>) -> ast::RecordF
    }
 }
+pub fn record_field_def(name: ast::NameRef, ty: ast::TypeRef) -> ast::RecordFieldDef {
+    ast_from_text(&format!("struct S {{ {}: {}, }}", name, ty))
+}
 pub fn block_expr(
    stmts: impl IntoIterator<Item = ast::Stmt>,
    tail_expr: Option<ast::Expr>,
diff --git a/crates/ra_syntax/src/lib.rs b/crates/ra_syntax/src/lib.rs
index a33a35cc1..9b7664576 100644
--- a/crates/ra_syntax/src/lib.rs
+++ b/crates/ra_syntax/src/lib.rs
@@ -168,6 +168,41 @@ impl SourceFile {
    }
 }
+impl ast::Path {
+    /// Returns `text`, parsed as a path, but only if it has no errors.
+    pub fn parse(text: &str) -> Result<Self, ()> {
+        parsing::parse_text_fragment(text, ra_parser::FragmentKind::Path)
+    }
+}
+impl ast::Pat {
+    /// Returns `text`, parsed as a pattern, but only if it has no errors.
+    pub fn parse(text: &str) -> Result<Self, ()> {
+        parsing::parse_text_fragment(text, ra_parser::FragmentKind::Pattern)
+    }
+}
+impl ast::Expr {
+    /// Returns `text`, parsed as an expression, but only if it has no errors.
+    pub fn parse(text: &str) -> Result<Self, ()> {
+        parsing::parse_text_fragment(text, ra_parser::FragmentKind::Expr)
+    }
+}
+impl ast::ModuleItem {
+    /// Returns `text`, parsed as an item, but only if it has no errors.
+    pub fn parse(text: &str) -> Result<Self, ()> {
+        parsing::parse_text_fragment(text, ra_parser::FragmentKind::Item)
+    }
+}
+impl ast::TypeRef {
+    /// Returns `text`, parsed as an type reference, but only if it has no errors.
+    pub fn parse(text: &str) -> Result<Self, ()> {
+        parsing::parse_text_fragment(text, ra_parser::FragmentKind::Type)
+    }
+}
 /// Matches a `SyntaxNode` against an `ast` type.
 ///
 /// # Example:
diff --git a/crates/ra_syntax/src/parsing.rs b/crates/ra_syntax/src/parsing.rs
index e5eb80850..0ed3c20ef 100644
--- a/crates/ra_syntax/src/parsing.rs
+++ b/crates/ra_syntax/src/parsing.rs
@@ -6,13 +6,14 @@ mod text_token_source;
 mod text_tree_sink;
 mod reparsing;
-use crate::{syntax_node::GreenNode, SyntaxError};
+use crate::{syntax_node::GreenNode, AstNode, SyntaxError, SyntaxNode};
 use text_token_source::TextTokenSource;
 use text_tree_sink::TextTreeSink;
 pub use lexer::*;
 pub(crate) use self::reparsing::incremental_reparse;
+use ra_parser::SyntaxKind;
 pub(crate) fn parse_text(text: &str) -> (GreenNode, Vec<SyntaxError>) {
    let (tokens, lexer_errors) = tokenize(&text);
@@ -27,3 +28,32 @@ pub(crate) fn parse_text(text: &str) -> (GreenNode, Vec<SyntaxError>) {
    (tree, parser_errors)
 }
+/// Returns `text` parsed as a `T` provided there are no parse errors.
+pub(crate) fn parse_text_fragment<T: AstNode>(
+    text: &str,
+    fragment_kind: ra_parser::FragmentKind,
+) -> Result<T, ()> {
+    let (tokens, lexer_errors) = tokenize(&text);
+    if !lexer_errors.is_empty() {
+        return Err(());
+    }
+    let mut token_source = TextTokenSource::new(text, &tokens);
+    let mut tree_sink = TextTreeSink::new(text, &tokens);
+    // TextTreeSink assumes that there's at least some root node to which it can attach errors and
+    // tokens. We arbitrarily give it a SourceFile.
+    use ra_parser::TreeSink;
+    tree_sink.start_node(SyntaxKind::SOURCE_FILE);
+    ra_parser::parse_fragment(&mut token_source, &mut tree_sink, fragment_kind);
+    tree_sink.finish_node();
+    let (tree, parser_errors) = tree_sink.finish();
+    use ra_parser::TokenSource;
+    if !parser_errors.is_empty() || token_source.current().kind != SyntaxKind::EOF {
+        return Err(());
+    }
+    SyntaxNode::new_root(tree).first_child().and_then(T::cast).ok_or(())
+}
diff --git a/crates/ra_syntax/src/parsing/text_token_source.rs b/crates/ra_syntax/src/parsing/text_token_source.rs
index 7ddc2c2c3..97aa3e795 100644
--- a/crates/ra_syntax/src/parsing/text_token_source.rs
+++ b/crates/ra_syntax/src/parsing/text_token_source.rs
@@ -1,40 +1,35 @@
-//! FIXME: write short doc here
+//! See `TextTokenSource` docs.
-use ra_parser::Token as PToken;
 use ra_parser::TokenSource;
 use crate::{parsing::lexer::Token, SyntaxKind::EOF, TextRange, TextSize};
+/// Implementation of `ra_parser::TokenSource` that takes tokens from source code text.
 pub(crate) struct TextTokenSource<'t> {
    text: &'t str,
-    /// start position of each token(expect whitespace and comment)
+    /// token and its start position (non-whitespace/comment tokens)
    /// ```non-rust
    ///  struct Foo;
-    /// ^------^---
+    ///  ^------^--^-
-    /// |      |  ^-
+    ///  |      |    \________
-    /// 0      7  10
+    ///  |      \____         \
+    ///  |           \         |
+    ///  (struct, 0) (Foo, 7) (;, 10)
    /// ```
-    /// (token, start_offset): `[(struct, 0), (Foo, 7), (;, 10)]`
+    /// `[(struct, 0), (Foo, 7), (;, 10)]`
-    start_offsets: Vec<TextSize>,
+    token_offset_pairs: Vec<(Token, TextSize)>,
-    /// non-whitespace/comment tokens
-    /// ```non-rust
-    /// struct Foo {}
-    /// ^^^^^^ ^^^ ^^
-    /// ```
-    /// tokens: `[struct, Foo, {, }]`
-    tokens: Vec<Token>,
    /// Current token and position
-    curr: (PToken, usize),
+    curr: (ra_parser::Token, usize),
 }
 impl<'t> TokenSource for TextTokenSource<'t> {
-    fn current(&self) -> PToken {
+    fn current(&self) -> ra_parser::Token {
        self.curr.0
    }
-    fn lookahead_nth(&self, n: usize) -> PToken {
+    fn lookahead_nth(&self, n: usize) -> ra_parser::Token {
-        mk_token(self.curr.1 + n, &self.start_offsets, &self.tokens)
+        mk_token(self.curr.1 + n, &self.token_offset_pairs)
    }
    fn bump(&mut self) {
@@ -43,45 +38,47 @@ impl<'t> TokenSource for TextTokenSource<'t> {
        }
        let pos = self.curr.1 + 1;
-        self.curr = (mk_token(pos, &self.start_offsets, &self.tokens), pos);
+        self.curr = (mk_token(pos, &self.token_offset_pairs), pos);
    }
    fn is_keyword(&self, kw: &str) -> bool {
-        let pos = self.curr.1;
+        self.token_offset_pairs
-        if pos >= self.tokens.len() {
+            .get(self.curr.1)
-            return false;
+            .map(|(token, offset)| &self.text[TextRange::at(*offset, token.len)] == kw)
-        }
+            .unwrap_or(false)
-        let range = TextRange::at(self.start_offsets[pos], self.tokens[pos].len);
-        self.text[range] == *kw
    }
 }
-fn mk_token(pos: usize, start_offsets: &[TextSize], tokens: &[Token]) -> PToken {
+fn mk_token(pos: usize, token_offset_pairs: &[(Token, TextSize)]) -> ra_parser::Token {
-    let kind = tokens.get(pos).map(|t| t.kind).unwrap_or(EOF);
+    let (kind, is_jointed_to_next) = match token_offset_pairs.get(pos) {
-    let is_jointed_to_next = if pos + 1 < start_offsets.len() {
+        Some((token, offset)) => (
-        start_offsets[pos] + tokens[pos].len == start_offsets[pos + 1]
+            token.kind,
-    } else {
+            token_offset_pairs
-        false
+                .get(pos + 1)
+                .map(|(_, next_offset)| offset + token.len == *next_offset)
+                .unwrap_or(false),
+        ),
+        None => (EOF, false),
    };
+    ra_parser::Token { kind, is_jointed_to_next }
-    PToken { kind, is_jointed_to_next }
 }
 impl<'t> TextTokenSource<'t> {
    /// Generate input from tokens(expect comment and whitespace).
    pub fn new(text: &'t str, raw_tokens: &'t [Token]) -> TextTokenSource<'t> {
-        let mut tokens = Vec::new();
+        let token_offset_pairs: Vec<_> = raw_tokens
-        let mut start_offsets = Vec::new();
+            .iter()
-        let mut len = 0.into();
+            .filter_map({
-        for &token in raw_tokens.iter() {
+                let mut len = 0.into();
-            if !token.kind.is_trivia() {
+                move |token| {
-                tokens.push(token);
+                    let pair = if token.kind.is_trivia() { None } else { Some((*token, len)) };
-                start_offsets.push(len);
+                    len += token.len;
-            }
+                    pair
-            len += token.len;
+                }
-        }
+            })
+            .collect();
-        let first = mk_token(0, &start_offsets, &tokens);
+        let first = mk_token(0, &token_offset_pairs);
-        TextTokenSource { text, start_offsets, tokens, curr: (first, 0) }
+        TextTokenSource { text, token_offset_pairs, curr: (first, 0) }
    }
 }
diff --git a/crates/ra_syntax/src/tests.rs b/crates/ra_syntax/src/tests.rs
index aee57db62..959967b79 100644
--- a/crates/ra_syntax/src/tests.rs
+++ b/crates/ra_syntax/src/tests.rs
@@ -55,6 +55,51 @@ fn parser_tests() {
 }
 #[test]
+fn expr_parser_tests() {
+    fragment_parser_dir_test(
+        &["parser/fragments/expr/ok"],
+        &["parser/fragments/expr/err"],
+        crate::ast::Expr::parse,
+    );
+}
+#[test]
+fn path_parser_tests() {
+    fragment_parser_dir_test(
+        &["parser/fragments/path/ok"],
+        &["parser/fragments/path/err"],
+        crate::ast::Path::parse,
+    );
+}
+#[test]
+fn pattern_parser_tests() {
+    fragment_parser_dir_test(
+        &["parser/fragments/pattern/ok"],
+        &["parser/fragments/pattern/err"],
+        crate::ast::Pat::parse,
+    );
+}
+#[test]
+fn item_parser_tests() {
+    fragment_parser_dir_test(
+        &["parser/fragments/item/ok"],
+        &["parser/fragments/item/err"],
+        crate::ast::ModuleItem::parse,
+    );
+}
+#[test]
+fn type_parser_tests() {
+    fragment_parser_dir_test(
+        &["parser/fragments/type/ok"],
+        &["parser/fragments/type/err"],
+        crate::ast::TypeRef::parse,
+    );
+}
+#[test]
 fn parser_fuzz_tests() {
    for (_, text) in collect_rust_files(&test_data_dir(), &["parser/fuzz-failures"]) {
        fuzz::check_parser(&text)
@@ -134,3 +179,24 @@ fn dump_tokens_and_errors(tokens: &[Token], errors: &[SyntaxError], text: &str)
    }
    acc
 }
+fn fragment_parser_dir_test<T, F>(ok_paths: &[&str], err_paths: &[&str], f: F)
+where
+    T: crate::AstNode,
+    F: Fn(&str) -> Result<T, ()>,
+{
+    dir_tests(&test_data_dir(), ok_paths, "rast", |text, path| {
+        if let Ok(node) = f(text) {
+            format!("{:#?}", crate::ast::AstNode::syntax(&node))
+        } else {
+            panic!("Failed to parse '{:?}'", path);
+        }
+    });
+    dir_tests(&test_data_dir(), err_paths, "rast", |text, path| {
+        if let Ok(_) = f(text) {
+            panic!("'{:?}' successfully parsed when it should have errored", path);
+        } else {
+            "ERROR\n".to_owned()
+        }
+    });
+}
diff --git a/crates/ra_syntax/test_data/parser/fragments/expr/err/0000_truncated_add.rast b/crates/ra_syntax/test_data/parser/fragments/expr/err/0000_truncated_add.rast
new file mode 100644
index 000000000..5df7507e2
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/fragments/expr/err/0000_truncated_add.rast
@@ -0,0 +1 @@
+ERROR
diff --git a/crates/ra_syntax/test_data/parser/fragments/expr/err/0000_truncated_add.rs b/crates/ra_syntax/test_data/parser/fragments/expr/err/0000_truncated_add.rs
new file mode 100644
index 000000000..ca49acb07
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/fragments/expr/err/0000_truncated_add.rs
@@ -0,0 +1 @@
+1 +
diff --git a/crates/ra_syntax/test_data/parser/fragments/expr/ok/0000_add.rast b/crates/ra_syntax/test_data/parser/fragments/expr/ok/0000_add.rast
new file mode 100644
index 000000000..fa78a02a6
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/fragments/expr/ok/0000_add.rast
@@ -0,0 +1,8 @@
+[email protected]
+  [email protected]
+    [email protected] "1"
+  [email protected] " "
+  [email protected] "+"
+  [email protected] " "
+  [email protected]
+    [email protected] "2"
diff --git a/crates/ra_syntax/test_data/parser/fragments/expr/ok/0000_add.rs b/crates/ra_syntax/test_data/parser/fragments/expr/ok/0000_add.rs
new file mode 100644
index 000000000..e0ef58402
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/fragments/expr/ok/0000_add.rs
@@ -0,0 +1 @@
+1 + 2
diff --git a/crates/ra_syntax/test_data/parser/fragments/item/err/0000_extra_keyword.rast b/crates/ra_syntax/test_data/parser/fragments/item/err/0000_extra_keyword.rast
new file mode 100644
index 000000000..5df7507e2
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/fragments/item/err/0000_extra_keyword.rast
@@ -0,0 +1 @@
+ERROR
diff --git a/crates/ra_syntax/test_data/parser/fragments/item/err/0000_extra_keyword.rs b/crates/ra_syntax/test_data/parser/fragments/item/err/0000_extra_keyword.rs
new file mode 100644
index 000000000..dc32389bb
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/fragments/item/err/0000_extra_keyword.rs
@@ -0,0 +1 @@
+fn fn foo() {}
diff --git a/crates/ra_syntax/test_data/parser/fragments/item/ok/0000_fn.rast b/crates/ra_syntax/test_data/parser/fragments/item/ok/0000_fn.rast
new file mode 100644
index 000000000..f1e78f388
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/fragments/item/ok/0000_fn.rast
@@ -0,0 +1,12 @@
+[email protected]
+  [email protected] "fn"
+  [email protected] " "
+  [email protected]
+    [email protected] "foo"
+  [email protected]
+    [email protected] "("
+    [email protected] ")"
+  [email protected] " "
+  [email protected]
+    [email protected] "{"
+    [email protected] "}"
diff --git a/crates/ra_syntax/test_data/parser/fragments/item/ok/0000_fn.rs b/crates/ra_syntax/test_data/parser/fragments/item/ok/0000_fn.rs
new file mode 100644
index 000000000..8f3b7ef11
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/fragments/item/ok/0000_fn.rs
@@ -0,0 +1 @@
+fn foo() {}
diff --git a/crates/ra_syntax/test_data/parser/fragments/path/err/0000_reserved_word.rast b/crates/ra_syntax/test_data/parser/fragments/path/err/0000_reserved_word.rast
new file mode 100644
index 000000000..5df7507e2
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/fragments/path/err/0000_reserved_word.rast
@@ -0,0 +1 @@
+ERROR
diff --git a/crates/ra_syntax/test_data/parser/fragments/path/err/0000_reserved_word.rs b/crates/ra_syntax/test_data/parser/fragments/path/err/0000_reserved_word.rs
new file mode 100644
index 000000000..2046de049
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/fragments/path/err/0000_reserved_word.rs
@@ -0,0 +1 @@
+struct
diff --git a/crates/ra_syntax/test_data/parser/fragments/path/err/0001_expression.rast b/crates/ra_syntax/test_data/parser/fragments/path/err/0001_expression.rast
new file mode 100644
index 000000000..5df7507e2
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/fragments/path/err/0001_expression.rast
@@ -0,0 +1 @@
+ERROR
diff --git a/crates/ra_syntax/test_data/parser/fragments/path/err/0001_expression.rs b/crates/ra_syntax/test_data/parser/fragments/path/err/0001_expression.rs
new file mode 100644
index 000000000..745e8d376
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/fragments/path/err/0001_expression.rs
@@ -0,0 +1 @@
+a + b
diff --git a/crates/ra_syntax/test_data/parser/fragments/path/ok/0000_single_ident.rast b/crates/ra_syntax/test_data/parser/fragments/path/ok/0000_single_ident.rast
new file mode 100644
index 000000000..0c5d4360f
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/fragments/path/ok/0000_single_ident.rast
@@ -0,0 +1,4 @@
+[email protected]
+  [email protected]
+    [email protected]
+      [email protected] "foo"
diff --git a/crates/ra_syntax/test_data/parser/fragments/path/ok/0000_single_ident.rs b/crates/ra_syntax/test_data/parser/fragments/path/ok/0000_single_ident.rs
new file mode 100644
index 000000000..257cc5642
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/fragments/path/ok/0000_single_ident.rs
@@ -0,0 +1 @@
+foo
diff --git a/crates/ra_syntax/test_data/parser/fragments/path/ok/0001_multipart.rast b/crates/ra_syntax/test_data/parser/fragments/path/ok/0001_multipart.rast
new file mode 100644
index 000000000..4a2b45e6a
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/fragments/path/ok/0001_multipart.rast
@@ -0,0 +1,14 @@
+[email protected]
+  [email protected]
+    [email protected]
+      [email protected]
+        [email protected]
+          [email protected] "foo"
+    [email protected] "::"
+    [email protected]
+      [email protected]
+        [email protected] "bar"
+  [email protected] "::"
+  [email protected]
+    [email protected]
+      [email protected] "baz"
diff --git a/crates/ra_syntax/test_data/parser/fragments/path/ok/0001_multipart.rs b/crates/ra_syntax/test_data/parser/fragments/path/ok/0001_multipart.rs
new file mode 100644
index 000000000..81e0b21cd
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/fragments/path/ok/0001_multipart.rs
@@ -0,0 +1 @@
+foo::bar::baz
diff --git a/crates/ra_syntax/test_data/parser/fragments/pattern/err/0000_reserved_word.rast b/crates/ra_syntax/test_data/parser/fragments/pattern/err/0000_reserved_word.rast
new file mode 100644
index 000000000..5df7507e2
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/fragments/pattern/err/0000_reserved_word.rast
@@ -0,0 +1 @@
+ERROR
diff --git a/crates/ra_syntax/test_data/parser/fragments/pattern/err/0000_reserved_word.rs b/crates/ra_syntax/test_data/parser/fragments/pattern/err/0000_reserved_word.rs
new file mode 100644
index 000000000..ae26fc455
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/fragments/pattern/err/0000_reserved_word.rs
@@ -0,0 +1 @@
+fn
diff --git a/crates/ra_syntax/test_data/parser/fragments/pattern/err/0001_missing_paren.rast b/crates/ra_syntax/test_data/parser/fragments/pattern/err/0001_missing_paren.rast
new file mode 100644
index 000000000..5df7507e2
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/fragments/pattern/err/0001_missing_paren.rast
@@ -0,0 +1 @@
+ERROR
diff --git a/crates/ra_syntax/test_data/parser/fragments/pattern/err/0001_missing_paren.rs b/crates/ra_syntax/test_data/parser/fragments/pattern/err/0001_missing_paren.rs
new file mode 100644
index 000000000..61a391d08
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/fragments/pattern/err/0001_missing_paren.rs
@@ -0,0 +1 @@
+Some(x
diff --git a/crates/ra_syntax/test_data/parser/fragments/pattern/ok/0000_enum.rast b/crates/ra_syntax/test_data/parser/fragments/pattern/ok/0000_enum.rast
new file mode 100644
index 000000000..15eb7f9c6
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/fragments/pattern/ok/0000_enum.rast
@@ -0,0 +1,10 @@
+[email protected]
+  [email protected]
+    [email protected]
+      [email protected]
+        [email protected] "Some"
+  [email protected] "("
+  [email protected]
+    [email protected]
+      [email protected] "x"
+  [email protected] ")"
diff --git a/crates/ra_syntax/test_data/parser/fragments/pattern/ok/0000_enum.rs b/crates/ra_syntax/test_data/parser/fragments/pattern/ok/0000_enum.rs
new file mode 100644
index 000000000..87114dd78
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/fragments/pattern/ok/0000_enum.rs
@@ -0,0 +1 @@
+Some(x)
diff --git a/crates/ra_syntax/test_data/parser/fragments/type/err/0000_missing_close.rast b/crates/ra_syntax/test_data/parser/fragments/type/err/0000_missing_close.rast
new file mode 100644
index 000000000..5df7507e2
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/fragments/type/err/0000_missing_close.rast
@@ -0,0 +1 @@
+ERROR
diff --git a/crates/ra_syntax/test_data/parser/fragments/type/err/0000_missing_close.rs b/crates/ra_syntax/test_data/parser/fragments/type/err/0000_missing_close.rs
new file mode 100644
index 000000000..caa4d7c09
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/fragments/type/err/0000_missing_close.rs
@@ -0,0 +1 @@
+Result<Foo, Bar
diff --git a/crates/ra_syntax/test_data/parser/fragments/type/ok/0000_result.rast b/crates/ra_syntax/test_data/parser/fragments/type/ok/0000_result.rast
new file mode 100644
index 000000000..8831cfa6c
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/fragments/type/ok/0000_result.rast
@@ -0,0 +1,22 @@
+[email protected]
+  [email protected]
+    [email protected]
+      [email protected]
+        [email protected] "Result"
+      [email protected]
+        [email protected] "<"
+        [email protected]
+          [email protected]
+            [email protected]
+              [email protected]
+                [email protected]
+                  [email protected] "Foo"
+        [email protected] ","
+        [email protected] " "
+        [email protected]
+          [email protected]
+            [email protected]
+              [email protected]
+                [email protected]
+                  [email protected] "Bar"
+        [email protected] ">"
diff --git a/crates/ra_syntax/test_data/parser/fragments/type/ok/0000_result.rs b/crates/ra_syntax/test_data/parser/fragments/type/ok/0000_result.rs
new file mode 100644
index 000000000..b50b3bb3b
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/fragments/type/ok/0000_result.rs
@@ -0,0 +1 @@
+Result<Foo, Bar>
diff --git a/crates/rust-analyzer/Cargo.toml b/crates/rust-analyzer/Cargo.toml
index 458089e53..2b46e8905 100644
--- a/crates/rust-analyzer/Cargo.toml
+++ b/crates/rust-analyzer/Cargo.toml
@@ -32,7 +32,7 @@ threadpool = "1.7.1"
 stdx = { path = "../stdx" }
-lsp-server = "0.3.2"
+lsp-server = "0.3.3"
 ra_flycheck = { path = "../ra_flycheck" }
 ra_ide = { path = "../ra_ide" }
 ra_prof = { path = "../ra_prof" }
diff --git a/crates/rust-analyzer/build.rs b/crates/rust-analyzer/build.rs
index d4b010c04..5ae76ba30 100644
--- a/crates/rust-analyzer/build.rs
+++ b/crates/rust-analyzer/build.rs
@@ -5,11 +5,14 @@ use std::{env, path::PathBuf, process::Command};
 fn main() {
    set_rerun();
-    let rev = rev().unwrap_or_else(|| "???????".to_string());
+    let rev =
+        env::var("RUST_ANALYZER_REV").ok().or_else(rev).unwrap_or_else(|| "???????".to_string());
    println!("cargo:rustc-env=REV={}", rev)
 }
 fn set_rerun() {
+    println!("cargo:rerun-if-env-changed=RUST_ANALYZER_REV");
    let mut manifest_dir = PathBuf::from(
        env::var("CARGO_MANIFEST_DIR").expect("`CARGO_MANIFEST_DIR` is always set by cargo."),
    );
diff --git a/crates/rust-analyzer/src/cargo_target_spec.rs b/crates/rust-analyzer/src/cargo_target_spec.rs
index 44f856f6b..5c22dce0d 100644
--- a/crates/rust-analyzer/src/cargo_target_spec.rs
+++ b/crates/rust-analyzer/src/cargo_target_spec.rs
@@ -2,7 +2,7 @@
 use ra_cfg::CfgExpr;
 use ra_ide::{FileId, RunnableKind, TestId};
-use ra_project_model::{self, ProjectWorkspace, TargetKind};
+use ra_project_model::{self, TargetKind};
 use crate::{global_state::GlobalStateSnapshot, Result};
@@ -89,27 +89,23 @@ impl CargoTargetSpec {
    }
    pub(crate) fn for_file(
-        world: &GlobalStateSnapshot,
+        global_state_snapshot: &GlobalStateSnapshot,
        file_id: FileId,
    ) -> Result<Option<CargoTargetSpec>> {
-        let &crate_id = match world.analysis().crate_for(file_id)?.first() {
+        let crate_id = match global_state_snapshot.analysis().crate_for(file_id)?.first() {
-            Some(crate_id) => crate_id,
+            Some(crate_id) => *crate_id,
            None => return Ok(None),
        };
-        let file_id = world.analysis().crate_root(crate_id)?;
+        let (cargo_ws, target) = match global_state_snapshot.cargo_target_for_crate_root(crate_id) {
-        let path = world.file_id_to_path(file_id);
+            Some(it) => it,
-        let res = world.workspaces.iter().find_map(|ws| match ws {
+            None => return Ok(None),
-            ProjectWorkspace::Cargo { cargo, .. } => {
+        };
-                let tgt = cargo.target_by_root(&path)?;
+        let res = CargoTargetSpec {
-                Some(CargoTargetSpec {
+            package: cargo_ws.package_flag(&cargo_ws[cargo_ws[target].package]),
-                    package: cargo.package_flag(&cargo[cargo[tgt].package]),
+            target: cargo_ws[target].name.clone(),
-                    target: cargo[tgt].name.clone(),
+            target_kind: cargo_ws[target].kind,
-                    target_kind: cargo[tgt].kind,
+        };
-                })
+        Ok(Some(res))
-            }
-            ProjectWorkspace::Json { .. } => None,
-        });
-        Ok(res)
    }
    pub(crate) fn push_to(self, buf: &mut Vec<String>, kind: &RunnableKind) {
diff --git a/crates/rust-analyzer/src/config.rs b/crates/rust-analyzer/src/config.rs
index 0e7a937a0..aa2c4ae15 100644
--- a/crates/rust-analyzer/src/config.rs
+++ b/crates/rust-analyzer/src/config.rs
@@ -9,6 +9,7 @@
 use std::{ffi::OsString, path::PathBuf};
+use crate::diagnostics::DiagnosticsConfig;
 use lsp_types::ClientCapabilities;
 use ra_flycheck::FlycheckConfig;
 use ra_ide::{AssistConfig, CompletionConfig, HoverConfig, InlayHintsConfig};
@@ -20,6 +21,7 @@ pub struct Config {
    pub client_caps: ClientCapsConfig,
    pub publish_diagnostics: bool,
+    pub diagnostics: DiagnosticsConfig,
    pub lru_capacity: Option<usize>,
    pub proc_macro_srv: Option<(PathBuf, Vec<OsString>)>,
    pub files: FilesConfig,
@@ -136,6 +138,7 @@ impl Default for Config {
            with_sysroot: true,
            publish_diagnostics: true,
+            diagnostics: DiagnosticsConfig::default(),
            lru_capacity: None,
            proc_macro_srv: None,
            files: FilesConfig { watcher: FilesWatcher::Notify, exclude: Vec::new() },
@@ -184,6 +187,8 @@ impl Config {
        set(value, "/withSysroot", &mut self.with_sysroot);
        set(value, "/diagnostics/enable", &mut self.publish_diagnostics);
+        set(value, "/diagnostics/warningsAsInfo", &mut self.diagnostics.warnings_as_info);
+        set(value, "/diagnostics/warningsAsHint", &mut self.diagnostics.warnings_as_hint);
        set(value, "/lruCapacity", &mut self.lru_capacity);
        self.files.watcher = match get(value, "/files/watcher") {
            Some("client") => FilesWatcher::Client,
@@ -291,6 +296,7 @@ impl Config {
            set(value, "/hoverActions/implementations", &mut self.hover.implementations);
            set(value, "/hoverActions/run", &mut self.hover.run);
            set(value, "/hoverActions/debug", &mut self.hover.debug);
+            set(value, "/hoverActions/gotoTypeDef", &mut self.hover.goto_type_def);
        } else {
            self.hover = HoverConfig::NO_ACTIONS;
        }
diff --git a/crates/rust-analyzer/src/diagnostics.rs b/crates/rust-analyzer/src/diagnostics.rs
index 25856c543..290609e7f 100644
--- a/crates/rust-analyzer/src/diagnostics.rs
+++ b/crates/rust-analyzer/src/diagnostics.rs
@@ -11,6 +11,12 @@ use crate::lsp_ext;
 pub type CheckFixes = Arc<HashMap<FileId, Vec<Fix>>>;
 #[derive(Debug, Default, Clone)]
+pub struct DiagnosticsConfig {
+    pub warnings_as_info: Vec<String>,
+    pub warnings_as_hint: Vec<String>,
+}
+#[derive(Debug, Default, Clone)]
 pub struct DiagnosticCollection {
    pub native: HashMap<FileId, Vec<Diagnostic>>,
    pub check: HashMap<FileId, Vec<Diagnostic>>,
diff --git a/crates/rust-analyzer/src/diagnostics/snapshots/rust_analyzer__diagnostics__to_proto__tests__snap_rustc_unused_variable_as_hint.snap b/crates/rust-analyzer/src/diagnostics/snapshots/rust_analyzer__diagnostics__to_proto__tests__snap_rustc_unused_variable_as_hint.snap
new file mode 100644
index 000000000..f0273315e
--- /dev/null
+++ b/crates/rust-analyzer/src/diagnostics/snapshots/rust_analyzer__diagnostics__to_proto__tests__snap_rustc_unused_variable_as_hint.snap
@@ -0,0 +1,86 @@
+---
+source: crates/rust-analyzer/src/diagnostics/to_proto.rs
+expression: diag
+---
+[
+    MappedRustDiagnostic {
+        location: Location {
+            uri: "file:///test/driver/subcommand/repl.rs",
+            range: Range {
+                start: Position {
+                    line: 290,
+                    character: 8,
+                },
+                end: Position {
+                    line: 290,
+                    character: 11,
+                },
+            },
+        },
+        diagnostic: Diagnostic {
+            range: Range {
+                start: Position {
+                    line: 290,
+                    character: 8,
+                },
+                end: Position {
+                    line: 290,
+                    character: 11,
+                },
+            },
+            severity: Some(
+                Hint,
+            ),
+            code: Some(
+                String(
+                    "unused_variables",
+                ),
+            ),
+            source: Some(
+                "rustc",
+            ),
+            message: "unused variable: `foo`\n#[warn(unused_variables)] on by default",
+            related_information: None,
+            tags: Some(
+                [
+                    Unnecessary,
+                ],
+            ),
+        },
+        fixes: [
+            CodeAction {
+                title: "consider prefixing with an underscore",
+                id: None,
+                group: None,
+                kind: Some(
+                    "quickfix",
+                ),
+                command: None,
+                edit: Some(
+                    SnippetWorkspaceEdit {
+                        changes: Some(
+                            {
+                                "file:///test/driver/subcommand/repl.rs": [
+                                    TextEdit {
+                                        range: Range {
+                                            start: Position {
+                                                line: 290,
+                                                character: 8,
+                                            },
+                                            end: Position {
+                                                line: 290,
+                                                character: 11,
+                                            },
+                                        },
+                                        new_text: "_foo",
+                                    },
+                                ],
+                            },
+                        ),
+                        document_changes: None,
+                    },
+                ),
+            },
+        ],
+    },
+]
diff --git a/crates/rust-analyzer/src/diagnostics/snapshots/rust_analyzer__diagnostics__to_proto__tests__snap_rustc_unused_variable_as_info.snap b/crates/rust-analyzer/src/diagnostics/snapshots/rust_analyzer__diagnostics__to_proto__tests__snap_rustc_unused_variable_as_info.snap
new file mode 100644
index 000000000..85fd050fd
--- /dev/null
+++ b/crates/rust-analyzer/src/diagnostics/snapshots/rust_analyzer__diagnostics__to_proto__tests__snap_rustc_unused_variable_as_info.snap
@@ -0,0 +1,86 @@
+---
+source: crates/rust-analyzer/src/diagnostics/to_proto.rs
+expression: diag
+---
+[
+    MappedRustDiagnostic {
+        location: Location {
+            uri: "file:///test/driver/subcommand/repl.rs",
+            range: Range {
+                start: Position {
+                    line: 290,
+                    character: 8,
+                },
+                end: Position {
+                    line: 290,
+                    character: 11,
+                },
+            },
+        },
+        diagnostic: Diagnostic {
+            range: Range {
+                start: Position {
+                    line: 290,
+                    character: 8,
+                },
+                end: Position {
+                    line: 290,
+                    character: 11,
+                },
+            },
+            severity: Some(
+                Information,
+            ),
+            code: Some(
+                String(
+                    "unused_variables",
+                ),
+            ),
+            source: Some(
+                "rustc",
+            ),
+            message: "unused variable: `foo`\n#[warn(unused_variables)] on by default",
+            related_information: None,
+            tags: Some(
+                [
+                    Unnecessary,
+                ],
+            ),
+        },
+        fixes: [
+            CodeAction {
+                title: "consider prefixing with an underscore",
+                id: None,
+                group: None,
+                kind: Some(
+                    "quickfix",
+                ),
+                command: None,
+                edit: Some(
+                    SnippetWorkspaceEdit {
+                        changes: Some(
+                            {
+                                "file:///test/driver/subcommand/repl.rs": [
+                                    TextEdit {
+                                        range: Range {
+                                            start: Position {
+                                                line: 290,
+                                                character: 8,
+                                            },
+                                            end: Position {
+                                                line: 290,
+                                                character: 11,
+                                            },
+                                        },
+                                        new_text: "_foo",
+                                    },
+                                ],
+                            },
+                        ),
+                        document_changes: None,
+                    },
+                ),
+            },
+        ],
+    },
+]
diff --git a/crates/rust-analyzer/src/diagnostics/to_proto.rs b/crates/rust-analyzer/src/diagnostics/to_proto.rs
index 24ff9b280..ba74f15f3 100644
--- a/crates/rust-analyzer/src/diagnostics/to_proto.rs
+++ b/crates/rust-analyzer/src/diagnostics/to_proto.rs
@@ -9,14 +9,24 @@ use lsp_types::{
 use ra_flycheck::{Applicability, DiagnosticLevel, DiagnosticSpan, DiagnosticSpanMacroExpansion};
 use stdx::format_to;
+use super::DiagnosticsConfig;
 use crate::{lsp_ext, to_proto::url_from_abs_path};
-/// Converts a Rust level string to a LSP severity
+/// Determines the LSP severity from a diagnostic
-fn map_level_to_severity(val: DiagnosticLevel) -> Option<DiagnosticSeverity> {
+fn map_diagnostic_to_severity(
-    let res = match val {
+    config: &DiagnosticsConfig,
+    val: &ra_flycheck::Diagnostic,
+) -> Option<DiagnosticSeverity> {
+    let res = match val.level {
        DiagnosticLevel::Ice => DiagnosticSeverity::Error,
        DiagnosticLevel::Error => DiagnosticSeverity::Error,
-        DiagnosticLevel::Warning => DiagnosticSeverity::Warning,
+        DiagnosticLevel::Warning => match &val.code {
+            Some(code) if config.warnings_as_hint.contains(&code.code) => DiagnosticSeverity::Hint,
+            Some(code) if config.warnings_as_info.contains(&code.code) => {
+                DiagnosticSeverity::Information
+            }
+            _ => DiagnosticSeverity::Warning,
+        },
        DiagnosticLevel::Note => DiagnosticSeverity::Information,
        DiagnosticLevel::Help => DiagnosticSeverity::Hint,
        DiagnosticLevel::Unknown => return None,
@@ -172,6 +182,7 @@ pub(crate) struct MappedRustDiagnostic {
 ///
 /// If the diagnostic has no primary span this will return `None`
 pub(crate) fn map_rust_diagnostic_to_lsp(
+    config: &DiagnosticsConfig,
    rd: &ra_flycheck::Diagnostic,
    workspace_root: &Path,
 ) -> Vec<MappedRustDiagnostic> {
@@ -180,7 +191,7 @@ pub(crate) fn map_rust_diagnostic_to_lsp(
        return Vec::new();
    }
-    let severity = map_level_to_severity(rd.level);
+    let severity = map_diagnostic_to_severity(config, rd);
    let mut source = String::from("rustc");
    let mut code = rd.code.as_ref().map(|c| c.code.clone());
@@ -328,7 +339,7 @@ mod tests {
        );
        let workspace_root = Path::new("/test/");
-        let diag = map_rust_diagnostic_to_lsp(&diag, workspace_root);
+        let diag = map_rust_diagnostic_to_lsp(&DiagnosticsConfig::default(), &diag, workspace_root);
        insta::assert_debug_snapshot!(diag);
    }
@@ -410,7 +421,183 @@ mod tests {
        );
        let workspace_root = Path::new("/test/");
-        let diag = map_rust_diagnostic_to_lsp(&diag, workspace_root);
+        let diag = map_rust_diagnostic_to_lsp(&DiagnosticsConfig::default(), &diag, workspace_root);
+        insta::assert_debug_snapshot!(diag);
+    }
+    #[test]
+    #[cfg(not(windows))]
+    fn snap_rustc_unused_variable_as_info() {
+        let diag = parse_diagnostic(
+            r##"{
+    "message": "unused variable: `foo`",
+    "code": {
+        "code": "unused_variables",
+        "explanation": null
+    },
+    "level": "warning",
+    "spans": [
+        {
+            "file_name": "driver/subcommand/repl.rs",
+            "byte_start": 9228,
+            "byte_end": 9231,
+            "line_start": 291,
+            "line_end": 291,
+            "column_start": 9,
+            "column_end": 12,
+            "is_primary": true,
+            "text": [
+                {
+                    "text": "    let foo = 42;",
+                    "highlight_start": 9,
+                    "highlight_end": 12
+                }
+            ],
+            "label": null,
+            "suggested_replacement": null,
+            "suggestion_applicability": null,
+            "expansion": null
+        }
+    ],
+    "children": [
+        {
+            "message": "#[warn(unused_variables)] on by default",
+            "code": null,
+            "level": "note",
+            "spans": [],
+            "children": [],
+            "rendered": null
+        },
+        {
+            "message": "consider prefixing with an underscore",
+            "code": null,
+            "level": "help",
+            "spans": [
+                {
+                    "file_name": "driver/subcommand/repl.rs",
+                    "byte_start": 9228,
+                    "byte_end": 9231,
+                    "line_start": 291,
+                    "line_end": 291,
+                    "column_start": 9,
+                    "column_end": 12,
+                    "is_primary": true,
+                    "text": [
+                        {
+                            "text": "    let foo = 42;",
+                            "highlight_start": 9,
+                            "highlight_end": 12
+                        }
+                    ],
+                    "label": null,
+                    "suggested_replacement": "_foo",
+                    "suggestion_applicability": "MachineApplicable",
+                    "expansion": null
+                }
+            ],
+            "children": [],
+            "rendered": null
+        }
+    ],
+    "rendered": "warning: unused variable: `foo`\n   --> driver/subcommand/repl.rs:291:9\n    |\n291 |     let foo = 42;\n    |         ^^^ help: consider prefixing with an underscore: `_foo`\n    |\n    = note: #[warn(unused_variables)] on by default\n\n"
+    }"##,
+        );
+        let config = DiagnosticsConfig {
+            warnings_as_info: vec!["unused_variables".to_string()],
+            ..DiagnosticsConfig::default()
+        };
+        let workspace_root = Path::new("/test/");
+        let diag = map_rust_diagnostic_to_lsp(&config, &diag, workspace_root);
+        insta::assert_debug_snapshot!(diag);
+    }
+    #[test]
+    #[cfg(not(windows))]
+    fn snap_rustc_unused_variable_as_hint() {
+        let diag = parse_diagnostic(
+            r##"{
+    "message": "unused variable: `foo`",
+    "code": {
+        "code": "unused_variables",
+        "explanation": null
+    },
+    "level": "warning",
+    "spans": [
+        {
+            "file_name": "driver/subcommand/repl.rs",
+            "byte_start": 9228,
+            "byte_end": 9231,
+            "line_start": 291,
+            "line_end": 291,
+            "column_start": 9,
+            "column_end": 12,
+            "is_primary": true,
+            "text": [
+                {
+                    "text": "    let foo = 42;",
+                    "highlight_start": 9,
+                    "highlight_end": 12
+                }
+            ],
+            "label": null,
+            "suggested_replacement": null,
+            "suggestion_applicability": null,
+            "expansion": null
+        }
+    ],
+    "children": [
+        {
+            "message": "#[warn(unused_variables)] on by default",
+            "code": null,
+            "level": "note",
+            "spans": [],
+            "children": [],
+            "rendered": null
+        },
+        {
+            "message": "consider prefixing with an underscore",
+            "code": null,
+            "level": "help",
+            "spans": [
+                {
+                    "file_name": "driver/subcommand/repl.rs",
+                    "byte_start": 9228,
+                    "byte_end": 9231,
+                    "line_start": 291,
+                    "line_end": 291,
+                    "column_start": 9,
+                    "column_end": 12,
+                    "is_primary": true,
+                    "text": [
+                        {
+                            "text": "    let foo = 42;",
+                            "highlight_start": 9,
+                            "highlight_end": 12
+                        }
+                    ],
+                    "label": null,
+                    "suggested_replacement": "_foo",
+                    "suggestion_applicability": "MachineApplicable",
+                    "expansion": null
+                }
+            ],
+            "children": [],
+            "rendered": null
+        }
+    ],
+    "rendered": "warning: unused variable: `foo`\n   --> driver/subcommand/repl.rs:291:9\n    |\n291 |     let foo = 42;\n    |         ^^^ help: consider prefixing with an underscore: `_foo`\n    |\n    = note: #[warn(unused_variables)] on by default\n\n"
+    }"##,
+        );
+        let config = DiagnosticsConfig {
+            warnings_as_hint: vec!["unused_variables".to_string()],
+            ..DiagnosticsConfig::default()
+        };
+        let workspace_root = Path::new("/test/");
+        let diag = map_rust_diagnostic_to_lsp(&config, &diag, workspace_root);
        insta::assert_debug_snapshot!(diag);
    }
@@ -534,7 +721,7 @@ mod tests {
        );
        let workspace_root = Path::new("/test/");
-        let diag = map_rust_diagnostic_to_lsp(&diag, workspace_root);
+        let diag = map_rust_diagnostic_to_lsp(&DiagnosticsConfig::default(), &diag, workspace_root);
        insta::assert_debug_snapshot!(diag);
    }
@@ -654,7 +841,7 @@ mod tests {
        );
        let workspace_root = Path::new("/test/");
-        let diag = map_rust_diagnostic_to_lsp(&diag, workspace_root);
+        let diag = map_rust_diagnostic_to_lsp(&DiagnosticsConfig::default(), &diag, workspace_root);
        insta::assert_debug_snapshot!(diag);
    }
@@ -697,7 +884,7 @@ mod tests {
        );
        let workspace_root = Path::new("/test/");
-        let diag = map_rust_diagnostic_to_lsp(&diag, workspace_root);
+        let diag = map_rust_diagnostic_to_lsp(&DiagnosticsConfig::default(), &diag, workspace_root);
        insta::assert_debug_snapshot!(diag);
    }
@@ -968,7 +1155,7 @@ mod tests {
        );
        let workspace_root = Path::new("/test/");
-        let diag = map_rust_diagnostic_to_lsp(&diag, workspace_root);
+        let diag = map_rust_diagnostic_to_lsp(&DiagnosticsConfig::default(), &diag, workspace_root);
        insta::assert_debug_snapshot!(diag);
    }
@@ -1197,7 +1384,7 @@ mod tests {
        );
        let workspace_root = Path::new("/test/");
-        let diag = map_rust_diagnostic_to_lsp(&diag, workspace_root);
+        let diag = map_rust_diagnostic_to_lsp(&DiagnosticsConfig::default(), &diag, workspace_root);
        insta::assert_debug_snapshot!(diag);
    }
@@ -1330,7 +1517,7 @@ mod tests {
        );
        let workspace_root = Path::new("/test/");
-        let diag = map_rust_diagnostic_to_lsp(&diag, workspace_root);
+        let diag = map_rust_diagnostic_to_lsp(&DiagnosticsConfig::default(), &diag, workspace_root);
        insta::assert_debug_snapshot!(diag);
    }
 }
diff --git a/crates/rust-analyzer/src/global_state.rs b/crates/rust-analyzer/src/global_state.rs
index 9d5685d88..d04ef4c61 100644
--- a/crates/rust-analyzer/src/global_state.rs
+++ b/crates/rust-analyzer/src/global_state.rs
@@ -12,41 +12,34 @@ use crossbeam_channel::{unbounded, Receiver};
 use lsp_types::Url;
 use parking_lot::RwLock;
 use ra_flycheck::{Flycheck, FlycheckConfig};
-use ra_ide::{
+use ra_ide::{Analysis, AnalysisChange, AnalysisHost, CrateGraph, FileId, SourceRootId};
-    Analysis, AnalysisChange, AnalysisHost, CrateGraph, FileId, LibraryData, SourceRootId,
+use ra_project_model::{CargoWorkspace, ProcMacroClient, ProjectWorkspace, Target};
-};
+use ra_vfs::{LineEndings, RootEntry, Vfs, VfsChange, VfsFile, VfsTask, Watch};
-use ra_project_model::{ProcMacroClient, ProjectWorkspace};
-use ra_vfs::{LineEndings, RootEntry, Vfs, VfsChange, VfsFile, VfsRoot, VfsTask, Watch};
-use relative_path::RelativePathBuf;
 use stdx::format_to;
 use crate::{
-    config::Config,
+    config::{Config, FilesWatcher},
    diagnostics::{CheckFixes, DiagnosticCollection},
-    main_loop::pending_requests::{CompletedRequest, LatestRequests},
+    main_loop::request_metrics::{LatestRequests, RequestMetrics},
    to_proto::url_from_abs_path,
    vfs_glob::{Glob, RustPackageFilterBuilder},
    LspError, Result,
 };
-use ra_db::ExternSourceId;
+use ra_db::{CrateId, ExternSourceId};
 use rustc_hash::{FxHashMap, FxHashSet};
 fn create_flycheck(workspaces: &[ProjectWorkspace], config: &FlycheckConfig) -> Option<Flycheck> {
    // FIXME: Figure out the multi-workspace situation
-    workspaces
+    workspaces.iter().find_map(|w| match w {
-        .iter()
+        ProjectWorkspace::Cargo { cargo, .. } => {
-        .find_map(|w| match w {
-            ProjectWorkspace::Cargo { cargo, .. } => Some(cargo),
-            ProjectWorkspace::Json { .. } => None,
-        })
-        .map(|cargo| {
            let cargo_project_root = cargo.workspace_root().to_path_buf();
            Some(Flycheck::new(config.clone(), cargo_project_root))
-        })
+        }
-        .unwrap_or_else(|| {
+        ProjectWorkspace::Json { .. } => {
            log::warn!("Cargo check watching only supported for cargo workspaces, disabling");
            None
-        })
+        }
+    })
 }
 /// `GlobalState` is the primary mutable state of the language server
@@ -62,10 +55,10 @@ pub struct GlobalState {
    pub analysis_host: AnalysisHost,
    pub vfs: Arc<RwLock<Vfs>>,
    pub task_receiver: Receiver<VfsTask>,
-    pub latest_requests: Arc<RwLock<LatestRequests>>,
    pub flycheck: Option<Flycheck>,
    pub diagnostics: DiagnosticCollection,
    pub proc_macro_client: ProcMacroClient,
+    pub(crate) latest_requests: Arc<RwLock<LatestRequests>>,
 }
 /// An immutable snapshot of the world's state at a point in time.
@@ -73,8 +66,8 @@ pub struct GlobalStateSnapshot {
    pub config: Config,
    pub workspaces: Arc<Vec<ProjectWorkspace>>,
    pub analysis: Analysis,
-    pub latest_requests: Arc<RwLock<LatestRequests>>,
    pub check_fixes: CheckFixes,
+    pub(crate) latest_requests: Arc<RwLock<LatestRequests>>,
    vfs: Arc<RwLock<Vfs>>,
 }
@@ -83,7 +76,6 @@ impl GlobalState {
        workspaces: Vec<ProjectWorkspace>,
        lru_capacity: Option<usize>,
        exclude_globs: &[Glob],
-        watch: Watch,
        config: Config,
    ) -> GlobalState {
        let mut change = AnalysisChange::new();
@@ -118,6 +110,7 @@ impl GlobalState {
        let (task_sender, task_receiver) = unbounded();
        let task_sender = Box::new(move |t| task_sender.send(t).unwrap());
+        let watch = Watch(matches!(config.files.watcher, FilesWatcher::Notify));
        let (mut vfs, vfs_roots) = Vfs::new(roots, task_sender, watch);
        let mut extern_source_roots = FxHashMap::default();
@@ -195,32 +188,18 @@ impl GlobalState {
    /// Returns a vec of libraries
    /// FIXME: better API here
-    pub fn process_changes(
+    pub fn process_changes(&mut self, roots_scanned: &mut usize) -> bool {
-        &mut self,
-        roots_scanned: &mut usize,
-    ) -> Option<Vec<(SourceRootId, Vec<(FileId, RelativePathBuf, Arc<String>)>)>> {
        let changes = self.vfs.write().commit_changes();
        if changes.is_empty() {
-            return None;
+            return false;
        }
-        let mut libs = Vec::new();
        let mut change = AnalysisChange::new();
        for c in changes {
            match c {
                VfsChange::AddRoot { root, files } => {
-                    let root_path = self.vfs.read().root2path(root);
+                    *roots_scanned += 1;
-                    let is_local = self.local_roots.iter().any(|r| root_path.starts_with(r));
+                    for (file, path, text) in files {
-                    if is_local {
+                        change.add_file(SourceRootId(root.0), FileId(file.0), path, text);
-                        *roots_scanned += 1;
-                        for (file, path, text) in files {
-                            change.add_file(SourceRootId(root.0), FileId(file.0), path, text);
-                        }
-                    } else {
-                        let files = files
-                            .into_iter()
-                            .map(|(vfsfile, path, text)| (FileId(vfsfile.0), path, text))
-                            .collect();
-                        libs.push((SourceRootId(root.0), files));
                    }
                }
                VfsChange::AddFile { root, file, path, text } => {
@@ -235,13 +214,7 @@ impl GlobalState {
            }
        }
        self.analysis_host.apply_change(change);
-        Some(libs)
+        true
-    }
-    pub fn add_lib(&mut self, data: LibraryData) {
-        let mut change = AnalysisChange::new();
-        change.add_library(data);
-        self.analysis_host.apply_change(change);
    }
    pub fn snapshot(&self) -> GlobalStateSnapshot {
@@ -263,7 +236,7 @@ impl GlobalState {
        self.analysis_host.collect_garbage()
    }
-    pub fn complete_request(&mut self, request: CompletedRequest) {
+    pub(crate) fn complete_request(&mut self, request: RequestMetrics) {
        self.latest_requests.write().record(request)
    }
 }
@@ -290,20 +263,31 @@ impl GlobalStateSnapshot {
        file_id_to_url(&self.vfs.read(), id)
    }
-    pub fn file_id_to_path(&self, id: FileId) -> PathBuf {
-        self.vfs.read().file2path(VfsFile(id.0))
-    }
    pub fn file_line_endings(&self, id: FileId) -> LineEndings {
        self.vfs.read().file_line_endings(VfsFile(id.0))
    }
-    pub fn path_to_url(&self, root: SourceRootId, path: &RelativePathBuf) -> Url {
+    pub fn anchored_path(&self, file_id: FileId, path: &str) -> Url {
-        let base = self.vfs.read().root2path(VfsRoot(root.0));
+        let mut base = self.vfs.read().file2path(VfsFile(file_id.0));
-        let path = path.to_path(base);
+        base.pop();
+        let path = base.join(path);
        url_from_abs_path(&path)
    }
+    pub(crate) fn cargo_target_for_crate_root(
+        &self,
+        crate_id: CrateId,
+    ) -> Option<(&CargoWorkspace, Target)> {
+        let file_id = self.analysis().crate_root(crate_id).ok()?;
+        let path = self.vfs.read().file2path(VfsFile(file_id.0));
+        self.workspaces.iter().find_map(|ws| match ws {
+            ProjectWorkspace::Cargo { cargo, .. } => {
+                cargo.target_by_root(&path).map(|it| (cargo, it))
+            }
+            ProjectWorkspace::Json { .. } => None,
+        })
+    }
    pub fn status(&self) -> String {
        let mut buf = String::new();
        if self.workspaces.is_empty() {
diff --git a/crates/rust-analyzer/src/lib.rs b/crates/rust-analyzer/src/lib.rs
index 609cb69d3..64e70955f 100644
--- a/crates/rust-analyzer/src/lib.rs
+++ b/crates/rust-analyzer/src/lib.rs
@@ -32,7 +32,7 @@ mod semantic_tokens;
 use serde::de::DeserializeOwned;
-pub type Result<T> = std::result::Result<T, Box<dyn std::error::Error + Send + Sync>>;
+pub type Result<T, E = Box<dyn std::error::Error + Send + Sync>> = std::result::Result<T, E>;
 pub use crate::{
    caps::server_capabilities,
    main_loop::LspError,
diff --git a/crates/rust-analyzer/src/main_loop.rs b/crates/rust-analyzer/src/main_loop.rs
index cc9bb1726..674b1323b 100644
--- a/crates/rust-analyzer/src/main_loop.rs
+++ b/crates/rust-analyzer/src/main_loop.rs
@@ -3,7 +3,7 @@
 mod handlers;
 mod subscriptions;
-pub(crate) mod pending_requests;
+pub(crate) mod request_metrics;
 use std::{
    borrow::Cow,
@@ -17,19 +17,19 @@ use std::{
 };
 use crossbeam_channel::{never, select, unbounded, RecvError, Sender};
-use lsp_server::{Connection, ErrorCode, Message, Notification, Request, RequestId, Response};
+use lsp_server::{
+    Connection, ErrorCode, Message, Notification, ReqQueue, Request, RequestId, Response,
+};
 use lsp_types::{
-    DidChangeTextDocumentParams, NumberOrString, TextDocumentContentChangeEvent, WorkDoneProgress,
+    request::Request as _, DidChangeTextDocumentParams, NumberOrString,
-    WorkDoneProgressBegin, WorkDoneProgressCreateParams, WorkDoneProgressEnd,
+    TextDocumentContentChangeEvent, WorkDoneProgress, WorkDoneProgressBegin,
-    WorkDoneProgressReport,
+    WorkDoneProgressCreateParams, WorkDoneProgressEnd, WorkDoneProgressReport,
 };
 use ra_flycheck::{CheckTask, Status};
-use ra_ide::{Canceled, FileId, LibraryData, LineIndex, SourceRootId};
+use ra_ide::{Canceled, FileId, LineIndex};
 use ra_prof::profile;
 use ra_project_model::{PackageRoot, ProjectWorkspace};
-use ra_vfs::{VfsTask, Watch};
+use ra_vfs::VfsTask;
-use relative_path::RelativePathBuf;
-use rustc_hash::FxHashSet;
 use serde::{de::DeserializeOwned, Serialize};
 use threadpool::ThreadPool;
@@ -39,10 +39,7 @@ use crate::{
    from_proto,
    global_state::{file_id_to_url, GlobalState, GlobalStateSnapshot},
    lsp_ext,
-    main_loop::{
+    main_loop::{request_metrics::RequestMetrics, subscriptions::Subscriptions},
-        pending_requests::{PendingRequest, PendingRequests},
-        subscriptions::Subscriptions,
-    },
    Result,
 };
@@ -154,32 +151,25 @@ pub fn main_loop(config: Config, connection: Connection) -> Result<()> {
                register_options: Some(serde_json::to_value(registration_options).unwrap()),
            };
            let params = lsp_types::RegistrationParams { registrations: vec![registration] };
-            let request = request_new::<lsp_types::request::RegisterCapability>(
+            let request = loop_state.req_queue.outgoing.register(
-                loop_state.next_request_id(),
+                lsp_types::request::RegisterCapability::METHOD.to_string(),
                params,
+                DO_NOTHING,
            );
            connection.sender.send(request.into()).unwrap();
        }
-        GlobalState::new(
+        GlobalState::new(workspaces, config.lru_capacity, &globs, config)
-            workspaces,
-            config.lru_capacity,
-            &globs,
-            Watch(matches!(config.files.watcher, FilesWatcher::Notify)),
-            config,
-        )
    };
    loop_state.roots_total = global_state.vfs.read().n_roots();
    let pool = ThreadPool::default();
    let (task_sender, task_receiver) = unbounded::<Task>();
-    let (libdata_sender, libdata_receiver) = unbounded::<LibraryData>();
    log::info!("server initialized, serving requests");
    {
        let task_sender = task_sender;
-        let libdata_sender = libdata_sender;
        loop {
            log::trace!("selecting");
            let event = select! {
@@ -192,7 +182,6 @@ pub fn main_loop(config: Config, connection: Connection) -> Result<()> {
                    Ok(task) => Event::Vfs(task),
                    Err(RecvError) => return Err("vfs died".into()),
                },
-                recv(libdata_receiver) -> data => Event::Lib(data.unwrap()),
                recv(global_state.flycheck.as_ref().map_or(&never(), |it| &it.task_recv)) -> task => match task {
                    Ok(task) => Event::CheckWatcher(task),
                    Err(RecvError) => return Err("check watcher died".into()),
@@ -203,23 +192,14 @@ pub fn main_loop(config: Config, connection: Connection) -> Result<()> {
                    break;
                };
            }
-            loop_turn(
+            loop_turn(&pool, &task_sender, &connection, &mut global_state, &mut loop_state, event)?;
-                &pool,
-                &task_sender,
-                &libdata_sender,
-                &connection,
-                &mut global_state,
-                &mut loop_state,
-                event,
-            )?;
        }
    }
    global_state.analysis_host.request_cancellation();
    log::info!("waiting for tasks to finish...");
    task_receiver.into_iter().for_each(|task| {
-        on_task(task, &connection.sender, &mut loop_state.pending_requests, &mut global_state)
+        on_task(task, &connection.sender, &mut loop_state.req_queue.incoming, &mut global_state)
    });
-    libdata_receiver.into_iter().for_each(drop);
    log::info!("...tasks have finished");
    log::info!("joining threadpool...");
    pool.join();
@@ -243,7 +223,6 @@ enum Event {
    Msg(Message),
    Task(Task),
    Vfs(VfsTask),
-    Lib(LibraryData),
    CheckWatcher(CheckTask),
 }
@@ -279,43 +258,28 @@ impl fmt::Debug for Event {
            Event::Msg(it) => fmt::Debug::fmt(it, f),
            Event::Task(it) => fmt::Debug::fmt(it, f),
            Event::Vfs(it) => fmt::Debug::fmt(it, f),
-            Event::Lib(it) => fmt::Debug::fmt(it, f),
            Event::CheckWatcher(it) => fmt::Debug::fmt(it, f),
        }
    }
 }
-#[derive(Debug, Default)]
+type ReqHandler = fn(&mut GlobalState, Response);
+const DO_NOTHING: ReqHandler = |_, _| ();
+type Incoming = lsp_server::Incoming<(&'static str, Instant)>;
+#[derive(Default)]
 struct LoopState {
-    next_request_id: u64,
+    req_queue: ReqQueue<(&'static str, Instant), ReqHandler>,
-    pending_responses: FxHashSet<RequestId>,
-    pending_requests: PendingRequests,
    subscriptions: Subscriptions,
-    // We try not to index more than MAX_IN_FLIGHT_LIBS libraries at the same
-    // time to always have a thread ready to react to input.
-    in_flight_libraries: usize,
-    pending_libraries: Vec<(SourceRootId, Vec<(FileId, RelativePathBuf, Arc<String>)>)>,
    workspace_loaded: bool,
    roots_progress_reported: Option<usize>,
    roots_scanned: usize,
    roots_total: usize,
-    configuration_request_id: Option<RequestId>,
-}
-impl LoopState {
-    fn next_request_id(&mut self) -> RequestId {
-        self.next_request_id += 1;
-        let res: RequestId = self.next_request_id.into();
-        let inserted = self.pending_responses.insert(res.clone());
-        assert!(inserted);
-        res
-    }
 }
 fn loop_turn(
    pool: &ThreadPool,
    task_sender: &Sender<Task>,
-    libdata_sender: &Sender<LibraryData>,
    connection: &Connection,
    global_state: &mut GlobalState,
    loop_state: &mut LoopState,
@@ -333,23 +297,17 @@ fn loop_turn(
    match event {
        Event::Task(task) => {
-            on_task(task, &connection.sender, &mut loop_state.pending_requests, global_state);
+            on_task(task, &connection.sender, &mut loop_state.req_queue.incoming, global_state);
            global_state.maybe_collect_garbage();
        }
        Event::Vfs(task) => {
            global_state.vfs.write().handle_task(task);
        }
-        Event::Lib(lib) => {
-            global_state.add_lib(lib);
-            global_state.maybe_collect_garbage();
-            loop_state.in_flight_libraries -= 1;
-            loop_state.roots_scanned += 1;
-        }
        Event::CheckWatcher(task) => on_check_task(task, global_state, task_sender)?,
        Event::Msg(msg) => match msg {
            Message::Request(req) => on_request(
                global_state,
-                &mut loop_state.pending_requests,
+                &mut loop_state.req_queue.incoming,
                pool,
                task_sender,
                &connection.sender,
@@ -360,66 +318,18 @@ fn loop_turn(
                on_notification(&connection.sender, global_state, loop_state, not)?;
            }
            Message::Response(resp) => {
-                let removed = loop_state.pending_responses.remove(&resp.id);
+                let handler = loop_state.req_queue.outgoing.complete(resp.id.clone());
-                if !removed {
+                handler(global_state, resp)
-                    log::error!("unexpected response: {:?}", resp)
-                }
-                if Some(&resp.id) == loop_state.configuration_request_id.as_ref() {
-                    loop_state.configuration_request_id = None;
-                    log::debug!("config update response: '{:?}", resp);
-                    let Response { error, result, .. } = resp;
-                    match (error, result) {
-                        (Some(err), _) => {
-                            log::error!("failed to fetch the server settings: {:?}", err)
-                        }
-                        (None, Some(configs)) => {
-                            if let Some(new_config) = configs.get(0) {
-                                let mut config = global_state.config.clone();
-                                config.update(&new_config);
-                                global_state.update_configuration(config);
-                            }
-                        }
-                        (None, None) => {
-                            log::error!("received empty server settings response from the client")
-                        }
-                    }
-                }
            }
        },
    };
-    let mut state_changed = false;
+    let mut state_changed = global_state.process_changes(&mut loop_state.roots_scanned);
-    if let Some(changes) = global_state.process_changes(&mut loop_state.roots_scanned) {
-        state_changed = true;
-        loop_state.pending_libraries.extend(changes);
-    }
-    let max_in_flight_libs = pool.max_count().saturating_sub(2).max(1);
-    while loop_state.in_flight_libraries < max_in_flight_libs {
-        let (root, files) = match loop_state.pending_libraries.pop() {
-            Some(it) => it,
-            None => break,
-        };
-        loop_state.in_flight_libraries += 1;
-        let sender = libdata_sender.clone();
-        pool.execute(move || {
-            log::info!("indexing {:?} ... ", root);
-            let data = LibraryData::prepare(root, files);
-            sender.send(data).unwrap();
-        });
-    }
    let show_progress =
        !loop_state.workspace_loaded && global_state.config.client_caps.work_done_progress;
-    if !loop_state.workspace_loaded
+    if !loop_state.workspace_loaded && loop_state.roots_scanned == loop_state.roots_total {
-        && loop_state.roots_scanned == loop_state.roots_total
-        && loop_state.pending_libraries.is_empty()
-        && loop_state.in_flight_libraries == 0
-    {
        state_changed = true;
        loop_state.workspace_loaded = true;
        if let Some(flycheck) = &global_state.flycheck {
@@ -463,14 +373,19 @@ fn loop_turn(
 fn on_task(
    task: Task,
    msg_sender: &Sender<Message>,
-    pending_requests: &mut PendingRequests,
+    incoming_requests: &mut Incoming,
    state: &mut GlobalState,
 ) {
    match task {
        Task::Respond(response) => {
-            if let Some(completed) = pending_requests.finish(&response.id) {
+            if let Some((method, start)) = incoming_requests.complete(response.id.clone()) {
-                log::info!("handled req#{} in {:?}", completed.id, completed.duration);
+                let duration = start.elapsed();
-                state.complete_request(completed);
+                log::info!("handled req#{} in {:?}", response.id, duration);
+                state.complete_request(RequestMetrics {
+                    id: response.id.clone(),
+                    method: method.to_string(),
+                    duration,
+                });
                msg_sender.send(response.into()).unwrap();
            }
        }
@@ -483,7 +398,7 @@ fn on_task(
 fn on_request(
    global_state: &mut GlobalState,
-    pending_requests: &mut PendingRequests,
+    incoming_requests: &mut Incoming,
    pool: &ThreadPool,
    task_sender: &Sender<Task>,
    msg_sender: &Sender<Message>,
@@ -496,7 +411,7 @@ fn on_request(
        global_state,
        task_sender,
        msg_sender,
-        pending_requests,
+        incoming_requests,
        request_received,
    };
    pool_dispatcher
@@ -560,12 +475,7 @@ fn on_notification(
                NumberOrString::Number(id) => id.into(),
                NumberOrString::String(id) => id.into(),
            };
-            if loop_state.pending_requests.cancel(&id) {
+            if let Some(response) = loop_state.req_queue.incoming.cancel(id) {
-                let response = Response::new_err(
-                    id,
-                    ErrorCode::RequestCanceled as i32,
-                    "canceled by client".to_string(),
-                );
                msg_sender.send(response.into()).unwrap()
            }
            return Ok(());
@@ -628,18 +538,36 @@ fn on_notification(
        Ok(_) => {
            // As stated in https://github.com/microsoft/language-server-protocol/issues/676,
            // this notification's parameters should be ignored and the actual config queried separately.
-            let request_id = loop_state.next_request_id();
+            let request = loop_state.req_queue.outgoing.register(
-            let request = request_new::<lsp_types::request::WorkspaceConfiguration>(
+                lsp_types::request::WorkspaceConfiguration::METHOD.to_string(),
-                request_id.clone(),
                lsp_types::ConfigurationParams {
                    items: vec![lsp_types::ConfigurationItem {
                        scope_uri: None,
                        section: Some("rust-analyzer".to_string()),
                    }],
                },
+                |global_state, resp| {
+                    log::debug!("config update response: '{:?}", resp);
+                    let Response { error, result, .. } = resp;
+                    match (error, result) {
+                        (Some(err), _) => {
+                            log::error!("failed to fetch the server settings: {:?}", err)
+                        }
+                        (None, Some(configs)) => {
+                            if let Some(new_config) = configs.get(0) {
+                                let mut config = global_state.config.clone();
+                                config.update(&new_config);
+                                global_state.update_configuration(config);
+                            }
+                        }
+                        (None, None) => {
+                            log::error!("received empty server settings response from the client")
+                        }
+                    }
+                },
            );
            msg_sender.send(request.into())?;
-            loop_state.configuration_request_id = Some(request_id);
            return Ok(());
        }
@@ -669,14 +597,11 @@ fn apply_document_changes(
    mut line_index: Cow<'_, LineIndex>,
    content_changes: Vec<TextDocumentContentChangeEvent>,
 ) {
-    // Remove when https://github.com/rust-analyzer/rust-analyzer/issues/4263 is fixed.
-    let backup_text = old_text.clone();
-    let backup_changes = content_changes.clone();
    // The changes we got must be applied sequentially, but can cross lines so we
    // have to keep our line index updated.
    // Some clients (e.g. Code) sort the ranges in reverse. As an optimization, we
    // remember the last valid line in the index and only rebuild it if needed.
+    // The VFS will normalize the end of lines to `\n`.
    enum IndexValid {
        All,
        UpToLineExclusive(u64),
@@ -700,19 +625,7 @@ fn apply_document_changes(
                }
                index_valid = IndexValid::UpToLineExclusive(range.start.line);
                let range = from_proto::text_range(&line_index, range);
-                let mut text = old_text.to_owned();
+                old_text.replace_range(Range::<usize>::from(range), &change.text);
-                match std::panic::catch_unwind(move || {
-                    text.replace_range(Range::<usize>::from(range), &change.text);
-                    text
-                }) {
-                    Ok(t) => *old_text = t,
-                    Err(e) => {
-                        eprintln!("Bug in incremental text synchronization. Please report the following output on https://github.com/rust-analyzer/rust-analyzer/issues/4263");
-                        dbg!(&backup_text);
-                        dbg!(&backup_changes);
-                        std::panic::resume_unwind(e);
-                    }
-                }
            }
            None => {
                *old_text = change.text;
@@ -734,6 +647,7 @@ fn on_check_task(
        CheckTask::AddDiagnostic { workspace_root, diagnostic } => {
            let diagnostics = crate::diagnostics::to_proto::map_rust_diagnostic_to_lsp(
+                &global_state.config.diagnostics,
                &diagnostic,
                &workspace_root,
            );
@@ -822,13 +736,14 @@ fn send_startup_progress(sender: &Sender<Message>, loop_state: &mut LoopState) {
    match (prev, loop_state.workspace_loaded) {
        (None, false) => {
-            let work_done_progress_create = request_new::<lsp_types::request::WorkDoneProgressCreate>(
+            let request = loop_state.req_queue.outgoing.register(
-                loop_state.next_request_id(),
+                lsp_types::request::WorkDoneProgressCreate::METHOD.to_string(),
                WorkDoneProgressCreateParams {
                    token: lsp_types::ProgressToken::String("rustAnalyzer/startup".into()),
                },
+                DO_NOTHING,
            );
-            sender.send(work_done_progress_create.into()).unwrap();
+            sender.send(request.into()).unwrap();
            send_startup_progress_notif(
                sender,
                WorkDoneProgress::Begin(WorkDoneProgressBegin {
@@ -870,7 +785,7 @@ struct PoolDispatcher<'a> {
    req: Option<Request>,
    pool: &'a ThreadPool,
    global_state: &'a mut GlobalState,
-    pending_requests: &'a mut PendingRequests,
+    incoming_requests: &'a mut Incoming,
    msg_sender: &'a Sender<Message>,
    task_sender: &'a Sender<Task>,
    request_received: Instant,
@@ -899,7 +814,7 @@ impl<'a> PoolDispatcher<'a> {
            result_to_task::<R>(id, result)
        })
        .map_err(|_| format!("sync task {:?} panicked", R::METHOD))?;
-        on_task(task, self.msg_sender, self.pending_requests, self.global_state);
+        on_task(task, self.msg_sender, self.incoming_requests, self.global_state);
        Ok(self)
    }
@@ -946,11 +861,7 @@ impl<'a> PoolDispatcher<'a> {
                return None;
            }
        };
-        self.pending_requests.start(PendingRequest {
+        self.incoming_requests.register(id.clone(), (R::METHOD, self.request_received));
-            id: id.clone(),
-            method: R::METHOD.to_string(),
-            received: self.request_received,
-        });
        Some((id, params))
    }
@@ -1063,14 +974,6 @@ where
    Notification::new(N::METHOD.to_string(), params)
 }
-fn request_new<R>(id: RequestId, params: R::Params) -> Request
-where
-    R: lsp_types::request::Request,
-    R::Params: Serialize,
-{
-    Request::new(id, R::METHOD.to_string(), params)
-}
 #[cfg(test)]
 mod tests {
    use std::borrow::Cow;
diff --git a/crates/rust-analyzer/src/main_loop/handlers.rs b/crates/rust-analyzer/src/main_loop/handlers.rs
index b34b529b5..2d7e649d2 100644
--- a/crates/rust-analyzer/src/main_loop/handlers.rs
+++ b/crates/rust-analyzer/src/main_loop/handlers.rs
@@ -18,8 +18,8 @@ use lsp_types::{
    TextDocumentIdentifier, Url, WorkspaceEdit,
 };
 use ra_ide::{
-    FileId, FilePosition, FileRange, HoverAction, Query, RangeInfo, Runnable, RunnableKind,
+    FileId, FilePosition, FileRange, HoverAction, HoverGotoTypeData, NavigationTarget, Query,
-    SearchScope, TextEdit,
+    RangeInfo, Runnable, RunnableKind, SearchScope, TextEdit,
 };
 use ra_prof::profile;
 use ra_project_model::TargetKind;
@@ -1150,6 +1150,23 @@ fn debug_single_command(runnable: &lsp_ext::Runnable) -> Command {
    }
 }
+fn goto_location_command(snap: &GlobalStateSnapshot, nav: &NavigationTarget) -> Option<Command> {
+    let value = if snap.config.client_caps.location_link {
+        let link = to_proto::location_link(snap, None, nav.clone()).ok()?;
+        to_value(link).ok()?
+    } else {
+        let range = FileRange { file_id: nav.file_id(), range: nav.range() };
+        let location = to_proto::location(snap, range).ok()?;
+        to_value(location).ok()?
+    };
+    Some(Command {
+        title: nav.name().to_string(),
+        command: "rust-analyzer.gotoLocation".into(),
+        arguments: Some(vec![value]),
+    })
+}
 fn to_command_link(command: Command, tooltip: String) -> lsp_ext::CommandLink {
    lsp_ext::CommandLink { tooltip: Some(tooltip), command }
 }
@@ -1180,13 +1197,13 @@ fn show_impl_command_link(
    None
 }
-fn to_runnable_action(
+fn runnable_action_links(
    snap: &GlobalStateSnapshot,
    file_id: FileId,
    runnable: Runnable,
 ) -> Option<lsp_ext::CommandLinkGroup> {
    let cargo_spec = CargoTargetSpec::for_file(&snap, file_id).ok()?;
-    if should_skip_target(&runnable, cargo_spec.as_ref()) {
+    if !snap.config.hover.runnable() || should_skip_target(&runnable, cargo_spec.as_ref()) {
        return None;
    }
@@ -1208,6 +1225,26 @@ fn to_runnable_action(
    })
 }
+fn goto_type_action_links(
+    snap: &GlobalStateSnapshot,
+    nav_targets: &[HoverGotoTypeData],
+) -> Option<lsp_ext::CommandLinkGroup> {
+    if !snap.config.hover.goto_type_def || nav_targets.is_empty() {
+        return None;
+    }
+    Some(lsp_ext::CommandLinkGroup {
+        title: Some("Go to ".into()),
+        commands: nav_targets
+            .iter()
+            .filter_map(|it| {
+                goto_location_command(snap, &it.nav)
+                    .map(|cmd| to_command_link(cmd, it.mod_path.clone()))
+            })
+            .collect(),
+    })
+}
 fn prepare_hover_actions(
    snap: &GlobalStateSnapshot,
    file_id: FileId,
@@ -1221,7 +1258,8 @@ fn prepare_hover_actions(
        .iter()
        .filter_map(|it| match it {
            HoverAction::Implementaion(position) => show_impl_command_link(snap, position),
-            HoverAction::Runnable(r) => to_runnable_action(snap, file_id, r.clone()),
+            HoverAction::Runnable(r) => runnable_action_links(snap, file_id, r.clone()),
+            HoverAction::GoToType(targets) => goto_type_action_links(snap, targets),
        })
        .collect()
 }
diff --git a/crates/rust-analyzer/src/main_loop/pending_requests.rs b/crates/rust-analyzer/src/main_loop/pending_requests.rs
deleted file mode 100644
index 73b33e419..000000000
--- a/crates/rust-analyzer/src/main_loop/pending_requests.rs
+++ /dev/null
@@ -1,75 +0,0 @@
-//! Data structures that keep track of inflight requests.
-use std::time::{Duration, Instant};
-use lsp_server::RequestId;
-use rustc_hash::FxHashMap;
-#[derive(Debug)]
-pub struct CompletedRequest {
-    pub id: RequestId,
-    pub method: String,
-    pub duration: Duration,
-}
-#[derive(Debug)]
-pub(crate) struct PendingRequest {
-    pub(crate) id: RequestId,
-    pub(crate) method: String,
-    pub(crate) received: Instant,
-}
-impl From<PendingRequest> for CompletedRequest {
-    fn from(pending: PendingRequest) -> CompletedRequest {
-        CompletedRequest {
-            id: pending.id,
-            method: pending.method,
-            duration: pending.received.elapsed(),
-        }
-    }
-}
-#[derive(Debug, Default)]
-pub(crate) struct PendingRequests {
-    map: FxHashMap<RequestId, PendingRequest>,
-}
-impl PendingRequests {
-    pub(crate) fn start(&mut self, request: PendingRequest) {
-        let id = request.id.clone();
-        let prev = self.map.insert(id.clone(), request);
-        assert!(prev.is_none(), "duplicate request with id {}", id);
-    }
-    pub(crate) fn cancel(&mut self, id: &RequestId) -> bool {
-        self.map.remove(id).is_some()
-    }
-    pub(crate) fn finish(&mut self, id: &RequestId) -> Option<CompletedRequest> {
-        self.map.remove(id).map(CompletedRequest::from)
-    }
-}
-const N_COMPLETED_REQUESTS: usize = 10;
-#[derive(Debug, Default)]
-pub struct LatestRequests {
-    // hand-rolling VecDeque here to print things in a nicer way
-    buf: [Option<CompletedRequest>; N_COMPLETED_REQUESTS],
-    idx: usize,
-}
-impl LatestRequests {
-    pub(crate) fn record(&mut self, request: CompletedRequest) {
-        // special case: don't track status request itself
-        if request.method == "rust-analyzer/analyzerStatus" {
-            return;
-        }
-        let idx = self.idx;
-        self.buf[idx] = Some(request);
-        self.idx = (idx + 1) % N_COMPLETED_REQUESTS;
-    }
-    pub(crate) fn iter(&self) -> impl Iterator<Item = (bool, &CompletedRequest)> {
-        let idx = self.idx;
-        self.buf.iter().enumerate().filter_map(move |(i, req)| Some((i == idx, req.as_ref()?)))
-    }
-}
diff --git a/crates/rust-analyzer/src/main_loop/request_metrics.rs b/crates/rust-analyzer/src/main_loop/request_metrics.rs
new file mode 100644
index 000000000..b1019e2d6
--- /dev/null
+++ b/crates/rust-analyzer/src/main_loop/request_metrics.rs
@@ -0,0 +1,37 @@
+//! Records stats about requests
+use std::time::Duration;
+use lsp_server::RequestId;
+#[derive(Debug)]
+pub(crate) struct RequestMetrics {
+    pub(crate) id: RequestId,
+    pub(crate) method: String,
+    pub(crate) duration: Duration,
+}
+const N_COMPLETED_REQUESTS: usize = 10;
+#[derive(Debug, Default)]
+pub(crate) struct LatestRequests {
+    // hand-rolling VecDeque here to print things in a nicer way
+    buf: [Option<RequestMetrics>; N_COMPLETED_REQUESTS],
+    idx: usize,
+}
+impl LatestRequests {
+    pub(crate) fn record(&mut self, request: RequestMetrics) {
+        // special case: don't track status request itself
+        if request.method == "rust-analyzer/analyzerStatus" {
+            return;
+        }
+        let idx = self.idx;
+        self.buf[idx] = Some(request);
+        self.idx = (idx + 1) % N_COMPLETED_REQUESTS;
+    }
+    pub(crate) fn iter(&self) -> impl Iterator<Item = (bool, &RequestMetrics)> {
+        let idx = self.idx;
+        self.buf.iter().enumerate().filter_map(move |(i, req)| Some((i == idx, req.as_ref()?)))
+    }
+}
diff --git a/crates/rust-analyzer/src/semantic_tokens.rs b/crates/rust-analyzer/src/semantic_tokens.rs
index 6f125c37c..2ea63d33b 100644
--- a/crates/rust-analyzer/src/semantic_tokens.rs
+++ b/crates/rust-analyzer/src/semantic_tokens.rs
@@ -45,6 +45,7 @@ define_semantic_token_types![
    (UNION, "union"),
    (UNRESOLVED_REFERENCE, "unresolvedReference"),
    (FORMAT_SPECIFIER, "formatSpecifier"),
+    (ESCAPE_SEQUENCE, "escapeSequence"),
 ];
 macro_rules! define_semantic_token_modifiers {
diff --git a/crates/rust-analyzer/src/to_proto.rs b/crates/rust-analyzer/src/to_proto.rs
index 881aa1c55..ec153097e 100644
--- a/crates/rust-analyzer/src/to_proto.rs
+++ b/crates/rust-analyzer/src/to_proto.rs
@@ -324,12 +324,14 @@ fn semantic_token_type_and_modifiers(
        HighlightTag::UnresolvedReference => semantic_tokens::UNRESOLVED_REFERENCE,
        HighlightTag::FormatSpecifier => semantic_tokens::FORMAT_SPECIFIER,
        HighlightTag::Operator => lsp_types::SemanticTokenType::OPERATOR,
+        HighlightTag::EscapeSequence => semantic_tokens::ESCAPE_SEQUENCE,
    };
    for modifier in highlight.modifiers.iter() {
        let modifier = match modifier {
            HighlightModifier::Attribute => semantic_tokens::ATTRIBUTE_MODIFIER,
            HighlightModifier::Definition => lsp_types::SemanticTokenModifier::DECLARATION,
+            HighlightModifier::Documentation => lsp_types::SemanticTokenModifier::DOCUMENTATION,
            HighlightModifier::ControlFlow => semantic_tokens::CONTROL_FLOW,
            HighlightModifier::Mutable => semantic_tokens::MUTABLE,
            HighlightModifier::Unsafe => semantic_tokens::UNSAFE,
@@ -528,13 +530,13 @@ pub(crate) fn resource_op(
    file_system_edit: FileSystemEdit,
 ) -> lsp_types::ResourceOp {
    match file_system_edit {
-        FileSystemEdit::CreateFile { source_root, path } => {
+        FileSystemEdit::CreateFile { anchor, dst } => {
-            let uri = snap.path_to_url(source_root, &path);
+            let uri = snap.anchored_path(anchor, &dst);
            lsp_types::ResourceOp::Create(lsp_types::CreateFile { uri, options: None })
        }
-        FileSystemEdit::MoveFile { src, dst_source_root, dst_path } => {
+        FileSystemEdit::MoveFile { src, anchor, dst } => {
            let old_uri = snap.file_id_to_url(src);
-            let new_uri = snap.path_to_url(dst_source_root, &dst_path);
+            let new_uri = snap.anchored_path(anchor, &dst);
            lsp_types::ResourceOp::Rename(lsp_types::RenameFile { old_uri, new_uri, options: None })
        }
    }
diff --git a/crates/stdx/src/lib.rs b/crates/stdx/src/lib.rs
index c0356344c..f2ff0e435 100644
--- a/crates/stdx/src/lib.rs
+++ b/crates/stdx/src/lib.rs
@@ -1,5 +1,4 @@
 //! Missing batteries for standard libraries.
 use std::{cell::Cell, fmt, time::Instant};
 #[inline(always)]
diff --git a/crates/vfs/Cargo.toml b/crates/vfs/Cargo.toml
new file mode 100644
index 000000000..c03e6363b
--- /dev/null
+++ b/crates/vfs/Cargo.toml
@@ -0,0 +1,14 @@
+[package]
+name = "vfs"
+version = "0.1.0"
+authors = ["rust-analyzer developers"]
+edition = "2018"
+[dependencies]
+rustc-hash = "1.0"
+jod-thread = "0.1.0"
+walkdir = "2.3.1"
+globset = "0.4.5"
+crossbeam-channel = "0.4.0"
+paths = { path = "../paths" }
diff --git a/crates/vfs/src/file_set.rs b/crates/vfs/src/file_set.rs
new file mode 100644
index 000000000..724606a3d
--- /dev/null
+++ b/crates/vfs/src/file_set.rs
@@ -0,0 +1,113 @@
+//! Partitions a list of files into disjoint subsets.
+//!
+//! Files which do not belong to any explicitly configured `FileSet` belong to
+//! the default `FileSet`.
+use std::{fmt, iter};
+use paths::AbsPathBuf;
+use rustc_hash::FxHashMap;
+use crate::{FileId, Vfs, VfsPath};
+#[derive(Default, Clone, Eq, PartialEq)]
+pub struct FileSet {
+    files: FxHashMap<VfsPath, FileId>,
+    paths: FxHashMap<FileId, VfsPath>,
+}
+impl FileSet {
+    pub fn resolve_path(&self, anchor: FileId, path: &str) -> Option<FileId> {
+        let mut base = self.paths[&anchor].clone();
+        base.pop();
+        let path = base.join(path);
+        let res = self.files.get(&path).copied();
+        res
+    }
+    pub fn insert(&mut self, file_id: FileId, path: VfsPath) {
+        self.files.insert(path.clone(), file_id);
+        self.paths.insert(file_id, path);
+    }
+    pub fn iter(&self) -> impl Iterator<Item = FileId> + '_ {
+        self.paths.keys().copied()
+    }
+}
+impl fmt::Debug for FileSet {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("FileSet").field("n_files", &self.files.len()).finish()
+    }
+}
+#[derive(Debug)]
+pub struct FileSetConfig {
+    n_file_sets: usize,
+    roots: Vec<(AbsPathBuf, usize)>,
+}
+impl Default for FileSetConfig {
+    fn default() -> Self {
+        FileSetConfig::builder().build()
+    }
+}
+impl FileSetConfig {
+    pub fn builder() -> FileSetConfigBuilder {
+        FileSetConfigBuilder::default()
+    }
+    pub fn partition(&self, vfs: &Vfs) -> Vec<FileSet> {
+        let mut res = vec![FileSet::default(); self.len()];
+        for (file_id, path) in vfs.iter() {
+            let root = self.classify(&path);
+            res[root].insert(file_id, path)
+        }
+        res
+    }
+    fn len(&self) -> usize {
+        self.n_file_sets
+    }
+    fn classify(&self, path: &VfsPath) -> usize {
+        let path = match path.as_path() {
+            Some(it) => it,
+            None => return self.len() - 1,
+        };
+        let idx = match self.roots.binary_search_by(|(p, _)| p.as_path().cmp(path)) {
+            Ok(it) => it,
+            Err(it) => it.saturating_sub(1),
+        };
+        if path.starts_with(&self.roots[idx].0) {
+            self.roots[idx].1
+        } else {
+            self.len() - 1
+        }
+    }
+}
+pub struct FileSetConfigBuilder {
+    roots: Vec<Vec<AbsPathBuf>>,
+}
+impl Default for FileSetConfigBuilder {
+    fn default() -> Self {
+        FileSetConfigBuilder { roots: Vec::new() }
+    }
+}
+impl FileSetConfigBuilder {
+    pub fn len(&self) -> usize {
+        self.roots.len()
+    }
+    pub fn add_file_set(&mut self, roots: Vec<AbsPathBuf>) {
+        self.roots.push(roots)
+    }
+    pub fn build(self) -> FileSetConfig {
+        let n_file_sets = self.roots.len() + 1;
+        let mut roots: Vec<(AbsPathBuf, usize)> = self
+            .roots
+            .into_iter()
+            .enumerate()
+            .flat_map(|(i, paths)| paths.into_iter().zip(iter::repeat(i)))
+            .collect();
+        roots.sort();
+        FileSetConfig { n_file_sets, roots }
+    }
+}
diff --git a/crates/vfs/src/lib.rs b/crates/vfs/src/lib.rs
new file mode 100644
index 000000000..055219b0c
--- /dev/null
+++ b/crates/vfs/src/lib.rs
@@ -0,0 +1,141 @@
+//! # Virtual File System
+//!
+//! VFS stores all files read by rust-analyzer. Reading file contents from VFS
+//! always returns the same contents, unless VFS was explicitly modified with
+//! `set_file_contents`. All changes to VFS are logged, and can be retrieved via
+//! `take_changes` method. The pack of changes is then pushed to `salsa` and
+//! triggers incremental recomputation.
+//!
+//! Files in VFS are identified with `FileId`s -- interned paths. The notion of
+//! the path, `VfsPath` is somewhat abstract: at the moment, it is represented
+//! as an `std::path::PathBuf` internally, but this is an implementation detail.
+//!
+//! VFS doesn't do IO or file watching itself. For that, see the `loader`
+//! module. `loader::Handle` is an object-safe trait which abstracts both file
+//! loading and file watching. `Handle` is dynamically configured with a set of
+//! directory entries which should be scanned and watched. `Handle` then
+//! asynchronously pushes file changes. Directory entries are configured in
+//! free-form via list of globs, it's up to the `Handle` to interpret the globs
+//! in any specific way.
+//!
+//! A simple `WalkdirLoaderHandle` is provided, which doesn't implement watching
+//! and just scans the directory using walkdir.
+//!
+//! VFS stores a flat list of files. `FileSet` can partition this list of files
+//! into disjoint sets of files. Traversal-like operations (including getting
+//! the neighbor file by the relative path) are handled by the `FileSet`.
+//! `FileSet`s are also pushed to salsa and cause it to re-check `mod foo;`
+//! declarations when files are created or deleted.
+//!
+//! `file_set::FileSet` and `loader::Entry` play similar, but different roles.
+//! Both specify the "set of paths/files", one is geared towards file watching,
+//! the other towards salsa changes. In particular, single `file_set::FileSet`
+//! may correspond to several `loader::Entry`. For example, a crate from
+//! crates.io which uses code generation would have two `Entries` -- for sources
+//! in `~/.cargo`, and for generated code in `./target/debug/build`. It will
+//! have a single `FileSet` which unions the two sources.
+mod vfs_path;
+mod path_interner;
+pub mod file_set;
+pub mod loader;
+pub mod walkdir_loader;
+use std::{fmt, mem};
+use crate::path_interner::PathInterner;
+pub use crate::vfs_path::VfsPath;
+pub use paths::{AbsPath, AbsPathBuf};
+#[derive(Copy, Clone, Debug, Ord, PartialOrd, Eq, PartialEq, Hash)]
+pub struct FileId(pub u32);
+#[derive(Default)]
+pub struct Vfs {
+    interner: PathInterner,
+    data: Vec<Option<Vec<u8>>>,
+    changes: Vec<ChangedFile>,
+}
+pub struct ChangedFile {
+    pub file_id: FileId,
+    pub change_kind: ChangeKind,
+}
+impl ChangedFile {
+    pub fn exists(&self) -> bool {
+        self.change_kind != ChangeKind::Delete
+    }
+    pub fn is_created_or_deleted(&self) -> bool {
+        matches!(self.change_kind, ChangeKind::Create | ChangeKind::Delete)
+    }
+}
+#[derive(Eq, PartialEq)]
+pub enum ChangeKind {
+    Create,
+    Modify,
+    Delete,
+}
+impl Vfs {
+    pub fn len(&self) -> usize {
+        self.data.len()
+    }
+    pub fn file_id(&self, path: &VfsPath) -> Option<FileId> {
+        self.interner.get(path).filter(|&it| self.get(it).is_some())
+    }
+    pub fn file_path(&self, file_id: FileId) -> VfsPath {
+        self.interner.lookup(file_id).clone()
+    }
+    pub fn file_contents(&self, file_id: FileId) -> &[u8] {
+        self.get(file_id).as_deref().unwrap()
+    }
+    pub fn iter(&self) -> impl Iterator<Item = (FileId, VfsPath)> + '_ {
+        (0..self.data.len())
+            .map(|it| FileId(it as u32))
+            .filter(move |&file_id| self.get(file_id).is_some())
+            .map(move |file_id| {
+                let path = self.interner.lookup(file_id).clone();
+                (file_id, path)
+            })
+    }
+    pub fn set_file_contents(&mut self, path: VfsPath, contents: Option<Vec<u8>>) {
+        let file_id = self.alloc_file_id(path);
+        let change_kind = match (&self.get(file_id), &contents) {
+            (None, None) => return,
+            (None, Some(_)) => ChangeKind::Create,
+            (Some(_), None) => ChangeKind::Delete,
+            (Some(old), Some(new)) if old == new => return,
+            (Some(_), Some(_)) => ChangeKind::Modify,
+        };
+        *self.get_mut(file_id) = contents;
+        self.changes.push(ChangedFile { file_id, change_kind })
+    }
+    pub fn has_changes(&self) -> bool {
+        !self.changes.is_empty()
+    }
+    pub fn take_changes(&mut self) -> Vec<ChangedFile> {
+        mem::take(&mut self.changes)
+    }
+    fn alloc_file_id(&mut self, path: VfsPath) -> FileId {
+        let file_id = self.interner.intern(path);
+        let idx = file_id.0 as usize;
+        let len = self.data.len().max(idx + 1);
+        self.data.resize_with(len, || None);
+        file_id
+    }
+    fn get(&self, file_id: FileId) -> &Option<Vec<u8>> {
+        &self.data[file_id.0 as usize]
+    }
+    fn get_mut(&mut self, file_id: FileId) -> &mut Option<Vec<u8>> {
+        &mut self.data[file_id.0 as usize]
+    }
+}
+impl fmt::Debug for Vfs {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Vfs").field("n_files", &self.data.len()).finish()
+    }
+}
diff --git a/crates/vfs/src/loader.rs b/crates/vfs/src/loader.rs
new file mode 100644
index 000000000..5a0ca68f3
--- /dev/null
+++ b/crates/vfs/src/loader.rs
@@ -0,0 +1,69 @@
+//! Object safe interface for file watching and reading.
+use std::fmt;
+use paths::AbsPathBuf;
+pub enum Entry {
+    Files(Vec<AbsPathBuf>),
+    Directory { path: AbsPathBuf, globs: Vec<String> },
+}
+pub struct Config {
+    pub load: Vec<Entry>,
+    pub watch: Vec<usize>,
+}
+pub enum Message {
+    DidSwitchConfig { n_entries: usize },
+    DidLoadAllEntries,
+    Loaded { files: Vec<(AbsPathBuf, Option<Vec<u8>>)> },
+}
+pub type Sender = Box<dyn Fn(Message) + Send>;
+pub trait Handle: fmt::Debug {
+    fn spawn(sender: Sender) -> Self
+    where
+        Self: Sized;
+    fn set_config(&mut self, config: Config);
+    fn invalidate(&mut self, path: AbsPathBuf);
+    fn load_sync(&mut self, path: &AbsPathBuf) -> Option<Vec<u8>>;
+}
+impl Entry {
+    pub fn rs_files_recursively(base: AbsPathBuf) -> Entry {
+        Entry::Directory { path: base, globs: globs(&["*.rs"]) }
+    }
+    pub fn local_cargo_package(base: AbsPathBuf) -> Entry {
+        Entry::Directory { path: base, globs: globs(&["*.rs", "!/target/"]) }
+    }
+    pub fn cargo_package_dependency(base: AbsPathBuf) -> Entry {
+        Entry::Directory {
+            path: base,
+            globs: globs(&["*.rs", "!/tests/", "!/examples/", "!/benches/"]),
+        }
+    }
+}
+fn globs(globs: &[&str]) -> Vec<String> {
+    globs.iter().map(|it| it.to_string()).collect()
+}
+impl fmt::Debug for Message {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Message::Loaded { files } => {
+                f.debug_struct("Loaded").field("n_files", &files.len()).finish()
+            }
+            Message::DidSwitchConfig { n_entries } => {
+                f.debug_struct("DidSwitchConfig").field("n_entries", n_entries).finish()
+            }
+            Message::DidLoadAllEntries => f.debug_struct("DidLoadAllEntries").finish(),
+        }
+    }
+}
+#[test]
+fn handle_is_object_safe() {
+    fn _assert(_: &dyn Handle) {}
+}
diff --git a/crates/vfs/src/path_interner.rs b/crates/vfs/src/path_interner.rs
new file mode 100644
index 000000000..4f70d61e8
--- /dev/null
+++ b/crates/vfs/src/path_interner.rs
@@ -0,0 +1,31 @@
+//! Maps paths to compact integer ids. We don't care about clearings paths which
+//! no longer exist -- the assumption is total size of paths we ever look at is
+//! not too big.
+use rustc_hash::FxHashMap;
+use crate::{FileId, VfsPath};
+#[derive(Default)]
+pub(crate) struct PathInterner {
+    map: FxHashMap<VfsPath, FileId>,
+    vec: Vec<VfsPath>,
+}
+impl PathInterner {
+    pub(crate) fn get(&self, path: &VfsPath) -> Option<FileId> {
+        self.map.get(path).copied()
+    }
+    pub(crate) fn intern(&mut self, path: VfsPath) -> FileId {
+        if let Some(id) = self.get(&path) {
+            return id;
+        }
+        let id = FileId(self.vec.len() as u32);
+        self.map.insert(path.clone(), id);
+        self.vec.push(path);
+        id
+    }
+    pub(crate) fn lookup(&self, id: FileId) -> &VfsPath {
+        &self.vec[id.0 as usize]
+    }
+}
diff --git a/crates/vfs/src/vfs_path.rs b/crates/vfs/src/vfs_path.rs
new file mode 100644
index 000000000..de5dc0bf3
--- /dev/null
+++ b/crates/vfs/src/vfs_path.rs
@@ -0,0 +1,49 @@
+//! Abstract-ish representation of paths for VFS.
+use std::fmt;
+use paths::{AbsPath, AbsPathBuf};
+/// Long-term, we want to support files which do not reside in the file-system,
+/// so we treat VfsPaths as opaque identifiers.
+#[derive(Debug, Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
+pub struct VfsPath(VfsPathRepr);
+impl VfsPath {
+    pub fn as_path(&self) -> Option<&AbsPath> {
+        match &self.0 {
+            VfsPathRepr::PathBuf(it) => Some(it.as_path()),
+        }
+    }
+    pub fn join(&self, path: &str) -> VfsPath {
+        match &self.0 {
+            VfsPathRepr::PathBuf(it) => {
+                let res = it.join(path).normalize();
+                VfsPath(VfsPathRepr::PathBuf(res))
+            }
+        }
+    }
+    pub fn pop(&mut self) -> bool {
+        match &mut self.0 {
+            VfsPathRepr::PathBuf(it) => it.pop(),
+        }
+    }
+}
+#[derive(Debug, Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
+enum VfsPathRepr {
+    PathBuf(AbsPathBuf),
+}
+impl From<AbsPathBuf> for VfsPath {
+    fn from(v: AbsPathBuf) -> Self {
+        VfsPath(VfsPathRepr::PathBuf(v))
+    }
+}
+impl fmt::Display for VfsPath {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match &self.0 {
+            VfsPathRepr::PathBuf(it) => fmt::Display::fmt(&it.display(), f),
+        }
+    }
+}
diff --git a/crates/vfs/src/walkdir_loader.rs b/crates/vfs/src/walkdir_loader.rs
new file mode 100644
index 000000000..13e59e3f3
--- /dev/null
+++ b/crates/vfs/src/walkdir_loader.rs
@@ -0,0 +1,108 @@
+//! A walkdir-based implementation of `loader::Handle`, which doesn't try to
+//! watch files.
+use std::convert::TryFrom;
+use globset::{Glob, GlobSetBuilder};
+use paths::{AbsPath, AbsPathBuf};
+use walkdir::WalkDir;
+use crate::loader;
+#[derive(Debug)]
+pub struct WalkdirLoaderHandle {
+    // Relative order of fields below is significant.
+    sender: crossbeam_channel::Sender<Message>,
+    _thread: jod_thread::JoinHandle,
+}
+enum Message {
+    Config(loader::Config),
+    Invalidate(AbsPathBuf),
+}
+impl loader::Handle for WalkdirLoaderHandle {
+    fn spawn(sender: loader::Sender) -> WalkdirLoaderHandle {
+        let actor = WalkdirLoaderActor { sender };
+        let (sender, receiver) = crossbeam_channel::unbounded::<Message>();
+        let thread = jod_thread::spawn(move || actor.run(receiver));
+        WalkdirLoaderHandle { sender, _thread: thread }
+    }
+    fn set_config(&mut self, config: loader::Config) {
+        self.sender.send(Message::Config(config)).unwrap()
+    }
+    fn invalidate(&mut self, path: AbsPathBuf) {
+        self.sender.send(Message::Invalidate(path)).unwrap();
+    }
+    fn load_sync(&mut self, path: &AbsPathBuf) -> Option<Vec<u8>> {
+        read(path)
+    }
+}
+struct WalkdirLoaderActor {
+    sender: loader::Sender,
+}
+impl WalkdirLoaderActor {
+    fn run(mut self, receiver: crossbeam_channel::Receiver<Message>) {
+        for msg in receiver {
+            match msg {
+                Message::Config(config) => {
+                    self.send(loader::Message::DidSwitchConfig { n_entries: config.load.len() });
+                    for entry in config.load.into_iter() {
+                        let files = self.load_entry(entry);
+                        self.send(loader::Message::Loaded { files });
+                    }
+                    drop(config.watch);
+                    self.send(loader::Message::DidLoadAllEntries);
+                }
+                Message::Invalidate(path) => {
+                    let contents = read(path.as_path());
+                    let files = vec![(path, contents)];
+                    self.send(loader::Message::Loaded { files });
+                }
+            }
+        }
+    }
+    fn load_entry(&mut self, entry: loader::Entry) -> Vec<(AbsPathBuf, Option<Vec<u8>>)> {
+        match entry {
+            loader::Entry::Files(files) => files
+                .into_iter()
+                .map(|file| {
+                    let contents = read(file.as_path());
+                    (file, contents)
+                })
+                .collect::<Vec<_>>(),
+            loader::Entry::Directory { path, globs } => {
+                let globset = {
+                    let mut builder = GlobSetBuilder::new();
+                    for glob in &globs {
+                        builder.add(Glob::new(glob).unwrap());
+                    }
+                    builder.build().unwrap()
+                };
+                let files = WalkDir::new(path)
+                    .into_iter()
+                    .filter_map(|it| it.ok())
+                    .filter(|it| it.file_type().is_file())
+                    .map(|it| it.into_path())
+                    .map(|it| AbsPathBuf::try_from(it).unwrap())
+                    .filter(|it| globset.is_match(&it));
+                files
+                    .map(|file| {
+                        let contents = read(file.as_path());
+                        (file, contents)
+                    })
+                    .collect()
+            }
+        }
+    }
+    fn send(&mut self, msg: loader::Message) {
+        (self.sender)(msg)
+    }
+}
+fn read(path: &AbsPath) -> Option<Vec<u8>> {
+    std::fs::read(path).ok()
+}