[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

346

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

255

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

346

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.)

515

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

793–796

(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

808

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.

862

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

990–1007

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

346

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.

805

Right? (Please add a regression test.)

854

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).

1084

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

551–554

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

854

I wasn't able to reproduce it.

libcxx/include/type_traits

551–554

_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

785–787

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

838

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.

1345

What's with the reference here

libcxx/include/type_traits

532

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

551–554

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

[EricWF]

libcxx/include/tuple

785–787

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

551–554

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

249

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

251

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

344

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

[ldionne]

libcxx/include/tuple

516

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.

767

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.

785–787

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.

838

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 :-).

854–855

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.

1021–1023

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

16 ↗

(On Diff #417045)

Why does it fail on GCC?

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

1 ↗

(On Diff #417045)

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.

13 ↗

(On Diff #417045)

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

785–787

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

533

I

551–554

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

991–1005

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.

1102

Are we implementing this for std::array too?

[EricWF]

libcxx/include/tuple

1090

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

533

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

1693

Use _If here to avoid adding more template instantiations.

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

16 ↗

(On Diff #417045)

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

838

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?

1090

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

1102

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

16 ↗

(On Diff #417045)

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.

770

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

775

776–777

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

779

785–787

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.

787–788

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.

838

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.

849

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

948

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

1084

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

1090

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

1102

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

1145

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.

1167–1174

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.

1299

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

1348

Ditto.

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

35–36

66

81

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

16

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.

42

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

2

4

This file is missing a license :)

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

115

Let's use TEST_COMPILER_GCC.

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

2

Same comment for license and header guard.

[huixie90]

address review comments. refactored more assignment operators

libcxx/include/tuple

838

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?

849

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

1167–1174

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

838

I think you're right.

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

112

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

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

 class 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... UTypes>
+        constexpr explicit(see-below) tuple(tuple<UTypes...>&);  // C++23
     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... UTypes>
+        constexpr explicit(see-below) tuple(const tuple<UTypes...>&&); // C++23
+
+    template<class U1, class U2>
+        constexpr explicit(see-below) tuple(pair<U1, U2>&);  // iff sizeof...(Types) == 2 // C++23
     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
+    template<class U1, class U2>
+        constexpr explicit(see-below) tuple(const pair<U1, U2>&&);  // iff sizeof...(Types) == 2 // C++23
 
     // allocator-extended constructors
     template <class Alloc>
         tuple(allocator_arg_t, const Alloc& a);
     template <class Alloc>
         explicit(see-below) tuple(allocator_arg_t, const Alloc& a, const T&...);          // constexpr in C++20
     template <class Alloc, class... U>
         explicit(see-below) tuple(allocator_arg_t, const Alloc& a, U&&...);               // constexpr in C++20
     template <class Alloc>
         tuple(allocator_arg_t, const Alloc& a, const tuple&);                             // constexpr in C++20
     template <class Alloc>
         tuple(allocator_arg_t, const Alloc& a, tuple&&);                                  // constexpr in C++20
+    template<class Alloc, class... UTypes>
+        constexpr explicit(see-below)
+          tuple(allocator_arg_t, const Alloc& a, tuple<UTypes...>&);                      // C++23    
     template <class Alloc, class... U>
         explicit(see-below) tuple(allocator_arg_t, const Alloc& a, const tuple<U...>&);   // constexpr in C++20
     template <class Alloc, class... U>
         explicit(see-below) tuple(allocator_arg_t, const Alloc& a, tuple<U...>&&);        // constexpr in C++20
+    template<class Alloc, class... UTypes>
+        constexpr explicit(see-below)
+          tuple(allocator_arg_t, const Alloc& a, const tuple<UTypes...>&&);               // C++23
+    template<class Alloc, class U1, class U2>
+        constexpr explicit(see-below)
+          tuple(allocator_arg_t, const Alloc& a, pair<U1, U2>&);                          // C++23
     template <class Alloc, class U1, class U2>
         explicit(see-below) tuple(allocator_arg_t, const Alloc& a, const pair<U1, U2>&);  // constexpr in C++20
     template <class Alloc, class U1, class U2>
         explicit(see-below) tuple(allocator_arg_t, const Alloc& a, pair<U1, U2>&&);       // constexpr in C++20
+    template<class Alloc, class U1, class U2>
+        constexpr explicit(see-below)
+          tuple(allocator_arg_t, const Alloc& a, const pair<U1, U2>&&);                   // C++23
 
     tuple& operator=(const tuple&);                                                       // constexpr in C++20
+    constexpr const tuple& operator=(const tuple&) const;                                 // C++23
     tuple& operator=(tuple&&) noexcept(is_nothrow_move_assignable_v<T> && ...);           // constexpr in C++20
+    constexpr const tuple& operator=(tuple&&) const;                                      // C++23
     template <class... U>
         tuple& operator=(const tuple<U...>&);                                             // constexpr in C++20
+    template<class... UTypes>
+        constexpr const tuple& operator=(const tuple<UTypes...>&) const;                  // C++23
     template <class... U>
         tuple& operator=(tuple<U...>&&);                                                  // constexpr in C++20
+    template<class... UTypes>
+        constexpr const tuple& operator=(tuple<UTypes...>&&) const;                       // C++23
     template <class U1, class U2>
         tuple& operator=(const pair<U1, U2>&); // iff sizeof...(T) == 2                   // constexpr in C++20
-    template <class U1, class U2>
+    template<class U1, class U2>
+        constexpr const tuple& operator=(const pair<U1, U2>&) const;   // iff sizeof...(Types) == 2 // C++23
+    template <class U1, class U2>
         tuple& operator=(pair<U1, U2>&&); // iff sizeof...(T) == 2                        // constexpr in C++20
+    template<class U1, class U2>
+        constexpr const tuple& operator=(pair<U1, U2>&&) const;  // iff sizeof...(Types) == 2 // C++23
 
     template<class U, size_t N>
         tuple& operator=(array<U, N> const&) // iff sizeof...(T) == N, EXTENSION
     template<class U, size_t N>
         tuple& operator=(array<U, N>&&) // iff sizeof...(T) == N, EXTENSION
 
     void swap(tuple&) noexcept(AND(swap(declval<T&>(), declval<T&>())...));               // constexpr in C++20
+    constexpr void swap(const tuple&) const noexcept(see-below);                          // C++23
 };
 
 
 template<class... TTypes, class... UTypes, template<class> class TQual, template<class> class UQual> // since C++23
   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>>...>;
 };

 
 template <class... Types, class Alloc>
   struct uses_allocator<tuple<Types...>, Alloc>;
 
 template <class... Types>
   void
   swap(tuple<Types...>& x, tuple<Types...>& y) noexcept(noexcept(x.swap(y)));
 
+template <class... Types>
+  constexpr void swap(const tuple<Types...>& x, const tuple<Types...>& y) noexcept(see-below);   // C++23
+
 }  // std
 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__compare/common_comparison_category.h>
 #include <__compare/synth_three_way.h>
 #include <__config>

 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());
 }
 
+template <size_t _Ip, class _Hp, bool _Ep>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11
+void swap(const __tuple_leaf<_Ip, _Hp, _Ep>& __x, const __tuple_leaf<_Ip, _Hp, _Ep>& __y) 
+     _NOEXCEPT_(__is_nothrow_swappable<const _Hp>::value) {
+  swap(__x.get(), __y.get());
+}
+
 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)
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;
     }
 
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
+    int swap(const __tuple_leaf& __t) const _NOEXCEPT_(__is_nothrow_swappable<const __tuple_leaf>::value) {
+        _VSTD::swap(*this, __t);
+        return 0;
+    }
+
     _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;
     }
 
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
+    int swap(const __tuple_leaf& __rhs) const _NOEXCEPT_(__is_nothrow_swappable<const __tuple_leaf>::value) {
+        _VSTD::swap(*this, __rhs);
+        return 0;
+    }
+
     _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))...);
     }
+
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
+    void swap(const __tuple_impl& __t) const
+        _NOEXCEPT_(__all<__is_nothrow_swappable<const _Tp>::value...>::value)
+    {
+        _VSTD::__swallow(__tuple_leaf<_Indx, _Tp>::swap(static_cast<const __tuple_leaf<_Indx, _Tp>&>(__t))...);
+    }
 };
 
 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:
 
     // Copy and move constructors (including the allocator_arg_t variants)
     tuple(const tuple&) = default;
     tuple(tuple&&) = default;
 
     template <class _Alloc, template<class...> class _And = _And, __enable_if_t<
         _And<is_copy_constructible<_Tp>...>::value
     , int> = 0>
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     tuple(allocator_arg_t, const _Alloc& __alloc, const tuple& __t)
         : __base_(allocator_arg_t(), __alloc, __t)
     { }
 
     template <class _Alloc, template<class...> class _And = _And, __enable_if_t<
         _And<is_move_constructible<_Tp>...>::value
     , int> = 0>
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     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>
-    struct _EnableCopyFromOtherTuple : _And<
-        _Not<is_same<tuple<_Tp...>, tuple<_Up...> > >,
-        _Lazy<_Or,
-            _BoolConstant<sizeof...(_Tp) != 1>,
+    
+    template <class _OtherTuple, class _DecayedOtherTuple = __uncvref_t<_OtherTuple>, class = void>
+    struct _EnableCtorFromUTypesTuple : false_type {};
+
+    template <class _OtherTuple, class... _Up>
+    struct _EnableCtorFromUTypesTuple<_OtherTuple, tuple<_Up...>, 
+              // the length of the packs needs to checked first otherwise the 2 packs cannot be expanded simultaneously below
+               __enable_if_t<sizeof...(_Up) == sizeof...(_Tp)>> : _And<
+        // the two conditions below are not in spec. The purpose is to disable the UTypes Ctor when copy/move Ctor can work.
+        // Otherwise, is_constructible can trigger hard error in those cases https://godbolt.org/z/M94cGdKcE
+        _Not<is_same<_OtherTuple, const tuple&> >,
+        _Not<is_same<_OtherTuple, tuple&&> >,
+        is_constructible<_Tp, __copy_cvref_t<_OtherTuple, _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>&> >...
-            >
-        >,
-        is_constructible<_Tp, const _Up&>...
-    > { };
+                _Not<is_same<_Tp, _Up> >...,
+                _Not<is_convertible<_OtherTuple, _Tp> >...,
+                _Not<is_constructible<_Tp, _OtherTuple> >...
+            >
+    > {};
 
     template <class ..._Up, __enable_if_t<
         _And<
-            _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
-            _EnableCopyFromOtherTuple<_Up...>,
+            _EnableCtorFromUTypesTuple<const tuple<_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...>,
+            _EnableCtorFromUTypesTuple<const tuple<_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...>,
+            _EnableCtorFromUTypesTuple<const tuple<_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...>,
+            _EnableCtorFromUTypesTuple<const tuple<_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)
     { }
 
+#if _LIBCPP_STD_VER > 20
+    // tuple(tuple<U...>&) constructors (including allocator_arg_t variants)
+
+    template <class... _Up, enable_if_t<
+        _EnableCtorFromUTypesTuple<tuple<_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<
+        _EnableCtorFromUTypesTuple<tuple<_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
+
     // 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>...
-    > { };
 
     template <class ..._Up, __enable_if_t<
         _And<
-            _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
-            _EnableMoveFromOtherTuple<_Up...>,
+            _EnableCtorFromUTypesTuple<tuple<_Up...>&&>,
             is_convertible<_Up, _Tp>... // explicit check
         >::value
     , int> = 0>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     tuple(tuple<_Up...>&& __t)
         _NOEXCEPT_((_And<is_nothrow_constructible<_Tp, _Up>...>::value))
         : __base_(_VSTD::move(__t))
     { }
 
     template <class ..._Up, __enable_if_t<
         _And<
-            _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
-            _EnableMoveFromOtherTuple<_Up...>,
+            _EnableCtorFromUTypesTuple<tuple<_Up...>&&>,
             _Not<_Lazy<_And, is_convertible<_Up, _Tp>...> > // explicit check
         >::value
     , int> = 0>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     explicit tuple(tuple<_Up...>&& __t)
         _NOEXCEPT_((_And<is_nothrow_constructible<_Tp, _Up>...>::value))
         : __base_(_VSTD::move(__t))
     { }
 
     template <class _Alloc, class ..._Up, __enable_if_t<
         _And<
-            _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
-            _EnableMoveFromOtherTuple<_Up...>,
+            _EnableCtorFromUTypesTuple<tuple<_Up...>&&>,
             is_convertible<_Up, _Tp>... // explicit check
         >::value
     , int> = 0>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     tuple(allocator_arg_t, const _Alloc& __a, tuple<_Up...>&& __t)
         : __base_(allocator_arg_t(), __a, _VSTD::move(__t))
     { }
 
     template <class _Alloc, class ..._Up, __enable_if_t<
         _And<
-            _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
-            _EnableMoveFromOtherTuple<_Up...>,
+            _EnableCtorFromUTypesTuple<tuple<_Up...>&&>,
             _Not<_Lazy<_And, is_convertible<_Up, _Tp>...> > // explicit check
         >::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))
     { }
 
+#if _LIBCPP_STD_VER > 20
+    // tuple(const tuple<U...>&&) constructors (including allocator_arg_t variants)
+
+    template <class... _Up, enable_if_t<
+        _EnableCtorFromUTypesTuple<const tuple<_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<
+        _EnableCtorFromUTypesTuple<const tuple<_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
+
     // tuple(const pair<U1, U2>&) constructors (including allocator_arg_t variants)
-    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...> >
-    > { };
+
+    template <template <class...> class Pred, class _Pair, class _DecayedPair = __uncvref_t<_Pair>, class _Tuple = tuple>
+    struct _CtorPredicateFromPair : false_type{};
+
+    template <template <class...> class Pred, class _Pair, class _Up1, class _Up2, class _Tp1, class _Tp2>
+    struct _CtorPredicateFromPair<Pred, _Pair, pair<_Up1, _Up2>, tuple<_Tp1, _Tp2> > : _And<
+        Pred<_Tp1, __copy_cvref_t<_Pair, _Up1> >,
+        Pred<_Tp2, __copy_cvref_t<_Pair, _Up2> >
+    > {};
 
