Basic support for declarative attribute/derive macros

Author: Zalathar

Cargo.lock

@@ -338,7 +338,7 @@ fn macro_def(db: &dyn DefDatabase, id: MacroId) -> MacroDefId {
     let kind = |expander, file_id, m| {
         let in_file = InFile::new(file_id, m);
         match expander {
-            MacroExpander::Declarative => MacroDefKind::Declarative(in_file),
+            MacroExpander::Declarative { styles } => MacroDefKind::Declarative(in_file, styles),
             MacroExpander::BuiltIn(it) => MacroDefKind::BuiltIn(in_file, it),
             MacroExpander::BuiltInAttr(it) => MacroDefKind::BuiltInAttr(in_file, it),
             MacroExpander::BuiltInDerive(it) => MacroDefKind::BuiltInDerive(in_file, it),

crates/hir-def/src/db.rs

@@ -17,9 +17,8 @@ use thin_vec::ThinVec;
 
 use crate::{
     AdtId, BuiltinType, ConstId, ExternBlockId, ExternCrateId, FxIndexMap, HasModule, ImplId,
-    LocalModuleId, Lookup, MacroId, ModuleDefId, ModuleId, TraitId, UseId,
+    LocalModuleId, Lookup, MacroCallStyles, MacroId, ModuleDefId, ModuleId, TraitId, UseId,
     db::DefDatabase,
-    nameres::MacroSubNs,
     per_ns::{Item, MacrosItem, PerNs, TypesItem, ValuesItem},
     visibility::Visibility,
 };
@@ -740,11 +739,15 @@ impl ItemScope {
         let mut entries: Vec<_> = self.resolutions().collect();
         entries.sort_by_key(|(name, _)| name.clone());
 
-        let print_macro_sub_ns =
-            |buf: &mut String, macro_id: MacroId| match MacroSubNs::from_id(db, macro_id) {
-                MacroSubNs::Bang => buf.push('!'),
-                MacroSubNs::Attr => buf.push('#'),
-            };
+        let print_macro_sub_ns = |buf: &mut String, macro_id: MacroId| {
+            let styles = crate::nameres::macro_styles_from_id(db, macro_id);
+            if styles.contains(MacroCallStyles::FN_LIKE) {
+                buf.push('!');
+            }
+            if styles.contains(MacroCallStyles::ATTR) || styles.contains(MacroCallStyles::DERIVE) {
+                buf.push('#');
+            }
+        };
 
         for (name, def) in entries {
             let display_name: &dyn fmt::Display = match &name {

crates/hir-def/src/item_scope.rs

@@ -61,8 +61,8 @@ use std::hash::{Hash, Hasher};
 
 use base_db::{Crate, impl_intern_key};
 use hir_expand::{
-    AstId, ExpandResult, ExpandTo, HirFileId, InFile, MacroCallId, MacroCallKind, MacroDefId,
-    MacroDefKind,
+    AstId, ExpandResult, ExpandTo, HirFileId, InFile, MacroCallId, MacroCallKind, MacroCallStyles,
+    MacroDefId, MacroDefKind,
     builtin::{BuiltinAttrExpander, BuiltinDeriveExpander, BuiltinFnLikeExpander, EagerExpander},
     db::ExpandDatabase,
     eager::expand_eager_macro_input,
@@ -403,7 +403,7 @@ bitflags::bitflags! {
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum MacroExpander {
-    Declarative,
+    Declarative { styles: MacroCallStyles },
     BuiltIn(BuiltinFnLikeExpander),
     BuiltInAttr(BuiltinAttrExpander),
     BuiltInDerive(BuiltinDeriveExpander),

crates/hir-def/src/lib.rs

@@ -77,7 +77,7 @@ use tt::TextRange;
 
 use crate::{
     AstId, BlockId, BlockLoc, CrateRootModuleId, ExternCrateId, FunctionId, FxIndexMap,
-    LocalModuleId, Lookup, MacroExpander, MacroId, ModuleId, ProcMacroId, UseId,
+    LocalModuleId, Lookup, MacroCallStyles, MacroExpander, MacroId, ModuleId, ProcMacroId, UseId,
     db::DefDatabase,
     item_scope::{BuiltinShadowMode, ItemScope},
     item_tree::TreeId,
@@ -813,26 +813,25 @@ pub enum MacroSubNs {
     Attr,
 }
 
-impl MacroSubNs {
-    pub(crate) fn from_id(db: &dyn DefDatabase, macro_id: MacroId) -> Self {
-        let expander = match macro_id {
-            MacroId::Macro2Id(it) => it.lookup(db).expander,
-            MacroId::MacroRulesId(it) => it.lookup(db).expander,
-            MacroId::ProcMacroId(it) => {
-                return match it.lookup(db).kind {
-                    ProcMacroKind::CustomDerive | ProcMacroKind::Attr => Self::Attr,
-                    ProcMacroKind::Bang => Self::Bang,
-                };
-            }
-        };
+pub(crate) fn macro_styles_from_id(db: &dyn DefDatabase, macro_id: MacroId) -> MacroCallStyles {
+    let expander = match macro_id {
+        MacroId::Macro2Id(it) => it.lookup(db).expander,
+        MacroId::MacroRulesId(it) => it.lookup(db).expander,
+        MacroId::ProcMacroId(it) => {
+            return match it.lookup(db).kind {
+                ProcMacroKind::CustomDerive => MacroCallStyles::DERIVE,
+                ProcMacroKind::Bang => MacroCallStyles::FN_LIKE,
+                ProcMacroKind::Attr => MacroCallStyles::ATTR,
+            };
+        }
+    };
 
+    match expander {
+        MacroExpander::Declarative { styles } => styles,
         // Eager macros aren't *guaranteed* to be bang macros, but they *are* all bang macros currently.
-        match expander {
-            MacroExpander::Declarative
-            | MacroExpander::BuiltIn(_)
-            | MacroExpander::BuiltInEager(_) => Self::Bang,
-            MacroExpander::BuiltInAttr(_) | MacroExpander::BuiltInDerive(_) => Self::Attr,
-        }
+        MacroExpander::BuiltIn(_) | MacroExpander::BuiltInEager(_) => MacroCallStyles::FN_LIKE,
+        MacroExpander::BuiltInAttr(_) => MacroCallStyles::ATTR,
+        MacroExpander::BuiltInDerive(_) => MacroCallStyles::DERIVE,
     }
 }
 
@@ -847,9 +846,14 @@ fn sub_namespace_match(
     macro_id: MacroId,
     expected: Option<MacroSubNs>,
 ) -> bool {
-    let candidate = MacroSubNs::from_id(db, macro_id);
+    let candidate = macro_styles_from_id(db, macro_id);
     match expected {
-        Some(expected) => candidate == expected,
+        Some(MacroSubNs::Bang) => candidate.contains(MacroCallStyles::FN_LIKE),
+        Some(MacroSubNs::Attr) => {
+            candidate.contains(MacroCallStyles::ATTR) || candidate.contains(MacroCallStyles::DERIVE)
+        }
+        // If we aren't expecting a specific sub-namespace
+        // (e.g. in `use` declarations), match any macro.
         None => true,
     }
 }

crates/hir-def/src/nameres.rs

@@ -2300,7 +2300,10 @@ impl ModCollector<'_, '_> {
             }
         } else {
             // Case 2: normal `macro_rules!` macro
-            MacroExpander::Declarative
+            let id = InFile::new(self.file_id(), ast_id);
+            let decl_expander = self.def_collector.db.decl_macro_expander(krate, id.upcast());
+            let styles = decl_expander.mac.rule_styles();
+            MacroExpander::Declarative { styles }
         };
         let allow_internal_unsafe = attrs.by_key(sym::allow_internal_unsafe).exists();
 
@@ -2369,7 +2372,10 @@ impl ModCollector<'_, '_> {
             }
         } else {
             // Case 2: normal `macro`
-            MacroExpander::Declarative
+            let id = InFile::new(self.file_id(), ast_id);
+            let decl_expander = self.def_collector.db.decl_macro_expander(krate, id.upcast());
+            let styles = decl_expander.mac.rule_styles();
+            MacroExpander::Declarative { styles }
         };
         let allow_internal_unsafe = attrs.by_key(sym::allow_internal_unsafe).exists();
 

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

@@ -222,6 +222,7 @@ pub struct S {}
                 "ast_id_map_shim",
                 "parse_shim",
                 "real_span_map_shim",
+                "decl_macro_expander_shim",
                 "file_item_tree_query",
                 "ast_id_map_shim",
                 "parse_shim",
@@ -235,7 +236,6 @@ pub struct S {}
                 "ast_id_map_shim",
                 "parse_macro_expansion_shim",
                 "macro_arg_shim",
-                "decl_macro_expander_shim",
             ]
         "#]],
         expect![[r#"
@@ -404,6 +404,7 @@ pub struct S {}
                 "ast_id_map_shim",
                 "parse_shim",
                 "real_span_map_shim",
+                "decl_macro_expander_shim",
                 "file_item_tree_query",
                 "ast_id_map_shim",
                 "parse_shim",
@@ -423,7 +424,6 @@ pub struct S {}
                 "ast_id_map_shim",
                 "parse_macro_expansion_shim",
                 "macro_arg_shim",
-                "decl_macro_expander_shim",
                 "crate_local_def_map",
                 "proc_macros_for_crate_shim",
                 "file_item_tree_query",
@@ -446,9 +446,9 @@ pub struct S {}
                 "file_item_tree_query",
                 "real_span_map_shim",
                 "macro_arg_shim",
-                "macro_arg_shim",
                 "decl_macro_expander_shim",
                 "macro_arg_shim",
+                "macro_arg_shim",
             ]
         "#]],
     );
@@ -520,6 +520,7 @@ m!(Z);
                 "ast_id_map_shim",
                 "parse_shim",
                 "real_span_map_shim",
+                "decl_macro_expander_shim",
                 "file_item_tree_query",
                 "ast_id_map_shim",
                 "parse_shim",
@@ -533,7 +534,6 @@ m!(Z);
                 "ast_id_map_shim",
                 "parse_macro_expansion_shim",
                 "macro_arg_shim",
-                "decl_macro_expander_shim",
                 "file_item_tree_query",
                 "ast_id_map_shim",
                 "parse_macro_expansion_shim",

crates/hir-def/src/nameres/tests/incremental.rs

@@ -1651,3 +1651,132 @@ pub mod prelude {
         "#]],
     );
 }
+
+#[test]
+fn macro_rules_mixed_style() {
+    check(
+        r#"
+
+macro_rules! foo {
+             () => {};
+      attr() () => {};
+    derive() () => {};
+}
+
+use foo;
+"#,
+        expect![[r#"
+    crate
+    - foo : macro!# (import)
+    - (legacy) foo : macro!#
+"#]],
+    );
+}
+
+#[test]
+fn macro_2_mixed_style() {
+    check(
+        r#"
+
+macro foo {
+             () => {};
+      attr() () => {};
+    derive() () => {};
+}
+
+use foo;
+"#,
+        expect![[r#"
+            crate
+            - foo : macro!#
+        "#]],
+    );
+}
+
+#[test]
+fn macro_rules_attr() {
+    check(
+        r#"
+
+macro_rules! my_attr {
+    attr() ($($tt:tt)*) => { fn attr_fn() {} }
+}
+
+#[my_attr]
+enum MyEnum {}
+
+"#,
+        expect![[r#"
+    crate
+    - attr_fn : value
+    - (legacy) my_attr : macro#
+"#]],
+    );
+}
+
+#[test]
+fn macro_2_attr() {
+    check(
+        r#"
+
+macro my_attr {
+    attr() ($($tt:tt)*) => { fn attr_fn() {} }
+}
+
+#[my_attr]
+enum MyEnum {}
+
+"#,
+        expect![[r#"
+    crate
+    - attr_fn : value
+    - my_attr : macro#
+"#]],
+    );
+}
+
+#[test]
+fn macro_rules_derive() {
+    check(
+        r#"
+//- minicore: derive
+
+macro_rules! MyDerive {
+    derive() ($($tt:tt)*) => { fn derived_fn() {} }
+}
+
+#[derive(MyDerive)]
+enum MyEnum {}
+
+"#,
+        expect![[r#"
+            crate
+            - MyEnum : type
+            - derived_fn : value
+            - (legacy) MyDerive : macro#
+        "#]],
+    );
+}
+
+#[test]
+fn macro_2_derive() {
+    check(
+        r#"
+//- minicore: derive
+
+macro MyDerive {
+    derive() ($($tt:tt)*) => { fn derived_fn() {} }
+}
+
+#[derive(MyDerive)]
+enum MyEnum {}
+
+"#,
+        expect![[r#"
+            crate
+            - MyDerive : macro#
+            - MyEnum : type
+            - derived_fn : value
+        "#]],
+    );
+}