[SYCL] Match kernel's function types with actual types. (#1949)

Using getFullyQualifiedType to calculcate the kernel function's types makes the
types in the kernel different from the actual type and that creates a type
mismatch.
getFullyQualifiedType's use is restricted to make type lookup correct in
templates.
This change, replacing the fully qualified type with the canonical
one, fixes the issue, but will imply that the pretty-printer needs to be
updated to print fully qualified names.

Author: zahiraam

clang/lib/Sema/SemaSYCL.cpp

@@ -706,8 +706,7 @@ static QualType calculateKernelNameType(ASTContext &Ctx,
   const TemplateArgumentList *TAL =
       KernelCallerFunc->getTemplateSpecializationArgs();
   assert(TAL && "No template argument info");
-  return TypeName::getFullyQualifiedType(TAL->get(0).getAsType(), Ctx,
-                                         /*WithGlobalNSPrefix=*/true);
+  return TAL->get(0).getAsType().getCanonicalType();
 }
 
 // Gets a name for the OpenCL kernel function, calculated from the first
@@ -1761,10 +1760,7 @@ class SyclKernelIntHeaderCreator
            "Incorrect template args for Accessor Type");
     // Get specialization constant ID type, which is the second template
     // argument.
-    QualType SpecConstIDTy =
-        TypeName::getFullyQualifiedType(TemplateArgs.get(1).getAsType(),
-                                        SemaRef.getASTContext(), true)
-            .getCanonicalType();
+    QualType SpecConstIDTy = TemplateArgs.get(1).getAsType().getCanonicalType();
     const std::string SpecConstName = PredefinedExpr::ComputeName(
         SemaRef.getASTContext(), PredefinedExpr::UniqueStableNameType,
         SpecConstIDTy);
@@ -2446,40 +2442,42 @@ static void printTemplateArguments(ASTContext &Ctx, raw_ostream &ArgOS,
   ArgOS << ">";
 }
 
-static std::string getKernelNameTypeString(QualType T, ASTContext &Ctx,
-                                           const PrintingPolicy &TypePolicy) {
-
-  QualType FullyQualifiedType = TypeName::getFullyQualifiedType(T, Ctx, true);
-
-  const CXXRecordDecl *RD = T->getAsCXXRecordDecl();
-
-  if (!RD)
-    return eraseAnonNamespace(FullyQualifiedType.getAsString(TypePolicy));
-
-  // If kernel name type is a template specialization with enum type
-  // template parameters, enumerators in name type string should be
-  // replaced  with their underlying value since the enum definition
-  // is not visible in integration header.
-  if (const auto *TSD = dyn_cast<ClassTemplateSpecializationDecl>(RD)) {
-    SmallString<64> Buf;
-    llvm::raw_svector_ostream ArgOS(Buf);
-
-    // Print the qualifiers for the type.
-    FullyQualifiedType.getQualifiers().print(ArgOS, TypePolicy,
+static std::string printRecordType(QualType T, const CXXRecordDecl *RD,
+                                   const PrintingPolicy &TypePolicy) {
+  SmallString<64> Buf;
+  llvm::raw_svector_ostream OS(Buf);
+  T.getCanonicalType().getQualifiers().print(OS, TypePolicy,
                                              /*appendSpaceIfNotEmpty*/ true);
+  if (const auto *TSD = dyn_cast<ClassTemplateSpecializationDecl>(RD)) {
 
     // Print template class name
-    TSD->printQualifiedName(ArgOS, TypePolicy, /*WithGlobalNsPrefix*/ true);
+    TSD->printQualifiedName(OS, TypePolicy, /*WithGlobalNsPrefix*/ true);
 
     // Print template arguments substituting enumerators
     ASTContext &Ctx = RD->getASTContext();
     const TemplateArgumentList &Args = TSD->getTemplateArgs();
-    printTemplateArguments(Ctx, ArgOS, Args.asArray(), TypePolicy);
+    printTemplateArguments(Ctx, OS, Args.asArray(), TypePolicy);
 
-    return eraseAnonNamespace(ArgOS.str().str());
+    return eraseAnonNamespace(OS.str().str());
   }
+  if (RD->getDeclContext()->isFunctionOrMethod())
+    return eraseAnonNamespace(T.getCanonicalType().getAsString(TypePolicy));
+  const NamespaceDecl *NS = dyn_cast<NamespaceDecl>(RD->getDeclContext());
+  RD->printQualifiedName(OS, TypePolicy, !(NS && NS->isAnonymousNamespace()));
+  return eraseAnonNamespace(OS.str().str());
+}
 
-  return eraseAnonNamespace(FullyQualifiedType.getAsString(TypePolicy));
+static std::string getKernelNameTypeString(QualType T, ASTContext &Ctx,
+                                           const PrintingPolicy &TypePolicy) {
+  if (T->isRecordType())
+    return printRecordType(T, T->getAsCXXRecordDecl(), TypePolicy);
+  if (T->isEnumeralType()) {
+    SmallString<64> Buf;
+    llvm::raw_svector_ostream OS(Buf);
+    OS << "::" << T.getCanonicalType().getAsString(TypePolicy);
+    return eraseAnonNamespace(OS.str().str());
+  }
+  return eraseAnonNamespace(T.getCanonicalType().getAsString(TypePolicy));
 }
 
 void SYCLIntegrationHeader::emit(raw_ostream &O) {

clang/test/SemaSYCL/kernel-function-type.cpp

@@ -0,0 +1,40 @@
+// RUN: %clang_cc1 -fsycl -fsycl-is-device -fsyntax-only -verify %s
+// expected-no-diagnostics
+
+// The kernel_single_task call is emitted as an OpenCL kernel function. The call
+// to getFullyQualifiedType caused a 2nd instantiation of zip_iterator<b,b> (the
+// first instantiation is on line 28 during phase 1).
+// Then, the call to 'foo' in 'main' causes 'foo' to be instantiated. The best
+// match for zip_iterator<j,d> is the one instantiated by the
+// kernel_single_task, which is now different from the one made in phase 1.
+// 'is_same<zip_iterator<b,b>' is instantiated during phase 1 at line 28, and
+// 'zip_iterator<b,b>' is instantiated by getFullyQualifiedName.
+// So 'is_same<zip_iterator<b,b>, zip_iterator<j,d>>::value' return false
+// even though zip_iterator<b,b> and zip_iterator<j,d> have the same type
+// 'zip_iterator<b,b>'.
+
+struct b {};
+
+template <typename T, typename U>
+struct is_same { static const bool value = false; };
+template <typename T>
+struct is_same<T, T> { static const bool value = true; };
+
+template <typename... Ts>
+struct zip_iterator {};
+
+template <class j, class d>
+void foo(j e, d k) {
+  static_assert(is_same<zip_iterator<b, b>, zip_iterator<j, d>>::value, "device_iterator");
+}
+
+template <typename name, typename Func>
+__attribute__((sycl_kernel)) void kernel_single_task(Func kernelFunc) {
+  kernelFunc();
+}
+
+int main() {
+  kernel_single_task<zip_iterator<b, b>>([] {});
+  foo(b{}, b{});
+  return 0;
+}