Line data    Source code

       1              : // Copyright (C) 2020-2026 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       665421 :   NodeMapping (CrateNum crateNum, NodeId nodeId, HirId hirId,
      42              :                LocalDefId localDefId)
      43       613723 :     : crateNum (crateNum), nodeId (nodeId), hirId (hirId),
      44       613723 :       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              :   tl::optional<const std::string &> get_crate_name (CrateNum crate_num) const;
      84              : 
      85              :   tl::optional<CrateNum> lookup_crate_num (NodeId node_id) const;
      86              :   void set_crate_name (CrateNum crate_num, const std::string &name);
      87              :   const std::string &get_current_crate_name () const;
      88              :   tl::optional<CrateNum>
      89              :   lookup_crate_name (const std::string &crate_name) const;
      90              :   tl::optional<NodeId> crate_num_to_nodeid (const CrateNum &crate_num) const;
      91              :   bool node_is_crate (NodeId node_id) const;
      92              : 
      93              :   NodeId get_next_node_id ();
      94       240082 :   HirId get_next_hir_id () { return get_next_hir_id (get_current_crate ()); }
      95              :   HirId get_next_hir_id (CrateNum crateNum);
      96              :   LocalDefId get_next_localdef_id ()
      97              :   {
      98              :     return get_next_localdef_id (get_current_crate ());
      99              :   }
     100              :   LocalDefId get_next_localdef_id (CrateNum crateNum);
     101              : 
     102              :   AST::Crate &get_ast_crate (CrateNum crateNum);
     103              :   AST::Crate &get_ast_crate_by_node_id (NodeId id);
     104              :   AST::Crate &insert_ast_crate (std::unique_ptr<AST::Crate> &&crate,
     105              :                                 CrateNum crate_num);
     106              :   HIR::Crate &insert_hir_crate (std::unique_ptr<HIR::Crate> &&crate);
     107              :   HIR::Crate &get_hir_crate (CrateNum crateNum);
     108              :   bool is_local_hirid_crate (HirId crateNum);
     109              : 
     110              :   void insert_defid_mapping (DefId id, HIR::Item *item);
     111              :   tl::optional<HIR::Item *> lookup_defid (DefId id);
     112              :   void insert_defid_mapping (DefId id, HIR::TraitItem *item);
     113              :   tl::optional<HIR::TraitItem *> lookup_trait_item_defid (DefId id);
     114              : 
     115              :   void insert_local_defid_mapping (CrateNum crateNum, LocalDefId id,
     116              :                                    HIR::Item *item);
     117              :   tl::optional<HIR::Item *> lookup_local_defid (CrateNum crateNum,
     118              :                                                 LocalDefId id);
     119              : 
     120              :   void insert_hir_item (HIR::Item *item);
     121              :   tl::optional<HIR::Item *> lookup_hir_item (HirId id);
     122              : 
     123              :   void insert_hir_enumitem (HIR::Enum *parent, HIR::EnumItem *item);
     124              :   std::pair<HIR::Enum *, HIR::EnumItem *> lookup_hir_enumitem (HirId id);
     125              : 
     126              :   void insert_hir_trait_item (HIR::TraitItem *item);
     127              :   tl::optional<HIR::TraitItem *> lookup_hir_trait_item (HirId id);
     128              : 
     129              :   void insert_hir_extern_block (HIR::ExternBlock *block);
     130              :   tl::optional<HIR::ExternBlock *> lookup_hir_extern_block (HirId id);
     131              : 
     132              :   void insert_hir_extern_item (HIR::ExternalItem *item, HirId parent_block);
     133              : 
     134              :   // std::pair<hir_extern_item, parent hirid>
     135              :   tl::optional<std::pair<HIR::ExternalItem *, HirId>>
     136              :   lookup_hir_extern_item (HirId id);
     137              : 
     138              :   void insert_hir_impl_block (HIR::ImplBlock *item);
     139              :   tl::optional<HIR::ImplBlock *> lookup_hir_impl_block (HirId id);
     140              :   tl::optional<HIR::ImplBlock *> lookup_impl_block_type (HirId id);
     141              : 
     142              :   void insert_module (HIR::Module *module);
     143              :   tl::optional<HIR::Module *> lookup_module (HirId id);
     144              : 
     145              :   void insert_hir_implitem (HirId parent_impl_id, HIR::ImplItem *item);
     146              :   // Optional<ImpItem, ParentImpl Hir id>
     147              :   tl::optional<std::pair<HIR::ImplItem *, HirId>>
     148              :   lookup_hir_implitem (HirId id);
     149              : 
     150              :   void insert_hir_expr (HIR::Expr *expr);
     151              :   tl::optional<HIR::Expr *> lookup_hir_expr (HirId id);
     152              : 
     153              :   void insert_hir_path_expr_seg (HIR::PathExprSegment *expr);
     154              :   tl::optional<HIR::PathExprSegment *> lookup_hir_path_expr_seg (HirId id);
     155              : 
     156              :   void insert_hir_generic_param (HIR::GenericParam *expr);
     157              :   tl::optional<HIR::GenericParam *> lookup_hir_generic_param (HirId id);
     158              : 
     159              :   void insert_hir_type (HIR::Type *type);
     160              :   tl::optional<HIR::Type *> lookup_hir_type (HirId id);
     161              : 
     162              :   void insert_hir_stmt (HIR::Stmt *stmt);
     163              :   tl::optional<HIR::Stmt *> lookup_hir_stmt (HirId id);
     164              : 
     165              :   void insert_hir_param (HIR::FunctionParam *type);
     166              :   tl::optional<HIR::FunctionParam *> lookup_hir_param (HirId id);
     167              : 
     168              :   void insert_hir_self_param (HIR::SelfParam *type);
     169              :   tl::optional<HIR::SelfParam *> lookup_hir_self_param (HirId id);
     170              : 
     171              :   void insert_hir_struct_field (HIR::StructExprField *type);
     172              :   tl::optional<HIR::StructExprField *> lookup_hir_struct_field (HirId id);
     173              : 
     174              :   void insert_hir_pattern (HIR::Pattern *pattern);
     175              :   tl::optional<HIR::Pattern *> lookup_hir_pattern (HirId id);
     176              : 
     177              :   void walk_local_defids_for_crate (CrateNum crateNum,
     178              :                                     std::function<bool (HIR::Item *)> cb);
     179              : 
     180              :   void insert_node_to_hir (NodeId id, HirId ref);
     181              :   tl::optional<HirId> lookup_node_to_hir (NodeId id);
     182              :   tl::optional<NodeId> lookup_hir_to_node (HirId id);
     183              : 
     184              :   void insert_location (HirId id, location_t locus);
     185              :   location_t lookup_location (HirId id);
     186              : 
     187              :   tl::optional<HIR::Stmt *> resolve_nodeid_to_stmt (NodeId id);
     188              : 
     189              :   std::set<HirId> &get_hirids_within_crate (CrateNum crate)
     190              :   {
     191              :     return hirNodesWithinCrate[crate];
     192              :   }
     193              : 
     194         9389 :   void insert_impl_item_mapping (HirId impl_item_id, HIR::ImplBlock *impl)
     195              :   {
     196         9389 :     rust_assert (hirImplItemsToImplMappings.find (impl_item_id)
     197              :                  == hirImplItemsToImplMappings.end ());
     198         9389 :     hirImplItemsToImplMappings[impl_item_id] = impl;
     199         9389 :   }
     200              : 
     201        86551 :   HIR::ImplBlock *lookup_associated_impl (HirId impl_item_id)
     202              :   {
     203        86551 :     auto lookup = hirImplItemsToImplMappings.find (impl_item_id);
     204        86551 :     rust_assert (lookup != hirImplItemsToImplMappings.end ());
     205        86551 :     return lookup->second;
     206              :   }
     207              : 
     208              :   void iterate_impl_items (
     209              :     std::function<bool (HirId, HIR::ImplItem *, HIR::ImplBlock *)> cb);
     210              : 
     211              :   template <typename Callback>
     212         3213 :   void iterate_inherent_impl_items (const std::string &name, Callback &&cb)
     213              :   {
     214         3213 :     auto items = hirInherentImplItemMappings.find (name);
     215         3213 :     if (items == hirInherentImplItemMappings.end ())
     216              :       return;
     217              : 
     218         9290 :     for (auto &item : items->second)
     219         7188 :       if (!cb (item.first, item.second))
     220              :         return;
     221              :   }
     222              : 
     223              :   void insert_adt_impl_mapping (DefId adt_id, HIR::ImplBlock *impl);
     224              : 
     225              :   void build_impl_indexes ();
     226              : 
     227              :   void iterate_adt_impl_items (
     228              :     DefId adt_id,
     229              :     std::function<bool (HirId, HIR::ImplItem *, HIR::ImplBlock *)> cb);
     230              : 
     231              :   void insert_trait_impl_mapping (DefId trait_id, HIR::ImplBlock *impl);
     232              : 
     233              :   void iterate_trait_impl_items (
     234              :     DefId trait_id,
     235              :     std::function<bool (HirId, HIR::ImplItem *, HIR::ImplBlock *)> cb);
     236              : 
     237              :   void
     238              :   iterate_trait_impl_blocks (DefId trait_id,
     239              :                              std::function<bool (HirId, HIR::ImplBlock *)> cb);
     240              : 
     241          475 :   template <typename Callback> void iterate_trait_impl_blocks (Callback &&cb)
     242              :   {
     243         2421 :     for (auto it = hirTraitImplBlockMappings.begin ();
     244         2421 :          it != hirTraitImplBlockMappings.end (); ++it)
     245         1946 :       if (!cb (it->first, it->second))
     246          475 :         return;
     247              :   }
     248              : 
     249              :   void iterate_trait_impl_blocks_for_item (
     250              :     const std::string &name, std::function<bool (HirId, HIR::ImplBlock *)> cb);
     251              : 
     252              :   void iterate_impl_blocks (std::function<bool (HirId, HIR::ImplBlock *)> cb);
     253              : 
     254              :   void iterate_trait_items (
     255              :     std::function<bool (HIR::TraitItem *item, HIR::Trait *)> cb);
     256              : 
     257         4510 :   bool is_impl_item (HirId id) { return lookup_hir_implitem (id).has_value (); }
     258              : 
     259              :   void insert_trait_item_mapping (HirId trait_item_id, HIR::Trait *trait);
     260              : 
     261         4021 :   HIR::Trait *lookup_trait_item_mapping (HirId trait_item_id)
     262              :   {
     263         4021 :     auto lookup = hirTraitItemsToTraitMappings.find (trait_item_id);
     264         4021 :     rust_assert (lookup != hirTraitItemsToTraitMappings.end ());
     265         4021 :     return lookup->second;
     266              :   }
     267              : 
     268              :   void insert_canonical_path (NodeId id, const Resolver::CanonicalPath path)
     269              :   {
     270              :     if (auto p = lookup_canonical_path (id))
     271              :       {
     272              :         // if we have already stored a canonical path this is ok so long as
     273              :         // this new path is equal or is smaller that the existing one but in
     274              :         // that case we ignore it.
     275              :         if (p->is_equal (path))
     276              :           return;
     277              :         else
     278              :           {
     279              :             rust_assert (p->size () >= path.size ());
     280              :             return;
     281              :           }
     282              :       }
     283              : 
     284              :     paths.emplace (id, std::move (path));
     285              :   }
     286              : 
     287              :   tl::optional<const Resolver::CanonicalPath &>
     288              :   lookup_canonical_path (NodeId id)
     289              :   {
     290              :     auto it = paths.find (id);
     291              :     if (it == paths.end ())
     292              :       return tl::nullopt;
     293              : 
     294              :     return it->second;
     295              :   }
     296              : 
     297              :   void insert_lang_item (LangItem::Kind item_type, DefId id);
     298              :   tl::optional<DefId &> lookup_lang_item (LangItem::Kind item_type);
     299              : 
     300              :   void insert_lang_item_node (LangItem::Kind item_type, NodeId node_id);
     301              :   tl::optional<NodeId &> lookup_lang_item_node (LangItem::Kind item_type);
     302              :   NodeId get_lang_item_node (LangItem::Kind item_type);
     303              :   std::string &get_lang_item_identifier (LangItem::Kind item_type);
     304              : 
     305              :   // This will fatal_error when this lang item does not exist
     306              :   DefId get_lang_item (LangItem::Kind item_type, location_t locus);
     307              : 
     308              :   void insert_macro_def (AST::MacroRulesDefinition *macro);
     309              : 
     310              :   tl::optional<AST::MacroRulesDefinition *> lookup_macro_def (NodeId id);
     311              :   tl::optional<CrateNum> lookup_macro_def_crate (NodeId id);
     312              : 
     313              :   void insert_macro_invocation (AST::MacroInvocation &invoc,
     314              :                                 AST::MacroRulesDefinition *def);
     315              :   tl::optional<AST::MacroRulesDefinition *>
     316              :   lookup_macro_invocation (AST::MacroInvocation &invoc);
     317              : 
     318              :   void insert_exported_macro (AST::MacroRulesDefinition &def);
     319              :   std::vector<AST::MacroRulesDefinition> get_exported_macros ();
     320              : 
     321              :   void insert_derive_proc_macros (CrateNum num,
     322              :                                   std::vector<CustomDeriveProcMacro> macros);
     323              :   void insert_bang_proc_macros (CrateNum num,
     324              :                                 std::vector<BangProcMacro> macros);
     325              :   void insert_attribute_proc_macros (CrateNum num,
     326              :                                      std::vector<AttributeProcMacro> macros);
     327              : 
     328              :   tl::optional<std::vector<CustomDeriveProcMacro> &>
     329              :   lookup_derive_proc_macros (CrateNum num);
     330              :   tl::optional<std::vector<BangProcMacro> &>
     331              :   lookup_bang_proc_macros (CrateNum num);
     332              :   tl::optional<std::vector<AttributeProcMacro> &>
     333              :   lookup_attribute_proc_macros (CrateNum num);
     334              : 
     335              :   void insert_derive_proc_macro_def (CustomDeriveProcMacro macro);
     336              :   void insert_bang_proc_macro_def (BangProcMacro macro);
     337              :   void insert_attribute_proc_macro_def (AttributeProcMacro macro);
     338              : 
     339              :   tl::optional<CustomDeriveProcMacro &>
     340              :   lookup_derive_proc_macro_def (NodeId id);
     341              :   tl::optional<BangProcMacro &> lookup_bang_proc_macro_def (NodeId id);
     342              :   tl::optional<AttributeProcMacro &>
     343              :   lookup_attribute_proc_macro_def (NodeId id);
     344              : 
     345              :   tl::optional<CustomDeriveProcMacro &>
     346              :   lookup_derive_proc_macro_invocation (AST::SimplePath &invoc);
     347              :   tl::optional<BangProcMacro &>
     348              :   lookup_bang_proc_macro_invocation (AST::MacroInvocation &invoc_id);
     349              :   tl::optional<AttributeProcMacro &>
     350              :   lookup_attribute_proc_macro_invocation (AST::SimplePath &invoc);
     351              :   void insert_derive_proc_macro_invocation (AST::SimplePath &invoc,
     352              :                                             CustomDeriveProcMacro def);
     353              :   void insert_bang_proc_macro_invocation (AST::MacroInvocation &invoc,
     354              :                                           BangProcMacro def);
     355              :   void insert_attribute_proc_macro_invocation (AST::SimplePath &invoc,
     356              :                                                AttributeProcMacro def);
     357              : 
     358              :   void insert_visibility (NodeId id, Privacy::ModuleVisibility visibility);
     359              :   tl::optional<Privacy::ModuleVisibility &> lookup_visibility (NodeId id);
     360              : 
     361              :   void insert_glob_container (NodeId, AST::GlobContainer *);
     362              :   tl::optional<AST::GlobContainer *> lookup_glob_container (NodeId id);
     363              : 
     364              :   void insert_module_id (NodeId);
     365              :   bool is_module (NodeId id);
     366              : 
     367              :   void insert_extern_crate_id (NodeId);
     368              :   bool is_extern_crate (NodeId id);
     369              : 
     370              :   void insert_module_child (NodeId module, NodeId child);
     371              :   tl::optional<std::vector<NodeId> &> lookup_module_children (NodeId module);
     372              : 
     373              :   void insert_module_child_item (NodeId module, Resolver::CanonicalPath item);
     374              :   tl::optional<std::vector<Resolver::CanonicalPath> &>
     375              :   lookup_module_chidren_items (NodeId module);
     376              :   tl::optional<Resolver::CanonicalPath &>
     377              :   lookup_module_child (NodeId module, const std::string &item_name);
     378              : 
     379              :   void insert_child_item_to_parent_module_mapping (NodeId child_item,
     380              :                                                    NodeId parent_module);
     381              :   tl::optional<NodeId> lookup_parent_module (NodeId child_item);
     382              :   bool node_is_module (NodeId query);
     383              : 
     384              :   void insert_ast_item (AST::Item *item);
     385              :   tl::optional<AST::Item *> lookup_ast_item (NodeId id);
     386              : 
     387              :   HIR::ImplBlock *lookup_builtin_marker ();
     388              : 
     389              :   tl::optional<HIR::TraitItem *>
     390              :   lookup_trait_item_lang_item (LangItem::Kind item, location_t locus);
     391              : 
     392              :   void insert_auto_trait (HIR::Trait *trait);
     393              :   std::vector<HIR::Trait *> &get_auto_traits ();
     394              :   void add_capture (NodeId closure, NodeId definition);
     395              :   tl::optional<std::vector<NodeId>> lookup_captures (NodeId closure);
     396              : 
     397              :   void add_derived_node (NodeId node_id);
     398              :   bool is_derived_node (NodeId node_id);
     399              : 
     400              :   void add_function_node (NodeId node_id);
     401              :   bool is_function_node (NodeId node_id);
     402              : 
     403              : private:
     404              :   Mappings ();
     405              : 
     406              :   CrateNum crateNumItr;
     407              :   CrateNum currentCrateNum;
     408              :   HirId hirIdIter;
     409              :   NodeId nodeIdIter;
     410              :   std::map<CrateNum, LocalDefId> localIdIter;
     411              :   HIR::ImplBlock *builtinMarker;
     412              : 
     413              :   AST::Crate *get_ast_crate_by_node_id_raw (NodeId id);
     414              : 
     415              :   std::map<NodeId, CrateNum> crate_node_to_crate_num;
     416              :   std::map<CrateNum, AST::Crate *> ast_crate_mappings;
     417              :   std::map<CrateNum, HIR::Crate *> hir_crate_mappings;
     418              :   std::map<DefId, HIR::Item *> defIdMappings;
     419              :   std::map<DefId, HIR::TraitItem *> defIdTraitItemMappings;
     420              :   std::map<CrateNum, std::map<LocalDefId, HIR::Item *>> localDefIdMappings;
     421              : 
     422              :   std::map<HirId, HIR::Module *> hirModuleMappings;
     423              :   std::map<HirId, HIR::Item *> hirItemMappings;
     424              :   std::map<HirId, std::pair<HIR::Enum *, HIR::EnumItem *>> hirEnumItemMappings;
     425              :   std::map<HirId, HIR::Type *> hirTypeMappings;
     426              :   std::map<HirId, HIR::Expr *> hirExprMappings;
     427              :   std::map<HirId, HIR::Stmt *> hirStmtMappings;
     428              :   std::map<HirId, HIR::FunctionParam *> hirParamMappings;
     429              :   std::map<HirId, HIR::StructExprField *> hirStructFieldMappings;
     430              :   std::map<HirId, std::pair<HirId, HIR::ImplItem *>> hirImplItemMappings;
     431              :   std::map<HirId, HIR::SelfParam *> hirSelfParamMappings;
     432              :   std::map<HirId, HIR::ImplBlock *> hirImplItemsToImplMappings;
     433              :   std::map<HirId, HIR::ImplBlock *> hirImplBlockMappings;
     434              :   std::map<HirId, HIR::ImplBlock *> hirTraitImplBlockMappings;
     435              :   std::map<std::string,
     436              :            std::vector<std::pair<HIR::ImplItem *, HIR::ImplBlock *>>>
     437              :     hirInherentImplItemMappings;
     438              :   std::map<HirId, HIR::ImplBlock *> hirImplBlockTypeMappings;
     439              :   std::map<DefId, std::vector<HIR::ImplBlock *>> hirAdtImplMappings;
     440              :   std::set<HIR::ImplBlock *> hirIndexedAdtImpls;
     441              :   std::map<DefId, std::vector<HIR::ImplBlock *>> hirTraitImplMappings;
     442              :   std::map<std::string, std::vector<DefId>> hirTraitItemNameMappings;
     443              :   bool hirImplIndexesBuilt;
     444              :   std::map<HirId, HIR::TraitItem *> hirTraitItemMappings;
     445              :   std::map<HirId, HIR::ExternBlock *> hirExternBlockMappings;
     446              :   std::map<HirId, std::pair<HIR::ExternalItem *, HirId>> hirExternItemMappings;
     447              :   std::map<HirId, HIR::PathExprSegment *> hirPathSegMappings;
     448              :   std::map<HirId, HIR::GenericParam *> hirGenericParamMappings;
     449              :   std::map<HirId, HIR::Trait *> hirTraitItemsToTraitMappings;
     450              :   std::map<HirId, HIR::Pattern *> hirPatternMappings;
     451              : 
     452              :   // FIXME: Add documentation
     453              :   std::vector<HIR::Trait *> auto_traits;
     454              : 
     455              :   // We need to have two maps here, as lang-items need to be used for both AST
     456              :   // passes and HIR passes. Thus those two maps are created at different times.
     457              :   std::map<LangItem::Kind, DefId> lang_item_mappings;
     458              :   std::map<LangItem::Kind, NodeId> lang_item_nodes;
     459              : 
     460              :   std::map<NodeId, Resolver::CanonicalPath> paths;
     461              :   std::map<NodeId, location_t> locations;
     462              :   std::map<NodeId, HirId> nodeIdToHirMappings;
     463              :   std::map<HirId, NodeId> hirIdToNodeMappings;
     464              : 
     465              :   // all hirid nodes
     466              :   std::map<CrateNum, std::set<HirId>> hirNodesWithinCrate;
     467              : 
     468              :   // MBE macros
     469              :   std::map<NodeId, std::pair<AST::MacroRulesDefinition *, CrateNum>>
     470              :     macroMappings;
     471              :   std::map<NodeId, AST::MacroRulesDefinition *> macroInvocations;
     472              :   std::vector<AST::MacroRulesDefinition> exportedMacros;
     473              : 
     474              :   // Procedural macros
     475              :   std::map<CrateNum, std::vector<CustomDeriveProcMacro>>
     476              :     procmacrosDeriveMappings;
     477              :   std::map<CrateNum, std::vector<BangProcMacro>> procmacrosBangMappings;
     478              :   std::map<CrateNum, std::vector<AttributeProcMacro>>
     479              :     procmacrosAttributeMappings;
     480              : 
     481              :   std::map<NodeId, CustomDeriveProcMacro> procmacroDeriveMappings;
     482              :   std::map<NodeId, BangProcMacro> procmacroBangMappings;
     483              :   std::map<NodeId, AttributeProcMacro> procmacroAttributeMappings;
     484              :   std::map<NodeId, CustomDeriveProcMacro> procmacroDeriveInvocations;
     485              :   std::map<NodeId, BangProcMacro> procmacroBangInvocations;
     486              :   std::map<NodeId, AttributeProcMacro> procmacroAttributeInvocations;
     487              : 
     488              :   // crate names
     489              :   std::map<CrateNum, std::string> crate_names;
     490              : 
     491              :   // Low level visibility map for each DefId
     492              :   std::map<NodeId, Privacy::ModuleVisibility> visibility_map;
     493              : 
     494              :   // Module tree maps
     495              : 
     496              :   // Maps each module's node id to a list of its children
     497              :   // TODO: I think these are only used by the old resolved and can be removed
     498              :   std::map<NodeId, std::vector<NodeId>> module_child_map;
     499              :   std::map<NodeId, std::vector<Resolver::CanonicalPath>> module_child_items;
     500              :   std::map<NodeId, NodeId> child_to_parent_module_map;
     501              : 
     502              :   std::map<NodeId, AST::GlobContainer *> glob_containers;
     503              :   std::set<NodeId> module_ids;
     504              :   std::set<NodeId> extern_crate_ids;
     505              : 
     506              :   // AST mappings
     507              :   std::map<NodeId, AST::Item *> ast_item_mappings;
     508              : 
     509              :   // Closure AST NodeId -> vector of Definition node ids
     510              :   std::unordered_map<NodeId, std::vector<NodeId>> captures;
     511              : 
     512              :   std::set<NodeId> derived_nodes;
     513              : 
     514              :   std::set<NodeId> function_nodes;
     515              : };
     516              : 
     517              : } // namespace Analysis
     518              : } // namespace Rust
     519              : 
     520              : #endif // RUST_HIR_MAP_H