stl_tree.h: Make erase return iterator as per DR 130.

2009-08-14  Edward Smith-Rowland  <3dw4rd@verizon.net>

	* include/bits/stl_tree.h: Make erase return iterator as per DR 130.
	* include/bits/stl_set.h: Same.
	* include/bits/stl_multiset.h: Same.
	* include/bits/stl_map.h: Same.
	* include/bits/stl_multimap.h: Same.
	* doc/xml/manual/intro.xml: Document.
	* testsuite/23_containers/set/dr130.cc: New.
	* testsuite/23_containers/multiset/dr130.cc: New.
	* testsuite/23_containers/map/dr130.cc: New.
	* testsuite/23_containers/multimap/dr130.cc: New.

From-SVN: r150768

libstdc++-v3/ChangeLog

@@ -1,3 +1,16 @@
+2009-08-14  Edward Smith-Rowland  <3dw4rd@verizon.net>
+
+	* include/bits/stl_tree.h: Make erase return iterator as per DR 130.
+	* include/bits/stl_set.h: Same.
+	* include/bits/stl_multiset.h: Same.
+	* include/bits/stl_map.h: Same.
+	* include/bits/stl_multimap.h: Same.
+	* doc/xml/manual/intro.xml: Document.
+	* testsuite/23_containers/set/dr130.cc: New.
+	* testsuite/23_containers/multiset/dr130.cc: New.
+	* testsuite/23_containers/map/dr130.cc: New.
+	* testsuite/23_containers/multimap/dr130.cc: New.
+
 2009-08-14  Benjamin Kosnik  <bkoz@redhat.com>
 
 	* include/ext/pointer.h: Add pragma system_header, use

libstdc++-v3/doc/xml/manual/intro.xml

@@ -393,6 +393,12 @@ requirements of the license of GCC.
     <listitem><para>These functions set <code>failbit</code> on error now.
     </para></listitem></varlistentry>
 
+    <varlistentry><term><ulink url="../ext/lwg-defects.html#130">130</ulink>:
+        <emphasis>Return type of container::erase(iterator) differs for associative containers</emphasis>
+    </term>
+    <listitem><para>Make member <code>erase</code> return iterator for <code>set</code>, <code>multiset</code>, <code>map</code>, <code>multimap</code>. 
+    </para></listitem></varlistentry>
+
     <varlistentry><term><ulink url="../ext/lwg-defects.html#136">136</ulink>:
         <emphasis>seekp, seekg setting wrong streams?</emphasis>
     </term>

libstdc++-v3/include/bits/stl_map.h

