1 files changed, 226 insertions, 159 deletions

diff --git a/gcc/rust/util/rust-hir-map.cc b/gcc/rust/util/rust-hir-map.cc
index 05b26d6..0917828 100644
--- a/gcc/rust/util/rust-hir-map.cc
+++ b/gcc/rust/util/rust-hir-map.cc
@@ -110,14 +110,11 @@ Mappings::Mappings ()
 
 Mappings::~Mappings () { delete builtinMarker; }
 
-Mappings *
+Mappings &
 Mappings::get ()
 {
-  static std::unique_ptr<Mappings> instance;
-  if (!instance)
-    instance = std::unique_ptr<Mappings> (new Mappings ());
-
-  return instance.get ();
+  static Mappings instance{};
+  return instance;
 }
 
 CrateNum
@@ -141,15 +138,24 @@ Mappings::get_current_crate () const
   return currentCrateNum;
 }
 
-bool
-Mappings::get_crate_name (CrateNum crate_num, std::string &name) const
+tl::optional<const std::string &>
+Mappings::get_crate_name (CrateNum crate_num) const
 {
   auto it = crate_names.find (crate_num);
   if (it == crate_names.end ())
-    return false;
+    return tl::nullopt;
+
+  return it->second;
+}
+
+tl::optional<CrateNum>
+Mappings::lookup_crate_num (NodeId node_id) const
+{
+  auto it = crate_node_to_crate_num.find (node_id);
+  if (it == crate_node_to_crate_num.end ())
+    return tl::nullopt;
 
-  name.assign (it->second);
-  return true;
+  return it->second;
 }
 
 void
@@ -158,51 +164,37 @@ Mappings::set_crate_name (CrateNum crate_num, const std::string &name)
   crate_names[crate_num] = name;
 }
 
-std::string
+const std::string &
 Mappings::get_current_crate_name () const
 {
-  std::string name;
-  bool ok = get_crate_name (get_current_crate (), name);
-  rust_assert (ok);
-  return name;
+  return get_crate_name (get_current_crate ()).value ();
 }
 
-bool
-Mappings::lookup_crate_name (const std::string &crate_name,
-			     CrateNum &resolved_crate_num) const
+tl::optional<CrateNum>
+Mappings::lookup_crate_name (const std::string &crate_name) const
 {
   for (const auto &it : crate_names)
     {
       if (it.second.compare (crate_name) == 0)
-	{
-	  resolved_crate_num = it.first;
-	  return true;
-	}
+	return it.first;
     }
-  return false;
+  return tl::nullopt;
 }
 
-bool
-Mappings::crate_num_to_nodeid (const CrateNum &crate_num, NodeId &node_id) const
+tl::optional<NodeId>
+Mappings::crate_num_to_nodeid (const CrateNum &crate_num) const
 {
   auto it = ast_crate_mappings.find (crate_num);
   if (it == ast_crate_mappings.end ())
-    return false;
+    return tl::nullopt;
 
-  node_id = it->second->get_node_id ();
-  return true;
+  return it->second->get_node_id ();
 }
 
 bool
 Mappings::node_is_crate (NodeId node_id) const
 {
-  for (const auto &it : ast_crate_mappings)
-    {
-      NodeId crate_node_id = it.second->get_node_id ();
-      if (crate_node_id == node_id)
-	return true;
-    }
-  return false;
+  return lookup_crate_num (node_id).has_value ();
 }
 
 NodeId
@@ -274,6 +266,7 @@ Mappings::insert_ast_crate (std::unique_ptr<AST::Crate> &&crate,
   rust_assert (it == ast_crate_mappings.end ());
 
   // store it
+  crate_node_to_crate_num.insert ({crate->get_node_id (), crate_num});
   ast_crate_mappings.insert ({crate_num, crate.release ()});
 
   // return the reference to it
@@ -324,20 +317,20 @@ Mappings::insert_defid_mapping (DefId id, HIR::Item *item)
   CrateNum crate_num = id.crateNum;
   LocalDefId local_def_id = id.localDefId;
 
-  rust_assert (lookup_defid (id) == nullptr);
-  rust_assert (lookup_local_defid (crate_num, local_def_id) == nullptr);
-  rust_assert (lookup_trait_item_defid (id) == nullptr);
+  rust_assert (!lookup_defid (id));
+  rust_assert (!lookup_local_defid (crate_num, local_def_id));
+  rust_assert (!lookup_trait_item_defid (id));
 
   defIdMappings[id] = item;
   insert_local_defid_mapping (crate_num, local_def_id, item);
 }
 
