Refactor mappings class and HIR lowering to be consistent

In order to support loading extern crates and use statements we needed to
clarify the usage of NodeId and HirId within gccrs. Each of these id's were
nested behind the CrateNum but the type resolution, linting and code-gen
passes do not support that level of nesting.

In order to get metadata exports and imports working lets focus on gccrs
supporting compilation of a single crate at a time. This means the crate
prefix only matters for imports and limits the complexity here. Down the
line there might be a way to leverage DefId's for all Path resolution
which could solve this problem but significant refactoring would be
required here to do this properly and its not nessecary for a basic working
rust compiler.

1 files changed, 89 insertions, 138 deletions

diff --git a/gcc/rust/util/rust-hir-map.h b/gcc/rust/util/rust-hir-map.h
index 4360ae2..804242e 100644
--- a/gcc/rust/util/rust-hir-map.h
+++ b/gcc/rust/util/rust-hir-map.h
@@ -74,10 +74,9 @@ public:
   static Mappings *get ();
   ~Mappings ();
 
-  CrateNum get_next_crate_num ();
+  CrateNum get_next_crate_num (const std::string &name);
   void set_current_crate (CrateNum crateNum);
   CrateNum get_current_crate () const;
-  CrateNum setup_crate_mappings (std::string crate_name);
 
   bool get_crate_name (CrateNum crate_num, std::string &name) const
   {
@@ -90,16 +89,9 @@ public:
   }
 
   // set crate name mid-compilation
-  // don't use this if setting crate name before Session::parse_files
-  bool set_crate_name (CrateNum crate_num, std::string name)
+  void set_crate_name (CrateNum crate_num, const std::string &name)
   {
-    rust_assert (!name.empty ());
-    auto it = crate_names.find (crate_num);
-    if (it == crate_names.end ())
-      return false;
-
-    it->second.assign (name);
-    return true;
+    crate_names[crate_num] = name;
   }
 
   std::string get_current_crate_name () const
@@ -110,20 +102,22 @@ public:
     return name;
   }
 
-  NodeId get_next_node_id () { return get_next_node_id (get_current_crate ()); }
-  NodeId get_next_node_id (CrateNum crateNum);
-
+  NodeId get_next_node_id ();
   HirId get_next_hir_id () { return get_next_hir_id (get_current_crate ()); }
   HirId get_next_hir_id (CrateNum crateNum);
-
+  LocalDefId get_next_localdef_id ()
+  {
+    return get_next_localdef_id (get_current_crate ());
+  }
   LocalDefId get_next_localdef_id (CrateNum crateNum);
 
-  AST::Crate *get_ast_crate (CrateNum crateNum);
-  void insert_ast_crate (AST::Crate *crate);
-
-  HIR::Crate *get_hir_crate (CrateNum crateNum);
+  AST::Crate &get_ast_crate (CrateNum crateNum);
+  AST::Crate &get_ast_crate_by_node_id (NodeId id);
+  AST::Crate &insert_ast_crate (std::unique_ptr<AST::Crate> &&crate,
+				CrateNum crate_num);
+  HIR::Crate &insert_hir_crate (std::unique_ptr<HIR::Crate> &&crate);
+  HIR::Crate &get_hir_crate (CrateNum crateNum);
   bool is_local_hirid_crate (HirId crateNum);
-  void insert_hir_crate (HIR::Crate *crate);
 
   void insert_defid_mapping (DefId id, HIR::Item *item);
   HIR::Item *lookup_defid (DefId id);
@@ -132,88 +126,62 @@ public:
 				   HIR::Item *item);
   HIR::Item *lookup_local_defid (CrateNum crateNum, LocalDefId id);
 
-  void insert_hir_item (CrateNum crateNum, HirId id, HIR::Item *item);
-  HIR::Item *lookup_hir_item (CrateNum crateNum, HirId id);
-
-  void insert_hir_trait_item (CrateNum crateNum, HirId id,
-			      HIR::TraitItem *item);
-  HIR::TraitItem *lookup_hir_trait_item (CrateNum crateNum, HirId id);
+  void insert_hir_item (HIR::Item *item);
+  HIR::Item *lookup_hir_item (HirId id);
 
-  void insert_hir_extern_item (CrateNum crateNum, HirId id,
-			       HIR::ExternalItem *item);
-  HIR::ExternalItem *lookup_hir_extern_item (CrateNum crateNum, HirId id);
+  void insert_hir_trait_item (HIR::TraitItem *item);
+  HIR::TraitItem *lookup_hir_trait_item (HirId id);
 
