[libc++][P2321R2] Add const overloads to tuple swap, construction and assignment

[huixie90]

Summary

Add const overloads to tuple swap, construction and assignment

Rational of the these tuple changes needed for zip

1. Constructor overloads that takes non-const lvalue reference, and const rvalue reference.
   
   Short answer: make zip_view::iterator model indirectly_readable.
   
   Long answer: indirectly_readable requires a common_reference between "lvalue reference to value_type" and reference, in zip's case, this could be tuple<Foo>& (lvalue reference to value_type) and tuple<Foo&> (reference). We need be able to construct tuple<Foo&> from tuple<Foo>&. pre-C++23, the tuple's converting copy constructors takes only const tuple<UTyles...>&. This won't work here because we cannot bind const Foo& to Foo&.

2. const member assignment operators
   
   Short answer: make zip_view::iterator model indirectly_writable
   
   Long answer: indirectly_writable requires the type const decltype(*it) to be assignable. The const there is to prevent cases such as sorting a transformed of range of prvalue string. It would have compiled without const because std::string{} = std::string{} is a valid expression. but const std::string{} = std::string{} is not. If the range is a range of references, adding const doesn't do anything. using T = int&, then const T is also int&. So this const in the concept is to ban range of prvalues. However, in zip case, although the reference is prvalue tuple, it is really just a proxy. If we have a tuple of references, we do want to model the concept because the underlying ranges are writable. So we need the const assignment operators if underlying types are const assignable (reference types are const assignable).

3. const swap
   
   because of the const assignment operator added above, the default std::swap's triple-move would lead to wrong result for const tuple<Foo&>

Now, here is the summary of the implementations.

1. for constructors that takes cvref variation of tuple<UTypes...>, there used to be two SFINAE helper _EnableCopyFromOtherTuple, _EnableMoveFromOtherTuple. And the implementations of these two helpers seem to slightly differ from the spec. But now, we need 4 variations. Instead of adding another two, this change refactored it to a single one _EnableCtrFromUTypesTuple, which directly maps to the spec without changing the C++11 behaviour. However, we need the helper __copy_cvref_t to get the type of std::get<i>(cvref tuple<Utypes...>) for different cvref, so I made __copy_cvref_t to be available in C++11.

2. for constructors that takes variations of std::pair, there used to be four helpers _EnableExplicitCopyFromPair, _EnableImplicitCopyFromPair, _EnableImplicitMoveFromPair, _EnableExplicitMoveFromPair. Instead of adding another four, this change refactored into two helper _EnableCtrFromPair and _BothImplicitlyConvertible. This also removes the need to use _nat

3. for const member assignment operator, since the requirement is very simple, I haven't refactored the old code but instead directly adding the new c++23 code.

4. for const swap, I pretty much copy pasted the non-const version to make these overloads look consistent

5. while doing these change, I found two of the old constructors wasn't marked constexpr for C++20 but they should. fixed them and added unit tests

[• Quuxplusone]

P2321R2 "zip" is a big paper, so it makes sense to chunk it up into smaller PRs like this. But I think this PR is too small. The notions of "const-swappable" and "const-assignable" seem very tightly coupled to each other. Therefore I'm pretty confident in asserting that whatever PR implements const-swap for T, should also implement const-assign for T.

It might even make sense to implement all the tuple stuff and all the pair stuff together in this same PR, although I'm not at all confident of that.

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.special/non_member_swap_const.pass.cpp

22–26

struct S {
  int *calls;
  friend constexpr void swap(S& a, S& b) {
    *calls += 1;
  }
};
struct CS {
  int *calls;
  friend constexpr void swap(const CS& a, const CS& b) {
    *calls += 1;
  }
};

And then test various mixtures of S, CS, and S&; and for the behavior tests, I wouldn't focus on the ultimate effects (like a.i == 1) but instead on whether they're actually calling the user's ADL swap function correctly:

static_assert( std::is_swappable_v<std::tuple<>>);
static_assert( std::is_swappable_v<std::tuple<S>>);
static_assert( std::is_swappable_v<std::tuple<CS>>);
static_assert( std::is_swappable_v<std::tuple<S&>>);
static_assert( std::is_swappable_v<std::tuple<CS, S>>);
static_assert( std::is_swappable_v<std::tuple<CS, S&>>);
static_assert( std::is_swappable_v<const std::tuple<>>);
static_assert(!std::is_swappable_v<const std::tuple<S>>);
static_assert( std::is_swappable_v<const std::tuple<CS>>);
static_assert( std::is_swappable_v<const std::tuple<S&>>);
static_assert(!std::is_swappable_v<const std::tuple<CS, S>>);
static_assert( std::is_swappable_v<const std::tuple<CS, S&>>);
{
  int cs_calls = 0;
  int s_calls = 0;
  S s1{s_calls};
  S s2{s_calls};
  const std::tuple<CS, S&> t1 = { CS{cs_calls}, s1 };
  const std::tuple<CS, S&> t2 = { CS{cs_calls}, s2 };
  swap(t1, t2);
  assert(cs_calls == 1);
  assert(s_calls == 1);
}

And then I guess there should be some tests for is_nothrow_swappable, too; and for a type that isn't swappable at all.

[Mordante]

I didn't have a close look, I prefer to see a version with @Quuxplusone's points addressed.

Can you update the C++2b status page to have a partial implementation of P2321R2?

Since P2321 is a large paper I think it makes sense to have a separate review with a new status pages so we can keep track of the part that are and aren't implemented. Can you take care of that?

[Mordante]

I just see D116538 already updates the status page, so discard that request.

[philnik]

I can add a status page. Is there any way to host the website locally for checking that it looks as expected?

[Mordante]

You can generate the .html files locally and then look at the output, no webserver required.
This requires Sphinx on your system.
The build instructions are:

• reconfigure cmake with -DLLVM_ENABLE_SPHINX=ON
• build the target docs-libcxx-html

When it works it gives the path where the output is stored. This should be ${BUILDDIR}/libcxx/docs/html

If you need further assistance, best ask on Discord.

[philnik]

• Updated test
• Fixed swap
• Add constructor and assignment overloads

I know the tests aren't covering everything. First of all I want to know if I understood the standard correctly.

[jloser]

libcxx/include/tuple

322

No action required, but it looks slightly odd that this uses noexcept directly whereas the one above uses _NOEXCEPT_ . Ditto for the new swap implemented below.

[• Quuxplusone]

libcxx/include/tuple

229

Please use __x and __y for consistency with lines 201–207.
Separately, don't you need a noexcept-spec similar to line 204?

322

