I do this with a rather heavy heart, but since gcc6 compiles boost 1.62, I'll rather have gcc7 do so as well, and I'll throw the tuple fix for lwg2729 to the wolves not because I want to, but because I have to.
Tested on Linux-x64. 2016-10-01 Ville Voutilainen <ville.voutilai...@gmail.com> PR libstdc++/77802 * testsuite/20_util/tuple/77802.cc: New. Revert: 2016-09-21 Ville Voutilainen <ville.voutilai...@gmail.com> Implement LWG 2729 for tuple. * include/std/tuple (_Tuple_impl(_Tuple_impl&&)): Suppress conditionally. (_Tuple_impl(_Tuple_impl<_Idx, _UHead, _UTails...>&&)): Likewise. (__is_tuple_impl_trait_impl, __is_tuple_impl_trait): New. (_Tuple_impl(const _Head&)): Constrain. (_Tuple_impl(_UHead&&)): Likewise. (_Tuple_impl(_Tuple_impl&&)): Suppress conditionally. (_Tuple_impl(const _Tuple_impl<_Idx, _UHead>&)): Constrain. (_Tuple_impl(_Tuple_impl<_Idx, _UHead>&&)): Likewise. (operator=(const tuple&)): Enable conditionally. (operator=(tuple&&)): Suppress conditionally. (operator=(const tuple<_UElements...>&)): Constrain. (operator=(tuple<_UElements...>&&)): Likewise. (operator=(const tuple&)): Enable conditionally (2-param tuple). (operator=(tuple&&)): Suppress conditionally (2-param tuple). (operator=(const tuple<_U1, _U2>&)): Constrain. (operator=(tuple<_U1, _U2>&&)): Likewise. (operator=(const pair<_U1, _U2>&)): Likewise. (operator=(pair<_U1, _U2>&&)): Likewise. * testsuite/20_util/tuple/element_access/get_neg.cc: Adjust. * testsuite/20_util/tuple/tuple_traits.cc: New.
diff --git a/libstdc++-v3/include/std/tuple b/libstdc++-v3/include/std/tuple index 32b932f..c06a040 100644 --- a/libstdc++-v3/include/std/tuple +++ b/libstdc++-v3/include/std/tuple @@ -220,11 +220,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION constexpr _Tuple_impl(const _Tuple_impl&) = default; constexpr - _Tuple_impl(typename conditional< - __and_<is_move_constructible<_Head>, - is_move_constructible<_Inherited>>::value, - _Tuple_impl&&, __nonesuch&&>::type __in) - noexcept(__and_<is_nothrow_move_constructible<_Head>, + _Tuple_impl(_Tuple_impl&& __in) + noexcept(__and_<is_nothrow_move_constructible<_Head>, is_nothrow_move_constructible<_Inherited>>::value) : _Inherited(std::move(_M_tail(__in))), _Base(std::forward<_Head>(_M_head(__in))) { } @@ -235,11 +232,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION _Base(_Tuple_impl<_Idx, _UElements...>::_M_head(__in)) { } template<typename _UHead, typename... _UTails> - constexpr _Tuple_impl(typename conditional< - __and_<is_move_constructible<_Head>, - is_move_constructible<_Inherited>>::value, - _Tuple_impl<_Idx, _UHead, _UTails...>&&, - __nonesuch&&>::type __in) + constexpr _Tuple_impl(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in) : _Inherited(std::move (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))), _Base(std::forward<_UHead> @@ -345,18 +338,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION } }; - template<typename...> - struct __is_tuple_impl_trait_impl : false_type - { }; - - template<std::size_t _Idx, typename... _Tp> - struct __is_tuple_impl_trait_impl<_Tuple_impl<_Idx, _Tp...>> : true_type - { }; - - template<typename _Tp> - struct __is_tuple_impl_trait : public __is_tuple_impl_trait_impl<_Tp> - { }; - // Basis case of inheritance recursion. template<std::size_t _Idx, typename _Head> struct _Tuple_impl<_Idx, _Head> @@ -375,20 +356,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION constexpr _Tuple_impl() : _Base() { } - template<typename _Dummy=void, - typename enable_if<is_constructible<_Base, const _Head&>::value, - bool>::type=true> explicit constexpr _Tuple_impl(const _Head& __head) : _Base(__head) { } - template<typename _UHead, - typename enable_if<__and_<is_constructible<_Base, _UHead&&>, - __not_<__is_tuple_impl_trait< - typename - remove_reference<_UHead>::type>> - >::value, - bool>::type = true> + template<typename _UHead> explicit constexpr _Tuple_impl(_UHead&& __head) : _Base(std::forward<_UHead>(__head)) { } @@ -396,21 +368,15 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION constexpr _Tuple_impl(const _Tuple_impl&) = default; constexpr - _Tuple_impl(typename conditional< - is_move_constructible<_Head>::value, - _Tuple_impl&&, __nonesuch&&>::type __in) + _Tuple_impl(_Tuple_impl&& __in) noexcept(is_nothrow_move_constructible<_Head>::value) : _Base(std::forward<_Head>(_M_head(__in))) { } - template<typename _UHead, - typename enable_if<!is_same<_Head, _UHead>::value, - bool>::type = true> + template<typename _UHead> constexpr _Tuple_impl(const _Tuple_impl<_Idx, _UHead>& __in) : _Base(_Tuple_impl<_Idx, _UHead>::_M_head(__in)) { } - template<typename _UHead, - typename enable_if<!is_same<_Head, _UHead>::value, - bool>::type = true> + template<typename _UHead> constexpr _Tuple_impl(_Tuple_impl<_Idx, _UHead>&& __in) : _Base(std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in))) { } @@ -866,18 +832,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { } tuple& - operator=(typename - conditional<__and_<is_copy_assignable<_Elements>...>::value, - const tuple&, const __nonesuch&>::type __in) + operator=(const tuple& __in) { static_cast<_Inherited&>(*this) = __in; return *this; } tuple& - operator=(typename - conditional<__and_<is_move_assignable<_Elements>...>::value, - tuple&&, __nonesuch&&>::type __in) + operator=(tuple&& __in) noexcept(is_nothrow_move_assignable<_Inherited>::value) { static_cast<_Inherited&>(*this) = std::move(__in); @@ -886,10 +848,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template<typename... _UElements, typename = typename enable_if<sizeof...(_UElements) - == sizeof...(_Elements) - && - __and_<is_assignable<_Elements&, - const _UElements&>...>::value>::type> + == sizeof...(_Elements)>::type> tuple& operator=(const tuple<_UElements...>& __in) { @@ -899,10 +858,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template<typename... _UElements, typename = typename enable_if<sizeof...(_UElements) - == sizeof...(_Elements) - && - __and_<is_assignable<_Elements&, - _UElements&&>...>::value>::type> + == sizeof...(_Elements)>::type> tuple& operator=(tuple<_UElements...>&& __in) { @@ -1233,20 +1189,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION std::forward<_U2>(__in.second)) { } tuple& - operator=(typename - conditional<__and_<is_copy_assignable<_T1>, - is_copy_assignable<_T2>>::value, - const tuple&, const __nonesuch&>::type __in) + operator=(const tuple& __in) { static_cast<_Inherited&>(*this) = __in; return *this; } tuple& - operator=(typename - conditional<__and_<is_move_assignable<_T1>, - is_move_assignable<_T2>>::value, - tuple&&, __nonesuch&&>::type __in) + operator=(tuple&& __in) noexcept(is_nothrow_move_assignable<_Inherited>::value) { static_cast<_Inherited&>(*this) = std::move(__in); @@ -1254,10 +1204,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION } template<typename _U1, typename _U2> - typename - enable_if<__and_<is_assignable<_T1&, const _U1&>, - is_assignable<_T2&, const _U2&>>::value, - tuple&>::type + tuple& operator=(const tuple<_U1, _U2>& __in) { static_cast<_Inherited&>(*this) = __in; @@ -1265,10 +1212,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION } template<typename _U1, typename _U2> - typename - enable_if<__and_<is_assignable<_T1&, _U1&&>, - is_assignable<_T2&, _U2&&>>::value, - tuple&>::type + tuple& operator=(tuple<_U1, _U2>&& __in) { static_cast<_Inherited&>(*this) = std::move(__in); @@ -1276,10 +1220,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION } template<typename _U1, typename _U2> - typename - enable_if<__and_<is_assignable<_T1&, const _U1&>, - is_assignable<_T2&, const _U2&>>::value, - tuple&>::type + tuple& operator=(const pair<_U1, _U2>& __in) { this->_M_head(*this) = __in.first; @@ -1288,10 +1229,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION } template<typename _U1, typename _U2> - typename - enable_if<__and_<is_assignable<_T1&, _U1&&>, - is_assignable<_T2&, _U2&&>>::value, - tuple&>::type + tuple& operator=(pair<_U1, _U2>&& __in) { this->_M_head(*this) = std::forward<_U1>(__in.first); diff --git a/libstdc++-v3/testsuite/20_util/tuple/77802.cc b/libstdc++-v3/testsuite/20_util/tuple/77802.cc new file mode 100644 index 0000000..6e9c18e --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/tuple/77802.cc @@ -0,0 +1,40 @@ +// { dg-do compile { target c++11 } } + +// Copyright (C) 2016 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 +// <http://www.gnu.org/licenses/>. + +#include <tuple> + +template <typename... Args> struct execution_context +{ + typedef std::tuple<Args...> args_tpl_t; + typedef std::tuple<execution_context, typename std::decay<Args>::type...> + ret_tpl_t; + execution_context(); + execution_context(execution_context &&); + ret_tpl_t operator()() { + args_tpl_t data; + return tuple_cat(std::forward_as_tuple(execution_context()), data); + } +}; + +void fn1() +{ + execution_context<int> cc; + cc(); +} + diff --git a/libstdc++-v3/testsuite/20_util/tuple/element_access/get_neg.cc b/libstdc++-v3/testsuite/20_util/tuple/element_access/get_neg.cc index 1c08d45..5bcf576 100644 --- a/libstdc++-v3/testsuite/20_util/tuple/element_access/get_neg.cc +++ b/libstdc++-v3/testsuite/20_util/tuple/element_access/get_neg.cc @@ -17,7 +17,7 @@ // { dg-options "-fno-show-column" } // { dg-do compile { target c++14 } } -// { dg-error "in range" "" { target *-*-* } 1342 } +// { dg-error "in range" "" { target *-*-* } 1280 } #include <tuple> diff --git a/libstdc++-v3/testsuite/20_util/tuple/tuple_traits.cc b/libstdc++-v3/testsuite/20_util/tuple/tuple_traits.cc deleted file mode 100644 index b72f535..0000000 --- a/libstdc++-v3/testsuite/20_util/tuple/tuple_traits.cc +++ /dev/null @@ -1,244 +0,0 @@ -// { dg-do compile { target c++11 } } - -// Copyright (C) 2016 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 -// <http://www.gnu.org/licenses/>. - -#include <tuple> -#include <type_traits> -#include <utility> -#include <vector> -#include <memory> - -using namespace std; - -struct Poison -{ - Poison(Poison&&) = delete; -}; - - -int main() -{ - static_assert(!is_copy_constructible<Poison>::value, ""); - static_assert(!is_move_constructible<Poison>::value, ""); - static_assert(!is_copy_assignable<Poison>::value, ""); - static_assert(!is_move_assignable<Poison>::value, ""); - - static_assert(!is_copy_constructible<std::tuple<Poison>>::value, ""); - static_assert(!is_move_constructible<std::tuple<Poison>>::value, ""); - static_assert(!is_copy_assignable<std::tuple<Poison>>::value, ""); - static_assert(!is_move_assignable<std::tuple<Poison>>::value, ""); - - static_assert(!is_copy_constructible<std::tuple<int, Poison>>::value, - ""); - static_assert(!is_move_constructible<std::tuple<int, Poison>>::value, - ""); - static_assert(!is_copy_assignable<std::tuple<int, Poison>>::value, ""); - static_assert(!is_move_assignable<std::tuple<int, Poison>>::value, ""); - static_assert(!is_constructible<std::tuple<int, Poison>&, - std::tuple<char, Poison>&>::value, ""); - static_assert(!is_assignable<std::tuple<int, Poison>&, - std::tuple<char, Poison>&>::value, ""); - static_assert(!is_constructible<std::tuple<int, Poison>&, - std::tuple<char, Poison>>::value, ""); - static_assert(!is_assignable<std::tuple<int, Poison>&, - std::tuple<char, Poison>>::value, ""); - static_assert(!is_constructible<std::tuple<int, Poison>&, - std::pair<char, Poison>&>::value, ""); - static_assert(!is_assignable<std::tuple<int, Poison>&, - std::pair<char, Poison>&>::value, ""); - static_assert(!is_constructible<std::tuple<int, Poison>&, - std::pair<char, Poison>>::value, ""); - static_assert(!is_assignable<std::tuple<int, Poison>&, - std::pair<char, Poison>>::value, ""); - - static_assert(!is_copy_constructible< - std::tuple<int, int, Poison>>::value, ""); - static_assert(!is_move_constructible< - std::tuple<int, int, Poison>>::value, ""); - static_assert(!is_copy_assignable< - std::tuple<int, int, Poison>>::value, ""); - static_assert(!is_move_assignable< - std::tuple<int, int, Poison>>::value, ""); - static_assert(!is_constructible< - std::tuple<int, int,Poison>&, - std::tuple<int, char, Poison>&>::value, ""); - static_assert(!is_assignable< - std::tuple<int, int, Poison>&, - std::tuple<int, char, Poison>&>::value, ""); - static_assert(!is_constructible< - std::tuple<int, int, Poison>&, - std::tuple<int, char, Poison>>::value, ""); - static_assert(!is_assignable< - std::tuple<int, int, Poison>&, - std::tuple<int, char, Poison>>::value, ""); - static_assert(!is_constructible< - std::tuple<int, int, Poison>&, - std::pair<char, Poison>&>::value, ""); - static_assert(!is_assignable< - std::tuple<int, int, Poison>&, - std::pair<char, Poison>&>::value, ""); - static_assert(!is_constructible< - std::tuple<int, int, Poison>&, - std::pair<char, Poison>>::value, ""); - static_assert(!is_assignable< - std::tuple<int, int, Poison>&, - std::pair<char, Poison>>::value, ""); - - static_assert(is_trivially_copy_constructible<tuple<int>>::value, ""); - static_assert(!is_trivially_move_constructible<tuple<int>>::value, ""); - - static_assert(!is_trivially_copy_assignable<tuple<int>>::value, ""); - static_assert(!is_trivially_move_assignable<tuple<int>>::value, ""); - - static_assert(is_copy_constructible<tuple<int>>::value, ""); - static_assert(is_move_constructible<tuple<int>>::value, ""); - - static_assert(is_copy_assignable<tuple<int>>::value, ""); - static_assert(is_move_assignable<tuple<int>>::value, ""); - - static_assert(!is_trivially_copy_constructible< - tuple<vector<int>>>::value, ""); - static_assert(!is_trivially_move_constructible< - tuple<vector<int>>>::value, ""); - - static_assert(!is_trivially_copy_assignable< - tuple<vector<int>>>::value, ""); - static_assert(!is_trivially_move_assignable< - tuple<vector<int>>>::value, ""); - - static_assert(is_copy_constructible<tuple<vector<int>>>::value, ""); - static_assert(is_move_constructible<tuple<vector<int>>>::value, ""); - - static_assert(is_copy_assignable<tuple<vector<int>>>::value, ""); - static_assert(is_move_assignable<tuple<vector<int>>>::value, ""); - - static_assert(!is_trivially_copy_constructible< - tuple<unique_ptr<int>>>::value, ""); - static_assert(!is_trivially_move_constructible< - tuple<unique_ptr<int>>>::value, ""); - - static_assert(!is_trivially_copy_assignable< - tuple<unique_ptr<int>>>::value, ""); - static_assert(!is_trivially_move_assignable< - tuple<unique_ptr<int>>>::value, ""); - static_assert(!is_copy_constructible< - tuple<unique_ptr<int>>>::value, ""); - static_assert(is_move_constructible<tuple<unique_ptr<int>>>::value, ""); - - static_assert(!is_copy_assignable<tuple<unique_ptr<int>>>::value, ""); - static_assert(is_move_assignable<tuple<unique_ptr<int>>>::value, ""); - - static_assert(is_trivially_copy_constructible< - tuple<int, int>>::value, ""); - static_assert(!is_trivially_move_constructible< - tuple<int, int>>::value, ""); - - static_assert(!is_trivially_copy_assignable< - tuple<int, int>>::value, ""); - static_assert(!is_trivially_move_assignable< - tuple<int, int>>::value, ""); - - static_assert(is_copy_constructible<tuple<int, int>>::value, ""); - static_assert(is_move_constructible<tuple<int, int>>::value, ""); - - static_assert(is_copy_assignable<tuple<int, int>>::value, ""); - static_assert(is_move_assignable<tuple<int, int>>::value, ""); - static_assert(!is_trivially_copy_constructible< - tuple<int, vector<int>>>::value, ""); - static_assert(!is_trivially_move_constructible< - tuple<int, vector<int>>>::value, ""); - - static_assert(!is_trivially_copy_assignable< - tuple<int, vector<int>>>::value, ""); - static_assert(!is_trivially_move_assignable< - tuple<int, vector<int>>>::value, ""); - - static_assert(is_copy_constructible< - tuple<int, vector<int>>>::value, ""); - static_assert(is_move_constructible< - tuple<int, vector<int>>>::value, ""); - - static_assert(is_copy_assignable<tuple<int, vector<int>>>::value, ""); - static_assert(is_move_assignable<tuple<int, vector<int>>>::value, ""); - - static_assert(!is_trivially_copy_constructible< - tuple<int, unique_ptr<int>>>::value, ""); - static_assert(!is_trivially_move_constructible< - tuple<int, unique_ptr<int>>>::value, ""); - - static_assert(!is_trivially_copy_assignable< - tuple<int, unique_ptr<int>>>::value, ""); - static_assert(!is_trivially_move_assignable< - tuple<int, unique_ptr<int>>>::value, ""); - - static_assert(!is_copy_constructible< - tuple<int, unique_ptr<int>>>::value, ""); - static_assert(is_move_constructible< - tuple<int, unique_ptr<int>>>::value, ""); - - static_assert(!is_copy_assignable< - tuple<int, unique_ptr<int>>>::value, ""); - static_assert(is_move_assignable< - tuple<int, unique_ptr<int>>>::value, ""); - - static_assert(is_copy_constructible<tuple<int, int, int>>::value, ""); - static_assert(is_move_constructible<tuple<int, int, int>>::value, ""); - - static_assert(is_copy_assignable<tuple<int, int, int>>::value, ""); - static_assert(is_move_assignable<tuple<int, int, int>>::value, ""); - - static_assert(!is_trivially_copy_constructible< - tuple<int, int, vector<int>>>::value, ""); - static_assert(!is_trivially_move_constructible< - tuple<int, int, vector<int>>>::value, ""); - - static_assert(!is_trivially_copy_assignable< - tuple<int, int, vector<int>>>::value, ""); - static_assert(!is_trivially_move_assignable< - tuple<int, int, vector<int>>>::value, ""); - - static_assert(is_copy_constructible< - tuple<int, int, vector<int>>>::value, ""); - static_assert(is_move_constructible< - tuple<int, int, vector<int>>>::value, ""); - - static_assert(is_copy_assignable< - tuple<int, int, vector<int>>>::value, ""); - static_assert(is_move_assignable< - tuple<int, int, vector<int>>>::value, ""); - - static_assert(!is_trivially_copy_constructible< - tuple<int, int, unique_ptr<int>>>::value, ""); - static_assert(!is_trivially_move_constructible< - tuple<int, int, unique_ptr<int>>>::value, ""); - - static_assert(!is_trivially_copy_assignable< - tuple<int, int, unique_ptr<int>>>::value, ""); - static_assert(!is_trivially_move_assignable< - tuple<int, int, unique_ptr<int>>>::value, ""); - - static_assert(!is_copy_constructible< - tuple<int, int, unique_ptr<int>>>::value, ""); - static_assert(is_move_constructible< - tuple<int, int, unique_ptr<int>>>::value, ""); - - static_assert(!is_copy_assignable< - tuple<int, int, unique_ptr<int>>>::value, ""); - static_assert(is_move_assignable< - tuple<int, int, unique_ptr<int>>>::value, ""); -}