-  void insert_hir_impl_block (CrateNum crateNum, HirId id,
-			      HIR::ImplBlock *item);
-  HIR::ImplBlock *lookup_hir_impl_block (CrateNum crateNum, HirId id);
+  void insert_hir_extern_item (HIR::ExternalItem *item);
+  HIR::ExternalItem *lookup_hir_extern_item (HirId id);
 
-  void insert_module (CrateNum crateNum, HirId id, HIR::Module *module);
-  HIR::Module *lookup_module (CrateNum crateNum, HirId id);
+  void insert_hir_impl_block (HIR::ImplBlock *item);
+  HIR::ImplBlock *lookup_hir_impl_block (HirId id);
 
-  void insert_hir_implitem (CrateNum crateNum, HirId id, HirId parent_impl_id,
-			    HIR::ImplItem *item);
-  HIR::ImplItem *lookup_hir_implitem (CrateNum crateNum, HirId id,
-				      HirId *parent_impl_id);
+  void insert_module (HIR::Module *module);
+  HIR::Module *lookup_module (HirId id);
 
-  void insert_hir_expr (CrateNum crateNum, HirId id, HIR::Expr *expr);
-  HIR::Expr *lookup_hir_expr (CrateNum crateNum, HirId id);
+  void insert_hir_implitem (HirId parent_impl_id, HIR::ImplItem *item);
+  HIR::ImplItem *lookup_hir_implitem (HirId id, HirId *parent_impl_id);
 
-  void insert_hir_path_expr_seg (CrateNum crateNum, HirId id,
-				 HIR::PathExprSegment *expr);
-  HIR::PathExprSegment *lookup_hir_path_expr_seg (CrateNum crateNum, HirId id);
+  void insert_hir_expr (HIR::Expr *expr);
+  HIR::Expr *lookup_hir_expr (HirId id);
 
-  void insert_simple_path_segment (CrateNum crateNum, HirId id,
-				   const AST::SimplePathSegment *path);
-  const AST::SimplePathSegment *lookup_simple_path_segment (CrateNum crateNum,
-							    HirId id);
+  void insert_hir_path_expr_seg (HIR::PathExprSegment *expr);
+  HIR::PathExprSegment *lookup_hir_path_expr_seg (HirId id);
 
-  void insert_simple_path (CrateNum crateNum, HirId id,
-			   const AST::SimplePath *path);
-  const AST::SimplePath *lookup_simple_path (CrateNum crateNum, HirId id);
+  void insert_hir_generic_param (HIR::GenericParam *expr);
+  HIR::GenericParam *lookup_hir_generic_param (HirId id);
 
-  void insert_hir_generic_param (CrateNum crateNum, HirId id,
-				 HIR::GenericParam *expr);
-  HIR::GenericParam *lookup_hir_generic_param (CrateNum crateNum, HirId id);
+  void insert_hir_type (HIR::Type *type);
+  HIR::Type *lookup_hir_type (HirId id);
 
-  void insert_hir_type (CrateNum crateNum, HirId id, HIR::Type *type);
-  HIR::Type *lookup_hir_type (CrateNum crateNum, HirId id);
+  void insert_hir_stmt (HIR::Stmt *stmt);
+  HIR::Stmt *lookup_hir_stmt (HirId id);
 
-  void insert_hir_stmt (CrateNum crateNum, HirId id, HIR::Stmt *stmt);
-  HIR::Stmt *lookup_hir_stmt (CrateNum crateNum, HirId id);
+  void insert_hir_param (HIR::FunctionParam *type);
+  HIR::FunctionParam *lookup_hir_param (HirId id);
 
-  void insert_hir_param (CrateNum crateNum, HirId id, HIR::FunctionParam *type);
-  HIR::FunctionParam *lookup_hir_param (CrateNum crateNum, HirId id);
+  void insert_hir_self_param (HIR::SelfParam *type);
+  HIR::SelfParam *lookup_hir_self_param (HirId id);
 
-  void insert_hir_self_param (CrateNum crateNum, HirId id,
-			      HIR::SelfParam *type);
-  HIR::SelfParam *lookup_hir_self_param (CrateNum crateNum, HirId id);
+  void insert_hir_struct_field (HIR::StructExprField *type);
+  HIR::StructExprField *lookup_hir_struct_field (HirId id);
 
-  void insert_hir_struct_field (CrateNum crateNum, HirId id,
-				HIR::StructExprField *type);
-  HIR::StructExprField *lookup_hir_struct_field (CrateNum crateNum, HirId id);
-
-  void insert_hir_pattern (CrateNum crateNum, HirId id, HIR::Pattern *pattern);
-  HIR::Pattern *lookup_hir_pattern (CrateNum crateNum, HirId id);
+  void insert_hir_pattern (HIR::Pattern *pattern);
+  HIR::Pattern *lookup_hir_pattern (HirId id);
 
   void walk_local_defids_for_crate (CrateNum crateNum,
 				    std::function<bool (HIR::Item *)> cb);
 
