[libc++] Rewrite the tuple constructors to be strictly Standards conforming

[ldionne]

Summary

This nasty patch rewrites the tuple constructors to match those defined
by the Standard. We were previously providing several extensions in those
constructors - those extensions are removed by this patch.

The issue with those extensions is that we've had numerous bugs filed
against us over the years for problems essentially caused by them. As a
result, people are unable to use tuple in ways that are blessed by the
Standard, all that for the perceived benefit of providing them extensions
that they never asked for.

Since this is an API break, I communicated it in the release notes.
I do not foresee major issues with this break because I don't think the
extensions are too widely relied upon, but we can ship it and see if we
get complaints before the next LLVM release - that will give us some
amount of information regarding how much use these extensions have.

[ldionne]

I would love to have some eyes on this. I know it's a nasty patch with a lot of metaprogramming, but I'd like to get some opinions on:

1. The correctness of the change
2. What people think about removing those extensions
3. Anything else reviewers want to talk about :-)

Pinging a few people that might be interested by this: @CaseyCarter @arthur.j.odwyer @curdeius @zoecarver @EricWF (not exhaustive)

[ldionne]

Oh, and some other levels of testing we can do:

1. Build our internal code bases with the change (I'm thinking Apple and Google but others are welcome to do it too)
2. Maybe we can have some open-source libraries try out the change - for example I'd love to see if Range-v3 sees issues with this

[zoecarver]

More comments later :)

libcxx/include/tuple

460

The standard has about 100 ways of abbreviating the word "constructor".

463

