3 files changed, 345 insertions, 483 deletions

diff --git a/gcc/rust/util/rust-attributes.cc b/gcc/rust/util/rust-attributes.cc
index 870ca21..b5989fb 100644
--- a/gcc/rust/util/rust-attributes.cc
+++ b/gcc/rust/util/rust-attributes.cc
@@ -35,6 +35,7 @@ static const BuiltinAttrDefinition __definitions[] = {
   {"link_section", CODE_GENERATION},
   {"no_mangle", CODE_GENERATION},
   {"repr", CODE_GENERATION},
+  {"path", EXPANSION},
 };
 
 BuiltinAttributeMappings *
diff --git a/gcc/rust/util/rust-hir-map.cc b/gcc/rust/util/rust-hir-map.cc
index 8b3be5c..353b7cb 100644
--- a/gcc/rust/util/rust-hir-map.cc
+++ b/gcc/rust/util/rust-hir-map.cc
@@ -20,6 +20,7 @@
 #include "rust-ast-full.h"
 #include "rust-hir-full.h"
 #include "rust-macro-builtins.h"
+#include "rust-mapping-common.h"
 
 namespace Rust {
 namespace Analysis {
@@ -87,8 +88,14 @@ NodeMapping::as_string () const
 }
 
 // Mappings Class now
+static const HirId kDefaultNodeIdBegin = 1;
+static const HirId kDefaultHirIdBegin = 1;
+static const HirId kDefaultCrateNumBegin = 0;
 
-Mappings::Mappings () {}
+Mappings::Mappings ()
+  : crateNumItr (kDefaultCrateNumBegin), currentCrateNum (UNKNOWN_CREATENUM),
+    hirIdIter (kDefaultHirIdBegin), nodeIdIter (kDefaultNodeIdBegin)
+{}
 
 Mappings::~Mappings () {}
 
@@ -103,9 +110,12 @@ Mappings::get ()
 }
 
 CrateNum
-Mappings::get_next_crate_num ()
+Mappings::get_next_crate_num (const std::string &name)
 {
-  return crateNumItr++;
+  auto id = crateNumItr;
+  crateNumItr++;
+  set_crate_name (id, name);
+  return id;
 }
 
 void
@@ -115,48 +125,31 @@ Mappings::set_current_crate (CrateNum crateNum)
 }
 
 CrateNum
-Mappings::setup_crate_mappings (std::string crate_name)
-{
-  CrateNum crate_num = get_next_crate_num ();
-
-  hirIdIter[crate_num] = UNKNOWN_HIRID;
-  nodeIdIter[crate_num] = UNKNOWN_NODEID;
-  localIdIter[crate_num] = UNKNOWN_LOCAL_DEFID;
-  nodeIdToHirMappings[crate_num] = {};
-  locations[crate_num] = {};
-  crate_names[crate_num] = crate_name;
-
-  return crate_num;
-}
-
-CrateNum
 Mappings::get_current_crate () const
 {
   return currentCrateNum;
 }
 
 NodeId
-Mappings::get_next_node_id (CrateNum crateNum)
+Mappings::get_next_node_id ()
 {
-  auto it = nodeIdIter.find (crateNum);
-  // We're probably *not* parsing actual rust code... but mostly reusing
-  // the parser in another way. Return 0
-  if (it == nodeIdIter.end ())
-    return 0;
-
-  auto id = it->second + 1;
-  nodeIdIter[crateNum] = id;
-  return id;
+  auto it = nodeIdIter;
+  nodeIdIter++;
+  return it;
 }
 
 HirId
 Mappings::get_next_hir_id (CrateNum crateNum)
 {
-  auto it = hirIdIter.find (crateNum);
-  rust_assert (it != hirIdIter.end ());
+  auto id = hirIdIter;
+  hirIdIter++;
+
+  auto it = hirNodesWithinCrate.find (crateNum);
+  if (it == hirNodesWithinCrate.end ())
+    {
+      hirNodesWithinCrate.insert ({crateNum, {}});
+    }
 
-  auto id = it->second + 1;
-  hirIdIter[crateNum] = id;
   hirNodesWithinCrate[crateNum].insert (id);
   return id;
 }
@@ -165,64 +158,89 @@ LocalDefId
 Mappings::get_next_localdef_id (CrateNum crateNum)
 {
   auto it = localIdIter.find (crateNum);
+  if (it == localIdIter.end ())
+    {
+      localIdIter.insert ({crateNum, 1});
+    }
+
+  it = localIdIter.find (crateNum);
   rust_assert (it != localIdIter.end ());
 
-  auto id = it->second + 1;
-  localIdIter[crateNum] = id;
+  LocalDefId id = it->second;
+  localIdIter[crateNum] = id + 1;
   return id;
 }
 
