address review comments

Author: smanna12

clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -11430,11 +11430,11 @@ def err_nullptr_t_type_in_sycl_kernel : Error<"%0 is an invalid kernel name, "
 def err_invalid_std_type_in_sycl_kernel : Error<"%0 is an invalid kernel name, " 
                                           "%q1 is declared in the 'std' namespace ">;
 
-def err_sycl_kernel_incorrectly_named : Error<"%0 is an invalid kernel name type">;
-def note_invalid_type_in_sycl_kernel : Note<
+def err_sycl_kernel_incorrectly_named : Error<
   "%select{%1 should be globally-visible"
   "|unscoped enum %1 requires fixed underlying type"
-  "|unnamed lambda is used in a SYCL kernel name"
+  "|unnamed type %1 is not valid in a SYCL kernel name, provide a kernel name "
+  "or enable unnamed kernel lambdas via -fsycl-unnamed-lambda"
   "}0">;
 
 def err_sycl_kernel_not_function_object

clang/lib/Sema/SemaSYCL.cpp

@@ -3657,10 +3657,8 @@ class SYCLKernelNameTypeVisitor
     if (const auto *ED = dyn_cast<EnumDecl>(DeclNamed)) {
       if (!ED->isScoped() && !ED->isFixed()) {
         S.Diag(KernelInvocationFuncLoc, diag::err_sycl_kernel_incorrectly_named)
-            << KernelNameType;
-        S.Diag(KernelInvocationFuncLoc, diag::note_invalid_type_in_sycl_kernel)
             << /* Unscoped enum requires fixed underlying type */ 1
-            << QualType(ED->getTypeForDecl(), 0);
+            << DeclNamed;
         IsInvalid = true;
       }
     }
@@ -3692,25 +3690,19 @@ class SYCLKernelNameTypeVisitor
           if (UnnamedLambdaUsed) {
             S.Diag(KernelInvocationFuncLoc,
                    diag::err_sycl_kernel_incorrectly_named)
-                << KernelNameType;
-            S.Diag(KernelInvocationFuncLoc,
-                   diag::note_invalid_type_in_sycl_kernel)
-                << /* unnamed lambda is used in a SYCL kernel name */ 2;
+		 << /* unnamed type is not valid in a SYCL kernel name */ 2
+		 << KernelNameType;
             IsInvalid = true;
             return;
           }
+
           // Check if the declaration is completely defined within a
           // function or class/struct.
-
           if (Tag->isCompleteDefinition()) {
             S.Diag(KernelInvocationFuncLoc,
                    diag::err_sycl_kernel_incorrectly_named)
-                << KernelNameType;
-            S.Diag(KernelInvocationFuncLoc,
-                   diag::note_invalid_type_in_sycl_kernel)
                 << /* kernel name should be globally visible */ 0
-                << QualType(Tag->getTypeForDecl(), 0);
-
+                << KernelNameType;
             IsInvalid = true;
           } else {
             S.Diag(KernelInvocationFuncLoc, diag::warn_sycl_implicit_decl);

clang/test/SemaSYCL/implicit_kernel_type.cpp

@@ -23,12 +23,10 @@ int main() {
   queue q;
 
 #if defined(WARN)
-  // expected-error@#KernelSingleTask {{'InvalidKernelName1' is an invalid kernel name type}}
-  // expected-note@#KernelSingleTask {{'InvalidKernelName1' should be globally-visible}}
-  // expected-note@+8 {{in instantiation of function template specialization}}
+  // expected-error@#KernelSingleTask {{'InvalidKernelName1' should be globally-visible}}
+  // expected-note@+7 {{in instantiation of function template specialization}}
 #elif defined(ERROR)
-  // expected-error@#KernelSingleTask {{'InvalidKernelName1' is an invalid kernel name type}}
-  // expected-note@#KernelSingleTask {{'InvalidKernelName1' should be globally-visible}}
+  // expected-error@#KernelSingleTask {{'InvalidKernelName1' should be globally-visible}}
   // expected-note@+4 {{in instantiation of function template specialization}}
 #endif
   class InvalidKernelName1 {};

clang/test/SemaSYCL/kernelname-enum.cpp

@@ -69,15 +69,13 @@ int main() {
   });
 
   q.submit([&](cl::sycl::handler &cgh) {
-    // expected-error@#KernelSingleTask {{'dummy_functor_2<val_3>' is an invalid kernel name type}}
-    // expected-note@#KernelSingleTask {{unscoped enum 'unscoped_enum_no_type_set' requires fixed underlying type}}
+    // expected-error@#KernelSingleTask {{unscoped enum 'unscoped_enum_no_type_set' requires fixed underlying type}}
     // expected-note@+1{{in instantiation of function template specialization}}
     cgh.single_task(f2);
   });
 
   q.submit([&](cl::sycl::handler &cgh) {
-    // expected-error@#KernelSingleTask {{'templated_functor<dummy_functor_2>' is an invalid kernel name type}}
-    // expected-note@#KernelSingleTask {{unscoped enum 'unscoped_enum_no_type_set' requires fixed underlying type}}
+    // expected-error@#KernelSingleTask {{unscoped enum 'unscoped_enum_no_type_set' requires fixed underlying type}}
     // expected-note@+1{{in instantiation of function template specialization}}
     cgh.single_task(f5);
   });

clang/test/SemaSYCL/nested-anon-and-std-ns.cpp

@@ -37,8 +37,7 @@ struct MyWrapper {
       h.single_task<ValidNS::StructinValidNS>([] {});
     });
 
