[clang] Add support for SYCL templated free functions declared in namespaces (#17936)

This PR adds support of templated free function declared both in
namespace or not. Support of accessor types should be added in a
separate PR because it requires effort not only on the frontend side.
Docs:
https://github.com/intel/llvm/blob/sycl/sycl/doc/extensions/proposed/sycl_ext_oneapi_free_function_kernels.asciidoc

---------

Co-authored-by: Mariya Podchishchaeva <mariya.podchishchaeva@intel.com>

Author: dklochkov-emb

clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -12670,6 +12670,8 @@ def err_registered_kernels_name_already_registered : Error<
   "free function kernel has already been registered with '%0'; cannot register with '%1'">;
 def err_not_sycl_free_function : Error<
   "attempting to register a function that is not a SYCL free function as '%0'">;
+def err_free_function_variadic_args: Error<
+  "free function kernel cannot be a variadic function">;
 
 // SYCL kernel entry point diagnostics
 def err_sycl_entry_point_invalid : Error<

clang/lib/Sema/SemaSYCL.cpp

@@ -5793,6 +5793,10 @@ void SemaSYCL::MarkDevices() {
 
 void SemaSYCL::ProcessFreeFunction(FunctionDecl *FD) {
   if (isFreeFunction(FD)) {
+    if (FD->isVariadic()) {
+      Diag(FD->getLocation(), diag::err_free_function_variadic_args);
+      return;
+    }
     SyclKernelDecompMarker DecompMarker(*this);
     SyclKernelFieldChecker FieldChecker(*this);
     SyclKernelUnionChecker UnionChecker(*this);
@@ -6491,16 +6495,36 @@ static void PrintNSClosingBraces(raw_ostream &OS, const DeclContext *DC) {
 
 class FreeFunctionPrinter {
   raw_ostream &O;
+  PrintingPolicy &Policy;
   bool NSInserted = false;
 
 public:
-  FreeFunctionPrinter(raw_ostream &O) : O(O) {}
+  FreeFunctionPrinter(raw_ostream &O, PrintingPolicy &PrintPolicy)
+      : O(O), Policy(PrintPolicy) {}
+
+  /// Emits the function declaration of template free function.
+  /// \param FTD The function declaration to print.
+  /// \param S Sema object.
+  void printFreeFunctionDeclaration(FunctionTemplateDecl *FTD,
+                                    clang::SemaSYCL &S) {
+    const FunctionDecl *TemplatedDecl = FTD->getTemplatedDecl();
+    if (!TemplatedDecl)
+      return;
+    const std::string TemplatedDeclParams =
+        getTemplatedParamList(TemplatedDecl->parameters(), Policy);
+    const std::string TemplateParams =
+        getTemplateParameters(FTD->getTemplateParameters(), S);
+    printFreeFunctionDeclaration(TemplatedDecl, TemplatedDeclParams,
+                                 TemplateParams);
+  }
 
   /// Emits the function declaration of a free function.
   /// \param FD The function declaration to print.
   /// \param Args The arguments of the function.
+  /// \param TemplateParameters The template parameters of the function.
   void printFreeFunctionDeclaration(const FunctionDecl *FD,
-                                    const std::string &Args) {
+                                    const std::string &Args,
+                                    std::string_view TemplateParameters = "") {
     const DeclContext *DC = FD->getDeclContext();
     if (DC) {
       // if function in namespace, print namespace
@@ -6510,6 +6534,7 @@ class FreeFunctionPrinter {
         // function
         NSInserted = true;
       }
+      O << TemplateParameters;
       O << FD->getReturnType().getAsString() << " ";
       O << FD->getNameAsString() << "(" << Args << ");";
       if (NSInserted) {
@@ -6533,6 +6558,95 @@ class FreeFunctionPrinter {
     if (NSInserted)
       PrintNamespaces(O, FD, /*isPrintNamesOnly=*/true);
     O << FD->getIdentifier()->getName().data();
+    if (FD->getPrimaryTemplate()) {
+      std::string Buffer;
+      llvm::raw_string_ostream StringStream(Buffer);
+      const TemplateArgumentList *TAL = FD->getTemplateSpecializationArgs();
+      ArrayRef<TemplateArgument> A = TAL->asArray();
+      bool FirstParam = true;
+      for (const auto &X : A) {
+        if (FirstParam)
+          FirstParam = false;
+        else if (X.getKind() == TemplateArgument::Pack) {
+          for (const auto &PackArg : X.pack_elements()) {
+            StringStream << ", ";
+            PackArg.print(Policy, StringStream, true);
+          }
+          continue;
+        } else {
+          StringStream << ", ";
+        }
+
+        X.print(Policy, StringStream, true);
+      }
+      StringStream.flush();
+      if (Buffer.front() != '<')
+        Buffer = "<" + Buffer + ">";
+      O << Buffer;
+    }
+  }
+
+private:
+  /// Helper method to get arguments of templated function as a string
+  /// \param Parameters Array of parameters of the function.
+  /// \param Policy Printing policy.
+  /// returned string Example:
+  /// \code
+  ///  template <typename T1, typename T2>
+  ///  void foo(T1 a, T2 b);
+  /// \endcode
+  /// returns string "T1 a, T2 b"
+  std::string
+  getTemplatedParamList(const llvm::ArrayRef<clang::ParmVarDecl *> Parameters,
+                        PrintingPolicy Policy) {
+    bool FirstParam = true;
+    llvm::SmallString<128> ParamList;
+    llvm::raw_svector_ostream ParmListOstream{ParamList};
+    Policy.SuppressTagKeyword = true;
+    for (ParmVarDecl *Param : Parameters) {
+      if (FirstParam)
+        FirstParam = false;
+      else
+        ParmListOstream << ", ";
+      ParmListOstream << Param->getType().getAsString(Policy);
+      ParmListOstream << " " << Param->getNameAsString();
+    }
+    return ParamList.str().str();
+  }
+
+  /// Helper method to get text representation of the template parameters.
+  /// Throws an error if the last parameter is a pack.
+  /// \param TPL The template parameter list.
+  /// \param S The SemaSYCL object.
+  /// Example:
+  /// \code
+  ///  template <typename T1, class T2>
+  ///  void foo(T1 a, T2 b);
+  /// \endcode
+  /// returns string "template <typename T1, class T2> "
+  std::string getTemplateParameters(const clang::TemplateParameterList *TPL,
+                                    SemaSYCL &S) {
+    std::string TemplateParams{"template <"};
+    bool FirstParam{true};
+    for (NamedDecl *Param : *TPL) {
+      if (!FirstParam)
+        TemplateParams += ", ";
+      FirstParam = false;
+      if (const auto *TemplateParam = dyn_cast<TemplateTypeParmDecl>(Param)) {
+        TemplateParams +=
+            TemplateParam->wasDeclaredWithTypename() ? "typename " : "class ";
+        if (TemplateParam->isParameterPack())
+          TemplateParams += "... ";
+        TemplateParams += TemplateParam->getNameAsString();
+      } else if (const auto *NonTypeParam =
+                     dyn_cast<NonTypeTemplateParmDecl>(Param)) {
+        TemplateParams += NonTypeParam->getType().getAsString();
+        TemplateParams += " ";
+        TemplateParams += NonTypeParam->getNameAsString();
+      }
+    }
+    TemplateParams += "> ";
+    return TemplateParams;
   }
 };
 
@@ -6836,11 +6950,16 @@ void SYCLIntegrationHeader::emit(raw_ostream &O) {
         ParmList += ", ";
         ParmListWithNamesOstream << ", ";
       }
-      Policy.SuppressTagKeyword = true;
-      Param->getType().print(ParmListWithNamesOstream, Policy);
-      Policy.SuppressTagKeyword = false;
-      ParmListWithNamesOstream << " " << Param->getNameAsString();
-      ParmList += Param->getType().getCanonicalType().getAsString(Policy);
+      if (Param->isParameterPack()) {
+        ParmListWithNamesOstream << "Args... args";
+        ParmList += "Args ...";
+      } else {
+        Policy.SuppressTagKeyword = true;
+        Param->getType().print(ParmListWithNamesOstream, Policy);
+        Policy.SuppressTagKeyword = false;
+        ParmListWithNamesOstream << " " << Param->getNameAsString();
+        ParmList += Param->getType().getCanonicalType().getAsString(Policy);
+      }
     }
     ParmListWithNamesOstream.flush();
     FunctionTemplateDecl *FTD = K.SyclKernel->getPrimaryTemplate();
@@ -6876,30 +6995,14 @@ void SYCLIntegrationHeader::emit(raw_ostream &O) {
     // template arguments that match default template arguments while printing
     // template-ids, even if the source code doesn't reference them.
     Policy.EnforceDefaultTemplateArgs = true;
-    FreeFunctionPrinter FFPrinter(O);
+    FreeFunctionPrinter FFPrinter(O, Policy);
     if (FTD) {
-      FTD->print(O, Policy);
-      O << ";\n";
+      FFPrinter.printFreeFunctionDeclaration(FTD, S);
     } else {
       FFPrinter.printFreeFunctionDeclaration(K.SyclKernel, ParmListWithNames);
     }
 
     FFPrinter.printFreeFunctionShim(K.SyclKernel, ShimCounter, ParmList);
-    if (FTD) {
-      const TemplateArgumentList *TAL =
-          K.SyclKernel->getTemplateSpecializationArgs();
-      ArrayRef<TemplateArgument> A = TAL->asArray();
-      bool FirstParam = true;
-      O << "<";
-      for (const auto &X : A) {
-        if (FirstParam)
-          FirstParam = false;
-        else
-          O << ", ";
-        X.print(Policy, O, true);
-      }
-      O << ">";
-    }
     O << ";\n";
     O << "}\n";
     Policy.SuppressDefaultTemplateArgs = true;