Skip to content

resolve: Remove MacroData #156236

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
petrochenkov wants to merge 2 commits into
base: main
Choose a base branch
from
Open

resolve: Remove MacroData #156236

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
c834e9f
resolve: Remove `MacroData`
petrochenkov May 6, 2026
503960c
resolve: Avoid some `Arc` cloning with syntax extensions
petrochenkov May 7, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
20 changes: 13 additions & 7 deletions compiler/rustc_expand/src/mbe/macro_rules.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -170,6 +170,7 @@ pub struct MacroRulesMacroExpander {
transparency: Transparency,
kinds: MacroKinds,
rules: Vec<MacroRule>,
macro_rules: bool,
}

impl MacroRulesMacroExpander {
Expand All @@ -189,6 +190,14 @@ impl MacroRulesMacroExpander {
self.kinds
}

pub fn nrules(&self) -> usize {
self.rules.len()
}

pub fn is_macro_rules(&self) -> bool {
self.macro_rules
}

pub fn expand_derive(
&self,
cx: &mut ExtCtxt<'_>,
Expand Down Expand Up @@ -714,13 +723,12 @@ pub fn compile_declarative_macro(
span: Span,
node_id: NodeId,
edition: Edition,
) -> (SyntaxExtension, usize) {
) -> SyntaxExtension {
let mk_syn_ext = |kind| {
let is_local = is_defined_in_current_crate(node_id);
SyntaxExtension::new(sess, kind, span, Vec::new(), edition, ident.name, attrs, is_local)
};
let dummy_syn_ext =
|guar| (mk_syn_ext(SyntaxExtensionKind::Bang(Arc::new(DummyBang(guar)))), 0);
let dummy_syn_ext = |guar| mk_syn_ext(SyntaxExtensionKind::Bang(Arc::new(DummyBang(guar))));

let macro_rules = macro_def.macro_rules;
let exp_sep = if macro_rules { exp!(Semi) } else { exp!(Comma) };
Expand Down Expand Up @@ -857,9 +865,6 @@ pub fn compile_declarative_macro(
return dummy_syn_ext(guar);
}

// Return the number of rules for unused rule linting, if this is a local macro.
let nrules = if is_defined_in_current_crate(node_id) { rules.len() } else { 0 };

let on_unmatch_args = find_attr!(
attrs,
OnUnmatchArgs { directive, .. } => directive.clone()
Expand All @@ -875,8 +880,9 @@ pub fn compile_declarative_macro(
on_unmatch_args,
transparency,
rules,
macro_rules,
};
(mk_syn_ext(SyntaxExtensionKind::MacroRules(Arc::new(exp))), nrules)
mk_syn_ext(SyntaxExtensionKind::MacroRules(Arc::new(exp)))
}

fn check_no_eof(sess: &Session, p: &Parser<'_>, msg: &'static str) -> Option<ErrorGuaranteed> {
Expand Down
32 changes: 16 additions & 16 deletions compiler/rustc_resolve/src/build_reduced_graph.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -14,7 +14,7 @@ use rustc_ast::{
TyAlias,
};
use rustc_attr_parsing::AttributeParser;
use rustc_expand::base::ResolverExpand;
use rustc_expand::base::{ResolverExpand, SyntaxExtension, SyntaxExtensionKind};
use rustc_hir::Attribute;
use rustc_hir::attrs::{AttributeKind, MacroUseArgs};
use rustc_hir::def::{self, *};
Expand All @@ -37,9 +37,8 @@ use crate::macros::{MacroRulesDecl, MacroRulesScope, MacroRulesScopeRef};
use crate::ref_mut::CmCell;
use crate::{
BindingKey, Decl, DeclData, DeclKind, DelayedVisResolutionError, ExternModule,
ExternPreludeEntry, Finalize, IdentKey, LocalModule, MacroData, Module, ModuleKind,
ModuleOrUniformRoot, ParentScope, PathResult, Res, Resolver, Segment, SyntaxExtension, Used,
VisResolutionError, errors,
ExternPreludeEntry, Finalize, IdentKey, LocalModule, Module, ModuleKind, ModuleOrUniformRoot,
ParentScope, PathResult, Res, Resolver, Segment, Used, VisResolutionError, errors,
};

impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
Expand Down Expand Up @@ -208,28 +207,28 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
}

/// Gets the `SyntaxExtension` corresponding to `res`.
pub(crate) fn get_macro(&self, res: Res) -> Option<&Arc<SyntaxExtension>> {
pub(crate) fn get_macro(&self, res: Res) -> Option<&'ra Arc<SyntaxExtension>> {
match res {
Res::Def(DefKind::Macro(..), def_id) => Some(&self.get_macro_by_def_id(def_id).ext),
Res::NonMacroAttr(_) => Some(&self.non_macro_attr),
Res::Def(DefKind::Macro(..), def_id) => Some(self.get_macro_by_def_id(def_id)),
Res::NonMacroAttr(_) => Some(self.non_macro_attr),
_ => None,
}
}

pub(crate) fn get_macro_by_def_id(&self, def_id: DefId) -> &'ra MacroData {
pub(crate) fn get_macro_by_def_id(&self, def_id: DefId) -> &'ra Arc<SyntaxExtension> {
// Local macros are always compiled.
match def_id.as_local() {
Some(local_def_id) => self.local_macro_map[&local_def_id],
None => *self.extern_macro_map.borrow_mut().entry(def_id).or_insert_with(|| {
None => self.extern_macro_map.borrow_mut().entry(def_id).or_insert_with(|| {
let loaded_macro = self.cstore().load_macro_untracked(self.tcx, def_id);
let macro_data = match loaded_macro {
let ext = match loaded_macro {
LoadedMacro::MacroDef { def, ident, attrs, span, edition } => {
self.compile_macro(&def, ident, &attrs, span, ast::DUMMY_NODE_ID, edition)
}
LoadedMacro::ProcMacro(ext) => MacroData::new(Arc::new(ext)),
LoadedMacro::ProcMacro(ext) => ext,
};

self.arenas.alloc_macro(macro_data)
self.arenas.alloc_macro(ext)
}),
}
}
Expand Down Expand Up @@ -1277,8 +1276,10 @@ impl<'a, 'ra, 'tcx> DefCollector<'a, 'ra, 'tcx> {
fn insert_unused_macro(&mut self, ident: Ident, def_id: LocalDefId, node_id: NodeId) {
if !ident.as_str().starts_with('_') {
self.r.unused_macros.insert(def_id, (node_id, ident));
let nrules = self.r.local_macro_map[&def_id].nrules;
self.r.unused_macro_rules.insert(node_id, (def_id, DenseBitSet::new_filled(nrules)));
if let SyntaxExtensionKind::MacroRules(mr) = &self.r.local_macro_map[&def_id].kind {
let value = (def_id, DenseBitSet::new_filled(mr.nrules()));
self.r.unused_macro_rules.insert(node_id, value);
}
}
}

Expand All @@ -1299,8 +1300,7 @@ impl<'a, 'ra, 'tcx> DefCollector<'a, 'ra, 'tcx> {
Some((macro_kind, ident, span)) => {
let macro_kinds = macro_kind.into();
let res = Res::Def(DefKind::Macro(macro_kinds), def_id.to_def_id());
let macro_data = MacroData::new(self.r.dummy_ext(macro_kind));
self.r.new_local_macro(def_id, macro_data);
self.r.local_macro_map.insert(def_id, self.r.dummy_ext(macro_kind));
self.r.proc_macro_stubs.insert(def_id);
(res, ident, span, false)
}
Expand Down
12 changes: 6 additions & 6 deletions compiler/rustc_resolve/src/def_collector.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -117,7 +117,7 @@ impl<'a, 'ra, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'ra, 'tcx> {
fn visit_item(&mut self, i: &'a Item) {
// Pick the def data. This need not be unique, but the more
// information we encapsulate into, the better
let mut opt_macro_data = None;
let mut opt_syn_ext = None;
let def_kind = match &i.kind {
ItemKind::Impl(i) => DefKind::Impl { of_trait: i.of_trait.is_some() },
ItemKind::ForeignMod(..) => DefKind::ForeignMod,
Expand Down Expand Up @@ -165,9 +165,9 @@ impl<'a, 'ra, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'ra, 'tcx> {
},
);

let macro_data = self.r.compile_macro(def, *ident, &attrs, i.span, i.id, edition);
let macro_kinds = macro_data.ext.macro_kinds();
opt_macro_data = Some(macro_data);
let ext = self.r.compile_macro(def, *ident, &attrs, i.span, i.id, edition);
let macro_kinds = ext.macro_kinds();
opt_syn_ext = Some(ext);
DefKind::Macro(macro_kinds)
}
ItemKind::GlobalAsm(..) => DefKind::GlobalAsm,
Expand All @@ -185,8 +185,8 @@ impl<'a, 'ra, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'ra, 'tcx> {
};
let feed = self.create_def(i.id, i.kind.ident().map(|ident| ident.name), def_kind, i.span);

if let Some(macro_data) = opt_macro_data {
self.r.new_local_macro(feed.def_id(), macro_data);
if let Some(ext) = opt_syn_ext {
self.r.local_macro_map.insert(feed.def_id(), self.r.arenas.alloc_macro(ext));
}

self.with_parent(feed.def_id(), |this| {
Expand Down
8 changes: 4 additions & 4 deletions compiler/rustc_resolve/src/diagnostics.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -1742,7 +1742,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
if let Some((def_id, unused_ident)) = unused_macro {
let scope = self.local_macro_def_scopes[&def_id];
let parent_nearest = parent_scope.module.nearest_parent_mod();
let unused_macro_kinds = self.local_macro_map[def_id].ext.macro_kinds();
let unused_macro_kinds = self.local_macro_map[def_id].macro_kinds();
if !unused_macro_kinds.contains(macro_kind.into()) {
match macro_kind {
MacroKind::Bang => {
Expand Down Expand Up @@ -1860,13 +1860,13 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
let mut all_attrs: UnordMap<Symbol, Vec<_>> = UnordMap::default();
// We're collecting these in a hashmap, and handle ordering the output further down.
#[allow(rustc::potential_query_instability)]
for (def_id, data) in self
for (def_id, ext) in self
.local_macro_map
.iter()
.map(|(local_id, data)| (local_id.to_def_id(), data))
.map(|(local_id, ext)| (local_id.to_def_id(), ext))
.chain(self.extern_macro_map.borrow().iter().map(|(id, d)| (*id, d)))
{
for helper_attr in &data.ext.helper_attrs {
for helper_attr in &ext.helper_attrs {
let item_name = self.tcx.item_name(def_id);
all_attrs.entry(*helper_attr).or_default().push(item_name);
if helper_attr == &ident.name {
Expand Down
2 changes: 1 addition & 1 deletion compiler/rustc_resolve/src/ident.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -271,7 +271,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
// The macro is a proc macro derive
&& let Some(def_id) = module.expansion.expn_data().macro_def_id
{
let ext = &self.get_macro_by_def_id(def_id).ext;
let ext = self.get_macro_by_def_id(def_id);
if ext.builtin_name.is_none()
&& ext.macro_kinds() == MacroKinds::DERIVE
&& parent.expansion.outer_expn_is_descendant_of(**ctxt)
Expand Down
5 changes: 4 additions & 1 deletion compiler/rustc_resolve/src/imports.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -12,6 +12,7 @@ use rustc_errors::codes::*;
use rustc_errors::{
Applicability, BufferedEarlyLint, Diagnostic, MultiSpan, pluralize, struct_span_code_err,
};
use rustc_expand::base::SyntaxExtensionKind;
use rustc_hir::Attribute;
use rustc_hir::attrs::AttributeKind;
use rustc_hir::attrs::diagnostic::{CustomDiagnostic, Directive, FormatArgs};
Expand Down Expand Up @@ -1656,7 +1657,9 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
match decl.kind {
// exclude decl_macro
DeclKind::Def(Res::Def(DefKind::Macro(_), def_id))
if self.get_macro_by_def_id(def_id).macro_rules =>
if let SyntaxExtensionKind::MacroRules(mr) =
&self.get_macro_by_def_id(def_id).kind
&& mr.is_macro_rules() =>
{
err.subdiagnostic(ConsiderAddingMacroExport { span: decl.span });
err.subdiagnostic(ConsiderMarkingAsPubCrate { vis_span: import.vis_span });
Expand Down
48 changes: 15 additions & 33 deletions compiler/rustc_resolve/src/lib.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -1265,18 +1265,6 @@ struct DeriveData {
has_derive_copy: bool,
}

struct MacroData {
ext: Arc<SyntaxExtension>,
nrules: usize,
macro_rules: bool,
}

impl MacroData {
fn new(ext: Arc<SyntaxExtension>) -> MacroData {
MacroData { ext, nrules: 0, macro_rules: false }
}
}

pub struct ResolverOutputs<'tcx> {
pub global_ctxt: ResolverGlobalCtxt,
pub ast_lowering: ResolverAstLowering<'tcx>,
Expand Down Expand Up @@ -1396,12 +1384,12 @@ pub struct Resolver<'ra, 'tcx> {
registered_tools: &'tcx RegisteredTools,
macro_use_prelude: FxIndexMap<Symbol, Decl<'ra>>,
/// Eagerly populated map of all local macro definitions.
local_macro_map: FxHashMap<LocalDefId, &'ra MacroData> = default::fx_hash_map(),
local_macro_map: FxHashMap<LocalDefId, &'ra Arc<SyntaxExtension>> = default::fx_hash_map(),
/// Lazily populated cache of macro definitions loaded from external crates.
extern_macro_map: CacheRefCell<FxHashMap<DefId, &'ra MacroData>>,
dummy_ext_bang: Arc<SyntaxExtension>,
dummy_ext_derive: Arc<SyntaxExtension>,
non_macro_attr: Arc<SyntaxExtension>,
extern_macro_map: CacheRefCell<FxHashMap<DefId, &'ra Arc<SyntaxExtension>>>,
dummy_ext_bang: &'ra Arc<SyntaxExtension>,
dummy_ext_derive: &'ra Arc<SyntaxExtension>,
non_macro_attr: &'ra Arc<SyntaxExtension>,
local_macro_def_scopes: FxHashMap<LocalDefId, LocalModule<'ra>> = default::fx_hash_map(),
ast_transform_scopes: FxHashMap<LocalExpnId, LocalModule<'ra>> = default::fx_hash_map(),
unused_macros: FxIndexMap<LocalDefId, (NodeId, Ident)>,
Expand Down Expand Up @@ -1520,7 +1508,7 @@ pub struct ResolverArenas<'ra> {
imports: TypedArena<ImportData<'ra>>,
name_resolutions: TypedArena<CmRefCell<NameResolution<'ra>>>,
ast_paths: TypedArena<ast::Path>,
macros: TypedArena<MacroData>,
macros: TypedArena<Arc<SyntaxExtension>>,
dropless: DroplessArena,
}

Expand Down Expand Up @@ -1599,8 +1587,8 @@ impl<'ra> ResolverArenas<'ra> {
fn alloc_ast_paths(&'ra self, paths: &[ast::Path]) -> &'ra [ast::Path] {
self.ast_paths.alloc_from_iter(paths.iter().cloned())
}
fn alloc_macro(&'ra self, macro_data: MacroData) -> &'ra MacroData {
self.macros.alloc(macro_data)
fn alloc_macro(&'ra self, ext: SyntaxExtension) -> &'ra Arc<SyntaxExtension> {
self.macros.alloc(Arc::new(ext))
}
fn alloc_pattern_spans(&'ra self, spans: impl Iterator<Item = Span>) -> &'ra [Span] {
self.dropless.alloc_from_iter(spans)
Expand Down Expand Up @@ -1819,9 +1807,9 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
registered_tools,
macro_use_prelude: Default::default(),
extern_macro_map: Default::default(),
dummy_ext_bang: Arc::new(SyntaxExtension::dummy_bang(edition)),
dummy_ext_derive: Arc::new(SyntaxExtension::dummy_derive(edition)),
non_macro_attr: Arc::new(SyntaxExtension::non_macro_attr(edition)),
dummy_ext_bang: arenas.alloc_macro(SyntaxExtension::dummy_bang(edition)),
dummy_ext_derive: arenas.alloc_macro(SyntaxExtension::dummy_derive(edition)),
non_macro_attr: arenas.alloc_macro(SyntaxExtension::non_macro_attr(edition)),
unused_macros: Default::default(),
unused_macro_rules: Default::default(),
single_segment_macro_resolutions: Default::default(),
Expand Down Expand Up @@ -1888,12 +1876,6 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
module
}

fn new_local_macro(&mut self, def_id: LocalDefId, macro_data: MacroData) -> &'ra MacroData {
let mac = self.arenas.alloc_macro(macro_data);
self.local_macro_map.insert(def_id, mac);
mac
}

fn next_node_id(&mut self) -> NodeId {
let start = self.next_node_id;
let next = start.as_u32().checked_add(1).expect("input too large; ran out of NodeIds");
Expand Down Expand Up @@ -1988,11 +1970,11 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
CStore::from_tcx_mut(self.tcx)
}

fn dummy_ext(&self, macro_kind: MacroKind) -> Arc<SyntaxExtension> {
fn dummy_ext(&self, macro_kind: MacroKind) -> &'ra Arc<SyntaxExtension> {
match macro_kind {
MacroKind::Bang => Arc::clone(&self.dummy_ext_bang),
MacroKind::Derive => Arc::clone(&self.dummy_ext_derive),
MacroKind::Attr => Arc::clone(&self.non_macro_attr),
MacroKind::Bang => self.dummy_ext_bang,
MacroKind::Derive => self.dummy_ext_derive,
MacroKind::Attr => self.non_macro_attr,
}
}

Expand Down
Loading
Loading