I assume the _Dep is just a "dummy type" for the _EnableIf? If so, maybe we could keep calling it _Dummy, because we use that name in a lot of places in the codebase to indicate that the type doesn't matter, or is just used for a following _EnableIf. Right now, when I look at this, I'm wondering if it was changed to add a "dependency" to this constructor (which I don't think is the case).

Additionally, if you change this to say class _T2 = _Tp or class _Dummy = _Tp you can omit the _And, I think. (Note: here it doesn't really matter because you'd go back to using __all but below I think you can eliminate some extra template logic, which is good for both readability and compile time.)

467

Nit: space.

(Same comment on a few of these ctors.)

491

This constructor could be _NOEXCEPT_(_And<is_nothrow_default_constructible<_Tp>...>::value), right?

I think there are a couple of missing noexcepts here, but I think that's better done as a follow-up patch, to keep things separated. I am happy to work on this, after this patch lands. (Also, I won't point it out again, because it's not really relevant to this patch.)

[zoecarver]

libcxx/include/tuple

480

When were these conditionally explicit overloads added? I think C++17.

This is a bit annoying because in C++20 we get the explicit(bool) operator which would make this implementation about 50% smaller.

It looks like that was added to clang in V10. I wonder if we could get away with a macro to do this. There would be a small overlap of users on the V6-V10 clang version using C++17 who might be affected.

[zoecarver]

libcxx/include/tuple

589

Nit: it might be simpler to just say sizeof...(_Up) != 1 || is_same<_Up, tuple>... (or even __is_same(_Up..., tuple)). Then you could get rid of _IsThisTuple.

937

If you're using _Up1 here, do you need the _Dep template type param?

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

57

Is this not an extension? If it is an extension, don't we want to keep this behind a condition so that the test suite is more portable?

[ldionne]

Address Zoe's comments.

[ldionne]

Also, I didn't mention it but I didn't add new tests. This is technically not increasing the API surface (in fact decreasing it), and the existing tests seemed to have the right coverage already.

libcxx/include/tuple

460

Ahah, indeed.

463

_Dep stands for _Dependent. IOW, I'm making the _And<...> instantiation dependent on a template argument to avoid it being evaluated eagerly. I can use _Dummy, but I went for the shortest thing that made sense since it's used to make _FirstType<...> and _SecondType<...> dependent below, where having a long name hurts readability. I think _Dummy is fine, though.

Additionally, if you change this to say class _T2 = _Tp

I can't do that, because _Tp is a parameter pack. Otherwise, I would replace all these occurrences by something notionally equivalent to <class ..._DependentTp = _Tp>, and I could get rid of much of the complexity. Unless I've missed something major, that isn't valid C++ right now though.

480

When were these conditionally explicit overloads added? I think C++17.

Hmm, I'm not 100% sure, but that sounds about right. Perhaps we've been supporting those in older Standards as an extension. While I generally dislike extensions, I think that not enabling those implicit/explicit constructors pre-C++17 would be a pretty big cost in complexity for little benefit, so I'd rather implement them even pre-C++17. Open to discussion, of course.

This is a bit annoying because in C++20 we get the explicit(bool) operator

Yes, I agree, those are a huge pain to write without explicit(bool), but I don't think there's a way around that TBH. To be fair, there is quite a bit of code duplication, but it's simple code. I was also planning on simplifying the calls to the __base_ constructor in a follow-up patch to reduce the magnitude of the duplication. Let me know if you have a blocking comment or if you want me to take an action here.

491

I tried keeping the same noexcepts that we had before this patch. None of the allocator_arg_t constructors had noexcept before the patch, so their don't either after the patch.

I don't really like those constructors :-).

589

I agree, I'd like to get rid of _IsThisTuple too. I tried the following three alternatives:

_Not<is_same<__uncvref_t<_Up>, tuple>...>

This doesn't work because we're expanding a pack into _Not, which takes a single template parameter.

_Not<is_same<__uncvref_t<_Up>..., tuple> >

This doesn't work because we're expanding a pack into is_same, which takes two parameters exactly.

_BoolConstant<!__is_same(__uncvref_t<_Up>..., tuple)>

This doesn't work but I don't know why.

Let me know if you can think of another way to get rid of _IsThisTuple.

937

Ok, so that's an excellent question, and I would have expected the answer to be "No". In fact, I initially wrote all those without these _Lazy calls whenever some arguments were dependent, but I was getting errors saying (basically): "you're expanding parameter packs of different lengths in the definition of the _EnableMoveFromPair alias".

I thought that sort of failure within the definition of an alias template would be considered part of the immediate context for SFINAE and it would result in the overload not being selected. But I was getting a hard error instead. I'm not sure whether I'm doing something subtly wrong, or my expectation about substitution failures in alias templates is wrong, or if it's a compiler bug. I decided not to investigate further because this worked, but I can if you request it.

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

57

Actually, I couldn't figure out what about the test case was an extension, so I thought it might have been marked as an extension incorrectly.

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

57

Same here, is this really testing an extension? I can't see what's an extension about it.

[• Quuxplusone]

I haven't really tried to understand this code, but if it passes tests, I certainly don't object to it.

libcxx/docs/ReleaseNotes.rst

57

IMHO it would be nice to provide code snippets (Godbolt links?) to things that have changed.
IIUC the removed signatures are https://godbolt.org/z/v49qKe
but I don't know what signatures (if any) are being added.

libcxx/include/tuple

589

FWIW, I don't understand what the "extension" is here, nor what "mis-behaved user constructors" we're worried about. But I haven't cared enough to remove that line and re-run the unit tests to find out.

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

17

// See https://llvm.org/PR27684 — as long as you're normalizing comments here.

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

40

Nit: when there are fewer initializers than elements or fewer constructor arguments than tuple elements.

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

97

I would like to see tests here for

std::tuple<int, int> t2(derived, A1<int>(), 42, 42);
std::tuple<int, int> t3(derived, A1<int>(), std::tuple<int, int>{42, 42});

just to prove that these work for non-empty tuples too.

[• Quuxplusone]

libcxx/include/tuple

937

I think Zoe is right that you could remove _Dummy. I have no opinion on the rest of the simplification you tried. But just this should work, right?:

template <class _Alloc, class _Up1, class _Up2, _EnableIf<
    _And<
        _Lazy<_EnableMoveFromPair, _Up1, _Up2>,
        _Not<_Lazy<_And, // explicit check
            is_convertible<_Up1, _FirstType<_Tp..., void> >,
            is_convertible<_Up2, _SecondType<_Tp..., void> >
        > >
    >::value
, int> = 0>

(replacing _Dummy with void in the places IIUC we don't care what it is)
(or maybe you need SecondType<_Tp..., void, void>?)

[zoecarver]

What would you think about extending the _v type traits to always be available (no matter the standard version)? Then we could remove a lot of the _Ands and similar types which would mean we would instantiate a lot few types, therefore, having much better compile time. Not a big deal, but it might be nice.

libcxx/include/tuple

463

I suppose _Dep makes sense now that I understand what it means. But I still think _Dummy is better because that's what we use everywhere else, so thanks for changing it.

I can't do that, because _Tp is a parameter pack.

Ah, yes, you're right. For some reason, I thought you could, but it looks like that's not a feature.

480

While I generally dislike extensions, I think that not enabling those implicit/explicit constructors pre-C++17 would be a pretty big cost in complexity for little benefit, so I'd rather implement them even pre-C++17.

I think if we removed the extension, we'd actually reduce the complexity significantly. Here's what I had in mind:

#if STD > 14 && CLANG >=10
#define _EXPLICIT_COND(...) explicit(...)
#else
#define _EXPLICIT_COND
#endif

Then we could just annotate all these overloads with _EXPLICIT_COND(...). The problem is we'd be non-conforming for those using C++17 on clang V9 or lower, and this would potentially break people's code if they were on C++11 or 14. WDYT? Could we get away with it? 😉

This is a non-blocking comment. I just thought it might be a way to reduce a bunch of code (but it looks it probably won't work for now, but maybe we can come back to it in a few years).

589

This works for me:

template<class ...U>
    static const size_t u_types_constraints =
        sizeof...(U) == sizeof...(T) &&
        sizeof...(U) >= 1 &&
        !is_same<Tuple, U...>::value;

template<class ...U, class = _EnableIf<u_types_constraints<U...> > >
    Tuple(U&&...) { }

---

FWIW, I don't understand what the "extension" is here, nor what "mis-behaved user constructors" we're worried about. But I haven't cared enough to remove that line and re-run the unit tests to find out.

I also am curious about what this means. I thought it was just to ensure that we picked the right overload (so that this doesn't look like a move constructor when _Up = tuple).

802

Wait... why do we have _Dummy types here? Why can't this just be:

template <class U1, class U2>
static const size_t __enable_copy_from_pair = sizeof...(_Tp) == 2 && 
    is_constructible<_FirstType <_Tp...>, const U1&>::value &&
    is_constructible<_SecondType<_Tp...>, const U2&>::value;

[zoecarver]

libcxx/include/tuple

937

First, why do we need the void types? We've already checked that there are at least two elements, and this should be a short-circuiting operator.

Second, I think type alias types should be counted as dependent types as long as they're substituted with template type arguments. So, what Arthur proposed should work. But I can play around with this patch a bit more locally tomorrow and try to get it working.

[zoecarver]

libcxx/include/tuple

589

Follow up: I got this working here. I like this approach much better because we instantiate less than half the types, so it should be much better for compile time.

Side note: I spent way too long banging my head against the wall trying to figure out why we can only zip parameter packs in type aliases (and not static vars). It turns out there's an issue for this open: 1844. Basically, various compilers read "immediate context" differently, so sometimes we get a hard error and sometimes we get a substitution failure. Here's a Godbolt to demonstrate the problem.

[• Quuxplusone]

libcxx/include/tuple

589

@zoecarver: Your Godbolt (https://godbolt.org/z/erqqGT ) makes perfect sense to me. Here's a "reduced" (but still icky) version: https://godbolt.org/z/x6c67o
If you have a type alias that says "Yy is the type you get by zipping these packs," and the packs can't be zipped, well, that's SFINAE-friendly. If you have a static constexpr bool whose initializer says "Xx is true if zipping these packs gives you foo, or false if zipping these packs gives you bar," and the packs can't be zipped, well, that's not SFINAE-friendly (not an "immediate context," if I've got my standardese right).

937

why do we need the void types?

Because when sizeof...(_Tp) == 1, then _SecondType<_Tp...> is ill-formed — which would make the entire type-expression

_EnableIf<
    _And<
        _Lazy<_EnableMoveFromPair, _Up1, _Up2>,
        _Not<_Lazy<_And, // explicit check
            is_convertible<_Up1, _FirstType<_Tp..., void> >,
            is_convertible<_Up2, _SecondType<_Tp..., void> >
        > >
    >::value
, int>

immediately ill-formed — which would make this constructor template drop out of overload resolution whenever sizeof...(_Tp) == 1. Hmm, I guess that's totally OK in this case!

The key thing to watch out for in all this metaprogramming ickiness is that regardless of short-circuiting evaluation of truth values, the compiler is still going to be instantiating the types that we name in the expression, such as _FirstType<_Tp..., void>. I guess that's exactly what _Lazy is for, though; and so if _SecondType<_Tp...> didn't suffice, the next thing we should try is not _SecondType<_Tp..., void> but rather _Lazy<_SecondType, _Tp...>.

[ldionne]

Address review comments, fix compilation on GCC and other minor simplifications to the SFINAE.

[ldionne]

I addressed all comments with a direct suggestion. For other comments on using various patterns for doing SFINAE, I actually reworked everything to make GCC happy.

You'll notice that we now never call a metafunction with the incorrect number of arguments. GCC does not seem to handle SFINAE failures for mismatched parameter pack lengths correctly, so I had to use this approach.

I still need to investigate a test failure in C++11 and C++14 mode - the behavior after this patch matches the libstdc++ behavior, so I think the test was wrong, but I need to understand it better.

libcxx/include/tuple

480

Does Clang trunk provide explicit(bool) as an extension in C++ < 20 modes? If so, then I suggest we come back once we drop support for older Clangs and remove the duplication.

Otherwise, if Clang doesn't support explicit(bool) in pre-C++20 mode, we will never be able to remove this duplication because we still have to implement the explicit/implicit constructors for tuple pre-C++20 (it was applied as a LWG issue IIRC).

589

FWIW, I don't understand what the "extension" is here, nor what "mis-behaved user constructors" we're worried about.

It refers to the test in libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR23256_constrain_UTypes_ctor.pass.cpp. That test fails if you remove that line.

We're on the same page regarding the SFINAE behavior for variable templates vs template aliases, but I don't think it's relevant to the issue directly at hand.

The issue here is that we want the overload to be enabled when sizeof...(_Up) > 1. But when that's the case, is_same will cause a SFINAE error because we'll try to instantiate it with too many template arguments. Basically, in order to get rid of _IsThisTuple, we'd have to write something like this instead:

_And<_BoolConstant<sizeof...(_Up) == 1>, _Lazy<is_same, uncvref_t<_Up>..., tuple> >

I don't think that's better, but WDYT?

802

Because when sizeof...(_Tp) < 2, the "expression" _FirstType<_Tp...> is a hard error. That "expression" is "evaluated" when the tuple template is instantiated, not when we instantiate the template alias.

937

the next thing we should try is not _SecondType<_Tp..., void> but rather _Lazy<_SecondType, _Tp...>.

That doesn't work, because _SecondType is an alias that expands to the type itself. So _Lazy would end up inheriting from that type, which isn't what we want.

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

40

Thanks, much better indeed!

[zoecarver]

Also, I just realized that we can use fold expressions here (on all supported compilers even in C++03 mode). I bet that would be faster/cleaner than instantiating all the _Ands.

libcxx/include/tuple

589

But when that's the case, is_same will cause a SFINAE error because we'll try to instantiate it with too many template arguments.

I think this is the point of confusion. This is also why we are able to use a static variable. Because tuple is not a parameter pack, so there are never too many template arguments.

However, in the diff I liked to, Arthur made a really good point, which is that using a static variable might not be faster here if we have to uncvref_t all of the Us.

So, I'm happy to ship this version. (Though, there is a small part of my brain saying, "I wonder if it would be faster to use a static variable and _IsThisTuple?")

757

I think there should be an (is_constructible_v<T, U&&> && ...) check.

[zoecarver]

libcxx/include/tuple

480

Yes. If there were a world where libc++ only supported Clang V10 and GCC V9, I think this could work really well.

[ldionne]

In D96523#2564329, @zoecarver wrote:

Also, I just realized that we can use fold expressions here (on all supported compilers even in C++03 mode). I bet that would be faster/cleaner than instantiating all the _Ands.

So we can't actually use fold expressions because they don't short-circuit instantiations. A fold expression like trait<args>::value && ... gets expanded to trait<arg0>::value && trait<arg1>::value && trait<arg2>::value && <etc>. While the evaluation of the boolean is short-circuited, the instantiation of trait<argn>::value is not, which is what we're trying to do here. As a result, if for example trait<arg2>::value causes a hard error, it will be instantiated even if trait<arg0>::value instantiates fine and evaluates to false. Does that make sense?

[zoecarver]

In D96523#2566911, @ldionne wrote:

In D96523#2564329, @zoecarver wrote:

Also, I just realized that we can use fold expressions here (on all supported compilers even in C++03 mode). I bet that would be faster/cleaner than instantiating all the _Ands.

So we can't actually use fold expressions because they don't short-circuit instantiations. A fold expression like trait<args>::value && ... gets expanded to trait<arg0>::value && trait<arg1>::value && trait<arg2>::value && <etc>. While the evaluation of the boolean is short-circuited, the instantiation of trait<argn>::value is not, which is what we're trying to do here. As a result, if for example trait<arg2>::value causes a hard error, it will be instantiated even if trait<arg0>::value instantiates fine and evaluates to false. Does that make sense?

Hmm. I understand what you're saying, but I think that's only the case if it's a static var. If it's actually part of the type (i.e., it's used to specialize a _BoolConstant), I think it works the same way. Here's an example.

[smeenai]

Will this fix https://bugs.llvm.org/show_bug.cgi?id=17550?

[ldionne]

In D96523#2566936, @zoecarver wrote:

[...]

Hmm. I understand what you're saying, but I think that's only the case if it's a static var. If it's actually part of the type (i.e., it's used to specialize a _BoolConstant), I think it works the same way. Here's an example.

Your example is broken - it SFINAEs out because you're zipping parameter packs of different lengths. See https://godbolt.org/z/qna759.

In D96523#2567168, @smeenai wrote:

Will this fix https://bugs.llvm.org/show_bug.cgi?id=17550?

Nope, but that's fixed by the parent patch https://reviews.llvm.org/D50106.

[• Quuxplusone]

libcxx/include/tuple

589

I would like to continue down this rabbit-hole, but I think we're all talking past each other at this point.

• There's the question of pack expansions, like where it's legit to put is_same<tuple, Up...> and where not.
• There's the question of eager vs lazy instantiation, like where it's legit to put (is_convertible<Tp, Up>::value && ...) and where _And<is_convertible<Tp, Up>...> (this is https://bugs.llvm.org/show_bug.cgi?id=23256 as I understand it).
• There's some desire to minimize instantiations, for speed. But there's also an explicit goal to avoid certain completions of is_convertible<T,U> because PR23256.
• There's maybe other questions.

(Perhaps _And<_Not<x>...> could be replaced by _NoneOf<x...>, if our toolbox were expanded to include an implementation of _NoneOf.)

I'd like to see either of these next steps:

• @ldionne to just land this thing already, or
• @ldionne to identify a single measurable goal, e.g. "let's figure out how to remove the identifier _IsThisTuple while still passing the tests in this patch," which we can then resume rabbit-holing on (but via suggesting actual patches that pass all the tests locally, not just brainstorming untested ideas).

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

16

What about gcc-8?
And does this patch change something that breaks gcc-9 and gcc-10, or is it more like "we never tested it and I just now noticed that it's broken"? Maybe this belongs in a severable commit.

[zoecarver]

Your example is broken - it SFINAEs out because you're zipping parameter packs of different lengths. See https://godbolt.org/z/qna759.

Oh, I thought you were saying that it wouldn't work because zipping parameter packs of different sizes would be a hard error. Anyway, I think I see what you're saying now. Thanks for the Godbolt link.

---

I think @Quuxplusone makes a good point. And for what it's worth, I'd be fine with this patch landing in its current state. I think we should attempt to remove extra template instantiations, but this can also be done after the fact and AFAICT this is already better than main (or at least easier to grok).

[ldionne]

I think I'd land this patch as-is and then try to identify some instantiations we want to remove and do that. Arthur, thanks for taking us back on track :-).

I'll need to figure out what the issue is with the remaining tests that fail in C++11 and C++14. Then I'll land this patch internally at Apple in a test build and see if there's any breakage. If that all works, I'll land this here.

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

16

I forgot to add gcc-8, I'll do that.

This patch causes GCC 10 to segfault when CTAD is used.

[ldionne]

Rebase onto main

[ldionne]

I was trying to close the loop on this and got down to the following behaving differently in C++11/14 and C++17/20: https://godbolt.org/z/6x75njn7v

#include <cstdio>

template <class ...T>
struct tuple {
  tuple() { }
  template <class ...U>
  tuple(tuple<U...>&&) { std::printf("construction\n"); }
};

struct Foo { };

struct Derived : tuple<int> {
  template<class U>
  operator tuple<U>() && { std::printf("conversion\n"); return {}; }
};

int main(int, char**) {
  tuple<Foo> bar(Derived{});
}

It looks like in C++11 and 14, we prefer the constructor, whereas in C++17 and above, we prefer the conversion. Both GCC and Clang have the same behavior. So I'm going to tweak the tests accordingly.

[ldionne]

Fix tests in C++11 and C++14

[ldionne]

I will ship this if CI passes, as discussed with the reviewers.

[zoecarver]

⛵️it!

[EricWF]

I'm a bit worried about some of the tests that were deleted. Not the ones for extensions, but some of the ones added to prevent regressions with SFINAE.

I would like to look into why they now fail.

[EricWF]

Here is one regression I've found so far:

https://godbolt.org/z/sahqsqarb

[ldionne]

Fix bug with eager default constructor

[ldionne]

In D96523#2666706, @EricWF wrote:

Here is one regression I've found so far:

https://godbolt.org/z/sahqsqarb

Thanks for the find. Did you find anything else?

I'm a bit worried about some of the tests that were deleted. Not the ones for extensions, but some of the ones added to prevent regressions with SFINAE.

Which specific tests are you worried about? I looked and I think the only ones I removed were related to libc++ extensions which do not exist after this patch.

[EricWF]

There's another bug with SFINAE depth increases that's blowing up at Google.
I suspect we can get that back.

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

22

Why were these tests deleted?

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

1

Why was this file deleted?

[ldionne]

In D96523#2674393, @EricWF wrote:

There's another bug with SFINAE depth increases that's blowing up at Google.
I suspect we can get that back.

Can you post a reproducer? I'll be happy to fix it.

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

39

That class was never used AFAICT.

57–66

This test requires libc++'s reduced arity initialization, as the comment says. That extension was removed.

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

1

Because the extension that allows constructing a tuple from an array was removed (as noted in the release notes).

[ldionne]

In D96523#2674422, @ldionne wrote:

In D96523#2674393, @EricWF wrote:

There's another bug with SFINAE depth increases that's blowing up at Google.
I suspect we can get that back.

Can you post a reproducer? I'll be happy to fix it.

I'll commit this on Wednesday unless I have more information. I don't want to break your internal users, but I'd like to get moving with this patch since it has good chances of being difficult to rebase, so keeping it around for a while is quite risky.

[miyuki]

Hi. It looks like this change broke the following code:

#include <tuple>

void test() {
    using pair_t = std::pair<int, char>;
    constexpr std::tuple<long, long> t(pair_t(0, 'a'));
}

<source>:5:38: error: constexpr variable 't' must be initialized by a constant expression
    constexpr std::tuple<long, long> t(pair_t(0, 'a'));
                                     ^~~~~~~~~~~~~~~~~
<source>:5:38: note: non-constexpr constructor 'tuple<int, char, _And, 0>' cannot be used in a constant expression
/opt/compiler-explorer/clang-trunk-20210428/bin/../include/c++/v1/tuple:900:5: note: declared here
    tuple(pair<_Up1, _Up2>&& __p)
    ^
1 error generated.
Compiler returned: 1

https://godbolt.org/z/6sd9TTMrq

Could you please have a look into it?

[rupprecht]

We're seeing some issues with this patch manifested as complicated tuple expressions that hit compiler limits with template depth. A bit of a synthetic example, but here it is: https://godbolt.org/z/TzvzWhYYs

template <size_t... I>
void MakeFoo(std::index_sequence<I...>) {
  auto tup = std::make_tuple(I...);
  (void)tup;
}

void Broken() {
  // At trunk, when this is >= 508, we see:
  // fatal error: recursive template instantiation exceeded maximum depth of
  // 1024

  auto seq = std::make_index_sequence<508>{};
  MakeFoo(seq);
}

Prior to this patch, the breaking point is at 1021. Interestingly though, this didn't reproduce in the latest clang/llvm 12 release on godbolt. I did a second bisection to D50106 as the point where std::make_index_sequence<1021>{} newly fails.

[EricWF]

In general this removes a bunch of carefully constructed SFINAE meant to improve compile times.
I'll look into getting that back.

libcxx/include/tuple

877

Why can't we use alias templates rather than instantiating a big type here?

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

52

What's going on here? Why are there different answers depending on the dialect?

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

1

This tested template depth. And this patch broke large tuples. It should have been rewritten in some other form.

We need to reallow big tuples and add another test.

1

It's worth noting that this was a conforming extension. Because array supports the tuple-like protocol. I'm disappointed this was removed.

[EricWF]

I'm working to see if I can fix forward the template depth and constexpr
issues, but I would appreciate some help from @ldionne as the original
author.

[ldionne]

In D96523#2729663, @EricWF wrote:

I'm working to see if I can fix forward the template depth and constexpr
issues, but I would appreciate some help from @ldionne as the original
author.

I'm working on the constexpr issue right now. I only just saw this.

In general this removes a bunch of carefully constructed SFINAE meant to improve compile times.

The SFINAE in this patch is also meant to instantiate as few templates as possible when it can. After looking into it, I think the problem is that our implementation of _And is a bit naive, it shouldn't recurse as much. I'm pretty sure that'll solve the problem.

libcxx/include/tuple

877

Cause we're hiding the instantiation of the _And behind the struct instantiation, such that when e.g. _BoolConstant<sizeof...(_Tp) == 2> is false below, we don't instantiate anything. Mentioning a template specialization is cheap when you don't actually instantiate it.

[ldionne]

This is the fix for the constexpr issue:

commit 3b8ab30ed526b15c3f82c61bb9476606db6f1630
Author: Louis Dionne <[e-mail]>
Date:   Fri Apr 30 15:52:26 2021 -0400

    [libc++] Fix constexpr-ness of std::tuple's constructor

    Mentioned in https://reviews.llvm.org/D96523.

I'm also going to overhaul all the tests as a follow-up, but I wanted to get the fix out the door ASAP.

Now I'll look into the recursion depth issue.

[rupprecht]

Another issue we're seeing is interactions between std::any and gmock -- I'll see if I can reduce it to something w/o the gmock dependency.

class X {
  // D96523 fixes this:
  // MOCK_METHOD(void, Func1, (const std::any&));
  // D96523 breaks this:
  MOCK_METHOD(void, Func2, (const std::any&, int));
};

(or: https://www.godbolt.org/z/454e8Mznx)

I don't know yet if this is an issue with libc++ or a misuse of libc++ by gtest.

[ldionne]

This should fix the instantiation depth issue: https://reviews.llvm.org/D101661

@rupprecht Please ping me once you've reduced to something that doesn't involve Gmock and I'll look into it.

[rupprecht]

In D96523#2730264, @ldionne wrote:

This should fix the instantiation depth issue: https://reviews.llvm.org/D101661

@rupprecht Please ping me once you've reduced to something that doesn't involve Gmock and I'll look into it.

#include <any>
#include <tuple>

template <typename a>
class b {
  b(a);
};

template <typename>
struct c;
template <typename m, typename... d>
struct c<m(d...)> {
  using e = std::tuple<b<d>...>;
};

template <typename>
class f;

template <typename g>
class h {
  typename c<g>::e i;
};

template <typename m, typename... d>
struct f<m(d...)> {
  h<m(d...)> n();
};

class j {
  void k() { l.n(); }
  // Note: D96523 breaks this:
  f<void(std::any, int)> l;
  // Note: D96523 fixes this:
  // f<void(std::any)> l;
};

https://www.godbolt.org/z/4W8b1G7Yd

[• Quuxplusone]

Further reduced, fwiw: https://www.godbolt.org/z/4f1xnWq59

[ldionne]

In D96523#2730953, @Quuxplusone wrote:

Further reduced, fwiw: https://www.godbolt.org/z/4f1xnWq59

Thanks a lot for the reduction. Here it is further reduced without libc++'s std::tuple or std::any: https://www.godbolt.org/z/5r7schPMK

If you add the static_assert, the error goes away. That is very suspicious to me. I know how to "fix" it from the standard library side, but it seems like we should take that to Clang folks too. WDYT?

[ldionne]

The bug with std::any should be addressed by https://reviews.llvm.org/D101770. As I said, I think it's a compiler bug, but https://reviews.llvm.org/D101770 should work around it.

[rupprecht]

I think we're all good now. The template depth fix in 84f0bb619507caf7c4809400138dae1da578282a actually exposed a long standing clang bug which needed another fix in 6bbfa0fd408e81055c360c2e059554dd76fd7f09. Thanks for the quick followups!

[ychen]

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

52

Yeah, I'm curious too. GCC/libstdc++ seems to have the same behavior.

[• Quuxplusone]

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

52

https://godbolt.org/z/vGPYqEnfo
C++14 sets bar to tuple<Explicit>{ Explicit(42) } by converting d's int(42) using Explicit(int) and then building a tuple out of that.
C++17 sets bar to tuple<Explicit>{} by invoking d.operator tuple<Explicit>().
Really, this test should be verifying std::get<0>(bar) == [42 or 0] as well as count == [1 or 2].

I don't know exactly why C++14 hadn't been considering the conversion operator, or why C++17 started considering it, but I would assume that the reason is buried somewhere in the changes due to LWG2312, LWG2419, LWG2549. (Actually I'm very puzzled as to why the conversion operator wouldn't have been the obviously best match in C++14. Did C++17 change something in the core language about conversion operators, completely independent of tuple?)

Note that in October 2021, tuple's constructor constraints changed again due to LWG3121, LWG3155. I assume libc++ has not yet implemented those changes; I don't know if they'll affect this test case again at all.

[ychen]

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

52

After some digging, this seems from rG67ef14fe486e169f937737672d68. But still no idea what is changed in the standard text.

[• Quuxplusone]

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

52

Perhaps this is relevant:
https://godbolt.org/z/hKbncT4zf
GCC 7+ and Clang 6+ agree that in C++17 this is legal, but in C++14 it's not.

struct Widget { Widget(const Widget&) = delete; };
struct From { operator Widget() const; };
~~~
From f;
(void)Widget(f);

C++14 seems to treat this as a call to some constructor of Widget (namely, the copy constructor, with an argument of f.operator Widget()); C++17 "more rightly" treats it as a request to produce a Widget by whatever means, such as just calling operator Widget alone. ...Or actually, instead, maybe C++17 is still treating this as Widget(f.operator Widget()); it's just that now Widget(some-prvalue-widget) is a no-op instead of trying to call the copy constructor. I wonder if there's any way to observe that difference, or if it's just philosophical at this point.

[ychen]

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

52

It seems rG67ef14fe486e169f937737672d68 is for https://wg21.link/cwg2327.

libcxx/docs/ReleaseNotes.rst

 New Features
 ------------
 
 - ...
 
 API Changes
 -----------
 
-- ...
+- There has been several changes in the tuple constructors provided by libc++.
+  Those changes were made as part of an effort to regularize libc++'s tuple
+  implementation, which contained several subtle bugs due to these extensions.
+  If you notice a build breakage when initializing a tuple, make sure you
+  properly initialize all the tuple elements - this is probably the culprit.
+
+  In particular, the extension allowing tuples to be constructed from fewer
+  elements than the number of elements in the tuple (in which case the remaining
+  elements would be default-constructed) has been removed. See https://godbolt.org/z/sqozjd.
+
+  Also, the extension allowing a tuple to be constructed from an array has been
+  removed. See https://godbolt.org/z/5esqbW.

libcxx/docs/UsingLibcxx.rst

**_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS**:
   build of libc++ which does not export any symbols, which can be useful when
   building statically for inclusion into another library.
 
 **_LIBCPP_DISABLE_EXTERN_TEMPLATE**:
   This macro is used to disable extern template declarations in the libc++
   headers. The intended use case is for clients who wish to use the libc++
   headers without taking a dependency on the libc++ library itself.
 
-**_LIBCPP_ENABLE_TUPLE_IMPLICIT_REDUCED_ARITY_EXTENSION**:
-  This macro is used to re-enable an extension in `std::tuple` which allowed
-  it to be implicitly constructed from fewer initializers than contained
-  elements. Elements without an initializer are default constructed. For example:
-
-  .. code-block:: cpp
-
-    std::tuple<std::string, int, std::error_code> foo() {
-      return {"hello world", 42}; // default constructs error_code
-    }
-
-
-  Since libc++ 4.0 this extension has been disabled by default. This macro
-  may be defined to re-enable it in order to support existing code that depends
-  on the extension. New use of this extension should be discouraged.
-  See `PR 27374 <https://llvm.org/PR27374>`_ for more information.
-
-  Note: The "reduced-arity-initialization" extension is still offered but only
-  for explicit conversions. Example:
-
-  .. code-block:: cpp
-
-    auto foo() {
-      using Tup = std::tuple<std::string, int, std::error_code>;
-      return Tup{"hello world", 42}; // explicit constructor called. OK.
-    }
-
 **_LIBCPP_DISABLE_ADDITIONAL_DIAGNOSTICS**:
   This macro disables the additional diagnostics generated by libc++ using the
   `diagnose_if` attribute. These additional diagnostics include checks for:
 
     * Giving `set`, `map`, `multiset`, `multimap` and their `unordered_`
       counterparts a comparator which is not const callable.
     * Giving an unordered associative container a hasher that is not const
       callable.

libcxx/include/tuple

 
 template <class ..._Tp>
 class _LIBCPP_TEMPLATE_VIS tuple
 {
     typedef __tuple_impl<typename __make_tuple_indices<sizeof...(_Tp)>::type, _Tp...> _BaseT;
 
     _BaseT __base_;
 
-#if defined(_LIBCPP_ENABLE_TUPLE_IMPLICIT_REDUCED_ARITY_EXTENSION)
-    static constexpr bool _EnableImplicitReducedArityExtension = true;
-#else
-    static constexpr bool _EnableImplicitReducedArityExtension = false;
-#endif
-
-    template <class ..._Args>
-    struct _PackExpandsToThisTuple : false_type {};
-
-    template <class _Arg>
-    struct _PackExpandsToThisTuple<_Arg>
-        : is_same<typename __uncvref<_Arg>::type, tuple> {};
-
-    template <bool _MaybeEnable, class _Dummy = void>
-    struct _CheckArgsConstructor : __check_tuple_constructor_fail {};
-
-    template <class _Dummy>
-    struct _CheckArgsConstructor<true, _Dummy>
-    {
-        template <int&...>
-        static constexpr bool __enable_implicit_default() {
-           return __all<__is_implicitly_default_constructible<_Tp>::value... >::value;
-        }
-
-        template <int&...>
-        static constexpr bool __enable_explicit_default() {
-            return
-                __all<is_default_constructible<_Tp>::value...>::value &&
-                !__enable_implicit_default< >();
-        }
-
-
-        template <class ..._Args>
-        static constexpr bool __enable_explicit() {
-            return
-                __tuple_constructible<
-                    tuple<_Args...>,
-                    typename __make_tuple_types<tuple,
-                             sizeof...(_Args) < sizeof...(_Tp) ?
-                                 sizeof...(_Args) :
-                                 sizeof...(_Tp)>::type
-                >::value &&
-                !__tuple_convertible<
-                    tuple<_Args...>,
-                    typename __make_tuple_types<tuple,
-                             sizeof...(_Args) < sizeof...(_Tp) ?
-                                 sizeof...(_Args) :
-                                 sizeof...(_Tp)>::type
-                >::value &&
-                __all_default_constructible<
-                    typename __make_tuple_types<tuple, sizeof...(_Tp),
-                             sizeof...(_Args) < sizeof...(_Tp) ?
-                                 sizeof...(_Args) :
-                                 sizeof...(_Tp)>::type
-                >::value;
-        }
-
-        template <class ..._Args>
-        static constexpr bool __enable_implicit() {
-            return
-               __tuple_constructible<
-                    tuple<_Args...>,
-                    typename __make_tuple_types<tuple,
-                             sizeof...(_Args) < sizeof...(_Tp) ?
-                                 sizeof...(_Args) :
-                                 sizeof...(_Tp)>::type
-                >::value &&
-                __tuple_convertible<
-                    tuple<_Args...>,
-                    typename __make_tuple_types<tuple,
-                             sizeof...(_Args) < sizeof...(_Tp) ?
-                                 sizeof...(_Args) :
-                                 sizeof...(_Tp)>::type
-                >::value &&
-                __all_default_constructible<
-                    typename __make_tuple_types<tuple, sizeof...(_Tp),
-                             sizeof...(_Args) < sizeof...(_Tp) ?
-                                 sizeof...(_Args) :
-                                 sizeof...(_Tp)>::type
-                >::value;
-        }
-    };
-
-    template <bool _MaybeEnable,
-              bool = sizeof...(_Tp) == 1,
-              class _Dummy = void>
-    struct _CheckTupleLikeConstructor : __check_tuple_constructor_fail {};
-
-    template <class _Dummy>
-    struct _CheckTupleLikeConstructor<true, false, _Dummy>
-    {
-        template <class _Tuple>
-        static constexpr bool __enable_implicit() {
-            return __tuple_constructible<_Tuple, tuple>::value
-                && __tuple_convertible<_Tuple, tuple>::value;
-        }
-
-        template <class _Tuple>
-        static constexpr bool __enable_explicit() {
-            return __tuple_constructible<_Tuple, tuple>::value
-               && !__tuple_convertible<_Tuple, tuple>::value;
-        }
-    };
-
-    template <class _Dummy>
-    struct _CheckTupleLikeConstructor<true, true, _Dummy>
-    {
-        // This trait is used to disable the tuple-like constructor when
-        // the UTypes... constructor should be selected instead.
-        // See LWG issue #2549.
-        template <class _Tuple>
-        using _PreferTupleLikeConstructor = _Or<
-            // Don't attempt the two checks below if the tuple we are given
-            // has the same type as this tuple.
-            _IsSame<__uncvref_t<_Tuple>, tuple>,
-            _Lazy<_And,
-                _Not<is_constructible<_Tp..., _Tuple>>,
-                _Not<is_convertible<_Tuple, _Tp...>>
-            >
-        >;
-
-        template <class _Tuple>
-        static constexpr bool __enable_implicit() {
-            return _And<
-                __tuple_constructible<_Tuple, tuple>,
-                __tuple_convertible<_Tuple, tuple>,
-                _PreferTupleLikeConstructor<_Tuple>
-            >::value;
-        }
-
-        template <class _Tuple>
-        static constexpr bool __enable_explicit() {
-            return _And<
-                __tuple_constructible<_Tuple, tuple>,
-                _PreferTupleLikeConstructor<_Tuple>,
-                _Not<__tuple_convertible<_Tuple, tuple>>
-            >::value;
-        }
-    };
-
-    template <class _Tuple, bool _DisableIfLValue>
-    using _EnableImplicitTupleLikeConstructor = _EnableIf<
-                         _CheckTupleLikeConstructor<
-                             __tuple_like_with_size<_Tuple, sizeof...(_Tp)>::value
-                             && !_PackExpandsToThisTuple<_Tuple>::value
-                             && (!is_lvalue_reference<_Tuple>::value || !_DisableIfLValue)
-                         >::template __enable_implicit<_Tuple>(),
-                         bool
-                      >;
-
-    template <class _Tuple, bool _DisableIfLValue>
-    using _EnableExplicitTupleLikeConstructor = _EnableIf<
-                         _CheckTupleLikeConstructor<
-                             __tuple_like_with_size<_Tuple, sizeof...(_Tp)>::value
-                             && !_PackExpandsToThisTuple<_Tuple>::value
-                             && (!is_lvalue_reference<_Tuple>::value || !_DisableIfLValue)
-                         >::template __enable_explicit<_Tuple>(),
-                         bool
-                      >;
     template <size_t _Jp, class ..._Up> friend _LIBCPP_CONSTEXPR_AFTER_CXX11
         typename tuple_element<_Jp, tuple<_Up...> >::type& get(tuple<_Up...>&) _NOEXCEPT;
     template <size_t _Jp, class ..._Up> friend _LIBCPP_CONSTEXPR_AFTER_CXX11
         const typename tuple_element<_Jp, tuple<_Up...> >::type& get(const tuple<_Up...>&) _NOEXCEPT;
     template <size_t _Jp, class ..._Up> friend _LIBCPP_CONSTEXPR_AFTER_CXX11
         typename tuple_element<_Jp, tuple<_Up...> >::type&& get(tuple<_Up...>&&) _NOEXCEPT;
     template <size_t _Jp, class ..._Up> friend _LIBCPP_CONSTEXPR_AFTER_CXX11
         const typename tuple_element<_Jp, tuple<_Up...> >::type&& get(const tuple<_Up...>&&) _NOEXCEPT;
 public:
+    // [tuple.cnstr]
 
-    template <bool _Dummy = true, _EnableIf<
-        _CheckArgsConstructor<_Dummy>::__enable_implicit_default()
-    , void*> = nullptr>
+    // tuple() constructors (including allocator_arg_t variants)
+    template <template<class...> class _IsImpDefault = __is_implicitly_default_constructible, _EnableIf<
+        _And<
+            _IsImpDefault<_Tp>... // explicit check
+        >::value
+    , int> = 0>
     _LIBCPP_INLINE_VISIBILITY constexpr
     tuple()
-        _NOEXCEPT_(__all<is_nothrow_default_constructible<_Tp>::value...>::value) {}
-
-    template <bool _Dummy = true, _EnableIf<
-        _CheckArgsConstructor<_Dummy>::__enable_explicit_default()
-    , void*> = nullptr>
-    explicit _LIBCPP_INLINE_VISIBILITY constexpr
-    tuple()
-        _NOEXCEPT_(__all<is_nothrow_default_constructible<_Tp>::value...>::value) {}
+        _NOEXCEPT_(_And<is_nothrow_default_constructible<_Tp>...>::value)
+    { }
 
-    tuple(tuple const&) = default;
-    tuple(tuple&&) = default;
+    template <template<class...> class _IsImpDefault = __is_implicitly_default_constructible,
+              template<class...> class _IsDefault = is_default_constructible, _EnableIf<
+        _And<
+            _IsDefault<_Tp>...,
+            _Not<_Lazy<_And, _IsImpDefault<_Tp>...> > // explicit check
+        >::value
+    , int> = 0>
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
+    explicit tuple()
+        _NOEXCEPT_(_And<is_nothrow_default_constructible<_Tp>...>::value)
+    { }
 
-    template <class _AllocArgT, class _Alloc, _EnableIf<
-             _CheckArgsConstructor<_IsSame<allocator_arg_t, _AllocArgT>::value >::__enable_implicit_default()
-      , void*> = nullptr
-    >
+    template <class _Alloc, template<class...> class _IsImpDefault = __is_implicitly_default_constructible, _EnableIf<
+        _And<
+            _IsImpDefault<_Tp>... // explicit check
+        >::value
+    , int> = 0>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
-    tuple(_AllocArgT, _Alloc const& __a)
+    tuple(allocator_arg_t, _Alloc const& __a)
       : __base_(allocator_arg_t(), __a,
                     __tuple_indices<>(), __tuple_types<>(),
                     typename __make_tuple_indices<sizeof...(_Tp), 0>::type(),
                     __tuple_types<_Tp...>()) {}
 
-    template <class _AllocArgT, class _Alloc, _EnableIf<
-             _CheckArgsConstructor<_IsSame<allocator_arg_t, _AllocArgT>::value>::__enable_explicit_default()
-      , void*> = nullptr
-    >
-    explicit _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
-    tuple(_AllocArgT, _Alloc const& __a)
+    template <class _Alloc,
+              template<class...> class _IsImpDefault = __is_implicitly_default_constructible,
+              template<class...> class _IsDefault = is_default_constructible, _EnableIf<
+        _And<
+            _IsDefault<_Tp>...,
+            _Not<_Lazy<_And, _IsImpDefault<_Tp>...> > // explicit check
+        >::value
+    , int> = 0>
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
+    explicit tuple(allocator_arg_t, _Alloc const& __a)
       : __base_(allocator_arg_t(), __a,
                     __tuple_indices<>(), __tuple_types<>(),
                     typename __make_tuple_indices<sizeof...(_Tp), 0>::type(),
                     __tuple_types<_Tp...>()) {}
 
-    template <bool _Dummy = true,
-              typename enable_if
-                      <
-                         _CheckArgsConstructor<
-                            _Dummy
-                         >::template __enable_implicit<_Tp const&...>(),
-                         bool
-                      >::type = false
-        >
+    // tuple(const T&...) constructors (including allocator_arg_t variants)
+    template <template<class...> class _And = _And, _EnableIf<
+        _And<
+            _BoolConstant<sizeof...(_Tp) >= 1>,
+            is_copy_constructible<_Tp>...,
+            is_convertible<const _Tp&, _Tp>... // explicit check
+        >::value
+    , int> = 0>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
-    tuple(const _Tp& ... __t) _NOEXCEPT_((__all<is_nothrow_copy_constructible<_Tp>::value...>::value))
+    tuple(const _Tp& ... __t)
+        _NOEXCEPT_(_And<is_nothrow_copy_constructible<_Tp>...>::value)
         : __base_(typename __make_tuple_indices<sizeof...(_Tp)>::type(),
                 typename __make_tuple_types<tuple, sizeof...(_Tp)>::type(),
                 typename __make_tuple_indices<0>::type(),
                 typename __make_tuple_types<tuple, 0>::type(),
                 __t...
                ) {}
 
-    template <bool _Dummy = true,
-              typename enable_if
-                      <
-                         _CheckArgsConstructor<
-                            _Dummy
-                         >::template __enable_explicit<_Tp const&...>(),
-                         bool
-                      >::type = false
-        >
+    template <template<class...> class _And = _And, _EnableIf<
+        _And<
+            _BoolConstant<sizeof...(_Tp) >= 1>,
+            is_copy_constructible<_Tp>...,
+            _Not<_Lazy<_And, is_convertible<const _Tp&, _Tp>...> > // explicit check
+        >::value
+    , int> = 0>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
-    explicit tuple(const _Tp& ... __t) _NOEXCEPT_((__all<is_nothrow_copy_constructible<_Tp>::value...>::value))
+    explicit tuple(const _Tp& ... __t)
+        _NOEXCEPT_(_And<is_nothrow_copy_constructible<_Tp>...>::value)
         : __base_(typename __make_tuple_indices<sizeof...(_Tp)>::type(),
                 typename __make_tuple_types<tuple, sizeof...(_Tp)>::type(),
                 typename __make_tuple_indices<0>::type(),
                 typename __make_tuple_types<tuple, 0>::type(),
                 __t...
                ) {}
 
-    template <class _Alloc, bool _Dummy = true,
-              typename enable_if
-                      <
-                         _CheckArgsConstructor<
-                            _Dummy
-                         >::template __enable_implicit<_Tp const&...>(),
-                         bool
-                      >::type = false
-        >
-      _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
-      tuple(allocator_arg_t, const _Alloc& __a, const _Tp& ... __t)
+    template <class _Alloc, template<class...> class _And = _And, _EnableIf<
+        _And<
+            _BoolConstant<sizeof...(_Tp) >= 1>,
+            is_copy_constructible<_Tp>...,
+            is_convertible<const _Tp&, _Tp>... // explicit check
+        >::value
+    , int> = 0>
         : __base_(allocator_arg_t(), __a,
                 typename __make_tuple_indices<sizeof...(_Tp)>::type(),
                 typename __make_tuple_types<tuple, sizeof...(_Tp)>::type(),
                 typename __make_tuple_indices<0>::type(),
                 typename __make_tuple_types<tuple, 0>::type(),
                 __t...
                ) {}
 
-    template <class _Alloc, bool _Dummy = true,
-              typename enable_if
-                      <
-                         _CheckArgsConstructor<
-                            _Dummy
-                         >::template __enable_explicit<_Tp const&...>(),
-                         bool
-                      >::type = false
-        >
-      _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
-      explicit
-      tuple(allocator_arg_t, const _Alloc& __a, const _Tp& ... __t)
+    template <class _Alloc, template<class...> class _And = _And, _EnableIf<
+        _And<
+            _BoolConstant<sizeof...(_Tp) >= 1>,
+            is_copy_constructible<_Tp>...,
+            _Not<_Lazy<_And, is_convertible<const _Tp&, _Tp>...> > // explicit check
+        >::value
+    , int> = 0>
+    explicit tuple(allocator_arg_t, const _Alloc& __a, const _Tp& ... __t)
         : __base_(allocator_arg_t(), __a,
                 typename __make_tuple_indices<sizeof...(_Tp)>::type(),
                 typename __make_tuple_types<tuple, sizeof...(_Tp)>::type(),
                 typename __make_tuple_indices<0>::type(),
                 typename __make_tuple_types<tuple, 0>::type(),
                 __t...
                ) {}
 
-    template <class ..._Up,
-              bool _PackIsTuple = _PackExpandsToThisTuple<_Up...>::value,
-              typename enable_if
-                      <
-                         _CheckArgsConstructor<
-                             sizeof...(_Up) == sizeof...(_Tp)
-                             && !_PackIsTuple
-                         >::template __enable_implicit<_Up...>() ||
-                        _CheckArgsConstructor<
-                            _EnableImplicitReducedArityExtension
-                            && sizeof...(_Up) < sizeof...(_Tp)
-                            && !_PackIsTuple
-                         >::template __enable_implicit<_Up...>(),
-                         bool
-                      >::type = false
-             >
-        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
-        tuple(_Up&&... __u)
-            _NOEXCEPT_((
-                is_nothrow_constructible<_BaseT,
-                    typename __make_tuple_indices<sizeof...(_Up)>::type,
-                    typename __make_tuple_types<tuple, sizeof...(_Up)>::type,
-                    typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type,
-                    typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type,
-                    _Up...
-                >::value
-            ))
-            : __base_(typename __make_tuple_indices<sizeof...(_Up)>::type(),
+    // tuple(U&& ...) constructors (including allocator_arg_t variants)
+    template <class ..._Up> struct _IsThisTuple : false_type { };
+    template <class _Up> struct _IsThisTuple<_Up> : is_same<__uncvref_t<_Up>, tuple> { };
+
+    template <class ..._Up>
+    struct _EnableUTypesCtor : _And<
+        _BoolConstant<sizeof...(_Tp) >= 1>,
+        _Not<_IsThisTuple<_Up...> >, // extension to allow mis-behaved user constructors
+        is_constructible<_Tp, _Up>...
+    > { };
+
+    template <class ..._Up, _EnableIf<
+        _And<
+            _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
+            _EnableUTypesCtor<_Up...>,
+            is_convertible<_Up, _Tp>... // explicit check
+        >::value
+    , int> = 0>
+        _NOEXCEPT_((_And<is_nothrow_constructible<_Tp, _Up>...>::value))
                     typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
                     typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
                     typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
                     _VSTD::forward<_Up>(__u)...) {}
 
-    template <class ..._Up,
-              typename enable_if
-                      <
-                         _CheckArgsConstructor<
-                             sizeof...(_Up) <= sizeof...(_Tp)
-                             && !_PackExpandsToThisTuple<_Up...>::value
-                         >::template __enable_explicit<_Up...>() ||
-                         _CheckArgsConstructor<
-                            !_EnableImplicitReducedArityExtension
-                            && sizeof...(_Up) < sizeof...(_Tp)
-                            && !_PackExpandsToThisTuple<_Up...>::value
-                         >::template __enable_implicit<_Up...>(),
-                         bool
-                      >::type = false
-             >
-        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
-        explicit
-        tuple(_Up&&... __u)
-            _NOEXCEPT_((
-                is_nothrow_constructible<_BaseT,
-                    typename __make_tuple_indices<sizeof...(_Up)>::type,
-                    typename __make_tuple_types<tuple, sizeof...(_Up)>::type,
-                    typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type,
-                    typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type,
-                    _Up...
-                >::value
-            ))
-            : __base_(typename __make_tuple_indices<sizeof...(_Up)>::type(),
+    template <class ..._Up, _EnableIf<
+        _And<
+            _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
+            _EnableUTypesCtor<_Up...>,
+            _Not<_Lazy<_And, is_convertible<_Up, _Tp>...> > // explicit check
+    , int> = 0>
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
+    explicit tuple(_Up&&... __u)
+        _NOEXCEPT_((_And<is_nothrow_constructible<_Tp, _Up>...>::value))
                     typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
                     typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
                     typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
                     _VSTD::forward<_Up>(__u)...) {}
 
-    template <class _Alloc, class ..._Up,
-              typename enable_if
-                      <
-                         _CheckArgsConstructor<
-                             sizeof...(_Up) == sizeof...(_Tp) &&
-                             !_PackExpandsToThisTuple<_Up...>::value
-                         >::template __enable_implicit<_Up...>(),
-                         bool
-                      >::type = false
-             >
-        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
-        tuple(allocator_arg_t, const _Alloc& __a, _Up&&... __u)
-            : __base_(allocator_arg_t(), __a,
+    template <class _Alloc, class ..._Up, _EnableIf<
+        _And<
+            _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
+            _EnableUTypesCtor<_Up...>,
+            is_convertible<_Up, _Tp>... // explicit check
+        >::value
+    , int> = 0>
                     typename __make_tuple_indices<sizeof...(_Up)>::type(),
                     typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
                     typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
                     typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
                     _VSTD::forward<_Up>(__u)...) {}
 
-    template <class _Alloc, class ..._Up,
-              typename enable_if
-                      <
-                         _CheckArgsConstructor<
-                             sizeof...(_Up) == sizeof...(_Tp) &&
-                             !_PackExpandsToThisTuple<_Up...>::value
-                         >::template __enable_explicit<_Up...>(),
-                         bool
-                      >::type = false
-             >
-        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
-        explicit
-        tuple(allocator_arg_t, const _Alloc& __a, _Up&&... __u)
-            : __base_(allocator_arg_t(), __a,
+    template <class _Alloc, class ..._Up, _EnableIf<
+        _And<
+            _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
+            _EnableUTypesCtor<_Up...>,
+            _Not<_Lazy<_And, is_convertible<_Up, _Tp>...> > // explicit check
+        >::value
+    , int> = 0>
+    explicit tuple(allocator_arg_t, const _Alloc& __a, _Up&&... __u)
                     typename __make_tuple_indices<sizeof...(_Up)>::type(),
                     typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
                     typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
                     typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
                     _VSTD::forward<_Up>(__u)...) {}
 
-    template <class _Tuple, _EnableImplicitTupleLikeConstructor<_Tuple, true> = false>
-        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
-        tuple(_Tuple&& __t) _NOEXCEPT_((is_nothrow_constructible<_BaseT, _Tuple>::value))
-            : __base_(_VSTD::forward<_Tuple>(__t)) {}
+    // 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, _EnableIf<
+        _And<is_copy_constructible<_Tp>...>::value
+    , int> = 0>
+    tuple(allocator_arg_t, const _Alloc& __alloc, const tuple& __t)
+        : __base_(allocator_arg_t(), __alloc, __t)
+    { }
+
+    template <class _Alloc, template<class...> class _And = _And, _EnableIf<
+        _And<is_move_constructible<_Tp>...>::value
+    , int> = 0>
+    tuple(allocator_arg_t, const _Alloc& __alloc, tuple&& __t)
+        : __base_(allocator_arg_t(), __alloc, _VSTD::move(__t))
+    { }
+
+    // tuple(const tuple<U...>&) constructors (including allocator_arg_t variants)
+    template <class ..._Up>
+    struct _EnableCopyFromOtherTuple : _And<
+        _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_same<_Tp, _Up> >...,
+                _Not<is_convertible<const tuple<_Up>&, _Tp> >...,
+                _Not<is_constructible<_Tp, const tuple<_Up>&> >...
+            >
+        >,
+        is_constructible<_Tp, const _Up&>...
+    > { };
+
+    template <class ..._Up, _EnableIf<
+        _And<
+            _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
+            _EnableCopyFromOtherTuple<_Up...>,
+            is_convertible<const _Up&, _Tp>... // explicit check
+        >::value
+    , int> = 0>
+    tuple(const tuple<_Up...>& __t)
+        _NOEXCEPT_((_And<is_nothrow_constructible<_Tp, const _Up&>...>::value))
+        : __base_(__t)
+    { }
 
-    template <class _Tuple, _EnableImplicitTupleLikeConstructor<const _Tuple&, false> = false>
-        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
-        tuple(const _Tuple& __t) _NOEXCEPT_((is_nothrow_constructible<_BaseT, const _Tuple&>::value))
-            : __base_(__t) {}
-    template <class _Tuple, _EnableExplicitTupleLikeConstructor<_Tuple, true> = false>
-        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
-        explicit
-        tuple(_Tuple&& __t) _NOEXCEPT_((is_nothrow_constructible<_BaseT, _Tuple>::value))
-            : __base_(_VSTD::forward<_Tuple>(__t)) {}
+    template <class ..._Up, _EnableIf<
+        _And<
+            _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
+            _EnableCopyFromOtherTuple<_Up...>,
+            _Not<_Lazy<_And, is_convertible<const _Up&, _Tp>...> > // explicit check
+        >::value
+    , int> = 0>
+    explicit tuple(const tuple<_Up...>& __t)
+        _NOEXCEPT_((_And<is_nothrow_constructible<_Tp, const _Up&>...>::value))
+        : __base_(__t)
+    { }
+
+    template <class ..._Up, class _Alloc, _EnableIf<
+        _And<
+            _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
+            _EnableCopyFromOtherTuple<_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, _EnableIf<
+        _And<
+            _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
+            _EnableCopyFromOtherTuple<_Up...>,
+            _Not<_Lazy<_And, is_convertible<const _Up&, _Tp>...> > // explicit check
+        >::value
+    , int> = 0>
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
+    explicit tuple(allocator_arg_t, const _Alloc& __a, const tuple<_Up...>& __t)
+        : __base_(allocator_arg_t(), __a, __t)
+    { }
+
+    // tuple(tuple<U...>&&) constructors (including allocator_arg_t variants)
+    template <class ..._Up>
+    struct _EnableMoveFromOtherTuple : _And<
+        _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_same<_Tp, _Up> >...,
+                _Not<is_convertible<tuple<_Up>, _Tp> >...,
+                _Not<is_constructible<_Tp, tuple<_Up> > >...
+            >
+        >,
+        is_constructible<_Tp, _Up>...
+    > { };
+
+    template <class ..._Up, _EnableIf<
+        _And<
+            _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
+            _EnableMoveFromOtherTuple<_Up...>,
+            is_convertible<_Up, _Tp>... // explicit check
+        >::value
+    , int> = 0>
+    tuple(tuple<_Up...>&& __t)
+        _NOEXCEPT_((_And<is_nothrow_constructible<_Tp, _Up>...>::value))
+        : __base_(_VSTD::move(__t))
+    { }
 
-    template <class _Tuple, _EnableExplicitTupleLikeConstructor<const _Tuple&, false> = false>
-        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
-        explicit
-        tuple(const _Tuple& __t) _NOEXCEPT_((is_nothrow_constructible<_BaseT, const _Tuple&>::value))
-            : __base_(__t) {}
+    template <class ..._Up, _EnableIf<
+        _And<
+            _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
+            _EnableMoveFromOtherTuple<_Up...>,
+            _Not<_Lazy<_And, is_convertible<_Up, _Tp>...> > // explicit check
+        >::value
+    , int> = 0>
+    explicit tuple(tuple<_Up...>&& __t)
+        _NOEXCEPT_((_And<is_nothrow_constructible<_Tp, _Up>...>::value))
+        : __base_(_VSTD::move(__t))
+    { }
 
-    template <class _Alloc, class _Tuple,
-              typename enable_if
-                      <
-                         _CheckTupleLikeConstructor<
-                             __tuple_like_with_size<_Tuple, sizeof...(_Tp)>::value
-                         >::template __enable_implicit<_Tuple>(),
-                         bool
-                      >::type = false
-             >
-        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
-        tuple(allocator_arg_t, const _Alloc& __a, _Tuple&& __t)
-            : __base_(allocator_arg_t(), __a, _VSTD::forward<_Tuple>(__t)) {}
+    template <class _Alloc, class ..._Up, _EnableIf<
+        _And<
+            _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
+            _EnableMoveFromOtherTuple<_Up...>,
+            is_convertible<_Up, _Tp>... // explicit check
+        >::value
+    , int> = 0>
+    tuple(allocator_arg_t, const _Alloc& __a, tuple<_Up...>&& __t)
+        : __base_(allocator_arg_t(), __a, _VSTD::move(__t))
+    { }
 
-    template <class _Alloc, class _Tuple,
-              typename enable_if
-                      <
-                         _CheckTupleLikeConstructor<
-                             __tuple_like_with_size<_Tuple, sizeof...(_Tp)>::value
-                         >::template __enable_explicit<_Tuple>(),
-                         bool
-                      >::type = false
-             >
-        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
-        explicit
-        tuple(allocator_arg_t, const _Alloc& __a, _Tuple&& __t)
-            : __base_(allocator_arg_t(), __a, _VSTD::forward<_Tuple>(__t)) {}
+    template <class _Alloc, class ..._Up, _EnableIf<
+        _And<
+            _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
+            _EnableMoveFromOtherTuple<_Up...>,
+            _Not<_Lazy<_And, is_convertible<_Up, _Tp>...> > // explicit check
+        >::value
+    , int> = 0>
+    explicit tuple(allocator_arg_t, const _Alloc& __a, tuple<_Up...>&& __t)
+        : __base_(allocator_arg_t(), __a, _VSTD::move(__t))
+    { }
+
+    // tuple(const pair<U1, U2>&) constructors (including allocator_arg_t variants)
+    template <class _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 <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 _Up1, class _Up2, template<class...> class _And = _And, _EnableIf<
+        _And<
+            _BoolConstant<sizeof...(_Tp) == 2>,
+            _EnableImplicitCopyFromPair<_Up1, _Up2, _Tp...>
+        >::value
+    , int> = 0>
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
+    tuple(const pair<_Up1, _Up2>& __p)
+        _NOEXCEPT_((_And<
+            is_nothrow_constructible<_FirstType<_Tp...>, const _Up1&>,
+            is_nothrow_constructible<_SecondType<_Tp...>, const _Up2&>
+        >::value))
+        : __base_(__p)
+    { }
+
+    template <class _Up1, class _Up2, template<class...> class _And = _And, _EnableIf<
+        _And<
+            _BoolConstant<sizeof...(_Tp) == 2>,
+            _EnableExplicitCopyFromPair<_Up1, _Up2, _Tp...>
+        >::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))
+        : __base_(__p)
+    { }
+
+    template <class _Alloc, class _Up1, class _Up2, template<class...> class _And = _And, _EnableIf<
+        _And<
+            _BoolConstant<sizeof...(_Tp) == 2>,
+            _EnableImplicitCopyFromPair<_Up1, _Up2, _Tp...>
+        >::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, _EnableIf<
+        _And<
+            _BoolConstant<sizeof...(_Tp) == 2>,
+            _EnableExplicitCopyFromPair<_Up1, _Up2, _Tp...>
+        >::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...> >
+    > { };
+
+    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 _Up1, class _Up2, template<class...> class _And = _And, _EnableIf<
+        _And<
+            _BoolConstant<sizeof...(_Tp) == 2>,
+            _EnableImplicitMoveFromPair<_Up1, _Up2, _Tp...>
+        >::value
+    , int> = 0>
+    _LIBCPP_INLINE_VISIBILITY
+    tuple(pair<_Up1, _Up2>&& __p)
+        _NOEXCEPT_((_And<
+            is_nothrow_constructible<_FirstType<_Tp...>, _Up1>,
+            is_nothrow_constructible<_SecondType<_Tp...>, _Up2>
+        >::value))
+        : __base_(_VSTD::move(__p))
+    { }
+
+    template <class _Up1, class _Up2, template<class...> class _And = _And, _EnableIf<
+        _And<
+            _BoolConstant<sizeof...(_Tp) == 2>,
+            _EnableExplicitMoveFromPair<_Up1, _Up2, _Tp...>
+        >::value
+    , int> = 0>
+    _LIBCPP_INLINE_VISIBILITY
+    explicit tuple(pair<_Up1, _Up2>&& __p)
+        _NOEXCEPT_((_And<
+            is_nothrow_constructible<_FirstType<_Tp...>, _Up1>,
+            is_nothrow_constructible<_SecondType<_Tp...>, _Up2>
+        >::value))
+        : __base_(_VSTD::move(__p))
+    { }
+
+    template <class _Alloc, class _Up1, class _Up2, template<class...> class _And = _And, _EnableIf<
+        _And<
+            _BoolConstant<sizeof...(_Tp) == 2>,
+            _EnableImplicitMoveFromPair<_Up1, _Up2, _Tp...>
+        >::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, _EnableIf<
+        _And<
+            _BoolConstant<sizeof...(_Tp) == 2>,
+            _EnableExplicitMoveFromPair<_Up1, _Up2, _Tp...>
+        >::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))
+    { }
 
     // [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());

libcxx/include/type_traits

 #ifndef _LIBCPP_CXX03_LANG
 // First of all, we can't implement this check in C++03 mode because the {}
 // default initialization syntax isn't valid.
 // Second, we implement the trait in a funny manner with two defaulted template
 // arguments to workaround Clang's PR43454.
 template <class _Tp>
 void __test_implicit_default_constructible(_Tp);
 
-template <class _Tp, class = void, bool = is_default_constructible<_Tp>::value>
+template <class _Tp, class = void, class = typename is_default_constructible<_Tp>::type>
 struct __is_implicitly_default_constructible
     : false_type
 { };
 
 template <class _Tp>
-struct __is_implicitly_default_constructible<_Tp, decltype(__test_implicit_default_constructible<_Tp const&>({})), true>
+struct __is_implicitly_default_constructible<_Tp, decltype(__test_implicit_default_constructible<_Tp const&>({})), true_type>
     : true_type
 { };
 
 template <class _Tp>
-struct __is_implicitly_default_constructible<_Tp, decltype(__test_implicit_default_constructible<_Tp const&>({})), false>
+struct __is_implicitly_default_constructible<_Tp, decltype(__test_implicit_default_constructible<_Tp const&>({})), false_type>
     : false_type
 { };
 #endif // !C++03
 
 // is_copy_constructible
 
 template <class _Tp>
 struct _LIBCPP_TEMPLATE_VIS is_copy_constructible

libcxx/test/libcxx/utilities/tuple/tuple.tuple/tuple.cnstr/disable_reduced_arity_initialization_extension.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// <tuple>
-
-// template <class... Types> class tuple;
-
-// template <class... UTypes>
-//   explicit tuple(UTypes&&... u);
-
-// UNSUPPORTED: c++03
-
-#include <tuple>
-#include <cassert>
-#include <type_traits>
-#include <string>
-#include <system_error>
-
-#include "test_macros.h"
-#include "test_convertible.h"
-#include "MoveOnly.h"
-
-#if defined(_LIBCPP_ENABLE_TUPLE_IMPLICIT_REDUCED_ARITY_EXTENSION)
-#error This macro should not be defined by default
-#endif
-
-struct NoDefault { NoDefault() = delete; };
-
-
-// Make sure the _Up... constructor SFINAEs out when the types that
-// are not explicitly initialized are not all default constructible.
-// Otherwise, std::is_constructible would return true but instantiating
-// the constructor would fail.
-void test_default_constructible_extension_sfinae()
-{
-    typedef MoveOnly MO;
-    typedef NoDefault ND;
-    {
-        typedef std::tuple<MO, ND> Tuple;
-        static_assert(!std::is_constructible<Tuple, MO>::value, "");
-        static_assert(std::is_constructible<Tuple, MO, ND>::value, "");
-        static_assert(test_convertible<Tuple, MO, ND>(), "");
-    }
-    {
-        typedef std::tuple<MO, MO, ND> Tuple;
-        static_assert(!std::is_constructible<Tuple, MO, MO>::value, "");
-        static_assert(std::is_constructible<Tuple, MO, MO, ND>::value, "");
-        static_assert(test_convertible<Tuple, MO, MO, ND>(), "");
-    }
-    {
-        // Same idea as above but with a nested tuple type.
-        typedef std::tuple<MO, ND> Tuple;
-        typedef std::tuple<MO, Tuple, MO, MO> NestedTuple;
-
-        static_assert(!std::is_constructible<
-            NestedTuple, MO, MO, MO, MO>::value, "");
-        static_assert(std::is_constructible<
-            NestedTuple, MO, Tuple, MO, MO>::value, "");
-    }
-}
-
-using ExplicitTup = std::tuple<std::string, int, std::error_code>;
-ExplicitTup doc_example() {
-      return ExplicitTup{"hello world", 42}; // explicit constructor called. OK.
-}
-
-// Test that the example given in UsingLibcxx.rst actually works.
-void test_example_from_docs() {
-  auto tup = doc_example();
-  assert(std::get<0>(tup) == "hello world");
-  assert(std::get<1>(tup) == 42);
-  assert(std::get<2>(tup) == std::error_code{});
-}
-
-int main(int, char**)
-{
-    {
-        using E = MoveOnly;
-        using Tup = std::tuple<E, E, E>;
-        // Test that the reduced arity initialization extension is only
-        // allowed on the explicit constructor.
-        static_assert(test_convertible<Tup, E, E, E>(), "");
-
-        Tup t(E(0), E(1));
-        static_assert(std::is_constructible<Tup, E, E>::value, "");
-        static_assert(!test_convertible<Tup, E, E>(), "");
-        assert(std::get<0>(t) == E(0));
-        assert(std::get<1>(t) == E(1));
-        assert(std::get<2>(t) == E());
-
-        Tup t2(E(0));
-        static_assert(std::is_constructible<Tup, E>::value, "");
-        static_assert(!test_convertible<Tup, E>(), "");
-        assert(std::get<0>(t2) == E(0));
-        assert(std::get<1>(t2) == E());
-        assert(std::get<2>(t2) == E());
-    }
-    // Check that SFINAE is properly applied with the default reduced arity
-    // constructor extensions.
-    test_default_constructible_extension_sfinae();
-    test_example_from_docs();
-
-  return 0;
-}

libcxx/test/libcxx/utilities/tuple/tuple.tuple/tuple.cnstr/enable_reduced_arity_initialization_extension.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// <tuple>
-
-// template <class... Types> class tuple;
-
-// template <class... UTypes>
-//   explicit tuple(UTypes&&... u);
-
-// UNSUPPORTED: c++03
-
-// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_TUPLE_IMPLICIT_REDUCED_ARITY_EXTENSION
-
-#include <tuple>
-#include <cassert>
-#include <type_traits>
-#include <string>
-#include <system_error>
-
-#include "test_macros.h"
-#include "test_convertible.h"
-#include "MoveOnly.h"
-
-
-struct NoDefault { NoDefault() = delete; };
-
-
-// Make sure the _Up... constructor SFINAEs out when the types that
-// are not explicitly initialized are not all default constructible.
-// Otherwise, std::is_constructible would return true but instantiating
-// the constructor would fail.
-void test_default_constructible_extension_sfinae()
-{
-    typedef MoveOnly MO;
-    typedef NoDefault ND;
-    {
-        typedef std::tuple<MO, ND> Tuple;
-        static_assert(!std::is_constructible<Tuple, MO>::value, "");
-        static_assert(std::is_constructible<Tuple, MO, ND>::value, "");
-        static_assert(test_convertible<Tuple, MO, ND>(), "");
-    }
-    {
-        typedef std::tuple<MO, MO, ND> Tuple;
-        static_assert(!std::is_constructible<Tuple, MO, MO>::value, "");
-        static_assert(std::is_constructible<Tuple, MO, MO, ND>::value, "");
-        static_assert(test_convertible<Tuple, MO, MO, ND>(), "");
-    }
-    {
-        // Same idea as above but with a nested tuple type.
-        typedef std::tuple<MO, ND> Tuple;
-        typedef std::tuple<MO, Tuple, MO, MO> NestedTuple;
-
-        static_assert(!std::is_constructible<
-            NestedTuple, MO, MO, MO, MO>::value, "");
-        static_assert(std::is_constructible<
-            NestedTuple, MO, Tuple, MO, MO>::value, "");
-    }
-    {
-        typedef std::tuple<MO, int> Tuple;
-        typedef std::tuple<MO, Tuple, MO, MO> NestedTuple;
-
-        static_assert(std::is_constructible<
-            NestedTuple, MO, MO, MO, MO>::value, "");
-        static_assert(test_convertible<
-            NestedTuple, MO, MO, MO, MO>(), "");
-
-        static_assert(std::is_constructible<
-            NestedTuple, MO, Tuple, MO, MO>::value, "");
-        static_assert(test_convertible<
-            NestedTuple, MO, Tuple, MO, MO>(), "");
-    }
-}
-
-std::tuple<std::string, int, std::error_code> doc_example() {
-      return {"hello world", 42};
-}
-
-// Test that the example given in UsingLibcxx.rst actually works.
-void test_example_from_docs() {
-  auto tup = doc_example();
-  assert(std::get<0>(tup) == "hello world");
-  assert(std::get<1>(tup) == 42);
-  assert(std::get<2>(tup) == std::error_code{});
-}
-
-int main(int, char**)
-{
-
-    {
-        using E = MoveOnly;
-        using Tup = std::tuple<E, E, E>;
-        static_assert(test_convertible<Tup, E, E, E>(), "");
-
-        Tup t = {E(0), E(1)};
-        static_assert(test_convertible<Tup, E, E>(), "");
-        assert(std::get<0>(t) == E(0));
-        assert(std::get<1>(t) == E(1));
-        assert(std::get<2>(t) == E());
-
-        Tup t2 = {E(0)};
-        static_assert(test_convertible<Tup, E>(), "");
-        assert(std::get<0>(t2) == E(0));
-        assert(std::get<1>(t2) == E());
-        assert(std::get<2>(t2) == E());
-    }
-    // Check that SFINAE is properly applied with the default reduced arity
-    // constructor extensions.
-    test_default_constructible_extension_sfinae();
-    test_example_from_docs();
-
-  return 0;
-}

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

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
 
 // <tuple>
 
-// See llvm.org/PR20855
+// See https://llvm.org/PR20855.
 
 #include <functional>
 #include <tuple>
 #include <string>
 #include <cassert>
 #include "test_macros.h"
 
 #if TEST_HAS_BUILTIN_IDENTIFIER(__reference_binds_to_temporary)

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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: c++03
 
 // <tuple>
 
 // template <class... Types> class tuple;
 
-// template <class TupleLike>
-//   tuple(TupleLike&&);
-// template <class Alloc, class TupleLike>
-//   tuple(std::allocator_arg_t, Alloc const&, TupleLike&&);
-
 // Check that the tuple-like ctors are properly disabled when the UTypes...
-// constructor should be selected. See PR22806.
+// constructor should be selected.
+//
+// See https://llvm.org/PR22806.
 
 #include <tuple>
 #include <memory>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class Tp>

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

 // <tuple>
 
 // template <class... Types> class tuple;
 
 // template <class ...UTypes>
 //    EXPLICIT(...) tuple(UTypes&&...)
 
 // Check that the UTypes... ctor is properly disabled before evaluating any
-// SFINAE when the tuple-like copy/move ctor should *clearly* be selected
+// SFINAE when the copy/move ctor from another tuple should clearly be selected
 // instead. This happens 'sizeof...(UTypes) == 1' and the first element of
-// 'UTypes...' is an instance of the tuple itself. See PR23256.
+// 'UTypes...' is an instance of the tuple itself.
+//
+// See https://llvm.org/PR23256.
 
 #include <tuple>
 #include <memory>
 #include <type_traits>
 
 #include "test_macros.h"
 
 

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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: c++03
 
 // <tuple>
 
 // template <class... Types> class tuple;
 
 // template <class Alloc> tuple(allocator_arg_t, Alloc const&)
 
-// Libc++ has to deduce the 'allocator_arg_t' parameter for this constructor
-// as 'AllocArgT'. Previously libc++ has tried to support tags derived from
-// 'allocator_arg_t' by using 'is_base_of<AllocArgT, allocator_arg_t>'.
-// However this breaks whenever a 2-tuple contains a reference to an incomplete
-// type as its first parameter. See PR27684.
+// See https://llvm.org/PR27684.
 
 #include <tuple>
 #include <cassert>
 
 #include "test_macros.h"
 
 struct IncompleteType;
 extern IncompleteType inc1;

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

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
 
-// <tuple>
+// See https://llvm.org/PR31384.
 
-// template <class TupleLike> tuple(TupleLike&&); // libc++ extension
-
-// See llvm.org/PR31384
 #include <tuple>
 #include <cassert>
 
 #include "test_macros.h"
 
 int count = 0;
 
 struct Explicit {
struct ExplicitDerived : std::tuple<T> {
   template<class U>
   explicit operator std::tuple<U>() && { ++count; return {}; }
 };
 
 int main(int, char**) {
   {
     std::tuple<Explicit> foo = Derived<int>{42}; ((void)foo);
     assert(count == 1);
-    std::tuple<Explicit> bar(Derived<int>{42}); ((void)bar);
+    Derived<int> d{42};
+    std::tuple<Explicit> bar(std::move(d)); ((void)bar);
+#if TEST_STD_VER < 17
+    assert(count == 1);
+#else
     assert(count == 2);
+#endif
   }
   count = 0;
   {
     std::tuple<Implicit> foo = Derived<int>{42}; ((void)foo);
     assert(count == 1);
-    std::tuple<Implicit> bar(Derived<int>{42}); ((void)bar);
+    Derived<int> d{42};
+    std::tuple<Implicit> bar(std::move(d)); ((void)bar);
+#if TEST_STD_VER < 17
+    assert(count == 1);
+#else
     assert(count == 2);
+#endif
   }
   count = 0;
   {
-    static_assert(!std::is_convertible<
-        ExplicitDerived<int>, std::tuple<Explicit>>::value, "");
-    std::tuple<Explicit> bar(ExplicitDerived<int>{42}); ((void)bar);
+    static_assert(!std::is_convertible<ExplicitDerived<int>, std::tuple<Explicit>>::value, "");
+    ExplicitDerived<int> d{42};
+    std::tuple<Explicit> bar(std::move(d)); ((void)bar);
+#if TEST_STD_VER < 17
+    assert(count == 0);
+#else
     assert(count == 1);
+#endif
   }
   count = 0;
   {
-    // FIXME: Libc++ incorrectly rejects this code.
-#ifndef _LIBCPP_VERSION
     std::tuple<Implicit> foo = ExplicitDerived<int>{42}; ((void)foo);
-    static_assert(std::is_convertible<
-        ExplicitDerived<int>, std::tuple<Implicit>>::value,
-        "correct STLs accept this");
-#else
-    static_assert(!std::is_convertible<
-        ExplicitDerived<int>, std::tuple<Implicit>>::value,
-        "libc++ incorrectly rejects this");
-#endif
+    static_assert(std::is_convertible<ExplicitDerived<int>, std::tuple<Implicit>>::value, "");
     assert(count == 0);
-    std::tuple<Implicit> bar(ExplicitDerived<int>{42}); ((void)bar);
+    ExplicitDerived<int> d{42};
+    std::tuple<Implicit> bar(std::move(d)); ((void)bar);
+#if TEST_STD_VER < 17
+    assert(count == 0);
+#else
     assert(count == 1);
+#endif
   }
   count = 0;
 
-
   return 0;
 }

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

struct A
     int id_;
     explicit constexpr A(int i) : id_(i) {}
 };
 
 #endif
 
 struct NoDefault { NoDefault() = delete; };
 
-// Make sure the _Up... constructor SFINAEs out when the types that
-// are not explicitly initialized are not all default constructible.
-// Otherwise, std::is_constructible would return true but instantiating
-// the constructor would fail.
-void test_default_constructible_extension_sfinae()
+// Make sure the _Up... constructor SFINAEs out when there are fewer
+// constructor arguments than tuple elements.
+void test_sfinae_missing_elements()
 {
     {
         typedef std::tuple<MoveOnly, NoDefault> Tuple;
 
         static_assert(!std::is_constructible<
             Tuple,
             MoveOnly
         >::value, "");
void test_sfinae_missing_elements()
             MoveOnly, MoveOnly, MoveOnly, MoveOnly
         >::value, "");
 
         static_assert(std::is_constructible<
             NestedTuple,
             MoveOnly, Tuple, MoveOnly, MoveOnly
         >::value, "");
     }
-    // testing extensions
-#ifdef _LIBCPP_VERSION
-    {
-        typedef std::tuple<MoveOnly, int> Tuple;
-        typedef std::tuple<MoveOnly, Tuple, MoveOnly, MoveOnly> NestedTuple;
-
-        static_assert(std::is_constructible<
-            NestedTuple,
-            MoveOnly, MoveOnly, MoveOnly, MoveOnly
-        >::value, "");
-
-        static_assert(std::is_constructible<
-            NestedTuple,
-            MoveOnly, Tuple, MoveOnly, MoveOnly
-        >::value, "");
-    }
-#endif
 }
 
 int main(int, char**)
 {
     {
         std::tuple<MoveOnly> t(MoveOnly(0));
         assert(std::get<0>(t) == 0);
     }
     {
         std::tuple<MoveOnly, MoveOnly> t(MoveOnly(0), MoveOnly(1));
         assert(std::get<0>(t) == 0);
         assert(std::get<1>(t) == 1);
     }
     {
         std::tuple<MoveOnly, MoveOnly, MoveOnly> t(MoveOnly(0),
                                                    MoveOnly(1),
                                                    MoveOnly(2));
         assert(std::get<0>(t) == 0);
         assert(std::get<1>(t) == 1);
         assert(std::get<2>(t) == 2);
     }
-    // extensions
-#ifdef _LIBCPP_VERSION
-    {
-        using E = MoveOnly;
-        using Tup = std::tuple<E, E, E>;
-        // Test that the reduced arity initialization extension is only
-        // allowed on the explicit constructor.
-        static_assert(test_convertible<Tup, E, E, E>(), "");
-
-        Tup t(E(0), E(1));
-        static_assert(!test_convertible<Tup, E, E>(), "");
-        assert(std::get<0>(t) == E(0));
-        assert(std::get<1>(t) == E(1));
-        assert(std::get<2>(t) == E());
-
-        Tup t2(E(0));
-        static_assert(!test_convertible<Tup, E>(), "");
-        assert(std::get<0>(t2) == E(0));
-        assert(std::get<1>(t2) == E());
-        assert(std::get<2>(t2) == E());
-    }
-#endif
 #if TEST_STD_VER > 11
     {
         constexpr std::tuple<Empty> t0{Empty()};
         (void)t0;
     }
     {
         constexpr std::tuple<A, A> t(3, 2);
         static_assert(std::get<0>(t).id_ == 3, "");
     }
 #endif
-    // Check that SFINAE is properly applied with the default reduced arity
-    // constructor extensions.
-    test_default_constructible_extension_sfinae();
+
+    test_sfinae_missing_elements();
 
   return 0;
 }

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

 
 // <tuple>
 
 // template <class... Types> class tuple;
 
 // template <class Alloc>
 //   explicit(see-below) tuple(allocator_arg_t, const Alloc& a);
 
-// NOTE: this constructor does not currently support tags derived from
-// allocator_arg_t because libc++ has to deduce the parameter as a template
-// argument. See PR27684 (https://llvm.org/PR27684)
-
 #include <tuple>
 #include <cassert>
 
 #include "test_macros.h"
 #include "DefaultOnly.h"
 #include "allocators.h"
 #include "../alloc_first.h"
 #include "../alloc_last.h"
int main(int, char**)
                                                            A2<int>(5));
         assert(std::get<0>(t) == DefaultOnly());
         assert(!alloc_first::allocator_constructed);
         assert(std::get<1>(t) == alloc_first());
         assert(!alloc_last::allocator_constructed);
         assert(std::get<2>(t) == alloc_last());
     }
     {
+        // Test that we can use a tag derived from allocator_arg_t
+        struct DerivedFromAllocatorArgT : std::allocator_arg_t { };
+        DerivedFromAllocatorArgT derived;
+        std::tuple<> t1(derived, A1<int>());
+        std::tuple<int> t2(derived, A1<int>());
+        std::tuple<int, int> t3(derived, A1<int>());
+    }
+    {
         // Test that the uses-allocator default constructor does not evaluate
         // its SFINAE when it otherwise shouldn't be selected. Do this by
         // using 'NonDefaultConstructible' which will cause a compile error
         // if std::is_default_constructible is evaluated on it.
         using T = NonDefaultConstructible<>;
         T v(42);
         std::tuple<T, T> t(v, v);
         (void)t;
         std::tuple<T, T> t2(42, 42);
         (void)t2;
     }
 
   return 0;
 }

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

int main(int, char**)
                                                    A2<int>(5), 1, alloc_first(2),
                                                    alloc_last(3));
         assert(std::get<0>(t) == 1);
         assert(!alloc_first::allocator_constructed);
         assert(std::get<1>(t) == alloc_first(2));
         assert(!alloc_last::allocator_constructed);
         assert(std::get<2>(t) == alloc_last(3));
     }
+    {
+        // Test that we can use a tag derived from allocator_arg_t
+        struct DerivedFromAllocatorArgT : std::allocator_arg_t { };
+        DerivedFromAllocatorArgT derived;
+        std::tuple<> t1(derived, A1<int>());
+        std::tuple<int> t2(derived, A1<int>(), 1);
+        std::tuple<int, int> t3(derived, A1<int>(), 1, 2);
+    }
 
     return 0;
 }

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