@@ -552,6 +552,26 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D)
         insert(_InputIterator __first, _InputIterator __last)
         { _M_t._M_insert_unique(__first, __last); }
 
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // DR 130. Associative erase should return an iterator.
+      /**
+       *  @brief Erases an element from a %map.
+       *  @param  position  An iterator pointing to the element to be erased.
+       *  @return An iterator pointing to the element immediately following
+       *          @a position prior to the element being erased. If no such 
+       *          element exists, end() is returned.
+       *
+       *  This function erases an element, pointed to by the given
+       *  iterator, from a %map.  Note that this function only erases
+       *  the element, and that if the element is itself a pointer,
+       *  the pointed-to memory is not touched in any way.  Managing
+       *  the pointer is the user's responsibility.
+       */
+      iterator
+      erase(iterator __position)
+      { return _M_t.erase(__position); }
+#else
       /**
        *  @brief Erases an element from a %map.
        *  @param  position  An iterator pointing to the element to be erased.
@@ -565,6 +585,7 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D)
       void
       erase(iterator __position)
       { _M_t.erase(__position); }
+#endif
 
       /**
        *  @brief Erases elements according to the provided key.
@@ -581,6 +602,25 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D)
       erase(const key_type& __x)
       { return _M_t.erase(__x); }
 
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // DR 130. Associative erase should return an iterator.
+      /**
+       *  @brief Erases a [first,last) range of elements from a %map.
+       *  @param  first  Iterator pointing to the start of the range to be
+       *                 erased.
+       *  @param  last  Iterator pointing to the end of the range to be erased.
+       *  @return The iterator @a last.
+       *
+       *  This function erases a sequence of elements from a %map.
+       *  Note that this function only erases the element, and that if
+       *  the element is itself a pointer, the pointed-to memory is not touched
+       *  in any way.  Managing the pointer is the user's responsibility.
+       */
+      iterator
+      erase(iterator __first, iterator __last)
+      { return _M_t.erase(__first, __last); }
+#else
       /**
        *  @brief Erases a [first,last) range of elements from a %map.
        *  @param  first  Iterator pointing to the start of the range to be
@@ -595,6 +635,7 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D)
       void
       erase(iterator __first, iterator __last)
       { _M_t.erase(__first, __last); }
+#endif
 
       /**
        *  @brief  Swaps data with another %map.

libstdc++-v3/include/bits/stl_multimap.h

@@ -488,6 +488,26 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D)
       { this->insert(__l.begin(), __l.end()); }
 #endif
 
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // DR 130. Associative erase should return an iterator.
+      /**
+       *  @brief Erases an element from a %multimap.
+       *  @param  position  An iterator pointing to the element to be erased.
+       *  @return An iterator pointing to the element immediately following
+       *          @a position prior to the element being erased. If no such 
+       *          element exists, end() is returned.
+       *
+       *  This function erases an element, pointed to by the given iterator,
+       *  from a %multimap.  Note that this function only erases the element,
+       *  and that if the element is itself a pointer, the pointed-to memory is
+       *  not touched in any way.  Managing the pointer is the user's
+       *  responsibility.
+       */
+      iterator
+      erase(iterator __position)
+      { return _M_t.erase(__position); }
+#else
       /**
        *  @brief Erases an element from a %multimap.
        *  @param  position  An iterator pointing to the element to be erased.
@@ -501,6 +521,7 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D)
       void
       erase(iterator __position)
       { _M_t.erase(__position); }
+#endif
 
       /**
        *  @brief Erases elements according to the provided key.
@@ -517,6 +538,27 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D)
       erase(const key_type& __x)
       { return _M_t.erase(__x); }
 
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // DR 130. Associative erase should return an iterator.
+      /**
+       *  @brief Erases a [first,last) range of elements from a %multimap.
+       *  @param  first  Iterator pointing to the start of the range to be
+       *                 erased.
+       *  @param  last  Iterator pointing to the end of the range to be erased.
+       *  @return The iterator @a last.
+       *
+       *  This function erases a sequence of elements from a %multimap.
+       *  Note that this function only erases the elements, and that if
+       *  the elements themselves are pointers, the pointed-to memory is not
+       *  touched in any way.  Managing the pointer is the user's responsibility.
+       */
+      iterator
+      erase(iterator __first, iterator __last)
+      { return _M_t.erase(__first, __last); }
+#else
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // DR 130. Associative erase should return an iterator.
       /**
        *  @brief Erases a [first,last) range of elements from a %multimap.
        *  @param  first  Iterator pointing to the start of the range to be
@@ -531,6 +573,7 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D)
       void
       erase(iterator __first, iterator __last)
       { _M_t.erase(__first, __last); }
+#endif
 
       /**
        *  @brief  Swaps data with another %multimap.

libstdc++-v3/include/bits/stl_multiset.h

@@ -445,6 +445,26 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D)
       { this->insert(__l.begin(), __l.end()); }
 #endif
 
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // DR 130. Associative erase should return an iterator.
+      /**
+       *  @brief Erases an element from a %multiset.
+       *  @param  position  An iterator pointing to the element to be erased.
+       *  @return An iterator pointing to the element immediately following
+       *          @a position prior to the element being erased. If no such 
+       *          element exists, end() is returned.
+       *
+       *  This function erases an element, pointed to by the given iterator,
+       *  from a %multiset.  Note that this function only erases the element,
+       *  and that if the element is itself a pointer, the pointed-to memory is
+       *  not touched in any way.  Managing the pointer is the user's
+       *  responsibility.
+       */
+      iterator
+      erase(iterator __position)
+      { return _M_t.erase(__position); }
+#else
       /**
        *  @brief Erases an element from a %multiset.
        *  @param  position  An iterator pointing to the element to be erased.
@@ -458,6 +478,7 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D)
       void
       erase(iterator __position)
       { _M_t.erase(__position); }
+#endif
 
       /**
        *  @brief Erases elements according to the provided key.
@@ -474,6 +495,25 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D)
       erase(const key_type& __x)
       { return _M_t.erase(__x); }
 
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // DR 130. Associative erase should return an iterator.
+      /**
+       *  @brief Erases a [first,last) range of elements from a %multiset.
+       *  @param  first  Iterator pointing to the start of the range to be
+       *                 erased.
+       *  @param  last  Iterator pointing to the end of the range to be erased.
+       *  @return The iterator @a last.
+       *
+       *  This function erases a sequence of elements from a %multiset.
+       *  Note that this function only erases the elements, and that if
+       *  the elements themselves are pointers, the pointed-to memory is not
+       *  touched in any way.  Managing the pointer is the user's responsibility.
+       */
+      iterator
+      erase(iterator __first, iterator __last)
+      { return _M_t.erase(__first, __last); }
+#else
       /**
        *  @brief Erases a [first,last) range of elements from a %multiset.
        *  @param  first  Iterator pointing to the start of the range to be
@@ -488,6 +528,7 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D)
       void
       erase(iterator __first, iterator __last)
       { _M_t.erase(__first, __last); }
+#endif
 
       /**
        *  Erases all elements in a %multiset.  Note that this function only

libstdc++-v3/include/bits/stl_set.h

@@ -458,6 +458,25 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D)
       { this->insert(__l.begin(), __l.end()); }
 #endif
 
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // DR 130. Associative erase should return an iterator.
+      /**
+       *  @brief Erases an element from a %set.
+       *  @param  position  An iterator pointing to the element to be erased.
+       *  @return An iterator pointing to the element immediately following
+       *          @a position prior to the element being erased. If no such 
+       *          element exists, end() is returned.
+       *
+       *  This function erases an element, pointed to by the given iterator,
+       *  from a %set.  Note that this function only erases the element, and
+       *  that if the element is itself a pointer, the pointed-to memory is not
+       *  touched in any way.  Managing the pointer is the user's responsibility.
+       */
+      iterator
+      erase(iterator __position)
+      { return _M_t.erase(__position); }
+#else
       /**
        *  @brief Erases an element from a %set.
        *  @param  position  An iterator pointing to the element to be erased.
@@ -470,6 +489,7 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D)
       void
       erase(iterator __position)
       { _M_t.erase(__position); }
+#endif
 
       /**
        *  @brief Erases elements according to the provided key.
@@ -486,6 +506,25 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D)
       erase(const key_type& __x)
       { return _M_t.erase(__x); }
 
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // DR 130. Associative erase should return an iterator.
+      /**
+       *  @brief Erases a [first,last) range of elements from a %set.
+       *  @param  first  Iterator pointing to the start of the range to be
+       *                 erased.
+       *  @param  last  Iterator pointing to the end of the range to be erased.
+       *  @return The iterator @a last.
+       *
+       *  This function erases a sequence of elements from a %set.
+       *  Note that this function only erases the element, and that if
+       *  the element is itself a pointer, the pointed-to memory is not touched
+       *  in any way.  Managing the pointer is the user's responsibility.
+       */
+      iterator
+      erase(iterator __first, iterator __last)
+      { return _M_t.erase(__first, __last); }
+#else
       /**
        *  @brief Erases a [first,last) range of elements from a %set.
        *  @param  first  Iterator pointing to the start of the range to be
@@ -500,6 +539,7 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D)
       void
       erase(iterator __first, iterator __last)
       { _M_t.erase(__first, __last); }
+#endif
 
       /**
        *  Erases all elements in a %set.  Note that this function only erases

libstdc++-v3/include/bits/stl_tree.h

@@ -698,21 +698,43 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
         void
         _M_insert_equal(_InputIterator __first, _InputIterator __last);
 
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // DR 130. Associative erase should return an iterator.
+      iterator
+      erase(iterator __position);
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // DR 130. Associative erase should return an iterator.
+      const_iterator
+      erase(const_iterator __position);
+#else
       void
       erase(iterator __position);
 
       void
       erase(const_iterator __position);
-
+#endif
       size_type
       erase(const key_type& __x);
 
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // DR 130. Associative erase should return an iterator.
+      iterator
+      erase(iterator __first, iterator __last);
+
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
+      // DR 130. Associative erase should return an iterator.
+      const_iterator
+      erase(const_iterator __first, const_iterator __last);
+#else
       void
       erase(iterator __first, iterator __last);
 
       void
       erase(const_iterator __first, const_iterator __last);
-
+#endif
       void
       erase(const key_type* __first, const key_type* __last);
 
@@ -1327,6 +1349,45 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
 	  _M_insert_equal_(end(), *__first);
       }
 
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+  // _GLIBCXX_RESOLVE_LIB_DEFECTS
+  // DR 130. Associative erase should return an iterator.
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    inline typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    erase(iterator __position)
+    {
+      iterator __result = __position;
+      ++__result;
+      _Link_type __y =
+	static_cast<_Link_type>(_Rb_tree_rebalance_for_erase
+				(__position._M_node,
+				 this->_M_impl._M_header));
+      _M_destroy_node(__y);
+      --_M_impl._M_node_count;
+      return __result;
+    }
+
+  // _GLIBCXX_RESOLVE_LIB_DEFECTS
+  // DR 130. Associative erase should return an iterator.
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    inline typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::const_iterator
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    erase(const_iterator __position)
+    {
+      const_iterator __result = __position;
+      ++__result;
+      _Link_type __y =
+	static_cast<_Link_type>(_Rb_tree_rebalance_for_erase
+				(const_cast<_Base_ptr>(__position._M_node),
+				 this->_M_impl._M_header));
+      _M_destroy_node(__y);
+      --_M_impl._M_node_count;
+      return __result;
+    }
+#else
   template<typename _Key, typename _Val, typename _KeyOfValue,
            typename _Compare, typename _Alloc>
     inline void
@@ -1354,6 +1415,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
       _M_destroy_node(__y);
       --_M_impl._M_node_count;
     }
+#endif
 
   template<typename _Key, typename _Val, typename _KeyOfValue,
            typename _Compare, typename _Alloc>
@@ -1367,6 +1429,49 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
       return __old_size - size();
     }
 
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+  // _GLIBCXX_RESOLVE_LIB_DEFECTS
+  // DR 130. Associative erase should return an iterator.
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    erase(iterator __first, iterator __last)
+    {
+      if (__first == begin() && __last == end())
+        {
+	  clear();
+	  return end();
+        }
+      else
+        {
+	  while (__first != __last)
+	    erase(__first++);
+	  return __last;
+        }
+    }
+
+  // _GLIBCXX_RESOLVE_LIB_DEFECTS
+  // DR 130. Associative erase should return an iterator.
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::const_iterator
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    erase(const_iterator __first, const_iterator __last)
+    {
+      if (__first == begin() && __last == end())
+        {
+	  clear();
+	  return end();
+        }
+      else
+        {
+	  while (__first != __last)
+	    erase(__first++);
+	  return __last;
+        }
+    }
+#else
   template<typename _Key, typename _Val, typename _KeyOfValue,
            typename _Compare, typename _Alloc>
     void
@@ -1392,6 +1497,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
 	while (__first != __last)
 	  erase(__first++);
     }
+#endif
 
   template<typename _Key, typename _Val, typename _KeyOfValue,
            typename _Compare, typename _Alloc>

libstdc++-v3/testsuite/23_containers/map/dr130.cc

@@ -0,0 +1,77 @@
+// { dg-options "-std=gnu++0x" }
+// 2008-07-22  Edward Smith-Rowland  <3dw4rd@verizon.net>
+//
+// Copyright (C) 2009 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 <map>
+#include <testsuite_hooks.h>
+
+//  DR 130. Associative erase should return an iterator.
+void
+test01()
+{
+  bool test __attribute__((unused)) = true;
+  using namespace std;
+
+  map<int, int> m0;
+  typedef map<int, int>::iterator iterator;
+  typedef map<int, int>::const_iterator const_iterator;
+  typedef map<int, int>::value_type value_type;
+  typedef pair<iterator, bool> insert_return_type;
+
+  insert_return_type irt0 = m0.insert(value_type(1, 1));
+  insert_return_type irt1 = m0.insert(value_type(2, 2));
+  insert_return_type irt2 = m0.insert(value_type(3, 3));
+
+  iterator pos1 = m0.erase(irt1.first);
+  VERIFY( pos1 == irt2.first );
+
+  iterator pos2 = m0.erase(irt2.first);
+  VERIFY( pos2 == m0.end() );
+}
+
+void
+test02()
+{
+  bool test __attribute__((unused)) = true;
+  using namespace std;
+
+  map<int, int> m0;
+  typedef map<int, int>::iterator iterator;
+  typedef map<int, int>::const_iterator const_iterator;
+  typedef map<int, int>::value_type value_type;
+  typedef pair<iterator, bool> insert_return_type;
+
+  insert_return_type irt0 = m0.insert(value_type(1, 1));
+  insert_return_type irt1 = m0.insert(value_type(2, 2));
+  insert_return_type irt2 = m0.insert(value_type(3, 3));
+  insert_return_type irt3 = m0.insert(value_type(4, 4));
+
+  iterator pos1 = m0.erase(irt0.first, irt2.first);
+  VERIFY( pos1 == irt2.first );
+
+  iterator pos2 = m0.erase(irt2.first, ++irt3.first);
+  VERIFY( pos2 == m0.end() );
+}
+
+int
+main()
+{
+  test01();
+  test02();
+}

libstdc++-v3/testsuite/23_containers/multimap/dr130.cc

@@ -0,0 +1,87 @@
+// { dg-options "-std=gnu++0x" }
+
+// Copyright (C) 2009 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 multiset (via swap). If the implementation changed
+// this test may begin to fail.
+
+#include <map>
+#include <vector>
+#include <testsuite_hooks.h>
+
+using namespace std;
+
+void
+test01()
+{
+  bool test __attribute__((unused)) = true;
+  using namespace std;
+
+  multimap<int, int> mm0;
+  typedef multimap<int, int>::iterator iterator;
+  typedef multimap<int, int>::const_iterator const_iterator;
+  typedef multimap<int, int>::value_type value_type;
+  typedef iterator insert_return_type;
+
+  vector<insert_return_type> irt;
+  for (int i = 1; i <= 4; ++i)
+    for (int j = 1; j <= i; ++j)
+      irt.push_back( mm0.insert( value_type( i, i ) ) );
+
+  iterator pos1 = mm0.erase(irt[1]);
+  VERIFY( pos1 == irt[2] );
+
+  iterator pos2 = mm0.erase(irt[2]);
+  VERIFY( pos2 == irt[3] );
+
+  iterator pos3 = mm0.erase(irt[9]);
+  VERIFY( pos3 == mm0.end() );
+}
+
+void
+test02()
+{
+  bool test __attribute__((unused)) = true;
+  using namespace std;
+
+  multimap<int, int> mm0;
+  typedef multimap<int, int>::iterator iterator;
+  typedef multimap<int, int>::const_iterator const_iterator;
+  typedef multimap<int, int>::value_type value_type;
+  typedef iterator insert_return_type;
+
+  vector<insert_return_type> irt;
+  for (int i = 1; i <= 4; ++i)
+    for (int j = 1; j <= i; ++j)
+      irt.push_back( mm0.insert( value_type( i, i ) ) );
+
+  iterator pos1 = mm0.erase(irt[3], irt[6]);
+  VERIFY( pos1 == irt[6] );
+
+  iterator pos2 = mm0.erase(irt[6], ++irt[9]);
+  VERIFY( pos2 == mm0.end() );
+}
+
+int
+main()
+{
+  test01();
+  test02();
+}

libstdc++-v3/testsuite/23_containers/multiset/dr130.cc

@@ -0,0 +1,85 @@
+// { dg-options "-std=gnu++0x" }
+
+// Copyright (C) 2009 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 multiset (via swap). If the implementation changed
+// this test may begin to fail.
+
+#include <set>
+#include <vector>
+#include <testsuite_hooks.h>
+
+using namespace std;
+
+void
+test01()
+{
+  bool test __attribute__((unused)) = true;
+  using namespace std;
+
+  multiset<int> ms0;
+  typedef multiset<int>::iterator iterator;
+  typedef multiset<int>::const_iterator const_iterator;
+  typedef iterator insert_return_type;
+
+  vector<insert_return_type> irt;
+  for ( int i = 1; i <= 4; ++i )
+    for (int j = 1; j <= i; ++j)
+      irt.push_back( ms0.insert( i ) );
+
+  iterator pos1 = ms0.erase(irt[1]);
+  VERIFY( pos1 == irt[2] );
+
+  iterator pos2 = ms0.erase(irt[2]);
+  VERIFY( pos2 == irt[3] );
+
+  iterator pos3 = ms0.erase(irt[9]);
+  VERIFY( pos3 == ms0.end() );
+}
+
+void
+test02()
+{
+  bool test __attribute__((unused)) = true;
+  using namespace std;
+
+  multiset<int> ms0;
+  typedef multiset<int>::iterator iterator;
+  typedef multiset<int>::const_iterator const_iterator;
+  typedef iterator insert_return_type;
+
+  vector<insert_return_type> irt;
+  for ( int i = 1; i <= 4; ++i )
+    for (int j = 1; j <= i; ++j)
+      irt.push_back( ms0.insert( i ) );
+
+  iterator pos1 = ms0.erase(irt[3], irt[6]);
+  VERIFY( pos1 == irt[6] );
+
+  iterator pos2 = ms0.erase(irt[6], ++irt[9]);
+  VERIFY( pos2 == ms0.end() );
+}
+
+int
+main()
+{
+  test01();
+  test02();
+}

libstdc++-v3/testsuite/23_containers/set/dr130.cc

@@ -0,0 +1,75 @@
+// { dg-options "-std=gnu++0x" }
+// 2008-07-22  Edward Smith-Rowland  <3dw4rd@verizon.net>
+//
+// Copyright (C) 2009 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 <set>
+#include <testsuite_hooks.h>
+
+//  DR 130. Associative erase should return an iterator.
+void
+test01()
+{
+  bool test __attribute__((unused)) = true;
+  using namespace std;
+
+  set<int> s0;
+  typedef set<int>::iterator iterator;
+  typedef set<int>::const_iterator const_iterator;
+  typedef pair<iterator, bool> insert_return_type;
+
+  insert_return_type irt0 = s0.insert(1);
+  insert_return_type irt1 = s0.insert(2);
+  insert_return_type irt2 = s0.insert(3);
+
+  iterator pos1 = s0.erase(irt1.first);
+  VERIFY( pos1 == irt2.first );
+
+  iterator pos2 = s0.erase(irt2.first);
+  VERIFY( pos2 == s0.end() );
+}
+
+void
+test02()
+{
+  bool test __attribute__((unused)) = true;
+  using namespace std;
+
+  set<int> s0;
+  typedef set<int>::iterator iterator;
+  typedef set<int>::const_iterator const_iterator;
+  typedef pair<iterator, bool> insert_return_type;
+
+  insert_return_type irt0 = s0.insert(1);
+  insert_return_type irt1 = s0.insert(2);
+  insert_return_type irt2 = s0.insert(3);
+  insert_return_type irt3 = s0.insert(4);
+
+  iterator pos1 = s0.erase(irt0.first, irt2.first);
+  VERIFY( pos1 == irt2.first );
+
+  iterator pos2 = s0.erase(irt2.first, ++irt3.first);
+  VERIFY( pos2 == s0.end() );
+}
+
+int
+main()
+{
+  test01();
+  test02();
+}