Apply CR suggestions

Author: Fznamznon

clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -11632,7 +11632,7 @@ def ext_sycl_2020_attr_spelling : ExtWarn<
   InGroup<Sycl2017Compat>;
 def err_sycl_taking_address_of_wrong_function : Error<
   "taking address of a function not marked with "
-  "`intel::device_indirectly_callable attribute` is not allowed in SYCL device "
+  "'intel::device_indirectly_callable' attribute is not allowed in SYCL device "
   "code">;
 
 // errors of expect.with.probability

clang/lib/Sema/SemaOverload.cpp

@@ -1817,12 +1817,12 @@ static bool IsStandardConversion(Sema &S, Expr* From, QualType ToType,
         // performed - it may end up here checking validity of a conversion.
         // If false is returned from here, initialization sequence is marked as
         // invalid, then checkAddressOfFunctionIsAvailable is called again
-        // to understand the reason of invaid initialization and and the end
-        // it is called with `Complain` parameter to emit diagnostics.
+        // to understand the reason of invaid initialization and in the end
+        // it is called with 'Complain' parameter to emit diagnostics.
         // We cannot mark an initialization permanently invalid for SYCL device,
         // because we may not know yet where the device code is.
-        // So, just call `checkAddressOfFunctionIsAvailable` again but with
-        // `Complain` parameter to issue a deferred diagnostic.
+        // So, just call 'checkAddressOfFunctionIsAvailable' again but with
+        // 'Complain' parameter to issue a deferred diagnostic.
         if (S.getLangOpts().SYCLIsDevice)
           S.checkAddressOfFunctionIsAvailable(FD, /*Complain=*/true,
                                               DRE->getExprLoc());

clang/test/SemaSYCL/wrong-address-taking.cpp

@@ -30,21 +30,21 @@ template <typename Fn, typename... Args> void templateCaller(Fn F, Args... As) {
 }
 
 template <auto Fn, typename... Args> void templateCaller1(Args... As) {
-  // expected-error@+1 {{taking address of a function not marked with `intel::device_indirectly_callable attribute` is not allowed in SYCL device code}}
+  // expected-error@+1 {{taking address of a function not marked with 'intel::device_indirectly_callable' attribute is not allowed in SYCL device code}}
   Fn(As...);
-  // expected-error@+1 {{taking address of a function not marked with `intel::device_indirectly_callable attribute` is not allowed in SYCL device code}}
+  // expected-error@+1 {{taking address of a function not marked with 'intel::device_indirectly_callable' attribute is not allowed in SYCL device code}}
   runFn(*Fn);
 }
 
 template <auto Fn, typename... Args> void templateCaller2(Args... As) {
-  // expected-error@+1 {{taking address of a function not marked with `intel::device_indirectly_callable attribute` is not allowed in SYCL device code}}
+  // expected-error@+1 {{taking address of a function not marked with 'intel::device_indirectly_callable' attribute is not allowed in SYCL device code}}
   Fn(As...);
 }
 
 void basicUsage() {
-  // expected-error@+1 {{taking address of a function not marked with `intel::device_indirectly_callable attribute` is not allowed in SYCL device code}}
+  // expected-error@+1 {{taking address of a function not marked with 'intel::device_indirectly_callable' attribute is not allowed in SYCL device code}}
   int (*p)(int) = &badFoo;
-  // expected-error@+1 {{taking address of a function not marked with `intel::device_indirectly_callable attribute` is not allowed in SYCL device code}}
+  // expected-error@+1 {{taking address of a function not marked with 'intel::device_indirectly_callable' attribute is not allowed in SYCL device code}}
   int (*p2)(int) = badFoo;
 }
 
@@ -68,32 +68,32 @@ int main() {
     // expected-note@#KernelSingleTaskKernelFuncCall 2{{called by 'kernel_single_task<Basic}}
     h.single_task<class Basic>(
         [=]() {
-          // expected-error@+1 {{taking address of a function not marked with `intel::device_indirectly_callable attribute` is not allowed in SYCL device code}}
+          // expected-error@+1 {{taking address of a function not marked with 'intel::device_indirectly_callable' attribute is not allowed in SYCL device code}}
           int (*p)(int) = &badFoo;
-          // expected-error@+1 {{taking address of a function not marked with `intel::device_indirectly_callable attribute` is not allowed in SYCL device code}}
+          // expected-error@+1 {{taking address of a function not marked with 'intel::device_indirectly_callable' attribute is not allowed in SYCL device code}}
           int (*p2)(int) = badFoo;
 
           // OK
           int (*p3)(int) = &goodFoo;
           int (*p4)(int) = goodFoo;
 
-          // expected-error@+1 {{taking address of a function not marked with `intel::device_indirectly_callable attribute` is not allowed in SYCL device code}}
+          // expected-error@+1 {{taking address of a function not marked with 'intel::device_indirectly_callable' attribute is not allowed in SYCL device code}}
           auto p5 = &externalBadFoo;
           auto *p6 = &externalGoodFoo;
 
           // Make sure that assignment is diagnosed correctly;
           int (*a)(int);
-          // expected-error@+1 {{taking address of a function not marked with `intel::device_indirectly_callable attribute` is not allowed in SYCL device code}}
+          // expected-error@+1 {{taking address of a function not marked with 'intel::device_indirectly_callable' attribute is not allowed in SYCL device code}}
           a = badFoo;
-          // expected-error@+1 {{taking address of a function not marked with `intel::device_indirectly_callable attribute` is not allowed in SYCL device code}}
+          // expected-error@+1 {{taking address of a function not marked with 'intel::device_indirectly_callable' attribute is not allowed in SYCL device code}}
           a = &badFoo;
 
           a = goodFoo;
           a = &goodFoo;
 
-          // expected-error@+1 {{taking address of a function not marked with `intel::device_indirectly_callable attribute` is not allowed in SYCL device code}}
+          // expected-error@+1 {{taking address of a function not marked with 'intel::device_indirectly_callable' attribute is not allowed in SYCL device code}}
           constexpr auto b = badFoo;
-          // expected-error@+1 {{taking address of a function not marked with `intel::device_indirectly_callable attribute` is not allowed in SYCL device code}}
+          // expected-error@+1 {{taking address of a function not marked with 'intel::device_indirectly_callable' attribute is not allowed in SYCL device code}}
           constexpr auto c = &badFoo;
           // expected-note@+1 {{called by 'operator()'}}
           basicUsage();
@@ -104,10 +104,10 @@ int main() {
     // expected-note@#KernelSingleTaskKernelFuncCall {{called by 'kernel_single_task<Members}}
     h.single_task<class Members>(
         [=]() {
-          // expected-error@+1 {{taking address of a function not marked with `intel::device_indirectly_callable attribute` is not allowed in SYCL device code}}
+          // expected-error@+1 {{taking address of a function not marked with 'intel::device_indirectly_callable' attribute is not allowed in SYCL device code}}
           auto p = &ForMembers::badMember;
           auto p1 = &ForMembers::goodMember;
-          // expected-error@+1 {{taking address of a function not marked with `intel::device_indirectly_callable attribute` is not allowed in SYCL device code}}
+          // expected-error@+1 {{taking address of a function not marked with 'intel::device_indirectly_callable' attribute is not allowed in SYCL device code}}
           auto *p2 = &ForMembers::badStaticMember;
         });
   });
@@ -116,24 +116,24 @@ int main() {
     // expected-note@#KernelSingleTaskKernelFuncCall 2{{called by 'kernel_single_task<RunVia}}
     h.single_task<class RunVia>(
         [=]() {
-          // expected-error@+1 {{taking address of a function not marked with `intel::device_indirectly_callable attribute` is not allowed in SYCL device code}}
+          // expected-error@+1 {{taking address of a function not marked with 'intel::device_indirectly_callable' attribute is not allowed in SYCL device code}}
           int baz = runFn(badFoo);
 
           baz = runFn(goodFoo);
 
-          // expected-error@+1 2{{taking address of a function not marked with `intel::device_indirectly_callable attribute` is not allowed in SYCL device code}}
+          // expected-error@+1 2{{taking address of a function not marked with 'intel::device_indirectly_callable' attribute is not allowed in SYCL device code}}
           baz = runFn1(badFoo);
 
           baz = runFn1(goodFoo);
 
-          // expected-error@+1 2{{taking address of a function not marked with `intel::device_indirectly_callable attribute` is not allowed in SYCL device code}}
+          // expected-error@+1 2{{taking address of a function not marked with 'intel::device_indirectly_callable' attribute is not allowed in SYCL device code}}
           templateCaller(badFoo, 2);
           templateCaller(goodFoo, 1);
 
           templateCaller1<goodFoo>(1);
 
           // expected-note@+2 {{called by 'operator()'}}
-          // expected-error@+1 {{taking address of a function not marked with `intel::device_indirectly_callable attribute` is not allowed in SYCL device code}}
+          // expected-error@+1 {{taking address of a function not marked with 'intel::device_indirectly_callable' attribute is not allowed in SYCL device code}}
           templateCaller1<badFoo>(1);
 
         });