int main(int, char**)
         alloc_first::allocator_constructed = false;
         alloc_last::allocator_constructed = false;
         T1 t1(std::allocator_arg, A1<int>(5), t0);
         assert(alloc_first::allocator_constructed);
         assert(alloc_last::allocator_constructed);
         assert(std::get<0>(t1) == 2);
         assert(std::get<1>(t1) == 3);
     }
+    {
+        // Test that we can use a tag derived from allocator_arg_t
+        struct DerivedFromAllocatorArgT : std::allocator_arg_t { };
+        DerivedFromAllocatorArgT derived;
+        std::pair<int, int> p(1, 2);
+        std::tuple<int, int> t(derived, A1<int>(), p);
+    }
 
     return 0;
 }

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

int main(int, char**)
         std::tuple<Explicit> t2{std::allocator_arg, std::allocator<int>{},  t1};
         assert(std::get<0>(t2).value == 42);
     }
     {
         const std::tuple<int> t1(42);
         std::tuple<Implicit> t2 = {std::allocator_arg, std::allocator<int>{}, t1};
         assert(std::get<0>(t2).value == 42);
     }
+    {
+        // 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);
+    }
 
     return 0;
 }

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

int main(int, char**)
         std::tuple<Explicit> t2{std::allocator_arg, std::allocator<int>{}, std::move(t1)};
         assert(std::get<0>(t2).value == 42);
     }
     {
         std::tuple<int> t1(42);
         std::tuple<Implicit> t2 = {std::allocator_arg, std::allocator<int>{}, std::move(t1)};
         assert(std::get<0>(t2).value == 42);
     }