-HIR::Item *
+tl::optional<HIR::Item *>
 Mappings::lookup_defid (DefId id)
 {
   auto it = defIdMappings.find (id);
   if (it == defIdMappings.end ())
-    return nullptr;
+    return tl::nullopt;
 
   return it->second;
 }
@@ -348,19 +341,19 @@ Mappings::insert_defid_mapping (DefId id, HIR::TraitItem *item)
   CrateNum crate_num = id.crateNum;
   LocalDefId local_def_id = id.localDefId;
 
-  rust_assert (lookup_defid (id) == nullptr);
-  rust_assert (lookup_local_defid (crate_num, local_def_id) == nullptr);
-  rust_assert (lookup_trait_item_defid (id) == nullptr);
+  rust_assert (!lookup_defid (id));
+  rust_assert (!lookup_local_defid (crate_num, local_def_id));
+  rust_assert (!lookup_trait_item_defid (id));
 
   defIdTraitItemMappings[id] = item;
 }
 
-HIR::TraitItem *
+tl::optional<HIR::TraitItem *>
 Mappings::lookup_trait_item_defid (DefId id)
 {
   auto it = defIdTraitItemMappings.find (id);
   if (it == defIdTraitItemMappings.end ())
-    return nullptr;
+    return tl::nullopt;
 
   return it->second;
 }
@@ -369,19 +362,18 @@ void
 Mappings::insert_hir_item (HIR::Item *item)
 {
   auto id = item->get_mappings ().get_hirid ();
-  rust_assert (lookup_hir_item (id) == nullptr);
+  rust_assert (!lookup_hir_item (id).has_value ());
 
   hirItemMappings[id] = item;
   insert_node_to_hir (item->get_mappings ().get_nodeid (), id);
 }
 
-HIR::Item *
+tl::optional<HIR::Item *>
 Mappings::lookup_hir_item (HirId id)
 {
   auto it = hirItemMappings.find (id);
   if (it == hirItemMappings.end ())
-    return nullptr;
-
+    return tl::nullopt;
   return it->second;
 }
 
@@ -410,18 +402,18 @@ void
 Mappings::insert_hir_trait_item (HIR::TraitItem *item)
 {
   auto id = item->get_mappings ().get_hirid ();
-  rust_assert (lookup_hir_trait_item (id) == nullptr);
+  rust_assert (!lookup_hir_trait_item (id).has_value ());
 
   hirTraitItemMappings[id] = item;
   insert_node_to_hir (item->get_mappings ().get_nodeid (), id);
 }
 
-HIR::TraitItem *
+tl::optional<HIR::TraitItem *>
 Mappings::lookup_hir_trait_item (HirId id)
 {
   auto it = hirTraitItemMappings.find (id);
   if (it == hirTraitItemMappings.end ())
-    return nullptr;
+    return tl::nullopt;
 
   return it->second;
 }
@@ -430,18 +422,18 @@ void
 Mappings::insert_hir_extern_block (HIR::ExternBlock *block)
 {
   auto id = block->get_mappings ().get_hirid ();
-  rust_assert (lookup_hir_extern_block (id) == nullptr);
+  rust_assert (!lookup_hir_extern_block (id).has_value ());
 
   hirExternBlockMappings[id] = block;
   insert_node_to_hir (block->get_mappings ().get_nodeid (), id);
 }
 
-HIR::ExternBlock *
+tl::optional<HIR::ExternBlock *>
 Mappings::lookup_hir_extern_block (HirId id)
 {
   auto it = hirExternBlockMappings.find (id);
   if (it == hirExternBlockMappings.end ())
-    return nullptr;
+    return tl::nullopt;
 
   return it->second;
 }
