[libc++][ranges] Implement Ranges changes to `istream{,buf}_iterator`.

[var-const]

Summary

The changes from the One Ranges Proposal amount to adding:

• a constructor that takes a default_sentinel_t and is equivalent to the default constructor;
• an operator== that compares the iterator to default_sentinel_t.

The original proposal defined two overloads for operator== (different
argument order) as well as operator!=. This has been removed by
P1614.

[var-const]

Use the actual patch number.

[var-const]

Mark changes to stream iterators as done.

[var-const]

libcxx/include/__iterator/istream_iterator.h

50

Note: the default constructor and this constructor are defined in the same clause in the Standard (23.6.2.2.1, http://eel.is/c++draft/istream.iterator#cons-1), so it made sense to define one in terms of the other.

libcxx/include/__iterator/istreambuf_iterator.h

97

This is the definition from the Standard verbatim (http://eel.is/c++draft/istreambuf.iterator#ops-7). At least conceptually, it involves creating a istreambuf_iterator from the sentinel. We could instead do something like return __test_for_eof();. I'm not sure if it's worth it, though.

libcxx/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/default.pass.cpp

54

Because these constructors (default constructor and default_sentinel_t constructor) are defined in the same clause, I'm leaning towards testing them in the same test file.

[var-const]

Add noexcept tests.

[var-const]

Small fixes to the synopsis.

[• Quuxplusone]

LGTM % minor comments!
Please fix (especially the operator!=s), rebase and re-upload to see a green CI run (now that the ASAN failures should be fixed, right?), but then this seems ready to ship.

libcxx/include/__iterator/istream_iterator.h

77

Nit: I know the standard says !in_stream, but can we please make this return __i.__in_stream_ == nullptr; for clarity? (Since it's just a raw pointer, there's no difference except readability.)

92–100

operator!= should be under #if _LIBCPP_STD_VER <= 17, because it's gone in '20.

libcxx/include/__iterator/istreambuf_iterator.h

70

97

I agree; but I think it is worth it, just to get rid of a layer of indirection and avoid having to name the __s parameter. :) return __i.__test_for_eof(); sounds like a win to me.

109–114

As above, this operator!= is gone in '20.

libcxx/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator.cons/default.pass.cpp

13–14

Nit: To match the synopsis comment, and the throw()/noexcept distinction isn't terribly important IMHO.

[• Quuxplusone]

Er, actually, I spoke too soon...! There are also test failures on Apple, because you changed the operator==/!= tests to include references to default_sentinel, and default_sentinel is disabled when libcpp-has-no-concepts.
I suggest fixing this by changing <__iterator/default_sentinel.h> to enable default_sentinel in C++20 regardless of _LIBCPP_HAS_NO_CONCEPTS — it should merely be guarded by #if _LIBCPP_STD_VER > 17 and nothing else. However, now this has become a more involved change, and I think at least I should re-review it once the CI is green, and perhaps also someone else.

(Alternatively, you could split out the default_sentinel-related tests into separate test files and skip them for libcpp-has-no-concepts targets. But that seems yuckier.)

[var-const]

In D119620#3317884, @Quuxplusone wrote:

I suggest fixing this by changing <__iterator/default_sentinel.h> to enable default_sentinel in C++20 regardless of _LIBCPP_HAS_NO_CONCEPTS — it should merely be guarded by #if _LIBCPP_STD_VER > 17 and nothing else.

Done. Since it doesn't actually use concepts, that seems reasonable.

libcxx/include/__iterator/istream_iterator.h

77

Sure.

92–100

Done (I don't think this is related to the One Ranges proposal, but it makes sense to do these changes in one go). Also mentioned this in the synopsis.

libcxx/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator.cons/default.pass.cpp

13–14

Done. I've done the same change in the synopsis -- you intended to change both, right?

[var-const]

Address feedback (in particular, remove the throw()/noexcept distinction
from the synopsis and guard default_sentinel on the language version, not the
availability of concepts).

[ldionne]

This LGTM. I'm fine with not guarding default_sentinel_t under _LIBCPP_HAS_NO_CONCEPTS, since (1) that macro will soon die and (2) it technically doesn't need concepts.

Leaving final approval to Arthur since he had comments.

libcxx/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/default.pass.cpp

54

I have a very slight preference for different files since they are really different constructors (except they happen to have the same effect). But definitely not a blocking comment.

libcxx/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.ops/equal.pass.cpp

11

If you add the test here (I'd weakly prefer another file), please update the synopsis. This applies in a couple other tests too.

[var-const]

Address feedback, fix the CI.

[var-const]

Rebase on main.

[• Quuxplusone]

I just landed D118736, so please check relatively carefully for merge conflicts; but I don't think you'll find any.

[var-const]

Rebase on main.

libcxx/docs/Status/RangesPaper.csv

 | [iterator.cust.swap]
 | [iterator.cust.move]",Zoe Carver,✅
 `[default.sentinel] <https://wg21.link/default.sentinel>`_,`std::default_sentinel_t <https://llvm.org/D103487>`_,No dependencies,Zoe Carver,✅
 `[counted.iterator] <https://wg21.link/counted.iterator>`_,`counted_iterator <https://llvm.org/D106205>`_,"| [iterator.concepts]
 | [iterator.cust.swap]
 | [iterator.cust.move]
 | [default.sentinels]",Zoe Carver,✅
 `[stream.iterators] <https://wg21.link/stream.iterators>`_,"
-| Updates to istream_iterator
+| `Updates to istream_iterator <https://llvm.org/D119620>`_
 | `Updates to ostream_iterator <https://llvm.org/D103273>`_
-| Updates to istreambuf_iterator
+| `Updates to istreambuf_iterator <https://llvm.org/D119620>`_
 | `Updates to ostreambuf_iterator <https://llvm.org/D103273>`_
-",[default.sentinels],Various,In progress
+",[default.sentinels],Various,✅
 `[range.access] <https://wg21.link/range.access>`_,"| `ranges::begin <https://llvm.org/D100255>`_
 | `ranges::end <https://llvm.org/D100255>`_
 | `range::cbegin <https://llvm.org/D100255>`_
 | `ranges::cend <https://llvm.org/D100255>`_
 | `ranges::rbegin <https://llvm.org/D119057>`_
 | `ranges::rend <https://llvm.org/D119057>`_
 | `ranges::crbegin <https://llvm.org/D119057>`_
 | `ranges::crend <https://llvm.org/D119057>`_

libcxx/include/__iterator/default_sentinel.h

 #include <__config>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-#if !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#if _LIBCPP_STD_VER > 17
 
 struct default_sentinel_t { };
 inline constexpr default_sentinel_t default_sentinel{};
 
-#endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
+#endif // _LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ITERATOR_DEFAULT_SENTINEL_H

libcxx/include/__iterator/istream_iterator.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___ITERATOR_ISTREAM_ITERATOR_H
 #define _LIBCPP___ITERATOR_ISTREAM_ITERATOR_H
 
 #include <__config>
+#include <__iterator/default_sentinel.h>
 #include <__iterator/iterator.h>
 #include <__iterator/iterator_traits.h>
 #include <__memory/addressof.h>
 #include <iosfwd> // for forward declarations of char_traits and basic_istream
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
public:
     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_() {}
+#if _LIBCPP_STD_VER > 17
+    _LIBCPP_HIDE_FROM_ABI constexpr istream_iterator(default_sentinel_t) : istream_iterator() {}
+#endif // _LIBCPP_STD_VER > 17
     _LIBCPP_INLINE_VISIBILITY istream_iterator(istream_type& __s) : __in_stream_(_VSTD::addressof(__s))
         {
             if (!(*__in_stream_ >> __value_))
                 __in_stream_ = nullptr;
         }
 
     _LIBCPP_INLINE_VISIBILITY const _Tp& operator*() const {return __value_;}
     _LIBCPP_INLINE_VISIBILITY const _Tp* operator->() const {return _VSTD::addressof((operator*()));}
     _LIBCPP_INLINE_VISIBILITY istream_iterator& operator++()
         {
             if (!(*__in_stream_ >> __value_))
                 __in_stream_ = nullptr;
             return *this;
         }
     _LIBCPP_INLINE_VISIBILITY istream_iterator  operator++(int)
         {istream_iterator __t(*this); ++(*this); return __t;}
 
     template <class _Up, class _CharU, class _TraitsU, class _DistanceU>
     friend _LIBCPP_INLINE_VISIBILITY
     bool
     operator==(const istream_iterator<_Up, _CharU, _TraitsU, _DistanceU>& __x,
                const istream_iterator<_Up, _CharU, _TraitsU, _DistanceU>& __y);
+
+#if _LIBCPP_STD_VER > 17
+    friend _LIBCPP_HIDE_FROM_ABI bool operator==(const istream_iterator& __i, default_sentinel_t) {
+      return __i.__in_stream_ == nullptr;
+    }
+#endif // _LIBCPP_STD_VER > 17
 };
 
 template <class _Tp, class _CharT, class _Traits, class _Distance>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator==(const istream_iterator<_Tp, _CharT, _Traits, _Distance>& __x,
            const istream_iterator<_Tp, _CharT, _Traits, _Distance>& __y)
 {
     return __x.__in_stream_ == __y.__in_stream_;
 }
 
+#if _LIBCPP_STD_VER <= 17
 template <class _Tp, class _CharT, class _Traits, class _Distance>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator!=(const istream_iterator<_Tp, _CharT, _Traits, _Distance>& __x,
            const istream_iterator<_Tp, _CharT, _Traits, _Distance>& __y)
 {
     return !(__x == __y);
 }
+#endif // _LIBCPP_STD_VER <= 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ITERATOR_ISTREAM_ITERATOR_H

libcxx/include/__iterator/istreambuf_iterator.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___ITERATOR_ISTREAMBUF_ITERATOR_H
 #define _LIBCPP___ITERATOR_ISTREAMBUF_ITERATOR_H
 
 #include <__config>
+#include <__iterator/default_sentinel.h>
 #include <__iterator/iterator.h>
 #include <__iterator/iterator_traits.h>
 #include <iosfwd> // for forward declaration of basic_streambuf
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
private:
     bool __test_for_eof() const
     {
         if (__sbuf_ && traits_type::eq_int_type(__sbuf_->sgetc(), traits_type::eof()))
             __sbuf_ = nullptr;
         return __sbuf_ == nullptr;
     }
 public:
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR istreambuf_iterator() _NOEXCEPT : __sbuf_(nullptr) {}
+#if _LIBCPP_STD_VER > 17
+    _LIBCPP_INLINE_VISIBILITY constexpr istreambuf_iterator(default_sentinel_t) noexcept
+        : istreambuf_iterator() {}
+#endif // _LIBCPP_STD_VER > 17
     _LIBCPP_INLINE_VISIBILITY istreambuf_iterator(istream_type& __s) _NOEXCEPT
         : __sbuf_(__s.rdbuf()) {}
     _LIBCPP_INLINE_VISIBILITY istreambuf_iterator(streambuf_type* __s) _NOEXCEPT
         : __sbuf_(__s) {}
     _LIBCPP_INLINE_VISIBILITY istreambuf_iterator(const __proxy& __p) _NOEXCEPT
         : __sbuf_(__p.__sbuf_) {}
 
     _LIBCPP_INLINE_VISIBILITY char_type  operator*() const
         {return static_cast<char_type>(__sbuf_->sgetc());}
     _LIBCPP_INLINE_VISIBILITY istreambuf_iterator& operator++()
         {
             __sbuf_->sbumpc();
             return *this;
         }
     _LIBCPP_INLINE_VISIBILITY __proxy              operator++(int)
         {
             return __proxy(__sbuf_->sbumpc(), __sbuf_);
         }
 
     _LIBCPP_INLINE_VISIBILITY bool equal(const istreambuf_iterator& __b) const
         {return __test_for_eof() == __b.__test_for_eof();}
+
+#if _LIBCPP_STD_VER > 17
+    friend _LIBCPP_HIDE_FROM_ABI bool operator==(const istreambuf_iterator& __i, default_sentinel_t) {
+      return __i.__test_for_eof();
+    }
+#endif // _LIBCPP_STD_VER > 17
 };
 
 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);}
 
