From fac7b0e252ab305f5c8d69b04c46c587ee021aa9 Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Thu, 11 Jun 2020 12:08:24 +0200 Subject: Don't guess macro expansion crate --- crates/ra_hir_expand/src/builtin_derive.rs | 28 +++++++++++--------------- crates/ra_hir_expand/src/builtin_macro.rs | 17 ++++++++-------- crates/ra_hir_expand/src/eager.rs | 32 ++++++++++++++++++++++-------- crates/ra_hir_expand/src/lib.rs | 16 ++++++++------- 4 files changed, 54 insertions(+), 39 deletions(-) (limited to 'crates/ra_hir_expand/src') diff --git a/crates/ra_hir_expand/src/builtin_derive.rs b/crates/ra_hir_expand/src/builtin_derive.rs index 967d1f3a1..26b667b55 100644 --- a/crates/ra_hir_expand/src/builtin_derive.rs +++ b/crates/ra_hir_expand/src/builtin_derive.rs @@ -8,8 +8,7 @@ use ra_syntax::{ match_ast, }; -use crate::db::AstDatabase; -use crate::{guess_crate, name, quote, LazyMacroId, MacroCallId, MacroDefId, MacroDefKind}; +use crate::{db::AstDatabase, name, quote, LazyMacroId, MacroDefId, MacroDefKind}; macro_rules! register_builtin { ( $($trait:ident => $expand:ident),* ) => { @@ -156,17 +155,8 @@ fn expand_simple_derive( fn find_builtin_crate(db: &dyn AstDatabase, id: LazyMacroId) -> tt::TokenTree { // FIXME: make hygiene works for builtin derive macro // such that $crate can be used here. - - let m: MacroCallId = id.into(); - let file_id = m.as_file().original_file(db); let cg = db.crate_graph(); - let krate = match guess_crate(db, file_id) { - Some(krate) => krate, - None => { - let tt = quote! { core }; - return tt.token_trees[0].clone(); - } - }; + let krate = db.lookup_intern_macro(id).krate; // XXX // All crates except core itself should have a dependency on core, @@ -263,10 +253,12 @@ fn partial_ord_expand( #[cfg(test)] mod tests { - use super::*; - use crate::{test_db::TestDB, AstId, MacroCallId, MacroCallKind, MacroCallLoc}; use name::{known, Name}; - use ra_db::{fixture::WithFixture, SourceDatabase}; + use ra_db::{fixture::WithFixture, CrateId, SourceDatabase}; + + use crate::{test_db::TestDB, AstId, MacroCallId, MacroCallKind, MacroCallLoc}; + + use super::*; fn expand_builtin_derive(s: &str, name: Name) -> String { let def = find_builtin_derive(&name).unwrap(); @@ -290,7 +282,11 @@ mod tests { let attr_id = AstId::new(file_id.into(), ast_id_map.ast_id(&items[0])); - let loc = MacroCallLoc { def, kind: MacroCallKind::Attr(attr_id, name.to_string()) }; + let loc = MacroCallLoc { + def, + krate: CrateId(0), + kind: MacroCallKind::Attr(attr_id, name.to_string()), + }; let id: MacroCallId = db.intern_macro(loc).into(); let parsed = db.parse_or_expand(id.as_file()).unwrap(); diff --git a/crates/ra_hir_expand/src/builtin_macro.rs b/crates/ra_hir_expand/src/builtin_macro.rs index 93da3f149..b50eb347c 100644 --- a/crates/ra_hir_expand/src/builtin_macro.rs +++ b/crates/ra_hir_expand/src/builtin_macro.rs @@ -1,15 +1,14 @@ //! Builtin macro -use crate::db::AstDatabase; use crate::{ - ast::{self, AstToken, HasStringValue}, - name, AstId, CrateId, MacroDefId, MacroDefKind, TextSize, + db::AstDatabase, name, quote, AstId, CrateId, EagerMacroId, LazyMacroId, MacroCallId, + MacroDefId, MacroDefKind, TextSize, }; -use crate::{guess_crate, quote, EagerMacroId, LazyMacroId, MacroCallId}; use either::Either; use mbe::parse_to_token_tree; use ra_db::FileId; use ra_parser::FragmentKind; +use ra_syntax::ast::{self, AstToken, HasStringValue}; macro_rules! register_builtin { ( LAZY: $(($name:ident, $kind: ident) => $expand:ident),* , EAGER: $(($e_name:ident, $e_kind: ident) => $e_expand:ident),* ) => { @@ -333,9 +332,7 @@ fn include_expand( } fn get_env_inner(db: &dyn AstDatabase, arg_id: EagerMacroId, key: &str) -> Option { - let call_id: MacroCallId = arg_id.into(); - let original_file = call_id.as_file().original_file(db); - let krate = guess_crate(db, original_file)?; + let krate = db.lookup_intern_eager_expansion(arg_id).krate; db.crate_graph()[krate].env.get(key) } @@ -394,6 +391,7 @@ mod tests { let expander = find_by_name(¯o_calls[0].name().unwrap().as_name()).unwrap(); + let krate = CrateId(0); let file_id = match expander { Either::Left(expander) => { // the first one should be a macro_rules @@ -406,6 +404,7 @@ mod tests { let loc = MacroCallLoc { def, + krate, kind: MacroCallKind::FnLike(AstId::new( file_id.into(), ast_id_map.ast_id(¯o_calls[1]), @@ -418,7 +417,7 @@ mod tests { Either::Right(expander) => { // the first one should be a macro_rules let def = MacroDefId { - krate: Some(CrateId(0)), + krate: Some(krate), ast_id: Some(AstId::new(file_id.into(), ast_id_map.ast_id(¯o_calls[0]))), kind: MacroDefKind::BuiltInEager(expander), local_inner: false, @@ -432,6 +431,7 @@ mod tests { def, fragment: FragmentKind::Expr, subtree: Arc::new(parsed_args.clone()), + krate, file_id: file_id.into(), } }); @@ -441,6 +441,7 @@ mod tests { def, fragment, subtree: Arc::new(subtree), + krate, file_id: file_id.into(), }; diff --git a/crates/ra_hir_expand/src/eager.rs b/crates/ra_hir_expand/src/eager.rs index 932f47c30..302d2b3e0 100644 --- a/crates/ra_hir_expand/src/eager.rs +++ b/crates/ra_hir_expand/src/eager.rs @@ -25,12 +25,14 @@ use crate::{ EagerCallLoc, EagerMacroId, InFile, MacroCallId, MacroCallKind, MacroDefId, MacroDefKind, }; +use ra_db::CrateId; use ra_parser::FragmentKind; use ra_syntax::{algo::SyntaxRewriter, SyntaxNode}; use std::sync::Arc; pub fn expand_eager_macro( db: &dyn AstDatabase, + krate: CrateId, macro_call: InFile, def: MacroDefId, resolver: &dyn Fn(ast::Path) -> Option, @@ -47,6 +49,7 @@ pub fn expand_eager_macro( def, fragment: FragmentKind::Expr, subtree: Arc::new(parsed_args.clone()), + krate, file_id: macro_call.file_id, } }); @@ -56,14 +59,20 @@ pub fn expand_eager_macro( let result = eager_macro_recur( db, InFile::new(arg_file_id.as_file(), parsed_args.syntax_node()), + krate, resolver, )?; let subtree = to_subtree(&result)?; if let MacroDefKind::BuiltInEager(eager) = def.kind { let (subtree, fragment) = eager.expand(db, arg_id, &subtree).ok()?; - let eager = - EagerCallLoc { def, fragment, subtree: Arc::new(subtree), file_id: macro_call.file_id }; + let eager = EagerCallLoc { + def, + fragment, + subtree: Arc::new(subtree), + krate, + file_id: macro_call.file_id, + }; Some(db.intern_eager_expansion(eager)) } else { @@ -81,11 +90,12 @@ fn lazy_expand( db: &dyn AstDatabase, def: &MacroDefId, macro_call: InFile, + krate: CrateId, ) -> Option> { let ast_id = db.ast_id_map(macro_call.file_id).ast_id(¯o_call.value); let id: MacroCallId = - def.as_lazy_macro(db, MacroCallKind::FnLike(macro_call.with_value(ast_id))).into(); + def.as_lazy_macro(db, krate, MacroCallKind::FnLike(macro_call.with_value(ast_id))).into(); db.parse_or_expand(id.as_file()).map(|node| InFile::new(id.as_file(), node)) } @@ -93,6 +103,7 @@ fn lazy_expand( fn eager_macro_recur( db: &dyn AstDatabase, curr: InFile, + krate: CrateId, macro_resolver: &dyn Fn(ast::Path) -> Option, ) -> Option { let original = curr.value.clone(); @@ -105,18 +116,23 @@ fn eager_macro_recur( let def: MacroDefId = macro_resolver(child.path()?)?; let insert = match def.kind { MacroDefKind::BuiltInEager(_) => { - let id: MacroCallId = - expand_eager_macro(db, curr.with_value(child.clone()), def, macro_resolver)? - .into(); + let id: MacroCallId = expand_eager_macro( + db, + krate, + curr.with_value(child.clone()), + def, + macro_resolver, + )? + .into(); db.parse_or_expand(id.as_file())? } MacroDefKind::Declarative | MacroDefKind::BuiltIn(_) | MacroDefKind::BuiltInDerive(_) | MacroDefKind::CustomDerive(_) => { - let expanded = lazy_expand(db, &def, curr.with_value(child.clone()))?; + let expanded = lazy_expand(db, &def, curr.with_value(child.clone()), krate)?; // replace macro inside - eager_macro_recur(db, expanded, macro_resolver)? + eager_macro_recur(db, expanded, krate, macro_resolver)? } }; diff --git a/crates/ra_hir_expand/src/lib.rs b/crates/ra_hir_expand/src/lib.rs index dc4d7f000..5eac2605b 100644 --- a/crates/ra_hir_expand/src/lib.rs +++ b/crates/ra_hir_expand/src/lib.rs @@ -209,8 +209,13 @@ pub struct MacroDefId { } impl MacroDefId { - pub fn as_lazy_macro(self, db: &dyn db::AstDatabase, kind: MacroCallKind) -> LazyMacroId { - db.intern_macro(MacroCallLoc { def: self, kind }) + pub fn as_lazy_macro( + self, + db: &dyn db::AstDatabase, + krate: CrateId, + kind: MacroCallKind, + ) -> LazyMacroId { + db.intern_macro(MacroCallLoc { def: self, krate, kind }) } } @@ -227,6 +232,7 @@ pub enum MacroDefKind { #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct MacroCallLoc { pub(crate) def: MacroDefId, + pub(crate) krate: CrateId, pub(crate) kind: MacroCallKind, } @@ -274,6 +280,7 @@ pub struct EagerCallLoc { pub(crate) def: MacroDefId, pub(crate) fragment: FragmentKind, pub(crate) subtree: Arc, + pub(crate) krate: CrateId, pub(crate) file_id: HirFileId, } @@ -424,8 +431,3 @@ impl InFile { self.with_value(self.value.syntax()) } } - -// FIXME: this is obviously wrong, there shouldn't be any guesing here -fn guess_crate(db: &dyn db::AstDatabase, file_id: FileId) -> Option { - db.relevant_crates(file_id).iter().next().copied() -} -- cgit v1.2.3