[SYCL][clang] Emit default template arguments in integration header

For free function kernels support clang forward declares the kernel
itself as well as its parameter types. In case a free function kernel has a
parameter that is templated and has a default template argument, all
template arguments including arguments that match default arguments must
be printed in kernel's forward declarations, for example

```
template <typename T, typename = int> struct Arg {
  T val;
};

// For the kernel
SYCL_EXT_ONEAPI_FUNCTION_PROPERTY(
    (ext::oneapi::experimental::nd_range_kernel<1>)) void foo(Arg<int> arg) {
  arg.val = 42;
}

// Integration header must contain
void foo(Arg<int, int> arg);
```

Unfortunately, even though integration header emission already has
extensive support for forward declarations priting,
some modifications to clang's type printing are still required.
infrastructure, since neither of existing PrintingPolicy flags help to
reach the correct result.
Using `SuppressDefaultTemplateArgs = true` doesn't help without printing
canonical types, printing canonical types for the case like
```
template <typename T>
SYCL_EXT_ONEAPI_FUNCTION_PROPERTY(
    (ext::oneapi::experimental::nd_range_kernel<1>)) void foo(Arg<T> arg) {
  arg.val = 42;
}
// Printing canonical types is causing the following integration header
template <typename T>
void foo(Arg<type-parameter-0-0, int> arg);
```

Using `SkipCanonicalizationOfTemplateTypeParms` field of printing policy
doesn't help here since at the one point where it is checked we take
canonical type of `Arg`, not its parameters and it will contain template
argument types in canonical type after that.

Author: Fznamznon

clang/include/clang/AST/PrettyPrinter.h