-AST::Crate *
+AST::Crate &
 Mappings::get_ast_crate (CrateNum crateNum)
 {
-  auto it = astCrateMappings.find (crateNum);
-  if (it == astCrateMappings.end ())
-    return nullptr;
+  auto it = ast_crate_mappings.find (crateNum);
+  rust_assert (it != ast_crate_mappings.end ());
+  return *it->second;
+}
 
-  return it->second;
+AST::Crate &
+Mappings::get_ast_crate_by_node_id (NodeId id)
+{
+  auto i = crate_node_to_crate_num.find (id);
+  rust_assert (i != crate_node_to_crate_num.end ());
+
+  CrateNum crateNum = i->second;
+  auto it = ast_crate_mappings.find (crateNum);
+  rust_assert (it != ast_crate_mappings.end ());
+  return *it->second;
 }
 
-void
-Mappings::insert_ast_crate (AST::Crate *crate)
+AST::Crate &
+Mappings::insert_ast_crate (std::unique_ptr<AST::Crate> &&crate,
+			    CrateNum crate_num)
 {
-  CrateNum crateNum = get_current_crate ();
-  rust_assert (get_ast_crate (crateNum) == nullptr);
+  auto it = ast_crate_mappings.find (crate_num);
+  rust_assert (it == ast_crate_mappings.end ());
 
-  astCrateMappings[crateNum] = crate;
+  // store it
+  ast_crate_mappings.insert ({crate_num, crate.get ()});
+
+  // return the reference to it
+  it = ast_crate_mappings.find (crate_num);
+  rust_assert (it != ast_crate_mappings.end ());
+  return *it->second;
 }
 
-HIR::Crate *
+HIR::Crate &
 Mappings::get_hir_crate (CrateNum crateNum)
 {
-  auto it = hirCrateMappings.find (crateNum);
-  if (it == hirCrateMappings.end ())
-    return nullptr;
-
-  return it->second;
+  auto it = hir_crate_mappings.find (crateNum);
+  rust_assert (it != hir_crate_mappings.end ());
+  return *it->second;
 }
 
 bool
 Mappings::is_local_hirid_crate (HirId crateNum)
 {
-  for (const auto &it : hirCrateMappings)
+  for (const auto &it : hir_crate_mappings)
     {
-      const HIR::Crate *crate = it.second;
+      const auto &crate = it.second;
       if (crate->get_mappings ().get_hirid () == crateNum)
 	return true;
     }
   return false;
 }
 
-void
-Mappings::insert_hir_crate (HIR::Crate *crate)
+HIR::Crate &
+Mappings::insert_hir_crate (std::unique_ptr<HIR::Crate> &&crate)
 {
   CrateNum crateNum = crate->get_mappings ().get_crate_num ();
-  rust_assert (get_hir_crate (crateNum) == nullptr);
+  auto it = hir_crate_mappings.find (crateNum);
+  rust_assert (it == hir_crate_mappings.end ());
 
-  hirCrateMappings[crateNum] = crate;
-  insert_node_to_hir (crate->get_mappings ().get_crate_num (),
-		      crate->get_mappings ().get_nodeid (),
+  insert_node_to_hir (crate->get_mappings ().get_nodeid (),
 		      crate->get_mappings ().get_hirid ());
+  hir_crate_mappings.insert ({crateNum, crate.get ()});
+
+  it = hir_crate_mappings.find (crateNum);
+  rust_assert (it != hir_crate_mappings.end ());
+  return *it->second;
 }
 
 void
@@ -249,145 +267,124 @@ Mappings::lookup_defid (DefId id)
 }
 
 void
-Mappings::insert_hir_item (CrateNum crateNum, HirId id, HIR::Item *item)
+Mappings::insert_hir_item (HIR::Item *item)
 {
-  rust_assert (lookup_hir_item (crateNum, id) == nullptr);
+  auto id = item->get_mappings ().get_hirid ();
+  rust_assert (lookup_hir_item (id) == nullptr);
 
-  hirItemMappings[crateNum][id] = item;
-  insert_node_to_hir (crateNum, item->get_mappings ().get_nodeid (), id);
+  hirItemMappings[id] = item;
+  insert_node_to_hir (item->get_mappings ().get_nodeid (), id);
 }
 
 HIR::Item *
