update patch and tests

Author: smanna12

clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -11431,7 +11431,7 @@ 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<
-  "%select{%1 should be globally-visible"
+  "%select{%1 should be globally visible"
   "|unscoped enum %1 requires fixed underlying type"
   "|unnamed type %1 is not valid in a SYCL kernel name, provide a kernel name "
   "or enable unnamed kernel lambdas via -fsycl-unnamed-lambda"

clang/lib/Sema/SemaSYCL.cpp

@@ -3657,7 +3657,7 @@ class SYCLKernelNameTypeVisitor
     if (const auto *ED = dyn_cast<EnumDecl>(DeclNamed)) {
       if (!ED->isScoped() && !ED->isFixed()) {
         S.Diag(KernelInvocationFuncLoc, diag::err_sycl_kernel_incorrectly_named)
-            << /* Unscoped enum requires fixed underlying type */ 1
+            << /* unscoped enum requires fixed underlying type */ 1
             << DeclNamed;
         IsInvalid = true;
       }
@@ -3690,8 +3690,8 @@ class SYCLKernelNameTypeVisitor
           if (UnnamedLambdaUsed) {
             S.Diag(KernelInvocationFuncLoc,
                    diag::err_sycl_kernel_incorrectly_named)
-		 << /* unnamed type is not valid in a SYCL kernel name */ 2
-		 << KernelNameType;
+                << /* unnamed type is not valid in a SYCL kernel name */ 2
+                << KernelNameType;
             IsInvalid = true;
             return;
           }

clang/test/SemaSYCL/implicit_kernel_type.cpp

@@ -23,10 +23,10 @@ int main() {
   queue q;
 
 #if defined(WARN)
-  // expected-error@#KernelSingleTask {{'InvalidKernelName1' should be globally-visible}}
+  // expected-error@#KernelSingleTask {{'InvalidKernelName1' should be globally visible}}
   // expected-note@+7 {{in instantiation of function template specialization}}
 #elif defined(ERROR)
-  // expected-error@#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/nested-anon-and-std-ns.cpp

@@ -37,7 +37,7 @@ struct MyWrapper {
       h.single_task<ValidNS::StructinValidNS>([] {});
     });
 
-    // expected-error@#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,27 +32,27 @@ struct MyWrapper {
 public:
   void test() {
     cl::sycl::queue q;
-    // expected-error@#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>' 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' 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>' 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>>([] {});
@@ -63,26 +63,26 @@ struct MyWrapper {
       h.single_task<ValidAlias>([] {});
     });
 
-    // expected-error@#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<std::max_align_t>([] {});
     });
 
     using InvalidAlias = InvalidKernelName4;
-    // 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<InvalidAlias>([] {});
     });
 
     using InvalidAlias1 = InvalidKernelName5;
-    // expected-error@#KernelSingleTask {{'namespace1::KernelName<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>>' 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>>>([] {});