+#if _LIBCPP_STD_VER <= 17
 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);}
+#endif // _LIBCPP_STD_VER <= 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ITERATOR_ISTREAMBUF_ITERATOR_H

libcxx/include/iterator

public:
     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(); // constexpr since C++11
+    constexpr istream_iterator(default_sentinel_t); // since C++20
     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);
+    friend bool operator==(const istream_iterator& i, default_sentinel_t); // since C++20
 };
 
 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);
+                const istream_iterator<T,charT,traits,Distance>& y); // until C++20
 
 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:
     typedef output_iterator_tag         iterator_category;
     typedef void                        value_type;
public:
     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() noexcept; // constexpr since C++11
+    constexpr istreambuf_iterator(default_sentinel_t) noexcept; // since C++20
     istreambuf_iterator(istream_type& s) noexcept;
     istreambuf_iterator(streambuf_type* s) noexcept;
     istreambuf_iterator(a-private-type) noexcept;
 
     charT                operator*() const;
     pointer operator->() const;
     istreambuf_iterator& operator++();
     a-private-type       operator++(int);
 
     bool equal(const istreambuf_iterator& b) const;
+    friend bool operator==(const istreambuf_iterator& i, default_sentinel_t s); // since C++20
 };
 
 template <class charT, class traits>
 bool operator==(const istreambuf_iterator<charT,traits>& a,
                 const istreambuf_iterator<charT,traits>& b);
 template <class charT, class traits>
 bool operator!=(const istreambuf_iterator<charT,traits>& a,
-                const istreambuf_iterator<charT,traits>& b);
+                const istreambuf_iterator<charT,traits>& b); // until C++20
 
 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 output_iterator_tag            iterator_category;
     typedef void                           value_type;

