projects / platform / upstream / gcc.git / commitdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | patch | inline | side by side (parent: c7dfcae)
type_traits (__or_, __and_): Add trivial definitions for a single element.
authorPaolo Carlini <paolo.carlini@oracle.com>
Tue, 31 May 2011 02:29:22 +0000 (02:29 +0000)
committerPaolo Carlini <paolo@gcc.gnu.org>
Tue, 31 May 2011 02:29:22 +0000 (02:29 +0000)
2011-05-30  Paolo Carlini  <paolo.carlini@oracle.com>

* include/std/type_traits (__or_, __and_): Add trivial definitions
for a single element.
* include/bits/stl_pair.h: Use __and_ in noexcept specs and
constraints.
(pair<>::pair(pair&&)): Define.
(pair<>::pair(const pair<>&)): Constrain with is_convertible.
(pair<>::pair(pair<>&&)): Likewise, remove noexcept.
* include/std/tuple: Use __and_ in noexcept specs and constraints.
(_Tuple_impl<>::_Tuple_impl(allocator_arg_t, const _Alloc&,
_Tuple_impl&&)): Remove noexcept.
(tuple<>::tuple(_UElements&&...), tuple(const tuple<_UElements...>&),
tuple(tuple<_UElements...>&&), tuple(const pair<_U1, _U2>&),
tuple(pair<_U1, _U2>&&)): Constrain with is_convertible.
* testsuite/20_util/tuple/moveable2.cc: Use = delete.
* testsuite/20_util/make_signed/requirements/typedefs_neg.cc:
Adjust dg-error line numbers.
* testsuite/20_util/make_unsigned/requirements/typedefs_neg.cc:
Likewise.
* testsuite/20_util/declval/requirements/1_neg.cc: Likewise.
* testsuite/20_util/ratio/cons/cons_overflow_neg.cc: Likewise.
* testsuite/20_util/weak_ptr/comparison/cmp_neg.cc: Likewise.

From-SVN: r174464

libstdc++-v3/ChangeLog patch | blob | history
libstdc++-v3/include/bits/stl_pair.h patch | blob | history
libstdc++-v3/include/std/tuple patch | blob | history
libstdc++-v3/include/std/type_traits patch | blob | history
libstdc++-v3/testsuite/20_util/declval/requirements/1_neg.cc patch | blob | history
libstdc++-v3/testsuite/20_util/make_signed/requirements/typedefs_neg.cc patch | blob | history
libstdc++-v3/testsuite/20_util/make_unsigned/requirements/typedefs_neg.cc patch | blob | history
libstdc++-v3/testsuite/20_util/ratio/cons/cons_overflow_neg.cc patch | blob | history
libstdc++-v3/testsuite/20_util/tuple/moveable2.cc patch | blob | history
libstdc++-v3/testsuite/20_util/weak_ptr/comparison/cmp_neg.cc patch | blob | history

diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog
index e5fd280..ba7bd9c 100644 (file)
--- a/libstdc++-v3/ChangeLog
+++ b/libstdc++-v3/ChangeLog
@@ -1,3 +1,27 @@
+2011-05-30  Paolo Carlini  <paolo.carlini@oracle.com>
+
+       * include/std/type_traits (__or_, __and_): Add trivial definitions
+       for a single element.
+       * include/bits/stl_pair.h: Use __and_ in noexcept specs and
+       constraints.
+       (pair<>::pair(pair&&)): Define.
+       (pair<>::pair(const pair<>&)): Constrain with is_convertible.
+       (pair<>::pair(pair<>&&)): Likewise, remove noexcept.
+       * include/std/tuple: Use __and_ in noexcept specs and constraints.
+       (_Tuple_impl<>::_Tuple_impl(allocator_arg_t, const _Alloc&,
+       _Tuple_impl&&)): Remove noexcept.
+       (tuple<>::tuple(_UElements&&...), tuple(const tuple<_UElements...>&),
+       tuple(tuple<_UElements...>&&), tuple(const pair<_U1, _U2>&),
+       tuple(pair<_U1, _U2>&&)): Constrain with is_convertible.
+       * testsuite/20_util/tuple/moveable2.cc: Use = delete.
+       * testsuite/20_util/make_signed/requirements/typedefs_neg.cc:
+       Adjust dg-error line numbers.
+       * testsuite/20_util/make_unsigned/requirements/typedefs_neg.cc:
+       Likewise.
+       * testsuite/20_util/declval/requirements/1_neg.cc: Likewise.
+       * testsuite/20_util/ratio/cons/cons_overflow_neg.cc: Likewise.
+       * testsuite/20_util/weak_ptr/comparison/cmp_neg.cc: Likewise.
+
 2011-05-31  Jonathan Wakely  <jwakely.gcc@gmail.com>
 
        * include/std/tuple: Restore is_convertible constraint.
