From 5270bca5f72fa65f0515be776e06d3d6a4d1efca Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Tue, 26 Mar 2019 13:09:39 +0300 Subject: store macro def inside macro id This solves the problem of "macro expansion can't call into name resolution, because name resolution calls back into macro expansion" Because we store macro def as a part of call id, macro expansion just knows the def! --- crates/ra_hir/src/code_model_impl/module.rs | 2 +- crates/ra_hir/src/db.rs | 9 ++- crates/ra_hir/src/ids.rs | 24 +++++-- crates/ra_hir/src/nameres.rs | 11 +-- crates/ra_hir/src/nameres/collector.rs | 93 +++++++++----------------- crates/ra_hir/src/nameres/raw.rs | 30 ++------- crates/ra_hir/src/nameres/tests/incremental.rs | 23 +++---- 7 files changed, 73 insertions(+), 119 deletions(-) (limited to 'crates/ra_hir') diff --git a/crates/ra_hir/src/code_model_impl/module.rs b/crates/ra_hir/src/code_model_impl/module.rs index 14237060c..790e2b80f 100644 --- a/crates/ra_hir/src/code_model_impl/module.rs +++ b/crates/ra_hir/src/code_model_impl/module.rs @@ -76,7 +76,7 @@ impl Module { import: ImportId, ) -> TreeArc { let (file_id, source) = self.definition_source(db); - let (_, source_map) = db.raw_items_with_source_map(file_id.original_file(db)); + let (_, source_map) = db.raw_items_with_source_map(file_id); source_map.get(&source, import) } diff --git a/crates/ra_hir/src/db.rs b/crates/ra_hir/src/db.rs index 143919cdc..6eb916149 100644 --- a/crates/ra_hir/src/db.rs +++ b/crates/ra_hir/src/db.rs @@ -1,7 +1,7 @@ use std::sync::Arc; use ra_syntax::{SyntaxNode, TreeArc, SourceFile}; -use ra_db::{SourceDatabase, salsa, FileId}; +use ra_db::{SourceDatabase, salsa}; use crate::{ HirFileId, SourceFileItems, SourceItemId, Crate, Module, HirInterner, @@ -38,10 +38,13 @@ pub trait DefDatabase: SourceDatabase + AsRef { fn file_item(&self, source_item_id: SourceItemId) -> TreeArc; #[salsa::invoke(RawItems::raw_items_query)] - fn raw_items(&self, file_id: FileId) -> Arc; + fn raw_items(&self, file_id: HirFileId) -> Arc; #[salsa::invoke(RawItems::raw_items_with_source_map_query)] - fn raw_items_with_source_map(&self, file_id: FileId) -> (Arc, Arc); + fn raw_items_with_source_map( + &self, + file_id: HirFileId, + ) -> (Arc, Arc); #[salsa::invoke(CrateDefMap::crate_def_map_query)] fn crate_def_map(&self, krate: Crate) -> Arc; diff --git a/crates/ra_hir/src/ids.rs b/crates/ra_hir/src/ids.rs index 18401f865..cf0566308 100644 --- a/crates/ra_hir/src/ids.rs +++ b/crates/ra_hir/src/ids.rs @@ -7,6 +7,7 @@ use std::{ use ra_db::{LocationInterner, FileId}; use ra_syntax::{TreeArc, SyntaxNode, SourceFile, AstNode, SyntaxNodePtr, ast}; use ra_arena::{Arena, RawId, ArenaId, impl_arena_id}; +use mbe::MacroRules; use crate::{ Module, @@ -100,10 +101,7 @@ fn parse_macro(db: &impl DefDatabase, macro_call_id: MacroCallId) -> Option for HirFileId { } } +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] +pub(crate) enum MacroDefId { + MacroByExample { source_item_id: SourceItemId }, +} + +fn macro_def_query(db: &impl DefDatabase, id: MacroDefId) -> Option> { + let syntax_node = match id { + MacroDefId::MacroByExample { source_item_id } => db.file_item(source_item_id), + }; + let macro_call = ast::MacroCall::cast(&syntax_node).unwrap(); + let arg = macro_call.token_tree()?; + let (tt, _) = mbe::ast_to_token_tree(arg)?; + let rules = MacroRules::parse(&tt).ok()?; + Some(Arc::new(rules)) +} + /// `MacroCallId` identifies a particular macro invocation, like /// `println!("Hello, {}", world)`. #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] @@ -134,7 +148,7 @@ impl_arena_id!(MacroCallId); #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct MacroCallLoc { - pub(crate) module: Module, + pub(crate) def: MacroDefId, pub(crate) source_item_id: SourceItemId, } diff --git a/crates/ra_hir/src/nameres.rs b/crates/ra_hir/src/nameres.rs index c34aa4b50..93c11f271 100644 --- a/crates/ra_hir/src/nameres.rs +++ b/crates/ra_hir/src/nameres.rs @@ -63,7 +63,7 @@ use test_utils::tested_by; use crate::{ ModuleDef, Name, Crate, Module, DefDatabase, Path, PathKind, HirFileId, Trait, - ids::{SourceItemId, SourceFileItemId, MacroCallId}, + ids::{SourceItemId, SourceFileItemId, MacroCallId, MacroDefId}, diagnostics::DiagnosticSink, nameres::diagnostics::DefDiagnostic, }; @@ -85,7 +85,7 @@ pub struct CrateDefMap { root: CrateModuleId, modules: Arena, macros: Arena, - public_macros: FxHashMap, + public_macros: FxHashMap, macro_resolutions: FxHashMap, diagnostics: Vec, } @@ -238,13 +238,6 @@ impl CrateDefMap { self.diagnostics.iter().for_each(|it| it.add_to(db, module, sink)) } - pub(crate) fn resolve_macro( - &self, - macro_call_id: MacroCallId, - ) -> Option<(Crate, CrateMacroId)> { - self.macro_resolutions.get(¯o_call_id).map(|&it| it) - } - pub(crate) fn find_module_by_source( &self, file_id: HirFileId, diff --git a/crates/ra_hir/src/nameres/collector.rs b/crates/ra_hir/src/nameres/collector.rs index 8830b4624..89300d2ec 100644 --- a/crates/ra_hir/src/nameres/collector.rs +++ b/crates/ra_hir/src/nameres/collector.rs @@ -6,15 +6,15 @@ use ra_db::FileId; use crate::{ Function, Module, Struct, Enum, Const, Static, Trait, TypeAlias, - DefDatabase, HirFileId, Name, Path, Crate, + DefDatabase, HirFileId, Name, Path, KnownName, nameres::{ Resolution, PerNs, ModuleDef, ReachedFixedPoint, ResolveMode, - CrateDefMap, CrateModuleId, ModuleData, CrateMacroId, + CrateDefMap, CrateModuleId, ModuleData, diagnostics::DefDiagnostic, raw, }, - ids::{AstItemDef, LocationCtx, MacroCallLoc, SourceItemId, MacroCallId}, + ids::{AstItemDef, LocationCtx, MacroCallLoc, SourceItemId, MacroCallId, MacroDefId}, }; pub(super) fn collect_defs(db: &impl DefDatabase, mut def_map: CrateDefMap) -> CrateDefMap { @@ -51,8 +51,8 @@ struct DefCollector { def_map: CrateDefMap, glob_imports: FxHashMap>, unresolved_imports: Vec<(CrateModuleId, raw::ImportId, raw::ImportData)>, - unexpanded_macros: Vec<(CrateModuleId, MacroCallId, Path, tt::Subtree)>, - global_macro_scope: FxHashMap, + unexpanded_macros: Vec<(CrateModuleId, SourceItemId, Path)>, + global_macro_scope: FxHashMap, } impl<'a, DB> DefCollector<&'a DB> @@ -62,7 +62,7 @@ where fn collect(&mut self) { let crate_graph = self.db.crate_graph(); let file_id = crate_graph.crate_root(self.def_map.krate.crate_id()); - let raw_items = self.db.raw_items(file_id); + let raw_items = self.db.raw_items(file_id.into()); let module_id = self.def_map.root; self.def_map.modules[module_id].definition = Some(file_id); ModCollector { @@ -93,14 +93,11 @@ where } } - fn define_macro(&mut self, name: Name, tt: &tt::Subtree, export: bool) { - if let Ok(rules) = mbe::MacroRules::parse(tt) { - let macro_id = self.def_map.macros.alloc(rules); - if export { - self.def_map.public_macros.insert(name.clone(), macro_id); - } - self.global_macro_scope.insert(name, macro_id); + fn define_macro(&mut self, name: Name, macro_id: MacroDefId, export: bool) { + if export { + self.def_map.public_macros.insert(name.clone(), macro_id); } + self.global_macro_scope.insert(name, macro_id); } fn resolve_imports(&mut self) -> ReachedFixedPoint { @@ -296,7 +293,7 @@ where let mut macros = std::mem::replace(&mut self.unexpanded_macros, Vec::new()); let mut resolved = Vec::new(); let mut res = ReachedFixedPoint::Yes; - macros.retain(|(module_id, call_id, path, tt)| { + macros.retain(|(module_id, source_item_id, path)| { if path.segments.len() != 2 { return true; } @@ -312,47 +309,24 @@ where res = ReachedFixedPoint::No; let def_map = self.db.crate_def_map(krate); if let Some(macro_id) = def_map.public_macros.get(&path.segments[1].name).cloned() { - resolved.push((*module_id, *call_id, (krate, macro_id), tt.clone())); + let call_id = + MacroCallLoc { def: macro_id, source_item_id: *source_item_id }.id(self.db); + resolved.push((*module_id, call_id)); } false }); - for (module_id, macro_call_id, macro_def_id, arg) in resolved { - self.collect_macro_expansion(module_id, macro_call_id, macro_def_id, arg); + for (module_id, macro_call_id) in resolved { + self.collect_macro_expansion(module_id, macro_call_id); } res } - fn collect_macro_expansion( - &mut self, - module_id: CrateModuleId, - macro_call_id: MacroCallId, - macro_def_id: (Crate, CrateMacroId), - macro_arg: tt::Subtree, - ) { - let (macro_krate, macro_id) = macro_def_id; - let dm; - let rules = if macro_krate == self.def_map.krate { - &self.def_map[macro_id] - } else { - dm = self.db.crate_def_map(macro_krate); - &dm[macro_id] - }; - if let Ok(expansion) = rules.expand(¯o_arg) { - self.def_map.macro_resolutions.insert(macro_call_id, macro_def_id); - // XXX: this **does not** go through a database, because we can't - // identify macro_call without adding the whole state of name resolution - // as a parameter to the query. - // - // So, we run the queries "manually" and we must ensure that - // `db.hir_parse(macro_call_id)` returns the same source_file. - let file_id: HirFileId = macro_call_id.into(); - let source_file = mbe::token_tree_to_ast_item_list(&expansion); - - let raw_items = raw::RawItems::from_source_file(&source_file, file_id); - ModCollector { def_collector: &mut *self, file_id, module_id, raw_items: &raw_items } - .collect(raw_items.items()) - } + fn collect_macro_expansion(&mut self, module_id: CrateModuleId, macro_call_id: MacroCallId) { + let file_id: HirFileId = macro_call_id.into(); + let raw_items = self.db.raw_items(file_id); + ModCollector { def_collector: &mut *self, file_id, module_id, raw_items: &raw_items } + .collect(raw_items.items()) } fn finish(self) -> CrateDefMap { @@ -412,7 +386,7 @@ where Ok(file_id) => { let module_id = self.push_child_module(name.clone(), source_item_id, Some(file_id)); - let raw_items = self.def_collector.db.raw_items(file_id); + let raw_items = self.def_collector.db.raw_items(file_id.into()); ModCollector { def_collector: &mut *self.def_collector, module_id, @@ -484,38 +458,33 @@ where // Case 1: macro rules, define a macro in crate-global mutable scope if is_macro_rules(&mac.path) { if let Some(name) = &mac.name { - self.def_collector.define_macro(name.clone(), &mac.arg, mac.export) + let macro_id = MacroDefId::MacroByExample { + source_item_id: mac.source_item_id.with_file_id(self.file_id), + }; + self.def_collector.define_macro(name.clone(), macro_id, mac.export) } return; } let source_item_id = SourceItemId { file_id: self.file_id, item_id: mac.source_item_id }; - let macro_call_id = MacroCallLoc { - module: Module { krate: self.def_collector.def_map.krate, module_id: self.module_id }, - source_item_id, - } - .id(self.def_collector.db); // Case 2: try to expand macro_rules from this crate, triggering // recursive item collection. if let Some(¯o_id) = mac.path.as_ident().and_then(|name| self.def_collector.global_macro_scope.get(name)) { - self.def_collector.collect_macro_expansion( - self.module_id, - macro_call_id, - (self.def_collector.def_map.krate, macro_id), - mac.arg.clone(), - ); + let macro_call_id = + MacroCallLoc { def: macro_id, source_item_id }.id(self.def_collector.db); + + self.def_collector.collect_macro_expansion(self.module_id, macro_call_id); return; } // Case 3: path to a macro from another crate, expand during name resolution self.def_collector.unexpanded_macros.push(( self.module_id, - macro_call_id, + source_item_id, mac.path.clone(), - mac.arg.clone(), )) } } diff --git a/crates/ra_hir/src/nameres/raw.rs b/crates/ra_hir/src/nameres/raw.rs index f8ba398ec..7a516e556 100644 --- a/crates/ra_hir/src/nameres/raw.rs +++ b/crates/ra_hir/src/nameres/raw.rs @@ -4,7 +4,6 @@ use std::{ }; use test_utils::tested_by; -use ra_db::FileId; use ra_arena::{Arena, impl_arena_id, RawId, map::ArenaMap}; use ra_syntax::{ AstNode, SourceFile, AstPtr, TreeArc, @@ -47,20 +46,20 @@ impl ImportSourceMap { } impl RawItems { - pub(crate) fn raw_items_query(db: &impl DefDatabase, file_id: FileId) -> Arc { + pub(crate) fn raw_items_query(db: &impl DefDatabase, file_id: HirFileId) -> Arc { db.raw_items_with_source_map(file_id).0 } pub(crate) fn raw_items_with_source_map_query( db: &impl DefDatabase, - file_id: FileId, + file_id: HirFileId, ) -> (Arc, Arc) { let mut collector = RawItemsCollector { raw_items: RawItems::default(), source_file_items: db.file_items(file_id.into()), source_map: ImportSourceMap::default(), }; - let source_file = db.parse(file_id); + let source_file = db.hir_parse(file_id); collector.process_module(None, &*source_file); (Arc::new(collector.raw_items), Arc::new(collector.source_map)) } @@ -68,19 +67,6 @@ impl RawItems { pub(crate) fn items(&self) -> &[RawItem] { &self.items } - - // We can't use queries during name resolution for fear of cycles, so this - // is a query-less variant of the above function. - pub(crate) fn from_source_file(source_file: &SourceFile, file_id: HirFileId) -> RawItems { - let source_file_items = SourceFileItems::from_source_file(source_file, file_id); - let mut collector = RawItemsCollector { - raw_items: RawItems::default(), - source_file_items: Arc::new(source_file_items), - source_map: ImportSourceMap::default(), - }; - collector.process_module(None, &*source_file); - collector.raw_items - } } impl Index for RawItems { @@ -173,7 +159,6 @@ pub(crate) struct MacroData { pub(crate) source_item_id: SourceFileItemId, pub(crate) path: Path, pub(crate) name: Option, - pub(crate) arg: tt::Subtree, pub(crate) export: bool, } @@ -291,18 +276,15 @@ impl RawItemsCollector { } fn add_macro(&mut self, current_module: Option, m: &ast::MacroCall) { - let (path, arg) = match ( - m.path().and_then(Path::from_ast), - m.token_tree().and_then(mbe::ast_to_token_tree), - ) { - (Some(path), Some((token_tree, _token_map))) => (path, token_tree), + let path = match m.path().and_then(Path::from_ast) { + Some(it) => it, _ => return, }; let name = m.name().map(|it| it.as_name()); let source_item_id = self.source_file_items.id_of_unchecked(m.syntax()); let export = m.has_atom_attr("macro_export"); - let m = self.raw_items.macros.alloc(MacroData { source_item_id, path, arg, name, export }); + let m = self.raw_items.macros.alloc(MacroData { source_item_id, path, name, export }); self.push_item(current_module, RawItem::Macro(m)); } diff --git a/crates/ra_hir/src/nameres/tests/incremental.rs b/crates/ra_hir/src/nameres/tests/incremental.rs index 698781923..a059634e2 100644 --- a/crates/ra_hir/src/nameres/tests/incremental.rs +++ b/crates/ra_hir/src/nameres/tests/incremental.rs @@ -90,34 +90,27 @@ fn adding_inner_items_should_not_invalidate_def_map() { ); } -// It would be awesome to make this work, but it's unclear how #[test] -#[ignore] -fn typing_inside_a_function_inside_a_macro_should_not_invalidate_def_map() { +fn typing_inside_a_macro_should_not_invalidate_def_map() { check_def_map_is_not_recomputed( " //- /lib.rs + macro_rules! m { + ($ident:ident) => { + struct Foo; + } + } 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 } - } - } + m!(X); ", " - salsa::query_group! { - trait Baz { - fn foo() -> i32 { 92 } - } - } + m!(Y); ", ); } -- cgit v1.2.3