1 // Copyright (C) 2020-2023 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 "rust-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
32 namespace Rust {
33 namespace Analysis {
34
35 class NodeMapping
36 {
37 public:
38 NodeMapping (CrateNum crateNum, NodeId nodeId, HirId hirId,
39 LocalDefId localDefId)
40 : crateNum (crateNum), nodeId (nodeId), hirId (hirId),
41 localDefId (localDefId)
42 {}
43
44 static NodeMapping get_error ();
45
46 CrateNum get_crate_num () const;
47 NodeId get_nodeid () const;
48 HirId get_hirid () const;
49 LocalDefId get_local_defid () const;
50 DefId get_defid () const;
51
52 static DefId get_defid (CrateNum crate_num, LocalDefId local_defid);
53
54 std::string as_string () const;
55
56 bool is_equal (const NodeMapping &other) const
57 {
58 return get_crate_num () == other.get_crate_num ()
59 && get_nodeid () == other.get_nodeid ()
60 && get_hirid () == other.get_hirid ()
61 && get_local_defid () == other.get_local_defid ();
62 }
63
64 private:
65 CrateNum crateNum;
66 NodeId nodeId;
67 HirId hirId;
68 LocalDefId localDefId;
69 };
70
71 class Mappings
72 {
73 public:
74 static Mappings *get ();
75 ~Mappings ();
76
77 CrateNum get_next_crate_num (const std::string &name);
78 void set_current_crate (CrateNum crateNum);
79 CrateNum get_current_crate () const;
80 bool get_crate_name (CrateNum crate_num, std::string &name) const;
81 void set_crate_name (CrateNum crate_num, const std::string &name);
82 std::string get_current_crate_name () const;
83 bool lookup_crate_name (const std::string &crate_name,
84 CrateNum &resolved_crate_num) const;
85 bool crate_num_to_nodeid (const CrateNum &crate_num, NodeId &node_id) const;
86 bool node_is_crate (NodeId node_id) const;
87
88 NodeId get_next_node_id ();
89 HirId get_next_hir_id () { return get_next_hir_id (get_current_crate ()); }
90 HirId get_next_hir_id (CrateNum crateNum);
91 LocalDefId get_next_localdef_id ()
92 {
93 return get_next_localdef_id (get_current_crate ());
94 }
95 LocalDefId get_next_localdef_id (CrateNum crateNum);
96
97 AST::Crate &get_ast_crate (CrateNum crateNum);
98 AST::Crate &get_ast_crate_by_node_id (NodeId id);
99 AST::Crate &insert_ast_crate (std::unique_ptr<AST::Crate> &&crate,
100 CrateNum crate_num);
101 HIR::Crate &insert_hir_crate (std::unique_ptr<HIR::Crate> &&crate);
102 HIR::Crate &get_hir_crate (CrateNum crateNum);
103 bool is_local_hirid_crate (HirId crateNum);
104
105 void insert_defid_mapping (DefId id, HIR::Item *item);
106 HIR::Item *lookup_defid (DefId id);
107 void insert_defid_mapping (DefId id, HIR::TraitItem *item);
108 HIR::TraitItem *lookup_trait_item_defid (DefId id);
109
110 void insert_local_defid_mapping (CrateNum crateNum, LocalDefId id,
111 HIR::Item *item);
112 HIR::Item *lookup_local_defid (CrateNum crateNum, LocalDefId id);
113
114 void insert_hir_item (HIR::Item *item);
115 HIR::Item *lookup_hir_item (HirId id);
116
117 void insert_hir_trait_item (HIR::TraitItem *item);
118 HIR::TraitItem *lookup_hir_trait_item (HirId id);
119
120 void insert_hir_extern_block (HIR::ExternBlock *block);
121 HIR::ExternBlock *lookup_hir_extern_block (HirId id);
122
123 void insert_hir_extern_item (HIR::ExternalItem *item, HirId parent_block);
124 HIR::ExternalItem *lookup_hir_extern_item (HirId id, HirId *parent_block);
125
126 void insert_hir_impl_block (HIR::ImplBlock *item);
127 HIR::ImplBlock *lookup_hir_impl_block (HirId id);
128 bool lookup_impl_block_type (HirId id, HIR::ImplBlock **impl_block);
129
130 void insert_module (HIR::Module *module);
131 HIR::Module *lookup_module (HirId id);
132
133 void insert_hir_implitem (HirId parent_impl_id, HIR::ImplItem *item);
134 HIR::ImplItem *lookup_hir_implitem (HirId id, HirId *parent_impl_id);
135
136 void insert_hir_expr (HIR::Expr *expr);
137 HIR::Expr *lookup_hir_expr (HirId id);
138
139 void insert_hir_path_expr_seg (HIR::PathExprSegment *expr);
140 HIR::PathExprSegment *lookup_hir_path_expr_seg (HirId id);
141
142 void insert_hir_generic_param (HIR::GenericParam *expr);
143 HIR::GenericParam *lookup_hir_generic_param (HirId id);
144
145 void insert_hir_type (HIR::Type *type);
146 HIR::Type *lookup_hir_type (HirId id);
147
148 void insert_hir_stmt (HIR::Stmt *stmt);
149 HIR::Stmt *lookup_hir_stmt (HirId id);
150
151 void insert_hir_param (HIR::FunctionParam *type);
152 HIR::FunctionParam *lookup_hir_param (HirId id);
153
154 void insert_hir_self_param (HIR::SelfParam *type);
155 HIR::SelfParam *lookup_hir_self_param (HirId id);
156
157 void insert_hir_struct_field (HIR::StructExprField *type);
158 HIR::StructExprField *lookup_hir_struct_field (HirId id);
159
160 void insert_hir_pattern (HIR::Pattern *pattern);
161 HIR::Pattern *lookup_hir_pattern (HirId id);
162
163 void walk_local_defids_for_crate (CrateNum crateNum,
164 std::function<bool (HIR::Item *)> cb);
165
166 void insert_node_to_hir (NodeId id, HirId ref);
167 bool lookup_node_to_hir (NodeId id, HirId *ref);
168 bool lookup_hir_to_node (HirId id, NodeId *ref);
169
170 void insert_location (HirId id, Location locus);
171 Location lookup_location (HirId id);
172
173 bool resolve_nodeid_to_stmt (NodeId id, HIR::Stmt **stmt);
174
175 std::set<HirId> &get_hirids_within_crate (CrateNum crate)
176 {
177 return hirNodesWithinCrate[crate];
178 }
179
180 void insert_impl_item_mapping (HirId impl_item_id, HIR::ImplBlock *impl)
181 {
182 rust_assert (hirImplItemsToImplMappings.find (impl_item_id)
183 == hirImplItemsToImplMappings.end ());
184 hirImplItemsToImplMappings[impl_item_id] = impl;
185 }
186
187 HIR::ImplBlock *lookup_associated_impl (HirId impl_item_id)
188 {
189 auto lookup = hirImplItemsToImplMappings.find (impl_item_id);
190 rust_assert (lookup != hirImplItemsToImplMappings.end ());
191 return lookup->second;
192 }
193
194 void iterate_impl_items (
195 std::function<bool (HirId, HIR::ImplItem *, HIR::ImplBlock *)> cb);
196
197 void iterate_impl_blocks (std::function<bool (HirId, HIR::ImplBlock *)> cb);
198
199 void iterate_trait_items (
200 std::function<bool (HIR::TraitItem *item, HIR::Trait *)> cb);
201
202 bool is_impl_item (HirId id)
203 {
204 HirId parent_impl_block_id = UNKNOWN_HIRID;
205 return lookup_hir_implitem (id, &parent_impl_block_id) != nullptr;
206 }
207
208 void insert_trait_item_mapping (HirId trait_item_id, HIR::Trait *trait)
209 {
210 rust_assert (hirTraitItemsToTraitMappings.find (trait_item_id)
211 == hirTraitItemsToTraitMappings.end ());
212 hirTraitItemsToTraitMappings[trait_item_id] = trait;
213 }
214
215 HIR::Trait *lookup_trait_item_mapping (HirId trait_item_id)
216 {
217 auto lookup = hirTraitItemsToTraitMappings.find (trait_item_id);
218 rust_assert (lookup != hirTraitItemsToTraitMappings.end ());
219 return lookup->second;
220 }
221
222 void insert_canonical_path (NodeId id, const Resolver::CanonicalPath path)
223 {
224 const Resolver::CanonicalPath *p = nullptr;
225 if (lookup_canonical_path (id, &p))
226 {
227 // if we have already stored a canonical path this is ok so long as
228 // this new path is equal or is smaller that the existing one but in
229 // that case we ignore it.
230 if (p->is_equal (path))
231 return;
232 else
233 {
234 rust_assert (p->size () >= path.size ());
235 return;
236 }
237 }
238
239 paths.emplace (id, std::move (path));
240 }
241
242 bool lookup_canonical_path (NodeId id, const Resolver::CanonicalPath **path)
243 {
244 auto it = paths.find (id);
245 if (it == paths.end ())
246 return false;
247
248 *path = &it->second;
249 return true;
250 }
251
252 void insert_lang_item (RustLangItem::ItemType item_type, DefId id)
253 {
254 auto it = lang_item_mappings.find (item_type);
255 rust_assert (it == lang_item_mappings.end ());
256
257 lang_item_mappings[item_type] = id;
258 }
259
260 bool lookup_lang_item (RustLangItem::ItemType item_type, DefId *id)
261 {
262 auto it = lang_item_mappings.find (item_type);
263 if (it == lang_item_mappings.end ())
264 return false;
265
266 *id = it->second;
267 return true;
268 }
269
270 void insert_macro_def (AST::MacroRulesDefinition *macro);
271
272 bool lookup_macro_def (NodeId id, AST::MacroRulesDefinition **def);
273
274 void insert_macro_invocation (AST::MacroInvocation &invoc,
275 AST::MacroRulesDefinition *def);
276 bool lookup_macro_invocation (AST::MacroInvocation &invoc,
277 AST::MacroRulesDefinition **def);
278
279 void insert_visibility (NodeId id, Privacy::ModuleVisibility visibility);
280 bool lookup_visibility (NodeId id, Privacy::ModuleVisibility &def);
281
282 void insert_module_child (NodeId module, NodeId child);
283 Optional<std::vector<NodeId> &> lookup_module_children (NodeId module);
284
285 void insert_module_child_item (NodeId module, Resolver::CanonicalPath item);
286 Optional<std::vector<Resolver::CanonicalPath> &>
287 lookup_module_chidren_items (NodeId module);
288 Optional<Resolver::CanonicalPath &>
289 lookup_module_child (NodeId module, const std::string &item_name);
290
291 void insert_child_item_to_parent_module_mapping (NodeId child_item,
292 NodeId parent_module);
293 Optional<NodeId> lookup_parent_module (NodeId child_item);
294 bool node_is_module (NodeId query);
295
296 void insert_ast_item (AST::Item *item);
297 bool lookup_ast_item (NodeId id, AST::Item **result);
298
299 HIR::ImplBlock *lookup_builtin_marker ();
300
301 private:
302 Mappings ();
303
304 CrateNum crateNumItr;
305 CrateNum currentCrateNum;
306 HirId hirIdIter;
307 NodeId nodeIdIter;
308 std::map<CrateNum, LocalDefId> localIdIter;
309 HIR::ImplBlock *builtinMarker;
310
311 std::map<NodeId, CrateNum> crate_node_to_crate_num;
312 std::map<CrateNum, AST::Crate *> ast_crate_mappings;
313 std::map<CrateNum, HIR::Crate *> hir_crate_mappings;
314 std::map<DefId, HIR::Item *> defIdMappings;
315 std::map<DefId, HIR::TraitItem *> defIdTraitItemMappings;
316 std::map<CrateNum, std::map<LocalDefId, HIR::Item *>> localDefIdMappings;
317
318 std::map<HirId, HIR::Module *> hirModuleMappings;
319 std::map<HirId, HIR::Item *> hirItemMappings;
320 std::map<HirId, HIR::Type *> hirTypeMappings;
321 std::map<HirId, HIR::Expr *> hirExprMappings;
322 std::map<HirId, HIR::Stmt *> hirStmtMappings;
323 std::map<HirId, HIR::FunctionParam *> hirParamMappings;
324 std::map<HirId, HIR::StructExprField *> hirStructFieldMappings;
325 std::map<HirId, std::pair<HirId, HIR::ImplItem *>> hirImplItemMappings;
326 std::map<HirId, HIR::SelfParam *> hirSelfParamMappings;
327 std::map<HirId, HIR::ImplBlock *> hirImplItemsToImplMappings;
328 std::map<HirId, HIR::ImplBlock *> hirImplBlockMappings;
329 std::map<HirId, HIR::ImplBlock *> hirImplBlockTypeMappings;
330 std::map<HirId, HIR::TraitItem *> hirTraitItemMappings;
331 std::map<HirId, HIR::ExternBlock *> hirExternBlockMappings;
332 std::map<HirId, std::pair<HIR::ExternalItem *, HirId>> hirExternItemMappings;
333 std::map<HirId, HIR::PathExprSegment *> hirPathSegMappings;
334 std::map<HirId, HIR::GenericParam *> hirGenericParamMappings;
335 std::map<HirId, HIR::Trait *> hirTraitItemsToTraitMappings;
336 std::map<HirId, HIR::Pattern *> hirPatternMappings;
337 std::map<RustLangItem::ItemType, DefId> lang_item_mappings;
338 std::map<NodeId, const Resolver::CanonicalPath> paths;
339 std::map<NodeId, Location> locations;
340 std::map<NodeId, HirId> nodeIdToHirMappings;
341 std::map<HirId, NodeId> hirIdToNodeMappings;
342
343 // all hirid nodes
344 std::map<CrateNum, std::set<HirId>> hirNodesWithinCrate;
345
346 // macros
347 std::map<NodeId, AST::MacroRulesDefinition *> macroMappings;
348 std::map<NodeId, AST::MacroRulesDefinition *> macroInvocations;
349
350 // crate names
351 std::map<CrateNum, std::string> crate_names;
352
353 // Low level visibility map for each DefId
354 std::map<NodeId, Privacy::ModuleVisibility> visibility_map;
355
356 // Module tree maps
357
358 // Maps each module's node id to a list of its children
359 std::map<NodeId, std::vector<NodeId>> module_child_map;
360 std::map<NodeId, std::vector<Resolver::CanonicalPath>> module_child_items;
361 std::map<NodeId, NodeId> child_to_parent_module_map;
362
363 // AST mappings
364 std::map<NodeId, AST::Item *> ast_item_mappings;
365 };
366
367 } // namespace Analysis
368 } // namespace Rust
369
370 #endif // RUST_HIR_MAP_H