Merge rust-lang#11663

11663: Internal: Add hir_def::MacroId, add Macro{Id} to ModuleDef{Id} r=Veykril a=Veykril

With this we can now handle macros like we handle ModuleDefs making them work more like other definitions and allowing us to remove a bunch of special cases. This also enables us to track the modules these macros are defined in, instead of only recording the crate they come from.

Introduces a new class of `MacroId`s (for each of the 3 macro kinds) into `hir_def`. We can't reuse `MacroDefId` as that is defined in `hir_expand` which doesn't know of modules, so now we have two different macro ids, this unfortunately requires some back and forth mapping between the two via database accesses which I hope won't be too expensive.

Co-authored-by: Lukas Wirth <[email protected]>

Author: bors[bot]

crates/hir/src/attrs.rs

@@ -1,6 +1,5 @@
 //! Attributes & documentation for hir types.
 
-use either::Either;
 use hir_def::{
     attr::{AttrsWithOwner, Documentation},
     item_scope::ItemInNs,
@@ -9,13 +8,13 @@ use hir_def::{
     resolver::HasResolver,
     AttrDefId, GenericParamId, ModuleDefId,
 };
-use hir_expand::{hygiene::Hygiene, MacroDefId};
+use hir_expand::hygiene::Hygiene;
 use hir_ty::db::HirDatabase;
 use syntax::{ast, AstNode};
 
 use crate::{
     Adt, AssocItem, Const, ConstParam, Enum, Field, Function, GenericParam, Impl, LifetimeParam,
-    MacroDef, Module, ModuleDef, Static, Struct, Trait, TypeAlias, TypeParam, Union, Variant,
+    Macro, Module, ModuleDef, Static, Struct, Trait, TypeAlias, TypeParam, Union, Variant,
 };
 
 pub trait HasAttrs {
@@ -26,7 +25,7 @@ pub trait HasAttrs {
         db: &dyn HirDatabase,
         link: &str,
         ns: Option<Namespace>,
-    ) -> Option<Either<ModuleDef, MacroDef>>;
+    ) -> Option<ModuleDef>;
 }
 
 #[derive(PartialEq, Eq, Hash, Copy, Clone, Debug)]
@@ -47,9 +46,9 @@ macro_rules! impl_has_attrs {
                 let def = AttrDefId::$def_id(self.into());
                 db.attrs(def).docs()
             }
-            fn resolve_doc_path(self, db: &dyn HirDatabase, link: &str, ns: Option<Namespace>) -> Option<Either<ModuleDef, MacroDef>> {
+            fn resolve_doc_path(self, db: &dyn HirDatabase, link: &str, ns: Option<Namespace>) -> Option<ModuleDef> {
                 let def = AttrDefId::$def_id(self.into());
-                resolve_doc_path(db, def, link, ns).map(|it| it.map_left(ModuleDef::from).map_right(MacroDef::from))
+                resolve_doc_path(db, def, link, ns).map(ModuleDef::from)
             }
         }
     )*};