I suspect this (and lines 381 and 479) should be noexcept(is_nothrow_swappable_v<const __tuple_leaf&>). If I'm right, you should be able to (and thus, should) write a regression test that detects this mistake by smacking into the noexcept and std::terminate'ing when in fact it shouldn't.
Here and line 380, please be consistent: either return int in both places for consistency with lines 299 and 373, or return void in both places because we can. (Ah, but if you return void then you'll have to use a fold-expression on line 480 instead of a __swallow. So return int for consistency.)

494

Since this is C++17-or-later, you can use noexcept((is_nothrow_swappable_v<const _Tp&> && ...))

779–782

(1) Can't use requires because of _LIBCPP_HAS_NO_CONCEPTS.
(2) Don't want to use requires because what you actually meant is sizeof...(_Up) == sizeof...(_Tp) should be true, not just well-formed. I'd go so far as to claim that in libc++ contexts, mixing enable_if_t with requires is always wrong. (But maybe that's trivially true because if you were able to use requires you wouldn't need enable_if_t to express a constraint.)
(3) __enable_if_t<sizeof...(_Up) == sizeof...(_Tp) && _EnableCopyFromOtherTuple<_Up...>::value>* = nullptr

794

Bikeshed: should explicit(...) be indented on lines 751 and 759? Personally I think not. It's not a "subordinate" clause in any sense; we don't normally indent the return type or constexpr when that's on a line by itself.
Significant: I assume you mean explicit(!(...)), right? Haven't checked the wording, but I would guess we want the ctor to be implicit only if all the types are convertible, not explicit. Please add a regression test for each of these explicits; you can check by temporarily removing the ! from one at a time, and making sure that some test fails, for each of them.

850

& should presumably be &&; please add a regression test.

993–1043

Again I haven't checked the wording (just cppreference), but this feels convoluted and thus wrong. It should be more like:

• EnableImplicitMoveFromPair if both types are implicitly convertible
• EnableExplicitMoveFromPair if both types are explicitly constructible and not EnableImplicitMoveFromPair

Which I think is how it was.
The only thing C++23 changes, AFAIK, is that now we've got two more ctors taking pair& and const pair&& in addition to C++11's const pair& and pair&&.

Actually I think your way of doing it below (lines 987-1012) is fine, except that you're misusing requires again — and you probably need to #if _LIBCPP_STD_VER <= 20 the existing ctors from pair, so that in C++23 we get only the new conditionally-explicit four below.

[philnik]

• Address comments

[• Quuxplusone]

libcxx/include/tuple

322

Even though I said is_nothrow_swappable_v<const __tuple_leaf&> above, it strikes me now that for consistency with line 300 we really want is_nothrow_swappable_v<const __tuple_leaf> (no ampersand).
Also, s/__rhs/__t/g here and line 383 and line 482.

774

Right? (Please add a regression test.)

828

You're going to need the same bool _Const technique here. Please add a regression test that can detect the problem (e.g. via a type A where A&& is convertible to B but B(const A&&)=delete, and vice versa).

1109

For comparison against line 1101, I think it'd be best to use is_assignable<X&, Y> for every one of these conditions, rather than switching from is_assignable to is_copy_assignable/is_move_assignable in special cases.
Chesterton's Fence on the use of _And rather than __all: I suspect there's a reason we want the short-circuiting behavior here. Please adjust line 1101 the same way. (Again, the guideline is "be consistent with pre-existing code unless you understand why the old code must be wrong.")

libcxx/include/type_traits

506–509

Uh...? This completely changes the meaning of e.g. _SecondType<int> from "ill-formed" to "well-formed __nat." There's no way that's safe.

[philnik]

• Rebased
• Address comments

[philnik]

libcxx/include/tuple

828

I wasn't able to reproduce it.

libcxx/include/type_traits

506–509

_FirstType and _SecondType are exclusively used in <tuple> and only in is_* contexts. If I'm not mistaken __nat should be false in every single case.

[EricWF]

I would like to test this against Google's source. I'll try to get that done by early this week. Please do not commit this until then.
Tuple is so sensitive that changing whitespace breaks users.

libcxx/include/tuple

754–755

What's __maybe_const? Should it be in this patch?

848

These bits of SFINAE were written very specifically because tuple is a very weird beast.

I'm surprised we don't have a test in the test suite that breaks after changing this, because I thought I added one.

There are certain SFINAE loops that crop up where checking these properties in the specific order is/was important.

1368

What's with the reference here

libcxx/include/type_traits

470

__nat is an awful hack. Let's not user it more.

506–509

I'm with Arthur, this should not succeed. This needs to be substitution failure.

[EricWF]

libcxx/include/tuple

754–755

Ignore this.

[philnik]

• Fixes

@EricWF This patch will probably not be ready within the next week. I can ping you again before landing this if you want.

libcxx/include/type_traits

506–509

In which case does it have to be a substitution failure? IIRC there are cases where I need it to not be a substitution failure.

[philnik]

• Try to fix CI

[philnik]

• Next try

[philnik]

• Fix no exceptions

[philnik]

• Add test_macros include

[ldionne]

Thanks a lot for the patch! This is a tough one for sure. I thought we would never add new constructors to tuple, but it looks like they did it again!

libcxx/include/tuple

223

I would *not* guard this with _LIBCPP_STD_VER since this is internal. We can guard the top-level swap on std::tuple only.

225

Since this is new code, I would recommend not using inline here.

320

Same, I would *not* guard this with _LIBCPP_STD_VER since this is internal.

[ldionne]

libcxx/include/tuple

495

Is there a reason for not doing it like we do for non-const types? Let's use the same approach for consistency, whatever that is.

745

This comment is now incorrect, I would say instead tuple([const] tuple<U...>&) constructors (including allocator_arg_t variants) or something like that.

The && comment below is also incorrect now -- please audit to make sure there aren't others too.

754–755

I don't like making these sorts of comments, but I don't understand why the indentation was changed. It used to be lined up to tabs.

830

Don't you need to make changes here too to pass _Const and use __maybe_const<_Const, _Tp>&& instead? I think this should look like:

template <bool _Const, class ..._Up>
struct _EnableMoveFromOtherTuple : _And<
    _Not<is_same<tuple<_Tp...>, tuple<_Up...> > >,
    _Lazy<_Or,
        _BoolConstant<sizeof...(_Tp) != 1>,
        // _Tp and _Up are 1-element packs - the pack expansions look
        // weird to avoid tripping up the type traits in degenerate cases
        _Lazy<_And,
            _Not<is_convertible<__maybe_const<_Const, tuple<_Up>>&&, _Tp> >...,
            _Not<is_constructible<_Tp, __maybe_const<_Const, tuple<_Up>>&& > >...
        >
    >,
    is_constructible<_Tp, __maybe_const<_Const, _Up>&&>...
> { };

This should be observable if you have a type Foo in your tuple like this:

struct Foo {
  Foo(Other const&&);
  Foo(Other&&) = delete;
};

If you use is_constructible<_Tp, _Up> (where _Tp=Foo and _Up=Other), we'll prefer the Foo(Other&&) constructor and the answer will be "no". If we use my proposed version, it should use Foo(Other const&&) instead and be satisfied.

https://godbolt.org/z/b47ffv43P

Please add a test for this in all the constructors that take rvalue-refs.

848

I think what Eric's saying here is that you need to test for _EnableCopyFromPair *before* you test the two is_convertible conditions.

I think you could witness the difference by using a type that is *not* constructible from _Up, but where a conversion from _Up triggers a hard error. In that case, the fact that you changed the order of checking will cause you to instantiate the conversion operator before the constructor, and explode. If you had checked for the constructibility first, you'd have gotten a false answer and stopped there, instead of being tripped up by the hard error later on while trying to check whether the constructor should be explicit or not.

Please add tests for this -- we actually see these sorts of funky bad-behaved constructors and conversions in the wild. I remember breaking nlohmann::json with a change a couple years ago -- it wasn't fun. I'm not sure whether it ended up being our fault our theirs, but regardless, we want to be bullet proof to avoid breaking widely used libraries, because we look like jokers when that happens :-).

1015–1017

Minor stylistic thing, but I'd do class _Alloc, class _U1, Class _U2 on the same line for consistency with the rest of the code in this file.

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.assign/convert_cpp23.pass.cpp

17

Why does it fail on GCC?

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/convert_cpp23.pass.cpp

2

Please follow the convention used for testing tuple constructors where we have one test file per constructor. It's a real pain, but it's the best way to ensure that we are testing everything. If you want to share code, that's fine, create a local .h in that directory.

14

Please use explicit(see-below), otherwise it looks like those are always implicit. Applies everywhere.

[EricWF]

Other than a couple breakages caused by this not working in C++14/C++11, I haven't seen anything blow up at Google, though I've yet to get a full test run in.
That is to say, I think this is good to land once the other inline comments are addressed.

libcxx/include/tuple

754–755

Actually, nevermind. __maybe_const is only available after C++17, but this compiles in older dialects. So we need to expose __maybe_const in older dialects.

libcxx/include/type_traits

471

I

506–509

It doesn't need to be substitution failure, but substitution failure is 1000x better than generating a bogus type and continuing on.
I'm not OK with this change.

In what cases are you trying to apply first/second type to a pack that doesn't have them?

[EricWF]

libcxx/include/tuple

994–997

If we don't have 2 types in the tuple, we shouldn't even be attempting this is_convertible check on the first one.

Don't instantiate any constructability/convertability checks in tuple if there are obvious reasons why the constructor evaluating them shouldn't be chosen, such as the arity.

1125

Are we implementing this for std::array too?

[EricWF]

libcxx/include/tuple

1115

I don't know that we need to do the _If trick here. Because it's not the true "copy assignment operator", we don't need to worry about the compiler generating one.

Try writing these like normal overloads with normal SFINAE.

libcxx/include/type_traits

471

I'm still against this. That's not how these meta-functions are meant to work. Also

4098

Use _If here to avoid adding more template instantiations.

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.assign/convert_cpp23.pass.cpp

17

Oh, good catch.

I suspect it's because GCC rejects mutating mutable members in constant expressions.

Since we want *some* test coverage on GCC, I suggest we find a way to make at least part of this test pass under it.

[huixie90]

Had a chat with @philnik on discord and agreed to commandeer this change

[huixie90]

[libc++][P2321R2] Add const overloads to tuple swap, construction and assignment

libcxx/include/tuple

848

I fixed the ordering issue from the previous version. But I am not sure If I understand the test case. IIUC, you are suggesting a case where
std::is_constructible_v<T, U> is false, but
std::is_convertible_v<U, T> is hard error

IIUC, convertible is a stricter version of constructible. if is_convertible_v has a hard error, the conversion operator/constructor that causes the error would also cause a hard error when evaluating is_constructible. or did I miss something?

1115

For this one, I tempt to keep _If as it is. few reasons:

1. This function does not naturally have a deduced type that can be used by SFINAE
2. I could introduce some template parameters, but that needs to have default value with Tp.... I am not sure if that is going to be very readable. Also, it will make it look like the overload that takes tuple<Us...>
3. The best way I think is to use requires but I am not sure if it is OK to use it as the rest of (C++20 bit) the file does not use it

1125

I am not sure if it is going to be very useful. The main use case (at least for the purpose of p2321r2) for these const overloads of assignment operators is that we can assign const tuple of reference types. (well, the const value types usually cannot be assigned to). I don't think std::array supports references

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.assign/convert_cpp23.pass.cpp

17

I disabled running these tests on compile time on gcc. but at least, it would run the tests at runtime with gcc

[ldionne]

I have some comments, but I really like the current state of this patch. This implements part of a new paper while refactoring a bunch of stuff and making it simpler at once, which is really great. Requesting changes because I'd like to take a look after comments have been applied, but I think this looks really good. Also, the tests are nicely structured and seem to cover all the required cases except for perhaps one minor detail mentioned in the comments. Thanks!

libcxx/include/tuple

30

Nit, but let's be consistent. Here and below.

752

Really small nitpick, but we generally use ctor instead of ctr for constructor (at least it's what I've seen so far).

