[SYCL] Add a nice error message to sycl::buffer to std::string (#4973)

Since sycl::vec is not a trivially copyable class, even though we
have defined a specialization for sycl::is_device_copyable template
for the sycl::vec class itself, it doesn't make any classes that have
members of the sycl::vec type device copyable since those classes aren't
trivially copyable yet. For example, a class from SYCL-CTS:

template
struct image_accessor_failure_item {
bool triggered;
T value;
T expected;

image_accessor_failure_item() :
triggered(false),
value(0),
expected(0) {}
};

is not trivially copyable since it has two fields: value and expected of
type sycl::vec; therefore, the class is not device copyable and a
compilation error occurs when a sycl::buffer is created for this class
instances.

The regression makes us to revert the commit and delay adding the general
check until the sycl::vec class is modified to be trivially copyable. Instead a particular
check for the std::string class only was added.

Author: Pavel Samolysov

sycl/include/CL/sycl/buffer.hpp

@@ -14,7 +14,6 @@
 #include <CL/sycl/exception.hpp>
 #include <CL/sycl/property_list.hpp>
 #include <CL/sycl/stl.hpp>
-#include <CL/sycl/types.hpp>
 #include <sycl/ext/oneapi/accessor_property_list.hpp>
 
 __SYCL_INLINE_NAMESPACE(cl) {
@@ -45,9 +44,10 @@ template <typename T, int dimensions = 1,
           typename __Enabled = typename detail::enable_if_t<(dimensions > 0) &&
                                                             (dimensions <= 3)>>
 class buffer {
-  static_assert(
-      is_device_copyable<T>::value,
-      "The underlying data type of a buffer 'T' must be device copyable");
+  // TODO check is_device_copyable<T>::value after converting sycl::vec into a
+  // trivially copyable class.
+  static_assert(!std::is_same<T, std::string>::value,
+                "'std::string' is not a device copyable type");
 
 public:
   using value_type = T;

sycl/include/CL/sycl/types.hpp

@@ -2423,13 +2423,6 @@ struct is_device_copyable<
                                          !std::is_trivially_copyable<T>::value>>
     : std::true_type {};
 
-// vec is device copyable on host, on device vec is trivially copyable
-// and therefore is device copyable too.
-#ifndef __SYCL_DEVICE_ONLY__
-template <typename T, int N>
-struct is_device_copyable<sycl::vec<T, N>> : std::true_type {};
-#endif
-
 namespace detail {
 template <typename T, typename = void>
 struct IsDeprecatedDeviceCopyable : std::false_type {};

sycl/test/basic_tests/buffer/buffer_for_not_device_copyable.cpp

@@ -13,10 +13,7 @@ int main() {
   static_assert(!is_device_copyable_v<std::string>);
   std::vector<std::string> sv{"hello", "sycl", "world"};
   buffer b2(sv.data(), range<1>(3));
-  //expected-error@CL/sycl/buffer.hpp:* {{"The underlying data type of a buffer 'T' must be device copyable"}}
+  //expected-error@CL/sycl/buffer.hpp:* {{"'std::string' is not a device copyable type"}}
 
-  static_assert(is_device_copyable<sycl::vec<int, 4>>::value);
-  vec<int, 4> iVec;
-  buffer b3(&iVec, range<1>(1));
   return 0;
 }