Add GetBinaryOperator (#319)

Author: Vipul-Cariappa

include/clang/Interpreter/CppInterOp.h

@@ -35,6 +35,43 @@ namespace Cpp {
   using TCppFuncAddr_t = void*;
   using TInterp_t = void*;
   using TCppObject_t = void*;
+
+  enum BinaryOperator {
+    PtrMemD = 0,
+    PtrMemI,
+    Mul,
+    Div,
+    Rem,
+    Add,
+    Sub,
+    Shl,
+    Shr,
+    Cmp,
+    LT,
+    GT,
+    LE,
+    GE,
+    EQ,
+    NE,
+    And,
+    Xor,
+    Or,
+    LAnd,
+    LOr,
+    Assign,
+    MulAssign,
+    DivAssign,
+    RemAssign,
+    AddAssign,
+    SubAssign,
+    ShlAssign,
+    ShrAssign,
+    AndAssign,
+    XorAssign,
+    OrAssign,
+    Comma,
+  };
+
   /// A class modeling function calls for functions produced by the interpreter
   /// in compiled code. It provides an information if we are calling a standard
   /// function, constructor or destructor.
@@ -464,6 +501,11 @@ namespace Cpp {
   CPPINTEROP_API std::string GetFunctionArgName(TCppFunction_t func,
                                                 TCppIndex_t param_index);
 
+  ///\returns function that performs operation op on lc and rc
+  TCppFunction_t GetBinaryOperator(TCppScope_t scope, enum BinaryOperator op,
+                                   const std::string& lc,
+                                   const std::string& rc);
+
   /// Creates an instance of the interpreter we need for the various interop
   /// services.
   ///\param[in] Args - the list of arguments for interpreter constructor.

lib/Interpreter/CppInterOp.cpp

@@ -3161,6 +3161,49 @@ namespace Cpp {
     return PI->getNameAsString();
   }
 
+  TCppFunction_t GetBinaryOperator(TCppScope_t scope, enum BinaryOperator op,
+                                   const std::string& lc,
+                                   const std::string& rc) {
+    Decl* D = static_cast<Decl*>(scope);
+    if (!D)
+      return nullptr;
+
+    DeclContext* DC = nullptr;
+    if (llvm::isa_and_nonnull<TranslationUnitDecl>(D))
+      DC = llvm::dyn_cast<DeclContext>(D);
+    else
+      DC = D->getDeclContext();
+
+    if (!DC)
+      return nullptr;
+
+    Scope* S = getSema().getScopeForContext(DC);
+    if (!S)
+      return nullptr;
+
+    clang::UnresolvedSet<8> lookup;
+
+    getSema().LookupBinOp(S, SourceLocation(), (clang::BinaryOperatorKind)op,
+                          lookup);
+
+    for (NamedDecl* D : lookup) {
+      if (auto* FD = llvm::dyn_cast<Decl>(D)) {
+        assert(GetFunctionNumArgs(FD) == 2 &&
+               "LookupBinOp returned function without 2 arguments");
+
+        std::string arg_type = GetTypeAsString(GetFunctionArgType(FD, 0));
+        if (arg_type != lc)
+          continue;
+        arg_type = GetTypeAsString(GetFunctionArgType(FD, 1));
+        if (arg_type != rc)
+          continue;
+
+        return FD;
+      }
+    }
+    return nullptr;
+  }
+
   TCppObject_t Allocate(TCppScope_t scope) {
     return (TCppObject_t)::operator new(Cpp::SizeOf(scope));
   }

unittests/CppInterOp/ScopeReflectionTest.cpp

@@ -952,3 +952,50 @@ TEST(ScopeReflectionTest, IncludeVector) {
   )";
   Interp->process(code);
 }
+
+TEST(ScopeReflectionTest, GetBinaryOperator) {
+  if (llvm::sys::RunningOnValgrind())
+    GTEST_SKIP() << "XFAIL due to Valgrind report";
+
+  Cpp::CreateInterpreter();
+
+  std::string code = R"(
+    class MyClass {
+    public:
+        int x;
+        MyClass(int x) : x(x) {}
+    };
+
+    MyClass operator-(MyClass lhs, MyClass rhs) {
+        return MyClass(lhs.x - rhs.x);
+    }
+
+    MyClass operator+(MyClass lhs, MyClass rhs) {
+        return MyClass(lhs.x + rhs.x);
+    }
+
+    MyClass operator+(MyClass lhs, int rhs) {
+        return MyClass(lhs.x + rhs);
+    }
+
+    MyClass operator+(int lhs, MyClass rhs) {
+        return MyClass(lhs + rhs.x);
+    }
+  )";
+
+  Cpp::Declare(code.c_str());
+
+  EXPECT_TRUE(Cpp::GetBinaryOperator(
+      Cpp::GetGlobalScope(), Cpp::BinaryOperator::Add, "MyClass", "MyClass"));
+  EXPECT_TRUE(Cpp::GetBinaryOperator(
+      Cpp::GetGlobalScope(), Cpp::BinaryOperator::Sub, "MyClass", "MyClass"));
+  EXPECT_TRUE(Cpp::GetBinaryOperator(
+      Cpp::GetGlobalScope(), Cpp::BinaryOperator::Add, "MyClass", "int"));
+  EXPECT_TRUE(Cpp::GetBinaryOperator(
+      Cpp::GetGlobalScope(), Cpp::BinaryOperator::Add, "int", "MyClass"));
+
+  EXPECT_FALSE(Cpp::GetBinaryOperator(
+      Cpp::GetGlobalScope(), Cpp::BinaryOperator::Add, "float", "MyClass"));
+  EXPECT_FALSE(Cpp::GetBinaryOperator(
+      Cpp::GetGlobalScope(), Cpp::BinaryOperator::Add, "MyClass", "float"));
+}