From: redi Date: Tue, 12 Jan 2016 21:19:58 +0000 (+0000) Subject: libstdc++/68877 Reimplement std::__is_swappable X-Git-Url: http://git.ipfire.org/?a=commitdiff_plain;h=03ff028945a51ed376f0039e586eb76da0f437dd;p=thirdparty%2Fgcc.git libstdc++/68877 Reimplement std::__is_swappable 2016-01-12 Daniel Kruegler PR libstdc++/68877 * include/std/type_traits: Following N4511, reimplement __is_swappable and __is_nothrow_swappable. Move __is_swappable to namespace std, adjust callers. Use __is_nothrow_swappable in swap. * include/bits/move.h: Use __is_nothrow_swappable in swap. * testsuite/20_util/is_nothrow_swappable/value.cc: Extend; remove __is_swappable related tests. * testsuite/20_util/is_swappable/value.cc: New. * testsuite/20_util/is_swappable/requirements/ explicit_instantiation.cc: New. * testsuite/20_util/is_swappable/requirements/typedefs.cc: New. * testsuite/25_algorithms/swap/68877.cc: New. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@232296 138bc75d-0d04-0410-961f-82ee72b054a4 --- diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog index 6713591fdbd5..95dbb439d816 100644 --- a/libstdc++-v3/ChangeLog +++ b/libstdc++-v3/ChangeLog @@ -1,3 +1,18 @@ +2016-01-12 Daniel Kruegler + + PR libstdc++/68877 + * include/std/type_traits: Following N4511, reimplement __is_swappable + and __is_nothrow_swappable. Move __is_swappable to namespace std, + adjust callers. Use __is_nothrow_swappable in swap. + * include/bits/move.h: Use __is_nothrow_swappable in swap. + * testsuite/20_util/is_nothrow_swappable/value.cc: Extend; remove + __is_swappable related tests. + * testsuite/20_util/is_swappable/value.cc: New. + * testsuite/20_util/is_swappable/requirements/ + explicit_instantiation.cc: New. + * testsuite/20_util/is_swappable/requirements/typedefs.cc: New. + * testsuite/25_algorithms/swap/68877.cc: New. + 2016-01-12 Jonathan Wakely * testsuite/20_util/function/68995.cc: Test reference_wrapper cases. diff --git a/libstdc++-v3/include/bits/move.h b/libstdc++-v3/include/bits/move.h index a9bcdca37c14..afcea2d84680 100644 --- a/libstdc++-v3/include/bits/move.h +++ b/libstdc++-v3/include/bits/move.h @@ -198,9 +198,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template inline #if __cplusplus >= 201103L - typename enable_if<__is_swappable_impl::__is_swappable<_Tp>::value>::type + typename enable_if<__is_swappable<_Tp>::value>::type swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm]) - noexcept(noexcept(swap(*__a, *__b))) + noexcept(__is_nothrow_swappable<_Tp>::value) #else void swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm]) diff --git a/libstdc++-v3/include/std/type_traits b/libstdc++-v3/include/std/type_traits index 37f039bcfe14..3a2b546b22f4 100644 --- a/libstdc++-v3/include/std/type_traits +++ b/libstdc++-v3/include/std/type_traits @@ -2587,12 +2587,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION : true_type \ { }; + template + struct __is_swappable; - namespace __is_swappable_impl { - template - struct __is_swappable : public false_type - { }; - } + template + struct __is_nothrow_swappable; template inline @@ -2604,33 +2603,58 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template inline - typename enable_if<__is_swappable_impl::__is_swappable<_Tp>::value>::type + typename enable_if<__is_swappable<_Tp>::value>::type swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm]) - noexcept(noexcept(swap(*__a, *__b))); + noexcept(__is_nothrow_swappable<_Tp>::value); - namespace __is_swappable_impl { + namespace __swappable_details { using std::swap; - template - struct __is_swappable<_Tp, __void_t(), - declval<_Tp&>()))>> - : public true_type - { }; + struct __do_is_swappable_impl + { + template(), std::declval<_Tp&>()))> + static true_type __test(int); + + template + static false_type __test(...); + }; + + struct __do_is_nothrow_swappable_impl + { + template + static __bool_constant< + noexcept(swap(std::declval<_Tp&>(), std::declval<_Tp&>())) + > __test(int); + + template + static false_type __test(...); + }; + } - template + template + struct __is_swappable_impl + : public __swappable_details::__do_is_swappable_impl + { + typedef decltype(__test<_Tp>(0)) type; + }; + + template struct __is_nothrow_swappable_impl - : public __bool_constant(), declval<_Tp&>()))> - { }; + : public __swappable_details::__do_is_nothrow_swappable_impl + { + typedef decltype(__test<_Tp>(0)) type; + }; - template - struct __is_nothrow_swappable_impl : public false_type + template + struct __is_swappable + : public __is_swappable_impl<_Tp>::type { }; - template + template struct __is_nothrow_swappable - : public __is_nothrow_swappable_impl< - __is_swappable_impl::__is_swappable<_Tp>::value, _Tp> + : public __is_nothrow_swappable_impl<_Tp>::type { }; _GLIBCXX_END_NAMESPACE_VERSION diff --git a/libstdc++-v3/testsuite/20_util/is_nothrow_swappable/value.cc b/libstdc++-v3/testsuite/20_util/is_nothrow_swappable/value.cc index eccc0bee42ba..5f93891b8a50 100644 --- a/libstdc++-v3/testsuite/20_util/is_nothrow_swappable/value.cc +++ b/libstdc++-v3/testsuite/20_util/is_nothrow_swappable/value.cc @@ -29,32 +29,195 @@ namespace funny { struct F {}; void swap(F&, F&) = delete; + void swap(F(&)[5], F(&)[5]) noexcept; + void swap(F(&)[6], F(&)[6]); + struct A {}; + void swap(A&, A&) noexcept(false); +} +namespace std { + template<> + void swap(funny::A&, funny::A&) noexcept + { + } + + template<> + void swap(funny::A(&)[3], funny::A(&)[3]) noexcept(false) + { + } +} +namespace ns1 { + struct SwapThrow {}; + void swap(SwapThrow&, SwapThrow&); + void swap(SwapThrow(&)[3], SwapThrow(&)[3]) noexcept; +} + +namespace ns2 { + struct SwapThrow { + SwapThrow() noexcept = default; + SwapThrow(const SwapThrow&) noexcept(false); + SwapThrow& operator=(const SwapThrow&) noexcept(false); + }; +} + +namespace ns3 { + struct SwapNoThrow { + SwapNoThrow() noexcept = default; + SwapNoThrow(const SwapNoThrow&) noexcept(false); + SwapNoThrow& operator =(const SwapNoThrow&) noexcept(false); + }; + void swap(SwapNoThrow&, SwapNoThrow&) noexcept; +} + +namespace ns4 { + struct SwapNoThrow {}; +} + +namespace ns5 { + struct SwapThrow { + SwapThrow() noexcept = default; + SwapThrow(SwapThrow&&) noexcept; + SwapThrow& operator=(const SwapThrow&) noexcept(false); + }; } void test01() { using std::__is_nothrow_swappable; - using std::__is_swappable_impl::__is_swappable; using namespace __gnu_test; // Positive tests. - static_assert(test_property<__is_swappable, int>(true), ""); static_assert(test_property<__is_nothrow_swappable, int>(true), ""); + static_assert(test_property<__is_nothrow_swappable, bool>(true), ""); + static_assert(test_property<__is_nothrow_swappable, + decltype(nullptr)>(true), ""); + static_assert(test_property<__is_nothrow_swappable, int&>(true), ""); + static_assert(test_property<__is_nothrow_swappable, int&&>(true), ""); static_assert(test_property<__is_nothrow_swappable, int[1]>(true), ""); + static_assert(test_property<__is_nothrow_swappable, int[1][2]>(true), ""); + static_assert(test_property<__is_nothrow_swappable, int[1][2][3]>(true), ""); + static_assert(test_property<__is_nothrow_swappable, funny::F[5]>(true), ""); + static_assert(test_property<__is_nothrow_swappable, EnumType>(true), ""); + static_assert(test_property<__is_nothrow_swappable, PODType>(true), ""); + static_assert(test_property<__is_nothrow_swappable, UnionType>(true), ""); + static_assert(test_property<__is_nothrow_swappable, + construct::SE>(true), ""); + static_assert(test_property<__is_nothrow_swappable, + construct::Empty>(true), ""); + static_assert(test_property<__is_nothrow_swappable, void*>(true), ""); + static_assert(test_property<__is_nothrow_swappable, void(*)()>(true), ""); + static_assert(test_property<__is_nothrow_swappable, int const*>(true), ""); + static_assert(test_property<__is_nothrow_swappable, ClassType*>(true), ""); + static_assert(test_property<__is_nothrow_swappable, + int ClassType::*>(true), ""); + static_assert(test_property<__is_nothrow_swappable, + void (ClassType::*)()>(true), ""); + static_assert(test_property<__is_nothrow_swappable, + int (ClassType::*)() const volatile>(true), ""); + static_assert(test_property<__is_nothrow_swappable, + ns1::SwapThrow[3]>(true), ""); + static_assert(!noexcept(std::swap(std::declval(), + std::declval())), + ""); + static_assert(test_property<__is_nothrow_swappable, + ns3::SwapNoThrow>(true), ""); + static_assert(!noexcept(std::swap(std::declval(), + std::declval())), ""); + static_assert(test_property<__is_nothrow_swappable, + ns3::SwapNoThrow[1]>(true), ""); + static_assert(test_property<__is_nothrow_swappable, + ns3::SwapNoThrow[3]>(true), ""); + static_assert(test_property<__is_nothrow_swappable, + ns3::SwapNoThrow[2][3][4]>(true), ""); + static_assert(test_property<__is_nothrow_swappable, + ns4::SwapNoThrow>(true), ""); + static_assert(test_property<__is_nothrow_swappable, + ns4::SwapNoThrow[1]>(true), ""); + static_assert(test_property<__is_nothrow_swappable, + ns4::SwapNoThrow[3]>(true), ""); + static_assert(test_property<__is_nothrow_swappable, + ns4::SwapNoThrow[2][3][4]>(true), ""); + static_assert(test_property<__is_nothrow_swappable, + std::pair>(true), ""); static_assert(test_property<__is_nothrow_swappable, - std::pair>(true), ""); + std::pair[1]>(true), ""); static_assert(test_property<__is_nothrow_swappable, - std::tuple>(true), ""); + std::pair[1][2]>(true), ""); static_assert(test_property<__is_nothrow_swappable, - std::array>(true), ""); + std::tuple>(true), ""); static_assert(test_property<__is_nothrow_swappable, - std::queue>(true), ""); + std::tuple[1]>(true), ""); static_assert(test_property<__is_nothrow_swappable, - std::priority_queue>(true), ""); + std::tuple[1][2]>(true), ""); static_assert(test_property<__is_nothrow_swappable, - std::stack>(true), ""); + std::tuple<>>(true), ""); + static_assert(test_property<__is_nothrow_swappable, + std::tuple<>[1]>(true), ""); + static_assert(test_property<__is_nothrow_swappable, + std::tuple<>[1][2]>(true), ""); + static_assert(test_property<__is_nothrow_swappable, + std::array>(true), ""); + static_assert(test_property<__is_nothrow_swappable, + std::queue>(true), ""); + static_assert(test_property<__is_nothrow_swappable, + std::priority_queue>(true), ""); + static_assert(test_property<__is_nothrow_swappable, + std::stack>(true), ""); // Negative tests. - static_assert(test_property<__is_swappable, construct::DelCopy>(false), ""); - static_assert(test_property<__is_swappable, funny::F>(false), ""); - static_assert(test_property<__is_swappable, funny::F[1]>(false), ""); + static_assert(test_property<__is_nothrow_swappable, void>(false), ""); + static_assert(test_property<__is_nothrow_swappable, const void>(false), ""); + static_assert(test_property<__is_nothrow_swappable, void()>(false), ""); + static_assert(test_property<__is_nothrow_swappable, + void() const>(false), ""); + static_assert(test_property<__is_nothrow_swappable, + void() volatile>(false), ""); + static_assert(test_property<__is_nothrow_swappable, + void() const volatile>(false), ""); + static_assert(test_property<__is_nothrow_swappable, const int>(false), ""); + static_assert(test_property<__is_nothrow_swappable, const bool>(false), ""); + static_assert(test_property<__is_nothrow_swappable, + const int[1]>(false), ""); + static_assert(test_property<__is_nothrow_swappable, + const int[1][2]>(false), ""); + static_assert(test_property<__is_nothrow_swappable, + const int[1][2][3]>(false), ""); + static_assert(test_property<__is_nothrow_swappable, int[]>(false), ""); + static_assert(test_property<__is_nothrow_swappable, const int[]>(false), ""); + static_assert(test_property<__is_nothrow_swappable, int[][1]>(false), ""); + static_assert(test_property<__is_nothrow_swappable, + const funny::F[5]>(false), ""); + static_assert(test_property<__is_nothrow_swappable, + construct::Abstract>(false), ""); + static_assert(test_property<__is_nothrow_swappable, + construct::DelCopy>(false), ""); + static_assert(test_property<__is_nothrow_swappable, funny::F>(false), ""); + static_assert(test_property<__is_nothrow_swappable, funny::F[1]>(false), ""); + static_assert(test_property<__is_nothrow_swappable, + funny::F[1][2]>(false), ""); + static_assert(test_property<__is_nothrow_swappable, + funny::F[1][2][3]>(false), ""); + static_assert(test_property<__is_nothrow_swappable, funny::F[6]>(false), ""); + static_assert(test_property<__is_nothrow_swappable, funny::A>(false), ""); + static_assert(noexcept(std::swap(std::declval(), + std::declval())), ""); + static_assert(test_property<__is_nothrow_swappable, funny::A[3]>(false), ""); + static_assert(test_property<__is_nothrow_swappable, + ns1::SwapThrow>(false), ""); + static_assert(test_property<__is_nothrow_swappable, + ns1::SwapThrow[1]>(false), ""); + static_assert(test_property<__is_nothrow_swappable, + ns1::SwapThrow[3][2]>(false), ""); + static_assert(test_property<__is_nothrow_swappable, + ns1::SwapThrow[2][3][4]>(false), ""); + static_assert(test_property<__is_nothrow_swappable, + ns2::SwapThrow>(false), ""); + static_assert(test_property<__is_nothrow_swappable, + ns2::SwapThrow[1]>(false), ""); + static_assert(test_property<__is_nothrow_swappable, + ns2::SwapThrow[2][3][4]>(false), ""); + static_assert(test_property<__is_nothrow_swappable, + ns5::SwapThrow>(false), ""); + static_assert(test_property<__is_nothrow_swappable, + ns5::SwapThrow[1]>(false), ""); + static_assert(test_property<__is_nothrow_swappable, + ns5::SwapThrow[2][3][4]>(false), ""); static_assert(test_property<__is_nothrow_swappable, ThrowCopyConsClass>(false), ""); static_assert(test_property<__is_nothrow_swappable, diff --git a/libstdc++-v3/testsuite/20_util/is_swappable/requirements/explicit_instantiation.cc b/libstdc++-v3/testsuite/20_util/is_swappable/requirements/explicit_instantiation.cc new file mode 100644 index 000000000000..c3f93435290e --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/is_swappable/requirements/explicit_instantiation.cc @@ -0,0 +1,27 @@ +// { dg-options "-std=gnu++11" } +// { dg-do compile } + +// Copyright (C) 2015 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 + +namespace std +{ + typedef short test_type; + template struct std::__is_swappable; +} diff --git a/libstdc++-v3/testsuite/20_util/is_swappable/requirements/typedefs.cc b/libstdc++-v3/testsuite/20_util/is_swappable/requirements/typedefs.cc new file mode 100644 index 000000000000..a1e289bb01fa --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/is_swappable/requirements/typedefs.cc @@ -0,0 +1,31 @@ +// { dg-options "-std=gnu++11" } +// { dg-do compile } + +// Copyright (C) 2015 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 + +void test01() +{ + // Check for required typedefs + typedef std::__is_swappable test_type; + typedef test_type::value_type value_type; + typedef test_type::type type; + typedef test_type::type::value_type type_value_type; + typedef test_type::type::type type_type; +} diff --git a/libstdc++-v3/testsuite/20_util/is_swappable/value.cc b/libstdc++-v3/testsuite/20_util/is_swappable/value.cc new file mode 100644 index 000000000000..d594cf652a58 --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/is_swappable/value.cc @@ -0,0 +1,185 @@ +// { dg-options "-std=gnu++11" } +// { dg-do compile } + +// Copyright (C) 2015 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 +#include +#include +#include +#include +#include + +namespace funny { + struct F {}; + void swap(F&, F&) = delete; + void swap(F(&)[5], F(&)[5]); + + struct F2 + { + friend void swap(F2&, F2&) = delete; + }; + + struct F3 + { + friend void swap(F3&, F3) {} + }; +} +void test01() +{ + using std::__is_swappable; + using namespace __gnu_test; + // Positive tests. + static_assert(test_property<__is_swappable, int>(true), ""); + static_assert(test_property<__is_swappable, bool>(true), ""); + static_assert(test_property<__is_swappable, decltype(nullptr)>(true), ""); + static_assert(test_property<__is_swappable, int&>(true), ""); + static_assert(test_property<__is_swappable, int&&>(true), ""); + static_assert(test_property<__is_swappable, int[1]>(true), ""); + static_assert(test_property<__is_swappable, int[1][2]>(true), ""); + static_assert(test_property<__is_swappable, int[1][2][3]>(true), ""); + static_assert(test_property<__is_swappable, int(&)[1]>(true), ""); + static_assert(test_property<__is_swappable, funny::F[5]>(true), ""); + static_assert(test_property<__is_swappable, funny::F3>(true), ""); + static_assert(test_property<__is_swappable, funny::F3[1]>(true), ""); + static_assert(test_property<__is_swappable, funny::F3[1][2]>(true), ""); + static_assert(test_property<__is_swappable, funny::F3[1][2][3]>(true), ""); + static_assert(test_property<__is_swappable, + ThrowCopyConsClass>(true), ""); + static_assert(test_property<__is_swappable, EnumType>(true), ""); + static_assert(test_property<__is_swappable, PODType>(true), ""); + static_assert(test_property<__is_swappable, UnionType>(true), ""); + static_assert(test_property<__is_swappable, construct::SE>(true), ""); + static_assert(test_property<__is_swappable, construct::Empty>(true), ""); + static_assert(test_property<__is_swappable, void*>(true), ""); + static_assert(test_property<__is_swappable, int const*>(true), ""); + static_assert(test_property<__is_swappable, ClassType*>(true), ""); + static_assert(test_property<__is_swappable, int ClassType::*>(true), ""); + static_assert(test_property<__is_swappable, + void (ClassType::*)()>(true), ""); + static_assert(test_property<__is_swappable, + construct::Nontrivial>(true), ""); + static_assert(test_property<__is_swappable, construct::Any>(true), ""); + static_assert(test_property<__is_swappable, construct::nAny>(true), ""); + static_assert(test_property<__is_swappable, + std::pair>(true), ""); + static_assert(test_property<__is_swappable, + std::pair[1]>(true), ""); + static_assert(test_property<__is_swappable, + std::pair[1][2]>(true), ""); + static_assert(test_property<__is_swappable, + std::pair[1][2][3]>(true), ""); + static_assert(test_property<__is_swappable, + std::pair>(true), ""); + static_assert(test_property<__is_swappable, + std::tuple>(true), ""); + static_assert(test_property<__is_swappable, + std::tuple[1]>(true), ""); + static_assert(test_property<__is_swappable, + std::tuple[1][2]>(true), ""); + static_assert(test_property<__is_swappable, + std::tuple[1][2][3]>(true), ""); + static_assert(test_property<__is_swappable, + std::tuple<>>(true), ""); + static_assert(test_property<__is_swappable, + std::tuple<>[1]>(true), ""); + static_assert(test_property<__is_swappable, + std::tuple<>[1][2]>(true), ""); + static_assert(test_property<__is_swappable, + std::tuple<>[1][2][3]>(true), ""); + static_assert(test_property<__is_swappable, + std::tuple>(true), ""); + static_assert(test_property<__is_swappable, + std::array>(true), ""); + static_assert(test_property<__is_swappable, + std::array[1]>(true), ""); + static_assert(test_property<__is_swappable, + std::array[1][2]>(true), ""); + static_assert(test_property<__is_swappable, + std::array[1][2][3]>(true), ""); + static_assert(test_property<__is_swappable, + std::array>(true), ""); + static_assert(test_property<__is_swappable, + std::queue>(true), ""); + static_assert(test_property<__is_swappable, + std::queue[1]>(true), ""); + static_assert(test_property<__is_swappable, + std::queue[1][2]>(true), ""); + static_assert(test_property<__is_swappable, + std::queue[1][2][3]>(true), ""); + static_assert(test_property<__is_swappable, + std::queue>(true), ""); + static_assert(test_property<__is_swappable, + std::priority_queue>(true), ""); + static_assert(test_property<__is_swappable, + std::priority_queue[1]>(true), ""); + static_assert(test_property<__is_swappable, + std::priority_queue[1][2]>(true), ""); + static_assert(test_property<__is_swappable, + std::priority_queue[1][2][3]>(true), ""); + static_assert(test_property<__is_swappable, + std::priority_queue>(true), ""); + static_assert(test_property<__is_swappable, + std::stack>(true), ""); + static_assert(test_property<__is_swappable, + std::stack[1]>(true), ""); + static_assert(test_property<__is_swappable, + std::stack[1][2]>(true), ""); + static_assert(test_property<__is_swappable, + std::stack[1][2][3]>(true), ""); + static_assert(test_property<__is_swappable, + std::stack>(true), ""); + // Negative tests. + static_assert(test_property<__is_swappable, void>(false), ""); + static_assert(test_property<__is_swappable, const void>(false), ""); + static_assert(test_property<__is_swappable, void()>(false), ""); + static_assert(test_property<__is_swappable, void() const>(false), ""); + static_assert(test_property<__is_swappable, void() volatile>(false), ""); + static_assert(test_property<__is_swappable, + void() const volatile>(false), ""); + static_assert(test_property<__is_swappable, const int>(false), ""); + static_assert(test_property<__is_swappable, const bool>(false), ""); + static_assert(test_property<__is_swappable, int[]>(false), ""); + static_assert(test_property<__is_swappable, const int[]>(false), ""); + static_assert(test_property<__is_swappable, int[][1]>(false), ""); + static_assert(test_property<__is_swappable, const int[1]>(false), ""); + static_assert(test_property<__is_swappable, const int[1][2]>(false), ""); + static_assert(test_property<__is_swappable, const int[1][2][3]>(false), ""); + static_assert(test_property<__is_swappable, construct::DelCopy>(false), ""); + static_assert(test_property<__is_swappable, + construct::Abstract>(false), ""); + static_assert(test_property<__is_swappable, + construct::NontrivialUnion>(false), ""); + static_assert(test_property<__is_swappable, funny::F>(false), ""); + static_assert(test_property<__is_swappable, funny::F[1]>(false), ""); + static_assert(test_property<__is_swappable, funny::F[1][2]>(false), ""); + static_assert(test_property<__is_swappable, funny::F[1][2][3]>(false), ""); + static_assert(test_property<__is_swappable, funny::F[4]>(false), ""); + static_assert(test_property<__is_swappable, construct::DelCopy>(false), ""); + static_assert(test_property<__is_swappable, + DeletedCopyAssignClass>(false), ""); + static_assert(test_property<__is_swappable, + DeletedMoveAssignClass>(false), ""); + static_assert(test_property<__is_swappable, funny::F2>(false), ""); + static_assert(test_property<__is_swappable, funny::F2[1]>(false), ""); + static_assert(test_property<__is_swappable, funny::F2[1][2]>(false), ""); + static_assert(test_property<__is_swappable, funny::F2[1][2][3]>(false), ""); + static_assert(test_property<__is_swappable, funny::F2[4]>(false), ""); + static_assert(test_property<__is_swappable, funny::F2[5]>(false), ""); +} diff --git a/libstdc++-v3/testsuite/25_algorithms/swap/68877.cc b/libstdc++-v3/testsuite/25_algorithms/swap/68877.cc new file mode 100644 index 000000000000..dd5aa8c6f7d0 --- /dev/null +++ b/libstdc++-v3/testsuite/25_algorithms/swap/68877.cc @@ -0,0 +1,33 @@ +// { dg-options "-std=gnu++11" } +// { dg-do compile } + +// Copyright (C) 2015 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 + +// libstdc++/68877 +void test01() +{ + int x[2][3]; + int y[2][3]; + + std::swap(x, y); + + using std::swap; + swap(x, y); +}