-  void insert_node_to_hir (CrateNum crate, NodeId id, HirId ref);
-  bool lookup_node_to_hir (CrateNum crate, NodeId id, HirId *ref);
-  bool lookup_hir_to_node (CrateNum crate, HirId id, NodeId *ref);
+  void insert_node_to_hir (NodeId id, HirId ref);
+  bool lookup_node_to_hir (NodeId id, HirId *ref);
+  bool lookup_hir_to_node (HirId id, NodeId *ref);
 
-  void insert_location (CrateNum crate, HirId id, Location locus);
-  Location lookup_location (CrateNum crate, HirId id);
-  Location lookup_location (HirId id)
-  {
-    return lookup_location (get_current_crate (), id);
-  }
+  void insert_location (HirId id, Location locus);
+  Location lookup_location (HirId id);
 
-  bool resolve_nodeid_to_stmt (CrateNum crate, NodeId id, HIR::Stmt **stmt);
-  bool resolve_nodeid_to_stmt (NodeId id, HIR::Stmt **stmt)
-  {
-    return resolve_nodeid_to_stmt (get_current_crate (), id, stmt);
-  }
+  bool resolve_nodeid_to_stmt (NodeId id, HIR::Stmt **stmt);
 
   std::set<HirId> &get_hirids_within_crate (CrateNum crate)
   {
@@ -245,8 +213,7 @@ public:
   bool is_impl_item (HirId id)
   {
     HirId parent_impl_block_id = UNKNOWN_HIRID;
-    return lookup_hir_implitem (get_current_crate (), id, &parent_impl_block_id)
-	   != nullptr;
+    return lookup_hir_implitem (id, &parent_impl_block_id) != nullptr;
   }
 
   void insert_trait_item_mapping (HirId trait_item_id, HIR::Trait *trait)
@@ -263,11 +230,10 @@ public:
     return lookup->second;
   }
 
-  void insert_canonical_path (CrateNum crate, NodeId id,
-			      const Resolver::CanonicalPath path)
+  void insert_canonical_path (NodeId id, const Resolver::CanonicalPath path)
   {
     const Resolver::CanonicalPath *p = nullptr;
-    if (lookup_canonical_path (crate, id, &p))
+    if (lookup_canonical_path (id, &p))
       {
 	// if we have already stored a canonical path this is ok so long as
 	// this new path is equal or is smaller that the existing one but in
@@ -281,21 +247,16 @@ public:
 	  }
       }
 
-    paths[crate].emplace (id, std::move (path));
+    paths.emplace (id, std::move (path));
   }
 
-  bool lookup_canonical_path (CrateNum crate, NodeId id,
-			      const Resolver::CanonicalPath **path)
+  bool lookup_canonical_path (NodeId id, const Resolver::CanonicalPath **path)
   {
-    auto it = paths.find (crate);
+    auto it = paths.find (id);
     if (it == paths.end ())
       return false;
 
-    auto iy = it->second.find (id);
-    if (iy == it->second.end ())
-      return false;
-
-    *path = &iy->second;
+    *path = &it->second;
     return true;
   }
 
@@ -338,59 +299,46 @@ public:
   Optional<NodeId> lookup_parent_module (NodeId child_item);
   bool node_is_module (NodeId query);
 
+  void insert_ast_item (AST::Item *item);
+  bool lookup_ast_item (NodeId id, AST::Item **result);
+
 private:
   Mappings ();
 
-  CrateNum crateNumItr = 0;
+  CrateNum crateNumItr;
   CrateNum currentCrateNum;
-
-  std::map<CrateNum, HirId> hirIdIter;
-  std::map<CrateNum, NodeId> nodeIdIter;
+  HirId hirIdIter;
+  NodeId nodeIdIter;
   std::map<CrateNum, LocalDefId> localIdIter;
 
-  std::map<CrateNum, AST::Crate *> astCrateMappings;
-  std::map<CrateNum, HIR::Crate *> hirCrateMappings;
-
+  std::map<NodeId, CrateNum> crate_node_to_crate_num;
+  std::map<CrateNum, AST::Crate *> ast_crate_mappings;
+  std::map<CrateNum, HIR::Crate *> hir_crate_mappings;
   std::map<DefId, HIR::Item *> defIdMappings;
   std::map<CrateNum, std::map<LocalDefId, HIR::Item *>> localDefIdMappings;