-    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...> > >
-    > { };
+    template <class _Pair>
+    struct _EnableCtorFromPair : _CtorPredicateFromPair<is_constructible, _Pair>{};
+
+    template <class _Pair>
+    struct _NothrowConstructibleFromPair : _CtorPredicateFromPair<is_nothrow_constructible, _Pair>{};
+
+    template <class _Pair, class _DecayedPair = __uncvref_t<_Pair>, class _Tuple = tuple>
+    struct _BothImplicitlyConvertible : false_type{};
+
+    template <class _Pair, class _Up1, class _Up2, class _Tp1, class _Tp2>
+    struct _BothImplicitlyConvertible<_Pair, pair<_Up1, _Up2>, tuple<_Tp1, _Tp2> > : _And<
+        is_convertible<__copy_cvref_t<_Pair, _Up1>, _Tp1>,
+        is_convertible<__copy_cvref_t<_Pair, _Up2>, _Tp2>
+    > {};
 
     template <class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
         _And<
-            _BoolConstant<sizeof...(_Tp) == 2>,
-            _EnableImplicitCopyFromPair<_Up1, _Up2, _Tp...>
+            _EnableCtorFromPair<const pair<_Up1, _Up2>&>,
+            _BothImplicitlyConvertible<const pair<_Up1, _Up2>&> // explicit check
         >::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))
+        _NOEXCEPT_((_NothrowConstructibleFromPair<const pair<_Up1, _Up2>&>::value))
         : __base_(__p)
     { }
 
     template <class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
         _And<
-            _BoolConstant<sizeof...(_Tp) == 2>,
-            _EnableExplicitCopyFromPair<_Up1, _Up2, _Tp...>
+            _EnableCtorFromPair<const pair<_Up1, _Up2>&>,
+            _Not<_BothImplicitlyConvertible<const pair<_Up1, _Up2>&> > // explicit check
         >::value
     , int> = 0>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     explicit tuple(const pair<_Up1, _Up2>& __p)
-        _NOEXCEPT_((_And<
-            is_nothrow_constructible<_FirstType<_Tp...>, const _Up1&>,
-            is_nothrow_constructible<_SecondType<_Tp...>, const _Up2&>
-        >::value))
+        _NOEXCEPT_((_NothrowConstructibleFromPair<const pair<_Up1, _Up2>&>::value))
         : __base_(__p)
     { }
 
     template <class _Alloc, class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
         _And<
-            _BoolConstant<sizeof...(_Tp) == 2>,
-            _EnableImplicitCopyFromPair<_Up1, _Up2, _Tp...>
+            _EnableCtorFromPair<const pair<_Up1, _Up2>&>,
+            _BothImplicitlyConvertible<const pair<_Up1, _Up2>&> // explicit check
         >::value
     , int> = 0>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     tuple(allocator_arg_t, const _Alloc& __a, const pair<_Up1, _Up2>& __p)
         : __base_(allocator_arg_t(), __a, __p)
     { }
 
     template <class _Alloc, class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
         _And<
-            _BoolConstant<sizeof...(_Tp) == 2>,
-            _EnableExplicitCopyFromPair<_Up1, _Up2, _Tp...>
+            _EnableCtorFromPair<const pair<_Up1, _Up2>&>,
+            _Not<_BothImplicitlyConvertible<const pair<_Up1, _Up2>&> > // explicit check
         >::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<
-        is_constructible<_FirstType<_DependentTp...>, _Up1>,
-        is_constructible<_SecondType<_DependentTp...>, _Up2>,
-        is_convertible<_Up1, _FirstType<_DependentTp...> >, // explicit check
-        is_convertible<_Up2, _SecondType<_DependentTp...> >
-    > { };
+#if _LIBCPP_STD_VER > 20
+    // tuple(pair<U1, U2>&) constructors (including allocator_arg_t variants)
 
-    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...> > >
-    > { };
+    template <class _U1, class _U2, enable_if_t<
+        _EnableCtorFromPair<pair<_U1, _U2>&>::value>* = nullptr>
+    _LIBCPP_HIDE_FROM_ABI constexpr
+        explicit(!_BothImplicitlyConvertible<pair<_U1, _U2>&>::value)
+    tuple(pair<_U1, _U2>& __p) : __base_(__p) {}
+
+    template <class _Alloc, class _U1, class _U2, enable_if_t<
+        _EnableCtorFromPair<std::pair<_U1, _U2>&>::value>* = nullptr>
+    _LIBCPP_HIDE_FROM_ABI constexpr
+        explicit(!_BothImplicitlyConvertible<pair<_U1, _U2>&>::value)
+    tuple(allocator_arg_t, const _Alloc& __alloc, pair<_U1, _U2>& __p) : __base_(allocator_arg_t(), __alloc, __p) {}
+#endif
+
+    // tuple(pair<U1, U2>&&) constructors (including allocator_arg_t variants)
 
     template <class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
         _And<
-            _BoolConstant<sizeof...(_Tp) == 2>,
-            _EnableImplicitMoveFromPair<_Up1, _Up2, _Tp...>
+            _EnableCtorFromPair<pair<_Up1, _Up2>&&>,
+            _BothImplicitlyConvertible<pair<_Up1, _Up2>&&> // explicit check
         >::value
     , int> = 0>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     tuple(pair<_Up1, _Up2>&& __p)
-        _NOEXCEPT_((_And<
-            is_nothrow_constructible<_FirstType<_Tp...>, _Up1>,
-            is_nothrow_constructible<_SecondType<_Tp...>, _Up2>
-        >::value))
+        _NOEXCEPT_((_NothrowConstructibleFromPair<pair<_Up1, _Up2>&&>::value))
         : __base_(_VSTD::move(__p))
     { }
 
     template <class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
         _And<
-            _BoolConstant<sizeof...(_Tp) == 2>,
-            _EnableExplicitMoveFromPair<_Up1, _Up2, _Tp...>
+            _EnableCtorFromPair<pair<_Up1, _Up2>&&>,
+            _Not<_BothImplicitlyConvertible<pair<_Up1, _Up2>&&> > // explicit check
         >::value
     , int> = 0>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     explicit tuple(pair<_Up1, _Up2>&& __p)
-        _NOEXCEPT_((_And<
-            is_nothrow_constructible<_FirstType<_Tp...>, _Up1>,
-            is_nothrow_constructible<_SecondType<_Tp...>, _Up2>
-        >::value))
+        _NOEXCEPT_((_NothrowConstructibleFromPair<pair<_Up1, _Up2>&&>::value))
         : __base_(_VSTD::move(__p))
     { }
 
     template <class _Alloc, class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
         _And<
-            _BoolConstant<sizeof...(_Tp) == 2>,
-            _EnableImplicitMoveFromPair<_Up1, _Up2, _Tp...>
+            _EnableCtorFromPair<pair<_Up1, _Up2>&&>,
+            _BothImplicitlyConvertible<pair<_Up1, _Up2>&&> // explicit check
         >::value
     , int> = 0>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     tuple(allocator_arg_t, const _Alloc& __a, pair<_Up1, _Up2>&& __p)
         : __base_(allocator_arg_t(), __a, _VSTD::move(__p))
     { }
 
     template <class _Alloc, class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
         _And<
-            _BoolConstant<sizeof...(_Tp) == 2>,
-            _EnableExplicitMoveFromPair<_Up1, _Up2, _Tp...>
+            _EnableCtorFromPair<pair<_Up1, _Up2>&&>,
+            _Not<_BothImplicitlyConvertible<pair<_Up1, _Up2>&&> > // explicit check
         >::value
     , int> = 0>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     explicit tuple(allocator_arg_t, const _Alloc& __a, pair<_Up1, _Up2>&& __p)
         : __base_(allocator_arg_t(), __a, _VSTD::move(__p))
     { }
 
+#if _LIBCPP_STD_VER > 20
+    // tuple(const pair<U1, U2>&&) constructors (including allocator_arg_t variants)
+
+    template <class _U1, class _U2, enable_if_t<
+        _EnableCtorFromPair<const pair<_U1, _U2>&&>::value>* = nullptr>
+    _LIBCPP_HIDE_FROM_ABI constexpr
+        explicit(!_BothImplicitlyConvertible<const pair<_U1, _U2>&&>::value)
+    tuple(const pair<_U1, _U2>&& __p) : __base_(std::move(__p)) {}
+
+    template <class _Alloc, class _U1, class _U2, enable_if_t<
+        _EnableCtorFromPair<const pair<_U1, _U2>&&>::value>* = nullptr>
+    _LIBCPP_HIDE_FROM_ABI constexpr
+        explicit(!_BothImplicitlyConvertible<const pair<_U1, _U2>&&>::value)
+    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
+
     // [tuple.assign]
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     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=(tuple const& __tuple) const
+      requires (_And<is_copy_assignable<const _Tp>...>::value) {
+        std::__memberwise_copy_assign(*this, __tuple, typename __make_tuple_indices<sizeof...(_Tp)>::type());
+        return *this;
+    }
+
+    _LIBCPP_HIDE_FROM_ABI constexpr
+    const tuple& operator=(tuple&& __tuple) const
+      requires (_And<is_assignable<const _Tp&, _Tp>...>::value) {
+        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;
     }
 