+    {
+        // 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));
+    }
 
     return 0;
 }

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

int main(int, char**)
     {
         typedef std::tuple<alloc_last> T;
         T t0(2);
         alloc_last::allocator_constructed = false;
         T t(std::allocator_arg, A1<int>(5), t0);
         assert(alloc_last::allocator_constructed);
         assert(std::get<0>(t) == 2);
     }
-// testing extensions
-#ifdef _LIBCPP_VERSION
     {
         typedef std::tuple<alloc_first, alloc_last> T;
         T t0(2, 3);
         alloc_first::allocator_constructed = false;
         alloc_last::allocator_constructed = false;
         T t(std::allocator_arg, A1<int>(5), t0);
         assert(alloc_first::allocator_constructed);
         assert(alloc_last::allocator_constructed);
         assert(std::get<0>(t) == 2);
         assert(std::get<1>(t) == 3);
     }
     {
         typedef std::tuple<int, alloc_first, alloc_last> T;
         T t0(1, 2, 3);
         alloc_first::allocator_constructed = false;
         alloc_last::allocator_constructed = false;
         T t(std::allocator_arg, A1<int>(5), t0);
         assert(alloc_first::allocator_constructed);
         assert(alloc_last::allocator_constructed);
         assert(std::get<0>(t) == 1);
         assert(std::get<1>(t) == 2);
         assert(std::get<2>(t) == 3);
     }