-  std::map<CrateNum, std::map<HirId, HIR::Module *>> hirModuleMappings;
-  std::map<CrateNum, std::map<HirId, HIR::Item *>> hirItemMappings;
-  std::map<CrateNum, std::map<HirId, HIR::Type *>> hirTypeMappings;
-  std::map<CrateNum, std::map<HirId, HIR::Expr *>> hirExprMappings;
-  std::map<CrateNum, std::map<HirId, HIR::Stmt *>> hirStmtMappings;
-  std::map<CrateNum, std::map<HirId, HIR::FunctionParam *>> hirParamMappings;
-  std::map<CrateNum, std::map<HirId, HIR::StructExprField *>>
-    hirStructFieldMappings;
-  std::map<CrateNum, std::map<HirId, std::pair<HirId, HIR::ImplItem *>>>
-    hirImplItemMappings;
-  std::map<CrateNum, std::map<HirId, HIR::SelfParam *>> hirSelfParamMappings;
+
+  std::map<HirId, HIR::Module *> hirModuleMappings;
+  std::map<HirId, HIR::Item *> hirItemMappings;
+  std::map<HirId, HIR::Type *> hirTypeMappings;
+  std::map<HirId, HIR::Expr *> hirExprMappings;
+  std::map<HirId, HIR::Stmt *> hirStmtMappings;
+  std::map<HirId, HIR::FunctionParam *> hirParamMappings;
+  std::map<HirId, HIR::StructExprField *> hirStructFieldMappings;
+  std::map<HirId, std::pair<HirId, HIR::ImplItem *>> hirImplItemMappings;
+  std::map<HirId, HIR::SelfParam *> hirSelfParamMappings;
   std::map<HirId, HIR::ImplBlock *> hirImplItemsToImplMappings;
-  std::map<CrateNum, std::map<HirId, HIR::ImplBlock *>> hirImplBlockMappings;
-  std::map<CrateNum, std::map<HirId, HIR::TraitItem *>> hirTraitItemMappings;
-  std::map<CrateNum, std::map<HirId, HIR::ExternalItem *>>
-    hirExternItemMappings;
-  std::map<CrateNum, std::map<HirId, const AST::SimplePath *>>
-    astSimplePathMappings;
-  std::map<CrateNum, std::map<HirId, const AST::SimplePathSegment *>>
-    astSimplePathSegmentMappings;
-  std::map<CrateNum, std::map<HirId, HIR::PathExprSegment *>>
-    hirPathSegMappings;
-  std::map<CrateNum, std::map<HirId, HIR::GenericParam *>>
-    hirGenericParamMappings;
+  std::map<HirId, HIR::ImplBlock *> hirImplBlockMappings;
+  std::map<HirId, HIR::TraitItem *> hirTraitItemMappings;
+  std::map<HirId, HIR::ExternalItem *> hirExternItemMappings;
+  std::map<HirId, HIR::PathExprSegment *> hirPathSegMappings;
+  std::map<HirId, HIR::GenericParam *> hirGenericParamMappings;
   std::map<HirId, HIR::Trait *> hirTraitItemsToTraitMappings;
-  std::map<CrateNum, std::map<HirId, HIR::Pattern *>> hirPatternMappings;
-
-  // this maps the lang=<item_type> to DefId mappings
+  std::map<HirId, HIR::Pattern *> hirPatternMappings;
   std::map<RustLangItem::ItemType, DefId> lang_item_mappings;
-
-  // canonical paths
-  std::map<CrateNum, std::map<NodeId, const Resolver::CanonicalPath>> paths;
-
-  // location info
-  std::map<CrateNum, std::map<NodeId, Location>> locations;
-
-  std::map<CrateNum, std::map<NodeId, HirId>> nodeIdToHirMappings;
-  std::map<CrateNum, std::map<HirId, NodeId>> hirIdToNodeMappings;
+  std::map<NodeId, const Resolver::CanonicalPath> paths;
+  std::map<NodeId, Location> locations;
+  std::map<NodeId, HirId> nodeIdToHirMappings;
+  std::map<HirId, NodeId> hirIdToNodeMappings;
 
   // all hirid nodes
   std::map<CrateNum, std::set<HirId>> hirNodesWithinCrate;
@@ -410,6 +358,9 @@ private:
   std::map<NodeId, std::vector<NodeId>> module_child_map;
   std::map<NodeId, std::vector<Resolver::CanonicalPath>> module_child_items;
   std::map<NodeId, NodeId> child_to_parent_module_map;
+
+  // AST mappings
+  std::map<NodeId, AST::Item *> ast_item_mappings;
 };
 
 } // namespace Analysis