) -> Span {
span.fresh_expansion(ExpnData {
allow_internal_unstable,
- ..ExpnData::default(ExpnKind::Desugaring(reason), span, self.sess.edition())
+ ..ExpnData::default(ExpnKind::Desugaring(reason), span, self.sess.edition(), None)
})
}
use rustc_errors::{DiagnosticBuilder, ErrorReported};
use rustc_parse::{self, parser, MACRO_ARGUMENTS};
use rustc_session::parse::ParseSess;
+use rustc_span::def_id::DefId;
use rustc_span::edition::Edition;
use rustc_span::hygiene::{AstPass, ExpnData, ExpnId, ExpnKind};
use rustc_span::source_map::SourceMap;
SyntaxExtension::default(SyntaxExtensionKind::NonMacroAttr { mark_used }, edition)
}
- pub fn expn_data(&self, parent: ExpnId, call_site: Span, descr: Symbol) -> ExpnData {
+ pub fn expn_data(
+ &self,
+ parent: ExpnId,
+ call_site: Span,
+ descr: Symbol,
+ macro_def_id: Option<DefId>,
+ ) -> ExpnData {
ExpnData {
kind: ExpnKind::Macro(self.macro_kind(), descr),
parent,
allow_internal_unsafe: self.allow_internal_unsafe,
local_inner_macros: self.local_inner_macros,
edition: self.edition,
+ macro_def_id,
}
}
}
ExpnKind::Macro(MacroKind::Attr, sym::derive),
item.span(),
self.cx.parse_sess.edition,
+ None,
)
}),
_ => None,
}
crate fn macro_def_scope(&mut self, expn_id: ExpnId) -> Module<'a> {
- let def_id = match self.macro_defs.get(&expn_id) {
- Some(def_id) => *def_id,
+ let def_id = match expn_id.expn_data().macro_def_id {
+ Some(def_id) => def_id,
None => return self.ast_transform_scopes.get(&expn_id).unwrap_or(&self.graph_root),
};
if let Some(id) = self.definitions.as_local_node_id(def_id) {
dummy_ext_bang: Lrc<SyntaxExtension>,
dummy_ext_derive: Lrc<SyntaxExtension>,
non_macro_attrs: [Lrc<SyntaxExtension>; 2],
- macro_defs: FxHashMap<ExpnId, DefId>,
local_macro_def_scopes: FxHashMap<NodeId, Module<'a>>,
ast_transform_scopes: FxHashMap<ExpnId, Module<'a>>,
unused_macros: NodeMap<Span>,
let mut invocation_parent_scopes = FxHashMap::default();
invocation_parent_scopes.insert(ExpnId::root(), ParentScope::module(graph_root));
- let mut macro_defs = FxHashMap::default();
- macro_defs.insert(ExpnId::root(), root_def_id);
-
let features = session.features_untracked();
let non_macro_attr =
|mark_used| Lrc::new(SyntaxExtension::non_macro_attr(mark_used, session.edition()));
invocation_parent_scopes,
output_macro_rules_scopes: Default::default(),
helper_attrs: Default::default(),
- macro_defs,
local_macro_def_scopes: FxHashMap::default(),
name_already_seen: FxHashMap::default(),
potentially_unused_imports: Vec::new(),
fn macro_def(&self, mut ctxt: SyntaxContext) -> DefId {
loop {
- match self.macro_defs.get(&ctxt.outer_expn()) {
- Some(&def_id) => return def_id,
+ match ctxt.outer_expn().expn_data().macro_def_id {
+ Some(def_id) => return def_id,
None => ctxt.remove_mark(),
};
}
&& module.expansion.is_descendant_of(parent.expansion)
{
// The macro is a proc macro derive
- if let Some(&def_id) = self.macro_defs.get(&module.expansion) {
+ if let Some(def_id) = module.expansion.expn_data().macro_def_id {
if let Some(ext) = self.get_macro_by_def_id(def_id) {
if !ext.is_builtin && ext.macro_kind() == MacroKind::Derive {
if parent.expansion.outer_expn_is_descendant_of(span.ctxt()) {
call_site,
self.session.edition(),
features.into(),
+ None,
)));
let parent_scope = if let Some(module_id) = parent_module_id {
let (ext, res) = self.smart_resolve_macro_path(path, kind, parent_scope, force)?;
let span = invoc.span();
- invoc_id.set_expn_data(ext.expn_data(parent_scope.expansion, span, fast_print_path(path)));
-
- if let Res::Def(_, def_id) = res {
+ invoc_id.set_expn_data(ext.expn_data(
+ parent_scope.expansion,
+ span,
+ fast_print_path(path),
+ res.opt_def_id(),
+ ));
+
+ if let Res::Def(_, _) = res {
if after_derive {
self.session.span_err(span, "macro attributes must be placed before `#[derive]`");
}
- self.macro_defs.insert(invoc_id, def_id);
let normal_module_def_id = self.macro_def_scope(invoc_id).normal_ancestor_id;
self.definitions.add_parent_module_of_macro_def(invoc_id, normal_module_def_id);
}
// because getting it wrong can lead to nested `HygieneData::with` calls that
// trigger runtime aborts. (Fortunately these are obvious and easy to fix.)
+use crate::def_id::{DefId, CRATE_DEF_INDEX};
use crate::edition::Edition;
use crate::symbol::{kw, sym, Symbol};
use crate::GLOBALS;
impl HygieneData {
crate fn new(edition: Edition) -> Self {
HygieneData {
- expn_data: vec![Some(ExpnData::default(ExpnKind::Root, DUMMY_SP, edition))],
+ expn_data: vec![Some(ExpnData::default(
+ ExpnKind::Root,
+ DUMMY_SP,
+ edition,
+ Some(DefId::local(CRATE_DEF_INDEX)),
+ ))],
syntax_context_data: vec![SyntaxContextData {
outer_expn: ExpnId::root(),
outer_transparency: Transparency::Opaque,
pub local_inner_macros: bool,
/// Edition of the crate in which the macro is defined.
pub edition: Edition,
+ /// The `DefId` of the macro being invoked,
+ /// if this `ExpnData` corresponds to a macro invocation
+ pub macro_def_id: Option<DefId>,
}
impl ExpnData {
/// Constructs expansion data with default properties.
- pub fn default(kind: ExpnKind, call_site: Span, edition: Edition) -> ExpnData {
+ pub fn default(
+ kind: ExpnKind,
+ call_site: Span,
+ edition: Edition,
+ macro_def_id: Option<DefId>,
+ ) -> ExpnData {
ExpnData {
kind,
parent: ExpnId::root(),
allow_internal_unsafe: false,
local_inner_macros: false,
edition,
+ macro_def_id,
}
}
call_site: Span,
edition: Edition,
allow_internal_unstable: Lrc<[Symbol]>,
+ macro_def_id: Option<DefId>,
) -> ExpnData {
ExpnData {
allow_internal_unstable: Some(allow_internal_unstable),
- ..ExpnData::default(kind, call_site, edition)
+ ..ExpnData::default(kind, call_site, edition, macro_def_id)
}
}