-#endif
+    {
+        // Test that we can use a tag derived from allocator_arg_t
+        struct DerivedFromAllocatorArgT : std::allocator_arg_t { };
+        DerivedFromAllocatorArgT derived;
+        std::tuple<int> from(3);
+        std::tuple<int> t0(derived, A1<int>(), from);
+    }
 
     return 0;
 }

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

int main(int, char**)
     {
         typedef std::tuple<alloc_last> T;
         T t0(1);
         alloc_last::allocator_constructed = false;
         T t(std::allocator_arg, A1<int>(5), std::move(t0));
         assert(alloc_last::allocator_constructed);
         assert(std::get<0>(t) == 1);
     }
-// testing extensions
-#ifdef _LIBCPP_VERSION
     {
         typedef std::tuple<MoveOnly, alloc_first> T;
         T t0(0 ,1);
         alloc_first::allocator_constructed = false;
         T t(std::allocator_arg, A1<int>(5), std::move(t0));
         assert(alloc_first::allocator_constructed);
         assert(std::get<0>(t) == 0);
         assert(std::get<1>(t) == 1);
     }
     {
         typedef std::tuple<MoveOnly, alloc_first, alloc_last> T;
         T t0(1, 2, 3);
         alloc_first::allocator_constructed = false;
         alloc_last::allocator_constructed = false;
         T t(std::allocator_arg, A1<int>(5), std::move(t0));
         assert(alloc_first::allocator_constructed);
         assert(alloc_last::allocator_constructed);
         assert(std::get<0>(t) == 1);
         assert(std::get<1>(t) == 2);
         assert(std::get<2>(t) == 3);
     }
