[libc++] Update all the pre-defined iterator types for C++20

[ldionne]

Summary

Make sure we provide the correct It::difference_type member and update
the tests and synopses to be accurate.

Supersedes D102657 and D103101 (thanks to the original authors).

[Mordante]

Thanks a lot for working on this! After this has landed I can remove some work-arounds from my <format> branch.

libcxx/include/iterator

253

std::ptrdiff_t -> ptrdiff_t here and other places.

280–281

I miss constexpr front_insert_iterator() noexcept = default; // since C++20 and the implementation.
back_insert_iterator has the same issue.

305–306

I miss insert_iterator() = default; // since C++20 and the implementation. (This one has no constexpr nor noexcept.)

392–400

Remove std:: here and similar places.

[zoecarver]

LGTM

[ldionne]

Address review comments.

[ldionne]

libcxx/include/iterator

280–281

Good catch, somehow I missed those. Thanks.

502

@tcanens I think this one is missing from cppreference: https://en.cppreference.com/w/cpp/iterator/ostreambuf_iterator/ostreambuf_iterator

[• Quuxplusone]

libcxx/include/iterator

502

It'll be DRed out of existence by p2325r3, so I bet it's not worth fixing on cppreference.
(See my LWG reflector thread of last week, "Must ostreambuf_iterator<char>().failed() == false?".)
There's an executive design decision to be made here as to whether we should just go ahead and implement p2325 (although it seems like both me and Louis have relatively independently made decisions to implement not-p2325). Either p2325 or not-p2325 would suffice to unblock @Mordante AIUI.

899

I strongly recommend removing the redundant constexpr and noexcept, for cleanliness' sake. (Defaulted functions are always constexpr-auto and noexcept-auto.)
Ditto line 908, 1075, 1200; already OK on line 954.

libcxx/test/std/iterators/iterator.primitives/iterator.traits/cxx20_iterator_traits.compile.pass.cpp

58

Nice! :)

[Mordante]

LGTM! I'll leave the final approval for @Quuxplusone.

libcxx/include/iterator

502

Yeah when P2325 is applied the default constructors will be removed, but an output_iterator should no longer require default_constructible. For <format> I only need the back_insert_iterator to be an output_iterator.

899

I've no strong opinion about this, but I slight prefer to use the wording the standard provides. Thus including constexpr and noexept.

[ldionne]

libcxx/include/iterator

899

Same as @Mordante , which is why I did it that way.

