gccrs: lang-items: Make lang items enum stronger, rename class, cleanup ns.

gcc/rust/ChangeLog:

	* util/rust-lang-item.h (class RustLangItem): Renamed to...
	(class LangItem): ...this. Rename ItemType enum to Kind
	* util/rust-lang-item.cc: Rename methods to use new class name.
	* backend/rust-compile-expr.cc (CompileExpr::visit): Use new lang-item API.
	(CompileExpr::resolve_operator_overload): Likewise.
	* backend/rust-compile-expr.h: Likewise.
	* hir/rust-ast-lower-base.cc (ASTLoweringBase::handle_lang_item_attribute): Likewise.
	* typecheck/rust-autoderef.cc (Adjuster::try_deref_type): Likewise.
	(AutoderefCycle::cycle): Likewise.
	* typecheck/rust-autoderef.h: Likewise.
	* typecheck/rust-hir-type-bounds.h: Likewise.
	* typecheck/rust-hir-type-check-base.cc (TypeCheckBase::get_marker_predicate): Likewise.
	* typecheck/rust-hir-type-check-base.h: Likewise.
	* typecheck/rust-hir-type-check-expr.cc (TypeCheckExpr::visit): Likewise.
	* typecheck/rust-hir-type-check-expr.h: Likewise.
	* typecheck/rust-hir-type-check-type.cc (TypeResolveGenericParam::visit): Likewise.
	* typecheck/rust-tyty-bounds.cc (TypeBoundsProbe::assemble_sized_builtin): Likewise.
	(TypeBoundsProbe::assemble_builtin_candidate): Likewise.
	(TypeCheckBase::get_predicate_from_bound): Likewise.
	* typecheck/rust-tyty.cc (ClosureType::setup_fn_once_output): Likewise.
	* util/rust-hir-map.cc (Mappings::get_lang_item): Likewise.
	(Mappings::lookup_trait_item_lang_item): Likewise.
	* util/rust-hir-map.h: Likewise.

4 files changed, 137 insertions, 132 deletions

diff --git a/gcc/rust/util/rust-hir-map.cc b/gcc/rust/util/rust-hir-map.cc
index 91fa256..1f7cb4d 100644
--- a/gcc/rust/util/rust-hir-map.cc
+++ b/gcc/rust/util/rust-hir-map.cc
@@ -1252,20 +1252,19 @@ Mappings::lookup_builtin_marker ()
 }
 
 DefId
-Mappings::get_lang_item (RustLangItem::ItemType item_type, location_t locus)
+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",
-		      RustLangItem::ToString (item_type).c_str ());
+		      LangItem::ToString (item_type).c_str ());
 
   return item;
 }
 
 HIR::TraitItem *
-Mappings::lookup_trait_item_lang_item (Analysis::RustLangItem::ItemType item,
-				       location_t locus)
+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);
diff --git a/gcc/rust/util/rust-hir-map.h b/gcc/rust/util/rust-hir-map.h
index a663bfe..927c012 100644
--- a/gcc/rust/util/rust-hir-map.h
+++ b/gcc/rust/util/rust-hir-map.h
@@ -255,7 +255,7 @@ public:
     return true;
   }
 
-  void insert_lang_item (RustLangItem::ItemType item_type, DefId id)
+  void insert_lang_item (LangItem::Kind item_type, DefId id)
   {
     auto it = lang_item_mappings.find (item_type);
     rust_assert (it == lang_item_mappings.end ());
@@ -263,7 +263,7 @@ public:
     lang_item_mappings[item_type] = id;
   }
 
-  bool lookup_lang_item (RustLangItem::ItemType item_type, DefId *id)
+  bool lookup_lang_item (LangItem::Kind item_type, DefId *id)
   {
     auto it = lang_item_mappings.find (item_type);
     if (it == lang_item_mappings.end ())
@@ -274,7 +274,7 @@ public:
   }
 
   // This will fatal_error when this lang item does not exist
-  DefId get_lang_item (RustLangItem::ItemType item_type, location_t locus);
+  DefId get_lang_item (LangItem::Kind item_type, location_t locus);
 
   void insert_macro_def (AST::MacroRulesDefinition *macro);
 