@@ -62,7 +61,7 @@ impl_has_attrs![
     (Const, ConstId),
     (Trait, TraitId),
     (TypeAlias, TypeAliasId),
-    (MacroDef, MacroDefId),
+    (Macro, MacroId),
     (Function, FunctionId),
     (Adt, AdtId),
     (Module, ModuleId),
@@ -79,7 +78,7 @@ macro_rules! impl_has_attrs_enum {
             fn docs(self, db: &dyn HirDatabase) -> Option<Documentation> {
                 $enum::$variant(self).docs(db)
             }
-            fn resolve_doc_path(self, db: &dyn HirDatabase, link: &str, ns: Option<Namespace>) -> Option<Either<ModuleDef, MacroDef>> {
+            fn resolve_doc_path(self, db: &dyn HirDatabase, link: &str, ns: Option<Namespace>) -> Option<ModuleDef> {
                 $enum::$variant(self).resolve_doc_path(db, link, ns)
             }
         }
@@ -111,7 +110,7 @@ impl HasAttrs for AssocItem {
         db: &dyn HirDatabase,
         link: &str,
         ns: Option<Namespace>,
-    ) -> Option<Either<ModuleDef, MacroDef>> {
+    ) -> Option<ModuleDef> {
         match self {
             AssocItem::Function(it) => it.resolve_doc_path(db, link, ns),
             AssocItem::Const(it) => it.resolve_doc_path(db, link, ns),
@@ -125,7 +124,7 @@ fn resolve_doc_path(
     def: AttrDefId,
     link: &str,
     ns: Option<Namespace>,
-) -> Option<Either<ModuleDefId, MacroDefId>> {
+) -> Option<ModuleDefId> {
     let resolver = match def {
         AttrDefId::ModuleId(it) => it.resolver(db.upcast()),
         AttrDefId::FieldId(it) => it.parent.resolver(db.upcast()),
@@ -138,14 +137,13 @@ fn resolve_doc_path(
         AttrDefId::TypeAliasId(it) => it.resolver(db.upcast()),
         AttrDefId::ImplId(it) => it.resolver(db.upcast()),
         AttrDefId::ExternBlockId(it) => it.resolver(db.upcast()),
+        AttrDefId::MacroId(it) => it.resolver(db.upcast()),
         AttrDefId::GenericParamId(it) => match it {
             GenericParamId::TypeParamId(it) => it.parent(),
             GenericParamId::ConstParamId(it) => it.parent(),
             GenericParamId::LifetimeParamId(it) => it.parent,
         }
         .resolver(db.upcast()),
-        // FIXME
-        AttrDefId::MacroDefId(_) => return None,
     };
 
     let modpath = {
@@ -167,13 +165,13 @@ fn resolve_doc_path(
         resolved
     };
     match ns {
-        Some(Namespace::Types) => resolved.take_types().map(Either::Left),
-        Some(Namespace::Values) => resolved.take_values().map(Either::Left),
-        Some(Namespace::Macros) => resolved.take_macros().map(Either::Right),
+        Some(Namespace::Types) => resolved.take_types(),
+        Some(Namespace::Values) => resolved.take_values(),
+        Some(Namespace::Macros) => resolved.take_macros().map(ModuleDefId::MacroId),
         None => resolved.iter_items().next().map(|it| match it {
-            ItemInNs::Types(it) => Either::Left(it),
-            ItemInNs::Values(it) => Either::Left(it),
-            ItemInNs::Macros(it) => Either::Right(it),
+            ItemInNs::Types(it) => it,
+            ItemInNs::Values(it) => it,
+            ItemInNs::Macros(it) => ModuleDefId::MacroId(it),
         }),
     }
 }

crates/hir/src/from_id.rs

@@ -45,7 +45,7 @@ from_id![
     (hir_def::TypeParamId, crate::TypeParam),
     (hir_def::ConstParamId, crate::ConstParam),
     (hir_def::LifetimeParamId, crate::LifetimeParam),
-    (hir_expand::MacroDefId, crate::MacroDef)
+    (hir_def::MacroId, crate::Macro)
 ];
 
 impl From<AdtId> for Adt {
@@ -112,6 +112,7 @@ impl From<ModuleDefId> for ModuleDef {
             ModuleDefId::TraitId(it) => ModuleDef::Trait(it.into()),
             ModuleDefId::TypeAliasId(it) => ModuleDef::TypeAlias(it.into()),
             ModuleDefId::BuiltinType(it) => ModuleDef::BuiltinType(it.into()),
+            ModuleDefId::MacroId(it) => ModuleDef::Macro(it.into()),
         }
     }
 }
@@ -128,6 +129,7 @@ impl From<ModuleDef> for ModuleDefId {
             ModuleDef::Trait(it) => ModuleDefId::TraitId(it.into()),
             ModuleDef::TypeAlias(it) => ModuleDefId::TypeAliasId(it.into()),
             ModuleDef::BuiltinType(it) => ModuleDefId::BuiltinType(it.into()),
+            ModuleDef::Macro(it) => ModuleDefId::MacroId(it.into()),
         }
     }
 }

crates/hir/src/has_source.rs

@@ -4,13 +4,13 @@ use either::Either;
 use hir_def::{
     nameres::{ModuleOrigin, ModuleSource},
     src::{HasChildSource, HasSource as _},
-    Lookup, VariantId,
+    Lookup, MacroId, VariantId,
 };
 use hir_expand::InFile;
 use syntax::ast;
 
 use crate::{
-    db::HirDatabase, Adt, Const, Enum, Field, FieldSource, Function, Impl, LifetimeParam, MacroDef,
+    db::HirDatabase, Adt, Const, Enum, Field, FieldSource, Function, Impl, LifetimeParam, Macro,
     Module, Static, Struct, Trait, TypeAlias, TypeOrConstParam, Union, Variant,
 };
 
@@ -123,13 +123,26 @@ impl HasSource for TypeAlias {
         Some(self.id.lookup(db.upcast()).source(db.upcast()))
     }
 }
-impl HasSource for MacroDef {
+impl HasSource for Macro {
     type Ast = Either<ast::Macro, ast::Fn>;
     fn source(self, db: &dyn HirDatabase) -> Option<InFile<Self::Ast>> {
-        Some(self.id.ast_id().either(
-            |id| id.with_value(Either::Left(id.to_node(db.upcast()))),
-            |id| id.with_value(Either::Right(id.to_node(db.upcast()))),
-        ))
+        match self.id {
+            MacroId::Macro2Id(it) => Some(
+                it.lookup(db.upcast())
+                    .source(db.upcast())
+                    .map(ast::Macro::MacroDef)
+                    .map(Either::Left),
+            ),
+            MacroId::MacroRulesId(it) => Some(
+                it.lookup(db.upcast())
+                    .source(db.upcast())
+                    .map(ast::Macro::MacroRules)
+                    .map(Either::Left),
+            ),
+            MacroId::ProcMacroId(it) => {
+                Some(it.lookup(db.upcast()).source(db.upcast()).map(Either::Right))
+            }
+        }
     }
 }
 impl HasSource for Impl {