@@ -450,73 +442,70 @@ void
 Mappings::insert_hir_extern_item (HIR::ExternalItem *item, HirId parent_block)
 {
   auto id = item->get_mappings ().get_hirid ();
-  rust_assert (lookup_hir_extern_item (id, nullptr) == nullptr);
+  rust_assert (!lookup_hir_extern_item (id));
 
   hirExternItemMappings[id] = {item, parent_block};
   insert_node_to_hir (item->get_mappings ().get_nodeid (), id);
 }
 
-HIR::ExternalItem *
-Mappings::lookup_hir_extern_item (HirId id, HirId *parent_block)
+tl::optional<std::pair<HIR::ExternalItem *, HirId>>
+Mappings::lookup_hir_extern_item (HirId id)
 {
   auto it = hirExternItemMappings.find (id);
   if (it == hirExternItemMappings.end ())
-    return nullptr;
-
-  *parent_block = it->second.second;
+    return tl::nullopt;
 
-  return it->second.first;
+  return it->second;
 }
 
 void
 Mappings::insert_hir_impl_block (HIR::ImplBlock *item)
 {
   auto id = item->get_mappings ().get_hirid ();
-  rust_assert (lookup_hir_impl_block (id) == nullptr);
+  rust_assert (!lookup_hir_impl_block (id));
 
-  HirId impl_type_id = item->get_type ()->get_mappings ().get_hirid ();
+  HirId impl_type_id = item->get_type ().get_mappings ().get_hirid ();
   hirImplBlockMappings[id] = item;
   hirImplBlockTypeMappings[impl_type_id] = item;
   insert_node_to_hir (item->get_mappings ().get_nodeid (), id);
 }
 
-HIR::ImplBlock *
+tl::optional<HIR::ImplBlock *>
 Mappings::lookup_hir_impl_block (HirId id)
 {
   auto it = hirImplBlockMappings.find (id);
   if (it == hirImplBlockMappings.end ())
-    return nullptr;
+    return tl::nullopt;
 
   return it->second;
 }
 
-bool
-Mappings::lookup_impl_block_type (HirId id, HIR::ImplBlock **impl_block)
+tl::optional<HIR::ImplBlock *>
+Mappings::lookup_impl_block_type (HirId id)
 {
   auto it = hirImplBlockTypeMappings.find (id);
   if (it == hirImplBlockTypeMappings.end ())
-    return false;
+    return tl::nullopt;
 
-  *impl_block = it->second;
-  return true;
+  return it->second;
 }
 
 void
 Mappings::insert_module (HIR::Module *module)
 {
   auto id = module->get_mappings ().get_hirid ();
-  rust_assert (lookup_module (id) == nullptr);
+  rust_assert (!lookup_module (id));
 
   hirModuleMappings[id] = module;
   insert_node_to_hir (module->get_mappings ().get_nodeid (), id);
 }
 
-HIR::Module *
+tl::optional<HIR::Module *>
 Mappings::lookup_module (HirId id)
 {
   auto it = hirModuleMappings.find (id);
   if (it == hirModuleMappings.end ())
-    return nullptr;
+    return tl::nullopt;
 
   return it->second;
 }
@@ -525,25 +514,21 @@ void
 Mappings::insert_hir_implitem (HirId parent_impl_id, HIR::ImplItem *item)
 {
   auto id = item->get_impl_mappings ().get_hirid ();
-  rust_assert (lookup_hir_implitem (id, nullptr) == nullptr);
+  rust_assert (!lookup_hir_implitem (id));
 
   hirImplItemMappings[id]
     = std::pair<HirId, HIR::ImplItem *> (parent_impl_id, item);
   insert_node_to_hir (item->get_impl_mappings ().get_nodeid (), id);
 }
 
