[libcxx] deprecates `std::iterator` and removes it as a base class

[cjdb]

Summary

C++17 deprecated std::iterator and removed it as a base class for all
iterator adaptors.

Affected subclauses:

• [depr.iterator] (previously [iterator.iterator])
• [reverse.iterator]
• [back.insert.iterator]
• [front.insert.iterator]
• [insert.iterator]
• [istream.iterator]
• [ostream.iterator]
• [istreambuf.iterator]
• [ostreambuf.iterator]
• [depr.storage.iterator]

Implements part of P0174R2 'Deprecating Vestigial Library Parts in C++17'.

[• Quuxplusone]

Looks pretty good to me, mod comments.

libcxx/include/__memory/raw_storage_iterator.h

30–36

Interestingly, libc++ has never been conforming here.
https://timsong-cpp.github.io/cppwp/n3337/storage.iterator
requires inheriting from iterator<output_iterator_tag, void, void, void, void>.
But since this is removed in '20, do we even care about it? I guess not; so this #if seems like the minimal change, and therefore OK by me.

41–47

Here, we could drop the #if and just unconditionally define these members... except that that would visibly change the value of raw_storage_iterator::difference_type (from non-conforming to conforming), and maybe we don't want that? But again I'd think we don't really care about this type and so we might as well lose the #if.

50–54

I vote for not reformatting here. Keeps the diff smaller.

libcxx/include/iterator

85

Stray ) here. But please remove this diff anyway; [[deprecated]] doesn't appear in the Standard and even if it did I don't think it needs to appear in the synopsis comments.

629–631

Lose the #if here.
(Any idea why the old code bothered to redundantly redefine difference_type etc.?)

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

45–53

Keep this one inheriting from iterator_traits's primary template and the next one inheriting from iterator's primary template; otherwise you lose the point of the test.
I recommend

struct MyIter {
  using iterator_category = std::random_access_iterator_tag;
  using value_type = char;
  using difference_type = std::ptrdiff_t;
  using pointer = char*;
  using reference = char&;
};
struct MyIter2 : MyIter {};
struct MyIter3 : MyIter {};
template<> struct std::iterator_traits<MyIter> : std::iterator_traits<char*> {};
#if TEST_STD_VER <= 17
template<> struct std::iterator_traits<MyIter2> : std::iterator<char*> {};
#endif

However, if you just wanted to rip out MyIter2 for being excessively silly, that might be a better solution.

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

56

This isn't right when T::iterator_category is contiguous_iterator_tag, although maybe the test doesn't care.
This also isn't right when T::difference_type isn't ptrdiff_t, etc.; but I'm sure the test doesn't care.

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

49

Might as well lose the double-parens while you're here. (Presumably a holdover from when static_assert was a macro.)

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

29–30

Throughout: It looks like buildkite isn't happy with some of these pragmas; and I don't really like them either... Aha!
git grep deprecated libcxx/include/
git grep const_fun_mem_t libcxx/test/
reveals that the correct incantation is

#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS

at the top of the test. Please make that change throughout.

[cjdb]

Haven't had time to respond to changes (and this is lowish in my p-queue).

libcxx/include/iterator

85

Let's take this one to Discord, I have some thoughts on this.

629–631

According to https://timsong-cpp.github.io/cppwp/n4140/reverse.iterator, it's standard to do this :S
I'm more curious to know why value_type is missing than why the others were redundantly added.

Does this change your opinion at all?

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

56

This isn't right when T::iterator_category is contiguous_iterator_tag, although maybe the test doesn't care.
This also isn't right when T::difference_type isn't ptrdiff_t, etc.; but I'm sure the test doesn't care.

I'm inclined to say the test doesn't care today, but it will should care when we get around to applying P0896. I've got no qualms punting this to future me, but since I wager an even chance that @zoecarver will beat me to it, I'd like his input before making that decision.

[• Quuxplusone]

libcxx/include/iterator

629–631

Nope, I'd still just drop the #if.

[tcanens]

libcxx/include/iterator

629–631

It redeclares things that it needs to use in the rest of the class, because name lookup doesn't look into dependent bases.

[ldionne]

Generally looks good, thanks for doing this cleanup. I agree we should unconditionally define the various typedefs everywhere to remove some #ifs.

