[SYCL] Revert support for templated call operators in functors and functors without call operators (#8047)

This PR reverts the support for templated call operators in functors and
functors without call operators which were introduced in #7104 and #7970

We found a regression internally with
#7104 that
#7970 attempted to fix. A subsequent
review of #7970 internally, lead to
identifying some pre-existing caveats with regards to supporting
templated call operators in functor, supporting cases where there are
multiple call operators in functor and making sure the right
instantiated version is selected etc.

In order to better address the pre-existing issues as well as gaps in
#7970 , it was decided to revert the above two
PRs.

Author: srividya-sundaram

clang/lib/Sema/SemaSYCL.cpp

@@ -991,42 +991,6 @@ static QualType GetSYCLKernelObjectType(const FunctionDecl *KernelCaller) {
   return KernelParamTy.getUnqualifiedType();
 }
 
-// Get the call operator function associated with the function object
-// for both templated and non-templated operator()().
-
-static CXXMethodDecl *getFunctorCallOperator(const CXXRecordDecl *RD) {
-  DeclarationName Name =
-      RD->getASTContext().DeclarationNames.getCXXOperatorName(OO_Call);
-  DeclContext::lookup_result Calls = RD->lookup(Name);
-
-  if (Calls.empty())
-    return nullptr;
-
-  NamedDecl *CallOp = Calls.front();
-
-  if (CallOp == nullptr)
-    return nullptr;
-
-  if (const auto *CallOpTmpl = dyn_cast<FunctionTemplateDecl>(CallOp))
-    return cast<CXXMethodDecl>(CallOpTmpl->getTemplatedDecl());
-
-  return cast<CXXMethodDecl>(CallOp);
-}
-
-// Fetch the associated call operator of the kernel object
-// (of either the lambda or the function object).
-static CXXMethodDecl *
-GetCallOperatorOfKernelObject(const CXXRecordDecl *KernelObjType) {
-  CXXMethodDecl *CallOperator = nullptr;
-  if (!KernelObjType)
-    return CallOperator;
-  if (KernelObjType->isLambda())
-    CallOperator = KernelObjType->getLambdaCallOperator();
-  else
-    CallOperator = getFunctorCallOperator(KernelObjType);
-  return CallOperator;
-}
-
 /// Creates a kernel parameter descriptor
 /// \param Src  field declaration to construct name from
 /// \param Ty   the desired parameter type
@@ -2815,8 +2779,16 @@ class SyclOptReportCreator : public SyclKernelFieldHandler {
   }
 };
 
+static CXXMethodDecl *getOperatorParens(const CXXRecordDecl *Rec) {
+  for (auto *MD : Rec->methods()) {
+    if (MD->getOverloadedOperator() == OO_Call)
+      return MD;
+  }
+  return nullptr;
+}
+
 static bool isESIMDKernelType(const CXXRecordDecl *KernelObjType) {
-  const CXXMethodDecl *OpParens = getFunctorCallOperator(KernelObjType);
+  const CXXMethodDecl *OpParens = getOperatorParens(KernelObjType);
   return (OpParens != nullptr) && OpParens->hasAttr<SYCLSimdAttr>();
 }
 
@@ -2903,10 +2875,13 @@ class SyclKernelBodyCreator : public SyclKernelFieldHandler {
 
     // Fetch the kernel object and the associated call operator
     // (of either the lambda or the function object).
-    const CXXRecordDecl *KernelObj =
+    CXXRecordDecl *KernelObj =
         GetSYCLKernelObjectType(KernelCallerFunc)->getAsCXXRecordDecl();
-    CXXMethodDecl *WGLambdaFn = GetCallOperatorOfKernelObject(KernelObj);
-
+    CXXMethodDecl *WGLambdaFn = nullptr;
+    if (KernelObj->isLambda())
+      WGLambdaFn = KernelObj->getLambdaCallOperator();
+    else
+      WGLambdaFn = getOperatorParens(KernelObj);
     assert(WGLambdaFn && "non callable object is passed as kernel obj");
     // Mark the function that it "works" in a work group scope:
     // NOTE: In case of parallel_for_work_item the marker call itself is
@@ -3563,7 +3538,7 @@ class SyclKernelBodyCreator : public SyclKernelFieldHandler {
 static bool IsSYCLUnnamedKernel(Sema &SemaRef, const FunctionDecl *FD) {
   if (!SemaRef.getLangOpts().SYCLUnnamedLambda)
     return false;
-  const QualType FunctorTy = GetSYCLKernelObjectType(FD);
+  QualType FunctorTy = GetSYCLKernelObjectType(FD);
   QualType TmplArgTy = calculateKernelNameType(SemaRef.Context, FD);
   return SemaRef.Context.hasSameType(FunctorTy, TmplArgTy);
 }
@@ -3989,7 +3964,7 @@ void Sema::CheckSYCLKernelCall(FunctionDecl *KernelFunc,
   const CXXRecordDecl *KernelObj =
       GetSYCLKernelObjectType(KernelFunc)->getAsCXXRecordDecl();
 
-  if (!GetCallOperatorOfKernelObject(KernelObj)) {
+  if (!KernelObj) {
     Diag(Args[0]->getExprLoc(), diag::err_sycl_kernel_not_function_object);
     KernelFunc->setInvalidDecl();
     return;
@@ -4055,7 +4030,7 @@ void Sema::CheckSYCLKernelCall(FunctionDecl *KernelFunc,
 // kernel to wrapped kernel.
 void Sema::copySYCLKernelAttrs(const CXXRecordDecl *KernelObj) {
   // Get the operator() function of the wrapper.
-  CXXMethodDecl *OpParens = getFunctorCallOperator(KernelObj);
+  CXXMethodDecl *OpParens = getOperatorParens(KernelObj);
   assert(OpParens && "invalid kernel object");
 
   typedef std::pair<FunctionDecl *, FunctionDecl *> ChildParentPair;