node_to_def_index: NodeMap<DefIndex>,
def_index_to_node: [Vec<ast::NodeId>; 2],
pub(super) node_to_hir_id: IndexVec<ast::NodeId, hir::HirId>,
- macro_def_scopes: FxHashMap<Mark, DefId>,
- expansions: FxHashMap<DefIndex, Mark>,
+ /// If `Mark` is an ID of some macro expansion,
+ /// then `DefId` is the normal module (`mod`) in which the expanded macro was defined.
+ parent_modules_of_macro_defs: FxHashMap<Mark, DefId>,
+ /// Item with a given `DefIndex` was defined during opaque macro expansion with ID `Mark`.
+ /// It can actually be defined during transparent macro expansions inside that opaque expansion,
+ /// but transparent expansions are ignored here.
+ opaque_expansions_that_defined: FxHashMap<DefIndex, Mark>,
next_disambiguator: FxHashMap<(DefIndex, DefPathData), u32>,
def_index_to_span: FxHashMap<DefIndex, Span>,
}
self.def_index_to_node[1].clone(),
],
node_to_hir_id: self.node_to_hir_id.clone(),
- macro_def_scopes: self.macro_def_scopes.clone(),
- expansions: self.expansions.clone(),
+ parent_modules_of_macro_defs: self.parent_modules_of_macro_defs.clone(),
+ opaque_expansions_that_defined: self.opaque_expansions_that_defined.clone(),
next_disambiguator: self.next_disambiguator.clone(),
def_index_to_span: self.def_index_to_span.clone(),
}
node_to_def_index: NodeMap(),
def_index_to_node: [vec![], vec![]],
node_to_hir_id: IndexVec::new(),
- macro_def_scopes: FxHashMap(),
- expansions: FxHashMap(),
+ parent_modules_of_macro_defs: FxHashMap(),
+ opaque_expansions_that_defined: FxHashMap(),
next_disambiguator: FxHashMap(),
def_index_to_span: FxHashMap(),
}
let expansion = expansion.modern();
if expansion != Mark::root() {
- self.expansions.insert(index, expansion);
+ self.opaque_expansions_that_defined.insert(index, expansion);
}
// The span is added if it isn't DUMMY_SP
self.node_to_hir_id = mapping;
}
- pub fn expansion(&self, index: DefIndex) -> Mark {
- self.expansions.get(&index).cloned().unwrap_or(Mark::root())
+ pub fn opaque_expansion_that_defined(&self, index: DefIndex) -> Mark {
+ self.opaque_expansions_that_defined.get(&index).cloned().unwrap_or(Mark::root())
}
- pub fn macro_def_scope(&self, mark: Mark) -> DefId {
- self.macro_def_scopes[&mark]
+ pub fn parent_module_of_macro_def(&self, mark: Mark) -> DefId {
+ self.parent_modules_of_macro_defs[&mark]
}
- pub fn add_macro_def_scope(&mut self, mark: Mark, scope: DefId) {
- self.macro_def_scopes.insert(mark, scope);
+ pub fn add_parent_module_of_macro_def(&mut self, mark: Mark, module: DefId) {
+ self.parent_modules_of_macro_defs.insert(mark, module);
}
}
}
pub fn adjust_ident(self, mut ident: Ident, scope: DefId, block: NodeId) -> (Ident, DefId) {
- let expansion = match scope.krate {
- LOCAL_CRATE => self.hir.definitions().expansion(scope.index),
+ ident = ident.modern();
+ let target_expansion = match scope.krate {
+ LOCAL_CRATE => self.hir.definitions().opaque_expansion_that_defined(scope.index),
_ => Mark::root(),
};
- ident = ident.modern();
- let scope = match ident.span.adjust(expansion) {
- Some(macro_def) => self.hir.definitions().macro_def_scope(macro_def),
+ let scope = match ident.span.adjust(target_expansion) {
+ Some(actual_expansion) =>
+ self.hir.definitions().parent_module_of_macro_def(actual_expansion),
None if block == DUMMY_NODE_ID => DefId::local(CRATE_DEF_INDEX), // Dummy DefId
None => self.hir.get_module_parent(block),
};