libcxx/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.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
 //
 //===----------------------------------------------------------------------===//
 
 // <iterator>
 
 // class istream_iterator
 
-// constexpr istream_iterator();
+// istream_iterator(); // constexpr since C++11
 // C++17 says: If is_trivially_default_constructible_v<T> is true, then this
 //    constructor is a constexpr constructor.
 
 #include <iterator>
 #include <cassert>
 #include <string>
 
 #include "test_macros.h"

 
 template <typename T>
 struct test_trivial<T, false> {
 void operator ()() const {}
 };
 #endif
 
 
-int main(int, char**)
-{
+int main(int, char**) {
     {
     typedef std::istream_iterator<int> T;
     T it;
     assert(it == T());
 #if TEST_STD_VER >= 11
     constexpr T it2;
     (void)it2;
 #endif
     }
 
 #if TEST_STD_VER > 14
     test_trivial<int>()();
     test_trivial<char>()();
     test_trivial<double>()();
     test_trivial<S>()();
     test_trivial<std::string>()();
 #endif
 
   return 0;
 }

libcxx/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/default_sentinel_t.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>
+//
+// constexpr istream_iterator(default_sentinel_t); // since C++20
+
+#include <iterator>
+#include <cassert>
+
+int main(int, char**) {
+  using T = std::istream_iterator<int>;
+
+  {
+    T it(std::default_sentinel);
+    assert(it == T());
+  }
+
+  {
+    T it = std::default_sentinel;
+    assert(it == T());
+  }
+
+  {
+    constexpr T it(std::default_sentinel);
+    (void)it;
+  }
+
+  return 0;
+}

libcxx/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.ops/equal.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>
 
 // class istream_iterator
 
 // 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);
+//
+// friend bool operator==(const istream_iterator& i, default_sentinel_t); // since C++20
 
 #include <iterator>
 #include <sstream>
 #include <cassert>
 
 #include "test_macros.h"
 
-int main(int, char**)
+int main(int, char**) {
   {
     std::istringstream inf1(" 1 23");
     std::istringstream inf2(" 1 23");
     std::istream_iterator<int> i1(inf1);
     std::istream_iterator<int> i2(inf1);
     std::istream_iterator<int> i3(inf2);
     std::istream_iterator<int> i4;
     std::istream_iterator<int> i5;
     assert(i1 == i1);
int main(int, char**) {
     assert(i3 == i3);
     assert(i3 != i4);
     assert(i3 != i5);
 
     assert(i4 == i4);
     assert(i4 == i5);
 
     assert(std::operator==(i1, i2));
+#if TEST_STD_VER <= 17
     assert(std::operator!=(i1, i3));
+#endif
+  }
+
+#if TEST_STD_VER > 17
+  {
+    std::istream_iterator<int> i1;
+    std::istream_iterator<int> i2(std::default_sentinel);
+    assert(i1 == i2);
+
+    assert(i1 == std::default_sentinel);
+    assert(i2 == std::default_sentinel);
+    assert(std::default_sentinel == i1);
+    assert(std::default_sentinel == i2);
+    assert(!(i1 != std::default_sentinel));
+    assert(!(i2 != std::default_sentinel));
+    assert(!(std::default_sentinel != i1));
+    assert(!(std::default_sentinel != i2));
+
+    std::istringstream stream(" 1 23");
+    std::istream_iterator<int> i3(stream);
+
+    assert(!(i3 == std::default_sentinel));
+    assert(!(std::default_sentinel == i3));
+    assert(i3 != std::default_sentinel);
+    assert(std::default_sentinel != i3);
+  }
+#endif
 
   return 0;
 }

libcxx/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator.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
 //
 //===----------------------------------------------------------------------===//
 
 // <iterator>
 
 // istreambuf_iterator
 //
-// istreambuf_iterator() throw();
+// istreambuf_iterator() noexcept; // constexpr since C++11
 //
 // All specializations of istreambuf_iterator shall have a trivial copy constructor,
 //    a constexpr default constructor and a trivial destructor.
 
 #include <iterator>
 #include <sstream>
 #include <cassert>
 
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    {
-        typedef std::istreambuf_iterator<char> T;
-        T it;
-        assert(it == T());
+int main(int, char**) {
 #if TEST_STD_VER >= 11
-        constexpr T it2;
-        (void)it2;
 #endif
-    }
+
+    ASSERT_NOEXCEPT(T());
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    {
-        typedef std::istreambuf_iterator<wchar_t> T;
-        T it;
-        assert(it == T());
 #if TEST_STD_VER >= 11
-        constexpr T it2;
-        (void)it2;
 #endif
-    }
+
+    ASSERT_NOEXCEPT(T());
 #endif // TEST_HAS_NO_WIDE_CHARACTERS
 
   return 0;
 }

libcxx/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator.cons/default_sentinel_t.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>
+
+// constexpr istreambuf_iterator(default_sentinel_t) noexcept; // since C++20
+
+#include <iterator>
+#include <sstream>
+#include <cassert>
+
+#include "test_macros.h"
+
+int main(int, char**) {
+  using T = std::istreambuf_iterator<char>;
+
+  {
+    T it(std::default_sentinel);
+    assert(it == T());
+  }
+
+  {
+    T it = std::default_sentinel;
+    assert(it == T());
+  }
+
+  {
+    constexpr T it(std::default_sentinel);
+    (void)it;
+  }
+
+  ASSERT_NOEXCEPT(T(std::default_sentinel));
+
+  return 0;
+}

libcxx/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_op!=/not_equal.pass.cpp

 //                   const istreambuf_iterator<charT,traits>& b);
 
 #include <iterator>
 #include <sstream>
 #include <cassert>
 
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    {
-        std::istringstream inf1("abc");
-        std::istringstream inf2("def");
-        std::istreambuf_iterator<char> i1(inf1);
-        std::istreambuf_iterator<char> i2(inf2);
-        std::istreambuf_iterator<char> i3;
-        std::istreambuf_iterator<char> i4;
-        std::istreambuf_iterator<char> i5(nullptr);
+int main(int, char**) {
 
-        assert(!(i1 != i1));
-        assert(!(i1 != i2));
-        assert( (i1 != i3));
-        assert( (i1 != i4));
-        assert( (i1 != i5));
 
-        assert(!(i2 != i1));
-        assert(!(i2 != i2));
-        assert( (i2 != i3));
-        assert( (i2 != i4));
-        assert( (i2 != i5));
 
-        assert( (i3 != i1));
-        assert( (i3 != i2));
-        assert(!(i3 != i3));
-        assert(!(i3 != i4));
-        assert(!(i3 != i5));
 
-        assert( (i4 != i1));
-        assert( (i4 != i2));
-        assert(!(i4 != i3));
-        assert(!(i4 != i4));
-        assert(!(i4 != i5));
 
-        assert( (i5 != i1));
-        assert( (i5 != i2));
-        assert(!(i5 != i3));
-        assert(!(i5 != i4));
-        assert(!(i5 != i5));
-    }
+
+#if TEST_STD_VER > 17
+  {
+    std::istreambuf_iterator<char> i1;
+    std::istreambuf_iterator<char> i2(std::default_sentinel);
+    assert(i1 == i2);
+
+    assert(!(i1 != std::default_sentinel));
+    assert(!(i2 != std::default_sentinel));
+    assert(!(std::default_sentinel != i1));
+    assert(!(std::default_sentinel != i2));
+
+    std::istringstream stream(" 1 23");
+    std::istreambuf_iterator<char> i3(stream);
+
+    assert(i3 != std::default_sentinel);
+    assert(std::default_sentinel != i3);
+  }
+#endif
+
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    {
-        std::wistringstream inf1(L"abc");
-        std::wistringstream inf2(L"def");
-        std::istreambuf_iterator<wchar_t> i1(inf1);
-        std::istreambuf_iterator<wchar_t> i2(inf2);
-        std::istreambuf_iterator<wchar_t> i3;
-        std::istreambuf_iterator<wchar_t> i4;
-        std::istreambuf_iterator<wchar_t> i5(nullptr);
 
-        assert(!(i1 != i1));
-        assert(!(i1 != i2));
-        assert( (i1 != i3));
-        assert( (i1 != i4));
-        assert( (i1 != i5));
 
-        assert(!(i2 != i1));
-        assert(!(i2 != i2));
-        assert( (i2 != i3));
-        assert( (i2 != i4));
-        assert( (i2 != i5));
 
-        assert( (i3 != i1));
-        assert( (i3 != i2));
-        assert(!(i3 != i3));
-        assert(!(i3 != i4));
-        assert(!(i3 != i5));
 
-        assert( (i4 != i1));
-        assert( (i4 != i2));
-        assert(!(i4 != i3));
-        assert(!(i4 != i4));
-        assert(!(i4 != i5));
 
-        assert( (i5 != i1));
-        assert( (i5 != i2));
-        assert(!(i5 != i3));
-        assert(!(i5 != i4));
-        assert(!(i5 != i5));
-    }
 #endif // TEST_HAS_NO_WIDE_CHARACTERS
 
   return 0;
 }

libcxx/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator_op==/equal.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>
 
 // istreambuf_iterator
 
 // template <class charT, class traits>
 //   bool operator==(const istreambuf_iterator<charT,traits>& a,
 //                   const istreambuf_iterator<charT,traits>& b);
+//
+// friend bool operator==(const istreambuf_iterator& i, default_sentinel_t s); // since C++20
 
 #include <iterator>
 #include <sstream>
 #include <cassert>
 
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    {
-        std::istringstream inf1("abc");
-        std::istringstream inf2("def");
-        std::istreambuf_iterator<char> i1(inf1);
-        std::istreambuf_iterator<char> i2(inf2);
-        std::istreambuf_iterator<char> i3;
-        std::istreambuf_iterator<char> i4;
-        std::istreambuf_iterator<char> i5(nullptr);
+int main(int, char**) {
 
-        assert( (i1 == i1));
-        assert( (i1 == i2));
-        assert(!(i1 == i3));
-        assert(!(i1 == i4));
-        assert(!(i1 == i5));
 
-        assert( (i2 == i1));
-        assert( (i2 == i2));
-        assert(!(i2 == i3));
-        assert(!(i2 == i4));
-        assert(!(i2 == i5));
 
-        assert(!(i3 == i1));
-        assert(!(i3 == i2));
-        assert( (i3 == i3));
-        assert( (i3 == i4));
-        assert( (i3 == i5));
 
-        assert(!(i4 == i1));
-        assert(!(i4 == i2));
-        assert( (i4 == i3));
-        assert( (i4 == i4));
-        assert( (i4 == i5));
 
-        assert(!(i5 == i1));
-        assert(!(i5 == i2));
-        assert( (i5 == i3));
-        assert( (i5 == i4));
-        assert( (i5 == i5));
-    }
+
+#if TEST_STD_VER > 17
+  {
+    std::istreambuf_iterator<char> i1;
+    std::istreambuf_iterator<char> i2(std::default_sentinel);
+    assert(i1 == i2);
+
+    assert(i1 == std::default_sentinel);
+    assert(i2 == std::default_sentinel);
+    assert(std::default_sentinel == i1);
+    assert(std::default_sentinel == i2);
+
+    std::istringstream stream(" 1 23");
+    std::istreambuf_iterator<char> i3(stream);
+
+    assert(!(i3 == std::default_sentinel));
+    assert(!(std::default_sentinel == i3));
+  }
+#endif
+
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    {
-        std::wistringstream inf1(L"abc");
-        std::wistringstream inf2(L"def");
-        std::istreambuf_iterator<wchar_t> i1(inf1);
-        std::istreambuf_iterator<wchar_t> i2(inf2);
-        std::istreambuf_iterator<wchar_t> i3;
-        std::istreambuf_iterator<wchar_t> i4;
-        std::istreambuf_iterator<wchar_t> i5(nullptr);
 
-        assert( (i1 == i1));
-        assert( (i1 == i2));
-        assert(!(i1 == i3));
-        assert(!(i1 == i4));
-        assert(!(i1 == i5));
 
-        assert( (i2 == i1));
-        assert( (i2 == i2));
-        assert(!(i2 == i3));
-        assert(!(i2 == i4));
-        assert(!(i2 == i5));
 
-        assert(!(i3 == i1));
-        assert(!(i3 == i2));
-        assert( (i3 == i3));
-        assert( (i3 == i4));
-        assert( (i3 == i5));
 
-        assert(!(i4 == i1));
-        assert(!(i4 == i2));
-        assert( (i4 == i3));
-        assert( (i4 == i4));
-        assert( (i4 == i5));
 
-        assert(!(i5 == i1));
-        assert(!(i5 == i2));
-        assert( (i5 == i3));
-        assert( (i5 == i4));
-        assert( (i5 == i5));
-    }
 #endif // TEST_HAS_NO_WIDE_CHARACTERS
 
   return 0;
 }