From b7be2b1d3cc2fd8ca8e7aa7542aaf9d4f905f9f5 Mon Sep 17 00:00:00 2001 From: Jonas Schievink Date: Mon, 1 Feb 2021 13:19:55 +0100 Subject: Use block_def_map in body lowering --- crates/hir_def/src/body.rs | 19 ++++++------------- crates/hir_def/src/body/lower.rs | 35 +++++++++++++++++++++++++---------- crates/hir_def/src/data.rs | 2 +- crates/hir_def/src/expr.rs | 2 ++ crates/hir_def/src/item_tree.rs | 6 +++++- crates/hir_ty/src/infer/expr.rs | 2 +- 6 files changed, 40 insertions(+), 26 deletions(-) diff --git a/crates/hir_def/src/body.rs b/crates/hir_def/src/body.rs index b9ecf22fa..41abd8f83 100644 --- a/crates/hir_def/src/body.rs +++ b/crates/hir_def/src/body.rs @@ -46,7 +46,7 @@ pub(crate) struct CfgExpander { pub(crate) struct Expander { cfg_expander: CfgExpander, - crate_def_map: Arc, + def_map: Arc, current_file_id: HirFileId, ast_id_map: Arc, module: ModuleId, @@ -91,7 +91,7 @@ impl Expander { let ast_id_map = db.ast_id_map(current_file_id); Expander { cfg_expander, - crate_def_map, + def_map: crate_def_map, current_file_id, ast_id_map, module, @@ -102,7 +102,6 @@ impl Expander { pub(crate) fn enter_expand( &mut self, db: &dyn DefDatabase, - local_scope: Option<&ItemScope>, macro_call: ast::MacroCall, ) -> ExpandResult> { if self.recursion_limit + 1 > EXPANSION_RECURSION_LIMIT { @@ -112,18 +111,12 @@ impl Expander { let macro_call = InFile::new(self.current_file_id, ¯o_call); - let resolver = |path: ModPath| -> Option { - if let Some(local_scope) = local_scope { - if let Some(def) = path.as_ident().and_then(|n| local_scope.get_legacy_macro(n)) { - return Some(def); - } - } - self.resolve_path_as_macro(db, &path) - }; + let resolver = + |path: ModPath| -> Option { self.resolve_path_as_macro(db, &path) }; let mut err = None; let call_id = - macro_call.as_call_id_with_errors(db, self.crate_def_map.krate(), resolver, &mut |e| { + macro_call.as_call_id_with_errors(db, self.def_map.krate(), resolver, &mut |e| { err.get_or_insert(e); }); let call_id = match call_id { @@ -204,7 +197,7 @@ impl Expander { } fn resolve_path_as_macro(&self, db: &dyn DefDatabase, path: &ModPath) -> Option { - self.crate_def_map + self.def_map .resolve_path(db, self.module.local_id, path, BuiltinShadowMode::Other) .0 .take_macros() diff --git a/crates/hir_def/src/body/lower.rs b/crates/hir_def/src/body/lower.rs index 209965fca..bc61730a7 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, sync::Arc}; +use std::{any::type_name, mem, 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, ConstLoc, ContainerId, DefWithBodyId, EnumLoc, FunctionLoc, Intern, ModuleDefId, - StaticLoc, StructLoc, TraitLoc, TypeAliasLoc, UnionLoc, + AdtId, BlockLoc, 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 empty_block(&mut self) -> ExprId { - self.alloc_expr_desugared(Expr::Block { statements: Vec::new(), tail: None, label: None }) + fn unit(&mut self) -> ExprId { + self.alloc_expr_desugared(Expr::Tuple { exprs: Vec::new() }) } 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.empty_block()), + expr: else_branch.unwrap_or_else(|| self.unit()), 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, Some(&self.body.item_scope), e); + let res = self.expander.enter_expand(self.db, e); match &res.err { Some(ExpandError::UnresolvedProcMacro) => { @@ -697,12 +697,27 @@ impl ExprCollector<'_> { } fn collect_block(&mut self, block: ast::BlockExpr) -> ExprId { - let syntax_node_ptr = AstPtr::new(&block.clone().into()); + 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); + 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)); - self.alloc_expr(Expr::Block { statements, tail, label: None }, syntax_node_ptr) + 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 } fn collect_stmts_items(&mut self, stmts: ast::AstChildren) { @@ -832,7 +847,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.crate_def_map.resolve_path( + let (resolved, _) = self.expander.def_map.resolve_path( self.db, self.expander.module.local_id, &name.clone().into(), diff --git a/crates/hir_def/src/data.rs b/crates/hir_def/src/data.rs index e7b7724f7..c2b0dc007 100644 --- a/crates/hir_def/src/data.rs +++ b/crates/hir_def/src/data.rs @@ -262,7 +262,7 @@ fn collect_items( let root = db.parse_or_expand(file_id).unwrap(); let call = ast_id_map.get(call.ast_id).to_node(&root); - if let Some((mark, mac)) = expander.enter_expand(db, None, call).value { + if let Some((mark, mac)) = expander.enter_expand(db, call).value { let src: InFile = expander.to_source(mac); let item_tree = db.item_tree(src.file_id); let iter = diff --git a/crates/hir_def/src/expr.rs b/crates/hir_def/src/expr.rs index 5be838f4a..4d72eaeaf 100644 --- a/crates/hir_def/src/expr.rs +++ b/crates/hir_def/src/expr.rs @@ -20,6 +20,7 @@ use crate::{ builtin_type::{BuiltinFloat, BuiltinInt}, path::{GenericArgs, Path}, type_ref::{Mutability, Rawness, TypeRef}, + BlockId, }; pub type ExprId = Idx; @@ -56,6 +57,7 @@ pub enum Expr { else_branch: Option, }, Block { + id: BlockId, statements: Vec, tail: Option, label: Option, diff --git a/crates/hir_def/src/item_tree.rs b/crates/hir_def/src/item_tree.rs index 42d9f0947..4bde67649 100644 --- a/crates/hir_def/src/item_tree.rs +++ b/crates/hir_def/src/item_tree.rs @@ -24,7 +24,7 @@ use la_arena::{Arena, Idx, RawIdx}; use profile::Count; use rustc_hash::FxHashMap; use smallvec::SmallVec; -use syntax::{ast, match_ast}; +use syntax::{ast, match_ast, SyntaxKind}; use test_utils::mark; use crate::{ @@ -80,6 +80,10 @@ impl ItemTree { pub(crate) fn item_tree_query(db: &dyn DefDatabase, file_id: HirFileId) -> Arc { let _p = profile::span("item_tree_query").detail(|| format!("{:?}", file_id)); let syntax = if let Some(node) = db.parse_or_expand(file_id) { + if node.kind() == SyntaxKind::ERROR { + // FIXME: not 100% sure why these crop up, but return an empty tree to avoid a panic + return Default::default(); + } node } else { return Default::default(); diff --git a/crates/hir_ty/src/infer/expr.rs b/crates/hir_ty/src/infer/expr.rs index d7351d212..12f1591c8 100644 --- a/crates/hir_ty/src/infer/expr.rs +++ b/crates/hir_ty/src/infer/expr.rs @@ -137,7 +137,7 @@ impl<'a> InferenceContext<'a> { self.coerce_merge_branch(&then_ty, &else_ty) } - Expr::Block { statements, tail, label } => match label { + Expr::Block { statements, tail, label, id: _ } => match label { Some(_) => { let break_ty = self.table.new_type_var(); self.breakables.push(BreakableContext { -- cgit v1.2.3