Add data queries for macros

crates/hir/src/lib.rs

@@ -340,7 +340,7 @@ impl ModuleDef {
             ModuleDef::Variant(it) => it.name(db),
             ModuleDef::TypeAlias(it) => it.name(db),
             ModuleDef::Static(it) => it.name(db),
-            ModuleDef::Macro(it) => it.name(db)?,
+            ModuleDef::Macro(it) => it.name(db),
             ModuleDef::BuiltinType(it) => it.name(),
         };
         Some(name)
@@ -426,8 +426,7 @@ impl HasVisibility for ModuleDef {
             ModuleDef::Trait(it) => it.visibility(db),
             ModuleDef::TypeAlias(it) => it.visibility(db),
             ModuleDef::Variant(it) => it.visibility(db),
-            // FIXME
+            ModuleDef::Macro(it) => it.visibility(db),
-            ModuleDef::Macro(_) => Visibility::Public,
             ModuleDef::BuiltinType(_) => Visibility::Public,
         }
     }
@@ -1766,14 +1765,12 @@ impl Macro {
         Module { id: self.id.module(db.upcast()) }
     }
 
-    pub fn name(self, _db: &dyn HirDatabase) -> Option<Name> {
+    pub fn name(self, db: &dyn HirDatabase) -> Name {
-        // match self.id {
+        match self.id {
-        //     MacroId::Macro2Id(id) => db.macro2_data(id).name.clone(),
+            MacroId::Macro2Id(id) => db.macro2_data(id).name.clone(),
-        //     MacroId::MacroRulesId(id) => db.macro_rules_data(id).name.clone(),
+            MacroId::MacroRulesId(id) => db.macro_rules_data(id).name.clone(),
-        //     MacroId::ProcMacroId(id) => db.proc_macro_data(id).name.clone(),
+            MacroId::ProcMacroId(id) => db.proc_macro_data(id).name.clone(),
-        // }
+        }
-        // FIXME
-        None
     }
 
     pub fn kind(&self, db: &dyn HirDatabase) -> MacroKind {
@@ -1826,6 +1823,20 @@ impl Macro {
     }
 }
 
+impl HasVisibility for Macro {
+    fn visibility(&self, db: &dyn HirDatabase) -> Visibility {
+        match self.id {
+            MacroId::Macro2Id(id) => {
+                let data = db.macro2_data(id);
+                let visibility = &data.visibility;
+                visibility.resolve(db.upcast(), &self.id.resolver(db.upcast()))
+            }
+            MacroId::MacroRulesId(_) => Visibility::Public,
+            MacroId::ProcMacroId(_) => Visibility::Public,
+        }
+    }
+}
+
 #[derive(Clone, Copy, PartialEq, Eq, Debug, Hash)]
 pub enum ItemInNs {
     Types(ModuleDef),
@@ -3374,3 +3385,9 @@ impl HasCrate for Type {
         self.krate.into()
     }
 }
+
+impl HasCrate for Macro {
+    fn krate(&self, db: &dyn HirDatabase) -> Crate {
+        self.module(db).krate()
+    }
+}

crates/hir_def/src/data.rs

@@ -15,7 +15,8 @@ use crate::{
     type_ref::{TraitRef, TypeBound, TypeRef},
     visibility::RawVisibility,
     AssocItemId, AstIdWithPath, ConstId, ConstLoc, FunctionId, FunctionLoc, HasModule, ImplId,
-    Intern, ItemContainerId, Lookup, ModuleId, StaticId, TraitId, TypeAliasId, TypeAliasLoc,
+    Intern, ItemContainerId, Lookup, Macro2Id, MacroRulesId, ModuleId, ProcMacroId, StaticId,
+    TraitId, TypeAliasId, TypeAliasLoc,
 };
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -293,6 +294,59 @@ impl ImplData {
     }
 }
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Macro2Data {
+    pub name: Name,
+    pub visibility: RawVisibility,
+}
+
+impl Macro2Data {
+    pub(crate) fn macro2_data_query(db: &dyn DefDatabase, makro: Macro2Id) -> Arc<Macro2Data> {
+        let loc = makro.lookup(db);
+        let item_tree = loc.id.item_tree(db);
+        let makro = &item_tree[loc.id.value];
+
+        Arc::new(Macro2Data {
+            name: makro.name.clone(),
+            visibility: item_tree[makro.visibility].clone(),
+        })
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct MacroRulesData {
+    pub name: Name,
+}
+
+impl MacroRulesData {
+    pub(crate) fn macro_rules_data_query(
+        db: &dyn DefDatabase,
+        makro: MacroRulesId,
+    ) -> Arc<MacroRulesData> {
+        let loc = makro.lookup(db);
+        let item_tree = loc.id.item_tree(db);
+        let makro = &item_tree[loc.id.value];
+
+        Arc::new(MacroRulesData { name: makro.name.clone() })
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ProcMacroData {
+    pub name: Name,
+}
+
+impl ProcMacroData {
+    pub(crate) fn proc_macro_data_query(
+        db: &dyn DefDatabase,
+        makro: ProcMacroId,
+    ) -> Arc<ProcMacroData> {
+        let loc = makro.lookup(db);
+        let item_tree = loc.id.item_tree(db);
+        let makro = &item_tree[loc.id.value];
+
+        Arc::new(ProcMacroData { name: makro.name.clone() })
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct ConstData {
     /// `None` for `const _: () = ();`

crates/hir_def/src/db.rs

@@ -11,7 +11,10 @@ use crate::{
     adt::{EnumData, StructData},
     attr::{Attrs, AttrsWithOwner},
     body::{scope::ExprScopes, Body, BodySourceMap},
-    data::{ConstData, FunctionData, ImplData, StaticData, TraitData, TypeAliasData},
+    data::{
+        ConstData, FunctionData, ImplData, Macro2Data, MacroRulesData, ProcMacroData, StaticData,
+        TraitData, TypeAliasData,
+    },
     generics::GenericParams,
     import_map::ImportMap,
     intern::Interned,
@@ -118,6 +121,15 @@ pub trait DefDatabase: InternDatabase + AstDatabase + Upcast<dyn AstDatabase> {
     #[salsa::invoke(StaticData::static_data_query)]
     fn static_data(&self, konst: StaticId) -> Arc<StaticData>;
 
+    #[salsa::invoke(Macro2Data::macro2_data_query)]
+    fn macro2_data(&self, makro: Macro2Id) -> Arc<Macro2Data>;
+
+    #[salsa::invoke(MacroRulesData::macro_rules_data_query)]
+    fn macro_rules_data(&self, makro: MacroRulesId) -> Arc<MacroRulesData>;
+
+    #[salsa::invoke(ProcMacroData::proc_macro_data_query)]
+    fn proc_macro_data(&self, makro: ProcMacroId) -> Arc<ProcMacroData>;
+
     #[salsa::invoke(Body::body_with_source_map_query)]
     fn body_with_source_map(&self, def: DefWithBodyId) -> (Arc<Body>, Arc<BodySourceMap>);
 

crates/ide/src/doc_links.rs

@@ -472,7 +472,7 @@ fn filename_and_frag_for_def(
         }
         Definition::Const(c) => format!("const.{}.html", c.name(db)?),
         Definition::Static(s) => format!("static.{}.html", s.name(db)),
-        Definition::Macro(mac) => format!("macro.{}.html", mac.name(db)?),
+        Definition::Macro(mac) => format!("macro.{}.html", mac.name(db)),
         Definition::Field(field) => {
             let def = match field.parent_def(db) {
                 hir::VariantDef::Struct(it) => Definition::Adt(it.into()),

crates/ide/src/expand_macro.rs

@@ -75,7 +75,7 @@ pub(crate) fn expand_macro(db: &RootDatabase, position: FilePosition) -> Option<
     for node in tok.ancestors() {
         if let Some(item) = ast::Item::cast(node.clone()) {
             if let Some(def) = sema.resolve_attr_macro_call(&item) {
-                name = def.name(db).map(|name| name.to_string());
+                name = Some(def.name(db).to_string());
                 expanded = expand_attr_macro_recur(&sema, &item);
                 break;
             }

crates/ide_completion/src/completions/attribute/derive.rs

@@ -36,7 +36,7 @@ pub(super) fn complete_derive(acc: &mut Completions, ctx: &CompletionContext, at
                         |&&dependency| {
                             !existing_derives
                                 .iter()
-                                .filter_map(|it| it.name(ctx.db))
+                                .map(|it| it.name(ctx.db))
                                 .any(|it| it.to_smol_str() == dependency)
                         },
                     ));
@@ -108,7 +108,7 @@ fn flyimport_derive(acc: &mut Completions, ctx: &CompletionContext) -> Option<()
                 let mut item = CompletionItem::new(
                     SymbolKind::Derive,
                     ctx.source_range(),
-                    mac.name(ctx.db)?.to_smol_str(),
+                    mac.name(ctx.db).to_smol_str(),
                 );
                 item.add_import(ImportEdit { import, scope: import_scope.clone() });
                 if let Some(docs) = mac.docs(ctx.db) {

crates/ide_db/src/defs.rs

@@ -94,7 +94,7 @@ impl Definition {
 
     pub fn name(&self, db: &RootDatabase) -> Option<Name> {
         let name = match self {
-            Definition::Macro(it) => it.name(db)?,
+            Definition::Macro(it) => it.name(db),
             Definition::Field(it) => it.name(db),
             Definition::Module(it) => it.name(db)?,
             Definition::Function(it) => it.name(db),

crates/ide_db/src/helpers.rs

@@ -15,7 +15,7 @@ pub fn item_name(db: &RootDatabase, item: ItemInNs) -> Option<Name> {
     match item {
         ItemInNs::Types(module_def_id) => ModuleDef::from(module_def_id).name(db),
         ItemInNs::Values(module_def_id) => ModuleDef::from(module_def_id).name(db),
-        ItemInNs::Macros(macro_def_id) => Macro::from(macro_def_id).name(db),
+        ItemInNs::Macros(macro_def_id) => Some(Macro::from(macro_def_id).name(db)),
     }
 }