]> git.lizzy.rs Git - rust.git/blobdiff - crates/hir_def/src/child_by_source.rs
parameters.split_last()
[rust.git] / crates / hir_def / src / child_by_source.rs
index 2a331dcaf9db2e38532e7fd9e4f37e82c32f46ce..5c32a31e443d5f3092f8758111a09764bfaabb0c 100644 (file)
@@ -5,6 +5,8 @@
 //! node for a *child*, and get its hir.
 
 use either::Either;
+use hir_expand::HirFileId;
+use syntax::ast::HasDocComments;
 
 use crate::{
     db::DefDatabase,
 };
 
 pub trait ChildBySource {
-    fn child_by_source(&self, db: &dyn DefDatabase) -> DynMap {
+    fn child_by_source(&self, db: &dyn DefDatabase, file_id: HirFileId) -> DynMap {
         let mut res = DynMap::default();
-        self.child_by_source_to(db, &mut res);
+        self.child_by_source_to(db, &mut res, file_id);
         res
     }
-    fn child_by_source_to(&self, db: &dyn DefDatabase, map: &mut DynMap);
+    fn child_by_source_to(&self, db: &dyn DefDatabase, map: &mut DynMap, file_id: HirFileId);
 }
 
 impl ChildBySource for TraitId {
-    fn child_by_source_to(&self, db: &dyn DefDatabase, res: &mut DynMap) {
+    fn child_by_source_to(&self, db: &dyn DefDatabase, res: &mut DynMap, file_id: HirFileId) {
         let data = db.trait_data(*self);
-        for (_name, item) in data.items.iter() {
-            match *item {
-                AssocItemId::FunctionId(func) => {
-                    let src = func.lookup(db).source(db);
-                    res[keys::FUNCTION].insert(src, func)
-                }
-                AssocItemId::ConstId(konst) => {
-                    let src = konst.lookup(db).source(db);
-                    res[keys::CONST].insert(src, konst)
-                }
-                AssocItemId::TypeAliasId(ty) => {
-                    let src = ty.lookup(db).source(db);
-                    res[keys::TYPE_ALIAS].insert(src, ty)
-                }
-            }
-        }
+
+        data.attribute_calls().filter(|(ast_id, _)| ast_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);
+            },
+        );
+        data.items.iter().for_each(|&(_, item)| {
+            add_assoc_item(db, res, file_id, item);
+        });
     }
 }
 
 impl ChildBySource for ImplId {
-    fn child_by_source_to(&self, db: &dyn DefDatabase, res: &mut DynMap) {
+    fn child_by_source_to(&self, db: &dyn DefDatabase, res: &mut DynMap, file_id: HirFileId) {
         let data = db.impl_data(*self);
-        for &item in data.items.iter() {
-            match item {
-                AssocItemId::FunctionId(func) => {
-                    let src = func.lookup(db).source(db);
-                    res[keys::FUNCTION].insert(src, func)
-                }
-                AssocItemId::ConstId(konst) => {
-                    let src = konst.lookup(db).source(db);
-                    res[keys::CONST].insert(src, konst)
-                }
-                AssocItemId::TypeAliasId(ty) => {
-                    let src = ty.lookup(db).source(db);
-                    res[keys::TYPE_ALIAS].insert(src, ty)
-                }
+        data.attribute_calls().filter(|(ast_id, _)| ast_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);
+            },
+        );
+        data.items.iter().for_each(|&item| {
+            add_assoc_item(db, res, file_id, item);
+        });
+    }
+}
+
+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)
             }
         }
     }
 }
 
 impl ChildBySource for ModuleId {
-    fn child_by_source_to(&self, db: &dyn DefDatabase, res: &mut DynMap) {
+    fn child_by_source_to(&self, db: &dyn DefDatabase, res: &mut DynMap, file_id: HirFileId) {
         let def_map = self.def_map(db);
         let module_data = &def_map[self.local_id];
-        module_data.scope.child_by_source_to(db, res);
+        module_data.scope.child_by_source_to(db, res, file_id);
     }
 }
 
 impl ChildBySource for ItemScope {
-    fn child_by_source_to(&self, db: &dyn DefDatabase, res: &mut DynMap) {
-        self.declarations().for_each(|item| add_module_def(db, res, item));
-        self.impls().for_each(|imp| add_impl(db, res, imp));
+    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.unnamed_consts().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.macros().for_each(|(_, makro)| {
+            let ast_id = makro.ast_id();
+            if ast_id.either(|it| it.file_id, |it| it.file_id) == file_id {
+                let src = match ast_id {
+                    Either::Left(ast_id) => ast_id.to_node(db.upcast()),
+                    // FIXME: Do we need to add proc-macros into a PROCMACRO dynmap here?
+                    Either::Right(_fn) => return,
+                };
+                res[keys::MACRO].insert(src, makro);
+            }
+        });
+        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);
+            },
+        );
+        self.derive_macro_invocs().filter(|(id, _)| id.file_id == file_id).for_each(
+            |(ast_id, calls)| {
+                let adt = ast_id.to_node(db.upcast());
+                calls.for_each(|(attr_id, calls)| {
+                    if let Some(Either::Left(attr)) =
+                        adt.doc_comments_and_attrs().nth(attr_id.ast_index as usize)
+                    {
+                        res[keys::DERIVE_MACRO_CALL].insert(attr, (attr_id, calls.into()));
+                    }
+                });
+            },
+        );
 
