1 files changed, 285 insertions, 499 deletions

diff --git a/crates/ra_hir/src/nameres/tests.rs b/crates/ra_hir/src/nameres/tests.rs
index 9b151bb0c..ac9b88520 100644
--- a/crates/ra_hir/src/nameres/tests.rs
+++ b/crates/ra_hir/src/nameres/tests.rs
@@ -1,34 +1,43 @@
+mod macros;
+mod globs;
+mod incremental;
+
 use std::sync::Arc;
 
 use ra_db::SourceDatabase;
-use test_utils::{assert_eq_text, covers};
-
-use crate::{
-    ItemMap,
-    PersistentHirDatabase,
-    mock::MockDatabase,
-    module_tree::ModuleId,
-};
-use super::Resolution;
-
-fn item_map(fixture: &str) -> (Arc<ItemMap>, ModuleId) {
-    let (db, pos) = MockDatabase::with_position(fixture);
-    let module = crate::source_binder::module_from_position(&db, pos).unwrap();
-    let krate = module.krate(&db).unwrap();
-    let module_id = module.module_id;
-    (db.item_map(krate), module_id)
+use test_utils::covers;
+use insta::assert_snapshot_matches;
+
+use crate::{Crate, mock::{MockDatabase, CrateGraphFixture}, nameres::Resolution};
+
+use super::*;
+
+fn compute_crate_def_map(fixture: &str, graph: Option<CrateGraphFixture>) -> Arc<CrateDefMap> {
+    let mut db = MockDatabase::with_files(fixture);
+    if let Some(graph) = graph {
+        db.set_crate_graph_from_fixture(graph);
+    }
+    let crate_id = db.crate_graph().iter().next().unwrap();
+    let krate = Crate { crate_id };
+    db.crate_def_map(krate)
 }
 
-fn check_module_item_map(map: &ItemMap, module_id: ModuleId, expected: &str) {
-    let mut lines = map[module_id]
-        .items
-        .iter()
-        .map(|(name, res)| format!("{}: {}", name, dump_resolution(res)))
-        .collect::<Vec<_>>();
-    lines.sort();
-    let actual = lines.join("\n");
-    let expected = expected.trim().lines().map(|it| it.trim()).collect::<Vec<_>>().join("\n");
-    assert_eq_text!(&expected, &actual);
+fn render_crate_def_map(map: &CrateDefMap) -> String {
+    let mut buf = String::new();
+    go(&mut buf, map, "\ncrate", map.root);
+    return buf;
+
+    fn go(buf: &mut String, map: &CrateDefMap, path: &str, module: CrateModuleId) {
+        *buf += path;
+        *buf += "\n";
+        for (name, res) in map.modules[module].scope.items.iter() {
+            *buf += &format!("{}: {}\n", name, dump_resolution(res))
+        }
+        for (name, child) in map.modules[module].children.iter() {
+            let path = path.to_string() + &format!("::{}", name);
+            go(buf, map, &path, *child);
+        }
+    }
 
     fn dump_resolution(resolution: &Resolution) -> &'static str {
         match (resolution.def.types.is_some(), resolution.def.values.is_some()) {
@@ -40,66 +49,112 @@ fn check_module_item_map(map: &ItemMap, module_id: ModuleId, expected: &str) {
     }
 }
 
+fn def_map(fixtute: &str) -> String {
+    let dm = compute_crate_def_map(fixtute, None);
+    render_crate_def_map(&dm)
+}
+
+fn def_map_with_crate_graph(fixtute: &str, graph: CrateGraphFixture) -> String {
+    let dm = compute_crate_def_map(fixtute, Some(graph));
+    render_crate_def_map(&dm)
+}
+
 #[test]
-fn item_map_smoke_test() {
-    let (item_map, module_id) = item_map(
+fn crate_def_map_smoke_test() {
+    let map = def_map(
         "
         //- /lib.rs
         mod foo;
-
-        use crate::foo::bar::Baz;
-        <|>
+        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;
-    ",
+        enum E { V }
+        ",
     );
-    check_module_item_map(
-        &item_map,
-        module_id,
+    assert_snapshot_matches!(map, @r###"
+crate
+V: t v
+E: t
+foo: t
+S: t v
+
+crate::foo
+bar: t
+f: v
+
+crate::foo::bar
+Baz: t v
+E: t
+"###
+    )
+}
+
+#[test]
+fn bogus_paths() {
+    covers!(bogus_paths);
+    let map = def_map(
         "
-            Baz: t v
-            foo: t
+        //- /lib.rs
+        mod foo;
+        struct S;
+        use self;
+
+        //- /foo/mod.rs
+        use super;
+        use crate;
+
         ",
     );
+    assert_snapshot_matches!(map, @r###"
+crate
+foo: t
+S: t v
+
+crate::foo
+"###
+    )
 }
 
 #[test]
 fn use_as() {
-    let (item_map, module_id) = item_map(
+    let map = def_map(
         "
         //- /lib.rs
         mod foo;
 
         use crate::foo::Baz as Foo;
-        <|>
 
         //- /foo/mod.rs
         pub struct Baz;
-    ",
-    );
-    check_module_item_map(
-        &item_map,
-        module_id,
-        "
-            Foo: t v
-            foo: t
         ",
     );
+    assert_snapshot_matches!(map,
+        @r###"
+crate
+Foo: t v
+foo: t
+
+crate::foo
+Baz: t v
+"###
+    );
 }
 
 #[test]
 fn use_trees() {
-    let (item_map, module_id) = item_map(
+    let map = def_map(
         "
         //- /lib.rs
         mod foo;
 
         use crate::foo::bar::{Baz, Quux};
-        <|>
 
         //- /foo/mod.rs
         pub mod bar;
@@ -107,28 +162,33 @@ fn use_trees() {
         //- /foo/bar.rs
         pub struct Baz;
         pub enum Quux {};
-    ",
-    );
-    check_module_item_map(
-        &item_map,
-        module_id,
-        "
-            Baz: t v
-            Quux: t
-            foo: t
         ",
     );
+    assert_snapshot_matches!(map,
+        @r###"
+crate
+Quux: t
+Baz: t v
+foo: t
+
+crate::foo
+bar: t
+
+crate::foo::bar
+Quux: t
+Baz: t v
+"###
+    );
 }
 
 #[test]
 fn re_exports() {
-    let (item_map, module_id) = item_map(
+    let map = def_map(
         "
         //- /lib.rs
         mod foo;
 
         use self::foo::Baz;
-        <|>
 
         //- /foo/mod.rs
         pub mod bar;
@@ -137,137 +197,73 @@ fn re_exports() {
 
         //- /foo/bar.rs
         pub struct Baz;
-    ",
-    );
-    check_module_item_map(
-        &item_map,
-        module_id,
-        "
-            Baz: t v
-            foo: t
         ",
     );
-}
+    assert_snapshot_matches!(map,
+        @r###"
+crate
+Baz: t v
+foo: t
 
-#[test]
-fn glob_1() {
-    let (item_map, module_id) = item_map(
-        "
-        //- /lib.rs
-        mod foo;
-        use foo::*;
-        <|>
-
-        //- /foo/mod.rs
-        pub mod bar;
-        pub use self::bar::Baz;
-        pub struct Foo;
+crate::foo
+bar: t
+Baz: t v
 
-        //- /foo/bar.rs
-        pub struct Baz;
-    ",
-    );
-    check_module_item_map(
-        &item_map,
-        module_id,
-        "
-            Baz: t v
-            Foo: t v
-            bar: t
-            foo: t
-        ",
+crate::foo::bar
+Baz: t v
+"###
     );
 }
 
 #[test]
-fn glob_2() {
-    let (item_map, module_id) = item_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::*;
-    ",
-    );
-    check_module_item_map(
-        &item_map,
-        module_id,
+fn std_prelude() {
+    covers!(std_prelude);
+    let map = def_map_with_crate_graph(
         "
-            Baz: t v
-            Foo: t v
-            bar: t
-            foo: t
-        ",
-    );
-}
+        //- /main.rs
+        use Foo::*;
 
-#[test]
-fn glob_enum() {
-    covers!(glob_enum);
-    let (item_map, module_id) = item_map(
-        "
         //- /lib.rs
-        enum Foo {
-            Bar, Baz
-        }
-        use self::Foo::*;
-        <|>
-    ",
-    );
-    check_module_item_map(
-        &item_map,
-        module_id,
-        "
-            Bar: t v
-            Baz: t v
-            Foo: t
+        mod prelude;
+        #[prelude_import]
+        use prelude::*;
+
+        //- /prelude.rs
+        pub enum Foo { Bar, Baz };
         ",
+        crate_graph! {
+            "main": ("/main.rs", ["test_crate"]),
+            "test_crate": ("/lib.rs", []),
+        },
     );
+    assert_snapshot_matches!(map, @r###"
+crate
+Bar: t v
+Baz: t v
+"###);
 }
 
 #[test]
-fn glob_across_crates() {
-    covers!(glob_across_crates);
-    let mut db = MockDatabase::with_files(
+fn can_import_enum_variant() {
+    covers!(can_import_enum_variant);
+    let map = def_map(
         "
-        //- /main.rs
-        use test_crate::*;
-
         //- /lib.rs
-        pub struct Baz;
+        enum E { V }
+        use self::E::V;
         ",
     );
-    db.set_crate_graph_from_fixture(crate_graph! {
-        "main": ("/main.rs", ["test_crate"]),
-        "test_crate": ("/lib.rs", []),
-    });
-    let main_id = db.file_id_of("/main.rs");
-
-    let module = crate::source_binder::module_from_file_id(&db, main_id).unwrap();
-    let krate = module.krate(&db).unwrap();
-    let item_map = db.item_map(krate);
-
-    check_module_item_map(
-        &item_map,
-        module.module_id,
-        "
-            Baz: t v
-        ",
+    assert_snapshot_matches!(map, @r###"
+crate
+V: t v
+E: t
+"###
     );
 }
 
 #[test]
 fn edition_2015_imports() {
-    let mut db = MockDatabase::with_files(
+    let map = def_map_with_crate_graph(
         "
         //- /main.rs
         mod foo;
@@ -282,31 +278,32 @@ fn edition_2015_imports() {
 
         //- /lib.rs
         struct FromLib;
-    ",
-    );
-    db.set_crate_graph_from_fixture(crate_graph! {
-        "main": ("/main.rs", "2015", ["other_crate"]),
-        "other_crate": ("/lib.rs", "2018", []),
-    });
-    let foo_id = db.file_id_of("/foo.rs");
-
-    let module = crate::source_binder::module_from_file_id(&db, foo_id).unwrap();
-    let krate = module.krate(&db).unwrap();
-    let item_map = db.item_map(krate);
-
-    check_module_item_map(
-        &item_map,
-        module.module_id,
-        "
-            Bar: t v
-            FromLib: t v
         ",
+        crate_graph! {
+            "main": ("/main.rs", "2015", ["other_crate"]),
+            "other_crate": ("/lib.rs", "2018", []),
+        },
+    );
+
+    assert_snapshot_matches!(map,
+        @r###"
+crate
+bar: t
+foo: t
+
+crate::bar
+Bar: t v
+
+crate::foo
+FromLib: t v
+Bar: t v
+"###
     );
 }
 
 #[test]
 fn module_resolution_works_for_non_standard_filenames() {
-    let mut db = MockDatabase::with_files(
+    let map = def_map_with_crate_graph(
         "
         //- /my_library.rs
         mod foo;
@@ -315,73 +312,32 @@ fn module_resolution_works_for_non_standard_filenames() {
         //- /foo/mod.rs
         pub struct Bar;
         ",
+        crate_graph! {
+            "my_library": ("/my_library.rs", []),
+        },
     );
-    db.set_crate_graph_from_fixture(crate_graph! {
-        "my_library": ("/my_library.rs", []),
-    });
-    let file_id = db.file_id_of("/my_library.rs");
-
-    let module = crate::source_binder::module_from_file_id(&db, file_id).unwrap();
-    let krate = module.krate(&db).unwrap();
-    let module_id = module.module_id;
-    let item_map = db.item_map(krate);
-    check_module_item_map(
-        &item_map,
-        module_id,
-        "
-        Bar: t v
-        foo: t
-        ",
-    );
-}
 
-#[test]
-fn std_prelude() {
-    covers!(std_prelude);
-    let mut db = MockDatabase::with_files(
-        "
-        //- /main.rs
-        use Foo::*;
-
-        //- /lib.rs
-        mod prelude;
-        #[prelude_import]
-        use prelude::*;
+    assert_snapshot_matches!(map,
+        @r###"
+crate
+Bar: t v
+foo: t
 
-        //- /prelude.rs
-        pub enum Foo { Bar, Baz };
-    ",
-    );
-    db.set_crate_graph_from_fixture(crate_graph! {
-        "main": ("/main.rs", ["test_crate"]),
-        "test_crate": ("/lib.rs", []),
-    });
-    let main_id = db.file_id_of("/main.rs");
-
-    let module = crate::source_binder::module_from_file_id(&db, main_id).unwrap();
-    let krate = module.krate(&db).unwrap();
-    let item_map = db.item_map(krate);
-
-    check_module_item_map(
-        &item_map,
-        module.module_id,
-        "
-            Bar: t v
-            Baz: t v
-        ",
+crate::foo
+Bar: t v
+"###
     );
 }
 
 #[test]
 fn name_res_works_for_broken_modules() {
     covers!(name_res_works_for_broken_modules);
-    let (item_map, module_id) = item_map(
+    let map = def_map(
         "
         //- /lib.rs
         mod foo // no `;`, no body
 
         use self::foo::Baz;
-        <|>
 
         //- /foo/mod.rs
         pub mod bar;
@@ -390,65 +346,47 @@ fn name_res_works_for_broken_modules() {
 
         //- /foo/bar.rs
         pub struct Baz;
-    ",
-    );
-    check_module_item_map(
-        &item_map,
-        module_id,
-        "
-            Baz: _
         ",
     );
-}
-
-#[test]
-fn item_map_using_self() {
-    let (item_map, module_id) = item_map(
-        "
-            //- /lib.rs
-            mod foo;
-            use crate::foo::bar::Baz::{self};
-            <|>
-            //- /foo/mod.rs
-            pub mod bar;
-            //- /foo/bar.rs
-            pub struct Baz;
-        ",
-    );
-    check_module_item_map(
-        &item_map,
-        module_id,
-        "
-            Baz: t v
-            foo: t
-        ",
+    assert_snapshot_matches!(map,
+        @r###"
+crate
+Baz: _
+"###
     );
 }
 
 #[test]
-fn item_map_enum_importing() {
-    covers!(item_map_enum_importing);
-    let (item_map, module_id) = item_map(
+fn item_map_using_self() {
+    let map = def_map(
         "
         //- /lib.rs
-        enum E { V }
-        use self::E::V;
-        <|>
+        mod foo;
+        use crate::foo::bar::Baz::{self};
+        //- /foo/mod.rs
+        pub mod bar;
+        //- /foo/bar.rs
+        pub struct Baz;
         ",
     );
-    check_module_item_map(
-        &item_map,
-        module_id,
-        "
-        E: t
-        V: t v
-        ",
+    assert_snapshot_matches!(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 mut db = MockDatabase::with_files(
+    let map = def_map_with_crate_graph(
         "
         //- /main.rs
         use test_crate::Baz;
@@ -456,29 +394,23 @@ fn item_map_across_crates() {
         //- /lib.rs
         pub struct Baz;
         ",
+        crate_graph! {
+            "main": ("/main.rs", ["test_crate"]),
+            "test_crate": ("/lib.rs", []),
+        },
     );
-    db.set_crate_graph_from_fixture(crate_graph! {
-        "main": ("/main.rs", ["test_crate"]),
-        "test_crate": ("/lib.rs", []),
-    });
-    let main_id = db.file_id_of("/main.rs");
-
-    let module = crate::source_binder::module_from_file_id(&db, main_id).unwrap();
-    let krate = module.krate(&db).unwrap();
-    let item_map = db.item_map(krate);
-
-    check_module_item_map(
-        &item_map,
-        module.module_id,
-        "
-        Baz: t v
-        ",
+
+    assert_snapshot_matches!(map,
+        @r###"
+crate
+Baz: t v
+"###
     );
 }
 
 #[test]
 fn extern_crate_rename() {
-    let mut db = MockDatabase::with_files(
+    let map = def_map_with_crate_graph(
         "
         //- /main.rs
         extern crate alloc as alloc_crate;
@@ -492,29 +424,23 @@ fn extern_crate_rename() {
         //- /lib.rs
         struct Arc;
         ",
+        crate_graph! {
+            "main": ("/main.rs", ["alloc"]),
+            "alloc": ("/lib.rs", []),
+        },
     );
-    db.set_crate_graph_from_fixture(crate_graph! {
-        "main": ("/main.rs", ["alloc"]),
-        "alloc": ("/lib.rs", []),
-    });
-    let sync_id = db.file_id_of("/sync.rs");
-
-    let module = crate::source_binder::module_from_file_id(&db, sync_id).unwrap();
-    let krate = module.krate(&db).unwrap();
-    let item_map = db.item_map(krate);
-
-    check_module_item_map(
-        &item_map,
-        module.module_id,
-        "
-        Arc: t v
-        ",
+
+    assert_snapshot_matches!(map,
+        @r###"
+crate
+Arc: t v
+"###
     );
 }
 
 #[test]
 fn extern_crate_rename_2015_edition() {
-    let mut db = MockDatabase::with_files(
+    let map = def_map_with_crate_graph(
         "
         //- /main.rs
         extern crate alloc as alloc_crate;
@@ -528,29 +454,23 @@ fn extern_crate_rename_2015_edition() {
         //- /lib.rs
         struct Arc;
         ",
+        crate_graph! {
+            "main": ("/main.rs", "2015", ["alloc"]),
+            "alloc": ("/lib.rs", []),
+        },
     );
-    db.set_crate_graph_from_fixture(crate_graph! {
-        "main": ("/main.rs", "2015", ["alloc"]),
-        "alloc": ("/lib.rs", []),
-    });
-    let sync_id = db.file_id_of("/sync.rs");
-
-    let module = crate::source_binder::module_from_file_id(&db, sync_id).unwrap();
-    let krate = module.krate(&db).unwrap();
-    let item_map = db.item_map(krate);
-
-    check_module_item_map(
-        &item_map,
-        module.module_id,
-        "
-        Arc: t v
-        ",
+
+    assert_snapshot_matches!(map,
+        @r###"
+crate
+Arc: t v
+"###
     );
 }
 
 #[test]
 fn import_across_source_roots() {
-    let mut db = MockDatabase::with_files(
+    let map = def_map_with_crate_graph(
         "
         //- /lib.rs
         pub mod a {
@@ -564,29 +484,23 @@ fn import_across_source_roots() {
         //- /main/main.rs
         use test_crate::a::b::C;
         ",
+        crate_graph! {
+            "main": ("/main/main.rs", ["test_crate"]),
+            "test_crate": ("/lib.rs", []),
+        },
     );
-    db.set_crate_graph_from_fixture(crate_graph! {
-        "main": ("/main/main.rs", ["test_crate"]),
-        "test_crate": ("/lib.rs", []),
-    });
-    let main_id = db.file_id_of("/main/main.rs");
-
-    let module = crate::source_binder::module_from_file_id(&db, main_id).unwrap();
-    let krate = module.krate(&db).unwrap();
-    let item_map = db.item_map(krate);
-
-    check_module_item_map(
-        &item_map,
-        module.module_id,
-        "
-            C: t v
-        ",
+
+    assert_snapshot_matches!(map,
+        @r###"
+crate
+C: t v
+"###
     );
 }
 
 #[test]
 fn reexport_across_crates() {
-    let mut db = MockDatabase::with_files(
+    let map = def_map_with_crate_graph(
         "
         //- /main.rs
         use test_crate::Baz;
@@ -599,29 +513,23 @@ fn reexport_across_crates() {
         //- /foo.rs
         pub struct Baz;
         ",
+        crate_graph! {
+            "main": ("/main.rs", ["test_crate"]),
+            "test_crate": ("/lib.rs", []),
+        },
     );
-    db.set_crate_graph_from_fixture(crate_graph! {
-        "main": ("/main.rs", ["test_crate"]),
-        "test_crate": ("/lib.rs", []),
-    });
-    let main_id = db.file_id_of("/main.rs");
-
-    let module = crate::source_binder::module_from_file_id(&db, main_id).unwrap();
-    let krate = module.krate(&db).unwrap();
-    let item_map = db.item_map(krate);
-
-    check_module_item_map(
-        &item_map,
-        module.module_id,
-        "
-        Baz: t v
-        ",
+
+    assert_snapshot_matches!(map,
+        @r###"
+crate
+Baz: t v
+"###
     );
 }
 
 #[test]
 fn values_dont_shadow_extern_crates() {
-    let mut db = MockDatabase::with_files(
+    let map = def_map_with_crate_graph(
         "
         //- /main.rs
         fn foo() {}
@@ -630,139 +538,17 @@ fn values_dont_shadow_extern_crates() {
         //- /foo/lib.rs
         pub struct Bar;
         ",
+        crate_graph! {
+            "main": ("/main.rs", ["foo"]),
+            "foo": ("/foo/lib.rs", []),
+        },
     );
-    db.set_crate_graph_from_fixture(crate_graph! {
-        "main": ("/main.rs", ["foo"]),
-        "foo": ("/foo/lib.rs", []),
-    });
-    let main_id = db.file_id_of("/main.rs");
-
-    let module = crate::source_binder::module_from_file_id(&db, main_id).unwrap();
-    let krate = module.krate(&db).unwrap();
-    let item_map = db.item_map(krate);
-
-    check_module_item_map(
-        &item_map,
-        module.module_id,
-        "
-        Bar: t v
-        foo: v
-        ",
-    );
-}
-
-fn check_item_map_is_not_recomputed(initial: &str, file_change: &str) {
-    let (mut db, pos) = MockDatabase::with_position(initial);
-    let module = crate::source_binder::module_from_file_id(&db, pos.file_id).unwrap();
-    let krate = module.krate(&db).unwrap();
-    {
-        let events = db.log_executed(|| {
-            db.item_map(krate);
-        });
-        assert!(format!("{:?}", events).contains("item_map"))
-    }
-    db.set_file_text(pos.file_id, Arc::new(file_change.to_string()));
-
-    {
-        let events = db.log_executed(|| {
-            db.item_map(krate);
-        });
-        assert!(!format!("{:?}", events).contains("item_map"), "{:#?}", events)
-    }
-}
-
-#[test]
-fn typing_inside_a_function_should_not_invalidate_item_map() {
-    check_item_map_is_not_recomputed(
-        "
-        //- /lib.rs
-        mod foo;<|>
-
-        use crate::foo::bar::Baz;
-
-        fn foo() -> i32 {
-            1 + 1
-        }
-        //- /foo/mod.rs
-        pub mod bar;
-
-        //- /foo/bar.rs
-        pub struct Baz;
-        ",
-        "
-        mod foo;
-
-        use crate::foo::bar::Baz;
-
-        fn foo() -> i32 { 92 }
-        ",
-    );
-}
-
-#[test]
-fn adding_inner_items_should_not_invalidate_item_map() {
-    check_item_map_is_not_recomputed(
-        "
-        //- /lib.rs
-        struct S { a: i32}
-        enum E { A }
-        trait T {
-            fn a() {}
-        }
-        mod foo;<|>
-        impl S {
-            fn a() {}
-        }
-        use crate::foo::bar::Baz;
-        //- /foo/mod.rs
-        pub mod bar;
-
-        //- /foo/bar.rs
-        pub struct Baz;
-        ",
-        "
-        struct S { a: i32, b: () }
-        enum E { A, B }
-        trait T {
-            fn a() {}
-            fn b() {}
-        }
-        mod foo;<|>
-        impl S {
-            fn a() {}
-            fn b() {}
-        }
-        use crate::foo::bar::Baz;
-        ",
-    );
-}
 
-#[test]
-fn typing_inside_a_function_inside_a_macro_should_not_invalidate_item_map() {
-    check_item_map_is_not_recomputed(
-        "
-        //- /lib.rs
-        mod foo;
-
-        use crate::foo::bar::Baz;
-
-        //- /foo/mod.rs
-        pub mod bar;
-
-        //- /foo/bar.rs
-        <|>
-        salsa::query_group! {
-            trait Baz {
-                fn foo() -> i32 { 1 + 1 }
-            }
-        }
-        ",
-        "
-        salsa::query_group! {
-            trait Baz {
-                fn foo() -> i32 { 92 }
-            }
-        }
-        ",
+    assert_snapshot_matches!(map,
+        @r###"
+crate
+Bar: t v
+foo: v
+"###
     );
 }