address review

Author: LorrensP-2158466

compiler/rustc_resolve/src/build_reduced_graph.rs

@@ -162,7 +162,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         }
     }
 
-    pub(crate) fn get_macro(&mut self, res: Res) -> Option<Macro<'ra>> {
+    pub(crate) fn get_macro(&self, res: Res) -> Option<Macro<'ra>> {
         match res {
             Res::Def(DefKind::Macro(..), def_id) => Some(self.get_macro_by_def_id(def_id)),
             Res::NonMacroAttr(_) => Some(self.non_macro_attr),
@@ -174,12 +174,9 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         match def_id.as_local() {
             Some(local_def_id) => {
                 // local macros are always compiled.
-                self.local_macro_map
-                    .get(&local_def_id)
-                    .copied()
-                    .expect("Local Macros should be compiled and available.")
+                self.local_macro_map[&local_def_id]
             }
-            None => *self.external_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(def_id, self.tcx);
                 let macro_data = match loaded_macro {
                     LoadedMacro::MacroDef { def, ident, attrs, span, edition } => {

compiler/rustc_resolve/src/diagnostics.rs

@@ -1673,7 +1673,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             .local_macro_map
             .iter()
             .map(|(local_id, data)| (local_id.to_def_id(), data))
-            .chain(self.external_macro_map.borrow().iter().map(|(id, d)| (*id, d)))
+            .chain(self.extern_macro_map.borrow().iter().map(|(id, d)| (*id, d)))
         {
             for helper_attr in &data.ext.helper_attrs {
                 let item_name = self.tcx.item_name(def_id);

compiler/rustc_resolve/src/lib.rs

@@ -1013,7 +1013,7 @@ struct DeriveData {
     has_derive_copy: bool,
 }
 
-pub struct MacroData {
+struct MacroData {
     ext: Arc<SyntaxExtension>,
     nrules: usize,
     macro_rules: bool,
@@ -1025,20 +1025,7 @@ impl MacroData {
     }
 }
 
-pub(crate) type Macro<'ra> = Interned<'ra, MacroData>;
-
-// Allows us to use Interned without actually enforcing (via Hash/PartialEq/...) uniqueness of the
-// contained data.
-// FIXME: We may wish to actually have at least debug-level assertions that Interned's guarantees
-// are upheld.
-impl std::hash::Hash for MacroData {
-    fn hash<H>(&self, _: &mut H)
-    where
-        H: std::hash::Hasher,
-    {
-        unreachable!()
-    }
-}
+type Macro<'ra> = &'ra MacroData;
 
 /// The main resolver class.
 ///
@@ -1144,7 +1131,8 @@ pub struct Resolver<'ra, 'tcx> {
     registered_tools: &'tcx RegisteredTools,
     macro_use_prelude: FxIndexMap<Symbol, NameBinding<'ra>>,
     local_macro_map: FxHashMap<LocalDefId, Macro<'ra>>,
-    external_macro_map: RefCell<FxHashMap<DefId, Macro<'ra>>>,
+    /// Lazily populated cache of macros loaded from external crates.
+    extern_macro_map: RefCell<FxHashMap<DefId, Macro<'ra>>>,
     dummy_ext_bang: Arc<SyntaxExtension>,
     dummy_ext_derive: Arc<SyntaxExtension>,
     non_macro_attr: Macro<'ra>,
@@ -1316,7 +1304,7 @@ impl<'ra> ResolverArenas<'ra> {
         self.ast_paths.alloc_from_iter(paths.iter().cloned())
     }
     fn alloc_macro(&'ra self, macro_data: MacroData) -> Macro<'ra> {
-        Interned::new_unchecked(self.macros.alloc(macro_data))
+        self.macros.alloc(macro_data)
     }
     fn alloc_pattern_spans(&'ra self, spans: impl Iterator<Item = Span>) -> &'ra [Span] {
         self.dropless.alloc_from_iter(spans)
@@ -1560,8 +1548,8 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             builtin_macros: Default::default(),
             registered_tools,
             macro_use_prelude: Default::default(),
-            local_macro_map: FxHashMap::default(),
-            external_macro_map: RefCell::default(),
+            local_macro_map: 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: arenas
@@ -1638,13 +1626,9 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         )
     }
 
-    pub fn new_local_macro(
-        &mut self,
-        local_def_id: LocalDefId,
-        macro_data: MacroData,
-    ) -> Macro<'ra> {
+    fn new_local_macro(&mut self, def_id: LocalDefId, macro_data: MacroData) -> Macro<'ra> {
         let mac = self.arenas.alloc_macro(macro_data);
-        self.local_macro_map.insert(local_def_id, mac);
+        self.local_macro_map.insert(def_id, mac);
         mac
     }
 
@@ -1766,7 +1750,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         f(self, MacroNS);
     }
 
-    fn is_builtin_macro(&mut self, res: Res) -> bool {
+    fn is_builtin_macro(&self, res: Res) -> bool {
         self.get_macro(res).is_some_and(|macro_data| macro_data.ext.builtin_name.is_some())
     }
 

compiler/rustc_resolve/src/macros.rs

@@ -354,8 +354,8 @@ impl<'ra, 'tcx> ResolverExpand for Resolver<'ra, 'tcx> {
             if unused_arms.is_empty() {
                 continue;
             }
-            let local_def_id = self.local_def_id(node_id);
-            let m = &self.local_macro_map[&local_def_id];
+            let def_id = self.local_def_id(node_id);
+            let m = &self.local_macro_map[&def_id];
             let SyntaxExtensionKind::LegacyBang(ref ext) = m.ext.kind else {
                 continue;
             };
@@ -1132,7 +1132,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         }
     }
 
-    pub(crate) fn check_reserved_macro_name(&mut self, ident: Ident, res: Res) {
+    pub(crate) fn check_reserved_macro_name(&self, ident: Ident, res: Res) {
         // Reserve some names that are not quite covered by the general check
         // performed on `Resolver::builtin_attrs`.
         if ident.name == sym::cfg || ident.name == sym::cfg_attr {