2018-09-02 François Dumont <fdumont@gcc.gnu.org>

	* include/debug/safe_iterator.h
	(_Safe_iterator<_It, _Seq, _Cat>::_Self): New.
	(_Safe_iterator<_It, _Seq, std::random_access_iterator_tag>::_Self):
	New.
	(_Safe_iterator<_It, _Seq, std::random_access_iterator_tag>
	::_OtherSelf): New.
	(_GLIBCXX_DEBUG_VERIFY_OPERANDS, _GLIBCXX_DEBUG_VERIFY_EQ_OPERANDS)
	(_GLIBCXX_DEBUG_VERIFY_REL_OPERANDS)
	(_GLIBCXX_DEBUG_VERIFY_DIST_OPERANDS): Define macros.
	(_Safe_iterator<_It, _Seq, std::random_access_iterator_tag>
	::operator+(difference_type)): Use latters, inline as friend.
	(_Safe_iterator<_It, _Seq, std::random_access_iterator_tag>
	::operator-(difference_type)): Likewise.
	(operator==(const _Safe_iterator<>&, const _Safe_iterator<>&)):
	Likewise.
	(operator!=(const _Safe_iterator<>&, const _Safe_iterator<>&)):
	Likewise.
	(operator<(const _Safe_iterator<>&, const _Safe_iterator<>&)): Likewise.
	(operator<=(const _Safe_iterator<>&, const _Safe_iterator<>&)):
	Likewise.
	(operator>(const _Safe_iterator<>&, const _Safe_iterator<>&)): Likewise.
	(operator>=(const _Safe_iterator<>&, const _Safe_iterator<>&)):
	Likewise.
	(operator-(const _Safe_iterator<>&, const _Safe_iterator<>&)): Likewise.
	(operator+(difference_type, const _Safe_iterator<>&)): Likewise.
	(operator-(const _Safe_iterator<>&, difference_type)): Likewise.
	* include/debug/safe_iterator.tcc
	(_Safe_iterator<>::_M_can_advance(difference_type)): Take parameter by
	copy.
	* include/debug/safe_local_iterator.h
	(_Safe_local_iterator<_It, _Seq>::_Self): New.
	(_Safe_local_iterator<_It, _Seq>::_OtherSelf): New.
	(_GLIBCXX_DEBUG_VERIFY_OPERANDS): Define macro.
	(operator==(const _Safe_local_iterator<>&,
	const _Safe_local_iterator<>&)): Use latter, inline as friend.
	(operator!=(const _Safe_local_iterator<>&,
	const _Safe_local_iterator<>&)): Likewise.
	* testsuite/util/testsuite_containers.h: Include utility.
	(struct forward_members_unordered<_Tp, bool>): Remove 2nd template
	parameter.
	(forward_members_unordered<>::forward_members_unordered(value_type&)):
	Add using namespace std::rel_ops.
	Add iterator_concept_checks on local_iterator and const_local_iterator.
	Add asserts on comparison between const_local_iterator and
	local_iterator.
	(struct forward_members_unordered<_Tp, false>): Remove partial
	specialization.
	* testsuite/23_containers/forward_list/types/1.cc: New.
	* testsuite/23_containers/list/types/1.cc: New.

From-SVN: r264039

3 files changed, 167 insertions, 20 deletions

diff --git a/libstdc++-v3/testsuite/23_containers/forward_list/types/1.cc b/libstdc++-v3/testsuite/23_containers/forward_list/types/1.cc
new file mode 100644
index 00000000000..164b9c4a14b
--- /dev/null
+++ b/libstdc++-v3/testsuite/23_containers/forward_list/types/1.cc
@@ -0,0 +1,34 @@
+// Copyright (C) 2018 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/>.
+
+// { dg-do compile { target c++11 } }
+
+#include <forward_list>
+#include <testsuite_greedy_ops.h>
+
+int main()
+{
+  std::forward_list<greedy_ops::X> fl;
+  const std::forward_list<greedy_ops::X> cfl;
+
+  fl.insert_after(fl.before_begin(), greedy_ops::X());
+  fl.insert_after(fl.before_begin(), 1, greedy_ops::X());
+  fl.insert_after(fl.before_begin(), cfl.begin(), cfl.end());
+  fl = cfl;
+
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/23_containers/list/types/1.cc b/libstdc++-v3/testsuite/23_containers/list/types/1.cc
new file mode 100644
index 00000000000..a7bb217c623
--- /dev/null
+++ b/libstdc++-v3/testsuite/23_containers/list/types/1.cc
@@ -0,0 +1,35 @@
+// Copyright (C) 2018 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/>.
+
+// { dg-do compile }
+
+#include <list>
+#include <testsuite_greedy_ops.h>
+
+int main()
+{
+  std::list<greedy_ops::X> l;
+  const std::list<greedy_ops::X> cl;
+
+  l.size();
+  l.insert(l.begin(), greedy_ops::X());
+  l.insert(l.begin(), 1, greedy_ops::X());
+  l.insert(l.begin(), cl.begin(), cl.end());
+  l = cl;
+
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/util/testsuite_containers.h b/libstdc++-v3/testsuite/util/testsuite_containers.h
index 759f4d6b79f..eadd43768d2 100644
--- a/libstdc++-v3/testsuite/util/testsuite_containers.h
+++ b/libstdc++-v3/testsuite/util/testsuite_containers.h
@@ -23,6 +23,7 @@
 #include <bits/boost_concept_check.h>
 #include <cassert>
 #include <testsuite_container_traits.h>
+#include <utility> // for rel_ops.
 
 // Container requirement testing.
 namespace __gnu_test
@@ -170,33 +171,38 @@ namespace __gnu_test
       reverse_members(_Tp& container) { }
     };
 
+  template<typename _Iterator,
+	   bool _Mutable,
+	   typename = typename std::iterator_traits<_Iterator>::iterator_category>
+    struct iterator_concept_checks;
+
   // DR 691.
-  template<typename _Tp, bool = traits<_Tp>::is_unordered::value>
+  template<typename _Tp>
     struct forward_members_unordered
     {
       forward_members_unordered(typename _Tp::value_type& v)
       {
+	// Make sure that even if rel_ops is injected there is no ambiguity
+	// when comparing iterators.
+	using namespace std::rel_ops;
+
 	typedef _Tp					test_type;
 	test_type container;
 	container.insert(v);
+
+	iterator_concept_checks<typename _Tp::local_iterator, false> cc;
+	iterator_concept_checks<typename _Tp::const_local_iterator,
+				false> ccc;
+
 	assert( container.cbegin(0) == container.begin(0) );
 	assert( container.cend(0) == container.end(0) );
 	const typename test_type::size_type bn = container.bucket(1);
 	assert( container.cbegin(bn) != container.cend(bn) );
+	assert( container.cbegin(bn) != container.end(bn) );
+	assert( container.begin(bn) != container.cend(bn) );
       }
     };
 
-  template<typename _Tp>
-    struct forward_members_unordered<_Tp, false>
-    {
-      forward_members_unordered(_Tp& container) { }
-    };
-
-  template<typename _Iterator,
-	   bool _Mutable,
-	   typename = typename std::iterator_traits<_Iterator>::iterator_category>
-    struct iterator_concept_checks;
-
   template<typename _Iterator>
     struct iterator_concept_checks<_Iterator, false,
 				   std::forward_iterator_tag>
@@ -264,6 +270,82 @@ namespace __gnu_test
     };
 
   template<typename _Tp>
