[SYCL] add clang diagnostic for illegal types of kernel free function arguments

clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -12969,6 +12969,8 @@ def err_free_function_first_occurrence_missing_attr: Error<
   "the first occurrence of SYCL kernel free function should be declared with 'sycl-nd-range-kernel' or 'sycl-single-task-kernel' compile time properties">;
 def err_free_function_class_method : Error<
   "%select{static |}0class method cannot be used to define a SYCL kernel free function kernel">;
+def err_free_function_virtual_arg : Error<
+  "argument type %0 of kernel free function can not %select{be virtually derived |have virtual methods}1">;
 
 
 // SYCL kernel entry point diagnostics

clang/lib/Sema/SemaSYCL.cpp

@@ -5849,6 +5849,43 @@ void SemaSYCL::MarkDevices() {
   }
 }
 
+static bool hasVirtuals(Sema &S, ParmVarDecl *Param) {
+  const clang::CXXRecordDecl *ParamType =
+      Param->getType()->getAsCXXRecordDecl();
+  if (!ParamType || !ParamType->isThisDeclarationADefinition())
+    return false;
+
+  llvm::SmallVector<const clang::CXXRecordDecl *, 8> WorkList;
+  llvm::SmallPtrSet<const clang::CXXRecordDecl *, 8> Visited;
+  WorkList.push_back(ParamType);
+
+  while (!WorkList.empty()) {
+    const clang::CXXRecordDecl *Cur = WorkList.pop_back_val();
+    if (!Visited.insert(Cur).second)
+      continue;
+
+    // Check for virtual bases
+    for (const clang::CXXBaseSpecifier &Base : Cur->bases()) {
+      if (Base.isVirtual())
+        return S.Diag(Param->getLocation(), diag::err_free_function_virtual_arg)
+               << ParamType->getNameAsString() << 0 << Param->getSourceRange();
+      const clang::CXXRecordDecl *BaseDecl =
+          Base.getType()->getAsCXXRecordDecl();
+      if (BaseDecl && BaseDecl->isThisDeclarationADefinition())
+        WorkList.push_back(BaseDecl);
+    }
+
+    // Check for virtual member functions
+    for (const auto *Method : Cur->methods()) {
+      if (Method->isVirtual()) {
+        return S.Diag(Param->getLocation(), diag::err_free_function_virtual_arg)
+               << ParamType->getNameAsString() << 1 << Param->getSourceRange();
+      }
+    }
+  }
+  return false;
+}
+
 static bool CheckFreeFunctionDiagnostics(Sema &S, const FunctionDecl *FD) {
   if (FD->isVariadic()) {
     return S.Diag(FD->getLocation(), diag::err_free_function_variadic_args);
@@ -5871,6 +5908,8 @@ static bool CheckFreeFunctionDiagnostics(Sema &S, const FunctionDecl *FD) {
                     diag::err_free_function_with_default_arg)
              << Param->getSourceRange();
     }
+    if (hasVirtuals(S, Param))
+      return true;
   }
   return false;
 }

clang/test/SemaSYCL/free_function_negative.cpp

@@ -118,3 +118,81 @@ static void StaticsingleTaskKernelMethod(int Value) {
 }
 
 };
+
+class Base {};
+class Derived : virtual public Base {};
+
+// expected-error@+2 {{argument type Derived of kernel free function can not be virtually derived}}
+[[__sycl_detail__::add_ir_attributes_function("sycl-single-task-kernel", 2)]] 
+void VirtualInheritArg(Derived Value) {
+}
+
+// expected-error@+2 {{argument type Derived of kernel free function can not be virtually derived}}
+[[__sycl_detail__::add_ir_attributes_function("sycl-single-task-kernel", 2)]] 
+void VirtualInheritArg1(int a, Derived Value, float b, Derived Value1) {
+}
+
+class Derived1 : public Derived {
+};
+
+// expected-error@+2 {{argument type Derived1 of kernel free function can not be virtually derived}}
+[[__sycl_detail__::add_ir_attributes_function("sycl-single-task-kernel", 2)]] 
+void VirtualInheritArg2(Derived1 Value) {
+}
+
+class Base1 {};
+class Derived2 : public Base1, public virtual Base {
+};
+
+// expected-error@+2 {{argument type Derived2 of kernel free function can not be virtually derived}}
+[[__sycl_detail__::add_ir_attributes_function("sycl-single-task-kernel", 2)]] 
+void VirtualInheritArg3(Derived2 Value) {
+}
+
+struct Derived3 : virtual public Base {
+};
+
+// expected-error@+2 {{argument type Derived3 of kernel free function can not be virtually derived}}
+[[__sycl_detail__::add_ir_attributes_function("sycl-single-task-kernel", 2)]] 
+void VirtualInheritArg4(Derived3 Value) {
+}
+
+class Class {
+    public:
+    virtual void virtualMethod() {}
+};
+
+// expected-error@+2 {{argument type Class of kernel free function can not have virtual methods}}
+[[__sycl_detail__::add_ir_attributes_function("sycl-single-task-kernel", 2)]] 
+void VirtualMethodArg1(Class Value) {
+}
+
+class Class1: public Class {
+    public:
+    void NewMethod() {}
+};
+
+// expected-error@+2 {{argument type Class1 of kernel free function can not have virtual methods}}
+[[__sycl_detail__::add_ir_attributes_function("sycl-single-task-kernel", 2)]] 
+void VirtualMethodArg2(Class1 Value) {
+}
+
+class Class2: Base1 {
+    public:
+    virtual void virtualMethod() {}
+};
+
+// expected-error@+2 {{argument type Class2 of kernel free function can not have virtual methods}}
+[[__sycl_detail__::add_ir_attributes_function("sycl-nd-range-kernel", 2)]] 
+void VirtualMethodArg2(Class2 Value) {
+}
+
+class Class3 {
+    public:
+    virtual ~Class3() {}
+};
+
+// expected-error@+2 {{argument type Class3 of kernel free function can not have virtual methods}}
+[[__sycl_detail__::add_ir_attributes_function("sycl-nd-range-kernel", 2)]] 
+void VirtualMethodArg3(Class3 Value) {
+}