@@ -66,9 +66,10 @@ struct PrintingPolicy {
         SuppressLifetimeQualifiers(false), SuppressTypedefs(false),
         SuppressFinalSpecifier(false),
         SuppressTemplateArgsInCXXConstructors(false),
-        SuppressDefaultTemplateArgs(true), Bool(LO.Bool),
-        Nullptr(LO.CPlusPlus11 || LO.C23), NullptrTypeInNamespace(LO.CPlusPlus),
-        Restrict(LO.C99), Alignof(LO.CPlusPlus11), UnderscoreAlignof(LO.C11),
+        SuppressDefaultTemplateArgs(true), EnforceDefaultTemplateArgs(false),
+        Bool(LO.Bool), Nullptr(LO.CPlusPlus11 || LO.C23),
+        NullptrTypeInNamespace(LO.CPlusPlus), Restrict(LO.C99),
+        Alignof(LO.CPlusPlus11), UnderscoreAlignof(LO.C11),
         UseVoidForZeroParams(!LO.CPlusPlus),
         SplitTemplateClosers(!LO.CPlusPlus11), TerseOutput(false),
         PolishForDeclaration(false), Half(LO.Half),
@@ -237,6 +238,12 @@ struct PrintingPolicy {
   LLVM_PREFERRED_TYPE(bool)
   unsigned SuppressDefaultTemplateArgs : 1;
 
+
+  /// When true, print template arguments that match the default argument for
+  /// the parameter, even if they're not specified in the source.
+  LLVM_PREFERRED_TYPE(bool)
+  unsigned EnforceDefaultTemplateArgs : 1;
+
   /// Whether we can use 'bool' rather than '_Bool' (even if the language
   /// doesn't actually have 'bool', because, e.g., it is defined as a macro).
   LLVM_PREFERRED_TYPE(bool)

clang/lib/AST/TypePrinter.cpp

@@ -2397,15 +2397,35 @@ template <typename TA>
 static void
 printTo(raw_ostream &OS, ArrayRef<TA> Args, const PrintingPolicy &Policy,
         const TemplateParameterList *TPL, bool IsPack, unsigned ParmIndex) {
-  // Drop trailing template arguments that match default arguments.
-  if (TPL && Policy.SuppressDefaultTemplateArgs &&
-      !Policy.PrintCanonicalTypes && !Args.empty() && !IsPack &&
+  llvm::SmallVector<TemplateArgument, 8> OrigArgs;
+  for (const TA &A : Args)
+    OrigArgs.push_back(getArgument(A));
+  if (TPL && !Policy.PrintCanonicalTypes && !IsPack &&
       Args.size() <= TPL->size()) {
-    llvm::SmallVector<TemplateArgument, 8> OrigArgs;
-    for (const TA &A : Args)
-      OrigArgs.push_back(getArgument(A));
-    while (!Args.empty() && getArgument(Args.back()).getIsDefaulted())
-      Args = Args.drop_back();
+    // Drop trailing template arguments that match default arguments.
+    if (Policy.SuppressDefaultTemplateArgs) {
+      while (!OrigArgs.empty() && getArgument(OrigArgs.back()).getIsDefaulted())
+        OrigArgs.pop_back();
+    } else if (Policy.EnforceDefaultTemplateArgs) {
+      for (unsigned I = Args.size(); I < TPL->size(); ++I) {
+        auto Param = TPL->getParam(I);
+        if (auto *TTPD = dyn_cast<TemplateTypeParmDecl>(Param)) {
+          if (!TTPD->hasDefaultArgument())
+            break;
+          OrigArgs.push_back(getArgument(TTPD->getDefaultArgument()));
+        } else if (auto *TTPD = dyn_cast<TemplateTemplateParmDecl>(Param)) {
+          if (!TTPD->hasDefaultArgument())
+            break;
+          OrigArgs.push_back(getArgument(TTPD->getDefaultArgument()));
+        } else if (auto *NTTPD = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
+          if (!NTTPD->hasDefaultArgument())
+            break;
+          OrigArgs.push_back(getArgument(NTTPD->getDefaultArgument()));
+        } else {
+          llvm_unreachable("unexpected template parameter");
+        }
+      }
+    }
   }
 
   const char *Comma = Policy.MSVCFormatting ? "," : ", ";
@@ -2414,7 +2434,7 @@ printTo(raw_ostream &OS, ArrayRef<TA> Args, const PrintingPolicy &Policy,
 
   bool NeedSpace = false;
   bool FirstArg = true;
-  for (const auto &Arg : Args) {
+  for (const auto &Arg : OrigArgs) {
     // Print the argument into a string.
     SmallString<128> Buf;
     llvm::raw_svector_ostream ArgOS(Buf);

clang/lib/Sema/SemaSYCL.cpp

@@ -6464,6 +6464,7 @@ void SYCLIntegrationHeader::emit(raw_ostream &O) {
 
     O << "\n";
     O << "// Forward declarations of kernel and its argument types:\n";
+    Policy.SuppressDefaultTemplateArgs = false;
     FwdDeclEmitter.Visit(K.SyclKernel->getType());
     O << "\n";
 
@@ -6476,11 +6477,12 @@ void SYCLIntegrationHeader::emit(raw_ostream &O) {
         FirstParam = false;
       else
         ParmList += ", ";
-      ParmList += Param->getType().getCanonicalType().getAsString();
+      ParmList += Param->getType().getCanonicalType().getAsString(Policy);
     }
     FunctionTemplateDecl *FTD = K.SyclKernel->getPrimaryTemplate();
     Policy.SuppressDefinition = true;
     Policy.PolishForDeclaration = true;
+    Policy.EnforceDefaultTemplateArgs = true;
     if (FTD) {
       FTD->print(O, Policy);
     } else {
@@ -6509,6 +6511,8 @@ void SYCLIntegrationHeader::emit(raw_ostream &O) {
     }
     O << ";\n";
     O << "}\n";
+    Policy.SuppressDefaultTemplateArgs = true;
+    Policy.EnforceDefaultTemplateArgs = false;
 
     // Generate is_kernel, is_single_task_kernel and nd_range_kernel functions.
     O << "namespace sycl {\n";