Refactor lang item mappings enum into its own header

2 files changed, 295 insertions, 269 deletions

diff --git a/gcc/rust/util/rust-hir-map.h b/gcc/rust/util/rust-hir-map.h
index 799351b..9bac328 100644
--- a/gcc/rust/util/rust-hir-map.h
+++ b/gcc/rust/util/rust-hir-map.h
@@ -25,279 +25,11 @@
 #include "rust-canonical-path.h"
 #include "rust-ast-full-decls.h"
 #include "rust-hir-full-decls.h"
-#include "operator.h"
+#include "rust-lang-item.h"
 
 namespace Rust {
 namespace Analysis {
 
-// https://github.com/rust-lang/rust/blob/master/library/core/src/ops/arith.rs
-class RustLangItem
-{
-public:
-  enum ItemType
-  {
-    ADD,
-    SUBTRACT,
-    MULTIPLY,
-    DIVIDE,
-    REMAINDER,
-    BITAND,
-    BITOR,
-    BITXOR,
-    SHL,
-    SHR,
-
-    NEGATION,
-    NOT,
-
-    ADD_ASSIGN,
-    SUB_ASSIGN,
-    MUL_ASSIGN,
-    DIV_ASSIGN,
-    REM_ASSIGN,
-    BITAND_ASSIGN,
-    BITOR_ASSIGN,
-    BITXOR_ASSIGN,
-    SHL_ASSIGN,
-    SHR_ASSIGN,
-
-    DEREF,
-    DEREF_MUT,
-
-    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;
-      }
-
-    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 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 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;
-  }
-};
-
 class NodeMapping
 {
 public:
diff --git a/gcc/rust/util/rust-lang-item.h b/gcc/rust/util/rust-lang-item.h
new file mode 100644
index 0000000..abf210d
--- /dev/null
+++ b/gcc/rust/util/rust-lang-item.h
@@ -0,0 +1,294 @@
+// Copyright (C) 2020-2022 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-system.h"
+#include "operator.h"
+
+namespace Rust {
+namespace Analysis {
+
+// https://github.com/rust-lang/rust/blob/master/library/core/src/ops/arith.rs
+class RustLangItem
+{
+public:
+  enum ItemType
+  {
+    ADD,
+    SUBTRACT,
+    MULTIPLY,
+    DIVIDE,
+    REMAINDER,
+    BITAND,
+    BITOR,
+    BITXOR,
+    SHL,
+    SHR,
+
+    NEGATION,
+    NOT,
+
+    ADD_ASSIGN,
+    SUB_ASSIGN,
+    MUL_ASSIGN,
+    DIV_ASSIGN,
+    REM_ASSIGN,
+    BITAND_ASSIGN,
+    BITOR_ASSIGN,
+    BITXOR_ASSIGN,
+    SHL_ASSIGN,
+    SHR_ASSIGN,
+
+    DEREF,
+    DEREF_MUT,
+
+    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;
+      }
+
+    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 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 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;
+  }
+};
+
+} // namespace Analysis
+} // namespace Rust