-Mappings::lookup_hir_item (CrateNum crateNum, HirId id)
+Mappings::lookup_hir_item (HirId id)
 {
-  auto it = hirItemMappings.find (crateNum);
+  auto it = hirItemMappings.find (id);
   if (it == hirItemMappings.end ())
     return nullptr;
 
-  auto iy = it->second.find (id);
-  if (iy == it->second.end ())
-    return nullptr;
-
-  return iy->second;
+  return it->second;
 }
 
 void
-Mappings::insert_hir_trait_item (CrateNum crateNum, HirId id,
-				 HIR::TraitItem *item)
+Mappings::insert_hir_trait_item (HIR::TraitItem *item)
 {
-  rust_assert (lookup_hir_trait_item (crateNum, id) == nullptr);
+  auto id = item->get_mappings ().get_hirid ();
+  rust_assert (lookup_hir_trait_item (id) == nullptr);
 
-  hirTraitItemMappings[crateNum][id] = item;
-  insert_node_to_hir (crateNum, item->get_mappings ().get_nodeid (), id);
+  hirTraitItemMappings[id] = item;
+  insert_node_to_hir (item->get_mappings ().get_nodeid (), id);
 }
 
 HIR::TraitItem *
-Mappings::lookup_hir_trait_item (CrateNum crateNum, HirId id)
+Mappings::lookup_hir_trait_item (HirId id)
 {
-  auto it = hirTraitItemMappings.find (crateNum);
+  auto it = hirTraitItemMappings.find (id);
   if (it == hirTraitItemMappings.end ())
     return nullptr;
 
-  auto iy = it->second.find (id);
-  if (iy == it->second.end ())
-    return nullptr;
-
-  return iy->second;
+  return it->second;
 }
 
 void
-Mappings::insert_hir_extern_item (CrateNum crateNum, HirId id,
-				  HIR::ExternalItem *item)
+Mappings::insert_hir_extern_item (HIR::ExternalItem *item)
 {
-  rust_assert (lookup_hir_extern_item (crateNum, id) == nullptr);
+  auto id = item->get_mappings ().get_hirid ();
+  rust_assert (lookup_hir_extern_item (id) == nullptr);
 
-  hirExternItemMappings[crateNum][id] = item;
-  insert_node_to_hir (crateNum, item->get_mappings ().get_nodeid (), id);
+  hirExternItemMappings[id] = item;
+  insert_node_to_hir (item->get_mappings ().get_nodeid (), id);
 }
 
 HIR::ExternalItem *
-Mappings::lookup_hir_extern_item (CrateNum crateNum, HirId id)
+Mappings::lookup_hir_extern_item (HirId id)
 {
-  auto it = hirExternItemMappings.find (crateNum);
+  auto it = hirExternItemMappings.find (id);
   if (it == hirExternItemMappings.end ())
     return nullptr;
 
-  auto iy = it->second.find (id);
-  if (iy == it->second.end ())
-    return nullptr;
-
-  return iy->second;
+  return it->second;
 }
 
 void
-Mappings::insert_hir_impl_block (CrateNum crateNum, HirId id,
-				 HIR::ImplBlock *item)
+Mappings::insert_hir_impl_block (HIR::ImplBlock *item)
 {
-  rust_assert (lookup_hir_impl_block (crateNum, id) == nullptr);
+  auto id = item->get_mappings ().get_hirid ();
+  rust_assert (lookup_hir_impl_block (id) == nullptr);
 
-  hirImplBlockMappings[crateNum][id] = item;
-  insert_node_to_hir (crateNum, item->get_mappings ().get_nodeid (), id);
+  hirImplBlockMappings[id] = item;
+  insert_node_to_hir (item->get_mappings ().get_nodeid (), id);
 }
 
 HIR::ImplBlock *
-Mappings::lookup_hir_impl_block (CrateNum crateNum, HirId id)
+Mappings::lookup_hir_impl_block (HirId id)
 {
-  auto it = hirImplBlockMappings.find (crateNum);
+  auto it = hirImplBlockMappings.find (id);
   if (it == hirImplBlockMappings.end ())
     return nullptr;
 
-  auto iy = it->second.find (id);
-  if (iy == it->second.end ())
-    return nullptr;
-
-  return iy->second;
+  return it->second;
 }
 
 void