754–755

I'm not requesting it, however if you'd like to add a regression test where for example _BoolConstant<sizeof...(_Tp) != 1> is false, but evaluating is_constructible<_Tp, _OtherTuple> is a hard error, I think it would catch this.

756–757

Mentioning _Not<T> does not instantiate T immediately, it only does when you do _Not<T>::whatever. Since you only do that lazily with my suggested edits to _And and _Or, you don't need _Lazy at this level anymore -- at least I think you don't, but our tests should tell you if I'm right.

757

758–759

What happens if you remove these conditions? The comments should explain what is the behavior that we are preserving.

761

848

I think I was thinking about a type having a conversion operator that triggers a hard error. However, it doesn't seem to apply anymore, but it would be nice to ensure that we don't trip over a type T where is_constructible<T, U>::value is false, but where is_convertible<T, U>::value is a hard error (by defining a conversion operator from U to T that causes a hard error). Let me know if you think this doesn't make sense, it might be impossible to actually trigger this issue but I'd need to dive deeper to be certain.

859

Do we need _SecondType and _FirstType in <type_traits> anymore? If not, let's remove them.

937

It's pretty obvious, but just to stay consistent with the other constructors above. This also applies to the other constructors below.

1109

We could use requires instead since we are in C++ > 20 and we only support compilers that support concepts.

1115

Per the above comment, we can use requires here and mark this original comment as done, IMO.

1125

Also, note that we don't support assigning tuple = array anymore. This was an extension, but it was removed.

1168

I like that you use _BoolConstant<sizeof...(_Tp) == sizeof...(_UTypes)> for self-documentation of the condition, however technically it is not needed because is_assignable<const _Tp&, const _UTypes&>... would SFINAE-away if that were not the case. I suggest you leave as-is for documentation purposes, I just wanted to point it out.

1190–1197

I think we should either use _EnableAssignFromPair with the const and the non-const overloads, or simplify _EnableAssignFromPair to always assume that _Const == true. Otherwise, this code looks buggy, even though it isn't.

1322

IMO it's not necessary for such a small block.

1371

Ditto.

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.assign/const_convert_copy.pass.cpp

34–35 ↗