-#endif
+    {
+        // Test that we can use a tag derived from allocator_arg_t
+        struct DerivedFromAllocatorArgT : std::allocator_arg_t { };
+        DerivedFromAllocatorArgT derived;
+        std::tuple<int> from(3);
+        std::tuple<int> t0(derived, A1<int>(), std::move(from));
+    }
 
     return 0;
 }

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

int main(int, char**)
         typedef std::tuple<alloc_first, std::unique_ptr<B>> T1;
         T0 t0(2, std::unique_ptr<D>(new D(3)));
         alloc_first::allocator_constructed = false;
         T1 t1(std::allocator_arg, A1<int>(5), std::move(t0));
         assert(alloc_first::allocator_constructed);
         assert(std::get<0>(t1) == 2);
         assert(std::get<1>(t1)->id_ == 3);
     }
+    {
+        // Test that we can use a tag derived from allocator_arg_t
+        struct DerivedFromAllocatorArgT : std::allocator_arg_t { };
+        DerivedFromAllocatorArgT derived;
+        std::pair<int, int> from(1, 2);
+        std::tuple<int, int> t0(derived, A1<int>(), std::move(from));
+    }
 
     return 0;
 }

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

// This checks that is_constructible is not evaluated when U == __tuple_leaf.
         assert(std::get<3>(t) == 3);
     }
     {
         std::tuple<int, NoValueCtorEmpty, int, int> t(1, NoValueCtorEmpty(), 2, 3);
         assert(std::get<0>(t) == 1);
         assert(std::get<2>(t) == 2);
         assert(std::get<3>(t) == 3);
     }
