Merge #7541

7541: Use block_def_map in body lowering (third time's the charm) r=jonas-schievink a=jonas-schievink

After https://github.com/rust-analyzer/rust-analyzer/pull/7380 and https://github.com/rust-analyzer/rust-analyzer/pull/7506 both had to be reverted, this should have finally resolved all remaining bugs.

Most importantly, the optimization to skip `block_def_map` computation when the block contains no inner items was fixed (which fortunately was simpler than expected).

I've ran `analysis-stats` on libstd locally, which works fine, and also ran this PR locally for a short while without issues.

Note that this *still* has no (or almost no) user-facing impact, because the rest of r-a still relies on some local item support hacks.

bors r+

Co-authored-by: Jonas Schievink <[email protected]>

2 files changed, 2 insertions, 252 deletions

diff --git a/crates/hir_def/src/nameres/tests.rs b/crates/hir_def/src/nameres/tests.rs
index b36d0b59b..723481c36 100644
--- a/crates/hir_def/src/nameres/tests.rs
+++ b/crates/hir_def/src/nameres/tests.rs
@@ -4,16 +4,14 @@ mod macros;
 mod mod_resolution;
 mod diagnostics;
 mod primitives;
-mod block;
 
 use std::sync::Arc;
 
-use base_db::{fixture::WithFixture, FilePosition, SourceDatabase};
+use base_db::{fixture::WithFixture, SourceDatabase};
 use expect_test::{expect, Expect};
-use syntax::AstNode;
 use test_utils::mark;
 
-use crate::{db::DefDatabase, nameres::*, test_db::TestDB, Lookup};
+use crate::{db::DefDatabase, nameres::*, test_db::TestDB};
 
 fn compute_crate_def_map(ra_fixture: &str) -> Arc<DefMap> {
     let db = TestDB::with_files(ra_fixture);
@@ -21,74 +19,12 @@ fn compute_crate_def_map(ra_fixture: &str) -> Arc<DefMap> {
     db.crate_def_map(krate)
 }
 
-fn compute_block_def_map(ra_fixture: &str) -> Arc<DefMap> {
-    let (db, position) = TestDB::with_position(ra_fixture);
-
-    // FIXME: perhaps we should make this use body lowering tests instead?
-
-    let module = db.module_for_file(position.file_id);
-    let mut def_map = db.crate_def_map(module.krate);
-    while let Some(new_def_map) = descend_def_map_at_position(&db, position, def_map.clone()) {
-        def_map = new_def_map;
-    }
-
-    // FIXME: select the right module, not the root
-
-    def_map
-}
-
-fn descend_def_map_at_position(
-    db: &dyn DefDatabase,
-    position: FilePosition,
-    def_map: Arc<DefMap>,
-) -> Option<Arc<DefMap>> {
-    for (local_id, module_data) in def_map.modules() {
-        let mod_def = module_data.origin.definition_source(db);
-        let ast_map = db.ast_id_map(mod_def.file_id);
-        let item_tree = db.item_tree(mod_def.file_id);
-        let root = db.parse_or_expand(mod_def.file_id).unwrap();
-        for item in module_data.scope.declarations() {
-            match item {
-                ModuleDefId::FunctionId(it) => {
-                    // Technically blocks can be inside any type (due to arrays and const generics),
-                    // and also in const/static initializers. For tests we only really care about
-                    // functions though.
-
-                    let ast = ast_map.get(item_tree[it.lookup(db).id.value].ast_id).to_node(&root);
-
-                    if ast.syntax().text_range().contains(position.offset) {
-                        // Cursor inside function, descend into its body's DefMap.
-                        // Note that we don't handle block *expressions* inside function bodies.
-                        let ast_map = db.ast_id_map(position.file_id.into());
-                        let ast_id = ast_map.ast_id(&ast.body().unwrap());
-                        let block = BlockLoc {
-                            ast_id: InFile::new(position.file_id.into(), ast_id),
-                            module: def_map.module_id(local_id),
-                        };
-                        let block_id = db.intern_block(block);
-                        return Some(db.block_def_map(block_id));
-                    }
-                }
-                _ => continue,
-            }
-        }
-    }
-
-    None
-}
-
 fn check(ra_fixture: &str, expect: Expect) {
     let def_map = compute_crate_def_map(ra_fixture);
     let actual = def_map.dump();
     expect.assert_eq(&actual);
 }
 
-fn check_at(ra_fixture: &str, expect: Expect) {
-    let def_map = compute_block_def_map(ra_fixture);
-    let actual = def_map.dump();
-    expect.assert_eq(&actual);
-}
-
 #[test]
 fn crate_def_map_smoke_test() {
     check(
diff --git a/crates/hir_def/src/nameres/tests/block.rs b/crates/hir_def/src/nameres/tests/block.rs
deleted file mode 100644
index 6cc659513..000000000
--- a/crates/hir_def/src/nameres/tests/block.rs
+++ /dev/null
@@ -1,186 +0,0 @@
-use super::*;
-
-#[test]
-fn inner_item_smoke() {
-    check_at(
-        r#"
-struct inner {}
-fn outer() {
-    $0
-    fn inner() {}
-}
-"#,
-        expect![[r#"
-            block scope
-            inner: v
-            crate
-            inner: t
-            outer: v
-        "#]],
-    );
-}
-
-#[test]
-fn use_from_crate() {
-    check_at(
-        r#"
-struct Struct;
-fn outer() {
-    use Struct;
-    use crate::Struct as CrateStruct;
-    use self::Struct as SelfStruct;
-    $0
-}
-"#,
-        expect![[r#"
-            block scope
-            CrateStruct: t v
-            SelfStruct: t v
-            Struct: t v
-            crate
-            Struct: t v
-            outer: v
-        "#]],
-    );
-}
-
-#[test]
-fn merge_namespaces() {
-    check_at(
-        r#"
-struct name {}
-fn outer() {
-    fn name() {}
-
-    use name as imported; // should import both `name`s
-
-    $0
-}
-"#,
-        expect![[r#"
-            block scope
-            imported: t v
-            name: v
-            crate
-            name: t
-            outer: v
-        "#]],
-    );
-}
-
-#[test]
-fn nested_blocks() {
-    check_at(
-        r#"
-fn outer() {
-    struct inner1 {}
-    fn inner() {
-        use inner1;
-        use outer;
-        fn inner2() {}
-        $0
-    }
-}
-"#,
-        expect![[r#"
-            block scope
-            inner1: t
-            inner2: v
-            outer: v
-            block scope
-            inner: v
-            inner1: t
-            crate
-            outer: v
-        "#]],
-    );
-}
-
-#[test]
-fn super_imports() {
-    check_at(
-        r#"
-mod module {
-    fn f() {
-        use super::Struct;
-        $0
-    }
-}
-
-struct Struct {}
-"#,
-        expect![[r#"
-            block scope
-            Struct: t
-            crate
-            Struct: t
-            module: t
-
-            crate::module
-            f: v
-        "#]],
-    );
-}
-
-#[test]
-fn legacy_macro_items() {
-    // Checks that legacy-scoped `macro_rules!` from parent namespaces are resolved and expanded
-    // correctly.
-    check_at(
-        r#"
-macro_rules! hit {
-    () => {
-        struct Hit {}
-    }
-}
-
-fn f() {
-    hit!();
-    $0
-}
-"#,
-        expect![[r#"
-            block scope
-            Hit: t
-            crate
-            f: v
-        "#]],
-    );
-}
-
-#[test]
-fn macro_resolve() {
-    check_at(
-        r#"
-//- /lib.rs crate:lib deps:core
-use core::mark;
-
-fn f() {
-    fn nested() {
-        mark::hit!(Hit);
-        $0
-    }
-}
-//- /core.rs crate:core
-pub mod mark {
-    #[macro_export]
-    macro_rules! _hit {
-        ($name:ident) => {
-            struct $name {}
-        }
-    }
-
-    pub use crate::_hit as hit;
-}
-"#,
-        expect![[r#"
-            block scope
-            Hit: t
-            block scope
-            nested: v
-            crate
-            f: v
-            mark: t
-        "#]],
-    );
-}