[libc++] LWG3745 noexcept for atomic_wait.

[Mordante]

Summary

The noexcept was already implemented, this only updates the synposis and
adds tests to validate that the functions are noexcept.

This implements:

• LWG3745 std::atomic_wait and its friends lack noexcept

[philnik]

LGTM with CI passing.

libcxx/docs/Status/Cxx2bIssues.csv

 "`3646 <https://wg21.link/LWG3646>`__","``std::ranges::view_interface::size`` returns a signed type","November 2022","|Complete|","16.0","|ranges|"
 "`3677 <https://wg21.link/LWG3677>`__","Is a cv-qualified ``pair`` specially handled in uses-allocator construction?", "November 2022","","",""
 "`3717 <https://wg21.link/LWG3717>`__","``common_view::end`` should improve ``random_access_range`` case", "November 2022","","","|ranges|"
 "`3732 <https://wg21.link/LWG3732>`__","``prepend_range`` and ``append_range`` can't be amortized constant time", "November 2022","|Nothing to do|","","|ranges|"
 "`3736 <https://wg21.link/LWG3736>`__","``move_iterator`` missing ``disable_sized_sentinel_for`` specialization", "November 2022","","","|ranges|"
 "`3737 <https://wg21.link/LWG3737>`__","``take_view::sentinel`` should provide ``operator-``", "November 2022","","","|ranges|"
 "`3738 <https://wg21.link/LWG3738>`__","Missing preconditions for ``take_view`` constructor", "November 2022","","","|ranges|"
 "`3743 <https://wg21.link/LWG3743>`__","``ranges::to``'s reserve may be ill-formed", "November 2022","","","|ranges|"
-"`3745 <https://wg21.link/LWG3745>`__","``std::atomic_wait`` and its friends lack ``noexcept``", "November 2022","","",""
+"`3745 <https://wg21.link/LWG3745>`__","``std::atomic_wait`` and its friends lack ``noexcept``", "November 2022","|Complete|","16.0",""
 "`3746 <https://wg21.link/LWG3746>`__","``optional``'s spaceship with ``U`` with a type derived from optional causes infinite constraint meta-recursion", "November 2022","","","|spaceship|"
 "`3747 <https://wg21.link/LWG3747>`__","``ranges::uninitialized_copy_n``, ``ranges::uninitialized_move_n``, and ``ranges::destroy_n`` should use ``std::move``", "November 2022","","","|ranges|"
 "`3750 <https://wg21.link/LWG3750>`__","Too many papers bump ``__cpp_lib_format``", "November 2022","","","|format|"
 "`3751 <https://wg21.link/LWG3751>`__","Missing feature macro for ``flat_set``", "November 2022","","","|flat_containers|"
 "`3753 <https://wg21.link/LWG3753>`__","Clarify entity vs. freestanding entity", "November 2022","","",""
 "`3754 <https://wg21.link/LWG3754>`__","Class template expected synopsis contains declarations that do not match the detailed description", "November 2022","","",""
 "`3755 <https://wg21.link/LWG3755>`__","``tuple-for-each`` can call ``user-defined`` ``operator,``", "November 2022","","",""
 "`3757 <https://wg21.link/LWG3757>`__","What's the effect of ``std::forward_like<void>(x)``?", "November 2022","","",""

libcxx/include/atomic

 template<class T>
   T atomic_fetch_xor_explicit(volatile atomic<T>*, atomic<T>::value_type,
                               memory_order) noexcept;
 template<class T>
   T atomic_fetch_xor_explicit(atomic<T>*, atomic<T>::value_type,
                               memory_order) noexcept;
 
 template<class T>
-  void atomic_wait(const volatile atomic<T>*, atomic<T>::value_type);
+  void atomic_wait(const volatile atomic<T>*, atomic<T>::value_type) noexcept;
 template<class T>
-  void atomic_wait(const atomic<T>*, atomic<T>::value_type);
+  void atomic_wait(const atomic<T>*, atomic<T>::value_type) noexcept;
 template<class T>
   void atomic_wait_explicit(const volatile atomic<T>*, atomic<T>::value_type,
-                            memory_order);
+                            memory_order) noexcept;
 template<class T>
   void atomic_wait_explicit(const atomic<T>*, atomic<T>::value_type,
-                            memory_order);
+                            memory_order) noexcept;
 template<class T>