-HIR::ImplItem *
-Mappings::lookup_hir_implitem (HirId id, HirId *parent_impl_id)
+tl::optional<std::pair<HIR::ImplItem *, HirId>>
+Mappings::lookup_hir_implitem (HirId id)
 {
   auto it = hirImplItemMappings.find (id);
   if (it == hirImplItemMappings.end ())
-    return nullptr;
-
-  std::pair<HirId, HIR::ImplItem *> &ref = it->second;
-  if (parent_impl_id != nullptr)
-    *parent_impl_id = ref.first;
+    return tl::nullopt;
 
-  return ref.second;
+  return std::make_pair (it->second.second, it->second.first);
 }
 
 void
@@ -556,12 +541,12 @@ Mappings::insert_hir_expr (HIR::Expr *expr)
   insert_location (id, expr->get_locus ());
 }
 
-HIR::Expr *
+tl::optional<HIR::Expr *>
 Mappings::lookup_hir_expr (HirId id)
 {
   auto it = hirExprMappings.find (id);
   if (it == hirExprMappings.end ())
-    return nullptr;
+    return tl::nullopt;
 
   return it->second;
 }
@@ -570,19 +555,19 @@ void
 Mappings::insert_hir_path_expr_seg (HIR::PathExprSegment *expr)
 {
   auto id = expr->get_mappings ().get_hirid ();
-  rust_assert (lookup_hir_path_expr_seg (id) == nullptr);
+  rust_assert (!lookup_hir_path_expr_seg (id));
 
   hirPathSegMappings[id] = expr;
   insert_node_to_hir (expr->get_mappings ().get_nodeid (), id);
   insert_location (id, expr->get_locus ());
 }
 
-HIR::PathExprSegment *
+tl::optional<HIR::PathExprSegment *>
 Mappings::lookup_hir_path_expr_seg (HirId id)
 {
   auto it = hirPathSegMappings.find (id);
   if (it == hirPathSegMappings.end ())
-    return nullptr;
+    return tl::nullopt;
 
   return it->second;
 }
@@ -591,19 +576,19 @@ void
 Mappings::insert_hir_generic_param (HIR::GenericParam *param)
 {
   auto id = param->get_mappings ().get_hirid ();
-  rust_assert (lookup_hir_generic_param (id) == nullptr);
+  rust_assert (!lookup_hir_generic_param (id));
 
   hirGenericParamMappings[id] = param;
   insert_node_to_hir (param->get_mappings ().get_nodeid (), id);
   insert_location (id, param->get_locus ());
 }
 
-HIR::GenericParam *
+tl::optional<HIR::GenericParam *>
 Mappings::lookup_hir_generic_param (HirId id)
 {
   auto it = hirGenericParamMappings.find (id);
   if (it == hirGenericParamMappings.end ())
-    return nullptr;
+    return tl::nullopt;
 
   return it->second;
 }
@@ -612,18 +597,18 @@ void
 Mappings::insert_hir_type (HIR::Type *type)
 {
   auto id = type->get_mappings ().get_hirid ();
-  rust_assert (lookup_hir_type (id) == nullptr);
+  rust_assert (!lookup_hir_type (id));
 
   hirTypeMappings[id] = type;
   insert_node_to_hir (type->get_mappings ().get_nodeid (), id);
 }
 
-HIR::Type *
+tl::optional<HIR::Type *>
 Mappings::lookup_hir_type (HirId id)
 {
   auto it = hirTypeMappings.find (id);
   if (it == hirTypeMappings.end ())
-    return nullptr;
+    return tl::nullopt;
 
   return it->second;
 }
@@ -632,18 +617,18 @@ void
 Mappings::insert_hir_stmt (HIR::Stmt *stmt)
 {
   auto id = stmt->get_mappings ().get_hirid ();
-  rust_assert (lookup_hir_stmt (id) == nullptr);
+  rust_assert (!lookup_hir_stmt (id));
 
   hirStmtMappings[id] = stmt;
   insert_node_to_hir (stmt->get_mappings ().get_nodeid (), id);
 }
 
-HIR::Stmt *
+tl::optional<HIR::Stmt *>
 Mappings::lookup_hir_stmt (HirId id)
 {
   auto it = hirStmtMappings.find (id);
   if (it == hirStmtMappings.end ())
-    return nullptr;
+    return tl::nullopt;
 
   return it->second;
 }