-Mappings::insert_module (CrateNum crateNum, HirId id, HIR::Module *module)
+Mappings::insert_module (HIR::Module *module)
 {
-  rust_assert (lookup_module (crateNum, id) == nullptr);
+  auto id = module->get_mappings ().get_hirid ();
+  rust_assert (lookup_module (id) == nullptr);
 
-  hirModuleMappings[crateNum][id] = module;
+  hirModuleMappings[id] = module;
+  insert_node_to_hir (module->get_mappings ().get_nodeid (), id);
 }
 
 HIR::Module *
-Mappings::lookup_module (CrateNum crateNum, HirId id)
+Mappings::lookup_module (HirId id)
 {
-  auto it = hirModuleMappings.find (crateNum);
+  auto it = hirModuleMappings.find (id);
   if (it == hirModuleMappings.end ())
     return nullptr;
 
-  auto iy = it->second.find (id);
-  if (iy == it->second.end ())
-    return nullptr;
-
-  return iy->second;
+  return it->second;
 }
 
 void
-Mappings::insert_hir_implitem (CrateNum crateNum, HirId id,
-			       HirId parent_impl_id, HIR::ImplItem *item)
+Mappings::insert_hir_implitem (HirId parent_impl_id, HIR::ImplItem *item)
 {
-  rust_assert (lookup_hir_implitem (crateNum, id, nullptr) == nullptr);
-  hirImplItemMappings[crateNum][id]
+  auto id = item->get_impl_mappings ().get_hirid ();
+  rust_assert (lookup_hir_implitem (id, nullptr) == nullptr);
+
+  hirImplItemMappings[id]
     = std::pair<HirId, HIR::ImplItem *> (parent_impl_id, item);
-  insert_node_to_hir (crateNum, item->get_impl_mappings ().get_nodeid (), id);
+  insert_node_to_hir (item->get_impl_mappings ().get_nodeid (), id);
 }
 
 HIR::ImplItem *