-  void atomic_notify_one(volatile atomic<T>*);
+  void atomic_notify_one(volatile atomic<T>*) noexcept;
 template<class T>
-  void atomic_notify_one(atomic<T>*);
+  void atomic_notify_one(atomic<T>*) noexcept;
 template<class T>
-  void atomic_notify_all(volatile atomic<T>*);
+  void atomic_notify_all(volatile atomic<T>*) noexcept;
 template<class T>
-  void atomic_notify_all(atomic<T>*);
+  void atomic_notify_all(atomic<T>*) noexcept;
 
 // Atomics for standard typedef types
 
 typedef atomic<bool>               atomic_bool;
 typedef atomic<char>               atomic_char;
 typedef atomic<signed char>        atomic_schar;
 typedef atomic<unsigned char>      atomic_uchar;
 typedef atomic<short>              atomic_short;

 }
 template <class _Tp>
 _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
 void atomic_notify_one(atomic<_Tp>* __o) _NOEXCEPT
 {
     __o->notify_one();
 }
 
-// atomic_notify_one
+// atomic_notify_all
 
 template <class _Tp>
 _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
 void atomic_notify_all(volatile atomic<_Tp>* __o) _NOEXCEPT
 {
     __o->notify_all();
 }
 template <class _Tp>

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.wait/atomic_notify_all.pass.cpp

 
 // This test requires the dylib support introduced in D68480, which shipped in macOS 11.0.
 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14|15}}
 
 // <atomic>
 
 // template<class T>
 //     void
-//     atomic_notify_all(volatile atomic<T>*);
+//     atomic_notify_all(volatile atomic<T>*) noexcept;
 //
 // template<class T>
 //     void
-//     atomic_notify_all(atomic<T>*);
+//     atomic_notify_all(atomic<T>*) noexcept;
 
 #include <atomic>
 #include <type_traits>
 #include <cassert>
 #include <thread>
 
 #include "make_test_thread.h"
 #include "test_macros.h"
 #include "atomic_helpers.h"
 
 template <class T>
 struct TestFn {
   void operator()() const {
     typedef std::atomic<T> A;
 
     {
       A a(T(1));
+      static_assert(noexcept(std::atomic_notify_all(&a)), "");
       auto f = [&]() {
         assert(std::atomic_load(&a) == T(1));
         std::atomic_wait(&a, T(1));
         assert(std::atomic_load(&a) == T(3));
       };
       std::thread t1 = support::make_test_thread(f);
       std::thread t2 = support::make_test_thread(f);
       std::this_thread::sleep_for(std::chrono::milliseconds(100));
 
       std::atomic_store(&a, T(3));
       std::atomic_notify_all(&a);
       t1.join();
       t2.join();
     }
     {
       volatile A a(T(2));
+      static_assert(noexcept(std::atomic_notify_all(&a)), "");
       auto f = [&]() {
         assert(std::atomic_load(&a) == T(2));
         std::atomic_wait(&a, T(2));
         assert(std::atomic_load(&a) == T(4));
       };
       std::thread t1 = support::make_test_thread(f);
       std::thread t2 = support::make_test_thread(f);
       std::this_thread::sleep_for(std::chrono::milliseconds(100));

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.wait/atomic_notify_one.pass.cpp

 
 // This test requires the dylib support introduced in D68480, which shipped in macOS 11.0.
 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14|15}}
 
 // <atomic>
 
 // template<class T>
 //     void
-//     atomic_notify_one(volatile atomic<T>*);
+//     atomic_notify_one(volatile atomic<T>*) noexcept;
 //
 // template<class T>
 //     void
-//     atomic_notify_one(atomic<T>*);
+//     atomic_notify_one(atomic<T>*) noexcept;
 
 #include <atomic>
 #include <type_traits>
 #include <cassert>
 #include <thread>
 
 #include "make_test_thread.h"
 #include "test_macros.h"
 #include "atomic_helpers.h"
 
 template <class T>
 struct TestFn {
   void operator()() const {
     typedef std::atomic<T> A;
 
     {
       A a(T(1));
+      static_assert(noexcept(std::atomic_notify_one(&a)), "");
       std::thread t = support::make_test_thread([&]() {
         std::atomic_store(&a, T(3));
         std::atomic_notify_one(&a);
       });
       std::atomic_wait(&a, T(1));
       assert(std::atomic_load(&a) == T(3));
       t.join();
     }
     {
       volatile A a(T(2));
+      static_assert(noexcept(std::atomic_notify_one(&a)), "");
       std::thread t = support::make_test_thread([&]() {
         std::atomic_store(&a, T(4));
         std::atomic_notify_one(&a);
       });
       std::atomic_wait(&a, T(2));
       assert(std::atomic_load(&a) == T(4));
       t.join();
     }
   }
 };
 
 int main(int, char**) {
   TestEachAtomicType<TestFn>()();
 
   return 0;
 }

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.wait/atomic_wait.pass.cpp

 
 // This test requires the dylib support introduced in D68480, which shipped in macOS 11.0.
 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14|15}}
 
 // <atomic>
 
 // template<class T>
 //     void
