[libc++] [test] The long-awaited mass refactor of "test_iterators.h" sentinels [WIP]

[ldionne]

Summary

I did this locally as about ten commits, which might be easier to grok individually; but I'm thinking I should land it as one monolithic commit.
https://github.com/Quuxplusone/llvm-project/compare/main...bogus-operators
The goals include:

• Rename sentinel_wrapper to just sentinel, so that now we have e.g. foo_iterator and e.g. sentinel, sized_sentinel. (This required doing some other refactors to get rid of a couple of global types named sentinel.)
• Where appropriate, use sized_sentinel<It>, instead of using sentinel_wrapper<It>-plus-some-bogus-ad-hoc-operator-overloads.
• Refactor sentinel and sized_sentinel to more closely resemble the existing foo_iterator archetypes, and to permit creating sentinel<cpp20_input_iterator<int*>> — iterators can be move-only, but sentinels must be copyable.
• Opportunistically simplify some Ranges tests (but not systematically; just anything I was already touching for other reasons).

[ldionne]

[Github PR transition cleanup]

Abandoning since this doesn't apply cleanly anymore and changes were planned.

libcxx/test/libcxx/ranges/range.utility.helpers/simple_view.compile.pass.cpp

 
 struct NoConstView : std::ranges::view_base {
   int *begin();
   int *end();
 };
 
 struct DifferentSentinel : std::ranges::view_base {
   int *begin() const;
-  sentinel_wrapper<int*> end() const;
+  sentinel<int*> end() const;
 };
 
 static_assert( std::ranges::__simple_view<SimpleView>);
 static_assert(!std::ranges::__simple_view<WrongConstView>);
 static_assert(!std::ranges::__simple_view<NoConstView>);
 static_assert(!std::ranges::__simple_view<DifferentSentinel>);

libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.advance/iterator_count_sentinel.pass.cpp