diff --git a/libstdc++-v3/include/bits/stl_pair.h b/libstdc++-v3/include/bits/stl_pair.h
index fbb475b..61ebc71 100644 (file)
--- a/libstdc++-v3/include/bits/stl_pair.h
+++ b/libstdc++-v3/include/bits/stl_pair.h
@@ -105,37 +105,47 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       : first(__a), second(__b) { }
 
       /** There is also a templated copy ctor for the @c pair class itself.  */
+#ifndef __GXX_EXPERIMENTAL_CXX0X__
       template<class _U1, class _U2>
-       _GLIBCXX_CONSTEXPR pair(const pair<_U1, _U2>& __p)
+       pair(const pair<_U1, _U2>& __p)
+       : first(__p.first), second(__p.second) { }
+#else
+      template<class _U1, class _U2, class = typename
+              enable_if<__and_<is_convertible<const _U1&, _T1>,
+                               is_convertible<const _U2&, _T2>>::value>::type>
+       constexpr pair(const pair<_U1, _U2>& __p)
        : first(__p.first), second(__p.second) { }
 
-#ifdef __GXX_EXPERIMENTAL_CXX0X__
       constexpr pair(const pair&) = default;
 
-      // Implicit?!? Breaks containers!!!
-      // pair(pair&&) = default;
+      // XXX Defaulted?!? Breaks std::map!!!
+      pair(pair&& __p)
+      noexcept(__and_<is_nothrow_move_constructible<_T1>,
+                     is_nothrow_move_constructible<_T2>>::value)
+      : first(std::forward<first_type>(__p.first)),
+       second(std::forward<second_type>(__p.second)) { }
 
       // DR 811.
       template<class _U1, class = typename
-              std::enable_if<std::is_convertible<_U1, _T1>::value>::type>
+              enable_if<is_convertible<_U1, _T1>::value>::type>
        pair(_U1&& __x, const _T2& __y)
        : first(std::forward<_U1>(__x)), second(__y) { }
 
       template<class _U2, class = typename
-              std::enable_if<std::is_convertible<_U2, _T2>::value>::type>
+              enable_if<is_convertible<_U2, _T2>::value>::type>
        pair(const _T1& __x, _U2&& __y)
        : first(__x), second(std::forward<_U2>(__y)) { }
 
       template<class _U1, class _U2, class = typename
-              std::enable_if<std::is_convertible<_U1, _T1>::value
-                             && std::is_convertible<_U2, _T2>::value>::type>
+              enable_if<__and_<is_convertible<_U1, _T1>,
+                               is_convertible<_U2, _T2>>::value>::type>
        pair(_U1&& __x, _U2&& __y)
        : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { }
 
-      template<class _U1, class _U2>
+      template<class _U1, class _U2, class = typename
+              enable_if<__and_<is_convertible<_U1, _T1>,
+                               is_convertible<_U2, _T2>>::value>::type>
        pair(pair<_U1, _U2>&& __p)
