[libc++] implement "pair" section of P2321R2 `zip`

[huixie90]

Summary

• add constructors that takes non-const lvalue ref pair and const rvalue ref pair
• add const assignment operators
• add const swap member and non member

(note) the pair changes in uses_allocator_construction_args has not been implemented as the C++20 paper P0591r4 has not been implemented in libcxx

[huixie90]

implement swap

[var-const]

Thanks a lot for working on this! Sorry about the slow review. I'll take a look at the tests soon.

libcxx/include/__utility/pair.h

211

The noexcept doesn't seem to be in the standard -- we're adding it for consistency with existing constructors, right?

319

Same question here re. noexcept.

384

I think you don't have to use the macro and can use just plain noexcept since it won't be available in older language modes.

502

The noexcept specification is different from the standard -- looks like it's copied from the member version.

[var-const]

libcxx/include/utility

87

This looks incorrect -- the template arguments are U and V, but the function arguments refer to U1 and U2.

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

22

It looks like these types should be moved somewhere under test_support.

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

16

Nit: s/U2/U1/.

21

Similar to the other tuple include: these types should live somewhere under test_support.

44

Nit: can line breaks here be more consistent?

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

16

Nit: s/U2/U1/.

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

25 ↗

(On Diff #451526)

Should this be const T&?

41 ↗

(On Diff #451526)

Optional: instead of using mutable, you could store a pointer or a reference, then modify the pointed-to value. That should fix the GCC issue.

[huixie90]

libcxx/include/__utility/pair.h

211

that is right. None of the overload in the standard has noexcept and we added noexcept to the other overloads. I am just trying to be consistent with what we did in the past. Do you think it is reasonable?

319

that is right. None of the overload in the standard has noexcept and we added noexcept to the other overloads. I am just trying to be consistent with what we did in the past. Do you think it is reasonable?

502

The standard is noexcept(noexcept(x.swap(y))); which is equivalent to the one here. The reason I wrote this way is to be consistent with what we did in the past (see the overload above this one). do you think we should change it?

libcxx/include/utility

87

good catch

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

25 ↗

(On Diff #451526)

could be but I prefer this way. here t1 and t2 are lvalues of T and T could be non const or const. In my usage in this test, I choose T to be const. see line 35 - 38. What do you think? If I make it const T& here, I need to call this concept ConstMemberSwapNoexcept`.

[huixie90]

address issues

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

41 ↗

(On Diff #451526)

I think it might be better to have a test to test this value semantics type, since we have a test that tests pair of references for the reference semantics already. what do you think?

[huixie90]

attempt to fix CI

[var-const]

Thanks a lot for working on this! LGTM, but I'll leave the final approval to @ldionne.

libcxx/include/__utility/pair.h

211

I think it's the right thing to do, but please double-check with @ldionne.

502

I'd rather use the same specification as the standard unless there's a reason to diverge (it saves the mental burden of thinking whether our specification is equivalent).

[huixie90]

rebase

libcxx/docs/Status/ZipProjects.csv

 Section,Description,Dependencies,Assignee,Complete
 | `[tuple.syn] <https://wg21.link/tuple.syn>`_, "`[tuple] basic_common_reference, common_type <https://reviews.llvm.org/D116538>`_", None, Nikolas Klauser, |Complete|
-| `[tuple.tuple] <https://wg21.link/tuple.tuple>`_, "`[tuple] constructor, assignment and swap overloads <https://reviews.llvm.org/D116621>`_", None, Nikolas Klauser, |In Progress|
+| `[tuple.tuple] <https://wg21.link/tuple.tuple>`_, "`[tuple] constructor, assignment and swap overloads <https://reviews.llvm.org/D116621>`_", None, Hui Xie, |Complete|
 | `[utility.syn] <https://wg21.link/utility.syn>`_, "[pair] basic_common_reference, common_type", None, Nikolas Klauser, |Complete|
-| `[pairs.pair] <https://wg21.link/pairs.pair>`_, "[pair] constructor, assignment and swap overloads", None, Nikolas Klauser, |Not Started|
+| `[pairs.pair] <https://wg21.link/pairs.pair>`_, "[pair] constructor, assignment and swap overloads", None, Hui Xie, |Complete|
 "| `[memory.syn] <https://wg21.link/memory.syn>`_
 | `[allocator.uses.construction] <https://wg21.link/allocator.uses.construction>`_", "[pair] uses_allocator_construction_args overloads", None, Unassigned, |Not Started|
 | `[vector.bool] <https://wg21.link/vector.bool>`_, "[vector<bool>::reference] add const operator= overload", None, Nikolas Klauser, |Not Started|
 | `[iterator.concept.winc] <https://wg21.link/iterator.concept.winc>`_, "Update weakly_comparable", None, Unassigned, |Not Started|
 | `[range.zip] <https://wg21.link/ranges.syn>`_, "`zip_view <https://reviews.llvm.org/D122806>`_", "| `zip_view::iterator`
 | `zip_view::sentinel`", Hui Xie, |Complete|
 | `[range.zip.iterator] <https://wg21.link/range.zip.iterator>`_, "`zip_view::iterator <https://reviews.llvm.org/D122806>`_", None, Hui Xie, |Complete|
 | `[range.zip.sentinel] <https://wg21.link/range.zip.sentinel>`_, "`zip_view::sentinel <https://reviews.llvm.org/D122806>`_", None, Hui Xie, |Complete|

libcxx/include/__utility/pair.h

struct _CheckArgs {
 
       template <int&...>
       static constexpr bool __enable_implicit_default() {
           return __is_implicitly_default_constructible<_T1>::value
               && __is_implicitly_default_constructible<_T2>::value;
       }
 
       template <class _U1, class _U2>
-      static constexpr bool __enable_explicit() {
+      static constexpr bool __is_pair_constructible() {
           return is_constructible<first_type, _U1>::value
-              && is_constructible<second_type, _U2>::value
-              && (!is_convertible<_U1, first_type>::value
-                  || !is_convertible<_U2, second_type>::value);
+              && is_constructible<second_type, _U2>::value;
       }
 
       template <class _U1, class _U2>
-      static constexpr bool __enable_implicit() {
-          return is_constructible<first_type, _U1>::value
-              && is_constructible<second_type, _U2>::value
-              && is_convertible<_U1, first_type>::value
+      static constexpr bool __is_implicit() {
+          return is_convertible<_U1, first_type>::value
               && is_convertible<_U2, second_type>::value;
       }
+
+      template <class _U1, class _U2>
+      static constexpr bool __enable_explicit() {
+          return __is_pair_constructible<_U1, _U2>() && !__is_implicit<_U1, _U2>();
+      }
+
+      template <class _U1, class _U2>
+      static constexpr bool __enable_implicit() {
+          return __is_pair_constructible<_U1, _U2>() && __is_implicit<_U1, _U2>();
+      }
     };
 
     template <bool _MaybeEnable>
     using _CheckArgsDep _LIBCPP_NODEBUG = typename conditional<
       _MaybeEnable, _CheckArgs, __check_tuple_constructor_fail>::type;
 
     struct _CheckTupleLikeConstructor {
         template <class _Tuple>
#endif
         typename enable_if<_CheckArgs::template __enable_implicit<_U1, _U2>()>::type* = nullptr
     >
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     pair(_U1&& __u1, _U2&& __u2)
         _NOEXCEPT_((is_nothrow_constructible<first_type, _U1>::value &&
                     is_nothrow_constructible<second_type, _U2>::value))
         : first(_VSTD::forward<_U1>(__u1)), second(_VSTD::forward<_U2>(__u2)) {}
 
+#if _LIBCPP_STD_VER > 20
+    template<class _U1, class _U2, __enable_if_t<
+            _CheckArgs::template __is_pair_constructible<_U1&, _U2&>()
+    >* = nullptr>
+    _LIBCPP_HIDE_FROM_ABI constexpr
+    explicit(!_CheckArgs::template __is_implicit<_U1&, _U2&>()) pair(pair<_U1, _U2>& __p)
+        noexcept((is_nothrow_constructible<first_type, _U1&>::value &&
+                  is_nothrow_constructible<second_type, _U2&>::value))
+        : first(__p.first), second(__p.second) {}
+#endif
+
     template<class _U1, class _U2, typename enable_if<
             _CheckArgs::template __enable_explicit<_U1 const&, _U2 const&>()
     >::type* = nullptr>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     explicit pair(pair<_U1, _U2> const& __p)
         _NOEXCEPT_((is_nothrow_constructible<first_type, _U1 const&>::value &&
                     is_nothrow_constructible<second_type, _U2 const&>::value))
         : first(__p.first), second(__p.second) {}
template<class _U1, class _U2, typename enable_if<
             _CheckArgs::template __enable_implicit<_U1, _U2>()
     >::type* = nullptr>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     pair(pair<_U1, _U2>&& __p)
         _NOEXCEPT_((is_nothrow_constructible<first_type, _U1&&>::value &&
                     is_nothrow_constructible<second_type, _U2&&>::value))
         : first(_VSTD::forward<_U1>(__p.first)), second(_VSTD::forward<_U2>(__p.second)) {}
 
+#if _LIBCPP_STD_VER > 20
+    template<class _U1, class _U2, __enable_if_t<
+            _CheckArgs::template __is_pair_constructible<const _U1&&, const _U2&&>()
+    >* = nullptr>
+    _LIBCPP_HIDE_FROM_ABI constexpr
+    explicit(!_CheckArgs::template __is_implicit<const _U1&&, const _U2&&>())
+    pair(const pair<_U1, _U2>&& __p)
+        noexcept((is_nothrow_constructible<first_type, const _U1&&>::value &&
+                  is_nothrow_constructible<second_type, const _U2&&>::value))
+        : first(std::move(__p.first)), second(std::move(__p.second)) {}
+#endif
+
     template<class _Tuple, typename enable_if<
             _CheckTLC<_Tuple>::template __enable_explicit<_Tuple>()
     >::type* = nullptr>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     explicit pair(_Tuple&& __p)
         : first(_VSTD::get<0>(_VSTD::forward<_Tuple>(__p))),
           second(_VSTD::get<1>(_VSTD::forward<_Tuple>(__p))) {}
 
pair& operator=(typename conditional<
         _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;
     }
 
+#if _LIBCPP_STD_VER > 20
+    _LIBCPP_HIDE_FROM_ABI constexpr
+    const pair& operator=(pair const& __p) const
+      noexcept(is_nothrow_copy_assignable_v<const first_type> &&
+               is_nothrow_copy_assignable_v<const second_type>)
+      requires (is_copy_assignable_v<const first_type> &&
+                is_copy_assignable_v<const second_type>){
+        first = __p.first;
+        second = __p.second;
+        return *this;
+    }
+
+    _LIBCPP_HIDE_FROM_ABI constexpr
+    const pair& operator=(pair&& __p) const
+      noexcept(is_nothrow_assignable_v<const first_type&, first_type> &&
+               is_nothrow_assignable_v<const second_type&, second_type>)
+      requires (is_assignable_v<const first_type&, first_type> &&
+                is_assignable_v<const second_type&, second_type>){
+        first = std::forward<first_type>(__p.first);
+        second = std::forward<second_type>(__p.second);
+        return *this;
+    }
+
+    template<class _U1, class _U2>
+    _LIBCPP_HIDE_FROM_ABI constexpr
+    const pair& operator=(const pair<_U1, _U2>& __p) const
+      requires (is_assignable_v<const first_type&, const _U1&> &&
+                is_assignable_v<const second_type&, const _U2&>){
+        first = __p.first;
+        second = __p.second;
+        return *this;
+    }
+
+    template<class _U1, class _U2>
+    _LIBCPP_HIDE_FROM_ABI constexpr
+    const pair& operator=(pair<_U1, _U2>&& __p) const
+      requires (is_assignable_v<const first_type&, _U1> &&
+                is_assignable_v<const second_type&, _U2>){
+        first = std::forward<_U1>(__p.first);
+        second = std::forward<_U2>(__p.second);
+        return *this;
+    }
+#endif // _LIBCPP_STD_VER > 20
+
     template <class _Tuple, typename enable_if<
             _CheckTLC<_Tuple>::template __enable_assign<_Tuple>()
      >::type* = nullptr>
     _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_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 _LIBCPP_CONSTEXPR_AFTER_CXX17
     pair(piecewise_construct_t,
          tuple<_Args1...>& __first_args, tuple<_Args2...>& __second_args,
          __tuple_indices<_I1...>, __tuple_indices<_I2...>);
 #endif
 };
 
 #if _LIBCPP_STD_VER > 14
 template<class _T1, class _T2>

 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _T1, class _T2>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 pair<typename __unwrap_ref_decay<_T1>::type, typename __unwrap_ref_decay<_T2>::type>
 make_pair(_T1&& __t1, _T2&& __t2)
 {
     return pair<typename __unwrap_ref_decay<_T1>::type, typename __unwrap_ref_decay<_T2>::type>
                (_VSTD::forward<_T1>(__t1), _VSTD::forward<_T2>(__t2));
 }
 
 #else  // _LIBCPP_CXX03_LANG
 
 template <class _T1, class _T2>
 inline _LIBCPP_INLINE_VISIBILITY

libcxx/include/utility

struct pair
     T1 first;
     T2 second;
 
     pair(const pair&) = default;
     pair(pair&&) = default;
     explicit(see-below) constexpr pair();
     explicit(see-below) pair(const T1& x, const T2& y);                          // constexpr in C++14
     template <class U = T1, class V = T2> explicit(see-below) pair(U&&, V&&);    // constexpr in C++14
+    template <class U, class V> constexpr explicit(see below) pair(pair<U, V>&); // since C++23
     template <class U, class V> explicit(see-below) pair(const pair<U, V>& p);   // constexpr in C++14
     template <class U, class V> explicit(see-below) pair(pair<U, V>&& p);        // constexpr in C++14
+    template <class U, class V>
+    constexpr explicit(see below) pair(const pair<U1, U2>&&);                    // since C++23
     template <class... Args1, class... Args2>
         pair(piecewise_construct_t, tuple<Args1...> first_args,
              tuple<Args2...> second_args);                                       // constexpr in C++20
 
+    constexpr const pair& operator=(const pair& p) const;                        // since C++23
     template <class U, class V> pair& operator=(const pair<U, V>& p);            // constexpr in C++20
+    template <class U, class V>
+    constexpr const pair& operator=(const pair<U, V>& p) const;                  // since C++23
     pair& operator=(pair&& p) noexcept(is_nothrow_move_assignable<T1>::value &&
                                        is_nothrow_move_assignable<T2>::value);   // constexpr in C++20
+    constexpr const pair& operator=(pair&& p) const;                             // since C++23
     template <class U, class V> pair& operator=(pair<U, V>&& p);                 // constexpr in C++20
+    template <class U, class V>
+    constexpr const pair& operator=(pair<U, V>&& p) const;                       // since C++23
 
     void swap(pair& p) noexcept(is_nothrow_swappable_v<T1> &&
                                 is_nothrow_swappable_v<T2>);                     // constexpr in C++20
+    constexpr void swap(const pair& p) const noexcept(see below);                // since C++23
 };
 
 template<class T1, class T2, class U1, class U2, template<class> class TQual, template<class> class UQual>
 struct basic_common_reference<pair<T1, T2>, pair<U1, U2>, TQual, UQual>;         // since C++23
 
 template<class T1, class T2, class U1, class U2>
 struct common_type<pair<T1, T2>, pair<U1, U2>>;                                  // since C++23
 
constexpr common_comparison_type_t<synth-three-way-result<T1>,
                                      synth-three-way-result<T2>>
     operator<=>(const pair<T1,T2>&, const pair<T1,T2>&);                               // C++20
 
 template <class T1, class T2> pair<V1, V2> make_pair(T1&&, T2&&);                // constexpr in C++14
 template <class T1, class T2>
 void
 swap(pair<T1, T2>& x, pair<T1, T2>& y) noexcept(noexcept(x.swap(y)));            // constexpr in C++20
 
+template<class T1, class T2>
+constexpr void swap(const pair<T1, T2>& x, const pair<T1, T2>& y) noexcept(noexcept(x.swap(y)));    // since C++23
+
 struct piecewise_construct_t { explicit piecewise_construct_t() = default; };
 inline constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t();
 
 template <class T> struct tuple_size;
 template <size_t I, class T> struct tuple_element;
 
 template <class T1, class T2> struct tuple_size<pair<T1, T2> >;
 template <class T1, class T2> struct tuple_element<0, pair<T1, T2> >;

libcxx/test/std/utilities/utility/pairs/pairs.pair/assign_const_copy_convert.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <utility>
+
+// template <class T1, class T2> struct pair
+// template<class U1, class U2> constexpr
+// const pair& operator=(const pair<U1, U2>& p) const;
+
+#include <cassert>
+#include <utility>
+
+#include "test_macros.h"
+#include "../../../tuple/tuple.tuple/tuple.assign/types.h"
+
+// Constraints:
+// is_assignable_v<const first_type&, const U1&> is true, and
+// is_assignable_v<const second_type&, const U2&> is true.
+
+// clang-format off
+static_assert(std::is_assignable_v<const std::pair<int&, int&>&,
+                                   const std::pair<long&, long&>&>);
+static_assert(!std::is_assignable_v<const std::pair<int, int>&,
+                                    const std::pair<long, long>&>);
+static_assert(!std::is_assignable_v<const std::pair<int, int&>&,
+                                    const std::pair<long, long&>&>);
+static_assert(!std::is_assignable_v<const std::pair<int&, int>&,
+                                    const std::pair<long&, long>&>);
+
+static_assert(std::is_assignable_v<
+    const std::pair<AssignableFrom<ConstCopyAssign>, AssignableFrom<ConstCopyAssign>>&,
+          const std::pair<ConstCopyAssign, ConstCopyAssign>&>);
+static_assert(!std::is_assignable_v<
+    const std::pair<AssignableFrom<CopyAssign>, AssignableFrom<CopyAssign>>&,
+                const std::pair<CopyAssign, CopyAssign>&>);
+
+// clang-format on
+
+constexpr bool test() {
+  // reference types
+  {
+    int i1  = 1;
+    int i2  = 2;
+    long j1 = 3;
+    long j2 = 4;
+    const std::pair<int&, int&> p1{i1, i2};
+    const std::pair<long&, long&> p2{j1, j2};
+    p2 = p1;
+    assert(p2.first == 1);
+    assert(p2.second == 2);
+  }
+
+  // user defined const copy assignment
+  {
+    const std::pair<ConstCopyAssign, ConstCopyAssign> p1{1, 2};
+    const std::pair<AssignableFrom<ConstCopyAssign>, AssignableFrom<ConstCopyAssign>> p2{3, 4};
+    p2 = p1;
+    assert(p2.first.v.val == 1);
+    assert(p2.second.v.val == 2);
+  }
+
+  // The correct assignment operator of the underlying type is used
+  {
+    std::pair<TracedAssignment, TracedAssignment> t1{};
+    const std::pair<AssignableFrom<TracedAssignment>, AssignableFrom<TracedAssignment>> t2{};
+    t2 = t1;
+    assert(t2.first.v.constCopyAssign == 1);
+    assert(t2.second.v.constCopyAssign == 1);
+  }
+
+  return true;
+}
+
+int main(int, const char**) {
+  test();
+// gcc cannot have mutable member in constant expression
+#if !defined(TEST_COMPILER_GCC)
+  static_assert(test());
+#endif
+}

libcxx/test/std/utilities/utility/pairs/pairs.pair/assign_const_copy_pair.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <utility>
+
+// template <class T1, class T2> struct pair
+// constexpr const pair& operator=(const pair& p) const;
+
+#include <cassert>
+#include <utility>
+
+#include "test_macros.h"
+#include "../../../tuple/tuple.tuple/tuple.assign/types.h"
+
+// Constraints:
+// is_copy_assignable<const first_type> is true and
+// is_copy_assignable<const second_type> is true.
+
+// clang-format off
+static_assert(std::is_assignable_v<const std::pair<int&, int&>&,
+                                   const std::pair<int&, int&>&>);
+static_assert(!std::is_assignable_v<const std::pair<int, int>&,
+                                    const std::pair<int, int>&>);
+static_assert(!std::is_assignable_v<const std::pair<int, int&>&,
+                                    const std::pair<int, int&>&>);
+static_assert(!std::is_assignable_v<const std::pair<int&, int>&,
+                                    const std::pair<int&, int>&>);
+
+static_assert(std::is_assignable_v<const std::pair<ConstCopyAssign, ConstCopyAssign>&,
+                                   const std::pair<ConstCopyAssign, ConstCopyAssign>&>);
+static_assert(!std::is_assignable_v<const std::pair<CopyAssign, CopyAssign>&,
+                                   const std::pair<CopyAssign, CopyAssign>&>);
+
+// clang-format on
+
+constexpr bool test() {
+  // reference types
+  {
+    int i1    = 1;
+    int i2    = 2;
+    double d1 = 3.0;
+    double d2 = 5.0;
+    const std::pair<int&, double&> p1{i1, d1};
+    const std::pair<int&, double&> p2{i2, d2};
+    p2 = p1;
+    assert(p2.first == 1);
+    assert(p2.second == 3.0);
+  }
+
+  // user defined const copy assignment
+  {
+    const std::pair<ConstCopyAssign, ConstCopyAssign> p1{1, 2};
+    const std::pair<ConstCopyAssign, ConstCopyAssign> p2{3, 4};
+    p2 = p1;
+    assert(p2.first.val == 1);
+    assert(p2.second.val == 2);
+  }
+
+  // The correct assignment operator of the underlying type is used
+  {
+    std::pair<TracedAssignment, const TracedAssignment> t1{};
+    const std::pair<TracedAssignment, const TracedAssignment> t2{};
+    t2 = t1;
+    assert(t2.first.constCopyAssign == 1);
+    assert(t2.second.constCopyAssign == 1);
+  }
+
+  return true;
+}
+
+int main(int, const char**) {
+  test();
+// gcc cannot have mutable member in constant expression
+#if !defined(TEST_COMPILER_GCC)
+  static_assert(test());
+#endif
+}

libcxx/test/std/utilities/utility/pairs/pairs.pair/assign_const_move_convert.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <utility>
+
+// template <class T1, class T2> struct pair
+// template <class U1, class U2>
+// constexpr const pair& operator=(pair<U1, U2>&& p) const;
+
+#include <cassert>
+#include <utility>
+
+#include "test_macros.h"
+#include "../../../tuple/tuple.tuple/tuple.assign/types.h"
+
+// Constraints:
+// is_assignable<const first_type&, U1> is true and
+// is_assignable<const second_type&, U2> is true.
+
+// clang-format off
+static_assert(std::is_assignable_v<const std::pair<int&&, int&&>&,
+                                   std::pair<long&&, long&&>&&>);
+static_assert(!std::is_assignable_v<const std::pair<int, int>&,
+                                    std::pair<long, long>&&>);
+static_assert(!std::is_assignable_v<const std::pair<int, int&&>&,
+                                    std::pair<long, long&&>&&>);
+static_assert(!std::is_assignable_v<const std::pair<int&&, int>&,
+                                    std::pair<long&&, long>&&>);
+
+static_assert(std::is_assignable_v<
+    const std::pair<AssignableFrom<ConstMoveAssign>, AssignableFrom<ConstMoveAssign>>&,
+                std::pair<ConstMoveAssign, ConstMoveAssign>&&>);
+static_assert(!std::is_assignable_v<
+    const std::pair<AssignableFrom<MoveAssign>, AssignableFrom<MoveAssign>>&,
+                std::pair<MoveAssign, MoveAssign>&&>);
+
+// clang-format on
+
+constexpr bool test() {
+  // reference types
+  {
+    int i1  = 1;
+    int i2  = 2;
+    long j1 = 3;
+    long j2 = 4;
+    std::pair<int&&, int&&> p1{std::move(i1), std::move(i2)};
+    const std::pair<long&&, long&&> p2{std::move(j1), std::move(j2)};
+    p2 = std::move(p1);
+    assert(p2.first == 1);
+    assert(p2.second == 2);
+  }
+
+  // user defined const move assignment
+  {
+    std::pair<ConstMoveAssign, ConstMoveAssign> p1{1, 2};
+    const std::pair<AssignableFrom<ConstMoveAssign>, AssignableFrom<ConstMoveAssign>> p2{3, 4};
+    p2 = std::move(p1);
+    assert(p2.first.v.val == 1);
+    assert(p2.second.v.val == 2);
+  }
+
+  // The correct assignment operator of the underlying type is used
+  {
+    std::pair<TracedAssignment, TracedAssignment> t1{};
+    const std::pair<AssignableFrom<TracedAssignment>, AssignableFrom<TracedAssignment>> t2{};
+    t2 = std::move(t1);
+    assert(t2.first.v.constMoveAssign == 1);
+    assert(t2.second.v.constMoveAssign == 1);
+  }
+
+  return true;
+}
+
+int main(int, const char**) {
+  test();
+// gcc cannot have mutable member in constant expression
+#if !defined(TEST_COMPILER_GCC)
+  static_assert(test());
+#endif
+}

libcxx/test/std/utilities/utility/pairs/pairs.pair/assign_const_move_pair.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <utility>
+
+// template <class T1, class T2> struct pair
+// constexpr const pair& operator=(pair&& p) const;
+
+#include <cassert>
+#include <utility>
+
+#include "test_macros.h"
+#include "../../../tuple/tuple.tuple/tuple.assign/types.h"
+
+// Constraints:
+// is_assignable<const first_type&, first_type> is true and
+// is_assignable<const second_type&, second_type> is true.
+
+// clang-format off
+static_assert(std::is_assignable_v<const std::pair<int&&, int&&>&,
+                                   std::pair<int&&, int&&>&&>);
+static_assert(!std::is_assignable_v<const std::pair<int, int>&,
+                                    std::pair<int, int>&&>);
+static_assert(!std::is_assignable_v<const std::pair<int, int&&>&,
+                                    std::pair<int, int&&>&&>);
+static_assert(!std::is_assignable_v<const std::pair<int&&, int>&,
+                                    std::pair<int&&, int>&&>);
+
+static_assert(std::is_assignable_v<const std::pair<ConstMoveAssign, ConstMoveAssign>&,
+                                   std::pair<ConstMoveAssign, ConstMoveAssign>&&>);
+static_assert(!std::is_assignable_v<const std::pair<MoveAssign, MoveAssign>&,
+                                   std::pair<MoveAssign, MoveAssign>&&>);
+
+// clang-format on
+
+constexpr bool test() {
+  // reference types
+  {
+    int i1    = 1;
+    int i2    = 2;
+    double d1 = 3.0;
+    double d2 = 5.0;
+    std::pair<int&&, double&&> p1{std::move(i1), std::move(d1)};
+    const std::pair<int&&, double&&> p2{std::move(i2), std::move(d2)};
+    p2 = std::move(p1);
+    assert(p2.first == 1);
+    assert(p2.second == 3.0);
+  }
+
+  // user defined const move assignment
+  {
+    std::pair<ConstMoveAssign, ConstMoveAssign> p1{1, 2};
+    const std::pair<ConstMoveAssign, ConstMoveAssign> p2{3, 4};
+    p2 = std::move(p1);
+    assert(p2.first.val == 1);
+    assert(p2.second.val == 2);
+  }
+
+  // The correct assignment operator of the underlying type is used
+  {
+    std::pair<TracedAssignment, const TracedAssignment> t1{};
+    const std::pair<TracedAssignment, const TracedAssignment> t2{};
+    t2 = std::move(t1);
+    assert(t2.first.constMoveAssign == 1);
+    assert(t2.second.constCopyAssign == 1);
+  }
+
+  return true;
+}
+
+int main(int, const char**) {
+  test();
+// gcc cannot have mutable member in constant expression
+#if !defined(TEST_COMPILER_GCC)
+  static_assert(test());
+#endif
+}

libcxx/test/std/utilities/utility/pairs/pairs.pair/ctor_pair_U_V_const_move.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <utility>
+
+// template <class T1, class T2> struct pair
+// template <class U1, class U2>
+//   constexpr explicit(see below) pair(const pair<U2, U2>&& p);
+
+#include <cassert>
+#include <utility>
+
+#include "../../../tuple/tuple.tuple/tuple.cnstr/convert_types.h"
+#include "test_macros.h"
+
+// Constraints:
+// is_constructible_v<T1, decltype(get<0>(FWD(p)))> is true and
+// is_constructible_v<T2, decltype(get<1>(FWD(p)))> is true.
+struct X {};
+struct Y {};
+struct NotConvertibleToXorY {};
+
+static_assert(std::is_constructible_v<std::pair<X, Y>, const std::pair<X, Y>&&>);
+static_assert(!std::is_constructible_v<std::pair<X, Y>, const std::pair<NotConvertibleToXorY, Y>&&>);
+static_assert(!std::is_constructible_v<std::pair<X, Y>, const std::pair<X, NotConvertibleToXorY>&&>);
+static_assert(!std::is_constructible_v<std::pair<X, Y>, const std::pair<NotConvertibleToXorY, NotConvertibleToXorY>&&>);
+
+// The expression inside explicit is equivalent to:
+// !is_convertible_v<decltype(get<0>(FWD(p))), first_type> ||
+//  !is_convertible_v<decltype(get<1>(FWD(p))), second_type>.
+static_assert(std::is_convertible_v<const std::pair<X, Y>&&, std::pair<ConvertibleFrom<X>, ConvertibleFrom<Y>>>);
+static_assert(
+    !std::is_convertible_v<const std::pair<X, Y>&&, std::pair<ConvertibleFrom<X>, ExplicitConstructibleFrom<Y>>>);
+static_assert(
+    !std::is_convertible_v<const std::pair<X, Y>&&, std::pair<ExplicitConstructibleFrom<X>, ConvertibleFrom<Y>>>);
+static_assert(!std::is_convertible_v<const std::pair<X, Y>&&,
+                                     std::pair<ExplicitConstructibleFrom<X>, ExplicitConstructibleFrom<Y>>>);
+
+constexpr bool test() {
+  // simple case: init pair<const T&&, const U&&> from const pair<T, U>&&
+  {
+    const std::pair<int, int> p1{1, 2};
+    std::pair<const int&&, const int&&> p2{std::move(p1)};
+    assert(&(p2.first) == &(p1.first));
+    assert(&(p2.second) == &(p1.second));
+  }
+
+  // test implicit conversions.
+  {
+    const std::pair<ConstMove, int> p1{1, 2};
+    std::pair<ConvertibleFrom<ConstMove>, ConvertibleFrom<int>> p2 = std::move(p1);
+    assert(p2.first.v.val == 1);
+    assert(p2.second.v == 2);
+  }
+
+  // test explicit conversions.
+  {
+    const std::pair<ConstMove, int> p1{1, 2};
+    std::pair<ExplicitConstructibleFrom<ConstMove>, ExplicitConstructibleFrom<int>> p2{std::move(p1)};
+    assert(p2.first.v.val == 1);
+    assert(p2.second.v == 2);
+  }
+
+  // test correct constructors of underlying types are called
+  {
+    const std::pair<TracedCopyMove, TracedCopyMove> p1{};
+    std::pair<ConvertibleFrom<TracedCopyMove>, ConvertibleFrom<TracedCopyMove>> p2{std::move(p1)};
+    assert(constMoveCtrCalled(p2.first.v));
+    assert(constMoveCtrCalled(p2.second.v));
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+  return 0;
+}

libcxx/test/std/utilities/utility/pairs/pairs.pair/ctor_pair_U_V_ref.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <utility>
+
+// template <class T1, class T2> struct pair
+// template <class U1, class U2>
+//   constexpr explicit(see below) pair(pair<U2, U2>& p);
+
+#include <cassert>
+#include <utility>
+
+#include "../../../tuple/tuple.tuple/tuple.cnstr/convert_types.h"
+#include "test_macros.h"
+
+// Constraints:
+// is_constructible_v<T1, decltype(get<0>(FWD(p)))> is true and
+// is_constructible_v<T2, decltype(get<1>(FWD(p)))> is true.
+struct X {};
+struct Y {};
+struct NotConvertibleToXorY {};
+
+static_assert(std::is_constructible_v<std::pair<X, Y>, std::pair<X, Y>&>);
+static_assert(!std::is_constructible_v<std::pair<X, Y>, std::pair<NotConvertibleToXorY, Y>&>);
+static_assert(!std::is_constructible_v<std::pair<X, Y>, std::pair<X, NotConvertibleToXorY>&>);
+static_assert(!std::is_constructible_v<std::pair<X, Y>, std::pair<NotConvertibleToXorY, NotConvertibleToXorY>&>);
+
+// The expression inside explicit is equivalent to:
+// !is_convertible_v<decltype(get<0>(FWD(p))), first_type> ||
+//  !is_convertible_v<decltype(get<1>(FWD(p))), second_type>.
+static_assert(std::is_convertible_v<std::pair<X, Y>&, std::pair<ConvertibleFrom<X>, ConvertibleFrom<Y>>>);
+static_assert(!std::is_convertible_v<std::pair<X, Y>&, std::pair<ConvertibleFrom<X>, ExplicitConstructibleFrom<Y>>>);
+static_assert(!std::is_convertible_v<std::pair<X, Y>&, std::pair<ExplicitConstructibleFrom<X>, ConvertibleFrom<Y>>>);
+static_assert(
+    !std::is_convertible_v<std::pair<X, Y>&, std::pair<ExplicitConstructibleFrom<X>, ExplicitConstructibleFrom<Y>>>);
+
+constexpr bool test() {
+  // use case in zip. Init pair<T&, U&> from pair<T, U>&
+  {
+    std::pair<int, int> p1{1, 2};
+    std::pair<int&, int&> p2{p1};
+    assert(&(p2.first) == &(p1.first));
+    assert(&(p2.second) == &(p1.second));
+  }
+
+  // test implicit conversions.
+  {
+    std::pair<MutableCopy, int> p1{1, 2};
+    std::pair<ConvertibleFrom<MutableCopy>, ConvertibleFrom<int>> p2 = p1;
+    assert(p2.first.v.val == 1);
+    assert(p2.second.v == 2);
+  }
+
+  // test explicit conversions.
+  {
+    std::pair<MutableCopy, int> p1{1, 2};
+    std::pair<ExplicitConstructibleFrom<MutableCopy>, ExplicitConstructibleFrom<int>> p2{p1};
+    assert(p2.first.v.val == 1);
+    assert(p2.second.v == 2);
+  }
+
+  // test correct constructors of underlying types are called
+  {
+    std::pair<TracedCopyMove, TracedCopyMove> p1{};
+    std::pair<ConvertibleFrom<TracedCopyMove>, ConvertibleFrom<TracedCopyMove>> p2{p1};
+    assert(nonConstCopyCtrCalled(p2.first.v));
+    assert(nonConstCopyCtrCalled(p2.second.v));
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+  return 0;
+}