-// extensions
-#ifdef _LIBCPP_VERSION
-    {
-        std::tuple<int, char*, std::string> t(2);
-        assert(std::get<0>(t) == 2);
-        assert(std::get<1>(t) == nullptr);
-        assert(std::get<2>(t) == "");
-    }
-    {
-        std::tuple<int, char*, std::string> t(2, nullptr);
-        assert(std::get<0>(t) == 2);
-        assert(std::get<1>(t) == nullptr);
-        assert(std::get<2>(t) == "");
-    }
-    {
-        std::tuple<int, char*, std::string, double> t(2, nullptr, "text");
-        assert(std::get<0>(t) == 2);
-        assert(std::get<1>(t) == nullptr);
-        assert(std::get<2>(t) == "text");
-        assert(std::get<3>(t) == 0.0);
-    }
-#endif
 
   return 0;
 }

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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
 // UNSUPPORTED: libcpp-no-deduction-guides
 // UNSUPPORTED: apple-clang-9
 
 // GCC's implementation of class template deduction is still immature and runs
 // into issues with libc++. However GCC accepts this code when compiling
 // against libstdc++.
-// XFAIL: gcc-5, gcc-6, gcc-7
+// XFAIL: gcc-5, gcc-6, gcc-7, gcc-8, gcc-9, gcc-10
 
 // <tuple>
 
 // Test that the constructors offered by std::tuple are formulated
 // so they're compatible with implicit deduction guides, or if that's not
 // possible that they provide explicit guides to make it work.
 
 #include <tuple>

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/default.lazy.verify.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
+//
+//===----------------------------------------------------------------------===//
+
+// This test makes sure that we don't evaluate `is_default_constructible<T>`
+// too early in std::tuple's default constructor.
+
+// UNSUPPORTED: c++03
+
+#include <tuple>
+
+#include "test_macros.h"
+
+struct Outer {
+    template <class T>
+    struct Inner {
+        bool foo = false;
+    };
+    std::tuple<Inner<int>> tup;
+};
+
+Outer x; // expected-no-diagnostics

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/test_lazy_sfinae.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;
 
 // UNSUPPORTED: c++03
 
