Make swap functions constexpr

[zoecarver]

Summary

This patch makes swap functions constexpr. This patch does not implement all of P0879R0 for two reasons a) to make this patch easier to review and b) because std::swap being a constexpr disproportionately helps when implementing other papers. Both swap overloads, swap_ranges and iter_swap are updated (with tests).

[EricWF]

Nicely done.

Thanks for the patch.

[zoecarver]

Committed as rL365238.

include/type_traits

 typename enable_if
 <
     is_move_constructible<_Tp>::value &&
     is_move_assignable<_Tp>::value
 >::type
 #else
 void
 #endif
+_LIBCPP_CONSTEXPR_AFTER_CXX17
 swap(_Tp& __x, _Tp& __y) _NOEXCEPT_(is_nothrow_move_constructible<_Tp>::value &&
                                     is_nothrow_move_assignable<_Tp>::value)
 {
     _Tp __t(_VSTD::move(__x));
     __x = _VSTD::move(__y);
     __y = _VSTD::move(__t);
 }
 
 template<class _Tp, size_t _Np>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 typename enable_if<
     __is_swappable<_Tp>::value
 >::type
 swap(_Tp (&__a)[_Np], _Tp (&__b)[_Np]) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value);
 
 template <class _ForwardIterator1, class _ForwardIterator2>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 void
 iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
     //                                  _NOEXCEPT_(_NOEXCEPT_(swap(*__a, *__b)))
                _NOEXCEPT_(_NOEXCEPT_(swap(*_VSTD::declval<_ForwardIterator1>(),
                                           *_VSTD::declval<_ForwardIterator2>())))
 {
     swap(*__a, *__b);
 }

include/utility

 }
 
 }  // rel_ops
 
 // swap_ranges
 
 
 template <class _ForwardIterator1, class _ForwardIterator2>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 _ForwardIterator2
 swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2)
 {
     for(; __first1 != __last1; ++__first1, (void) ++__first2)
         swap(*__first1, *__first2);
     return __first2;
 }
 
 // forward declared in <type_traits>
 template<class _Tp, size_t _Np>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 typename enable_if<
     __is_swappable<_Tp>::value
 >::type
 swap(_Tp (&__a)[_Np], _Tp (&__b)[_Np]) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value)
 {
     _VSTD::swap_ranges(__a, __a + _Np, __b);
 }
 

test/std/algorithms/alg.modifying.operations/alg.swap/iter_swap.pass.cpp

 //   void
 //   iter_swap(Iter1 a, Iter2 b);
 
 #include <algorithm>
 #include <cassert>
 
 #include "test_macros.h"
 
+#if TEST_STD_VER > 17
+constexpr bool test_swap_constexpr()
+{
+    int i = 1;
+    int j = 2;
+    std::iter_swap(&i, &j);
+    return i == 2 && j == 1;
+}
+#endif // TEST_STD_VER > 17
+
 int main(int, char**)
 {
     int i = 1;
     int j = 2;
     std::iter_swap(&i, &j);
     assert(i == 2);
     assert(j == 1);
 
+#if TEST_STD_VER > 17
+    static_assert(test_swap_constexpr());
+#endif // TEST_STD_VER > 17
+
   return 0;
 }

test/std/algorithms/alg.modifying.operations/alg.swap/swap_ranges.pass.cpp

void test2()
     assert ( dest[1][1] == 4 );
     assert ( dest[1][2] == 5 );
     assert ( dest[2][0] == 6 );
     assert ( dest[2][1] == 7 );
     assert ( dest[2][2] == 8 );
     }
 }
 
+#if TEST_STD_VER > 17
+constexpr bool test_swap_constexpr()
+{
+    int i[3] = {1, 2, 3};
+    int j[3] = {4, 5, 6};
+    std::swap_ranges(i, i+3, j);
+    return i[0] == 4 &&
+           i[1] == 5 &&
+           i[2] == 6 &&
+           j[0] == 1 &&
+           j[1] == 2 &&
+           j[2] == 3;
+}
+#endif // TEST_STD_VER > 17
+
 int main(int, char**)
 {
     test<forward_iterator<int*>, forward_iterator<int*> >();
     test<forward_iterator<int*>, bidirectional_iterator<int*> >();
     test<forward_iterator<int*>, random_access_iterator<int*> >();
     test<forward_iterator<int*>, int*>();
 
     test<bidirectional_iterator<int*>, forward_iterator<int*> >();
#if TEST_STD_VER >= 11
     test1<random_access_iterator<std::unique_ptr<int>*>, std::unique_ptr<int>*>();
 
     test1<std::unique_ptr<int>*, forward_iterator<std::unique_ptr<int>*> >();
     test1<std::unique_ptr<int>*, bidirectional_iterator<std::unique_ptr<int>*> >();
     test1<std::unique_ptr<int>*, random_access_iterator<std::unique_ptr<int>*> >();
     test1<std::unique_ptr<int>*, std::unique_ptr<int>*>();
 #endif // TEST_STD_VER >= 11
 
+#if TEST_STD_VER > 17
+    static_assert(test_swap_constexpr());
+#endif // TEST_STD_VER > 17
+
     test2();
 
   return 0;
 }

test/std/utilities/utility/utility.swap/swap.pass.cpp

 auto can_swap_test(...) -> std::false_type;
 
 template <class Tp>
 constexpr bool can_swap() {
     return std::is_same<decltype(can_swap_test<Tp>(0)), void>::value;
 }
 #endif
 
+#if TEST_STD_VER > 17
+constexpr bool test_swap_constexpr()
+{
+    int i = 1;
+    int j = 2;
+    std::swap(i, j);
+    return i == 2 && j == 1;
+}
+#endif // TEST_STD_VER > 17
+
 int main(int, char**)
 {
 
     {
         int i = 1;
         int j = 2;
         std::swap(i, j);
         assert(i == 2);
#if TEST_STD_VER >= 11
         MoveOnly m;
         NoexceptMoveOnly nm;
         static_assert(!noexcept(std::swap(c, c)), "");
         static_assert(!noexcept(std::swap(m, m)), "");
         static_assert(noexcept(std::swap(nm, nm)), "");
     }
 #endif
 
+#if TEST_STD_VER > 17
+    static_assert(test_swap_constexpr());
+#endif // TEST_STD_VER > 17
+
   return 0;
 }

test/std/utilities/utility/utility.swap/swap_array.pass.cpp

 auto can_swap_test(...) -> std::false_type;
 
 template <class Tp>
 constexpr bool can_swap() {
     return std::is_same<decltype(can_swap_test<Tp>(0)), void>::value;
 }
 #endif
 
+#if TEST_STD_VER > 17
+constexpr bool test_swap_constexpr()
+{
+    int i[3] = {1, 2, 3};
+    int j[3] = {4, 5, 6};
+    std::swap(i, j);
+    return i[0] == 4 &&
+           i[1] == 5 &&
+           i[2] == 6 &&
+           j[0] == 1 &&
+           j[1] == 2 &&
+           j[2] == 3;
+}
+#endif // TEST_STD_VER > 17
 
 int main(int, char**)
 {
     {
         int i[3] = {1, 2, 3};
         int j[3] = {4, 5, 6};
         std::swap(i, j);
         assert(i[0] == 4);
#if TEST_STD_VER >= 11
 
         CA ca;
         MA ma;
         static_assert(!noexcept(std::swap(ca, ca)), "");
         static_assert(noexcept(std::swap(ma, ma)), "");
     }
 #endif
 
+#if TEST_STD_VER > 17
+    static_assert(test_swap_constexpr());
+#endif // TEST_STD_VER > 17
+
   return 0;
 }