add GetSpellingFromOperator & GetOperatorFromSpelling

Author: Vipul-Cariappa

include/CppInterOp/CppInterOp.h

@@ -593,6 +593,12 @@ CPPINTEROP_API std::string GetFunctionArgDefault(TCppFunction_t func,
 CPPINTEROP_API std::string GetFunctionArgName(TCppFunction_t func,
                                               TCppIndex_t param_index);
 
+///\returns string representation of the operator
+std::string GetSpellingFromOperator(Operator Operator);
+
+///\returns operator of representing the string
+Operator GetOperatorFromSpelling(const std::string& op);
+
 ///\returns arity of the operator or kNone
 CPPINTEROP_API OperatorArity GetOperatorArity(TCppFunction_t op);
 

lib/CppInterOp/CppInterOp.cpp

@@ -2070,7 +2070,8 @@ void make_narg_call(const FunctionDecl* FD, const std::string& return_type,
       if (op_flag) {
         callbuf << ", ";
       } else {
-        callbuf << ' ' << Cpp::getOperatorSpelling(FD->getOverloadedOperator())
+        callbuf << ' '
+                << clang::getOperatorSpelling(FD->getOverloadedOperator())
                 << ' ';
       }
     }
@@ -3559,6 +3560,19 @@ std::string GetFunctionArgName(TCppFunction_t func, TCppIndex_t param_index) {
   return PI->getNameAsString();
 }
 
+std::string GetSpellingFromOperator(Operator Operator) {
+  return clang::getOperatorSpelling((clang::OverloadedOperatorKind)Operator);
+}
+
+Operator GetOperatorFromSpelling(const std::string& op) {
+#define OVERLOADED_OPERATOR(Name, Spelling, Token, Unary, Binary, MemberOnly)  \
+  if ((Spelling) == op) {                                                      \
+    return (Operator)OO_##Name;                                                \
+  }
+#include "clang/Basic/OperatorKinds.def"
+  return Operator::OP_None;
+}
+
 OperatorArity GetOperatorArity(TCppFunction_t op) {
   Decl* D = static_cast<Decl*>(op);
   if (auto* FD = llvm::dyn_cast<FunctionDecl>(D)) {

unittests/CppInterOp/TypeReflectionTest.cpp

@@ -611,3 +611,10 @@ TEST(TypeReflectionTest, IsFunctionPointerType) {
   EXPECT_FALSE(
       Cpp::IsFunctionPointerType(Cpp::GetVariableType(Cpp::GetNamed("i"))));
 }
+
+TEST(TypeReflectionTest, OperatorSpelling) {
+  EXPECT_EQ(Cpp::GetSpellingFromOperator(Cpp::OP_Less), "<");
+  EXPECT_EQ(Cpp::GetSpellingFromOperator(Cpp::OP_Plus), "+");
+  EXPECT_EQ(Cpp::GetOperatorFromSpelling("->"), Cpp::OP_Arrow);
+  EXPECT_EQ(Cpp::GetOperatorFromSpelling("()"), Cpp::OP_Call);
+}