libcxx/include/__memory/raw_storage_iterator.h

41–47

I think it's an acceptable change - I doubt it will break many users since raw_storage_iterator isn't widely used, and it's a compile-time breakage in all cases, so not some nasty runtime issue.

libcxx/include/iterator

85

Please use // deprecated in C++17 instead -- that is what we do elsewhere.

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

11–12

Why do we need this? Aren't we removing the use of those deprecated decls?

[EricWF]

Removing the std::iterator inheritance is potentially ABI breaking. In particular in the case of reverse_iterator.
If the iterator provided to reverse_iterator also inherits from std::iterator, then the first member of reverse_iterator goes from having an offset of 4 to an offset of 0 bytes
(because the compiler couldn't place the same empty base at the same address).

I'm not sure how much we care, but I see this being a case that could easily arise in real world code.
@ldionne thoughts?

[ldionne]

In D101729#2739518, @EricWF wrote:

Removing the std::iterator inheritance is potentially ABI breaking. In particular in the case of reverse_iterator.
If the iterator provided to reverse_iterator also inherits from std::iterator, then the first member of reverse_iterator goes from having an offset of 4 to an offset of 0 bytes
(because the compiler couldn't place the same empty base at the same address).

I'm not sure how much we care, but I see this being a case that could easily arise in real world code.
@ldionne thoughts?

Interesting catch Eric, thanks for chiming in. It looks like raw_storage_iterator has the same issue since the first member is a user-provided iterator, but I don't think we care for this one since it's deprecated in C++17 and removed in C++20 anyway (so there's likely no important ABI reliance on this type).

Thinking out loud: Before C++17, this is not an issue because std::iterator is there and we inherit from it. In C++17 and above, std::iterator is marked as [[deprecated]], so if a user inherits from it, they are getting the deprecation warning and also the potential ABI break in reverse_iterator. I see the following solutions:

1. Don't care about it - it has a small chance to happen, and std::iterator is deprecated. If we do this, we should push to actually remove std::iterator ASAP, since we wouldn't have this problem if std::iterator were removed entirely.

2. In >= C++17, add static_assert(!std::is_base_of<std::iterator, _Iter>::value, "Would be an ABI break"); inside reverse_iterator. That way, if anyone's using std::reverse_iterator with a type that would be potentially impacted by an ABI break, they'd be told at compile-time.

3. Use:

class __one_byte { char __byte; };
class __empty { };

template <class _Iter>
class _LIBCPP_TEMPLATE_VIS reverse_iterator
#if _LIBCPP_STD_VER <= 14
    : 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>
#else
    // We must keep the __t member below at the same offset in all Standards, which requires
    // some work if _Iter inherits from std::iterator.
    : private conditional_t<is_base_of_v<iterator<XXXX>, _Iter> && !is_final_v<_Iter>, __one_byte, __empty>
#endif
{
private:
    /*mutable*/ _Iter __t;  // no longer used as of LWG #2360, not removed due to ABI break

    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;

    // ...
};

(1) seems a bit reckless to me. (2) seems too constraining to me - I'm sure a lot of older code in the wild is still using std::iterator in ways that are not ABI sensitive, and it would be silly to break their code for that.

I think I'd go with (3) if we all agree it solves the ABI issue, since it's not such a big deal for us to do. In the future, I'd consider breaking the ABI of reverse_iterator and removing both this workaround and the __t workaround at once.

[• Quuxplusone]

@ldionne: I recommend my blog post https://quuxplusone.github.io/blog/2021/05/07/std-iterator-as-a-base-class/
and the full discussion in D102657. I'll even volunteer to make the "remove all base classes for iterators and function-objects, and drive-by fix the reverse_iterator explosion, under an ABI flag" solution PR; it'll just take a week or two before I'm guaranteed to have time for it.

[• Quuxplusone]

Also, concretely, @ldionne I believe your (3) still does not solve the ABI break for reverse_iterator<reverse_iterator<int*>>.
Also also, if we really cared about ABI breaks, we would put a test on them. Do you have any interest in adding some simple platform-specific tests (REQUIRES a certain platform) for things like static_assert(sizeof(std::reverse_iterator<...>) == ...)? Then ABI breakage would correspond to buildkite breakage, and people wouldn't be so likely to do it by accident.

[cjdb]

In D101729#2774913, @Quuxplusone wrote:

@ldionne: I recommend my blog post https://quuxplusone.github.io/blog/2021/05/07/std-iterator-as-a-base-class/
and the full discussion in D102657. I'll even volunteer to make the "remove all base classes for iterators and function-objects, and drive-by fix the reverse_iterator explosion, under an ABI flag" solution PR; it'll just take a week or two before I'm guaranteed to have time for it.

That's what this patch does?

[• Quuxplusone]

In D101729#2776070, @cjdb wrote:

In D101729#2774913, @Quuxplusone wrote:

@ldionne: I recommend my blog post https://quuxplusone.github.io/blog/2021/05/07/std-iterator-as-a-base-class/
and the full discussion in D102657. I'll even volunteer to make the "remove all base classes for iterators and function-objects, and drive-by fix the reverse_iterator explosion, under an ABI flag" solution PR; it'll just take a week or two before I'm guaranteed to have time for it.

That's what this patch does?

This PR (D101729) currently doesn't do any of the three things I mentioned (remove base classes for iterators and function-objects, fix the reverse_iterator explosion, add an ABI flag). But I'd be happy to commandeer it; is that OK by you?

[cjdb]

In D101729#2776136, @Quuxplusone wrote:

In D101729#2776070, @cjdb wrote:

In D101729#2774913, @Quuxplusone wrote:

@ldionne: I recommend my blog post https://quuxplusone.github.io/blog/2021/05/07/std-iterator-as-a-base-class/
and the full discussion in D102657. I'll even volunteer to make the "remove all base classes for iterators and function-objects, and drive-by fix the reverse_iterator explosion, under an ABI flag" solution PR; it'll just take a week or two before I'm guaranteed to have time for it.

That's what this patch does?

This PR (D101729) currently doesn't do any of the three things I mentioned (remove base classes for iterators

This patch definitely removes std::iterator as a base class for all iterator adaptors. Is there some other base class I'm not seeing?

and function-objects,

Function objects are out of scope.

fix the reverse_iterator explosion,

I don't know what "explosion" you're referring to.

add an ABI flag). But I'd be happy to commandeer it; is that OK by you?

Your timeline is far out enough that it stalls other work. @Mordante is blocked by this patch.
It's also a simple enough thing to resolve (once we've agreed on a direction) that handing it over seems pointless.

In D101729#2774481, @ldionne wrote:

In D101729#2739518, @EricWF wrote:

Removing the std::iterator inheritance is potentially ABI breaking. In particular in the case of reverse_iterator.
If the iterator provided to reverse_iterator also inherits from std::iterator, then the first member of reverse_iterator goes from having an offset of 4 to an offset of 0 bytes
(because the compiler couldn't place the same empty base at the same address).

I'm not sure how much we care, but I see this being a case that could easily arise in real world code.
@ldionne thoughts?

Interesting catch Eric, thanks for chiming in. It looks like raw_storage_iterator has the same issue since the first member is a user-provided iterator, but I don't think we care for this one since it's deprecated in C++17 and removed in C++20 anyway (so there's likely no important ABI reliance on this type).

Thinking out loud: Before C++17, this is not an issue because std::iterator is there and we inherit from it. In C++17 and above, std::iterator is marked as [[deprecated]], so if a user inherits from it, they are getting the deprecation warning and also the potential ABI break in reverse_iterator. I see the following solutions:

1. Don't care about it - it has a small chance to happen, and std::iterator is deprecated. If we do this, we should push to actually remove std::iterator ASAP, since we wouldn't have this problem if std::iterator were removed entirely.

2. In >= C++17, add static_assert(!std::is_base_of<std::iterator, _Iter>::value, "Would be an ABI break"); inside reverse_iterator. That way, if anyone's using std::reverse_iterator with a type that would be potentially impacted by an ABI break, they'd be told at compile-time.

3. Use:

class __one_byte { char __byte; };
class __empty { };

template <class _Iter>
class _LIBCPP_TEMPLATE_VIS reverse_iterator
#if _LIBCPP_STD_VER <= 14
    : 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>
#else
    // We must keep the __t member below at the same offset in all Standards, which requires
    // some work if _Iter inherits from std::iterator.
    : private conditional_t<is_base_of_v<iterator<XXXX>, _Iter> && !is_final_v<_Iter>, __one_byte, __empty>
#endif
{
private:
    /*mutable*/ _Iter __t;  // no longer used as of LWG #2360, not removed due to ABI break

    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;

    // ...
};

(1) seems a bit reckless to me. (2) seems too constraining to me - I'm sure a lot of older code in the wild is still using std::iterator in ways that are not ABI sensitive, and it would be silly to break their code for that.

I think I'd go with (3) if we all agree it solves the ABI issue, since it's not such a big deal for us to do. In the future, I'd consider breaking the ABI of reverse_iterator and removing both this workaround and the __t workaround at once.

I'll grumblingly go along with (3), but if we're going to consider breaking iterator adaptor ABI at "some point" in the future, why not just rip the band-aid off here and now? It'll immediately simplify the implementation, and I can't see how it would be any less reckless to make this decision in a year's time as opposed to today.

[Mordante]

In D101729#2776309, @cjdb wrote:

In D101729#2776136, @Quuxplusone wrote:

Your timeline is far out enough that it stalls other work. @Mordante is blocked by this patch.
It's also a simple enough thing to resolve (once we've agreed on a direction) that handing it over seems pointless.

I'm not really blocked by this patch, I now have an ugly work-around in my format branch. So I could put that up for review and clean up later. And actually I'm not blocked by the base class but the fact the back_insert_iterator isn't default constructible and its difference_type is void.

(1) seems a bit reckless to me. (2) seems too constraining to me - I'm sure a lot of older code in the wild is still using std::iterator in ways that are not ABI sensitive, and it would be silly to break their code for that.

I think I'd go with (3) if we all agree it solves the ABI issue, since it's not such a big deal for us to do. In the future, I'd consider breaking the ABI of reverse_iterator and removing both this workaround and the __t workaround at once.

I'll grumblingly go along with (3), but if we're going to consider breaking iterator adaptor ABI at "some point" in the future, why not just rip the band-aid off here and now? It'll immediately simplify the implementation, and I can't see how it would be any less reckless to make this decision in a year's time as opposed to today.

I think it would be nice to consider making ABI v2 the default and move Unstable to v3. But I think this requires some planning and communicating to involved parties upfront. Maybe that becomes moot if https://wg21.link/p2123 "Extending the Type System to Provide API and ABI Flexibility" gets accepted before C++23.

libcxx/include/__memory/raw_storage_iterator.h

 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _OutputIterator, class _Tp>
 class _LIBCPP_TEMPLATE_VIS raw_storage_iterator
+#if _LIBCPP_STD_VER <= 14
     : 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
+#endif
 {
 private:
     _OutputIterator __x_;
 public:
-    _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
+  using iterator_category = output_iterator_tag;
+  using value_type = void;
+  using difference_type = void;
+  using pointer = void;
+  using reference = void;
+#endif
+
+  _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
     _LIBCPP_INLINE_VISIBILITY raw_storage_iterator& operator++() {++__x_; return *this;}
     _LIBCPP_INLINE_VISIBILITY raw_storage_iterator  operator++(int)
         {raw_storage_iterator __t(*this); ++__x_; return __t;}
 #if _LIBCPP_STD_VER >= 14

libcxx/include/iterator

template<class S, class I>
   concept sized_sentinel_for = see below;
 
 // [iterator.concept.input], concept input_iterator
 template<class I>
   concept input_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                                            // until C++17
+struct [[deprecated)]] iterator                            // since C++17
 {
     typedef T         value_type;
     typedef Distance  difference_type;
     typedef Pointer   pointer;
     typedef Reference reference;
     typedef Category  iterator_category;
 };
 

 #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;
 };
 

 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 {};
 
 template <class _Iter>
 class _LIBCPP_TEMPLATE_VIS reverse_iterator
+#if _LIBCPP_STD_VER <= 14
     : 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
 {
 private:
     /*mutable*/ _Iter __t;  // no longer used as of LWG #2360, not removed due to ABI break
 
     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;
+#if _LIBCPP_STD_VER > 14
+    typedef typename iterator_traits<_Iter>::value_type      value_type;
+#endif
+    typedef typename iterator_traits<_Iter>::difference_type difference_type;
+    typedef typename iterator_traits<_Iter>::pointer         pointer;
+    typedef typename iterator_traits<_Iter>::reference       reference;
 #if _LIBCPP_STD_VER > 17
     typedef _If<__is_cpp17_random_access_iterator<_Iter>::value,
         random_access_iterator_tag,
         bidirectional_iterator_tag>                          iterator_concept;
 #endif
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
     reverse_iterator() : __t(), current() {}

 reverse_iterator<_Iter> make_reverse_iterator(_Iter __i)
 {
     return reverse_iterator<_Iter>(__i);
 }
 #endif
 
 template <class _Container>
 class _LIBCPP_TEMPLATE_VIS back_insert_iterator
+#if _LIBCPP_STD_VER <= 14
     : public iterator<output_iterator_tag,
                       void,
                       void,
                       void,
                       void>
+#endif
 {
 protected:
     _Container* container;
 public:
+#if _LIBCPP_STD_VER > 14
+    typedef output_iterator_tag iterator_category;
+    typedef void value_type;
+    typedef void difference_type;
+    typedef void pointer;
+    typedef void reference;
+#endif
     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);
 }
 
 template <class _Container>
 class _LIBCPP_TEMPLATE_VIS front_insert_iterator
+#if _LIBCPP_STD_VER <= 14
     : public iterator<output_iterator_tag,
                       void,
                       void,
                       void,
                       void>
+#endif
 {
 protected:
     _Container* container;
 public:
+#if _LIBCPP_STD_VER > 14
+    typedef output_iterator_tag iterator_category;
+    typedef void value_type;
+    typedef void difference_type;
+    typedef void pointer;
+    typedef void reference;
+#endif
     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);
 }
 
 template <class _Container>
 class _LIBCPP_TEMPLATE_VIS insert_iterator
