add test & comment

Author: Vipul-Cariappa

lib/Interpreter/CppInterOp.cpp

@@ -1964,6 +1964,8 @@ namespace Cpp {
       // even when we supply the object parameter. Therefore we only use it in
       // cases where we know it works and set this variable to true when we do.
 
+      // true if not a overloaded operators or the overloaded operator is call
+      // operator
       bool op_flag = !FD->isOverloadedOperator() ||
                      FD->getOverloadedOperator() == clang::OO_Call;
 

unittests/CppInterOp/FunctionReflectionTest.cpp

@@ -1684,6 +1684,45 @@ TEST(FunctionReflectionTest, GetFunctionCallWrapper) {
   bool boolean = false;
   FCI_op.Invoke((void*)&boolean, {args, /*args_size=*/1}, object);
   EXPECT_TRUE(boolean);
+
+  Interp->process(R"(
+    namespace N1 {
+
+    template <typename... _Tn> struct Klass3 {
+      using type = int;
+    };
+    
+    namespace N2 {
+    template <typename T1, typename T2> class Klass1 {};
+
+    template <typename T1, typename T2> class Klass2 {};
+
+    template <typename T1, typename T2, typename T3, typename T4>
+    constexpr Klass2<
+      T1, typename Klass3<T2, Klass1<T3, T4>>::type>
+    operator+(const Klass2<T1, T2> &__lhs,
+              const Klass1<T3, T4> &__rhs) {
+      typedef Klass1<T3, T4> __T1;
+      typedef typename Klass3<T2, __T1>::type __ct;
+      typedef Klass2<T1, __ct> __T2;
+      return {};
+    }
+    } // namespace N2
+    } // namespace N1
+  
+    N1::N2::Klass2<int, double> K1;
+    N1::N2::Klass1<char, float> K2;
+  )");
+
+  Cpp::TCppType_t K1 = Cpp::GetTypeFromScope(Cpp::GetNamed("K1"));
+  Cpp::TCppType_t K2 = Cpp::GetTypeFromScope(Cpp::GetNamed("K2"));
+  operators.clear();
+  Cpp::GetOperator(Cpp::GetScope("N2", Cpp::GetScope("N1")), Cpp::OP_Plus, operators);
+  EXPECT_EQ(operators.size(), 1);
+  Cpp::TCppFunction_t kop =
+      Cpp::BestOverloadFunctionMatch(operators, {}, {K1, K2});
+  auto chrono_op_fn_callable = Cpp::MakeFunctionCallable(kop);
+  EXPECT_EQ(chrono_op_fn_callable.getKind(), Cpp::JitCall::kGenericCall);
 }
 
 TEST(FunctionReflectionTest, IsConstMethod) {