constexpr void check_backward_sized_sentinel(std::ptrdiff_t n, expected_t expected, range_t& range) {
   assert(current.stride_count() == 0 || current.stride_count() == 1);
   assert(current.stride_displacement() == current.stride_count());
 }
 
 template <std::input_or_output_iterator It>
 constexpr void check_forward(std::ptrdiff_t n, expected_t expected, range_t& range) {
   using Difference = std::iter_difference_t<It>;
   auto current = stride_counting_iterator(It(range.begin()));
-  Difference const result = std::ranges::advance(current, n, sentinel_wrapper(It(range.end())));
+  Difference const result = std::ranges::advance(current, n, sentinel(It(range.end())));
   assert(current.base().base() == expected.coordinate);
   assert(result == expected.result);
   assert(current.stride_count() == n - result);
 }
 
 template <std::bidirectional_iterator It>
 constexpr void check_backward(std::ptrdiff_t n, expected_t expected, range_t& range) {
   using Difference = std::iter_difference_t<It>;

libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.advance/iterator_sentinel.pass.cpp

constexpr void check_sized_sentinel_case(std::ptrdiff_t const n) {
   }
 }
 
 template <std::input_or_output_iterator It>
 constexpr void check_sentinel_case(std::ptrdiff_t const n) {
   auto range = range_t{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
   auto first = stride_counting_iterator(It(range.begin()));
   auto const last = It(range.begin() + n);
-  std::ranges::advance(first, sentinel_wrapper(last));
+  std::ranges::advance(first, sentinel(last));
   assert(first.base() == last);
   assert(first.stride_count() == n);
 }
 
 constexpr bool test() {
   check_assignable_case<cpp17_input_iterator<range_t::const_iterator> >(1);
   check_assignable_case<forward_iterator<range_t::const_iterator> >(3);
   check_assignable_case<bidirectional_iterator<range_t::const_iterator> >(4);

libcxx/test/std/iterators/iterator.primitives/range.iter.ops/range.iter.ops.next/iterator_sentinel.pass.cpp

constexpr void check_sized_sentinel(It it, It last, int const* expected) {
   }
 }
 
 template <std::input_or_output_iterator It>
 constexpr void check_sentinel(It it, It last, int const* expected) {
   auto n = (last.base() - it.base());
 
   {
-    auto sent = sentinel_wrapper(last);
+    auto sent = sentinel(last);
     It result = std::ranges::next(std::move(it), sent);
     assert(&*result == expected);
   }
 
   // Count operations
   {
     auto strided_it = stride_counting_iterator(it);
-    auto sent = sentinel_wrapper(stride_counting_iterator(last));
+    auto sent = sentinel(stride_counting_iterator(last));
     stride_counting_iterator result = std::ranges::next(std::move(strided_it), sent);
     assert(&*result == expected);
     assert(result.stride_count() == n); // must have used ++ until it hit the sentinel
   }
 }
 
 constexpr bool test() {
   int range[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};

libcxx/test/std/ranges/range.access/range.prim/empty.pass.cpp

struct HasMemberAndFunction {
   constexpr bool empty() const { return true; }
   // We should never do ADL lookup for std::ranges::empty.
   friend bool empty(const HasMemberAndFunction&) { return false; }
 };
 
 struct BadReturnType {
   BadReturnType empty() { return {}; }
 };
-static_assert(!std::is_invocable_v<RangeEmptyT, BadReturnType>);
+static_assert(!std::is_invocable_v<RangeEmptyT, BadReturnType&>);
 
 struct BoolConvertible {
   constexpr operator bool() noexcept(false) { return true; }
 };
 struct BoolConvertibleReturnType {
   constexpr BoolConvertible empty() noexcept { return {}; }
 };
-
 static_assert(!noexcept(std::ranges::empty(BoolConvertibleReturnType())));
 
 constexpr bool testEmptyMember() {
   HasMemberAndFunction a;
   assert(std::ranges::empty(a) == true);
 
   BoolConvertibleReturnType b;
   assert(std::ranges::empty(b) == true);
constexpr bool testUsingRangesSize() {
   SizeFunction c{1};
   assert(std::ranges::empty(c) == false);
   SizeFunction d{0};
   assert(std::ranges::empty(d) == true);
 
   return true;
 }
 
-struct other_forward_iterator : forward_iterator<int*> { };
-
-struct sentinel {
-  constexpr bool operator==(std::input_or_output_iterator auto) const { return true; }
-};
-
 struct BeginEndNotSizedSentinel {
-  friend constexpr forward_iterator<int*> begin(BeginEndNotSizedSentinel) { return {}; }
-  friend constexpr sentinel end(BeginEndNotSizedSentinel) { return {}; }
-};
-static_assert(!std::is_invocable_v<RangeSizeT, BeginEndNotSizedSentinel&>);
-
-struct InvalidMinusBeginEnd {
-  friend constexpr random_access_iterator<int*> begin(InvalidMinusBeginEnd) { return {}; }
-  friend constexpr sentinel end(InvalidMinusBeginEnd) { return {}; }
-};
-
-// Int is integer-like, but it is not other_forward_iterator's difference_type.
-constexpr short operator-(sentinel, random_access_iterator<int*>) { return 2; }
-constexpr short operator-(random_access_iterator<int*>, sentinel) { return 2; }
-static_assert(!std::is_invocable_v<RangeSizeT, InvalidMinusBeginEnd&>);
-
-// This type will use ranges::size.
-struct IntPtrBeginAndEnd {
-  int buff[8];
-  constexpr int* begin() { return buff; }
-  constexpr int* end() { return buff + 8; }
+  constexpr int *begin() const { return nullptr; }
+  constexpr auto end() const { return sentinel<int*>(nullptr); }
 };
-static_assert(std::is_invocable_v<RangeSizeT, IntPtrBeginAndEnd&>);
+static_assert( std::ranges::forward_range<BeginEndNotSizedSentinel>);
+static_assert(!std::ranges::sized_range<BeginEndNotSizedSentinel>);
 
-// size is disabled here, and it isn't sized_sentinel_for, so we have to compare begin
-// and end again.
+// size is disabled here, so we have to compare begin and end.
 struct DisabledSizeRangeWithBeginEnd {
-  friend constexpr forward_iterator<int*> begin(DisabledSizeRangeWithBeginEnd) { return {}; }
-  friend constexpr sentinel end(DisabledSizeRangeWithBeginEnd) { return {}; }
-  constexpr size_t size() const { return 1; }
+  constexpr int *begin() const { return {}; }
+  constexpr sentinel<int*> end() const { return {}; }
+  size_t size() const;
 };
-
-template <>
+template<>
 inline constexpr bool std::ranges::disable_sized_range<DisabledSizeRangeWithBeginEnd> = true;
-static_assert(!std::is_invocable_v<RangeSizeT, DisabledSizeRangeWithBeginEnd&>);
+static_assert(std::ranges::contiguous_range<DisabledSizeRangeWithBeginEnd>);
+static_assert(!std::ranges::sized_range<DisabledSizeRangeWithBeginEnd>);
 
 struct BeginEndAndEmpty {
-  int* begin();
-  int* end();
-  constexpr bool empty() { return true; }
-};
-
-struct BeginEndAndConstEmpty {
-  int* begin();
-  int* end();
-  constexpr bool empty() const { return true; }
+  constexpr int *begin() const { return nullptr; }
+  constexpr int *end() const { return nullptr; }
+  constexpr bool empty() { return false; }
 };
 
 constexpr bool testBeginEqualsEnd() {
   BeginEndNotSizedSentinel a;
   assert(std::ranges::empty(a) == true);
 
-  InvalidMinusBeginEnd b;
-  assert(std::ranges::empty(b) == true);
-
-  IntPtrBeginAndEnd c;
-  assert(std::ranges::empty(c) == false);
-
   DisabledSizeRangeWithBeginEnd d;
   assert(std::ranges::empty(d) == true);
 
   BeginEndAndEmpty e;
-  assert(std::ranges::empty(e) == true);
-
-  BeginEndAndConstEmpty f;
-  assert(std::ranges::empty(f) == true);
-  assert(std::ranges::empty(std::as_const(f)) == true);
+  assert(std::ranges::empty(e) == false);  // using begin()==end()
+  assert(std::ranges::empty(std::as_const(e)) == true);  // using empty()
 
   return true;
 }
 
 int main(int, char**) {
   testEmptyMember();
   static_assert(testEmptyMember());
 
   testUsingRangesSize();
   static_assert(testUsingRangesSize());
 
   testBeginEqualsEnd();
   static_assert(testBeginEqualsEnd());
 
   return 0;
 }

libcxx/test/std/ranges/range.access/range.prim/ssize.pass.cpp

 static_assert( std::is_invocable_v<RangeSSizeT, int (&&)[1]>);
 static_assert( std::is_invocable_v<RangeSSizeT, int (&)[1]>);
 
 static_assert(std::semiregular<std::remove_cv_t<RangeSSizeT>>);
 
 struct SizeMember {
   constexpr size_t size() { return 42; }
 };
-
-static_assert(!std::is_invocable_v<RangeSSizeT, const SizeMember>);
+static_assert(!std::is_invocable_v<decltype(std::ranges::ssize), const SizeMember&>);
 
 struct SizeFunction {
   friend constexpr size_t size(SizeFunction) { return 42; }
 };
 
 struct SizeFunctionSigned {
   friend constexpr std::ptrdiff_t size(SizeFunctionSigned) { return 42; }
 };
 
-struct sentinel {
-  bool operator==(std::input_or_output_iterator auto) const { return true; }
-};
-
-struct RandomAccesslRange {
-  constexpr random_access_iterator<int*> begin() { return {}; }
-  constexpr sentinel end() { return {}; }
+int globalBuff[2];
+struct SizedSentinelRange {
+  constexpr int *begin() { return globalBuff; }
+  constexpr auto end() { return sized_sentinel<int*>(globalBuff + 2); }
 };
 
-constexpr std::ptrdiff_t operator-(const sentinel, const random_access_iterator<int*>) { return 2; }
-constexpr std::ptrdiff_t operator-(const random_access_iterator<int*>, const sentinel) { return 2; }
-
 struct ShortUnsignedReturnType {
   constexpr unsigned short size() { return 42; }
 };
 
 // size_t changes depending on the platform.
 using SignedSizeT = std::make_signed_t<size_t>;
 
 constexpr bool test() {
   int a[4];
 
   assert(std::ranges::ssize(a) == 4);
   ASSERT_SAME_TYPE(decltype(std::ranges::ssize(a)), SignedSizeT);
 
   assert(std::ranges::ssize(SizeMember()) == 42);
   ASSERT_SAME_TYPE(decltype(std::ranges::ssize(SizeMember())), SignedSizeT);
 
   assert(std::ranges::ssize(SizeFunction()) == 42);
   ASSERT_SAME_TYPE(decltype(std::ranges::ssize(SizeFunction())), SignedSizeT);
 
   assert(std::ranges::ssize(SizeFunctionSigned()) == 42);
   ASSERT_SAME_TYPE(decltype(std::ranges::ssize(SizeFunctionSigned())), std::ptrdiff_t);
 
-  RandomAccesslRange b;
+  SizedSentinelRange b;
   assert(std::ranges::ssize(b) == 2);
   ASSERT_SAME_TYPE(decltype(std::ranges::ssize(b)), std::ptrdiff_t);
 
   // This gets converted to ptrdiff_t because it's wider.
   ShortUnsignedReturnType c;
   assert(std::ranges::ssize(c) == 42);
   ASSERT_SAME_TYPE(decltype(std::ranges::ssize(c)), ptrdiff_t);
 

libcxx/test/std/ranges/range.adaptors/range.all/all_t.compile.pass.cpp

 
 // Otherwise, when T is a reference to a range, returns ref_view<T>
 ASSERT_SAME_TYPE(std::views::all_t<Range&>, std::ranges::ref_view<Range>);
 ASSERT_SAME_TYPE(std::views::all_t<Range const&>, std::ranges::ref_view<Range const>);
 ASSERT_SAME_TYPE(std::views::all_t<BorrowableRange&>, std::ranges::ref_view<BorrowableRange>);
 ASSERT_SAME_TYPE(std::views::all_t<BorrowableRange const&>, std::ranges::ref_view<BorrowableRange const>);
 
 // Otherwise, returns subrange<iterator_t<T>, sentinel_t<R>>
-ASSERT_SAME_TYPE(std::views::all_t<BorrowableRange>, std::ranges::subrange<forward_iterator<int*>, sentinel>);
-ASSERT_SAME_TYPE(std::views::all_t<BorrowableRange const>, std::ranges::subrange<forward_iterator<int const*>, sentinel>);
+ASSERT_SAME_TYPE(std::views::all_t<BorrowableRange>, std::ranges::subrange<forward_iterator<int*>, sentinel<forward_iterator<int*>>>);
+ASSERT_SAME_TYPE(std::views::all_t<BorrowableRange const>, std::ranges::subrange<forward_iterator<const int*>, sentinel<forward_iterator<const int*>>>);

libcxx/test/std/ranges/range.adaptors/range.common.view/begin.pass.cpp

 #include <concepts>
 #include <utility>
 
 #include "test_iterators.h"
 #include "types.h"
 
 struct MutableView : std::ranges::view_base {
   int* begin();
-  sentinel_wrapper<int*> end();
+  sentinel<int*> end();
 };
 
 template<class View>
 concept BeginEnabled = requires(View v) { v.begin(); };
 
 constexpr bool test() {
   int buf[8] = {1, 2, 3, 4, 5, 6, 7, 8};
 
int main(int, char**) {
   static_assert(test());
 
   // The non-constexpr tests:
   int buf[8] = {1, 2, 3, 4, 5, 6, 7, 8};
 
   {
     SizedForwardView view{buf, buf + 8};
     std::ranges::common_view<SizedForwardView> common(view);
-    using CommonIter = std::common_iterator<ForwardIter, sentinel_wrapper<ForwardIter>>;
-    std::same_as<CommonIter> auto begin = common.begin();
-    assert(begin == std::ranges::begin(view));
-  }
-  {
-    SizedForwardView view{buf, buf + 8};
-    std::ranges::common_view<SizedForwardView> const common(view);
-    using CommonIter = std::common_iterator<ForwardIter, sentinel_wrapper<ForwardIter>>;
+    using CommonIter = std::common_iterator<ForwardIter, sized_sentinel<ForwardIter>>;
     std::same_as<CommonIter> auto begin = common.begin();
     assert(begin == std::ranges::begin(view));
+    std::same_as<CommonIter> auto cbegin = std::as_const(common).begin();
+    assert(cbegin == std::ranges::begin(view));
   }
 
   {
     MoveOnlyView view{buf, buf + 8};
     std::ranges::common_view<MoveOnlyView> common(std::move(view));
-    using CommonIter = std::common_iterator<int*, sentinel_wrapper<int*>>;
+    using CommonIter = std::common_iterator<int*, sentinel<int*>>;
     std::same_as<CommonIter> auto begin = common.begin();
     assert(begin == std::ranges::begin(view));
   }
 
   {
     CopyableView view{buf, buf + 8};
     std::ranges::common_view<CopyableView> const common(view);
-    using CommonIter = std::common_iterator<int*, sentinel_wrapper<int*>>;
+    using CommonIter = std::common_iterator<int*, sentinel<int*>>;
     std::same_as<CommonIter> auto begin = common.begin();
     assert(begin == std::ranges::begin(view));
   }
 
   return 0;
 }

libcxx/test/std/ranges/range.adaptors/range.common.view/borrowing.compile.pass.cpp

 
 #include <ranges>
 #include <cassert>
 
 #include "test_iterators.h"
 
 struct View : std::ranges::view_base {
   int *begin() const;
-  sentinel_wrapper<int*> end() const;
+  sentinel<int*> end() const;
 };
 
 struct BorrowableView : std::ranges::view_base {
   int *begin() const;
-  sentinel_wrapper<int*> end() const;
+  sentinel<int*> end() const;
 };
 template<>
 inline constexpr bool std::ranges::enable_borrowed_range<BorrowableView> = true;
 
 static_assert(!std::ranges::enable_borrowed_range<std::ranges::common_view<View>>);
 static_assert( std::ranges::enable_borrowed_range<std::ranges::common_view<BorrowableView>>);

libcxx/test/std/ranges/range.adaptors/range.common.view/ctad.compile.pass.cpp

 
 #include <ranges>
 #include <cassert>
 
 #include "test_iterators.h"
 
 struct View : std::ranges::view_base {
   int *begin() const;
-  sentinel_wrapper<int*> end() const;
+  sentinel<int*> end() const;
 };
 
 struct Range {
   int *begin() const;
-  sentinel_wrapper<int*> end() const;
+  sentinel<int*> end() const;
 };
 
 struct BorrowedRange {
   int *begin() const;
-  sentinel_wrapper<int*> end() const;
+  sentinel<int*> end() const;
 };
 template<>
 inline constexpr bool std::ranges::enable_borrowed_range<BorrowedRange> = true;
 
 void testCTAD() {
     View v;
     Range r;
     BorrowedRange br;
     static_assert(std::same_as<
         decltype(std::ranges::common_view(v)),
         std::ranges::common_view<View>
     >);
     static_assert(std::same_as<
         decltype(std::ranges::common_view(r)),
         std::ranges::common_view<std::ranges::ref_view<Range>>
     >);
     // std::ranges::common_view(std::move(r)) invalid. RValue range must be borrowed.
     static_assert(std::same_as<
         decltype(std::ranges::common_view(br)),
         std::ranges::common_view<std::ranges::ref_view<BorrowedRange>>
     >);
     static_assert(std::same_as<
         decltype(std::ranges::common_view(std::move(br))),
         std::ranges::common_view<std::ranges::subrange<
-          int *, sentinel_wrapper<int *>, std::ranges::subrange_kind::unsized>>
+          int *, sentinel<int *>, std::ranges::subrange_kind::unsized>>
     >);
 }

libcxx/test/std/ranges/range.adaptors/range.common.view/end.pass.cpp

 
 int main(int, char**) {
   test();
   static_assert(test());
 
   {
     int buf[8] = {1, 2, 3, 4, 5, 6, 7, 8};
 
-    using CommonForwardIter = std::common_iterator<ForwardIter, sentinel_wrapper<ForwardIter>>;
-    using CommonIntIter = std::common_iterator<int*, sentinel_wrapper<int*>>;
+    using CommonForwardIter = std::common_iterator<ForwardIter, sized_sentinel<ForwardIter>>;
+    using CommonIntIter = std::common_iterator<int*, sentinel<int*>>;
 
     {
       SizedForwardView view{buf, buf + 8};
       std::ranges::common_view<SizedForwardView> common(view);
       std::same_as<CommonForwardIter> auto end = common.end();
       assert(end == CommonForwardIter(std::ranges::end(view)));
     }
     {

libcxx/test/std/ranges/range.adaptors/range.common.view/types.h

 
 #include "test_iterators.h"
 
 struct DefaultConstructibleView : std::ranges::view_base {
   int* begin_ = nullptr;
   int* end_ = nullptr;
   explicit DefaultConstructibleView() = default;
   constexpr int *begin() const { return begin_; }
-  constexpr auto end() const { return sentinel_wrapper<int*>(end_); }
+  constexpr auto end() const { return sentinel<int*>(end_); }
 };
 static_assert(std::ranges::view<DefaultConstructibleView>);
 static_assert(std::default_initializable<DefaultConstructibleView>);
 
 struct MoveOnlyView : std::ranges::view_base {
   int* begin_;
   int* end_;
   constexpr explicit MoveOnlyView(int* b, int* e) : begin_(b), end_(e) { }
   constexpr MoveOnlyView(MoveOnlyView&&) = default;
   constexpr MoveOnlyView& operator=(MoveOnlyView&&) = default;
   constexpr int *begin() const { return begin_; }
-  constexpr auto end() const { return sentinel_wrapper<int*>(end_); }
+  constexpr auto end() const { return sentinel<int*>(end_); }
 };
 static_assert( std::ranges::view<MoveOnlyView>);
 static_assert( std::ranges::contiguous_range<MoveOnlyView>);
 static_assert(!std::copyable<MoveOnlyView>);
 
 struct CopyableView : std::ranges::view_base {
   int* begin_;
   int* end_;
   constexpr explicit CopyableView(int* b, int* e) : begin_(b), end_(e) { }
   constexpr int *begin() const { return begin_; }
-  constexpr auto end() const { return sentinel_wrapper<int*>(end_); }
+  constexpr auto end() const { return sentinel<int*>(end_); }
 };
 static_assert(std::ranges::view<CopyableView>);
 static_assert(std::copyable<CopyableView>);
 
 using ForwardIter = forward_iterator<int*>;
 struct SizedForwardView : std::ranges::view_base {
   int* begin_;
   int* end_;
   constexpr explicit SizedForwardView(int* b, int* e) : begin_(b), end_(e) { }
   constexpr auto begin() const { return forward_iterator<int*>(begin_); }
-  constexpr auto end() const { return sentinel_wrapper<forward_iterator<int*>>(forward_iterator<int*>(end_)); }
+  constexpr auto end() const { return sized_sentinel<forward_iterator<int*>>(forward_iterator<int*>(end_)); }
 };
-// Required to make SizedForwardView a sized view.
-constexpr auto operator-(sentinel_wrapper<ForwardIter> sent, ForwardIter iter) {
-  return sent.base().base() - iter.base();
-}
-constexpr auto operator-(ForwardIter iter, sentinel_wrapper<ForwardIter> sent) {
-  return iter.base() - sent.base().base();
-}
 static_assert(std::ranges::view<SizedForwardView>);
 static_assert(std::ranges::forward_range<SizedForwardView>);
 static_assert(std::ranges::sized_range<SizedForwardView>);
 
 using RandomAccessIter = random_access_iterator<int*>;
 struct SizedRandomAccessView : std::ranges::view_base {
   int* begin_;
   int* end_;
   constexpr explicit SizedRandomAccessView(int* b, int* e) : begin_(b), end_(e) { }
   constexpr auto begin() const { return random_access_iterator<int*>(begin_); }
-  constexpr auto end() const { return sentinel_wrapper<random_access_iterator<int*>>(random_access_iterator<int*>(end_)); }
+  constexpr auto end() const { return sized_sentinel<random_access_iterator<int*>>(random_access_iterator<int*>(end_)); }
 };
-// Required to make SizedRandomAccessView a sized view.
-constexpr auto operator-(sentinel_wrapper<RandomAccessIter> sent, RandomAccessIter iter) {
-  return sent.base().base() - iter.base();
-}
-constexpr auto operator-(RandomAccessIter iter, sentinel_wrapper<RandomAccessIter> sent) {
-  return iter.base() - sent.base().base();
-}
 static_assert(std::ranges::view<SizedRandomAccessView>);
 static_assert(std::ranges::random_access_range<SizedRandomAccessView>);
 static_assert(std::ranges::sized_range<SizedRandomAccessView>);
 
 struct CommonView : std::ranges::view_base {
   int* begin_;
   int* end_;
   constexpr explicit CommonView(int* b, int* e) : begin_(b), end_(e) { }
   constexpr int *begin() const { return begin_; }
   constexpr int *end() const { return end_; }
 };
 static_assert(std::ranges::view<CommonView>);
 static_assert(std::ranges::common_range<CommonView>);
 
 struct NonCommonView : std::ranges::view_base {
   int* begin_;
   int* end_;
   constexpr explicit NonCommonView(int* b, int* e) : begin_(b), end_(e) { }
   constexpr int *begin() const { return begin_; }
-  constexpr auto end() const { return sentinel_wrapper<int*>(end_); }
+  constexpr auto end() const { return sentinel<int*>(end_); }
 };
 static_assert( std::ranges::view<NonCommonView>);
 static_assert(!std::ranges::common_range<NonCommonView>);
 
 #endif // TEST_STD_RANGES_RANGE_ADAPTORS_RANGE_COMMON_VIEW_TYPES_H

libcxx/test/std/ranges/range.adaptors/range.drop/end.pass.cpp

 
 constexpr bool test() {
   // range<const V>
   std::ranges::drop_view dropView1(MoveOnlyView(), 4);
   assert(dropView1.end() == globalBuff + 8);
 
   // !simple-view<V>
   std::ranges::drop_view dropView2(InputView(), 4);
-  assert(dropView2.end() == globalBuff + 8);
+  assert(base(base(dropView2.end())) == globalBuff + 8);
 
   // range<const V>
   const std::ranges::drop_view dropView3(MoveOnlyView(), 0);
   assert(dropView3.end() == globalBuff + 8);
 
   // !simple-view<V>
   const std::ranges::drop_view dropView4(InputView(), 2);
-  assert(dropView4.end() == globalBuff + 8);
+  assert(base(base(dropView4.end())) == globalBuff + 8);
 
   // range<const V>
   std::ranges::drop_view dropView5(MoveOnlyView(), 10);
   assert(dropView5.end() == globalBuff + 8);
 
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/ranges/range.adaptors/range.drop/types.h

 struct BorrowableView : std::ranges::view_base {
   int *begin() const;
   int *end() const;
 };
 template<>
 inline constexpr bool std::ranges::enable_borrowed_range<BorrowableView> = true;
 
 struct InputView : std::ranges::view_base {
-  constexpr cpp20_input_iterator<int*> begin() const { return cpp20_input_iterator<int*>(globalBuff); }
-  constexpr int* end() const { return globalBuff + 8; }
+  constexpr auto begin() const { return cpp20_input_iterator<int*>(globalBuff); }
+  constexpr auto end() const { return sentinel<cpp20_input_iterator<int*>>(cpp20_input_iterator<int*>(globalBuff + 8)); }
 };
-// TODO: remove these bogus operators
-constexpr bool operator==(const cpp20_input_iterator<int*> &lhs, int* rhs) { return lhs.base() == rhs; }
-constexpr bool operator==(int* lhs, const cpp20_input_iterator<int*> &rhs) { return rhs.base() == lhs; }
 
 struct Range {
   int *begin() const;
   int *end() const;
 };
 
 using CountedIter = stride_counting_iterator<forward_iterator<int*>>;
 struct CountedView : std::ranges::view_base {
   constexpr CountedIter begin() const { return CountedIter(ForwardIter(globalBuff)); }
   constexpr CountedIter end() const { return CountedIter(ForwardIter(globalBuff + 8)); }
 };
 
 #endif // TEST_STD_RANGES_RANGE_ADAPTORS_RANGE_DROP_TYPES_H

libcxx/test/std/ranges/range.adaptors/range.join.view/ctad.compile.pass.cpp

 
 #include "test_iterators.h"
 
 template<class T>
 struct View : std::ranges::view_base {
   // All friends here are defined to prevent GCC warnings.
   friend T* begin(View&) { return nullptr; }
   friend T* begin(View const&) { return nullptr; }
-  friend sentinel_wrapper<T*> end(View&) { return sentinel_wrapper<T*>(nullptr); }
-  friend sentinel_wrapper<T*> end(View const&) { return sentinel_wrapper<T*>(nullptr); }
+  friend sentinel<T*> end(View&) { return sentinel<T*>(nullptr); }
+  friend sentinel<T*> end(View const&) { return sentinel<T*>(nullptr); }
 };
 
 template<class T>
 struct Range {
   friend T* begin(Range&) { return nullptr; }
   friend T* begin(Range const&) { return nullptr; }
-  friend sentinel_wrapper<T*> end(Range&) { return sentinel_wrapper<T*>(nullptr); }
-  friend sentinel_wrapper<T*> end(Range const&) { return sentinel_wrapper<T*>(nullptr); }
+  friend sentinel<T*> end(Range&) { return sentinel<T*>(nullptr); }
+  friend sentinel<T*> end(Range const&) { return sentinel<T*>(nullptr); }
 };
 
 template<class T>
 struct BorrowedRange {
   friend T* begin(BorrowedRange&) { return nullptr; }
   friend T* begin(BorrowedRange const&) { return nullptr; }
-  friend sentinel_wrapper<T*> end(BorrowedRange&) { return sentinel_wrapper<T*>(nullptr); }
-  friend sentinel_wrapper<T*> end(BorrowedRange const&) { return sentinel_wrapper<T*>(nullptr); }
+  friend sentinel<T*> end(BorrowedRange&) { return sentinel<T*>(nullptr); }
+  friend sentinel<T*> end(BorrowedRange const&) { return sentinel<T*>(nullptr); }
 };
 
 template<>
 inline constexpr bool std::ranges::enable_borrowed_range<BorrowedRange<BorrowedRange<int>>> = true;
 
 void testCTAD() {
     View<View<int>> v;
     Range<Range<int>> r;
void testCTAD() {
     // std::ranges::join_view(std::move(r)) invalid. RValue range must be borrowed.
     static_assert(std::same_as<
         decltype(std::ranges::join_view(br)),
         std::ranges::join_view<std::ranges::ref_view<BorrowedRange<BorrowedRange<int>>>>
     >);
     static_assert(std::same_as<
         decltype(std::ranges::join_view(std::move(br))),
         std::ranges::join_view<std::ranges::subrange<BorrowedRange<int> *,
-                               sentinel_wrapper<BorrowedRange<int> *>,
+                               sentinel<BorrowedRange<int> *>,
                                std::ranges::subrange_kind::unsized>>
     >);
 }

libcxx/test/std/ranges/range.adaptors/range.join.view/ctad.verify.cpp

 #include <ranges>
 
 #include "test_iterators.h"
 
 template<class T>
 struct Range {
   friend T* begin(Range&) { return nullptr; }
   friend T* begin(Range const&) { return nullptr; }
-  friend sentinel_wrapper<T*> end(Range&) { return sentinel_wrapper<T*>(nullptr); }
-  friend sentinel_wrapper<T*> end(Range const&) { return sentinel_wrapper<T*>(nullptr); }
+  friend sentinel<T*> end(Range&) { return sentinel<T*>(nullptr); }
+  friend sentinel<T*> end(Range const&) { return sentinel<T*>(nullptr); }
 };
 
 void testExplicitCTAD() {
   Range<Range<int>> r;
   std::ranges::join_view v = r; // expected-error {{no viable constructor or deduction guide for deduction of template arguments of 'join_view'}}
 }

libcxx/test/std/ranges/range.adaptors/range.reverse/begin.pass.cpp

 struct CountedView : std::ranges::view_base {
   int* begin_;
   int* end_;
 
   CountedView(int* b, int* e) : begin_(b), end_(e) { }
 
   auto begin() { return CountedIter(begin_); }
   auto begin() const { return CountedIter(begin_); }
-  auto end() { return sentinel_wrapper<CountedIter>(CountedIter(end_)); }
-  auto end() const { return sentinel_wrapper<CountedIter>(CountedIter(end_)); }
+  auto end() { return sentinel<CountedIter>(CountedIter(end_)); }
+  auto end() const { return sentinel<CountedIter>(CountedIter(end_)); }
 };
 
 struct RASentRange : std::ranges::view_base {
-  using sent_t = sentinel_wrapper<random_access_iterator<int*>>;
-  using sent_const_t = sentinel_wrapper<random_access_iterator<const int*>>;
+  using sent_t = sentinel<random_access_iterator<int*>>;
+  using sent_const_t = sentinel<random_access_iterator<const int*>>;
 
   int* begin_;
   int* end_;
 
   constexpr RASentRange(int* b, int* e) : begin_(b), end_(e) { }
 
   constexpr random_access_iterator<int*> begin() { return random_access_iterator<int*>{begin_}; }
   constexpr random_access_iterator<const int*> begin() const { return random_access_iterator<const int*>{begin_}; }

libcxx/test/std/ranges/range.adaptors/range.reverse/borrowing.compile.pass.cpp

 #include <ranges>
 #include <cassert>
 
 #include "test_iterators.h"
 
 struct View : std::ranges::view_base {
   friend int* begin(View&);
   friend int* begin(View const&);
-  friend sentinel_wrapper<int*> end(View&);
-  friend sentinel_wrapper<int*> end(View const&);
+  friend sentinel<int*> end(View&);
+  friend sentinel<int*> end(View const&);
 };
 
 struct BorrowableView : std::ranges::view_base {
   friend int* begin(BorrowableView&);
   friend int* begin(BorrowableView const&);
-  friend sentinel_wrapper<int*> end(BorrowableView&);
-  friend sentinel_wrapper<int*> end(BorrowableView const&);
+  friend sentinel<int*> end(BorrowableView&);
+  friend sentinel<int*> end(BorrowableView const&);
 };
 
 template<>
 inline constexpr bool std::ranges::enable_borrowed_range<BorrowableView> = true;
 
 static_assert(!std::ranges::enable_borrowed_range<std::ranges::reverse_view<View>>);
 static_assert( std::ranges::enable_borrowed_range<std::ranges::reverse_view<BorrowableView>>);

libcxx/test/std/ranges/range.adaptors/range.reverse/ctad.pass.cpp

 #include <concepts>
 #include <utility>
 
 #include "test_iterators.h"
 
 struct View : std::ranges::view_base {
   friend int* begin(View&) { return nullptr; }
   friend int* begin(View const&) { return nullptr; }
-  friend sentinel_wrapper<int*> end(View&) { return sentinel_wrapper<int*>(nullptr); }
-  friend sentinel_wrapper<int*> end(View const&) { return sentinel_wrapper<int*>(nullptr); }
+  friend sentinel<int*> end(View&) { return sentinel<int*>(nullptr); }
+  friend sentinel<int*> end(View const&) { return sentinel<int*>(nullptr); }
 };
 
 struct Range {
   friend int* begin(Range&) { return nullptr; }
   friend int* begin(Range const&) { return nullptr; }
-  friend sentinel_wrapper<int*> end(Range&) { return sentinel_wrapper<int*>(nullptr); }
-  friend sentinel_wrapper<int*> end(Range const&) { return sentinel_wrapper<int*>(nullptr); }
+  friend sentinel<int*> end(Range&) { return sentinel<int*>(nullptr); }
+  friend sentinel<int*> end(Range const&) { return sentinel<int*>(nullptr); }
 };
 
 struct BorrowedRange {
   friend int* begin(BorrowedRange&) { return nullptr; }
   friend int* begin(BorrowedRange const&) { return nullptr; }
-  friend sentinel_wrapper<int*> end(BorrowedRange&) { return sentinel_wrapper<int*>(nullptr); }
-  friend sentinel_wrapper<int*> end(BorrowedRange const&) { return sentinel_wrapper<int*>(nullptr); }
+  friend sentinel<int*> end(BorrowedRange&) { return sentinel<int*>(nullptr); }
+  friend sentinel<int*> end(BorrowedRange const&) { return sentinel<int*>(nullptr); }
 };
 
 template<>
 inline constexpr bool std::ranges::enable_borrowed_range<BorrowedRange> = true;
 
 int main(int, char**) {
   View v;
   Range r;
   BorrowedRange br;
 
   {
     std::same_as<std::ranges::reverse_view<View>> auto x = std::ranges::reverse_view(v);
     (void)x;
   }
   {
     std::same_as<std::ranges::reverse_view<std::ranges::ref_view<Range>>> auto x = std::ranges::reverse_view(r);
     (void)x;
     // std::ranges::reverse_view(std::move(r)) is invalid. RValue range must be borrowed.
   }
   {
     std::same_as<std::ranges::reverse_view<std::ranges::ref_view<BorrowedRange>>> auto x = std::ranges::reverse_view(br);
     (void)x;
   }
   {
-    using Subrange = std::ranges::subrange<int *, sentinel_wrapper<int *>, std::ranges::subrange_kind::unsized>;
+    using Subrange = std::ranges::subrange<int *, sentinel<int *>, std::ranges::subrange_kind::unsized>;
     std::same_as<std::ranges::reverse_view<Subrange>> auto x = std::ranges::reverse_view(std::move(br));
     (void)x;
   }
 
   return 0;
 }

libcxx/test/std/ranges/range.adaptors/range.reverse/types.h

 static_assert( std::ranges::bidirectional_range<BidirRange>);
 static_assert( std::ranges::common_range<BidirRange>);
 static_assert( std::ranges::view<BidirRange>);
 static_assert( std::copyable<BidirRange>);
 
 enum CopyCategory { MoveOnly, Copyable };
 template<CopyCategory CC>
 struct BidirSentRange : std::ranges::view_base {
-  using sent_t = sentinel_wrapper<bidirectional_iterator<int*>>;
-  using sent_const_t = sentinel_wrapper<bidirectional_iterator<const int*>>;
+  using sent_t = sentinel<bidirectional_iterator<int*>>;
+  using sent_const_t = sentinel<bidirectional_iterator<const int*>>;
 
   int* begin_;
   int* end_;
 
   constexpr BidirSentRange(int* b, int* e) : begin_(b), end_(e) { }
   constexpr BidirSentRange(const BidirSentRange &) requires (CC == Copyable) = default;
   constexpr BidirSentRange(BidirSentRange &&) requires (CC == MoveOnly) = default;
   constexpr BidirSentRange& operator=(const BidirSentRange &) requires (CC == Copyable) = default;

libcxx/test/std/ranges/range.adaptors/range.take/borrowing.compile.pass.cpp

 #include <ranges>
 #include <cassert>
 
 #include "test_iterators.h"
 
 struct View : std::ranges::view_base {
   friend int* begin(View&);
   friend int* begin(View const&);
-  friend sentinel_wrapper<int*> end(View&);
-  friend sentinel_wrapper<int*> end(View const&);
+  friend sentinel<int*> end(View&);
+  friend sentinel<int*> end(View const&);
 };
 
 struct BorrowableView : std::ranges::view_base {
   friend int* begin(BorrowableView&);
   friend int* begin(BorrowableView const&);
-  friend sentinel_wrapper<int*> end(BorrowableView&);
-  friend sentinel_wrapper<int*> end(BorrowableView const&);
+  friend sentinel<int*> end(BorrowableView&);
+  friend sentinel<int*> end(BorrowableView const&);
 };
 
 template<>
 inline constexpr bool std::ranges::enable_borrowed_range<BorrowableView> = true;
 
 static_assert(!std::ranges::enable_borrowed_range<std::ranges::take_view<View>>);
 static_assert( std::ranges::enable_borrowed_range<std::ranges::take_view<BorrowableView>>);

libcxx/test/std/ranges/range.adaptors/range.take/ctad.compile.pass.cpp

 #include <cassert>
 #include <concepts>
 
 #include "test_iterators.h"
 
 struct View : std::ranges::view_base {
   friend int* begin(View&);
   friend int* begin(View const&);
-  friend sentinel_wrapper<int*> end(View&);
-  friend sentinel_wrapper<int*> end(View const&);
+  friend sentinel<int*> end(View&);
+  friend sentinel<int*> end(View const&);
 };
 
 struct Range {
   friend int* begin(Range&);
   friend int* begin(Range const&);
-  friend sentinel_wrapper<int*> end(Range&);
-  friend sentinel_wrapper<int*> end(Range const&);
+  friend sentinel<int*> end(Range&);
+  friend sentinel<int*> end(Range const&);
 };
 
 struct BorrowedRange {
   friend int* begin(BorrowedRange&);
   friend int* begin(BorrowedRange const&);
-  friend sentinel_wrapper<int*> end(BorrowedRange&);
-  friend sentinel_wrapper<int*> end(BorrowedRange const&);
+  friend sentinel<int*> end(BorrowedRange&);
+  friend sentinel<int*> end(BorrowedRange const&);
 };
 
 template<>
 inline constexpr bool std::ranges::enable_borrowed_range<BorrowedRange> = true;
 
 void testCTAD() {
     View v;
     Range r;
void testCTAD() {
     // std::ranges::take_view(std::move(r), 0) invalid. RValue range must be borrowed.
     static_assert(std::same_as<
         decltype(std::ranges::take_view(br, 0)),
         std::ranges::take_view<std::ranges::ref_view<BorrowedRange>>
     >);
     static_assert(std::same_as<
         decltype(std::ranges::take_view(std::move(br), 0)),
         std::ranges::take_view<std::ranges::subrange<
-          int *, sentinel_wrapper<int *>, std::ranges::subrange_kind::unsized>>
+          int *, sentinel<int *>, std::ranges::subrange_kind::unsized>>
     >);
 }

libcxx/test/std/ranges/range.adaptors/range.take/sentinel/base.pass.cpp

 #include <cassert>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "../types.h"
 
 constexpr bool test() {
   int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
-  auto sw = sentinel_wrapper<int *>(buffer + 8); // Note: not 4, but that's OK.
-
   {
-    const std::ranges::take_view<MoveOnlyView> tv(MoveOnlyView{buffer}, 4);
-    assert(tv.end().base().base() == sw.base());
-    ASSERT_SAME_TYPE(decltype(tv.end().base()), sentinel_wrapper<int *>);
+    std::ranges::take_view<MoveOnlyView> tv(MoveOnlyView(buffer), 4);
+    std::same_as<sentinel<int*>> auto sw1 = tv.end().base();
+    assert(base(sw1) == buffer + 8);
+    std::same_as<sentinel<int*>> auto sw2 = std::as_const(tv).end().base();
+    assert(base(sw2) == buffer + 8);
   }
-
-  {
-    std::ranges::take_view<MoveOnlyView> tv(MoveOnlyView{buffer}, 4);
-    assert(tv.end().base().base() == sw.base());
-    ASSERT_SAME_TYPE(decltype(tv.end().base()), sentinel_wrapper<int *>);
-  }
-
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/ranges/range.adaptors/range.take/sentinel/ctor.pass.cpp

 #include "test_iterators.h"
 #include "../types.h"
 
 constexpr bool test() {
   int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
 
   {
     // Test the default ctor.
-    std::ranges::take_view<MoveOnlyView> tv(MoveOnlyView{buffer}, 4);
-    assert(decltype(tv.end()){} == std::ranges::next(tv.begin(), 4));
+    using TakeView = std::ranges::take_view<MoveOnlyView>;
+    using Sentinel = std::ranges::sentinel_t<TakeView>;
+    Sentinel s;
+    TakeView tv = TakeView(MoveOnlyView(buffer), 4);
+    assert(tv.begin() + 4 == s);
   }
 
   {
-    std::ranges::take_view<MoveOnlyView> nonConst(MoveOnlyView{buffer}, 5);
-    const std::ranges::take_view<MoveOnlyView> tvConst(MoveOnlyView{buffer}, 5);
-    auto sent1 = nonConst.end();
-    // Convert to const. Note, we cannot go the other way.
-    std::remove_cv_t<decltype(tvConst.end())> sent2 = sent1;
-
-    assert(sent1 == std::ranges::next(tvConst.begin(), 5));
-    assert(sent2 == std::ranges::next(tvConst.begin(), 5));
+    // Test the conversion from "sentinel" to "sentinel-to-const".
+    using TakeView = std::ranges::take_view<MoveOnlyView>;
+    using Sentinel = std::ranges::sentinel_t<TakeView>;
+    using ConstSentinel = std::ranges::sentinel_t<const TakeView>;
+    static_assert(std::is_convertible_v<Sentinel, ConstSentinel>);
+    TakeView tv = TakeView(MoveOnlyView(buffer), 4);
+    Sentinel s = tv.end();
+    ConstSentinel cs = s;
+    cs = s;  // test assignment also
+    assert(tv.begin() + 4 == s);
+    assert(tv.begin() + 4 == cs);
+    assert(std::as_const(tv).begin() + 4 == s);
+    assert(std::as_const(tv).begin() + 4 == cs);
   }
 
   {
-    std::ranges::take_view<CopyableView> tv(CopyableView{buffer}, 6);
-    auto sw = sentinel_wrapper<int *>(buffer + 6);
-    using Sent = decltype(tv.end());
-    Sent sent = Sent(sw);
-    assert(sent.base().base() == sw.base());
+    // Test the constructor from "base-sentinel" to "sentinel".
+    using TakeView = std::ranges::take_view<MoveOnlyView>;
+    using Sentinel = std::ranges::sentinel_t<TakeView>;
+    sentinel<int*> sw1 = MoveOnlyView(buffer).end();
+    static_assert( std::is_constructible_v<Sentinel, sentinel<int*>>);
+    static_assert(!std::is_convertible_v<sentinel<int*>, Sentinel>);
+    auto s = Sentinel(sw1);
+    std::same_as<sentinel<int*>> auto sw2 = s.base();
+    assert(base(sw2) == base(sw1));
   }
 
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/ranges/range.adaptors/range.take/types.h

 struct MoveOnlyView : std::ranges::view_base {
   int *ptr_;
 
   constexpr explicit MoveOnlyView(int* ptr) : ptr_(ptr) {}
   MoveOnlyView(MoveOnlyView&&) = default;
   MoveOnlyView& operator=(MoveOnlyView&&) = default;
 
   constexpr int* begin() const {return ptr_;}
-  constexpr sentinel_wrapper<int*> end() const {return sentinel_wrapper<int*>{ptr_ + 8};}
+  constexpr sentinel<int*> end() const {return sentinel<int*>{ptr_ + 8};}
 };
 static_assert( std::ranges::view<MoveOnlyView>);
 static_assert( std::ranges::contiguous_range<MoveOnlyView>);
 static_assert(!std::copyable<MoveOnlyView>);
 
 struct CopyableView : std::ranges::view_base {
   int *ptr_;
   constexpr explicit CopyableView(int* ptr) : ptr_(ptr) {}
 
   constexpr int* begin() const {return ptr_;}
-  constexpr sentinel_wrapper<int*> end() const {return sentinel_wrapper<int*>{ptr_ + 8};}
+  constexpr sentinel<int*> end() const {return sentinel<int*>{ptr_ + 8};}
 };
 static_assert(std::ranges::view<CopyableView>);
 static_assert(std::ranges::contiguous_range<CopyableView>);
 static_assert(std::copyable<CopyableView>);
 
 using ForwardIter = forward_iterator<int*>;
 struct SizedForwardView : std::ranges::view_base {
   int *ptr_;
   constexpr explicit SizedForwardView(int* ptr) : ptr_(ptr) {}
   constexpr auto begin() const { return ForwardIter(ptr_); }
-  constexpr auto end() const { return sentinel_wrapper<ForwardIter>(ForwardIter(ptr_ + 8)); }
+  constexpr auto end() const { return sized_sentinel<ForwardIter>(ForwardIter(ptr_ + 8)); }
 };
-// Required to make SizedForwardView a sized view.
-constexpr auto operator-(sentinel_wrapper<ForwardIter> sent, ForwardIter iter) {
-  return sent.base().base() - iter.base();
-}
-constexpr auto operator-(ForwardIter iter, sentinel_wrapper<ForwardIter> sent) {
-  return iter.base() - sent.base().base();
-}
 static_assert(std::ranges::view<SizedForwardView>);
 static_assert(std::ranges::forward_range<SizedForwardView>);
 static_assert(std::ranges::sized_range<SizedForwardView>);
 
 using RandomAccessIter = random_access_iterator<int*>;
 struct SizedRandomAccessView : std::ranges::view_base {
   int *ptr_;
   constexpr explicit SizedRandomAccessView(int* ptr) : ptr_(ptr) {}
   constexpr auto begin() const { return RandomAccessIter(ptr_); }
-  constexpr auto end() const { return sentinel_wrapper<RandomAccessIter>(RandomAccessIter(ptr_ + 8)); }
+  constexpr auto end() const { return sized_sentinel<RandomAccessIter>(RandomAccessIter(ptr_ + 8)); }
 };
-// Required to make SizedRandomAccessView a sized view.
-constexpr auto operator-(sentinel_wrapper<RandomAccessIter> sent, RandomAccessIter iter) {
-  return sent.base().base() - iter.base();
-}
-constexpr auto operator-(RandomAccessIter iter, sentinel_wrapper<RandomAccessIter> sent) {
-  return iter.base() - sent.base().base();
-}
 static_assert(std::ranges::view<SizedRandomAccessView>);
 static_assert(std::ranges::random_access_range<SizedRandomAccessView>);
 static_assert(std::ranges::sized_range<SizedRandomAccessView>);
 
 #endif // TEST_STD_RANGES_RANGE_ADAPTORS_RANGE_TAKE_TYPES_H

libcxx/test/std/ranges/range.adaptors/range.transform/end.pass.cpp

 template<class T>
 concept EndInvocable = requires(T t) { t.end(); };
 
 template<class T>
 concept EndIsIter = requires(T t) { ++t.end(); };
 
 constexpr bool test() {
   {
-    std::ranges::transform_view transformView(MoveOnlyView{}, PlusOneMutable{});
-    assert(transformView.end().base() == globalBuff + 8);
+    using TransformView = std::ranges::transform_view<ForwardView, PlusOneMutable>;
+    static_assert(std::ranges::common_range<TransformView>);
+    TransformView tv;
+    auto end = tv.end();
+    ASSERT_SAME_TYPE(decltype(end.base()), std::ranges::sentinel_t<ForwardView>);
+    assert(base(end.base()) == globalBuff + 8);
+    static_assert(!EndInvocable<const TransformView>); // because PlusOneMutable
   }
-
   {
-    std::ranges::transform_view transformView(ForwardView{}, PlusOneMutable{});
-    assert(transformView.end().base().base() == globalBuff + 8);
+    using TransformView = std::ranges::transform_view<InputView, PlusOneMutable>;
+    static_assert(!std::ranges::common_range<TransformView>);
+    TransformView tv;
+    auto end = tv.end();
+    ASSERT_SAME_TYPE(decltype(end.base()), std::ranges::sentinel_t<InputView>);
+    assert(base(base(end.base())) == globalBuff + 8);
+    static_assert(!EndInvocable<const TransformView>); // because PlusOneMutable
   }
-
   {
-    std::ranges::transform_view transformView(InputView{}, PlusOneMutable{});
-    assert(transformView.end().base() == globalBuff + 8);
+    using TransformView = std::ranges::transform_view<InputView, PlusOne>;
+    static_assert(!std::ranges::common_range<TransformView>);
+    TransformView tv;
+    auto end = tv.end();
+    ASSERT_SAME_TYPE(decltype(end.base()), std::ranges::sentinel_t<InputView>);
+    assert(base(base(end.base())) == globalBuff + 8);
+    auto cend = std::as_const(tv).end();
+    ASSERT_SAME_TYPE(decltype(cend.base()), std::ranges::sentinel_t<const InputView>);
+    assert(base(base(cend.base())) == globalBuff + 8);
   }
-
   {
-    const std::ranges::transform_view transformView(MoveOnlyView{}, PlusOne{});
-    assert(transformView.end().base() == globalBuff + 8);
+    using TransformView = std::ranges::transform_view<MoveOnlyView, PlusOneMutable>;
+    static_assert(std::ranges::common_range<TransformView>);
+    TransformView tv;
+    auto end = tv.end();
+    ASSERT_SAME_TYPE(decltype(end.base()), std::ranges::sentinel_t<MoveOnlyView>);
+    assert(end.base() == globalBuff + 8);
+    static_assert(!EndInvocable<const TransformView>); // because PlusOneMutable
+  }
+  {
+    using TransformView = std::ranges::transform_view<MoveOnlyView, PlusOne>;
+    static_assert(std::ranges::common_range<TransformView>);
+    TransformView tv;
+    auto end = tv.end();
+    ASSERT_SAME_TYPE(decltype(end.base()), std::ranges::sentinel_t<MoveOnlyView>);
+    assert(end.base() == globalBuff + 8);
+    auto cend = std::as_const(tv).end();
+    ASSERT_SAME_TYPE(decltype(cend.base()), std::ranges::sentinel_t<const MoveOnlyView>);
+    assert(cend.base() == globalBuff + 8);
   }
-
-  static_assert(!EndInvocable<const std::ranges::transform_view<MoveOnlyView, PlusOneMutable>>);
-  static_assert( EndInvocable<      std::ranges::transform_view<MoveOnlyView, PlusOneMutable>>);
-  static_assert( EndInvocable<const std::ranges::transform_view<MoveOnlyView, PlusOne>>);
-  static_assert(!EndInvocable<const std::ranges::transform_view<InputView, PlusOneMutable>>);
-  static_assert( EndInvocable<      std::ranges::transform_view<InputView, PlusOneMutable>>);
-  static_assert( EndInvocable<const std::ranges::transform_view<InputView, PlusOne>>);
-
-  static_assert(!EndIsIter<const std::ranges::transform_view<InputView, PlusOne>>);
-  static_assert(!EndIsIter<      std::ranges::transform_view<InputView, PlusOneMutable>>);
-  static_assert( EndIsIter<const std::ranges::transform_view<MoveOnlyView, PlusOne>>);
-  static_assert( EndIsIter<      std::ranges::transform_view<MoveOnlyView, PlusOneMutable>>);
-
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/ranges/range.adaptors/range.transform/iterator/base.pass.cpp

 
 // transform_view::<iterator>::base
 
 #include <ranges>
 
 #include "test_macros.h"
 #include "../types.h"
 
-template<class V, class F>
-concept BaseInvocable = requires(std::ranges::iterator_t<std::ranges::transform_view<V, F>> iter) {
-  iter.base();
+template<class It>
+concept BaseInvocable = requires(It it) {
+  it.base();
 };
 
 constexpr bool test() {
   {
-    std::ranges::transform_view<MoveOnlyView, PlusOneMutable> transformView;
-    auto iter = std::move(transformView).begin();
-    ASSERT_SAME_TYPE(int*, decltype(iter.base()));
-    assert(iter.base() == globalBuff);
-    ASSERT_SAME_TYPE(int*, decltype(std::move(iter).base()));
-    assert(std::move(iter).base() == globalBuff);
+    using TransformView = std::ranges::transform_view<MoveOnlyView, PlusOneMutable>;
+    TransformView tv;
+    auto begin = tv.begin();
+    ASSERT_SAME_TYPE(decltype(begin.base()), int*);
+    assert(begin.base() == globalBuff);
+    ASSERT_SAME_TYPE(decltype(std::move(begin).base()), int*);
+    assert(std::move(begin).base() == globalBuff);
   }
-
   {
-    std::ranges::transform_view<InputView, PlusOneMutable> transformView;
-    auto iter = transformView.begin();
-    assert(std::move(iter).base() == globalBuff);
-    ASSERT_SAME_TYPE(cpp20_input_iterator<int *>, decltype(std::move(iter).base()));
+    using TransformView = std::ranges::transform_view<InputView, PlusOneMutable>;
+    TransformView tv;
+    auto begin = tv.begin();
+    static_assert(!BaseInvocable<decltype(begin)&>);
+    std::same_as<cpp20_input_iterator<int *>> auto it = std::move(begin).base();
+    assert(base(it) == globalBuff);
   }
-
-  static_assert(!BaseInvocable<InputView, PlusOneMutable>);
-
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/ranges/range.adaptors/range.transform/size.pass.cpp

constexpr bool test() {
 
   {
     const std::ranges::transform_view transformView(MoveOnlyView{globalBuff, 4}, PlusOne{});
     assert(transformView.size() == 4);
   }
 
   static_assert(!SizeInvocable<std::ranges::transform_view<ForwardView, PlusOne>>);
 
-  static_assert(SizeInvocable<std::ranges::transform_view<SizedSentinelNotConstView, PlusOne>>);
-  static_assert(!SizeInvocable<const std::ranges::transform_view<SizedSentinelNotConstView, PlusOne>>);
+  static_assert(SizeInvocable<std::ranges::transform_view<NonConstSizedView, PlusOne>>);
+  static_assert(!SizeInvocable<const std::ranges::transform_view<NonConstSizedView, PlusOne>>);
 
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/ranges/range.adaptors/range.transform/types.h

 inline constexpr bool std::ranges::enable_borrowed_range<BorrowableRange> = true;
 static_assert(!std::ranges::view<BorrowableRange>);
 static_assert( std::ranges::contiguous_range<BorrowableRange>);
 static_assert( std::ranges::borrowed_range<BorrowableRange>);
 
 struct InputView : std::ranges::view_base {
   int *ptr_;
   constexpr explicit InputView(int* ptr = globalBuff) : ptr_(ptr) {}
-  constexpr cpp20_input_iterator<int*> begin() const { return cpp20_input_iterator<int*>(ptr_); }
-  constexpr int *end() const { return ptr_ + 8; }
+  constexpr auto begin() const { return cpp20_input_iterator<int*>(ptr_); }
+  constexpr auto end() const { return sentinel<cpp20_input_iterator<int*>>(cpp20_input_iterator<int*>(ptr_ + 8)); }
 };
-// TODO: remove these bogus operators
-constexpr bool operator==(const cpp20_input_iterator<int*> &lhs, int* rhs) { return lhs.base() == rhs; }
-constexpr bool operator==(int* lhs, const cpp20_input_iterator<int*> &rhs) { return rhs.base() == lhs; }
+static_assert( std::ranges::view<InputView>);
+static_assert(!std::ranges::sized_range<InputView>);
 
 struct SizedSentinelView : std::ranges::view_base {
   int count_;
   constexpr explicit SizedSentinelView(int count = 8) : count_(count) {}
-  constexpr auto begin() const { return RandomAccessIter(globalBuff); }
-  constexpr int *end() const { return globalBuff + count_; }
+  constexpr int *begin() const { return globalBuff; }
+  constexpr auto end() const { return sized_sentinel<int*>(globalBuff + count_); }
 };
-// TODO: remove these bogus operators
-constexpr auto operator- (const RandomAccessIter &lhs, int* rhs) { return lhs.base() - rhs; }
-constexpr auto operator- (int* lhs, const RandomAccessIter &rhs) { return lhs - rhs.base(); }
-constexpr bool operator==(const RandomAccessIter &lhs, int* rhs) { return lhs.base() == rhs; }
-constexpr bool operator==(int* lhs, const RandomAccessIter &rhs) { return rhs.base() == lhs; }
 
-struct SizedSentinelNotConstView : std::ranges::view_base {
-  ForwardIter begin() const;
-  int *end() const;
+struct NonConstSizedView : std::ranges::view_base {
+  forward_iterator<int*> begin() const;
+  forward_iterator<int*> end() const;
   size_t size();
 };
-// TODO: remove these bogus operators
-bool operator==(const ForwardIter &lhs, int* rhs);
-bool operator==(int* lhs, const ForwardIter &rhs);
+static_assert( std::ranges::view<NonConstSizedView>);
+static_assert( std::ranges::sized_range<NonConstSizedView>);
+static_assert( std::ranges::range<const NonConstSizedView>);
+static_assert(!std::ranges::sized_range<const NonConstSizedView>);
 
 struct Range {
   int *begin() const;
   int *end() const;
 };
 
 using CountedIter = stride_counting_iterator<forward_iterator<int*>>;
 struct CountedView : std::ranges::view_base {

libcxx/test/std/ranges/range.req/range.range/helper_aliases.compile.pass.cpp

 // template<range R>
 // using range_reference_t = iter_reference_t<iterator_t<R>>;
 
 // template<range R>
 // using range_rvalue_reference_t = iter_rvalue_reference_t<iterator_t<R>>;
 
 #include <ranges>
 
-#include <concepts>
-
-#include "test_iterators.h"
-#include "test_range.h"
-
-
-
-static_assert(std::same_as<std::ranges::range_difference_t<test_range<cpp20_input_iterator> >, std::iter_difference_t<int*> >);
-static_assert(std::same_as<std::ranges::range_value_t<test_range<cpp20_input_iterator> >, std::iter_value_t<int*> >);
-static_assert(std::same_as<std::ranges::range_reference_t<test_range<cpp20_input_iterator> >, std::iter_reference_t<int*> >);
-static_assert(std::same_as<std::ranges::range_rvalue_reference_t<test_range<cpp20_input_iterator> >, std::iter_rvalue_reference_t<int*> >);
+struct Range {
+    int *begin();
+    int *end();
+};
+static_assert(std::same_as<std::ranges::range_difference_t<Range>, std::ptrdiff_t>);
+static_assert(std::same_as<std::ranges::range_value_t<Range>, int>);
+static_assert(std::same_as<std::ranges::range_reference_t<Range>, int&>);
+static_assert(std::same_as<std::ranges::range_rvalue_reference_t<Range>, int&&>);

libcxx/test/std/ranges/range.req/range.range/iterator_t.compile.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
 // UNSUPPORTED: libcpp-has-no-incomplete-ranges
 
-// template<class T>
-// using iterator_t = decltype(ranges::begin(declval<T&>()));
+// template<range _Rp>
+// using iterator_t = decltype(ranges::begin(declval<_Rp&>()));
 
 #include <ranges>
 
-#include <concepts>
+#include "test_iterators.h"
 
-#include "test_range.h"
-
-
-
-static_assert(std::same_as<std::ranges::iterator_t<test_range<cpp17_input_iterator> >, cpp17_input_iterator<int*> >);
-static_assert(std::same_as<std::ranges::iterator_t<test_range<cpp17_input_iterator> const>, cpp17_input_iterator<int const*> >);
-
-static_assert(std::same_as<std::ranges::iterator_t<test_non_const_range<cpp17_input_iterator> >, cpp17_input_iterator<int*> >);
-
-static_assert(std::same_as<std::ranges::iterator_t<test_common_range<cpp17_input_iterator> >, cpp17_input_iterator<int*> >);
-static_assert(std::same_as<std::ranges::iterator_t<test_common_range<cpp17_input_iterator> const>, cpp17_input_iterator<int const*> >);
-
-static_assert(std::same_as<std::ranges::iterator_t<test_non_const_common_range<cpp17_input_iterator> >, cpp17_input_iterator<int*> >);
+template<class T>
+concept HasIteratorT = requires {
+    typename std::ranges::iterator_t<T>;
+};
+
+static_assert(std::same_as<std::ranges::iterator_t<int[]>, int*>);
+static_assert(std::same_as<std::ranges::iterator_t<int(&)[]>, int*>);
+static_assert(std::same_as<std::ranges::iterator_t<int[10]>, int*>);
+static_assert(std::same_as<std::ranges::iterator_t<int(&)[10]>, int*>);
+
+struct Range {
+    char *begin() &;
+    sentinel<char*> end() &;
+    short *begin() &&;
+    sentinel<short*> end() &&;
+    int *begin() const&;
+    sentinel<int*> end() const&;
+    long *begin() const&&;
+    sentinel<long*> end() const&&;
+};
+static_assert(std::same_as<std::ranges::iterator_t<Range>, char*>);
+static_assert(std::same_as<std::ranges::iterator_t<Range&>, char*>);
+static_assert(std::same_as<std::ranges::iterator_t<Range&&>, char*>);
+static_assert(std::same_as<std::ranges::iterator_t<const Range>, int*>);
+static_assert(std::same_as<std::ranges::iterator_t<const Range&>, int*>);
+static_assert(std::same_as<std::ranges::iterator_t<const Range&&>, int*>);
+
+struct NonConstRange {
+    int *begin();
+    int *end();
+};
+static_assert(std::same_as<std::ranges::iterator_t<NonConstRange>, int*>);
+static_assert(std::same_as<std::ranges::iterator_t<NonConstRange&>, int*>);
+static_assert(std::same_as<std::ranges::iterator_t<NonConstRange&&>, int*>);
+static_assert(!HasIteratorT<const NonConstRange>);
+static_assert(!HasIteratorT<const NonConstRange&>);
+static_assert(!HasIteratorT<const NonConstRange&&>);

libcxx/test/std/ranges/range.req/range.range/sentinel_t.compile.pass.cpp

 // UNSUPPORTED: libcpp-no-concepts
 // UNSUPPORTED: libcpp-has-no-incomplete-ranges
 
 // template<range _Rp>
 // using sentinel_t = decltype(ranges::end(declval<_Rp&>()));
 
 #include <ranges>
 
-#include <concepts>
-
 #include "test_iterators.h"
-#include "test_range.h"
-
-
 
-static_assert(std::same_as<std::ranges::sentinel_t<test_range<cpp20_input_iterator> >, sentinel>);
-static_assert(std::same_as<std::ranges::sentinel_t<test_range<cpp20_input_iterator> const>, sentinel>);
-static_assert(std::same_as<std::ranges::sentinel_t<test_non_const_range<cpp20_input_iterator> >, sentinel>);
-static_assert(std::same_as<std::ranges::sentinel_t<test_common_range<cpp17_input_iterator> >, cpp17_input_iterator<int*> >);
-static_assert(std::same_as<std::ranges::sentinel_t<test_common_range<cpp17_input_iterator> const>, cpp17_input_iterator<int const*> >);
-static_assert(std::same_as<std::ranges::sentinel_t<test_non_const_common_range<cpp17_input_iterator> >, cpp17_input_iterator<int*> >);
+template<class T>
+concept HasSentinelT = requires {
+    typename std::ranges::sentinel_t<T>;
+};
+
+static_assert(!HasSentinelT<int[]>);
+static_assert(!HasSentinelT<int(&)[]>);
+static_assert(std::same_as<std::ranges::sentinel_t<int[10]>, int*>);
+static_assert(std::same_as<std::ranges::sentinel_t<int(&)[10]>, int*>);
+
+struct Range {
+    char *begin() &;
+    sentinel<char*> end() &;
+    short *begin() &&;
+    sentinel<short*> end() &&;
+    int *begin() const&;
+    sentinel<int*> end() const&;
+    long *begin() const&&;
+    sentinel<long*> end() const&&;
+};
+static_assert(std::same_as<std::ranges::sentinel_t<Range>, sentinel<char*>>);
+static_assert(std::same_as<std::ranges::sentinel_t<Range&>, sentinel<char*>>);
+static_assert(std::same_as<std::ranges::sentinel_t<Range&&>, sentinel<char*>>);
+static_assert(std::same_as<std::ranges::sentinel_t<const Range>, sentinel<int*>>);
+static_assert(std::same_as<std::ranges::sentinel_t<const Range&>, sentinel<int*>>);
+static_assert(std::same_as<std::ranges::sentinel_t<const Range&&>, sentinel<int*>>);
+
+struct NonConstRange {
+    int *begin();
+    int *end();
+};
+static_assert(std::same_as<std::ranges::sentinel_t<NonConstRange>, int*>);
+static_assert(std::same_as<std::ranges::sentinel_t<NonConstRange&>, int*>);
+static_assert(std::same_as<std::ranges::sentinel_t<NonConstRange&&>, int*>);
+static_assert(!HasSentinelT<const NonConstRange>);
+static_assert(!HasSentinelT<const NonConstRange&>);
+static_assert(!HasSentinelT<const NonConstRange&&>);

libcxx/test/std/ranges/range.req/range.refinements/output_range.compile.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
 // UNSUPPORTED: libcpp-has-no-incomplete-ranges
 
 // template<class R, class T>
 // concept output_range;
 
 #include <ranges>
-
 #include <iterator>
+
 #include "test_iterators.h"
-#include "test_range.h"
 
 struct T { };
 
 // Satisfied when it's a range and has the right iterator
 struct GoodRange {
     output_iterator<T*> begin();
-    sentinel end();
+    sentinel<output_iterator<T*>> end();
 };
 static_assert(std::ranges::range<GoodRange>);
 static_assert(std::output_iterator<std::ranges::iterator_t<GoodRange>, T>);
 static_assert(std::ranges::output_range<GoodRange, T>);
 
 // Not satisfied when it's not a range
 struct NotRange {
     output_iterator<T*> begin();
 };
 static_assert(!std::ranges::range<NotRange>);
 static_assert( std::output_iterator<std::ranges::iterator_t<NotRange>, T>);
 static_assert(!std::ranges::output_range<NotRange, T>);
 
 // Not satisfied when the iterator is not an output_iterator
 struct RangeWithBadIterator {
-    cpp17_input_iterator<T const*> begin();
-    sentinel end();
+    cpp17_input_iterator<const T*> begin();
+    sentinel<cpp17_input_iterator<const T*>> end();
 };
 static_assert( std::ranges::range<RangeWithBadIterator>);
 static_assert(!std::output_iterator<std::ranges::iterator_t<RangeWithBadIterator>, T>);
 static_assert(!std::ranges::output_range<RangeWithBadIterator, T>);

libcxx/test/std/ranges/range.utility/range.subrange/enable_borrowed_range.compile.pass.cpp

 #include <ranges>
 
 #include "test_iterators.h"
 
 namespace ranges = std::ranges;
 
 static_assert(ranges::borrowed_range<ranges::subrange<int*>>);
 static_assert(ranges::borrowed_range<ranges::subrange<int*, int const*>>);
-static_assert(ranges::borrowed_range<ranges::subrange<int*, sentinel_wrapper<int*>, ranges::subrange_kind::unsized>>);
+static_assert(ranges::borrowed_range<ranges::subrange<int*, sentinel<int*>, ranges::subrange_kind::unsized>>);

libcxx/test/support/test_iterators.h

struct cpp20_input_iterator {
     }
 
     constexpr void operator++(int) { ++base_; }
 
     constexpr const I& base() const& { return base_; }
 
     constexpr I base() && { return std::move(base_); }
 
+    friend constexpr I base(const cpp20_input_iterator& it) { return it.base_; }
+
     template <class T>
     void operator,(T const &) = delete;
 
 private:
     I base_ = I();
 };
 
 template <std::input_or_output_iterator I>

 
 template<class T, class U>
 concept sentinel_for_base = requires(U const& u) {
     u.base();
     requires std::input_or_output_iterator<std::remove_cvref_t<decltype(u.base())>>;
     requires std::equality_comparable_with<T, decltype(u.base())>;
 };
 
-template <std::input_or_output_iterator I>
-class sentinel_wrapper {
+template <class It>
+class sentinel {
 public:
-    sentinel_wrapper() = default;
-    constexpr explicit sentinel_wrapper(I base) : base_(std::move(base)) {}
-
-    constexpr bool operator==(const I& other) const requires std::equality_comparable<I> {
-        return base_ == other;
-    }
-
-    constexpr const I& base() const& { return base_; }
-    constexpr I base() && { return std::move(base_); }
-
-    template<std::input_or_output_iterator I2>
-        requires sentinel_for_base<I, I2>
-    constexpr bool operator==(const I2& other) const {
-        return base_ == other.base();
-    }
-
+    sentinel() = default;
+    constexpr explicit sentinel(const It& it) : base_(base(it)) {}
+    constexpr bool operator==(const It& other) const { return base_ == base(other); }
+    friend constexpr auto base(const sentinel& s) { return It(s.base_); }
 private:
-    I base_ = I();
+    decltype(base(std::declval<It>())) base_;
 };
 
-template <std::input_or_output_iterator I>
+template <class It>
 class sized_sentinel {
 public:
-    sized_sentinel() = default;
-    constexpr explicit sized_sentinel(I base) : base_(std::move(base)) {}
-
-    constexpr bool operator==(const I& other) const requires std::equality_comparable<I> {
-        return base_ == other;
-    }
-
-    constexpr const I& base() const& { return base_; }
-    constexpr I base() && { return std::move(base_); }
-
-    template<std::input_or_output_iterator I2>
-        requires sentinel_for_base<I, I2>
-    constexpr bool operator==(const I2& other) const {
-        return base_ == other.base();
-    }
-
+    explicit sized_sentinel() = default;
+    constexpr explicit sized_sentinel(const It& it) : base_(base(it)) {}
+    constexpr bool operator==(const It& other) const { return base_ == base(other); }
+    friend constexpr auto operator-(const sized_sentinel& s, const It& i) { return s.base_ - base(i); }
+    friend constexpr auto operator-(const It& i, const sized_sentinel& s) { return base(i) - s.base_; }
+    friend constexpr auto base(const sized_sentinel& s) { return It(s.base_); }
 private:
-    I base_ = I();
+    decltype(base(std::declval<It>())) base_;
 };
 
-template <std::input_or_output_iterator I>
-constexpr auto operator-(sized_sentinel<I> sent, std::input_or_output_iterator auto iter) {
-  return sent.base() - iter;
-}
-
-template <std::input_or_output_iterator I>
-constexpr auto operator-(std::input_or_output_iterator auto iter, sized_sentinel<I> sent) {
-  return iter - sent.base();
-}
-
 template <class It>
 class three_way_contiguous_iterator
 {
     static_assert(std::is_pointer_v<It>, "Things probably break in this case");
 
     It it_;
 
     template <class U> friend class three_way_contiguous_iterator;

libcxx/test/support/test_range.h

 #include <ranges>
 
 #include "test_iterators.h"
 
 #ifdef _LIBCPP_HAS_NO_RANGES
 #error "test/support/test_range.h" can only be included in builds supporting ranges
 #endif
 
-struct sentinel {
-  bool operator==(std::input_or_output_iterator auto const&) const;
-};
-
 template <template <class...> class I>
 requires std::input_or_output_iterator<I<int*> >
 struct test_range {
   I<int*> begin();
   I<int const*> begin() const;
-  sentinel end();
-  sentinel end() const;
+  sentinel<I<int*>> end();
+  sentinel<I<const int*>> end() const;
 };
 
 template <template <class...> class I>
 requires std::input_or_output_iterator<I<int*> >
 struct test_non_const_range {
   I<int*> begin();
-  sentinel end();
+  sentinel<I<int*>> end();
 };
 
 template <template <class...> class I>
 requires std::input_or_output_iterator<I<int*> >
 struct test_common_range {
   I<int*> begin();
   I<int const*> begin() const;
   I<int*> end();
   I<int const*> end() const;
 };
 
 template <template <class...> class I>
 requires std::input_or_output_iterator<I<int*> >
 struct test_non_const_common_range {
   I<int*> begin();
   I<int*> end();
 };
 
 template <template <class...> class I>
 requires std::input_or_output_iterator<I<int*> >
 struct test_view : std::ranges::view_base {
   I<int*> begin();
   I<int const*> begin() const;
-  sentinel end();
-  sentinel end() const;
+  sentinel<I<int*>> end();
+  sentinel<I<const int*>> end() const;
 };
 
 #endif // LIBCXX_TEST_SUPPORT_TEST_RANGE_H