Branch data Line data Source code
1 : : // Copyright (C) 2020-2024 Free Software Foundation, Inc.
2 : :
3 : : // This file is part of GCC.
4 : :
5 : : // GCC is free software; you can redistribute it and/or modify it under
6 : : // the terms of the GNU General Public License as published by the Free
7 : : // Software Foundation; either version 3, or (at your option) any later
8 : : // version.
9 : :
10 : : // GCC is distributed in the hope that it will be useful, but WITHOUT ANY
11 : : // WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 : : // FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
13 : : // for more details.
14 : :
15 : : // You should have received a copy of the GNU General Public License
16 : : // along with GCC; see the file COPYING3. If not see
17 : : // <http://www.gnu.org/licenses/>.
18 : :
19 : : #ifndef RUST_HIR_MAP_H
20 : : #define RUST_HIR_MAP_H
21 : :
22 : : #include "optional.h"
23 : : #include "rust-system.h"
24 : : #include "rust-location.h"
25 : : #include "rust-mapping-common.h"
26 : : #include "rust-canonical-path.h"
27 : : #include "rust-ast-full-decls.h"
28 : : #include "rust-hir-full-decls.h"
29 : : #include "rust-lang-item.h"
30 : : #include "rust-privacy-common.h"
31 : : #include "libproc_macro_internal/proc_macro.h"
32 : : #include "rust-proc-macro.h"
33 : : #include "optional.h"
34 : :
35 : : namespace Rust {
36 : : namespace Analysis {
37 : :
38 : : class NodeMapping
39 : : {
40 : : public:
41 : 526888 : NodeMapping (CrateNum crateNum, NodeId nodeId, HirId hirId,
42 : : LocalDefId localDefId)
43 : 483200 : : crateNum (crateNum), nodeId (nodeId), hirId (hirId),
44 : 483200 : localDefId (localDefId)
45 : : {}
46 : :
47 : : static NodeMapping get_error ();
48 : :
49 : : CrateNum get_crate_num () const;
50 : : NodeId get_nodeid () const;
51 : : HirId get_hirid () const;
52 : : LocalDefId get_local_defid () const;
53 : : DefId get_defid () const;
54 : :
55 : : static DefId get_defid (CrateNum crate_num, LocalDefId local_defid);
56 : :
57 : : std::string as_string () const;
58 : :
59 : : bool is_equal (const NodeMapping &other) const
60 : : {
61 : : return get_crate_num () == other.get_crate_num ()
62 : : && get_nodeid () == other.get_nodeid ()
63 : : && get_hirid () == other.get_hirid ()
64 : : && get_local_defid () == other.get_local_defid ();
65 : : }
66 : :
67 : : private:
68 : : CrateNum crateNum;
69 : : NodeId nodeId;
70 : : HirId hirId;
71 : : LocalDefId localDefId;
72 : : };
73 : :
74 : : class Mappings
75 : : {
76 : : public:
77 : : static Mappings *get ();
78 : : ~Mappings ();
79 : :
80 : : CrateNum get_next_crate_num (const std::string &name);
81 : : void set_current_crate (CrateNum crateNum);
82 : : CrateNum get_current_crate () const;
83 : : bool get_crate_name (CrateNum crate_num, std::string &name) const;
84 : : void set_crate_name (CrateNum crate_num, const std::string &name);
85 : : std::string get_current_crate_name () const;
86 : : bool lookup_crate_name (const std::string &crate_name,
87 : : CrateNum &resolved_crate_num) const;
88 : : bool crate_num_to_nodeid (const CrateNum &crate_num, NodeId &node_id) const;
89 : : bool node_is_crate (NodeId node_id) const;
90 : :
91 : : NodeId get_next_node_id ();
92 : 147128 : HirId get_next_hir_id () { return get_next_hir_id (get_current_crate ()); }
93 : : HirId get_next_hir_id (CrateNum crateNum);
94 : : LocalDefId get_next_localdef_id ()
95 : : {
96 : : return get_next_localdef_id (get_current_crate ());
97 : : }
98 : : LocalDefId get_next_localdef_id (CrateNum crateNum);
99 : :
100 : : AST::Crate &get_ast_crate (CrateNum crateNum);
101 : : AST::Crate &get_ast_crate_by_node_id (NodeId id);
102 : : AST::Crate &insert_ast_crate (std::unique_ptr<AST::Crate> &&crate,
103 : : CrateNum crate_num);
104 : : HIR::Crate &insert_hir_crate (std::unique_ptr<HIR::Crate> &&crate);
105 : : HIR::Crate &get_hir_crate (CrateNum crateNum);
106 : : bool is_local_hirid_crate (HirId crateNum);
107 : :
108 : : void insert_defid_mapping (DefId id, HIR::Item *item);
109 : : HIR::Item *lookup_defid (DefId id);
110 : : void insert_defid_mapping (DefId id, HIR::TraitItem *item);
111 : : HIR::TraitItem *lookup_trait_item_defid (DefId id);
112 : :
113 : : void insert_local_defid_mapping (CrateNum crateNum, LocalDefId id,
114 : : HIR::Item *item);
115 : : HIR::Item *lookup_local_defid (CrateNum crateNum, LocalDefId id);
116 : :
117 : : void insert_hir_item (HIR::Item *item);
118 : : HIR::Item *lookup_hir_item (HirId id);
119 : :
120 : : void insert_hir_enumitem (HIR::Enum *parent, HIR::EnumItem *item);
121 : : std::pair<HIR::Enum *, HIR::EnumItem *> lookup_hir_enumitem (HirId id);
122 : :
123 : : void insert_hir_trait_item (HIR::TraitItem *item);
124 : : HIR::TraitItem *lookup_hir_trait_item (HirId id);
125 : :
126 : : void insert_hir_extern_block (HIR::ExternBlock *block);
127 : : HIR::ExternBlock *lookup_hir_extern_block (HirId id);
128 : :
129 : : void insert_hir_extern_item (HIR::ExternalItem *item, HirId parent_block);
130 : : HIR::ExternalItem *lookup_hir_extern_item (HirId id, HirId *parent_block);
131 : :
132 : : void insert_hir_impl_block (HIR::ImplBlock *item);
133 : : HIR::ImplBlock *lookup_hir_impl_block (HirId id);
134 : : bool lookup_impl_block_type (HirId id, HIR::ImplBlock **impl_block);
135 : :
136 : : void insert_module (HIR::Module *module);
137 : : HIR::Module *lookup_module (HirId id);
138 : :
139 : : void insert_hir_implitem (HirId parent_impl_id, HIR::ImplItem *item);
140 : : HIR::ImplItem *lookup_hir_implitem (HirId id, HirId *parent_impl_id);
141 : :
142 : : void insert_hir_expr (HIR::Expr *expr);
143 : : HIR::Expr *lookup_hir_expr (HirId id);
144 : :
145 : : void insert_hir_path_expr_seg (HIR::PathExprSegment *expr);
146 : : HIR::PathExprSegment *lookup_hir_path_expr_seg (HirId id);
147 : :
148 : : void insert_hir_generic_param (HIR::GenericParam *expr);
149 : : HIR::GenericParam *lookup_hir_generic_param (HirId id);
150 : :
151 : : void insert_hir_type (HIR::Type *type);
152 : : HIR::Type *lookup_hir_type (HirId id);
153 : :
154 : : void insert_hir_stmt (HIR::Stmt *stmt);
155 : : HIR::Stmt *lookup_hir_stmt (HirId id);
156 : :
157 : : void insert_hir_param (HIR::FunctionParam *type);
158 : : HIR::FunctionParam *lookup_hir_param (HirId id);
159 : :
160 : : void insert_hir_self_param (HIR::SelfParam *type);
161 : : HIR::SelfParam *lookup_hir_self_param (HirId id);
162 : :
163 : : void insert_hir_struct_field (HIR::StructExprField *type);
164 : : HIR::StructExprField *lookup_hir_struct_field (HirId id);
165 : :
166 : : void insert_hir_pattern (HIR::Pattern *pattern);
167 : : HIR::Pattern *lookup_hir_pattern (HirId id);
168 : :
169 : : void walk_local_defids_for_crate (CrateNum crateNum,
170 : : std::function<bool (HIR::Item *)> cb);
171 : :
172 : : void insert_node_to_hir (NodeId id, HirId ref);
173 : : bool lookup_node_to_hir (NodeId id, HirId *ref);
174 : : bool lookup_hir_to_node (HirId id, NodeId *ref);
175 : :
176 : : void insert_location (HirId id, location_t locus);
177 : : location_t lookup_location (HirId id);
178 : :
179 : : bool resolve_nodeid_to_stmt (NodeId id, HIR::Stmt **stmt);
180 : :
181 : : std::set<HirId> &get_hirids_within_crate (CrateNum crate)
182 : : {
183 : : return hirNodesWithinCrate[crate];
184 : : }
185 : :
186 : 4100 : void insert_impl_item_mapping (HirId impl_item_id, HIR::ImplBlock *impl)
187 : : {
188 : 4100 : rust_assert (hirImplItemsToImplMappings.find (impl_item_id)
189 : : == hirImplItemsToImplMappings.end ());
190 : 4100 : hirImplItemsToImplMappings[impl_item_id] = impl;
191 : 4100 : }
192 : :
193 : 80775 : HIR::ImplBlock *lookup_associated_impl (HirId impl_item_id)
194 : : {
195 : 80775 : auto lookup = hirImplItemsToImplMappings.find (impl_item_id);
196 : 80775 : rust_assert (lookup != hirImplItemsToImplMappings.end ());
197 : 80775 : return lookup->second;
198 : : }
199 : :
200 : : void iterate_impl_items (
201 : : std::function<bool (HirId, HIR::ImplItem *, HIR::ImplBlock *)> cb);
202 : :
203 : : void iterate_impl_blocks (std::function<bool (HirId, HIR::ImplBlock *)> cb);
204 : :
205 : : void iterate_trait_items (
206 : : std::function<bool (HIR::TraitItem *item, HIR::Trait *)> cb);
207 : :
208 : 1718 : bool is_impl_item (HirId id)
209 : : {
210 : 1718 : HirId parent_impl_block_id = UNKNOWN_HIRID;
211 : 1718 : return lookup_hir_implitem (id, &parent_impl_block_id) != nullptr;
212 : : }
213 : :
214 : 1522 : void insert_trait_item_mapping (HirId trait_item_id, HIR::Trait *trait)
215 : : {
216 : 1522 : rust_assert (hirTraitItemsToTraitMappings.find (trait_item_id)
217 : : == hirTraitItemsToTraitMappings.end ());
218 : 1522 : hirTraitItemsToTraitMappings[trait_item_id] = trait;
219 : 1522 : }
220 : :
221 : 414 : HIR::Trait *lookup_trait_item_mapping (HirId trait_item_id)
222 : : {
223 : 414 : auto lookup = hirTraitItemsToTraitMappings.find (trait_item_id);
224 : 414 : rust_assert (lookup != hirTraitItemsToTraitMappings.end ());
225 : 414 : return lookup->second;
226 : : }
227 : :
228 : 98028 : void insert_canonical_path (NodeId id, const Resolver::CanonicalPath path)
229 : : {
230 : 98028 : const Resolver::CanonicalPath *p = nullptr;
231 : 196056 : if (lookup_canonical_path (id, &p))
232 : : {
233 : : // if we have already stored a canonical path this is ok so long as
234 : : // this new path is equal or is smaller that the existing one but in
235 : : // that case we ignore it.
236 : 10332 : if (p->is_equal (path))
237 : 98028 : return;
238 : : else
239 : : {
240 : 1524 : rust_assert (p->size () >= path.size ());
241 : : return;
242 : : }
243 : : }
244 : :
245 : 87696 : paths.emplace (id, std::move (path));
246 : : }
247 : :
248 : 129360 : bool lookup_canonical_path (NodeId id, const Resolver::CanonicalPath **path)
249 : : {
250 : 129360 : auto it = paths.find (id);
251 : 129360 : if (it == paths.end ())
252 : : return false;
253 : :
254 : 41664 : *path = &it->second;
255 : 41664 : return true;
256 : : }
257 : :
258 : 1779 : void insert_lang_item (RustLangItem::ItemType item_type, DefId id)
259 : : {
260 : 1779 : auto it = lang_item_mappings.find (item_type);
261 : 1779 : rust_assert (it == lang_item_mappings.end ());
262 : :
263 : 1779 : lang_item_mappings[item_type] = id;
264 : 1779 : }
265 : :
266 : 23421 : bool lookup_lang_item (RustLangItem::ItemType item_type, DefId *id)
267 : : {
268 : 23421 : auto it = lang_item_mappings.find (item_type);
269 : 23421 : if (it == lang_item_mappings.end ())
270 : : return false;
271 : :
272 : 19639 : *id = it->second;
273 : 19639 : return true;
274 : : }
275 : :
276 : : // This will fatal_error when this lang item does not exist
277 : : DefId get_lang_item (RustLangItem::ItemType item_type, location_t locus);
278 : :
279 : : void insert_macro_def (AST::MacroRulesDefinition *macro);
280 : :
281 : : bool lookup_macro_def (NodeId id, AST::MacroRulesDefinition **def);
282 : :
283 : : void insert_macro_invocation (AST::MacroInvocation &invoc,
284 : : AST::MacroRulesDefinition *def);
285 : : bool lookup_macro_invocation (AST::MacroInvocation &invoc,
286 : : AST::MacroRulesDefinition **def);
287 : :
288 : : void insert_exported_macro (AST::MacroRulesDefinition &def);
289 : : std::vector<NodeId> &get_exported_macros ();
290 : :
291 : : void insert_derive_proc_macros (CrateNum num,
292 : : std::vector<CustomDeriveProcMacro> macros);
293 : : void insert_bang_proc_macros (CrateNum num,
294 : : std::vector<BangProcMacro> macros);
295 : : void insert_attribute_proc_macros (CrateNum num,
296 : : std::vector<AttributeProcMacro> macros);
297 : :
298 : : tl::optional<std::vector<CustomDeriveProcMacro> &>
299 : : lookup_derive_proc_macros (CrateNum num);
300 : : tl::optional<std::vector<BangProcMacro> &>
301 : : lookup_bang_proc_macros (CrateNum num);
302 : : tl::optional<std::vector<AttributeProcMacro> &>
303 : : lookup_attribute_proc_macros (CrateNum num);
304 : :
305 : : void insert_derive_proc_macro_def (CustomDeriveProcMacro macro);
306 : : void insert_bang_proc_macro_def (BangProcMacro macro);
307 : : void insert_attribute_proc_macro_def (AttributeProcMacro macro);
308 : :
309 : : tl::optional<CustomDeriveProcMacro &>
310 : : lookup_derive_proc_macro_def (NodeId id);
311 : : tl::optional<BangProcMacro &> lookup_bang_proc_macro_def (NodeId id);
312 : : tl::optional<AttributeProcMacro &>
313 : : lookup_attribute_proc_macro_def (NodeId id);
314 : :
315 : : tl::optional<CustomDeriveProcMacro &>
316 : : lookup_derive_proc_macro_invocation (AST::SimplePath &invoc);
317 : : tl::optional<BangProcMacro &>
318 : : lookup_bang_proc_macro_invocation (AST::MacroInvocation &invoc_id);
319 : : tl::optional<AttributeProcMacro &>
320 : : lookup_attribute_proc_macro_invocation (AST::SimplePath &invoc);
321 : : void insert_derive_proc_macro_invocation (AST::SimplePath &invoc,
322 : : CustomDeriveProcMacro def);
323 : : void insert_bang_proc_macro_invocation (AST::MacroInvocation &invoc,
324 : : BangProcMacro def);
325 : : void insert_attribute_proc_macro_invocation (AST::SimplePath &invoc,
326 : : AttributeProcMacro def);
327 : :
328 : : void insert_visibility (NodeId id, Privacy::ModuleVisibility visibility);
329 : : bool lookup_visibility (NodeId id, Privacy::ModuleVisibility &def);
330 : :
331 : : void insert_module_child (NodeId module, NodeId child);
332 : : tl::optional<std::vector<NodeId> &> lookup_module_children (NodeId module);
333 : :
334 : : void insert_module_child_item (NodeId module, Resolver::CanonicalPath item);
335 : : tl::optional<std::vector<Resolver::CanonicalPath> &>
336 : : lookup_module_chidren_items (NodeId module);
337 : : tl::optional<Resolver::CanonicalPath &>
338 : : lookup_module_child (NodeId module, const std::string &item_name);
339 : :
340 : : void insert_child_item_to_parent_module_mapping (NodeId child_item,
341 : : NodeId parent_module);
342 : : tl::optional<NodeId> lookup_parent_module (NodeId child_item);
343 : : bool node_is_module (NodeId query);
344 : :
345 : : void insert_ast_item (AST::Item *item);
346 : : bool lookup_ast_item (NodeId id, AST::Item **result);
347 : :
348 : : HIR::ImplBlock *lookup_builtin_marker ();
349 : :
350 : : HIR::TraitItem *
351 : : lookup_trait_item_lang_item (Analysis::RustLangItem::ItemType item,
352 : : location_t locus);
353 : :
354 : : private:
355 : : Mappings ();
356 : :
357 : : CrateNum crateNumItr;
358 : : CrateNum currentCrateNum;
359 : : HirId hirIdIter;
360 : : NodeId nodeIdIter;
361 : : std::map<CrateNum, LocalDefId> localIdIter;
362 : : HIR::ImplBlock *builtinMarker;
363 : :
364 : : std::map<NodeId, CrateNum> crate_node_to_crate_num;
365 : : std::map<CrateNum, AST::Crate *> ast_crate_mappings;
366 : : std::map<CrateNum, HIR::Crate *> hir_crate_mappings;
367 : : std::map<DefId, HIR::Item *> defIdMappings;
368 : : std::map<DefId, HIR::TraitItem *> defIdTraitItemMappings;
369 : : std::map<CrateNum, std::map<LocalDefId, HIR::Item *>> localDefIdMappings;
370 : :
371 : : std::map<HirId, HIR::Module *> hirModuleMappings;
372 : : std::map<HirId, HIR::Item *> hirItemMappings;
373 : : std::map<HirId, std::pair<HIR::Enum *, HIR::EnumItem *>> hirEnumItemMappings;
374 : : std::map<HirId, HIR::Type *> hirTypeMappings;
375 : : std::map<HirId, HIR::Expr *> hirExprMappings;
376 : : std::map<HirId, HIR::Stmt *> hirStmtMappings;
377 : : std::map<HirId, HIR::FunctionParam *> hirParamMappings;
378 : : std::map<HirId, HIR::StructExprField *> hirStructFieldMappings;
379 : : std::map<HirId, std::pair<HirId, HIR::ImplItem *>> hirImplItemMappings;
380 : : std::map<HirId, HIR::SelfParam *> hirSelfParamMappings;
381 : : std::map<HirId, HIR::ImplBlock *> hirImplItemsToImplMappings;
382 : : std::map<HirId, HIR::ImplBlock *> hirImplBlockMappings;
383 : : std::map<HirId, HIR::ImplBlock *> hirImplBlockTypeMappings;
384 : : std::map<HirId, HIR::TraitItem *> hirTraitItemMappings;
385 : : std::map<HirId, HIR::ExternBlock *> hirExternBlockMappings;
386 : : std::map<HirId, std::pair<HIR::ExternalItem *, HirId>> hirExternItemMappings;
387 : : std::map<HirId, HIR::PathExprSegment *> hirPathSegMappings;
388 : : std::map<HirId, HIR::GenericParam *> hirGenericParamMappings;
389 : : std::map<HirId, HIR::Trait *> hirTraitItemsToTraitMappings;
390 : : std::map<HirId, HIR::Pattern *> hirPatternMappings;
391 : : std::map<RustLangItem::ItemType, DefId> lang_item_mappings;
392 : : std::map<NodeId, const Resolver::CanonicalPath> paths;
393 : : std::map<NodeId, location_t> locations;
394 : : std::map<NodeId, HirId> nodeIdToHirMappings;
395 : : std::map<HirId, NodeId> hirIdToNodeMappings;
396 : :
397 : : // all hirid nodes
398 : : std::map<CrateNum, std::set<HirId>> hirNodesWithinCrate;
399 : :
400 : : // MBE macros
401 : : std::map<NodeId, AST::MacroRulesDefinition *> macroMappings;
402 : : std::map<NodeId, AST::MacroRulesDefinition *> macroInvocations;
403 : : std::vector<NodeId> exportedMacros;
404 : :
405 : : // Procedural macros
406 : : std::map<CrateNum, std::vector<CustomDeriveProcMacro>>
407 : : procmacrosDeriveMappings;
408 : : std::map<CrateNum, std::vector<BangProcMacro>> procmacrosBangMappings;
409 : : std::map<CrateNum, std::vector<AttributeProcMacro>>
410 : : procmacrosAttributeMappings;
411 : :
412 : : std::map<NodeId, CustomDeriveProcMacro> procmacroDeriveMappings;
413 : : std::map<NodeId, BangProcMacro> procmacroBangMappings;
414 : : std::map<NodeId, AttributeProcMacro> procmacroAttributeMappings;
415 : : std::map<NodeId, CustomDeriveProcMacro> procmacroDeriveInvocations;
416 : : std::map<NodeId, BangProcMacro> procmacroBangInvocations;
417 : : std::map<NodeId, AttributeProcMacro> procmacroAttributeInvocations;
418 : :
419 : : // crate names
420 : : std::map<CrateNum, std::string> crate_names;
421 : :
422 : : // Low level visibility map for each DefId
423 : : std::map<NodeId, Privacy::ModuleVisibility> visibility_map;
424 : :
425 : : // Module tree maps
426 : :
427 : : // Maps each module's node id to a list of its children
428 : : std::map<NodeId, std::vector<NodeId>> module_child_map;
429 : : std::map<NodeId, std::vector<Resolver::CanonicalPath>> module_child_items;
430 : : std::map<NodeId, NodeId> child_to_parent_module_map;
431 : :
432 : : // AST mappings
433 : : std::map<NodeId, AST::Item *> ast_item_mappings;
434 : : };
435 : :
436 : : } // namespace Analysis
437 : : } // namespace Rust
438 : :
439 : : #endif // RUST_HIR_MAP_H
|
