Add constexpr to pair

[miscco]

I somehow missed to add the description to the PR so here it is:

This implements the changes to utility as described by the misc_constexpr paper.

While there I tried to overhaul the tests to get rid of the local classes that should be able to be replaced by the archetypes

[miscco]

Ping, a second *pair* of eyes wouldn't hurt.

I am terrible at jokes ...

[miscco]

Took the opportunity to look through this again. Mostly nits about the tests

libcxx/test/std/utilities/utility/pairs/pairs.pair/assign_rv_pair.pass.cpp

39

I believe I have to check this one here, It seems moving to ConstexprTestTypes::MoveOnly should suffice

libcxx/test/std/utilities/utility/pairs/pairs.pair/assign_rv_pair_U_V.pass.cpp

43

I am really not too happy with this dance. I guess one should add one additional section for C++20 only

libcxx/test/std/utilities/utility/pairs/pairs.pair/swap.pass.cpp

21–22

Could we remove those by the way? I do not see any use for them

[miscco]

Could someone have a look at this?

[miscco]

Updated tests

[miscco]

Missed some changes

[ldionne]

Mostly LGTM with nits.

libcxx/test/std/utilities/utility/pairs/pairs.pair/assign_rv_pair.pass.cpp

27

This isn't used.

libcxx/test/std/utilities/utility/pairs/pairs.pair/assign_rv_pair_U_V.pass.cpp

43

I think this is acceptable, we do it in a bunch of other places for testing constexpr. I do agree that something in the test runner would be better, but eh.

libcxx/test/std/utilities/utility/pairs/pairs.pair/swap.pass.cpp

21–22

Do you mean remove S altogether? It's used below.

[miscco]

libcxx/test/std/utilities/utility/pairs/pairs.pair/assign_rv_pair.pass.cpp

27

True, will remove

libcxx/test/std/utilities/utility/pairs/pairs.pair/swap.pass.cpp

21–22

I think that was from a previous revision where I did not yet removed those two lines

S * operator& () { assert(false); return this; }
S const * operator& () const { assert(false); return this; }

[miscco]

Remove the unused member function from CountAssign

[miscco]

Please use all the changes

[miscco]

Once again into the breach

[miscco]

• Fix formatting of meow.version.pass.cpp

[ldionne]

Thanks!

libcxx/docs/FeatureTestMacroTable.rst

.. table:: Current Status
     ``__cpp_lib_char8_t``                             ``201811L``      
     ------------------------------------------------- -----------------
     ``__cpp_lib_concepts``                            *unimplemented*  
     ------------------------------------------------- -----------------
     ``__cpp_lib_constexpr_misc``                      *unimplemented*  
     ------------------------------------------------- -----------------
     ``__cpp_lib_constexpr_swap_algorithms``           *unimplemented*  
     ------------------------------------------------- -----------------
+    ``__cpp_lib_constexpr_utility ``                  ``201811L``      
+    ------------------------------------------------- -----------------
     ``__cpp_lib_destroying_delete``                   ``201806L``      
     ------------------------------------------------- -----------------
     ``__cpp_lib_endian``                              ``201907L``      
     ------------------------------------------------- -----------------
     ``__cpp_lib_erase_if``                            ``202002L``      
     ------------------------------------------------- -----------------
     ``__cpp_lib_generic_unordered_lookup``            *unimplemented*  
     ------------------------------------------------- -----------------

libcxx/include/tuple

 }
 
 template <class ..._Tp, class _Alloc>
 struct _LIBCPP_TEMPLATE_VIS uses_allocator<tuple<_Tp...>, _Alloc>
     : true_type {};
 
 template <class _T1, class _T2>
 template <class... _Args1, class... _Args2, size_t ..._I1, size_t ..._I2>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 pair<_T1, _T2>::pair(piecewise_construct_t,
                      tuple<_Args1...>& __first_args, tuple<_Args2...>& __second_args,
                      __tuple_indices<_I1...>, __tuple_indices<_I2...>)
     :  first(_VSTD::forward<_Args1>(_VSTD::get<_I1>( __first_args))...),
       second(_VSTD::forward<_Args2>(_VSTD::get<_I2>(__second_args))...)
 {
 }
 

libcxx/include/utility

template<class _Tuple, _EnableB<
             _CheckTLC<_Tuple>::template __enable_implicit<_Tuple>()
     > = false>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     pair(_Tuple&& __p)
         : first(_VSTD::get<0>(_VSTD::forward<_Tuple>(__p))),
           second(_VSTD::get<1>(_VSTD::forward<_Tuple>(__p))) {}
 
     template <class... _Args1, class... _Args2>
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     pair(piecewise_construct_t __pc,
          tuple<_Args1...> __first_args, tuple<_Args2...> __second_args)
         _NOEXCEPT_((is_nothrow_constructible<first_type, _Args1...>::value &&
                     is_nothrow_constructible<second_type, _Args2...>::value))
         : pair(__pc, __first_args, __second_args,
                 typename __make_tuple_indices<sizeof...(_Args1)>::type(),
                 typename __make_tuple_indices<sizeof...(_Args2) >::type()) {}
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     pair& operator=(typename conditional<
                         is_copy_assignable<first_type>::value &&
                         is_copy_assignable<second_type>::value,
                     pair, __nat>::type const& __p)
         _NOEXCEPT_(is_nothrow_copy_assignable<first_type>::value &&
                    is_nothrow_copy_assignable<second_type>::value)
     {
         first = __p.first;
         second = __p.second;
         return *this;
     }
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     pair& operator=(typename conditional<
                         is_move_assignable<first_type>::value &&
                         is_move_assignable<second_type>::value,
                     pair, __nat>::type&& __p)
         _NOEXCEPT_(is_nothrow_move_assignable<first_type>::value &&
                    is_nothrow_move_assignable<second_type>::value)
     {
         first = _VSTD::forward<first_type>(__p.first);
         second = _VSTD::forward<second_type>(__p.second);
         return *this;
     }
 
     template <class _Tuple, _EnableB<
             _CheckTLC<_Tuple>::template __enable_assign<_Tuple>()
      > = false>
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     pair& operator=(_Tuple&& __p) {
         first = _VSTD::get<0>(_VSTD::forward<_Tuple>(__p));
         second = _VSTD::get<1>(_VSTD::forward<_Tuple>(__p));
         return *this;
     }
 #endif
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     void
     swap(pair& __p) _NOEXCEPT_(__is_nothrow_swappable<first_type>::value &&
                                __is_nothrow_swappable<second_type>::value)
     {
         using _VSTD::swap;
         swap(first,  __p.first);
         swap(second, __p.second);
     }
 private:
 
 #ifndef _LIBCPP_CXX03_LANG
     template <class... _Args1, class... _Args2, size_t... _I1, size_t... _I2>
