From 3aabd2640386849134d54f8021d1b74dfb5932ea Mon Sep 17 00:00:00 2001
From: AidanBeltonS <87009434+AidanBeltonS@users.noreply.github.com>
Date: Mon, 17 Oct 2022 12:04:24 +0100
Subject: [PATCH] [SYCL] Stop reinterpret from changing buffer_allocator type
 to const (#6769)

This PR prevents the `buffer_allocator` from being rebound to a const
type. Currently when a `buffer` is reinterpreted from type `T` to type
`const T` the `buffer_allocator` type is also changed to `const T`. This
does not agree with the SYCL spec which states "A buffer of data type
const T uses buffer_allocator<T> by default."

This PR also adds a compile time test which validates the returned type.
---
 sycl/include/sycl/buffer.hpp                  | 12 ++--
 .../basic_tests/buffer/buffer_reinterpret.cpp | 70 +++++++++++++++++++
 2 files changed, 76 insertions(+), 6 deletions(-)
 create mode 100644 sycl/test/basic_tests/buffer/buffer_reinterpret.cpp

diff --git a/sycl/include/sycl/buffer.hpp b/sycl/include/sycl/buffer.hpp
index 3225f7827737c..ffcfcc9802677 100644
--- a/sycl/include/sycl/buffer.hpp
+++ b/sycl/include/sycl/buffer.hpp
@@ -627,7 +627,7 @@ class buffer : public detail::buffer_plain {
   template <typename ReinterpretT, int ReinterpretDim>
   buffer<ReinterpretT, ReinterpretDim,
          typename std::allocator_traits<AllocatorT>::template rebind_alloc<
-             ReinterpretT>>
+             std::remove_const_t<ReinterpretT>>>
   reinterpret(range<ReinterpretDim> reinterpretRange) const {
     if (sizeof(ReinterpretT) * reinterpretRange.size() != byte_size())
       throw sycl::invalid_object_error(
@@ -637,8 +637,8 @@ class buffer : public detail::buffer_plain {
           PI_ERROR_INVALID_VALUE);
 
     return buffer<ReinterpretT, ReinterpretDim,
-                  typename std::allocator_traits<
-                      AllocatorT>::template rebind_alloc<ReinterpretT>>(
+                  typename std::allocator_traits<AllocatorT>::
+                      template rebind_alloc<std::remove_const_t<ReinterpretT>>>(
         impl, reinterpretRange, OffsetInBytes, IsSubBuffer);
   }
 
@@ -647,11 +647,11 @@ class buffer : public detail::buffer_plain {
       (sizeof(ReinterpretT) == sizeof(T)) && (dimensions == ReinterpretDim),
       buffer<ReinterpretT, ReinterpretDim,
              typename std::allocator_traits<AllocatorT>::template rebind_alloc<
-                 ReinterpretT>>>::type
+                 std::remove_const_t<ReinterpretT>>>>::type
   reinterpret() const {
     return buffer<ReinterpretT, ReinterpretDim,
-                  typename std::allocator_traits<
-                      AllocatorT>::template rebind_alloc<ReinterpretT>>(
+                  typename std::allocator_traits<AllocatorT>::
+                      template rebind_alloc<std::remove_const_t<ReinterpretT>>>(
         impl, get_range(), OffsetInBytes, IsSubBuffer);
   }
 
diff --git a/sycl/test/basic_tests/buffer/buffer_reinterpret.cpp b/sycl/test/basic_tests/buffer/buffer_reinterpret.cpp
new file mode 100644
index 0000000000000..c6a12538bbb05
--- /dev/null
+++ b/sycl/test/basic_tests/buffer/buffer_reinterpret.cpp
@@ -0,0 +1,70 @@
+// RUN: %clangxx -fsycl -fsyntax-only %s
+
+#include <sycl/sycl.hpp>
+
+template <int Dimensions> sycl::range<Dimensions> create_range() {
+  return sycl::range<Dimensions>(1);
+}
+
+template <> sycl::range<2> create_range() { return sycl::range<2>(1, 1); }
+
+template <> sycl::range<3> create_range() { return sycl::range<3>(1, 1, 1); }
+
+// Compile only test to check that buffer_allocator type does not get
+// reinterpreted with const keyworkd
+template <typename T, int Dimensions,
+          typename Allocator = sycl::buffer_allocator<T>>
+void test_buffer_const_reinterpret() {
+  sycl::buffer<T, Dimensions, Allocator> buff(create_range<Dimensions>());
+  sycl::buffer<T const, Dimensions, Allocator> const_buff(
+      create_range<Dimensions>());
+
+  auto reinterpret_buff = buff.template reinterpret<T const, Dimensions>(
+      create_range<Dimensions>());
+
+  static_assert(
+      std::is_same_v<decltype(const_buff), decltype(reinterpret_buff)>);
+}
+
+struct my_struct {
+  int my_int = 0;
+  float my_float = 0;
+  double my_double = 0;
+};
+
+int main() {
+  test_buffer_const_reinterpret<short, 1>();
+  test_buffer_const_reinterpret<int, 1>();
+  test_buffer_const_reinterpret<long, 1>();
+  test_buffer_const_reinterpret<unsigned short, 1>();
+  test_buffer_const_reinterpret<unsigned int, 1>();
+  test_buffer_const_reinterpret<unsigned long, 1>();
+  test_buffer_const_reinterpret<sycl::half, 1>();
+  test_buffer_const_reinterpret<float, 1>();
+  test_buffer_const_reinterpret<double, 1>();
+  test_buffer_const_reinterpret<my_struct, 1>();
+
+  test_buffer_const_reinterpret<short, 2>();
+  test_buffer_const_reinterpret<int, 2>();
+  test_buffer_const_reinterpret<long, 2>();
+  test_buffer_const_reinterpret<unsigned short, 2>();
+  test_buffer_const_reinterpret<unsigned int, 2>();
+  test_buffer_const_reinterpret<unsigned long, 2>();
+  test_buffer_const_reinterpret<sycl::half, 2>();
+  test_buffer_const_reinterpret<float, 2>();
+  test_buffer_const_reinterpret<double, 2>();
+  test_buffer_const_reinterpret<my_struct, 2>();
+
+  test_buffer_const_reinterpret<short, 3>();
+  test_buffer_const_reinterpret<int, 3>();
+  test_buffer_const_reinterpret<long, 3>();
+  test_buffer_const_reinterpret<unsigned short, 3>();
+  test_buffer_const_reinterpret<unsigned int, 3>();
+  test_buffer_const_reinterpret<unsigned long, 3>();
+  test_buffer_const_reinterpret<sycl::half, 3>();
+  test_buffer_const_reinterpret<float, 3>();
+  test_buffer_const_reinterpret<double, 3>();
+  test_buffer_const_reinterpret<my_struct, 3>();
+
+  return 0;
+}