libcxx/include/__memory/raw_storage_iterator.h

 #endif
 {
 _LIBCPP_SUPPRESS_DEPRECATED_POP
 private:
     _OutputIterator __x_;
 public:
     typedef output_iterator_tag iterator_category;
     typedef void                value_type;
+#if _LIBCPP_STD_VER > 17
+    typedef ptrdiff_t           difference_type;
+#else
     typedef void                difference_type;
+#endif
     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

libcxx/include/iterator

 operator+(typename reverse_iterator<Iterator>::difference_type n,
           const reverse_iterator<Iterator>& x);   // constexpr in C++17
 
 template <class Iterator>
 constexpr reverse_iterator<Iterator> make_reverse_iterator(Iterator i); // C++14, constexpr in C++17
 
 template <class Container>
 class back_insert_iterator
+    : public iterator<output_iterator_tag, void, void, void, void> // until C++17
 {
 protected:
     Container* container;
 public:
     typedef Container                   container_type;
     typedef void                        value_type;
-    typedef void                        difference_type;
+    typedef void                        difference_type; // until C++20
+    typedef ptrdiff_t                   difference_type; // since C++20
     typedef void                        reference;
     typedef void                        pointer;
 
+    constexpr back_insert_iterator() noexcept = default; // since C++20
     explicit back_insert_iterator(Container& x);  // constexpr in C++20
     back_insert_iterator& operator=(const typename Container::value_type& value);  // constexpr in C++20
     back_insert_iterator& operator*();  // constexpr in C++20
     back_insert_iterator& operator++();  // constexpr in C++20
     back_insert_iterator  operator++(int);  // constexpr in C++20
 };
 
 template <class Container> back_insert_iterator<Container> back_inserter(Container& x);  // constexpr in C++20
 
 template <class Container>
 class front_insert_iterator
+    : public iterator<output_iterator_tag, void, void, void, void> // until C++17
 {
 protected:
     Container* container;
 public:
     typedef Container                    container_type;
     typedef void                         value_type;
-    typedef void                         difference_type;
+    typedef void                         difference_type; // until C++20
+    typedef ptrdiff_t                    difference_type; // since C++20
     typedef void                         reference;
     typedef void                         pointer;
 
+    constexpr front_insert_iterator() noexcept = default; // since C++20
     explicit front_insert_iterator(Container& x);  // constexpr in C++20
     front_insert_iterator& operator=(const typename Container::value_type& value);  // constexpr in C++20
     front_insert_iterator& operator*();  // constexpr in C++20
     front_insert_iterator& operator++();  // constexpr in C++20
     front_insert_iterator  operator++(int);  // constexpr in C++20
 };
 
 template <class Container> front_insert_iterator<Container> front_inserter(Container& x);  // constexpr in C++20
 
 template <class Container>
 class insert_iterator
+    : public iterator<output_iterator_tag, void, void, void, void> // until C++17
 {
 protected:
     Container* container;
     typename Container::iterator iter;
 public:
     typedef Container              container_type;
     typedef void                   value_type;
-    typedef void                   difference_type;
+    typedef void                   difference_type; // until C++20
+    typedef ptrdiff_t              difference_type; // since C++20
     typedef void                   reference;
     typedef void                   pointer;
 
+    insert_iterator() = default; // since C++20
     insert_iterator(Container& x, typename Container::iterator i);  // constexpr in C++20
     insert_iterator& operator=(const typename Container::value_type& value);  // constexpr in C++20
     insert_iterator& operator*();  // constexpr in C++20
     insert_iterator& operator++();  // constexpr in C++20
     insert_iterator& operator++(int);  // constexpr in C++20
 };
 
 template <class Container, class Iterator>

 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&> // until C++17
 {
 public:
-    typedef charT char_type;
-    typedef traits traits_type;
-    typedef basic_istream<charT,traits> istream_type;
+    typedef input_iterator_tag           iterator_category;
+    typedef T                            value_type;
+    typedef Distance                     difference_type;
+    typedef const T*                     pointer;
+    typedef const T&                     reference;
+
+    typedef charT                        char_type;
+    typedef traits                       traits_type;
+    typedef basic_istream<charT, traits> istream_type;
 
     constexpr istream_iterator();
     istream_iterator(istream_type& s);
     istream_iterator(const istream_iterator& x);
     ~istream_iterator();
 
     const T& operator*() const;
     const T* operator->() const;
     istream_iterator& operator++();
     istream_iterator  operator++(int);
 };
 
 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, 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> // until C++17
+    : public iterator<output_iterator_tag, void, void, void, void> // until C++17
 {
 public:
+    typedef output_iterator_tag         iterator_category;
+    typedef void                        value_type;
+    typedef void                        difference_type; // until C++20
+    typedef ptrdiff_t                   difference_type; // since C++20
+    typedef void                        pointer;
+    typedef void                        reference;
+
     typedef charT char_type;
     typedef traits traits_type;
     typedef basic_ostream<charT,traits> ostream_type;
 
+    constexpr ostream_iterator() noexcept = default; // since C++20
     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,                // until C++17
-                      typename traits::off_type, unspecified,
-                      charT>
+    : public iterator<input_iterator_tag, charT, traits::off_type, unspecified, charT> // until C++17
 {
 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;
+    typedef input_iterator_tag              iterator_category;
+    typedef charT                           value_type;
+    typedef traits::off_type                difference_type;
+    typedef unspecified                     pointer;
+    typedef charT                           reference;
+
+    typedef charT                           char_type;
+    typedef traits                          traits_type;
+    typedef traits::int_type                int_type;
+    typedef basic_streambuf<charT, traits>  streambuf_type;
+    typedef basic_istream<charT, traits>    istream_type;
 
     istreambuf_iterator() noexcept;
     istreambuf_iterator(istream_type& s) noexcept;
     istreambuf_iterator(streambuf_type* s) noexcept;
     istreambuf_iterator(a-private-type) noexcept;
 
     charT                operator*() const;
     pointer operator->() const;

 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> // 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;
+    typedef output_iterator_tag            iterator_category;
+    typedef void                           value_type;
+    typedef void                           difference_type; // until C++20
+    typedef ptrdiff_t                      difference_type; // since C++20
+    typedef void                           pointer;
+    typedef void                           reference;
+
+    typedef charT                          char_type;
+    typedef traits                         traits_type;
+    typedef basic_streambuf<charT, traits> streambuf_type;
+    typedef basic_ostream<charT, traits>   ostream_type;
 
+    constexpr ostreambuf_iterator() noexcept = default; // since C++20
     ostreambuf_iterator(ostream_type& s) noexcept;
     ostreambuf_iterator(streambuf_type* s) noexcept;
     ostreambuf_iterator& operator=(charT c);
     ostreambuf_iterator& operator*();
     ostreambuf_iterator& operator++();
     ostreambuf_iterator& operator++(int);
     bool failed() const noexcept;
 };

 #endif
 {
 _LIBCPP_SUPPRESS_DEPRECATED_POP
 protected:
     _Container* container;
 public:
     typedef output_iterator_tag iterator_category;
     typedef void value_type;
+#if _LIBCPP_STD_VER > 17
+    typedef ptrdiff_t difference_type;
+#else
     typedef void difference_type;
+#endif
     typedef void pointer;
     typedef void reference;
     typedef _Container container_type;
 
+#if _LIBCPP_STD_VER > 17
+    _LIBCPP_INLINE_VISIBILITY constexpr back_insert_iterator() noexcept = default;
+#endif
     _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;}

 #endif
 {
 _LIBCPP_SUPPRESS_DEPRECATED_POP
 protected:
     _Container* container;
 public:
     typedef output_iterator_tag iterator_category;
     typedef void value_type;
+#if _LIBCPP_STD_VER > 17
+    typedef ptrdiff_t difference_type;
+#else
     typedef void difference_type;
+#endif
     typedef void pointer;
     typedef void reference;
     typedef _Container container_type;
 
+#if _LIBCPP_STD_VER > 17
+    _LIBCPP_INLINE_VISIBILITY constexpr front_insert_iterator() noexcept = default;
+#endif
     _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_SUPPRESS_DEPRECATED_POP
 protected:
     _Container* container;
     typename _Container::iterator iter;
 public:
     typedef output_iterator_tag iterator_category;
     typedef void value_type;
+#if _LIBCPP_STD_VER > 17
+    typedef ptrdiff_t difference_type;
+#else
     typedef void difference_type;
+#endif
     typedef void pointer;
     typedef void reference;
     typedef _Container container_type;
 
+#if _LIBCPP_STD_VER > 17
+    _LIBCPP_INLINE_VISIBILITY insert_iterator() = default;
+#endif
     _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
#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;
+    typedef ptrdiff_t                       difference_type;
 #else
     typedef void                            difference_type;
 #endif
     typedef void                            pointer;
     typedef void                            reference;
     typedef _CharT                          char_type;
     typedef _Traits                         traits_type;
     typedef basic_ostream<_CharT, _Traits>  ostream_type;
 
 private:
     ostream_type* __out_stream_;
     const char_type* __delim_;
 public:
+#if _LIBCPP_STD_VER > 17
+    _LIBCPP_INLINE_VISIBILITY constexpr ostream_iterator() noexcept = default;
+#endif
     _LIBCPP_INLINE_VISIBILITY ostream_iterator(ostream_type& __s) _NOEXCEPT
         : __out_stream_(_VSTD::addressof(__s)), __delim_(nullptr) {}
     _LIBCPP_INLINE_VISIBILITY ostream_iterator(ostream_type& __s, const _CharT* __delimiter) _NOEXCEPT
         : __out_stream_(_VSTD::addressof(__s)), __delim_(__delimiter) {}
     _LIBCPP_INLINE_VISIBILITY ostream_iterator& operator=(const _Tp& __value_)
         {
             *__out_stream_ << __value_;
             if (__delim_)
#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;
+    typedef ptrdiff_t                           difference_type;
 #else
     typedef void                                difference_type;
 #endif
     typedef void                                pointer;
     typedef void                                reference;
     typedef _CharT                              char_type;
     typedef _Traits                             traits_type;
     typedef basic_streambuf<_CharT, _Traits>    streambuf_type;
     typedef basic_ostream<_CharT, _Traits>      ostream_type;
 
 private:
     streambuf_type* __sbuf_;
 public:
+#if _LIBCPP_STD_VER > 17
+    _LIBCPP_INLINE_VISIBILITY constexpr ostreambuf_iterator() noexcept = default;
+#endif
     _LIBCPP_INLINE_VISIBILITY ostreambuf_iterator(ostream_type& __s) _NOEXCEPT
         : __sbuf_(__s.rdbuf()) {}
     _LIBCPP_INLINE_VISIBILITY ostreambuf_iterator(streambuf_type* __s) _NOEXCEPT
         : __sbuf_(__s) {}
     _LIBCPP_INLINE_VISIBILITY ostreambuf_iterator& operator=(_CharT __c)
         {
             if (__sbuf_ && traits_type::eq_int_type(__sbuf_->sputc(__c), traits_type::eof()))
                 __sbuf_ = nullptr;

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
+class raw_storage_iterator // deprecated in C++17, removed in C++20
     : public iterator<output_iterator_tag, void, void, void, void> // until C++17
 {
 public:
+    typedef output_iterator_tag iterator_category;
+    typedef void                value_type;
+    typedef void                difference_type; // until C++20
+    typedef ptrdiff_t           difference_type; // since C++20
+    typedef void                pointer;
+    typedef void                reference;
+
     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);
 };
 
 template <class T> pair<T*,ptrdiff_t> get_temporary_buffer(ptrdiff_t n) noexcept;

libcxx/test/std/iterators/iterator.primitives/iterator.traits/cxx20_iterator_traits.compile.pass.cpp

 #include "test_iterators.h"
 #include "iterator_traits_cpp17_iterators.h"
 
 template <class Traits>
 constexpr bool has_iterator_concept_v = requires {
   typename Traits::iterator_concept;
 };
 
-template <class Iter, class Category, class Diff = void>
+template <class Iter, class Category>
 constexpr bool testIOIterator() {
   using Traits = std::iterator_traits<Iter>;
   static_assert(std::same_as<typename Traits::iterator_category, Category>);
   static_assert(std::same_as<typename Traits::value_type, void>);
-  static_assert(std::same_as<typename Traits::difference_type, Diff>);
+  static_assert(std::same_as<typename Traits::difference_type, std::ptrdiff_t>);
   static_assert(std::same_as<typename Traits::reference, void>);
   static_assert(std::same_as<typename Traits::pointer, void>);
   static_assert(!has_iterator_concept_v<Traits>);
 
   return true;
 }
 
 template <class Iter, class ValueType, class Category>

 static_assert(testIOIterator<std::back_insert_iterator<std::vector<int>>, std::output_iterator_tag>());
 static_assert(testIOIterator<std::front_insert_iterator<std::vector<int>>, std::output_iterator_tag>());
 static_assert(testIOIterator<std::insert_iterator<std::vector<int>>, std::output_iterator_tag>());
 static_assert(testConstWithoutConcept<std::istream_iterator<int, char>, int, std::input_iterator_tag>());
 
 #if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
 static_assert(testWithoutConcept<std::istreambuf_iterator<char>, char, long long, char, char*, std::input_iterator_tag>());
 static_assert(testWithoutConcept<std::move_iterator<int*>, int, std::ptrdiff_t, int&&, int*, std::random_access_iterator_tag>());
-static_assert(testIOIterator<std::ostream_iterator<int, char>, std::output_iterator_tag, std::ptrdiff_t>());
-static_assert(testIOIterator<std::ostreambuf_iterator<int, char>, std::output_iterator_tag, std::ptrdiff_t>());
+static_assert(testIOIterator<std::ostream_iterator<int, char>, std::output_iterator_tag>());
+static_assert(testIOIterator<std::ostreambuf_iterator<int, char>, std::output_iterator_tag>());
 static_assert(testConstWithoutConcept<std::cregex_iterator, std::cmatch, std::forward_iterator_tag>());
 static_assert(testConstWithoutConcept<std::cregex_token_iterator, std::csub_match, std::forward_iterator_tag>());
 #endif // !_LIBCPP_HAS_NO_LOCALIZATION
 
 #ifndef _LIBCPP_HAS_NO_FILESYSTEM_LIBRARY
 static_assert(testWithoutConcept<std::filesystem::directory_iterator, std::filesystem::directory_entry, std::ptrdiff_t,
                                  const std::filesystem::directory_entry&, const std::filesystem::directory_entry*,
                                  std::input_iterator_tag>());

libcxx/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.cons/default.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, c++11, c++14, c++17
-// UNSUPPORTED: libcpp-no-concepts
-// UNSUPPORTED: gcc-10
 
-// insert_iterator
+// <iterator>
 
-#include <iterator>
+// class back_insert_iterator
+
+// constexpr back_insert_iterator() noexcept = default;
 
+#include <iterator>
 #include <vector>
 
-using iterator = std::insert_iterator<std::vector<int> >;
-static_assert(!std::indirectly_readable<iterator>);
-static_assert(std::indirectly_writable<iterator, int>);
-static_assert(!std::weakly_incrementable<iterator>);
-static_assert(!std::input_or_output_iterator<iterator>);
-static_assert(!std::sentinel_for<iterator, iterator>);
-static_assert(!std::input_iterator<iterator>);
+#include "test_macros.h"
+
+struct T { };
+using Container = std::vector<T>;
+
+constexpr bool test() {
+    std::back_insert_iterator<Container> it;
+    (void)it;
+    return true;
+}
+
+int main(int, char**) {
+    ASSERT_NOEXCEPT(std::back_insert_iterator<Container>());
+
+    test();
+    static_assert(test());
+
+    return 0;
+}

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

 
 #include <iterator>
 
 #include <vector>
 
 using iterator = std::back_insert_iterator<std::vector<int> >;
 static_assert(!std::indirectly_readable<iterator>);
 static_assert(std::indirectly_writable<iterator, int>);
-static_assert(!std::weakly_incrementable<iterator>);
-static_assert(!std::input_or_output_iterator<iterator>);
+static_assert(std::weakly_incrementable<iterator>);
+static_assert(std::input_or_output_iterator<iterator>);
 static_assert(!std::sentinel_for<iterator, iterator>);
 static_assert(!std::sized_sentinel_for<iterator, iterator>);
 static_assert(!std::input_iterator<iterator>);

libcxx/test/std/iterators/predef.iterators/insert.iterators/back.insert.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>
 
 // back_insert_iterator
 
 // Test nested types and data member:
 
 // template <BackInsertionContainer Cont>
-// class back_insert_iterator {
+// class back_insert_iterator
+//  : public iterator<output_iterator_tag, void, void, void, void> // until C++17
+// {
 // protected:
 //   Cont* container;
 // public:
 //   typedef Cont                        container_type;
 //   typedef void                        value_type;
-//   typedef void                        difference_type;
+//   typedef void                        difference_type; // until C++20
+//   typedef ptrdiff_t                   difference_type; // since C++20
 //   typedef void                        reference;
 //   typedef void                        pointer;
 // };
 
 #include <iterator>
 #include <type_traits>
 #include <vector>
 

 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), "");
+#if TEST_STD_VER > 17
+    static_assert((std::is_same<typename R::difference_type, std::ptrdiff_t>::value), "");
+#else
     static_assert((std::is_same<typename R::difference_type, void>::value), "");
+#endif
     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.iter.ops/front.insert.iter.cons/default.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, c++11, c++14, c++17
-// UNSUPPORTED: libcpp-no-concepts
-// UNSUPPORTED: gcc-10
 
-// insert_iterator
+// <iterator>
 
-#include <iterator>
+// class front_insert_iterator
+
+// constexpr front_insert_iterator() noexcept = default;
 
+#include <iterator>
 #include <vector>
 
-using iterator = std::insert_iterator<std::vector<int> >;
-static_assert(!std::indirectly_readable<iterator>);
-static_assert(std::indirectly_writable<iterator, int>);
-static_assert(!std::weakly_incrementable<iterator>);
-static_assert(!std::input_or_output_iterator<iterator>);
-static_assert(!std::sentinel_for<iterator, iterator>);
-static_assert(!std::input_iterator<iterator>);
+#include "test_macros.h"
+
+struct T { };
+using Container = std::vector<T>;
+
+constexpr bool test() {
+    std::front_insert_iterator<Container> it;
+    (void)it;
+    return true;
+}
+
+int main(int, char**) {
+    ASSERT_NOEXCEPT(std::front_insert_iterator<Container>());
+
+    test();
+    static_assert(test());
+
+    return 0;
+}

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

 
 #include <iterator>
 
 #include <list>
 
 using iterator = std::front_insert_iterator<std::list<int> >;
 static_assert(!std::indirectly_readable<iterator>);
 static_assert(std::indirectly_writable<iterator, int>);
-static_assert(!std::weakly_incrementable<iterator>);
-static_assert(!std::input_or_output_iterator<iterator>);
+static_assert(std::weakly_incrementable<iterator>);
+static_assert(std::input_or_output_iterator<iterator>);
 static_assert(!std::sentinel_for<iterator, iterator>);
 static_assert(!std::sized_sentinel_for<iterator, iterator>);
 static_assert(!std::input_iterator<iterator>);

libcxx/test/std/iterators/predef.iterators/insert.iterators/front.insert.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>
 
 // front_insert_iterator
 
 // Test nested types and data member:
 
 // template <class Container>
-// class front_insert_iterator {
+// class front_insert_iterator
+//  : public iterator<output_iterator_tag, void, void, void, void> // until C++17
+// {
 // protected:
 //   Container* container;
 // public:
 //   typedef Container                   container_type;
 //   typedef void                        value_type;
-//   typedef void                        difference_type;
+//   typedef void                        difference_type; // until C++20
+//   typedef ptrdiff_t                   difference_type; // since C++20
 //   typedef void                        reference;
 //   typedef void                        pointer;
 //   typedef output_iterator_tag         iterator_category;
 // };
 
 #include <iterator>
 #include <type_traits>
 #include <vector>

 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), "");