+#if _LIBCPP_STD_VER <= 14
     : public iterator<output_iterator_tag,
                       void,
                       void,
                       void,
                       void>
+#endif
 {
 protected:
     _Container* container;
     typename _Container::iterator iter;
 public:
+#if _LIBCPP_STD_VER > 14
+    typedef output_iterator_tag iterator_category;
+    typedef void value_type;
+    typedef void difference_type;
+    typedef void pointer;
+    typedef void reference;
+#endif
     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_)

 inserter(_Container& __x, typename _Container::iterator __i)
 {
     return insert_iterator<_Container>(__x, __i);
 }
 
 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
     : public iterator<input_iterator_tag, _Tp, _Distance, const _Tp*, const _Tp&>
+#endif
 {
 public:
+#if _LIBCPP_STD_VER > 14
+    typedef input_iterator_tag iterator_category;
+    typedef _Tp value_type;
+    typedef _Distance difference_type;
+    typedef const _Tp* pointer;
+    typedef const _Tp& reference;
+#endif
     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_() {}

 operator!=(const istream_iterator<_Tp, _CharT, _Traits, _Distance>& __x,
            const istream_iterator<_Tp, _CharT, _Traits, _Distance>& __y)
 {
     return !(__x == __y);
 }
 
 template <class _Tp, class _CharT = char, class _Traits = char_traits<_CharT> >
 class _LIBCPP_TEMPLATE_VIS ostream_iterator
+#if _LIBCPP_STD_VER <= 14
     : public iterator<output_iterator_tag, void, void, void, void>
+#endif
 {
 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;
public:
 
     _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;}
 };
 
 template<class _CharT, class _Traits>
 class _LIBCPP_TEMPLATE_VIS istreambuf_iterator
+#if _LIBCPP_STD_VER <= 14
     : public iterator<input_iterator_tag, _CharT,
                       typename _Traits::off_type, _CharT*,
                       _CharT>
+#endif
 {
 public:
+#if _LIBCPP_STD_VER > 14
+    typedef input_iterator_tag              iterator_category;
+    typedef _CharT                          value_type;
+    typedef typename _Traits::off_type      difference_type;
+    typedef _CharT*                         pointer;
+    typedef _CharT                          reference;
+#endif
     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_;
 

 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);}
 
 template <class _CharT, class _Traits>
 class _LIBCPP_TEMPLATE_VIS ostreambuf_iterator
+#if _LIBCPP_STD_VER <= 14
     : public iterator<output_iterator_tag, void, void, void, void>
+#endif
 {
 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;

libcxx/test/libcxx/iterators/iterator.requirements/iterator.concepts/cpp20_iter_concepts.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
 
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
 // ITER_TRAITS(I)
 
 // -- If the qualified-id ITER_TRAITS(I)::iterator_concept is valid and names a
 //   type, then ITER_CONCEPT(I) denotes that type.
 // (1.2) -- Otherwise, if the qualified-id ITER_TRAITS(I)::iterator_category is
 // valid and names a type, then ITER_CONCEPT(I) denotes that type.
 // (1.3) -- Otherwise, if iterator_traits<I> names a specialization generated
 // from the primary template, then ITER_CONCEPT(I) denotes
 // 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 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> {
   // empty non-default.
 };
 } // namespace std
 
 int main(int, char**) {

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

 // 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> {};
+struct MyIter {
+  using iterator_category = std::random_access_iterator_tag;
+  using value_type = char;
+  using difference_type = std::ptrdiff_t;
+  using pointer = char*;
+  using reference = char&;
+};
+
+struct MyIter2 {
+  using iterator_category = std::random_access_iterator_tag;
+  using value_type = char;
+  using difference_type = std::ptrdiff_t;
+  using pointer = char*;
+  using reference = char&;
+};
+
+struct MyIter3 {
+  using iterator_category = std::random_access_iterator_tag;
+  using value_type = char;
+  using difference_type = std::ptrdiff_t;
+  using pointer = char*;
+  using reference = char&;
+};
 
 namespace std {
 template <>
-struct iterator_traits<MyIter>
-    : iterator_traits<std::iterator<std::random_access_iterator_tag, char> > {};
+struct iterator_traits<MyIter> {
+  using iterator_category = std::random_access_iterator_tag;
+  using value_type = char;
+  using difference_type = std::ptrdiff_t;
+  using pointer = char*;
+  using reference = char&;
+};
+
 template <>
-struct iterator_traits<MyIter2>
-    : std::iterator<std::random_access_iterator_tag, char> {};
+struct iterator_traits<MyIter2> {
+  using iterator_category = std::random_access_iterator_tag;
+  using value_type = char;
+  using difference_type = std::ptrdiff_t;
+  using pointer = char*;
+  using reference = 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@-1{{'iterator<std::input_iterator_tag, char>' is deprecated}}

libcxx/test/std/iterators/iterator.primitives/iterator.basic/iterator.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
 //
 //===----------------------------------------------------------------------===//
 
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
 // <iterator>
 
 // template<class Category, class T, class Distance = ptrdiff_t,
 //          class Pointer = T*, class Reference = T&>
 // struct iterator
 // {
 //   typedef T         value_type;
 //   typedef Distance  difference_type;

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

 // };
 
 #include <iterator>
 #include <type_traits>
 #include <vector>
 
 #include "test_macros.h"
 
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
 template <class C>
 struct find_container
     : private std::back_insert_iterator<C>
 {
     explicit find_container(C& c) : std::back_insert_iterator<C>(c) {}
     void test() {this->container = 0;}
 };
 
 template <class C>
 void
 test()
 {
     typedef std::back_insert_iterator<C> R;
     C c;
     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), "");
+
+    using iterator_base = std::iterator<std::output_iterator_tag, void, void, void, void>;
+#if TEST_STD_VER <= 14
+    static_assert(std::is_base_of<iterator_base, R>::value, "");
+#else
+    static_assert(!std::is_base_of_v<iterator_base, R>);
+#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

 // };
 
 #include <iterator>
 #include <type_traits>
 #include <vector>
 
 #include "test_macros.h"
 
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
 template <class C>
 struct find_container
     : private std::front_insert_iterator<C>
 {
     explicit find_container(C& c) : std::front_insert_iterator<C>(c) {}
     void test() {this->container = 0;}
 };
 
 template <class C>
 void
 test()
 {
     typedef std::front_insert_iterator<C> R;
     C c;
     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), "");
+
+    using iterator_base = std::iterator<std::output_iterator_tag, void, void, void, void>;
+#if TEST_STD_VER <= 14
+    static_assert(std::is_base_of<iterator_base, R>::value, "");
+#else
+    static_assert(!std::is_base_of_v<iterator_base, R>);
+#endif
 }
 
 int main(int, char**)
 {
     test<std::vector<int> >();
 
   return 0;
 }

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

 //   typedef void                   pointer;
 // };
 
 #include <iterator>
 #include <type_traits>
 #include <vector>
 #include "test_macros.h"
 
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
 template <class C>
 struct find_members
     : private std::insert_iterator<C>
 {
     explicit find_members(C& c) : std::insert_iterator<C>(c, c.begin()) {}
     void test()
     {
         this->container = 0;
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), "");
+
+    using iterator_base = std::iterator<std::output_iterator_tag, void, void, void, void>;
+#if TEST_STD_VER <= 14
+    static_assert(std::is_base_of<iterator_base, R>::value, "");
+#else
+    static_assert(!std::is_base_of_v<iterator_base, R>);
+#endif
 }
 
 int main(int, char**)
 {
     test<std::vector<int> >();
 
   return 0;
 }

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

 // };
 
 #include <iterator>
 #include <type_traits>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
 template <class It>
 struct find_current
     : private std::reverse_iterator<It>
 {
     void test() { (void)this->current; }
 };
 
 template <class It>
 void
 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), "");
+
+    using iterator_base = std::iterator<typename T::iterator_category, char>;
+#if TEST_STD_VER <= 14
+    static_assert(std::is_base_of<iterator_base, R>::value, "");
+#else
+    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

 //  Testing the C++17 ctors for this are in the ctor tests.
 
 #include <iterator>
 #include <type_traits>
 #include <string>
 
 #include "test_macros.h"
 
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
 int main(int, char**)
 {
     typedef std::istream_iterator<double> I1; // double is trivially destructible
+    using iterator_base = std::iterator<std::input_iterator_tag, double, std::ptrdiff_t, double const*, double const&>;
 #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), "");
+    static_assert((std::is_convertible<I1, iterator_base>::value), "");
+    static_assert(std::is_base_of<iterator_base, std::istream_iterator<double> >::value, "");
 #else
+    static_assert(!std::is_base_of<iterator_base, std::istream_iterator<double> >::value, "");
     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), "");

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

 //    a constexpr default constructor and a trivial destructor.
 
 #include <iterator>
 #include <string>
 #include <type_traits>
 
 #include "test_macros.h"
 
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
 int main(int, char**)
 {
     typedef std::istreambuf_iterator<char> I1;
+    using iterator_base = std::iterator<std::input_iterator_tag, char, std::char_traits<char>::off_type, char*, char>;
+#if TEST_STD_VER <= 14
+    static_assert(std::is_base_of<iterator_base, I1>::value, "");
+#else
+    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), "");

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

 //     ...
 
 #include <cstddef>
 #include <iterator>
 #include <type_traits>
 
 #include "test_macros.h"
 
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
 int main(int, char**)
 {
     typedef std::ostream_iterator<double> I1;
+    using iterator_base = std::iterator<std::output_iterator_tag, void, void, void, void>;
 #if TEST_STD_VER <= 14
-    static_assert((std::is_convertible<I1,
-        std::iterator<std::output_iterator_tag, void, void, void, void> >::value), "");
+    static_assert(std::is_base_of<iterator_base, I1>::value, "");
+    static_assert((std::is_convertible<I1, iterator_base>::value), "");
 #else
+    static_assert(!std::is_base_of<iterator_base, I1>::value, "");
     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), "");

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

 
 #include <cstddef>
 #include <iterator>
 #include <string>
 #include <type_traits>
 
 #include "test_macros.h"
 
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
 int main(int, char**)
 {
     typedef std::ostreambuf_iterator<char> I1;
+    using iterator_base = std::iterator<std::output_iterator_tag, void, void, void, void>;
 #if TEST_STD_VER <= 14
-    static_assert((std::is_convertible<I1,
-        std::iterator<std::output_iterator_tag, void, void, void, void> >::value), "");
+    static_assert(std::is_base_of<iterator_base, I1>::value, "");
+    static_assert((std::is_convertible<I1, iterator_base>::value), "");
 #else
+    static_assert(!std::is_base_of<iterator_base, I1>::value, "");
     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), "");