@@ -652,18 +637,18 @@ void
 Mappings::insert_hir_param (HIR::FunctionParam *param)
 {
   auto id = param->get_mappings ().get_hirid ();
-  rust_assert (lookup_hir_param (id) == nullptr);
+  rust_assert (!lookup_hir_param (id));
 
   hirParamMappings[id] = param;
   insert_node_to_hir (param->get_mappings ().get_nodeid (), id);
 }
 
-HIR::FunctionParam *
+tl::optional<HIR::FunctionParam *>
 Mappings::lookup_hir_param (HirId id)
 {
   auto it = hirParamMappings.find (id);
   if (it == hirParamMappings.end ())
-    return nullptr;
+    return tl::nullopt;
 
   return it->second;
 }
@@ -672,18 +657,18 @@ void
 Mappings::insert_hir_self_param (HIR::SelfParam *param)
 {
   auto id = param->get_mappings ().get_hirid ();
-  rust_assert (lookup_hir_self_param (id) == nullptr);
+  rust_assert (!lookup_hir_self_param (id));
 
   hirSelfParamMappings[id] = param;
   insert_node_to_hir (param->get_mappings ().get_nodeid (), id);
 }
 
-HIR::SelfParam *
+tl::optional<HIR::SelfParam *>
 Mappings::lookup_hir_self_param (HirId id)
 {
   auto it = hirSelfParamMappings.find (id);
   if (it == hirSelfParamMappings.end ())
-    return nullptr;
+    return tl::nullopt;
 
   return it->second;
 }
@@ -692,18 +677,18 @@ void
 Mappings::insert_hir_struct_field (HIR::StructExprField *field)
 {
   auto id = field->get_mappings ().get_hirid ();
-  rust_assert (lookup_hir_struct_field (id) == nullptr);
+  rust_assert (!lookup_hir_struct_field (id));
 
   hirStructFieldMappings[id] = field;
   insert_node_to_hir (field->get_mappings ().get_nodeid (), id);
 }
 
-HIR::StructExprField *
+tl::optional<HIR::StructExprField *>
 Mappings::lookup_hir_struct_field (HirId id)
 {
   auto it = hirStructFieldMappings.find (id);
   if (it == hirStructFieldMappings.end ())
-    return nullptr;
+    return tl::nullopt;
 
   return it->second;
 }
@@ -712,18 +697,18 @@ void
 Mappings::insert_hir_pattern (HIR::Pattern *pattern)
 {
   auto id = pattern->get_mappings ().get_hirid ();
-  rust_assert (lookup_hir_pattern (id) == nullptr);
+  rust_assert (!lookup_hir_pattern (id));
 
   hirPatternMappings[id] = pattern;
   insert_node_to_hir (pattern->get_mappings ().get_nodeid (), id);
 }
 
-HIR::Pattern *
+tl::optional<HIR::Pattern *>
 Mappings::lookup_hir_pattern (HirId id)
 {
   auto it = hirPatternMappings.find (id);
   if (it == hirPatternMappings.end ())
-    return nullptr;
+    return tl::nullopt;
 
   return it->second;
 }
@@ -732,20 +717,20 @@ void
 Mappings::insert_local_defid_mapping (CrateNum crateNum, LocalDefId id,
 				      HIR::Item *item)
 {
-  rust_assert (lookup_local_defid (crateNum, id) == nullptr);
+  rust_assert (!lookup_local_defid (crateNum, id));
   localDefIdMappings[crateNum][id] = item;
 }
 
-HIR::Item *
+tl::optional<HIR::Item *>
 Mappings::lookup_local_defid (CrateNum crateNum, LocalDefId id)
 {
   auto it = localDefIdMappings.find (crateNum);
   if (it == localDefIdMappings.end ())
-    return nullptr;
+    return tl::nullopt;
 
   auto iy = it->second.find (id);
   if (iy == it->second.end ())
-    return nullptr;
+    return tl::nullopt;
 
   return iy->second;
 }
@@ -772,26 +757,24 @@ Mappings::insert_node_to_hir (NodeId id, HirId ref)
   hirIdToNodeMappings[ref] = id;
 }
 
