hir/semantics/
child_by_source.rs

1//! When *constructing* `hir`, we start at some parent syntax node and recursively
2//! lower the children.
3//!
4//! This module allows one to go in the opposite direction: start with a syntax
5//! node for a *child*, and get its hir.
6
7use base_db::SourceDatabase;
8use either::Either;
9use hir_expand::HirFileId;
10use span::AstIdNode;
11use syntax::{AstPtr, ast};
12
13use hir_def::{
14    AdtId, AssocItemId, AstIdLoc, AttrDefId, DefWithBodyId, EnumId, FieldId, GenericDefId, ImplId,
15    LifetimeParamId, Lookup, MacroId, ModuleDefId, ModuleId, TraitId, TypeOrConstParamId,
16    VariantId,
17    attrs::{AttrFlags, Docs},
18    dyn_map::{
19        DynMap,
20        keys::{self, Key},
21    },
22    expr_store::Body,
23    hir::generics::GenericParams,
24    item_scope::ItemScope,
25    signatures::{EnumSignature, ImplSignature, TraitSignature},
26    src::{HasChildSource, HasSource},
27};
28
29pub(crate) trait ChildBySource {
30    fn child_by_source(&self, db: &dyn SourceDatabase, file_id: HirFileId) -> DynMap {
31        let mut res = DynMap::default();
32        self.child_by_source_to(db, &mut res, file_id);
33        res
34    }
35    fn child_by_source_to(&self, db: &dyn SourceDatabase, map: &mut DynMap, file_id: HirFileId);
36}
37
38impl ChildBySource for Docs {
39    fn child_by_source_to(&self, db: &dyn SourceDatabase, res: &mut DynMap, file_id: HirFileId) {
40        self.macro_calls().filter(|(ast_id, _)| ast_id.file_id == file_id).for_each(
41            |(ast_id, call_id)| {
42                let ptr = ast_id.to_ptr(db);
43                res[keys::MACRO_CALL].insert(ptr, call_id);
44            },
45        );
46    }
47}
48
49impl ChildBySource for AttrDefId {
50    fn child_by_source_to(&self, db: &dyn SourceDatabase, map: &mut DynMap, file_id: HirFileId) {
51        if let Some(docs) = AttrFlags::docs(db, *self) {
52            docs.child_by_source_to(db, map, file_id);
53        }
54    }
55}
56
57impl ChildBySource for TraitId {
58    fn child_by_source_to(&self, db: &dyn SourceDatabase, res: &mut DynMap, file_id: HirFileId) {
59        let data = self.trait_items(db);
60
61        data.macro_calls().filter(|(ast_id, _)| ast_id.file_id == file_id).for_each(
62            |(ast_id, call_id)| {
63                let ptr = ast_id.to_ptr(db);
64                if let Some(ptr) = ptr.cast::<ast::MacroCall>() {
65                    res[keys::MACRO_CALL].insert(ptr, call_id);
66                } else {
67                    res[keys::ATTR_MACRO_CALL].insert(ptr, call_id);
68                }
69            },
70        );
71        data.items.iter().for_each(|&(_, item)| {
72            add_assoc_item(db, res, file_id, item);
73        });
74        let (_, source_map) = TraitSignature::with_source_map(db, *self);
75        source_map.expansions().filter(|(ast, _)| ast.file_id == file_id).for_each(
76            |(ast, &exp_id)| {
77                res[keys::MACRO_CALL].insert(ast.value, exp_id);
78            },
79        );
80
81        AttrDefId::from(*self).child_by_source_to(db, res, file_id);
82    }
83}
84
85impl ChildBySource for ImplId {
86    fn child_by_source_to(&self, db: &dyn SourceDatabase, res: &mut DynMap, file_id: HirFileId) {
87        let data = self.impl_items(db);
88        data.macro_calls().filter(|(ast_id, _)| ast_id.file_id == file_id).for_each(
89            |(ast_id, call_id)| {
90                let ptr = ast_id.to_ptr(db);
91                if let Some(ptr) = ptr.cast::<ast::MacroCall>() {
92                    res[keys::MACRO_CALL].insert(ptr, call_id);
93                } else {
94                    res[keys::ATTR_MACRO_CALL].insert(ptr, call_id);
95                }
96            },
97        );
98        data.items.iter().for_each(|&(_, item)| {
99            add_assoc_item(db, res, file_id, item);
100        });
101        let (_, source_map) = ImplSignature::with_source_map(db, *self);
102        source_map.expansions().filter(|(ast, _)| ast.file_id == file_id).for_each(
103            |(ast, &exp_id)| {
104                res[keys::MACRO_CALL].insert(ast.value, exp_id);
105            },
106        );
107
108        AttrDefId::from(*self).child_by_source_to(db, res, file_id);
109    }
110}
111
112impl ChildBySource for ModuleId {
113    fn child_by_source_to(&self, db: &dyn SourceDatabase, res: &mut DynMap, file_id: HirFileId) {
114        let def_map = self.def_map(db);
115        let module_data = &def_map[*self];
116        module_data.scope.child_by_source_to(db, res, file_id);
117
118        AttrDefId::from(*self).child_by_source_to(db, res, file_id);
119    }
120}
121
122impl ChildBySource for ItemScope {
123    fn child_by_source_to(&self, db: &dyn SourceDatabase, res: &mut DynMap, file_id: HirFileId) {
124        self.declarations().for_each(|item| add_module_def(db, res, file_id, item));
125        self.impls().for_each(|imp| insert_item_loc(db, res, file_id, imp, keys::IMPL));
126        self.extern_blocks().for_each(|extern_block| {
127            insert_item_loc(db, res, file_id, extern_block, keys::EXTERN_BLOCK)
128        });
129        self.extern_crate_decls()
130            .for_each(|ext| insert_item_loc(db, res, file_id, ext, keys::EXTERN_CRATE));
131        self.use_decls().for_each(|ext| insert_item_loc(db, res, file_id, ext, keys::USE));
132        self.unnamed_consts()
133            .for_each(|konst| insert_item_loc(db, res, file_id, konst, keys::CONST));
134        self.attr_macro_invocs().filter(|(id, _)| id.file_id == file_id).for_each(
135            |(ast_id, call_id)| {
136                res[keys::ATTR_MACRO_CALL].insert(ast_id.to_ptr(db), call_id);
137            },
138        );
139        self.legacy_macros().for_each(|(_, ids)| {
140            ids.iter().for_each(|&id| {
141                if let MacroId::MacroRulesId(id) = id {
142                    let loc = id.lookup(db);
143                    if loc.id.file_id == file_id {
144                        res[keys::MACRO_RULES].insert(loc.ast_ptr(db).value, id);
145                    }
146                }
147            })
148        });
149        self.derive_macro_invocs().filter(|(id, _)| id.file_id == file_id).for_each(
150            |(ast_id, calls)| {
151                let adt = ast_id.to_node(db);
152                calls.for_each(|(attr_id, call_id, calls)| {
153                    // FIXME: Is this the right crate?
154                    let krate = call_id.lookup(db).krate;
155                    let (_, attr) = attr_id.find_attr_range_with_source(db, krate, &adt);
156                    res[keys::DERIVE_MACRO_CALL]
157                        .insert(AstPtr::new(&attr), (attr_id, call_id, calls.into()));
158                });
159            },
160        );
161        self.iter_macro_invoc().filter(|(id, _)| id.file_id == file_id).for_each(
162            |(ast_id, &call)| {
163                let ast = ast_id.to_ptr(db);
164                res[keys::MACRO_CALL].insert(ast, call);
165            },
166        );
167        fn add_module_def(
168            db: &dyn SourceDatabase,
169            map: &mut DynMap,
170            file_id: HirFileId,
171            item: ModuleDefId,
172        ) {
173            match item {
174                ModuleDefId::FunctionId(id) => {
175                    insert_item_loc(db, map, file_id, id, keys::FUNCTION)
176                }
177                ModuleDefId::ConstId(id) => insert_item_loc(db, map, file_id, id, keys::CONST),
178                ModuleDefId::TypeAliasId(id) => {
179                    insert_item_loc(db, map, file_id, id, keys::TYPE_ALIAS)
180                }
181                ModuleDefId::StaticId(id) => insert_item_loc(db, map, file_id, id, keys::STATIC),
182                ModuleDefId::TraitId(id) => insert_item_loc(db, map, file_id, id, keys::TRAIT),
183                ModuleDefId::AdtId(adt) => match adt {
184                    AdtId::StructId(id) => insert_item_loc(db, map, file_id, id, keys::STRUCT),
185                    AdtId::UnionId(id) => insert_item_loc(db, map, file_id, id, keys::UNION),
186                    AdtId::EnumId(id) => insert_item_loc(db, map, file_id, id, keys::ENUM),
187                },
188                ModuleDefId::MacroId(id) => match id {
189                    MacroId::Macro2Id(id) => insert_item_loc(db, map, file_id, id, keys::MACRO2),
190                    MacroId::MacroRulesId(id) => {
191                        insert_item_loc(db, map, file_id, id, keys::MACRO_RULES)
192                    }
193                    MacroId::ProcMacroId(id) => {
194                        insert_item_loc(db, map, file_id, id, keys::PROC_MACRO)
195                    }
196                },
197                ModuleDefId::ModuleId(_)
198                | ModuleDefId::EnumVariantId(_)
199                | ModuleDefId::BuiltinType(_) => (),
200            }
201        }
202    }
203}
204
205impl ChildBySource for VariantId {
206    fn child_by_source_to(&self, db: &dyn SourceDatabase, res: &mut DynMap, file_id: HirFileId) {
207        let arena_map = self.child_source(db);
208        let arena_map = arena_map.as_ref();
209        let parent = *self;
210        for (local_id, source) in arena_map.value.iter() {
211            let id = FieldId { parent, local_id };
212            match source.clone() {
213                Either::Left(source) => res[keys::TUPLE_FIELD].insert(AstPtr::new(&source), id),
214                Either::Right(source) => res[keys::RECORD_FIELD].insert(AstPtr::new(&source), id),
215            }
216        }
217        let (_, sm) = self.fields_with_source_map(db);
218        sm.expansions().for_each(|(ast, &exp_id)| res[keys::MACRO_CALL].insert(ast.value, exp_id));
219
220        AttrDefId::from(*self).child_by_source_to(db, res, file_id);
221        AttrFlags::fields_docs(db, *self)
222            .values()
223            .flatten()
224            .for_each(|docs| docs.child_by_source_to(db, res, file_id));
225    }
226}
227
228impl ChildBySource for EnumId {
229    fn child_by_source_to(&self, db: &dyn SourceDatabase, res: &mut DynMap, file_id: HirFileId) {
230        let loc = &self.lookup(db);
231        if file_id != loc.id.file_id {
232            return;
233        }
234
235        let ast_id_map = loc.id.file_id.ast_id_map(db);
236
237        self.enum_variants(db).variants.values().for_each(|&(variant, _)| {
238            res[keys::ENUM_VARIANT].insert(ast_id_map.get(variant.lookup(db).id.value), variant);
239        });
240        let (_, source_map) = EnumSignature::with_source_map(db, *self);
241        source_map
242            .expansions()
243            .filter(|(ast, _)| ast.file_id == file_id)
244            .for_each(|(ast, &exp_id)| res[keys::MACRO_CALL].insert(ast.value, exp_id));
245
246        AttrDefId::from(*self).child_by_source_to(db, res, file_id);
247    }
248}
249
250impl ChildBySource for DefWithBodyId {
251    fn child_by_source_to(&self, db: &dyn SourceDatabase, res: &mut DynMap, file_id: HirFileId) {
252        let (body, sm) = Body::with_source_map(db, *self);
253        if let &DefWithBodyId::VariantId(v) = self {
254            VariantId::EnumVariantId(v).child_by_source_to(db, res, file_id)
255        }
256
257        sm.expansions().filter(|(ast, _)| ast.file_id == file_id).for_each(|(ast, &exp_id)| {
258            res[keys::MACRO_CALL].insert(ast.value, exp_id);
259        });
260
261        for (block, def_map) in body.blocks(db) {
262            // All block expressions are merged into the same map, because they logically all add
263            // inner items to the containing `DefWithBodyId`.
264            def_map[def_map.root].scope.child_by_source_to(db, res, file_id);
265            res[keys::BLOCK].insert(block.ast_id(db).to_ptr(db), block);
266        }
267    }
268}
269
270impl ChildBySource for GenericDefId {
271    fn child_by_source_to(&self, db: &dyn SourceDatabase, res: &mut DynMap, file_id: HirFileId) {
272        let (gfile_id, generic_params_list) = self.file_id_and_params_of(db);
273        if gfile_id != file_id {
274            return;
275        }
276
277        let (generic_params, _, source_map) = GenericParams::with_source_map(db, *self);
278        let mut toc_idx_iter = generic_params.iter_type_or_consts().map(|(idx, _)| idx);
279        let lts_idx_iter = generic_params.iter_lt().map(|(idx, _)| idx);
280
281        // For traits the first type index is `Self`, skip it.
282        if let GenericDefId::TraitId(_) = *self {
283            toc_idx_iter.next().unwrap(); // advance_by(1);
284        }
285
286        if let Some(generic_params_list) = generic_params_list {
287            for (local_id, ast_param) in
288                toc_idx_iter.zip(generic_params_list.type_or_const_params())
289            {
290                let id = TypeOrConstParamId { parent: *self, local_id };
291                match ast_param {
292                    ast::TypeOrConstParam::Type(a) => {
293                        res[keys::TYPE_PARAM].insert(AstPtr::new(&a), id)
294                    }
295                    ast::TypeOrConstParam::Const(a) => {
296                        res[keys::CONST_PARAM].insert(AstPtr::new(&a), id)
297                    }
298                }
299            }
300            for (local_id, ast_param) in lts_idx_iter.zip(generic_params_list.lifetime_params()) {
301                let id = LifetimeParamId { parent: *self, local_id };
302                res[keys::LIFETIME_PARAM].insert(AstPtr::new(&ast_param), id);
303            }
304        }
305
306        source_map
307            .expansions()
308            .filter(|(ast, _)| ast.file_id == file_id)
309            .for_each(|(ast, &exp_id)| res[keys::MACRO_CALL].insert(ast.value, exp_id));
310
311        let attr_def = match *self {
312            GenericDefId::AdtId(it) => AttrDefId::from(it),
313            GenericDefId::ConstId(it) => it.into(),
314            GenericDefId::FunctionId(it) => it.into(),
315            GenericDefId::ImplId(it) => it.into(),
316            GenericDefId::StaticId(it) => it.into(),
317            GenericDefId::TraitId(it) => it.into(),
318            GenericDefId::TypeAliasId(it) => it.into(),
319        };
320        attr_def.child_by_source_to(db, res, file_id);
321    }
322}
323
324fn insert_item_loc<ID, N, Data>(
325    db: &dyn SourceDatabase,
326    res: &mut DynMap,
327    file_id: HirFileId,
328    id: ID,
329    key: Key<N, ID>,
330) where
331    ID: Lookup<Data = Data> + 'static,
332    Data: AstIdLoc<Ast = N>,
333    N: AstIdNode + 'static,
334{
335    let loc = id.lookup(db);
336    if loc.ast_id().file_id == file_id {
337        res[key].insert(loc.ast_ptr(db).value, id)
338    }
339}
340
341fn add_assoc_item(
342    db: &dyn SourceDatabase,
343    res: &mut DynMap,
344    file_id: HirFileId,
345    item: AssocItemId,
346) {
347    match item {
348        AssocItemId::FunctionId(func) => insert_item_loc(db, res, file_id, func, keys::FUNCTION),
349        AssocItemId::ConstId(konst) => insert_item_loc(db, res, file_id, konst, keys::CONST),
350        AssocItemId::TypeAliasId(ty) => insert_item_loc(db, res, file_id, ty, keys::TYPE_ALIAS),
351    }
352}
hir/semantics/child_by_source.rs

hir/semantics/
child_by_source.rs