-       noexcept(std::is_nothrow_constructible<_T1, _U1&&>::value
-                && std::is_nothrow_constructible<_T2, _U2&&>::value)
        : first(std::forward<_U1>(__p.first)),
          second(std::forward<_U2>(__p.second)) { }
 
@@ -155,11 +165,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
       pair&
       operator=(pair&& __p)
-      noexcept(std::is_nothrow_move_assignable<_T1>::value
-              && std::is_nothrow_move_assignable<_T2>::value)
+      noexcept(__and_<is_nothrow_move_assignable<_T1>,
+                     is_nothrow_move_assignable<_T2>>::value)
       {
-       first = std::move(__p.first);
-       second = std::move(__p.second);
+       first = std::forward<first_type>(__p.first);
+       second = std::forward<second_type>(__p.second);
        return *this;
       }
 
@@ -176,8 +186,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
        pair&
        operator=(pair<_U1, _U2>&& __p)
        {
-         first = std::move(__p.first);
-         second = std::move(__p.second);
+         first = std::forward<_U1>(__p.first);
+         second = std::forward<_U2>(__p.second);
          return *this;
        }
 
diff --git a/libstdc++-v3/include/std/tuple b/libstdc++-v3/include/std/tuple
index f8ec271..10272cc 100644 (file)
--- a/libstdc++-v3/include/std/tuple
+++ b/libstdc++-v3/include/std/tuple
@@ -224,7 +224,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       : _Inherited(__tail...), _Base(__head) { }
 
       template<typename _UHead, typename... _UTail, typename = typename
-               std::enable_if<sizeof...(_Tail)==sizeof...(_UTail)>::type> 
+               enable_if<sizeof...(_Tail) == sizeof...(_UTail)>::type> 
         explicit
         _Tuple_impl(_UHead&& __head, _UTail&&... __tail)
        : _Inherited(std::forward<_UTail>(__tail)...),
@@ -233,8 +233,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       constexpr _Tuple_impl(const _Tuple_impl&) = default;
 
       _Tuple_impl(_Tuple_impl&& __in)
-      noexcept(std::is_nothrow_move_constructible<_Head>::value
-              && std::is_nothrow_move_constructible<_Inherited>::value)
+      noexcept(__and_<is_nothrow_move_constructible<_Head>,
+                     is_nothrow_move_constructible<_Inherited>>::value)
       : _Inherited(std::move(__in._M_tail())), 
        _Base(std::forward<_Head>(__in._M_head())) { }
 
@@ -254,13 +254,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
       template<typename _Alloc>
        _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
-           const _Head& __head, const _Tail&... __tail)
+                   const _Head& __head, const _Tail&... __tail)
        : _Inherited(__tag, __a, __tail...),
           _Base(__use_alloc<_Head, _Alloc, _Head>(__a), __head) { }
 
       template<typename _Alloc, typename _UHead, typename... _UTail,
-               typename = typename std::enable_if<sizeof...(_Tail)
-                                                 ==sizeof...(_UTail)>::type>
+               typename = typename enable_if<sizeof...(_Tail)
+                                            == sizeof...(_UTail)>::type>
        _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
                    _UHead&& __head, _UTail&&... __tail)
        : _Inherited(__tag, __a, std::forward<_UTail>(__tail)...),
@@ -276,8 +276,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       template<typename _Alloc>
        _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
                    _Tuple_impl&& __in)
-       noexcept(std::is_nothrow_move_constructible<_Head>::value
-                && std::is_nothrow_move_constructible<_Inherited>::value)
        : _Inherited(__tag, __a, std::move(__in._M_tail())), 
          _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
                std::forward<_Head>(__in._M_head())) { }
@@ -305,8 +303,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
       _Tuple_impl&
       operator=(_Tuple_impl&& __in)