@@ -347,9 +347,8 @@ public:
 
   HIR::ImplBlock *lookup_builtin_marker ();
 
-  HIR::TraitItem *
-  lookup_trait_item_lang_item (Analysis::RustLangItem::ItemType item,
-			       location_t locus);
+  HIR::TraitItem *lookup_trait_item_lang_item (LangItem::Kind item,
+					       location_t locus);
 
 private:
   Mappings ();
@@ -388,7 +387,7 @@ private:
   std::map<HirId, HIR::GenericParam *> hirGenericParamMappings;
   std::map<HirId, HIR::Trait *> hirTraitItemsToTraitMappings;
   std::map<HirId, HIR::Pattern *> hirPatternMappings;
-  std::map<RustLangItem::ItemType, DefId> lang_item_mappings;
+  std::map<LangItem::Kind, DefId> lang_item_mappings;
   std::map<NodeId, const Resolver::CanonicalPath> paths;
   std::map<NodeId, location_t> locations;
   std::map<NodeId, HirId> nodeIdToHirMappings;
diff --git a/gcc/rust/util/rust-lang-item.cc b/gcc/rust/util/rust-lang-item.cc
index 9fe212d..38df90f 100644
--- a/gcc/rust/util/rust-lang-item.cc
+++ b/gcc/rust/util/rust-lang-item.cc
@@ -20,172 +20,168 @@
 #include "rust-system.h"
 
 namespace Rust {
-namespace Analysis {
-
-const BiMap<std::string, RustLangItem::ItemType>
-  Rust::Analysis::RustLangItem::lang_items = {{
-    {"add", ADD},
-    {"sub", SUBTRACT},
-    {"mul", MULTIPLY},
-    {"div", DIVIDE},
-    {"rem", REMAINDER},
-    {"bitand", BITAND},
-    {"bitor", BITOR},
-    {"bitxor", BITXOR},
-    {"shl", SHL},
-    {"shr", SHR},
-    {"neg", NEGATION},
-    {"not", NOT},
-    {"add_assign", ADD_ASSIGN},
-    {"sub_assign", SUB_ASSIGN},
-    {"mul_assign", MUL_ASSIGN},
-    {"div_assign", DIV_ASSIGN},
-    {"rem_assign", REM_ASSIGN},
-    {"bitand_assign", BITAND_ASSIGN},
-    {"bitor_assign", BITOR_ASSIGN},
-    {"bitxor_assign", BITXOR_ASSIGN},
-    {"shl_assign", SHL_ASSIGN},
-    {"shr_assign", SHR_ASSIGN},
-    {"deref", DEREF},
-    {"deref_mut", DEREF_MUT},
-    {"index", INDEX},
-    {"index_mut", INDEX_MUT},
-    {"RangeFull", RANGE_FULL},
-    {"Range", RANGE},
-    {"RangeFrom", RANGE_FROM},
-    {"RangeTo", RANGE_TO},
-    {"RangeInclusive", RANGE_INCLUSIVE},
-    {"RangeToInclusive", RANGE_TO_INCLUSIVE},
-    {"phantom_data", PHANTOM_DATA},
-    {"fn", FN},
-    {"fn_mut", FN_MUT},
-    {"fn_once", FN_ONCE},
-    {"fn_once_output", FN_ONCE_OUTPUT},
-    {"copy", COPY},
-    {"clone", CLONE},
-    {"sized", SIZED},
-    {"slice_alloc", SLICE_ALLOC},
-    {"slice_u8_alloc", SLICE_U8_ALLOC},
-    {"str_alloc", STR_ALLOC},
-    {"array", ARRAY},
-    {"bool", BOOL},
-    {"char", CHAR},
-    {"f32", F32},
-    {"f64", F64},
-    {"i8", I8},
-    {"i16", I16},
-    {"i32", I32},
-    {"i64", I64},
-    {"i128", I128},
-    {"isize", ISIZE},
-    {"u8", U8},
-    {"u16", U16},
-    {"u32", U32},
-    {"u64", U64},
-    {"u128", U128},
-    {"usize", USIZE},
-    {"const_ptr", CONST_PTR},
-    {"const_slice_ptr", CONST_SLICE_PTR},
-    {"mut_ptr", MUT_PTR},
-    {"mut_slice_ptr", MUT_SLICE_PTR},
-    {"slice_u8", SLICE_U8},
-    {"slice", SLICE},
-    {"str", STR},
-    {"f32_runtime", F32_RUNTIME},
-    {"f64_runtime", F64_RUNTIME},
-  }};
-
-tl::optional<RustLangItem::ItemType>
-RustLangItem::Parse (const std::string &item)
+
+const BiMap<std::string, LangItem::Kind> Rust::LangItem::lang_items = {{
+  {"add", Kind::ADD},
+  {"sub", Kind::SUBTRACT},
+  {"mul", Kind::MULTIPLY},
+  {"div", Kind::DIVIDE},
+  {"rem", Kind::REMAINDER},
+  {"bitand", Kind::BITAND},
+  {"bitor", Kind::BITOR},
+  {"bitxor", Kind::BITXOR},
+  {"shl", Kind::SHL},
+  {"shr", Kind::SHR},
+  {"neg", Kind::NEGATION},
+  {"not", Kind::NOT},
+  {"add_assign", Kind::ADD_ASSIGN},
+  {"sub_assign", Kind::SUB_ASSIGN},
+  {"mul_assign", Kind::MUL_ASSIGN},
+  {"div_assign", Kind::DIV_ASSIGN},
+  {"rem_assign", Kind::REM_ASSIGN},
+  {"bitand_assign", Kind::BITAND_ASSIGN},
+  {"bitor_assign", Kind::BITOR_ASSIGN},
+  {"bitxor_assign", Kind::BITXOR_ASSIGN},
+  {"shl_assign", Kind::SHL_ASSIGN},
+  {"shr_assign", Kind::SHR_ASSIGN},
+  {"deref", Kind::DEREF},
+  {"deref_mut", Kind::DEREF_MUT},
+  {"index", Kind::INDEX},
+  {"index_mut", Kind::INDEX_MUT},
+  {"RangeFull", Kind::RANGE_FULL},
+  {"Range", Kind::RANGE},
+  {"RangeFrom", Kind::RANGE_FROM},
+  {"RangeTo", Kind::RANGE_TO},
+  {"RangeInclusive", Kind::RANGE_INCLUSIVE},
+  {"RangeToInclusive", Kind::RANGE_TO_INCLUSIVE},
+  {"phantom_data", Kind::PHANTOM_DATA},
+  {"fn", Kind::FN},
+  {"fn_mut", Kind::FN_MUT},
+  {"fn_once", Kind::FN_ONCE},
+  {"fn_once_output", Kind::FN_ONCE_OUTPUT},
+  {"copy", Kind::COPY},
+  {"clone", Kind::CLONE},
+  {"sized", Kind::SIZED},
+  {"slice_alloc", Kind::SLICE_ALLOC},
+  {"slice_u8_alloc", Kind::SLICE_U8_ALLOC},
+  {"str_alloc", Kind::STR_ALLOC},
+  {"array", Kind::ARRAY},
+  {"bool", Kind::BOOL},
+  {"char", Kind::CHAR},
+  {"f32", Kind::F32},
+  {"f64", Kind::F64},
+  {"i8", Kind::I8},
+  {"i16", Kind::I16},
+  {"i32", Kind::I32},
+  {"i64", Kind::I64},
+  {"i128", Kind::I128},
+  {"isize", Kind::ISIZE},
+  {"u8", Kind::U8},
+  {"u16", Kind::U16},
+  {"u32", Kind::U32},
+  {"u64", Kind::U64},
+  {"u128", Kind::U128},
+  {"usize", Kind::USIZE},
+  {"const_ptr", Kind::CONST_PTR},
+  {"const_slice_ptr", Kind::CONST_SLICE_PTR},
+  {"mut_ptr", Kind::MUT_PTR},
+  {"mut_slice_ptr", Kind::MUT_SLICE_PTR},
+  {"slice_u8", Kind::SLICE_U8},
+  {"slice", Kind::SLICE},
+  {"str", Kind::STR},
+  {"f32_runtime", Kind::F32_RUNTIME},
+  {"f64_runtime", Kind::F64_RUNTIME},
+}};
+
+tl::optional<LangItem::Kind>
+LangItem::Parse (const std::string &item)
 {
-  auto lang_item = RustLangItem::lang_items.lookup (item);
-  if (!RustLangItem::lang_items.is_iter_ok (lang_item))
+  auto lang_item = LangItem::lang_items.lookup (item);
+  if (!LangItem::lang_items.is_iter_ok (lang_item))
     return tl::nullopt;
 
   return lang_item->second;
 }
 
 std::string
-RustLangItem::ToString (RustLangItem::ItemType type)
+LangItem::ToString (LangItem::Kind type)
 {
-  auto str = RustLangItem::lang_items.lookup (type);
+  auto str = LangItem::lang_items.lookup (type);
   return str->second;
 }
 
-RustLangItem::ItemType
-RustLangItem::OperatorToLangItem (ArithmeticOrLogicalOperator op)
+LangItem::Kind
+LangItem::OperatorToLangItem (ArithmeticOrLogicalOperator op)
 {
   switch (op)
     {
     case ArithmeticOrLogicalOperator::ADD:
-      return RustLangItem::ItemType::ADD;
+      return LangItem::Kind::ADD;
     case ArithmeticOrLogicalOperator::SUBTRACT:
-      return RustLangItem::ItemType::SUBTRACT;
+      return LangItem::Kind::SUBTRACT;
     case ArithmeticOrLogicalOperator::MULTIPLY:
-      return RustLangItem::ItemType::MULTIPLY;
+      return LangItem::Kind::MULTIPLY;
     case ArithmeticOrLogicalOperator::DIVIDE:
-      return RustLangItem::ItemType::DIVIDE;
+      return LangItem::Kind::DIVIDE;
     case ArithmeticOrLogicalOperator::MODULUS:
-      return RustLangItem::ItemType::REMAINDER;
+      return LangItem::Kind::REMAINDER;
     case ArithmeticOrLogicalOperator::BITWISE_AND:
-      return RustLangItem::ItemType::BITAND;
+      return LangItem::Kind::BITAND;
     case ArithmeticOrLogicalOperator::BITWISE_OR:
-      return RustLangItem::ItemType::BITOR;
+      return LangItem::Kind::BITOR;
     case ArithmeticOrLogicalOperator::BITWISE_XOR:
-      return RustLangItem::ItemType::BITXOR;
+      return LangItem::Kind::BITXOR;
     case ArithmeticOrLogicalOperator::LEFT_SHIFT:
-      return RustLangItem::ItemType::SHL;
+      return LangItem::Kind::SHL;
     case ArithmeticOrLogicalOperator::RIGHT_SHIFT:
-      return RustLangItem::ItemType::SHR;
+      return LangItem::Kind::SHR;
     }
 
   rust_unreachable ();
 }
 
-RustLangItem::ItemType
-RustLangItem::CompoundAssignmentOperatorToLangItem (
-  ArithmeticOrLogicalOperator op)
+LangItem::Kind
+LangItem::CompoundAssignmentOperatorToLangItem (ArithmeticOrLogicalOperator op)
 {
   switch (op)
     {
     case ArithmeticOrLogicalOperator::ADD:
-      return RustLangItem::ItemType::ADD_ASSIGN;
+      return LangItem::Kind::ADD_ASSIGN;
     case ArithmeticOrLogicalOperator::SUBTRACT:
-      return RustLangItem::ItemType::SUB_ASSIGN;
+      return LangItem::Kind::SUB_ASSIGN;
     case ArithmeticOrLogicalOperator::MULTIPLY:
-      return RustLangItem::ItemType::MUL_ASSIGN;
+      return LangItem::Kind::MUL_ASSIGN;
     case ArithmeticOrLogicalOperator::DIVIDE:
-      return RustLangItem::ItemType::DIV_ASSIGN;
+      return LangItem::Kind::DIV_ASSIGN;
     case ArithmeticOrLogicalOperator::MODULUS:
-      return RustLangItem::ItemType::REM_ASSIGN;
+      return LangItem::Kind::REM_ASSIGN;
     case ArithmeticOrLogicalOperator::BITWISE_AND:
-      return RustLangItem::ItemType::BITAND_ASSIGN;
+      return LangItem::Kind::BITAND_ASSIGN;
     case ArithmeticOrLogicalOperator::BITWISE_OR:
-      return RustLangItem::ItemType::BITOR_ASSIGN;
+      return LangItem::Kind::BITOR_ASSIGN;
     case ArithmeticOrLogicalOperator::BITWISE_XOR:
-      return RustLangItem::ItemType::BITXOR_ASSIGN;
+      return LangItem::Kind::BITXOR_ASSIGN;
     case ArithmeticOrLogicalOperator::LEFT_SHIFT:
-      return RustLangItem::ItemType::SHL_ASSIGN;
+      return LangItem::Kind::SHL_ASSIGN;
     case ArithmeticOrLogicalOperator::RIGHT_SHIFT:
-      return RustLangItem::ItemType::SHR_ASSIGN;
+      return LangItem::Kind::SHR_ASSIGN;
     }
 
   rust_unreachable ();
 }
 
-RustLangItem::ItemType
-RustLangItem::NegationOperatorToLangItem (NegationOperator op)
+LangItem::Kind
+LangItem::NegationOperatorToLangItem (NegationOperator op)
 {
   switch (op)
     {
     case NegationOperator::NEGATE:
-      return RustLangItem::ItemType::NEGATION;
+      return LangItem::Kind::NEGATION;
     case NegationOperator::NOT:
-      return RustLangItem::ItemType::NOT;
+      return LangItem::Kind::NOT;
     }
 
   rust_unreachable ();
 }
 
-} // namespace Analysis
 } // namespace Rust
