Merge #953

953: Refactor lang item mappings r=philberty a=philberty

This refactors how we find our lang items so that during HIR lowering
we have a generic outer attributes handler on Items. The old code only
done lang item mappings during the type check pass and assumed all
lang items are Traits which is not the case. To implement slices range
syntax actually map to structs within libcore/ops/range.rs which have
lang items on structs. This means we can have lang items on any Item.

Co-authored-by: Philip Herron <philip.herron@embecosm.com>

1 files changed, 1 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: