[libc++] Deprecate std::iterator and remove it as a base class

[ldionne]

Summary

C++17 deprecated std::iterator and removed it as a base class for all
iterator adaptors. We implement that change, but we still provide a way
to inherit from std::iterator in the few cases where doing otherwise
would be an ABI break.

Supersedes D101729 and the std::iterator base parts of D103101 and D102657.

[Mordante]

SGTM some questions.

libcxx/include/__memory/raw_storage_iterator.h

45

Is it intended to change the types of these typedefs and the base class?

libcxx/include/iterator

510

Can we remove this class when _LIBCPP_ABI_NO_ITERATOR_BASES is defined?

[• Quuxplusone]

LGTM % comments!

libcxx/include/iterator

510

No. The existence of this class doesn't have ABI implications. Also, this class is still present (but deprecated) in C++20. https://timsong-cpp.github.io/cppwp/n4861/depr.iterator.basic#lib:iterator
If this class were removed from C++23, we'd want to guard it under an API macro such as _LIBCPP_ENABLE_CXX23_REMOVED_ITERATOR.

818

D103101 updates this code for C++20 (where difference_type becomes ptrdiff_t instead of void). Do you want to roll that in here á là D103101, or would you like a followup PR for that?
Notice that we want to change the value of the typedef in C++20, but not alter the name of the base class (because that would break ABI).

libcxx/test/libcxx/iterators/iterator.requirements/iterator.concepts/cpp20_iter_concepts.pass.cpp

48–62

These changes look OK to me, but it would be useful to know what the author was originally trying to test here: this test didn't have anything to do with std::iterator's behavior, did it?
I suggest drive-by changing

namespace std {
template <>
struct iterator_traits<MyIter3> {

to

template <>
struct std::iterator_traits<MyIter3> {

both to save LOC and to avoid reopening namespace std.

libcxx/test/libcxx/iterators/iterator.requirements/iterator.concepts/cpp20_iter_traits.pass.cpp

0

Same comment here about reopening namespace std.
But also here it is clear that MyIter and MyIter2 are exactly equivalent, and so you can eliminate one of them.
It looks like the point of this test is to verify that std::_ITER_TRAITS<T> is std::iterator_traits<T> when T specializes iterator_traits, and T when it doesn't. So the entire test file should look like

#include <iterator>
#include "test_iterators.h"
struct A : random_access_iterator<int*> {};
struct B : random_access_iterator<int*> {};
struct C : random_access_iterator<int*> {};
struct D : random_access_iterator<int*> {};
template<> struct std::iterator_traits<B> {};
template<> struct std::iterator_traits<C> : std::iterator_traits<A> {};
template<> struct std::iterator_traits<D> : std::iterator_traits<int*> {};

static_assert(std::is_same_v<std::_ITER_TRAITS<int*>, std::iterator_traits<int*>>);
static_assert(std::is_same_v<std::_ITER_TRAITS<A>, A>);
static_assert(std::is_same_v<std::_ITER_TRAITS<B>, std::iterator_traits<B>>);
static_assert(std::is_same_v<std::_ITER_TRAITS<C>, std::iterator_traits<C>>);
static_assert(std::is_same_v<std::_ITER_TRAITS<D>, std::iterator_traits<D>>);

and it should be a .compile.pass.cpp test.

libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iterator/types.pass.cpp

54

Probably should say typename R::value_type instead of char, for consistency with lines 49-53.

[ldionne]

Apply review feedback

[ldionne]

libcxx/include/__memory/raw_storage_iterator.h

45

Yes, I'm making it standards conforming. I'll add a test too, it seems like we didn't have any.

libcxx/include/iterator

510

That's all correct.

However, going forward, I'll be keen to remove things without guarding them with something like _LIBCPP_ENABLE_CXX23_REMOVED_ITERATOR: if you opt-in to a newer standard mode, it means you're OK with the removal. So, for example, I'd be fine if we had not guarded the removal of std::raw_storage_iterator by _LIBCPP_ENABLE_CXX20_REMOVED_RAW_STORAGE_ITERATOR, but it's fine too cause it's done now.

818

I was planning on a different review where I update all the iterator types like you did in D103101 (and @zoecarver in his own similar patch).

libcxx/test/libcxx/iterators/iterator.requirements/iterator.concepts/cpp20_iter_concepts.pass.cpp

48–62

I think it's safe to assume there was no intent to test std::iterator specifically here. Agreed about the drive-by change.

libcxx/test/libcxx/iterators/iterator.requirements/iterator.concepts/cpp20_iter_traits.pass.cpp

0

Yup, I agree this is more straightforward.

[• Quuxplusone]

LGTM, ship it!
Will still need a followup to fix the difference_type of the output iterators for C++20. Are you doing that, or am I repurposing D103101, or what?

libcxx/include/__config

97–99

I wish this list were alphabetized, but it's already not-alphabetized, so meh.

libcxx/include/__memory/raw_storage_iterator.h

45

This is also, technically, an ABI break ;) but you're right, it fixes a bug that's apparently been undetected forever.

libcxx/test/std/iterators/stream.iterators/istream.iterator/types.pass.cpp

33

I think you don't need this because std::iterator wasn't deprecated <=14 and now you're mentioning it only under #if TEST_STD_VER <= 14.
Presumably ditto in some other files as well.

[• Quuxplusone]

libcxx/include/__memory/raw_storage_iterator.h

34–36

Actually, one last thing I don't understand: What's the purpose of _LIBCPP_SUPPRESS_DEPRECATED_PUSH here, given that this entire file is already controlled by #pragma GCC system_header? Do we hit situations where we're actually seeing deprecation diagnostics from this and other system headers?
I know you didn't invent _LIBCPP_SUPPRESS_DEPRECATED_PUSH, so it must be solving some problem, but I don't get it.

[ldionne]

Apply review comments and fix GCC build.

[ldionne]

libcxx/include/__memory/raw_storage_iterator.h

34–36

We disable #pragma GCC system_header when we run the test suite to avoid missing some potentially important warnings/errors, so we need to disable this warning locally to avoid failing the test suite.

45

I agree, but I don't care about this one. I think literally nobody is ever going to be affected.

libcxx/test/std/iterators/stream.iterators/istream.iterator/types.pass.cpp

33

Good catch, thanks.

libcxx/include/__config

 // of nullptr_t. This option is ABI incompatible with GCC in C++03 mode.
 #  define _LIBCPP_ABI_ALWAYS_USE_CXX11_NULLPTR
 // Define a key function for `bad_function_call` in the library, to centralize
 // its vtable and typeinfo to libc++ rather than having all other libraries
 // using that class define their own copies.
 #  define _LIBCPP_ABI_BAD_FUNCTION_CALL_KEY_FUNCTION
 // Enable optimized version of __do_get_(un)signed which avoids redundant copies.
 #  define _LIBCPP_ABI_OPTIMIZED_LOCALE_NUM_GET
+// Give reverse_iterator<T> one data member of type T, not two.
+// Also, in C++17 and later, don't derive iterator types from std::iterator.
+#  define _LIBCPP_ABI_NO_ITERATOR_BASES
 // Use the smallest possible integer type to represent the index of the variant.
 // Previously libc++ used "unsigned int" exclusively.
 #  define _LIBCPP_ABI_VARIANT_INDEX_TYPE_OPTIMIZATION
 // Unstable attempt to provide a more optimized std::function
 #  define _LIBCPP_ABI_OPTIMIZED_FUNCTION
 // All the regex constants must be distinct and nonzero.
 #  define _LIBCPP_ABI_REGEX_CONSTANTS_NONZERO
 // Use raw pointers, not wrapped ones, for std::span's iterator type.

libcxx/include/__memory/raw_storage_iterator.h

 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_RAW_STORAGE_ITERATOR)
 
+_LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <class _OutputIterator, class _Tp>
 class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX17 raw_storage_iterator
-    : public iterator<output_iterator_tag,
-                      _Tp,                                         // purposefully not C++03
-                      ptrdiff_t,                                   // purposefully not C++03
-                      _Tp*,                                        // purposefully not C++03
-                      raw_storage_iterator<_OutputIterator, _Tp>&> // purposefully not C++03
+#if _LIBCPP_STD_VER <= 14 || !defined(_LIBCPP_ABI_NO_ITERATOR_BASES)
+    : public iterator<output_iterator_tag, void, void, void, void>
+#endif
 {
+_LIBCPP_SUPPRESS_DEPRECATED_POP
 private:
     _OutputIterator __x_;
 public:
+    typedef output_iterator_tag iterator_category;
+    typedef void                value_type;
+    typedef void                difference_type;
+    typedef void                pointer;
+    typedef void                reference;
+
     _LIBCPP_INLINE_VISIBILITY explicit raw_storage_iterator(_OutputIterator __x) : __x_(__x) {}
     _LIBCPP_INLINE_VISIBILITY raw_storage_iterator& operator*() {return *this;}
     _LIBCPP_INLINE_VISIBILITY raw_storage_iterator& operator=(const _Tp& __element)
         {::new ((void*)_VSTD::addressof(*__x_)) _Tp(__element); return *this;}
 #if _LIBCPP_STD_VER >= 14
     _LIBCPP_INLINE_VISIBILITY raw_storage_iterator& operator=(_Tp&& __element)
         {::new ((void*)_VSTD::addressof(*__x_)) _Tp(_VSTD::move(__element)); return *this;}
 #endif

libcxx/include/iterator

template<class I>
   concept bidirectional_iterator = see below;              // since C++20
 
 // [iterator.concept.random.access], concept random_access_iterator
 template<class I>
   concept random_access_iterator = see below;              // since C++20
 
 template<class Category, class T, class Distance = ptrdiff_t,
          class Pointer = T*, class Reference = T&>
-struct iterator
+struct iterator                                            // deprecated in C++17
 {
     typedef T         value_type;
     typedef Distance  difference_type;
     typedef Pointer   pointer;
     typedef Reference reference;
     typedef Category  iterator_category;
 };
 
namespace ranges {
   template<input_or_output_iterator I, sentinel_for<I> S>
     constexpr void advance(I& i, S bound);                                         // since C++20
   template<input_or_output_iterator I, sentinel_for<I> S>
     constexpr iter_difference_t<I> advance(I& i, iter_difference_t<I> n, S bound); // since C++20
 }
 
 template <class Iterator>
 class reverse_iterator
-    : public iterator<typename iterator_traits<Iterator>::iterator_category,
+    : public iterator<typename iterator_traits<Iterator>::iterator_category, // until C++17
                       typename iterator_traits<Iterator>::value_type,
                       typename iterator_traits<Iterator>::difference_type,
                       typename iterator_traits<Iterator>::pointer,
                       typename iterator_traits<Iterator>::reference>
 {
 protected:
     Iterator current;
 public:
constexpr move_iterator<Iterator> operator+(   // constexpr in C++17
             const move_iterator<Iterator>& x);
 
 template <class Iterator>   // constexpr in C++17
 constexpr  move_iterator<Iterator> make_move_iterator(const Iterator& i);
 
 
 template <class T, class charT = char, class traits = char_traits<charT>, class Distance = ptrdiff_t>
 class istream_iterator
-    : public iterator<input_iterator_tag, T, Distance, const T*, const T&>
+    : public iterator<input_iterator_tag, T, Distance, const T*, const T&> // until C++17
 {
 public:
     typedef charT char_type;
     typedef traits traits_type;
     typedef basic_istream<charT,traits> istream_type;
 
     constexpr istream_iterator();
     istream_iterator(istream_type& s);

 bool operator==(const istream_iterator<T,charT,traits,Distance>& x,
                 const istream_iterator<T,charT,traits,Distance>& y);
 template <class T, class charT, class traits, class Distance>
 bool operator!=(const istream_iterator<T,charT,traits,Distance>& x,
                 const istream_iterator<T,charT,traits,Distance>& y);
 
 template <class T, class charT = char, class traits = char_traits<charT> >
 class ostream_iterator
-    : public iterator<output_iterator_tag, void, void, void ,void>
+    : public iterator<output_iterator_tag, void, void, void ,void> // until C++17
 {
 public:
     typedef charT char_type;
     typedef traits traits_type;
     typedef basic_ostream<charT,traits> ostream_type;
 
     ostream_iterator(ostream_type& s);
     ostream_iterator(ostream_type& s, const charT* delimiter);
     ostream_iterator(const ostream_iterator& x);
     ~ostream_iterator();
     ostream_iterator& operator=(const T& value);
 
     ostream_iterator& operator*();
     ostream_iterator& operator++();
     ostream_iterator& operator++(int);
 };
 
 template<class charT, class traits = char_traits<charT> >
 class istreambuf_iterator
-    : public iterator<input_iterator_tag, charT,
+    : public iterator<input_iterator_tag, charT,                // until C++17
                       typename traits::off_type, unspecified,
                       charT>
 {
 public:
     typedef charT                         char_type;
     typedef traits                        traits_type;
     typedef typename traits::int_type     int_type;
     typedef basic_streambuf<charT,traits> streambuf_type;

 bool operator==(const istreambuf_iterator<charT,traits>& a,
                 const istreambuf_iterator<charT,traits>& b);
 template <class charT, class traits>
 bool operator!=(const istreambuf_iterator<charT,traits>& a,
                 const istreambuf_iterator<charT,traits>& b);
 
 template <class charT, class traits = char_traits<charT> >
 class ostreambuf_iterator
-    : public iterator<output_iterator_tag, void, void, void, void>
+    : public iterator<output_iterator_tag, void, void, void, void> // until C++17
 {
 public:
     typedef charT                         char_type;
     typedef traits                        traits_type;
     typedef basic_streambuf<charT,traits> streambuf_type;
     typedef basic_ostream<charT,traits>   ostream_type;
 
     ostreambuf_iterator(ostream_type& s) noexcept;

 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template<class _Category, class _Tp, class _Distance = ptrdiff_t,
          class _Pointer = _Tp*, class _Reference = _Tp&>
-struct _LIBCPP_TEMPLATE_VIS iterator
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX17 iterator
 {
     typedef _Tp        value_type;
     typedef _Distance  difference_type;
     typedef _Pointer   pointer;
     typedef _Reference reference;
     typedef _Category  iterator_category;
 };
 

 
 template <class _Tp, class = void>
 struct __is_stashing_iterator : false_type {};
 
 template <class _Tp>
 struct __is_stashing_iterator<_Tp, typename __void_t<typename _Tp::__stashing_iterator_tag>::type>
   : true_type {};
 
+_LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <class _Iter>
 class _LIBCPP_TEMPLATE_VIS reverse_iterator
+#if _LIBCPP_STD_VER <= 14 || !defined(_LIBCPP_ABI_NO_ITERATOR_BASES)
     : public iterator<typename iterator_traits<_Iter>::iterator_category,
                       typename iterator_traits<_Iter>::value_type,
                       typename iterator_traits<_Iter>::difference_type,
                       typename iterator_traits<_Iter>::pointer,
                       typename iterator_traits<_Iter>::reference>
+#endif
 {
+_LIBCPP_SUPPRESS_DEPRECATED_POP
 private:
-    /*mutable*/ _Iter __t;  // no longer used as of LWG #2360, not removed due to ABI break
+#ifndef _LIBCPP_ABI_NO_ITERATOR_BASES
+    _Iter __t; // no longer used as of LWG #2360, not removed due to ABI break
+#endif
 
     static_assert(!__is_stashing_iterator<_Iter>::value,
       "The specified iterator type cannot be used with reverse_iterator; "
       "Using stashing iterators with reverse_iterator causes undefined behavior");
 
 protected:
     _Iter current;
 public:
     typedef _Iter                                            iterator_type;
     typedef typename iterator_traits<_Iter>::difference_type difference_type;
     typedef typename iterator_traits<_Iter>::reference       reference;
     typedef typename iterator_traits<_Iter>::pointer         pointer;
     typedef _If<__is_cpp17_random_access_iterator<_Iter>::value,
         random_access_iterator_tag,
         typename iterator_traits<_Iter>::iterator_category>  iterator_category;
+    typedef typename iterator_traits<_Iter>::value_type      value_type;
+
 #if _LIBCPP_STD_VER > 17
     typedef _If<__is_cpp17_random_access_iterator<_Iter>::value,
         random_access_iterator_tag,
         bidirectional_iterator_tag>                          iterator_concept;
 #endif
 
+#ifndef _LIBCPP_ABI_NO_ITERATOR_BASES
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
     reverse_iterator() : __t(), current() {}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
     explicit reverse_iterator(_Iter __x) : __t(__x), current(__x) {}
     template <class _Up>
         _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
         reverse_iterator(const reverse_iterator<_Up>& __u) : __t(__u.base()), current(__u.base()) {}
     template <class _Up>
         _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
         reverse_iterator& operator=(const reverse_iterator<_Up>& __u)
             { __t = current = __u.base(); return *this; }
+#else
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
+    reverse_iterator() : current() {}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
+    explicit reverse_iterator(_Iter __x) : current(__x) {}
+    template <class _Up>
+        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
+        reverse_iterator(const reverse_iterator<_Up>& __u) : current(__u.base()) {}
+    template <class _Up>
+        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
+        reverse_iterator& operator=(const reverse_iterator<_Up>& __u)
+            { current = __u.base(); return *this; }
+#endif
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
     _Iter base() const {return current;}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
     reference operator*() const {_Iter __tmp = current; return *--__tmp;}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
     pointer  operator->() const {return _VSTD::addressof(operator*());}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
     reverse_iterator& operator++() {--current; return *this;}

 template <class _Iter>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
 reverse_iterator<_Iter> make_reverse_iterator(_Iter __i)
 {
     return reverse_iterator<_Iter>(__i);
 }
 #endif
 
+_LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <class _Container>
 class _LIBCPP_TEMPLATE_VIS back_insert_iterator
-    : public iterator<output_iterator_tag,
-                      void,
-                      void,
-                      void,
-                      void>
+#if _LIBCPP_STD_VER <= 14 || !defined(_LIBCPP_ABI_NO_ITERATOR_BASES)
+    : public iterator<output_iterator_tag, void, void, void, void>
+#endif
 {
+_LIBCPP_SUPPRESS_DEPRECATED_POP
 protected:
     _Container* container;
 public:
+    typedef output_iterator_tag iterator_category;
+    typedef void value_type;
+    typedef void difference_type;
+    typedef void pointer;
+    typedef void reference;
     typedef _Container container_type;
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 explicit back_insert_iterator(_Container& __x) : container(_VSTD::addressof(__x)) {}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 back_insert_iterator& operator=(const typename _Container::value_type& __value_)
         {container->push_back(__value_); return *this;}
 #ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 back_insert_iterator& operator=(typename _Container::value_type&& __value_)
         {container->push_back(_VSTD::move(__value_)); return *this;}
 #endif // _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 back_insert_iterator& operator*()     {return *this;}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 back_insert_iterator& operator++()    {return *this;}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 back_insert_iterator  operator++(int) {return *this;}
 };
 
 template <class _Container>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 back_insert_iterator<_Container>
 back_inserter(_Container& __x)
 {
     return back_insert_iterator<_Container>(__x);
 }
 
+_LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <class _Container>
 class _LIBCPP_TEMPLATE_VIS front_insert_iterator
-    : public iterator<output_iterator_tag,
-                      void,
-                      void,
-                      void,
-                      void>
+#if _LIBCPP_STD_VER <= 14 || !defined(_LIBCPP_ABI_NO_ITERATOR_BASES)
+    : public iterator<output_iterator_tag, void, void, void, void>
+#endif
 {
+_LIBCPP_SUPPRESS_DEPRECATED_POP
 protected:
     _Container* container;
 public:
+    typedef output_iterator_tag iterator_category;
+    typedef void value_type;
+    typedef void difference_type;
+    typedef void pointer;
+    typedef void reference;
     typedef _Container container_type;
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 explicit front_insert_iterator(_Container& __x) : container(_VSTD::addressof(__x)) {}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 front_insert_iterator& operator=(const typename _Container::value_type& __value_)
         {container->push_front(__value_); return *this;}
 #ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 front_insert_iterator& operator=(typename _Container::value_type&& __value_)
         {container->push_front(_VSTD::move(__value_)); return *this;}
 #endif // _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 front_insert_iterator& operator*()     {return *this;}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 front_insert_iterator& operator++()    {return *this;}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 front_insert_iterator  operator++(int) {return *this;}
 };
 
 template <class _Container>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 front_insert_iterator<_Container>
 front_inserter(_Container& __x)
 {
     return front_insert_iterator<_Container>(__x);
 }
 
+_LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <class _Container>
 class _LIBCPP_TEMPLATE_VIS insert_iterator
-    : public iterator<output_iterator_tag,
-                      void,
-                      void,
-                      void,
-                      void>
+#if _LIBCPP_STD_VER <= 14 || !defined(_LIBCPP_ABI_NO_ITERATOR_BASES)
+    : public iterator<output_iterator_tag, void, void, void, void>
+#endif
 {
+_LIBCPP_SUPPRESS_DEPRECATED_POP
 protected:
     _Container* container;
     typename _Container::iterator iter;
 public:
+    typedef output_iterator_tag iterator_category;
+    typedef void value_type;
+    typedef void difference_type;
+    typedef void pointer;
+    typedef void reference;
     typedef _Container container_type;
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 insert_iterator(_Container& __x, typename _Container::iterator __i)
         : container(_VSTD::addressof(__x)), iter(__i) {}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 insert_iterator& operator=(const typename _Container::value_type& __value_)
         {iter = container->insert(iter, __value_); ++iter; return *this;}
 #ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 insert_iterator& operator=(typename _Container::value_type&& __value_)
         {iter = container->insert(iter, _VSTD::move(__value_)); ++iter; return *this;}
 #endif // _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 insert_iterator& operator*()        {return *this;}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 insert_iterator& operator++()       {return *this;}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 insert_iterator& operator++(int)    {return *this;}
 };
 
 template <class _Container>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 insert_iterator<_Container>
 inserter(_Container& __x, typename _Container::iterator __i)
 {
     return insert_iterator<_Container>(__x, __i);
 }
 
+_LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <class _Tp, class _CharT = char,
           class _Traits = char_traits<_CharT>, class _Distance = ptrdiff_t>
 class _LIBCPP_TEMPLATE_VIS istream_iterator
+#if _LIBCPP_STD_VER <= 14 || !defined(_LIBCPP_ABI_NO_ITERATOR_BASES)
     : public iterator<input_iterator_tag, _Tp, _Distance, const _Tp*, const _Tp&>
+#endif
 {
+_LIBCPP_SUPPRESS_DEPRECATED_POP
 public:
+    typedef input_iterator_tag iterator_category;
+    typedef _Tp value_type;
+    typedef _Distance difference_type;
+    typedef const _Tp* pointer;
+    typedef const _Tp& reference;
     typedef _CharT char_type;
     typedef _Traits traits_type;
     typedef basic_istream<_CharT,_Traits> istream_type;
 private:
     istream_type* __in_stream_;
     _Tp __value_;
 public:
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR istream_iterator() : __in_stream_(nullptr), __value_() {}

 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator!=(const istream_iterator<_Tp, _CharT, _Traits, _Distance>& __x,
            const istream_iterator<_Tp, _CharT, _Traits, _Distance>& __y)
 {
     return !(__x == __y);
 }
 
+_LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <class _Tp, class _CharT = char, class _Traits = char_traits<_CharT> >
 class _LIBCPP_TEMPLATE_VIS ostream_iterator
+#if _LIBCPP_STD_VER <= 14 || !defined(_LIBCPP_ABI_NO_ITERATOR_BASES)
     : public iterator<output_iterator_tag, void, void, void, void>
+#endif
 {
+_LIBCPP_SUPPRESS_DEPRECATED_POP
 public:
     typedef output_iterator_tag             iterator_category;
     typedef void                            value_type;
 #if _LIBCPP_STD_VER > 17
     typedef std::ptrdiff_t                  difference_type;
 #else
     typedef void                            difference_type;
 #endif
_LIBCPP_INLINE_VISIBILITY ostream_iterator& operator=(const _Tp& __value_)
             return *this;
         }
 
     _LIBCPP_INLINE_VISIBILITY ostream_iterator& operator*()     {return *this;}
     _LIBCPP_INLINE_VISIBILITY ostream_iterator& operator++()    {return *this;}
     _LIBCPP_INLINE_VISIBILITY ostream_iterator& operator++(int) {return *this;}
 };
 
+_LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template<class _CharT, class _Traits>
 class _LIBCPP_TEMPLATE_VIS istreambuf_iterator
+#if _LIBCPP_STD_VER <= 14 || !defined(_LIBCPP_ABI_NO_ITERATOR_BASES)
     : public iterator<input_iterator_tag, _CharT,
                       typename _Traits::off_type, _CharT*,
                       _CharT>
+#endif
 {
+_LIBCPP_SUPPRESS_DEPRECATED_POP
 public:
+    typedef input_iterator_tag              iterator_category;
+    typedef _CharT                          value_type;
+    typedef typename _Traits::off_type      difference_type;
+    typedef _CharT*                         pointer;
+    typedef _CharT                          reference;
     typedef _CharT                          char_type;
     typedef _Traits                         traits_type;
     typedef typename _Traits::int_type      int_type;
     typedef basic_streambuf<_CharT,_Traits> streambuf_type;
     typedef basic_istream<_CharT,_Traits>   istream_type;
 private:
     mutable streambuf_type* __sbuf_;
 
bool operator==(const istreambuf_iterator<_CharT,_Traits>& __a,
                 {return __a.equal(__b);}
 
 template <class _CharT, class _Traits>
 inline _LIBCPP_INLINE_VISIBILITY
 bool operator!=(const istreambuf_iterator<_CharT,_Traits>& __a,
                 const istreambuf_iterator<_CharT,_Traits>& __b)
                 {return !__a.equal(__b);}
 
+_LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <class _CharT, class _Traits>
 class _LIBCPP_TEMPLATE_VIS ostreambuf_iterator
+#if _LIBCPP_STD_VER <= 14 || !defined(_LIBCPP_ABI_NO_ITERATOR_BASES)
     : public iterator<output_iterator_tag, void, void, void, void>
+#endif
 {
+_LIBCPP_SUPPRESS_DEPRECATED_POP
 public:
     typedef output_iterator_tag                 iterator_category;
     typedef void                                value_type;
 #if _LIBCPP_STD_VER > 17
     typedef std::ptrdiff_t                      difference_type;
 #else
     typedef void                                difference_type;
 #endif

libcxx/include/memory

 template <class T, class U>
 bool operator==(const allocator<T>&, const allocator<U>&) noexcept; // constexpr in C++20
 
 template <class T, class U>
 bool operator!=(const allocator<T>&, const allocator<U>&) noexcept; // constexpr in C++20
 
 template <class OutputIterator, class T>
 class raw_storage_iterator
-    : public iterator<output_iterator_tag,
-                      T,                               // purposefully not C++03
-                      ptrdiff_t,                       // purposefully not C++03
-                      T*,                              // purposefully not C++03
-                      raw_storage_iterator&>           // purposefully not C++03
+    : public iterator<output_iterator_tag, void, void, void, void> // until C++17
 {
 public:
     explicit raw_storage_iterator(OutputIterator x);
     raw_storage_iterator& operator*();
     raw_storage_iterator& operator=(const T& element);
     raw_storage_iterator& operator++();
     raw_storage_iterator  operator++(int);
 };

libcxx/test/libcxx/iterators/iterator.requirements/iterator.concepts/cpp20_iter_concepts.pass.cpp

 // random_access_iterator_tag.
 // (1.4) -- Otherwise, ITER_CONCEPT(I) does not denote a type.
 
 #include "test_macros.h"
 
 #include <iterator>
 struct OtherTag : std::input_iterator_tag {};
 struct OtherTagTwo : std::output_iterator_tag {};
-struct MyIter : std::iterator<std::random_access_iterator_tag, char> {
+
+struct MyIter {
+  using iterator_category = std::random_access_iterator_tag;
   using iterator_concept = int;
+  using value_type = char;
+  using difference_type = std::ptrdiff_t;
+  using pointer = char*;
+  using reference = char&;
 };
-struct MyIter2 : std::iterator<OtherTag, char> {
 
+struct MyIter2 {
+  using iterator_category = OtherTag;
+  using value_type = char;
+  using difference_type = std::ptrdiff_t;
+  using pointer = char*;
+  using reference = char&;
 };
+
 struct MyIter3 {};
 
 struct Empty {};
 struct EmptyWithSpecial {};
-namespace std {
 template <>
-struct iterator_traits<MyIter3>
-    : std::iterator<OtherTagTwo, char> {};
+struct std::iterator_traits<MyIter3> {
+  using iterator_category = OtherTagTwo;
+  using value_type = char;
+  using difference_type = std::ptrdiff_t;
+  using pointer = char*;
+  using reference = char&;
+};
 
 template <>
-struct iterator_traits<EmptyWithSpecial> {
+struct std::iterator_traits<EmptyWithSpecial> {
   // empty non-default.
 };
-} // namespace std
 
 int main(int, char**) {
   // If the qualified-id ITER_TRAITS(I)::iterator_concept is valid and names a type,
   // then ITER_CONCEPT(I) denotes that type.
   {
 #if TEST_STD_VER > 17
     ASSERT_SAME_TYPE(std::_ITER_CONCEPT<char*>, std::contiguous_iterator_tag);
 #endif
     ASSERT_SAME_TYPE(std::_ITER_CONCEPT<MyIter>, int);

libcxx/test/libcxx/iterators/iterator.requirements/iterator.concepts/cpp20_iter_traits.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03
+
+// ITER_TRAITS(I)
+
+// For a type I, let ITER_TRAITS(I) denote the type I if iterator_traits<I> names
+// a specialization generated from the primary template. Otherwise,
+// ITER_TRAITS(I) denotes iterator_traits<I>.
+
+#include <iterator>
+#include <type_traits>
+
+#include "test_iterators.h"
+
+struct A : random_access_iterator<int*> {};
+struct B : random_access_iterator<int*> {};
+struct C : random_access_iterator<int*> {};
+struct D : random_access_iterator<int*> {};
+template<> struct std::iterator_traits<B> {};
+template<> struct std::iterator_traits<C> : std::iterator_traits<A> {};
+template<> struct std::iterator_traits<D> : std::iterator_traits<int*> {};
+
+static_assert(std::is_same<std::_ITER_TRAITS<int*>, std::iterator_traits<int*>>::value, "");
+static_assert(std::is_same<std::_ITER_TRAITS<A>, A>::value, "");
+static_assert(std::is_same<std::_ITER_TRAITS<B>, std::iterator_traits<B>>::value, "");
+static_assert(std::is_same<std::_ITER_TRAITS<C>, std::iterator_traits<C>>::value, "");
+static_assert(std::is_same<std::_ITER_TRAITS<D>, std::iterator_traits<D>>::value, "");

libcxx/test/libcxx/iterators/iterator.requirements/iterator.concepts/cpp20_iter_traits.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03
-
-// ITER_TRAITS(I)
-
-// For a type I, let ITER_TRAITS(I) denote the type I if iterator_traits<I> names
-// a specialization generated from the primary template. Otherwise,
-// ITER_TRAITS(I) denotes iterator_traits<I>.
-
-#include "test_macros.h"
-
-#include <iterator>
-
-struct MyIter : std::iterator<std::random_access_iterator_tag, char> {};
-struct MyIter2 : std::iterator<std::random_access_iterator_tag, char> {};
-struct MyIter3 : std::iterator<std::random_access_iterator_tag, char> {};
-
-namespace std {
-template <>
-struct iterator_traits<MyIter>
-    : iterator_traits<std::iterator<std::random_access_iterator_tag, char> > {};
-template <>
-struct iterator_traits<MyIter2>
-    : std::iterator<std::random_access_iterator_tag, char> {};
-
-} // namespace std
-
-int main(int, char**) {
-  ASSERT_SAME_TYPE(std::_ITER_TRAITS<char*>, std::iterator_traits<char*>);
-  {
-    using ClassIter = std::reverse_iterator<char*>;
-    ASSERT_SAME_TYPE(std::_ITER_TRAITS<ClassIter>, ClassIter);
-    ASSERT_SAME_TYPE(std::_ITER_TRAITS<MyIter3>, MyIter3);
-  }
-  {
-    ASSERT_SAME_TYPE(std::_ITER_TRAITS<MyIter>, std::iterator_traits<MyIter>);
-    ASSERT_SAME_TYPE(std::_ITER_TRAITS<MyIter2>, std::iterator_traits<MyIter2>);
-  }
-  return 0;
-}

libcxx/test/std/iterators/iterator.primitives/iterator.basic/deprecated.verify.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+// std::iterator
+
+#include <iterator>
+
+std::iterator<std::input_iterator_tag, char> it; // expected-warning-re {{'iterator<{{.+}}>' is deprecated}}

libcxx/test/std/iterators/iterator.primitives/iterator.basic/iterator.pass.cpp

 // {
 //   typedef T         value_type;
 //   typedef Distance  difference_type;
 //   typedef Pointer   pointer;
 //   typedef Reference reference;
 //   typedef Category  iterator_category;
 // };
 
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <iterator>
 #include <type_traits>
 
 #include "test_macros.h"
 
 struct A {};
 
 template <class T>

libcxx/test/std/iterators/predef.iterators/insert.iterators/back.insert.iterator/types.pass.cpp

test()
     find_container<C> q(c);
     q.test();
     static_assert((std::is_same<typename R::container_type, C>::value), "");
     static_assert((std::is_same<typename R::value_type, void>::value), "");
     static_assert((std::is_same<typename R::difference_type, void>::value), "");
     static_assert((std::is_same<typename R::reference, void>::value), "");
     static_assert((std::is_same<typename R::pointer, void>::value), "");
     static_assert((std::is_same<typename R::iterator_category, std::output_iterator_tag>::value), "");
+
+#if TEST_STD_VER <= 14
+    typedef std::iterator<std::output_iterator_tag, void, void, void, void> iterator_base;
+    static_assert((std::is_base_of<iterator_base, R>::value), "");
+#endif
 }
 
 int main(int, char**)
 {
     test<std::vector<int> >();
 
   return 0;
 }

libcxx/test/std/iterators/predef.iterators/insert.iterators/front.insert.iterator/types.pass.cpp

test()
     find_container<C> q(c);
     q.test();
     static_assert((std::is_same<typename R::container_type, C>::value), "");
     static_assert((std::is_same<typename R::value_type, void>::value), "");
     static_assert((std::is_same<typename R::difference_type, void>::value), "");
     static_assert((std::is_same<typename R::reference, void>::value), "");
     static_assert((std::is_same<typename R::pointer, void>::value), "");
     static_assert((std::is_same<typename R::iterator_category, std::output_iterator_tag>::value), "");
+
+#if TEST_STD_VER <= 14
+    typedef std::iterator<std::output_iterator_tag, void, void, void, void> iterator_base;
+    static_assert((std::is_base_of<iterator_base, R>::value), "");
+#endif
 }
 
 int main(int, char**)
 {
     test<std::vector<int> >();
 
   return 0;
 }

libcxx/test/std/iterators/predef.iterators/insert.iterators/insert.iterator/types.pass.cpp

test()
     find_members<C> q(c);
     q.test();
     static_assert((std::is_same<typename R::container_type, C>::value), "");
     static_assert((std::is_same<typename R::value_type, void>::value), "");
     static_assert((std::is_same<typename R::difference_type, void>::value), "");
     static_assert((std::is_same<typename R::reference, void>::value), "");
     static_assert((std::is_same<typename R::pointer, void>::value), "");
     static_assert((std::is_same<typename R::iterator_category, std::output_iterator_tag>::value), "");
+
+#if TEST_STD_VER <= 14
+    typedef std::iterator<std::output_iterator_tag, void, void, void, void> iterator_base;
+    static_assert((std::is_base_of<iterator_base, R>::value), "");
+#endif
 }
 
 int main(int, char**)
 {
     test<std::vector<int> >();
 
   return 0;
 }

libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iterator/types.pass.cpp

test()
     typedef std::reverse_iterator<It> R;
     typedef std::iterator_traits<It> T;
     find_current<It> q; q.test(); // Just test that we can access `.current` from derived classes
     static_assert((std::is_same<typename R::iterator_type, It>::value), "");
     static_assert((std::is_same<typename R::value_type, typename T::value_type>::value), "");
     static_assert((std::is_same<typename R::difference_type, typename T::difference_type>::value), "");
     static_assert((std::is_same<typename R::reference, typename T::reference>::value), "");
     static_assert((std::is_same<typename R::pointer, typename std::iterator_traits<It>::pointer>::value), "");
+
+#if TEST_STD_VER <= 14
+    typedef std::iterator<typename T::iterator_category, typename T::value_type> iterator_base;
+    static_assert((std::is_base_of<iterator_base, R>::value), "");
+#endif
 #if TEST_STD_VER > 17
     if constexpr (std::is_same_v<typename T::iterator_category, std::contiguous_iterator_tag>) {
         static_assert((std::is_same<typename R::iterator_category, std::random_access_iterator_tag>::value), "");
     } else {
         static_assert((std::is_same<typename R::iterator_category, typename T::iterator_category>::value), "");
     }
 #else
     static_assert((std::is_same<typename R::iterator_category, typename T::iterator_category>::value), "");

libcxx/test/std/iterators/stream.iterators/istream.iterator/types.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <iterator>
 
 // template <class T, class charT = char, class traits = char_traits<charT>,
 //           class Distance = ptrdiff_t>
-// class istream_iterator
-//     : public iterator<input_iterator_tag, T, Distance, const T*, const T&>
-// {
+// class istream_iterator {
 // public:
 //     typedef charT char_type;
 //     typedef traits traits_type;
 //     typedef basic_istream<charT,traits> istream_type;
 //     ...
 //
 // Before C++17, we have:
 //   If T is a literal type, then the default constructor shall be a constexpr constructor.
 //   If T is a literal type, then this constructor shall be a trivial copy constructor.
 //   If T is a literal type, then this destructor shall be a trivial destructor.
 // C++17 says:
 //   If is_trivially_default_constructible_v<T> is true, then
 //       this constructor (the default ctor) is a constexpr constructor.
 //   If is_trivially_copy_constructible_v<T> is true, then
 //       this constructor (the copy ctor) is a trivial copy constructor.
 //   If is_trivially_destructible_v<T> is true, then this
 //       destructor is a trivial destructor.
 //  Testing the C++17 ctors for this are in the ctor tests.
 
 #include <iterator>
 #include <type_traits>
 #include <string>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
+    {
     typedef std::istream_iterator<double> I1; // double is trivially destructible
 #if TEST_STD_VER <= 14
-    static_assert((std::is_convertible<I1,
-        std::iterator<std::input_iterator_tag, double, std::ptrdiff_t,
-        const double*, const double&> >::value), "");
-#else
+    typedef std::iterator<std::input_iterator_tag, double, std::ptrdiff_t, double const*, double const&> iterator_base;
+    static_assert((std::is_base_of<iterator_base, I1>::value), "");
+#endif
     static_assert((std::is_same<I1::iterator_category, std::input_iterator_tag>::value), "");
     static_assert((std::is_same<I1::value_type, double>::value), "");
     static_assert((std::is_same<I1::difference_type, std::ptrdiff_t>::value), "");
     static_assert((std::is_same<I1::pointer, const double*>::value), "");
     static_assert((std::is_same<I1::reference, const double&>::value), "");
-#endif
     static_assert((std::is_same<I1::char_type, char>::value), "");
     static_assert((std::is_same<I1::traits_type, std::char_traits<char> >::value), "");
     static_assert((std::is_same<I1::istream_type, std::istream>::value), "");
     static_assert( std::is_trivially_copy_constructible<I1>::value, "");
     static_assert( std::is_trivially_destructible<I1>::value, "");
+    }
 
+    {
     typedef std::istream_iterator<unsigned, wchar_t> I2; // unsigned is trivially destructible
 #if TEST_STD_VER <= 14
-    static_assert((std::is_convertible<I2,
-        std::iterator<std::input_iterator_tag, unsigned, std::ptrdiff_t,
-        const unsigned*, const unsigned&> >::value), "");
-#else
+    typedef std::iterator<std::input_iterator_tag, unsigned, std::ptrdiff_t, const unsigned*, const unsigned&> iterator_base;
+    static_assert((std::is_base_of<iterator_base, I2>::value), "");
+#endif
     static_assert((std::is_same<I2::iterator_category, std::input_iterator_tag>::value), "");
     static_assert((std::is_same<I2::value_type, unsigned>::value), "");
     static_assert((std::is_same<I2::difference_type, std::ptrdiff_t>::value), "");
     static_assert((std::is_same<I2::pointer, const unsigned*>::value), "");
     static_assert((std::is_same<I2::reference, const unsigned&>::value), "");
-#endif
     static_assert((std::is_same<I2::char_type, wchar_t>::value), "");
     static_assert((std::is_same<I2::traits_type, std::char_traits<wchar_t> >::value), "");
     static_assert((std::is_same<I2::istream_type, std::wistream>::value), "");
     static_assert( std::is_trivially_copy_constructible<I2>::value, "");
     static_assert( std::is_trivially_destructible<I2>::value, "");
+    }
 
     typedef std::istream_iterator<std::string> I3; // string is NOT trivially destructible
     static_assert(!std::is_trivially_copy_constructible<I3>::value, "");
     static_assert(!std::is_trivially_destructible<I3>::value, "");
 
   return 0;
 }

libcxx/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_proxy/proxy.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <iterator>
 
 // template<class charT, class traits = char_traits<charT> >
-// class istreambuf_iterator
-//     : public iterator<input_iterator_tag, charT,
-//                       typename traits::off_type, charT*,
-//                       charT>
-// {
+// class istreambuf_iterator {
 // public:
 //     ...
 //     proxy operator++(int);
 
 // class proxy
 // {
 // public:
 //     charT operator*();

libcxx/test/std/iterators/stream.iterators/istreambuf.iterator/types.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <iterator>
 
 // template<class charT, class traits = char_traits<charT> >
-// class istreambuf_iterator
-//     : public iterator<input_iterator_tag, charT,
-//                       typename traits::off_type, unspecified,
-//                       charT>
-// {
+// class istreambuf_iterator {
 // public:
 //     typedef charT                         char_type;
 //     typedef traits                        traits_type;
 //     typedef typename traits::int_type     int_type;
 //     typedef basic_streambuf<charT,traits> streambuf_type;
 //     typedef basic_istream<charT,traits>   istream_type;
 //     ...
 //
 // All specializations of istreambuf_iterator shall have a trivial copy constructor,
 //    a constexpr default constructor and a trivial destructor.
 
 #include <iterator>
 #include <string>
 #include <type_traits>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
+    {
     typedef std::istreambuf_iterator<char> I1;
+#if TEST_STD_VER <= 14
+    typedef std::iterator<std::input_iterator_tag, char, std::char_traits<char>::off_type, char*, char> iterator_base;
+    static_assert((std::is_base_of<iterator_base, I1>::value), "");
+#endif
     static_assert((std::is_same<I1::iterator_category, std::input_iterator_tag>::value), "");
     static_assert((std::is_same<I1::value_type, char>::value), "");
     static_assert((std::is_same<I1::difference_type, std::char_traits<char>::off_type>::value), "");
     LIBCPP_STATIC_ASSERT((std::is_same<I1::pointer, char*>::value), "");
     static_assert((std::is_same<I1::reference, char>::value), "");
     static_assert((std::is_same<I1::char_type, char>::value), "");
     static_assert((std::is_same<I1::traits_type, std::char_traits<char> >::value), "");
     static_assert((std::is_same<I1::int_type, I1::traits_type::int_type>::value), "");
     static_assert((std::is_same<I1::streambuf_type, std::streambuf>::value), "");
     static_assert((std::is_same<I1::istream_type, std::istream>::value), "");
     static_assert((std::is_nothrow_default_constructible<I1>::value), "" );
     static_assert((std::is_trivially_copy_constructible<I1>::value), "" );
     static_assert((std::is_trivially_destructible<I1>::value), "" );
+    }
 
+    {
     typedef std::istreambuf_iterator<wchar_t> I2;
+#if TEST_STD_VER <= 14
+    typedef std::iterator<std::input_iterator_tag, wchar_t, std::char_traits<wchar_t>::off_type, wchar_t*, wchar_t> iterator_base;
+    static_assert((std::is_base_of<iterator_base, I2>::value), "");
+#endif
     static_assert((std::is_same<I2::iterator_category, std::input_iterator_tag>::value), "");
     static_assert((std::is_same<I2::value_type, wchar_t>::value), "");
     static_assert((std::is_same<I2::difference_type, std::char_traits<wchar_t>::off_type>::value), "");
     LIBCPP_STATIC_ASSERT((std::is_same<I2::pointer, wchar_t*>::value), "");
     static_assert((std::is_same<I2::reference, wchar_t>::value), "");
     static_assert((std::is_same<I2::char_type, wchar_t>::value), "");
     static_assert((std::is_same<I2::traits_type, std::char_traits<wchar_t> >::value), "");
     static_assert((std::is_same<I2::int_type, I2::traits_type::int_type>::value), "");
     static_assert((std::is_same<I2::streambuf_type, std::wstreambuf>::value), "");
     static_assert((std::is_same<I2::istream_type, std::wistream>::value), "");
     static_assert((std::is_nothrow_default_constructible<I2>::value), "" );
     static_assert((std::is_trivially_copy_constructible<I2>::value), "" );
     static_assert((std::is_trivially_destructible<I2>::value), "" );
+    }
 
   return 0;
 }

libcxx/test/std/iterators/stream.iterators/ostream.iterator/types.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <iterator>
 
 // template <class T, class charT = char, class traits = char_traits<charT>,
 //           class Distance = ptrdiff_t>
-// class ostream_iterator
-//     : public iterator<output_iterator_tag, void, void, void, void>
-// {
+// class ostream_iterator {
 // public:
 //     typedef charT char_type;
 //     typedef traits traits_type;
 //     typedef basic_istream<charT,traits> istream_type;
 //     ...
 
 #include <cstddef>
 #include <iterator>
 #include <type_traits>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
+    {
     typedef std::ostream_iterator<double> I1;
 #if TEST_STD_VER <= 14
-    static_assert((std::is_convertible<I1,
-        std::iterator<std::output_iterator_tag, void, void, void, void> >::value), "");
-#else
+    typedef std::iterator<std::output_iterator_tag, void, void, void, void> iterator_base;
+    static_assert((std::is_base_of<iterator_base, I1>::value), "");
+#endif
     static_assert((std::is_same<I1::iterator_category, std::output_iterator_tag>::value), "");
     static_assert((std::is_same<I1::value_type, void>::value), "");
 #if TEST_STD_VER <= 17
     static_assert((std::is_same<I1::difference_type, void>::value), "");
 #else
     static_assert((std::is_same<I1::difference_type, std::ptrdiff_t>::value), "");
 #endif
     static_assert((std::is_same<I1::pointer, void>::value), "");
     static_assert((std::is_same<I1::reference, void>::value), "");
-#endif
     static_assert((std::is_same<I1::char_type, char>::value), "");
     static_assert((std::is_same<I1::traits_type, std::char_traits<char> >::value), "");
     static_assert((std::is_same<I1::ostream_type, std::ostream>::value), "");
+    }
+
+    {
     typedef std::ostream_iterator<unsigned, wchar_t> I2;
 #if TEST_STD_VER <= 14
-    static_assert((std::is_convertible<I2,
-        std::iterator<std::output_iterator_tag, void, void, void, void> >::value), "");
-#else
+    typedef std::iterator<std::output_iterator_tag, void, void, void, void> iterator_base;
+    static_assert((std::is_base_of<iterator_base, I2>::value), "");
+#endif
     static_assert((std::is_same<I2::iterator_category, std::output_iterator_tag>::value), "");
     static_assert((std::is_same<I2::value_type, void>::value), "");
 #if TEST_STD_VER <= 17
     static_assert((std::is_same<I2::difference_type, void>::value), "");
 #else
     static_assert((std::is_same<I2::difference_type, std::ptrdiff_t>::value), "");
 #endif
     static_assert((std::is_same<I2::pointer, void>::value), "");
     static_assert((std::is_same<I2::reference, void>::value), "");
-#endif
     static_assert((std::is_same<I2::char_type, wchar_t>::value), "");
     static_assert((std::is_same<I2::traits_type, std::char_traits<wchar_t> >::value), "");
     static_assert((std::is_same<I2::ostream_type, std::wostream>::value), "");
+    }
 
   return 0;
 }

libcxx/test/std/iterators/stream.iterators/ostreambuf.iterator/types.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <iterator>
 
 // template <class charT, class traits = char_traits<charT> >
-// class ostreambuf_iterator
-//   : public iterator<output_iterator_tag, void, void, void, void>
-// {
+// class ostreambuf_iterator {
 // public:
 //   typedef charT                          char_type;
 //   typedef traits                         traits_type;
 //   typedef basic_streambuf<charT, traits> streambuf_type;
 //   typedef basic_ostream<charT, traits>   ostream_type;
 //   ...
 
 #include <cstddef>
 #include <iterator>
 #include <string>
 #include <type_traits>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
+    {
     typedef std::ostreambuf_iterator<char> I1;
 #if TEST_STD_VER <= 14
-    static_assert((std::is_convertible<I1,
-        std::iterator<std::output_iterator_tag, void, void, void, void> >::value), "");
-#else
+    typedef std::iterator<std::output_iterator_tag, void, void, void, void> iterator_base;
+    static_assert((std::is_base_of<iterator_base, I1>::value), "");
+#endif
     static_assert((std::is_same<I1::iterator_category, std::output_iterator_tag>::value), "");
     static_assert((std::is_same<I1::value_type, void>::value), "");
 #if TEST_STD_VER <= 17
     static_assert((std::is_same<I1::difference_type, void>::value), "");
 #else
     static_assert((std::is_same<I1::difference_type, std::ptrdiff_t>::value), "");
 #endif
     static_assert((std::is_same<I1::pointer, void>::value), "");
     static_assert((std::is_same<I1::reference, void>::value), "");
-#endif
     static_assert((std::is_same<I1::char_type, char>::value), "");
     static_assert((std::is_same<I1::traits_type, std::char_traits<char> >::value), "");
     static_assert((std::is_same<I1::streambuf_type, std::streambuf>::value), "");
     static_assert((std::is_same<I1::ostream_type, std::ostream>::value), "");
+    }
 
+    {
     typedef std::ostreambuf_iterator<wchar_t> I2;
 #if TEST_STD_VER <= 14
-    static_assert((std::is_convertible<I2,
-        std::iterator<std::output_iterator_tag, void, void, void, void> >::value), "");
-#else
+    typedef std::iterator<std::output_iterator_tag, void, void, void, void> iterator_base;
+    static_assert((std::is_base_of<iterator_base, I2>::value), "");
+#endif
     static_assert((std::is_same<I2::iterator_category, std::output_iterator_tag>::value), "");
     static_assert((std::is_same<I2::value_type, void>::value), "");
 #if TEST_STD_VER <= 17
     static_assert((std::is_same<I2::difference_type, void>::value), "");
 #else
     static_assert((std::is_same<I2::difference_type, std::ptrdiff_t>::value), "");
 #endif
     static_assert((std::is_same<I2::pointer, void>::value), "");
     static_assert((std::is_same<I2::reference, void>::value), "");
-#endif
     static_assert((std::is_same<I2::char_type, wchar_t>::value), "");
     static_assert((std::is_same<I2::traits_type, std::char_traits<wchar_t> >::value), "");
     static_assert((std::is_same<I2::streambuf_type, std::wstreambuf>::value), "");
     static_assert((std::is_same<I2::ostream_type, std::wostream>::value), "");
+    }
 
   return 0;
 }

libcxx/test/std/utilities/memory/storage.iterator/types.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_CXX20_REMOVED_RAW_STORAGE_ITERATOR
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
+// raw_storage_iterator associated types
+
+#include <memory>
+#include <type_traits>
+
+struct T;
+typedef T* OutputIt;
+typedef std::raw_storage_iterator<OutputIt, T> It;
+
+static_assert(std::is_same<It::iterator_category, std::output_iterator_tag>::value, "");
+static_assert(std::is_same<It::value_type, void>::value, "");
+static_assert(std::is_same<It::difference_type, void>::value, "");
+static_assert(std::is_same<It::pointer, void>::value, "");
+static_assert(std::is_same<It::reference, void>::value, "");