[022/125] gccrs: lang-items: Cleanup parsing and lookups of lang items.

diff --git a/gcc/rust/Make-lang.in b/gcc/rust/Make-lang.in
index baf55161d78..af5d775a3a6 100644
--- a/gcc/rust/Make-lang.in
+++ b/gcc/rust/Make-lang.in
@@ -203,6 +203,7 @@  GRS_OBJS = \
     rust/rust-dir-owner.o \
     rust/rust-unicode.o \
     rust/rust-punycode.o \
+	rust/rust-lang-item.o \
     $(END)
 # removed object files from here
 
diff --git a/gcc/rust/hir/rust-ast-lower-base.cc b/gcc/rust/hir/rust-ast-lower-base.cc
index 3ff0f52e0c6..815b98f9f0a 100644
--- a/gcc/rust/hir/rust-ast-lower-base.cc
+++ b/gcc/rust/hir/rust-ast-lower-base.cc
@@ -789,13 +789,12 @@  ASTLoweringBase::handle_lang_item_attribute (const ItemWrapper &item,
   auto &literal = static_cast<AST::AttrInputLiteral &> (attr.get_attr_input ());
   const auto &lang_item_type_str = literal.get_literal ().as_string ();
   auto lang_item_type = Analysis::RustLangItem::Parse (lang_item_type_str);
-  if (lang_item_type == Analysis::RustLangItem::ItemType::UNKNOWN)
-    {
-      rust_error_at (attr.get_locus (), "unknown lang item");
-      return;
-    }
-  mappings->insert_lang_item (lang_item_type,
-			      item.get_mappings ().get_defid ());
+
+  if (lang_item_type)
+    mappings->insert_lang_item (*lang_item_type,
+				item.get_mappings ().get_defid ());
+  else
+    rust_error_at (attr.get_locus (), "unknown lang item");
 }
 
 bool
