Disallow std names in kernel names

Author: jtmott-intel

clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -10835,7 +10835,7 @@ def err_sycl_kernel_incorrectly_named : Error<
   "kernel %select{name is missing"
   "|needs to have a globally-visible name"
   "|name is invalid. Unscoped enum requires fixed underlying type"
-  "|name cannot be or use std::nullptr_t"
+  "|name cannot be a type in the \"std\" namespace"
   "}0">;
 def err_sycl_restrict : Error<
   "SYCL kernel cannot "

clang/lib/Sema/SemaSYCL.cpp

@@ -1914,6 +1914,13 @@ void SYCLIntegrationHeader::emitFwdDecl(raw_ostream &O, const Decl *D,
       }
       break;
     }
+
+    if (NS->isStdNamespace()) {
+      Diag.Report(KernelLocation, diag::err_sycl_kernel_incorrectly_named)
+          << /* name cannot be a type in the std namespace */ 3;
+      return;
+    }
+
     ++NamespaceCnt;
     const StringRef NSInlinePrefix = NS->isInline() ? "inline " : "";
     NSStr.insert(
@@ -1997,12 +2004,9 @@ void SYCLIntegrationHeader::emitForwardClassDecls(
   const CXXRecordDecl *RD = T->getAsCXXRecordDecl();
 
   if (!RD) {
-    // Most non-class types such as `int` can safely skip forward declarations,
-    // but `std::nullptr_t` is a special case that doesn't behave well.
-    if (T->isNullPtrType()) {
+    if (T->isNullPtrType())
       Diag.Report(KernelLocation, diag::err_sycl_kernel_incorrectly_named)
-          << /* name cannot be or use std::nullptr_t */ 3;
-    }
+          << /* name cannot be a type in the std namespace */ 3;
 
     return;
   }

clang/test/CodeGenSYCL/stdtypes_kernel_type.cpp

@@ -1,4 +1,4 @@
-// RUN: %clang_cc1 -fsycl -fsycl-is-device -fsycl-int-header=%t.h -DNULLPTRT_CHECK -verify %s
+// RUN: %clang_cc1 -fsycl -fsycl-is-device -fsycl-int-header=%t.h -DCHECK_ERROR -verify %s
 // RUN: %clang_cc1 -fsycl -fsycl-is-device -fsycl-int-header=%t.h %s
 // RUN: FileCheck -input-file=%t.h %s
 //
@@ -41,20 +41,29 @@ typedef long unsigned int size_t;
 typedef long int ptrdiff_t;
 typedef decltype(nullptr) nullptr_t;
 enum class byte : unsigned char {};
+class T;
+class U;
 } // namespace std
 
+template <typename T> struct Templated_kernel_name;
+
 template <typename name, typename Func>
 __attribute__((sycl_kernel)) void kernel_single_task(Func kernelFunc) {
   kernelFunc();
 }
 
 int main() {
-#ifdef NULLPTRT_CHECK
-  // expected-error@+1 {{kernel name cannot be or use std::nullptr_t}}
-  kernel_single_task<std::nullptr_t>([=]() {});
+#ifdef CHECK_ERROR
+  kernel_single_task<std::nullptr_t>([=]() {}); // expected-error {{kernel name cannot be a type in the "std" namespace}}
+  kernel_single_task<std::T>([=]() {}); // expected-error {{kernel name cannot be a type in the "std" namespace}}
+  kernel_single_task<Templated_kernel_name<std::nullptr_t>>([=]() {}); // expected-error {{kernel name cannot be a type in the "std" namespace}}
+  kernel_single_task<Templated_kernel_name<std::U>>([=]() {}); // expected-error {{kernel name cannot be a type in the "std" namespace}}
 #endif
+
+  // Although in the std namespace, these resolve to builtins such as `int` that are allowed in kernel names
   kernel_single_task<std::byte>([=]() {});
   kernel_single_task<std::size_t>([=]() {});
   kernel_single_task<std::ptrdiff_t>([=]() {});
+
   return 0;
 }