-    // expected-error@#KernelSingleTask {{'ParentStruct::ChildStruct' is an invalid kernel name type}}
-    // expected-note@#KernelSingleTask {{'ParentStruct::ChildStruct' should be globally-visible}}
+    // expected-error@#KernelSingleTask {{'ParentStruct::ChildStruct' should be globally-visible}}
     // expected-note@+2{{in instantiation of function template specialization}}
     q.submit([&](cl::sycl::handler &h) {
       h.single_task<ParentStruct::ChildStruct>([] {});

clang/test/SemaSYCL/unnamed-kernel.cpp

@@ -32,31 +32,27 @@ struct MyWrapper {
 public:
   void test() {
     cl::sycl::queue q;
-    // expected-error@#KernelSingleTask {{'InvalidKernelName1' is an invalid kernel name type}}
-    // expected-note@#KernelSingleTask {{'InvalidKernelName1' should be globally-visible}}
+    // expected-error@#KernelSingleTask {{'InvalidKernelName1' should be globally-visible}}
     // expected-note@+3{{in instantiation of function template specialization}}
     class InvalidKernelName1 {};
     q.submit([&](cl::sycl::handler &h) {
       h.single_task<InvalidKernelName1>([] {});
     });
 
-    // expected-error@#KernelSingleTask {{'namespace1::KernelName<InvalidKernelName2>' is an invalid kernel name type}}
-    // expected-note@#KernelSingleTask {{'InvalidKernelName2' should be globally-visible}}
+    // expected-error@#KernelSingleTask {{'namespace1::KernelName<InvalidKernelName2>' should be globally-visible}}
     // expected-note@+3{{in instantiation of function template specialization}}
     class InvalidKernelName2 {};
     q.submit([&](cl::sycl::handler &h) {
       h.single_task<namespace1::KernelName<InvalidKernelName2>>([] {});
     });
 
-    // expected-error@#KernelSingleTask {{'MyWrapper::InvalidKernelName0' is an invalid kernel name type}}
-    // expected-note@#KernelSingleTask {{'MyWrapper::InvalidKernelName0' should be globally-visible}}
+    // expected-error@#KernelSingleTask {{'MyWrapper::InvalidKernelName0' should be globally-visible}}
     // expected-note@+2{{in instantiation of function template specialization}}
     q.submit([&](cl::sycl::handler &h) {
       h.single_task<InvalidKernelName0>([] {});
     });
 
-    // expected-error@#KernelSingleTask {{'namespace1::KernelName<MyWrapper::InvalidKernelName3>' is an invalid kernel name type}}
-    // expected-note@#KernelSingleTask {{'MyWrapper::InvalidKernelName3' should be globally-visible}}
+    // expected-error@#KernelSingleTask {{'namespace1::KernelName<MyWrapper::InvalidKernelName3>' should be globally-visible}}
     // expected-note@+2{{in instantiation of function template specialization}}
     q.submit([&](cl::sycl::handler &h) {
       h.single_task<namespace1::KernelName<InvalidKernelName3>>([] {});
@@ -67,29 +63,26 @@ struct MyWrapper {
       h.single_task<ValidAlias>([] {});
     });
 
-    // expected-error@#KernelSingleTask {{'std::max_align_t' is an invalid kernel name, 'std::(anonymous)' is declared in the 'std' namespace}}
+    // expected-error@#KernelSingleTask {{'MyWrapper::InvalidKernelName4' should be globally-visible}}
     // expected-note@+2{{in instantiation of function template specialization}}
     q.submit([&](cl::sycl::handler &h) {
       h.single_task<std::max_align_t>([] {});
     });
 
     using InvalidAlias = InvalidKernelName4;
-    // expected-error@#KernelSingleTask {{'MyWrapper::InvalidKernelName4' is an invalid kernel name type}}
-    // expected-note@#KernelSingleTask {{'MyWrapper::InvalidKernelName4' should be globally-visible}}
+    // expected-error@#KernelSingleTask {{'std::max_align_t' is an invalid kernel name, 'std::(anonymous)' is declared in the 'std' namespace}}
     // expected-note@+2{{in instantiation of function template specialization}}
     q.submit([&](cl::sycl::handler &h) {
       h.single_task<InvalidAlias>([] {});
     });
 
     using InvalidAlias1 = InvalidKernelName5;
-    // expected-error@#KernelSingleTask {{'namespace1::KernelName<MyWrapper::InvalidKernelName5>' is an invalid kernel name type}}
-    // expected-note@#KernelSingleTask {{'MyWrapper::InvalidKernelName5' should be globally-visible}}
+    // expected-error@#KernelSingleTask {{'namespace1::KernelName<MyWrapper::InvalidKernelName5>' should be globally-visible}}
     // expected-note@+2{{in instantiation of function template specialization}}
     q.submit([&](cl::sycl::handler &h) {
       h.single_task<namespace1::KernelName<InvalidAlias1>>([] {});
     });
-    // expected-error@#KernelSingleTask {{'Templated_kernel_name2<Templated_kernel_name<InvalidKernelName1>>' is an invalid kernel name type}}
-    // expected-note@#KernelSingleTask {{'InvalidKernelName1' should be globally-visible}}
+    // expected-error@#KernelSingleTask {{'Templated_kernel_name2<Templated_kernel_name<InvalidKernelName1>>' should be globally-visible}}
     // expected-note@+2{{in instantiation of function template specialization}}
     q.submit([&](cl::sycl::handler &h) {
       h.single_task<Templated_kernel_name2<Templated_kernel_name<InvalidKernelName1>>>([] {});
@@ -144,8 +137,7 @@ struct MyWrapper {
 
     // This errors because const decltype(SomeLambda) != decltype(SomeLambda),
     //  so this is not the unnamed lambda situation.
-    // expected-error-re@#KernelSingleTask {{'const (lambda at {{.*}}unnamed-kernel.cpp{{.*}}' is an invalid kernel name type}}
-    // expected-note@#KernelSingleTask {{unnamed lambda is used in a SYCL kernel name}}
+    // expected-error@#KernelSingleTask {{unnamed type 'const}}
     // expected-note@+3{{in instantiation of function template specialization}}
     q.submit([&](cl::sycl::handler &h) {
       auto SomeLambda = []() {};
@@ -158,8 +150,7 @@ struct MyWrapper {
 int main() {
   cl::sycl::queue q;
 #ifndef __SYCL_UNNAMED_LAMBDA__
-  // expected-error-re@#KernelSingleTask {{'(lambda at {{.*}}unnamed-kernel.cpp{{.*}}' is an invalid kernel name type}}
-  // expected-note@#KernelSingleTask {{unnamed lambda is used in a SYCL kernel name}}
+  // expected-error-re@#KernelSingleTask {{unnamed type '(lambda at {{.*}}unnamed-kernel.cpp{{.*}}' is not valid in a SYCL kernel name, provide a kernel name or enable unnamed kernel lambdas via -fsycl-unnamed-lambda}}
   // expected-note@+2{{in instantiation of function template specialization}}
 #endif
   q.submit([&](cl::sycl::handler &h) { h.single_task([] {}); });