]>
Commit | Line | Data |
---|---|---|
a945c346 | 1 | // Copyright (C) 2020-2024 Free Software Foundation, Inc. |
9ce37e72 PH |
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); | |
8f0b1526 PH |
107 | void insert_defid_mapping (DefId id, HIR::TraitItem *item); |
108 | HIR::TraitItem *lookup_trait_item_defid (DefId id); | |
9ce37e72 PH |
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); | |
104cc285 | 128 | bool lookup_impl_block_type (HirId id, HIR::ImplBlock **impl_block); |
9ce37e72 PH |
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 | ||
a08f2656 AC |
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 | ||
9ce37e72 PH |
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 | ||
4b25fc15 PH |
299 | HIR::ImplBlock *lookup_builtin_marker (); |
300 | ||
9ce37e72 PH |
301 | private: |
302 | Mappings (); | |
303 | ||
304 | CrateNum crateNumItr; | |
305 | CrateNum currentCrateNum; | |
306 | HirId hirIdIter; | |
307 | NodeId nodeIdIter; | |
308 | std::map<CrateNum, LocalDefId> localIdIter; | |
4b25fc15 | 309 | HIR::ImplBlock *builtinMarker; |
9ce37e72 PH |
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; | |
8f0b1526 | 315 | std::map<DefId, HIR::TraitItem *> defIdTraitItemMappings; |
9ce37e72 PH |
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; | |
104cc285 | 329 | std::map<HirId, HIR::ImplBlock *> hirImplBlockTypeMappings; |
9ce37e72 PH |
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; | |
a08f2656 | 348 | std::map<NodeId, AST::MacroRulesDefinition *> macroInvocations; |
9ce37e72 PH |
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 |