+#if TEST_STD_VER > 17
+    static_assert((std::is_same<typename R::difference_type, std::ptrdiff_t>::value), "");
+#else
     static_assert((std::is_same<typename R::difference_type, void>::value), "");
+#endif
     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.iter.ops/insert.iter.cons/default.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, c++11, c++14, c++17
-// UNSUPPORTED: libcpp-no-concepts
-// UNSUPPORTED: gcc-10
 
-// insert_iterator
+// <iterator>
 
-#include <iterator>
+// class insert_iterator
+
+// insert_iterator() = default;
 
+#include <iterator>
 #include <vector>
 
-using iterator = std::insert_iterator<std::vector<int> >;
-static_assert(!std::indirectly_readable<iterator>);
-static_assert(std::indirectly_writable<iterator, int>);
-static_assert(!std::weakly_incrementable<iterator>);
-static_assert(!std::input_or_output_iterator<iterator>);
-static_assert(!std::sentinel_for<iterator, iterator>);
-static_assert(!std::input_iterator<iterator>);
+struct T { };
+using Container = std::vector<T>;
+
+int main(int, char**) {
+    std::insert_iterator<Container> it; (void)it;
+    return 0;
+}

libcxx/test/std/iterators/predef.iterators/insert.iterators/insert.iterator/iterator_concept_conformance.compile.pass.cpp

 
 #include <iterator>
 
 #include <vector>
 
 using iterator = std::insert_iterator<std::vector<int> >;
 static_assert(!std::indirectly_readable<iterator>);
 static_assert(std::indirectly_writable<iterator, int>);