-        _LIBCPP_INLINE_VISIBILITY
-        pair(piecewise_construct_t,
-             tuple<_Args1...>& __first_args, tuple<_Args2...>& __second_args,
-             __tuple_indices<_I1...>, __tuple_indices<_I2...>);
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 #endif
 };
 
 #ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES
 template<class _T1, class _T2>
 pair(_T1, _T2) -> pair<_T1, _T2>;
 #endif // _LIBCPP_HAS_NO_DEDUCTION_GUIDES
 

 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 bool
 operator<=(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
 {
     return !(__y < __x);
 }
 
 template <class _T1, class _T2>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 typename enable_if
 <
     __is_swappable<_T1>::value &&
     __is_swappable<_T2>::value,
     void
 >::type
 swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y)
                      _NOEXCEPT_((__is_nothrow_swappable<_T1>::value &&

libcxx/include/version

 __cpp_lib_chrono                                        201611L <chrono>
 __cpp_lib_chrono_udls                                   201304L <chrono>
 __cpp_lib_clamp                                         201603L <algorithm>
 __cpp_lib_complex_udls                                  201309L <complex>
 __cpp_lib_concepts                                      201806L <concepts>
 __cpp_lib_constexpr_misc                                201811L <array> <functional> <iterator>
                                                                 <string_view> <tuple> <utility>
 __cpp_lib_constexpr_swap_algorithms                     201806L <algorithm>
+__cpp_lib_constexpr_utility                             201811L <utility>
 __cpp_lib_destroying_delete                             201806L <new>
 __cpp_lib_enable_shared_from_this                       201603L <memory>
 __cpp_lib_endian                                        201907L <bit>
 __cpp_lib_erase_if                                      202002L <string> <deque> <forward_list>
                                                                 <list> <vector> <map>
                                                                 <set> <unordered_map> <unordered_set>
 __cpp_lib_exchange_function                             201304L <utility>
 __cpp_lib_execution                                     201603L <execution>

 // # define __cpp_lib_bind_front                           201811L
 // # define __cpp_lib_bit_cast                             201806L
 # if !defined(_LIBCPP_NO_HAS_CHAR8_T)
 #   define __cpp_lib_char8_t                            201811L
 # endif
 // # define __cpp_lib_concepts                             201806L
 // # define __cpp_lib_constexpr_misc                       201811L
 // # define __cpp_lib_constexpr_swap_algorithms            201806L
+# define __cpp_lib_constexpr_utility                    201811L
 # if _LIBCPP_STD_VER > 17 && defined(__cpp_impl_destroying_delete) && __cpp_impl_destroying_delete >= 201806L
 #   define __cpp_lib_destroying_delete                  201806L
 # endif
 # define __cpp_lib_endian                               201907L
 # define __cpp_lib_erase_if                             202002L
 // # define __cpp_lib_generic_unordered_lookup             201811L
 # define __cpp_lib_interpolate                          201902L
 # if !defined(_LIBCPP_HAS_NO_BUILTIN_IS_CONSTANT_EVALUATED)

libcxx/test/std/language.support/support.limits/support.limits.general/utility.version.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // WARNING: This test was generated by generate_feature_test_macro_components.py
 // and should not be edited manually.
 
 // <utility>
 
 // Test the feature test macros defined by <utility>
 
-/*  Constant                       Value
-    __cpp_lib_as_const             201510L [C++17]
-    __cpp_lib_constexpr_misc       201811L [C++2a]
-    __cpp_lib_exchange_function    201304L [C++14]
-    __cpp_lib_integer_sequence     201304L [C++14]
-    __cpp_lib_to_chars             201611L [C++17]
-    __cpp_lib_tuples_by_type       201304L [C++14]
+/*  Constant                        Value
+    __cpp_lib_as_const              201510L [C++17]
+    __cpp_lib_constexpr_misc        201811L [C++2a]
+    __cpp_lib_constexpr_utility     201811L [C++2a]
+    __cpp_lib_exchange_function     201304L [C++14]
+    __cpp_lib_integer_sequence      201304L [C++14]
+    __cpp_lib_to_chars              201611L [C++17]
+    __cpp_lib_tuples_by_type        201304L [C++14]
 */
 
 #include <utility>
 #include "test_macros.h"
 
 #if TEST_STD_VER < 14
 
 # ifdef __cpp_lib_as_const
 #   error "__cpp_lib_as_const should not be defined before c++17"
 # endif
 
 # ifdef __cpp_lib_constexpr_misc
 #   error "__cpp_lib_constexpr_misc should not be defined before c++2a"
 # endif
 
+# ifdef __cpp_lib_constexpr_utility 
+#   error "__cpp_lib_constexpr_utility  should not be defined before c++2a"
+# endif
+
 # ifdef __cpp_lib_exchange_function
 #   error "__cpp_lib_exchange_function should not be defined before c++14"
 # endif
 
 # ifdef __cpp_lib_integer_sequence
 #   error "__cpp_lib_integer_sequence should not be defined before c++14"
 # endif
 

 # ifdef __cpp_lib_as_const
 #   error "__cpp_lib_as_const should not be defined before c++17"
 # endif
 
 # ifdef __cpp_lib_constexpr_misc
 #   error "__cpp_lib_constexpr_misc should not be defined before c++2a"
 # endif
 
+# ifdef __cpp_lib_constexpr_utility 
+#   error "__cpp_lib_constexpr_utility  should not be defined before c++2a"
+# endif
+
 # ifndef __cpp_lib_exchange_function
 #   error "__cpp_lib_exchange_function should be defined in c++14"
 # endif
 # if __cpp_lib_exchange_function != 201304L
 #   error "__cpp_lib_exchange_function should have the value 201304L in c++14"
 # endif
 
 # ifndef __cpp_lib_integer_sequence

 # if __cpp_lib_as_const != 201510L
 #   error "__cpp_lib_as_const should have the value 201510L in c++17"
 # endif
 
 # ifdef __cpp_lib_constexpr_misc
 #   error "__cpp_lib_constexpr_misc should not be defined before c++2a"
 # endif
 
+# ifdef __cpp_lib_constexpr_utility 
+#   error "__cpp_lib_constexpr_utility  should not be defined before c++2a"
+# endif
+
 # ifndef __cpp_lib_exchange_function
 #   error "__cpp_lib_exchange_function should be defined in c++17"
 # endif
 # if __cpp_lib_exchange_function != 201304L
 #   error "__cpp_lib_exchange_function should have the value 201304L in c++17"
 # endif
 
 # ifndef __cpp_lib_integer_sequence

 #     error "__cpp_lib_constexpr_misc should have the value 201811L in c++2a"
 #   endif
 # else // _LIBCPP_VERSION
 #   ifdef __cpp_lib_constexpr_misc
 #     error "__cpp_lib_constexpr_misc should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
+# ifndef __cpp_lib_constexpr_utility 
+#   error "__cpp_lib_constexpr_utility  should be defined in c++2a"
+# endif
+# if __cpp_lib_constexpr_utility  != 201811L
+#   error "__cpp_lib_constexpr_utility  should have the value 201811L in c++2a"
+# endif
+
 # ifndef __cpp_lib_exchange_function
 #   error "__cpp_lib_exchange_function should be defined in c++2a"
 # endif
 # if __cpp_lib_exchange_function != 201304L
 #   error "__cpp_lib_exchange_function should have the value 201304L in c++2a"
 # endif
 
 # ifndef __cpp_lib_integer_sequence

libcxx/test/std/language.support/support.limits/support.limits.general/version.version.pass.cpp

/*  Constant                                       Value
     __cpp_lib_char8_t                              201811L [C++2a]
     __cpp_lib_chrono                               201611L [C++17]
     __cpp_lib_chrono_udls                          201304L [C++14]
     __cpp_lib_clamp                                201603L [C++17]
     __cpp_lib_complex_udls                         201309L [C++14]
     __cpp_lib_concepts                             201806L [C++2a]
     __cpp_lib_constexpr_misc                       201811L [C++2a]
     __cpp_lib_constexpr_swap_algorithms            201806L [C++2a]
+    __cpp_lib_constexpr_utility                    201811L [C++2a]
     __cpp_lib_destroying_delete                    201806L [C++2a]
     __cpp_lib_enable_shared_from_this              201603L [C++17]
     __cpp_lib_endian                               201907L [C++2a]
     __cpp_lib_erase_if                             202002L [C++2a]
     __cpp_lib_exchange_function                    201304L [C++14]
     __cpp_lib_execution                            201603L [C++17]
     __cpp_lib_filesystem                           201703L [C++17]
     __cpp_lib_gcd_lcm                              201606L [C++17]

 # ifdef __cpp_lib_constexpr_misc
 #   error "__cpp_lib_constexpr_misc should not be defined before c++2a"
 # endif
 
 # ifdef __cpp_lib_constexpr_swap_algorithms
 #   error "__cpp_lib_constexpr_swap_algorithms should not be defined before c++2a"
 # endif
 
+# ifdef __cpp_lib_constexpr_utility 
+#   error "__cpp_lib_constexpr_utility  should not be defined before c++2a"
+# endif
+
 # ifdef __cpp_lib_destroying_delete
 #   error "__cpp_lib_destroying_delete should not be defined before c++2a"
 # endif
 
 # ifdef __cpp_lib_enable_shared_from_this
 #   error "__cpp_lib_enable_shared_from_this should not be defined before c++17"
 # endif
 

 # ifdef __cpp_lib_constexpr_misc
 #   error "__cpp_lib_constexpr_misc should not be defined before c++2a"
 # endif
 
 # ifdef __cpp_lib_constexpr_swap_algorithms
 #   error "__cpp_lib_constexpr_swap_algorithms should not be defined before c++2a"
 # endif
 
+# ifdef __cpp_lib_constexpr_utility 
+#   error "__cpp_lib_constexpr_utility  should not be defined before c++2a"
+# endif
+
 # ifdef __cpp_lib_destroying_delete
 #   error "__cpp_lib_destroying_delete should not be defined before c++2a"
 # endif
 
 # ifdef __cpp_lib_enable_shared_from_this
 #   error "__cpp_lib_enable_shared_from_this should not be defined before c++17"
 # endif
 

 # ifdef __cpp_lib_constexpr_misc
 #   error "__cpp_lib_constexpr_misc should not be defined before c++2a"
 # endif
 
 # ifdef __cpp_lib_constexpr_swap_algorithms
 #   error "__cpp_lib_constexpr_swap_algorithms should not be defined before c++2a"
 # endif
 
+# ifdef __cpp_lib_constexpr_utility 
+#   error "__cpp_lib_constexpr_utility  should not be defined before c++2a"
+# endif
+
 # ifdef __cpp_lib_destroying_delete
 #   error "__cpp_lib_destroying_delete should not be defined before c++2a"
 # endif
 
 # ifndef __cpp_lib_enable_shared_from_this
 #   error "__cpp_lib_enable_shared_from_this should be defined in c++17"
 # endif
 # if __cpp_lib_enable_shared_from_this != 201603L

 #     error "__cpp_lib_constexpr_swap_algorithms should have the value 201806L in c++2a"
 #   endif
 # else // _LIBCPP_VERSION
 #   ifdef __cpp_lib_constexpr_swap_algorithms
 #     error "__cpp_lib_constexpr_swap_algorithms should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
+# ifndef __cpp_lib_constexpr_utility 
+#   error "__cpp_lib_constexpr_utility  should be defined in c++2a"
+# endif
+# if __cpp_lib_constexpr_utility  != 201811L
+#   error "__cpp_lib_constexpr_utility  should have the value 201811L in c++2a"
+# endif
+
 # if TEST_STD_VER > 17 && defined(__cpp_impl_destroying_delete) && __cpp_impl_destroying_delete >= 201806L
 #   ifndef __cpp_lib_destroying_delete
 #     error "__cpp_lib_destroying_delete should be defined in c++2a"
 #   endif
 #   if __cpp_lib_destroying_delete != 201806L
 #     error "__cpp_lib_destroying_delete should have the value 201806L in c++2a"
 #   endif
 # else

libcxx/test/std/utilities/utility/pairs/pairs.pair/assign_const_pair_U_V.pass.cpp

 #include <utility>
 #include <cassert>
 
 #include "test_macros.h"
 #if TEST_STD_VER >= 11
 #include "archetypes.h"
 #endif
 
-int main(int, char**)
-{
-    {
-        typedef std::pair<int, short> P1;
-        typedef std::pair<double, long> P2;
-        P1 p1(3, static_cast<short>(4));
-        P2 p2;
-        p2 = p1;
-        assert(p2.first == 3);
-        assert(p2.second == 4);
-    }
-#if TEST_STD_VER >= 11
-    {
-       using C = TestTypes::TestType;
-       using P = std::pair<int, C>;
-       using T = std::pair<long, C>;
-       const T t(42, -42);
-       P p(101, 101);
-       C::reset_constructors();
-       p = t;
-       assert(C::constructed == 0);
-       assert(C::assigned == 1);
-       assert(C::copy_assigned == 1);
-       assert(C::move_assigned == 0);
-       assert(p.first == 42);
-       assert(p.second.value == -42);
-    }
+TEST_CONSTEXPR_CXX20 bool test() {
+#if TEST_STD_VER >= 20
+  {
+    using C = ConstexprTestTypes::TestType;
+    using P = std::pair<int, C>;
+    using T = std::pair<long, C>;
+    const T t(42, -42);
+    P p(101, 101);
+    p = t;
+    assert(p.first == 42);
+    assert(p.second.value == -42);
+  }
+#elif TEST_STD_VER >= 11
 #endif
+  return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER >= 20
+  static_assert(test());
+#endif
 
   return 0;
 }

libcxx/test/std/utilities/utility/pairs/pairs.pair/assign_pair.pass.cpp

 
 // pair& operator=(pair const& p);
 
 #include <utility>
 #include <memory>
 #include <cassert>
 
 #include "test_macros.h"
-
-
-struct NonAssignable {
-  NonAssignable& operator=(NonAssignable const&) = delete;
-  NonAssignable& operator=(NonAssignable&&) = delete;
-};
-struct CopyAssignable {
-  CopyAssignable() = default;
-  CopyAssignable(CopyAssignable const&) = default;
-  CopyAssignable& operator=(CopyAssignable const&) = default;
-  CopyAssignable& operator=(CopyAssignable&&) = delete;
-};
-struct MoveAssignable {
-  MoveAssignable() = default;
-  MoveAssignable& operator=(MoveAssignable const&) = delete;
-  MoveAssignable& operator=(MoveAssignable&&) = default;
-};
+#include "archetypes.h"
 
 struct CountAssign {
-  static int copied;
-  static int moved;
-  static void reset() { copied = moved = 0; }
-  CountAssign() = default;
-  CountAssign& operator=(CountAssign const&) { ++copied; return *this; }
-  CountAssign& operator=(CountAssign&&) { ++moved; return *this; }
+  int copied = 0;
+  int moved = 0;
+  TEST_CONSTEXPR_CXX20 CountAssign() = default;
+  TEST_CONSTEXPR_CXX20 CountAssign& operator=(CountAssign const&) {
+    ++copied;
+    return *this;
+  }
+  TEST_CONSTEXPR_CXX20 CountAssign& operator=(CountAssign&&) {
+    ++moved;
+    return *this;
+  }
 };
-int CountAssign::copied = 0;
-int CountAssign::moved = 0;
 
 struct Incomplete;
 extern Incomplete inc_obj;
 
-int main(int, char**)
-{
-    {
-        typedef std::pair<CopyAssignable, int> P;
-        const P p1(CopyAssignable(), short{4});
-        P p2;
-        p2 = p1;
-        assert(p2.second == 4);
-    }
-    {
-        using P = std::pair<int&, int&&>;
-        int x = 42;
-        int y = 101;
-        int x2 = -1;
-        int y2 = 300;
-        P p1(x, std::move(y));
-        P p2(x2, std::move(y2));
-        p1 = p2;
-        assert(p1.first == x2);
-        assert(p1.second == y2);
-    }
-    {
-        using P = std::pair<int, NonAssignable>;
-        static_assert(!std::is_copy_assignable<P>::value, "");
-    }
-    {
-        CountAssign::reset();
-        using P = std::pair<CountAssign, CopyAssignable>;
-        static_assert(std::is_copy_assignable<P>::value, "");
-        P p;
-        P p2;
-        p = p2;
-        assert(CountAssign::copied == 1);
-        assert(CountAssign::moved == 0);
-    }
-    {
-        using P = std::pair<int, MoveAssignable>;
-        static_assert(!std::is_copy_assignable<P>::value, "");
-    }
-    {
-        using P = std::pair<int, Incomplete&>;
-        static_assert(!std::is_copy_assignable<P>::value, "");
-        P p(42, inc_obj);
-        assert(&p.second == &inc_obj);
-    }
+TEST_CONSTEXPR_CXX20 bool test() {
+    typedef std::pair<ConstexprTestTypes::CopyOnly, int> P;
+    const P p1(ConstexprTestTypes::CopyOnly(), short{4});
+    using P = std::pair<int, ConstexprTestTypes::NonCopyable>;
+    using P = std::pair<CountAssign, ConstexprTestTypes::Copyable>;
+    assert(p.first.copied == 1);
+    assert(p.first.moved == 0);
+    assert(p2.first.copied == 0);
+    assert(p2.first.moved == 0);
+    using P = std::pair<int, ConstexprTestTypes::MoveAssignOnly>;
 
-    return 0;
+  return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER >= 20
+  static_assert(test());
+#endif
+
 }
 
 struct Incomplete {};
 Incomplete inc_obj;

libcxx/test/std/utilities/utility/pairs/pairs.pair/assign_rv_pair.pass.cpp

 
 // pair& operator=(pair&& p);
 
 #include <utility>
 #include <memory>
 #include <cassert>
 
 #include "test_macros.h"
-
-
-struct NonAssignable {
-  NonAssignable& operator=(NonAssignable const&) = delete;
-  NonAssignable& operator=(NonAssignable&&) = delete;
-};
-struct CopyAssignable {
-  CopyAssignable() = default;
-  CopyAssignable& operator=(CopyAssignable const&) = default;
-  CopyAssignable& operator=(CopyAssignable&&) = delete;
-};
-struct MoveAssignable {
-  MoveAssignable() = default;
-  MoveAssignable& operator=(MoveAssignable const&) = delete;
-  MoveAssignable& operator=(MoveAssignable&&) = default;
-};
+#include "archetypes.h"
 
 struct CountAssign {
-  static int copied;
-  static int moved;
-  static void reset() { copied = moved = 0; }
-  CountAssign() = default;
-  CountAssign& operator=(CountAssign const&) { ++copied; return *this; }
-  CountAssign& operator=(CountAssign&&) { ++moved; return *this; }
+  int copied = 0;
+  int moved = 0;
+  TEST_CONSTEXPR_CXX20 CountAssign() = default;
+  TEST_CONSTEXPR_CXX20 CountAssign& operator=(CountAssign const&) {
+    ++copied;
+    return *this;
+  }
+  TEST_CONSTEXPR_CXX20 CountAssign& operator=(CountAssign&&) {
+    ++moved;
+    return *this;
+  }
 };
-int CountAssign::copied = 0;
-int CountAssign::moved = 0;
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool test() {
   {
-    {
-        typedef std::pair<std::unique_ptr<int>, int> P;
-        P p1(std::unique_ptr<int>(new int(3)), 4);
-        P p2;
-        p2 = std::move(p1);
-        assert(*p2.first == 3);
-        assert(p2.second == 4);
-    }
-    {
-        using P = std::pair<int&, int&&>;
-        int x = 42;
-        int y = 101;
-        int x2 = -1;
-        int y2 = 300;
-        P p1(x, std::move(y));
-        P p2(x2, std::move(y2));
-        p1 = std::move(p2);
-        assert(p1.first == x2);
-        assert(p1.second == y2);
-    }
-    {
-        using P = std::pair<int, NonAssignable>;
-        static_assert(!std::is_move_assignable<P>::value, "");
-    }
-    {
-        // The move decays to the copy constructor
-        CountAssign::reset();
-        using P = std::pair<CountAssign, CopyAssignable>;
-        static_assert(std::is_move_assignable<P>::value, "");
-        P p;
-        P p2;
-        p = std::move(p2);
-        assert(CountAssign::moved == 0);
-        assert(CountAssign::copied == 1);
-    }
-    {
-        CountAssign::reset();
-        using P = std::pair<CountAssign, MoveAssignable>;
-        static_assert(std::is_move_assignable<P>::value, "");
-        P p;
-        P p2;
-        p = std::move(p2);
-        assert(CountAssign::moved == 1);
-        assert(CountAssign::copied == 0);
-    }
+    typedef std::pair<ConstexprTestTypes::MoveOnly, int> P;
+    P p1(3, 4);
+    assert(p2.first.value == 3);
+    using P = std::pair<int, ConstexprTestTypes::DefaultOnly>;
+    using P = std::pair<CountAssign, ConstexprTestTypes::CopyOnly>;
+    assert(p.first.moved == 0);
+    assert(p.first.copied == 1);
+    assert(p2.first.moved == 0);
+    assert(p2.first.copied == 0);
+    using P = std::pair<CountAssign, ConstexprTestTypes::MoveOnly>;
+    assert(p.first.moved == 1);
+    assert(p.first.copied == 0);
+    assert(p2.first.moved == 0);
+    assert(p2.first.copied == 0);
+  }
+  return true;
 
+int main(int, char**) {
+  test();
+#if TEST_STD_VER >= 20
+  static_assert(test());
+#endif
+
   return 0;
 }

libcxx/test/std/utilities/utility/pairs/pairs.pair/assign_rv_pair_U_V.pass.cpp

 
 // template <class T1, class T2> struct pair
 
 // template<class U, class V> pair& operator=(pair<U, V>&& p);
 
 #include <utility>
 #include <memory>
 #include <cassert>
-#include <archetypes.h>
 
 #include "test_macros.h"
+#include "archetypes.h"
 
-struct Base
-{
-    virtual ~Base() {}
+struct Derived : ConstexprTestTypes::MoveOnly {
+  Derived() = default;
+  TEST_CONSTEXPR_CXX20 Derived(ConstexprTestTypes::MoveOnly&&){};
 };
-
-struct Derived
-    : public Base
-{
+struct CountAssign {
+  int copied = 0;
+  int moved = 0;
+  TEST_CONSTEXPR_CXX20 CountAssign() = default;
+  TEST_CONSTEXPR_CXX20 CountAssign(const int){};
+  TEST_CONSTEXPR_CXX20 CountAssign& operator=(CountAssign const&) {
+    ++copied;
+    return *this;
+  }
+  TEST_CONSTEXPR_CXX20 CountAssign& operator=(CountAssign&&) {
+    ++moved;
+    return *this;
+  }
 };
 
-int main(int, char**)
-{
-    {
-        typedef std::pair<std::unique_ptr<Derived>, short> P1;
-        typedef std::pair<std::unique_ptr<Base>, long> P2;
-        P1 p1(std::unique_ptr<Derived>(), static_cast<short>(4));
-        P2 p2;
-        p2 = std::move(p1);
-        assert(p2.first == nullptr);
-        assert(p2.second == 4);
-    }
-    {
-       using C = TestTypes::TestType;
-       using P = std::pair<int, C>;
-       using T = std::pair<long, C>;
-       T t(42, -42);
-       P p(101, 101);
-       C::reset_constructors();
-       p = std::move(t);
-       assert(C::constructed == 0);
-       assert(C::assigned == 1);
-       assert(C::copy_assigned == 0);
-       assert(C::move_assigned == 1);
-       assert(p.first == 42);
-       assert(p.second.value == -42);
-    }
+TEST_CONSTEXPR_CXX20 bool test() {
+    typedef std::pair<Derived, short> P1;
+    typedef std::pair<ConstexprTestTypes::MoveOnly, long> P2;
+    P1 p1(Derived(), static_cast<short>(4));
+    using P = std::pair<int, CountAssign>;
+    using T = std::pair<long, CountAssign>;
+    assert(p.second.moved == 1);
+    assert(p.second.copied == 0);
+    assert(t.second.moved == 0);
+    assert(t.second.copied == 0);
+  return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER >= 20
+  static_assert(test());
+#endif
 
   return 0;
 }

libcxx/test/std/utilities/utility/pairs/pairs.pair/const_pair_U_V.pass.cpp

 #include <cassert>
 
 #include "archetypes.h"
 #include "test_convertible.h"
 
 #include "test_macros.h"
 using namespace ImplicitTypes; // Get implicitly archetypes
 
-template <class T1, class U1,
-          bool CanCopy = true, bool CanConvert = CanCopy>
-void test_pair_const()
-{
-    using P1 = std::pair<T1, int>;
-    using P2 = std::pair<int, T1>;
-    using UP1 = std::pair<U1, int> const&;
-    using UP2 = std::pair<int, U1> const&;
-    static_assert(std::is_constructible<P1, UP1>::value == CanCopy, "");
-    static_assert(test_convertible<P1, UP1>() == CanConvert, "");
-    static_assert(std::is_constructible<P2, UP2>::value == CanCopy, "");
-    static_assert(test_convertible<P2,  UP2>() == CanConvert, "");
+template <class T1, class U1, bool CanCopy = true, bool CanConvert = CanCopy>
+TEST_CONSTEXPR_CXX20 void test_pair_const() {
+  static_assert(test_convertible<P2, UP2>() == CanConvert, "");
 }
 
 template <class T, class U>
 struct DPair : public std::pair<T, U> {
   using Base = std::pair<T, U>;
   using Base::Base;
 };
 
 struct ExplicitT {
   constexpr explicit ExplicitT(int x) : value(x) {}
   constexpr explicit ExplicitT(ExplicitT const& o) : value(o.value) {}
   int value;
 };
 
 struct ImplicitT {
   constexpr ImplicitT(int x) : value(x) {}
   constexpr ImplicitT(ImplicitT const& o) : value(o.value) {}
   int value;
 };
 
-int main(int, char**)
-{
-    {
-        typedef std::pair<int, int> P1;
-        typedef std::pair<double, long> P2;
-        const P1 p1(3, 4);
-        const P2 p2 = p1;
-        assert(p2.first == 3);
-        assert(p2.second == 4);
-    }
-    {
-        // We allow derived types to use this constructor
-        using P1 = DPair<long, long>;
-        using P2 = std::pair<int, int>;
-        P1 p1(42, 101);
-        P2 p2(p1);
-        assert(p2.first == 42);
-        assert(p2.second == 101);
-    }
-    {
-        test_pair_const<AllCtors, AllCtors>(); // copy construction
-        test_pair_const<AllCtors, AllCtors&>();
-        test_pair_const<AllCtors, AllCtors&&>();
-        test_pair_const<AllCtors, const AllCtors&>();
-        test_pair_const<AllCtors, const AllCtors&&>();
+TEST_CONSTEXPR_CXX20 bool test() {
 
-        test_pair_const<ExplicitTypes::AllCtors, ExplicitTypes::AllCtors>(); // copy construction
-        test_pair_const<ExplicitTypes::AllCtors, ExplicitTypes::AllCtors&, true, false>();
-        test_pair_const<ExplicitTypes::AllCtors, ExplicitTypes::AllCtors&&, true, false>();
-        test_pair_const<ExplicitTypes::AllCtors, const ExplicitTypes::AllCtors&, true, false>();
-        test_pair_const<ExplicitTypes::AllCtors, const ExplicitTypes::AllCtors&&, true, false>();
+    test_pair_const<ExplicitTypes::AllCtors,
+                    ExplicitTypes::AllCtors>(); // copy construction
+    test_pair_const<ExplicitTypes::AllCtors, ExplicitTypes::AllCtors&, true,
+                    false>();
+    test_pair_const<ExplicitTypes::AllCtors, ExplicitTypes::AllCtors&&, true,
+                    false>();
+    test_pair_const<ExplicitTypes::AllCtors, const ExplicitTypes::AllCtors&,
+                    true, false>();
+    test_pair_const<ExplicitTypes::AllCtors, const ExplicitTypes::AllCtors&&,
+                    true, false>();
 
-        test_pair_const<MoveOnly, MoveOnly, false>(); // copy construction
-        test_pair_const<MoveOnly, MoveOnly&, false>();
-        test_pair_const<MoveOnly, MoveOnly&&, false>();
 
-        test_pair_const<ExplicitTypes::MoveOnly, ExplicitTypes::MoveOnly, false>(); // copy construction
-        test_pair_const<ExplicitTypes::MoveOnly, ExplicitTypes::MoveOnly&, false>();
-        test_pair_const<ExplicitTypes::MoveOnly, ExplicitTypes::MoveOnly&&, false>();
+    test_pair_const<ExplicitTypes::MoveOnly, ExplicitTypes::MoveOnly,
+                    false>(); // copy construction
+    test_pair_const<ExplicitTypes::MoveOnly, ExplicitTypes::MoveOnly&&,
+                    false>();
 
-        test_pair_const<CopyOnly, CopyOnly>();
-        test_pair_const<CopyOnly, CopyOnly&>();
-        test_pair_const<CopyOnly, CopyOnly&&>();
 
-        test_pair_const<ExplicitTypes::CopyOnly, ExplicitTypes::CopyOnly>();
-        test_pair_const<ExplicitTypes::CopyOnly, ExplicitTypes::CopyOnly&, true, false>();
-        test_pair_const<ExplicitTypes::CopyOnly, ExplicitTypes::CopyOnly&&, true, false>();
+    test_pair_const<ExplicitTypes::CopyOnly, ExplicitTypes::CopyOnly&, true,
+                    false>();
+    test_pair_const<ExplicitTypes::CopyOnly, ExplicitTypes::CopyOnly&&, true,
+                    false>();
 
-        test_pair_const<NonCopyable, NonCopyable, false>();
-        test_pair_const<NonCopyable, NonCopyable&, false>();
-        test_pair_const<NonCopyable, NonCopyable&&, false>();
-        test_pair_const<NonCopyable, const NonCopyable&, false>();
-        test_pair_const<NonCopyable, const NonCopyable&&, false>();
-    }
 
-    { // Test construction of references
-        test_pair_const<NonCopyable&, NonCopyable&>();
-        test_pair_const<NonCopyable&, NonCopyable&&>();
-        test_pair_const<NonCopyable&, NonCopyable const&, false>();
-        test_pair_const<NonCopyable const&, NonCopyable&&>();
-        test_pair_const<NonCopyable&&, NonCopyable&&, false>();
 
-        test_pair_const<ConvertingType&, int, false>();
-        test_pair_const<ExplicitTypes::ConvertingType&, int, false>();
-        // Unfortunately the below conversions are allowed and create dangling
-        // references.
-        //test_pair_const<ConvertingType&&, int>();
-        //test_pair_const<ConvertingType const&, int>();
-        //test_pair_const<ConvertingType const&&, int>();
-        // But these are not because the converting constructor is explicit.
-        test_pair_const<ExplicitTypes::ConvertingType&&, int, false>();
-        test_pair_const<ExplicitTypes::ConvertingType const&, int, false>();
-        test_pair_const<ExplicitTypes::ConvertingType const&&, int, false>();
-
-    }
-    {
-        test_pair_const<AllCtors, int, false>();
-        test_pair_const<ExplicitTypes::AllCtors, int, false>();
-        test_pair_const<ConvertingType, int>();
-        test_pair_const<ExplicitTypes::ConvertingType, int, true, false>();
 
-        test_pair_const<ConvertingType, int>();
-        test_pair_const<ConvertingType, ConvertingType>();
-        test_pair_const<ConvertingType, ConvertingType const&>();
-        test_pair_const<ConvertingType, ConvertingType&>();
-        test_pair_const<ConvertingType, ConvertingType&&>();
 
-        test_pair_const<ExplicitTypes::ConvertingType, int, true, false>();
-        test_pair_const<ExplicitTypes::ConvertingType, int&, true, false>();
-        test_pair_const<ExplicitTypes::ConvertingType, const int&, true, false>();
-        test_pair_const<ExplicitTypes::ConvertingType, int&&, true, false>();
-        test_pair_const<ExplicitTypes::ConvertingType, const int&&, true, false>();
 
-        test_pair_const<ExplicitTypes::ConvertingType, ExplicitTypes::ConvertingType>();
-        test_pair_const<ExplicitTypes::ConvertingType, ExplicitTypes::ConvertingType const&, true, false>();
-        test_pair_const<ExplicitTypes::ConvertingType, ExplicitTypes::ConvertingType&, true, false>();
-        test_pair_const<ExplicitTypes::ConvertingType, ExplicitTypes::ConvertingType&&, true, false>();
-    }
+    test_pair_const<ExplicitTypes::ConvertingType,
+                    ExplicitTypes::ConvertingType>();
+    test_pair_const<ExplicitTypes::ConvertingType,
+                    ExplicitTypes::ConvertingType const&, true, false>();
+    test_pair_const<ExplicitTypes::ConvertingType,
+                    ExplicitTypes::ConvertingType&, true, false>();
+    test_pair_const<ExplicitTypes::ConvertingType,
+                    ExplicitTypes::ConvertingType&&, true, false>();
 #if TEST_STD_VER > 11
     {
         typedef std::pair<int, int> P1;
         typedef std::pair<double, long> P2;
         constexpr P1 p1(3, 4);
         constexpr P2 p2 = p1;
         static_assert(p2.first == 3, "");
         static_assert(p2.second == 4, "");
     }
     {
         using P1 = std::pair<int, int>;
         using P2 = std::pair<ExplicitT, ExplicitT>;
         constexpr P1 p1(42, 101);
         constexpr P2 p2(p1);
         static_assert(p2.first.value == 42, "");
         static_assert(p2.second.value == 101, "");
     }
     {
-        using P1 = std::pair<int, int>;
-        using P2 = std::pair<ImplicitT, ImplicitT>;
-        constexpr P1 p1(42, 101);
-        constexpr P2 p2 = p1;
-        static_assert(p2.first.value == 42, "");
-        static_assert(p2.second.value == 101, "");
     }
 #endif
+    return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER >= 20
+  static_assert(test());
+#endif
 
   return 0;
 }

libcxx/test/std/utilities/utility/pairs/pairs.pair/piecewise.pass.cpp

 //                                 tuple<Args2...> second_args);
 
 #include <cassert>
 #include <tuple>
 #include <utility>
 
 #include "test_macros.h"
 
-
-int main(int, char**)
-{
-    {
-        typedef std::pair<int, int*> P1;
-        typedef std::pair<int*, int> P2;
-        typedef std::pair<P1, P2> P3;
-        P3 p3(std::piecewise_construct, std::tuple<int, int*>(3, nullptr),
-                                        std::tuple<int*, int>(nullptr, 4));
-        assert(p3.first == P1(3, nullptr));
-        assert(p3.second == P2(nullptr, 4));
-    }
+TEST_CONSTEXPR_CXX20 bool test() {
+  return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER >= 20
+  static_assert(test());
+#endif
 
   return 0;
 }

libcxx/test/std/utilities/utility/pairs/pairs.pair/swap.pass.cpp

 // void swap(pair& p);
 
 #include <utility>
 #include <cassert>
 
 #include "test_macros.h"
 
 struct S {
     int i;
-    S() : i(0) {}
-    S(int j) : i(j) {}
-    S * operator& () { assert(false); return this; }
-    S const * operator& () const { assert(false); return this; }
-    bool operator==(int x) const { return i == x; }
-    };
+    TEST_CONSTEXPR_CXX20 S() : i(0) {}
+    TEST_CONSTEXPR_CXX20 S(int j) : i(j) {}
+    TEST_CONSTEXPR_CXX20 bool operator==(int x) const { return i == x; }
 
-int main(int, char**)
-{
-    {
-        typedef std::pair<int, short> P1;
-        P1 p1(3, static_cast<short>(4));
-        P1 p2(5, static_cast<short>(6));
-        p1.swap(p2);
-        assert(p1.first == 5);
-        assert(p1.second == 6);
-        assert(p2.first == 3);
-        assert(p2.second == 4);
-    }
-    {
-        typedef std::pair<int, S> P1;
-        P1 p1(3, S(4));
-        P1 p2(5, S(6));
-        p1.swap(p2);
-        assert(p1.first == 5);
-        assert(p1.second == 6);
-        assert(p2.first == 3);
-        assert(p2.second == 4);
-    }
+TEST_CONSTEXPR_CXX20 bool test() {
+  return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER >= 20
+  static_assert(test());
+#endif
 
   return 0;
 }

libcxx/utils/generate_feature_test_macro_components.py

feature_test_macros = sorted([ add_version_header(x) for x in [
   {"name": "__cpp_lib_math_constants",
    "values": {
      "c++2a": int(201907),
    },
    "headers": ["numbers"],
    "depends": "defined(__cpp_concepts) && __cpp_concepts >= 201811L",
    "internal_depends": "defined(__cpp_concepts) && __cpp_concepts >= 201811L",
    },
+  {"name": "__cpp_lib_constexpr_utility ",
+   "values": {
+     "c++2a": int(201811),
+   },
+   "headers": ["utility"],
+   },
 ]], key=lambda tc: tc["name"])
 
 def get_std_dialects():
   std_dialects = ['c++14', 'c++17', 'c++2a']
   return list(std_dialects)
 
 def get_first_std(d):
     for s in get_std_dialects():