-      noexcept(std::is_nothrow_move_assignable<_Head>::value
-              && std::is_nothrow_move_assignable<_Inherited>::value)
+      noexcept(__and_<is_nothrow_move_assignable<_Head>,
+                     is_nothrow_move_assignable<_Inherited>>::value)
       {
        _M_head() = std::forward<_Head>(__in._M_head());
        _M_tail() = std::move(__in._M_tail());
@@ -359,9 +357,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       : _Inherited(__elements...) { }
 
       template<typename... _UElements, typename = typename
-              std::enable_if<sizeof...(_UElements)
-                             == sizeof...(_Elements)>::type>
-        explicit
+       enable_if<__and_<integral_constant<bool, sizeof...(_UElements)
+                                          == sizeof...(_Elements)>,
+                        __and_<is_convertible<_UElements,
+                                              _Elements>...>>::value>::type>
+       explicit
         tuple(_UElements&&... __elements)
        : _Inherited(std::forward<_UElements>(__elements)...) { }
 
@@ -369,15 +369,19 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       tuple(tuple&&) = default;
 
       template<typename... _UElements, typename = typename
-              std::enable_if<sizeof...(_UElements)
-                             == sizeof...(_Elements)>::type>
+       enable_if<__and_<integral_constant<bool, sizeof...(_UElements)
+                                          == sizeof...(_Elements)>,
+                        __and_<is_convertible<const _UElements&,
+                                              _Elements>...>>::value>::type>
         tuple(const tuple<_UElements...>& __in)
         : _Inherited(static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
         { }
 
       template<typename... _UElements, typename = typename
-              std::enable_if<sizeof...(_UElements)
-                             == sizeof...(_Elements)>::type>
+       enable_if<__and_<integral_constant<bool, sizeof...(_UElements)
+                                          == sizeof...(_Elements)>,
+                        __and_<is_convertible<_UElements,
+                                              _Elements>...>>::value>::type>
         tuple(tuple<_UElements...>&& __in)
         : _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { }
 
@@ -393,8 +397,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
        : _Inherited(__tag, __a, __elements...) { }
 
       template<typename _Alloc, typename... _UElements, typename = typename
-              std::enable_if<sizeof...(_UElements)
-                             == sizeof...(_Elements)>::type>
+              enable_if<sizeof...(_UElements)
+                        == sizeof...(_Elements)>::type>
        tuple(allocator_arg_t __tag, const _Alloc& __a,
              _UElements&&... __elements)
        : _Inherited(__tag, __a, std::forward<_UElements>(__elements)...)
@@ -409,8 +413,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
        : _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { }
 
       template<typename _Alloc, typename... _UElements, typename = typename
-              std::enable_if<sizeof...(_UElements)
-                             == sizeof...(_Elements)>::type>
+              enable_if<sizeof...(_UElements)
+                        == sizeof...(_Elements)>::type>
        tuple(allocator_arg_t __tag, const _Alloc& __a,
              const tuple<_UElements...>& __in)
        : _Inherited(__tag, __a,
@@ -418,8 +422,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
        { }
 
       template<typename _Alloc, typename... _UElements, typename = typename
-              std::enable_if<sizeof...(_UElements)
-                             == sizeof...(_Elements)>::type>
+              enable_if<sizeof...(_UElements)
+                        == sizeof...(_Elements)>::type>
        tuple(allocator_arg_t __tag, const _Alloc& __a,
              tuple<_UElements...>&& __in)
        : _Inherited(__tag, __a,
@@ -435,15 +439,15 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
       tuple&
       operator=(tuple&& __in)
-      noexcept(std::is_nothrow_move_assignable<_Inherited>::value)
+      noexcept(is_nothrow_move_assignable<_Inherited>::value)
       {
        static_cast<_Inherited&>(*this) = std::move(__in);
        return *this;
       }
 
       template<typename... _UElements, typename = typename
-              std::enable_if<sizeof...(_UElements)
-                             == sizeof...(_Elements)>::type>
+              enable_if<sizeof...(_UElements)
+                        == sizeof...(_Elements)>::type>
         tuple&
         operator=(const tuple<_UElements...>& __in)
         {
@@ -452,8 +456,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
        }
 
       template<typename... _UElements, typename = typename
-              std::enable_if<sizeof...(_UElements)
-                             == sizeof...(_Elements)>::type>
+              enable_if<sizeof...(_UElements)
+                        == sizeof...(_Elements)>::type>
         tuple&
         operator=(tuple<_UElements...>&& __in)
         {
@@ -488,7 +492,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       constexpr tuple(const _T1& __a1, const _T2& __a2)
       : _Inherited(__a1, __a2) { }
 
-      template<typename _U1, typename _U2>
+      template<typename _U1, typename _U2, typename = typename
+              enable_if<__and_<is_convertible<_U1, _T1>,
+                               is_convertible<_U2, _T2>>::value>::type>
         explicit
         tuple(_U1&& __a1, _U2&& __a2)
        : _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { }
@@ -496,20 +502,28 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       constexpr tuple(const tuple&) = default;
       tuple(tuple&&) = default;
 
-      template<typename _U1, typename _U2>
+      template<typename _U1, typename _U2, typename = typename
+       enable_if<__and_<is_convertible<const _U1&, _T1>,
+                        is_convertible<const _U2&, _T2>>::value>::type>
         tuple(const tuple<_U1, _U2>& __in)
        : _Inherited(static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in)) { }
 
-      template<typename _U1, typename _U2>
+      template<typename _U1, typename _U2, typename = typename
+              enable_if<__and_<is_convertible<_U1, _T1>,
+                               is_convertible<_U2, _T2>>::value>::type>
         tuple(tuple<_U1, _U2>&& __in)
        : _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { }
 
-      template<typename _U1, typename _U2>
+      template<typename _U1, typename _U2, typename = typename
+       enable_if<__and_<is_convertible<const _U1&, _T1>,
+                        is_convertible<const _U2&, _T2>>::value>::type>
         tuple(const pair<_U1, _U2>& __in)
        : _Inherited(__in.first, __in.second) { }
 
-      template<typename _U1, typename _U2>
-        tuple(pair<_U1, _U2>&& __in)
+      template<typename _U1, typename _U2, typename = typename
+              enable_if<__and_<is_convertible<_U1, _T1>,
+                               is_convertible<_U2, _T2>>::value>::type>
+         tuple(pair<_U1, _U2>&& __in)
        : _Inherited(std::forward<_U1>(__in.first),
                     std::forward<_U2>(__in.second)) { }
 
@@ -568,7 +582,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
       tuple&
       operator=(tuple&& __in)
-      noexcept(std::is_nothrow_move_assignable<_Inherited>::value)
+      noexcept(is_nothrow_move_assignable<_Inherited>::value)
       {
        static_cast<_Inherited&>(*this) = std::move(__in);
        return *this;
@@ -615,6 +629,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     };
 
   /// tuple (1-element).
+  // TODO: Should be simply removed when c++/49225 is fixed, worst case
+  //       together with a different way to constrain the constructors
+  //       of the primary template.
   template<typename _T1>
     class tuple<_T1> : public _Tuple_impl<0, _T1>
     {
@@ -629,7 +646,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       : _Inherited(__a1) { }
 
       template<typename _U1, typename = typename
-              std::enable_if<std::is_convertible<_U1, _T1>::value>::type>
+              enable_if<is_convertible<_U1, _T1>::value>::type>
         explicit
         tuple(_U1&& __a1)
        : _Inherited(std::forward<_U1>(__a1)) { }
@@ -637,11 +654,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       constexpr tuple(const tuple&) = default;
       tuple(tuple&&) = default;
 
-      template<typename _U1>
+      template<typename _U1, typename = typename
+              enable_if<is_convertible<const _U1&, _T1>::value>::type>
         tuple(const tuple<_U1>& __in)
        : _Inherited(static_cast<const _Tuple_impl<0, _U1>&>(__in)) { }
 
-      template<typename _U1>
+      template<typename _U1, typename = typename
+              enable_if<is_convertible<_U1, _T1>::value>::type>
         tuple(tuple<_U1>&& __in)
        : _Inherited(static_cast<_Tuple_impl<0, _U1>&&>(__in)) { }
 
@@ -686,7 +705,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
       tuple&
       operator=(tuple&& __in)
-      noexcept(std::is_nothrow_move_assignable<_Inherited>::value)
+      noexcept(is_nothrow_move_assignable<_Inherited>::value)
       {
        static_cast<_Inherited&>(*this) = std::move(__in);
        return *this;
diff --git a/libstdc++-v3/include/std/type_traits b/libstdc++-v3/include/std/type_traits
index 184e28b..a8842ed 100644 (file)
--- a/libstdc++-v3/include/std/type_traits
+++ b/libstdc++-v3/include/std/type_traits
@@ -59,9 +59,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   template<typename _Tp, _Tp>
     struct integral_constant;
 
-  template<typename, typename, typename...>
+  template<typename...>
     struct __or_;
 
+  template<typename _B1>
+    struct __or_<_B1>
+    : public _B1
+    { };
+
   template<typename _B1, typename _B2>
     struct __or_<_B1, _B2>
     : public conditional<_B1::value, _B1, _B2>::type
@@ -72,9 +77,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     : public conditional<_B1::value, _B1, __or_<_B2, _B3, _Bn...>>::type
     { };
 
-  template<typename, typename, typename...>
+  template<typename...>
     struct __and_;
 
+  template<typename _B1>
+    struct __and_<_B1>
+    : public _B1
+    { };
+
   template<typename _B1, typename _B2>
     struct __and_<_B1, _B2>
     : public conditional<_B1::value, _B2, _B1>::type
diff --git a/libstdc++-v3/testsuite/20_util/declval/requirements/1_neg.cc b/libstdc++-v3/testsuite/20_util/declval/requirements/1_neg.cc
index 3ca56e9..8fcdab4 100644 (file)
--- a/libstdc++-v3/testsuite/20_util/declval/requirements/1_neg.cc
+++ b/libstdc++-v3/testsuite/20_util/declval/requirements/1_neg.cc
@@ -19,7 +19,7 @@
 // with this library; see the file COPYING3.  If not see
 // <http://www.gnu.org/licenses/>.
 
-// { dg-error "static assertion failed" "" { target *-*-* } 1715 }
+// { dg-error "static assertion failed" "" { target *-*-* } 1725 }
 
 #include <utility>
 
diff --git a/libstdc++-v3/testsuite/20_util/make_signed/requirements/typedefs_neg.cc b/libstdc++-v3/testsuite/20_util/make_signed/requirements/typedefs_neg.cc
index c92df36..77328d8 100644 (file)
--- a/libstdc++-v3/testsuite/20_util/make_signed/requirements/typedefs_neg.cc
+++ b/libstdc++-v3/testsuite/20_util/make_signed/requirements/typedefs_neg.cc
@@ -48,5 +48,5 @@ void test01()
 // { dg-error "instantiated from here" "" { target *-*-* } 40 }
 // { dg-error "instantiated from here" "" { target *-*-* } 42 }
 
-// { dg-error "invalid use of incomplete type" "" { target *-*-* } 1501 }
-// { dg-error "declaration of" "" { target *-*-* } 1465 }
+// { dg-error "invalid use of incomplete type" "" { target *-*-* } 1511 }
+// { dg-error "declaration of" "" { target *-*-* } 1475 }
diff --git a/libstdc++-v3/testsuite/20_util/make_unsigned/requirements/typedefs_neg.cc b/libstdc++-v3/testsuite/20_util/make_unsigned/requirements/typedefs_neg.cc
index 2bb62cb..572953e 100644 (file)
--- a/libstdc++-v3/testsuite/20_util/make_unsigned/requirements/typedefs_neg.cc
+++ b/libstdc++-v3/testsuite/20_util/make_unsigned/requirements/typedefs_neg.cc
@@ -48,5 +48,5 @@ void test01()
 // { dg-error "instantiated from here" "" { target *-*-* } 40 }
 // { dg-error "instantiated from here" "" { target *-*-* } 42 }
 
-// { dg-error "invalid use of incomplete type" "" { target *-*-* } 1425 }
-// { dg-error "declaration of" "" { target *-*-* } 1389 }
+// { dg-error "invalid use of incomplete type" "" { target *-*-* } 1435 }
+// { dg-error "declaration of" "" { target *-*-* } 1399 }
diff --git a/libstdc++-v3/testsuite/20_util/ratio/cons/cons_overflow_neg.cc b/libstdc++-v3/testsuite/20_util/ratio/cons/cons_overflow_neg.cc
index 14076a2..e6a71c3 100644 (file)
--- a/libstdc++-v3/testsuite/20_util/ratio/cons/cons_overflow_neg.cc
+++ b/libstdc++-v3/testsuite/20_util/ratio/cons/cons_overflow_neg.cc
@@ -51,4 +51,4 @@ test04()
 // { dg-error "instantiated from here" "" { target *-*-* } 46 }
 // { dg-error "denominator cannot be zero" "" { target *-*-* } 268 }
 // { dg-error "out of range" "" { target *-*-* } 269 }
-// { dg-error "overflow in constant expression" "" { target *-*-* } 99 }
+// { dg-error "overflow in constant expression" "" { target *-*-* } 109 }
diff --git a/libstdc++-v3/testsuite/20_util/tuple/moveable2.cc b/libstdc++-v3/testsuite/20_util/tuple/moveable2.cc
index f080074..5ed8de5 100644 (file)
--- a/libstdc++-v3/testsuite/20_util/tuple/moveable2.cc
+++ b/libstdc++-v3/testsuite/20_util/tuple/moveable2.cc
@@ -1,6 +1,6 @@
 // { dg-options "-std=gnu++0x" }
 
-// Copyright (C) 2008, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2008, 2009, 2010, 2011 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
@@ -17,7 +17,6 @@
 // with this library; see the file COPYING3.  If not see
 // <http://www.gnu.org/licenses/>.
 
-
 #include <tuple>
 #include <utility>
 
@@ -30,9 +29,8 @@ struct MoveOnly
   MoveOnly& operator=(MoveOnly&&)
   { return *this; }
 
-private:
-  MoveOnly(MoveOnly const&); // = delete
-  MoveOnly& operator=(MoveOnly const&); // = delete
+  MoveOnly(MoveOnly const&) = delete;
+  MoveOnly& operator=(MoveOnly const&) = delete;
 };
 
 MoveOnly
diff --git a/libstdc++-v3/testsuite/20_util/weak_ptr/comparison/cmp_neg.cc b/libstdc++-v3/testsuite/20_util/weak_ptr/comparison/cmp_neg.cc
index 040c196..ace80cf 100644 (file)
--- a/libstdc++-v3/testsuite/20_util/weak_ptr/comparison/cmp_neg.cc
+++ b/libstdc++-v3/testsuite/20_util/weak_ptr/comparison/cmp_neg.cc
@@ -51,9 +51,9 @@ main()
 // { dg-warning "note" "" { target *-*-* } 485 }
 // { dg-warning "note" "" { target *-*-* } 479 }
 // { dg-warning "note" "" { target *-*-* } 469 }
-// { dg-warning "note" "" { target *-*-* } 868 }
+// { dg-warning "note" "" { target *-*-* } 887 }
 // { dg-warning "note" "" { target *-*-* } 1056 }
 // { dg-warning "note" "" { target *-*-* } 1050 }
 // { dg-warning "note" "" { target *-*-* } 342 }
 // { dg-warning "note" "" { target *-*-* } 292 }
-// { dg-warning "note" "" { target *-*-* } 214 }
+// { dg-warning "note" "" { target *-*-* } 224 }
Domain: System / Toolchain;