-static_assert(!std::weakly_incrementable<iterator>);
-static_assert(!std::input_or_output_iterator<iterator>);
+static_assert(std::weakly_incrementable<iterator>);
+static_assert(std::input_or_output_iterator<iterator>);
 static_assert(!std::sentinel_for<iterator, iterator>);
 static_assert(!std::input_iterator<iterator>);

libcxx/test/std/iterators/predef.iterators/insert.iterators/insert.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>
 
 // insert_iterator
 
 // Test nested types and data members:
 
 // template <InsertionContainer Cont>
-// class insert_iterator {
+// class insert_iterator
+//  : public iterator<output_iterator_tag, void, void, void, void> // until C++17
+// {
 // protected:
 //   Cont* container;
 //   Cont::iterator iter;
 // public:
 //   typedef Cont                   container_type;
 //   typedef void                   value_type;
-//   typedef void                   difference_type;
+//   typedef void                   difference_type; // until C++20
+//   typedef ptrdiff_t              difference_type; // since C++20
 //   typedef void                   reference;
 //   typedef void                   pointer;
 // };
 
 #include <iterator>
 #include <type_traits>
 #include <vector>
 #include "test_macros.h"

 test()
 {
     typedef std::insert_iterator<C> R;
     C c;
     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), "");
+#if TEST_STD_VER > 17
+    static_assert((std::is_same<typename R::difference_type, std::ptrdiff_t>::value), "");
+#else
     static_assert((std::is_same<typename R::difference_type, void>::value), "");