-    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
+
+#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,
+                                      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;
+    }
+#endif // _LIBCPP_STD_VER > 20
+
+    template <template<class...> class Pred, bool _Const, 
+              class _Pair, class _DecayedPair = __uncvref_t<_Pair>, class _Tuple = tuple>
+    struct _AssignPredicateFromPair : false_type {};
+
+    template <template<class...> class Pred, bool _Const, 
+              class _Pair, class _Up1, class _Up2, class _Tp1, class _Tp2>
+    struct _AssignPredicateFromPair<Pred, _Const, _Pair, pair<_Up1, _Up2>, tuple<_Tp1, _Tp2> > : 
+        _And<Pred<__maybe_const<_Const, _Tp1>&, __copy_cvref_t<_Pair, _Up1> >,
+             Pred<__maybe_const<_Const, _Tp2>&, __copy_cvref_t<_Pair, _Up2> >
+            > {};
+
+    template <bool _Const, class _Pair>
+    struct _EnableAssignFromPair : _AssignPredicateFromPair<is_assignable, _Const, _Pair> {};
+
+    template <bool _Const, class _Pair>
+    struct _NothrowAssignFromPair : _AssignPredicateFromPair<is_nothrow_assignable, _Const, _Pair> {};
+
+#if _LIBCPP_STD_VER > 20
+    template <class _U1, class _U2, enable_if_t<
+        _EnableAssignFromPair<true, const pair<_U1, _U2>&>::value>* = nullptr>
+    _LIBCPP_HIDE_FROM_ABI constexpr
+    const tuple& operator=(const pair<_U1, _U2>& __pair) const
+      noexcept(_NothrowAssignFromPair<true, const pair<_U1, _U2>&>::value) {
+        std::get<0>(*this) = __pair.first;
+        std::get<1>(*this) = __pair.second;
+        return *this;
+    }
+
+    template <class _U1, class _U2, enable_if_t<
+        _EnableAssignFromPair<true, pair<_U1, _U2>&&>::value>* = nullptr>
+    _LIBCPP_HIDE_FROM_ABI constexpr
+    const tuple& operator=(pair<_U1, _U2>&& __pair) const
+      noexcept(_NothrowAssignFromPair<true, pair<_U1, _U2>&&>::value) {
+        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, __enable_if_t<
+        _EnableAssignFromPair<false, pair<_Up1, _Up2> const&>::value
     ,int> = 0>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     tuple& operator=(pair<_Up1, _Up2> const& __pair)
-        _NOEXCEPT_((_And<
-            is_nothrow_assignable<_FirstType<_Tp...>&, _Up1 const&>,
-            is_nothrow_assignable<_SecondType<_Tp...>&, _Up2 const&>
-        >::value))
+        _NOEXCEPT_((_NothrowAssignFromPair<false, pair<_Up1, _Up2> const&>::value))
     {
         _VSTD::get<0>(*this) = __pair.first;
         _VSTD::get<1>(*this) = __pair.second;
         return *this;
     }
 
-    template<class _Up1, class _Up2, class _Dep = true_type, __enable_if_t<
-        _And<_Dep,
-            _BoolConstant<sizeof...(_Tp) == 2>,
-            is_assignable<_FirstType<_Tp..., _Dep>&, _Up1>,
-            is_assignable<_SecondType<_Tp..., _Dep>&, _Up2>
-        >::value
+    template<class _Up1, class _Up2, __enable_if_t<
+        _EnableAssignFromPair<false, pair<_Up1, _Up2>&&>::value
     ,int> = 0>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     tuple& operator=(pair<_Up1, _Up2>&& __pair)
-        _NOEXCEPT_((_And<
-            is_nothrow_assignable<_FirstType<_Tp...>&, _Up1>,
-            is_nothrow_assignable<_SecondType<_Tp...>&, _Up2>
-        >::value))
+        _NOEXCEPT_((_NothrowAssignFromPair<false, pair<_Up1, _Up2>&&>::value))
     {
         _VSTD::get<0>(*this) = _VSTD::forward<_Up1>(__pair.first);
         _VSTD::get<1>(*this) = _VSTD::forward<_Up2>(__pair.second);
         return *this;
     }
 
     // EXTENSION
     template<class _Up, size_t _Np, class = __enable_if_t<
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& __t) const noexcept(__all<is_nothrow_swappable_v<const _Tp&>...>::value) {
+        __base_.swap(__t.__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
 };
 
 #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
+
 // 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

 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _T1, class _T2> struct _LIBCPP_TEMPLATE_VIS pair;
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS hash;
 
 template <bool> struct _MetaBase;
 template <>
 struct _MetaBase<true> {
   template <class _Tp, class _Up>
   using _SelectImpl _LIBCPP_NODEBUG = _Tp;
   template <template <class...> class _FirstFn, template <class...> class, class ..._Args>
   using _SelectApplyImpl _LIBCPP_NODEBUG = _FirstFn<_Args...>;
-  template <class _First, class...>
-  using _FirstImpl _LIBCPP_NODEBUG = _First;
-  template <class, class _Second, class...>
-  using _SecondImpl _LIBCPP_NODEBUG = _Second;
   template <class _Result, class _First, class ..._Rest>
   using _OrImpl _LIBCPP_NODEBUG = typename _MetaBase<_First::value != true && sizeof...(_Rest) != 0>::template _OrImpl<_First, _Rest...>;
 };
 
 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 <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 ..._Args>
-using _FirstType _LIBCPP_NODEBUG = typename _MetaBase<(sizeof...(_Args) >= 1)>::template _FirstImpl<_Args...>;
-template <class ..._Args>
-using _SecondType _LIBCPP_NODEBUG = typename _MetaBase<(sizeof...(_Args) >= 2)>::template _SecondImpl<_Args...>;
 
 template <class ...> using __expand_to_true = true_type;
 template <class ..._Pred>
 __expand_to_true<__enable_if_t<_Pred::value>...> __and_helper(int);
 template <class ...>
 false_type __and_helper(...);
 template <class ..._Pred>
 using _And _LIBCPP_NODEBUG = decltype(__and_helper<_Pred...>(0));
struct __can_extract_map_key<_ValTy, _Key, _Key, _RawValTy>
     : false_type {};
 
 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/libcxx/utilities/meta/meta_base.pass.cpp

void test_is_valid_trait() {
   static_assert(std::_IsValidExpansion<HasFooData, MemberTest>::value, "");
   static_assert(!std::_IsValidExpansion<HasFooType, MemberTest>::value, "");
   static_assert(!std::_IsValidExpansion<HasFooData, MemberTest2>::value, "");
   static_assert(std::_IsValidExpansion<HasFooType, MemberTest2>::value, "");
   static_assert(std::_IsValidExpansion<FuncCallable, MemberTest, int>::value, "");
   static_assert(!std::_IsValidExpansion<FuncCallable, MemberTest, void*>::value, "");
 }
 
-void test_first_and_second_type() {
-  ASSERT_SAME_TYPE(std::_FirstType<int, long, void*>, int);
-  ASSERT_SAME_TYPE(std::_FirstType<char>, char);
-  ASSERT_SAME_TYPE(std::_SecondType<char, long>, long);
-  ASSERT_SAME_TYPE(std::_SecondType<long long, int, void*>, int);
-}
-
 int main(int, char**) {
   return 0;
 }

libcxx/test/std/ranges/range.adaptors/range.zip/range.concept.compile.pass.cpp

void testConceptPair() {
   }
 }
 
 void testConceptTuple() {
   int buffer1[2] = {1, 2};
   int buffer2[3] = {1, 2, 3};
   int buffer3[4] = {1, 2, 3, 4};
 
-  // TODO: uncomment all the static_asserts once [tuple.tuple] section in P2321R2 is implemented
-  // This is because convertible_to<tuple<int&,int&,int&>&, tuple<int,int,int>> is false without
-  // the above implementation, thus the zip iterator does not model indirectly_readable
-
   {
     std::ranges::zip_view v{ContiguousCommonView{buffer1}, ContiguousCommonView{buffer2},
                             ContiguousCommonView{buffer3}};
     using View = decltype(v);
-    //  static_assert(std::ranges::random_access_range<View>);
+    static_assert(std::ranges::random_access_range<View>);
     static_assert(!std::ranges::contiguous_range<View>);
     static_assert(std::ranges::common_range<View>);
     static_assert(std::ranges::sized_range<View>);
   }
 
   {
     std::ranges::zip_view v{ContiguousNonCommonView{buffer1}, ContiguousNonCommonView{buffer2},
                             ContiguousNonCommonView{buffer3}};
     using View = decltype(v);
-    //  static_assert(std::ranges::random_access_range<View>);
+    static_assert(std::ranges::random_access_range<View>);
     static_assert(!std::ranges::contiguous_range<View>);
     static_assert(!std::ranges::common_range<View>);
     static_assert(!std::ranges::sized_range<View>);
   }
 
   {
     std::ranges::zip_view v{ContiguousNonCommonSized{buffer1}, ContiguousNonCommonSized{buffer2},
                             ContiguousNonCommonSized{buffer3}};
     using View = decltype(v);
-    //   static_assert(std::ranges::random_access_range<View>);
+    static_assert(std::ranges::random_access_range<View>);
     static_assert(!std::ranges::contiguous_range<View>);
     static_assert(std::ranges::common_range<View>);
     static_assert(std::ranges::sized_range<View>);
   }
 
   {
     std::ranges::zip_view v{SizedRandomAccessView{buffer1}, ContiguousCommonView{buffer2},
                             ContiguousCommonView{buffer3}};
     using View = decltype(v);
-    //  static_assert(std::ranges::random_access_range<View>);
+    static_assert(std::ranges::random_access_range<View>);
     static_assert(!std::ranges::contiguous_range<View>);
     static_assert(std::ranges::common_range<View>);
     static_assert(std::ranges::sized_range<View>);
   }
 
   {
     std::ranges::zip_view v{SizedRandomAccessView{buffer1}, SizedRandomAccessView{buffer2},
                             SizedRandomAccessView{buffer3}};
     using View = decltype(v);
-    //  static_assert(std::ranges::random_access_range<View>);
+    static_assert(std::ranges::random_access_range<View>);
     static_assert(!std::ranges::contiguous_range<View>);
     static_assert(std::ranges::common_range<View>);
     static_assert(std::ranges::sized_range<View>);
   }
 
   {
     std::ranges::zip_view v{NonSizedRandomAccessView{buffer1}, NonSizedRandomAccessView{buffer2},
                             NonSizedRandomAccessView{buffer3}};
     using View = decltype(v);
-    //  static_assert(std::ranges::random_access_range<View>);
+    static_assert(std::ranges::random_access_range<View>);
     static_assert(!std::ranges::contiguous_range<View>);
     static_assert(!std::ranges::common_range<View>);
     static_assert(!std::ranges::sized_range<View>);
   }
 
   {
     std::ranges::zip_view v{BidiCommonView{buffer1}, SizedRandomAccessView{buffer2}, SizedRandomAccessView{buffer3}};
     using View = decltype(v);
-    //  static_assert(std::ranges::bidirectional_range<View>);
+    static_assert(std::ranges::bidirectional_range<View>);
     static_assert(!std::ranges::random_access_range<View>);
     static_assert(!std::ranges::common_range<View>);
     static_assert(!std::ranges::sized_range<View>);
   }
 
   {
     std::ranges::zip_view v{BidiCommonView{buffer1}, BidiCommonView{buffer2}, BidiCommonView{buffer3}};
     using View = decltype(v);
-    //  static_assert(std::ranges::bidirectional_range<View>);
+    static_assert(std::ranges::bidirectional_range<View>);
     static_assert(!std::ranges::random_access_range<View>);
     static_assert(!std::ranges::common_range<View>);
     static_assert(!std::ranges::sized_range<View>);
   }
 
   {
     std::ranges::zip_view v{BidiCommonView{buffer1}, ForwardSizedView{buffer2}, ForwardSizedView{buffer3}};
     using View = decltype(v);
-    //  static_assert(std::ranges::forward_range<View>);
+    static_assert(std::ranges::forward_range<View>);
     static_assert(!std::ranges::bidirectional_range<View>);
     static_assert(std::ranges::common_range<View>);
     static_assert(!std::ranges::sized_range<View>);
   }
 
   {
     std::ranges::zip_view v{BidiNonCommonView{buffer1}, ForwardSizedView{buffer2}, ForwardSizedView{buffer3}};
     using View = decltype(v);
-    //  static_assert(std::ranges::forward_range<View>);
+    static_assert(std::ranges::forward_range<View>);
     static_assert(!std::ranges::bidirectional_range<View>);
     static_assert(!std::ranges::common_range<View>);
     static_assert(!std::ranges::sized_range<View>);
   }
 
   {
     std::ranges::zip_view v{ForwardSizedView{buffer1}, ForwardSizedView{buffer2}, ForwardSizedView{buffer3}};
     using View = decltype(v);
-    //  static_assert(std::ranges::forward_range<View>);
+    static_assert(std::ranges::forward_range<View>);
     static_assert(!std::ranges::bidirectional_range<View>);
     static_assert(std::ranges::common_range<View>);
     static_assert(std::ranges::sized_range<View>);
   }
 
   {
     std::ranges::zip_view v{ForwardSizedNonCommon{buffer1}, ForwardSizedView{buffer2}, ForwardSizedView{buffer3}};
     using View = decltype(v);
-    // static_assert(std::ranges::forward_range<View>);
+    static_assert(std::ranges::forward_range<View>);
     static_assert(!std::ranges::bidirectional_range<View>);
     static_assert(!std::ranges::common_range<View>);
     static_assert(std::ranges::sized_range<View>);
   }
 
   {
     std::ranges::zip_view v{InputCommonView{buffer1}, ForwardSizedView{buffer2}, ForwardSizedView{buffer3}};
     using View = decltype(v);
-    //  static_assert(std::ranges::input_range<View>);
+    static_assert(std::ranges::input_range<View>);
     static_assert(!std::ranges::forward_range<View>);
     static_assert(std::ranges::common_range<View>);
     static_assert(!std::ranges::sized_range<View>);
   }
 
   {
     std::ranges::zip_view v{InputCommonView{buffer1}, InputCommonView{buffer2}, InputCommonView{buffer3}};
     using View = decltype(v);
-    //   static_assert(std::ranges::input_range<View>);
+    static_assert(std::ranges::input_range<View>);
     static_assert(!std::ranges::forward_range<View>);
     static_assert(std::ranges::common_range<View>);
     static_assert(!std::ranges::sized_range<View>);
   }
 
   {
     std::ranges::zip_view v{InputNonCommonView{buffer1}, InputCommonView{buffer2}, InputCommonView{buffer3}};
     using View = decltype(v);
-    //   static_assert(std::ranges::input_range<View>);
+    static_assert(std::ranges::input_range<View>);
     static_assert(!std::ranges::forward_range<View>);
     static_assert(!std::ranges::common_range<View>);
     static_assert(!std::ranges::sized_range<View>);
   }
 }
 
 using OutputIter = cpp17_output_iterator<int*>;
 static_assert(std::output_iterator<OutputIter, int>);

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.assign/const_convert_copy.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... UTypes>
+// constexpr const tuple& operator=(const tuple<UTypes...>& u) const;
+//
+// Constraints:
+// - sizeof...(Types) equals sizeof...(UTypes) and
+// - (is_assignable_v<const Types&, const UTypes&> && ...) is true.
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <cassert>
+#include <tuple>
+#include <type_traits>
+
+#include "test_macros.h"
+#include "types.h"
+
+// test constraints
+
+// sizeof...(Types) equals sizeof...(UTypes)
+static_assert(std::is_assignable_v<const std::tuple<int&>&, const std::tuple<long&>&>);
+static_assert(!std::is_assignable_v<const std::tuple<int&, int&>&, const std::tuple<long&>&>);
+static_assert(!std::is_assignable_v<const std::tuple<int&>&, const std::tuple<long&, long&>&>);
+
+// (is_assignable_v<const Types&, const UTypes&> && ...) is true
+static_assert(std::is_assignable_v<const std::tuple<AssignableFrom<ConstCopyAssign>>&, 
+                                   const std::tuple<ConstCopyAssign>&>);
+
+static_assert(std::is_assignable_v<const std::tuple<AssignableFrom<ConstCopyAssign>, ConstCopyAssign>&,
+                                   const std::tuple<ConstCopyAssign, ConstCopyAssign>&>);
+
+static_assert(!std::is_assignable_v<const std::tuple<AssignableFrom<ConstCopyAssign>, CopyAssign>&,
+                                    const std::tuple<ConstCopyAssign, CopyAssign>&>);
+
+constexpr bool test() {
+  // reference types
+  {
+    int i1 = 1;
+    int i2 = 2;
+    long j1 = 3;
+    long j2 = 4;
+    const std::tuple<int&, int&> t1{i1, i2};
+    const std::tuple<long&, long&> t2{j1, j2};
+    t2 = t1;
+    assert(std::get<0>(t2) == 1);
+    assert(std::get<1>(t2) == 2);
+  }
+
+  // user defined const copy assignment
+  {
+    const std::tuple<ConstCopyAssign> t1{1};
+    const std::tuple<AssignableFrom<ConstCopyAssign>> t2{2};
+    t2 = t1;
+    assert(std::get<0>(t2).v.val == 1);
+  }
+
+  // make sure the right assignment operator of the type in the tuple is used
+  {
+    std::tuple<TracedAssignment> t1{};
+    const std::tuple<AssignableFrom<TracedAssignment>> t2{};
+    t2 = t1;
+    assert(std::get<0>(t2).v.constCopyAssign == 1);
+  }
+
+  return true;
+}
+
+int main() {
+  test();
+
+// gcc cannot have mutable member in constant expression
+#if !defined(TEST_COMPILER_GCC)
+  static_assert(test());
+#endif
+  return 0;
+}

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.assign/const_convert_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
+//
+//===----------------------------------------------------------------------===//
+
+// <tuple>
+
+// template <class... UTypes>
+// constexpr const tuple& operator=(tuple<UTypes...>&& u) const;
+//
+// Constraints:
+// - sizeof...(Types) equals sizeof...(UTypes) and
+// - (is_assignable_v<const Types&, UTypes> && ...) is true.
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <cassert>
+#include <tuple>
+#include <type_traits>
+
+#include "test_macros.h"
+#include "types.h"
+
+// test constraints
+
+// sizeof...(Types) equals sizeof...(UTypes)
+static_assert(std::is_assignable_v<const std::tuple<int&>&, std::tuple<long&>&&>);
+static_assert(!std::is_assignable_v<const std::tuple<int&, int&>&, std::tuple<long&>&&>);
+static_assert(!std::is_assignable_v<const std::tuple<int&>&, std::tuple<long&, long&>&&>);
+
+// (is_assignable_v<const Types&, UTypes&&> && ...) is true
+static_assert(std::is_assignable_v<const std::tuple<AssignableFrom<ConstMoveAssign>>&, std::tuple<ConstMoveAssign>&&>);
+
+static_assert(std::is_assignable_v<const std::tuple<AssignableFrom<ConstMoveAssign>, ConstMoveAssign>&,
+                                   std::tuple<ConstMoveAssign, ConstMoveAssign>&&>);
+
+static_assert(!std::is_assignable_v<const std::tuple<AssignableFrom<ConstMoveAssign>, AssignableFrom<MoveAssign>>&,
+                                    std::tuple<ConstMoveAssign, MoveAssign>&&>);
+
+constexpr bool test() {
+  // reference types
+  {
+    int i1 = 1;
+    int i2 = 2;
+    long j1 = 3;
+    long j2 = 4;
+    std::tuple<int&, int&> t1{i1, i2};
+    const std::tuple<long&, long&> t2{j1, j2};
+    t2 = std::move(t1);
+    assert(std::get<0>(t2) == 1);
+    assert(std::get<1>(t2) == 2);
+  }
+
+  // user defined const copy assignment
+  {
+    std::tuple<ConstMoveAssign> t1{1};
+    const std::tuple<AssignableFrom<ConstMoveAssign>> t2{2};
+    t2 = std::move(t1);
+    assert(std::get<0>(t2).v.val == 1);
+  }
+
+  // make sure the right assignment operator of the type in the tuple is used
+  {
+    std::tuple<TracedAssignment> t1{};
+    const std::tuple<AssignableFrom<TracedAssignment>> t2{};
+    t2 = std::move(t1);
+    assert(std::get<0>(t2).v.constMoveAssign == 1);
+  }
+
+  return true;
+}
+
+int main() {
+  test();
+
+// gcc cannot have mutable member in constant expression
+#if !defined(TEST_COMPILER_GCC)
+  static_assert(test());
+#endif
+  return 0;
+}

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.assign/const_copy.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>
+
+// constexpr const tuple& operator=(const tuple&) const;
+//
+// Constraints: (is_copy_assignable_v<const Types> && ...) is true.
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// test constraints
+
+#include <cassert>
+#include <tuple>
+#include <type_traits>
+
+#include "test_macros.h"
+#include "types.h"
+
+static_assert(!std::is_assignable_v<const std::tuple<int>&, const std::tuple<int>&>);
+static_assert(std::is_assignable_v<const std::tuple<int&>&, const std::tuple<int&>&>);
+static_assert(std::is_assignable_v<const std::tuple<int&, int&>&, const std::tuple<int&, int&>&>);
+static_assert(!std::is_assignable_v<const std::tuple<int&, int>&, const std::tuple<int&, int>&>);
+static_assert(std::is_assignable_v<const std::tuple<ConstCopyAssign>&, const std::tuple<ConstCopyAssign>&>);
+static_assert(!std::is_assignable_v<const std::tuple<CopyAssign>&, const std::tuple<CopyAssign>&>);
+static_assert(!std::is_assignable_v<const std::tuple<ConstMoveAssign>&, const std::tuple<ConstMoveAssign>&>);
+static_assert(!std::is_assignable_v<const std::tuple<MoveAssign>&, const std::tuple<MoveAssign>&>);
+
+constexpr bool test() {
+  // reference types
+  {
+    int i1 = 1;
+    int i2 = 2;
+    double d1 = 3.0;
+    double d2 = 5.0;
+    const std::tuple<int&, double&> t1{i1, d1};
+    const std::tuple<int&, double&> t2{i2, d2};
+    t2 = t1;
+    assert(std::get<0>(t2) == 1);
+    assert(std::get<1>(t2) == 3.0);
+  }
+
+  // user defined const copy assignment
+  {
+    const std::tuple<ConstCopyAssign> t1{1};
+    const std::tuple<ConstCopyAssign> t2{2};
+    t2 = t1;
+    assert(std::get<0>(t2).val == 1);
+  }
+
+  // make sure the right assignment operator of the type in the tuple is used
+  {
+    std::tuple<TracedAssignment, const TracedAssignment> t1{};
+    const std::tuple<TracedAssignment, const TracedAssignment> t2{};
+    t2 = t1;
+    assert(std::get<0>(t2).constCopyAssign == 1);
+    assert(std::get<1>(t2).constCopyAssign == 1);
+  }
+
+  return true;
+}
+
+int main() {
+  test();
+
+// gcc cannot have mutable member in constant expression
+#if !defined(TEST_COMPILER_GCC)
+  static_assert(test());
+#endif
+  return 0;
+}

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.assign/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
+//
+//===----------------------------------------------------------------------===//
+
+// <tuple>
+
+// constexpr const tuple& operator=(tuple&&) const;
+//
+// Constraints: (is_assignable_v<const Types&, Types> && ...) is true.
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// test constraints
+
+#include <cassert>
+#include <tuple>
+#include <type_traits>
+
+#include "test_macros.h"
+#include "types.h"
+
+static_assert(!std::is_assignable_v<const std::tuple<int>&, std::tuple<int>&&>);
+static_assert(std::is_assignable_v<const std::tuple<int&>&, std::tuple<int&>&&>);
+static_assert(std::is_assignable_v<const std::tuple<int&, int&>&, std::tuple<int&, int&>&&>);
+static_assert(!std::is_assignable_v<const std::tuple<int&, int>&, std::tuple<int&, int>&&>);
+
+// this is fallback to tuple's const copy assignment
+static_assert(std::is_assignable_v<const std::tuple<ConstCopyAssign>&, std::tuple<ConstCopyAssign>&&>);
+
+static_assert(!std::is_assignable_v<const std::tuple<CopyAssign>&, std::tuple<CopyAssign>&&>);
+static_assert(std::is_assignable_v<const std::tuple<ConstMoveAssign>&, std::tuple<ConstMoveAssign>&&>);
+static_assert(!std::is_assignable_v<const std::tuple<MoveAssign>&, std::tuple<MoveAssign>&&>);
+
+constexpr bool test() {
+  // reference types
+  {
+    int i1 = 1;
+    int i2 = 2;
+    double d1 = 3.0;
+    double d2 = 5.0;
+    std::tuple<int&, double&> t1{i1, d1};
+    const std::tuple<int&, double&> t2{i2, d2};
+    t2 = std::move(t1);
+    assert(std::get<0>(t2) == 1);
+    assert(std::get<1>(t2) == 3.0);
+  }
+
+  // user defined const move assignment
+  {
+    std::tuple<ConstMoveAssign> t1{1};
+    const std::tuple<ConstMoveAssign> t2{2};
+    t2 = std::move(t1);
+    assert(std::get<0>(t2).val == 1);
+  }
+
+  // make sure the right assignment operator of the type in the tuple is used
+  {
+    std::tuple<TracedAssignment, const TracedAssignment> t1{};
+    const std::tuple<TracedAssignment, const TracedAssignment> t2{};
+    t2 = std::move(t1);
+    assert(std::get<0>(t2).constMoveAssign == 1);
+    assert(std::get<1>(t2).constCopyAssign == 1);
+  }
+
+  return true;
+}
+
+int main() {
+  test();
+// gcc cannot have mutable member in constant expression
+#if !defined(TEST_COMPILER_GCC)
+  static_assert(test());
+#endif
+  return 0;
+}

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.assign/const_pair_copy.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 U1, class U2>
+// constexpr const tuple& operator=(const pair<U1, U2>& u) const;
+//
+// - sizeof...(Types) is 2,
+// - is_assignable_v<const T1&, const U1&> is true, and
+// - is_assignable_v<const T2&, const U2&> is true
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <cassert>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+#include "test_macros.h"
+#include "types.h"
+
+// test constraints
+
+// sizeof...(Types) != 2,
+static_assert(std::is_assignable_v<const std::tuple<int&, int&>&, const std::pair<int&, int&>&>);
+static_assert(!std::is_assignable_v<const std::tuple<int&>&, const std::pair<int&, int&>&>);
+static_assert(!std::is_assignable_v<const std::tuple<int&, int&, int&>&, const std::pair<int&, int&>&>);
+
+static_assert(std::is_assignable_v<const std::tuple<AssignableFrom<ConstCopyAssign>, ConstCopyAssign>&,
+                                   const std::pair<ConstCopyAssign, ConstCopyAssign>&>);
+
+// is_assignable_v<const T1&, const U1&> is false
+static_assert(!std::is_assignable_v<const std::tuple<AssignableFrom<CopyAssign>, ConstCopyAssign>&,
+                                    const std::pair<CopyAssign, ConstCopyAssign>&>);
+
+// is_assignable_v<const T2&, const U2&> is false
+static_assert(!std::is_assignable_v<const std::tuple<AssignableFrom<ConstCopyAssign>, AssignableFrom<CopyAssign>>&,
+                                    const std::tuple<ConstCopyAssign, CopyAssign>&>);
+
+constexpr bool test() {
+  // reference types
+  {
+    int i1 = 1;
+    int i2 = 2;
+    long j1 = 3;
+    long j2 = 4;
+    const std::pair<int&, int&> t1{i1, i2};
+    const std::tuple<long&, long&> t2{j1, j2};
+    t2 = t1;
+    assert(std::get<0>(t2) == 1);
+    assert(std::get<1>(t2) == 2);
+  }
+
+  // user defined const copy assignment
+  {
+    const std::pair<ConstCopyAssign, ConstCopyAssign> t1{1, 2};
+    const std::tuple<AssignableFrom<ConstCopyAssign>, ConstCopyAssign> t2{3, 4};
+    t2 = t1;
+    assert(std::get<0>(t2).v.val == 1);
+    assert(std::get<1>(t2).val == 2);
+  }
+
+  // make sure the right assignment operator of the type in the tuple is used
+  {
+    std::pair<TracedAssignment, TracedAssignment> t1{};
+    const std::tuple<AssignableFrom<TracedAssignment>, AssignableFrom<TracedAssignment>> t2{};
+    t2 = t1;
+    assert(std::get<0>(t2).v.constCopyAssign == 1);
+    assert(std::get<1>(t2).v.constCopyAssign == 1);
+  }
+
+  return true;
+}
+
+int main() {
+  test();
+
+// gcc cannot have mutable member in constant expression
+#if !defined(TEST_COMPILER_GCC)
+  static_assert(test());
+#endif
+  return 0;
+}

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.assign/const_pair_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
+//
+//===----------------------------------------------------------------------===//
+
+// <tuple>
+
+// template<class U1, class U2>
+// constexpr const tuple& operator=(pair<U1, U2>&& u) const;
+//
+// - sizeof...(Types) is 2,
+// - is_assignable_v<const T1&, U1> is true, and
+// - is_assignable_v<const T2&, U2> is true
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <cassert>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+#include "test_macros.h"
+#include "types.h"
+
+// test constraints
+
+// sizeof...(Types) != 2,
+static_assert(std::is_assignable_v<const std::tuple<int&, int&>&, std::pair<int&, int&>&&>);
+static_assert(!std::is_assignable_v<const std::tuple<int&>&, std::pair<int&, int&>&&>);
+static_assert(!std::is_assignable_v<const std::tuple<int&, int&, int&>&, std::pair<int&, int&>&&>);
+
+static_assert(std::is_assignable_v<const std::tuple<AssignableFrom<ConstMoveAssign>, ConstMoveAssign>&,
+                                   std::pair<ConstMoveAssign, ConstMoveAssign>&&>);
+
+// is_assignable_v<const T1&, U1> is false
+static_assert(!std::is_assignable_v<const std::tuple<AssignableFrom<MoveAssign>, ConstMoveAssign>&,
+                                    std::pair<MoveAssign, ConstMoveAssign>&&>);
+
+// is_assignable_v<const T2&, U2> is false
+static_assert(!std::is_assignable_v<const std::tuple<AssignableFrom<ConstMoveAssign>, AssignableFrom<MoveAssign>>&,
+                                    std::tuple<ConstMoveAssign, MoveAssign>&&>);
+
+constexpr bool test() {
+  // reference types
+  {
+    int i1 = 1;
+    int i2 = 2;
+    long j1 = 3;
+    long j2 = 4;
+    std::pair<int&, int&> t1{i1, i2};
+    const std::tuple<long&, long&> t2{j1, j2};
+    t2 = std::move(t1);
+    assert(std::get<0>(t2) == 1);
+    assert(std::get<1>(t2) == 2);
+  }
+
+  // user defined const copy assignment
+  {
+    std::pair<ConstMoveAssign, ConstMoveAssign> t1{1, 2};
+    const std::tuple<AssignableFrom<ConstMoveAssign>, ConstMoveAssign> t2{3, 4};
+    t2 = std::move(t1);
+    assert(std::get<0>(t2).v.val == 1);
+    assert(std::get<1>(t2).val == 2);
+  }
+
+  // make sure the right assignment operator of the type in the tuple is used
+  {
+    std::pair<TracedAssignment, TracedAssignment> t1{};
+    const std::tuple<AssignableFrom<TracedAssignment>, AssignableFrom<TracedAssignment>> t2{};
+    t2 = std::move(t1);
+    assert(std::get<0>(t2).v.constMoveAssign == 1);
+    assert(std::get<1>(t2).v.constMoveAssign == 1);
+  }
+
+  return true;
+}
+
+int main() {
+  test();
+
+// gcc cannot have mutable member in constant expression
+#if !defined(TEST_COMPILER_GCC)
+  static_assert(test());
+#endif
+  return 0;
+}

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

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+#ifndef LIBCXX_TEST_STD_UTILITIES_TUPLE_ASSIGN_TYPES_H
+#define LIBCXX_TEST_STD_UTILITIES_TUPLE_ASSIGN_TYPES_H
+
+#include "test_allocator.h"
+#include <type_traits>
+
+struct CopyAssign {
+  int val;
+
+  constexpr CopyAssign() = default;
+  constexpr CopyAssign(int v) : val(v) {}
+
+  constexpr CopyAssign& operator=(const CopyAssign&) = default;
+
+  constexpr const CopyAssign& operator=(const CopyAssign&) const = delete;
+  constexpr CopyAssign& operator=(CopyAssign&&) = delete;
+  constexpr const CopyAssign& operator=(CopyAssign&&) const = delete;
+};
+
+struct ConstCopyAssign {
+  mutable int val;
+
+  constexpr ConstCopyAssign() = default;
+  constexpr ConstCopyAssign(int v) : val(v) {}
+
+  constexpr const ConstCopyAssign& operator=(const ConstCopyAssign& other) const {
+    val = other.val;
+    return *this;
+  }
+
+  constexpr ConstCopyAssign& operator=(const ConstCopyAssign&) = delete;
+  constexpr ConstCopyAssign& operator=(ConstCopyAssign&&) = delete;
+  constexpr const ConstCopyAssign& operator=(ConstCopyAssign&&) const = delete;
+};
+
+struct MoveAssign {
+  int val;
+
+  constexpr MoveAssign() = default;
+  constexpr MoveAssign(int v) : val(v) {}
+
+  constexpr MoveAssign& operator=(MoveAssign&&) = default;
+
+  constexpr MoveAssign& operator=(const MoveAssign&) = delete;
+  constexpr const MoveAssign& operator=(const MoveAssign&) const = delete;
+  constexpr const MoveAssign& operator=(MoveAssign&&) const = delete;
+};
+
+struct ConstMoveAssign {
+  mutable int val;
+
+  constexpr ConstMoveAssign() = default;
+  constexpr ConstMoveAssign(int v) : val(v) {}
+
+  constexpr const ConstMoveAssign& operator=(ConstMoveAssign&& other) const {
+    val = other.val;
+    return *this;
+  }
+
+  constexpr ConstMoveAssign& operator=(const ConstMoveAssign&) = delete;
+  constexpr const ConstMoveAssign& operator=(const ConstMoveAssign&) const = delete;
+  constexpr ConstMoveAssign& operator=(ConstMoveAssign&&) = delete;
+};
+
+template <class T>
+struct AssignableFrom {
+  T v;
+
+  constexpr AssignableFrom() = default;
+
+  template <class U>
+  constexpr AssignableFrom(U&& u)
+    requires std::is_constructible_v<T, U&&>
+  : v(std::forward<U>(u)) {}
+
+  constexpr AssignableFrom& operator=(const T& t)
+    requires std::is_copy_assignable_v<T>
+  {
+    v = t;
+    return *this;
+  }
+
+  constexpr AssignableFrom& operator=(T&& t)
+    requires std::is_move_assignable_v<T>
+  {
+    v = std::move(t);
+    return *this;
+  }
+
+  constexpr const AssignableFrom& operator=(const T& t) const
+    requires std::is_assignable_v<const T&, const T&>
+  {
+    v = t;
+    return *this;
+  }
+
+  constexpr const AssignableFrom& operator=(T&& t) const
+    requires std::is_assignable_v<const T&, T&&>
+  {
+    v = std::move(t);
+    return *this;
+  }
+};
+
+struct TracedAssignment {
+  int copyAssign = 0;
+  mutable int constCopyAssign = 0;
+  int moveAssign = 0;
+  mutable int constMoveAssign = 0;
+
+  constexpr TracedAssignment() = default;
+
+  constexpr TracedAssignment& operator=(const TracedAssignment&) {
+    copyAssign++;
+    return *this;
+  }
+  constexpr const TracedAssignment& operator=(const TracedAssignment&) const {
+    constCopyAssign++;
+    return *this;
+  }
+  constexpr TracedAssignment& operator=(TracedAssignment&&) {
+    moveAssign++;
+    return *this;
+  }
+  constexpr const TracedAssignment& operator=(TracedAssignment&&) const {
+    constMoveAssign++;
+    return *this;
+  }
+};
+
+#endif

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_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
+//
+//===----------------------------------------------------------------------===//
+
+// <tuple>
+
+// template <class... Types>
+// template <class Alloc, class U1, class U2>
+// constexpr explicit(see below)
+//   tuple<Types...>::tuple(allocator_arg_t, const Alloc& a, const pair<U1,
+//   U2>&& u);
+
+// Constraints:
+// - sizeof...(Types) is 2 and
+// - is_constructible_v<T0, decltype(get<0>(FWD(u)))> is true and
+// - is_constructible_v<T1, decltype(get<1>(FWD(u)))> is true.
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <cassert>
+#include <tuple>
+#include <utility>
+
+#include "convert_types.h"
+#include "test_allocator.h"
+
+// test constraints
+// sizeof...(Types) == 2
+static_assert(std::is_constructible_v<std::tuple<ConstMove, int>, std::allocator_arg_t, test_allocator<int>,
+                                      const std::pair<ConstMove, int>&&>);
+
+static_assert(!std::is_constructible_v< std::tuple<ConstMove>, std::allocator_arg_t, test_allocator<int>,
+                                        const std::pair<ConstMove, int>&&>);
+
+static_assert(!std::is_constructible_v< std::tuple<ConstMove, int, int>, std::allocator_arg_t, test_allocator<int>,
+                                        const std::pair<ConstMove, int>&&>);
+
+// test constraints
+// is_constructible_v<T0, decltype(get<0>(FWD(u)))> is true and
+// is_constructible_v<T1, decltype(get<1>(FWD(u)))> is true.
+static_assert(std::is_constructible_v<std::tuple<int, int>, std::allocator_arg_t, test_allocator<int>,
+                                      const std::pair<int, int>&&>);
+
+static_assert(!std::is_constructible_v< std::tuple<NoConstructorFromInt, int>, std::allocator_arg_t,
+                                        test_allocator<int>, const std::pair<int, int>&&>);
+
+static_assert(!std::is_constructible_v< std::tuple<int, NoConstructorFromInt>, std::allocator_arg_t,
+                                        test_allocator<int>, const std::pair<int, int>&&>);
+
+static_assert(!std::is_constructible_v< std::tuple<NoConstructorFromInt, NoConstructorFromInt>, std::allocator_arg_t,
+                                        test_allocator<int>, const std::pair<int, int>&&>);
+
+// test: The expression inside explicit is equivalent to:
+// !is_convertible_v<decltype(get<0>(FWD(u))), T0> ||
+// !is_convertible_v<decltype(get<1>(FWD(u))), T1>
+static_assert(
+    ImplicitlyConstructible< std::tuple<ConvertibleFrom<ConstMove>, ConvertibleFrom<ConstMove>>, std::allocator_arg_t,
+                             test_allocator<int>, const std::pair<ConstMove, ConstMove>&&>);
+
+static_assert(
+    !ImplicitlyConstructible<std::tuple<ConvertibleFrom<ConstMove>, ExplicitConstructibleFrom<ConstMove>>,
+                             std::allocator_arg_t, test_allocator<int>, const std::pair<ConstMove, ConstMove>&&>);
+
+static_assert(
+    !ImplicitlyConstructible<std::tuple<ExplicitConstructibleFrom<ConstMove>, ConvertibleFrom<ConstMove>>,
+                             std::allocator_arg_t, test_allocator<int>, const std::pair<ConstMove, ConstMove>&&>);
+
+constexpr bool test() {
+  // test implicit conversions.
+  {
+    const std::pair<ConstMove, int> p{1, 2};
+    std::tuple<ConvertibleFrom<ConstMove>, ConvertibleFrom<int>> t = {std::allocator_arg, test_allocator<int>{},
+                                                                      std::move(p)};
+    assert(std::get<0>(t).v.val == 1);
+    assert(std::get<1>(t).v == 2);
+    assert(std::get<0>(t).alloc_constructed);
+    assert(std::get<1>(t).alloc_constructed);
+  }
+
+  // test explicit conversions.
+  {
+    const std::pair<ConstMove, int> p{1, 2};
+    std::tuple<ExplicitConstructibleFrom<ConstMove>, ExplicitConstructibleFrom<int>> t{
+        std::allocator_arg, test_allocator<int>{}, std::move(p)};
+    assert(std::get<0>(t).v.val == 1);
+    assert(std::get<1>(t).v == 2);
+    assert(std::get<0>(t).alloc_constructed);
+    assert(std::get<1>(t).alloc_constructed);
+  }
+
+  // non const overload should be called
+  {
+    const std::pair<TracedCopyMove, TracedCopyMove> p;
+    std::tuple<ConvertibleFrom<TracedCopyMove>, TracedCopyMove> t = {std::allocator_arg, test_allocator<int>{},
+                                                                     std::move(p)};
+    assert(constMoveCtrCalled(std::get<0>(t).v));
+    assert(constMoveCtrCalled(std::get<1>(t)));
+    assert(std::get<0>(t).alloc_constructed);
+    assert(std::get<1>(t).alloc_constructed);
+  }
+
+  return true;
+}
+
+int main() {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_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
+//
+//===----------------------------------------------------------------------===//
+
+// <tuple>
+
+// template <class... Types>
+// template<class Alloc, class... UTypes>
+//   constexpr explicit(see below)
+//     tuple<Types...>::tuple(allocator_arg_t, const Alloc& a,
+//     const tuple<UTypes...>&&);
+//
+// Constraints:
+//  sizeof...(Types) equals sizeof...(UTypes) &&
+//  (is_constructible_v<Types, decltype(get<I>(FWD(u)))> && ...) is true &&
+//  (
+//  sizeof...(Types) is not 1 ||
+//  (
+//    !is_convertible_v<decltype(u), T> &&
+//    !is_constructible_v<T, decltype(u)> &&
+//    !is_same_v<T, U>
+//  )
+//  )
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <cassert>
+#include <tuple>
+
+#include "convert_types.h"
+#include "test_allocator.h"
+#include "test_macros.h"
+
+// test: The expression inside explicit is equivalent to:
+// !(is_convertible_v<decltype(get<I>(FWD(u))), Types> && ...)
+static_assert(ImplicitlyConstructible< std::tuple<ConvertibleFrom<ConstMove>>, std::allocator_arg_t,
+                                       const test_allocator<int>&, const std::tuple<ConstMove>&&>);
+
+static_assert(
+    ImplicitlyConstructible< std::tuple<ConvertibleFrom<ConstMove>, ConvertibleFrom<ConstMove>>, std::allocator_arg_t,
+                             const test_allocator<int>&, const std::tuple<ConstMove, ConstMove>&&>);
+
+static_assert(!ImplicitlyConstructible<std::tuple<ExplicitConstructibleFrom<ConstMove>>, std::allocator_arg_t,
+                                       const test_allocator<int>&, const std::tuple<ConstMove>&&>);
+
+static_assert(!ImplicitlyConstructible<std::tuple<ExplicitConstructibleFrom<ConstMove>, ConvertibleFrom<ConstMove>>,
+                                       std::allocator_arg_t, const test_allocator<int>&,
+                                       const std::tuple<ConstMove, ConstMove>&&>);
+
+constexpr bool test() {
+  // test implicit conversions.
+  // sizeof...(Types) == 1
+  {
+    const std::tuple<ConstMove> t1{1};
+    std::tuple<ConvertibleFrom<ConstMove>> t2 = {std::allocator_arg, test_allocator<int>{}, std::move(t1)};
+    assert(std::get<0>(t2).v.val == 1);
+    assert(std::get<0>(t2).alloc_constructed);
+  }
+
+  // test implicit conversions.
+  // sizeof...(Types) > 1
+  {
+    const std::tuple<ConstMove, int> t1{1, 2};
+    std::tuple<ConvertibleFrom<ConstMove>, int> t2 = {std::allocator_arg_t{}, test_allocator<int>{}, std::move(t1)};
+    assert(std::get<0>(t2).v.val == 1);
+    assert(std::get<1>(t2) == 2);
+    assert(std::get<0>(t2).alloc_constructed);
+  }
+
+  // test explicit conversions.
+  // sizeof...(Types) == 1
+  {
+    const std::tuple<ConstMove> t1{1};
+    std::tuple<ExplicitConstructibleFrom<ConstMove>> t2{std::allocator_arg_t{}, test_allocator<int>{}, std::move(t1)};
+    assert(std::get<0>(t2).v.val == 1);
+    assert(std::get<0>(t2).alloc_constructed);
+  }
+
+  // test explicit conversions.
+  // sizeof...(Types) > 1
+  {
+    const std::tuple<ConstMove, int> t1{1, 2};
+    std::tuple<ExplicitConstructibleFrom<ConstMove>, int> t2{std::allocator_arg_t{}, test_allocator<int>{},
+                                                             std::move(t1)};
+    assert(std::get<0>(t2).v.val == 1);
+    assert(std::get<1>(t2) == 2);
+    assert(std::get<0>(t2).alloc_constructed);
+  }
+
+  // test constraints
+
+  // sizeof...(Types) != sizeof...(UTypes)
+  static_assert(!std::is_constructible_v<std::tuple<int, int>, std::allocator_arg_t, const test_allocator<int>&,
+                                         const std::tuple<int>&&>);
+  static_assert(!std::is_constructible_v<std::tuple<int, int, int>, std::allocator_arg_t, const test_allocator<int>&,
+                                         const std::tuple<int, int>&&>);
+
+  // !(is_constructible_v<Types, decltype(get<I>(FWD(u)))> && ...)
+  static_assert(!std::is_constructible_v< std::tuple<int, NoConstructorFromInt>, std::allocator_arg_t,
+                                          const test_allocator<int>&, const std::tuple<int, int>&&>);
+
+  // sizeof...(Types) == 1 && other branch of "||" satisfied
+  {
+    const std::tuple<TracedCopyMove> t1{};
+    std::tuple<ConvertibleFrom<TracedCopyMove>> t2{std::allocator_arg_t{}, test_allocator<int>{}, std::move(t1)};
+    assert(constMoveCtrCalled(std::get<0>(t2).v));
+    assert(std::get<0>(t2).alloc_constructed);
+  }
+
+  // sizeof...(Types) == 1 && is_same_v<T, U>
+  {
+    const std::tuple<TracedCopyMove> t1{};
+    std::tuple<TracedCopyMove> t2{std::allocator_arg_t{}, test_allocator<int>{}, std::move(t1)};
+    assert(!constMoveCtrCalled(std::get<0>(t2)));
+    assert(std::get<0>(t2).alloc_constructed);
+  }
+
+  // sizeof...(Types) != 1
+  {
+    const std::tuple<TracedCopyMove, TracedCopyMove> t1{};
+    std::tuple<TracedCopyMove, TracedCopyMove> t2{std::allocator_arg_t{}, test_allocator<int>{}, std::move(t1)};
+    assert(constMoveCtrCalled(std::get<0>(std::move(t2))));
+    assert(std::get<0>(t2).alloc_constructed);
+  }
+
+  // These two test points cause gcc to ICE
+#if !defined(TEST_COMPILER_GCC)
+  // sizeof...(Types) == 1 && is_convertible_v<decltype(u), T>
+  {
+    const std::tuple<CvtFromTupleRef> t1{};
+    std::tuple<ConvertibleFrom<CvtFromTupleRef>> t2{std::allocator_arg_t{}, test_allocator<int>{}, std::move(t1)};
+    assert(!constMoveCtrCalled(std::get<0>(t2).v));
+    assert(std::get<0>(t2).alloc_constructed);
+  }
+
+  // sizeof...(Types) == 1 && is_constructible_v<decltype(u), T>
+  {
+    const std::tuple<ExplicitCtrFromTupleRef> t1{};
+    std::tuple<ConvertibleFrom<ExplicitCtrFromTupleRef>> t2{std::allocator_arg_t{}, test_allocator<int>{},
+                                                            std::move(t1)};
+    assert(!constMoveCtrCalled(std::get<0>(t2).v));
+    assert(std::get<0>(t2).alloc_constructed);
+  }
+#endif
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+  return 0;
+}

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_copy.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 Alloc, class... UTypes>
+// constexpr                                        // since c++20
 //   tuple(allocator_arg_t, const Alloc& a, const tuple<UTypes...>&);
 
 // UNSUPPORTED: c++03
 
 #include <tuple>
 #include <memory>
 #include <cassert>
 
 #include "test_macros.h"
 #include "allocators.h"
+#include "test_allocator.h"
 #include "../alloc_first.h"
 #include "../alloc_last.h"
 
 struct Explicit {
   int value;
   explicit Explicit(int x) : value(x) {}
 };
 
 struct Implicit {
   int value;
   Implicit(int x) : value(x) {}
 };
 
+#if _LIBCPP_STD_VER > 17
+constexpr bool alloc_copy_constructor_is_constexpr() {
+  const std::tuple<int> t1 = 1;
+  std::tuple<int> t2 = {std::allocator_arg, test_allocator<int>{}, t1};
+  assert(std::get<0>(t2) == 1);
+  return true;
+}
+#endif
+
 int main(int, char**)
 {
     {
         typedef std::tuple<long> T0;
         typedef std::tuple<long long> T1;
         T0 t0(2);
         T1 t1(std::allocator_arg, A1<int>(), t0);
         assert(std::get<0>(t1) == 2);
int main(int, char**)
     {
         // Test that we can use a tag derived from allocator_arg_t
         struct DerivedFromAllocatorArgT : std::allocator_arg_t { };
         DerivedFromAllocatorArgT derived;
         std::tuple<long> from(3l);
         std::tuple<long long> t0(derived, A1<int>(), from);
     }
 
+#if _LIBCPP_STD_VER > 17
+    static_assert(alloc_copy_constructor_is_constexpr());
+#endif
     return 0;
 }

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

 
 #include <tuple>
 #include <string>
 #include <memory>
 #include <cassert>
 
 #include "test_macros.h"
 #include "allocators.h"
+#include "test_allocator.h"
 #include "../alloc_first.h"
 #include "../alloc_last.h"
 
 struct B
 {
     int id_;
 
     explicit B(int i) : id_(i) {}
struct Explicit {
   explicit Explicit(int x) : value(x) {}
 };
 
 struct Implicit {
   int value;
   Implicit(int x) : value(x) {}
 };
 
+#if _LIBCPP_STD_VER > 17
+constexpr bool alloc_move_constructor_is_constexpr() {
+  std::tuple<int> t1 = 1;
+  std::tuple<int> t2 = {std::allocator_arg, test_allocator<int>{}, std::move(t1)};
+  assert(std::get<0>(t2) == 1);
+  return true;
+}
+#endif
+
 int main(int, char**)
 {
     {
         typedef std::tuple<int> T0;
         typedef std::tuple<alloc_first> T1;
         T0 t0(2);
         alloc_first::allocator_constructed = false;
         T1 t1(std::allocator_arg, A1<int>(5), std::move(t0));
int main(int, char**)
     {
         // Test that we can use a tag derived from allocator_arg_t
         struct DerivedFromAllocatorArgT : std::allocator_arg_t { };
         DerivedFromAllocatorArgT derived;
         std::tuple<long> from(3l);
         std::tuple<long long> t0(derived, A1<int>(), std::move(from));
     }
 
+#if _LIBCPP_STD_VER > 17
+    static_assert(alloc_move_constructor_is_constexpr());
+#endif
+
     return 0;
 }

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_non_const_copy.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>
+// template<class Alloc, class... UTypes>
+//   constexpr explicit(see below)
+//     tuple<Types...>::tuple(allocator_arg_t, const Alloc& a,
+//     tuple<UTypes...>&);
+//
+// Constraints:
+//  sizeof...(Types) equals sizeof...(UTypes) &&
+//  (is_constructible_v<Types, decltype(get<I>(FWD(u)))> && ...) is true &&
+//  (
+//  sizeof...(Types) is not 1 ||
+//  (
+//    !is_convertible_v<decltype(u), T> &&
+//    !is_constructible_v<T, decltype(u)> &&
+//    !is_same_v<T, U>
+//  )
+//  )
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <cassert>
+#include <tuple>
+
+#include "convert_types.h"
+#include "test_allocator.h"
+#include "test_macros.h"
+
+// test: The expression inside explicit is equivalent to:
+// !(is_convertible_v<decltype(get<I>(FWD(u))), Types> && ...)
+static_assert(ImplicitlyConstructible< std::tuple<ConvertibleFrom<MutableCopy>>, std::allocator_arg_t,
+                                       const test_allocator<int>&, std::tuple<MutableCopy>&>);
+
+static_assert(
+    ImplicitlyConstructible< std::tuple<ConvertibleFrom<MutableCopy>, ConvertibleFrom<MutableCopy>>,
+                             std::allocator_arg_t, const test_allocator<int>&, std::tuple<MutableCopy, MutableCopy>&>);
+
+static_assert(!ImplicitlyConstructible<std::tuple<ExplicitConstructibleFrom<MutableCopy>>, std::allocator_arg_t,
+                                       const test_allocator<int>&, std::tuple<MutableCopy>&>);
+
+static_assert(
+    !ImplicitlyConstructible<std::tuple<ExplicitConstructibleFrom<MutableCopy>, ConvertibleFrom<MutableCopy>>,
+                             std::allocator_arg_t, const test_allocator<int>&, std::tuple<MutableCopy, MutableCopy>&>);
+
+constexpr bool test() {
+  // test implicit conversions.
+  // sizeof...(Types) == 1
+  {
+    std::tuple<MutableCopy> t1{1};
+    std::tuple<ConvertibleFrom<MutableCopy>> t2 = {std::allocator_arg, test_allocator<int>{}, t1};
+    assert(std::get<0>(t2).v.val == 1);
+    assert(std::get<0>(t2).alloc_constructed);
+  }
+
+  // test implicit conversions.
+  // sizeof...(Types) > 1
+  {
+    std::tuple<MutableCopy, int> t1{1, 2};
+    std::tuple<ConvertibleFrom<MutableCopy>, int> t2 = {std::allocator_arg_t{}, test_allocator<int>{}, t1};
+    assert(std::get<0>(t2).v.val == 1);
+    assert(std::get<1>(t2) == 2);
+    assert(std::get<0>(t2).alloc_constructed);
+  }
+
+  // test explicit conversions.
+  // sizeof...(Types) == 1
+  {
+    std::tuple<MutableCopy> t1{1};
+    std::tuple<ExplicitConstructibleFrom<MutableCopy>> t2{std::allocator_arg_t{}, test_allocator<int>{}, t1};
+    assert(std::get<0>(t2).v.val == 1);
+    assert(std::get<0>(t2).alloc_constructed);
+  }
+
+  // test explicit conversions.
+  // sizeof...(Types) > 1
+  {
+    std::tuple<MutableCopy, int> t1{1, 2};
+    std::tuple<ExplicitConstructibleFrom<MutableCopy>, int> t2{std::allocator_arg_t{}, test_allocator<int>{}, t1};
+    assert(std::get<0>(t2).v.val == 1);
+    assert(std::get<1>(t2) == 2);
+    assert(std::get<0>(t2).alloc_constructed);
+  }
+
+  // test constraints
+
+  // sizeof...(Types) != sizeof...(UTypes)
+  static_assert(!std::is_constructible_v<std::tuple<int, int>, std::allocator_arg_t, const test_allocator<int>&,
+                                         std::tuple<int>&>);
+  static_assert(!std::is_constructible_v<std::tuple<int, int, int>, std::allocator_arg_t, const test_allocator<int>&,
+                                         std::tuple<int, int>&>);
+
+  // !(is_constructible_v<Types, decltype(get<I>(FWD(u)))> && ...)
+  static_assert(!std::is_constructible_v< std::tuple<int, NoConstructorFromInt>, std::allocator_arg_t,
+                                          const test_allocator<int>&, std::tuple<int, int>&>);
+
+  // sizeof...(Types) == 1 && other branch of "||" satisfied
+  {
+    std::tuple<TracedCopyMove> t1{};
+    std::tuple<ConvertibleFrom<TracedCopyMove>> t2{std::allocator_arg_t{}, test_allocator<int>{}, t1};
+    assert(nonConstCopyCtrCalled(std::get<0>(t2).v));
+    assert(std::get<0>(t2).alloc_constructed);
+  }
+
+  // sizeof...(Types) == 1 && is_same_v<T, U>
+  {
+    std::tuple<TracedCopyMove> t1{};
+    std::tuple<TracedCopyMove> t2{std::allocator_arg_t{}, test_allocator<int>{}, t1};
+    assert(!nonConstCopyCtrCalled(std::get<0>(t2)));
+    assert(std::get<0>(t2).alloc_constructed);
+  }
+
+  // sizeof...(Types) != 1
+  {
+    std::tuple<TracedCopyMove, TracedCopyMove> t1{};
+    std::tuple<TracedCopyMove, TracedCopyMove> t2{std::allocator_arg_t{}, test_allocator<int>{}, t1};
+    assert(nonConstCopyCtrCalled(std::get<0>(t2)));
+    assert(std::get<0>(t2).alloc_constructed);
+  }
+
+  // These two test points cause gcc to ICE
+#if !defined(TEST_COMPILER_GCC)
+  // sizeof...(Types) == 1 && is_convertible_v<decltype(u), T>
+  {
+    std::tuple<CvtFromTupleRef> t1{};
+    std::tuple<ConvertibleFrom<CvtFromTupleRef>> t2{std::allocator_arg_t{}, test_allocator<int>{}, t1};
+    assert(!nonConstCopyCtrCalled(std::get<0>(t2).v));
+    assert(std::get<0>(t2).alloc_constructed);
+  }
+
+  // sizeof...(Types) == 1 && is_constructible_v<decltype(u), T>
+  {
+    std::tuple<ExplicitCtrFromTupleRef> t1{};
+    std::tuple<ConvertibleFrom<ExplicitCtrFromTupleRef>> t2{std::allocator_arg_t{}, test_allocator<int>{}, t1};
+    assert(!nonConstCopyCtrCalled(std::get<0>(t2).v));
+    assert(std::get<0>(t2).alloc_constructed);
+  }
+#endif
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+  return 0;
+}

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_non_const_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
+//
+//===----------------------------------------------------------------------===//
+
+// <tuple>
+
+// template <class... Types>
+// template <class Alloc, class U1, class U2>
+// constexpr explicit(see below)
+//   tuple<Types...>::tuple(allocator_arg_t, const Alloc& a, pair<U1, U2>&
+// u);
+
+// Constraints:
+// - sizeof...(Types) is 2 and
+// - is_constructible_v<T0, decltype(get<0>(FWD(u)))> is true and
+// - is_constructible_v<T1, decltype(get<1>(FWD(u)))> is true.
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <cassert>
+#include <tuple>
+#include <utility>
+
+#include "convert_types.h"
+#include "test_allocator.h"
+
+// test constraints
+// sizeof...(Types) == 2
+static_assert(std::is_constructible_v<std::tuple<MutableCopy, int>, std::allocator_arg_t, test_allocator<int>,
+                                      std::pair<MutableCopy, int>&>);
+
+static_assert(!std::is_constructible_v< std::tuple<MutableCopy>, std::allocator_arg_t, test_allocator<int>,
+                                        std::pair<MutableCopy, int>&>);
+
+static_assert(!std::is_constructible_v< std::tuple<MutableCopy, int, int>, std::allocator_arg_t, test_allocator<int>,
+                                        std::pair<MutableCopy, int>&>);
+
+// test constraints
+// is_constructible_v<T0, decltype(get<0>(FWD(u)))> is true and
+// is_constructible_v<T1, decltype(get<1>(FWD(u)))> is true.
+static_assert(
+    std::is_constructible_v<std::tuple<int, int>, std::allocator_arg_t, test_allocator<int>, std::pair<int, int>&>);
+
+static_assert(!std::is_constructible_v< std::tuple<NoConstructorFromInt, int>, std::allocator_arg_t,
+                                        test_allocator<int>, std::pair<int, int>&>);
+
+static_assert(!std::is_constructible_v< std::tuple<int, NoConstructorFromInt>, std::allocator_arg_t,
+                                        test_allocator<int>, std::pair<int, int>&>);
+
+static_assert(!std::is_constructible_v< std::tuple<NoConstructorFromInt, NoConstructorFromInt>, std::allocator_arg_t,
+                                        test_allocator<int>, std::pair<int, int>&>);
+
+// test: The expression inside explicit is equivalent to:
+// !is_convertible_v<decltype(get<0>(FWD(u))), T0> ||
+// !is_convertible_v<decltype(get<1>(FWD(u))), T1>
+static_assert(ImplicitlyConstructible<std::tuple<ConvertibleFrom<MutableCopy>, ConvertibleFrom<MutableCopy>>,
+                                      std::allocator_arg_t, test_allocator<int>, std::pair<MutableCopy, MutableCopy>&>);
+
+static_assert(
+    !ImplicitlyConstructible<std::tuple<ConvertibleFrom<MutableCopy>, ExplicitConstructibleFrom<MutableCopy>>,
+                             std::allocator_arg_t, test_allocator<int>, std::pair<MutableCopy, MutableCopy>&>);
+
+static_assert(
+    !ImplicitlyConstructible<std::tuple<ExplicitConstructibleFrom<MutableCopy>, ConvertibleFrom<MutableCopy>>,
+                             std::allocator_arg_t, test_allocator<int>, std::pair<MutableCopy, MutableCopy>&>);
+
+constexpr bool test() {
+  // test implicit conversions.
+  {
+    std::pair<MutableCopy, int> p{1, 2};
+    std::tuple<ConvertibleFrom<MutableCopy>, ConvertibleFrom<int>> t = {std::allocator_arg, test_allocator<int>{}, p};
+    assert(std::get<0>(t).v.val == 1);
+    assert(std::get<1>(t).v == 2);
+    assert(std::get<0>(t).alloc_constructed);
+    assert(std::get<1>(t).alloc_constructed);
+  }
+
+  // test explicit conversions.
+  {
+    std::pair<MutableCopy, int> p{1, 2};
+    std::tuple<ExplicitConstructibleFrom<MutableCopy>, ExplicitConstructibleFrom<int>> t{std::allocator_arg,
+                                                                                         test_allocator<int>{}, p};
+    assert(std::get<0>(t).v.val == 1);
+    assert(std::get<1>(t).v == 2);
+    assert(std::get<0>(t).alloc_constructed);
+    assert(std::get<1>(t).alloc_constructed);
+  }
+
+  // non const overload should be called
+  {
+    std::pair<TracedCopyMove, TracedCopyMove> p;
+    std::tuple<ConvertibleFrom<TracedCopyMove>, TracedCopyMove> t = {std::allocator_arg, test_allocator<int>{}, p};
+    assert(nonConstCopyCtrCalled(std::get<0>(t).v));
+    assert(nonConstCopyCtrCalled(std::get<1>(t)));
+    assert(std::get<0>(t).alloc_constructed);
+    assert(std::get<1>(t).alloc_constructed);
+  }
+
+  return true;
+}
+
+int main() {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/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
+//
+//===----------------------------------------------------------------------===//
+
+// <tuple>
+
+// template <class... Types>
+// template <class U1, class U2>
+// constexpr explicit(see below) tuple<Types...>::tuple(const pair<U1, U2>&& u);
+
+// Constraints:
+// - sizeof...(Types) is 2 and
+// - is_constructible_v<T0, decltype(get<0>(FWD(u)))> is true and
+// - is_constructible_v<T1, decltype(get<1>(FWD(u)))> is true.
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <cassert>
+#include <tuple>
+#include <utility>
+
+#include "convert_types.h"
+
+// test constraints
+// sizeof...(Types) == 2
+static_assert(std::is_constructible_v<std::tuple<ConstMove, int>, const std::pair<ConstMove, int>&&>);
+
+static_assert(!std::is_constructible_v<std::tuple<ConstMove>, const std::pair<ConstMove, int>&&>);
+
+static_assert(!std::is_constructible_v<std::tuple<ConstMove, int, int>, const std::pair<ConstMove, int>&&>);
+
+// test constraints
+// is_constructible_v<T0, decltype(get<0>(FWD(u)))> is true and
+// is_constructible_v<T1, decltype(get<1>(FWD(u)))> is true.
+static_assert(std::is_constructible_v<std::tuple<int, int>, const std::pair<int, int>&&>);
+
+static_assert(!std::is_constructible_v<std::tuple<NoConstructorFromInt, int>, const std::pair<int, int>&&>);
+
+static_assert(!std::is_constructible_v<std::tuple<int, NoConstructorFromInt>, const std::pair<int, int>&&>);
+
+static_assert(
+    !std::is_constructible_v< std::tuple<NoConstructorFromInt, NoConstructorFromInt>, const std::pair<int, int>&&>);
+
+// test: The expression inside explicit is equivalent to:
+// !is_convertible_v<decltype(get<0>(FWD(u))), T0> ||
+// !is_convertible_v<decltype(get<1>(FWD(u))), T1>
+static_assert(std::is_convertible_v<const std::pair<ConstMove, ConstMove>&&,
+                                    std::tuple<ConvertibleFrom<ConstMove>, ConvertibleFrom<ConstMove>>>);
+
+static_assert(!std::is_convertible_v<const std::pair<ConstMove, ConstMove>&&,
+                                     std::tuple<ExplicitConstructibleFrom<ConstMove>, ConvertibleFrom<ConstMove>>>);
+
+static_assert(!std::is_convertible_v<const std::pair<ConstMove, ConstMove>&&,
+                                     std::tuple<ConvertibleFrom<ConstMove>, ExplicitConstructibleFrom<ConstMove>>>);
+
+constexpr bool test() {
+  // test implicit conversions.
+  {
+    const std::pair<ConstMove, int> p{1, 2};
+    std::tuple<ConvertibleFrom<ConstMove>, ConvertibleFrom<int>> t = std::move(p);
+    assert(std::get<0>(t).v.val == 1);
+    assert(std::get<1>(t).v == 2);
+  }
+
+  // test explicit conversions.
+  {
+    const std::pair<ConstMove, int> p{1, 2};
+    std::tuple<ExplicitConstructibleFrom<ConstMove>, ExplicitConstructibleFrom<int>> t{std::move(p)};
+    assert(std::get<0>(t).v.val == 1);
+    assert(std::get<1>(t).v == 2);
+  }
+
+  // non const overload should be called
+  {
+    const std::pair<TracedCopyMove, TracedCopyMove> p;
+    std::tuple<ConvertibleFrom<TracedCopyMove>, TracedCopyMove> t = std::move(p);
+    assert(constMoveCtrCalled(std::get<0>(t).v));
+    assert(constMoveCtrCalled(std::get<1>(t)));
+  }
+
+  return true;
+}
+
+int main() {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/convert_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
+//
+//===----------------------------------------------------------------------===//
+
+// <tuple>
+
+// template <class... Types>
+// template <class... UTypes>
+//   constexpr explicit(see below) tuple<Types>::tuple(const
+//   tuple<UTypes...>&&);
+//
+// Constraints:
+//  sizeof...(Types) equals sizeof...(UTypes) &&
+//  (is_constructible_v<Types, decltype(get<I>(FWD(u)))> && ...) is true &&
+//  (
+//  sizeof...(Types) is not 1 ||
+//  (
+//    !is_convertible_v<decltype(u), T> &&
+//    !is_constructible_v<T, decltype(u)> &&
+//    !is_same_v<T, U>
+//  )
+//  )
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <cassert>
+#include <tuple>
+
+#include "convert_types.h"
+#include "test_macros.h"
+
+// test: The expression inside explicit is equivalent to:
+// !(is_convertible_v<decltype(get<I>(FWD(u))), Types> && ...)
+static_assert(std::is_convertible_v<const std::tuple<ConstMove>&&, std::tuple<ConvertibleFrom<ConstMove>>>);
+
+static_assert(std::is_convertible_v<const std::tuple<ConstMove, ConstMove>&&,
+                                    std::tuple<ConvertibleFrom<ConstMove>, ConvertibleFrom<ConstMove>>>);
+
+static_assert(
+    !std::is_convertible_v<const std::tuple<MutableCopy>&&, std::tuple<ExplicitConstructibleFrom<ConstMove>>>);
+
+static_assert(!std::is_convertible_v<const std::tuple<ConstMove, ConstMove>&&,
+                                     std::tuple<ConvertibleFrom<ConstMove>, ExplicitConstructibleFrom<ConstMove>>>);
+
+constexpr bool test() {
+  // test implicit conversions.
+  // sizeof...(Types) == 1
+  {
+    const std::tuple<ConstMove> t1{1};
+    std::tuple<ConvertibleFrom<ConstMove>> t2 = std::move(t1);
+    assert(std::get<0>(t2).v.val == 1);
+  }
+
+  // test implicit conversions.
+  // sizeof...(Types) > 1
+  {
+    const std::tuple<ConstMove, int> t1{1, 2};
+    std::tuple<ConvertibleFrom<ConstMove>, int> t2 = std::move(t1);
+    assert(std::get<0>(t2).v.val == 1);
+    assert(std::get<1>(t2) == 2);
+  }
+
+  // test explicit conversions.
+  // sizeof...(Types) == 1
+  {
+    const std::tuple<ConstMove> t1{1};
+    std::tuple<ExplicitConstructibleFrom<ConstMove>> t2{std::move(t1)};
+    assert(std::get<0>(t2).v.val == 1);
+  }
+
+  // test explicit conversions.
+  // sizeof...(Types) > 1
+  {
+    const std::tuple<ConstMove, int> t1{1, 2};
+    std::tuple<ExplicitConstructibleFrom<ConstMove>, int> t2{std::move(t1)};
+    assert(std::get<0>(t2).v.val == 1);
+    assert(std::get<1>(t2) == 2);
+  }
+
+  // test constraints
+
+  // sizeof...(Types) != sizeof...(UTypes)
+  static_assert(!std::is_constructible_v<std::tuple<int, int>, const std::tuple<int>&&>);
+  static_assert(!std::is_constructible_v<std::tuple<int, int, int>, const std::tuple<int, int>&&>);
+
+  // !(is_constructible_v<Types, decltype(get<I>(FWD(u)))> && ...)
+  static_assert(!std::is_constructible_v<std::tuple<int, NoConstructorFromInt>, const std::tuple<int, int>&&>);
+
+  // sizeof...(Types) == 1 && other branch of "||" satisfied
+  {
+    const std::tuple<TracedCopyMove> t1{};
+    std::tuple<ConvertibleFrom<TracedCopyMove>> t2{std::move(t1)};
+    assert(constMoveCtrCalled(std::get<0>(t2).v));
+  }
+
+  // sizeof...(Types) == 1 && is_same_v<T, U>
+  {
+    const std::tuple<TracedCopyMove> t1{};
+    std::tuple<TracedCopyMove> t2{t1};
+    assert(!constMoveCtrCalled(std::get<0>(t2)));
+  }
+
+  // sizeof...(Types) != 1
+  {
+    const std::tuple<TracedCopyMove, TracedCopyMove> t1{};
+    std::tuple<TracedCopyMove, TracedCopyMove> t2{std::move(t1)};
+    assert(constMoveCtrCalled(std::get<0>(t2)));
+  }
+
+  // These two test points cause gcc to ICE
+#if !defined(TEST_COMPILER_GCC)
+  // sizeof...(Types) == 1 && is_convertible_v<decltype(u), T>
+  {
+    const std::tuple<CvtFromConstTupleRefRef> t1{};
+    std::tuple<ConvertibleFrom<CvtFromConstTupleRefRef>> t2{std::move(t1)};
+    assert(!constMoveCtrCalled(std::get<0>(t2).v));
+  }
+
+  // sizeof...(Types) == 1 && is_constructible_v<decltype(u), T>
+  {
+    const std::tuple<ExplicitCtrFromConstTupleRefRef> t1{};
+    std::tuple<ConvertibleFrom<ExplicitCtrFromConstTupleRefRef>> t2{std::move(t1)};
+    assert(!constMoveCtrCalled(std::get<0>(t2).v));
+  }
+#endif
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+  return 0;
+}

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/convert_non_const_copy.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>
+// template <class... UTypes>
+//   constexpr explicit(see below) tuple<Types>::tuple(tuple<UTypes...>&);
+//
+// Constraints:
+//  sizeof...(Types) equals sizeof...(UTypes) &&
+//  (is_constructible_v<Types, decltype(get<I>(FWD(u)))> && ...) is true &&
+//  (
+//  sizeof...(Types) is not 1 ||
+//  (
+//    !is_convertible_v<decltype(u), T> &&
+//    !is_constructible_v<T, decltype(u)> &&
+//    !is_same_v<T, U>
+//  )
+//  )
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <cassert>
+#include <tuple>
+
+#include "convert_types.h"
+#include "test_macros.h"
+
+// test: The expression inside explicit is equivalent to:
+// !(is_convertible_v<decltype(get<I>(FWD(u))), Types> && ...)
+static_assert(std::is_convertible_v<std::tuple<MutableCopy>&, std::tuple<ConvertibleFrom<MutableCopy>>>);
+
+static_assert(std::is_convertible_v<std::tuple<MutableCopy, MutableCopy>&,
+                                    std::tuple<ConvertibleFrom<MutableCopy>, ConvertibleFrom<MutableCopy>>>);
+
+static_assert(!std::is_convertible_v<std::tuple<MutableCopy>&, std::tuple<ExplicitConstructibleFrom<MutableCopy>>>);
+
+static_assert(!std::is_convertible_v<std::tuple<MutableCopy, MutableCopy>&,
+                                     std::tuple<ConvertibleFrom<MutableCopy>, ExplicitConstructibleFrom<MutableCopy>>>);
+
+constexpr bool test() {
+  // test implicit conversions.
+  // sizeof...(Types) == 1
+  {
+    std::tuple<MutableCopy> t1{1};
+    std::tuple<ConvertibleFrom<MutableCopy>> t2 = t1;
+    assert(std::get<0>(t2).v.val == 1);
+  }
+
+  // test implicit conversions.
+  // sizeof...(Types) > 1
+  {
+    std::tuple<MutableCopy, int> t1{1, 2};
+    std::tuple<ConvertibleFrom<MutableCopy>, int> t2 = t1;
+    assert(std::get<0>(t2).v.val == 1);
+    assert(std::get<1>(t2) == 2);
+  }
+
+  // test explicit conversions.
+  // sizeof...(Types) == 1
+  {
+    std::tuple<MutableCopy> t1{1};
+    std::tuple<ExplicitConstructibleFrom<MutableCopy>> t2{t1};
+    assert(std::get<0>(t2).v.val == 1);
+  }
+
+  // test explicit conversions.
+  // sizeof...(Types) > 1
+  {
+    std::tuple<MutableCopy, int> t1{1, 2};
+    std::tuple<ExplicitConstructibleFrom<MutableCopy>, int> t2{t1};
+    assert(std::get<0>(t2).v.val == 1);
+    assert(std::get<1>(t2) == 2);
+  }
+
+  // test constraints
+
+  // sizeof...(Types) != sizeof...(UTypes)
+  static_assert(!std::is_constructible_v<std::tuple<int, int>, std::tuple<int>&>);
+  static_assert(!std::is_constructible_v<std::tuple<int>, std::tuple<int, int>&>);
+  static_assert(!std::is_constructible_v<std::tuple<int, int, int>, std::tuple<int, int>&>);
+
+  // !(is_constructible_v<Types, decltype(get<I>(FWD(u)))> && ...)
+  static_assert(!std::is_constructible_v<std::tuple<int, NoConstructorFromInt>, std::tuple<int, int>&>);
+
+  // sizeof...(Types) == 1 && other branch of "||" satisfied
+  {
+    std::tuple<TracedCopyMove> t1{};
+    std::tuple<ConvertibleFrom<TracedCopyMove>> t2{t1};
+    assert(nonConstCopyCtrCalled(std::get<0>(t2).v));
+  }
+
+  // sizeof...(Types) == 1 && is_same_v<T, U>
+  {
+    std::tuple<TracedCopyMove> t1{};
+    std::tuple<TracedCopyMove> t2{t1};
+    assert(!nonConstCopyCtrCalled(std::get<0>(t2)));
+  }
+
+  // sizeof...(Types) != 1
+  {
+    std::tuple<TracedCopyMove, TracedCopyMove> t1{};
+    std::tuple<TracedCopyMove, TracedCopyMove> t2{t1};
+    assert(nonConstCopyCtrCalled(std::get<0>(t2)));
+  }
+
+  // These two test points cause gcc to ICE
+#if !defined(TEST_COMPILER_GCC)
+  // sizeof...(Types) == 1 && is_convertible_v<decltype(u), T>
+  {
+    std::tuple<CvtFromTupleRef> t1{};
+    std::tuple<ConvertibleFrom<CvtFromTupleRef>> t2{t1};
+    assert(!nonConstCopyCtrCalled(std::get<0>(t2).v));
+  }
+
+  // sizeof...(Types) == 1 && is_constructible_v<decltype(u), T>
+  {
+    std::tuple<ExplicitCtrFromTupleRef> t1{};
+    std::tuple<ConvertibleFrom<ExplicitCtrFromTupleRef>> t2{t1};
+    assert(!nonConstCopyCtrCalled(std::get<0>(t2).v));
+  }
+#endif
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+  return 0;
+}

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

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+#ifndef LIBCXX_TEST_STD_UTILITIES_TUPLE_CNSTR_TYPES_H
+#define LIBCXX_TEST_STD_UTILITIES_TUPLE_CNSTR_TYPES_H
+
+#include "test_allocator.h"
+#include <type_traits>
+
+struct MutableCopy {
+  int val;
+  bool alloc_constructed{false};
+
+  constexpr MutableCopy() = default;
+  constexpr MutableCopy(int _val) : val(_val) {}
+  constexpr MutableCopy(MutableCopy&) = default;
+  constexpr MutableCopy(const MutableCopy&) = delete;
+
+  constexpr MutableCopy(std::allocator_arg_t, const test_allocator<int>&, MutableCopy& o)
+      : val(o.val), alloc_constructed(true) {}
+};
+
+template <>
+struct std::uses_allocator<MutableCopy, test_allocator<int>> : std::true_type {};
+
+struct ConstCopy {
+  int val;
+  bool alloc_constructed{false};
+
+  constexpr ConstCopy() = default;
+  constexpr ConstCopy(int _val) : val(_val) {}
+  constexpr ConstCopy(const ConstCopy&) = default;
+  constexpr ConstCopy(ConstCopy&) = delete;
+
+  constexpr ConstCopy(std::allocator_arg_t, const test_allocator<int>&, const ConstCopy& o)
+      : val(o.val), alloc_constructed(true) {}
+};
+
+template <>
+struct std::uses_allocator<ConstCopy, test_allocator<int>> : std::true_type {};
+
+struct MutableMove {
+  int val;
+  bool alloc_constructed{false};
+
+  constexpr MutableMove() = default;
+  constexpr MutableMove(int _val) : val(_val) {}
+  constexpr MutableMove(MutableMove&&) = default;
+  constexpr MutableMove(const MutableMove&&) = delete;
+
+  constexpr MutableMove(std::allocator_arg_t, const test_allocator<int>&, MutableMove&& o)
+      : val(o.val), alloc_constructed(true) {}
+};
+
+template <>
+struct std::uses_allocator<MutableMove, test_allocator<int>> : std::true_type {};
+
+struct ConstMove {
+  int val;
+  bool alloc_constructed{false};
+
+  constexpr ConstMove() = default;
+  constexpr ConstMove(int _val) : val(_val) {}
+  constexpr ConstMove(const ConstMove&& o) : val(o.val) {}
+  constexpr ConstMove(ConstMove&&) = delete;
+
+  constexpr ConstMove(std::allocator_arg_t, const test_allocator<int>&, const ConstMove&& o)
+      : val(o.val), alloc_constructed(true) {}
+};
+
+template <>
+struct std::uses_allocator<ConstMove, test_allocator<int>> : std::true_type {};
+
+template <class T>
+struct ConvertibleFrom {
+  T v;
+  bool alloc_constructed{false};
+
+  constexpr ConvertibleFrom() = default;
+  constexpr ConvertibleFrom(T& _v)
+    requires(std::is_constructible_v<T, T&>)
+  : v(_v) {}
+  constexpr ConvertibleFrom(const T& _v)
+    requires(std::is_constructible_v<T, const T&> && !std::is_const_v<T>)
+  : v(_v) {}
+  constexpr ConvertibleFrom(T&& _v)
+    requires(std::is_constructible_v<T, T &&>)
+  : v(std::move(_v)) {}
+  constexpr ConvertibleFrom(const T&& _v)
+    requires(std::is_constructible_v<T, const T &&> && !std::is_const_v<T>)
+  : v(std::move(_v)) {}
+
+  template <class U>
+    requires std::is_constructible_v<ConvertibleFrom, U&&>
+  constexpr ConvertibleFrom(std::allocator_arg_t, const test_allocator<int>&, U&& _u)
+      : ConvertibleFrom{std::forward<U>(_u)} {
+    alloc_constructed = true;
+  }
+};
+
+template <class T>
+struct std::uses_allocator<ConvertibleFrom<T>, test_allocator<int>> : std::true_type {};
+
+template <class T>
+struct ExplicitConstructibleFrom {
+  T v;
+  bool alloc_constructed{false};
+
+  constexpr explicit ExplicitConstructibleFrom() = default;
+  constexpr explicit ExplicitConstructibleFrom(T& _v)
+    requires(std::is_constructible_v<T, T&>)
+  : v(_v) {}
+  constexpr explicit ExplicitConstructibleFrom(const T& _v)
+    requires(std::is_constructible_v<T, const T&> && !std::is_const_v<T>)
+  : v(_v) {}
+  constexpr explicit ExplicitConstructibleFrom(T&& _v)
+    requires(std::is_constructible_v<T, T &&>)
+  : v(std::move(_v)) {}
+  constexpr explicit ExplicitConstructibleFrom(const T&& _v)
+    requires(std::is_constructible_v<T, const T &&> && !std::is_const_v<T>)
+  : v(std::move(_v)) {}
+
+  template <class U>
+    requires std::is_constructible_v<ExplicitConstructibleFrom, U&&>
+  constexpr ExplicitConstructibleFrom(std::allocator_arg_t, const test_allocator<int>&, U&& _u)
+      : ExplicitConstructibleFrom{std::forward<U>(_u)} {
+    alloc_constructed = true;
+  }
+};
+
+template <class T>
+struct std::uses_allocator<ExplicitConstructibleFrom<T>, test_allocator<int>> : std::true_type {};
+
+struct TracedCopyMove {
+  int nonConstCopy = 0;
+  int constCopy = 0;
+  int nonConstMove = 0;
+  int constMove = 0;
+  bool alloc_constructed = false;
+
+  constexpr TracedCopyMove() = default;
+  constexpr TracedCopyMove(const TracedCopyMove& other)
+      : nonConstCopy(other.nonConstCopy), constCopy(other.constCopy + 1), nonConstMove(other.nonConstMove),
+        constMove(other.constMove) {}
+  constexpr TracedCopyMove(TracedCopyMove& other)
+      : nonConstCopy(other.nonConstCopy + 1), constCopy(other.constCopy), nonConstMove(other.nonConstMove),
+        constMove(other.constMove) {}
+
+  constexpr TracedCopyMove(TracedCopyMove&& other)
+      : nonConstCopy(other.nonConstCopy), constCopy(other.constCopy), nonConstMove(other.nonConstMove + 1),
+        constMove(other.constMove) {}
+
+  constexpr TracedCopyMove(const TracedCopyMove&& other)
+      : nonConstCopy(other.nonConstCopy), constCopy(other.constCopy), nonConstMove(other.nonConstMove),
+        constMove(other.constMove + 1) {}
+
+  template <class U>
+    requires std::is_constructible_v<TracedCopyMove, U&&>
+  constexpr TracedCopyMove(std::allocator_arg_t, const test_allocator<int>&, U&& _u)
+      : TracedCopyMove{std::forward<U>(_u)} {
+    alloc_constructed = true;
+  }
+};
+
+template <>
+struct std::uses_allocator<TracedCopyMove, test_allocator<int>> : std::true_type {};
+
+// If the constructor tuple(tuple<UTyles...>&) is not available,
+// the fallback call to `tuple(const tuple&) = default;` or any other
+// constructor that takes const ref would increment the constCopy.
+inline constexpr bool nonConstCopyCtrCalled(const TracedCopyMove& obj) {
+  return obj.nonConstCopy == 1 && obj.constCopy == 0 && obj.constMove == 0 && obj.nonConstMove == 0;
+}
+
+// If the constructor tuple(const tuple<UTyles...>&&) is not available,
+// the fallback call to `tuple(const tuple&) = default;` or any other
+// constructor that takes const ref would increment the constCopy.
+inline constexpr bool constMoveCtrCalled(const TracedCopyMove& obj) {
+  return obj.nonConstMove == 0 && obj.constMove == 1 && obj.constCopy == 0 && obj.nonConstCopy == 0;
+}
+
+struct NoConstructorFromInt {};
+
+struct CvtFromTupleRef : TracedCopyMove {
+  constexpr CvtFromTupleRef() = default;
+  constexpr CvtFromTupleRef(std::tuple<CvtFromTupleRef>& other)
+      : TracedCopyMove(static_cast<TracedCopyMove&>(std::get<0>(other))) {}
+};
+
+struct ExplicitCtrFromTupleRef : TracedCopyMove {
+  constexpr explicit ExplicitCtrFromTupleRef() = default;
+  constexpr explicit ExplicitCtrFromTupleRef(std::tuple<ExplicitCtrFromTupleRef>& other)
+      : TracedCopyMove(static_cast<TracedCopyMove&>(std::get<0>(other))) {}
+};
+
+struct CvtFromConstTupleRefRef : TracedCopyMove {
+  constexpr CvtFromConstTupleRefRef() = default;
+  constexpr CvtFromConstTupleRefRef(const std::tuple<CvtFromConstTupleRefRef>&& other)
+      : TracedCopyMove(static_cast<const TracedCopyMove&&>(std::get<0>(other))) {}
+};
+
+struct ExplicitCtrFromConstTupleRefRef : TracedCopyMove {
+  constexpr explicit ExplicitCtrFromConstTupleRefRef() = default;
+  constexpr explicit ExplicitCtrFromConstTupleRefRef(std::tuple<const ExplicitCtrFromConstTupleRefRef>&& other)
+      : TracedCopyMove(static_cast<const TracedCopyMove&&>(std::get<0>(other))) {}
+};
+
+template <class T>
+void conversion_test(T);
+
+template <class T, class... Args>
+concept ImplicitlyConstructible = requires(Args&&... args) { conversion_test<T>({std::forward<Args>(args)...}); };
+
+#endif

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/non_const_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
+//
+//===----------------------------------------------------------------------===//
+
+// <tuple>
+
+// template <class... Types>
+// template <class U1, class U2>
+// constexpr explicit(see below) tuple<Types...>::tuple(pair<U1, U2>& u);
+
+// Constraints:
+// - sizeof...(Types) is 2 and
+// - is_constructible_v<T0, decltype(get<0>(FWD(u)))> is true and
+// - is_constructible_v<T1, decltype(get<1>(FWD(u)))> is true.
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <cassert>
+#include <tuple>
+#include <utility>
+
+#include "convert_types.h"
+
+// test constraints
+// sizeof...(Types) == 2
+static_assert(std::is_constructible_v<std::tuple<MutableCopy, int>, std::pair<MutableCopy, int>&>);
+
+static_assert(!std::is_constructible_v<std::tuple<MutableCopy>, std::pair<MutableCopy, int>&>);
+
+static_assert(!std::is_constructible_v<std::tuple<MutableCopy, int, int>, std::pair<MutableCopy, int>&>);
+
+// test constraints
+// is_constructible_v<T0, decltype(get<0>(FWD(u)))> is true and
+// is_constructible_v<T1, decltype(get<1>(FWD(u)))> is true.
+static_assert(std::is_constructible_v<std::tuple<int, int>, std::pair<int, int>&>);
+
+static_assert(!std::is_constructible_v<std::tuple<NoConstructorFromInt, int>, std::pair<int, int>&>);
+
+static_assert(!std::is_constructible_v<std::tuple<int, NoConstructorFromInt>, std::pair<int, int>&>);
+
+static_assert(!std::is_constructible_v< std::tuple<NoConstructorFromInt, NoConstructorFromInt>, std::pair<int, int>&>);
+
+// test: The expression inside explicit is equivalent to:
+// !is_convertible_v<decltype(get<0>(FWD(u))), T0> ||
+// !is_convertible_v<decltype(get<1>(FWD(u))), T1>
+static_assert(std::is_convertible_v<std::pair<MutableCopy, MutableCopy>&,
+                                    std::tuple<ConvertibleFrom<MutableCopy>, ConvertibleFrom<MutableCopy>>>);
+
+static_assert(!std::is_convertible_v<std::pair<MutableCopy, MutableCopy>&,
+                                     std::tuple<ExplicitConstructibleFrom<MutableCopy>, ConvertibleFrom<MutableCopy>>>);
+
+static_assert(!std::is_convertible_v<std::pair<MutableCopy, MutableCopy>&,
+                                     std::tuple<ConvertibleFrom<MutableCopy>, ExplicitConstructibleFrom<MutableCopy>>>);
+
+constexpr bool test() {
+  // test implicit conversions.
+  {
+    std::pair<MutableCopy, int> p{1, 2};
+    std::tuple<ConvertibleFrom<MutableCopy>, ConvertibleFrom<int>> t = p;
+    assert(std::get<0>(t).v.val == 1);
+    assert(std::get<1>(t).v == 2);
+  }
+
+  // test explicit conversions.
+  {
+    std::pair<MutableCopy, int> p{1, 2};
+    std::tuple<ExplicitConstructibleFrom<MutableCopy>, ExplicitConstructibleFrom<int>> t{p};
+    assert(std::get<0>(t).v.val == 1);
+    assert(std::get<1>(t).v == 2);
+  }
+
+  // non const overload should be called
+  {
+    std::pair<TracedCopyMove, TracedCopyMove> p;
+    std::tuple<ConvertibleFrom<TracedCopyMove>, TracedCopyMove> t = p;
+    assert(nonConstCopyCtrCalled(std::get<0>(t).v));
+    assert(nonConstCopyCtrCalled(std::get<1>(t)));
+  }
+
+  return true;
+}
+
+int main() {
+  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
+
+#include <cassert>
+#include <tuple>
+#include <utility>
+
+#include "test_macros.h"
+
+#ifndef TEST_HAS_NO_EXCEPTIONS
+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) {
+  }
+}
+#endif // TEST_HAS_NO_EXCEPTIONS
+
+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(ConstSwappable{0});
+    T t1(ConstSwappable{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**) {
+#ifndef TEST_HAS_NO_EXCEPTIONS
+  test_noexcept();
+#endif
+  test();
+
+// gcc cannot have mutable member in constant expression
+#if !defined(TEST_COMPILER_GCC)
+  static_assert(test());
+#endif
+
+  return 0;
+}