[libcxx] Make std::tuple<> trivially constructible

[ldionne]

Summary

This is not mandated by the Standard, but it's nonetheless a nice
property to have, especially since it's so easy to implement. It
also shrinks our bug list!

PR41714

[mclow.lists]

Other than the "this is not standard behavior", and my general feeling about "things that everyone does, but aren't in the standard", I'm fine with this.
Once we get an LWG issue open on this behavior, I'll be strongly in favor of this.

[mclow.lists]

I have no problems with the code, btw.

[ldionne]

I opened a LWG issue per your request, I'm waiting for the LWG chair (hmm, I wonder who that is) to give me an issue number 🙃.

[EricWF]

Changing the triviality of a type can be ABI breaking because it will change the calling conventions the compiler uses.
We have hacks in pair to keep it non-trivial on some platforms for this reason.

I'm not sure if this case triggers that change (it may only be when you change is_trivially_copyable). But we need to double check.

libcxx/include/tuple

910 ↗

(On Diff #202018)

This is C++11 and up so you can just write = default.

[dexonsmith]

In D62618#1521964, @EricWF wrote:

Changing the triviality of a type can be ABI breaking because it will change the calling conventions the compiler uses.
We have hacks in pair to keep it non-trivial on some platforms for this reason.

Right, I think we at least need a macro to choose the ABI so that (a) vendors can pick a default and (b) users can override it.

[ldionne]

In D62618#1521964, @EricWF wrote:

Changing the triviality of a type can be ABI breaking because it will change the calling conventions the compiler uses.
We have hacks in pair to keep it non-trivial on some platforms for this reason.

I'm not sure if this case triggers that change (it may only be when you change is_trivially_copyable). But we need to double check.

I was going to close PR41714 as "Can't fix, this is an ABI break", but then I checked the Itanium C++ ABI and it did not mention default constructors. Here, it says:

*non-trivial for the purposes of calls*
A type is considered non-trivial for the purposes of calls if:

• it has a non-trivial copy constructor, move constructor, or destructor, or
• all of its copy and move constructors are deleted.

This definition, as applied to class types, is intended to be the complement of the definition in [class.temporary]p3 of types for which an extra temporary is allowed when passing or returning a type. A type which is trivial for the purposes of the ABI will be passed and returned according to the rules of the underlying C ABI, e.g. in registers; often this has the effect of performing a trivial copy of the type.

I'd welcome a double-check, but I think this isn't ABI breaking. Otherwise the resolution is evident, y'all know me :-).

libcxx/include/tuple

910 ↗

(On Diff #202018)

I thought this was trying to work in C++03 -- isn't that why we're using _NOEXCEPT and _LIBCPP_CONSTEXPR??

[EricWF]

Thanks for the link Louis. This should be safe then. .

libcxx/include/tuple

910 ↗

(On Diff #202018)

Not really. And even then I believe Clang accepts = default as an extension in C++03.

[mclow.lists]

libcxx/include/tuple

910 ↗

(On Diff #202018)

Yes.

[ldionne]

Use = default per Eric's comment.

[ldionne]

Just to confirm, @mclow.lists are we OK with this since the LWG issue has been filed?

[mclow.lists]

In D62618#1529886, @ldionne wrote:

Just to confirm, @mclow.lists are we OK with this since the LWG issue has been filed?

Yes - thanks for checking.

libcxx/trunk/include/tuple

void swap(tuple& __t) _NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value)
         {__base_.swap(__t.__base_);}
 };
 
 template <>
 class _LIBCPP_TEMPLATE_VIS tuple<>
 {
 public:
     _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR tuple() _NOEXCEPT {}
+    _LIBCPP_CONSTEXPR tuple() _NOEXCEPT = default;
     template <class _Alloc>
     _LIBCPP_INLINE_VISIBILITY
         tuple(allocator_arg_t, const _Alloc&) _NOEXCEPT {}
     template <class _Alloc>
     _LIBCPP_INLINE_VISIBILITY
         tuple(allocator_arg_t, const _Alloc&, const tuple&) _NOEXCEPT {}
     template <class _Up>
     _LIBCPP_INLINE_VISIBILITY

libcxx/trunk/test/libcxx/utilities/tuple/tuple.tuple/tuple.cnstr/empty_tuple_trivial.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
+//
+//===----------------------------------------------------------------------===//
+
+// This test ensures that std::tuple<> is trivially constructible. That is not
+// required by the Standard, but libc++ provides that guarantee.
+
+// UNSUPPORTED: c++98, c++03
+
+#include <tuple>
+#include <type_traits>
+
+
+static_assert(std::is_trivially_constructible<std::tuple<>>::value, "");
+
+int main(int, char**) {
+  return 0;
+}