[SYCL] Remove IsDeprecatedDeviceCopyable

This was discussed in
#15342 (comment) and the
consensus seemd to be that we should drop it right away in a separate
PR, do it here.

Technically, it is a breaking change that could also be considered a
bugfix. An example of a class failing the updated check is

```
struct Kernel {
    Kernel(int);
    Kernel(const Kernel&) = default;
    Kernel& operator=(const Kernel&) { return *this; } // non-trivial
};
```

An additional minor reason (other than not being SYCL-conformant) to
drop it right away is to save a tiny bit of compile time that is
currently used to support something violating the spec.

Author: aelovikov-intel

sycl/include/sycl/detail/is_device_copyable.hpp

@@ -31,6 +31,8 @@ inline namespace _V1 {
 template <typename T> struct is_device_copyable;
 
 namespace detail {
+template <typename... T> struct tuple;
+
 template <typename T, typename = void>
 struct is_device_copyable_impl : std::is_trivially_copyable<T> {};
 
@@ -70,6 +72,10 @@ template <typename... Ts>
 struct is_device_copyable<std::tuple<Ts...>>
     : std::bool_constant<(... && is_device_copyable<Ts>::value)> {};
 
+template <typename... Ts>
+struct is_device_copyable<sycl::detail::tuple<Ts...>>
+    : std::bool_constant<(... && is_device_copyable<Ts>::value)> {};
+
 // std::variant<Ts...> is implicitly device copyable type if each type T of
 // Ts... is device copyable.
 template <typename... Ts>
@@ -83,31 +89,14 @@ struct is_device_copyable<T[N]> : is_device_copyable<T> {};
 template <typename T>
 inline constexpr bool is_device_copyable_v = is_device_copyable<T>::value;
 namespace detail {
-template <typename T, typename = void>
-struct IsDeprecatedDeviceCopyable : std::false_type {};
-
-// TODO: using C++ attribute [[deprecated]] or the macro __SYCL2020_DEPRECATED
-// does not produce expected warning message for the type 'T'.
-template <typename T>
-struct __SYCL2020_DEPRECATED("This type isn't device copyable in SYCL 2020")
-    IsDeprecatedDeviceCopyable<
-        T, std::enable_if_t<std::is_trivially_copy_constructible_v<T> &&
-                            std::is_trivially_destructible_v<T> &&
-                            !is_device_copyable_v<T>>> : std::true_type {};
-
-template <typename T, int N>
-struct __SYCL2020_DEPRECATED("This type isn't device copyable in SYCL 2020")
-    IsDeprecatedDeviceCopyable<T[N]> : IsDeprecatedDeviceCopyable<T> {};
-
 #ifdef __SYCL_DEVICE_ONLY__
 // Checks that the fields of the type T with indices 0 to (NumFieldsToCheck -
 // 1) are device copyable.
 template <typename T, unsigned NumFieldsToCheck>
 struct CheckFieldsAreDeviceCopyable
     : CheckFieldsAreDeviceCopyable<T, NumFieldsToCheck - 1> {
   using FieldT = decltype(__builtin_field_type(T, NumFieldsToCheck - 1));
-  static_assert(is_device_copyable_v<FieldT> ||
-                    detail::IsDeprecatedDeviceCopyable<FieldT>::value,
+  static_assert(is_device_copyable_v<FieldT>,
                 "The specified type is not device copyable");
 };
 
@@ -119,8 +108,7 @@ template <typename T, unsigned NumBasesToCheck>
 struct CheckBasesAreDeviceCopyable
     : CheckBasesAreDeviceCopyable<T, NumBasesToCheck - 1> {
   using BaseT = decltype(__builtin_base_type(T, NumBasesToCheck - 1));
-  static_assert(is_device_copyable_v<BaseT> ||
-                    detail::IsDeprecatedDeviceCopyable<BaseT>::value,
+  static_assert(is_device_copyable_v<BaseT>,
                 "The specified type is not device copyable");
 };
 

sycl/include/sycl/reduction.hpp

@@ -389,7 +389,7 @@ class ReductionIdentityContainer<
   static constexpr bool has_identity = true;
 
   ReductionIdentityContainer(const T &) {}
-  ReductionIdentityContainer() {}
+  ReductionIdentityContainer() = default;
 
   /// Returns the statically known identity value.
   static constexpr T getIdentity() {
@@ -407,6 +407,10 @@ class ReductionIdentityContainer<
 
   ReductionIdentityContainer(const T &Identity) : MIdentity(Identity) {}
 
+  // Make it trivially copyable (need at least on of the special member
+  // functions):
+  ReductionIdentityContainer(const ReductionIdentityContainer &) = default;
+
   /// Returns the identity value given by user.
   T getIdentity() const { return MIdentity; }
 
@@ -2334,6 +2338,10 @@ void reduCGFuncMulti(handler &CGH, KernelType KernelFunc,
                                          reduction::strategy::multi,
                                          decltype(KernelTag)>;
 
+    static_assert(is_device_copyable_v<decltype(IdentitiesTuple)>);
+    static_assert(is_device_copyable_v<decltype(BOPsTuple)>);
+    static_assert(is_device_copyable_v<decltype(InitToIdentityProps)>);
+
     CGH.parallel_for<Name>(Range, Properties, [=](nd_item<Dims> NDIt) {
       // We can deduce IsOneWG from the tag type.
       constexpr bool IsOneWG =

sycl/test/basic_tests/is_device_copyable.cpp

@@ -25,14 +25,6 @@ struct BCopyable {
   BCopyable(const BCopyable &x) : i(x.i) {}
 };
 
-// Not trivially copyable, but trivially copy constructible/destructible.
-// Such types are passed to kernels to stay compatible with deprecated
-// sycl 1.2.1 rules.
-struct C : A {
-  const A C2;
-  C() : A{0}, C2{2} {}
-};
-
 // Not copyable type, but it will be declared as device copyable.
 struct DCopyable {
   int i;
@@ -67,7 +59,6 @@ void test() {
   A IamGood;
   IamGood.i = 0;
   BCopyable IamBadButCopyable(1);
-  C IamAlsoGood;
   DCopyable IamAlsoBadButCopyable{0};
   marray<int, 5> MarrayForCopyableIsCopyable(0);
   range<2> Range{1,2};
@@ -78,7 +69,6 @@ void test() {
     int A = IamGood.i;
     int B = IamBadButCopyable.i;
     int C = IamAlsoBadButCopyable.i;
-    int D = IamAlsoGood.i;
     int E = MarrayForCopyableIsCopyable[0];
     int F = Range[1];
     int G = Id[2];