+// Test the following constructors:
+// (1) tuple(Types const&...)
+// (2) tuple(UTypes&&...)
+// Test that (1) short circuits before evaluating the copy constructor of the
+// second argument. Constructor (2) should be selected.
+
 #include <tuple>
 #include <utility>
 #include <cassert>
 
 #include "test_macros.h"
 
-template <class ConstructFrom>
-struct ConstructibleFromT {
-  ConstructibleFromT() = default;
-  ConstructibleFromT(ConstructFrom v) : value(v) {}
-  ConstructFrom value;
-};
-
-template <class AssertOn>
-struct CtorAssertsT {
-  bool defaulted;
-  CtorAssertsT() : defaulted(true) {}
-  template <class T>
-  constexpr CtorAssertsT(T) : defaulted(false) {
-      static_assert(!std::is_same<T, AssertOn>::value, "");
-  }
-};
-
-template <class AllowT, class AssertT>
-struct AllowAssertT {
-  AllowAssertT() = default;
-  AllowAssertT(AllowT) {}
-  template <class U>
-  constexpr AllowAssertT(U) {
-      static_assert(!std::is_same<U, AssertT>::value, "");
-  }
-};
-
-// Construct a tuple<T1, T2> from pair<int, int> where T1 and T2
-// are not constructible from ints but T1 is constructible from std::pair.
-// This considers the following constructors:
-// (1) tuple(TupleLike) -> checks is_constructible<Tn, int>
-// (2) tuple(UTypes...) -> checks is_constructible<T1, pair<int, int>>
-//                            and is_default_constructible<T2>
-// The point of this test is to ensure that the consideration of (1)
-// short circuits before evaluating is_constructible<T2, int>, which
-// will cause a static assertion.
-void test_tuple_like_lazy_sfinae() {
-#if defined(_LIBCPP_VERSION)
-    // This test requires libc++'s reduced arity initialization.
-    using T1 = ConstructibleFromT<std::pair<int, int>>;
-    using T2 = CtorAssertsT<int>;
-    std::pair<int, int> p(42, 100);
-    std::tuple<T1, T2> t(p);
-    assert(std::get<0>(t).value == p);
-    assert(std::get<1>(t).defaulted);
-#endif
-}
-
-
 struct NonConstCopyable {
   NonConstCopyable() = default;
   explicit NonConstCopyable(int v) : value(v) {}
   NonConstCopyable(NonConstCopyable&) = default;
   NonConstCopyable(NonConstCopyable const&) = delete;
   int value;
 };
 
 template <class T>
 struct BlowsUpOnConstCopy {
   BlowsUpOnConstCopy() = default;
   constexpr BlowsUpOnConstCopy(BlowsUpOnConstCopy const&) {
       static_assert(!std::is_same<T, T>::value, "");
   }
   BlowsUpOnConstCopy(BlowsUpOnConstCopy&) = default;
 };
 
-// Test the following constructors:
-// (1) tuple(Types const&...)
-// (2) tuple(UTypes&&...)
-// Test that (1) short circuits before evaluating the copy constructor of the
-// second argument. Constructor (2) should be selected.
-void test_const_Types_lazy_sfinae()
-{
-    NonConstCopyable v(42);
-    BlowsUpOnConstCopy<int> b;
-    std::tuple<NonConstCopyable, BlowsUpOnConstCopy<int>> t(v, b);
-    assert(std::get<0>(t).value == 42);
-}
-
-int main(int, char**) {
-    test_tuple_like_lazy_sfinae();
-    test_const_Types_lazy_sfinae();
+int main(int, char**) {
 
   return 0;
 }

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

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03
-
-// <tuple>
-
-// template <class... Types> class tuple;
-
-// template <class Tuple, __tuple_convertible<Tuple, tuple> >
-//   tuple(Tuple &&);
-//
-// template <class Tuple, __tuple_constructible<Tuple, tuple> >
-//   tuple(Tuple &&);
-
-// This test checks that we do not evaluate __make_tuple_types
-// on the array.
-
-#include <array>
-#include <tuple>
-
-#include "test_macros.h"
-
-// Use 1256 to try and blow the template instantiation depth for all compilers.
-typedef std::array<char, 1256> array_t;
-typedef std::tuple<array_t> tuple_t;
-
-int main(int, char**)
-{
-    array_t arr;
-    tuple_t tup(arr);
-
-  return 0;
-}