diff --git a/gcc/rust/util/rust-lang-item.cc b/gcc/rust/util/rust-lang-item.cc
new file mode 100644
index 00000000000..9fe212d412d
--- /dev/null
+++ b/gcc/rust/util/rust-lang-item.cc
@@ -0,0 +1,191 @@ 
+// Copyright (C) 2020-2024 Free Software Foundation, Inc.
+
+// This file is part of GCC.
+
+// GCC is free software; you can redistribute it and/or modify it under
+// the terms of the GNU General Public License as published by the Free
+// Software Foundation; either version 3, or (at your option) any later
+// version.
+
+// GCC is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or
+// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+// for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with GCC; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+#include "rust-lang-item.h"
+#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)
+{
+  auto lang_item = RustLangItem::lang_items.lookup (item);
+  if (!RustLangItem::lang_items.is_iter_ok (lang_item))
+    return tl::nullopt;
+
+  return lang_item->second;
+}
+
+std::string
+RustLangItem::ToString (RustLangItem::ItemType type)
+{
+  auto str = RustLangItem::lang_items.lookup (type);
+  return str->second;
+}
+
+RustLangItem::ItemType
+RustLangItem::OperatorToLangItem (ArithmeticOrLogicalOperator op)
+{
+  switch (op)
+    {
+    case ArithmeticOrLogicalOperator::ADD:
+      return RustLangItem::ItemType::ADD;
+    case ArithmeticOrLogicalOperator::SUBTRACT:
+      return RustLangItem::ItemType::SUBTRACT;
+    case ArithmeticOrLogicalOperator::MULTIPLY:
+      return RustLangItem::ItemType::MULTIPLY;
+    case ArithmeticOrLogicalOperator::DIVIDE:
+      return RustLangItem::ItemType::DIVIDE;
+    case ArithmeticOrLogicalOperator::MODULUS:
+      return RustLangItem::ItemType::REMAINDER;
+    case ArithmeticOrLogicalOperator::BITWISE_AND:
+      return RustLangItem::ItemType::BITAND;
+    case ArithmeticOrLogicalOperator::BITWISE_OR:
+      return RustLangItem::ItemType::BITOR;
+    case ArithmeticOrLogicalOperator::BITWISE_XOR:
+      return RustLangItem::ItemType::BITXOR;
+    case ArithmeticOrLogicalOperator::LEFT_SHIFT:
+      return RustLangItem::ItemType::SHL;
+    case ArithmeticOrLogicalOperator::RIGHT_SHIFT:
+      return RustLangItem::ItemType::SHR;
+    }
+
+  rust_unreachable ();
+}
+
+RustLangItem::ItemType
+RustLangItem::CompoundAssignmentOperatorToLangItem (
+  ArithmeticOrLogicalOperator op)
+{
+  switch (op)
+    {
+    case ArithmeticOrLogicalOperator::ADD:
+      return RustLangItem::ItemType::ADD_ASSIGN;
+    case ArithmeticOrLogicalOperator::SUBTRACT:
+      return RustLangItem::ItemType::SUB_ASSIGN;
+    case ArithmeticOrLogicalOperator::MULTIPLY:
+      return RustLangItem::ItemType::MUL_ASSIGN;
+    case ArithmeticOrLogicalOperator::DIVIDE:
+      return RustLangItem::ItemType::DIV_ASSIGN;
+    case ArithmeticOrLogicalOperator::MODULUS:
+      return RustLangItem::ItemType::REM_ASSIGN;
+    case ArithmeticOrLogicalOperator::BITWISE_AND:
+      return RustLangItem::ItemType::BITAND_ASSIGN;
+    case ArithmeticOrLogicalOperator::BITWISE_OR:
+      return RustLangItem::ItemType::BITOR_ASSIGN;
+    case ArithmeticOrLogicalOperator::BITWISE_XOR:
+      return RustLangItem::ItemType::BITXOR_ASSIGN;
+    case ArithmeticOrLogicalOperator::LEFT_SHIFT:
+      return RustLangItem::ItemType::SHL_ASSIGN;
+    case ArithmeticOrLogicalOperator::RIGHT_SHIFT:
+      return RustLangItem::ItemType::SHR_ASSIGN;
+    }
+
+  rust_unreachable ();
+}
+
+RustLangItem::ItemType
+RustLangItem::NegationOperatorToLangItem (NegationOperator op)
+{
+  switch (op)
+    {
+    case NegationOperator::NEGATE:
+      return RustLangItem::ItemType::NEGATION;
+    case NegationOperator::NOT:
+      return RustLangItem::ItemType::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 86323d9e267..3447e3680c8 100644
--- a/gcc/rust/util/rust-lang-item.h
+++ b/gcc/rust/util/rust-lang-item.h
@@ -18,6 +18,8 @@ 
 
 #include "rust-system.h"
 #include "rust-operators.h"
+#include "optional.h"
+#include "bi-map.h"
 
 namespace Rust {
 namespace Analysis {
@@ -115,510 +117,16 @@  public:
     STR,
     F32_RUNTIME,
     F64_RUNTIME,
-
-    // delimiter
-    UNKNOWN,
   };
 
-  static ItemType Parse (const std::string &item)
-  {
-    if (item.compare ("add") == 0)
-      {
-	return ItemType::ADD;
-      }
-    else if (item.compare ("sub") == 0)
-      {
-	return ItemType::SUBTRACT;
-      }
-    else if (item.compare ("mul") == 0)
-      {
-	return ItemType::MULTIPLY;
-      }
-    else if (item.compare ("div") == 0)
-      {
-	return ItemType::DIVIDE;
-      }
-    else if (item.compare ("rem") == 0)
-      {
-	return ItemType::REMAINDER;
-      }
-    else if (item.compare ("bitand") == 0)
-      {
-	return ItemType::BITAND;
-      }
-    else if (item.compare ("bitor") == 0)
-      {
-	return ItemType::BITOR;
-      }
-    else if (item.compare ("bitxor") == 0)
-      {
-	return ItemType::BITXOR;
-      }
-    else if (item.compare ("shl") == 0)
-      {
-	return ItemType::SHL;
-      }
-    else if (item.compare ("shr") == 0)
-      {
-	return ItemType::SHR;
-      }
-    else if (item.compare ("neg") == 0)
-      {
-	return ItemType::NEGATION;
-      }
-    else if (item.compare ("not") == 0)
-      {
-	return ItemType::NOT;
-      }
-    else if (item.compare ("add_assign") == 0)
-      {
-	return ItemType::ADD_ASSIGN;
-      }
-    else if (item.compare ("sub_assign") == 0)
-      {
-	return ItemType::SUB_ASSIGN;
-      }
-    else if (item.compare ("mul_assign") == 0)
-      {
-	return ItemType::MUL_ASSIGN;
-      }
-    else if (item.compare ("div_assign") == 0)
-      {
-	return ItemType::DIV_ASSIGN;
-      }
-    else if (item.compare ("rem_assign") == 0)
-      {
-	return ItemType::REM_ASSIGN;
-      }
-    else if (item.compare ("bitand_assign") == 0)
-      {
-	return ItemType::BITAND_ASSIGN;
-      }
-    else if (item.compare ("bitor_assign") == 0)
-      {
-	return ItemType::BITOR_ASSIGN;
-      }
-    else if (item.compare ("bitxor_assign") == 0)
-      {
-	return ItemType::BITXOR_ASSIGN;
-      }
-    else if (item.compare ("shl_assign") == 0)
-      {
-	return ItemType::SHL_ASSIGN;
-      }
-    else if (item.compare ("shr_assign") == 0)
-      {
-	return ItemType::SHR_ASSIGN;
-      }
-    else if (item.compare ("deref") == 0)
-      {
-	return ItemType::DEREF;
-      }
-    else if (item.compare ("deref_mut") == 0)
-      {
-	return ItemType::DEREF_MUT;
-      }
-    else if (item.compare ("index") == 0)
-      {
-	return ItemType::INDEX;
-      }
-    else if (item.compare ("index_mut") == 0)
-      {
-	return ItemType::INDEX_MUT;
-      }
-    else if (item.compare ("RangeFull") == 0)
-      {
-	return ItemType::RANGE_FULL;
-      }
-    else if (item.compare ("Range") == 0)
-      {
-	return ItemType::RANGE;
-      }
-    else if (item.compare ("RangeFrom") == 0)
-      {
-	return ItemType::RANGE_FROM;
-      }
-    else if (item.compare ("RangeTo") == 0)
-      {
-	return ItemType::RANGE_TO;
-      }
-    else if (item.compare ("RangeInclusive") == 0)
-      {
-	return ItemType::RANGE_INCLUSIVE;
-      }
-    else if (item.compare ("RangeToInclusive") == 0)
-      {
-	return ItemType::RANGE_TO_INCLUSIVE;
-      }
-    else if (item.compare ("phantom_data") == 0)
-      {
-	return ItemType::PHANTOM_DATA;
-      }
-    else if (item.compare ("fn") == 0)
-      {
-	return ItemType::FN;
-      }
-    else if (item.compare ("fn_mut") == 0)
-      {
-	return ItemType::FN_MUT;
-      }
-    else if (item.compare ("fn_once") == 0)
-      {
-	return ItemType::FN_ONCE;
-      }
-    else if (item.compare ("fn_once_output") == 0)
-      {
-	return ItemType::FN_ONCE_OUTPUT;
-      }
-    else if (item.compare ("copy") == 0)
-      {
-	return ItemType::COPY;
-      }
-    else if (item.compare ("clone") == 0)
-      {
-	return ItemType::CLONE;
-      }
-    else if (item.compare ("sized") == 0)
-      {
-	return ItemType::SIZED;
-      }
-    else if (item.compare ("slice_alloc") == 0)
-      {
-	return ItemType::SLICE_ALLOC;
-      }
-    else if (item.compare ("slice_u8_alloc") == 0)
-      {
-	return ItemType::SLICE_U8_ALLOC;
-      }
-    else if (item.compare ("str_alloc") == 0)
-      {
-	return ItemType::STR_ALLOC;
-      }
-    else if (item.compare ("array") == 0)
-      {
-	return ItemType::ARRAY;
-      }
-    else if (item.compare ("bool") == 0)
-      {
-	return ItemType::BOOL;
-      }
-    else if (item.compare ("char") == 0)
-      {
-	return ItemType::CHAR;
-      }
-    else if (item.compare ("f32") == 0)
-      {
-	return ItemType::F32;
-      }
-    else if (item.compare ("f64") == 0)
-      {
-	return ItemType::F64;
-      }
-    else if (item.compare ("i8") == 0)
-      {
-	return ItemType::I8;
-      }
-    else if (item.compare ("i16") == 0)
-      {
-	return ItemType::I16;
-      }
-    else if (item.compare ("i32") == 0)
-      {
-	return ItemType::I32;
-      }
-    else if (item.compare ("i64") == 0)
-      {
-	return ItemType::I64;
-      }
-    else if (item.compare ("i128") == 0)
-      {
-	return ItemType::I128;
-      }
-    else if (item.compare ("isize") == 0)
-      {
-	return ItemType::ISIZE;
-      }
-    else if (item.compare ("u8") == 0)
-      {
-	return ItemType::U8;
-      }
-    else if (item.compare ("u16") == 0)
-      {
-	return ItemType::U16;
-      }
-    else if (item.compare ("u32") == 0)
-      {
-	return ItemType::U32;
-      }
-    else if (item.compare ("u64") == 0)
-      {
-	return ItemType::U64;
-      }
-    else if (item.compare ("u128") == 0)
-      {
-	return ItemType::U128;
-      }
-    else if (item.compare ("usize") == 0)
-      {
-	return ItemType::USIZE;
-      }
-    else if (item.compare ("const_ptr") == 0)
-      {
-	return ItemType::CONST_PTR;
-      }
-    else if (item.compare ("const_slice_ptr") == 0)
-      {
-	return ItemType::CONST_SLICE_PTR;
-      }
-    else if (item.compare ("mut_ptr") == 0)
-      {
-	return ItemType::MUT_PTR;
-      }
-    else if (item.compare ("mut_slice_ptr") == 0)
-      {
-	return ItemType::MUT_SLICE_PTR;
-      }
-    else if (item.compare ("slice_u8") == 0)
-      {
-	return ItemType::SLICE_U8;
-      }
-    else if (item.compare ("slice") == 0)
-      {
-	return ItemType::SLICE;
-      }
-    else if (item.compare ("str") == 0)
-      {
-	return ItemType::STR;
-      }
-    else if (item.compare ("f32_runtime") == 0)
-      {
-	return ItemType::F32_RUNTIME;
-      }
-    else if (item.compare ("f64_runtime") == 0)
-      {
-	return ItemType::F64_RUNTIME;
-      }
-
-    return ItemType::UNKNOWN;
-  }
-
-  static std::string ToString (ItemType type)
-  {
-    switch (type)
-      {
-      case ADD:
-	return "add";
-      case SUBTRACT:
-	return "sub";
-      case MULTIPLY:
-	return "mul";
-      case DIVIDE:
-	return "div";
-      case REMAINDER:
-	return "rem";
-      case BITAND:
-	return "bitand";
-      case BITOR:
-	return "bitor";
-      case BITXOR:
-	return "bitxor";
-      case SHL:
-	return "shl";
-      case SHR:
-	return "shr";
-      case NEGATION:
-	return "neg";
-      case NOT:
-	return "not";
-      case ADD_ASSIGN:
-	return "add_assign";
-      case SUB_ASSIGN:
-	return "sub_assign";
-      case MUL_ASSIGN:
-	return "mul_assign";
-      case DIV_ASSIGN:
-	return "div_assign";
-      case REM_ASSIGN:
-	return "rem_assign";
-      case BITAND_ASSIGN:
-	return "bitand_assign";
-      case BITOR_ASSIGN:
-	return "bitor_assign";
-      case BITXOR_ASSIGN:
-	return "bitxor_assign";
-      case SHL_ASSIGN:
-	return "shl_assign";
-      case SHR_ASSIGN:
-	return "shr_assign";
-      case DEREF:
-	return "deref";
-      case DEREF_MUT:
-	return "deref_mut";
-      case INDEX:
-	return "index";
-      case INDEX_MUT:
-	return "index_mut";
-      case RANGE_FULL:
-	return "RangeFull";
-      case RANGE:
-	return "Range";
-      case RANGE_FROM:
-	return "RangeFrom";
-      case RANGE_TO:
-	return "RangeTo";
-      case RANGE_INCLUSIVE:
-	return "RangeInclusive";
-      case RANGE_TO_INCLUSIVE:
-	return "RangeToInclusive";
-      case PHANTOM_DATA:
-	return "phantom_data";
-      case FN:
-	return "fn";
-      case FN_MUT:
-	return "fn_mut";
-      case FN_ONCE:
-	return "fn_once";
-      case FN_ONCE_OUTPUT:
-	return "fn_once_output";
-      case COPY:
-	return "copy";
-      case CLONE:
-	return "clone";
-      case SIZED:
-	return "sized";
-      case SLICE_ALLOC:
-	return "slice_alloc";
-      case SLICE_U8_ALLOC:
-	return "slice_u8_alloc";
-      case STR_ALLOC:
-	return "str_alloc";
-      case ARRAY:
-	return "array";
-      case BOOL:
-	return "bool";
-      case CHAR:
-	return "char";
-      case F32:
-	return "f32";
-      case F64:
-	return "f64";
-      case I8:
-	return "i8";
-      case I16:
-	return "i16";
-      case I32:
-	return "i32";
-      case I64:
-	return "i64";
-      case I128:
-	return "i128";
-      case ISIZE:
-	return "isize";
-      case U8:
-	return "u8";
-      case U16:
-	return "u16";
-      case U32:
-	return "u32";
-      case U64:
-	return "u64";
-      case U128:
-	return "u128";
-      case USIZE:
-	return "usize";
-      case CONST_PTR:
-	return "const_ptr";
-      case CONST_SLICE_PTR:
-	return "const_slice_ptr";
-      case MUT_PTR:
-	return "mut_ptr";
-      case MUT_SLICE_PTR:
-	return "mut_slice_ptr";
-      case SLICE_U8:
-	return "slice_u8";
-      case SLICE:
-	return "slice";
-      case STR:
-	return "str";
-      case F32_RUNTIME:
-	return "f32_runtime";
-      case F64_RUNTIME:
-	return "f64_runtime";
-
-      case UNKNOWN:
-	return "<UNKNOWN>";
-      }
-    return "<UNKNOWN>";
-  }
-
-  static ItemType OperatorToLangItem (ArithmeticOrLogicalOperator op)
-  {
-    switch (op)
-      {
-      case ArithmeticOrLogicalOperator::ADD:
-	return ItemType::ADD;
-      case ArithmeticOrLogicalOperator::SUBTRACT:
-	return ItemType::SUBTRACT;
-      case ArithmeticOrLogicalOperator::MULTIPLY:
-	return ItemType::MULTIPLY;
-      case ArithmeticOrLogicalOperator::DIVIDE:
-	return ItemType::DIVIDE;
-      case ArithmeticOrLogicalOperator::MODULUS:
-	return ItemType::REMAINDER;
-      case ArithmeticOrLogicalOperator::BITWISE_AND:
-	return ItemType::BITAND;
-      case ArithmeticOrLogicalOperator::BITWISE_OR:
-	return ItemType::BITOR;
-      case ArithmeticOrLogicalOperator::BITWISE_XOR:
-	return ItemType::BITXOR;
-      case ArithmeticOrLogicalOperator::LEFT_SHIFT:
-	return ItemType::SHL;
-      case ArithmeticOrLogicalOperator::RIGHT_SHIFT:
-	return ItemType::SHR;
-      }
-    return ItemType::UNKNOWN;
-  }
+  static const BiMap<std::string, ItemType> lang_items;
 
+  static tl::optional<ItemType> Parse (const std::string &item);
+  static std::string ToString (ItemType type);
+  static ItemType OperatorToLangItem (ArithmeticOrLogicalOperator op);
   static ItemType
-  CompoundAssignmentOperatorToLangItem (ArithmeticOrLogicalOperator op)
-  {
-    switch (op)
-      {
-      case ArithmeticOrLogicalOperator::ADD:
-	return ItemType::ADD_ASSIGN;
-      case ArithmeticOrLogicalOperator::SUBTRACT:
-	return ItemType::SUB_ASSIGN;
-      case ArithmeticOrLogicalOperator::MULTIPLY:
-	return ItemType::MUL_ASSIGN;
-      case ArithmeticOrLogicalOperator::DIVIDE:
-	return ItemType::DIV_ASSIGN;
-      case ArithmeticOrLogicalOperator::MODULUS:
-	return ItemType::REM_ASSIGN;
-      case ArithmeticOrLogicalOperator::BITWISE_AND:
-	return ItemType::BITAND_ASSIGN;
-      case ArithmeticOrLogicalOperator::BITWISE_OR:
-	return ItemType::BITOR_ASSIGN;
-      case ArithmeticOrLogicalOperator::BITWISE_XOR:
-	return ItemType::BITXOR_ASSIGN;
-      case ArithmeticOrLogicalOperator::LEFT_SHIFT:
-	return ItemType::SHL_ASSIGN;
-      case ArithmeticOrLogicalOperator::RIGHT_SHIFT:
-	return ItemType::SHR_ASSIGN;
-      }
-    return ItemType::UNKNOWN;
-  }
-
-  static ItemType NegationOperatorToLangItem (NegationOperator op)
-  {
-    switch (op)
-      {
-      case NegationOperator::NEGATE:
-	return ItemType::NEGATION;
-      case NegationOperator::NOT:
-	return ItemType::NOT;
-      }
-    return ItemType::UNKNOWN;
-  }
+  CompoundAssignmentOperatorToLangItem (ArithmeticOrLogicalOperator op);
+  static ItemType NegationOperatorToLangItem (NegationOperator op);
 };
 
 } // namespace Analysis