-bool
-Mappings::lookup_node_to_hir (NodeId id, HirId *ref)
+tl::optional<HirId>
+Mappings::lookup_node_to_hir (NodeId id)
 {
   auto it = nodeIdToHirMappings.find (id);
   if (it == nodeIdToHirMappings.end ())
-    return false;
+    return tl::nullopt;
 
-  *ref = it->second;
-  return true;
+  return {it->second};
 }
 
-bool
-Mappings::lookup_hir_to_node (HirId id, NodeId *ref)
+tl::optional<NodeId>
+Mappings::lookup_hir_to_node (HirId id)
 {
   auto it = hirIdToNodeMappings.find (id);
   if (it == hirIdToNodeMappings.end ())
-    return false;
+    return tl::nullopt;
 
-  *ref = it->second;
-  return true;
+  return {it->second};
 }
 
 void
@@ -810,17 +793,15 @@ Mappings::lookup_location (HirId id)
   return it->second;
 }
 
-bool
-Mappings::resolve_nodeid_to_stmt (NodeId id, HIR::Stmt **stmt)
+tl::optional<HIR::Stmt *>
+Mappings::resolve_nodeid_to_stmt (NodeId id)
 {
   auto it = nodeIdToHirMappings.find (id);
   if (it == nodeIdToHirMappings.end ())
-    return false;
+    return tl::nullopt;
 
   HirId resolved = it->second;
-  auto resolved_stmt = lookup_hir_stmt (resolved);
-  *stmt = resolved_stmt;
-  return resolved_stmt != nullptr;
+  return lookup_hir_stmt (resolved);
 }
 
 void
@@ -898,18 +879,27 @@ Mappings::insert_macro_def (AST::MacroRulesDefinition *macro)
   auto it = macroMappings.find (macro->get_node_id ());
   rust_assert (it == macroMappings.end ());
 
-  macroMappings[macro->get_node_id ()] = macro;
+  macroMappings[macro->get_node_id ()] = {macro, currentCrateNum};
 }
 
-bool
-Mappings::lookup_macro_def (NodeId id, AST::MacroRulesDefinition **def)
+tl::optional<AST::MacroRulesDefinition *>
+Mappings::lookup_macro_def (NodeId id)
 {
   auto it = macroMappings.find (id);
   if (it == macroMappings.end ())
-    return false;
+    return tl::nullopt;
+
+  return it->second.first;
+}
+
+tl::optional<CrateNum>
+Mappings::lookup_macro_def_crate (NodeId id)
+{
+  auto it = macroMappings.find (id);
+  if (it == macroMappings.end ())
+    return tl::nullopt;
 
-  *def = it->second;
-  return true;
+  return it->second.second;
 }
 
 void
@@ -922,16 +912,14 @@ Mappings::insert_macro_invocation (AST::MacroInvocation &invoc,
   macroInvocations[invoc.get_macro_node_id ()] = def;
 }
 
-bool
-Mappings::lookup_macro_invocation (AST::MacroInvocation &invoc,
-				   AST::MacroRulesDefinition **def)
+tl::optional<AST::MacroRulesDefinition *>
+Mappings::lookup_macro_invocation (AST::MacroInvocation &invoc)
 {
   auto it = macroInvocations.find (invoc.get_macro_node_id ());
   if (it == macroInvocations.end ())
-    return false;
+    return tl::nullopt;
 
-  *def = it->second;
-  return true;
+  return it->second;
 }
 
 void
@@ -1129,15 +1117,14 @@ Mappings::insert_visibility (NodeId id, Privacy::ModuleVisibility visibility)
   visibility_map.insert ({id, visibility});
 }
 
-bool
-Mappings::lookup_visibility (NodeId id, Privacy::ModuleVisibility &def)
+tl::optional<Privacy::ModuleVisibility &>
+Mappings::lookup_visibility (NodeId id)
 {
   auto it = visibility_map.find (id);
   if (it == visibility_map.end ())
-    return false;
+    return tl::nullopt;
 
-  def = it->second;
-  return true;
+  return it->second;
 }
 
 void