(On Diff #428911)

65 ↗

(On Diff #428911)

80 ↗

(On Diff #428911)

You'll want to #include "test_macros.h" to get this.

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.assign/const_pair_copy.pass.cpp

15 ↗

(On Diff #428911)

Would it make sense to use T1, T2 instead of T0, T1? That way, indexing would match for Ti and Ui? If so, we should update the comments below.

41 ↗

(On Diff #428911)

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.assign/types.h

1 ↗

(On Diff #428911)

3 ↗

(On Diff #428911)

This file is missing a license :)

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/convert_const_move.pass.cpp

114 ↗

(On Diff #428911)

Let's use TEST_COMPILER_GCC.

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/convert_types.h

1 ↗

(On Diff #428911)

Same comment for license and header guard.

[huixie90]

address review comments. refactored more assignment operators

libcxx/include/tuple

848

hmm. IIUC, is_constructible also looks for conversion operator. If a conversion operator from U to T causes a hard error, both is_convertible and is_constructible would cause hard error. or, did I miss anything?

859

They were used in the noexcept specifier of some constructors and assignment operators. I went ahead refactoring these functions and _FirstType and _SecondType are no longer used

1190–1197

I did the former as refactoring the non-const allows me to completely remove _FirstType

[ldionne]

Thank you! This is a complicated patch but it ends up simplifying our tuple implementation quite a bit. Thanks for the great testing coverage. too.

libcxx/include/tuple

848

I think you're right.

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_non_const_pair.pass.cpp

112 ↗

(On Diff #434989)

Can you please make sure you have newlines at the end of files?

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.swap/member_swap_const.pass.cpp

15

Why does it fail on GCC?

[huixie90]

added new lines to the end of every file and enable const swap runtime test for gcc

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_non_const_pair.pass.cpp

112 ↗

(On Diff #434989)

done

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.swap/member_swap_const.pass.cpp

15

good catch. gcc only fail when running the test at compile time because it doesn't allow mutable member in constexpr. but this test can run at time with gcc so I enable the runtime test for gcc now

[huixie90]

pull --rebase

[ldionne]

I looked at the diff before and after the rebase, still LGTM. Thanks!

libcxx/include/tuple

public:
     explicit(see-below) constexpr tuple();
     explicit(see-below) tuple(const T&...);  // constexpr in C++14
     template <class... U>
         explicit(see-below) tuple(U&&...);  // constexpr in C++14
     tuple(const tuple&) = default;
     tuple(tuple&&) = default;
     template <class... U>
         explicit(see-below) tuple(const tuple<U...>&);  // constexpr in C++14
     template <class... U>
         explicit(see-below) tuple(tuple<U...>&&);  // constexpr in C++14
     template <class U1, class U2>
         explicit(see-below) tuple(const pair<U1, U2>&); // iff sizeof...(T) == 2 // constexpr in C++14
     template <class U1, class U2>
         explicit(see-below) tuple(pair<U1, U2>&&); // iff sizeof...(T) == 2  // constexpr in C++14
 
     // allocator-extended constructors
     template <class Alloc>

 template <size_t _Ip, class _Hp, bool _Ep>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 void swap(__tuple_leaf<_Ip, _Hp, _Ep>& __x, __tuple_leaf<_Ip, _Hp, _Ep>& __y)
     _NOEXCEPT_(__is_nothrow_swappable<_Hp>::value)
 {
     swap(__x.get(), __y.get());
 }
 
+#if _LIBCPP_STD_VER > 20
+template <size_t _Ip, class _Hp, bool _Ep>
+inline _LIBCPP_HIDE_FROM_ABI constexpr void
+swap(const __tuple_leaf<_Ip, _Hp, _Ep>& __x,
+     const __tuple_leaf<_Ip, _Hp, _Ep>& __y) noexcept(is_nothrow_swappable_v<const _Hp&>) {
+  swap(__x.get(), __y.get());
+}
+#endif // _LIBCPP_STD_VER > 20
+
 template <size_t _Ip, class _Hp, bool>
 class __tuple_leaf
 {
     _Hp __value_;
 
     template <class _Tp>
     static constexpr bool __can_bind_reference() {
 #if __has_keyword(__reference_binds_to_temporary)
template <class _Tp, class _Alloc>
            "Attempted to uses-allocator construct a reference element in a tuple");}
 
     __tuple_leaf(const __tuple_leaf& __t) = default;
     __tuple_leaf(__tuple_leaf&& __t) = default;
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     int swap(__tuple_leaf& __t) _NOEXCEPT_(__is_nothrow_swappable<__tuple_leaf>::value)
     {
-        _VSTD::swap(*this, __t);
+        std::swap(*this, __t);
         return 0;
     }
 
+#if _LIBCPP_STD_VER > 20
+    _LIBCPP_HIDE_FROM_ABI constexpr
+    int swap(const __tuple_leaf& __rhs) const noexcept(is_nothrow_swappable_v<const __tuple_leaf>) {
+        std::swap(*this, __rhs);
+        return 0;
+    }
+#endif // _LIBCPP_STD_VER > 20
+
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11       _Hp& get()       _NOEXCEPT {return __value_;}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 const _Hp& get() const _NOEXCEPT {return __value_;}
 };
 
 template <size_t _Ip, class _Hp>
 class __tuple_leaf<_Ip, _Hp, true>
     : private _Hp
 {
public:
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     int
     swap(__tuple_leaf& __t) _NOEXCEPT_(__is_nothrow_swappable<__tuple_leaf>::value)
     {
         _VSTD::swap(*this, __t);
         return 0;
     }
 
+#if _LIBCPP_STD_VER > 20
+    _LIBCPP_HIDE_FROM_ABI constexpr
+    void swap(const __tuple_leaf& __rhs) const noexcept(is_nothrow_swappable_v<const __tuple_leaf&>) {
+      std::swap(*this, __rhs);
+    }
+#endif // _LIBCPP_STD_VER > 20
+
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11       _Hp& get()       _NOEXCEPT {return static_cast<_Hp&>(*this);}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 const _Hp& get() const _NOEXCEPT {return static_cast<const _Hp&>(*this);}
 };
 
 template <class ..._Tp>
 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 void __swallow(_Tp&&...) _NOEXCEPT {}
 
struct _LIBCPP_DECLSPEC_EMPTY_BASES __tuple_impl<__tuple_indices<_Indx...>, _Tp...>
     __tuple_impl(__tuple_impl&&) = default;
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     void swap(__tuple_impl& __t)
         _NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value)
     {
         _VSTD::__swallow(__tuple_leaf<_Indx, _Tp>::swap(static_cast<__tuple_leaf<_Indx, _Tp>&>(__t))...);
     }
+
+#if _LIBCPP_STD_VER > 20
+    _LIBCPP_HIDE_FROM_ABI constexpr
+    void swap(const __tuple_impl& __rhs) const noexcept((is_nothrow_swappable_v<const _Tp&> && ...)) {
+        (static_cast<const __tuple_leaf<_Indx, _Tp>&>(*this).swap(static_cast<const __tuple_leaf<_Indx, _Tp>&>(__rhs)),
+         ...);
+    }
+#endif // _LIBCPP_STD_VER > 20
 };
 
 template<class _Dest, class _Source, size_t ..._Np>
 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 void __memberwise_copy_assign(_Dest& __dest, _Source const& __source, __tuple_indices<_Np...>) {
     _VSTD::__swallow(((_VSTD::get<_Np>(__dest) = _VSTD::get<_Np>(__source)), void(), 0)...);
 }
 
public:
 
     template <class _Alloc, template<class...> class _And = _And, __enable_if_t<
         _And<is_move_constructible<_Tp>...>::value
     , int> = 0>
     tuple(allocator_arg_t, const _Alloc& __alloc, tuple&& __t)
         : __base_(allocator_arg_t(), __alloc, _VSTD::move(__t))
     { }
 
     // tuple(const tuple<U...>&) constructors (including allocator_arg_t variants)
-    template <class ..._Up>
+    template <bool _Const, class ..._Up>
     struct _EnableCopyFromOtherTuple : _And<
         _Not<is_same<tuple<_Tp...>, tuple<_Up...> > >,
         _Lazy<_Or,
             _BoolConstant<sizeof...(_Tp) != 1>,
             // _Tp and _Up are 1-element packs - the pack expansions look
             // weird to avoid tripping up the type traits in degenerate cases
             _Lazy<_And,
-                _Not<is_convertible<const tuple<_Up>&, _Tp> >...,
-                _Not<is_constructible<_Tp, const tuple<_Up>&> >...
+                  _Not<is_convertible<__maybe_const<_Const, tuple<_Up>>&, _Tp> >...,
+                  _Not<is_constructible<_Tp, __maybe_const<_Const, tuple<_Up>>&> >...
             >
         >,
-        is_constructible<_Tp, const _Up&>...
-    > { };
+        is_constructible<_Tp, __maybe_const<_Const, _Up>&>...
+    > {};
 
+#if _LIBCPP_STD_VER > 20
+    template <class... _Up,
+              enable_if_t<_And<_BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
+                               _EnableCopyFromOtherTuple<false, _Up...>>::value>* = nullptr>
+    _LIBCPP_HIDE_FROM_ABI constexpr
+        explicit(!(is_convertible_v<_Up&, _Tp> && ...))
+    tuple(tuple<_Up...>& __t) : __base_(__t) {}
+
+    template <class _Alloc,
+              class... _Up,
+              enable_if_t<_And<_BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
+                               _EnableCopyFromOtherTuple<false, _Up...>>::value>* = nullptr>
+    _LIBCPP_HIDE_FROM_ABI constexpr
+        explicit(!(is_convertible_v<_Up&, _Tp> && ...))
+    tuple(allocator_arg_t, const _Alloc& __alloc, tuple<_Up...>& __t) : __base_(allocator_arg_t(), __alloc, __t) {}
+#endif // _LIBCPP_STD_VER > 20
+
     template <class ..._Up, __enable_if_t<
         _And<
             _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
-            _EnableCopyFromOtherTuple<_Up...>,
+            _EnableCopyFromOtherTuple<true, _Up...>,
             is_convertible<const _Up&, _Tp>... // explicit check
         >::value
     , int> = 0>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     tuple(const tuple<_Up...>& __t)
         _NOEXCEPT_((_And<is_nothrow_constructible<_Tp, const _Up&>...>::value))
         : __base_(__t)
     { }
 
     template <class ..._Up, __enable_if_t<
         _And<
             _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
-            _EnableCopyFromOtherTuple<_Up...>,
+            _EnableCopyFromOtherTuple<true, _Up...>,
             _Not<_Lazy<_And, is_convertible<const _Up&, _Tp>...> > // explicit check
         >::value
     , int> = 0>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     explicit tuple(const tuple<_Up...>& __t)
         _NOEXCEPT_((_And<is_nothrow_constructible<_Tp, const _Up&>...>::value))
         : __base_(__t)
     { }
 
     template <class ..._Up, class _Alloc, __enable_if_t<
         _And<
             _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
-            _EnableCopyFromOtherTuple<_Up...>,
+            _EnableCopyFromOtherTuple<true, _Up...>,
             is_convertible<const _Up&, _Tp>... // explicit check
         >::value
     , int> = 0>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     tuple(allocator_arg_t, const _Alloc& __a, const tuple<_Up...>& __t)
         : __base_(allocator_arg_t(), __a, __t)
     { }
 
     template <class ..._Up, class _Alloc, __enable_if_t<
         _And<
             _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
-            _EnableCopyFromOtherTuple<_Up...>,
+            _EnableCopyFromOtherTuple<true, _Up...>,
             _Not<_Lazy<_And, is_convertible<const _Up&, _Tp>...> > // explicit check
         >::value
     , int> = 0>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     explicit tuple(allocator_arg_t, const _Alloc& __a, const tuple<_Up...>& __t)
         : __base_(allocator_arg_t(), __a, __t)
     { }
 
     // tuple(tuple<U...>&&) constructors (including allocator_arg_t variants)
     template <class ..._Up>
     struct _EnableMoveFromOtherTuple : _And<
         _Not<is_same<tuple<_Tp...>, tuple<_Up...> > >,
         _Lazy<_Or,
             _BoolConstant<sizeof...(_Tp) != 1>,
             // _Tp and _Up are 1-element packs - the pack expansions look
             // weird to avoid tripping up the type traits in degenerate cases
             _Lazy<_And,
                 _Not<is_convertible<tuple<_Up>, _Tp> >...,
                 _Not<is_constructible<_Tp, tuple<_Up> > >...
             >
         >,
         is_constructible<_Tp, _Up>...
     > { };
 
+#if _LIBCPP_STD_VER > 20
+    template <class... _Up,
+              enable_if_t<_And<_BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
+                               _EnableMoveFromOtherTuple<_Up...>>::value>* = nullptr>
+    _LIBCPP_HIDE_FROM_ABI constexpr
+        explicit(!(is_convertible_v<const _Up&&, _Tp> && ...))
+    tuple(const tuple<_Up...>&& __t) : __base_(std::move(__t)) {}
+
+    template <class _Alloc,
+              class... _Up,
+              enable_if_t<_And<_BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
+                               _EnableMoveFromOtherTuple<_Up...>>::value>* = nullptr>
+    _LIBCPP_HIDE_FROM_ABI constexpr
+        explicit(!(is_convertible_v<const _Up&&, _Tp> && ...))
+    tuple(allocator_arg_t, const _Alloc& __alloc, const tuple<_Up...>&& __t)
+        : __base_(allocator_arg_t(), __alloc, std::move(__t)) {}
+#endif // _LIBCPP_STD_VER > 20
+
     template <class ..._Up, __enable_if_t<
         _And<
             _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
             _EnableMoveFromOtherTuple<_Up...>,
             is_convertible<_Up, _Tp>... // explicit check
         >::value
     , int> = 0>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
template <class _Alloc, class ..._Up, __enable_if_t<
         >::value
     , int> = 0>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     explicit tuple(allocator_arg_t, const _Alloc& __a, tuple<_Up...>&& __t)
         : __base_(allocator_arg_t(), __a, _VSTD::move(__t))
     { }
 
     // tuple(const pair<U1, U2>&) constructors (including allocator_arg_t variants)
+    template <class _U1, class _U2, class... _DependentTp>
+    struct _EnableCopyFromPair : _And<
+        is_constructible<_FirstType<_DependentTp...>, _U1>,
+        is_constructible<_SecondType<_DependentTp...>, _U2>
+    > {};
+
     template <class _Up1, class _Up2, class ..._DependentTp>
     struct _EnableImplicitCopyFromPair : _And<
-        is_constructible<_FirstType<_DependentTp...>, const _Up1&>,
-        is_constructible<_SecondType<_DependentTp...>, const _Up2&>,
         is_convertible<const _Up1&, _FirstType<_DependentTp...> >, // explicit check
-        is_convertible<const _Up2&, _SecondType<_DependentTp...> >
-    > { };
+        is_convertible<const _Up2&, _SecondType<_DependentTp...> >,
+        _EnableCopyFromPair<const _Up1&, const _Up2&, _DependentTp...>
+    > {};
 
     template <class _Up1, class _Up2, class ..._DependentTp>
     struct _EnableExplicitCopyFromPair : _And<
-        is_constructible<_FirstType<_DependentTp...>, const _Up1&>,
-        is_constructible<_SecondType<_DependentTp...>, const _Up2&>,
-        _Not<is_convertible<const _Up1&, _FirstType<_DependentTp...> > >, // explicit check
-        _Not<is_convertible<const _Up2&, _SecondType<_DependentTp...> > >
-    > { };
+        _Or<_Not<is_convertible<const _Up1&, _FirstType<_DependentTp...> > >, // explicit check
+            _Not<is_convertible<const _Up2&, _SecondType<_DependentTp...> > > >,
+        _EnableCopyFromPair<const _Up1&, const _Up2&, _DependentTp...>
+    > {};
 
     template <class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
         _And<
             _BoolConstant<sizeof...(_Tp) == 2>,
             _EnableImplicitCopyFromPair<_Up1, _Up2, _Tp...>
         >::value
     , int> = 0>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     tuple(const pair<_Up1, _Up2>& __p)
         _NOEXCEPT_((_And<
             is_nothrow_constructible<_FirstType<_Tp...>, const _Up1&>,
             is_nothrow_constructible<_SecondType<_Tp...>, const _Up2&>
         >::value))
         : __base_(__p)
template <class _Alloc, class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
         >::value
     , int> = 0>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     explicit tuple(allocator_arg_t, const _Alloc& __a, const pair<_Up1, _Up2>& __p)
         : __base_(allocator_arg_t(), __a, __p)
     { }
 
     // tuple(pair<U1, U2>&&) constructors (including allocator_arg_t variants)
-    template <class _Up1, class _Up2, class ..._DependentTp>
-    struct _EnableImplicitMoveFromPair : _And<
+    template <class _Up1, class _Up2, class... _DependentTp>
+    struct _EnableMoveFromPair : _And<
         is_constructible<_FirstType<_DependentTp...>, _Up1>,
-        is_constructible<_SecondType<_DependentTp...>, _Up2>,
-        is_convertible<_Up1, _FirstType<_DependentTp...> >, // explicit check
-        is_convertible<_Up2, _SecondType<_DependentTp...> >
-    > { };
+        is_constructible<_SecondType<_DependentTp...>, _Up2>
+    > {};
+
+    template <class _Up1, class _Up2, class ..._DependentTp>
+    struct _EnableImplicitMoveFromPair : _And<
+        is_convertible<_Up1, _FirstType<_DependentTp...> >,
+        is_convertible<_Up2, _SecondType<_DependentTp...> >,
+        _EnableMoveFromPair<_Up1, _Up2, _DependentTp...>
+    > {};
 
     template <class _Up1, class _Up2, class ..._DependentTp>
     struct _EnableExplicitMoveFromPair : _And<
-        is_constructible<_FirstType<_DependentTp...>, _Up1>,
-        is_constructible<_SecondType<_DependentTp...>, _Up2>,
-        _Not<is_convertible<_Up1, _FirstType<_DependentTp...> > >, // explicit check
-        _Not<is_convertible<_Up2, _SecondType<_DependentTp...> > >
-    > { };
+        _Or<_Not<is_convertible<_Up1, _FirstType<_DependentTp...> > >,
+            _Not<is_convertible<_Up2, _SecondType<_DependentTp...> > > >,
+        _EnableMoveFromPair<_Up1, _Up2, _DependentTp...>
+    > {};
 
+#if _LIBCPP_STD_VER > 20
+    template <class _U1,
+              class _U2,
+              enable_if_t<_And<_BoolConstant<sizeof...(_Tp) == 2>,
+                               _EnableCopyFromPair<_U1&, _U2&, _Tp...>>::value>* = nullptr>
+    _LIBCPP_HIDE_FROM_ABI constexpr
+        explicit(!is_convertible_v<_U1&, _FirstType<_Tp...>> || !is_convertible_v<_U2&, _SecondType<_Tp...>>)
+    tuple(pair<_U1, _U2>& __p) : __base_(__p) {}
+
+    template <class _Alloc,
+              class _U1,
+              class _U2,
+              enable_if_t<_And<_BoolConstant<sizeof...(_Tp) == 2>,
+                               _EnableCopyFromPair<_U1&, _U2&, _Tp...>>::value>* = nullptr>
+    _LIBCPP_HIDE_FROM_ABI constexpr
+        explicit(!is_convertible_v<_U1&, _FirstType<_Tp...>> || !is_convertible_v<_U2&, _SecondType<_Tp...>>)
+    tuple(allocator_arg_t, const _Alloc& __alloc, pair<_U1, _U2>& __p) : __base_(allocator_arg_t(), __alloc, __p) {}
+
+    template <class _U1,
+              class _U2,
+              enable_if_t<_And<_BoolConstant<sizeof...(_Tp) == 2>,
+                               _EnableMoveFromPair<_U1, _U2, _Tp...>>::value>* = nullptr>
+        requires (sizeof...(_Tp) == 2)
+    _LIBCPP_HIDE_FROM_ABI constexpr
+        explicit(!is_convertible_v<const _U1&&, _FirstType<_Tp...>> || !is_convertible_v<const _U2&&, _SecondType<_Tp...>>)
+    tuple(const pair<_U1, _U2>&& __p) : __base_(std::move(__p)) {}
+
+    template <class _Alloc,
+              class _U1,
+              class _U2,
+              enable_if_t<_And<_BoolConstant<sizeof...(_Tp) == 2>,
+                               _EnableMoveFromPair<_U1, _U2, _Tp...>>::value>* = nullptr>
+        requires (sizeof...(_Tp) == 2)
+    _LIBCPP_HIDE_FROM_ABI constexpr
+        explicit(!is_convertible_v<const _U1&&, _FirstType<_Tp...>> || !is_convertible_v<const _U2&&, _SecondType<_Tp...>>)
+    tuple(allocator_arg_t, const _Alloc& __alloc, const pair<_U1, _U2>&& __p)
+        : __base_(allocator_arg_t(), __alloc, std::move(__p)) {}
+#endif // _LIBCPP_STD_VER > 20
+
     template <class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
         _And<
             _BoolConstant<sizeof...(_Tp) == 2>,
             _EnableImplicitMoveFromPair<_Up1, _Up2, _Tp...>
         >::value
     , int> = 0>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     tuple(pair<_Up1, _Up2>&& __p)
#endif // _LIBCPP_STD_VER > 20
     tuple& operator=(_If<_And<is_copy_assignable<_Tp>...>::value, tuple, __nat> const& __tuple)
         _NOEXCEPT_((_And<is_nothrow_copy_assignable<_Tp>...>::value))
     {
         _VSTD::__memberwise_copy_assign(*this, __tuple,
             typename __make_tuple_indices<sizeof...(_Tp)>::type());
         return *this;
     }
 
+#if _LIBCPP_STD_VER > 20
+    _LIBCPP_HIDE_FROM_ABI constexpr
+    const tuple& operator=(_If<_And<is_assignable<const _Tp&, const _Tp&>...>::value, tuple, __nat> const& __tuple) const {
+        std::__memberwise_copy_assign(*this, __tuple, typename __make_tuple_indices<sizeof...(_Tp)>::type());
+        return *this;
+    }
+
+    _LIBCPP_HIDE_FROM_ABI constexpr
+    const tuple& operator=(_If<_And<is_assignable<_Tp&&, _Tp&&>...>::value, tuple, __nat>&& __tuple) const {
+        std::__memberwise_forward_assign(*this,
+                                         std::move(__tuple),
+                                         __tuple_types<_Tp...>(),
+                                         typename __make_tuple_indices<sizeof...(_Tp)>::type());
+        return *this;
+    }
+#endif // _LIBCPP_STD_VER > 20
+
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     tuple& operator=(_If<_And<is_move_assignable<_Tp>...>::value, tuple, __nat>&& __tuple)
         _NOEXCEPT_((_And<is_nothrow_move_assignable<_Tp>...>::value))
     {
         _VSTD::__memberwise_forward_assign(*this, _VSTD::move(__tuple),
             __tuple_types<_Tp...>(),
             typename __make_tuple_indices<sizeof...(_Tp)>::type());
         return *this;
     }
 
tuple& operator=(tuple<_Up...>&& __tuple)
         _NOEXCEPT_((_And<is_nothrow_assignable<_Tp&, _Up>...>::value))
     {
         _VSTD::__memberwise_forward_assign(*this, _VSTD::move(__tuple),
             __tuple_types<_Up...>(),
             typename __make_tuple_indices<sizeof...(_Tp)>::type());
         return *this;
     }
 
+
+#if _LIBCPP_STD_VER > 20
+    template <class... _UTypes,
+              enable_if_t<_And<_BoolConstant<sizeof...(_Tp) == sizeof...(_UTypes)>,
+                               is_assignable<const _Tp&, const _UTypes&>...>::value>* = nullptr>
+    _LIBCPP_HIDE_FROM_ABI constexpr
+    const tuple& operator=(const tuple<_UTypes...>& __u) const {
+        std::__memberwise_copy_assign(*this,
+                                      __u,
+                                      __tuple_types<_UTypes...>(),
+                                      typename __make_tuple_indices<sizeof...(_Tp)>::type());
+        return *this;
+    }
+
+    template <class... _UTypes,
+              enable_if_t<_And<_BoolConstant<sizeof...(_Tp) == sizeof...(_UTypes)>,
+                               is_assignable<const _Tp&, _UTypes>...>::value>* = nullptr>
+    _LIBCPP_HIDE_FROM_ABI constexpr
+    const tuple& operator=(tuple<_UTypes...>&& __u) const {
+        std::__memberwise_forward_assign(*this,
+                                         __u,
+                                         __tuple_types<_UTypes...>(),
+                                         typename __make_tuple_indices<sizeof...(_Tp)>::type());
+        return *this;
+    }
+
+    template <class _U1,
+              class _U2,
+              enable_if_t<_And<_BoolConstant<sizeof...(_Tp) == 2>,
+                               is_assignable<add_const_t<_FirstType<_Tp...>>&, const _U1&>,
+                               is_assignable<add_const_t<_SecondType<_Tp...>>&, const _U2&>>::value>* = nullptr>
+    _LIBCPP_HIDE_FROM_ABI constexpr
+    const tuple& operator=(const pair<_U1, _U2>& __pair) const {
+        std::get<0>(*this) = __pair.first;
+        std::get<1>(*this) = __pair.second;
+        return *this;
+    }
+
+    template <class _U1,
+              class _U2,
+              enable_if_t<_And<_BoolConstant<sizeof...(_Tp) == 2>,
+                               is_assignable<add_const_t<_FirstType<_Tp...>>&, _U1>,
+                               is_assignable<add_const_t<_SecondType<_Tp...>>&, _U2>>::value>* = nullptr>
+    _LIBCPP_HIDE_FROM_ABI constexpr
+    const tuple& operator=(pair<_U1, _U2>&& __pair) const {
+        std::get<0>(*this) = std::move(__pair.first);
+        std::get<1>(*this) = std::move(__pair.second);
+        return *this;
+    }
+#endif // _LIBCPP_STD_VER > 20
+
     template<class _Up1, class _Up2, class _Dep = true_type, __enable_if_t<
         _And<_Dep,
             _BoolConstant<sizeof...(_Tp) == 2>,
             is_assignable<_FirstType<_Tp..., _Dep>&, _Up1 const&>,
             is_assignable<_SecondType<_Tp..., _Dep>&, _Up2 const&>
         >::value
     ,int> = 0>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
tuple& operator=(array<_Up, _Np>&& __array)
             typename __make_tuple_indices<sizeof...(_Tp)>::type());
         return *this;
     }
 
     // [tuple.swap]
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     void swap(tuple& __t) _NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value)
         {__base_.swap(__t.__base_);}
+
+#if _LIBCPP_STD_VER > 20
+    _LIBCPP_HIDE_FROM_ABI constexpr
+    void swap(const tuple& __rhs) const noexcept(__all<is_nothrow_swappable_v<const _Tp&>...>::value) {
+        __base_.swap(__rhs.__base_);
+    }
+#endif // _LIBCPP_STD_VER > 20
 };
 
 template <>
 class _LIBCPP_TEMPLATE_VIS tuple<>
 {
 public:
     _LIBCPP_INLINE_VISIBILITY constexpr
         tuple() _NOEXCEPT = default;
     template <class _Alloc>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
         tuple(allocator_arg_t, const _Alloc&) _NOEXCEPT {}
     template <class _Alloc>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
         tuple(allocator_arg_t, const _Alloc&, const tuple&) _NOEXCEPT {}
     template <class _Up>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
         tuple(array<_Up, 0>) _NOEXCEPT {}
     template <class _Alloc, class _Up>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
         tuple(allocator_arg_t, const _Alloc&, array<_Up, 0>) _NOEXCEPT {}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     void swap(tuple&) _NOEXCEPT {}
+#if _LIBCPP_STD_VER > 20
+    _LIBCPP_HIDE_FROM_ABI constexpr void swap(const tuple&) const noexcept {}
+#endif // _LIBCPP_STD_VER > 20
 };
 
 #if _LIBCPP_STD_VER > 20
 template <class... _TTypes, class... _UTypes, template<class> class _TQual, template<class> class _UQual>
     requires requires { typename tuple<common_reference_t<_TQual<_TTypes>, _UQual<_UTypes>>...>; }
 struct basic_common_reference<tuple<_TTypes...>, tuple<_UTypes...>, _TQual, _UQual> {
     using type = tuple<common_reference_t<_TQual<_TTypes>, _UQual<_UTypes>>...>;
 };

 <
     __all<__is_swappable<_Tp>::value...>::value,
     void
 >::type
 swap(tuple<_Tp...>& __t, tuple<_Tp...>& __u)
                  _NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value)
     {__t.swap(__u);}
 
+#if _LIBCPP_STD_VER > 20
+template <class... _Tp>
+_LIBCPP_HIDE_FROM_ABI constexpr
+enable_if_t<__all<is_swappable_v<const _Tp>...>::value, void>
+swap(const tuple<_Tp...>& __lhs, const tuple<_Tp...>& __rhs)
+        noexcept(__all<is_nothrow_swappable_v<const _Tp>...>::value) {
+    __lhs.swap(__rhs);
+}
+#endif // _LIBCPP_STD_VER > 20
+
 // get
 
 template <size_t _Ip, class ..._Tp>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 typename tuple_element<_Ip, tuple<_Tp...> >::type&
 get(tuple<_Tp...>& __t) _NOEXCEPT
 {
     typedef _LIBCPP_NODEBUG typename tuple_element<_Ip, tuple<_Tp...> >::type type;

libcxx/include/type_traits

 
 #if _LIBCPP_STD_VER > 11
 template <bool _Bp, class _Tp = void> using enable_if_t = typename enable_if<_Bp, _Tp>::type;
 #endif
 
 typedef _LIBCPP_BOOL_CONSTANT(true)  true_type;
 typedef _LIBCPP_BOOL_CONSTANT(false) false_type;
 
+struct __nat
+{
+#ifndef _LIBCPP_CXX03_LANG
+    __nat() = delete;
+    __nat(const __nat&) = delete;
+    __nat& operator=(const __nat&) = delete;
+    ~__nat() = delete;
+#endif
+};
+
 template <bool _Val>
 using _BoolConstant _LIBCPP_NODEBUG = integral_constant<bool, _Val>;
 
 template <bool> struct _MetaBase;
 template <>
 struct _MetaBase<true> {
   template <class _Tp, class _Up>
   using _SelectImpl _LIBCPP_NODEBUG = _Tp;

 template <>
 struct _MetaBase<false> {
   template <class _Tp, class _Up>
   using _SelectImpl _LIBCPP_NODEBUG = _Up;
   template <template <class...> class, template <class...> class _SecondFn, class ..._Args>
   using _SelectApplyImpl _LIBCPP_NODEBUG = _SecondFn<_Args...>;
   template <class _Result, class ...>
   using _OrImpl _LIBCPP_NODEBUG = _Result;
+  template <class...>
+  using _FirstImpl = __nat;
+  template <class...>
+  using _SecondImpl = __nat;
 };
+
 template <bool _Cond, class _IfRes, class _ElseRes>
 using _If _LIBCPP_NODEBUG = typename _MetaBase<_Cond>::template _SelectImpl<_IfRes, _ElseRes>;
 template <class ..._Rest>
 using _Or _LIBCPP_NODEBUG = typename _MetaBase< sizeof...(_Rest) != 0 >::template _OrImpl<false_type, _Rest...>;
 template <class _Pred>
 struct _Not : _BoolConstant<!_Pred::value> {};
 template <class ..._Args>
 using _FirstType _LIBCPP_NODEBUG = typename _MetaBase<(sizeof...(_Args) >= 1)>::template _FirstImpl<_Args...>;

 
 template <class _Hp, class _Tp>
 struct __type_list
 {
     typedef _Hp _Head;
     typedef _Tp _Tail;
 };
 
-struct __nat
-{
-#ifndef _LIBCPP_CXX03_LANG
-    __nat() = delete;
-    __nat(const __nat&) = delete;
-    __nat& operator=(const __nat&) = delete;
-    ~__nat() = delete;
-#endif
-};
-
 template <class _Tp>
 struct __align_type
 {
     static const size_t value = _LIBCPP_PREFERRED_ALIGNOF(_Tp);
     typedef _Tp type;
 };
 
 struct __struct_double {long double __lx;};

 bool __libcpp_is_constant_evaluated() _NOEXCEPT { return __builtin_is_constant_evaluated(); }
 
 template <class _CharT>
 using _IsCharLikeType = _And<is_standard_layout<_CharT>, is_trivial<_CharT> >;
 
 template<class _Tp>
 using __make_const_lvalue_ref = const typename remove_reference<_Tp>::type&;
 
-#if _LIBCPP_STD_VER > 17
 template<bool _Const, class _Tp>
-using __maybe_const = conditional_t<_Const, const _Tp, _Tp>;
-#endif // _LIBCPP_STD_VER > 17
+using __maybe_const = typename conditional<_Const, const _Tp, _Tp>::type;
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_TYPE_TRAITS

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.assign/convert_cpp23.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
+//
+//===----------------------------------------------------------------------===//
+
+// <tuple>
+
+// template <class... Types> class tuple;
+
+// template <class... UTypes> tuple(const tuple<UTypes...>& u);
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// XFAIL: gcc
+
+#include <cassert>
+#include <tuple>
+
+struct MutableCopy {
+  int val;
+
+  constexpr MutableCopy() = default;
+  constexpr MutableCopy(int _val) : val(_val) {}
+  constexpr MutableCopy& operator=(const MutableCopy& o) { val = o.val; return *this; }
+};
+
+struct ConstCopy {
+  mutable int val;
+
+  constexpr ConstCopy() = default;
+  constexpr ConstCopy(int _val) : val(_val) {}
+  constexpr ConstCopy(const ConstCopy&) = default;
+  constexpr const ConstCopy& operator=(const ConstCopy& o) const { val = o.val; return *this; }
+};
+
+struct MutableMove {
+  int val;
+
+  constexpr MutableMove() = default;
+  constexpr MutableMove(int _val) : val(_val) {}
+  constexpr MutableMove& operator=(MutableMove&& o) { val = o.val; return *this; }
+};
+
+struct ConstMove {
+  mutable int val;
+
+  constexpr ConstMove() = default;
+  constexpr ConstMove(int _val) : val(_val) {}
+  constexpr const ConstMove& operator=(ConstMove&& o) const { val = o.val; return *this; }
+  constexpr ConstMove& operator=(const ConstMove&) = delete;
+};
+
+static_assert(std::is_assignable_v<const ConstMove&&, ConstMove&&>);
+
+template <class T>
+struct ConvertibleFrom {
+  T v;
+  constexpr ConvertibleFrom() = default;
+  constexpr ConvertibleFrom(T& _v) : v(_v) {}
+  constexpr ConvertibleFrom(T&& _v) : v(std::move(_v)) {}
+};
+
+template <class T>
+struct ConstConvertibleFrom {
+  mutable T v;
+  constexpr ConstConvertibleFrom() = default;
+  constexpr ConstConvertibleFrom(T& _v) : v(_v) {}
+  constexpr ConstConvertibleFrom(T&& _v) : v(std::move(_v)) {}
+  constexpr ConstConvertibleFrom(const ConstConvertibleFrom&) = default;
+  constexpr const ConstConvertibleFrom& operator=(const ConstConvertibleFrom& o) const { v = o.v; return *this; }
+};
+
+constexpr bool test() {
+  {
+    using T = std::tuple<MutableCopy>;
+
+    T t1{1};
+    T t2;
+    t2 = t1;
+    assert(std::get<0>(t2).val == 1);
+  }
+  {
+    using T = std::tuple<ConstCopy>;
+
+    T t1{1};
+    const T t2;
+    t2 = t1;
+    assert(std::get<0>(t2).val == 1);
+  }
+  {
+    using T = std::tuple<MutableMove>;
+
+    T t1{1};
+    T t2;
+    t2 = std::move(t1);
+    assert(std::get<0>(t2).val == 1);
+  }
+  {
+    using T = std::tuple<ConstMove>;
+
+    T t1{1};
+    const T t2;
+    t2 = std::move(t1);
+    assert(std::get<0>(t2).val == 1);
+  }
+
+  {
+    using T1 = std::pair<MutableCopy, int>;
+    using T2 = std::tuple<MutableCopy, int>;
+
+    T1 t1{1, 2};
+    T2 t2;
+    t2 = t1;
+    assert(std::get<0>(t2).val == 1);
+  }
+  {
+    using T1 = std::pair<ConstCopy, ConstConvertibleFrom<int>>;
+    using T2 = std::tuple<ConstCopy, ConstConvertibleFrom<int>>;
+
+    T1 t1{1, 2};
+    const T2 t2;
+    t2 = t1;
+    assert(std::get<0>(t2).val == 1);
+  }
+  {
+    using T1 = std::pair<MutableMove, int>;
+    using T2 = std::tuple<MutableMove, int>;
+
+    T1 t1{1, 2};
+    T2 t2;
+    t2 = std::move(t1);
+    assert(std::get<0>(t2).val == 1);
+  }
+  {
+    using T1 = std::pair<ConstMove, ConstConvertibleFrom<int>>;
+    using T2 = std::tuple<ConstMove, ConstConvertibleFrom<int>>;
+
+    T1 t1{1, 2};
+    const T2 t2;
+    t2 = std::move(t1);
+    assert(std::get<0>(t2).val == 1);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/convert_cpp23.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
+//
+//===----------------------------------------------------------------------===//
+
+// <tuple>
+
+// template <class... Types> class tuple;
+
+// template <class... UTypes> tuple(const tuple<UTypes...>& u);
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// XFAIL: gcc
+
+#include <cassert>
+#include <tuple>
+
+#include "test_allocator.h"
+
+struct MutableCopy {
+  int val;
+
+  constexpr MutableCopy() = default;
+  constexpr MutableCopy(int _val) : val(_val) {}
+  constexpr MutableCopy(MutableCopy& o) : val(o.val) {}
+  constexpr MutableCopy(const MutableCopy&) = delete;
+};
+
+struct ConstCopy {
+  mutable int val;
+
+  constexpr ConstCopy() = default;
+  constexpr ConstCopy(int _val) : val(_val) {}
+  constexpr ConstCopy(const ConstCopy& o) : val(o.val) {}
+  constexpr ConstCopy(ConstCopy&) = delete;
+};
+
+struct MutableMove {
+  int val;
+
+  constexpr MutableMove() = default;
+  constexpr MutableMove(int _val) : val(_val) {}
+  constexpr MutableMove(MutableMove&& o) : val(o.val) {}
+  constexpr MutableMove(const MutableMove&&) = delete;
+};
+
+struct ConstMove {
+  mutable int val;
+
+  constexpr ConstMove() = default;
+  constexpr ConstMove(int _val) : val(_val) {}
+  constexpr ConstMove(const ConstMove&& o) : val(o.val) {}
+  constexpr ConstMove(ConstMove&&) = delete;
+};
+
+template <class T>
+struct ConvertibleFrom {
+  T v;
+  constexpr ConvertibleFrom() = default;
+  constexpr ConvertibleFrom(T& _v) requires(std::is_constructible_v<T, T&>) : v(_v) {}
+  constexpr ConvertibleFrom(T&& _v) requires(std::is_constructible_v<T, T&&>) : v(std::move(_v)) {}
+};
+
+template <class T>
+struct ExplicitConstructibleFrom {
+  T v;
+  constexpr explicit ExplicitConstructibleFrom() = default;
+  constexpr explicit ExplicitConstructibleFrom(T& _v) requires(std::is_constructible_v<T, T&>) : v(_v) {}
+  constexpr explicit ExplicitConstructibleFrom(T&& _v) requires(std::is_constructible_v<T, T&&>) : v(std::move(_v)) {}
+
+  constexpr explicit ExplicitConstructibleFrom(std::remove_const<T>& _v) requires(std::is_const_v<T>) = delete;
+  constexpr explicit ExplicitConstructibleFrom(std::remove_const<T>&& _v) requires(std::is_const_v<T>) = delete;
+  constexpr explicit ExplicitConstructibleFrom(const T& _v) requires(!std::is_const_v<T>) = delete;
+  constexpr explicit ExplicitConstructibleFrom(const T&& _v) requires(!std::is_const_v<T>) = delete;
+};
+
+static_assert(!std::is_convertible_v<std::tuple<MutableCopy>&, std::tuple<ExplicitConstructibleFrom<MutableCopy>>>);
+static_assert(!std::is_convertible_v<const std::tuple<ConstCopy>&, const std::tuple<ExplicitConstructibleFrom<ConstCopy>>>);
+static_assert(!std::is_convertible_v<std::tuple<MutableMove>&&, std::tuple<ExplicitConstructibleFrom<MutableMove>>>);
+static_assert(!std::is_convertible_v<const std::tuple<ConstMove>&&, const std::tuple<ExplicitConstructibleFrom<ConstMove>>>);
+
+template <class T, class U>
+constexpr void test_copy() {
+  T t1{1, 2};
+  U t2 = t1;
+  assert(std::get<0>(t2).v.val == 1);
+  assert(std::get<1>(t2) == 2);
+}
+
+template <class T, class U>
+constexpr void test_move() {
+  T t1{1, 2};
+  U t2 = std::move(t1);
+  assert(std::get<0>(t2).v.val == 1);
+  assert(std::get<1>(t2) == 2);
+}
+
+template <class T, class U>
+constexpr void test_copy_allocator() {
+  test_allocator<int> alloc;
+
+  T t1{1, 2};
+  U t2 = {std::allocator_arg_t{}, alloc, t1};
+  assert(std::get<0>(t2).v.val == 1);
+  assert(std::get<1>(t2) == 2);
+}
+
+template <class T, class U>
+constexpr void test_move_allocator() {
+  test_allocator<int> alloc;
+
+  T t1{1, 2};
+  U t2 = {std::allocator_arg_t{}, alloc, std::move(t1)};
+  assert(std::get<0>(t2).v.val == 1);
+  assert(std::get<1>(t2) == 2);
+}
+
+template <class T, class U>
+constexpr void test_copy_explicit() {
+  T t1{1, 2};
+  U t2{t1};
+  assert(std::get<0>(t2).v.val == 1);
+  assert(std::get<1>(t2) == 2);
+}
+
+template <class T, class U>
+constexpr void test_move_explicit() {
+  T t1{1, 2};
+  U t2{std::move(t1)};
+  assert(std::get<0>(t2).v.val == 1);
+  assert(std::get<1>(t2) == 2);
+}
+
+template <class T, class U>
+constexpr void test_copy_allocator_explicit() {
+  test_allocator<int> alloc;
+
+  T t1{1, 2};
+  U t2{std::allocator_arg_t{}, alloc, t1};
+  assert(std::get<0>(t2).v.val == 1);
+  assert(std::get<1>(t2) == 2);
+}
+
+template <class T, class U>
+constexpr void test_move_allocator_explicit() {
+  test_allocator<int> alloc;
+
+  T t1{1, 2};
+  U t2{std::allocator_arg_t{}, alloc, std::move(t1)};
+  assert(std::get<0>(t2).v.val == 1);
+  assert(std::get<1>(t2) == 2);
+}
+
+constexpr bool test() {
+  // test implicit conversions
+  test_copy<      std::tuple<MutableCopy, int>, std::tuple<ConvertibleFrom<      MutableCopy>, int>>();
+  test_copy<const std::tuple<ConstCopy  , int>, std::tuple<ConvertibleFrom<const ConstCopy  >, int>>();
+  test_move<      std::tuple<MutableMove, int>, std::tuple<ConvertibleFrom<      MutableMove>, int>>();
+  test_move<const std::tuple<ConstMove  , int>, std::tuple<ConvertibleFrom<const ConstMove  >, int>>();
+  test_copy<      std::pair <MutableCopy, int>, std::tuple<ConvertibleFrom<      MutableCopy>, int>>();
+  test_copy<const std::pair <ConstCopy  , int>, std::tuple<ConvertibleFrom<const ConstCopy  >, int>>();
+  test_move<      std::pair <MutableMove, int>, std::tuple<ConvertibleFrom<      MutableMove>, int>>();
+  test_move<const std::pair <ConstMove  , int>, std::tuple<ConvertibleFrom<const ConstMove  >, int>>();
+  // test implicit conversions with allocator
+  test_copy_allocator<      std::tuple<MutableCopy, int>, std::tuple<ConvertibleFrom<      MutableCopy>, int>>();
+  test_copy_allocator<const std::tuple<ConstCopy  , int>, std::tuple<ConvertibleFrom<const ConstCopy  >, int>>();
+  test_move_allocator<      std::tuple<MutableMove, int>, std::tuple<ConvertibleFrom<      MutableMove>, int>>();
+  test_move_allocator<const std::tuple<ConstMove  , int>, std::tuple<ConvertibleFrom<const ConstMove  >, int>>();
+  test_copy_allocator<      std::pair <MutableCopy, int>, std::tuple<ConvertibleFrom<      MutableCopy>, int>>();
+  test_copy_allocator<const std::pair <ConstCopy  , int>, std::tuple<ConvertibleFrom<const ConstCopy  >, int>>();
+  test_move_allocator<      std::pair <MutableMove, int>, std::tuple<ConvertibleFrom<      MutableMove>, int>>();
+  test_move_allocator<const std::pair <ConstMove  , int>, std::tuple<ConvertibleFrom<const ConstMove  >, int>>();
+  // test explicit conversions
+  test_copy_explicit<      std::tuple<MutableCopy, int>, std::tuple<ExplicitConstructibleFrom<      MutableCopy>, int>>();
+  test_copy_explicit<const std::tuple<ConstCopy  , int>, std::tuple<ExplicitConstructibleFrom<const ConstCopy  >, int>>();
+  test_move_explicit<      std::tuple<MutableMove, int>, std::tuple<ExplicitConstructibleFrom<      MutableMove>, int>>();
+  test_move_explicit<const std::tuple<ConstMove  , int>, std::tuple<ExplicitConstructibleFrom<const ConstMove  >, int>>();
+  test_copy_explicit<      std::pair <MutableCopy, int>, std::tuple<ExplicitConstructibleFrom<      MutableCopy>, int>>();
+  test_copy_explicit<const std::pair <ConstCopy  , int>, std::tuple<ExplicitConstructibleFrom<const ConstCopy  >, int>>();
+  test_move_explicit<      std::pair <MutableMove, int>, std::tuple<ExplicitConstructibleFrom<      MutableMove>, int>>();
+  test_move_explicit<const std::pair <ConstMove  , int>, std::tuple<ExplicitConstructibleFrom<const ConstMove  >, int>>();
+  // test explicit conversions with allocator
+  test_copy_allocator_explicit<      std::tuple<MutableCopy, int>, std::tuple<ExplicitConstructibleFrom<      MutableCopy>, int>>();
+  test_copy_allocator_explicit<const std::tuple<ConstCopy  , int>, std::tuple<ExplicitConstructibleFrom<const ConstCopy  >, int>>();
+  test_move_allocator_explicit<      std::tuple<MutableMove, int>, std::tuple<ExplicitConstructibleFrom<      MutableMove>, int>>();
+  test_move_allocator_explicit<const std::tuple<ConstMove  , int>, std::tuple<ExplicitConstructibleFrom<const ConstMove  >, int>>();
+  test_copy_allocator_explicit<      std::pair <MutableCopy, int>, std::tuple<ExplicitConstructibleFrom<      MutableCopy>, int>>();
+  test_copy_allocator_explicit<const std::pair <ConstCopy  , int>, std::tuple<ExplicitConstructibleFrom<const ConstCopy  >, int>>();
+  test_move_allocator_explicit<      std::pair <MutableMove, int>, std::tuple<ExplicitConstructibleFrom<      MutableMove>, int>>();
+  test_move_allocator_explicit<const std::pair <ConstMove  , int>, std::tuple<ExplicitConstructibleFrom<const ConstMove  >, int>>();
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+  return 0;
+}

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.special/non_member_swap_const.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
+//
+//===----------------------------------------------------------------------===//
+
+// <tuple>
+
+// template <class... Types> class tuple;
+
+// template <class... Types>
+//   void swap(const tuple<Types...>& x, const tuple<Types...>& y);
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <tuple>
+#include <cassert>
+
+struct S {
+  int* calls;
+  friend constexpr void swap(S& a, S& b) {
+    *a.calls += 1;
+    *b.calls += 1;
+  }
+};
+struct CS {
+  int* calls;
+  friend constexpr void swap(const CS& a, const CS& b) {
+    *a.calls += 1;
+    *b.calls += 1;
+  }
+};
+
+static_assert(std::is_swappable_v<std::tuple<>>);
+static_assert(std::is_swappable_v<std::tuple<S>>);
+static_assert(std::is_swappable_v<std::tuple<CS>>);
+static_assert(std::is_swappable_v<std::tuple<S&>>);
+static_assert(std::is_swappable_v<std::tuple<CS, S>>);
+static_assert(std::is_swappable_v<std::tuple<CS, S&>>);
+static_assert(std::is_swappable_v<const std::tuple<>>);
+static_assert(!std::is_swappable_v<const std::tuple<S>>);
+static_assert(std::is_swappable_v<const std::tuple<CS>>);
+static_assert(std::is_swappable_v<const std::tuple<S&>>);
+static_assert(!std::is_swappable_v<const std::tuple<CS, S>>);
+static_assert(std::is_swappable_v<const std::tuple<CS, S&>>);
+
+constexpr bool test() {
+  int cs_calls = 0;
+  int s_calls = 0;
+  S s1{&s_calls};
+  S s2{&s_calls};
+  const std::tuple<CS, S&> t1 = {CS{&cs_calls}, s1};
+  const std::tuple<CS, S&> t2 = {CS{&cs_calls}, s2};
+  swap(t1, t2);
+  assert(cs_calls == 2);
+  assert(s_calls == 2);
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.swap/member_swap.pass.cpp

bool test()
         assert(std::get<2>(t1) == 2);
     }
     return true;
 }
 
 int main(int, char**)
 {
     test();
-#if TEST_STD_VER >= 20
+#if TEST_STD_VER > 17
     static_assert(test());
 #endif
 
     return 0;
 }

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.swap/member_swap_const.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
+//
+//===----------------------------------------------------------------------===//
+
+// <tuple>
+
+// void swap(const tuple& rhs);
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// XFAIL: gcc
+
+#include <cassert>
+#include <tuple>
+
+class SwapThrower {
+    void swap(SwapThrower&) = delete;
+    void swap(const SwapThrower&) const = delete;
+};
+
+void swap(const SwapThrower&, const SwapThrower&) { throw 0.f; }
+
+static_assert(std::is_swappable_v<const SwapThrower>);
+static_assert(std::is_swappable_with_v<const SwapThrower&, const SwapThrower&>);
+
+void test_noexcept() {
+    const std::tuple<SwapThrower> t1;
+    const std::tuple<SwapThrower> t2;
+
+    try {
+        t1.swap(t2);
+        std::swap(t1, t2);
+        assert(false);
+    } catch(float) {}
+
+    try {
+        std::swap(std::as_const(t1), std::as_const(t2));
+        assert(false);
+    } catch(float) {}
+}
+
+struct ConstSwappable {
+  mutable int i;
+};
+
+constexpr void swap(const ConstSwappable& lhs, const ConstSwappable& rhs) { std::swap(lhs.i, rhs.i); }
+
+constexpr bool test() {
+  {
+    typedef std::tuple<const ConstSwappable> T;
+    const T t0({0});
+    T t1({1});
+    t0.swap(t1);
+    assert(std::get<0>(t0).i == 1);
+    assert(std::get<0>(t1).i == 0);
+  }
+  {
+    typedef std::tuple<ConstSwappable, ConstSwappable> T;
+    const T t0({0}, {1});
+    const T t1({2}, {3});
+    t0.swap(t1);
+    assert(std::get<0>(t0).i == 2);
+    assert(std::get<1>(t0).i == 3);
+    assert(std::get<0>(t1).i == 0);
+    assert(std::get<1>(t1).i == 1);
+  }
+  {
+    typedef std::tuple<ConstSwappable, const ConstSwappable, const ConstSwappable> T;
+    const T t0({0}, {1}, {2});
+    const T t1({3}, {4}, {5});
+    t0.swap(t1);
+    assert(std::get<0>(t0).i == 3);
+    assert(std::get<1>(t0).i == 4);
+    assert(std::get<2>(t0).i == 5);
+    assert(std::get<0>(t1).i == 0);
+    assert(std::get<1>(t1).i == 1);
+    assert(std::get<2>(t1).i == 2);
+  }
+  return true;
+}
+
+int main(int, char**) {
+  test_noexcept();
+  test();
+  static_assert(test());
+
+  return 0;
+}