From 6d1402f0edf15480a1eb37141bc165cab5bca508 Mon Sep 17 00:00:00 2001 From: Edward Smith-Rowland <3dw4rd@verizon.net> Date: Sat, 16 Nov 2019 03:16:35 +0000 Subject: [PATCH] Implement the part of C++20 p1032 Misc constexpr bits. 2019-11-15 Edward Smith-Rowland <3dw4rd@verizon.net> Implement the part of C++20 p1032 Misc constexpr bits. * include/std/tuple (_Head_base, _Tuple_impl(allocator_arg_t,...) (_M_assign, tuple(allocator_arg_t,...), _Inherited, operator=, _M_swap) (swap, pair(piecewise_construct_t,): Constexpr. * (__uses_alloc0::_Sink::operator=, __uses_alloc_t): Constexpr. * testsuite/20_util/tuple/cons/constexpr_allocator_arg_t.cc: New test. * testsuite/20_util/tuple/constexpr_swap.cc : New test. * testsuite/20_util/uses_allocator/69293_neg.cc: Extra error for C++20. * testsuite/20_util/uses_allocator/cons_neg.cc: : Extra error for C++20. From-SVN: r278331 --- libstdc++-v3/ChangeLog | 12 ++++ libstdc++-v3/include/std/tuple | 67 ++++++++++++++++++- .../tuple/cons/constexpr_allocator_arg_t.cc | 48 +++++++++++++ .../testsuite/20_util/tuple/constexpr_swap.cc | 36 ++++++++++ .../20_util/uses_allocator/69293_neg.cc | 1 + .../20_util/uses_allocator/cons_neg.cc | 1 + 6 files changed, 164 insertions(+), 1 deletion(-) create mode 100644 libstdc++-v3/testsuite/20_util/tuple/cons/constexpr_allocator_arg_t.cc create mode 100644 libstdc++-v3/testsuite/20_util/tuple/constexpr_swap.cc diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog index 0db99e41239..ccbb0b456da 100644 --- a/libstdc++-v3/ChangeLog +++ b/libstdc++-v3/ChangeLog @@ -1,3 +1,15 @@ +2019-11-15 Edward Smith-Rowland <3dw4rd@verizon.net> + + Implement the part of C++20 p1032 Misc constexpr bits. + * include/std/tuple (_Head_base, _Tuple_impl(allocator_arg_t,...) + (_M_assign, tuple(allocator_arg_t,...), _Inherited, operator=, _M_swap) + (swap, pair(piecewise_construct_t,): Constexpr. + * (__uses_alloc0::_Sink::operator=, __uses_alloc_t): Constexpr. + * testsuite/20_util/tuple/cons/constexpr_allocator_arg_t.cc: New test. + * testsuite/20_util/tuple/constexpr_swap.cc : New test. + * testsuite/20_util/uses_allocator/69293_neg.cc: Extra error for C++20. + * testsuite/20_util/uses_allocator/cons_neg.cc: : Extra error for C++20. + 2019-11-15 Jonathan Wakely * include/std/stop_token: Reduce header dependencies by including diff --git a/libstdc++-v3/include/std/tuple b/libstdc++-v3/include/std/tuple index ae1a3d0d18b..4844475d0d0 100644 --- a/libstdc++-v3/include/std/tuple +++ b/libstdc++-v3/include/std/tuple @@ -132,6 +132,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION constexpr _Head_base(_UHead&& __h) : _M_head_impl(std::forward<_UHead>(__h)) { } + _GLIBCXX20_CONSTEXPR _Head_base(allocator_arg_t, __uses_alloc0) : _M_head_impl() { } @@ -144,6 +145,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION : _M_head_impl(*__a._M_a) { } template + _GLIBCXX20_CONSTEXPR _Head_base(__uses_alloc0, _UHead&& __uhead) : _M_head_impl(std::forward<_UHead>(__uhead)) { } @@ -243,6 +245,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) { } template + _GLIBCXX20_CONSTEXPR _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a) : _Inherited(__tag, __a), _Base(__tag, __use_alloc<_Head>(__a)) { } @@ -256,6 +259,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template::type> + _GLIBCXX20_CONSTEXPR _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, _UHead&& __head, _UTail&&... __tail) : _Inherited(__tag, __a, std::forward<_UTail>(__tail)...), @@ -263,12 +267,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION std::forward<_UHead>(__head)) { } template + _GLIBCXX20_CONSTEXPR _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, const _Tuple_impl& __in) : _Inherited(__tag, __a, _M_tail(__in)), _Base(__use_alloc<_Head, _Alloc, _Head>(__a), _M_head(__in)) { } template + _GLIBCXX20_CONSTEXPR _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, _Tuple_impl&& __in) : _Inherited(__tag, __a, std::move(_M_tail(__in))), @@ -276,6 +282,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION std::forward<_Head>(_M_head(__in))) { } template + _GLIBCXX20_CONSTEXPR _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, const _Tuple_impl<_Idx, _UElements...>& __in) : _Inherited(__tag, __a, @@ -284,6 +291,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION _Tuple_impl<_Idx, _UElements...>::_M_head(__in)) { } template + _GLIBCXX20_CONSTEXPR _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, _Tuple_impl<_Idx, _UHead, _UTails...>&& __in) : _Inherited(__tag, __a, std::move @@ -293,6 +301,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) { } template + _GLIBCXX20_CONSTEXPR void _M_assign(const _Tuple_impl<_Idx, _UElements...>& __in) { @@ -302,6 +311,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION } template + _GLIBCXX20_CONSTEXPR void _M_assign(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in) { @@ -312,6 +322,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION } protected: + _GLIBCXX20_CONSTEXPR void _M_swap(_Tuple_impl& __in) { @@ -369,6 +380,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { } template + _GLIBCXX20_CONSTEXPR _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a) : _Base(__tag, __use_alloc<_Head>(__a)) { } @@ -378,29 +390,34 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION : _Base(__use_alloc<_Head, _Alloc, _Head>(__a), __head) { } template + _GLIBCXX20_CONSTEXPR _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, _UHead&& __head) : _Base(__use_alloc<_Head, _Alloc, _UHead>(__a), std::forward<_UHead>(__head)) { } template + _GLIBCXX20_CONSTEXPR _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, const _Tuple_impl& __in) : _Base(__use_alloc<_Head, _Alloc, _Head>(__a), _M_head(__in)) { } template + _GLIBCXX20_CONSTEXPR _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, _Tuple_impl&& __in) : _Base(__use_alloc<_Head, _Alloc, _Head>(__a), std::forward<_Head>(_M_head(__in))) { } template + _GLIBCXX20_CONSTEXPR _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, const _Tuple_impl<_Idx, _UHead>& __in) : _Base(__use_alloc<_Head, _Alloc, _Head>(__a), _Tuple_impl<_Idx, _UHead>::_M_head(__in)) { } template + _GLIBCXX20_CONSTEXPR _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, _Tuple_impl<_Idx, _UHead>&& __in) : _Base(__use_alloc<_Head, _Alloc, _UHead>(__a), @@ -408,6 +425,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { } template + _GLIBCXX20_CONSTEXPR void _M_assign(const _Tuple_impl<_Idx, _UHead>& __in) { @@ -415,6 +433,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION } template + _GLIBCXX20_CONSTEXPR void _M_assign(_Tuple_impl<_Idx, _UHead>&& __in) { @@ -423,6 +442,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION } protected: + _GLIBCXX20_CONSTEXPR void _M_swap(_Tuple_impl& __in) { @@ -680,17 +700,20 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template::value> = true> + _GLIBCXX20_CONSTEXPR tuple(allocator_arg_t __tag, const _Alloc& __a) : _Inherited(__tag, __a) { } template= 1), _ImplicitCtor<_NotEmpty, const _Elements&...> = true> + _GLIBCXX20_CONSTEXPR tuple(allocator_arg_t __tag, const _Alloc& __a, const _Elements&... __elements) : _Inherited(__tag, __a, __elements...) { } template= 1), _ExplicitCtor<_NotEmpty, const _Elements&...> = false> + _GLIBCXX20_CONSTEXPR explicit tuple(allocator_arg_t __tag, const _Alloc& __a, const _Elements&... __elements) @@ -699,6 +722,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template(), _ImplicitCtor<_Valid, _UElements...> = true> + _GLIBCXX20_CONSTEXPR tuple(allocator_arg_t __tag, const _Alloc& __a, _UElements&&... __elements) : _Inherited(__tag, __a, std::forward<_UElements>(__elements)...) @@ -707,6 +731,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template(), _ExplicitCtor<_Valid, _UElements...> = false> + _GLIBCXX20_CONSTEXPR explicit tuple(allocator_arg_t __tag, const _Alloc& __a, _UElements&&... __elements) @@ -714,10 +739,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { } template + _GLIBCXX20_CONSTEXPR tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in) : _Inherited(__tag, __a, static_cast(__in)) { } template + _GLIBCXX20_CONSTEXPR tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in) : _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { } @@ -725,6 +752,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION bool _Valid = (sizeof...(_Elements) == sizeof...(_UElements)) && !__use_other_ctor&>(), _ImplicitCtor<_Valid, const _UElements&...> = true> + _GLIBCXX20_CONSTEXPR tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple<_UElements...>& __in) : _Inherited(__tag, __a, @@ -735,6 +763,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION bool _Valid = (sizeof...(_Elements) == sizeof...(_UElements)) && !__use_other_ctor&>(), _ExplicitCtor<_Valid, const _UElements&...> = false> + _GLIBCXX20_CONSTEXPR explicit tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple<_UElements...>& __in) @@ -746,6 +775,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION bool _Valid = (sizeof...(_Elements) == sizeof...(_UElements)) && !__use_other_ctor&&>(), _ImplicitCtor<_Valid, _UElements...> = true> + _GLIBCXX20_CONSTEXPR tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_UElements...>&& __in) : _Inherited(__tag, __a, @@ -756,6 +786,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION bool _Valid = (sizeof...(_Elements) == sizeof...(_UElements)) && !__use_other_ctor&&>(), _ExplicitCtor<_Valid, _UElements...> = false> + _GLIBCXX20_CONSTEXPR explicit tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_UElements...>&& __in) @@ -765,6 +796,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION // tuple assignment + _GLIBCXX20_CONSTEXPR tuple& operator=(typename conditional<__assignable(), const tuple&, @@ -775,6 +807,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION return *this; } + _GLIBCXX20_CONSTEXPR tuple& operator=(typename conditional<__assignable<_Elements...>(), tuple&&, @@ -786,6 +819,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION } template + _GLIBCXX20_CONSTEXPR __enable_if_t<__assignable(), tuple&> operator=(const tuple<_UElements...>& __in) noexcept(__nothrow_assignable()) @@ -795,6 +829,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION } template + _GLIBCXX20_CONSTEXPR __enable_if_t<__assignable<_UElements...>(), tuple&> operator=(tuple<_UElements...>&& __in) noexcept(__nothrow_assignable<_UElements...>()) @@ -804,6 +839,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION } // tuple swap + _GLIBCXX20_CONSTEXPR void swap(tuple& __in) noexcept(__and_<__is_nothrow_swappable<_Elements>...>::value) @@ -834,8 +870,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION tuple() = default; // No-op allocator constructors. template + _GLIBCXX20_CONSTEXPR tuple(allocator_arg_t, const _Alloc&) noexcept { } template + _GLIBCXX20_CONSTEXPR tuple(allocator_arg_t, const _Alloc&, const tuple&) noexcept { } }; @@ -1015,11 +1053,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template::value, _T1, _T2> = true> + _GLIBCXX20_CONSTEXPR tuple(allocator_arg_t __tag, const _Alloc& __a) : _Inherited(__tag, __a) { } template = true> + _GLIBCXX20_CONSTEXPR tuple(allocator_arg_t __tag, const _Alloc& __a, const _T1& __a1, const _T2& __a2) : _Inherited(__tag, __a, __a1, __a2) { } @@ -1027,12 +1067,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template = false> explicit + _GLIBCXX20_CONSTEXPR tuple(allocator_arg_t __tag, const _Alloc& __a, const _T1& __a1, const _T2& __a2) : _Inherited(__tag, __a, __a1, __a2) { } template = true> + _GLIBCXX20_CONSTEXPR tuple(allocator_arg_t __tag, const _Alloc& __a, _U1&& __a1, _U2&& __a2) : _Inherited(__tag, __a, std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { } @@ -1040,21 +1082,25 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template = false> explicit + _GLIBCXX20_CONSTEXPR tuple(allocator_arg_t __tag, const _Alloc& __a, _U1&& __a1, _U2&& __a2) : _Inherited(__tag, __a, std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { } template + _GLIBCXX20_CONSTEXPR tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in) : _Inherited(__tag, __a, static_cast(__in)) { } template + _GLIBCXX20_CONSTEXPR tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in) : _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { } template = true> + _GLIBCXX20_CONSTEXPR tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple<_U1, _U2>& __in) : _Inherited(__tag, __a, @@ -1064,6 +1110,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template = false> explicit + _GLIBCXX20_CONSTEXPR tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple<_U1, _U2>& __in) : _Inherited(__tag, __a, @@ -1072,6 +1119,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template = true> + _GLIBCXX20_CONSTEXPR tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_U1, _U2>&& __in) : _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { } @@ -1079,12 +1127,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template = false> explicit + _GLIBCXX20_CONSTEXPR tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_U1, _U2>&& __in) : _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { } template = true> + _GLIBCXX20_CONSTEXPR tuple(allocator_arg_t __tag, const _Alloc& __a, const pair<_U1, _U2>& __in) : _Inherited(__tag, __a, __in.first, __in.second) { } @@ -1092,12 +1142,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template = false> explicit + _GLIBCXX20_CONSTEXPR tuple(allocator_arg_t __tag, const _Alloc& __a, const pair<_U1, _U2>& __in) : _Inherited(__tag, __a, __in.first, __in.second) { } template = true> + _GLIBCXX20_CONSTEXPR tuple(allocator_arg_t __tag, const _Alloc& __a, pair<_U1, _U2>&& __in) : _Inherited(__tag, __a, std::forward<_U1>(__in.first), std::forward<_U2>(__in.second)) { } @@ -1105,10 +1157,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template = false> explicit + _GLIBCXX20_CONSTEXPR tuple(allocator_arg_t __tag, const _Alloc& __a, pair<_U1, _U2>&& __in) : _Inherited(__tag, __a, std::forward<_U1>(__in.first), std::forward<_U2>(__in.second)) { } + // Tuple assignment. + + _GLIBCXX20_CONSTEXPR tuple& operator=(typename conditional<__assignable(), const tuple&, @@ -1119,6 +1175,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION return *this; } + _GLIBCXX20_CONSTEXPR tuple& operator=(typename conditional<__assignable<_T1, _T2>(), tuple&&, @@ -1130,6 +1187,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION } template + _GLIBCXX20_CONSTEXPR __enable_if_t<__assignable(), tuple&> operator=(const tuple<_U1, _U2>& __in) noexcept(__nothrow_assignable()) @@ -1139,6 +1197,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION } template + _GLIBCXX20_CONSTEXPR __enable_if_t<__assignable<_U1, _U2>(), tuple&> operator=(tuple<_U1, _U2>&& __in) noexcept(__nothrow_assignable<_U1, _U2>()) @@ -1148,6 +1207,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION } template + _GLIBCXX20_CONSTEXPR __enable_if_t<__assignable(), tuple&> operator=(const pair<_U1, _U2>& __in) noexcept(__nothrow_assignable()) @@ -1158,6 +1218,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION } template + _GLIBCXX20_CONSTEXPR __enable_if_t<__assignable<_U1, _U2>(), tuple&> operator=(pair<_U1, _U2>&& __in) noexcept(__nothrow_assignable<_U1, _U2>()) @@ -1167,6 +1228,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION return *this; } + _GLIBCXX20_CONSTEXPR void swap(tuple& __in) noexcept(__and_<__is_nothrow_swappable<_T1>, @@ -1521,6 +1583,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION /// swap template + _GLIBCXX20_CONSTEXPR inline #if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11 // Constrained free swap overload, see p0185r1 @@ -1535,6 +1598,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION #if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11 template + _GLIBCXX20_CONSTEXPR typename enable_if...>::value>::type swap(tuple<_Elements...>&, tuple<_Elements...>&) = delete; #endif @@ -1570,7 +1634,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION */ template template - _GLIBCXX20_CONSTEXPR inline + _GLIBCXX20_CONSTEXPR + inline pair<_T1, _T2>:: pair(piecewise_construct_t, tuple<_Args1...> __first, tuple<_Args2...> __second) diff --git a/libstdc++-v3/testsuite/20_util/tuple/cons/constexpr_allocator_arg_t.cc b/libstdc++-v3/testsuite/20_util/tuple/cons/constexpr_allocator_arg_t.cc new file mode 100644 index 00000000000..6497374b6ec --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/tuple/cons/constexpr_allocator_arg_t.cc @@ -0,0 +1,48 @@ +// { dg-options "-std=gnu++2a" } +// { dg-do compile { target c++2a } } +// +// Copyright (C) 2019 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// . + +#include +#include + +const std::allocator alloc{}; + +constexpr bool +test_tuple() +{ + auto ok = true; + + std::tuple ta(std::allocator_arg, alloc); + std::tuple tb(std::allocator_arg, alloc, 0, 3.456, 6.789); + std::tuple tc(std::allocator_arg, alloc, 0, 3.456f, 6.789f); + std::tuple td(std::allocator_arg, alloc, tb); + std::tuple te(std::allocator_arg, alloc, std::move(tb)); + + std::tuple tf(std::allocator_arg, alloc, 0, 3.456f, 6.789f); + std::tuple tg(std::allocator_arg, alloc, tf); + std::tuple th(std::allocator_arg, alloc, std::move(tf)); + + std::pair pf(12, 3.142f); + std::tuple ti(std::allocator_arg, alloc, pf); + std::tuple tj(std::allocator_arg, alloc, std::move(pf)); + + return ok; +} + +static_assert(test_tuple()); diff --git a/libstdc++-v3/testsuite/20_util/tuple/constexpr_swap.cc b/libstdc++-v3/testsuite/20_util/tuple/constexpr_swap.cc new file mode 100644 index 00000000000..eae14fd53f9 --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/tuple/constexpr_swap.cc @@ -0,0 +1,36 @@ +// { dg-options "-std=gnu++2a" } +// { dg-do compile { target c++2a } } +// +// Copyright (C) 2019 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// . + +#include + +constexpr bool +test_tuple() +{ + auto ok = true; + + std::tuple t1(1, 3.1415, 2.7182); + std::tuple t2(1, 4.1234, 3.3333); + t1.swap(t2); + std::swap(t1, t2); + + return ok; +} + +static_assert(test_tuple()); diff --git a/libstdc++-v3/testsuite/20_util/uses_allocator/69293_neg.cc b/libstdc++-v3/testsuite/20_util/uses_allocator/69293_neg.cc index 8f2d4b16a16..e216a35d349 100644 --- a/libstdc++-v3/testsuite/20_util/uses_allocator/69293_neg.cc +++ b/libstdc++-v3/testsuite/20_util/uses_allocator/69293_neg.cc @@ -45,4 +45,5 @@ test01() alloc_type a; std::tuple t(std::allocator_arg, a); // this is required to be ill-formed // { dg-error "failed: .* uses_allocator is true" "" { target *-*-* } 0 } + // { dg-error "no matching function for call" "" { target c++2a } 0 } } diff --git a/libstdc++-v3/testsuite/20_util/uses_allocator/cons_neg.cc b/libstdc++-v3/testsuite/20_util/uses_allocator/cons_neg.cc index abad4ec6a3a..7955650bdad 100644 --- a/libstdc++-v3/testsuite/20_util/uses_allocator/cons_neg.cc +++ b/libstdc++-v3/testsuite/20_util/uses_allocator/cons_neg.cc @@ -44,3 +44,4 @@ void test01() tuple t(allocator_arg, a, 1); } // { dg-error "failed: .* uses_allocator is true" "" { target *-*-* } 0 } +// { dg-error "no matching function for call" "" { target c++2a } 0 } -- 2.30.2