[libcxx-commits] [libcxx] [libc++] cv-qualified types in atomic and atomic_ref (P3323R1) (PR #121414)

[Louis Dionne via libcxx-commits]

================
@@ -20,26 +20,42 @@
 #include "test_helper.h"
 #include "test_macros.h"
 
-template <typename T>
+template <typename U>
----------------
ldionne wrote:

I would suggest the following pattern for the tests:

```c++
template <typename T>
struct TestAssign {
  void operator()() const {
    static_assert(std::is_assignable_v<std::atomic_ref<T>, T> == !std::is_const_v<T>);

    using Unqualified = std::remove_cv_t<T>;
    if constexpr (!std::is_const_v<T>) {
        {
            T x(Unqualified(1));
            std::atomic_ref<T> const a(x);

            std::same_as<Unqualified> decltype(auto) y = (a = Unqualified(2));
            assert(y == Unqualified(2));
            assert(Unqualified(x) == Unqualified(2));

            ASSERT_NOEXCEPT(a = Unqualified(0));
            static_assert(std::is_nothrow_assignable_v<std::atomic_ref<T>, T>);
            static_assert(!std::is_copy_assignable_v<std::atomic_ref<T>>);
        }

        {
            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>();
            F<T volatile>();
            F<T const volatile>();
        }
    };
};

int main() {
    TestEachAtomicType<CallWithCVQualifiers<TestAssign>::apply>()();
}

```

https://github.com/llvm/llvm-project/pull/121414