-        fn add_module_def(db: &dyn DefDatabase, map: &mut DynMap, item: ModuleDefId) {
+        fn add_module_def(
+            db: &dyn DefDatabase,
+            map: &mut DynMap,
+            file_id: HirFileId,
+            item: ModuleDefId,
+        ) {
+            macro_rules! insert {
+                ($map:ident[$key:path].$insert:ident($id:ident)) => {{
+                    let loc = $id.lookup(db);
+                    if loc.id.file_id() == file_id {
+                        $map[$key].$insert(loc.source(db).value, $id)
+                    }
+                }};
+            }
             match item {
-                ModuleDefId::FunctionId(func) => {
-                    let src = func.lookup(db).source(db);
-                    map[keys::FUNCTION].insert(src, func)
-                }
-                ModuleDefId::ConstId(konst) => {
-                    let src = konst.lookup(db).source(db);
-                    map[keys::CONST].insert(src, konst)
-                }
-                ModuleDefId::StaticId(statik) => {
-                    let src = statik.lookup(db).source(db);
-                    map[keys::STATIC].insert(src, statik)
-                }
-                ModuleDefId::TypeAliasId(ty) => {
-                    let src = ty.lookup(db).source(db);
-                    map[keys::TYPE_ALIAS].insert(src, ty)
-                }
-                ModuleDefId::TraitId(trait_) => {
-                    let src = trait_.lookup(db).source(db);
-                    map[keys::TRAIT].insert(src, trait_)
-                }
+                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::AdtId(adt) => match adt {
-                    AdtId::StructId(strukt) => {
-                        let src = strukt.lookup(db).source(db);
-                        map[keys::STRUCT].insert(src, strukt)
-                    }
-                    AdtId::UnionId(union_) => {
-                        let src = union_.lookup(db).source(db);
-                        map[keys::UNION].insert(src, union_)
-                    }
-                    AdtId::EnumId(enum_) => {
-                        let src = enum_.lookup(db).source(db);
-                        map[keys::ENUM].insert(src, enum_)
-                    }
+                    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)),
                 },
                 _ => (),
             }
         }
-        fn add_impl(db: &dyn DefDatabase, map: &mut DynMap, imp: ImplId) {
-            let src = imp.lookup(db).source(db);
-            map[keys::IMPL].insert(src, imp)
+        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)
+            }
         }
     }
 }
 
 impl ChildBySource for VariantId {
-    fn child_by_source_to(&self, db: &dyn DefDatabase, res: &mut DynMap) {
+    fn child_by_source_to(&self, db: &dyn DefDatabase, res: &mut DynMap, _: HirFileId) {
         let arena_map = self.child_source(db);
         let arena_map = arena_map.as_ref();
+        let parent = *self;
         for (local_id, source) in arena_map.value.iter() {
-            let id = FieldId { parent: *self, local_id };
-            match source {
-                Either::Left(source) => {
-                    res[keys::TUPLE_FIELD].insert(arena_map.with_value(source.clone()), id)
-                }
-                Either::Right(source) => {
-                    res[keys::RECORD_FIELD].insert(arena_map.with_value(source.clone()), id)
-                }
+            let id = FieldId { parent, local_id };
+            match source.clone() {
+                Either::Left(source) => res[keys::TUPLE_FIELD].insert(source, id),
+                Either::Right(source) => res[keys::RECORD_FIELD].insert(source, id),
             }
         }
     }
 }
 
 impl ChildBySource for EnumId {
-    fn child_by_source_to(&self, db: &dyn DefDatabase, res: &mut DynMap) {
+    fn child_by_source_to(&self, db: &dyn DefDatabase, res: &mut DynMap, _: HirFileId) {
         let arena_map = self.child_source(db);
         let arena_map = arena_map.as_ref();
         for (local_id, source) in arena_map.value.iter() {
             let id = EnumVariantId { parent: *self, local_id };
-            res[keys::VARIANT].insert(arena_map.with_value(source.clone()), id)
+            res[keys::VARIANT].insert(source.clone(), id)
         }
     }
 }
 
 impl ChildBySource for DefWithBodyId {
-    fn child_by_source_to(&self, db: &dyn DefDatabase, res: &mut DynMap) {
+    fn child_by_source_to(&self, db: &dyn DefDatabase, res: &mut DynMap, file_id: HirFileId) {
         let body = db.body(*self);
-        for def_map in body.block_scopes.iter().filter_map(|block| db.block_def_map(*block)) {
+        for (_, def_map) in body.blocks(db) {
             // All block expressions are merged into the same map, because they logically all add
             // inner items to the containing `DefWithBodyId`.
-            def_map[def_map.root()].scope.child_by_source_to(db, res);
+            def_map[def_map.root()].scope.child_by_source_to(db, res, file_id);
         }
     }
 }