Repository: rust-analyzer/rust-analyzer
Pull request #5422 (2020-07-17 12:38:37)

Rewrite def map tests from insta to expect
Those indentation markers are annoying...



bors r+
🤖


Patch:
diff --git a/crates/ra_ide/src/display/navigation_target.rs b/crates/ra_ide/src/display/navigation_target.rs
index 6dcb9415ab..fd245705c1 100644
--- a/crates/ra_ide/src/display/navigation_target.rs
+++ b/crates/ra_ide/src/display/navigation_target.rs
@@ -418,3 +418,74 @@ pub(crate) fn description_from_symbol(db: &RootDatabase, symbol: &FileSymbol) ->
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use expect::expect;
+
+    use crate::{mock_analysis::single_file, Query};
+
+    #[test]
+    fn test_nav_for_symbol() {
+        let (analysis, _) = single_file(
+            r#"
+enum FooInner { }
+fn foo() { enum FooInner { } }
+"#,
+        );
+
+        let navs = analysis.symbol_search(Query::new("FooInner".to_string())).unwrap();
+        expect![[r#"
+            [
+                NavigationTarget {
+                    file_id: FileId(
+                        1,
+                    ),
+                    full_range: 0..17,
+                    focus_range: Some(
+                        5..13,
+                    ),
+                    name: "FooInner",
+                    kind: ENUM_DEF,
+                    container_name: None,
+                    description: Some(
+                        "enum FooInner",
+                    ),
+                    docs: None,
+                },
+                NavigationTarget {
+                    file_id: FileId(
+                        1,
+                    ),
+                    full_range: 29..46,
+                    focus_range: Some(
+                        34..42,
+                    ),
+                    name: "FooInner",
+                    kind: ENUM_DEF,
+                    container_name: Some(
+                        "foo",
+                    ),
+                    description: Some(
+                        "enum FooInner",
+                    ),
+                    docs: None,
+                },
+            ]
+        "#]]
+        .assert_debug_eq(&navs);
+    }
+
+    #[test]
+    fn test_world_symbols_are_case_sensitive() {
+        let (analysis, _) = single_file(
+            r#"
+fn foo() {}
+struct Foo;
+"#,
+        );
+
+        let navs = analysis.symbol_search(Query::new("foo".to_string())).unwrap();
+        assert_eq!(navs.len(), 2)
+    }
+}
diff --git a/crates/ra_ide/src/lib.rs b/crates/ra_ide/src/lib.rs
index 353f430ff1..dc9192d42c 100644
--- a/crates/ra_ide/src/lib.rs
+++ b/crates/ra_ide/src/lib.rs
@@ -526,77 +526,3 @@ fn analysis_is_send() {
     fn is_send<T: Send>() {}
     is_send::<Analysis>();
 }
-
-#[cfg(test)]
-mod tests {
-    use crate::{display::NavigationTarget, mock_analysis::single_file, Query};
-    use ra_syntax::{
-        SmolStr,
-        SyntaxKind::{FN_DEF, STRUCT_DEF},
-    };
-
-    #[test]
-    fn test_world_symbols_with_no_container() {
-        let code = r#"
-    enum FooInner { }
-    "#;
-
-        let mut symbols = get_symbols_matching(code, "FooInner");
-
-        let s = symbols.pop().unwrap();
-
-        assert_eq!(s.name, "FooInner");
-        assert!(s.container_name.is_none());
-    }
-
-    #[test]
-    fn test_world_symbols_include_container_name() {
-        let code = r#"
-fn foo() {
-    enum FooInner { }
-}
-    "#;
-
-        let mut symbols = get_symbols_matching(code, "FooInner");
-
-        let s = symbols.pop().unwrap();
-
-        assert_eq!(s.name, "FooInner");
-        assert_eq!(s.container_name, Some(SmolStr::new("foo")));
-
-        let code = r#"
-mod foo {
-    struct FooInner;
-}
-    "#;
-
-        let mut symbols = get_symbols_matching(code, "FooInner");
-
-        let s = symbols.pop().unwrap();
-
-        assert_eq!(s.name, "FooInner");
-        assert_eq!(s.container_name, Some(SmolStr::new("foo")));
-    }
-
-    #[test]
-    fn test_world_symbols_are_case_sensitive() {
-        let code = r#"
-fn foo() {}
-
-struct Foo;
-        "#;
-
-        let symbols = get_symbols_matching(code, "Foo");
-
-        let fn_match = symbols.iter().find(|s| s.name == "foo").map(|s| s.kind);
-        let struct_match = symbols.iter().find(|s| s.name == "Foo").map(|s| s.kind);
-
-        assert_eq!(fn_match, Some(FN_DEF));
-        assert_eq!(struct_match, Some(STRUCT_DEF));
-    }
-
-    fn get_symbols_matching(text: &str, query: &str) -> Vec<NavigationTarget> {
-        let (analysis, _) = single_file(text);
-        analysis.symbol_search(Query::new(query.into())).unwrap()
-    }
-}


Test patch:
diff --git a/crates/ra_hir_def/src/nameres/tests.rs b/crates/ra_hir_def/src/nameres/tests.rs
index 503099fb74..02dca80c25 100644
--- a/crates/ra_hir_def/src/nameres/tests.rs
+++ b/crates/ra_hir_def/src/nameres/tests.rs
@@ -6,558 +6,531 @@ mod primitives;
 
 use std::sync::Arc;
 
-use insta::assert_snapshot;
+use expect::{expect, Expect};
 use ra_db::{fixture::WithFixture, SourceDatabase};
 use test_utils::mark;
 
 use crate::{db::DefDatabase, nameres::*, test_db::TestDB};
 
-fn def_map(ra_fixture: &str) -> String {
-    compute_crate_def_map(ra_fixture).dump()
-}
-
 fn compute_crate_def_map(fixture: &str) -> Arc<CrateDefMap> {
     let db = TestDB::with_files(fixture);
     let krate = db.crate_graph().iter().next().unwrap();
     db.crate_def_map(krate)
 }
 
+fn check(ra_fixture: &str, expect: Expect) {
+    let db = TestDB::with_files(ra_fixture);
+    let krate = db.crate_graph().iter().next().unwrap();
+    let actual = db.crate_def_map(krate).dump() + "\n";
+    expect.assert_eq(&actual);
+}
+
 #[test]
 fn crate_def_map_smoke_test() {
-    let map = def_map(
-        r"
-        //- /lib.rs
-        mod foo;
-        struct S;
-        use crate::foo::bar::E;
-        use self::E::V;
-
-        //- /foo/mod.rs
-        pub mod bar;
-        fn f() {}
-
-        //- /foo/bar.rs
-        pub struct Baz;
-
-        union U {
-            to_be: bool,
-            not_to_be: u8,
-        }
+    check(
+        r#"
+//- /lib.rs
+mod foo;
+struct S;
+use crate::foo::bar::E;
+use self::E::V;
 
-        enum E { V }
+//- /foo/mod.rs
+pub mod bar;
+fn f() {}
 
-        extern {
-            static EXT: u8;
-            fn ext();
-        }
-        ",
+//- /foo/bar.rs
+pub struct Baz;
+
+union U { to_be: bool, not_to_be: u8 }
+enum E { V }
+
+extern {
+    static EXT: u8;
+    fn ext();
+}
+"#,
+        expect![[r#"
+            crate
+            E: t
+            S: t v
+            V: t v
+            foo: t
+
+            crate::foo
+            bar: t
+            f: v
+
+            crate::foo::bar
+            Baz: t v
+            E: t
+            EXT: v
+            U: t
+            ext: v
+        "#]],
     );
-    assert_snapshot!(map, @r###"
-        ⋮crate
-        ⋮E: t
-        ⋮S: t v
-        ⋮V: t v
-        ⋮foo: t
-        ⋮
-        ⋮crate::foo
-        ⋮bar: t
-        ⋮f: v
-        ⋮
-        ⋮crate::foo::bar
-        ⋮Baz: t v
-        ⋮E: t
-        ⋮EXT: v
-        ⋮U: t
-        ⋮ext: v
-    "###)
 }
 
 #[test]
 fn crate_def_map_super_super() {
-    let map = def_map(
-        "
-        //- /lib.rs
-        mod a {
-            const A: usize = 0;
-
-            mod b {
-                const B: usize = 0;
-
-                mod c {
-                    use super::super::*;
-                }
-            }
+    check(
+        r#"
+mod a {
+    const A: usize = 0;
+    mod b {
+        const B: usize = 0;
+        mod c {
+            use super::super::*;
         }
-        ",
+    }
+}
+"#,
+        expect![[r#"
+            crate
+            a: t
+
+            crate::a
+            A: v
+            b: t
+
+            crate::a::b
+            B: v
+            c: t
+
+            crate::a::b::c
+            A: v
+            b: t
+        "#]],
     );
-    assert_snapshot!(map, @r###"
-        ⋮crate
-        ⋮a: t
-        ⋮
-        ⋮crate::a
-        ⋮A: v
-        ⋮b: t
-        ⋮
-        ⋮crate::a::b
-        ⋮B: v
-        ⋮c: t
-        ⋮
-        ⋮crate::a::b::c
-        ⋮A: v
-        ⋮b: t
-    "###)
 }
 
 #[test]
 fn crate_def_map_fn_mod_same_name() {
-    let map = def_map(
-        "
-        //- /lib.rs
-        mod m {
-            pub mod z {}
-            pub fn z() {}
-        }
-        ",
+    check(
+        r#"
+mod m {
+    pub mod z {}
+    pub fn z() {}
+}
+"#,
+        expect![[r#"
+            crate
+            m: t
+
+            crate::m
+            z: t v
+
+            crate::m::z
+        "#]],
     );
-    assert_snapshot!(map, @r###"
-        ⋮crate
-        ⋮m: t
-        ⋮
-        ⋮crate::m
-        ⋮z: t v
-        ⋮
-        ⋮crate::m::z
-    "###)
 }
 
 #[test]
 fn bogus_paths() {
     mark::check!(bogus_paths);
-    let map = def_map(
-        "
-        //- /lib.rs
-        mod foo;
-        struct S;
-        use self;
-
-        //- /foo/mod.rs
-        use super;
-        use crate;
-
-        ",
+    check(
+        r#"
+//- /lib.rs
+mod foo;
+struct S;
+use self;
+
+//- /foo/mod.rs
+use super;
+use crate;
+"#,
+        expect![[r#"
+            crate
+            S: t v
+            foo: t
+
+            crate::foo
+        "#]],
     );
-    assert_snapshot!(map, @r###"
-   ⋮crate
-   ⋮S: t v
-   ⋮foo: t
-   ⋮
-   ⋮crate::foo
-    "###
-    )
 }
 
 #[test]
 fn use_as() {
-    let map = def_map(
-        "
-        //- /lib.rs
-        mod foo;
-
-        use crate::foo::Baz as Foo;
+    check(
+        r#"
+//- /lib.rs
+mod foo;
+use crate::foo::Baz as Foo;
 
-        //- /foo/mod.rs
-        pub struct Baz;
-        ",
-    );
-    assert_snapshot!(map,
-        @r###"
-   ⋮crate
-   ⋮Foo: t v
-   ⋮foo: t
-   ⋮
-   ⋮crate::foo
-   ⋮Baz: t v
-    "###
+//- /foo/mod.rs
+pub struct Baz;
+"#,
+        expect![[r#"
+            crate
+            Foo: t v
+            foo: t
+
+            crate::foo
+            Baz: t v
+        "#]],
     );
 }
 
 #[test]
 fn use_trees() {
-    let map = def_map(
-        "
-        //- /lib.rs
-        mod foo;
-
-        use crate::foo::bar::{Baz, Quux};
+    check(
+        r#"
+//- /lib.rs
+mod foo;
+use crate::foo::bar::{Baz, Quux};
 
-        //- /foo/mod.rs
-        pub mod bar;
+//- /foo/mod.rs
+pub mod bar;
 
-        //- /foo/bar.rs
-        pub struct Baz;
-        pub enum Quux {};
-        ",
+//- /foo/bar.rs
+pub struct Baz;
+pub enum Quux {};
+"#,
+        expect![[r#"
+            crate
+            Baz: t v
+            Quux: t
+            foo: t
+
+            crate::foo
+            bar: t
+
+            crate::foo::bar
+            Baz: t v
+            Quux: t
+        "#]],
     );
-    assert_snapshot!(map, @r###"
-        ⋮crate
-        ⋮Baz: t v
-        ⋮Quux: t
-        ⋮foo: t
-        ⋮
-        ⋮crate::foo
-        ⋮bar: t
-        ⋮
-        ⋮crate::foo::bar
-        ⋮Baz: t v
-        ⋮Quux: t
-    "###);
 }
 
 #[test]
 fn re_exports() {
-    let map = def_map(
-        "
-        //- /lib.rs
-        mod foo;
-
-        use self::foo::Baz;
-
-        //- /foo/mod.rs
-        pub mod bar;
+    check(
+        r#"
+//- /lib.rs
+mod foo;
+use self::foo::Baz;
 
-        pub use self::bar::Baz;
+//- /foo/mod.rs
+pub mod bar;
+pub use self::bar::Baz;
 
-        //- /foo/bar.rs
-        pub struct Baz;
-        ",
+//- /foo/bar.rs
+pub struct Baz;
+"#,
+        expect![[r#"
+            crate
+            Baz: t v
+            foo: t
+
+            crate::foo
+            Baz: t v
+            bar: t
+
+            crate::foo::bar
+            Baz: t v
+        "#]],
     );
-    assert_snapshot!(map, @r###"
-        ⋮crate
-        ⋮Baz: t v
-        ⋮foo: t
-        ⋮
-        ⋮crate::foo
-        ⋮Baz: t v
-        ⋮bar: t
-        ⋮
-        ⋮crate::foo::bar
-        ⋮Baz: t v
-    "###);
 }
 
 #[test]
 fn std_prelude() {
     mark::check!(std_prelude);
-    let map = def_map(
-        "
-        //- /main.rs crate:main deps:test_crate
-        use Foo::*;
-
-        //- /lib.rs crate:test_crate
-        mod prelude;
-        #[prelude_import]
-        use prelude::*;
-
-        //- /prelude.rs
-        pub enum Foo { Bar, Baz };
-        ",
+    check(
+        r#"
+//- /main.rs crate:main deps:test_crate
+use Foo::*;
+
+//- /lib.rs crate:test_crate
+mod prelude;
+#[prelude_import]
+use prelude::*;
+
+//- /prelude.rs
+pub enum Foo { Bar, Baz };
+"#,
+        expect![[r#"
+            crate
+            Bar: t v
+            Baz: t v
+        "#]],
     );
-    assert_snapshot!(map, @r###"
-        ⋮crate
-        ⋮Bar: t v
-        ⋮Baz: t v
-    "###);
 }
 
 #[test]
 fn can_import_enum_variant() {
     mark::check!(can_import_enum_variant);
-    let map = def_map(
-        "
-        //- /lib.rs
-        enum E { V }
-        use self::E::V;
-        ",
-    );
-    assert_snapshot!(map, @r###"
-        ⋮crate
-        ⋮E: t
-        ⋮V: t v
-    "###
+    check(
+        r#"
+enum E { V }
+use self::E::V;
+"#,
+        expect![[r#"
+            crate
+            E: t
+            V: t v
+        "#]],
     );
 }
 
 #[test]
 fn edition_2015_imports() {
-    let map = def_map(
-        "
-        //- /main.rs crate:main deps:other_crate edition:2015
-        mod foo;
-        mod bar;
-
-        //- /bar.rs
-        struct Bar;
-
-        //- /foo.rs
-        use bar::Bar;
-        use other_crate::FromLib;
-
-        //- /lib.rs crate:other_crate edition:2018
-        struct FromLib;
-        ",
-    );
+    check(
+        r#"
+//- /main.rs crate:main deps:other_crate edition:2015
+mod foo;
+mod bar;
+
+//- /bar.rs
+struct Bar;
 
-    assert_snapshot!(map, @r###"
-        ⋮crate
-        ⋮bar: t
-        ⋮foo: t
-        ⋮
-        ⋮crate::bar
-        ⋮Bar: t v
-        ⋮
-        ⋮crate::foo
-        ⋮Bar: t v
-        ⋮FromLib: t v
-    "###);
+//- /foo.rs
+use bar::Bar;
+use other_crate::FromLib;
+
+//- /lib.rs crate:other_crate edition:2018
+struct FromLib;
+"#,
+        expect![[r#"
+            crate
+            bar: t
+            foo: t
+
+            crate::bar
+            Bar: t v
+
+            crate::foo
+            Bar: t v
+            FromLib: t v
+        "#]],
+    );
 }
 
 #[test]
 fn item_map_using_self() {
-    let map = def_map(
-        "
-        //- /lib.rs
-        mod foo;
-        use crate::foo::bar::Baz::{self};
-        //- /foo/mod.rs
-        pub mod bar;
-        //- /foo/bar.rs
-        pub struct Baz;
-        ",
+    check(
+        r#"
+//- /lib.rs
+mod foo;
+use crate::foo::bar::Baz::{self};
+
+//- /foo/mod.rs
+pub mod bar;
+
+//- /foo/bar.rs
+pub struct Baz;
+"#,
+        expect![[r#"
+            crate
+            Baz: t v
+            foo: t
+
+            crate::foo
+            bar: t
+
+            crate::foo::bar
+            Baz: t v
+        "#]],
     );
-    assert_snapshot!(map, @r###"
-        ⋮crate
-        ⋮Baz: t v
-        ⋮foo: t
-        ⋮
-        ⋮crate::foo
-        ⋮bar: t
-        ⋮
-        ⋮crate::foo::bar
-        ⋮Baz: t v
-    "###);
 }
 
 #[test]
 fn item_map_across_crates() {
-    let map = def_map(
-        "
-        //- /main.rs crate:main deps:test_crate
-        use test_crate::Baz;
-
-        //- /lib.rs crate:test_crate
-        pub struct Baz;
-        ",
-    );
+    check(
+        r#"
+//- /main.rs crate:main deps:test_crate
+use test_crate::Baz;
 
-    assert_snapshot!(map, @r###"
-        ⋮crate
-        ⋮Baz: t v
-    "###);
+//- /lib.rs crate:test_crate
+pub struct Baz;
+"#,
+        expect![[r#"
+            crate
+            Baz: t v
+        "#]],
+    );
 }
 
 #[test]
 fn extern_crate_rename() {
-    let map = def_map(
-        "
-        //- /main.rs crate:main deps:alloc
-        extern crate alloc as alloc_crate;
-
-        mod alloc;
-        mod sync;
+    check(
+        r#"
+//- /main.rs crate:main deps:alloc
+extern crate alloc as alloc_crate;
+mod alloc;
+mod sync;
 
-        //- /sync.rs
-        use alloc_crate::Arc;
+//- /sync.rs
+use alloc_crate::Arc;
 
-        //- /lib.rs crate:alloc
-        struct Arc;
-        ",
+//- /lib.rs crate:alloc
+struct Arc;
+"#,
+        expect![[r#"
+            crate
+            alloc_crate: t
+            sync: t
+
+            crate::sync
+            Arc: t v
+        "#]],
     );
-
-    assert_snapshot!(map, @r###"
-   ⋮crate
-   ⋮alloc_crate: t
-   ⋮sync: t
-   ⋮
-   ⋮crate::sync
-   ⋮Arc: t v
-    "###);
 }
 
 #[test]
 fn extern_crate_rename_2015_edition() {
-    let map = def_map(
-        "
-        //- /main.rs crate:main deps:alloc edition:2015
-        extern crate alloc as alloc_crate;
-
-        mod alloc;
-        mod sync;
-
-        //- /sync.rs
-        use alloc_crate::Arc;
+    check(
+        r#"
+//- /main.rs crate:main deps:alloc edition:2015
+extern crate alloc as alloc_crate;
+mod alloc;
+mod sync;
 
-        //- /lib.rs crate:alloc
-        struct Arc;
-        ",
-    );
+//- /sync.rs
+use alloc_crate::Arc;
 
-    assert_snapshot!(map,
-        @r###"
-   ⋮crate
-   ⋮alloc_crate: t
-   ⋮sync: t
-   ⋮
-   ⋮crate::sync
-   ⋮Arc: t v
-    "###
+//- /lib.rs crate:alloc
+struct Arc;
+"#,
+        expect![[r#"
+            crate
+            alloc_crate: t
+            sync: t
+
+            crate::sync
+            Arc: t v
+        "#]],
     );
 }
 
 #[test]
 fn reexport_across_crates() {
-    let map = def_map(
-        "
-        //- /main.rs crate:main deps:test_crate
-        use test_crate::Baz;
-
-        //- /lib.rs crate:test_crate
-        pub use foo::Baz;
+    check(
+        r#"
+//- /main.rs crate:main deps:test_crate
+use test_crate::Baz;
 
-        mod foo;
+//- /lib.rs crate:test_crate
+pub use foo::Baz;
+mod foo;
 
-        //- /foo.rs
-        pub struct Baz;
-        ",
+//- /foo.rs
+pub struct Baz;
+"#,
+        expect![[r#"
+            crate
+            Baz: t v
+        "#]],
     );
-
-    assert_snapshot!(map, @r###"
-        ⋮crate
-        ⋮Baz: t v
-    "###);
 }
 
 #[test]
 fn values_dont_shadow_extern_crates() {
-    let map = def_map(
-        "
-        //- /main.rs crate:main deps:foo
-        fn foo() {}
-        use foo::Bar;
-
-        //- /foo/lib.rs crate:foo
-        pub struct Bar;
-        ",
-    );
+    check(
+        r#"
+//- /main.rs crate:main deps:foo
+fn foo() {}
+use foo::Bar;
 
-    assert_snapshot!(map, @r###"
-        ⋮crate
-        ⋮Bar: t v
-        ⋮foo: v
-    "###);
+//- /foo/lib.rs crate:foo
+pub struct Bar;
+"#,
+        expect![[r#"
+            crate
+            Bar: t v
+            foo: v
+        "#]],
+    );
 }
 
 #[test]
 fn std_prelude_takes_precedence_above_core_prelude() {
-    let map = def_map(
+    check(
         r#"
-        //- /main.rs crate:main deps:core,std
-        use {Foo, Bar};
-
-        //- /std.rs crate:std deps:core
-        #[prelude_import]
-        pub use self::prelude::*;
-        mod prelude {
-            pub struct Foo;
-            pub use core::prelude::Bar;
-        }
+//- /main.rs crate:main deps:core,std
+use {Foo, Bar};
+
+//- /std.rs crate:std deps:core
+#[prelude_import]
+pub use self::prelude::*;
+mod prelude {
+    pub struct Foo;
+    pub use core::prelude::Bar;
+}
 
-        //- /core.rs crate:core
-        #[prelude_import]
-        pub use self::prelude::*;
-        mod prelude {
-            pub struct Bar;
-        }
-        "#,
+//- /core.rs crate:core
+#[prelude_import]
+pub use self::prelude::*;
+mod prelude {
+    pub struct Bar;
+}
+"#,
+        expect![[r#"
+            crate
+            Bar: t v
+            Foo: t v
+        "#]],
     );
-
-    assert_snapshot!(map, @r###"
-        ⋮crate
-        ⋮Bar: t v
-        ⋮Foo: t v
-    "###);
 }
 
 #[test]
 fn cfg_not_test() {
-    let map = def_map(
+    check(
         r#"
-        //- /main.rs crate:main deps:std
-        use {Foo, Bar, Baz};
-
-        //- /lib.rs crate:std
-        #[prelude_import]
-        pub use self::prelude::*;
-        mod prelude {
-            #[cfg(test)]
-            pub struct Foo;
-            #[cfg(not(test))]
-            pub struct Bar;
-            #[cfg(all(not(any()), feature = "foo", feature = "bar", opt = "42"))]
-            pub struct Baz;
-        }
-        "#,
+//- /main.rs crate:main deps:std
+use {Foo, Bar, Baz};
+
+//- /lib.rs crate:std
+#[prelude_import]
+pub use self::prelude::*;
+mod prelude {
+    #[cfg(test)]
+    pub struct Foo;
+    #[cfg(not(test))]
+    pub struct Bar;
+    #[cfg(all(not(any()), feature = "foo", feature = "bar", opt = "42"))]
+    pub struct Baz;
+}
+"#,
+        expect![[r#"
+            crate
+            Bar: t v
+            Baz: _
+            Foo: _
+        "#]],
     );
-
-    assert_snapshot!(map, @r###"
-        ⋮crate
-        ⋮Bar: t v
-        ⋮Baz: _
-        ⋮Foo: _
-    "###);
 }
 
 #[test]
 fn cfg_test() {
-    let map = def_map(
+    check(
         r#"
-        //- /main.rs crate:main deps:std
-        use {Foo, Bar, Baz};
-
-        //- /lib.rs crate:std cfg:test,feature=foo,feature=bar,opt=42
-        #[prelude_import]
-        pub use self::prelude::*;
-        mod prelude {
-            #[cfg(test)]
-            pub struct Foo;
-            #[cfg(not(test))]
-            pub struct Bar;
-            #[cfg(all(not(any()), feature = "foo", feature = "bar", opt = "42"))]
-            pub struct Baz;
-        }
-        "#,
+//- /main.rs crate:main deps:std
+use {Foo, Bar, Baz};
+
+//- /lib.rs crate:std cfg:test,feature=foo,feature=bar,opt=42
+#[prelude_import]
+pub use self::prelude::*;
+mod prelude {
+    #[cfg(test)]
+    pub struct Foo;
+    #[cfg(not(test))]
+    pub struct Bar;
+    #[cfg(all(not(any()), feature = "foo", feature = "bar", opt = "42"))]
+    pub struct Baz;
+}
+"#,
+        expect![[r#"
+            crate
+            Bar: _
+            Baz: t v
+            Foo: t v
+        "#]],
     );
-
-    assert_snapshot!(map, @r###"
-        ⋮crate
-        ⋮Bar: _
-        ⋮Baz: t v
-        ⋮Foo: t v
-    "###);
 }
 
 #[test]
 fn infer_multiple_namespace() {
-    let map = def_map(
+    check(
         r#"
 //- /main.rs
 mod a {
@@ -571,18 +544,17 @@ mod b {
     pub const T: () = ();
 }
 "#,
+        expect![[r#"
+            crate
+            T: t v
+            a: t
+            b: t
+
+            crate::b
+            T: v
+
+            crate::a
+            T: t v
+        "#]],
     );
-
-    assert_snapshot!(map, @r###"
-    ⋮crate
-    ⋮T: t v
-    ⋮a: t
-    ⋮b: t
-    ⋮
-    ⋮crate::b
-    ⋮T: v
-    ⋮
-    ⋮crate::a
-    ⋮T: t v
-"###);
 }
diff --git a/crates/ra_hir_def/src/nameres/tests/globs.rs b/crates/ra_hir_def/src/nameres/tests/globs.rs
index 7f3d7509c9..2ae836e3c2 100644
--- a/crates/ra_hir_def/src/nameres/tests/globs.rs
+++ b/crates/ra_hir_def/src/nameres/tests/globs.rs
@@ -2,367 +2,337 @@ use super::*;
 
 #[test]
 fn glob_1() {
-    let map = def_map(
-        r"
-        //- /lib.rs
-        mod foo;
-        use foo::*;
-
-        //- /foo/mod.rs
-        pub mod bar;
-        pub use self::bar::Baz;
-        pub struct Foo;
-
-        //- /foo/bar.rs
-        pub struct Baz;
-        ",
-    );
-    assert_snapshot!(map, @r###"
-   ⋮crate
-   ⋮Baz: t v
-   ⋮Foo: t v
-   ⋮bar: t
-   ⋮foo: t
-   ⋮
-   ⋮crate::foo
-   ⋮Baz: t v
-   ⋮Foo: t v
-   ⋮bar: t
-   ⋮
-   ⋮crate::foo::bar
-   ⋮Baz: t v
-    "###
+    check(
+        r#"
+//- /lib.rs
+mod foo;
+use foo::*;
+
+//- /foo/mod.rs
+pub mod bar;
+pub use self::bar::Baz;
+pub struct Foo;
+
+//- /foo/bar.rs
+pub struct Baz;
+"#,
+        expect![[r#"
+            crate
+            Baz: t v
+            Foo: t v
+            bar: t
+            foo: t
+
+            crate::foo
+            Baz: t v
+            Foo: t v
+            bar: t
+
+            crate::foo::bar
+            Baz: t v
+        "#]],
     );
 }
 
 #[test]
 fn glob_2() {
-    let map = def_map(
-        "
-        //- /lib.rs
-        mod foo;
-        use foo::*;
-
-        //- /foo/mod.rs
-        pub mod bar;
-        pub use self::bar::*;
-        pub struct Foo;
-
-        //- /foo/bar.rs
-        pub struct Baz;
-        pub use super::*;
-        ",
-    );
-    assert_snapshot!(map, @r###"
-   ⋮crate
-   ⋮Baz: t v
-   ⋮Foo: t v
-   ⋮bar: t
-   ⋮foo: t
-   ⋮
-   ⋮crate::foo
-   ⋮Baz: t v
-   ⋮Foo: t v
-   ⋮bar: t
-   ⋮
-   ⋮crate::foo::bar
-   ⋮Baz: t v
-   ⋮Foo: t v
-   ⋮bar: t
-    "###
+    check(
+        r#"
+//- /lib.rs
+mod foo;
+use foo::*;
+
+//- /foo/mod.rs
+pub mod bar;
+pub use self::bar::*;
+pub struct Foo;
+
+//- /foo/bar.rs
+pub struct Baz;
+pub use super::*;
+"#,
+        expect![[r#"
+            crate
+            Baz: t v
+            Foo: t v
+            bar: t
+            foo: t
+
+            crate::foo
+            Baz: t v
+            Foo: t v
+            bar: t
+
+            crate::foo::bar
+            Baz: t v
+            Foo: t v
+            bar: t
+        "#]],
     );
 }
 
 #[test]
 fn glob_privacy_1() {
-    let map = def_map(
+    check(
         r"
-        //- /lib.rs
-        mod foo;
-        use foo::*;
-
-        //- /foo/mod.rs
-        pub mod bar;
-        pub use self::bar::*;
-        struct PrivateStructFoo;
-
-        //- /foo/bar.rs
-        pub struct Baz;
-        struct PrivateStructBar;
-        pub use super::*;
-        ",
-    );
-    assert_snapshot!(map, @r###"
-        ⋮crate
-        ⋮Baz: t v
-        ⋮bar: t
-        ⋮foo: t
-        ⋮
-        ⋮crate::foo
-        ⋮Baz: t v
-        ⋮PrivateStructFoo: t v
-        ⋮bar: t
-        ⋮
-        ⋮crate::foo::bar
-        ⋮Baz: t v
-        ⋮PrivateStructBar: t v
-        ⋮PrivateStructFoo: t v
-        ⋮bar: t
-    "###
+//- /lib.rs
+mod foo;
+use foo::*;
+
+//- /foo/mod.rs
+pub mod bar;
+pub use self::bar::*;
+struct PrivateStructFoo;
+
+//- /foo/bar.rs
+pub struct Baz;
+struct PrivateStructBar;
+pub use super::*;
+",
+        expect![[r#"
+            crate
+            Baz: t v
+            bar: t
+            foo: t
+
+            crate::foo
+            Baz: t v
+            PrivateStructFoo: t v
+            bar: t
+
+            crate::foo::bar
+            Baz: t v
+            PrivateStructBar: t v
+            PrivateStructFoo: t v
+            bar: t
+        "#]],
     );
 }
 
 #[test]
 fn glob_privacy_2() {
-    let map = def_map(
+    check(
         r"
-        //- /lib.rs
-        mod foo;
-        use foo::*;
-        use foo::bar::*;
-
-        //- /foo/mod.rs
-        mod bar;
-        fn Foo() {};
-        pub struct Foo {};
-
-        //- /foo/bar.rs
-        pub(super) struct PrivateBaz;
-        struct PrivateBar;
-        pub(crate) struct PubCrateStruct;
-        ",
-    );
-    assert_snapshot!(map, @r###"
-        ⋮crate
-        ⋮Foo: t
-        ⋮PubCrateStruct: t v
-        ⋮foo: t
-        ⋮
-        ⋮crate::foo
-        ⋮Foo: t v
-        ⋮bar: t
-        ⋮
-        ⋮crate::foo::bar
-        ⋮PrivateBar: t v
-        ⋮PrivateBaz: t v
-        ⋮PubCrateStruct: t v
-    "###
+//- /lib.rs
+mod foo;
+use foo::*;
+use foo::bar::*;
+
+//- /foo/mod.rs
+mod bar;
+fn Foo() {};
+pub struct Foo {};
+
+//- /foo/bar.rs
+pub(super) struct PrivateBaz;
+struct PrivateBar;
+pub(crate) struct PubCrateStruct;
+",
+        expect![[r#"
+            crate
+            Foo: t
+            PubCrateStruct: t v
+            foo: t
+
+            crate::foo
+            Foo: t v
+            bar: t
+
+            crate::foo::bar
+            PrivateBar: t v
+            PrivateBaz: t v
+            PubCrateStruct: t v
+        "#]],
     );
 }
 
 #[test]
 fn glob_across_crates() {
     mark::check!(glob_across_crates);
-    let map = def_map(
-        r"
-        //- /main.rs crate:main deps:test_crate
-        use test_crate::*;
+    check(
+        r#"
+//- /main.rs crate:main deps:test_crate
+use test_crate::*;
 
-        //- /lib.rs crate:test_crate
-        pub struct Baz;
-        ",
-    );
-    assert_snapshot!(map, @r###"
-        ⋮crate
-        ⋮Baz: t v
-    "###
+//- /lib.rs crate:test_crate
+pub struct Baz;
+"#,
+        expect![[r#"
+            crate
+            Baz: t v
+        "#]],
     );
 }
 
 #[test]
 fn glob_privacy_across_crates() {
-    let map = def_map(
-        r"
-        //- /main.rs crate:main deps:test_crate
-        use test_crate::*;
+    check(
+        r#"
+//- /main.rs crate:main deps:test_crate
+use test_crate::*;
 
-        //- /lib.rs crate:test_crate
-        pub struct Baz;
-        struct Foo;
-        ",
-    );
-    assert_snapshot!(map, @r###"
-        ⋮crate
-        ⋮Baz: t v
-    "###
+//- /lib.rs crate:test_crate
+pub struct Baz;
+struct Foo;
+"#,
+        expect![[r#"
+            crate
+            Baz: t v
+        "#]],
     );
 }
 
 #[test]
 fn glob_enum() {
     mark::check!(glob_enum);
-    let map = def_map(
-        "
-        //- /lib.rs
-        enum Foo {
-            Bar, Baz
-        }
-        use self::Foo::*;
-        ",
-    );
-    assert_snapshot!(map, @r###"
-        ⋮crate
-        ⋮Bar: t v
-        ⋮Baz: t v
-        ⋮Foo: t
-    "###
+    check(
+        r#"
+enum Foo { Bar, Baz }
+use self::Foo::*;
+"#,
+        expect![[r#"
+            crate
+            Bar: t v
+            Baz: t v
+            Foo: t
+        "#]],
     );
 }
 
 #[test]
 fn glob_enum_group() {
     mark::check!(glob_enum_group);
-    let map = def_map(
-        r"
-        //- /lib.rs
-        enum Foo {
-            Bar, Baz
-        }
-        use self::Foo::{*};
-        ",
-    );
-    assert_snapshot!(map, @r###"
-        ⋮crate
-        ⋮Bar: t v
-        ⋮Baz: t v
-        ⋮Foo: t
-    "###
+    check(
+        r#"
+enum Foo { Bar, Baz }
+use self::Foo::{*};
+"#,
+        expect![[r#"
+            crate
+            Bar: t v
+            Baz: t v
+            Foo: t
+        "#]],
     );
 }
 
 #[test]
 fn glob_shadowed_def() {
     mark::check!(import_shadowed);
-    let map = def_map(
-        r###"
-        //- /lib.rs
-        mod foo;
-        mod bar;
-
-        use foo::*;
-        use bar::baz;
-
-        use baz::Bar;
-
-        //- /foo.rs
-        pub mod baz {
-            pub struct Foo;
-        }
-
-        //- /bar.rs
-        pub mod baz {
-            pub struct Bar;
-        }
-        "###,
-    );
-    assert_snapshot!(map, @r###"
-        ⋮crate
-        ⋮Bar: t v
-        ⋮bar: t
-        ⋮baz: t
-        ⋮foo: t
-        ⋮
-        ⋮crate::bar
-        ⋮baz: t
-        ⋮
-        ⋮crate::bar::baz
-        ⋮Bar: t v
-        ⋮
-        ⋮crate::foo
-        ⋮baz: t
-        ⋮
-        ⋮crate::foo::baz
-        ⋮Foo: t v
-    "###
+    check(
+        r#"
+//- /lib.rs
+mod foo;
+mod bar;
+use foo::*;
+use bar::baz;
+use baz::Bar;
+
+//- /foo.rs
+pub mod baz { pub struct Foo; }
+
+//- /bar.rs
+pub mod baz { pub struct Bar; }
+"#,
+        expect![[r#"
+            crate
+            Bar: t v
+            bar: t
+            baz: t
+            foo: t
+
+            crate::bar
+            baz: t
+
+            crate::bar::baz
+            Bar: t v
+
+            crate::foo
+            baz: t
+
+            crate::foo::baz
+            Foo: t v
+        "#]],
     );
 }
 
 #[test]
 fn glob_shadowed_def_reversed() {
-    let map = def_map(
-        r###"
-        //- /lib.rs
-        mod foo;
-        mod bar;
-
-        use bar::baz;
-        use foo::*;
-
-        use baz::Bar;
-
-        //- /foo.rs
-        pub mod baz {
-            pub struct Foo;
-        }
-
-        //- /bar.rs
-        pub mod baz {
-            pub struct Bar;
-        }
-        "###,
-    );
-    assert_snapshot!(map, @r###"
-        ⋮crate
-        ⋮Bar: t v
-        ⋮bar: t
-        ⋮baz: t
-        ⋮foo: t
-        ⋮
-        ⋮crate::bar
-        ⋮baz: t
-        ⋮
-        ⋮crate::bar::baz
-        ⋮Bar: t v
-        ⋮
-        ⋮crate::foo
-        ⋮baz: t
-        ⋮
-        ⋮crate::foo::baz
-        ⋮Foo: t v
-    "###
+    check(
+        r#"
+//- /lib.rs
+mod foo;
+mod bar;
+use bar::baz;
+use foo::*;
+use baz::Bar;
+
+//- /foo.rs
+pub mod baz { pub struct Foo; }
+
+//- /bar.rs
+pub mod baz { pub struct Bar; }
+"#,
+        expect![[r#"
+            crate
+            Bar: t v
+            bar: t
+            baz: t
+            foo: t
+
+            crate::bar
+            baz: t
+
+            crate::bar::baz
+            Bar: t v
+
+            crate::foo
+            baz: t
+
+            crate::foo::baz
+            Foo: t v
+        "#]],
     );
 }
 
 #[test]
 fn glob_shadowed_def_dependencies() {
-    let map = def_map(
-        r###"
-        //- /lib.rs
-        mod a { pub mod foo { pub struct X; } }
-        mod b { pub use super::a::foo; }
-        mod c { pub mod foo { pub struct Y; } }
-        mod d {
-            use super::c::foo;
-            use super::b::*;
-            use foo::Y;
-        }
-        "###,
-    );
-    assert_snapshot!(map, @r###"
-        ⋮crate
-        ⋮a: t
-        ⋮b: t
-        ⋮c: t
-        ⋮d: t
-        ⋮
-        ⋮crate::d
-        ⋮Y: t v
-        ⋮foo: t
-        ⋮
-        ⋮crate::c
-        ⋮foo: t
-        ⋮
-        ⋮crate::c::foo
-        ⋮Y: t v
-        ⋮
-        ⋮crate::b
-        ⋮foo: t
-        ⋮
-        ⋮crate::a
-        ⋮foo: t
-        ⋮
-        ⋮crate::a::foo
-        ⋮X: t v
-    "###
+    check(
+        r#"
+mod a { pub mod foo { pub struct X; } }
+mod b { pub use super::a::foo; }
+mod c { pub mod foo { pub struct Y; } }
+mod d {
+    use super::c::foo;
+    use super::b::*;
+    use foo::Y;
+}
+"#,
+        expect![[r#"
+            crate
+            a: t
+            b: t
+            c: t
+            d: t
+
+            crate::d
+            Y: t v
+            foo: t
+
+            crate::c
+            foo: t
+
+            crate::c::foo
+            Y: t v
+
+            crate::b
+            foo: t
+
+            crate::a
+            foo: t
+
+            crate::a::foo
+            X: t v
+        "#]],
     );
 }
diff --git a/crates/ra_hir_def/src/nameres/tests/macros.rs b/crates/ra_hir_def/src/nameres/tests/macros.rs
index c52341a077..e0fb8bdef4 100644
--- a/crates/ra_hir_def/src/nameres/tests/macros.rs
+++ b/crates/ra_hir_def/src/nameres/tests/macros.rs
@@ -2,655 +2,635 @@ use super::*;
 
 #[test]
 fn macro_rules_are_globally_visible() {
-    let map = def_map(
-        r"
-        //- /lib.rs
-        macro_rules! structs {
-            ($($i:ident),*) => {
-                $(struct $i { field: u32 } )*
-            }
-        }
-        structs!(Foo);
-        mod nested;
-
-        //- /nested.rs
-        structs!(Bar, Baz);
-        ",
+    check(
+        r#"
+//- /lib.rs
+macro_rules! structs {
+    ($($i:ident),*) => {
+        $(struct $i { field: u32 } )*
+    }
+}
+structs!(Foo);
+mod nested;
+
+//- /nested.rs
+structs!(Bar, Baz);
+"#,
+        expect![[r#"
+            crate
+            Foo: t
+            nested: t
+
+            crate::nested
+            Bar: t
+            Baz: t
+        "#]],
     );
-    assert_snapshot!(map, @r###"
-   ⋮crate
-   ⋮Foo: t
-   ⋮nested: t
-   ⋮
-   ⋮crate::nested
-   ⋮Bar: t
-   ⋮Baz: t
-    "###);
 }
 
 #[test]
 fn macro_rules_can_define_modules() {
-    let map = def_map(
-        r"
-        //- /lib.rs
-        macro_rules! m {
-            ($name:ident) => { mod $name;  }
-        }
-        m!(n1);
-
-        mod m {
-            m!(n3)
-        }
-
-        //- /n1.rs
-        m!(n2)
-        //- /n1/n2.rs
-        struct X;
-        //- /m/n3.rs
-        struct Y;
-        ",
+    check(
+        r#"
+//- /lib.rs
+macro_rules! m {
+    ($name:ident) => { mod $name;  }
+}
+m!(n1);
+mod m { m!(n3) }
+
+//- /n1.rs
+m!(n2)
+//- /n1/n2.rs
+struct X;
+//- /m/n3.rs
+struct Y;
+"#,
+        expect![[r#"
+            crate
+            m: t
+            n1: t
+
+            crate::m
+            n3: t
+
+            crate::m::n3
+            Y: t v
+
+            crate::n1
+            n2: t
+
+            crate::n1::n2
+            X: t v
+        "#]],
     );
-    assert_snapshot!(map, @r###"
-        ⋮crate
-        ⋮m: t
-        ⋮n1: t
-        ⋮
-        ⋮crate::m
-        ⋮n3: t
-        ⋮
-        ⋮crate::m::n3
-        ⋮Y: t v
-        ⋮
-        ⋮crate::n1
-        ⋮n2: t
-        ⋮
-        ⋮crate::n1::n2
-        ⋮X: t v
-    "###);
 }
 
 #[test]
 fn macro_rules_from_other_crates_are_visible() {
-    let map = def_map(
-        "
-        //- /main.rs crate:main deps:foo
-        foo::structs!(Foo, Bar)
-        mod bar;
-
-        //- /bar.rs
-        use crate::*;
-
-        //- /lib.rs crate:foo
-        #[macro_export]
-        macro_rules! structs {
-            ($($i:ident),*) => {
-                $(struct $i { field: u32 } )*
-            }
-        }
-        ",
+    check(
+        r#"
+//- /main.rs crate:main deps:foo
+foo::structs!(Foo, Bar)
+mod bar;
+
+//- /bar.rs
+use crate::*;
+
+//- /lib.rs crate:foo
+#[macro_export]
+macro_rules! structs {
+    ($($i:ident),*) => {
+        $(struct $i { field: u32 } )*
+    }
+}
+"#,
+        expect![[r#"
+            crate
+            Bar: t
+            Foo: t
+            bar: t
+
+            crate::bar
+            Bar: t
+            Foo: t
+            bar: t
+        "#]],
     );
-    assert_snapshot!(map, @r###"
-   ⋮crate
-   ⋮Bar: t
-   ⋮Foo: t
-   ⋮bar: t
-   ⋮
-   ⋮crate::bar
-   ⋮Bar: t
-   ⋮Foo: t
-   ⋮bar: t
-    "###);
 }
 
 #[test]
 fn macro_rules_export_with_local_inner_macros_are_visible() {
-    let map = def_map(
-        "
-        //- /main.rs crate:main deps:foo
-        foo::structs!(Foo, Bar)
-        mod bar;
-
-        //- /bar.rs
-        use crate::*;
-
-        //- /lib.rs crate:foo
-        #[macro_export(local_inner_macros)]
-        macro_rules! structs {
-            ($($i:ident),*) => {
-                $(struct $i { field: u32 } )*
-            }
-        }
-        ",
+    check(
+        r#"
+//- /main.rs crate:main deps:foo
+foo::structs!(Foo, Bar)
+mod bar;
+
+//- /bar.rs
+use crate::*;
+
+//- /lib.rs crate:foo
+#[macro_export(local_inner_macros)]
+macro_rules! structs {
+    ($($i:ident),*) => {
+        $(struct $i { field: u32 } )*
+    }
+}
+"#,
+        expect![[r#"
+            crate
+            Bar: t
+            Foo: t
+            bar: t
+
+            crate::bar
+            Bar: t
+            Foo: t
+            bar: t
+        "#]],
     );
-    assert_snapshot!(map, @r###"
-   ⋮crate
-   ⋮Bar: t
-   ⋮Foo: t
-   ⋮bar: t
-   ⋮
-   ⋮crate::bar
-   ⋮Bar: t
-   ⋮Foo: t
-   ⋮bar: t
-    "###);
 }
 
 #[test]
 fn local_inner_macros_makes_local_macros_usable() {
-    let map = def_map(
-        "
-        //- /main.rs crate:main deps:foo
-        foo::structs!(Foo, Bar);
-        mod bar;
-        //- /bar.rs
-        use crate::*;
-        //- /lib.rs crate:foo
-        #[macro_export(local_inner_macros)]
-        macro_rules! structs {
-            ($($i:ident),*) => {
-                inner!($($i),*);
-            }
-        }
-        #[macro_export]
-        macro_rules! inner {
-            ($($i:ident),*) => {
-                $(struct $i { field: u32 } )*
-            }
-        }
-        ",
+    check(
+        r#"
+//- /main.rs crate:main deps:foo
+foo::structs!(Foo, Bar);
+mod bar;
+
+//- /bar.rs
+use crate::*;
+
+//- /lib.rs crate:foo
+#[macro_export(local_inner_macros)]
+macro_rules! structs {
+    ($($i:ident),*) => {
+        inner!($($i),*);
+    }
+}
+#[macro_export]
+macro_rules! inner {
+    ($($i:ident),*) => {
+        $(struct $i { field: u32 } )*
+    }
+}
+"#,
+        expect![[r#"
+            crate
+            Bar: t
+            Foo: t
+            bar: t
+
+            crate::bar
+            Bar: t
+            Foo: t
+            bar: t
+        "#]],
     );
-    assert_snapshot!(map, @r###"
-   ⋮crate
-   ⋮Bar: t
-   ⋮Foo: t
-   ⋮bar: t
-   ⋮
-   ⋮crate::bar
-   ⋮Bar: t
-   ⋮Foo: t
-   ⋮bar: t
-    "###);
 }
 
 #[test]
 fn unexpanded_macro_should_expand_by_fixedpoint_loop() {
-    let map = def_map(
-        "
-        //- /main.rs crate:main deps:foo
-        macro_rules! baz {
-            () => {
-                use foo::bar;
-            }
-        }
-
-        foo!();
-        bar!();
-        baz!();
-
-        //- /lib.rs crate:foo
-        #[macro_export]
-        macro_rules! foo {
-            () => {
-                struct Foo { field: u32 }
-            }
-        }
-        #[macro_export]
-        macro_rules! bar {
-            () => {
-                use foo::foo;
-            }
-        }
-        ",
+    check(
+        r#"
+//- /main.rs crate:main deps:foo
+macro_rules! baz {
+    () => {
+        use foo::bar;
+    }
+}
+foo!();
+bar!();
+baz!();
+
+//- /lib.rs crate:foo
+#[macro_export]
+macro_rules! foo {
+    () => {
+        struct Foo { field: u32 }
+    }
+}
+#[macro_export]
+macro_rules! bar {
+    () => {
+        use foo::foo;
+    }
+}
+"#,
+        expect![[r#"
+            crate
+            Foo: t
+            bar: m
+            foo: m
+        "#]],
     );
-    assert_snapshot!(map, @r###"
-   ⋮crate
-   ⋮Foo: t
-   ⋮bar: m
-   ⋮foo: m
-    "###);
 }
 
 #[test]
 fn macro_rules_from_other_crates_are_visible_with_macro_use() {
     mark::check!(macro_rules_from_other_crates_are_visible_with_macro_use);
-    let map = def_map(
-        "
-        //- /main.rs crate:main deps:foo
-        structs!(Foo);
-        structs_priv!(Bar);
-        structs_not_exported!(MacroNotResolved1);
-        crate::structs!(MacroNotResolved2);
+    check(
+        r#"
+//- /main.rs crate:main deps:foo
+structs!(Foo);
+structs_priv!(Bar);
+structs_not_exported!(MacroNotResolved1);
+crate::structs!(MacroNotResolved2);
 
-        mod bar;
+mod bar;
 
-        #[macro_use]
-        extern crate foo;
+#[macro_use]
+extern crate foo;
 
-        //- /bar.rs
-        structs!(Baz);
-        crate::structs!(MacroNotResolved3);
+//- /bar.rs
+structs!(Baz);
+crate::structs!(MacroNotResolved3);
 
-        //- /lib.rs crate:foo
-        #[macro_export]
-        macro_rules! structs {
-            ($i:ident) => { struct $i; }
-        }
+//- /lib.rs crate:foo
+#[macro_export]
+macro_rules! structs {
+    ($i:ident) => { struct $i; }
+}
 
-        macro_rules! structs_not_exported {
-            ($i:ident) => { struct $i; }
-        }
+macro_rules! structs_not_exported {
+    ($i:ident) => { struct $i; }
+}
 
-        mod priv_mod {
-            #[macro_export]
-            macro_rules! structs_priv {
-                ($i:ident) => { struct $i; }
-            }
-        }
-        ",
+mod priv_mod {
+    #[macro_export]
+    macro_rules! structs_priv {
+        ($i:ident) => { struct $i; }
+    }
+}
+"#,
+        expect![[r#"
+            crate
+            Bar: t v
+            Foo: t v
+            bar: t
+            foo: t
+
+            crate::bar
+            Baz: t v
+        "#]],
     );
-    assert_snapshot!(map, @r###"
-   ⋮crate
-   ⋮Bar: t v
-   ⋮Foo: t v
-   ⋮bar: t
-   ⋮foo: t
-   ⋮
-   ⋮crate::bar
-   ⋮Baz: t v
-    "###);
 }
 
 #[test]
 fn prelude_is_macro_use() {
     mark::check!(prelude_is_macro_use);
-    let map = def_map(
-        "
-        //- /main.rs crate:main deps:foo
-        structs!(Foo);
-        structs_priv!(Bar);
-        structs_outside!(Out);
-        crate::structs!(MacroNotResolved2);
-
-        mod bar;
-
-        //- /bar.rs
-        structs!(Baz);
-        crate::structs!(MacroNotResolved3);
-
-        //- /lib.rs crate:foo
-        #[prelude_import]
-        use self::prelude::*;
-
-        mod prelude {
-            #[macro_export]
-            macro_rules! structs {
-                ($i:ident) => { struct $i; }
-            }
-
-            mod priv_mod {
-                #[macro_export]
-                macro_rules! structs_priv {
-                    ($i:ident) => { struct $i; }
-                }
-            }
-        }
+    check(
+        r#"
+//- /main.rs crate:main deps:foo
+structs!(Foo);
+structs_priv!(Bar);
+structs_outside!(Out);
+crate::structs!(MacroNotResolved2);
 
+mod bar;
+
+//- /bar.rs
+structs!(Baz);
+crate::structs!(MacroNotResolved3);
+
+//- /lib.rs crate:foo
+#[prelude_import]
+use self::prelude::*;
+
+mod prelude {
+    #[macro_export]
+    macro_rules! structs {
+        ($i:ident) => { struct $i; }
+    }
+
+    mod priv_mod {
         #[macro_export]
-        macro_rules! structs_outside {
+        macro_rules! structs_priv {
             ($i:ident) => { struct $i; }
         }
-        ",
+    }
+}
+
+#[macro_export]
+macro_rules! structs_outside {
+    ($i:ident) => { struct $i; }
+}
+"#,
+        expect![[r#"
+            crate
+            Bar: t v
+            Foo: t v
+            Out: t v
+            bar: t
+
+            crate::bar
+            Baz: t v
+        "#]],
     );
-    assert_snapshot!(map, @r###"
-   ⋮crate
-   ⋮Bar: t v
-   ⋮Foo: t v
-   ⋮Out: t v
-   ⋮bar: t
-   ⋮
-   ⋮crate::bar
-   ⋮Baz: t v
-    "###);
 }
 
 #[test]
 fn prelude_cycle() {
-    let map = def_map(
-        "
-        //- /lib.rs
-        #[prelude_import]
-        use self::prelude::*;
+    check(
+        r#"
+#[prelude_import]
+use self::prelude::*;
 
-        declare_mod!();
+declare_mod!();
 
-        mod prelude {
-            macro_rules! declare_mod {
-                () => (mod foo {})
-            }
-        }
-        ",
+mod prelude {
+    macro_rules! declare_mod {
+        () => (mod foo {})
+    }
+}
+"#,
+        expect![[r#"
+            crate
+            prelude: t
+
+            crate::prelude
+        "#]],
     );
-    assert_snapshot!(map, @r###"
-        ⋮crate
-        ⋮prelude: t
-        ⋮
-        ⋮crate::prelude
-    "###);
 }
 
 #[test]
 fn plain_macros_are_legacy_textual_scoped() {
-    let map = def_map(
+    check(
         r#"
-        //- /main.rs
-        mod m1;
-        bar!(NotFoundNotMacroUse);
+//- /main.rs
+mod m1;
+bar!(NotFoundNotMacroUse);
 
-        mod m2 {
-            foo!(NotFoundBeforeInside2);
-        }
+mod m2 { foo!(NotFoundBeforeInside2); }
 
-        macro_rules! foo {
-            ($x:ident) => { struct $x; }
-        }
-        foo!(Ok);
-
-        mod m3;
-        foo!(OkShadowStop);
-        bar!(NotFoundMacroUseStop);
-
-        #[macro_use]
-        mod m5 {
-            #[macro_use]
-            mod m6 {
-                macro_rules! foo {
-                    ($x:ident) => { fn $x() {} }
-                }
-            }
-        }
-        foo!(ok_double_macro_use_shadow);
-
-        baz!(NotFoundBefore);
-        #[macro_use]
-        mod m7 {
-            macro_rules! baz {
-                ($x:ident) => { struct $x; }
-            }
-        }
-        baz!(OkAfter);
+macro_rules! foo {
+    ($x:ident) => { struct $x; }
+}
+foo!(Ok);
 
-        //- /m1.rs
-        foo!(NotFoundBeforeInside1);
-        macro_rules! bar {
-            ($x:ident) => { struct $x; }
-        }
+mod m3;
+foo!(OkShadowStop);
+bar!(NotFoundMacroUseStop);
 
-        //- /m3/mod.rs
-        foo!(OkAfterInside);
+#[macro_use]
+mod m5 {
+    #[macro_use]
+    mod m6 {
         macro_rules! foo {
             ($x:ident) => { fn $x() {} }
         }
-        foo!(ok_shadow);
+    }
+}
+foo!(ok_double_macro_use_shadow);
+
+baz!(NotFoundBefore);
+#[macro_use]
+mod m7 {
+    macro_rules! baz {
+        ($x:ident) => { struct $x; }
+    }
+}
+baz!(OkAfter);
 
-        #[macro_use]
-        mod m4;
-        bar!(OkMacroUse);
+//- /m1.rs
+foo!(NotFoundBeforeInside1);
+macro_rules! bar {
+    ($x:ident) => { struct $x; }
+}
 
-        //- /m3/m4.rs
-        foo!(ok_shadow_deep);
-        macro_rules! bar {
-            ($x:ident) => { struct $x; }
-        }
-        "#,
+//- /m3/mod.rs
+foo!(OkAfterInside);
+macro_rules! foo {
+    ($x:ident) => { fn $x() {} }
+}
+foo!(ok_shadow);
+
+#[macro_use]
+mod m4;
+bar!(OkMacroUse);
+
+//- /m3/m4.rs
+foo!(ok_shadow_deep);
+macro_rules! bar {
+    ($x:ident) => { struct $x; }
+}
+"#,
+        expect![[r#"
+            crate
+            Ok: t v
+            OkAfter: t v
+            OkShadowStop: t v
+            m1: t
+            m2: t
+            m3: t
+            m5: t
+            m7: t
+            ok_double_macro_use_shadow: v
+
+            crate::m7
+
+            crate::m1
+
+            crate::m5
+            m6: t
+
+            crate::m5::m6
+
+            crate::m2
+
+            crate::m3
+            OkAfterInside: t v
+            OkMacroUse: t v
+            m4: t
+            ok_shadow: v
+
+            crate::m3::m4
+            ok_shadow_deep: v
+        "#]],
     );
-    assert_snapshot!(map, @r###"
-   ⋮crate
-   ⋮Ok: t v
-   ⋮OkAfter: t v
-   ⋮OkShadowStop: t v
-   ⋮m1: t
-   ⋮m2: t
-   ⋮m3: t
-   ⋮m5: t
-   ⋮m7: t
-   ⋮ok_double_macro_use_shadow: v
-   ⋮
-   ⋮crate::m7
-   ⋮
-   ⋮crate::m1
-   ⋮
-   ⋮crate::m5
-   ⋮m6: t
-   ⋮
-   ⋮crate::m5::m6
-   ⋮
-   ⋮crate::m2
-   ⋮
-   ⋮crate::m3
-   ⋮OkAfterInside: t v
-   ⋮OkMacroUse: t v
-   ⋮m4: t
-   ⋮ok_shadow: v
-   ⋮
-   ⋮crate::m3::m4
-   ⋮ok_shadow_deep: v
-    "###);
 }
 
 #[test]
 fn type_value_macro_live_in_different_scopes() {
-    let map = def_map(
-        "
-        //- /main.rs
-        #[macro_export]
-        macro_rules! foo {
-            ($x:ident) => { type $x = (); }
-        }
-
-        foo!(foo);
-        use foo as bar;
+    check(
+        r#"
+#[macro_export]
+macro_rules! foo {
+    ($x:ident) => { type $x = (); }
+}
 
-        use self::foo as baz;
-        fn baz() {}
-        ",
+foo!(foo);
+use foo as bar;
+
+use self::foo as baz;
+fn baz() {}
+"#,
+        expect![[r#"
+            crate
+            bar: t m
+            baz: t v m
+            foo: t m
+        "#]],
     );
-    assert_snapshot!(map, @r###"
-        ⋮crate
-        ⋮bar: t m
-        ⋮baz: t v m
-        ⋮foo: t m
-    "###);
 }
 
 #[test]
 fn macro_use_can_be_aliased() {
-    let map = def_map(
-        "
-        //- /main.rs crate:main deps:foo
-        #[macro_use]
-        extern crate foo;
+    check(
+        r#"
+//- /main.rs crate:main deps:foo
+#[macro_use]
+extern crate foo;
 
-        foo!(Direct);
-        bar!(Alias);
+foo!(Direct);
+bar!(Alias);
 
-        //- /lib.rs crate:foo
-        use crate::foo as bar;
+//- /lib.rs crate:foo
+use crate::foo as bar;
 
-        mod m {
-            #[macro_export]
-            macro_rules! foo {
-                ($x:ident) => { struct $x; }
-            }
-        }
-        ",
+mod m {
+    #[macro_export]
+    macro_rules! foo {
+        ($x:ident) => { struct $x; }
+    }
+}
+"#,
+        expect![[r#"
+            crate
+            Alias: t v
+            Direct: t v
+            foo: t
+        "#]],
     );
-    assert_snapshot!(map, @r###"
-        ⋮crate
-        ⋮Alias: t v
-        ⋮Direct: t v
-        ⋮foo: t
-    "###);
 }
 
 #[test]
 fn path_qualified_macros() {
-    let map = def_map(
-        "
-        //- /main.rs
-        macro_rules! foo {
-            ($x:ident) => { struct $x; }
-        }
+    check(
+        r#"
+macro_rules! foo {
+    ($x:ident) => { struct $x; }
+}
 
-        crate::foo!(NotResolved);
-
-        crate::bar!(OkCrate);
-        bar!(OkPlain);
-        alias1!(NotHere);
-        m::alias1!(OkAliasPlain);
-        m::alias2!(OkAliasSuper);
-        m::alias3!(OkAliasCrate);
-        not_found!(NotFound);
-
-        mod m {
-            #[macro_export]
-            macro_rules! bar {
-                ($x:ident) => { struct $x; }
-            }
-
-            pub use bar as alias1;
-            pub use super::bar as alias2;
-            pub use crate::bar as alias3;
-            pub use self::bar as not_found;
-        }
-        ",
+crate::foo!(NotResolved);
+
+crate::bar!(OkCrate);
+bar!(OkPlain);
+alias1!(NotHere);
+m::alias1!(OkAliasPlain);
+m::alias2!(OkAliasSuper);
+m::alias3!(OkAliasCrate);
+not_found!(NotFound);
+
+mod m {
+    #[macro_export]
+    macro_rules! bar {
+        ($x:ident) => { struct $x; }
+    }
+    pub use bar as alias1;
+    pub use super::bar as alias2;
+    pub use crate::bar as alias3;
+    pub use self::bar as not_found;
+}
+"#,
+        expect![[r#"
+            crate
+            OkAliasCrate: t v
+            OkAliasPlain: t v
+            OkAliasSuper: t v
+            OkCrate: t v
+            OkPlain: t v
+            bar: m
+            m: t
+
+            crate::m
+            alias1: m
+            alias2: m
+            alias3: m
+            not_found: _
+        "#]],
     );
-    assert_snapshot!(map, @r###"
-        ⋮crate
-        ⋮OkAliasCrate: t v
-        ⋮OkAliasPlain: t v
-        ⋮OkAliasSuper: t v
-        ⋮OkCrate: t v
-        ⋮OkPlain: t v
-        ⋮bar: m
-        ⋮m: t
-        ⋮
-        ⋮crate::m
-        ⋮alias1: m
-        ⋮alias2: m
-        ⋮alias3: m
-        ⋮not_found: _
-    "###);
 }
 
 #[test]
 fn macro_dollar_crate_is_correct_in_item() {
     mark::check!(macro_dollar_crate_self);
-    let map = def_map(
-        "
-        //- /main.rs crate:main deps:foo
-        #[macro_use]
-        extern crate foo;
-
-        #[macro_use]
-        mod m {
-            macro_rules! current {
-                () => {
-                    use $crate::Foo as FooSelf;
-                }
-            }
+    check(
+        r#"
+//- /main.rs crate:main deps:foo
+#[macro_use]
+extern crate foo;
+
+#[macro_use]
+mod m {
+    macro_rules! current {
+        () => {
+            use $crate::Foo as FooSelf;
         }
+    }
+}
 
-        struct Foo;
+struct Foo;
 
-        current!();
-        not_current1!();
-        foo::not_current2!();
-
-        //- /lib.rs crate:foo
-        mod m {
-            #[macro_export]
-            macro_rules! not_current1 {
-                () => {
-                    use $crate::Bar;
-                }
-            }
-        }
+current!();
+not_current1!();
+foo::not_current2!();
 
-        #[macro_export]
-        macro_rules! not_current2 {
-            () => {
-                use $crate::Baz;
-            }
+//- /lib.rs crate:foo
+mod m {
+    #[macro_export]
+    macro_rules! not_current1 {
+        () => {
+            use $crate::Bar;
         }
+    }
+}
 
-        struct Bar;
-        struct Baz;
-        ",
+#[macro_export]
+macro_rules! not_current2 {
+    () => {
+        use $crate::Baz;
+    }
+}
+
+struct Bar;
+struct Baz;
+"#,
+        expect![[r#"
+            crate
+            Bar: t v
+            Baz: t v
+            Foo: t v
+            FooSelf: t v
+            foo: t
+            m: t
+
+            crate::m
+        "#]],
     );
-    assert_snapshot!(map, @r###"
-        ⋮crate
-        ⋮Bar: t v
-        ⋮Baz: t v
-        ⋮Foo: t v
-        ⋮FooSelf: t v
-        ⋮foo: t
-        ⋮m: t
-        ⋮
-        ⋮crate::m
-    "###);
 }
 
 #[test]
 fn macro_dollar_crate_is_correct_in_indirect_deps() {
     mark::check!(macro_dollar_crate_other);
     // From std
-    let map = def_map(
+    check(
         r#"
-        //- /main.rs crate:main deps:std
-        foo!();
+//- /main.rs crate:main deps:std
+foo!();
 
-        //- /std.rs crate:std deps:core
-        #[prelude_import]
-        use self::prelude::*;
+//- /std.rs crate:std deps:core
+#[prelude_import]
+use self::prelude::*;
 
-        pub use core::foo;
+pub use core::foo;
 
-        mod prelude {}
+mod prelude {}
 
-        #[macro_use]
-        mod std_macros;
+#[macro_use]
+mod std_macros;
 
-        //- /core.rs crate:core
-        #[macro_export]
-        macro_rules! foo {
-            () => {
-                use $crate::bar;
-            }
-        }
-
-        pub struct bar;
-        "#,
-    );
-    assert_snapshot!(map, @r###"
-        ⋮crate
-        ⋮bar: t v
-    "###);
+//- /core.rs crate:core
+#[macro_export]
+macro_rules! foo {
+    () => {
+        use $crate::bar;
+    }
 }
 
-#[test]
-fn expand_derive() {
-    let map = compute_crate_def_map(
-        "
-        //- /main.rs
-        #[derive(Clone)]
-        struct Foo;
-        ",
+pub struct bar;
+"#,
+        expect![[r#"
+            crate
+            bar: t v
+        "#]],
     );
-    assert_eq!(map.modules[map.root].scope.impls().len(), 1);
 }
 
 #[test]
-fn expand_multiple_derive() {
+fn expand_derive() {
     let map = compute_crate_def_map(
         "
         //- /main.rs
@@ -664,8 +644,8 @@ fn expand_multiple_derive() {
 #[test]
 fn macro_expansion_overflow() {
     mark::check!(macro_expansion_overflow);
-    compute_crate_def_map(
-        "
+    check(
+        r#"
 macro_rules! a {
     ($e:expr; $($t:tt)*) => {
         b!($($t)*);
@@ -681,6 +661,9 @@ macro_rules! b {
 }
 
 b! { static = #[] (); }
-",
+"#,
+        expect![[r#"
+            crate
+        "#]],
     );
 }
diff --git a/crates/ra_hir_def/src/nameres/tests/mod_resolution.rs b/crates/ra_hir_def/src/nameres/tests/mod_resolution.rs
index 7536842011..3da16fbe30 100644
--- a/crates/ra_hir_def/src/nameres/tests/mod_resolution.rs
+++ b/crates/ra_hir_def/src/nameres/tests/mod_resolution.rs
@@ -3,710 +3,672 @@ use super::*;
 #[test]
 fn name_res_works_for_broken_modules() {
     mark::check!(name_res_works_for_broken_modules);
-    let map = def_map(
+    check(
         r"
-        //- /lib.rs
-        mod foo // no `;`, no body
-
-        use self::foo::Baz;
-
-        //- /foo/mod.rs
-        pub mod bar;
-
-        pub use self::bar::Baz;
-
-        //- /foo/bar.rs
-        pub struct Baz;
-        ",
+//- /lib.rs
+mod foo // no `;`, no body
+use self::foo::Baz;
+
+//- /foo/mod.rs
+pub mod bar;
+pub use self::bar::Baz;
+
+//- /foo/bar.rs
+pub struct Baz;
+",
+        expect![[r#"
+            crate
+            Baz: _
+            foo: t
+
+            crate::foo
+        "#]],
     );
-    assert_snapshot!(map, @r###"
-crate
-Baz: _
-foo: t
-
-crate::foo
-    "###);
 }
 
 #[test]
 fn nested_module_resolution() {
-    let map = def_map(
-        r"
-        //- /lib.rs
-        mod n1;
-
-        //- /n1.rs
-        mod n2;
-
-        //- /n1/n2.rs
-        struct X;
-        ",
+    check(
+        r#"
+//- /lib.rs
+mod n1;
+
+//- /n1.rs
+mod n2;
+
+//- /n1/n2.rs
+struct X;
+"#,
+        expect![[r#"
+            crate
+            n1: t
+
+            crate::n1
+            n2: t
+
+            crate::n1::n2
+            X: t v
+        "#]],
     );
-
-    assert_snapshot!(map, @r###"
-        ⋮crate
-        ⋮n1: t
-        ⋮
-        ⋮crate::n1
-        ⋮n2: t
-        ⋮
-        ⋮crate::n1::n2
-        ⋮X: t v
-    "###);
 }
 
 #[test]
 fn nested_module_resolution_2() {
-    let map = def_map(
-        r"
-        //- /lib.rs
-        mod prelude;
-        mod iter;
-
-        //- /prelude.rs
-        pub use crate::iter::Iterator;
-
-        //- /iter.rs
-        pub use self::traits::Iterator;
-        mod traits;
-
-        //- /iter/traits.rs
-        pub use self::iterator::Iterator;
-        mod iterator;
-
-        //- /iter/traits/iterator.rs
-        pub trait Iterator;
-        ",
+    check(
+        r#"
+//- /lib.rs
+mod prelude;
+mod iter;
+
+//- /prelude.rs
+pub use crate::iter::Iterator;
+
+//- /iter.rs
+pub use self::traits::Iterator;
+mod traits;
+
+//- /iter/traits.rs
+pub use self::iterator::Iterator;
+mod iterator;
+
+//- /iter/traits/iterator.rs
+pub trait Iterator;
+"#,
+        expect![[r#"
+            crate
+            iter: t
+            prelude: t
+
+            crate::iter
+            Iterator: t
+            traits: t
+
+            crate::iter::traits
+            Iterator: t
+            iterator: t
+
+            crate::iter::traits::iterator
+            Iterator: t
+
+            crate::prelude
+            Iterator: t
+        "#]],
     );
-
-    assert_snapshot!(map, @r###"
-        ⋮crate
-        ⋮iter: t
-        ⋮prelude: t
-        ⋮
-        ⋮crate::iter
-        ⋮Iterator: t
-        ⋮traits: t
-        ⋮
-        ⋮crate::iter::traits
-        ⋮Iterator: t
-        ⋮iterator: t
-        ⋮
-        ⋮crate::iter::traits::iterator
-        ⋮Iterator: t
-        ⋮
-        ⋮crate::prelude
-        ⋮Iterator: t
-    "###);
 }
 
 #[test]
 fn module_resolution_works_for_non_standard_filenames() {
-    let map = def_map(
-        "
-        //- /my_library.rs crate:my_library
-        mod foo;
-        use self::foo::Bar;
-
-        //- /foo/mod.rs
-        pub struct Bar;
-        ",
+    check(
+        r#"
+//- /my_library.rs crate:my_library
+mod foo;
+use self::foo::Bar;
+
+//- /foo/mod.rs
+pub struct Bar;
+"#,
+        expect![[r#"
+            crate
+            Bar: t v
+            foo: t
+
+            crate::foo
+            Bar: t v
+        "#]],
     );
-
-    assert_snapshot!(map, @r###"
-        ⋮crate
-        ⋮Bar: t v
-        ⋮foo: t
-        ⋮
-        ⋮crate::foo
-        ⋮Bar: t v
-    "###);
 }
 
 #[test]
 fn module_resolution_works_for_raw_modules() {
-    let map = def_map(
-        "
-        //- /lib.rs
-        mod r#async;
-        use self::r#async::Bar;
-
-        //- /async.rs
-        pub struct Bar;
-        ",
+    check(
+        r#"
+//- /lib.rs
+mod r#async;
+use self::r#async::Bar;
+
+//- /async.rs
+pub struct Bar;
+"#,
+        expect![[r#"
+            crate
+            Bar: t v
+            async: t
+
+            crate::async
+            Bar: t v
+        "#]],
     );
-
-    assert_snapshot!(map, @r###"
-        ⋮crate
-        ⋮Bar: t v
-        ⋮async: t
-        ⋮
-        ⋮crate::async
-        ⋮Bar: t v
-    "###);
 }
 
 #[test]
 fn module_resolution_decl_path() {
-    let map = def_map(
-        r###"
-        //- /lib.rs
-        #[path = "bar/baz/foo.rs"]
-        mod foo;
-        use self::foo::Bar;
-
-        //- /bar/baz/foo.rs
-        pub struct Bar;
-        "###,
+    check(
+        r#"
+//- /lib.rs
+#[path = "bar/baz/foo.rs"]
+mod foo;
+use self::foo::Bar;
+
+//- /bar/baz/foo.rs
+pub struct Bar;
+"#,
+        expect![[r#"
+            crate
+            Bar: t v
+            foo: t
+
+            crate::foo
+            Bar: t v
+        "#]],
     );
-
-    assert_snapshot!(map, @r###"
-        ⋮crate
-        ⋮Bar: t v
-        ⋮foo: t
-        ⋮
-        ⋮crate::foo
-        ⋮Bar: t v
-    "###);
 }
 
 #[test]
 fn module_resolution_module_with_path_in_mod_rs() {
-    let map = def_map(
-        r###"
-        //- /main.rs
-        mod foo;
-
-        //- /foo/mod.rs
-        #[path = "baz.rs"]
-        pub mod bar;
-
-        use self::bar::Baz;
-
-        //- /foo/baz.rs
-        pub struct Baz;
-        "###,
+    check(
+        r#"
+//- /main.rs
+mod foo;
+
+//- /foo/mod.rs
+#[path = "baz.rs"]
+pub mod bar;
+use self::bar::Baz;
+
+//- /foo/baz.rs
+pub struct Baz;
+"#,
+        expect![[r#"
+            crate
+            foo: t
+
+            crate::foo
+            Baz: t v
+            bar: t
+
+            crate::foo::bar
+            Baz: t v
+        "#]],
     );
-
-    assert_snapshot!(map, @r###"
-        ⋮crate
-        ⋮foo: t
-        ⋮
-        ⋮crate::foo
-        ⋮Baz: t v
-        ⋮bar: t
-        ⋮
-        ⋮crate::foo::bar
-        ⋮Baz: t v
-    "###);
 }
 
 #[test]
 fn module_resolution_module_with_path_non_crate_root() {
-    let map = def_map(
-        r###"
-        //- /main.rs
-        mod foo;
-
-        //- /foo.rs
-        #[path = "baz.rs"]
-        pub mod bar;
-
-        use self::bar::Baz;
-
-        //- /baz.rs
-        pub struct Baz;
-        "###,
+    check(
+        r#"
+//- /main.rs
+mod foo;
+
+//- /foo.rs
+#[path = "baz.rs"]
+pub mod bar;
+use self::bar::Baz;
+
+//- /baz.rs
+pub struct Baz;
+"#,
+        expect![[r#"
+            crate
+            foo: t
+
+            crate::foo
+            Baz: t v
+            bar: t
+
+            crate::foo::bar
+            Baz: t v
+        "#]],
     );
-
-    assert_snapshot!(map, @r###"
-        ⋮crate
-        ⋮foo: t
-        ⋮
-        ⋮crate::foo
-        ⋮Baz: t v
-        ⋮bar: t
-        ⋮
-        ⋮crate::foo::bar
-        ⋮Baz: t v
-    "###);
 }
 
 #[test]
 fn module_resolution_module_decl_path_super() {
-    let map = def_map(
-        r###"
-        //- /main.rs
-        #[path = "bar/baz/module.rs"]
-        mod foo;
-        pub struct Baz;
-
-        //- /bar/baz/module.rs
-        use super::Baz;
-        "###,
+    check(
+        r#"
+//- /main.rs
+#[path = "bar/baz/module.rs"]
+mod foo;
+pub struct Baz;
+
+//- /bar/baz/module.rs
+use super::Baz;
+"#,
+        expect![[r#"
+            crate
+            Baz: t v
+            foo: t
+
+            crate::foo
+            Baz: t v
+        "#]],
     );
-
-    assert_snapshot!(map, @r###"
-        ⋮crate
-        ⋮Baz: t v
-        ⋮foo: t
-        ⋮
-        ⋮crate::foo
-        ⋮Baz: t v
-    "###);
 }
 
 #[test]
 fn module_resolution_explicit_path_mod_rs() {
-    let map = def_map(
-        r###"
-        //- /main.rs
-        #[path = "module/mod.rs"]
-        mod foo;
-
-        //- /module/mod.rs
-        pub struct Baz;
-        "###,
+    check(
+        r#"
+//- /main.rs
+#[path = "module/mod.rs"]
+mod foo;
+
+//- /module/mod.rs
+pub struct Baz;
+"#,
+        expect![[r#"
+            crate
+            foo: t
+
+            crate::foo
+            Baz: t v
+        "#]],
     );
-
-    assert_snapshot!(map, @r###"
-        ⋮crate
-        ⋮foo: t
-        ⋮
-        ⋮crate::foo
-        ⋮Baz: t v
-    "###);
 }
 
 #[test]
 fn module_resolution_relative_path() {
-    let map = def_map(
-        r###"
-        //- /main.rs
-        mod foo;
-
-        //- /foo.rs
-        #[path = "./sub.rs"]
-        pub mod foo_bar;
-
-        //- /sub.rs
-        pub struct Baz;
-        "###,
+    check(
+        r#"
+//- /main.rs
+mod foo;
+
+//- /foo.rs
+#[path = "./sub.rs"]
+pub mod foo_bar;
+
+//- /sub.rs
+pub struct Baz;
+"#,
+        expect![[r#"
+            crate
+            foo: t
+
+            crate::foo
+            foo_bar: t
+
+            crate::foo::foo_bar
+            Baz: t v
+        "#]],
     );
-
-    assert_snapshot!(map, @r###"
-        ⋮crate
-        ⋮foo: t
-        ⋮
-        ⋮crate::foo
-        ⋮foo_bar: t
-        ⋮
-        ⋮crate::foo::foo_bar
-        ⋮Baz: t v
-    "###);
 }
 
 #[test]
 fn module_resolution_relative_path_2() {
-    let map = def_map(
-        r###"
-        //- /main.rs
-        mod foo;
-
-        //- /foo/mod.rs
-        #[path="../sub.rs"]
-        pub mod foo_bar;
-
-        //- /sub.rs
-        pub struct Baz;
-        "###,
+    check(
+        r#"
+//- /main.rs
+mod foo;
+
+//- /foo/mod.rs
+#[path="../sub.rs"]
+pub mod foo_bar;
+
+//- /sub.rs
+pub struct Baz;
+"#,
+        expect![[r#"
+            crate
+            foo: t
+
+            crate::foo
+            foo_bar: t
+
+            crate::foo::foo_bar
+            Baz: t v
+        "#]],
     );
-
-    assert_snapshot!(map, @r###"
-        ⋮crate
-        ⋮foo: t
-        ⋮
-        ⋮crate::foo
-        ⋮foo_bar: t
-        ⋮
-        ⋮crate::foo::foo_bar
-        ⋮Baz: t v
-    "###);
 }
 
 #[test]
 fn module_resolution_relative_path_outside_root() {
-    let map = def_map(
-        r###"
-        //- /main.rs
-
-        #[path="../../../../../outside.rs"]
-        mod foo;
-        "###,
+    check(
+        r#"
+//- /main.rs
+#[path="../../../../../outside.rs"]
+mod foo;
+"#,
+        expect![[r#"
+            crate
+        "#]],
     );
-
-    assert_snapshot!(map, @r###"
-        ⋮crate
-    "###);
 }
 
 #[test]
 fn module_resolution_explicit_path_mod_rs_2() {
-    let map = def_map(
-        r###"
-        //- /main.rs
-        #[path = "module/bar/mod.rs"]
-        mod foo;
-
-        //- /module/bar/mod.rs
-        pub struct Baz;
-        "###,
+    check(
+        r#"
+//- /main.rs
+#[path = "module/bar/mod.rs"]
+mod foo;
+
+//- /module/bar/mod.rs
+pub struct Baz;
+"#,
+        expect![[r#"
+            crate
+            foo: t
+
+            crate::foo
+            Baz: t v
+        "#]],
     );
-
-    assert_snapshot!(map, @r###"
-        ⋮crate
-        ⋮foo: t
-        ⋮
-        ⋮crate::foo
-        ⋮Baz: t v
-    "###);
 }
 
 #[test]
 fn module_resolution_explicit_path_mod_rs_with_win_separator() {
-    let map = def_map(
-        r###"
-        //- /main.rs
-        #[path = "module\bar\mod.rs"]
-        mod foo;
-
-        //- /module/bar/mod.rs
-        pub struct Baz;
-        "###,
+    check(
+        r#"
+//- /main.rs
+#[path = "module\bar\mod.rs"]
+mod foo;
+
+//- /module/bar/mod.rs
+pub struct Baz;
+"#,
+        expect![[r#"
+            crate
+            foo: t
+
+            crate::foo
+            Baz: t v
+        "#]],
     );
-
-    assert_snapshot!(map, @r###"
-        ⋮crate
-        ⋮foo: t
-        ⋮
-        ⋮crate::foo
-        ⋮Baz: t v
-    "###);
 }
 
 #[test]
 fn module_resolution_decl_inside_inline_module_with_path_attribute() {
-    let map = def_map(
-        r###"
-        //- /main.rs
-        #[path = "models"]
-        mod foo {
-            mod bar;
-        }
-
-        //- /models/bar.rs
-        pub struct Baz;
-        "###,
+    check(
+        r#"
+//- /main.rs
+#[path = "models"]
+mod foo { mod bar; }
+
+//- /models/bar.rs
+pub struct Baz;
+"#,
+        expect![[r#"
+            crate
+            foo: t
+
+            crate::foo
+            bar: t
+
+            crate::foo::bar
+            Baz: t v
+        "#]],
     );
-
-    assert_snapshot!(map, @r###"
-        ⋮crate
-        ⋮foo: t
-        ⋮
-        ⋮crate::foo
-        ⋮bar: t
-        ⋮
-        ⋮crate::foo::bar
-        ⋮Baz: t v
-    "###);
 }
 
 #[test]
 fn module_resolution_decl_inside_inline_module() {
-    let map = def_map(
-        r###"
-        //- /main.rs
-        mod foo {
-            mod bar;
-        }
-
-        //- /foo/bar.rs
-        pub struct Baz;
-        "###,
+    check(
+        r#"
+//- /main.rs
+mod foo { mod bar; }
+
+//- /foo/bar.rs
+pub struct Baz;
+"#,
+        expect![[r#"
+            crate
+            foo: t
+
+            crate::foo
+            bar: t
+
+            crate::foo::bar
+            Baz: t v
+        "#]],
     );
-
-    assert_snapshot!(map, @r###"
-        ⋮crate
-        ⋮foo: t
-        ⋮
-        ⋮crate::foo
-        ⋮bar: t
-        ⋮
-        ⋮crate::foo::bar
-        ⋮Baz: t v
-    "###);
 }
 
 #[test]
 fn module_resolution_decl_inside_inline_module_2_with_path_attribute() {
-    let map = def_map(
-        r###"
-        //- /main.rs
-        #[path = "models/db"]
-        mod foo {
-            mod bar;
-        }
-
-        //- /models/db/bar.rs
-        pub struct Baz;
-        "###,
+    check(
+        r#"
+//- /main.rs
+#[path = "models/db"]
+mod foo { mod bar; }
+
+//- /models/db/bar.rs
+pub struct Baz;
+"#,
+        expect![[r#"
+            crate
+            foo: t
+
+            crate::foo
+            bar: t
+
+            crate::foo::bar
+            Baz: t v
+        "#]],
     );
-
-    assert_snapshot!(map, @r###"
-        ⋮crate
-        ⋮foo: t
-        ⋮
-        ⋮crate::foo
-        ⋮bar: t
-        ⋮
-        ⋮crate::foo::bar
-        ⋮Baz: t v
-    "###);
 }
 
 #[test]
 fn module_resolution_decl_inside_inline_module_3() {
-    let map = def_map(
-        r###"
-        //- /main.rs
-        #[path = "models/db"]
-        mod foo {
-            #[path = "users.rs"]
-            mod bar;
-        }
-
-        //- /models/db/users.rs
-        pub struct Baz;
-        "###,
-    );
+    check(
+        r#"
+//- /main.rs
+#[path = "models/db"]
+mod foo {
+    #[path = "users.rs"]
+    mod bar;
+}
 
-    assert_snapshot!(map, @r###"
-        ⋮crate
-        ⋮foo: t
-        ⋮
-        ⋮crate::foo
-        ⋮bar: t
-        ⋮
-        ⋮crate::foo::bar
-        ⋮Baz: t v
-    "###);
+//- /models/db/users.rs
+pub struct Baz;
+"#,
+        expect![[r#"
+            crate
+            foo: t
+
+            crate::foo
+            bar: t
+
+            crate::foo::bar
+            Baz: t v
+        "#]],
+    );
 }
 
 #[test]
 fn module_resolution_decl_inside_inline_module_empty_path() {
-    let map = def_map(
-        r###"
-        //- /main.rs
-        #[path = ""]
-        mod foo {
-            #[path = "users.rs"]
-            mod bar;
-        }
-
-        //- /users.rs
-        pub struct Baz;
-        "###,
-    );
+    check(
+        r#"
+//- /main.rs
+#[path = ""]
+mod foo {
+    #[path = "users.rs"]
+    mod bar;
+}
+
+//- /users.rs
+pub struct Baz;
+"#,
+        expect![[r#"
+            crate
+            foo: t
 
-    assert_snapshot!(map, @r###"
-        ⋮crate
-        ⋮foo: t
-        ⋮
-        ⋮crate::foo
-        ⋮bar: t
-        ⋮
-        ⋮crate::foo::bar
-        ⋮Baz: t v
-    "###);
+            crate::foo
+            bar: t
+
+            crate::foo::bar
+            Baz: t v
+        "#]],
+    );
 }
 
 #[test]
 fn module_resolution_decl_empty_path() {
-    let map = def_map(
-        r###"
-        //- /main.rs
-        #[path = ""] // Should try to read `/` (a directory)
-        mod foo;
-
-        //- /foo.rs
-        pub struct Baz;
-        "###,
+    check(
+        r#"
+//- /main.rs
+#[path = ""] // Should try to read `/` (a directory)
+mod foo;
+
+//- /foo.rs
+pub struct Baz;
+"#,
+        expect![[r#"
+            crate
+        "#]],
     );
-
-    assert_snapshot!(map, @r###"
-        ⋮crate
-    "###);
 }
 
 #[test]
 fn module_resolution_decl_inside_inline_module_relative_path() {
-    let map = def_map(
-        r###"
-        //- /main.rs
-        #[path = "./models"]
-        mod foo {
-            mod bar;
-        }
-
-        //- /models/bar.rs
-        pub struct Baz;
-        "###,
+    check(
+        r#"
+//- /main.rs
+#[path = "./models"]
+mod foo { mod bar; }
+
+//- /models/bar.rs
+pub struct Baz;
+"#,
+        expect![[r#"
+            crate
+            foo: t
+
+            crate::foo
+            bar: t
+
+            crate::foo::bar
+            Baz: t v
+        "#]],
     );
-
-    assert_snapshot!(map, @r###"
-        ⋮crate
-        ⋮foo: t
-        ⋮
-        ⋮crate::foo
-        ⋮bar: t
-        ⋮
-        ⋮crate::foo::bar
-        ⋮Baz: t v
-    "###);
 }
 
 #[test]
 fn module_resolution_decl_inside_inline_module_in_crate_root() {
-    let map = def_map(
-        r###"
-        //- /main.rs
-        mod foo {
-            #[path = "baz.rs"]
-            mod bar;
-        }
-        use self::foo::bar::Baz;
-
-        //- /foo/baz.rs
-        pub struct Baz;
-        "###,
+    check(
+        r#"
+//- /main.rs
+mod foo {
+    #[path = "baz.rs"]
+    mod bar;
+}
+use self::foo::bar::Baz;
+
+//- /foo/baz.rs
+pub struct Baz;
+"#,
+        expect![[r#"
+            crate
+            Baz: t v
+            foo: t
+
+            crate::foo
+            bar: t
+
+            crate::foo::bar
+            Baz: t v
+        "#]],
     );
-
-    assert_snapshot!(map, @r###"
-        ⋮crate
-        ⋮Baz: t v
-        ⋮foo: t
-        ⋮
-        ⋮crate::foo
-        ⋮bar: t
-        ⋮
-        ⋮crate::foo::bar
-        ⋮Baz: t v
-    "###);
 }
 
 #[test]
 fn module_resolution_decl_inside_inline_module_in_mod_rs() {
-    let map = def_map(
-        r###"
-        //- /main.rs
-        mod foo;
+    check(
+        r#"
+//- /main.rs
+mod foo;
+
+//- /foo/mod.rs
+mod bar {
+    #[path = "qwe.rs"]
+    pub mod baz;
+}
+use self::bar::baz::Baz;
 
-        //- /foo/mod.rs
-        mod bar {
-            #[path = "qwe.rs"]
-            pub mod baz;
-        }
-        use self::bar::baz::Baz;
+//- /foo/bar/qwe.rs
+pub struct Baz;
+"#,
+        expect![[r#"
+            crate
+            foo: t
 
-        //- /foo/bar/qwe.rs
-        pub struct Baz;
-        "###,
-    );
+            crate::foo
+            Baz: t v
+            bar: t
+
+            crate::foo::bar
+            baz: t
 
-    assert_snapshot!(map, @r###"
-        ⋮crate
-        ⋮foo: t
-        ⋮
-        ⋮crate::foo
-        ⋮Baz: t v
-        ⋮bar: t
-        ⋮
-        ⋮crate::foo::bar
-        ⋮baz: t
-        ⋮
-        ⋮crate::foo::bar::baz
-        ⋮Baz: t v
-    "###);
+            crate::foo::bar::baz
+            Baz: t v
+        "#]],
+    );
 }
 
 #[test]
 fn module_resolution_decl_inside_inline_module_in_non_crate_root() {
-    let map = def_map(
-        r###"
-        //- /main.rs
-        mod foo;
+    check(
+        r#"
+//- /main.rs
+mod foo;
+
+//- /foo.rs
+mod bar {
+    #[path = "qwe.rs"]
+    pub mod baz;
+}
+use self::bar::baz::Baz;
 
-        //- /foo.rs
-        mod bar {
-            #[path = "qwe.rs"]
-            pub mod baz;
-        }
-        use self::bar::baz::Baz;
-
-        //- /foo/bar/qwe.rs
-        pub struct Baz;
-        "###,
-    );
+//- /foo/bar/qwe.rs
+pub struct Baz;
+"#,
+        expect![[r#"
+            crate
+            foo: t
+
+            crate::foo
+            Baz: t v
+            bar: t
 
-    assert_snapshot!(map, @r###"
-        ⋮crate
-        ⋮foo: t
-        ⋮
-        ⋮crate::foo
-        ⋮Baz: t v
-        ⋮bar: t
-        ⋮
-        ⋮crate::foo::bar
-        ⋮baz: t
-        ⋮
-        ⋮crate::foo::bar::baz
-        ⋮Baz: t v
-    "###);
+            crate::foo::bar
+            baz: t
+
+            crate::foo::bar::baz
+            Baz: t v
+        "#]],
+    );
 }
 
 #[test]
 fn module_resolution_decl_inside_inline_module_in_non_crate_root_2() {
-    let map = def_map(
-        r###"
-        //- /main.rs
-        mod foo;
+    check(
+        r#"
+//- /main.rs
+mod foo;
+
+//- /foo.rs
+#[path = "bar"]
+mod bar {
+    pub mod baz;
+}
+use self::bar::baz::Baz;
 
-        //- /foo.rs
-        #[path = "bar"]
-        mod bar {
-            pub mod baz;
-        }
-        use self::bar::baz::Baz;
-
-        //- /bar/baz.rs
-        pub struct Baz;
-        "###,
-    );
+//- /bar/baz.rs
+pub struct Baz;
+"#,
+        expect![[r#"
+            crate
+            foo: t
 
-    assert_snapshot!(map, @r###"
-        ⋮crate
-        ⋮foo: t
-        ⋮
-        ⋮crate::foo
-        ⋮Baz: t v
-        ⋮bar: t
-        ⋮
-        ⋮crate::foo::bar
-        ⋮baz: t
-        ⋮
-        ⋮crate::foo::bar::baz
-        ⋮Baz: t v
-    "###);
+            crate::foo
+            Baz: t v
+            bar: t
+
+            crate::foo::bar
+            baz: t
+
+            crate::foo::bar::baz
+            Baz: t v
+        "#]],
+    );
 }
 
 #[test]
@@ -749,91 +711,88 @@ fn unresolved_module_diagnostics() {
 
 #[test]
 fn module_resolution_decl_inside_module_in_non_crate_root_2() {
-    let map = def_map(
-        r###"
-        //- /main.rs
-        #[path="module/m2.rs"]
-        mod module;
-
-        //- /module/m2.rs
-        pub mod submod;
-
-        //- /module/submod.rs
-        pub struct Baz;
-        "###,
+    check(
+        r#"
+//- /main.rs
+#[path="module/m2.rs"]
+mod module;
+
+//- /module/m2.rs
+pub mod submod;
+
+//- /module/submod.rs
+pub struct Baz;
+"#,
+        expect![[r#"
+            crate
+            module: t
+
+            crate::module
+            submod: t
+
+            crate::module::submod
+            Baz: t v
+        "#]],
     );
-
-    assert_snapshot!(map, @r###"
-        ⋮crate
-        ⋮module: t
-        ⋮
-        ⋮crate::module
-        ⋮submod: t
-        ⋮
-        ⋮crate::module::submod
-        ⋮Baz: t v
-    "###);
 }
 
 #[test]
 fn nested_out_of_line_module() {
-    let map = def_map(
-        r###"
-        //- /lib.rs
-        mod a {
-            mod b {
-                mod c;
-            }
-        }
-
-        //- /a/b/c.rs
-        struct X;
-        "###,
-    );
+    check(
+        r#"
+//- /lib.rs
+mod a {
+    mod b {
+        mod c;
+    }
+}
 
-    assert_snapshot!(map, @r###"
-        ⋮crate
-        ⋮a: t
-        ⋮
-        ⋮crate::a
-        ⋮b: t
-        ⋮
-        ⋮crate::a::b
-        ⋮c: t
-        ⋮
-        ⋮crate::a::b::c
-        ⋮X: t v
-    "###);
+//- /a/b/c.rs
+struct X;
+"#,
+        expect![[r#"
+            crate
+            a: t
+
+            crate::a
+            b: t
+
+            crate::a::b
+            c: t
+
+            crate::a::b::c
+            X: t v
+        "#]],
+    );
 }
 
 #[test]
 fn nested_out_of_line_module_with_path() {
-    let map = def_map(
-        r###"
-        //- /lib.rs
-        mod a {
-            #[path = "d/e"]
-            mod b {
-                mod c;
-            }
-        }
-
-        //- /a/d/e/c.rs
-        struct X;
-        "###,
-    );
+    check(
+        r#"
+//- /lib.rs
+mod a {
+    #[path = "d/e"]
+    mod b {
+        mod c;
+    }
+}
+
+//- /a/d/e/c.rs
+struct X;
+"#,
+        expect![[r#"
+            crate
+            a: t
 
-    assert_snapshot!(map, @r###"
-        ⋮crate
-        ⋮a: t
-        ⋮
-        ⋮crate::a
-        ⋮b: t
-        ⋮
-        ⋮crate::a::b
-        ⋮c: t
-        ⋮
-        ⋮crate::a::b::c
-        ⋮X: t v
-    "###);
+            crate::a
+            b: t
+
+            crate::a::b
+            c: t
+
+            crate::a::b::c
+            X: t v
+        "#]],
+    );
 }
diff --git a/crates/ra_hir_def/src/nameres/tests/primitives.rs b/crates/ra_hir_def/src/nameres/tests/primitives.rs
index 0e27086585..215e8952d9 100644
--- a/crates/ra_hir_def/src/nameres/tests/primitives.rs
+++ b/crates/ra_hir_def/src/nameres/tests/primitives.rs
@@ -2,23 +2,22 @@ use super::*;
 
 #[test]
 fn primitive_reexport() {
-    let map = def_map(
-        "
-        //- /lib.rs
-        mod foo;
-        use foo::int;
+    check(
+        r#"
+//- /lib.rs
+mod foo;
+use foo::int;
 
-        //- /foo.rs
-        pub use i32 as int;
-        ",
-    );
-    assert_snapshot!(map, @r###"
-   ⋮crate
-   ⋮foo: t
-   ⋮int: t
-   ⋮
-   ⋮crate::foo
-   ⋮int: t
-    "###
+//- /foo.rs
+pub use i32 as int;
+"#,
+        expect![[r#"
+            crate
+            foo: t
+            int: t
+
+            crate::foo
+            int: t
+        "#]],
     );
 }