[SYCL] Enable diagnosing of indirect implicit capture of "this" (#4745)

The compiler issues an error if a lambda passed directly to a SYCL kernel
function implicitly captures "this", but does not issue an error if the
lambda that captures "this" is itself captured by the kernel lambda.
The situation when SYCL kernel function captures lambda is a normal
workflow for SYCL reductions, so it is important to diagnose this case
as well.

Author: Fznamznon

clang/lib/Sema/SemaSYCL.cpp

@@ -1703,6 +1703,15 @@ class SyclKernelFieldChecker : public SyclKernelFieldHandler {
 
   bool handleStructType(FieldDecl *FD, QualType FieldTy) final {
     IsInvalid |= checkNotCopyableToKernel(FD, FieldTy);
+    CXXRecordDecl *RD = FieldTy->getAsCXXRecordDecl();
+    assert(RD && "Not a RecordDecl inside the handler for struct type");
+    if (RD->isLambda()) {
+      for (const LambdaCapture &LC : RD->captures())
+        if (LC.capturesThis() && LC.isImplicit()) {
+          SemaRef.Diag(LC.getLocation(), diag::err_implicit_this_capture);
+          IsInvalid = true;
+        }
+    }
     return isValid();
   }
 
@@ -3758,7 +3767,6 @@ void Sema::CheckSYCLKernelCall(FunctionDecl *KernelFunc, SourceRange CallLoc,
     for (const LambdaCapture &LC : KernelObj->captures())
       if (LC.capturesThis() && LC.isImplicit()) {
         Diag(LC.getLocation(), diag::err_implicit_this_capture);
-        Diag(CallLoc.getBegin(), diag::note_used_here);
         KernelFunc->setInvalidDecl();
       }
   }

clang/test/SemaSYCL/lambda_implicit_capture_this.cpp

@@ -1,24 +1,95 @@
 // RUN: %clang_cc1 -fsycl-is-device -fsyntax-only -Wno-sycl-2017-compat -verify %s
+//
+// This test checks that the compiler issues an error on attempt to capture
+// "this" pointer by lambdas passed to the device code (directly and indirectly)
 
-template <typename name, typename Func>
-__attribute__((sycl_kernel)) void kernel(const Func &kernelFunc) {
-  kernelFunc();
-}
+#include "Inputs/sycl.hpp"
+using namespace cl::sycl;
+queue q;
 
 class Class {
 public:
   Class() : member(1) {}
   void function();
+  void function2();
+  void function3();
   int member;
 };
 
+void Class::function3() {
+  auto Lambda = [=]() {
+    int acc[1] = {5};
+    acc[0] *= member;
+  };
+}
+
+void Class::function2() {
+  auto Lambda = [=]() {
+    int acc[1] = {5};
+    acc[0] *= member;
+  };
+  function3();
+}
+
 void Class::function() {
-  // expected-note@+1{{used here}}
-  kernel<class kernel_wrapper>(
-      [=]() {
+  auto Lambda = [=]() {
+    int acc[1] = {5};
+    acc[0] *= member; // expected-error 2{{implicit capture of 'this' is not allowed for kernel functions}}
+  };
+  q.submit([&](handler &h) {
+    // expected-note@+1 {{in instantiation of function template specialization}}
+    h.single_task<class Simple>([=]() {
+      int acc[1] = {5};
+      acc[0] *= member; // expected-error{{implicit capture of 'this' is not allowed for kernel functions}}
+    });
+  });
+  q.submit([&](handler &h) {
+    // expected-note@+1 {{in instantiation of function template specialization}}
+    h.single_task<class CapturedOnDevice>([=]() {
+      auto DeviceLambda = [=]() {
         int acc[1] = {5};
         acc[0] *= member; // expected-error{{implicit capture of 'this' is not allowed for kernel functions}}
-      });
+      };
+      DeviceLambda();
+    });
+  });
+  q.submit([&](handler &h) {
+    // expected-note@+1 {{in instantiation of function template specialization}}
+    h.single_task<class CapturedOnDevice1>([=]() {
+      // FIXME: That is probably not correct source location for a diagnostic
+      function2(); // expected-error{{implicit capture of 'this' is not allowed for kernel functions}}
+    });
+  });
+  q.submit([&](handler &h) {
+    // expected-note@+1 {{in instantiation of function template specialization}}
+    h.single_task<class CapturedOnDevice2>([=]() {
+      // FIXME: That is probably not correct source location for a diagnostic
+      function3(); // expected-error{{implicit capture of 'this' is not allowed for kernel functions}}
+    });
+  });
+  q.submit([&](handler &h) {
+    // expected-note@+1 {{in instantiation of function template specialization}}
+    h.single_task<class CapturedOnHost>([=]() {
+      Lambda();
+    });
+  });
+  q.submit([&](handler &h) {
+    // expected-note@+1 {{in instantiation of function template specialization}}
+    h.single_task<class CapturedOnHost1>([Lambda]() {
+    });
+  });
+  auto InnerLambda = [=]() {
+    int A = 2 + member; // expected-error {{implicit capture of 'this' is not allowed for kernel functions}}
+  };
+  auto ExternalLambda = [=]() {
+    InnerLambda();
+  };
+  q.submit([&](handler &h) {
+    // expected-note@+1 {{in instantiation of function template specialization}}
+    h.single_task<class CapturedOnHost2>([=]() {
+      ExternalLambda();
+    });
+  });
 }
 
 int main(int argc, char *argv[]) {