Revert "Use block_def_map in body lowering"

3 files changed, 12 insertions, 326 deletions

diff --git a/crates/hir_def/src/body/lower.rs b/crates/hir_def/src/body/lower.rs
index bc61730a7..209965fca 100644
--- a/crates/hir_def/src/body/lower.rs
+++ b/crates/hir_def/src/body/lower.rs
@@ -1,7 +1,7 @@
 //! Transforms `ast::Expr` into an equivalent `hir_def::expr::Expr`
 //! representation.
 
-use std::{any::type_name, mem, sync::Arc};
+use std::{any::type_name, sync::Arc};
 
 use either::Either;
 use hir_expand::{
@@ -36,8 +36,8 @@ use crate::{
     item_tree::{ItemTree, ItemTreeId, ItemTreeNode},
     path::{GenericArgs, Path},
     type_ref::{Mutability, Rawness, TypeRef},
-    AdtId, BlockLoc, ConstLoc, ContainerId, DefWithBodyId, EnumLoc, FunctionLoc, Intern,
-    ModuleDefId, StaticLoc, StructLoc, TraitLoc, TypeAliasLoc, UnionLoc,
+    AdtId, ConstLoc, ContainerId, DefWithBodyId, EnumLoc, FunctionLoc, Intern, ModuleDefId,
+    StaticLoc, StructLoc, TraitLoc, TypeAliasLoc, UnionLoc,
 };
 
 use super::{diagnostics::BodyDiagnostic, ExprSource, PatSource};
@@ -152,8 +152,8 @@ impl ExprCollector<'_> {
     fn alloc_expr_desugared(&mut self, expr: Expr) -> ExprId {
         self.make_expr(expr, Err(SyntheticSyntax))
     }
-    fn unit(&mut self) -> ExprId {
-        self.alloc_expr_desugared(Expr::Tuple { exprs: Vec::new() })
+    fn empty_block(&mut self) -> ExprId {
+        self.alloc_expr_desugared(Expr::Block { statements: Vec::new(), tail: None, label: None })
     }
     fn missing_expr(&mut self) -> ExprId {
         self.alloc_expr_desugared(Expr::Missing)
@@ -222,7 +222,7 @@ impl ExprCollector<'_> {
                                 MatchArm { pat, expr: then_branch, guard: None },
                                 MatchArm {
                                     pat: placeholder_pat,
-                                    expr: else_branch.unwrap_or_else(|| self.unit()),
+                                    expr: else_branch.unwrap_or_else(|| self.empty_block()),
                                     guard: None,
                                 },
                             ];
@@ -561,7 +561,7 @@ impl ExprCollector<'_> {
         let outer_file = self.expander.current_file_id;
 
         let macro_call = self.expander.to_source(AstPtr::new(&e));
-        let res = self.expander.enter_expand(self.db, e);
+        let res = self.expander.enter_expand(self.db, Some(&self.body.item_scope), e);
 
         match &res.err {
             Some(ExpandError::UnresolvedProcMacro) => {
@@ -697,27 +697,12 @@ impl ExprCollector<'_> {
     }
 
     fn collect_block(&mut self, block: ast::BlockExpr) -> ExprId {
-        let ast_id = self.expander.ast_id(&block);
-        let block_loc = BlockLoc { ast_id, module: self.expander.module };
-        let block_id = self.db.intern_block(block_loc);
-        let def_map = self.db.block_def_map(block_id);
-        let root = def_map.module_id(def_map.root());
-        let prev_def_map = mem::replace(&mut self.expander.def_map, def_map);
-        let prev_module = mem::replace(&mut self.expander.module, root);
-
+        let syntax_node_ptr = AstPtr::new(&block.clone().into());
         self.collect_stmts_items(block.statements());
         let statements =
             block.statements().filter_map(|s| self.collect_stmt(s)).flatten().collect();
         let tail = block.tail_expr().map(|e| self.collect_expr(e));
-        let syntax_node_ptr = AstPtr::new(&block.clone().into());
-        let expr_id = self.alloc_expr(
-            Expr::Block { id: block_id, statements, tail, label: None },
-            syntax_node_ptr,
-        );
-
-        self.expander.def_map = prev_def_map;
-        self.expander.module = prev_module;
-        expr_id
+        self.alloc_expr(Expr::Block { statements, tail, label: None }, syntax_node_ptr)
     }
 
     fn collect_stmts_items(&mut self, stmts: ast::AstChildren<ast::Stmt>) {
@@ -847,7 +832,7 @@ impl ExprCollector<'_> {
                 if annotation == BindingAnnotation::Unannotated && subpat.is_none() {
                     // This could also be a single-segment path pattern. To
                     // decide that, we need to try resolving the name.
-                    let (resolved, _) = self.expander.def_map.resolve_path(
+                    let (resolved, _) = self.expander.crate_def_map.resolve_path(
                         self.db,
                         self.expander.module.local_id,
                         &name.clone().into(),
diff --git a/crates/hir_def/src/body/tests.rs b/crates/hir_def/src/body/tests.rs
index da60072ce..2e5d0a01e 100644
--- a/crates/hir_def/src/body/tests.rs
+++ b/crates/hir_def/src/body/tests.rs
@@ -1,10 +1,7 @@
-mod block;
-
-use base_db::{fixture::WithFixture, FilePosition, SourceDatabase};
-use expect_test::Expect;
+use base_db::{fixture::WithFixture, SourceDatabase};
 use test_utils::mark;
 
-use crate::{test_db::TestDB, BlockId, ModuleDefId};
+use crate::{test_db::TestDB, ModuleDefId};
 
 use super::*;
 
@@ -34,115 +31,6 @@ fn check_diagnostics(ra_fixture: &str) {
     db.check_diagnostics();
 }
 
-fn block_def_map_at(ra_fixture: &str) -> Arc<DefMap> {
-    let (db, position) = crate::test_db::TestDB::with_position(ra_fixture);
-
-    let krate = db.crate_graph().iter().next().unwrap();
-    let def_map = db.crate_def_map(krate);
-
-    let mut block =
-        block_at_pos(&db, &def_map, position).expect("couldn't find enclosing function or block");
-    loop {
-        let def_map = db.block_def_map(block);
-        let new_block = block_at_pos(&db, &def_map, position);
-        match new_block {
-            Some(new_block) => {
-                assert_ne!(block, new_block);
-                block = new_block;
-            }
-            None => {
-                return def_map;
-            }
-        }
-    }
-}
-
-fn block_at_pos(db: &dyn DefDatabase, def_map: &DefMap, position: FilePosition) -> Option<BlockId> {
-    let mut size = None;
-    let mut fn_def = None;
-    for (_, module) in def_map.modules() {
-        let file_id = module.definition_source(db).file_id;
-        if file_id != position.file_id.into() {
-            continue;
-        }
-        let root = db.parse_or_expand(file_id).unwrap();
-        let ast_map = db.ast_id_map(file_id);
-        let item_tree = db.item_tree(file_id);
-        for decl in module.scope.declarations() {
-            if let ModuleDefId::FunctionId(it) = decl {
-                let ast = ast_map.get(item_tree[it.lookup(db).id.value].ast_id).to_node(&root);
-                let range = ast.syntax().text_range();
-
-                // Find the smallest (innermost) function containing the cursor.
-                if !range.contains(position.offset) {
-                    continue;
-                }
-
-                let new_size = match size {
-                    None => range.len(),
-                    Some(size) => {
-                        if range.len() < size {
-                            range.len()
-                        } else {
-                            size
-                        }
-                    }
-                };
-                if size != Some(new_size) {
-                    size = Some(new_size);
-                    fn_def = Some(it);
-                }
-            }
-        }
-    }
-
-    let (body, source_map) = db.body_with_source_map(fn_def?.into());
-
-    // Now find the smallest encompassing block expression in the function body.
-    let mut size = None;
-    let mut block_id = None;
-    for (expr_id, expr) in body.exprs.iter() {
-        if let Expr::Block { id, .. } = expr {
-            if let Ok(ast) = source_map.expr_syntax(expr_id) {
-                if ast.file_id != position.file_id.into() {
-                    continue;
-                }
-
-                let root = db.parse_or_expand(ast.file_id).unwrap();
-                let ast = ast.value.to_node(&root);
-                let range = ast.syntax().text_range();
-
-                if !range.contains(position.offset) {
-                    continue;
-                }
-
-                let new_size = match size {
-                    None => range.len(),
-                    Some(size) => {
-                        if range.len() < size {
-                            range.len()
-                        } else {
-                            size
-                        }
-                    }
-                };
-                if size != Some(new_size) {
-                    size = Some(new_size);
-                    block_id = Some(*id);
-                }
-            }
-        }
-    }
-
-    Some(block_id.expect("can't find block containing cursor"))
-}
-
-fn check_at(ra_fixture: &str, expect: Expect) {
-    let def_map = block_def_map_at(ra_fixture);
-    let actual = def_map.dump();
-    expect.assert_eq(&actual);
-}
-
 #[test]
 fn your_stack_belongs_to_me() {
     mark::check!(your_stack_belongs_to_me);
diff --git a/crates/hir_def/src/body/tests/block.rs b/crates/hir_def/src/body/tests/block.rs
deleted file mode 100644
index 6b1ed2555..000000000
--- a/crates/hir_def/src/body/tests/block.rs
+++ /dev/null
@@ -1,187 +0,0 @@
-use super::*;
-use expect_test::expect;
-
-#[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
-        "#]],
-    );
-}