@@ -1253,15 +1240,14 @@ Mappings::insert_ast_item (AST::Item *item)
   ast_item_mappings[item->get_node_id ()] = item;
 }
 
-bool
-Mappings::lookup_ast_item (NodeId id, AST::Item **result)
+tl::optional<AST::Item *>
+Mappings::lookup_ast_item (NodeId id)
 {
   auto it = ast_item_mappings.find (id);
   if (it == ast_item_mappings.end ())
-    return false;
+    return tl::nullopt;
 
-  *result = it->second;
-  return true;
+  return it->second;
 }
 
 HIR::ImplBlock *
@@ -1270,24 +1256,105 @@ Mappings::lookup_builtin_marker ()
   return builtinMarker;
 }
 
+// FIXME: Before merging: Should we remove the `locus` parameter here? since
+// lang items are looked up mostly for code generation, it doesn't make sense to
+// error out on the locus of the node trying to access an inexistant lang item
 DefId
 Mappings::get_lang_item (LangItem::Kind item_type, location_t locus)
 {
-  DefId item = UNKNOWN_DEFID;
-  bool ok = lookup_lang_item (item_type, &item);
-  if (!ok)
-    rust_fatal_error (locus, "failed to find lang item %s",
-		      LangItem::ToString (item_type).c_str ());
+  if (auto item = lookup_lang_item (item_type))
+    return *item;
 
-  return item;
+  rust_fatal_error (locus, "failed to find lang item %s",
+		    LangItem::ToString (item_type).c_str ());
 }
 
-HIR::TraitItem *
+tl::optional<HIR::TraitItem *>
 Mappings::lookup_trait_item_lang_item (LangItem::Kind item, location_t locus)
 {
   DefId trait_item_id = get_lang_item (item, locus);
   return lookup_trait_item_defid (trait_item_id);
 }
 
+void
+Mappings::insert_lang_item (LangItem::Kind item_type, DefId id)
+{
+  auto it = lang_item_mappings.find (item_type);
+  rust_assert (it == lang_item_mappings.end ());
+
+  lang_item_mappings[item_type] = id;
+}
+
+tl::optional<DefId &>
+Mappings::lookup_lang_item (LangItem::Kind item_type)
+{
+  auto it = lang_item_mappings.find (item_type);
+  if (it == lang_item_mappings.end ())
+    return tl::nullopt;
+
+  return it->second;
+}
+
+void
+Mappings::insert_lang_item_node (LangItem::Kind item_type, NodeId node_id)
+{
+  auto it = lang_item_nodes.find (item_type);
+  rust_assert (it == lang_item_nodes.end ());
+
+  lang_item_nodes.insert ({item_type, node_id});
+}
+
+tl::optional<NodeId &>
+Mappings::lookup_lang_item_node (LangItem::Kind item_type)
+{
+  auto it = lang_item_nodes.find (item_type);
+  if (it == lang_item_nodes.end ())
+    return tl::nullopt;
+
+  return it->second;
+}
+
+NodeId
+Mappings::get_lang_item_node (LangItem::Kind item_type)
+{
+  if (auto lookup = lookup_lang_item_node (item_type))
+    return *lookup;
+
+  rust_fatal_error (UNKNOWN_LOCATION, "undeclared lang item: %qs",
+		    LangItem::PrettyString (item_type).c_str ());
+}
+
+void
+Mappings::insert_auto_trait (HIR::Trait *trait)
+{
+  auto_traits.emplace_back (trait);
+}
+
+std::vector<HIR::Trait *> &
+Mappings::get_auto_traits ()
+{
+  return auto_traits;
+}
+
+void
+Mappings::add_capture (NodeId closure, NodeId definition)
+{
+  auto cap = captures.find (closure);
+  if (cap == captures.end ())
+    captures[closure] = {definition};
+  else
+    cap->second.push_back (definition);
+}
+
+tl::optional<std::vector<NodeId>>
+Mappings::lookup_captures (NodeId closure)
+{
+  auto cap = captures.find (closure);
+  if (cap == captures.end ())
+    return tl::nullopt;
+  else
+    return cap->second;
+}
+
 } // namespace Analysis
 } // namespace Rust