-//     atomic_wait(const volatile atomic<T>*, atomic<T>::value_type);
+//     atomic_wait(const volatile atomic<T>*, atomic<T>::value_type) noexcept;
 //
 // template<class T>
 //     void
-//     atomic_wait(const atomic<T>*, atomic<T>::value_type);
+//     atomic_wait(const atomic<T>*, atomic<T>::value_type) noexcept;
 
 #include <atomic>
 #include <type_traits>
 #include <cassert>
 #include <thread>
 
 #include "make_test_thread.h"
 #include "test_macros.h"
 #include "atomic_helpers.h"
 
 template <class T>
 struct TestFn {
   void operator()() const {
     typedef std::atomic<T> A;
     {
       A t(T(1));
+      static_assert(noexcept(std::atomic_wait(&t, T(0))), "");
       assert(std::atomic_load(&t) == T(1));
       std::atomic_wait(&t, T(0));
       std::thread t1 = support::make_test_thread([&]() {
         std::atomic_store(&t, T(3));
         std::atomic_notify_one(&t);
       });
       std::atomic_wait(&t, T(1));
       assert(std::atomic_load(&t) == T(3));
       t1.join();
     }
     {
       volatile A vt(T(2));
+      static_assert(noexcept(std::atomic_wait(&vt, T(0))), "");
       assert(std::atomic_load(&vt) == T(2));
       std::atomic_wait(&vt, T(1));
       std::thread t2 = support::make_test_thread([&]() {
         std::atomic_store(&vt, T(4));
         std::atomic_notify_one(&vt);
       });
       std::atomic_wait(&vt, T(2));
       assert(std::atomic_load(&vt) == T(4));

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.wait/atomic_wait_explicit.pass.cpp

 // This test requires the dylib support introduced in D68480, which shipped in macOS 11.0.
 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14|15}}
 
 // <atomic>
 
 // template<class T>
 //     void
 //     atomic_wait_explicit(const volatile atomic<T>*, atomic<T>::value_type,
-//                          memory_order);
+//                          memory_order) noexcept;
 //
 // template<class T>
 //     void
 //     atomic_wait_explicit(const volatile atomic<T>*, atomic<T>::value_type,
-//                          memory_order);
+//                          memory_order) noexcept;
 
 #include <atomic>
 #include <type_traits>
 #include <cassert>
 #include <thread>
 
 #include "make_test_thread.h"
 #include "test_macros.h"
 #include "atomic_helpers.h"
 
 template <class T>
 struct TestFn {
   void operator()() const {
     typedef std::atomic<T> A;
     {
       A t(T(1));
+      static_assert(noexcept(std::atomic_wait_explicit(&t, T(0), std::memory_order_seq_cst)), "");
       assert(std::atomic_load(&t) == T(1));
       std::atomic_wait_explicit(&t, T(0), std::memory_order_seq_cst);
       std::thread t1 = support::make_test_thread([&]() {
         std::atomic_store(&t, T(3));
         std::atomic_notify_one(&t);
       });
       std::atomic_wait_explicit(&t, T(1), std::memory_order_seq_cst);
       assert(std::atomic_load(&t) == T(3));
       t1.join();
     }
     {
       volatile A vt(T(2));
+      static_assert(noexcept(std::atomic_wait_explicit(&vt, T(0), std::memory_order_seq_cst)), "");
       assert(std::atomic_load(&vt) == T(2));
       std::atomic_wait_explicit(&vt, T(1), std::memory_order_seq_cst);
       std::thread t2 = support::make_test_thread([&]() {
         std::atomic_store(&vt, T(4));
         std::atomic_notify_one(&vt);
       });
       std::atomic_wait_explicit(&vt, T(2), std::memory_order_seq_cst);
       assert(std::atomic_load(&vt) == T(4));