+#endif
     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/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 {
+// class istream_iterator
+//  : 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;
+//     typedef input_iterator_tag           iterator_category;
+//     typedef T                            value_type;
+//     typedef Distance                     difference_type;
+//     typedef const T*                     pointer;
+//     typedef const T&                     reference;
+//
+//     typedef basic_istream<charT, Traits> istream_type;
+//     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

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 {
+// class istreambuf_iterator
+//  : public iterator<input_iterator_tag, charT, traits::off_type, unspecified, charT> // until C++17
+// {
 // 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;
+//     typedef input_iterator_tag             iterator_category;
+//     typedef charT                          value_type;
+//     typedef traits::off_type               difference_type;
+//     typedef unspecified                    pointer;
+//     typedef charT                          reference;
+//
+//     typedef charT                          char_type;
+//     typedef traits                         traits_type;
+//     typedef 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>

libcxx/test/std/iterators/stream.iterators/ostream.iterator/iterator_concept_conformance.compile.pass.cpp

 
 #include <iterator>
 
 #include <iosfwd>
 
 using iterator = std::ostream_iterator<int, std::ostream>;
 static_assert(!std::indirectly_readable<iterator>);
 static_assert(std::indirectly_writable<iterator, int>);
-static_assert(!std::weakly_incrementable<iterator>);
-static_assert(!std::input_or_output_iterator<iterator>);
+static_assert(std::weakly_incrementable<iterator>);
+static_assert(std::input_or_output_iterator<iterator>);
 static_assert(!std::sentinel_for<iterator, iterator>);
 static_assert(!std::sized_sentinel_for<iterator, iterator>);
 static_assert(!std::input_iterator<iterator>);

libcxx/test/std/iterators/stream.iterators/ostream.iterator/ostream.iterator.cons.des/default.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, c++11, c++14, c++17
+
+// <iterator>
+
+// class ostream_iterator
+
+// constexpr ostream_iterator() noexcept = default;
+
+#include <iterator>
+#include <string> // char_traits
+
+#include "test_macros.h"
+
+struct MyTraits : std::char_traits<char> {
+    MyTraits();  // This should not be called.
+};
+
+constexpr bool test() {
+    std::ostream_iterator<int> it;
+    (void)it;
+    std::ostream_iterator<int, char, MyTraits> wit;
+    (void)wit;
+    return true;
+}
+
+int main(int, char**) {
+    ASSERT_NOEXCEPT(std::ostream_iterator<int>());
+    ASSERT_NOEXCEPT(std::ostream_iterator<int, char, MyTraits>());
+
+    test();
+    static_assert(test());
+
+    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 {
+// class ostream_iterator
+//  : public iterator<output_iterator_tag, void, void, void, void> // until C++17
+// {
 // public:
-//     typedef charT char_type;
-//     typedef traits traits_type;
-//     typedef basic_istream<charT,traits> istream_type;
+//     typedef output_iterator_tag          iterator_category;
+//     typedef void                         value_type;
+//     typedef void                         difference_type; // until C++20
+//     typedef ptrdiff_t                    difference_type; // since C++20
+//     typedef void                         pointer;
+//     typedef void                         reference;
+//
+//     typedef charT                        char_type;
+//     typedef traits                       traits_type;
+//     typedef basic_ostream<charT, traits> ostream_type;
 //     ...
 
 #include <cstddef>
 #include <iterator>
 #include <type_traits>
 
 #include "test_macros.h"
 

libcxx/test/std/iterators/stream.iterators/ostreambuf.iterator/iterator_concept_conformance.compile.pass.cpp

 #include <iterator>
 
 #include <ostream>
 #include <string>
 
 using iterator = std::ostreambuf_iterator<char>;
 static_assert(!std::indirectly_readable<iterator>);
 static_assert(std::indirectly_writable<iterator, char>);
-static_assert(!std::weakly_incrementable<iterator>);
-static_assert(!std::input_or_output_iterator<iterator>);
+static_assert(std::weakly_incrementable<iterator>);
+static_assert(std::input_or_output_iterator<iterator>);
 static_assert(!std::sentinel_for<iterator, iterator>);
 static_assert(!std::sized_sentinel_for<iterator, iterator>);
 static_assert(!std::input_iterator<iterator>);

libcxx/test/std/iterators/stream.iterators/ostreambuf.iterator/ostreambuf.iter.cons/default.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, c++11, c++14, c++17
+
+// <iterator>
+
+// class ostreambuf_iterator
+
+// constexpr ostreambuf_iterator() noexcept = default;
+
+#include <iterator>
+
+#include "test_macros.h"
+
+constexpr bool test() {
+    std::ostreambuf_iterator<char> it;
+    (void)it;
+    std::ostreambuf_iterator<wchar_t> wit;
+    (void)wit;
+    return true;
+}
+
+int main(int, char**) {
+    ASSERT_NOEXCEPT(std::ostreambuf_iterator<char>());
+    ASSERT_NOEXCEPT(std::ostreambuf_iterator<wchar_t>());
+
+    test();
+    static_assert(test());
+
+    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 {
+// class ostreambuf_iterator
+//  : 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;
-//   ...
+//     typedef output_iterator_tag            iterator_category;
+//     typedef void                           value_type;
+//     typedef void                           difference_type; // until C++20
+//     typedef ptrdiff_t                      difference_type; // since C++20
+//     typedef void                           pointer;
+//     typedef void                           reference;
+//
+//     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"
 

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 <cstddef>
 #include <memory>
 #include <type_traits>
 
+#include "test_macros.h"
+
 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, "");
+#if TEST_STD_VER > 17
+static_assert(std::is_same<It::difference_type, std::ptrdiff_t>::value, "");
+#else
 static_assert(std::is_same<It::difference_type, void>::value, "");
+#endif
 static_assert(std::is_same<It::pointer, void>::value, "");
 static_assert(std::is_same<It::reference, void>::value, "");