fix codegen for template operator (#682)

* fix codegen for template operator

do not specify the template arguments explicitly

Co-authored-by: Vassil Vassilev <v.g.vassilev@gmail.com>

---------

Co-authored-by: Vassil Vassilev <v.g.vassilev@gmail.com>

Author: Vipul-Cariappa

lib/CppInterOp/CppInterOp.cpp

@@ -2146,23 +2146,14 @@ void make_narg_call(const FunctionDecl* FD, const std::string& return_type,
       PP.SuppressElaboration = true;
       FD->getNameForDiagnostic(stream, PP,
                                /*Qualified=*/false);
-
-      // insert space between template argument list and the function name
-      // this is require if the function is `operator<`
-      // `operator<<type1, type2, ...>` is invalid syntax
-      // whereas `operator< <type1, type2, ...>` is valid
-      std::string simple_name = FD->getNameAsString();
-      size_t idx = complete_name.find(simple_name, 0) + simple_name.size();
-      std::string name_without_template_args = complete_name.substr(0, idx);
-      std::string template_args = complete_name.substr(idx);
-      name = name_without_template_args +
-             (template_args.empty() ? "" : " " + template_args);
+      name = complete_name;
 
       // If a template has consecutive parameter packs, then it is impossible to
       // use the explicit name in the wrapper, since the type deduction is what
       // determines the split of the packs. Instead, we'll revert to the
       // non-templated function name and hope that the type casts in the wrapper
       // will suffice.
+      std::string simple_name = FD->getNameAsString();
       if (FD->isTemplateInstantiation() && FD->getPrimaryTemplate()) {
         const FunctionTemplateDecl* FTDecl =
             llvm::dyn_cast<FunctionTemplateDecl>(FD->getPrimaryTemplate());
@@ -2177,10 +2168,12 @@ void make_narg_call(const FunctionDecl* FD, const std::string& return_type,
               numPacks = 0;
           }
           if (numPacks > 1) {
-            name = name_without_template_args;
+            name = simple_name;
           }
         }
       }
+      if (FD->isOverloadedOperator())
+        name = simple_name;
     }
     if (op_flag || N <= 1)
       callbuf << name;

unittests/CppInterOp/FunctionReflectionTest.cpp

@@ -2030,6 +2030,44 @@ TEST(FunctionReflectionTest, GetFunctionCallWrapper) {
 
   auto consume_callable = Cpp::MakeFunctionCallable(consume);
   EXPECT_EQ(consume_callable.getKind(), Cpp::JitCall::kGenericCall);
+
+  Cpp::Declare(R"(
+  template<typename T1, typename T2>
+  struct Product {};
+
+  template<typename T>
+  struct KlassProduct {
+    template<typename O>
+    const Product<T, O>
+    operator*(const KlassProduct<O> &other) const { return Product<T, O>(); }
+
+    template<typename TT, typename O>
+    const Product<TT, O>
+    operator*(const KlassProduct<O> &other) const { return Product<TT, O>(); }
+  };
+  )");
+
+  Cpp::TCppScope_t KlassProduct = Cpp::GetNamed("KlassProduct");
+  EXPECT_TRUE(KlassProduct);
+
+  Cpp::TCppScope_t KlassProduct_int =
+      Cpp::InstantiateTemplate(KlassProduct, &TAI, 1);
+  EXPECT_TRUE(KlassProduct_int);
+  TAI = Cpp::TemplateArgInfo(Cpp::GetType("float"));
+  Cpp::TCppScope_t KlassProduct_float =
+      Cpp::InstantiateTemplate(KlassProduct, &TAI, 1);
+  EXPECT_TRUE(KlassProduct_float);
+
+  operators.clear();
+  Cpp::GetOperator(KlassProduct_int, Cpp::OP_Star, operators);
+  EXPECT_EQ(operators.size(), 2);
+
+  op = Cpp::BestOverloadFunctionMatch(
+      operators, {}, {{Cpp::GetTypeFromScope(KlassProduct_float)}});
+  EXPECT_TRUE(op);
+
+  auto op_callable = Cpp::MakeFunctionCallable(op);
+  EXPECT_EQ(op_callable.getKind(), Cpp::JitCall::kGenericCall);
 }
 
 TEST(FunctionReflectionTest, IsConstMethod) {