-Mappings::lookup_hir_implitem (CrateNum crateNum, HirId id,
-			       HirId *parent_impl_id)
+Mappings::lookup_hir_implitem (HirId id, HirId *parent_impl_id)
 {
-  auto it = hirImplItemMappings.find (crateNum);
+  auto it = hirImplItemMappings.find (id);
   if (it == hirImplItemMappings.end ())
     return nullptr;
 
-  auto iy = it->second.find (id);
-  if (iy == it->second.end ())
-    return nullptr;
-
-  std::pair<HirId, HIR::ImplItem *> &ref = iy->second;
+  std::pair<HirId, HIR::ImplItem *> &ref = it->second;
   if (parent_impl_id != nullptr)
     *parent_impl_id = ref.first;
 
@@ -395,266 +392,185 @@ Mappings::lookup_hir_implitem (CrateNum crateNum, HirId id,
 }
 
 void
-Mappings::insert_hir_expr (CrateNum crateNum, HirId id, HIR::Expr *expr)
+Mappings::insert_hir_expr (HIR::Expr *expr)
 {
-  hirExprMappings[crateNum][id] = expr;
-  insert_node_to_hir (crateNum, expr->get_mappings ().get_nodeid (), id);
-  insert_location (crateNum, id, expr->get_locus ());
+  auto id = expr->get_mappings ().get_hirid ();
+  hirExprMappings[id] = expr;
+
+  insert_node_to_hir (expr->get_mappings ().get_nodeid (), id);
+  insert_location (id, expr->get_locus ());
 }
 
 HIR::Expr *
-Mappings::lookup_hir_expr (CrateNum crateNum, HirId id)
+Mappings::lookup_hir_expr (HirId id)
 {
-  auto it = hirExprMappings.find (crateNum);
+  auto it = hirExprMappings.find (id);
   if (it == hirExprMappings.end ())
     return nullptr;
 
-  auto iy = it->second.find (id);
-  if (iy == it->second.end ())
-    return nullptr;
-
-  return iy->second;
+  return it->second;
 }
 
 void
-Mappings::insert_hir_path_expr_seg (CrateNum crateNum, HirId id,
-				    HIR::PathExprSegment *expr)
+Mappings::insert_hir_path_expr_seg (HIR::PathExprSegment *expr)
 {
-  rust_assert (lookup_hir_path_expr_seg (crateNum, id) == nullptr);
+  auto id = expr->get_mappings ().get_hirid ();
+  rust_assert (lookup_hir_path_expr_seg (id) == nullptr);
 
-  hirPathSegMappings[crateNum][id] = expr;
-  insert_node_to_hir (crateNum, expr->get_mappings ().get_nodeid (), id);
-  insert_location (crateNum, id, expr->get_locus ());
+  hirPathSegMappings[id] = expr;
+  insert_node_to_hir (expr->get_mappings ().get_nodeid (), id);
+  insert_location (id, expr->get_locus ());
 }
 
 HIR::PathExprSegment *
-Mappings::lookup_hir_path_expr_seg (CrateNum crateNum, HirId id)
+Mappings::lookup_hir_path_expr_seg (HirId id)
 {
-  auto it = hirPathSegMappings.find (crateNum);
+  auto it = hirPathSegMappings.find (id);
   if (it == hirPathSegMappings.end ())
     return nullptr;
 
-  auto iy = it->second.find (id);
-  if (iy == it->second.end ())
-    return nullptr;
-
-  return iy->second;
-}
-
-void
-Mappings::insert_simple_path_segment (CrateNum crateNum, HirId id,
-				      const AST::SimplePathSegment *path)
-{
-  rust_assert (lookup_simple_path_segment (crateNum, id) == nullptr);
-
-  astSimplePathSegmentMappings[crateNum][id] = path;
-  insert_node_to_hir (crateNum, path->get_node_id (), id);
-  insert_location (crateNum, id, path->get_locus ());
-}
-
-const AST::SimplePathSegment *
-Mappings::lookup_simple_path_segment (CrateNum crateNum, HirId id)
-{
-  auto it = astSimplePathSegmentMappings.find (crateNum);
-  if (it == astSimplePathSegmentMappings.end ())
-    return nullptr;
-
-  auto iy = it->second.find (id);
-  if (iy == it->second.end ())
-    return nullptr;
-
-  return iy->second;
-}
-
-void
-Mappings::insert_simple_path (CrateNum crateNum, HirId id,
-			      const AST::SimplePath *path)
-{
-  rust_assert (lookup_simple_path (crateNum, id) == nullptr);
-
-  astSimplePathMappings[crateNum][id] = path;
-  insert_node_to_hir (crateNum, path->get_node_id (), id);
-  insert_location (crateNum, id, path->get_locus ());
-}
-
-const AST::SimplePath *
-Mappings::lookup_simple_path (CrateNum crateNum, HirId id)
-{
-  auto it = astSimplePathMappings.find (crateNum);
-  if (it == astSimplePathMappings.end ())
-    return nullptr;
-
-  auto iy = it->second.find (id);
-  if (iy == it->second.end ())
-    return nullptr;
-
-  return iy->second;
+  return it->second;
 }
 
 void
-Mappings::insert_hir_generic_param (CrateNum crateNum, HirId id,
-				    HIR::GenericParam *param)
+Mappings::insert_hir_generic_param (HIR::GenericParam *param)
 {
-  rust_assert (lookup_hir_generic_param (crateNum, id) == nullptr);
+  auto id = param->get_mappings ().get_hirid ();
+  rust_assert (lookup_hir_generic_param (id) == nullptr);
 
-  hirGenericParamMappings[crateNum][id] = param;
-  insert_node_to_hir (crateNum, param->get_mappings ().get_nodeid (), id);
-  insert_location (crateNum, id, param->get_locus ());
+  hirGenericParamMappings[id] = param;
+  insert_node_to_hir (param->get_mappings ().get_nodeid (), id);
+  insert_location (id, param->get_locus ());
 }
 
 HIR::GenericParam *
-Mappings::lookup_hir_generic_param (CrateNum crateNum, HirId id)
+Mappings::lookup_hir_generic_param (HirId id)
 {
-  auto it = hirGenericParamMappings.find (crateNum);
+  auto it = hirGenericParamMappings.find (id);
   if (it == hirGenericParamMappings.end ())
     return nullptr;
 
-  auto iy = it->second.find (id);
-  if (iy == it->second.end ())
-    return nullptr;
-
-  return iy->second;
+  return it->second;
 }
 
 void
-Mappings::insert_hir_type (CrateNum crateNum, HirId id, HIR::Type *type)
+Mappings::insert_hir_type (HIR::Type *type)
 {
-  rust_assert (lookup_hir_type (crateNum, id) == nullptr);
+  auto id = type->get_mappings ().get_hirid ();
+  rust_assert (lookup_hir_type (id) == nullptr);
 
-  hirTypeMappings[crateNum][id] = type;
-  insert_node_to_hir (crateNum, type->get_mappings ().get_nodeid (), id);
+  hirTypeMappings[id] = type;
+  insert_node_to_hir (type->get_mappings ().get_nodeid (), id);
 }
 
 HIR::Type *
-Mappings::lookup_hir_type (CrateNum crateNum, HirId id)
+Mappings::lookup_hir_type (HirId id)
 {
-  auto it = hirTypeMappings.find (crateNum);
+  auto it = hirTypeMappings.find (id);
   if (it == hirTypeMappings.end ())
     return nullptr;
 
-  auto iy = it->second.find (id);
-  if (iy == it->second.end ())
-    return nullptr;
-
-  return iy->second;
+  return it->second;
 }
 
 void
-Mappings::insert_hir_stmt (CrateNum crateNum, HirId id, HIR::Stmt *stmt)
+Mappings::insert_hir_stmt (HIR::Stmt *stmt)
 {
-  rust_assert (lookup_hir_stmt (crateNum, id) == nullptr);
+  auto id = stmt->get_mappings ().get_hirid ();
+  rust_assert (lookup_hir_stmt (id) == nullptr);
 
-  hirStmtMappings[crateNum][id] = stmt;
-  insert_node_to_hir (crateNum, stmt->get_mappings ().get_nodeid (), id);
+  hirStmtMappings[id] = stmt;
+  insert_node_to_hir (stmt->get_mappings ().get_nodeid (), id);
 }
 
 HIR::Stmt *
-Mappings::lookup_hir_stmt (CrateNum crateNum, HirId id)
+Mappings::lookup_hir_stmt (HirId id)
 {
-  auto it = hirStmtMappings.find (crateNum);
+  auto it = hirStmtMappings.find (id);
   if (it == hirStmtMappings.end ())
     return nullptr;
 
-  auto iy = it->second.find (id);
-  if (iy == it->second.end ())
-    return nullptr;
-
-  return iy->second;
+  return it->second;
 }
 
 void
-Mappings::insert_hir_param (CrateNum crateNum, HirId id,
-			    HIR::FunctionParam *param)
+Mappings::insert_hir_param (HIR::FunctionParam *param)
 {
-  rust_assert (lookup_hir_stmt (crateNum, id) == nullptr);
+  auto id = param->get_mappings ().get_hirid ();
+  rust_assert (lookup_hir_param (id) == nullptr);
 
-  hirParamMappings[crateNum][id] = param;
-  insert_node_to_hir (crateNum, param->get_mappings ().get_nodeid (), id);
+  hirParamMappings[id] = param;
+  insert_node_to_hir (param->get_mappings ().get_nodeid (), id);
 }
 
 HIR::FunctionParam *
-Mappings::lookup_hir_param (CrateNum crateNum, HirId id)
+Mappings::lookup_hir_param (HirId id)
 {
-  auto it = hirParamMappings.find (crateNum);
+  auto it = hirParamMappings.find (id);
   if (it == hirParamMappings.end ())
     return nullptr;
 
-  auto iy = it->second.find (id);
-  if (iy == it->second.end ())
-    return nullptr;
-
-  return iy->second;
+  return it->second;
 }
 
 void
-Mappings::insert_hir_self_param (CrateNum crateNum, HirId id,
-				 HIR::SelfParam *param)
+Mappings::insert_hir_self_param (HIR::SelfParam *param)
 {
-  rust_assert (lookup_hir_stmt (crateNum, id) == nullptr);
+  auto id = param->get_mappings ().get_hirid ();
+  rust_assert (lookup_hir_self_param (id) == nullptr);
 
-  hirSelfParamMappings[crateNum][id] = param;
-  insert_node_to_hir (crateNum, param->get_mappings ().get_nodeid (), id);
+  hirSelfParamMappings[id] = param;
+  insert_node_to_hir (param->get_mappings ().get_nodeid (), id);
 }
 
 HIR::SelfParam *
-Mappings::lookup_hir_self_param (CrateNum crateNum, HirId id)
+Mappings::lookup_hir_self_param (HirId id)
 {
-  auto it = hirSelfParamMappings.find (crateNum);
+  auto it = hirSelfParamMappings.find (id);
   if (it == hirSelfParamMappings.end ())
     return nullptr;
 
-  auto iy = it->second.find (id);
-  if (iy == it->second.end ())
-    return nullptr;
-
-  return iy->second;
+  return it->second;
 }
 
 void
-Mappings::insert_hir_struct_field (CrateNum crateNum, HirId id,
-				   HIR::StructExprField *field)
+Mappings::insert_hir_struct_field (HIR::StructExprField *field)
 {
-  rust_assert (lookup_hir_stmt (crateNum, id) == nullptr);
+  auto id = field->get_mappings ().get_hirid ();
+  rust_assert (lookup_hir_struct_field (id) == nullptr);
 
-  hirStructFieldMappings[crateNum][id] = field;
-  insert_node_to_hir (crateNum, field->get_mappings ().get_nodeid (), id);
+  hirStructFieldMappings[id] = field;
+  insert_node_to_hir (field->get_mappings ().get_nodeid (), id);
 }
 
 HIR::StructExprField *
-Mappings::lookup_hir_struct_field (CrateNum crateNum, HirId id)
+Mappings::lookup_hir_struct_field (HirId id)
 {
-  auto it = hirStructFieldMappings.find (crateNum);
+  auto it = hirStructFieldMappings.find (id);
   if (it == hirStructFieldMappings.end ())
     return nullptr;
 
-  auto iy = it->second.find (id);
-  if (iy == it->second.end ())
-    return nullptr;
-
-  return iy->second;
+  return it->second;
 }
 
 void
-Mappings::insert_hir_pattern (CrateNum crateNum, HirId id,
-			      HIR::Pattern *pattern)
+Mappings::insert_hir_pattern (HIR::Pattern *pattern)
 {
-  hirPatternMappings[crateNum][id] = pattern;
-  insert_node_to_hir (crateNum, pattern->get_pattern_mappings ().get_nodeid (),
-		      id);
+  auto id = pattern->get_pattern_mappings ().get_hirid ();
+  rust_assert (lookup_hir_pattern (id) == nullptr);
+
+  hirPatternMappings[id] = pattern;
+  insert_node_to_hir (pattern->get_pattern_mappings ().get_nodeid (), id);
 }
 
 HIR::Pattern *
-Mappings::lookup_hir_pattern (CrateNum crateNum, HirId id)
+Mappings::lookup_hir_pattern (HirId id)
 {
-  auto it = hirPatternMappings.find (crateNum);
+  auto it = hirPatternMappings.find (id);
   if (it == hirPatternMappings.end ())
     return nullptr;
 
-  auto iy = it->second.find (id);
-  if (iy == it->second.end ())
-    return nullptr;
-
-  return iy->second;
+  return it->second;
 }
 
 void
@@ -662,7 +578,6 @@ Mappings::insert_local_defid_mapping (CrateNum crateNum, LocalDefId id,
 				      HIR::Item *item)
 {
   rust_assert (lookup_local_defid (crateNum, id) == nullptr);
-
   localDefIdMappings[crateNum][id] = item;
 }
 
@@ -696,75 +611,59 @@ Mappings::walk_local_defids_for_crate (CrateNum crateNum,
 }
 
 void
-Mappings::insert_node_to_hir (CrateNum crate, NodeId id, HirId ref)
+Mappings::insert_node_to_hir (NodeId id, HirId ref)
 {
-  nodeIdToHirMappings[crate][id] = ref;
-  hirIdToNodeMappings[crate][ref] = id;
+  nodeIdToHirMappings[id] = ref;
+  hirIdToNodeMappings[ref] = id;
 }
 
 bool
-Mappings::lookup_node_to_hir (CrateNum crate, NodeId id, HirId *ref)
+Mappings::lookup_node_to_hir (NodeId id, HirId *ref)
 {
-  auto it = nodeIdToHirMappings.find (crate);
+  auto it = nodeIdToHirMappings.find (id);
   if (it == nodeIdToHirMappings.end ())
     return false;
 
-  auto iy = it->second.find (id);
-  if (iy == it->second.end ())
-    return false;
-
-  *ref = iy->second;
+  *ref = it->second;
   return true;
 }
 
 bool
-Mappings::lookup_hir_to_node (CrateNum crate, HirId id, NodeId *ref)
+Mappings::lookup_hir_to_node (HirId id, NodeId *ref)
 {
-  auto it = hirIdToNodeMappings.find (crate);
+  auto it = hirIdToNodeMappings.find (id);
   if (it == hirIdToNodeMappings.end ())
     return false;
 
-  auto iy = it->second.find (id);
-  if (iy == it->second.end ())
-    return false;
-
-  *ref = iy->second;
+  *ref = it->second;
   return true;
 }
 
 void
-Mappings::insert_location (CrateNum crate, HirId id, Location locus)
+Mappings::insert_location (HirId id, Location locus)
 {
-  locations[crate][id] = locus;
+  locations[id] = locus;
 }
 
 Location
-Mappings::lookup_location (CrateNum crate, HirId id)
+Mappings::lookup_location (HirId id)
 {
-  auto it = locations.find (crate);
+  auto it = locations.find (id);
   if (it == locations.end ())
     return Location ();
 
-  auto iy = it->second.find (id);
-  if (iy == it->second.end ())
-    return Location ();
-
-  return iy->second;
+  return it->second;
 }
 
 bool
-Mappings::resolve_nodeid_to_stmt (CrateNum crate, NodeId id, HIR::Stmt **stmt)
+Mappings::resolve_nodeid_to_stmt (NodeId id, HIR::Stmt **stmt)
 {
-  auto it = nodeIdToHirMappings.find (crate);
+  auto it = nodeIdToHirMappings.find (id);
   if (it == nodeIdToHirMappings.end ())
     return false;
 
-  auto iy = it->second.find (id);
-  if (iy == it->second.end ())
-    return false;
-
-  HirId resolved = iy->second;
-  auto resolved_stmt = lookup_hir_stmt (crate, resolved);
+  HirId resolved = it->second;
+  auto resolved_stmt = lookup_hir_stmt (resolved);
   *stmt = resolved_stmt;
   return resolved_stmt != nullptr;
 }
@@ -776,15 +675,12 @@ Mappings::iterate_impl_items (
   for (auto it = hirImplItemMappings.begin (); it != hirImplItemMappings.end ();
        it++)
     {
-      for (auto iy = it->second.begin (); iy != it->second.end (); iy++)
-	{
-	  auto id = iy->first;
-	  auto impl_item = iy->second.second;
-	  auto impl = lookup_associated_impl (
-	    impl_item->get_impl_mappings ().get_hirid ());
-	  if (!cb (id, impl_item, impl))
-	    return;
-	}
+      auto id = it->first;
+      auto impl_item = it->second.second;
+      auto impl
+	= lookup_associated_impl (impl_item->get_impl_mappings ().get_hirid ());
+      if (!cb (id, impl_item, impl))
+	return;
     }
 }
 
@@ -794,13 +690,10 @@ Mappings::iterate_impl_blocks (std::function<bool (HirId, HIR::ImplBlock *)> cb)
   for (auto it = hirImplBlockMappings.begin ();
        it != hirImplBlockMappings.end (); it++)
     {
-      for (auto iy = it->second.begin (); iy != it->second.end (); iy++)
-	{
-	  HirId id = iy->first;
-	  HIR::ImplBlock *impl_block = iy->second;
-	  if (!cb (id, impl_block))
-	    return;
-	}
+      HirId id = it->first;
+      HIR::ImplBlock *impl_block = it->second;
+      if (!cb (id, impl_block))
+	return;
     }
 }
 
