[clang] [clang][SYCL] Diagnose reference kernel arguments (PR #192957)

[Tom Honermann via cfe-commits]

================
@@ -0,0 +1,93 @@
+// RUN: %clang_cc1 -triple x86_64-linux-gnu -std=c++17 -fsyntax-only -Wno-vla-cxx-extension -fsycl-is-host -verify %s
+// RUN: %clang_cc1 -triple spirv64 -std=c++17 -fsyntax-only -Wno-vla-cxx-extension -fsycl-is-device -verify %s
+
+// A unique kernel name type is required for each declared kernel entry point.
+template<int, int = 0> struct KN;
+
+// A generic kernel launch function.
+template<typename KNT, typename... Ts>
+void sycl_kernel_launch(const char *, Ts...) {}
+
+// Kernel entry point template definition.
+template<typename KNT, typename T>
+[[clang::sycl_kernel_entry_point(KNT)]]
+void kernel_single_task(T) {}
+
+struct S { // expected-note 3{{within field of type 'S' declared here}}
+  int a;
+  int &b; //expected-error 3{{'int &' cannot be used as the type of a kernel parameter}}
+};
+
+void fooarr(int (&arr)[5]) {
+}
+
+template <typename T> class Callable { // expected-note 2{{within field of type 'Callable<int &>' declared here}}
+  T data; // expected-error 2{{'int &' cannot be used as the type of a kernel parameter}}
+public:
+  Callable(T d) : data(d) {}
+  void operator()() {
+  }
+};
+
+class Derived1 : Callable<int> { // expected-note {{within field of type 'Derived1' declared here}}
+  int &a; // expected-error {{'int &' cannot be used as the type of a kernel parameter}}
+public:
+  Derived1(int d, int &b) : Callable<int>(d), a(b) {}
+};
+
+class Derived2 : Callable<int&> { // expected-note {{within base of type 'Callable<int &>' declared here}}
+  int a;
+public:
+  Derived2(int d, int &b) : Callable<int&>(b), a(d) {}
+};
+
+void refCases(int AS) {
+  int p = 0;
+  double q = 0;
+  float s = 0;
+  kernel_single_task<class KN<1>>( // expected-note {{requested here}}
+      [ // expected-note2{{within field of type}}
+          // expected-error at +1 {{'int &' cannot be used as the type of a kernel parameter}}
+          &p, q,
+          // expected-error at +1 {{'float &' cannot be used as the type of a kernel parameter}}
+          &s] {
+        (void)q;
+        (void)p;
+        (void)s;
+      });
+
+   auto L = [&]() { (void)p;}; // expected-error {{'int &' cannot be used as the type of a kernel parameter}}
+                               // expected-note at -1 {{within field of type}}
+  S Str {p, p};
+  kernel_single_task<class KN<2>>( // expected-note {{requested here}}
+      [=] { // expected-note 2{{within field of type}}
+        (void)L;
+        (void)Str; // no error because fail for L already
+      });
+
+  kernel_single_task<class KN<3>>( // expected-note {{requested here}}
+     [=] { // // expected-note {{within field of type}}
+       (void)Str;
+     });
+
+  S arr[2] = {Str, Str};
+  kernel_single_task<class KN<4>>( // expected-note {{requested here}}
+      [=] { // expected-note {{within field of type}}
+        (void)arr;
+      });
+  int arr1[AS];
+  kernel_single_task<class KN<5>>( // expected-note {{requested here}}
+      [&] { // expected-note {{within field of type}}
+        (void)arr1; // expected-error {{'int (&)[AS]' cannot be used as the type of a kernel parameter}}
+      });
+  int arrayints[5] = {0};
+  kernel_single_task<class KN<7>>( // expected-note {{requested here}}
+      [&] { // expected-note {{within field of type}}
+        fooarr(arrayints); // expected-error {{'int (&)[5]' cannot be used as the type of a kernel parameter}}
+      });
+  kernel_single_task<class KN<8>>(Callable<int&>{p}); // expected-note {{requested here}}
+  kernel_single_task<class KN<9>>(Callable<int>{p});
+  kernel_single_task<class KN<10>>(Derived1{p, p}); // expected-note {{requested here}}
+  kernel_single_task<class KN<11>>(Derived2{p, p}); // expected-note {{requested here}}
+}
+
----------------
tahonermann wrote:

It is difficult to follow the notes when the same types are used for distinct error cases. If it isn't too laborious, I think it would be helpful to introduce new types for each error that is exercised. That makes it easier to understand precisely what changed when diagnostic changes happen with new development. See `clang/test/SemaSYCL/sycl-kernel-launch.cpp` as an example where each error case has a comment expressing what is intended to be tested, and where all associated notes are colocated with their corresponding error.

https://github.com/llvm/llvm-project/pull/192957