Collect nameres eager macros

Author: Veykril

crates/hir-def/src/db.rs

@@ -149,7 +149,7 @@ pub trait DefDatabase:
     fn enum_variants_with_diagnostics(
         &self,
         id: EnumId,
-    ) -> (Arc<EnumVariants>, Arc<ThinVec<InactiveEnumVariantCode>>);
+    ) -> (Arc<EnumVariants>, Option<Arc<ThinVec<InactiveEnumVariantCode>>>);
 
     #[salsa::transparent]
     #[salsa::invoke_actual(ImplItems::impl_items_query)]

crates/hir-def/src/nameres/collector.rs

@@ -1229,6 +1229,7 @@ impl DefCollector<'_> {
             No,
         }
 
+        let mut eager_callback_buffer = vec![];
         let mut res = ReachedFixedPoint::Yes;
         // Retain unresolved macros after this round of resolution.
         let mut retain = |directive: &MacroDirective| {
@@ -1261,11 +1262,8 @@ impl DefCollector<'_> {
                         *expand_to,
                         self.def_map.krate,
                         resolver_def_id,
-                        &mut |_ptr, _call_id| {
-                            // FIXME:
-                            // self.def_map.modules[directive.module_id]
-                            //     .scope
-                            //     .add_macro_invoc(ptr.map(|(_, it)| it), call_id);
+                        &mut |ptr, call_id| {
+                            eager_callback_buffer.push((directive.module_id, ptr, call_id));
                         },
                     );
                     if let Ok(Some(call_id)) = call_id {
@@ -1492,6 +1490,10 @@ impl DefCollector<'_> {
         macros.extend(mem::take(&mut self.unresolved_macros));
         self.unresolved_macros = macros;
 
+        for (module_id, ptr, call_id) in eager_callback_buffer {
+            self.def_map.modules[module_id].scope.add_macro_invoc(ptr.map(|(_, it)| it), call_id);
+        }
+
         for (module_id, depth, container, macro_call_id) in resolved {
             self.collect_macro_expansion(module_id, macro_call_id, depth, container);
         }
@@ -2419,6 +2421,7 @@ impl ModCollector<'_, '_> {
         // new legacy macros that create textual scopes. We need a way to resolve names in textual
         // scopes without eager expansion.
 
+        let mut eager_callback_buffer = vec![];
         // Case 1: try to resolve macro calls with single-segment name and expand macro_rules
         if let Ok(res) = macro_call_as_call_id_with_eager(
             db.upcast(),
@@ -2460,13 +2463,13 @@ impl ModCollector<'_, '_> {
                 );
                 resolved_res.resolved_def.take_macros().map(|it| db.macro_def(it))
             },
-            &mut |_ptr, _call_id| {
-                // FIXME:
-                // self.def_collector.def_map.modules[self.module_id]
-                //     .scope
-                //     .add_macro_invoc(ptr.map(|(_, it)| it), call_id);
-            },
+            &mut |ptr, call_id| eager_callback_buffer.push((ptr, call_id)),
         ) {
+            for (ptr, call_id) in eager_callback_buffer {
+                self.def_collector.def_map.modules[self.module_id]
+                    .scope
+                    .add_macro_invoc(ptr.map(|(_, it)| it), call_id);
+            }
             // FIXME: if there were errors, this might've been in the eager expansion from an
             // unresolved macro, so we need to push this into late macro resolution. see fixme above
             if res.err.is_none() {
@@ -2629,7 +2632,7 @@ foo!(KABOOM);
         // the release mode. That's why the argument is not an ra_fixture --
         // otherwise injection highlighting gets stuck.
         //
-        // We need to find a way to fail this faster.
+        // We need to find a way to fail this faster!
         do_resolve(
             r#"
 macro_rules! foo {

crates/hir-def/src/signatures.rs

@@ -1,5 +1,7 @@
 //! Item signature IR definitions
 
+use std::ops::Not as _;
+
 use bitflags::bitflags;
 use cfg::{CfgExpr, CfgOptions};
 use either::Either;
@@ -907,7 +909,7 @@ impl EnumVariants {
     pub(crate) fn enum_variants_query(
         db: &dyn DefDatabase,
         e: EnumId,
-    ) -> (Arc<EnumVariants>, Arc<ThinVec<InactiveEnumVariantCode>>) {
+    ) -> (Arc<EnumVariants>, Option<Arc<ThinVec<InactiveEnumVariantCode>>>) {
         let loc = e.lookup(db);
         let item_tree = loc.id.item_tree(db);
 
@@ -937,7 +939,10 @@ impl EnumVariants {
             })
             .collect();
 
-        (Arc::new(EnumVariants { variants }), Arc::new(diagnostics))
+        (
+            Arc::new(EnumVariants { variants }),
+            diagnostics.is_empty().not().then(|| Arc::new(diagnostics)),
+        )
     }
 
     pub fn variant(&self, name: &Name) -> Option<EnumVariantId> {

crates/hir/src/lib.rs

@@ -691,18 +691,20 @@ impl Module {
                             let (variants, diagnostics) = db.enum_variants_with_diagnostics(e.id);
                             let file = e.id.lookup(db.upcast()).id.file_id();
                             let ast_id_map = db.ast_id_map(file);
-                            for diag in diagnostics.iter() {
-                                acc.push(
-                                    InactiveCode {
-                                        node: InFile::new(
-                                            file,
-                                            ast_id_map.get(diag.ast_id).syntax_node_ptr(),
-                                        ),
-                                        cfg: diag.cfg.clone(),
-                                        opts: diag.opts.clone(),
-                                    }
-                                    .into(),
-                                );
+                            if let Some(diagnostics) = &diagnostics {
+                                for diag in diagnostics.iter() {
+                                    acc.push(
+                                        InactiveCode {
+                                            node: InFile::new(
+                                                file,
+                                                ast_id_map.get(diag.ast_id).syntax_node_ptr(),
+                                            ),
+                                            cfg: diag.cfg.clone(),
+                                            opts: diag.opts.clone(),
+                                        }
+                                        .into(),
+                                    );
+                                }
                             }
                             for &(v, _) in &variants.variants {
                                 let source_map = db.variant_fields_with_source_map(v.into()).1;