diff --git a/gcc/rust/util/rust-lang-item.h b/gcc/rust/util/rust-lang-item.h
index 3447e36..414436f 100644
--- a/gcc/rust/util/rust-lang-item.h
+++ b/gcc/rust/util/rust-lang-item.h
@@ -22,13 +22,12 @@
 #include "bi-map.h"
 
 namespace Rust {
-namespace Analysis {
 
 // https://github.com/rust-lang/rust/blob/master/library/core/src/ops/arith.rs
-class RustLangItem
+class LangItem
 {
 public:
-  enum ItemType
+  enum class Kind
   {
     ADD,
     SUBTRACT,
@@ -119,15 +118,27 @@ public:
     F64_RUNTIME,
   };
 
-  static const BiMap<std::string, ItemType> lang_items;
+  static const BiMap<std::string, Kind> lang_items;
 
-  static tl::optional<ItemType> Parse (const std::string &item);
-  static std::string ToString (ItemType type);
-  static ItemType OperatorToLangItem (ArithmeticOrLogicalOperator op);
-  static ItemType
+  static tl::optional<Kind> Parse (const std::string &item);
+  static std::string ToString (Kind type);
+  static Kind OperatorToLangItem (ArithmeticOrLogicalOperator op);
+  static Kind
   CompoundAssignmentOperatorToLangItem (ArithmeticOrLogicalOperator op);
-  static ItemType NegationOperatorToLangItem (NegationOperator op);
+  static Kind NegationOperatorToLangItem (NegationOperator op);
 };
 
-} // namespace Analysis
 } // namespace Rust
+
+// GCC 4.8 needs us to manually implement hashing for enum classes
+namespace std {
+template <> struct hash<Rust::LangItem::Kind>
+{
+  size_t operator() (const Rust::LangItem::Kind &lang_item) const noexcept
+  {
+    return hash<std::underlying_type<Rust::LangItem::Kind>::type> () (
+      static_cast<std::underlying_type<Rust::LangItem::Kind>::type> (
+	lang_item));
+  }
+};
+} // namespace std