diff mbox

[v3] LWG 2766, LWG 2749

Message ID CAFk2RUaJLt6c4neRwjaX-oXDMqtAwuACAwScwAqPA-UqF4-0eQ@mail.gmail.com
State New
Headers show

Commit Message

Ville Voutilainen Nov. 26, 2016, 12:47 p.m. UTC 
On 22 November 2016 at 17:06, Jonathan Wakely <jwakely@redhat.com> wrote:
>> so I can certainly change all these swaps to use operator! rather than
>> __not_. Is the
>> patch otherwise ok for trunk? What about the tuple part?
>
>
> Yes, OK changing the top-level __not_s to operator!
> I haven't reviewed the tuple part fully yet.

Updated patches attached, and tested with the full testsuite on Linux-PPC64.

diff --git a/libstdc++-v3/include/bits/move.h b/libstdc++-v3/include/bits/move.h
index d0aefe7..0bd11d6 100644
--- a/libstdc++-v3/include/bits/move.h
+++ b/libstdc++-v3/include/bits/move.h
@@ -181,7 +181,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   template<typename _Tp>
     inline
 #if __cplusplus >= 201103L
-    typename enable_if<__and_<is_move_constructible<_Tp>,
+    typename enable_if<__and_<__not_<__is_tuple_like<_Tp>>,
+			      is_move_constructible<_Tp>,
 			      is_move_assignable<_Tp>>::value>::type
     swap(_Tp& __a, _Tp& __b)
     noexcept(__and_<is_nothrow_move_constructible<_Tp>,
diff --git a/libstdc++-v3/include/std/tuple b/libstdc++-v3/include/std/tuple
index 63cacd4..8952750 100644
--- a/libstdc++-v3/include/std/tuple
+++ b/libstdc++-v3/include/std/tuple
@@ -1442,17 +1442,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     forward_as_tuple(_Elements&&... __args) noexcept
     { return tuple<_Elements&&...>(std::forward<_Elements>(__args)...); }
 
-  template<typename... _Tps>
-    struct __is_tuple_like_impl<tuple<_Tps...>> : true_type
-    { };
-
-  // Internal type trait that allows us to sfinae-protect tuple_cat.
-  template<typename _Tp>
-    struct __is_tuple_like
-    : public __is_tuple_like_impl<typename std::remove_cv
-            <typename std::remove_reference<_Tp>::type>::type>::type
-    { };
-
   template<size_t, typename, typename, size_t>
     struct __make_tuple_impl;
 
@@ -1596,6 +1585,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     swap(tuple<_Elements...>& __x, tuple<_Elements...>& __y)
     noexcept(noexcept(__x.swap(__y)))
     { __x.swap(__y); }
+#if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11
+  template<typename... _Elements>
+    inline
+    typename enable_if<!__and_<__is_swappable<_Elements>...>::value>::type
+    swap(tuple<_Elements...>&, tuple<_Elements...>&) = delete;
+#endif
 
   // A class (and instance) which can be used in 'tie' when an element
   // of a tuple is not required
diff --git a/libstdc++-v3/include/std/type_traits b/libstdc++-v3/include/std/type_traits
index e5f2bba..49f76cc 100644
--- a/libstdc++-v3/include/std/type_traits
+++ b/libstdc++-v3/include/std/type_traits
@@ -2593,9 +2593,28 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   template <typename _Tp>
     struct __is_nothrow_swappable;
 
+  template<typename... _Elements>
+    class tuple;
+
+  template<typename>
+    struct __is_tuple_like_impl : false_type
+    { };
+
+  template<typename... _Tps>
+    struct __is_tuple_like_impl<tuple<_Tps...>> : true_type
+    { };
+
+  // Internal type trait that allows us to sfinae-protect tuple_cat.
+  template<typename _Tp>
+    struct __is_tuple_like
+    : public __is_tuple_like_impl<typename std::remove_cv
+            <typename std::remove_reference<_Tp>::type>::type>::type
+    { };
+
   template<typename _Tp>
     inline
-    typename enable_if<__and_<is_move_constructible<_Tp>,
+    typename enable_if<__and_<__not_<__is_tuple_like<_Tp>>,
+			      is_move_constructible<_Tp>,
 			      is_move_assignable<_Tp>>::value>::type
     swap(_Tp&, _Tp&)
     noexcept(__and_<is_nothrow_move_constructible<_Tp>,
diff --git a/libstdc++-v3/include/std/utility b/libstdc++-v3/include/std/utility
index 3982156..8e02f0e 100644
--- a/libstdc++-v3/include/std/utility
+++ b/libstdc++-v3/include/std/utility
@@ -140,10 +140,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     using tuple_element_t = typename tuple_element<__i, _Tp>::type;
 #endif
 
-  template<typename>
-    struct __is_tuple_like_impl : false_type
-    { };
-
   // Various functions which give std::pair a tuple-like interface.
 
   /// Partial specialization for std::pair
diff --git a/libstdc++-v3/testsuite/20_util/tuple/swap_cxx17.cc b/libstdc++-v3/testsuite/20_util/tuple/swap_cxx17.cc
new file mode 100644
index 0000000..d2a75ce
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/tuple/swap_cxx17.cc
@@ -0,0 +1,43 @@
+// { dg-options "-std=gnu++17" }
+// { dg-do compile }
+
+// 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/>.
+
+
+// NOTE: This makes use of the fact that we know how moveable
+// is implemented on tuple.  If the implementation changed
+// this test may begin to fail.
+
+#include <tuple>
+
+// Not swappable, and tuple not swappable via the generic std::swap.
+struct C { };
+void swap(C&, C&) = delete;
+
+static_assert( !std::is_swappable_v<std::tuple<int, C>> );
+static_assert( !std::is_swappable_v<std::tuple<C, int>> );
+static_assert( !std::is_swappable_v<std::tuple<int, int, C>> );
+static_assert( !std::is_swappable_v<std::tuple<C, int, int>> );
+
+// Not swappable, and tuple not swappable via the generic std::swap.
+struct D { D(D&&) = delete; };
+
+static_assert( !std::is_swappable_v<std::tuple<int, D>> );
+static_assert( !std::is_swappable_v<std::tuple<D, int>> );
+static_assert( !std::is_swappable_v<std::tuple<int, int, D>> );
+static_assert( !std::is_swappable_v<std::tuple<D, int, int>> );

Comments

Jonathan Wakely Nov. 30, 2016, 3:08 p.m. UTC | #1 
On 26/11/16 14:47 +0200, Ville Voutilainen wrote:
>Updated patches attached, and tested with the full testsuite on Linux-PPC64.

Both patches are OK for trunk with the minor tweaks noted below.
Thanks.


>diff --git a/libstdc++-v3/include/bits/stl_pair.h b/libstdc++-v3/include/bits/stl_pair.h
>index ef52538..981dbeb 100644
>--- a/libstdc++-v3/include/bits/stl_pair.h
>+++ b/libstdc++-v3/include/bits/stl_pair.h
>@@ -478,6 +478,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
>     swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y)
>     noexcept(noexcept(__x.swap(__y)))
>     { __x.swap(__y); }
>+
>+#if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11
>+  template<typename _T1, typename _T2>
>+    inline
>+    typename enable_if<!__and_<__is_swappable<_T1>,
>+			       __is_swappable<_T2>>::value>::type
>+    swap(pair<_T1, _T2>&, pair<_T1, _T2>&) = delete;
>+#endif
> #endif // __cplusplus >= 201103L
>
>   /**
>diff --git a/libstdc++-v3/include/bits/unique_ptr.h b/libstdc++-v3/include/bits/unique_ptr.h
>index f9ec60f..21b0bac 100644
>--- a/libstdc++-v3/include/bits/unique_ptr.h
>+++ b/libstdc++-v3/include/bits/unique_ptr.h
>@@ -649,6 +649,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
>     swap(unique_ptr<_Tp, _Dp>& __x,
> 	 unique_ptr<_Tp, _Dp>& __y) noexcept
>     { __x.swap(__y); }

Insert a blank line here please.

>+#if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11
>+  template<typename _Tp, typename _Dp>
>+    inline
>+    typename enable_if<!__is_swappable<_Dp>::value>::type
>+    swap(unique_ptr<_Tp, _Dp>&,
>+	 unique_ptr<_Tp, _Dp>&) = delete;
>+#endif
>
>   template<typename _Tp, typename _Dp,
> 	   typename _Up, typename _Ep>
>diff --git a/libstdc++-v3/include/std/array b/libstdc++-v3/include/std/array
>index 3ab0355..86100b5 100644
>--- a/libstdc++-v3/include/std/array
>+++ b/libstdc++-v3/include/std/array
>@@ -287,6 +287,13 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
>     swap(array<_Tp, _Nm>& __one, array<_Tp, _Nm>& __two)
>     noexcept(noexcept(__one.swap(__two)))
>     { __one.swap(__two); }

Insert a blank line here please.

>+#if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11
>+  template<typename _Tp, std::size_t _Nm>
>+    inline
>+    typename enable_if<
>+      !_GLIBCXX_STD_C::__array_traits<_Tp, _Nm>::_Is_swappable::value>::type
>+    swap(array<_Tp, _Nm>&, array<_Tp, _Nm>&) = delete;
>+#endif
>
>   template<std::size_t _Int, typename _Tp, std::size_t _Nm>
>     constexpr _Tp&


>diff --git a/libstdc++-v3/include/std/tuple b/libstdc++-v3/include/std/tuple
>index 63cacd4..8952750 100644
>--- a/libstdc++-v3/include/std/tuple
>+++ b/libstdc++-v3/include/std/tuple
>@@ -1442,17 +1442,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
>     forward_as_tuple(_Elements&&... __args) noexcept
>     { return tuple<_Elements&&...>(std::forward<_Elements>(__args)...); }
>
>-  template<typename... _Tps>
>-    struct __is_tuple_like_impl<tuple<_Tps...>> : true_type
>-    { };
>-
>-  // Internal type trait that allows us to sfinae-protect tuple_cat.
>-  template<typename _Tp>
>-    struct __is_tuple_like
>-    : public __is_tuple_like_impl<typename std::remove_cv
>-            <typename std::remove_reference<_Tp>::type>::type>::type
>-    { };
>-
>   template<size_t, typename, typename, size_t>
>     struct __make_tuple_impl;
>
>@@ -1596,6 +1585,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
>     swap(tuple<_Elements...>& __x, tuple<_Elements...>& __y)
>     noexcept(noexcept(__x.swap(__y)))
>     { __x.swap(__y); }

Insert a blank line here please.

>+#if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11
>+  template<typename... _Elements>
>+    inline
>+    typename enable_if<!__and_<__is_swappable<_Elements>...>::value>::type
>+    swap(tuple<_Elements...>&, tuple<_Elements...>&) = delete;
>+#endif
>
>   // A class (and instance) which can be used in 'tie' when an element
>   // of a tuple is not required
>diff --git a/libstdc++-v3/include/std/type_traits b/libstdc++-v3/include/std/type_traits
>index e5f2bba..49f76cc 100644
>--- a/libstdc++-v3/include/std/type_traits
>+++ b/libstdc++-v3/include/std/type_traits
>@@ -2593,9 +2593,28 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
>   template <typename _Tp>
>     struct __is_nothrow_swappable;
>
>+  template<typename... _Elements>
>+    class tuple;
>+
>+  template<typename>
>+    struct __is_tuple_like_impl : false_type
>+    { };
>+
>+  template<typename... _Tps>
>+    struct __is_tuple_like_impl<tuple<_Tps...>> : true_type
>+    { };
>+
>+  // Internal type trait that allows us to sfinae-protect tuple_cat.
>+  template<typename _Tp>
>+    struct __is_tuple_like
>+    : public __is_tuple_like_impl<typename std::remove_cv
>+            <typename std::remove_reference<_Tp>::type>::type>::type

We can lose the std:: quals here.

>+    { };
>+
>   template<typename _Tp>
>     inline
>-    typename enable_if<__and_<is_move_constructible<_Tp>,
>+    typename enable_if<__and_<__not_<__is_tuple_like<_Tp>>,
>+			      is_move_constructible<_Tp>,
> 			      is_move_assignable<_Tp>>::value>::type
>     swap(_Tp&, _Tp&)
>     noexcept(__and_<is_nothrow_move_constructible<_Tp>,
diff mbox

Patch

diff --git a/libstdc++-v3/include/bits/stl_pair.h b/libstdc++-v3/include/bits/stl_pair.h
index ef52538..981dbeb 100644
--- a/libstdc++-v3/include/bits/stl_pair.h
+++ b/libstdc++-v3/include/bits/stl_pair.h
@@ -478,6 +478,14 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
     swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y)
     noexcept(noexcept(__x.swap(__y)))
     { __x.swap(__y); }
+
+#if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11
+  template<typename _T1, typename _T2>
+    inline
+    typename enable_if<!__and_<__is_swappable<_T1>,
+			       __is_swappable<_T2>>::value>::type
+    swap(pair<_T1, _T2>&, pair<_T1, _T2>&) = delete;
+#endif
 #endif // __cplusplus >= 201103L
 
   /**
diff --git a/libstdc++-v3/include/bits/unique_ptr.h b/libstdc++-v3/include/bits/unique_ptr.h
index f9ec60f..21b0bac 100644
--- a/libstdc++-v3/include/bits/unique_ptr.h
+++ b/libstdc++-v3/include/bits/unique_ptr.h
@@ -649,6 +649,13 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
     swap(unique_ptr<_Tp, _Dp>& __x,
 	 unique_ptr<_Tp, _Dp>& __y) noexcept
     { __x.swap(__y); }
+#if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11
+  template<typename _Tp, typename _Dp>
+    inline
+    typename enable_if<!__is_swappable<_Dp>::value>::type
+    swap(unique_ptr<_Tp, _Dp>&,
+	 unique_ptr<_Tp, _Dp>&) = delete;
+#endif
 
   template<typename _Tp, typename _Dp,
 	   typename _Up, typename _Ep>
diff --git a/libstdc++-v3/include/std/array b/libstdc++-v3/include/std/array
index 3ab0355..86100b5 100644
--- a/libstdc++-v3/include/std/array
+++ b/libstdc++-v3/include/std/array
@@ -287,6 +287,13 @@  _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
     swap(array<_Tp, _Nm>& __one, array<_Tp, _Nm>& __two)
     noexcept(noexcept(__one.swap(__two)))
     { __one.swap(__two); }
+#if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11
+  template<typename _Tp, std::size_t _Nm>
+    inline
+    typename enable_if<
+      !_GLIBCXX_STD_C::__array_traits<_Tp, _Nm>::_Is_swappable::value>::type
+    swap(array<_Tp, _Nm>&, array<_Tp, _Nm>&) = delete;
+#endif
 
   template<std::size_t _Int, typename _Tp, std::size_t _Nm>
     constexpr _Tp&
diff --git a/libstdc++-v3/include/std/optional b/libstdc++-v3/include/std/optional
index ea673cc..191d64b 100644
--- a/libstdc++-v3/include/std/optional
+++ b/libstdc++-v3/include/std/optional
@@ -930,6 +930,10 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
     { __lhs.swap(__rhs); }
 
   template<typename _Tp>
+    inline enable_if_t<!(is_move_constructible_v<_Tp> && is_swappable_v<_Tp>)>
+    swap(optional<_Tp>&, optional<_Tp>&) = delete;
+
+  template<typename _Tp>
     constexpr optional<decay_t<_Tp>>
     make_optional(_Tp&& __t)
     { return optional<decay_t<_Tp>> { std::forward<_Tp>(__t) }; }
diff --git a/libstdc++-v3/include/std/variant b/libstdc++-v3/include/std/variant
index 7d93575..c87d83d 100644
--- a/libstdc++-v3/include/std/variant
+++ b/libstdc++-v3/include/std/variant
@@ -877,10 +877,17 @@  _GLIBCXX_BEGIN_NAMESPACE_VERSION
   { return false; }
 
   template<typename... _Types>
-    inline auto swap(variant<_Types...>& __lhs, variant<_Types...>& __rhs)
-    noexcept(noexcept(__lhs.swap(__rhs))) -> decltype(__lhs.swap(__rhs))
+    inline enable_if_t<__and_<is_move_constructible<_Types>...,
+			      is_swappable<_Types>...>::value>
+    swap(variant<_Types...>& __lhs, variant<_Types...>& __rhs)
+    noexcept(noexcept(__lhs.swap(__rhs)))
     { __lhs.swap(__rhs); }
 
+  template<typename... _Types>
+    inline enable_if_t<!__and_<is_move_constructible<_Types>...,
+			       is_swappable<_Types>...>::value>
+    swap(variant<_Types...>&, variant<_Types...>&) = delete;
+
   class bad_variant_access : public exception
   {
   public:
diff --git a/libstdc++-v3/testsuite/20_util/optional/swap/2.cc b/libstdc++-v3/testsuite/20_util/optional/swap/2.cc
index 5793488..cb9291a 100644
--- a/libstdc++-v3/testsuite/20_util/optional/swap/2.cc
+++ b/libstdc++-v3/testsuite/20_util/optional/swap/2.cc
@@ -33,11 +33,11 @@  void swap(B&, B&) noexcept(false);
 static_assert( std::is_swappable_v<std::optional<B>> );
 static_assert( !std::is_nothrow_swappable_v<std::optional<B>> );
 
-// Not swappable, but optional<C> is swappable via the generic std::swap.
+// Not swappable, and optional<C> not swappable via the generic std::swap.
 struct C { };
 void swap(C&, C&) = delete;
 
-static_assert( std::is_swappable_v<std::optional<C>> );
+static_assert( !std::is_swappable_v<std::optional<C>> );
 
 // Not swappable, and optional<D> not swappable via the generic std::swap.
 struct D { D(D&&) = delete; };
diff --git a/libstdc++-v3/testsuite/20_util/pair/swap_cxx17.cc b/libstdc++-v3/testsuite/20_util/pair/swap_cxx17.cc
new file mode 100644
index 0000000..6b09f42
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/pair/swap_cxx17.cc
@@ -0,0 +1,35 @@ 
+// { dg-options "-std=gnu++17" }
+// { dg-do compile }
+
+// 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 <utility>
+
+// Not swappable, and pair not swappable via the generic std::swap.
+struct C { };
+void swap(C&, C&) = delete;
+
+static_assert( !std::is_swappable_v<std::pair<int, C>> );
+static_assert( !std::is_swappable_v<std::pair<C, int>> );
+
+// Not swappable, and pair not swappable via the generic std::swap.
+struct D { D(D&&) = delete; };
+
+static_assert( !std::is_swappable_v<std::pair<int, D>> );
+static_assert( !std::is_swappable_v<std::pair<D, int>> );
diff --git a/libstdc++-v3/testsuite/20_util/unique_ptr/specialized_algorithms/swap_cxx17.cc b/libstdc++-v3/testsuite/20_util/unique_ptr/specialized_algorithms/swap_cxx17.cc
new file mode 100644
index 0000000..bf106ec
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/unique_ptr/specialized_algorithms/swap_cxx17.cc
@@ -0,0 +1,33 @@ 
+// { dg-options "-std=gnu++17" }
+// { dg-do compile }
+
+// 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 <memory>
+
+// Not swappable, and unique_ptr not swappable via the generic std::swap.
+struct C { };
+void swap(C&, C&) = delete;
+
+static_assert( !std::is_swappable_v<std::unique_ptr<int, C>> );
+
+// Not swappable, and unique_ptr not swappable via the generic std::swap.
+struct D { D(D&&) = delete; };
+
+static_assert( !std::is_swappable_v<std::unique_ptr<int, D>> );
+
diff --git a/libstdc++-v3/testsuite/20_util/variant/compile.cc b/libstdc++-v3/testsuite/20_util/variant/compile.cc
index 2470bcc..4ce8b5e 100644
--- a/libstdc++-v3/testsuite/20_util/variant/compile.cc
+++ b/libstdc++-v3/testsuite/20_util/variant/compile.cc
@@ -219,6 +219,21 @@  void test_relational()
   }
 }
 
+// Not swappable, and variant<C> not swappable via the generic std::swap.
+struct C { };
+void swap(C&, C&) = delete;
+
+static_assert( !std::is_swappable_v<variant<C>> );
+static_assert( !std::is_swappable_v<variant<int, C>> );
+static_assert( !std::is_swappable_v<variant<C, int>> );
+
+// Not swappable, and variant<D> not swappable via the generic std::swap.
+struct D { D(D&&) = delete; };
+
+static_assert( !std::is_swappable_v<variant<D>> );
+static_assert( !std::is_swappable_v<variant<int, D>> );
+static_assert( !std::is_swappable_v<variant<D, int>> );
+
 void test_swap()
 {
   variant<int, string> a, b;
diff --git a/libstdc++-v3/testsuite/23_containers/array/specialized_algorithms/swap_cxx17.cc b/libstdc++-v3/testsuite/23_containers/array/specialized_algorithms/swap_cxx17.cc
new file mode 100644
index 0000000..2e93c4d
--- /dev/null
+++ b/libstdc++-v3/testsuite/23_containers/array/specialized_algorithms/swap_cxx17.cc
@@ -0,0 +1,33 @@ 
+// { dg-options "-std=gnu++17" }
+// { dg-do compile }
+
+// 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 <array>
+
+// Not swappable, and pair not swappable via the generic std::swap.
+struct C { };
+void swap(C&, C&) = delete;
+
+static_assert( !std::is_swappable_v<std::array<C, 42>> );
+
+// Not swappable, and pair not swappable via the generic std::swap.
+struct D { D(D&&) = delete; };
+
+static_assert( !std::is_swappable_v<std::array<D, 42>> );
+
diff --git a/libstdc++-v3/testsuite/23_containers/array/tuple_interface/get_neg.cc b/libstdc++-v3/testsuite/23_containers/array/tuple_interface/get_neg.cc
index f99bbf6..69d638b 100644
--- a/libstdc++-v3/testsuite/23_containers/array/tuple_interface/get_neg.cc
+++ b/libstdc++-v3/testsuite/23_containers/array/tuple_interface/get_neg.cc
@@ -27,6 +27,6 @@  int n1 = std::get<1>(a);
 int n2 = std::get<1>(std::move(a));
 int n3 = std::get<1>(ca);
 
-// { dg-error "static assertion failed" "" { target *-*-* } 295 }
-// { dg-error "static assertion failed" "" { target *-*-* } 304 }
-// { dg-error "static assertion failed" "" { target *-*-* } 312 }
+// { dg-error "static assertion failed" "" { target *-*-* } 302 }
+// { dg-error "static assertion failed" "" { target *-*-* } 311 }
+// { dg-error "static assertion failed" "" { target *-*-* } 319 }
diff --git a/libstdc++-v3/testsuite/23_containers/array/tuple_interface/tuple_element_neg.cc b/libstdc++-v3/testsuite/23_containers/array/tuple_interface/tuple_element_neg.cc
index 1941f3c..016c747 100644
--- a/libstdc++-v3/testsuite/23_containers/array/tuple_interface/tuple_element_neg.cc
+++ b/libstdc++-v3/testsuite/23_containers/array/tuple_interface/tuple_element_neg.cc
@@ -22,4 +22,4 @@ 
 
 typedef std::tuple_element<1, std::array<int, 1>>::type type;
 
-// { dg-error "static assertion failed" "" { target *-*-* } 343 }
+// { dg-error "static assertion failed" "" { target *-*-* } 350 }