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

via cfe-commits cfe-commits at lists.llvm.org
Fri Apr 24 03:50:21 PDT 2026


================
@@ -294,6 +294,268 @@ void SemaSYCL::CheckSYCLExternalFunctionDecl(FunctionDecl *FD) {
   }
 }
 
+namespace {
+/// A special visitor to visit subobjects within a type, i.e. fields of a
+/// class or elements of an array. Useful for SYCl because in SYCL kernels are
+/// defined via lambda expressions or named callable objects and kernel
+/// parameters are fields of these. These visitors will be used for diagnosing
+/// invalid kernel arugments as well as for functional transformations.
+class SubobjectVisitor {
+  ASTContext &Ctx;
+
+  // These enable handler execution only when previous Handlers succeed.
+  template <typename... Tn>
+  bool handleField(FieldDecl *FD, QualType FDTy, Tn &&...tn) {
+    bool result = true;
+    (void)std::initializer_list<int>{(result = result && tn(FD, FDTy), 0)...};
+    return result;
+  }
+  template <typename... Tn>
+  bool handleField(const CXXBaseSpecifier &BD, QualType BDTy, Tn &&...tn) {
+    bool result = true;
+    std::initializer_list<int>{(result = result && tn(BD, BDTy), 0)...};
+    return result;
+  }
+
+#define KF_FOR_EACH(FUNC, Item, Qt)                                            \
+  handleField(Item, Qt, ([&](FieldDecl *FD, QualType FDTy) {                   \
+                return Handlers.FUNC(FD, FDTy);                                \
+              })...)
+
+  // Parent contains the FieldDecl or CXXBaseSpecifier that was used to enter
+  // the Wrapper structure that we're currently visiting. Owner is the parent
+  // type (which doesn't exist in cases where it is a FieldDecl in the
+  // 'root'), and Wrapper is the current struct being unwrapped.
+  template <typename ParentTy, typename... HandlerTys>
+  void visitComplexRecord(const CXXRecordDecl *Owner, ParentTy &Parent,
+                          const CXXRecordDecl *Wrapper, QualType RecordTy,
+                          HandlerTys &...Handlers) {
+    (void)std::initializer_list<int>{
+        (Handlers.enterStruct(Owner, Parent, RecordTy), 0)...};
+    visitRecordHelper(Wrapper, Wrapper->bases(), Handlers...);
+    visitRecordHelper(Wrapper, Wrapper->fields(), Handlers...);
+    (void)std::initializer_list<int>{
+        (Handlers.leaveStruct(Owner, Parent, RecordTy), 0)...};
+  }
+
+  template <typename... HandlerTys>
+  void visitArray(const CXXRecordDecl *Owner, FieldDecl *Field,
+                  QualType ArrayTy, HandlerTys &...Handlers) {
+    // TODO add support for simple array visiting, i.e. without entering array
+    // elements.
+    visitComplexArray(Owner, Field, ArrayTy, Handlers...);
+  }
+
+  template <typename ParentTy, typename... HandlerTys>
+  void visitRecord(const CXXRecordDecl *Owner, ParentTy &Parent,
+                   const CXXRecordDecl *Wrapper, QualType RecordTy,
+                   HandlerTys &...Handlers) {
+    // TODO add support for simple record visiting, i.e. without entering record
+    // fields.
+    visitComplexRecord(Owner, Parent, Wrapper, RecordTy, Handlers...);
+  }
+
+  template <typename... HandlerTys>
+  void visitRecordHelper(const CXXRecordDecl *Owner,
+                         clang::CXXRecordDecl::base_class_const_range Range,
+                         HandlerTys &...Handlers) {
+    for (const auto &Base : Range) {
+      QualType BaseTy = Base.getType();
+      visitRecord(Owner, Base, BaseTy->getAsCXXRecordDecl(), BaseTy,
+                  Handlers...);
+    }
+  }
+
+  template <typename... HandlerTys>
+  void visitRecordHelper(const CXXRecordDecl *Owner, RecordDecl::field_range,
+                         HandlerTys &...Handlers) {
+    visitRecordFields(Owner, Handlers...);
+  }
+
+  template <typename... HandlerTys>
+  void visitArrayElementImpl(const CXXRecordDecl *Owner, FieldDecl *ArrayField,
+                             QualType ElementTy, uint64_t Index,
+                             HandlerTys &...Handlers) {
+    visitField(Owner, ArrayField, ElementTy, Handlers...);
+  }
+
+  template <typename... HandlerTys>
+  void visitNthArrayElement(const CXXRecordDecl *Owner, FieldDecl *ArrayField,
+                            QualType ElementTy, uint64_t Index,
+                            HandlerTys &...Handlers) {
+    visitArrayElementImpl(Owner, ArrayField, ElementTy, Index, Handlers...);
+  }
+
+  template <typename... HandlerTys>
+  void visitComplexArray(const CXXRecordDecl *Owner, FieldDecl *Field,
----------------
elizabethandrews wrote:

No I mean a different PR. I'm ok with keeping it in this PR if you disagree. I was just wondering if this PR is too confusing for someone not familiar with our downstream implementation.

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


More information about the cfe-commits mailing list