@@ -811,15 +704,12 @@ Mappings::iterate_trait_items (
   for (auto it = hirTraitItemMappings.begin ();
        it != hirTraitItemMappings.end (); it++)
     {
-      for (auto iy = it->second.begin (); iy != it->second.end (); iy++)
-	{
-	  HirId trait_item_id = iy->first;
-	  HIR::TraitItem *trait_item = iy->second;
-	  HIR::Trait *trait = lookup_trait_item_mapping (trait_item_id);
-
-	  if (!cb (trait_item, trait))
-	    return;
-	}
+      HirId trait_item_id = it->first;
+      HIR::TraitItem *trait_item = it->second;
+      HIR::Trait *trait = lookup_trait_item_mapping (trait_item_id);
+
+      if (!cb (trait_item, trait))
+	return;
     }
 }
 
@@ -966,5 +856,25 @@ Mappings::node_is_module (NodeId query)
   return module_child_items.find (query) != module_child_items.end ();
 }
 
+void
+Mappings::insert_ast_item (AST::Item *item)
+{
+  auto it = ast_item_mappings.find (item->get_node_id ());
+  rust_assert (it == ast_item_mappings.end ());
+
+  ast_item_mappings[item->get_node_id ()] = item;
+}
+
+bool
+Mappings::lookup_ast_item (NodeId id, AST::Item **result)
+{
+  auto it = ast_item_mappings.find (id);
+  if (it == ast_item_mappings.end ())
+    return false;
+
+  *result = it->second;
+  return true;
+}
+
 } // namespace Analysis
 } // namespace Rust
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