Auto merge of #16525 - Veykril:item-loc, r=Veykril

Abstract more over ItemTreeLoc-like structs

Allows reducing some code duplication by using functions generic over said structs. The diff isn't negative due to me adding some additional impls for completeness.

Author: bors

crates/hir-def/src/attr.rs

@@ -24,12 +24,11 @@ use triomphe::Arc;
 
 use crate::{
     db::DefDatabase,
-    item_tree::{AttrOwner, Fields, ItemTreeId, ItemTreeModItemNode},
+    item_tree::{AttrOwner, Fields, ItemTreeNode},
     lang_item::LangItem,
     nameres::{ModuleOrigin, ModuleSource},
     src::{HasChildSource, HasSource},
-    AdtId, AssocItemLoc, AttrDefId, GenericParamId, ItemLoc, LocalFieldId, Lookup, MacroId,
-    VariantId,
+    AdtId, AttrDefId, GenericParamId, ItemTreeLoc, LocalFieldId, Lookup, MacroId, VariantId,
 };
 
 /// Desugared attributes of an item post `cfg_attr` expansion.
@@ -356,12 +355,7 @@ impl AttrsWithOwner {
             AttrDefId::FieldId(it) => {
                 return db.fields_attrs(it.parent)[it.local_id].clone();
             }
-            // FIXME: DRY this up
-            AttrDefId::EnumVariantId(it) => {
-                let id = it.lookup(db).id;
-                let tree = id.item_tree(db);
-                tree.raw_attrs(id.value.into()).clone()
-            }
+            AttrDefId::EnumVariantId(it) => attrs_from_item_tree_loc(db, it),
             AttrDefId::AdtId(it) => match it {
                 AdtId::StructId(it) => attrs_from_item_tree_loc(db, it),
                 AdtId::EnumId(it) => attrs_from_item_tree_loc(db, it),
@@ -370,15 +364,15 @@ impl AttrsWithOwner {
             AttrDefId::TraitId(it) => attrs_from_item_tree_loc(db, it),
             AttrDefId::TraitAliasId(it) => attrs_from_item_tree_loc(db, it),
             AttrDefId::MacroId(it) => match it {
-                MacroId::Macro2Id(it) => attrs_from_item_tree(db, it.lookup(db).id),
-                MacroId::MacroRulesId(it) => attrs_from_item_tree(db, it.lookup(db).id),
-                MacroId::ProcMacroId(it) => attrs_from_item_tree(db, it.lookup(db).id),
+                MacroId::Macro2Id(it) => attrs_from_item_tree_loc(db, it),
+                MacroId::MacroRulesId(it) => attrs_from_item_tree_loc(db, it),
+                MacroId::ProcMacroId(it) => attrs_from_item_tree_loc(db, it),
             },
             AttrDefId::ImplId(it) => attrs_from_item_tree_loc(db, it),
-            AttrDefId::ConstId(it) => attrs_from_item_tree_assoc(db, it),
-            AttrDefId::StaticId(it) => attrs_from_item_tree_assoc(db, it),
-            AttrDefId::FunctionId(it) => attrs_from_item_tree_assoc(db, it),
-            AttrDefId::TypeAliasId(it) => attrs_from_item_tree_assoc(db, it),
+            AttrDefId::ConstId(it) => attrs_from_item_tree_loc(db, it),
+            AttrDefId::StaticId(it) => attrs_from_item_tree_loc(db, it),
+            AttrDefId::FunctionId(it) => attrs_from_item_tree_loc(db, it),
+            AttrDefId::TypeAliasId(it) => attrs_from_item_tree_loc(db, it),
             AttrDefId::GenericParamId(it) => match it {
                 GenericParamId::ConstParamId(it) => {
                     let src = it.parent().child_source(db);
@@ -603,29 +597,14 @@ fn any_has_attrs<'db>(
     id.lookup(db).source(db).map(ast::AnyHasAttrs::new)
 }
 
-fn attrs_from_item_tree<N: ItemTreeModItemNode>(
-    db: &dyn DefDatabase,
-    id: ItemTreeId<N>,
-) -> RawAttrs {
-    let tree = id.item_tree(db);
-    let mod_item = N::id_to_mod_item(id.value);
-    tree.raw_attrs(mod_item.into()).clone()
-}
-
-fn attrs_from_item_tree_loc<'db, N: ItemTreeModItemNode>(
+fn attrs_from_item_tree_loc<'db, N: ItemTreeNode>(
     db: &(dyn DefDatabase + 'db),
-    lookup: impl Lookup<Database<'db> = dyn DefDatabase + 'db, Data = ItemLoc<N>>,
+    lookup: impl Lookup<Database<'db> = dyn DefDatabase + 'db, Data = impl ItemTreeLoc<Id = N>>,
 ) -> RawAttrs {
-    let id = lookup.lookup(db).id;
-    attrs_from_item_tree(db, id)
-}
-
-fn attrs_from_item_tree_assoc<'db, N: ItemTreeModItemNode>(
-    db: &(dyn DefDatabase + 'db),
-    lookup: impl Lookup<Database<'db> = dyn DefDatabase + 'db, Data = AssocItemLoc<N>>,
-) -> RawAttrs {
-    let id = lookup.lookup(db).id;
-    attrs_from_item_tree(db, id)
+    let id = lookup.lookup(db).item_tree_id();
+    let tree = id.item_tree(db);
+    let attr_owner = N::attr_owner(id.value);
+    tree.raw_attrs(attr_owner).clone()
 }
 
 pub(crate) fn fields_attrs_source_map(

crates/hir-def/src/child_by_source.rs

@@ -9,12 +9,16 @@ use hir_expand::{attrs::collect_attrs, HirFileId};
 
 use crate::{
     db::DefDatabase,
-    dyn_map::{keys, DynMap},
+    dyn_map::{
+        keys::{self, Key},
+        DynMap,
+    },
     item_scope::ItemScope,
+    item_tree::ItemTreeNode,
     nameres::DefMap,
     src::{HasChildSource, HasSource},
-    AdtId, AssocItemId, DefWithBodyId, EnumId, ExternCrateId, FieldId, ImplId, Lookup, MacroId,
-    ModuleDefId, ModuleId, TraitId, UseId, VariantId,
+    AdtId, AssocItemId, DefWithBodyId, EnumId, FieldId, ImplId, ItemTreeLoc, Lookup, MacroId,
+    ModuleDefId, ModuleId, TraitId, VariantId,
 };
 
 pub trait ChildBySource {
@@ -57,24 +61,9 @@ impl ChildBySource for ImplId {
 
 fn add_assoc_item(db: &dyn DefDatabase, res: &mut DynMap, file_id: HirFileId, item: AssocItemId) {
     match item {
-        AssocItemId::FunctionId(func) => {
-            let loc = func.lookup(db);
-            if loc.id.file_id() == file_id {
-                res[keys::FUNCTION].insert(loc.source(db).value, func)
-            }
-        }
-        AssocItemId::ConstId(konst) => {
-            let loc = konst.lookup(db);
-            if loc.id.file_id() == file_id {
-                res[keys::CONST].insert(loc.source(db).value, konst)
-            }
-        }
-        AssocItemId::TypeAliasId(ty) => {
-            let loc = ty.lookup(db);
-            if loc.id.file_id() == file_id {
-                res[keys::TYPE_ALIAS].insert(loc.source(db).value, ty)
-            }
-        }
+        AssocItemId::FunctionId(func) => insert_item_loc(db, res, file_id, func, keys::FUNCTION),
+        AssocItemId::ConstId(konst) => insert_item_loc(db, res, file_id, konst, keys::CONST),
+        AssocItemId::TypeAliasId(ty) => insert_item_loc(db, res, file_id, ty, keys::TYPE_ALIAS),
     }
 }
 
@@ -89,15 +78,12 @@ impl ChildBySource for ModuleId {
 impl ChildBySource for ItemScope {
     fn child_by_source_to(&self, db: &dyn DefDatabase, res: &mut DynMap, file_id: HirFileId) {
         self.declarations().for_each(|item| add_module_def(db, res, file_id, item));
-        self.impls().for_each(|imp| add_impl(db, res, file_id, imp));
-        self.extern_crate_decls().for_each(|ext| add_extern_crate(db, res, file_id, ext));
-        self.use_decls().for_each(|ext| add_use(db, res, file_id, ext));
-        self.unnamed_consts(db).for_each(|konst| {
-            let loc = konst.lookup(db);
-            if loc.id.file_id() == file_id {
-                res[keys::CONST].insert(loc.source(db).value, konst);
-            }
-        });
+        self.impls().for_each(|imp| insert_item_loc(db, res, file_id, imp, keys::IMPL));
+        self.extern_crate_decls()
+            .for_each(|ext| insert_item_loc(db, res, file_id, ext, keys::EXTERN_CRATE));
+        self.use_decls().for_each(|ext| insert_item_loc(db, res, file_id, ext, keys::USE));
+        self.unnamed_consts(db)
+            .for_each(|konst| insert_item_loc(db, res, file_id, konst, keys::CONST));
         self.attr_macro_invocs().filter(|(id, _)| id.file_id == file_id).for_each(
             |(ast_id, call_id)| {
                 res[keys::ATTR_MACRO_CALL].insert(ast_id.to_node(db.upcast()), call_id);
@@ -141,16 +127,22 @@ impl ChildBySource for ItemScope {
                 }};
             }
             match item {
-                ModuleDefId::FunctionId(id) => insert!(map[keys::FUNCTION].insert(id)),
-                ModuleDefId::ConstId(id) => insert!(map[keys::CONST].insert(id)),
-                ModuleDefId::StaticId(id) => insert!(map[keys::STATIC].insert(id)),
-                ModuleDefId::TypeAliasId(id) => insert!(map[keys::TYPE_ALIAS].insert(id)),
-                ModuleDefId::TraitId(id) => insert!(map[keys::TRAIT].insert(id)),
-                ModuleDefId::TraitAliasId(id) => insert!(map[keys::TRAIT_ALIAS].insert(id)),
+                ModuleDefId::FunctionId(id) => {
+                    insert_item_loc(db, map, file_id, id, keys::FUNCTION)
+                }
+                ModuleDefId::ConstId(id) => insert_item_loc(db, map, file_id, id, keys::CONST),
+                ModuleDefId::TypeAliasId(id) => {
+                    insert_item_loc(db, map, file_id, id, keys::TYPE_ALIAS)
+                }
+                ModuleDefId::StaticId(id) => insert_item_loc(db, map, file_id, id, keys::STATIC),
+                ModuleDefId::TraitId(id) => insert_item_loc(db, map, file_id, id, keys::TRAIT),
+                ModuleDefId::TraitAliasId(id) => {
+                    insert_item_loc(db, map, file_id, id, keys::TRAIT_ALIAS)
+                }
                 ModuleDefId::AdtId(adt) => match adt {
-                    AdtId::StructId(id) => insert!(map[keys::STRUCT].insert(id)),
-                    AdtId::UnionId(id) => insert!(map[keys::UNION].insert(id)),
-                    AdtId::EnumId(id) => insert!(map[keys::ENUM].insert(id)),
+                    AdtId::StructId(id) => insert_item_loc(db, map, file_id, id, keys::STRUCT),
+                    AdtId::UnionId(id) => insert_item_loc(db, map, file_id, id, keys::UNION),
+                    AdtId::EnumId(id) => insert_item_loc(db, map, file_id, id, keys::ENUM),
                 },
                 ModuleDefId::MacroId(id) => match id {
                     MacroId::Macro2Id(id) => insert!(map[keys::MACRO2].insert(id)),
@@ -162,29 +154,6 @@ impl ChildBySource for ItemScope {
                 | ModuleDefId::BuiltinType(_) => (),
             }
         }
-        fn add_impl(db: &dyn DefDatabase, map: &mut DynMap, file_id: HirFileId, imp: ImplId) {
-            let loc = imp.lookup(db);
-            if loc.id.file_id() == file_id {
-                map[keys::IMPL].insert(loc.source(db).value, imp)
-            }
-        }
-        fn add_extern_crate(
-            db: &dyn DefDatabase,
-            map: &mut DynMap,
-            file_id: HirFileId,
-            ext: ExternCrateId,
-        ) {
-            let loc = ext.lookup(db);
-            if loc.id.file_id() == file_id {
-                map[keys::EXTERN_CRATE].insert(loc.source(db).value, ext)
-            }
-        }
-        fn add_use(db: &dyn DefDatabase, map: &mut DynMap, file_id: HirFileId, ext: UseId) {
-            let loc = ext.lookup(db);
-            if loc.id.file_id() == file_id {
-                map[keys::USE].insert(loc.source(db).value, ext)
-            }
-        }
     }
 }
 
@@ -237,3 +206,21 @@ impl ChildBySource for DefWithBodyId {
         }
     }
 }
+
+fn insert_item_loc<ID, N, Data>(
+    db: &dyn DefDatabase,
+    res: &mut DynMap,
+    file_id: HirFileId,
+    id: ID,
+    key: Key<N::Source, ID>,
+) where
+    ID: for<'db> Lookup<Database<'db> = dyn DefDatabase + 'db, Data = Data> + 'static,
+    Data: ItemTreeLoc<Id = N>,
+    N: ItemTreeNode,
+    N::Source: 'static,
+{
+    let loc = id.lookup(db);
+    if loc.item_tree_id().file_id() == file_id {
+        res[key].insert(loc.source(db).value, id)
+    }
+}

crates/hir-def/src/generics.rs

@@ -509,47 +509,36 @@ impl GenericParams {
 }
 
 fn file_id_and_params_of(
-    def: GenericDefId,
     db: &dyn DefDatabase,
+    def: GenericDefId,
 ) -> (HirFileId, Option<ast::GenericParamList>) {
     match def {
-        GenericDefId::FunctionId(it) => {
-            let src = it.lookup(db).source(db);
-            (src.file_id, src.value.generic_param_list())
-        }
-        GenericDefId::AdtId(AdtId::StructId(it)) => {
-            let src = it.lookup(db).source(db);
-            (src.file_id, src.value.generic_param_list())
-        }
-        GenericDefId::AdtId(AdtId::UnionId(it)) => {
-            let src = it.lookup(db).source(db);
-            (src.file_id, src.value.generic_param_list())
-        }
-        GenericDefId::AdtId(AdtId::EnumId(it)) => {
-            let src = it.lookup(db).source(db);
-            (src.file_id, src.value.generic_param_list())
-        }
-        GenericDefId::TraitId(it) => {
-            let src = it.lookup(db).source(db);
-            (src.file_id, src.value.generic_param_list())
-        }
-        GenericDefId::TraitAliasId(it) => {
-            let src = it.lookup(db).source(db);
-            (src.file_id, src.value.generic_param_list())
-        }
-        GenericDefId::TypeAliasId(it) => {
-            let src = it.lookup(db).source(db);
-            (src.file_id, src.value.generic_param_list())
-        }
-        GenericDefId::ImplId(it) => {
-            let src = it.lookup(db).source(db);
-            (src.file_id, src.value.generic_param_list())
-        }
+        GenericDefId::FunctionId(it) => file_id_and_params_of_item_loc(db, it),
+        GenericDefId::TypeAliasId(it) => file_id_and_params_of_item_loc(db, it),
+        GenericDefId::ConstId(_) => (FileId::BOGUS.into(), None),
+        GenericDefId::AdtId(AdtId::StructId(it)) => file_id_and_params_of_item_loc(db, it),
+        GenericDefId::AdtId(AdtId::UnionId(it)) => file_id_and_params_of_item_loc(db, it),
+        GenericDefId::AdtId(AdtId::EnumId(it)) => file_id_and_params_of_item_loc(db, it),
+        GenericDefId::TraitId(it) => file_id_and_params_of_item_loc(db, it),
+        GenericDefId::TraitAliasId(it) => file_id_and_params_of_item_loc(db, it),
+        GenericDefId::ImplId(it) => file_id_and_params_of_item_loc(db, it),
         // We won't be using this ID anyway
-        GenericDefId::EnumVariantId(_) | GenericDefId::ConstId(_) => (FileId::BOGUS.into(), None),
+        GenericDefId::EnumVariantId(_) => (FileId::BOGUS.into(), None),
     }
 }
 
+fn file_id_and_params_of_item_loc<Loc>(
+    db: &dyn DefDatabase,
+    def: impl for<'db> Lookup<Database<'db> = dyn DefDatabase + 'db, Data = Loc>,
+) -> (HirFileId, Option<ast::GenericParamList>)
+where
+    Loc: HasSource,
+    Loc::Value: HasGenericParams,
+{
+    let src = def.lookup(db).source(db);
+    (src.file_id, src.value.generic_param_list())
+}
+
 impl HasChildSource<LocalTypeOrConstParamId> for GenericDefId {
     type Value = Either<ast::TypeOrConstParam, ast::TraitOrAlias>;
     fn child_source(
@@ -559,7 +548,7 @@ impl HasChildSource<LocalTypeOrConstParamId> for GenericDefId {
         let generic_params = db.generic_params(*self);
         let mut idx_iter = generic_params.type_or_consts.iter().map(|(idx, _)| idx);
 
-        let (file_id, generic_params_list) = file_id_and_params_of(*self, db);
+        let (file_id, generic_params_list) = file_id_and_params_of(db, *self);
 
         let mut params = ArenaMap::default();
 
@@ -598,7 +587,7 @@ impl HasChildSource<LocalLifetimeParamId> for GenericDefId {
         let generic_params = db.generic_params(*self);
         let idx_iter = generic_params.lifetimes.iter().map(|(idx, _)| idx);
 
-        let (file_id, generic_params_list) = file_id_and_params_of(*self, db);
+        let (file_id, generic_params_list) = file_id_and_params_of(db, *self);
 
         let mut params = ArenaMap::default();
 
@@ -614,7 +603,7 @@ impl HasChildSource<LocalLifetimeParamId> for GenericDefId {
 
 impl ChildBySource for GenericDefId {
     fn child_by_source_to(&self, db: &dyn DefDatabase, res: &mut DynMap, file_id: HirFileId) {
-        let (gfile_id, generic_params_list) = file_id_and_params_of(*self, db);
+        let (gfile_id, generic_params_list) = file_id_and_params_of(db, *self);
         if gfile_id != file_id {
             return;
         }