+    struct forward_members
+    {
+      forward_members(_Tp& container)
+      {
+	// Make sure that even if rel_ops is injected there is no ambiguity
+	// when comparing iterators.
+	using namespace std::rel_ops;
+
+	typedef traits<_Tp> traits_type;
+	iterator_concept_checks<typename _Tp::iterator,
+				!(traits_type::is_associative::value
+				  || traits_type::is_unordered::value)> cc;
+	iterator_concept_checks<typename _Tp::const_iterator, false> ccc;
+
+	assert( container.cbegin() == container.begin() );
+	assert( container.end() == container.cend() );
+	assert( container.cbegin() != container.cend() );
+	assert( container.cbegin() != container.end() );
+	assert( container.begin() != container.cend() );
+      }
+  };
+
+  template<typename _Tp,
+	   typename
+    = typename std::iterator_traits<typename _Tp::iterator>::iterator_category>
+    struct category_members : forward_members<_Tp>
+    {
+      category_members(_Tp& container)
+	: forward_members<_Tp>(container)
+      { };
+    };
+
+  template<typename _Tp>
+    struct category_members<_Tp, std::random_access_iterator_tag>
+    : forward_members<_Tp>
+    {
+      category_members(_Tp& container)
+	: forward_members<_Tp>(container)
+      {
+	// Make sure that even if rel_ops is injected there is no ambiguity
+	// when comparing iterators.
+	using namespace std::rel_ops;
+
+	assert( !(container.begin() < container.begin()) );
+	assert( !(container.cbegin() < container.cbegin()) );
+	assert( !(container.cbegin() < container.begin()) );
+	assert( !(container.begin() < container.cbegin()) );
+	assert( container.begin() <= container.begin() );
+	assert( container.cbegin() <= container.cbegin() );
+	assert( container.cbegin() <= container.begin() );
+	assert( container.begin() <= container.cbegin() );
+
+	assert( !(container.begin() > container.begin()) );
+	assert( !(container.cbegin() > container.cbegin()) );
+	assert( !(container.cbegin() > container.begin()) );
+	assert( !(container.begin() > container.cbegin()) );
+	assert( container.begin() >= container.begin() );
+	assert( container.cbegin() >= container.cbegin() );
+	assert( container.cbegin() >= container.begin() );
+	assert( container.begin() >= container.cbegin() );
+
+	assert( container.begin() - container.begin() == 0 );
+	assert( container.cbegin() - container.cbegin() == 0 );
+	assert( container.cbegin() - container.begin() == 0 );
+	assert( container.begin() - container.cbegin() == 0 );
+
+	assert( container.begin() + 0 == container.begin() );
+	assert( container.cbegin() + 0 == container.cbegin() );
+	assert( 0 + container.begin() == container.begin() );
+	assert( 0 + container.cbegin() == container.cbegin() );
+	assert( container.begin() - 0 == container.begin() );
+	assert( container.cbegin() - 0 == container.cbegin() );
+      }
+  };
+
+  template<typename _Tp>
     struct citerator
     {
       typedef _Tp 					test_type;
@@ -273,21 +355,17 @@ namespace __gnu_test
       static test_type _S_container;
 
       // Unconditional.
-      struct forward_members
+      struct members : category_members<_Tp>
       {
-	forward_members()
-	{
-	  assert( _S_container.cbegin() == _S_container.begin() );
-	  assert( _S_container.cend() == _S_container.end() );
-	  assert( _S_container.cbegin() != _S_container.cend() );
-	}
+	members() : category_members<_Tp>(_S_container)
+	{ }
       };
 
       // Run test.
       citerator()
       {
 	populate<test_type> p(_S_container);
-	forward_members m1;
+	members m1;
 	reverse_members<test_type> m2(_S_container);
       }
   };