[libc++][span] LWG4243: as_bytes/as_writable_bytes is broken with span<volatile T> (llvm#200993)

Closes llvm#171317

Author: eiytoq

libcxx/docs/Status/Cxx2cIssues.csv

@@ -157,7 +157,7 @@
 "`LWG4137 <https://wg21.link/LWG4137>`__","Fix *Mandates*, *Preconditions*, and *Complexity* elements of [linalg] algorithms","2025-11 (Kona)","","","`#171313 <https://github.com/llvm/llvm-project/issues/171313>`__",""
 "`LWG4166 <https://wg21.link/LWG4166>`__","``concat_view::end()`` should be more constrained in order to support noncopyable iterators","2025-11 (Kona)","|Complete|","23","`#171314 <https://github.com/llvm/llvm-project/issues/171314>`__",""
 "`LWG4230 <https://wg21.link/LWG4230>`__","``simd<complex>::real/imag`` is overconstrained","2025-11 (Kona)","","","`#171316 <https://github.com/llvm/llvm-project/issues/171316>`__",""
-"`LWG4243 <https://wg21.link/LWG4243>`__","``as_bytes``/``as_writable_bytes`` is broken with ``span<volatile T>``","2025-11 (Kona)","","","`#171317 <https://github.com/llvm/llvm-project/issues/171317>`__",""
+"`LWG4243 <https://wg21.link/LWG4243>`__","``as_bytes``/``as_writable_bytes`` is broken with ``span<volatile T>``","2025-11 (Kona)","|Complete|","23","`#171317 <https://github.com/llvm/llvm-project/issues/171317>`__",""
 "`LWG4251 <https://wg21.link/LWG4251>`__","Move assignment for ``indirect`` unnecessarily requires copy construction","2025-11 (Kona)","","","`#171318 <https://github.com/llvm/llvm-project/issues/171318>`__",""
 "`LWG4253 <https://wg21.link/LWG4253>`__","``basic_const_iterator`` should provide ``iterator_type``","2025-11 (Kona)","","","`#171319 <https://github.com/llvm/llvm-project/issues/171319>`__",""
 "`LWG4255 <https://wg21.link/LWG4255>`__","``move_only_function`` constructor should recognize empty ``copyable_function``\s","2025-11 (Kona)","","","`#171320 <https://github.com/llvm/llvm-project/issues/171320>`__",""

libcxx/include/span

@@ -172,6 +172,7 @@ template<class R>
 #  include <__type_traits/is_convertible.h>
 #  include <__type_traits/is_integral.h>
 #  include <__type_traits/is_same.h>
+#  include <__type_traits/is_volatile.h>
 #  include <__type_traits/remove_const.h>
 #  include <__type_traits/remove_cv.h>
 #  include <__type_traits/remove_cvref.h>
@@ -585,12 +586,13 @@ inline constexpr bool ranges::enable_view<span<_ElementType, _Extent>> = true;
 
 //  as_bytes & as_writable_bytes
 template <class _Tp, size_t _Extent>
+  requires(!is_volatile_v<_Tp>)
 [[nodiscard]] _LIBCPP_HIDE_FROM_ABI auto as_bytes(span<_Tp, _Extent> __s) noexcept {
   return __s.__as_bytes();
 }
 
 template <class _Tp, size_t _Extent>
-  requires(!is_const_v<_Tp>)
+  requires(!is_const_v<_Tp> && !is_volatile_v<_Tp>)
 [[nodiscard]] _LIBCPP_HIDE_FROM_ABI auto as_writable_bytes(span<_Tp, _Extent> __s) noexcept {
   return __s.__as_writable_bytes();
 }

libcxx/test/std/containers/views/views.span/span.objectrep/as_bytes.pass.cpp

@@ -9,12 +9,12 @@
 
 // <span>
 
-// template <class ElementType, size_t Extent>
-//     span<const byte,
-//          Extent == dynamic_extent
-//              ? dynamic_extent
-//              : sizeof(ElementType) * Extent>
+// template<class ElementType, size_t Extent>
+//   span<const byte, Extent == dynamic_extent ? dynamic_extent : sizeof(ElementType) * Extent>
 //     as_bytes(span<ElementType, Extent> s) noexcept;
+//
+// Constraints:
+//   is_volatile_v<ElementType> is false.
 
 #include <cassert>
 #include <cstddef>
@@ -23,6 +23,9 @@
 
 #include "test_macros.h"
 
+template <class T, std::size_t Extent = std::dynamic_extent>
+concept hasAsBytes = requires(std::span<T, Extent> s) { std::as_bytes(s); };
+
 template <typename Span>
 void testRuntimeSpan(Span sp) {
   ASSERT_NOEXCEPT(std::as_bytes(sp));
@@ -43,7 +46,59 @@ void testRuntimeSpan(Span sp) {
 struct A {};
 int iArr2[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
 
+void test_constraints() {
+  static_assert(hasAsBytes<int>);
+  static_assert(hasAsBytes<long>);
+  static_assert(hasAsBytes<double>);
+  static_assert(hasAsBytes<A>);
+  static_assert(hasAsBytes<std::string>);
+
+  static_assert(hasAsBytes<const int>);
+  static_assert(hasAsBytes<const long>);
+  static_assert(hasAsBytes<const double>);
+  static_assert(hasAsBytes<const A>);
+  static_assert(hasAsBytes<const std::string>);
+
+  static_assert(!hasAsBytes<volatile int>);
+  static_assert(!hasAsBytes<volatile long>);
+  static_assert(!hasAsBytes<volatile double>);
+  static_assert(!hasAsBytes<volatile A>);
+  static_assert(!hasAsBytes<volatile std::string>);
+
+  static_assert(!hasAsBytes<const volatile int>);
+  static_assert(!hasAsBytes<const volatile long>);
+  static_assert(!hasAsBytes<const volatile double>);
+  static_assert(!hasAsBytes<const volatile A>);
+  static_assert(!hasAsBytes<const volatile std::string>);
+
+  static_assert(hasAsBytes<int, 0>);
+  static_assert(hasAsBytes<long, 0>);
+  static_assert(hasAsBytes<double, 0>);
+  static_assert(hasAsBytes<A, 0>);
+  static_assert(hasAsBytes<std::string, 0>);
+
+  static_assert(hasAsBytes<const int, 0>);
+  static_assert(hasAsBytes<const long, 0>);
+  static_assert(hasAsBytes<const double, 0>);
+  static_assert(hasAsBytes<const A, 0>);
+  static_assert(hasAsBytes<const std::string, 0>);
+
+  static_assert(!hasAsBytes<volatile int, 0>);
+  static_assert(!hasAsBytes<volatile long, 0>);
+  static_assert(!hasAsBytes<volatile double, 0>);
+  static_assert(!hasAsBytes<volatile A, 0>);
+  static_assert(!hasAsBytes<volatile std::string, 0>);
+
+  static_assert(!hasAsBytes<const volatile int, 0>);
+  static_assert(!hasAsBytes<const volatile long, 0>);
+  static_assert(!hasAsBytes<const volatile double, 0>);
+  static_assert(!hasAsBytes<const volatile A, 0>);
+  static_assert(!hasAsBytes<const volatile std::string, 0>);
+}
+
 int main(int, char**) {
+  test_constraints();
+
   testRuntimeSpan(std::span<int>());
   testRuntimeSpan(std::span<long>());
   testRuntimeSpan(std::span<double>());

libcxx/test/std/containers/views/views.span/span.objectrep/as_writable_bytes.pass.cpp

@@ -9,12 +9,12 @@
 
 // <span>
 
-// template <class ElementType, size_t Extent>
-//     span<byte,
-//          Extent == dynamic_extent
-//              ? dynamic_extent
-//              : sizeof(ElementType) * Extent>
+// template<class ElementType, size_t Extent>
+//   span<byte, Extent == dynamic_extent ? dynamic_extent : sizeof(ElementType) * Extent>
 //     as_writable_bytes(span<ElementType, Extent> s) noexcept;
+//
+// Constraints:
+//   is_const_v<ElementType> is false and is_volatile_v<ElementType> is false.
 
 #include <cassert>
 #include <cstddef>
@@ -23,6 +23,9 @@
 
 #include "test_macros.h"
 
+template <class T, std::size_t Extent = std::dynamic_extent>
+concept hasAsWritableBytes = requires(std::span<T, Extent> s) { std::as_writable_bytes(s); };
+
 template <typename Span>
 void testRuntimeSpan(Span sp) {
   ASSERT_NOEXCEPT(std::as_writable_bytes(sp));
@@ -43,7 +46,59 @@ void testRuntimeSpan(Span sp) {
 struct A {};
 int iArr2[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
 
+void test_constraints() {
+  static_assert(hasAsWritableBytes<int>);
+  static_assert(hasAsWritableBytes<long>);
+  static_assert(hasAsWritableBytes<double>);
+  static_assert(hasAsWritableBytes<A>);
+  static_assert(hasAsWritableBytes<std::string>);
+
+  static_assert(!hasAsWritableBytes<const int>);
+  static_assert(!hasAsWritableBytes<const long>);
+  static_assert(!hasAsWritableBytes<const double>);
+  static_assert(!hasAsWritableBytes<const A>);
+  static_assert(!hasAsWritableBytes<const std::string>);
+
+  static_assert(!hasAsWritableBytes<volatile int>);
+  static_assert(!hasAsWritableBytes<volatile long>);
+  static_assert(!hasAsWritableBytes<volatile double>);
+  static_assert(!hasAsWritableBytes<volatile A>);
+  static_assert(!hasAsWritableBytes<volatile std::string>);
+
+  static_assert(!hasAsWritableBytes<const volatile int>);
+  static_assert(!hasAsWritableBytes<const volatile long>);
+  static_assert(!hasAsWritableBytes<const volatile double>);
+  static_assert(!hasAsWritableBytes<const volatile A>);
+  static_assert(!hasAsWritableBytes<const volatile std::string>);
+
+  static_assert(hasAsWritableBytes<int, 0>);
+  static_assert(hasAsWritableBytes<long, 0>);
+  static_assert(hasAsWritableBytes<double, 0>);
+  static_assert(hasAsWritableBytes<A, 0>);
+  static_assert(hasAsWritableBytes<std::string, 0>);
+
+  static_assert(!hasAsWritableBytes<const int, 0>);
+  static_assert(!hasAsWritableBytes<const long, 0>);
+  static_assert(!hasAsWritableBytes<const double, 0>);
+  static_assert(!hasAsWritableBytes<const A, 0>);
+  static_assert(!hasAsWritableBytes<const std::string, 0>);
+
+  static_assert(!hasAsWritableBytes<volatile int, 0>);
+  static_assert(!hasAsWritableBytes<volatile long, 0>);
+  static_assert(!hasAsWritableBytes<volatile double, 0>);
+  static_assert(!hasAsWritableBytes<volatile A, 0>);
+  static_assert(!hasAsWritableBytes<volatile std::string, 0>);
+
+  static_assert(!hasAsWritableBytes<const volatile int, 0>);
+  static_assert(!hasAsWritableBytes<const volatile long, 0>);
+  static_assert(!hasAsWritableBytes<const volatile double, 0>);
+  static_assert(!hasAsWritableBytes<const volatile A, 0>);
+  static_assert(!hasAsWritableBytes<const volatile std::string, 0>);
+}
+
 int main(int, char**) {
+  test_constraints();
+
   testRuntimeSpan(std::span<int>());
   testRuntimeSpan(std::span<long>());
   testRuntimeSpan(std::span<double>());