[libc++] cv-qualified types in atomic and atomic_ref (P3323R1)

libcxx/docs/ReleaseNotes/21.rst

@@ -45,6 +45,7 @@ Implemented Papers
 - P2562R1: ``constexpr`` Stable Sorting (`Github <https://github.com/llvm/llvm-project/issues/105360>`__)
 - P1222R4: A Standard ``flat_set`` is partially implemented and ``flat_set`` is provided (`Github <https://github.com/llvm/llvm-project/issues/105193>`__)
 - P0472R3: Put std::monostate in <utility> (`Github <https://github.com/llvm/llvm-project/issues/127874>`__)
+- P3323R1: cv-qualified types in ``atomic`` and ``atomic_ref`` (`Github <https://github.com/llvm/llvm-project/issues/118378>`__)
 
 Improvements and New Features
 -----------------------------

libcxx/docs/Status/Cxx2cPapers.csv

@@ -86,7 +86,7 @@
 "`P3050R2 <https://wg21.link/P3050R2>`__","Fix C++26 by optimizing ``linalg::conjugated`` for noncomplex value types","2024-11 (Wrocław)","","",""
 "`P3396R1 <https://wg21.link/P3396R1>`__","``std::execution`` wording fixes","2024-11 (Wrocław)","","",""
 "`P2835R7 <https://wg21.link/P2835R7>`__","Expose ``std::atomic_ref``'s object address","2024-11 (Wrocław)","","",""
-"`P3323R1 <https://wg21.link/P3323R1>`__","cv-qualified types in ``atomic`` and ``atomic_ref``","2024-11 (Wrocław)","","",""
+"`P3323R1 <https://wg21.link/P3323R1>`__","cv-qualified types in ``atomic`` and ``atomic_ref``","2024-11 (Wrocław)","|Complete|","21","Implemented as DR against C++20."
 "`P3508R0 <https://wg21.link/P3508R0>`__","Wording for ""constexpr for specialized memory algorithms""","2024-11 (Wrocław)","","",""
 "`P3369R0 <https://wg21.link/P3369R0>`__","constexpr for ``uninitialized_default_construct``","2024-11 (Wrocław)","","",""
 "`P3370R1 <https://wg21.link/P3370R1>`__","Add new library headers from C23","2024-11 (Wrocław)","","",""

libcxx/include/__atomic/support.h

@@ -10,7 +10,9 @@
 #define _LIBCPP___ATOMIC_SUPPORT_H
 
 #include <__config>
+#include <__type_traits/is_const.h>
 #include <__type_traits/is_trivially_copyable.h>
+#include <__type_traits/is_volatile.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
@@ -114,6 +116,8 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 template <typename _Tp, typename _Base = __cxx_atomic_base_impl<_Tp> >
 struct __cxx_atomic_impl : public _Base {
   static_assert(is_trivially_copyable<_Tp>::value, "std::atomic<T> requires that 'T' be a trivially copyable type");
+  static_assert(!is_const<_Tp>::value && !is_volatile<_Tp>::value,
+                "std::atomic<T> requires that 'T' be a cv-unqualified type");
 
   _LIBCPP_HIDE_FROM_ABI __cxx_atomic_impl() _NOEXCEPT = default;
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR explicit __cxx_atomic_impl(_Tp __value) _NOEXCEPT : _Base(__value) {}

libcxx/test/std/atomics/atomics.ref/assign.pass.cpp

@@ -23,29 +23,50 @@
 template <typename T>
 struct TestAssign {
   void operator()() const {
-    {
-      T x(T(1));
-      std::atomic_ref<T> const a(x);
+    using Unqualified = std::remove_cv_t<T>;
+    static_assert(std::is_assignable_v<std::atomic_ref<T>, Unqualified> == !std::is_const_v<T>);
 
-      std::same_as<T> decltype(auto) y = (a = T(2));
-      assert(y == T(2));
-      assert(x == T(2));
+    if constexpr (!std::is_const_v<T>) {
+      {
+        T x(Unqualified(1));
+        std::atomic_ref<T> const a(x);
 
-      ASSERT_NOEXCEPT(a = T(0));
-      static_assert(std::is_nothrow_assignable_v<std::atomic_ref<T>, T>);
+        std::same_as<Unqualified> decltype(auto) y = (a = Unqualified(2));
+        assert(y == Unqualified(2));
+        assert(const_cast<Unqualified const&>(x) == Unqualified(2));
 
-      static_assert(!std::is_copy_assignable_v<std::atomic_ref<T>>);
-    }
+        ASSERT_NOEXCEPT(a = Unqualified(0));
+        static_assert(std::is_nothrow_assignable_v<std::atomic_ref<T>, Unqualified>);
+        static_assert(!std::is_copy_assignable_v<std::atomic_ref<T>>);
+      }
 
-    {
-      auto assign = [](std::atomic_ref<T> const& y, T, T new_val) { y = new_val; };
-      auto load   = [](std::atomic_ref<T> const& y) { return y.load(); };
-      test_seq_cst<T>(assign, load);
+      {
+        auto assign = [](std::atomic_ref<T> const& y, T const&, T const& new_val) {
+          y = const_cast<Unqualified const&>(new_val);
+        };
+        auto load = [](std::atomic_ref<T> const& y) { return y.load(); };
+        test_seq_cst<T>(assign, load);
+      }
     }
   }
 };
 
+template <template <class...> class F>
+struct CallWithCVQualifiers {
+  template <class T>
+  struct apply {
+    void operator()() const {
+      F<T>()();
+      F<T const>()();
+      if constexpr (std::atomic_ref<T>::is_always_lock_free) {
+        F<T volatile>()();
+        F<T const volatile>()();
+      }
+    }
+  };
+};
+
 int main(int, char**) {
-  TestEachAtomicType<TestAssign>()();
+  TestEachAtomicType<CallWithCVQualifiers<TestAssign>::apply>()();
   return 0;
 }