52 files changed, 4006 insertions, 1744 deletions

diff --git a/crates/ra_assists/src/ast_transform.rs b/crates/ra_assists/src/ast_transform.rs
index 9ac65ab39..3079a02a2 100644
--- a/crates/ra_assists/src/ast_transform.rs
+++ b/crates/ra_assists/src/ast_transform.rs
@@ -1,7 +1,7 @@
 //! `AstTransformer`s are functions that replace nodes in an AST and can be easily combined.
 use rustc_hash::FxHashMap;
 
-use hir::{PathResolution, SemanticsScope};
+use hir::{HirDisplay, PathResolution, SemanticsScope};
 use ra_ide_db::RootDatabase;
 use ra_syntax::{
     algo::SyntaxRewriter,
@@ -51,7 +51,27 @@ impl<'a> SubstituteTypeParams<'a> {
             .into_iter()
             // this is a trait impl, so we need to skip the first type parameter -- this is a bit hacky
             .skip(1)
-            .zip(substs.into_iter())
+            // The actual list of trait type parameters may be longer than the one
+            // used in the `impl` block due to trailing default type parametrs.
+            // For that case we extend the `substs` with an empty iterator so we
+            // can still hit those trailing values and check if they actually have
+            // a default type. If they do, go for that type from `hir` to `ast` so
+            // the resulting change can be applied correctly.
+            .zip(substs.into_iter().map(Some).chain(std::iter::repeat(None)))
+            .filter_map(|(k, v)| match v {
+                Some(v) => Some((k, v)),
+                None => {
+                    let default = k.default(source_scope.db)?;
+                    Some((
+                        k,
+                        ast::make::type_ref(
+                            &default
+                                .display_source_code(source_scope.db, source_scope.module()?.into())
+                                .ok()?,
+                        ),
+                    ))
+                }
+            })
             .collect();
         return SubstituteTypeParams {
             source_scope,
diff --git a/crates/ra_assists/src/handlers/add_custom_impl.rs b/crates/ra_assists/src/handlers/add_custom_impl.rs
index 795a225a4..2baeb8607 100644
--- a/crates/ra_assists/src/handlers/add_custom_impl.rs
+++ b/crates/ra_assists/src/handlers/add_custom_impl.rs
@@ -49,7 +49,7 @@ pub(crate) fn add_custom_impl(acc: &mut Assists, ctx: &AssistContext) -> Option<
     let start_offset = annotated.syntax().parent()?.text_range().end();
 
     let label =
-        format!("Add custom impl '{}' for '{}'", trait_token.text().as_str(), annotated_name);
+        format!("Add custom impl `{}` for `{}`", trait_token.text().as_str(), annotated_name);
 
     let target = attr.syntax().text_range();
     acc.add(AssistId("add_custom_impl"), label, target, |edit| {
diff --git a/crates/ra_assists/src/handlers/add_explicit_type.rs b/crates/ra_assists/src/handlers/add_explicit_type.rs
index 7ced00626..0c7d5e355 100644
--- a/crates/ra_assists/src/handlers/add_explicit_type.rs
+++ b/crates/ra_assists/src/handlers/add_explicit_type.rs
@@ -61,7 +61,7 @@ pub(crate) fn add_explicit_type(acc: &mut Assists, ctx: &AssistContext) -> Optio
     let inferred_type = ty.display_source_code(ctx.db, module.into()).ok()?;
     acc.add(
         AssistId("add_explicit_type"),
-        format!("Insert explicit type '{}'", inferred_type),
+        format!("Insert explicit type `{}`", inferred_type),
         pat_range,
         |builder| match ascribed_ty {
             Some(ascribed_ty) => {
diff --git a/crates/ra_assists/src/handlers/add_missing_impl_members.rs b/crates/ra_assists/src/handlers/add_missing_impl_members.rs
index c1ce87914..22e1156d2 100644
--- a/crates/ra_assists/src/handlers/add_missing_impl_members.rs
+++ b/crates/ra_assists/src/handlers/add_missing_impl_members.rs
@@ -618,4 +618,54 @@ impl Foo for S {
 }"#,
         )
     }
+
+    #[test]
+    fn test_generic_single_default_parameter() {
+        check_assist(
+            add_missing_impl_members,
+            r#"
+trait Foo<T = Self> {
+    fn bar(&self, other: &T);
+}
+
+struct S;
+impl Foo for S { <|> }"#,
+            r#"
+trait Foo<T = Self> {
+    fn bar(&self, other: &T);
+}
+
+struct S;
+impl Foo for S {
+    <|>fn bar(&self, other: &Self) {
+        todo!()
+    }
+}"#,
+        )
+    }
+
+    #[test]
+    fn test_generic_default_parameter_is_second() {
+        check_assist(
+            add_missing_impl_members,
+            r#"
+trait Foo<T1, T2 = Self> {
+    fn bar(&self, this: &T1, that: &T2);
+}
+
+struct S<T>;
+impl Foo<T> for S<T> { <|> }"#,
+            r#"
+trait Foo<T1, T2 = Self> {
+    fn bar(&self, this: &T1, that: &T2);
+}
+
+struct S<T>;
+impl Foo<T> for S<T> {
+    <|>fn bar(&self, this: &T, that: &Self) {
+        todo!()
+    }
+}"#,
+        )
+    }
 }
diff --git a/crates/ra_assists/src/handlers/change_visibility.rs b/crates/ra_assists/src/handlers/change_visibility.rs
index e631766ef..40cf4b422 100644
--- a/crates/ra_assists/src/handlers/change_visibility.rs
+++ b/crates/ra_assists/src/handlers/change_visibility.rs
@@ -5,11 +5,14 @@ use ra_syntax::{
         ATTR, COMMENT, CONST_DEF, ENUM_DEF, FN_DEF, MODULE, STRUCT_DEF, TRAIT_DEF, VISIBILITY,
         WHITESPACE,
     },
-    SyntaxNode, TextSize, T,
+    SyntaxNode, TextRange, TextSize, T,
 };
+
+use hir::{db::HirDatabase, HasSource, HasVisibility, PathResolution};
 use test_utils::tested_by;
 
 use crate::{AssistContext, AssistId, Assists};
+use ra_db::FileId;
 
 // Assist: change_visibility
 //
@@ -27,6 +30,8 @@ pub(crate) fn change_visibility(acc: &mut Assists, ctx: &AssistContext) -> Optio
         return change_vis(acc, vis);
     }
     add_vis(acc, ctx)
+        .or_else(|| add_vis_to_referenced_module_def(acc, ctx))
+        .or_else(|| add_vis_to_referenced_record_field(acc, ctx))
 }
 
 fn add_vis(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
@@ -72,6 +77,143 @@ fn add_vis(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
     })
 }
 
+fn add_vis_to_referenced_module_def(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
+    let path: ast::Path = ctx.find_node_at_offset()?;
+    let path_res = ctx.sema.resolve_path(&path)?;
+    let def = match path_res {
+        PathResolution::Def(def) => def,
+        _ => return None,
+    };
+
+    let current_module = ctx.sema.scope(&path.syntax()).module()?;
+    let target_module = def.module(ctx.db)?;
+
+    let vis = target_module.visibility_of(ctx.db, &def)?;
+    if vis.is_visible_from(ctx.db, current_module.into()) {
+        return None;
+    };
+
+    let (offset, target, target_file, target_name) = target_data_for_def(ctx.db, def)?;
+
+    let missing_visibility =
+        if current_module.krate() == target_module.krate() { "pub(crate)" } else { "pub" };
+
+    let assist_label = match target_name {
+        None => format!("Change visibility to {}", missing_visibility),
+        Some(name) => format!("Change visibility of {} to {}", name, missing_visibility),
+    };
+
+    acc.add(AssistId("change_visibility"), assist_label, target, |edit| {
+        edit.set_file(target_file);
+        edit.insert(offset, format!("{} ", missing_visibility));
+        edit.set_cursor(offset);
+    })
+}
+
+fn add_vis_to_referenced_record_field(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
+    let record_field: ast::RecordField = ctx.find_node_at_offset()?;
+    let (record_field_def, _) = ctx.sema.resolve_record_field(&record_field)?;
+
+    let current_module = ctx.sema.scope(record_field.syntax()).module()?;
+    let visibility = record_field_def.visibility(ctx.db);
+    if visibility.is_visible_from(ctx.db, current_module.into()) {
+        return None;
+    }
+
+    let parent = record_field_def.parent_def(ctx.db);
+    let parent_name = parent.name(ctx.db);
+    let target_module = parent.module(ctx.db);
+
+    let in_file_source = record_field_def.source(ctx.db);
+    let (offset, target) = match in_file_source.value {
+        hir::FieldSource::Named(it) => {
+            let s = it.syntax();
+            (vis_offset(s), s.text_range())
+        }
+        hir::FieldSource::Pos(it) => {
+            let s = it.syntax();
+            (vis_offset(s), s.text_range())
+        }
+    };
+
+    let missing_visibility =
+        if current_module.krate() == target_module.krate() { "pub(crate)" } else { "pub" };
+    let target_file = in_file_source.file_id.original_file(ctx.db);
+
+    let target_name = record_field_def.name(ctx.db);
+    let assist_label =
+        format!("Change visibility of {}.{} to {}", parent_name, target_name, missing_visibility);
+
+    acc.add(AssistId("change_visibility"), assist_label, target, |edit| {
+        edit.set_file(target_file);
+        edit.insert(offset, format!("{} ", missing_visibility));
+        edit.set_cursor(offset)
+    })
+}
+
+fn target_data_for_def(
+    db: &dyn HirDatabase,
+    def: hir::ModuleDef,
+) -> Option<(TextSize, TextRange, FileId, Option<hir::Name>)> {
+    fn offset_target_and_file_id<S, Ast>(
+        db: &dyn HirDatabase,
+        x: S,
+    ) -> (TextSize, TextRange, FileId)
+    where
+        S: HasSource<Ast = Ast>,
+        Ast: AstNode,
+    {
+        let source = x.source(db);
+        let in_file_syntax = source.syntax();
+        let file_id = in_file_syntax.file_id;
+        let syntax = in_file_syntax.value;
+        (vis_offset(syntax), syntax.text_range(), file_id.original_file(db.upcast()))
+    }
+
+    let target_name;
+    let (offset, target, target_file) = match def {
+        hir::ModuleDef::Function(f) => {
+            target_name = Some(f.name(db));
+            offset_target_and_file_id(db, f)
+        }
+        hir::ModuleDef::Adt(adt) => {
+            target_name = Some(adt.name(db));
+            match adt {
+                hir::Adt::Struct(s) => offset_target_and_file_id(db, s),
+                hir::Adt::Union(u) => offset_target_and_file_id(db, u),
+                hir::Adt::Enum(e) => offset_target_and_file_id(db, e),
+            }
+        }
+        hir::ModuleDef::Const(c) => {
+            target_name = c.name(db);
+            offset_target_and_file_id(db, c)
+        }
+        hir::ModuleDef::Static(s) => {
+            target_name = s.name(db);
+            offset_target_and_file_id(db, s)
+        }
+        hir::ModuleDef::Trait(t) => {
+            target_name = Some(t.name(db));
+            offset_target_and_file_id(db, t)
+        }
+        hir::ModuleDef::TypeAlias(t) => {
+            target_name = Some(t.name(db));
+            offset_target_and_file_id(db, t)
+        }
+        hir::ModuleDef::Module(m) => {
+            target_name = m.name(db);
+            let in_file_source = m.declaration_source(db)?;
+            let file_id = in_file_source.file_id.original_file(db.upcast());
+            let syntax = in_file_source.value.syntax();
+            (vis_offset(syntax), syntax.text_range(), file_id)
+        }
+        // Enum variants can't be private, we can't modify builtin types
+        hir::ModuleDef::EnumVariant(_) | hir::ModuleDef::BuiltinType(_) => return None,
+    };
+
+    Some((offset, target, target_file, target_name))
+}
+
 fn vis_offset(node: &SyntaxNode) -> TextSize {
     node.children_with_tokens()
         .skip_while(|it| match it.kind() {
@@ -192,6 +334,378 @@ mod tests {
     }
 
     #[test]
+    fn change_visibility_of_fn_via_path() {
+        check_assist(
+            change_visibility,
+            r"mod foo { fn foo() {} }
+              fn main() { foo::foo<|>() } ",
+            r"mod foo { <|>pub(crate) fn foo() {} }
+              fn main() { foo::foo() } ",
+        );
+        check_assist_not_applicable(
+            change_visibility,
+            r"mod foo { pub fn foo() {} }
+              fn main() { foo::foo<|>() } ",
+        )
+    }
+
+    #[test]
+    fn change_visibility_of_adt_in_submodule_via_path() {
+        check_assist(
+            change_visibility,
+            r"mod foo { struct Foo; }
+              fn main() { foo::Foo<|> } ",
+            r"mod foo { <|>pub(crate) struct Foo; }
+              fn main() { foo::Foo } ",
+        );
+        check_assist_not_applicable(
+            change_visibility,
+            r"mod foo { pub struct Foo; }
+              fn main() { foo::Foo<|> } ",
+        );
+        check_assist(
+            change_visibility,
+            r"mod foo { enum Foo; }
+              fn main() { foo::Foo<|> } ",
+            r"mod foo { <|>pub(crate) enum Foo; }
+              fn main() { foo::Foo } ",
+        );
+        check_assist_not_applicable(
+            change_visibility,
+            r"mod foo { pub enum Foo; }
+              fn main() { foo::Foo<|> } ",
+        );
+        check_assist(
+            change_visibility,
+            r"mod foo { union Foo; }
+              fn main() { foo::Foo<|> } ",
+            r"mod foo { <|>pub(crate) union Foo; }
+              fn main() { foo::Foo } ",
+        );
+        check_assist_not_applicable(
+            change_visibility,
+            r"mod foo { pub union Foo; }
+              fn main() { foo::Foo<|> } ",
+        );
+    }
+
+    #[test]
+    fn change_visibility_of_adt_in_other_file_via_path() {
+        check_assist(
+            change_visibility,
+            r"
+              //- /main.rs
+              mod foo;
+              fn main() { foo::Foo<|> }
+
+              //- /foo.rs
+              struct Foo;
+              ",
+            r"<|>pub(crate) struct Foo;
+
+",
+        );
+    }
+
+    #[test]
+    fn change_visibility_of_struct_field_via_path() {
+        check_assist(
+            change_visibility,
+            r"mod foo { pub struct Foo { bar: (), } }
+              fn main() { foo::Foo { <|>bar: () }; } ",
+            r"mod foo { pub struct Foo { <|>pub(crate) bar: (), } }
+              fn main() { foo::Foo { bar: () }; } ",
+        );
+        check_assist(
+            change_visibility,
+            r"//- /lib.rs
+              mod foo;
+              fn main() { foo::Foo { <|>bar: () }; }
+              //- /foo.rs
+              pub struct Foo { bar: () }
+              ",
+            r"pub struct Foo { <|>pub(crate) bar: () }
+
+",
+        );
+        check_assist_not_applicable(
+            change_visibility,
+            r"mod foo { pub struct Foo { pub bar: (), } }
+              fn main() { foo::Foo { <|>bar: () }; } ",
+        );
+        check_assist_not_applicable(
+            change_visibility,
+            r"//- /lib.rs
+              mod foo;
+              fn main() { foo::Foo { <|>bar: () }; }
+              //- /foo.rs
+              pub struct Foo { pub bar: () }
+              ",
+        );
+    }
+
+    #[test]
+    fn change_visibility_of_enum_variant_field_via_path() {
+        check_assist(
+            change_visibility,
+            r"mod foo { pub enum Foo { Bar { bar: () } } }
+              fn main() { foo::Foo::Bar { <|>bar: () }; } ",
+            r"mod foo { pub enum Foo { Bar { <|>pub(crate) bar: () } } }
+              fn main() { foo::Foo::Bar { bar: () }; } ",
+        );
+        check_assist(
+            change_visibility,
+            r"//- /lib.rs
+              mod foo;
+              fn main() { foo::Foo::Bar { <|>bar: () }; }
+              //- /foo.rs
+              pub enum Foo { Bar { bar: () } }
+              ",
+            r"pub enum Foo { Bar { <|>pub(crate) bar: () } }
+
+",
+        );
+        check_assist_not_applicable(
+            change_visibility,
+            r"mod foo { pub struct Foo { pub bar: (), } }
+              fn main() { foo::Foo { <|>bar: () }; } ",
+        );
+        check_assist_not_applicable(
+            change_visibility,
+            r"//- /lib.rs
+              mod foo;
+              fn main() { foo::Foo { <|>bar: () }; }
+              //- /foo.rs
+              pub struct Foo { pub bar: () }
+              ",
+        );
+    }
+
+    #[test]
+    #[ignore]
+    // FIXME reenable this test when `Semantics::resolve_record_field` works with union fields
+    fn change_visibility_of_union_field_via_path() {
+        check_assist(
+            change_visibility,
+            r"mod foo { pub union Foo { bar: (), } }
+              fn main() { foo::Foo { <|>bar: () }; } ",
+            r"mod foo { pub union Foo { <|>pub(crate) bar: (), } }
+              fn main() { foo::Foo { bar: () }; } ",
+        );
+        check_assist(
+            change_visibility,
+            r"//- /lib.rs
+              mod foo;
+              fn main() { foo::Foo { <|>bar: () }; }
+              //- /foo.rs
+              pub union Foo { bar: () }
+              ",
+            r"pub union Foo { <|>pub(crate) bar: () }
+
+",
+        );
+        check_assist_not_applicable(
+            change_visibility,
+            r"mod foo { pub union Foo { pub bar: (), } }
+              fn main() { foo::Foo { <|>bar: () }; } ",
+        );
+        check_assist_not_applicable(
+            change_visibility,
+            r"//- /lib.rs
+              mod foo;
+              fn main() { foo::Foo { <|>bar: () }; }
+              //- /foo.rs
+              pub union Foo { pub bar: () }
+              ",
+        );
+    }
+
+    #[test]
+    fn not_applicable_for_enum_variants() {
+        check_assist_not_applicable(
+            change_visibility,
+            r"mod foo { pub enum Foo {Foo1} }
+              fn main() { foo::Foo::Foo1<|> } ",
+        );
+    }
+
+    #[test]
+    fn change_visibility_of_const_via_path() {
+        check_assist(
+            change_visibility,
+            r"mod foo { const FOO: () = (); }
+              fn main() { foo::FOO<|> } ",
+            r"mod foo { <|>pub(crate) const FOO: () = (); }
+              fn main() { foo::FOO } ",
+        );
+        check_assist_not_applicable(
+            change_visibility,
+            r"mod foo { pub const FOO: () = (); }
+              fn main() { foo::FOO<|> } ",
+        );
+    }
+
+    #[test]
+    fn change_visibility_of_static_via_path() {
+        check_assist(
+            change_visibility,
+            r"mod foo { static FOO: () = (); }
+              fn main() { foo::FOO<|> } ",
+            r"mod foo { <|>pub(crate) static FOO: () = (); }
+              fn main() { foo::FOO } ",
+        );
+        check_assist_not_applicable(
+            change_visibility,
+            r"mod foo { pub static FOO: () = (); }
+              fn main() { foo::FOO<|> } ",
+        );
+    }
+
+    #[test]
+    fn change_visibility_of_trait_via_path() {
+        check_assist(
+            change_visibility,
+            r"mod foo { trait Foo { fn foo(&self) {} } }
+              fn main() { let x: &dyn foo::<|>Foo; } ",
+            r"mod foo { <|>pub(crate) trait Foo { fn foo(&self) {} } }
+              fn main() { let x: &dyn foo::Foo; } ",
+        );
+        check_assist_not_applicable(
+            change_visibility,
+            r"mod foo { pub trait Foo { fn foo(&self) {} } }
+              fn main() { let x: &dyn foo::Foo<|>; } ",
+        );
+    }
+
+    #[test]
+    fn change_visibility_of_type_alias_via_path() {
+        check_assist(
+            change_visibility,
+            r"mod foo { type Foo = (); }
+              fn main() { let x: foo::Foo<|>; } ",
+            r"mod foo { <|>pub(crate) type Foo = (); }
+              fn main() { let x: foo::Foo; } ",
+        );
+        check_assist_not_applicable(
+            change_visibility,
+            r"mod foo { pub type Foo = (); }
+              fn main() { let x: foo::Foo<|>; } ",
+        );
+    }
+
+    #[test]
+    fn change_visibility_of_module_via_path() {
+        check_assist(
+            change_visibility,
+            r"mod foo { mod bar { fn bar() {} } }
+              fn main() { foo::bar<|>::bar(); } ",
+            r"mod foo { <|>pub(crate) mod bar { fn bar() {} } }
+              fn main() { foo::bar::bar(); } ",
+        );
+
+        check_assist(
+            change_visibility,
+            r"
+            //- /main.rs
+            mod foo;
+            fn main() { foo::bar<|>::baz(); }
+
+            //- /foo.rs
+            mod bar {
+                pub fn baz() {}
+            }
+            ",
+            r"<|>pub(crate) mod bar {
+    pub fn baz() {}
+}
+
+",
+        );
+
+        check_assist_not_applicable(
+            change_visibility,
+            r"mod foo { pub mod bar { pub fn bar() {} } }
+              fn main() { foo::bar<|>::bar(); } ",
+        );
+    }
+
+    #[test]
+    fn change_visibility_of_inline_module_in_other_file_via_path() {
+        check_assist(
+            change_visibility,
+            r"
+            //- /main.rs
+            mod foo;
+            fn main() { foo::bar<|>::baz(); }
+
+            //- /foo.rs
+            mod bar;
+
+            //- /foo/bar.rs
+            pub fn baz() {}
+            }
+            ",
+            r"<|>pub(crate) mod bar;
+",
+        );
+    }
+
+    #[test]
+    fn change_visibility_of_module_declaration_in_other_file_via_path() {
+        check_assist(
+            change_visibility,
+            r"//- /main.rs
+              mod foo;
+              fn main() { foo::bar<|>>::baz(); }
+
+              //- /foo.rs
+              mod bar {
+                  pub fn baz() {}
+              }",
+            r"<|>pub(crate) mod bar {
+    pub fn baz() {}
+}
+",
+        );
+    }
+
+    #[test]
+    #[ignore]
+    // FIXME handle reexports properly
+    fn change_visibility_of_reexport() {
+        check_assist(
+            change_visibility,
+            r"
+            mod foo {
+                use bar::Baz;
+                mod bar { pub(super) struct Baz; }
+            }
+            foo::Baz<|>
+            ",
+            r"
+            mod foo {
+                <|>pub(crate) use bar::Baz;
+                mod bar { pub(super) struct Baz; }
+            }
+            foo::Baz
+            ",
+        )
+    }
+
+    #[test]
+    fn adds_pub_when_target_is_in_another_crate() {
+        check_assist(
+            change_visibility,
+            r"//- /main.rs crate:a deps:foo
+              foo::Bar<|>
+              //- /lib.rs crate:foo
+              struct Bar;",
+            r"<|>pub struct Bar;
+",
+        )
+    }
+
+    #[test]
     fn change_visibility_target() {
         check_assist_target(change_visibility, "<|>fn foo() {}", "fn");
         check_assist_target(change_visibility, "pub(crate)<|> fn foo() {}", "pub(crate)");
diff --git a/crates/ra_assists/src/utils.rs b/crates/ra_assists/src/utils.rs
index 2f15a3f15..f3fc92ebf 100644
--- a/crates/ra_assists/src/utils.rs
+++ b/crates/ra_assists/src/utils.rs
@@ -103,7 +103,7 @@ fn invert_special_case(expr: &ast::Expr) -> Option<ast::Expr> {
 }
 
 #[derive(Clone, Copy)]
-pub(crate) enum TryEnum {
+pub enum TryEnum {
     Result,
     Option,
 }
@@ -111,7 +111,7 @@ pub(crate) enum TryEnum {
 impl TryEnum {
     const ALL: [TryEnum; 2] = [TryEnum::Option, TryEnum::Result];
 
-    pub(crate) fn from_ty(sema: &Semantics<RootDatabase>, ty: &Type) -> Option<TryEnum> {
+    pub fn from_ty(sema: &Semantics<RootDatabase>, ty: &Type) -> Option<TryEnum> {
         let enum_ = match ty.as_adt() {
             Some(Adt::Enum(it)) => it,
             _ => return None,
diff --git a/crates/ra_db/src/fixture.rs b/crates/ra_db/src/fixture.rs
index 51d4c493e..f8f767091 100644
--- a/crates/ra_db/src/fixture.rs
+++ b/crates/ra_db/src/fixture.rs
@@ -2,7 +2,7 @@
 //! A fixture without metadata is parsed into a single source file.
 //! Use this to test functionality local to one file.
 //!
-//! Example:
+//! Simple Example:
 //! ```
 //! r#"
 //! fn main() {
@@ -15,7 +15,7 @@
 //! The basic form is specifying filenames,
 //! which is also how to define multiple files in a single test fixture
 //!
-//! Example:
+//! Example using two files in the same crate:
 //! ```
 //! "
 //! //- /main.rs
@@ -29,6 +29,20 @@
 //! "
 //! ```
 //!
+//! Example using two crates with one file each, with one crate depending on the other:
+//! ```
+//! r#"
+//! //- /main.rs crate:a deps:b
+//! fn main() {
+//!     b::foo();
+//! }
+//! //- /lib.rs crate:b
+//! pub fn b() {
+//!     println!("Hello World")
+//! }
+//! "#
+//! ```
+//!
 //! Metadata allows specifying all settings and variables
 //! that are available in a real rust project:
 //! - crate names via `crate:cratename`
@@ -36,7 +50,7 @@
 //! - configuration settings via `cfg:dbg=false,opt_level=2`
 //! - environment variables via `env:PATH=/bin,RUST_LOG=debug`
 //!
-//! Example:
+//! Example using all available metadata:
 //! ```
 //! "
 //! //- /lib.rs crate:foo deps:bar,baz cfg:foo=a,bar=b env:OUTDIR=path/to,OTHER=foo
diff --git a/crates/ra_flycheck/Cargo.toml b/crates/ra_flycheck/Cargo.toml
index eac502da5..1aa39bade 100644
--- a/crates/ra_flycheck/Cargo.toml
+++ b/crates/ra_flycheck/Cargo.toml
@@ -9,12 +9,8 @@ doctest = false
 
 [dependencies]
 crossbeam-channel = "0.4.0"
-lsp-types = { version = "0.74.0", features = ["proposed"] }
 log = "0.4.8"
 cargo_metadata = "0.10.0"
 serde_json = "1.0.48"
 jod-thread = "0.1.1"
 ra_toolchain = { path = "../ra_toolchain" }
-
-[dev-dependencies]
-insta = "0.16.0"
diff --git a/crates/ra_flycheck/src/conv.rs b/crates/ra_flycheck/src/conv.rs
deleted file mode 100644
index 817543deb..000000000
--- a/crates/ra_flycheck/src/conv.rs
+++ /dev/null
@@ -1,341 +0,0 @@
-//! This module provides the functionality needed to convert diagnostics from
-//! `cargo check` json format to the LSP diagnostic format.
-use cargo_metadata::diagnostic::{
-    Applicability, Diagnostic as RustDiagnostic, DiagnosticLevel, DiagnosticSpan,
-    DiagnosticSpanMacroExpansion,
-};
-use lsp_types::{
-    CodeAction, Diagnostic, DiagnosticRelatedInformation, DiagnosticSeverity, DiagnosticTag,
-    Location, NumberOrString, Position, Range, TextEdit, Url, WorkspaceEdit,
-};
-use std::{
-    collections::HashMap,
-    fmt::Write,
-    path::{Component, Path, PathBuf, Prefix},
-    str::FromStr,
-};
-
-#[cfg(test)]
-mod test;
-
-/// Converts a Rust level string to a LSP severity
-fn map_level_to_severity(val: DiagnosticLevel) -> Option<DiagnosticSeverity> {
-    match val {
-        DiagnosticLevel::Ice => Some(DiagnosticSeverity::Error),
-        DiagnosticLevel::Error => Some(DiagnosticSeverity::Error),
-        DiagnosticLevel::Warning => Some(DiagnosticSeverity::Warning),
-        DiagnosticLevel::Note => Some(DiagnosticSeverity::Information),
-        DiagnosticLevel::Help => Some(DiagnosticSeverity::Hint),
-        DiagnosticLevel::Unknown => None,
-    }
-}
-
-/// Check whether a file name is from macro invocation
-fn is_from_macro(file_name: &str) -> bool {
-    file_name.starts_with('<') && file_name.ends_with('>')
-}
-
-/// Converts a Rust macro span to a LSP location recursively
-fn map_macro_span_to_location(
-    span_macro: &DiagnosticSpanMacroExpansion,
-    workspace_root: &PathBuf,
-) -> Option<Location> {
-    if !is_from_macro(&span_macro.span.file_name) {
-        return Some(map_span_to_location(&span_macro.span, workspace_root));
-    }
-
-    if let Some(expansion) = &span_macro.span.expansion {
-        return map_macro_span_to_location(&expansion, workspace_root);
-    }
-
-    None
-}
-
-/// Converts a Rust span to a LSP location, resolving macro expansion site if neccesary
-fn map_span_to_location(span: &DiagnosticSpan, workspace_root: &PathBuf) -> Location {
-    if span.expansion.is_some() {
-        let expansion = span.expansion.as_ref().unwrap();
-        if let Some(macro_range) = map_macro_span_to_location(&expansion, workspace_root) {
-            return macro_range;
-        }
-    }
-
-    map_span_to_location_naive(span, workspace_root)
-}
-
-/// Converts a Rust span to a LSP location
-fn map_span_to_location_naive(span: &DiagnosticSpan, workspace_root: &PathBuf) -> Location {
-    let mut file_name = workspace_root.clone();
-    file_name.push(&span.file_name);
-    let uri = url_from_path_with_drive_lowercasing(file_name).unwrap();
-
-    let range = Range::new(
-        Position::new(span.line_start as u64 - 1, span.column_start as u64 - 1),
-        Position::new(span.line_end as u64 - 1, span.column_end as u64 - 1),
-    );
-
-    Location { uri, range }
-}
-
-/// Converts a secondary Rust span to a LSP related information
-///
-/// If the span is unlabelled this will return `None`.
-fn map_secondary_span_to_related(
-    span: &DiagnosticSpan,
-    workspace_root: &PathBuf,
-) -> Option<DiagnosticRelatedInformation> {
-    if let Some(label) = &span.label {
-        let location = map_span_to_location(span, workspace_root);
-        Some(DiagnosticRelatedInformation { location, message: label.clone() })
-    } else {
-        // Nothing to label this with
-        None
-    }
-}
-
-/// Determines if diagnostic is related to unused code
-fn is_unused_or_unnecessary(rd: &RustDiagnostic) -> bool {
-    if let Some(code) = &rd.code {
-        match code.code.as_str() {
-            "dead_code" | "unknown_lints" | "unreachable_code" | "unused_attributes"
-            | "unused_imports" | "unused_macros" | "unused_variables" => true,
-            _ => false,
-        }
-    } else {
-        false
-    }
-}
-
-/// Determines if diagnostic is related to deprecated code
-fn is_deprecated(rd: &RustDiagnostic) -> bool {
-    if let Some(code) = &rd.code {
-        match code.code.as_str() {
-            "deprecated" => true,
-            _ => false,
-        }
-    } else {
-        false
-    }
-}
-
-enum MappedRustChildDiagnostic {
-    Related(DiagnosticRelatedInformation),
-    SuggestedFix(CodeAction),
-    MessageLine(String),
-}
-
-fn map_rust_child_diagnostic(
-    rd: &RustDiagnostic,
-    workspace_root: &PathBuf,
-) -> MappedRustChildDiagnostic {
-    let spans: Vec<&DiagnosticSpan> = rd.spans.iter().filter(|s| s.is_primary).collect();
-    if spans.is_empty() {
-        // `rustc` uses these spanless children as a way to print multi-line
-        // messages
-        return MappedRustChildDiagnostic::MessageLine(rd.message.clone());
-    }
-
-    let mut edit_map: HashMap<Url, Vec<TextEdit>> = HashMap::new();
-    for &span in &spans {
-        match (&span.suggestion_applicability, &span.suggested_replacement) {
-            (Some(Applicability::MachineApplicable), Some(suggested_replacement)) => {
-                let location = map_span_to_location(span, workspace_root);
-                let edit = TextEdit::new(location.range, suggested_replacement.clone());
-                edit_map.entry(location.uri).or_default().push(edit);
-            }
-            _ => {}
-        }
-    }
-
-    if !edit_map.is_empty() {
-        MappedRustChildDiagnostic::SuggestedFix(CodeAction {
-            title: rd.message.clone(),
-            kind: Some("quickfix".to_string()),
-            diagnostics: None,
-            edit: Some(WorkspaceEdit::new(edit_map)),
-            command: None,
-            is_preferred: None,
-        })
-    } else {
-        MappedRustChildDiagnostic::Related(DiagnosticRelatedInformation {
-            location: map_span_to_location(spans[0], workspace_root),
-            message: rd.message.clone(),
-        })
-    }
-}
-
-#[derive(Debug)]
-pub(crate) struct MappedRustDiagnostic {
-    pub location: Location,
-    pub diagnostic: Diagnostic,
-    pub fixes: Vec<CodeAction>,
-}
-
-/// Converts a Rust root diagnostic to LSP form
-///
-/// This flattens the Rust diagnostic by:
-///
-/// 1. Creating a LSP diagnostic with the root message and primary span.
-/// 2. Adding any labelled secondary spans to `relatedInformation`
-/// 3. Categorising child diagnostics as either `SuggestedFix`es,
-///    `relatedInformation` or additional message lines.
-///
-/// If the diagnostic has no primary span this will return `None`
-pub(crate) fn map_rust_diagnostic_to_lsp(
-    rd: &RustDiagnostic,
-    workspace_root: &PathBuf,
-) -> Vec<MappedRustDiagnostic> {
-    let primary_spans: Vec<&DiagnosticSpan> = rd.spans.iter().filter(|s| s.is_primary).collect();
-    if primary_spans.is_empty() {
-        return vec![];
-    }
-
-    let severity = map_level_to_severity(rd.level);
-
-    let mut source = String::from("rustc");
-    let mut code = rd.code.as_ref().map(|c| c.code.clone());
-    if let Some(code_val) = &code {
-        // See if this is an RFC #2103 scoped lint (e.g. from Clippy)
-        let scoped_code: Vec<&str> = code_val.split("::").collect();
-        if scoped_code.len() == 2 {
-            source = String::from(scoped_code[0]);
-            code = Some(String::from(scoped_code[1]));
-        }
-    }
-
-    let mut needs_primary_span_label = true;
-    let mut related_information = vec![];
-    let mut tags = vec![];
-
-    for secondary_span in rd.spans.iter().filter(|s| !s.is_primary) {
-        let related = map_secondary_span_to_related(secondary_span, workspace_root);
-        if let Some(related) = related {
-            related_information.push(related);
-        }
-    }
-
-    let mut fixes = vec![];
-    let mut message = rd.message.clone();
-    for child in &rd.children {
-        let child = map_rust_child_diagnostic(&child, workspace_root);
-        match child {
-            MappedRustChildDiagnostic::Related(related) => related_information.push(related),
-            MappedRustChildDiagnostic::SuggestedFix(code_action) => fixes.push(code_action),
-            MappedRustChildDiagnostic::MessageLine(message_line) => {
-                write!(&mut message, "\n{}", message_line).unwrap();
-
-                // These secondary messages usually duplicate the content of the
-                // primary span label.
-                needs_primary_span_label = false;
-            }
-        }
-    }
-
-    if is_unused_or_unnecessary(rd) {
-        tags.push(DiagnosticTag::Unnecessary);
-    }
-
-    if is_deprecated(rd) {
-        tags.push(DiagnosticTag::Deprecated);
-    }
-
-    primary_spans
-        .iter()
-        .map(|primary_span| {
-            let location = map_span_to_location(&primary_span, workspace_root);
-
-            let mut message = message.clone();
-            if needs_primary_span_label {
-                if let Some(primary_span_label) = &primary_span.label {
-                    write!(&mut message, "\n{}", primary_span_label).unwrap();
-                }
-            }
-
-            // If error occurs from macro expansion, add related info pointing to
-            // where the error originated
-            if !is_from_macro(&primary_span.file_name) && primary_span.expansion.is_some() {
-                let def_loc = map_span_to_location_naive(&primary_span, workspace_root);
-                related_information.push(DiagnosticRelatedInformation {
-                    location: def_loc,
-                    message: "Error originated from macro here".to_string(),
-                });
-            }
-
-            let diagnostic = Diagnostic {
-                range: location.range,
-                severity,
-                code: code.clone().map(NumberOrString::String),
-                source: Some(source.clone()),
-                message,
-                related_information: if !related_information.is_empty() {
-                    Some(related_information.clone())
-                } else {
-                    None
-                },
-                tags: if !tags.is_empty() { Some(tags.clone()) } else { None },
-            };
-
-            MappedRustDiagnostic { location, diagnostic, fixes: fixes.clone() }
-        })
-        .collect()
-}
-
-/// Returns a `Url` object from a given path, will lowercase drive letters if present.
-/// This will only happen when processing windows paths.
-///
-/// When processing non-windows path, this is essentially the same as `Url::from_file_path`.
-pub fn url_from_path_with_drive_lowercasing(
-    path: impl AsRef<Path>,
-) -> Result<Url, Box<dyn std::error::Error + Send + Sync>> {
-    let component_has_windows_drive = path.as_ref().components().any(|comp| {
-        if let Component::Prefix(c) = comp {
-            match c.kind() {
-                Prefix::Disk(_) | Prefix::VerbatimDisk(_) => return true,
-                _ => return false,
-            }
-        }
-        false
-    });
-
-    // VSCode expects drive letters to be lowercased, where rust will uppercase the drive letters.
-    if component_has_windows_drive {
-        let url_original = Url::from_file_path(&path)
-            .map_err(|_| format!("can't convert path to url: {}", path.as_ref().display()))?;
-
-        let drive_partition: Vec<&str> = url_original.as_str().rsplitn(2, ':').collect();
-
-        // There is a drive partition, but we never found a colon.
-        // This should not happen, but in this case we just pass it through.
-        if drive_partition.len() == 1 {
-            return Ok(url_original);
-        }
-
-        let joined = drive_partition[1].to_ascii_lowercase() + ":" + drive_partition[0];
-        let url = Url::from_str(&joined).expect("This came from a valid `Url`");
-
-        Ok(url)
-    } else {
-        Ok(Url::from_file_path(&path)
-            .map_err(|_| format!("can't convert path to url: {}", path.as_ref().display()))?)
-    }
-}
-
-// `Url` is not able to parse windows paths on unix machines.
-#[cfg(target_os = "windows")]
-#[cfg(test)]
-mod path_conversion_windows_tests {
-    use super::url_from_path_with_drive_lowercasing;
-    #[test]
-    fn test_lowercase_drive_letter_with_drive() {
-        let url = url_from_path_with_drive_lowercasing("C:\\Test").unwrap();
-
-        assert_eq!(url.to_string(), "file:///c:/Test");
-    }
-
-    #[test]
-    fn test_drive_without_colon_passthrough() {
-        let url = url_from_path_with_drive_lowercasing(r#"\\localhost\C$\my_dir"#).unwrap();
-
-        assert_eq!(url.to_string(), "file://localhost/C$/my_dir");
-    }
-}
diff --git a/crates/ra_flycheck/src/conv/test.rs b/crates/ra_flycheck/src/conv/test.rs
deleted file mode 100644
index 4e81455ca..000000000
--- a/crates/ra_flycheck/src/conv/test.rs
+++ /dev/null
@@ -1,1072 +0,0 @@
-//! This module contains the large and verbose snapshot tests for the
-//! conversions between `cargo check` json and LSP diagnostics.
-#[cfg(not(windows))]
-use crate::*;
-
-#[cfg(not(windows))]
-fn parse_diagnostic(val: &str) -> cargo_metadata::diagnostic::Diagnostic {
-    serde_json::from_str::<cargo_metadata::diagnostic::Diagnostic>(val).unwrap()
-}
-
-#[test]
-#[cfg(not(windows))]
-fn snap_rustc_incompatible_type_for_trait() {
-    let diag = parse_diagnostic(
-        r##"{
-            "message": "method `next` has an incompatible type for trait",
-            "code": {
-                "code": "E0053",
-                "explanation": "\nThe parameters of any trait method must match between a trait implementation\nand the trait definition.\n\nHere are a couple examples of this error:\n\n```compile_fail,E0053\ntrait Foo {\n    fn foo(x: u16);\n    fn bar(&self);\n}\n\nstruct Bar;\n\nimpl Foo for Bar {\n    // error, expected u16, found i16\n    fn foo(x: i16) { }\n\n    // error, types differ in mutability\n    fn bar(&mut self) { }\n}\n```\n"
-            },
-            "level": "error",
-            "spans": [
-                {
-                    "file_name": "compiler/ty/list_iter.rs",
-                    "byte_start": 1307,
-                    "byte_end": 1350,
-                    "line_start": 52,
-                    "line_end": 52,
-                    "column_start": 5,
-                    "column_end": 48,
-                    "is_primary": true,
-                    "text": [
-                        {
-                            "text": "    fn next(&self) -> Option<&'list ty::Ref<M>> {",
-                            "highlight_start": 5,
-                            "highlight_end": 48
-                        }
-                    ],
-                    "label": "types differ in mutability",
-                    "suggested_replacement": null,
-                    "suggestion_applicability": null,
-                    "expansion": null
-                }
-            ],
-            "children": [
-                {
-                    "message": "expected type `fn(&mut ty::list_iter::ListIterator<'list, M>) -> std::option::Option<&ty::Ref<M>>`\n   found type `fn(&ty::list_iter::ListIterator<'list, M>) -> std::option::Option<&'list ty::Ref<M>>`",
-                    "code": null,
-                    "level": "note",
-                    "spans": [],
-                    "children": [],
-                    "rendered": null
-                }
-            ],
-            "rendered": "error[E0053]: method `next` has an incompatible type for trait\n  --> compiler/ty/list_iter.rs:52:5\n   |\n52 |     fn next(&self) -> Option<&'list ty::Ref<M>> {\n   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ types differ in mutability\n   |\n   = note: expected type `fn(&mut ty::list_iter::ListIterator<'list, M>) -> std::option::Option<&ty::Ref<M>>`\n              found type `fn(&ty::list_iter::ListIterator<'list, M>) -> std::option::Option<&'list ty::Ref<M>>`\n\n"
-        }
-        "##,
-    );
-
-    let workspace_root = PathBuf::from("/test/");
-    let diag = map_rust_diagnostic_to_lsp(&diag, &workspace_root);
-    insta::assert_debug_snapshot!(diag);
-}
-
-#[test]
-#[cfg(not(windows))]
-fn snap_rustc_unused_variable() {
-    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 workspace_root = PathBuf::from("/test/");
-    let diag = map_rust_diagnostic_to_lsp(&diag, &workspace_root);
-    insta::assert_debug_snapshot!(diag);
-}
-
-#[test]
-#[cfg(not(windows))]
-fn snap_rustc_wrong_number_of_parameters() {
-    let diag = parse_diagnostic(
-        r##"{
-"message": "this function takes 2 parameters but 3 parameters were supplied",
-"code": {
-    "code": "E0061",
-    "explanation": "\nThe number of arguments passed to a function must match the number of arguments\nspecified in the function signature.\n\nFor example, a function like:\n\n```\nfn f(a: u16, b: &str) {}\n```\n\nMust always be called with exactly two arguments, e.g., `f(2, \"test\")`.\n\nNote that Rust does not have a notion of optional function arguments or\nvariadic functions (except for its C-FFI).\n"
-},
-"level": "error",
-"spans": [
-    {
-        "file_name": "compiler/ty/select.rs",
-        "byte_start": 8787,
-        "byte_end": 9241,
-        "line_start": 219,
-        "line_end": 231,
-        "column_start": 5,
-        "column_end": 6,
-        "is_primary": false,
-        "text": [
-            {
-                "text": "    pub fn add_evidence(",
-                "highlight_start": 5,
-                "highlight_end": 25
-            },
-            {
-                "text": "        &mut self,",
-                "highlight_start": 1,
-                "highlight_end": 19
-            },
-            {
-                "text": "        target_poly: &ty::Ref<ty::Poly>,",
-                "highlight_start": 1,
-                "highlight_end": 41
-            },
-            {
-                "text": "        evidence_poly: &ty::Ref<ty::Poly>,",
-                "highlight_start": 1,
-                "highlight_end": 43
-            },
-            {
-                "text": "    ) {",
-                "highlight_start": 1,
-                "highlight_end": 8
-            },
-            {
-                "text": "        match target_poly {",
-                "highlight_start": 1,
-                "highlight_end": 28
-            },
-            {
-                "text": "            ty::Ref::Var(tvar, _) => self.add_var_evidence(tvar, evidence_poly),",
-                "highlight_start": 1,
-                "highlight_end": 81
-            },
-            {
-                "text": "            ty::Ref::Fixed(target_ty) => {",
-                "highlight_start": 1,
-                "highlight_end": 43
-            },
-            {
-                "text": "                let evidence_ty = evidence_poly.resolve_to_ty();",
-                "highlight_start": 1,
-                "highlight_end": 65
-            },
-            {
-                "text": "                self.add_evidence_ty(target_ty, evidence_poly, evidence_ty)",
-                "highlight_start": 1,
-                "highlight_end": 76
-            },
-            {
-                "text": "            }",
-                "highlight_start": 1,
-                "highlight_end": 14
-            },
-            {
-                "text": "        }",
-                "highlight_start": 1,
-                "highlight_end": 10
-            },
-            {
-                "text": "    }",
-                "highlight_start": 1,
-                "highlight_end": 6
-            }
-        ],
-        "label": "defined here",
-        "suggested_replacement": null,
-        "suggestion_applicability": null,
-        "expansion": null
-    },
-    {
-        "file_name": "compiler/ty/select.rs",
-        "byte_start": 4045,
-        "byte_end": 4057,
-        "line_start": 104,
-        "line_end": 104,
-        "column_start": 18,
-        "column_end": 30,
-        "is_primary": true,
-        "text": [
-            {
-                "text": "            self.add_evidence(target_fixed, evidence_fixed, false);",
-                "highlight_start": 18,
-                "highlight_end": 30
-            }
-        ],
-        "label": "expected 2 parameters",
-        "suggested_replacement": null,
-        "suggestion_applicability": null,
-        "expansion": null
-    }
-],
-"children": [],
-"rendered": "error[E0061]: this function takes 2 parameters but 3 parameters were supplied\n   --> compiler/ty/select.rs:104:18\n    |\n104 |               self.add_evidence(target_fixed, evidence_fixed, false);\n    |                    ^^^^^^^^^^^^ expected 2 parameters\n...\n219 | /     pub fn add_evidence(\n220 | |         &mut self,\n221 | |         target_poly: &ty::Ref<ty::Poly>,\n222 | |         evidence_poly: &ty::Ref<ty::Poly>,\n...   |\n230 | |         }\n231 | |     }\n    | |_____- defined here\n\n"
-}"##,
-    );
-
-    let workspace_root = PathBuf::from("/test/");
-    let diag = map_rust_diagnostic_to_lsp(&diag, &workspace_root);
-    insta::assert_debug_snapshot!(diag);
-}
-
-#[test]
-#[cfg(not(windows))]
-fn snap_clippy_pass_by_ref() {
-    let diag = parse_diagnostic(
-        r##"{
-"message": "this argument is passed by reference, but would be more efficient if passed by value",
-"code": {
-    "code": "clippy::trivially_copy_pass_by_ref",
-    "explanation": null
-},
-"level": "warning",
-"spans": [
-    {
-        "file_name": "compiler/mir/tagset.rs",
-        "byte_start": 941,
-        "byte_end": 946,
-        "line_start": 42,
-        "line_end": 42,
-        "column_start": 24,
-        "column_end": 29,
-        "is_primary": true,
-        "text": [
-            {
-                "text": "    pub fn is_disjoint(&self, other: Self) -> bool {",
-                "highlight_start": 24,
-                "highlight_end": 29
-            }
-        ],
-        "label": null,
-        "suggested_replacement": null,
-        "suggestion_applicability": null,
-        "expansion": null
-    }
-],
-"children": [
-    {
-        "message": "lint level defined here",
-        "code": null,
-        "level": "note",
-        "spans": [
-            {
-                "file_name": "compiler/lib.rs",
-                "byte_start": 8,
-                "byte_end": 19,
-                "line_start": 1,
-                "line_end": 1,
-                "column_start": 9,
-                "column_end": 20,
-                "is_primary": true,
-                "text": [
-                    {
-                        "text": "#![warn(clippy::all)]",
-                        "highlight_start": 9,
-                        "highlight_end": 20
-                    }
-                ],
-                "label": null,
-                "suggested_replacement": null,
-                "suggestion_applicability": null,
-                "expansion": null
-            }
-        ],
-        "children": [],
-        "rendered": null
-    },
-    {
-        "message": "#[warn(clippy::trivially_copy_pass_by_ref)] implied by #[warn(clippy::all)]",
-        "code": null,
-        "level": "note",
-        "spans": [],
-        "children": [],
-        "rendered": null
-    },
-    {
-        "message": "for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#trivially_copy_pass_by_ref",
-        "code": null,
-        "level": "help",
-        "spans": [],
-        "children": [],
-        "rendered": null
-    },
-    {
-        "message": "consider passing by value instead",
-        "code": null,
-        "level": "help",
-        "spans": [
-            {
-                "file_name": "compiler/mir/tagset.rs",
-                "byte_start": 941,
-                "byte_end": 946,
-                "line_start": 42,
-                "line_end": 42,
-                "column_start": 24,
-                "column_end": 29,
-                "is_primary": true,
-                "text": [
-                    {
-                        "text": "    pub fn is_disjoint(&self, other: Self) -> bool {",
-                        "highlight_start": 24,
-                        "highlight_end": 29
-                    }
-                ],
-                "label": null,
-                "suggested_replacement": "self",
-                "suggestion_applicability": "Unspecified",
-                "expansion": null
-            }
-        ],
-        "children": [],
-        "rendered": null
-    }
-],
-"rendered": "warning: this argument is passed by reference, but would be more efficient if passed by value\n  --> compiler/mir/tagset.rs:42:24\n   |\n42 |     pub fn is_disjoint(&self, other: Self) -> bool {\n   |                        ^^^^^ help: consider passing by value instead: `self`\n   |\nnote: lint level defined here\n  --> compiler/lib.rs:1:9\n   |\n1  | #![warn(clippy::all)]\n   |         ^^^^^^^^^^^\n   = note: #[warn(clippy::trivially_copy_pass_by_ref)] implied by #[warn(clippy::all)]\n   = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#trivially_copy_pass_by_ref\n\n"
-}"##,
-    );
-
-    let workspace_root = PathBuf::from("/test/");
-    let diag = map_rust_diagnostic_to_lsp(&diag, &workspace_root);
-    insta::assert_debug_snapshot!(diag);
-}
-
-#[test]
-#[cfg(not(windows))]
-fn snap_rustc_mismatched_type() {
-    let diag = parse_diagnostic(
-        r##"{
-"message": "mismatched types",
-"code": {
-    "code": "E0308",
-    "explanation": "\nThis error occurs when the compiler was unable to infer the concrete type of a\nvariable. It can occur for several cases, the most common of which is a\nmismatch in the expected type that the compiler inferred for a variable's\ninitializing expression, and the actual type explicitly assigned to the\nvariable.\n\nFor example:\n\n```compile_fail,E0308\nlet x: i32 = \"I am not a number!\";\n//     ~~~   ~~~~~~~~~~~~~~~~~~~~\n//      |             |\n//      |    initializing expression;\n//      |    compiler infers type `&str`\n//      |\n//    type `i32` assigned to variable `x`\n```\n"
-},
-"level": "error",
-"spans": [
-    {
-        "file_name": "runtime/compiler_support.rs",
-        "byte_start": 1589,
-        "byte_end": 1594,
-        "line_start": 48,
-        "line_end": 48,
-        "column_start": 65,
-        "column_end": 70,
-        "is_primary": true,
-        "text": [
-            {
-                "text": "    let layout = alloc::Layout::from_size_align_unchecked(size, align);",
-                "highlight_start": 65,
-                "highlight_end": 70
-            }
-        ],
-        "label": "expected usize, found u32",
-        "suggested_replacement": null,
-        "suggestion_applicability": null,
-        "expansion": null
-    }
-],
-"children": [],
-"rendered": "error[E0308]: mismatched types\n  --> runtime/compiler_support.rs:48:65\n   |\n48 |     let layout = alloc::Layout::from_size_align_unchecked(size, align);\n   |                                                                 ^^^^^ expected usize, found u32\n\n"
-}"##,
-    );
-
-    let workspace_root = PathBuf::from("/test/");
-    let diag = map_rust_diagnostic_to_lsp(&diag, &workspace_root);
-    insta::assert_debug_snapshot!(diag);
-}
-
-#[test]
-#[cfg(not(windows))]
-fn snap_handles_macro_location() {
-    let diag = parse_diagnostic(
-        r##"{
-"rendered": "error[E0277]: can't compare `{integer}` with `&str`\n --> src/main.rs:2:5\n  |\n2 |     assert_eq!(1, \"love\");\n  |     ^^^^^^^^^^^^^^^^^^^^^^ no implementation for `{integer} == &str`\n  |\n  = help: the trait `std::cmp::PartialEq<&str>` is not implemented for `{integer}`\n  = note: this error originates in a macro outside of the current crate (in Nightly builds, run with -Z external-macro-backtrace for more info)\n\n",
-"children": [
-    {
-        "children": [],
-        "code": null,
-        "level": "help",
-        "message": "the trait `std::cmp::PartialEq<&str>` is not implemented for `{integer}`",
-        "rendered": null,
-        "spans": []
-    }
-],
-"code": {
-    "code": "E0277",
-    "explanation": "\nYou tried to use a type which doesn't implement some trait in a place which\nexpected that trait. Erroneous code example:\n\n```compile_fail,E0277\n// here we declare the Foo trait with a bar method\ntrait Foo {\n    fn bar(&self);\n}\n\n// we now declare a function which takes an object implementing the Foo trait\nfn some_func<T: Foo>(foo: T) {\n    foo.bar();\n}\n\nfn main() {\n    // we now call the method with the i32 type, which doesn't implement\n    // the Foo trait\n    some_func(5i32); // error: the trait bound `i32 : Foo` is not satisfied\n}\n```\n\nIn order to fix this error, verify that the type you're using does implement\nthe trait. Example:\n\n```\ntrait Foo {\n    fn bar(&self);\n}\n\nfn some_func<T: Foo>(foo: T) {\n    foo.bar(); // we can now use this method since i32 implements the\n               // Foo trait\n}\n\n// we implement the trait on the i32 type\nimpl Foo for i32 {\n    fn bar(&self) {}\n}\n\nfn main() {\n    some_func(5i32); // ok!\n}\n```\n\nOr in a generic context, an erroneous code example would look like:\n\n```compile_fail,E0277\nfn some_func<T>(foo: T) {\n    println!(\"{:?}\", foo); // error: the trait `core::fmt::Debug` is not\n                           //        implemented for the type `T`\n}\n\nfn main() {\n    // We now call the method with the i32 type,\n    // which *does* implement the Debug trait.\n    some_func(5i32);\n}\n```\n\nNote that the error here is in the definition of the generic function: Although\nwe only call it with a parameter that does implement `Debug`, the compiler\nstill rejects the function: It must work with all possible input types. In\norder to make this example compile, we need to restrict the generic type we're\naccepting:\n\n```\nuse std::fmt;\n\n// Restrict the input type to types that implement Debug.\nfn some_func<T: fmt::Debug>(foo: T) {\n    println!(\"{:?}\", foo);\n}\n\nfn main() {\n    // Calling the method is still fine, as i32 implements Debug.\n    some_func(5i32);\n\n    // This would fail to compile now:\n    // struct WithoutDebug;\n    // some_func(WithoutDebug);\n}\n```\n\nRust only looks at the signature of the called function, as such it must\nalready specify all requirements that will be used for every type parameter.\n"
-},
-"level": "error",
-"message": "can't compare `{integer}` with `&str`",
-"spans": [
-    {
-        "byte_end": 155,
-        "byte_start": 153,
-        "column_end": 33,
-        "column_start": 31,
-        "expansion": {
-            "def_site_span": {
-                "byte_end": 940,
-                "byte_start": 0,
-                "column_end": 6,
-                "column_start": 1,
-                "expansion": null,
-                "file_name": "<::core::macros::assert_eq macros>",
-                "is_primary": false,
-                "label": null,
-                "line_end": 36,
-                "line_start": 1,
-                "suggested_replacement": null,
-                "suggestion_applicability": null,
-                "text": [
-                    {
-                        "highlight_end": 35,
-                        "highlight_start": 1,
-                        "text": "($ left : expr, $ right : expr) =>"
-                    },
-                    {
-                        "highlight_end": 3,
-                        "highlight_start": 1,
-                        "text": "({"
-                    },
-                    {
-                        "highlight_end": 33,
-                        "highlight_start": 1,
-                        "text": "     match (& $ left, & $ right)"
-                    },
-                    {
-                        "highlight_end": 7,
-                        "highlight_start": 1,
-                        "text": "     {"
-                    },
-                    {
-                        "highlight_end": 34,
-                        "highlight_start": 1,
-                        "text": "         (left_val, right_val) =>"
-                    },
-                    {
-                        "highlight_end": 11,
-                        "highlight_start": 1,
-                        "text": "         {"
-                    },
-                    {
-                        "highlight_end": 46,
-                        "highlight_start": 1,
-                        "text": "             if ! (* left_val == * right_val)"
-                    },
-                    {
-                        "highlight_end": 15,
-                        "highlight_start": 1,
-                        "text": "             {"
-                    },
-                    {
-                        "highlight_end": 25,
-                        "highlight_start": 1,
-                        "text": "                 panic !"
-                    },
-                    {
-                        "highlight_end": 57,
-                        "highlight_start": 1,
-                        "text": "                 (r#\"assertion failed: `(left == right)`"
-                    },
-                    {
-                        "highlight_end": 16,
-                        "highlight_start": 1,
-                        "text": "  left: `{:?}`,"
-                    },
-                    {
-                        "highlight_end": 18,
-                        "highlight_start": 1,
-                        "text": " right: `{:?}`\"#,"
-                    },
-                    {
-                        "highlight_end": 47,
-                        "highlight_start": 1,
-                        "text": "                  & * left_val, & * right_val)"
-                    },
-                    {
-                        "highlight_end": 15,
-                        "highlight_start": 1,
-                        "text": "             }"
-                    },
-                    {
-                        "highlight_end": 11,
-                        "highlight_start": 1,
-                        "text": "         }"
-                    },
-                    {
-                        "highlight_end": 7,
-                        "highlight_start": 1,
-                        "text": "     }"
-                    },
-                    {
-                        "highlight_end": 42,
-                        "highlight_start": 1,
-                        "text": " }) ; ($ left : expr, $ right : expr,) =>"
-                    },
-                    {
-                        "highlight_end": 49,
-                        "highlight_start": 1,
-                        "text": "({ $ crate :: assert_eq ! ($ left, $ right) }) ;"
-                    },
-                    {
-                        "highlight_end": 53,
-                        "highlight_start": 1,
-                        "text": "($ left : expr, $ right : expr, $ ($ arg : tt) +) =>"
-                    },
-                    {
-                        "highlight_end": 3,
-                        "highlight_start": 1,
-                        "text": "({"
-                    },
-                    {
-                        "highlight_end": 37,
-                        "highlight_start": 1,
-                        "text": "     match (& ($ left), & ($ right))"
-                    },
-                    {
-                        "highlight_end": 7,
-                        "highlight_start": 1,
-                        "text": "     {"
-                    },
-                    {
-                        "highlight_end": 34,
-                        "highlight_start": 1,
-                        "text": "         (left_val, right_val) =>"
-                    },
-                    {
-                        "highlight_end": 11,
-                        "highlight_start": 1,
-                        "text": "         {"
-                    },
-                    {
-                        "highlight_end": 46,
-                        "highlight_start": 1,
-                        "text": "             if ! (* left_val == * right_val)"
-                    },
-                    {
-                        "highlight_end": 15,
-                        "highlight_start": 1,
-                        "text": "             {"
-                    },
-                    {
-                        "highlight_end": 25,
-                        "highlight_start": 1,
-                        "text": "                 panic !"
-                    },
-                    {
-                        "highlight_end": 57,
-                        "highlight_start": 1,
-                        "text": "                 (r#\"assertion failed: `(left == right)`"
-                    },
-                    {
-                        "highlight_end": 16,
-                        "highlight_start": 1,
-                        "text": "  left: `{:?}`,"
-                    },
-                    {
-                        "highlight_end": 22,
-                        "highlight_start": 1,
-                        "text": " right: `{:?}`: {}\"#,"
-                    },
-                    {
-                        "highlight_end": 72,
-                        "highlight_start": 1,
-                        "text": "                  & * left_val, & * right_val, $ crate :: format_args !"
-                    },
-                    {
-                        "highlight_end": 33,
-                        "highlight_start": 1,
-                        "text": "                  ($ ($ arg) +))"
-                    },
-                    {
-                        "highlight_end": 15,
-                        "highlight_start": 1,
-                        "text": "             }"
-                    },
-                    {
-                        "highlight_end": 11,
-                        "highlight_start": 1,
-                        "text": "         }"
-                    },
-                    {
-                        "highlight_end": 7,
-                        "highlight_start": 1,
-                        "text": "     }"
-                    },
-                    {
-                        "highlight_end": 6,
-                        "highlight_start": 1,
-                        "text": " }) ;"
-                    }
-                ]
-            },
-            "macro_decl_name": "assert_eq!",
-            "span": {
-                "byte_end": 38,
-                "byte_start": 16,
-                "column_end": 27,
-                "column_start": 5,
-                "expansion": null,
-                "file_name": "src/main.rs",
-                "is_primary": false,
-                "label": null,
-                "line_end": 2,
-                "line_start": 2,
-                "suggested_replacement": null,
-                "suggestion_applicability": null,
-                "text": [
-                    {
-                        "highlight_end": 27,
-                        "highlight_start": 5,
-                        "text": "    assert_eq!(1, \"love\");"
-                    }
-                ]
-            }
-        },
-        "file_name": "<::core::macros::assert_eq macros>",
-        "is_primary": true,
-        "label": "no implementation for `{integer} == &str`",
-        "line_end": 7,
-        "line_start": 7,
-        "suggested_replacement": null,
-        "suggestion_applicability": null,
-        "text": [
-            {
-                "highlight_end": 33,
-                "highlight_start": 31,
-                "text": "             if ! (* left_val == * right_val)"
-            }
-        ]
-    }
-]
-}"##,
-    );
-
-    let workspace_root = PathBuf::from("/test/");
-    let diag = map_rust_diagnostic_to_lsp(&diag, &workspace_root);
-    insta::assert_debug_snapshot!(diag);
-}
-
-#[test]
-#[cfg(not(windows))]
-fn snap_macro_compiler_error() {
-    let diag = parse_diagnostic(
-        r##"{
-    "rendered": "error: Please register your known path in the path module\n   --> crates/ra_hir_def/src/path.rs:265:9\n    |\n265 |         compile_error!(\"Please register your known path in the path module\")\n    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n    | \n   ::: crates/ra_hir_def/src/data.rs:80:16\n    |\n80  |     let path = path![std::future::Future];\n    |                -------------------------- in this macro invocation\n\n",
-    "children": [],
-    "code": null,
-    "level": "error",
-    "message": "Please register your known path in the path module",
-    "spans": [
-        {
-            "byte_end": 8285,
-            "byte_start": 8217,
-            "column_end": 77,
-            "column_start": 9,
-            "expansion": {
-                "def_site_span": {
-                    "byte_end": 8294,
-                    "byte_start": 7858,
-                    "column_end": 2,
-                    "column_start": 1,
-                    "expansion": null,
-                    "file_name": "crates/ra_hir_def/src/path.rs",
-                    "is_primary": false,
-                    "label": null,
-                    "line_end": 267,
-                    "line_start": 254,
-                    "suggested_replacement": null,
-                    "suggestion_applicability": null,
-                    "text": [
-                        {
-                            "highlight_end": 28,
-                            "highlight_start": 1,
-                            "text": "macro_rules! __known_path {"
-                        },
-                        {
-                            "highlight_end": 37,
-                            "highlight_start": 1,
-                            "text": "    (std::iter::IntoIterator) => {};"
-                        },
-                        {
-                            "highlight_end": 33,
-                            "highlight_start": 1,
-                            "text": "    (std::result::Result) => {};"
-                        },
-                        {
-                            "highlight_end": 29,
-                            "highlight_start": 1,
-                            "text": "    (std::ops::Range) => {};"
-                        },
-                        {
-                            "highlight_end": 33,
-                            "highlight_start": 1,
-                            "text": "    (std::ops::RangeFrom) => {};"
-                        },
-                        {
-                            "highlight_end": 33,
-                            "highlight_start": 1,
-                            "text": "    (std::ops::RangeFull) => {};"
-                        },
-                        {
-                            "highlight_end": 31,
-                            "highlight_start": 1,
-                            "text": "    (std::ops::RangeTo) => {};"
-                        },
-                        {
-                            "highlight_end": 40,
-                            "highlight_start": 1,
-                            "text": "    (std::ops::RangeToInclusive) => {};"
-                        },
-                        {
-                            "highlight_end": 38,
-                            "highlight_start": 1,
-                            "text": "    (std::ops::RangeInclusive) => {};"
-                        },
-                        {
-                            "highlight_end": 27,
-                            "highlight_start": 1,
-                            "text": "    (std::ops::Try) => {};"
-                        },
-                        {
-                            "highlight_end": 22,
-                            "highlight_start": 1,
-                            "text": "    ($path:path) => {"
-                        },
-                        {
-                            "highlight_end": 77,
-                            "highlight_start": 1,
-                            "text": "        compile_error!(\"Please register your known path in the path module\")"
-                        },
-                        {
-                            "highlight_end": 7,
-                            "highlight_start": 1,
-                            "text": "    };"
-                        },
-                        {
-                            "highlight_end": 2,
-                            "highlight_start": 1,
-                            "text": "}"
-                        }
-                    ]
-                },
-                "macro_decl_name": "$crate::__known_path!",
-                "span": {
-                    "byte_end": 8427,
-                    "byte_start": 8385,
-                    "column_end": 51,
-                    "column_start": 9,
-                    "expansion": {
-                        "def_site_span": {
-                            "byte_end": 8611,
-                            "byte_start": 8312,
-                            "column_end": 2,
-                            "column_start": 1,
-                            "expansion": null,
-                            "file_name": "crates/ra_hir_def/src/path.rs",
-                            "is_primary": false,
-                            "label": null,
-                            "line_end": 277,
-                            "line_start": 270,
-                            "suggested_replacement": null,
-                            "suggestion_applicability": null,
-                            "text": [
-                                {
-                                    "highlight_end": 22,
-                                    "highlight_start": 1,
-                                    "text": "macro_rules! __path {"
-                                },
-                                {
-                                    "highlight_end": 43,
-                                    "highlight_start": 1,
-                                    "text": "    ($start:ident $(:: $seg:ident)*) => ({"
-                                },
-                                {
-                                    "highlight_end": 51,
-                                    "highlight_start": 1,
-                                    "text": "        $crate::__known_path!($start $(:: $seg)*);"
-                                },
-                                {
-                                    "highlight_end": 87,
-                                    "highlight_start": 1,
-                                    "text": "        $crate::path::ModPath::from_simple_segments($crate::path::PathKind::Abs, vec!["
-                                },
-                                {
-                                    "highlight_end": 76,
-                                    "highlight_start": 1,
-                                    "text": "            $crate::path::__name![$start], $($crate::path::__name![$seg],)*"
-                                },
-                                {
-                                    "highlight_end": 11,
-                                    "highlight_start": 1,
-                                    "text": "        ])"
-                                },
-                                {
-                                    "highlight_end": 8,
-                                    "highlight_start": 1,
-                                    "text": "    });"
-                                },
-                                {
-                                    "highlight_end": 2,
-                                    "highlight_start": 1,
-                                    "text": "}"
-                                }
-                            ]
-                        },
-                        "macro_decl_name": "path!",
-                        "span": {
-                            "byte_end": 2966,
-                            "byte_start": 2940,
-                            "column_end": 42,
-                            "column_start": 16,
-                            "expansion": null,
-                            "file_name": "crates/ra_hir_def/src/data.rs",
-                            "is_primary": false,
-                            "label": null,
-                            "line_end": 80,
-                            "line_start": 80,
-                            "suggested_replacement": null,
-                            "suggestion_applicability": null,
-                            "text": [
-                                {
-                                    "highlight_end": 42,
-                                    "highlight_start": 16,
-                                    "text": "    let path = path![std::future::Future];"
-                                }
-                            ]
-                        }
-                    },
-                    "file_name": "crates/ra_hir_def/src/path.rs",
-                    "is_primary": false,
-                    "label": null,
-                    "line_end": 272,
-                    "line_start": 272,
-                    "suggested_replacement": null,
-                    "suggestion_applicability": null,
-                    "text": [
-                        {
-                            "highlight_end": 51,
-                            "highlight_start": 9,
-                            "text": "        $crate::__known_path!($start $(:: $seg)*);"
-                        }
-                    ]
-                }
-            },
-            "file_name": "crates/ra_hir_def/src/path.rs",
-            "is_primary": true,
-            "label": null,
-            "line_end": 265,
-            "line_start": 265,
-            "suggested_replacement": null,
-            "suggestion_applicability": null,
-            "text": [
-                {
-                    "highlight_end": 77,
-                    "highlight_start": 9,
-                    "text": "        compile_error!(\"Please register your known path in the path module\")"
-                }
-            ]
-        }
-    ]
-}
-        "##,
-    );
-
-    let workspace_root = PathBuf::from("/test/");
-    let diag = map_rust_diagnostic_to_lsp(&diag, &workspace_root);
-    insta::assert_debug_snapshot!(diag);
-}
-
-#[test]
-#[cfg(not(windows))]
-fn snap_multi_line_fix() {
-    let diag = parse_diagnostic(
-        r##"{
-            "rendered": "warning: returning the result of a let binding from a block\n --> src/main.rs:4:5\n  |\n3 |     let a = (0..10).collect();\n  |     -------------------------- unnecessary let binding\n4 |     a\n  |     ^\n  |\n  = note: `#[warn(clippy::let_and_return)]` on by default\n  = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#let_and_return\nhelp: return the expression directly\n  |\n3 |     \n4 |     (0..10).collect()\n  |\n\n",
-            "children": [
-                {
-                "children": [],
-                "code": null,
-                "level": "note",
-                "message": "`#[warn(clippy::let_and_return)]` on by default",
-                "rendered": null,
-                "spans": []
-                },
-                {
-                "children": [],
-                "code": null,
-                "level": "help",
-                "message": "for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#let_and_return",
-                "rendered": null,
-                "spans": []
-                },
-                {
-                "children": [],
-                "code": null,
-                "level": "help",
-                "message": "return the expression directly",
-                "rendered": null,
-                "spans": [
-                    {
-                    "byte_end": 55,
-                    "byte_start": 29,
-                    "column_end": 31,
-                    "column_start": 5,
-                    "expansion": null,
-                    "file_name": "src/main.rs",
-                    "is_primary": true,
-                    "label": null,
-                    "line_end": 3,
-                    "line_start": 3,
-                    "suggested_replacement": "",
-                    "suggestion_applicability": "MachineApplicable",
-                    "text": [
-                        {
-                        "highlight_end": 31,
-                        "highlight_start": 5,
-                        "text": "    let a = (0..10).collect();"
-                        }
-                    ]
-                    },
-                    {
-                    "byte_end": 61,
-                    "byte_start": 60,
-                    "column_end": 6,
-                    "column_start": 5,
-                    "expansion": null,
-                    "file_name": "src/main.rs",
-                    "is_primary": true,
-                    "label": null,
-                    "line_end": 4,
-                    "line_start": 4,
-                    "suggested_replacement": "(0..10).collect()",
-                    "suggestion_applicability": "MachineApplicable",
-                    "text": [
-                        {
-                        "highlight_end": 6,
-                        "highlight_start": 5,
-                        "text": "    a"
-                        }
-                    ]
-                    }
-                ]
-                }
-            ],
-            "code": {
-                "code": "clippy::let_and_return",
-                "explanation": null
-            },
-            "level": "warning",
-            "message": "returning the result of a let binding from a block",
-            "spans": [
-                {
-                "byte_end": 55,
-                "byte_start": 29,
-                "column_end": 31,
-                "column_start": 5,
-                "expansion": null,
-                "file_name": "src/main.rs",
-                "is_primary": false,
-                "label": "unnecessary let binding",
-                "line_end": 3,
-                "line_start": 3,
-                "suggested_replacement": null,
-                "suggestion_applicability": null,
-                "text": [
-                    {
-                    "highlight_end": 31,
-                    "highlight_start": 5,
-                    "text": "    let a = (0..10).collect();"
-                    }
-                ]
-                },
-                {
-                "byte_end": 61,
-                "byte_start": 60,
-                "column_end": 6,
-                "column_start": 5,
-                "expansion": null,
-                "file_name": "src/main.rs",
-                "is_primary": true,
-                "label": null,
-                "line_end": 4,
-                "line_start": 4,
-                "suggested_replacement": null,
-                "suggestion_applicability": null,
-                "text": [
-                    {
-                    "highlight_end": 6,
-                    "highlight_start": 5,
-                    "text": "    a"
-                    }
-                ]
-                }
-            ]
-        }
-        "##,
-    );
-
-    let workspace_root = PathBuf::from("/test/");
-    let diag = map_rust_diagnostic_to_lsp(&diag, &workspace_root);
-    insta::assert_debug_snapshot!(diag);
-}
diff --git a/crates/ra_flycheck/src/lib.rs b/crates/ra_flycheck/src/lib.rs
index 24af75c95..041e38a9f 100644
--- a/crates/ra_flycheck/src/lib.rs
+++ b/crates/ra_flycheck/src/lib.rs
@@ -1,10 +1,9 @@
 //! cargo_check provides the functionality needed to run `cargo check` or
 //! another compatible command (f.x. clippy) in a background thread and provide
 //! LSP diagnostics based on the output of the command.
-mod conv;
 
 use std::{
-    io::{self, BufRead, BufReader},
+    io::{self, BufReader},
     path::PathBuf,
     process::{Command, Stdio},
     time::Instant,
@@ -12,14 +11,10 @@ use std::{
 
 use cargo_metadata::Message;
 use crossbeam_channel::{never, select, unbounded, Receiver, RecvError, Sender};
-use lsp_types::{
-    CodeAction, CodeActionOrCommand, Diagnostic, Url, WorkDoneProgress, WorkDoneProgressBegin,
-    WorkDoneProgressEnd, WorkDoneProgressReport,
-};
-
-use crate::conv::{map_rust_diagnostic_to_lsp, MappedRustDiagnostic};
 
-pub use crate::conv::url_from_path_with_drive_lowercasing;
+pub use cargo_metadata::diagnostic::{
+    Applicability, Diagnostic, DiagnosticLevel, DiagnosticSpan, DiagnosticSpanMacroExpansion,
+};
 
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum FlycheckConfig {
@@ -61,10 +56,17 @@ pub enum CheckTask {
     ClearDiagnostics,
 
     /// Request adding a diagnostic with fixes included to a file
-    AddDiagnostic { url: Url, diagnostic: Diagnostic, fixes: Vec<CodeActionOrCommand> },
+    AddDiagnostic { workspace_root: PathBuf, diagnostic: Diagnostic },
 
     /// Request check progress notification to client
-    Status(WorkDoneProgress),
+    Status(Status),
+}
+
+#[derive(Debug)]
+pub enum Status {
+    Being,
+    Progress(String),
+    End,
 }
 
 pub enum CheckCommand {
@@ -131,9 +133,7 @@ impl FlycheckThread {
 
     fn clean_previous_results(&self, task_send: &Sender<CheckTask>) {
         task_send.send(CheckTask::ClearDiagnostics).unwrap();
-        task_send
-            .send(CheckTask::Status(WorkDoneProgress::End(WorkDoneProgressEnd { message: None })))
-            .unwrap();
+        task_send.send(CheckTask::Status(Status::End)).unwrap();
     }
 
     fn should_recheck(&mut self) -> bool {
@@ -155,52 +155,24 @@ impl FlycheckThread {
     fn handle_message(&self, msg: CheckEvent, task_send: &Sender<CheckTask>) {
         match msg {
             CheckEvent::Begin => {
-                task_send
-                    .send(CheckTask::Status(WorkDoneProgress::Begin(WorkDoneProgressBegin {
-                        title: "Running 'cargo check'".to_string(),
-                        cancellable: Some(false),
-                        message: None,
-                        percentage: None,
-                    })))
-                    .unwrap();
+                task_send.send(CheckTask::Status(Status::Being)).unwrap();
             }
 
             CheckEvent::End => {
-                task_send
-                    .send(CheckTask::Status(WorkDoneProgress::End(WorkDoneProgressEnd {
-                        message: None,
-                    })))
-                    .unwrap();
+                task_send.send(CheckTask::Status(Status::End)).unwrap();
             }
 
             CheckEvent::Msg(Message::CompilerArtifact(msg)) => {
-                task_send
-                    .send(CheckTask::Status(WorkDoneProgress::Report(WorkDoneProgressReport {
-                        cancellable: Some(false),
-                        message: Some(msg.target.name),
-                        percentage: None,
-                    })))
-                    .unwrap();
+                task_send.send(CheckTask::Status(Status::Progress(msg.target.name))).unwrap();
             }
 
             CheckEvent::Msg(Message::CompilerMessage(msg)) => {
-                let map_result = map_rust_diagnostic_to_lsp(&msg.message, &self.workspace_root);
-                if map_result.is_empty() {
-                    return;
-                }
-
-                for MappedRustDiagnostic { location, diagnostic, fixes } in map_result {
-                    let fixes = fixes
-                        .into_iter()
-                        .map(|fix| {
-                            CodeAction { diagnostics: Some(vec![diagnostic.clone()]), ..fix }.into()
-                        })
-                        .collect();
-
-                    task_send
-                        .send(CheckTask::AddDiagnostic { url: location.uri, diagnostic, fixes })
-                        .unwrap();
-                }
+                task_send
+                    .send(CheckTask::AddDiagnostic {
+                        workspace_root: self.workspace_root.clone(),
+                        diagnostic: msg.message,
+                    })
+                    .unwrap();
             }
 
             CheckEvent::Msg(Message::BuildScriptExecuted(_msg)) => {}
@@ -271,12 +243,6 @@ impl FlycheckThread {
     }
 }
 
-#[derive(Debug)]
-pub struct DiagnosticWithFixes {
-    diagnostic: Diagnostic,
-    fixes: Vec<CodeAction>,
-}
-
 enum CheckEvent {
     Begin,
     Msg(cargo_metadata::Message),
@@ -300,15 +266,11 @@ fn run_cargo(
     // erroneus output.
     let stdout = BufReader::new(child.stdout.take().unwrap());
     let mut read_at_least_one_message = false;
-
-    for line in stdout.lines() {
-        let line = line?;
-
-        let message = serde_json::from_str::<cargo_metadata::Message>(&line);
+    for message in cargo_metadata::Message::parse_stream(stdout) {
         let message = match message {
             Ok(message) => message,
             Err(err) => {
-                log::error!("Invalid json from cargo check, ignoring ({}): {:?} ", err, line);
+                log::error!("Invalid json from cargo check, ignoring ({})", err);
                 continue;
             }
         };
diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs
index 3fc2eccdd..840cfdfc8 100644
--- a/crates/ra_hir/src/code_model.rs
+++ b/crates/ra_hir/src/code_model.rs
@@ -148,6 +148,26 @@ impl ModuleDef {
             ModuleDef::BuiltinType(_) => None,
         }
     }
+
+    pub fn definition_visibility(&self, db: &dyn HirDatabase) -> Option<Visibility> {
+        let module = match self {
+            ModuleDef::Module(it) => it.parent(db)?,
+            ModuleDef::Function(it) => return Some(it.visibility(db)),
+            ModuleDef::Adt(it) => it.module(db),
+            ModuleDef::EnumVariant(it) => {
+                let parent = it.parent_enum(db);
+                let module = it.module(db);
+                return module.visibility_of(db, &ModuleDef::Adt(Adt::Enum(parent)));
+            }
+            ModuleDef::Const(it) => return Some(it.visibility(db)),
+            ModuleDef::Static(it) => it.module(db),
+            ModuleDef::Trait(it) => it.module(db),
+            ModuleDef::TypeAlias(it) => return Some(it.visibility(db)),
+            ModuleDef::BuiltinType(_) => return None,
+        };
+
+        module.visibility_of(db, self)
+    }
 }
 
 pub use hir_def::{
@@ -969,6 +989,17 @@ impl TypeParam {
             ty: InEnvironment { value: ty, environment },
         }
     }
+
+    pub fn default(self, db: &dyn HirDatabase) -> Option<Type> {
+        let params = db.generic_defaults(self.id.parent);
+        let local_idx = hir_ty::param_idx(db, self.id)?;
+        let resolver = self.id.parent.resolver(db.upcast());
+        let environment = TraitEnvironment::lower(db, &resolver);
+        params.get(local_idx).cloned().map(|ty| Type {
+            krate: self.id.parent.module(db.upcast()).krate,
+            ty: InEnvironment { value: ty, environment },
+        })
+    }
 }
 
 // FIXME: rename from `ImplDef` to `Impl`
diff --git a/crates/ra_hir_expand/src/builtin_macro.rs b/crates/ra_hir_expand/src/builtin_macro.rs
index d8b3d342c..3bce8f673 100644
--- a/crates/ra_hir_expand/src/builtin_macro.rs
+++ b/crates/ra_hir_expand/src/builtin_macro.rs
@@ -360,7 +360,7 @@ fn env_expand(
     // However, we cannot use an empty string here, because for
     // `include!(concat!(env!("OUT_DIR"), "/foo.rs"))` will become
     // `include!("foo.rs"), which might go to infinite loop
-    let s = get_env_inner(db, arg_id, &key).unwrap_or_else(|| "__RA_UNIMPLEMENTATED__".to_string());
+    let s = get_env_inner(db, arg_id, &key).unwrap_or_else(|| "__RA_UNIMPLEMENTED__".to_string());
     let expanded = quote! { #s };
 
     Ok((expanded, FragmentKind::Expr))
@@ -508,7 +508,7 @@ mod tests {
             "#,
         );
 
-        assert_eq!(expanded, "\"__RA_UNIMPLEMENTATED__\"");
+        assert_eq!(expanded, "\"__RA_UNIMPLEMENTED__\"");
     }
 
     #[test]
diff --git a/crates/ra_hir_expand/src/db.rs b/crates/ra_hir_expand/src/db.rs
index 4c12d0a15..bf30d7151 100644
--- a/crates/ra_hir_expand/src/db.rs
+++ b/crates/ra_hir_expand/src/db.rs
@@ -34,7 +34,12 @@ impl TokenExpander {
             // FIXME switch these to ExpandResult as well
             TokenExpander::Builtin(it) => it.expand(db, id, tt).into(),
             TokenExpander::BuiltinDerive(it) => it.expand(db, id, tt).into(),
-            TokenExpander::ProcMacro(it) => it.expand(db, id, tt).into(),
+            TokenExpander::ProcMacro(_) => {
+                // We store the result in salsa db to prevent non-determinisc behavior in
+                // some proc-macro implementation
+                // See #4315 for details
+                db.expand_proc_macro(id.into()).into()
+            }
         }
     }
 
@@ -75,6 +80,8 @@ pub trait AstDatabase: SourceDatabase {
 
     #[salsa::interned]
     fn intern_eager_expansion(&self, eager: EagerCallLoc) -> EagerMacroId;
+
+    fn expand_proc_macro(&self, call: MacroCallId) -> Result<tt::Subtree, mbe::ExpandError>;
 }
 
 /// This expands the given macro call, but with different arguments. This is
@@ -216,6 +223,33 @@ fn macro_expand_with_arg(
     (Some(Arc::new(tt)), err.map(|e| format!("{:?}", e)))
 }
 
+pub(crate) fn expand_proc_macro(
+    db: &dyn AstDatabase,
+    id: MacroCallId,
+) -> Result<tt::Subtree, mbe::ExpandError> {
+    let lazy_id = match id {
+        MacroCallId::LazyMacro(id) => id,
+        MacroCallId::EagerMacro(_) => unreachable!(),
+    };
+
+    let loc = db.lookup_intern_macro(lazy_id);
+    let macro_arg = match db.macro_arg(id) {
+        Some(it) => it,
+        None => {
+            return Err(
+                tt::ExpansionError::Unknown("No arguments for proc-macro".to_string()).into()
+            )
+        }
+    };
+
+    let expander = match loc.def.kind {
+        MacroDefKind::CustomDerive(expander) => expander,
+        _ => unreachable!(),
+    };
+
+    expander.expand(db, lazy_id, &macro_arg.0)
+}
+
 pub(crate) fn parse_or_expand(db: &dyn AstDatabase, file_id: HirFileId) -> Option<SyntaxNode> {
     match file_id.0 {
         HirFileIdRepr::FileId(file_id) => Some(db.parse(file_id).tree().syntax().clone()),
diff --git a/crates/ra_hir_ty/src/lib.rs b/crates/ra_hir_ty/src/lib.rs
index e8f3482fe..ccc4348f4 100644
--- a/crates/ra_hir_ty/src/lib.rs
+++ b/crates/ra_hir_ty/src/lib.rs
@@ -427,6 +427,11 @@ impl Substs {
     }
 }
 
+/// Return an index of a parameter in the generic type parameter list by it's id.
+pub fn param_idx(db: &dyn HirDatabase, id: TypeParamId) -> Option<usize> {
+    generics(db.upcast(), id.parent).param_idx(id)
+}
+
 #[derive(Debug, Clone)]
 pub struct SubstsBuilder {
     vec: Vec<Ty>,
diff --git a/crates/ra_ide/src/completion/complete_postfix.rs b/crates/ra_ide/src/completion/complete_postfix.rs
index 6a0f0c72e..f2a52a407 100644
--- a/crates/ra_ide/src/completion/complete_postfix.rs
+++ b/crates/ra_ide/src/completion/complete_postfix.rs
@@ -14,6 +14,7 @@ use crate::{
     },
     CompletionItem,
 };
+use ra_assists::utils::TryEnum;
 
 pub(super) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
     if !ctx.config.enable_postfix_completions {
@@ -37,8 +38,53 @@ pub(super) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
         Some(it) => it,
         None => return,
     };
+    let try_enum = TryEnum::from_ty(&ctx.sema, &receiver_ty);
+    if let Some(try_enum) = &try_enum {
+        match try_enum {
+            TryEnum::Result => {
+                postfix_snippet(
+                    ctx,
+                    cap,
+                    &dot_receiver,
+                    "ifl",
+                    "if let Ok {}",
+                    &format!("if let Ok($1) = {} {{\n    $0\n}}", receiver_text),
+                )
+                .add_to(acc);
 
-    if receiver_ty.is_bool() || receiver_ty.is_unknown() {
+                postfix_snippet(
+                    ctx,
+                    cap,
+                    &dot_receiver,
+                    "while",
+                    "while let Ok {}",
+                    &format!("while let Ok($1) = {} {{\n    $0\n}}", receiver_text),
+                )
+                .add_to(acc);
+            }
+            TryEnum::Option => {
+                postfix_snippet(
+                    ctx,
+                    cap,
+                    &dot_receiver,
+                    "ifl",
+                    "if let Some {}",
+                    &format!("if let Some($1) = {} {{\n    $0\n}}", receiver_text),
+                )
+                .add_to(acc);
+
+                postfix_snippet(
+                    ctx,
+                    cap,
+                    &dot_receiver,
+                    "while",
+                    "while let Some {}",
+                    &format!("while let Some($1) = {} {{\n    $0\n}}", receiver_text),
+                )
+                .add_to(acc);
+            }
+        }
+    } else if receiver_ty.is_bool() || receiver_ty.is_unknown() {
         postfix_snippet(
             ctx,
             cap,
@@ -58,7 +104,6 @@ pub(super) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
         )
         .add_to(acc);
     }
-
     // !&&&42 is a compiler error, ergo process it before considering the references
     postfix_snippet(ctx, cap, &dot_receiver, "not", "!expr", &format!("!{}", receiver_text))
         .add_to(acc);
@@ -80,16 +125,45 @@ pub(super) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
     let dot_receiver = include_references(dot_receiver);
     let receiver_text =
         get_receiver_text(&dot_receiver, ctx.dot_receiver_is_ambiguous_float_literal);
-
-    postfix_snippet(
-        ctx,
-        cap,
-        &dot_receiver,
-        "match",
-        "match expr {}",
-        &format!("match {} {{\n    ${{1:_}} => {{$0\\}},\n}}", receiver_text),
-    )
-    .add_to(acc);
+    match try_enum {
+        Some(try_enum) => {
+            match try_enum {
+                TryEnum::Result => {
+                    postfix_snippet(
+                    ctx,
+                    cap,
+                    &dot_receiver,
+                    "match",
+                    "match expr {}",
+                    &format!("match {} {{\n    Ok(${{1:_}}) => {{$2\\}},\n    Err(${{3:_}}) => {{$0\\}},\n}}", receiver_text),
+                )
+                .add_to(acc);
+                }
+                TryEnum::Option => {
+                    postfix_snippet(
+                    ctx,
+                    cap,
+                    &dot_receiver,
+                    "match",
+                    "match expr {}",
+                    &format!("match {} {{\n    Some(${{1:_}}) => {{$2\\}},\n    None => {{$0\\}},\n}}", receiver_text),
+                )
+                .add_to(acc);
+                }
+            }
+        }
+        None => {
+            postfix_snippet(
+                ctx,
+                cap,
+                &dot_receiver,
+                "match",
+                "match expr {}",
+                &format!("match {} {{\n    ${{1:_}} => {{$0\\}},\n}}", receiver_text),
+            )
+            .add_to(acc);
+        }
+    }
 
     postfix_snippet(
         ctx,
@@ -236,6 +310,164 @@ mod tests {
     }
 
     #[test]
+    fn postfix_completion_works_for_option() {
+        assert_debug_snapshot!(
+            do_postfix_completion(
+                r#"
+                enum Option<T> {
+                    Some(T),
+                    None,
+                }
+
+                fn main() {
+                    let bar = Option::Some(true);
+                    bar.<|>
+                }
+                "#,
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "box",
+                source_range: 210..210,
+                delete: 206..210,
+                insert: "Box::new(bar)",
+                detail: "Box::new(expr)",
+            },
+            CompletionItem {
+                label: "dbg",
+                source_range: 210..210,
+                delete: 206..210,
+                insert: "dbg!(bar)",
+                detail: "dbg!(expr)",
+            },
+            CompletionItem {
+                label: "ifl",
+                source_range: 210..210,
+                delete: 206..210,
+                insert: "if let Some($1) = bar {\n    $0\n}",
+                detail: "if let Some {}",
+            },
+            CompletionItem {
+                label: "match",
+                source_range: 210..210,
+                delete: 206..210,
+                insert: "match bar {\n    Some(${1:_}) => {$2\\},\n    None => {$0\\},\n}",
+                detail: "match expr {}",
+            },
+            CompletionItem {
+                label: "not",
+                source_range: 210..210,
+                delete: 206..210,
+                insert: "!bar",
+                detail: "!expr",
+            },
+            CompletionItem {
+                label: "ref",
+                source_range: 210..210,
+                delete: 206..210,
+                insert: "&bar",
+                detail: "&expr",
+            },
+            CompletionItem {
+                label: "refm",
+                source_range: 210..210,
+                delete: 206..210,
+                insert: "&mut bar",
+                detail: "&mut expr",
+            },
+            CompletionItem {
+                label: "while",
+                source_range: 210..210,
+                delete: 206..210,
+                insert: "while let Some($1) = bar {\n    $0\n}",
+                detail: "while let Some {}",
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
+    fn postfix_completion_works_for_result() {
+        assert_debug_snapshot!(
+            do_postfix_completion(
+                r#"
+                enum Result<T, E> {
+                    Ok(T),
+                    Err(E),
+                }
+
+                fn main() {
+                    let bar = Result::Ok(true);
+                    bar.<|>
+                }
+                "#,
+            ),
+            @r###"
+        [
+            CompletionItem {
+                label: "box",
+                source_range: 211..211,
+                delete: 207..211,
+                insert: "Box::new(bar)",
+                detail: "Box::new(expr)",
+            },
+            CompletionItem {
+                label: "dbg",
+                source_range: 211..211,
+                delete: 207..211,
+                insert: "dbg!(bar)",
+                detail: "dbg!(expr)",
+            },
+            CompletionItem {
+                label: "ifl",
+                source_range: 211..211,
+                delete: 207..211,
+                insert: "if let Ok($1) = bar {\n    $0\n}",
+                detail: "if let Ok {}",
+            },
+            CompletionItem {
+                label: "match",
+                source_range: 211..211,
+                delete: 207..211,
+                insert: "match bar {\n    Ok(${1:_}) => {$2\\},\n    Err(${3:_}) => {$0\\},\n}",
+                detail: "match expr {}",
+            },
+            CompletionItem {
+                label: "not",
+                source_range: 211..211,
+                delete: 207..211,
+                insert: "!bar",
+                detail: "!expr",
+            },
+            CompletionItem {
+                label: "ref",
+                source_range: 211..211,
+                delete: 207..211,
+                insert: "&bar",
+                detail: "&expr",
+            },
+            CompletionItem {
+                label: "refm",
+                source_range: 211..211,
+                delete: 207..211,
+                insert: "&mut bar",
+                detail: "&mut expr",
+            },
+            CompletionItem {
+                label: "while",
+                source_range: 211..211,
+                delete: 207..211,
+                insert: "while let Ok($1) = bar {\n    $0\n}",
+                detail: "while let Ok {}",
+            },
+        ]
+        "###
+        );
+    }
+
+    #[test]
     fn some_postfix_completions_ignored() {
         assert_debug_snapshot!(
             do_postfix_completion(
diff --git a/crates/ra_ide/src/completion/complete_snippet.rs b/crates/ra_ide/src/completion/complete_snippet.rs
index a3f5d1b6a..0568d9ccf 100644
--- a/crates/ra_ide/src/completion/complete_snippet.rs
+++ b/crates/ra_ide/src/completion/complete_snippet.rs
@@ -36,6 +36,24 @@ pub(super) fn complete_item_snippet(acc: &mut Completions, ctx: &CompletionConte
     snippet(
         ctx,
         cap,
+        "Test module",
+        "\
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn ${1:test_name}() {
+        $0
+    }
+}",
+    )
+    .lookup_by("tmod")
+    .add_to(acc);
+
+    snippet(
+        ctx,
+        cap,
         "Test function",
         "\
 #[test]
@@ -118,6 +136,14 @@ mod tests {
                 lookup: "tfn",
             },
             CompletionItem {
+                label: "Test module",
+                source_range: 78..78,
+                delete: 78..78,
+                insert: "#[cfg(test)]\nmod tests {\n    use super::*;\n\n    #[test]\n    fn ${1:test_name}() {\n        $0\n    }\n}",
+                kind: Snippet,
+                lookup: "tmod",
+            },
+            CompletionItem {
                 label: "macro_rules",
                 source_range: 78..78,
                 delete: 78..78,
diff --git a/crates/ra_ide/src/completion/completion_context.rs b/crates/ra_ide/src/completion/completion_context.rs
index b6b9627de..da336973c 100644
--- a/crates/ra_ide/src/completion/completion_context.rs
+++ b/crates/ra_ide/src/completion/completion_context.rs
@@ -34,7 +34,7 @@ pub(crate) struct CompletionContext<'a> {
     pub(super) record_pat_syntax: Option<ast::RecordPat>,
     pub(super) record_field_syntax: Option<ast::RecordField>,
     pub(super) impl_def: Option<ast::ImplDef>,
-    /// FIXME: `ActiveParameter` is string-based, which is very wrong
+    /// FIXME: `ActiveParameter` is string-based, which is very very wrong
     pub(super) active_parameter: Option<ActiveParameter>,
     pub(super) is_param: bool,
     /// If a name-binding or reference to a const in a pattern.
diff --git a/crates/ra_ide/src/completion/presentation.rs b/crates/ra_ide/src/completion/presentation.rs
index 2edb130cf..077cf9647 100644
--- a/crates/ra_ide/src/completion/presentation.rs
+++ b/crates/ra_ide/src/completion/presentation.rs
@@ -17,12 +17,11 @@ use crate::{
 impl Completions {
     pub(crate) fn add_field(&mut self, ctx: &CompletionContext, field: hir::Field, ty: &Type) {
         let is_deprecated = is_deprecated(field, ctx.db);
-        let ty = ty.display(ctx.db).to_string();
         let name = field.name(ctx.db);
         let mut completion_item =
             CompletionItem::new(CompletionKind::Reference, ctx.source_range(), name.to_string())
                 .kind(CompletionItemKind::Field)
-                .detail(ty.clone())
+                .detail(ty.display(ctx.db).to_string())
                 .set_documentation(field.docs(ctx.db))
                 .set_deprecated(is_deprecated);
 
@@ -107,6 +106,12 @@ impl Completions {
             }
         };
 
+        if let ScopeDef::Local(local) = resolution {
+            if let Some(score) = compute_score(ctx, &local.ty(ctx.db), &local_name) {
+                completion_item = completion_item.set_score(score);
+            }
+        }
+
         // Add `<>` for generic types
         if ctx.is_path_type && !ctx.has_type_args && ctx.config.add_call_parenthesis {
             if let Some(cap) = ctx.config.snippet_cap {
@@ -319,10 +324,11 @@ impl Completions {
 
 pub(crate) fn compute_score(
     ctx: &CompletionContext,
-    // FIXME: this definitely should be a `Type`
-    ty: &str,
+    ty: &Type,
     name: &str,
 ) -> Option<CompletionScore> {
+    // FIXME: this should not fall back to string equality.
+    let ty = &ty.display(ctx.db).to_string();
     let (active_name, active_type) = if let Some(record_field) = &ctx.record_field_syntax {
         tested_by!(test_struct_field_completion_in_record_lit);
         let (struct_field, _local) = ctx.sema.resolve_record_field(record_field)?;
@@ -1405,4 +1411,48 @@ mod tests {
         "###
         );
     }
+
+    #[test]
+    fn prioritize_exact_ref_match() {
+        assert_debug_snapshot!(
+        do_reference_completion(
+                r"
+                    struct WorldSnapshot { _f: () };
+                    fn go(world: &WorldSnapshot) {
+                        go(w<|>)
+                    }
+                    ",
+        ),
+            @r###"
+        [
+            CompletionItem {
+                label: "WorldSnapshot",
+                source_range: 132..133,
+                delete: 132..133,
+                insert: "WorldSnapshot",
+                kind: Struct,
+            },
+            CompletionItem {
+                label: "go(…)",
+                source_range: 132..133,
+                delete: 132..133,
+                insert: "go(${1:world})$0",
+                kind: Function,
+                lookup: "go",
+                detail: "fn go(world: &WorldSnapshot)",
+                trigger_call_info: true,
+            },
+            CompletionItem {
+                label: "world",
+                source_range: 132..133,
+                delete: 132..133,
+                insert: "world",
+                kind: Binding,
+                detail: "&WorldSnapshot",
+                score: TypeAndNameMatch,
+            },
+        ]
+        "###
+        );
+    }
 }
diff --git a/crates/ra_ide/src/lib.rs b/crates/ra_ide/src/lib.rs
index 915199bd8..78149ddfc 100644
--- a/crates/ra_ide/src/lib.rs
+++ b/crates/ra_ide/src/lib.rs
@@ -176,14 +176,10 @@ impl AnalysisHost {
     pub fn request_cancellation(&mut self) {
         self.db.request_cancellation();
     }
-    pub fn raw_database(
-        &self,
-    ) -> &(impl hir::db::HirDatabase + salsa::Database + ra_db::SourceDatabaseExt) {
+    pub fn raw_database(&self) -> &RootDatabase {
         &self.db
     }
-    pub fn raw_database_mut(
-        &mut self,
-    ) -> &mut (impl hir::db::HirDatabase + salsa::Database + ra_db::SourceDatabaseExt) {
+    pub fn raw_database_mut(&mut self) -> &mut RootDatabase {
         &mut self.db
     }
 }
diff --git a/crates/ra_ide/src/references.rs b/crates/ra_ide/src/references.rs
index 555ccf295..074284b42 100644
--- a/crates/ra_ide/src/references.rs
+++ b/crates/ra_ide/src/references.rs
@@ -593,6 +593,31 @@ mod tests {
         check_result(refs, "i BIND_PAT FileId(1) 36..37 Other", &["FileId(1) 51..52 Other Write"]);
     }
 
+    #[test]
+    fn test_find_struct_function_refs_outside_module() {
+        let code = r#"
+        mod foo {
+            pub struct Foo;
+
+            impl Foo {
+                pub fn new<|>() -> Foo {
+                    Foo
+                }
+            }
+        }
+
+        fn main() {
+            let _f = foo::Foo::new();
+        }"#;
+
+        let refs = get_all_refs(code);
+        check_result(
+            refs,
+            "new FN_DEF FileId(1) 87..150 94..97 Other",
+            &["FileId(1) 227..230 StructLiteral"],
+        );
+    }
+
     fn get_all_refs(text: &str) -> ReferenceSearchResult {
         let (analysis, position) = single_file_with_position(text);
         analysis.find_all_refs(position, None).unwrap().unwrap()
diff --git a/crates/ra_ide/src/snapshots/highlighting.html b/crates/ra_ide/src/snapshots/highlighting.html
index 4c27aade4..635fe5cf9 100644
--- a/crates/ra_ide/src/snapshots/highlighting.html
+++ b/crates/ra_ide/src/snapshots/highlighting.html
@@ -33,6 +33,16 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
     <span class="keyword">pub</span> <span class="field declaration">y</span>: <span class="builtin_type">i32</span>,
 }
 
+<span class="keyword">trait</span> <span class="trait declaration">Bar</span> {
+    <span class="keyword">fn</span> <span class="function declaration">bar</span>(&<span class="keyword">self</span>) -&gt; <span class="builtin_type">i32</span>;
+}
+
+<span class="keyword">impl</span> <span class="trait">Bar</span> <span class="keyword">for</span> <span class="struct">Foo</span> {
+    <span class="keyword">fn</span> <span class="function declaration">bar</span>(&<span class="keyword">self</span>) -&gt; <span class="builtin_type">i32</span> {
+        <span class="keyword">self</span>.<span class="field">x</span>
+    }
+}
+
 <span class="keyword">static</span> <span class="keyword">mut</span> <span class="static declaration mutable">STATIC_MUT</span>: <span class="builtin_type">i32</span> = <span class="numeric_literal">0</span>;
 
 <span class="keyword">fn</span> <span class="function declaration">foo</span>&lt;<span class="lifetime declaration">'a</span>, <span class="type_param declaration">T</span>&gt;() -&gt; <span class="type_param">T</span> {
@@ -63,6 +73,10 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
         <span class="static mutable">STATIC_MUT</span> = <span class="numeric_literal">1</span>;
     }
 
+    <span class="keyword control">for</span> <span class="variable declaration">e</span> <span class="keyword control">in</span> <span class="variable mutable">vec</span> {
+        <span class="comment">// Do nothing</span>
+    }
+
     <span class="keyword">let</span> <span class="keyword">mut</span> <span class="variable declaration mutable">x</span> = <span class="numeric_literal">42</span>;
     <span class="keyword">let</span> <span class="variable declaration mutable">y</span> = &<span class="keyword">mut</span> <span class="variable mutable">x</span>;
     <span class="keyword">let</span> <span class="variable declaration">z</span> = &<span class="variable mutable">y</span>;
diff --git a/crates/ra_ide/src/syntax_highlighting.rs b/crates/ra_ide/src/syntax_highlighting.rs
index d53a39f57..be57eeb0a 100644
--- a/crates/ra_ide/src/syntax_highlighting.rs
+++ b/crates/ra_ide/src/syntax_highlighting.rs
@@ -403,12 +403,13 @@ fn highlight_element(
                 T![break]
                 | T![continue]
                 | T![else]
-                | T![for]
                 | T![if]
                 | T![loop]
                 | T![match]
                 | T![return]
-                | T![while] => h | HighlightModifier::ControlFlow,
+                | T![while]
+                | T![in] => h | HighlightModifier::ControlFlow,
+                T![for] if !is_child_of_impl(element) => h | HighlightModifier::ControlFlow,
                 T![unsafe] => h | HighlightModifier::Unsafe,
                 _ => h,
             }
@@ -432,6 +433,13 @@ fn highlight_element(
     }
 }
 
+fn is_child_of_impl(element: SyntaxElement) -> bool {
+    match element.parent() {
+        Some(e) => e.kind() == IMPL_DEF,
+        _ => false,
+    }
+}
+
 fn highlight_name(db: &RootDatabase, def: Definition) -> Highlight {
     match def {
         Definition::Macro(_) => HighlightTag::Macro,
diff --git a/crates/ra_ide/src/syntax_highlighting/tests.rs b/crates/ra_ide/src/syntax_highlighting/tests.rs
index 13894869c..eb43a23da 100644
--- a/crates/ra_ide/src/syntax_highlighting/tests.rs
+++ b/crates/ra_ide/src/syntax_highlighting/tests.rs
@@ -17,6 +17,16 @@ struct Foo {
     pub y: i32,
 }
 
+trait Bar {
+    fn bar(&self) -> i32;
+}
+
+impl Bar for Foo {
+    fn bar(&self) -> i32 {
+        self.x
+    }
+}
+
 static mut STATIC_MUT: i32 = 0;
 
 fn foo<'a, T>() -> T {
@@ -47,6 +57,10 @@ fn main() {
         STATIC_MUT = 1;
     }
 
+    for e in vec {
+        // Do nothing
+    }
+
     let mut x = 42;
     let y = &mut x;
     let z = &y;
diff --git a/crates/ra_ide_db/src/defs.rs b/crates/ra_ide_db/src/defs.rs
index f990e3bb9..60c11178e 100644
--- a/crates/ra_ide_db/src/defs.rs
+++ b/crates/ra_ide_db/src/defs.rs
@@ -6,7 +6,7 @@
 // FIXME: this badly needs rename/rewrite (matklad, 2020-02-06).
 
 use hir::{
-    Adt, Field, HasVisibility, ImplDef, Local, MacroDef, Module, ModuleDef, Name, PathResolution,
+    Field, HasVisibility, ImplDef, Local, MacroDef, Module, ModuleDef, Name, PathResolution,
     Semantics, TypeParam, Visibility,
 };
 use ra_prof::profile;
@@ -42,18 +42,10 @@ impl Definition {
     }
 
     pub fn visibility(&self, db: &RootDatabase) -> Option<Visibility> {
-        let module = self.module(db);
-
         match self {
             Definition::Macro(_) => None,
             Definition::Field(sf) => Some(sf.visibility(db)),
-            Definition::ModuleDef(def) => match def {
-                ModuleDef::EnumVariant(id) => {
-                    let parent = id.parent_enum(db);
-                    module?.visibility_of(db, &ModuleDef::Adt(Adt::Enum(parent)))
-                }
-                _ => module?.visibility_of(db, def),
-            },
+            Definition::ModuleDef(def) => def.definition_visibility(db),
             Definition::SelfType(_) => None,
             Definition::Local(_) => None,
             Definition::TypeParam(_) => None,
diff --git a/crates/ra_mbe/src/lib.rs b/crates/ra_mbe/src/lib.rs
index 1a020398e..9c450eaba 100644
--- a/crates/ra_mbe/src/lib.rs
+++ b/crates/ra_mbe/src/lib.rs
@@ -22,7 +22,7 @@ pub enum ParseError {
     RepetitionEmtpyTokenTree,
 }
 
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Debug, PartialEq, Eq, Clone)]
 pub enum ExpandError {
     NoMatchingRule,
     UnexpectedToken,
diff --git a/crates/ra_project_model/src/lib.rs b/crates/ra_project_model/src/lib.rs
index 4f098b706..a2e9f65ef 100644
--- a/crates/ra_project_model/src/lib.rs
+++ b/crates/ra_project_model/src/lib.rs
@@ -35,7 +35,7 @@ pub enum ProjectWorkspace {
 /// `PackageRoot` describes a package root folder.
 /// Which may be an external dependency, or a member of
 /// the current workspace.
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub struct PackageRoot {
     /// Path to the root folder
     path: PathBuf,
diff --git a/crates/ra_syntax/src/ast/generated/nodes.rs b/crates/ra_syntax/src/ast/generated/nodes.rs
index b00c15608..cf6067e57 100644
--- a/crates/ra_syntax/src/ast/generated/nodes.rs
+++ b/crates/ra_syntax/src/ast/generated/nodes.rs
@@ -5,7 +5,9 @@ use crate::{
     SyntaxKind::{self, *},
     SyntaxNode, SyntaxToken, T,
 };
-
+/// The entire Rust source file. Includes all top-level inner attributes and module items.
+///
+/// [Reference](https://doc.rust-lang.org/reference/crates-and-source-files.html)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct SourceFile {
     pub(crate) syntax: SyntaxNode,
@@ -16,7 +18,28 @@ impl ast::DocCommentsOwner for SourceFile {}
 impl SourceFile {
     pub fn modules(&self) -> AstChildren<Module> { support::children(&self.syntax) }
 }
-
+/// Function definition either with body or not.
+/// Includes all of its attributes and doc comments.
+///
+/// ```
+/// ❰
+///     /// Docs
+///     #[attr]
+///     pub extern "C" fn foo<T>(#[attr] Patern {p}: Pattern) -> u32
+///     where
+///         T: Debug
+///     {
+///         42
+///     }
+/// ❱
+///
+/// extern "C" {
+///     ❰ fn fn_decl(also_variadic_ffi: u32, ...) -> u32; ❱
+/// }
+/// ```
+///
+/// - [Reference](https://doc.rust-lang.org/reference/items/functions.html)
+/// - [Nomicon](https://doc.rust-lang.org/nomicon/ffi.html#variadic-functions)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct FnDef {
     pub(crate) syntax: SyntaxNode,
@@ -38,7 +61,13 @@ impl FnDef {
     pub fn body(&self) -> Option<BlockExpr> { support::child(&self.syntax) }
     pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
 }
-
+/// Return type annotation.
+///
+/// ```
+/// fn foo(a: u32) ❰ -> Option<u32> ❱ { Some(a) }
+/// ```
+///
+/// [Reference](https://doc.rust-lang.org/reference/items/functions.html)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct RetType {
     pub(crate) syntax: SyntaxNode,
@@ -47,7 +76,26 @@ impl RetType {
     pub fn thin_arrow_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![->]) }
     pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
 }
-
+/// Struct definition.
+/// Includes all of its attributes and doc comments.
+///
+/// ```
+/// ❰
+///     /// Docs
+///     #[attr]
+///     struct Foo<T> where T: Debug {
+///         /// Docs
+///         #[attr]
+///         pub a: u32,
+///         b: T,
+///     }
+/// ❱
+///
+/// ❰ struct Foo; ❱
+/// ❰ struct Foo<T>(#[attr] T) where T: Debug; ❱
+/// ```
+///
+/// [Reference](https://doc.rust-lang.org/reference/items/structs.html)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct StructDef {
     pub(crate) syntax: SyntaxNode,
@@ -62,7 +110,23 @@ impl StructDef {
     pub fn field_def_list(&self) -> Option<FieldDefList> { support::child(&self.syntax) }
     pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
 }
-
+/// Union definition.
+/// Includes all of its attributes and doc comments.
+///
+/// ```
+/// ❰
+///     /// Docs
+///     #[attr]
+///     pub union Foo<T> where T: Debug {
+///         /// Docs
+///         #[attr]
+///         a: T,
+///         b: u32,
+///     }
+/// ❱
+/// ```
+///
+/// [Reference](https://doc.rust-lang.org/reference/items/unions.html)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct UnionDef {
     pub(crate) syntax: SyntaxNode,
@@ -78,7 +142,19 @@ impl UnionDef {
         support::child(&self.syntax)
     }
 }
-
+/// Record field definition list including enclosing curly braces.
+///
+/// ```
+/// struct Foo // same for union
+/// ❰
+///     {
+///         a: u32,
+///         b: bool,
+///     }
+/// ❱
+/// ```
+///
+/// [Reference](https://doc.rust-lang.org/reference/items/structs.html)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct RecordFieldDefList {
     pub(crate) syntax: SyntaxNode,
@@ -88,7 +164,22 @@ impl RecordFieldDefList {
     pub fn fields(&self) -> AstChildren<RecordFieldDef> { support::children(&self.syntax) }
     pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
 }
-
+/// Record field definition including its attributes and doc comments.
+///
+/// ` ``
+/// same for union
+/// struct Foo {
+///      ❰
+///          /// Docs
+///          #[attr]
+///          pub a: u32
+///      ❱
+///
+///      ❰ b: bool ❱
+/// }
+/// ```
+///
+/// [Reference](https://doc.rust-lang.org/reference/items/structs.html)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct RecordFieldDef {
     pub(crate) syntax: SyntaxNode,
@@ -99,7 +190,13 @@ impl ast::AttrsOwner for RecordFieldDef {}
 impl ast::DocCommentsOwner for RecordFieldDef {}
 impl ast::TypeAscriptionOwner for RecordFieldDef {}
 impl RecordFieldDef {}
-
+/// Tuple field definition list including enclosing parens.
+///
+/// ```
+/// struct Foo ❰ (u32, String, Vec<u32>) ❱;
+/// ```
+///
+/// [Reference](https://doc.rust-lang.org/reference/items/structs.html)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct TupleFieldDefList {
     pub(crate) syntax: SyntaxNode,
@@ -109,7 +206,13 @@ impl TupleFieldDefList {
     pub fn fields(&self) -> AstChildren<TupleFieldDef> { support::children(&self.syntax) }
     pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
 }
-
+/// Tuple field definition including its attributes.
+///
+/// ```
+/// struct Foo(❰ #[attr] u32 ❱);
+/// ```
+///
+/// [Reference](https://doc.rust-lang.org/reference/items/structs.html)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct TupleFieldDef {
     pub(crate) syntax: SyntaxNode,
@@ -119,7 +222,29 @@ impl ast::AttrsOwner for TupleFieldDef {}
 impl TupleFieldDef {
     pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
 }
-
+/// Enum definition.
+/// Includes all of its attributes and doc comments.
+///
+/// ```
+/// ❰
+///     /// Docs
+///     #[attr]
+///     pub enum Foo<T> where T: Debug {
+///         /// Docs
+///         #[attr]
+///         Bar,
+///         Baz(#[attr] u32),
+///         Bruh {
+///             a: u32,
+///             /// Docs
+///             #[attr]
+///             b: T,
+///         }
+///     }
+/// ❱
+/// ```
+///
+/// [Reference](https://doc.rust-lang.org/reference/items/enumerations.html)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct EnumDef {
     pub(crate) syntax: SyntaxNode,
@@ -133,7 +258,22 @@ impl EnumDef {
     pub fn enum_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![enum]) }
     pub fn variant_list(&self) -> Option<EnumVariantList> { support::child(&self.syntax) }
 }
-
+/// Enum variant definition list including enclosing curly braces.
+///
+/// ```
+/// enum Foo
+/// ❰
+///     {
+///         Bar,
+///         Baz(u32),
+///         Bruh {
+///             a: u32
+///         }
+///     }
+/// ❱
+/// ```
+///
+/// [Reference](https://doc.rust-lang.org/reference/items/enumerations.html)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct EnumVariantList {
     pub(crate) syntax: SyntaxNode,
@@ -143,7 +283,21 @@ impl EnumVariantList {
     pub fn variants(&self) -> AstChildren<EnumVariant> { support::children(&self.syntax) }
     pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
 }
-
+/// Enum variant definition including its attributes and discriminant value definition.
+///
+/// ```
+/// enum Foo {
+///     ❰
+///         /// Docs
+///         #[attr]
+///         Bar
+///     ❱
+///
+///     // same for tuple and record variants
+/// }
+/// ```
+///
+/// [Reference](https://doc.rust-lang.org/reference/items/enumerations.html)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct EnumVariant {
     pub(crate) syntax: SyntaxNode,
@@ -157,7 +311,20 @@ impl EnumVariant {
     pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
 }
-
+/// Trait definition.
+/// Includes all of its attributes and doc comments.
+///
+/// ```
+/// ❰
+///     /// Docs
+///     #[attr]
+///     pub unsafe trait Foo<T>: Debug where T: Debug {
+///         // ...
+///     }
+/// ❱
+/// ```
+///
+/// [Reference](https://doc.rust-lang.org/reference/items/traits.html)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct TraitDef {
     pub(crate) syntax: SyntaxNode,
@@ -174,7 +341,27 @@ impl TraitDef {
     pub fn trait_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![trait]) }
     pub fn item_list(&self) -> Option<ItemList> { support::child(&self.syntax) }
 }
-
+/// Module definition either with body or not.
+/// Includes all of its inner and outer attributes, module items, doc comments.
+///
+/// ```
+/// ❰
+///     /// Docs
+///     #[attr]
+///     pub mod foo;
+/// ❱
+///
+/// ❰
+///     /// Docs
+///     #[attr]
+///     pub mod bar {
+///        //! Inner docs
+///        #![inner_attr]
+///     }
+/// ❱
+/// ```
+///
+/// [Reference](https://doc.rust-lang.org/reference/items/modules.html)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Module {
     pub(crate) syntax: SyntaxNode,
@@ -188,7 +375,28 @@ impl Module {
     pub fn item_list(&self) -> Option<ItemList> { support::child(&self.syntax) }
     pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
 }
-
+/// Item defintion list.
+/// This is used for both top-level items and impl block items.
+///
+/// ```
+/// ❰
+///     fn foo {}
+///     struct Bar;
+///     enum Baz;
+///     trait Bruh;
+///     const BRUUH: u32 = 42;
+/// ❱
+///
+/// impl Foo
+/// ❰
+///     {
+///         fn bar() {}
+///         const BAZ: u32 = 42;
+///     }
+/// ❱
+/// ```
+///
+/// [Reference](https://doc.rust-lang.org/reference/items.html)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ItemList {
     pub(crate) syntax: SyntaxNode,
@@ -199,7 +407,18 @@ impl ItemList {
     pub fn assoc_items(&self) -> AstChildren<AssocItem> { support::children(&self.syntax) }
     pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
 }
-
+/// Constant variable definition.
+/// Includes all of its attributes and doc comments.
+///
+/// ```
+/// ❰
+///     /// Docs
+///     #[attr]
+///     pub const FOO: u32 = 42;
+/// ❱
+/// ```
+///
+/// [Reference](https://doc.rust-lang.org/reference/items/constant-items.html)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ConstDef {
     pub(crate) syntax: SyntaxNode,
@@ -217,7 +436,18 @@ impl ConstDef {
     pub fn body(&self) -> Option<Expr> { support::child(&self.syntax) }
     pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
 }
-
+/// Static variable definition.
+/// Includes all of its attributes and doc comments.
+///
+/// ```
+/// ❰
+///     /// Docs
+///     #[attr]
+///     pub static mut FOO: u32 = 42;
+/// ❱
+/// ```
+///
+/// [Reference](https://doc.rust-lang.org/reference/items/static-items.html)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct StaticDef {
     pub(crate) syntax: SyntaxNode,
@@ -235,7 +465,24 @@ impl StaticDef {
     pub fn body(&self) -> Option<Expr> { support::child(&self.syntax) }
     pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
 }
-
+/// Type alias definition.
+/// Includes associated type clauses with type bounds.
+///
+/// ```
+/// ❰
+///     /// Docs
+///     #[attr]
+///     pub type Foo<T> where T: Debug = T;
+/// ❱
+///
+/// trait Bar {
+///     ❰ type Baz: Debug; ❱
+///     ❰ type Bruh = String; ❱
+///     ❰ type Bruuh: Debug = u32; ❱
+/// }
+/// ```
+///
+/// [Reference](https://doc.rust-lang.org/reference/items/type-aliases.html)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct TypeAliasDef {
     pub(crate) syntax: SyntaxNode,
@@ -253,7 +500,20 @@ impl TypeAliasDef {
     pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
     pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
 }
-
+/// Inherent and trait impl definition.
+/// Includes all of its inner and outer attributes.
+///
+/// ```
+/// ❰
+///     #[attr]
+///     unsafe impl<T> const !Foo for Bar where T: Debug {
+///         #![inner_attr]
+///         // ...
+///     }
+/// ❱
+/// ```
+///
+/// [Reference](https://doc.rust-lang.org/reference/items/implementations.html)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ImplDef {
     pub(crate) syntax: SyntaxNode,
@@ -270,7 +530,16 @@ impl ImplDef {
     pub fn for_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![for]) }
     pub fn item_list(&self) -> Option<ItemList> { support::child(&self.syntax) }